# Expressions

The basic expressions in Lua are the following:

```
exp ::= prefixexp
exp ::=
```**nil |** **null** | **false** | **true**
exp ::= Number
exp ::= String
exp ::= function
exp ::= tableconstructor
exp ::= `**...**´
exp ::= exp binop exp
exp ::= unop exp
prefixexp ::= var | functioncall | `**(**´ exp `**)**´

Numbers and literal strings are explained in Lexical Conventions; variables are explained in Variables; function definitions are explained in Function Definitions; function calls are explained in Function Calls; table constructors are explained in Table Constructors. Vararg expressions, denoted by three dots ('`...`

'), can only be used when directly inside a vararg function; they are explained in Function Definitions.

Binary operators comprise arithmetic operators (see Arithmetic Operators), relational operators (see Relational Operators), logical operators (see Logical Operators), and the concatenation operator (see Concatenation). Unary operators comprise the unary minus (see Arithmetic Operators), the unary **not** (see Logical Operators), and the unary *length operator* (see The Length Operator).

Both function calls and vararg expressions can result in multiple values. If an expression is used as a statement, which is only possible for function calls (see Precedence), then its return list is adjusted to zero elements, thus discarding all returned values. If an expression is used as the last (or the only) element of a list of expressions, then no adjustment is made (unless the call is enclosed in parentheses). In all other contexts, Lua adjusts the result list to one element, discarding all values except the first one.

Here are some examples:

```
f() -- adjusted to 0 results
g(f(), x) -- f() is adjusted to 1 result
g(x, f()) -- g gets x plus all results from f()
a,b,c = f(), x -- f() is adjusted to 1 result (c gets null)
a,b = ... -- a gets the first vararg parameter, b gets
-- the second (both a and b can get null if there
-- is no corresponding vararg parameter)
a,b,c = x, f() -- f() is adjusted to 2 results
a,b,c = f() -- f() is adjusted to 3 results
return f() -- returns all results from f()
return ... -- returns all received vararg parameters
return x,y,f() -- returns x, y, and all results from f()
{f()} -- creates a list with all results from f()
{...} -- creates a list with all vararg parameters
{f(), null} -- f() is adjusted to 1 result
```

Any expression enclosed in parentheses always results in only one value. Thus, `(f(x,y,z))`

is always a single value, even if `f`

returns several values. (The value of `(f(x,y,z))`

is the first value returned by `f`

or **null** if `f`

does not return any values.)