如何在Lua中用类型声明变量

Question

Is it possible to create variables to be a specific type in Lua?

Eg int x = 4

If this is not possible, is there at least some way to have a fake "type" shown before the variable so that anyone reading the code will know what type the variable is supposed to be?

Eg function addInt(int x=4, int y=5) , but x/y could still be any type of variable? I find it much easier to type the variable's type before it rather than putting a comment at above the function to let any readers know what type of variable it is supposed to be.

The sole reason I'm asking isn't to limit the variable to a specific data type, but simply to have the ability to put a data type before the variable, whether it does anything or not, to let the reader know what type of variable that it is supposed to be without getting an error.

Answer 1

You can do this using comments:

local x = 4 -- int

function addInt(x --[[int]],
                y --[[int]] )

---

You can make the syntax a = int(5) from your other comment work using the following:

function int(a) return a end
function string(a) return a end
function dictionary(a) return a end

a = int(5)
b = string "hello, world!"
c = dictionary({foo = "hey"})

Still, this doesn't really offer any benefits over a comment.

Answer 2

The only way I can think of to do this, would be by creating a custom type in C.

Lua Integer type

Answer 3

No. But I understand your goal is to improve understanding when reading and writing functions calls.

Stating the expected data type of parameters adds only a little in terms of giving a specification for the function. Also, some function parameters are polymorphic, accepting a specific value, or a function or table from which to obtain the value for a context in which the function operates. See string.gsub , for example.

When reading a function call, the only thing known at the call site is the name of the variable or field whose value is being invoked as a function (sometimes read as the "name" of the function) and the expressions being passed as actual parameters. It is sometimes helpful to refactor parameter expressions into named local variables to add to the readability.

When writing a function call, the name of the function is key. The names of the formal parameters are also helpful. But still, names (like types) do not comprise much of a specification. The most help comes from embedded structured documentation used in conjunction with an IDE that infers the context of a name and performs content assistance and presentations of available documentation.

luadoc is one such a system of documentation. You can write luadoc for function you declare.

Eclipse Koneki LDT is one such an IDE. Due to the dynamic nature of Lua, it is a difficult problem so LDT is not always as helpful as one would like. (To be clear, LDT does not use luadoc; It evolved its own embedded documentation system.)