Scribd
Upload
44 views

Programming in Lua - 6.2

lua.org

Uploaded by

Qin Krein
Copyright
© © All Rights Reserved
Available Formats
Download as PDF, TXT or read online on Scribd
44 views

Programming in Lua - 6.2

lua.org

Uploaded by

Qin Krein
Copyright
© © All Rights Reserved
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 3

This first edition was written for Lua 5.0.

While still largely relevant for later versions, there are


some differences.
The fourth edition
targets Lua 5.3 and is available at Amazon and other bookstores.
By buying the book, you also help to support the Lua project.

Programming in Lua
Part I. The Language
Chapter 6. More about Functions

6.2 – Non-Global Functions


An obvious consequence of first-class functions is that
we can store functions
not only in global variables,
but also in table fields and in local variables.

We have already seen several examples of functions in table fields:


Most Lua
libraries use this mechanism
(e.g., io.read, math.sin).
To create such
functions in Lua,
we only have to put together the regular syntax for functions
and
for tables:

Lib = {}

Lib.foo = function (x,y) return x + y end

Lib.goo = function (x,y) return x - y end

Of course, we can also use constructors:

Lib = {

foo = function (x,y) return x + y end,

goo = function (x,y) return x - y end

Moreover, Lua offers yet another syntax to define such functions:

Lib = {}

function Lib.foo (x,y)

return x + y

end

function Lib.goo (x,y)

return x - y

end

This last fragment is exactly equivalent to the first example.

When we store a function into a local variable


we get a local function,
that is, a
function that is restricted to a given scope.
Such definitions are particularly
useful for packages:
Because Lua handles each chunk as a function,
a chunk
may declare local functions,
which are visible only inside the chunk.
Lexical
scoping ensures that other functions in the package
can use these local
functions:

local f = function (...)

...

end

local g = function (...)

...

f() -- external local `f' is visible here

...

end

Lua supports such uses of local functions with a syntactic sugar


for them:

local function f (...)

...

end

A subtle point arises in the definition of recursive local functions.


The naive
approach does not work here:

local fact = function (n)

if n == 0 then return 1

else return n*fact(n-1) -- buggy

end

end

When Lua compiles the call fact(n-1),


in the function body,
the local fact is
not yet defined.
Therefore, that expression calls a global fact,
not the local
one.
To solve that problem,
we must first define the local variable
and then
define the function:

local fact

fact = function (n)

if n == 0 then return 1

else return n*fact(n-1)

end

end

Now the fact inside the function refers to the local variable.
Its value when
the function is defined does not matter;
by the time the function executes,
fact already has the right value.
That is the way Lua expands its syntactic
sugar for local functions,
so you can use it for recursive functions without
worrying:

local function fact (n)

if n == 0 then return 1

else return n*fact(n-1)

end

end

Of course, this trick does not work if you have indirect


recursive functions.
In
such cases, you must use the equivalent of
an explicit forward declaration:

local f, g -- `forward' declarations

function g ()

... f() ...

end

function f ()

... g() ...

end

Copyright © 2003–2004 Roberto Ierusalimschy. All rights reserved.

You might also like