Lua

**Lua** ( [/ˈluːə/] [loo-ə], portugali keeles lua [ˈlu.(w)ɐ] tähendab Kuud) on mitmeparadigmaline programmeerimiskeel, mis on eeskätt loodud välja kutsumiseks teiste programmeerimiskeelte ja -keskkondade seest. Lua keel on alates loomisest platvormiülene ja on ANSI standardile vastavas C-programmeerimiskeeles ning omab suhteliselt lihtsat C-rakendusliidest.

Lua loodi aastal 1993 ning oli mõeldud tarkvararakenduste üha kasvavate vajaduste täitmiseks. See tagas põhilised võimalused enamikule protseduurilistele programmeerimiskeeltele, kuid piiratumate ning valdkonnapõhiste programmeerimiskeelte omadusi ei ole kaasatud. Lua sisaldab keelt laiendavaid mehhanisme, lubades arendajal keele omadusi implementeerida. Kuigi Lua oli kavandatud olema üldine integreeritav keelelaiendus, siis Lua disainerid suunasid tähelepanu ka selle kiirusele, porditavusele, laiendatavusele ja kasutusmugavusele arenduses.

## Ajalugu

Lua programmeerimiskeele lõid 1993. aastal Roberto Ierusalimschy, Luiz Henrique de Figueiredo ja Waldemar Celes ning Computer Graphics Technology Group (Techgraf) liikmed Rio de Janeiro Piiskoplikus Katoliku Ülikoolis (Pontifical Catholic University of Rio de Janeiro) Brasiilias.

Aastatel 1977–1992 kehtisid Brasiilias arvutitarkvarale ja -riistvarale tugevad kaubandustõkked. Nende piirangute tõttu ei olnud Tecgrafi klientidel võimalik (ei poliitilistel ega rahalistel põhjustel) osta kohandatavat tarkvara välismaalt. Nende asjaolude tõttu implementeeris Tecgraf põhilised vahendid iseseisvalt.

Lua ajalooline "isa ja ema" olid andmete kirjeldus/konfiguratsiooni keel *SOL* (Simple Object Language) ja *DEL* (Data-Entry Language). Neid on iseseisvalt arendanud Tecgraf aastatel 1992–1993, lisades paindlikkust kahte projekti (mõlemad olid interaktiivsed graafilised programmid ettevõtte Petrobras rakenduste jaoks). Neis oli puudus igasugustest voo reguleerimise struktuuridest SOL-is ja DEL-is ja Petrobras tundis kasvavat vajadust lisada rakendustesse täiendavaid programmeeritavaid võimalusi.

Lua 1.0 oli disainitud nii, et selle objekti konstruktorid, olles nii vähesel määral erinevad praegusest kergusest ja paindlikkuse laadist, inkorporeeritud SOLi andmekirjelduse süntaksiga (siit tuleneb ka nimi "Lua". *Sol tähendab* portugali keeles 'päikest', seega *sobis arendatava keele nimeks [[sõna]] "Lua" -* 'Kuu'). Lua kontrollstruktuuride süntaksist oli suurem osa laenatud Modulast (if, while, repeat/until), aga samuti oli võetud mõjutusi CLU-st (korduvad ülesanded ja korduv tagastamine funktsioonide väljakutsumisel kui lihtsam alternatiiv viitparameetritele või kaudsetele viitadele), C++ keelest (" lokaalse muutuja deklareerimine ainult seal, kus me vajame seda), SNOBOL-ist ja AWK-st (assotsiatiivne massiiv). Artiklis, mis avaldati Dr. Dobb's Journalis, väitsid* Lua keele loojad, et LISP ja Scheme kui nende ainsad üldlevinud andmete struktureerimise mehhanismid ([[List (programmeerimine)|list]]) olid tugevalt mõjutatud nende otsusest arendada tabelit kui tähtsaimat Lua andmestruktuuri.

Lua [[semantika]] on enim mõjutatud Scheme poolt, eriti seoses [[Anonüümne funktsioon|anonüümsete funktsioonide]] kasutuselevõtuga ja täieliku sõnastiku kindlaksmääramisega.

Lua versioonid enne versiooni 5.0 olid välja lastud [[BSD-litsents]]iga sarnase litsentsi alusel. Alates versioonist 5.0 on Lua olnud [[MIT litsents]]i all. Mõlemad on [[Vaba tarkvara|leebed vaba tarkvara litsentsid]] ja peaaegu identsed.

== Funktsionaalsus ==
Luad on tavaliselt kirjeldatud kui "[[Paradigma|mitmeparadigmalist]]" keelt, toetades väikest hulka üldisi funktsioone, millega saab laiendada sobivust eri tüüpi probleemidele, selle asemel et toetada palju keerulisemat ja ranget spetsifikatsiooni, sobitamaks ühte paradigmat. Näiteks Lua ei sisalda ilmset [[Pärilus (objektorienteeritud programmeerimine)|päriluse]] tuge, aga lubab seda implementeerida koos [[metatabel]]itega. Lisaks lubab Lua programmeerijal implementeerida [[nimeruum]]e, [[Klass (programmeerimine)|klasse]] ja teisi seotud funktsioone, kasutades selle üksiku tabeli implementeerimist. Esimese klassi funktsioonid, mis võimaldavad töötamist paljude [[Funktsionaalne programmeerimine|funktsionaalse programmeerimise]] tehnikatega ja täielik staatiline skoopimine võimaldavad tihedat informatsiooni peitmist, täites väiksema privileegi printsiipi.

Üldiselt püüab Lua tagada lihtsust ning paindlikke [[Metaprogrammeerimine|metafunktsioone]], mis võivad olla vajadusel sisseehitatud, selle asemel et varustada funktsiooni seadistamise spetsiifikaga üht programmeerimisparadigmat. Tulemuseks olev baaskeel on [[Kergekaalu programmeerimiskeel|kerge]] – [[interpretaator]]i maht on kompileeritult ainult umbes 180&nbsp;[[Kilobait|kB]] ning on lihtsasti kohandatav laiale rakenduste valikule.

Lua keel võimaldab dünaamilist tüüpimist ja on mõeldud kasutamiseks kui keelelaiendus või [[skriptimiskeel]] ning on piisavalt kompaktne, et sobib erinevate platvormidega. See toetab ainult väikest osa elementaarseid andmestruktuure nagu tõeväärtuse väärtused, numbrid (kahekohalise täpsusega ujukomaarvud tavaliselt) ja sõned. Enamlevinud andmestruktuure nagu massiive, hulki, liste ja kirjeid saab taasesitada Lua ainsat omaenda andmestruktuuri – tabelit – kasutades, Tabel näol on tegu põhimõtteliselt heterogeenne assotsiatiivse massiiviga.

Lua implementeerib väikest hulka kõrgetasemelisi funktsioone nagu esimese klassi funktsioonid, "prügikorjajad" (garbage collection), sulundid, sabakutse (tail call), tüübiteisendus (automaatne muutmine sõne ja numbri vahel), kaasprogrammid (ühise multitegumitöötlusega) ja dünaamiline mooduli laadimine.

Sisaldades ainult minimaalset hulka andmetüüpe, Lua püüdis saavutada tasakaalu jõudluse ja mahu vahel.

=== Koodi näidis ===
Klassikalist programmi [[Hello world|"Tere maailm"]] saab kirjutada järgmise koodiga:

<syntaxhighlight lang="lua">
print("Tere maailm!")
</syntaxhighlight>
Seda sama programmi saab kirjutada ka sedamoodi:
<syntaxhighlight lang="lua">
io.write('Tere maailm!\n')
</syntaxhighlight>
Seda programmi saab luua ka nii nagu [http://www.lua.org/cgi-bin/demo?hello Lua veebilehel].
<syntaxhighlight lang="lua">
io.write("Hello world, from ", _VERSION, "!\n")
</syntaxhighlight>

[[Kommentaar (programmeerimine)|Kommentaarides]] kasutatakse järgmist süntaksit, mis sarnaneb programmeerimiskeelte [[Ada (programmeerimiskeel)|Ada]], [[Eiffel (programmeerimiskeel)|Eiffeli]], [[Haskell]]i, [[SQL|SQL-i]] ja [[VHDL|VHDL-i]] omadega:
<syntaxhighlight lang="lua">
--Kommentaar keeles Lua algab kahe sidekriipsuga ja on kuni rea lõpuni.

--[[ Mitmerealised sõned ja kommentaarid
     on ümbritsetud kahekordsete kandiliste sulgudega. ]]

--[=[ Seda tüüpi kommentaaridesse on teine --[[kommentaar]] pesastatud. ]=]
</syntaxhighlight>

[[Faktoriaal]]i funktsioon on implementeeritud, nii nagu järgmises näites näidatud.

<syntaxhighlight lang="lua">
function factoriaal(n)
  local x = 1
  for i = 2, n do
    x = x * i
  end
  return x
end
</syntaxhighlight>

=== Tsüklid  ===
Lua keeles on nelja tüüpi [[Tsükkel (programmeerimine)|tsükleid]]: [[Tsükkel (programmeerimine)|<tt>while-tsükkel</tt>]], <tt>repeat</tt> tsükkel (sarnane [[Tsükkel (programmeerimine)|<tt>do-while</tt> tsükliga]]), numbriline [[Tsükkel (programmeerimine)|<tt>for</tt> tsükkel]] ja üldine <tt>for</tt> tsükkel.

<syntaxhighlight lang="lua">
--tingimus = true

while tingimus do
  --käsud
end

repeat
  --käsud
until tingimus

for i = esimene,viimane,samm do     --samm võib olla negatiivne, lubades for-tsüklil loendada alla või üles. Samm näitab, kui palju on järgmine väärtus eelmisest suurem. Näiteks kui samm on 1, i esimene väärtus on 1, siis järgmine on 1+1=2
  --käsud
  --näiteks väljastame i väärtuse: print(i)
end
</syntaxhighlight>

Üldine <tt>for-tsükkel</tt>:
<syntaxhighlight lang="lua">
for key, value in pairs(_G) do
  print(key, value)
end
</syntaxhighlight>
Üldine for-tsükkel itereerib üle tabeli <tt>_G,</tt> kasutades standardset iteraatori funktsiooni <tt>pairs</tt>, kuni see tagastab tühiväärtuse <tt>null</tt>.

=== Funktsioonid ===
Lua funktsioonikäsitluses on [[esimese klassi funktsioon]]ide väärtused, mis on näidatud järgnevas näites, kus print-funktsiooni käitumine on modifitseeritud:
<syntaxhighlight lang="lua">
do
  local oldprint = print
  -- varu praeguse print funktsioon kui oldprint
  function print(s)
    --[[ Defineeri uuesti print function, tavalist print funktsiooni saab endiselt kasutada
         läbi oldprint. Uuel on ainult üks argument]]
    oldprint(s == "foo" and "bar" or s)
  end
end
</syntaxhighlight>
Iga tulevane print-käsu väljakutse hakkab nüüd olema suunatud läbi uue funktsiooni ja tulenevalt Lua staatilisest skoopimisest on vana print funktsioon kättesaadav ainult uue modifitseeritud print jaoks.

Lua samuti toetab [[Sulund (informaatika)|sulundeid]], mida on demonstreeritud järgmises koodis:
<syntaxhighlight lang="lua">
function addto(x)
  --tagastab uue funktsiooni, mis lisab x-i argumendiks
  return function(y)
    --[=[ kui me viitame muutujale x, mis on väljaspool seda skoopi ja mille
         eluperiood on lühem kui sellel anonüümsel funktsioonil,
          Lua loob sulundi.]=]
    return x + y
  end
end
fourplus = addto(4)
print(fourplus(3))  -- väljastab 7

--Seda saab saavutada ka funktsiooni järgmisel viisil välja kutsudes:
print(addto(4)(3))
--[[ See on nii, sest me oleme kutsumas tagastatud funktsiooni `addto(4)'  koos argumendiga `3' otse.
     See aitab ka vähendada andmehinda ja tõsta kasutust, kui oleme kutsunud iteratiivselt.
]]
</syntaxhighlight>
Muutuja x uus sulund on loodud igal korral, kui <tt>addto</tt> kutsutakse välja, nii et iga uus anonüümne funktsioon naaseb alati juurdepääsuga oma x-parameetrile. Sulundit haldab Lua "prügivedaja" just nagu iga teist objekti. 
=== Tabelid ===
Tabelid on kõige tähtsamad andmestruktuurid (ja disainilt ainus sisseehitatud [[liitandmetüüp]]) Lua keeles ning on alus kõigile kasutaja loodud tüüpidele. Need sarnanevad kontseptuaalselt [[Massiiv (programmeerimine)|assotsiatiivse massiiviga]] PHP-s, [[Sõnastik (programmeerimine)|sõnastikuga]] Pythonis ja räsidele Rubys või Perlis.

Tabel on kogum võtmete ja andmete paaridest, kus andmetele viitavad võtmed. Teiste sõnadega on see [[Paisktabel|räsitud]] [[Homogeensus ja heterogeensus|heterogeenne]] [[Massiiv (programmeerimine)|assotsiatiivne massiiv]]. Võti (indeks) võib omada iga väärtust, aga mitte NaN. Numbrilist võtit 1 peetakse erinevaks [[Sõne (andmetüüp)|sõnelisest]] võtmest "1". i

Tabeleid luuakse kasutades <code>{}</code> konstruktorit:
<syntaxhighlight lang="lua">
a_table = {} -- Loome uue tabeli nimega a_table
</syntaxhighlight>
Tabelid saavad viidata ka üksteisele:
<syntaxhighlight lang="lua">
a_table = {x = 10}  -- Loome uue tabeli koos ühe kirje kujutusega, kus "x" on seotud 10-ga.
print(a_table["x"]) -- Väljastame sõnelise võtmega seotud väärtuse, mis on praegusel juhul 10.
b_table = a_table
b_table["x"] = 20   -- Väärtuse muutmine tabelis. Uus väärtus on 20.
print(b_table["x"]) -- Väljastame 20.
print(a_table["x"]) -- Samuti väljastab 20, sest a_table ja b_table mõlemad viitavad samale tabelile.
</syntaxhighlight>

==== Kirje ====
Tabelit on tihti kasutatud nagu struktuuri (või [[Kirje (programmeerimine)|kirjet]]),kus on kasutatud [[Sõne (andmetüüp)|sõnesid]] kui võtmeid, sest selline kasutus on väga tavaline. Lua funktsioonid on spetsiaalse süntaksiga, tegelemiseks selliste väljadega. Seda näitab järgmine koodinäide:
<syntaxhighlight lang="lua">
point = { x = 10, y = 20 }   -- Loome uue tabeli.
print(point["x"])            -- Väljastame 10.
print(point.x)               -- See rida on enamvähem sama, mis eelmine, kuid lihtsam lugeda.
                             -- .
</syntaxhighlight>
Tsiteerides Lua 5.1 manuaali:

"Süntaks var.Name on [[Süntaktika|süntaktiline suhkur]] süntaksist var['Name'];"

==== Nimeruum ====
Seotud funktsioonide salvestamiseks kasutatavaid tabeleid saab näidatu kui nimeruumi.<syntaxhighlight lang="lua">
Point = {}

Point.new = function(x, y)
  return {x = x, y = y}  --  return {["x"] = x, ["y"] = y}
end

Point.set_x = function(point, x)
  point.x = x  --  point["x"] = x;
end
</syntaxhighlight>

==== Massiiv ====
Numbrilise võtme kasutamise korral sarnaneb tabel [[Massiiv (programmeerimine)|massiivi andmetüübiga]]. Lua massiivid on 1-baasil. Erinevalt paljudest programmeerimiskeeltest, kus esimene indeks on 0, on siin esimene indeks 1 (kuigi on lubatud kasutada ka indeksit 0).

Lihtne sõnemassiiv:

<syntaxhighlight lang="lua">
array = { "a", "b", "c", "d" }   -- Indeksid määratakse automaatselt
print(array[2])                  -- Väljastab  "b". Automaatne indekseerimine Luas hakkab 1-st.
print(#array)                    -- Väljastab 4.  # See on pikkuse määramise operaator tabelitel ja sõnedel.
array[0] = "z"                   -- 0 on legaalne indeks.
print(#array)                    -- Jätkuvalt väljastab 4, Lua massiivid on 1-põhised.
</syntaxhighlight>
Tabeli <tt>t pikkus on defineeritud</tt> olema iga täisarvuline indeks <tt>n</tt> nii, et <tt>t[n]</tt> ei ole tühi ja <tt>t[n+1]</tt> on tühi; veel enam, kui <tt>t[1]</tt> on tühi, siis <tt>n on</tt> 0. Regulaarse massiivi üks mitte-null väärtustest antakse muutujale <tt>n</tt>, Selle pikkus on sel juhul täpselt <tt>n ehk</tt> viimase indeksi väärtus. Kui massiivil on "auke" (tühjad väärtused on mittetühjade väärtuste vahel), siis <tt>#t</tt> saab olla iga indeks, mis on vahetult eelnev tühjale väärtusele (see tähendab, et ta võib iga sellist tühja väärtust pidada massiivi lõpuks).

Kahedimensiooniline tabel:

<syntaxhighlight lang="lua">
ExampleTable =
{
     {1,2,3,4},
     {5,6,7,8}
}
print(ExampleTable[1][3]) -- Väljastab "3"
print(ExampleTable[2][4]) -- Väljastab "8"
</syntaxhighlight>
Objektide massiiv:
<syntaxhighlight lang="lua">
function Point(x, y)        -- "Point" objekti konstruktor
  return { x = x, y = y }   -- Loome ja tagastame uue objekti (tabel)
end
array = { Point(10, 20), Point(30, 40), Point(50, 60) }   -- Loome punktide massiivi
                        -- massiiv = { { x = 10, y = 20 }, { x = 30, y = 40 }, { x = 50, y = 60 } };
print(array[2].y)                                         -- Väljastab 40
</syntaxhighlight>
Kasutades kujutust normaalse massiivi järgitegemiseks on aeglasem kui kasutada seda tegeliku massiivina. Siiski on Lua tabelid optimeeritud kasutama neid nagu massiive.
=== Metatabelid ===
Laiendatud semantikas on Lua võtmefunktsioon ja [[metatabel]]i kontseptsioon lubab Lua tabeleid kohandada võimsaimasse olekusse. Järgnev näide demonstreerib "lõpmatut" tabelit. Iga <math>n</math>, <tt>fibs[n]</tt> annab <math>n</math>-inda [[Fibonacci jada]] liikme kasutades [[Dünaamiline programmeerimine|dünaamilist programmeerimist]] ja [[Memoisatsioon|tabeli pidamist]], mis on optimeerimise tehnika.
<syntaxhighlight lang="lua">
fibs = { 1, 1 }                                -- esialgne väärtus fibs[1]'le ja fibs[2]'le.
setmetatable(fibs, {
  __index = function(values, n)                --[[ __index on funktsioon, mis on eeldefineeritud Lua poolt,
                                                    See kutsutakse välja, kui võtit "n" ei eksisteeri. ]]
    values[n] = values[n - 1] + values[n - 2]  -- Calculate and memoize fibs[n].
    return values[n]
  end
})
</syntaxhighlight>

=== Objektorienteeritud programmeerimine ===
Lua keeles ei ole sisseehitatud klasse, kuid sellegipoolest on võimalik objektorienteeritult programmeerida. Selleks tuleb kasutada kaht Lua keele funktsiooni: esimese klassi funktsioone ja tabeleid. Objekti saab luua funktsioonide ja seotud andmete tabelisse paigutamisega. Metatabeli mehhanismi abil saab implementeerida pärilust.

Luas ei ole sellist mõistet nagu "[[Klass (programmeerimine)|klass]]" koos nende tehnikatega: pigem on kasutusel prototüübid nagu programmeerimiskeeltes [[Self (programmeerimiskeel)|Self]] ja [[JavaScript]]. Uusi objekte luuakse nii [[tehase meetod]]iga (see konstrueerib uued objektid nullist) kui ka kloonides eksisteerivat objekti.

Lua toetab mõnda süntaktilist suhkrut, et aidata kaasa objekti orientatsioonile. Deklareerides liikmefunktsiooni prototüübi tabelisse sisse, saab kasutada koodi <tt>function table:func(args), millega on samaväärne kood <tt>function table.func(self, args). Klassimeetodeid saab samuti kutsuda kooloni abil. Kood <tt>object:func(args) on samaväärne koodiga</tt> <tt>object.func(object, args)</tt>.</tt></tt>

Loome tavalise [[vektor]]i objekti:
<syntaxhighlight lang="lua">
local Vector = {}
Vector.__index = Vector

function Vector:new(x, y, z)    -- konstruktor
  return setmetatable({x = x, y = y, z = z}, Vector)
end

function Vector:magnitude()     -- teine meetod
  -- viitab varjatud objektile kasutades iseennast
  return math.sqrt(self.x^2 + self.y^2 + self.z^2)
end

local vec = Vector:new(0, 1, 0) -- Loome vektori
print(vec:magnitude())          -- Kutsume välja (output: 1)
print(vec.x)                    -- Ligipääs mälus olevale väärtusele (output: 0)
</syntaxhighlight>

== Sisemus ==
Lua [[Arvutiprogramm|programmid]] ei ole otseselt [[Interpreteerimine|interpreteeritud]] Lua [[tekstifail]]idest, aga on [[Kompileerima|kompileeritud]] [[baitkood]]i, mis töötab Lua [[virtuaalmasin]]as. Kompileerimise protsess on tüüpiliselt nähtamatu kasutajale ja on sooritatud käitamisaja kestel, aga seda saab teha ühenduseta, et kasvatada laadimiskiirust või vähendada rakenduse keskkonna mälu "jalajälge" kompilaatorit välja jättes. Lua baitkood saab samuti olla produtseeritud ja täidetud Luaga kasutades minemaviskamise funktsiooni sõne teegist ja load/loadstring/loadfile funktsioone. Lua versioon 5.3.3 on implementeeritud umbes 24 000 rea C-keele koodiga. 

Nagu enamik [[keskprotsessor]]eid (CPU) ja erinevalt enamikust virtuaalmasinatest, mis on pinupõhised, Lua virtuaalmasin on registripõhine ja järelikult palju enam sarnane päevakajalise riistvara disainiga. Registri arhitektuur väldib nii ülemäärast väärtuste kopeerimist kui ka vähendab kogu instruktsioonide arvu funktsiooni kohta. Lua 5 virtuaalmasin on üks esimesi puhtalt registripõhiseid virtuaalmasinaid omades laia kasutust. [[Perl]]i [[Parrot]] ja [[Android]]i [[Dalvik]] on kaks teist teada-tuntud registripõhist virtuaalmasinat.

See näide on baitkoodi list faktoriaali funktsioonist, mis sai defineeritud ülal (nagu näha <tt>luac</tt> 5.1 kompilaatori poolt):

 function <factorial.lua:1,7> (9 instructions, 36 bytes at 0x8063c60)
 1 param, 6 slots, 0 upvalues, 6 locals, 2 constants, 0 functions
 	1	[2]	LOADK 	1 -1	; 1
 	2	[3]	LOADK 	2 -2	; 2
 	3	[3]	MOVE  	3 0
 	4	[3]	LOADK 	4 -1	; 1
 	5	[3]	FORPREP 	2 1	; to 7
 	6	[4]	MUL  	1 1 5
 	7	[3]	FORLOOP 	2 -2	; to 6
 	8	[6]	RETURN 	1 2
 	9	[7]	RETURN 	0 1

== C API ==
Lua on kavandatud olema sisseehitatud teistese rakendustesse ja C API toetab seda eesmärki. API on jagatud kaheks osaks: Lua südamikuks ja Lua abiteegiks.

Lua API disain elimineerib vajaduse manuaalseks viidete haldamiseks C koodis, erinevalt Pythoni API-st. Keeltel nagu see on API minimalistlik. Arenenud funktsionaalsus on toetatud abiteegi poolt, mis koosneb suurel määral eeltöödeldud makrodest, mis abistavad koos liittabeli operatsioonidega.

=== Kuhi ===
Lua C API põhineb [[Kuhi (informaatika)|kuhjal]]. Lua tagab funktsioonide tõukamist ja esiletoomist enamikus lihtsates C andmetüüpides (näiteks täisarvud, reaalarvud ja nii edasi) ning kuhjas. Lisaks ka funktsioonid töötlevad tabeleid läbi kuhja. Lua kuhi erineb mõnevõrra traditsioonilisest kuhjast. Kuhi saab olla indekseeritud otse. Negatiivsed indeksid kalduvad kõrvale kuhja ülemisest otsast. Kui −1 on üleval (viimati uuendatud väärtus), kuna positiivsed indeksid annavad märku nihkest alumises otsas (vanad väärtused).

C ja Lua vaheliste andmete kogumise funktsioonid on samuti tehtud kasutades kuhja. Kutsudes Lua funktsiooni, argumendid on surutud kuhja peale ja siis lua_call on kasutatud kutsumaks tegelikku funktsiooni. Kui C-keeles kirjutatud funktsiooni otseselt kutsuda Lua keeles, siis argumendid on loetud kuhjast.

=== Näide ===
Siin on näide sellest, kuidas kutsuda välja Lua funktsiooni C-keeles.

<syntaxhighlight lang="c">
#include <stdio.h>
#include <lua.h> //Lua main library (lua_*)
#include <lauxlib.h> //Lua auxiliary library (luaL_*)

int main(void)
{
    //loome Lua seisundi
    lua_State *L = luaL_newstate();

    //lae ning täida string
    if (luaL_dostring(L, "function foo (x,y) return x+y end")) {
        lua_close(L);
        return -1;
    }

    //lükka globaalne väärtus "foo" (funktsioon on eelnevalt defineeritud)
    //kuhja, jälgitud täisarvude 5 ja 3 poolt.
    lua_getglobal(L, "foo");
    lua_pushinteger(L, 5);
    lua_pushinteger(L, 3);
    lua_call(L, 2, 1); //kutsu funktsioon koos kahe argumendiga ja tagasta üks väärtus.
    printf("Result:%d\n", lua_tointeger(L, -1)); //väljastame väärtuse
    lua_close(L); //sulgeme lua seisundi.
    return 0;
}
</syntaxhighlight>

Näite käitamine annab: 
<pre>$ cc -o example example.c -llua
$ ./example
Result: 8
</pre>

=== Spetsiaalsed tabelid ===
C API samuti tagab mõned spetsiaalsed tabelid lokaliseeritult mitmesuguste "pseudo-indeksitega" Lua kuhjas. LUA_GLOBALSINDEX enne Lua 5.2 on üldises tabelis. _G on peamine nimeruum. Seal on samuti registriga määratud LUA_REGISTRYINDEX, kus C programmid saavad salvestada Lua väärtusi hilisema vajaduse jaoks.

=== Laiendus ja seos ===
Lua API-t kasutades on võimalik kirjutada laiendmooduleid. Laiendmoodulid on jagatud objektid, mis on harjunud laiendama interpreteerija funktsionaalsust, tagades algupärase hõlpsuse Lua skriptidele. Selline moodul ilmub, kui nimeruumi tabelis hoitakse vastavaid funktsioone ja muutujaid. Lua skriptid võivad laadida laiendusmooduleid kasutades <tt>require</tt>, just nagu moodulid oleks kirjutatud Lua keeles endas.

Kasvav moodulite kollektsiooni teatakse kui "rocks", mis on saadaval paketihaldussüsteemi LuaRocks kaudu, [[CPAN]] vaimus, [[RubyGems]], [[Python Eggs]].

Eelkirjutatud Lua seosed eksisteerivad enamikus populaarsetes programmeerimiskeeltes, sealhulgas skriptimiskeeltes nagu [[C++]]. Seal on mitu mallipõhist juurdepääsu ja mõni automaatne seosegeneraator.

== Rakendused ==

=== Videomängud ===

Videomängude arenduses on Lua mängude programmeerijate poolt laialdaselt kasutatud kui skriptimiskeel ehk tänu selle tajutud lihtsuses manustamisel, kiirel täitmisel ja lühikesel õppimiskõveral.

2003. aastal korraldatud GameDev.neti küsitlus näitas, et Lua on kõige populaarsem skriptimiskeel mängude programmeerimisel. Lua kuulutati 12. jaanuaril 2012 Front Line Award 2011 võitjaks ajakirjas Game Developer kategoorias "Programmeerimisvahendid".

=== Muid rakendusi ===

Muud rakendused, mis on loodud Lua keelega:

* [[3DMLW]] plugin, kasutatakse Lua [[3D computer graphics|3D]]-animatsioonide skriptimiseks ja käsitlemaks erinevaid sündmusi.
* [[Adobe Photoshop Lightroom]], kasutab Lua'd oma kasutaja kasutajaliideses.
* [[Aerospike database|Aerospike Database]], kasutab Lua'd kui oma sisemist skriptimiskeelt oma "UDF" (User Defined Function) suutlikkuse jaoks – sarnased protseduurid.
* [[Apache HTTP Server]], saab kasutada Lua keelt igal pool päringuprotsessis (alates versioon 2.3, läbi tuumse mod_lua mooduli).
* [[Artweaver]], graafika redaktor kasutab Lua'd skriptimisfiltrina.
* [[Autodesk Stingray]], mängumootor, mis kasutab Lua'd videomängude arendamiseks.
* [[Awesome (window manager)|Awesome]], [[aknahaldur]], mis on kirjutatud osaliselt Lua keeles, samuti kasutatakse seda konfiguratsioonifailivorminguna.
* [http://www.eterna.com.au/bozohttpd/ bozohttpd], vaikimisi veebiserver koos [[NetBSD]]-ga, on integreeritud Lua toega dünaamilise sisu loomiseks.
* [[CHDK|The Canon Hack Development Kit]] (CHDK), avaliku lähtekoodiga püsivara Canoni kaameras, kasutatakse Lua kui ühte kahest skriptimiskeelest.
* [[Celestia]], astronoomia hariduslik programm, kasutab Lua keelt kui oma skriptimiskeelt.
* [[Cheat Engine]], mälu redaktor/silur, lubab Lua skripte manustada oma "cheat table" failidesse. Lisaks sisaldab GUI disainijat. 
* [[Cisco Systems|Cisco]], kasutab Lua'l implementeerida dünaamilise juurdepääsu poliise Adaptive Security Appliance'i piires.
* [[Conky (software)|Conky]], Linux süsteemiseire rakendus, mis kasutab Lua arenenud graafika jaoks. 
* [[Cocos2d]], kasutab Lua'd mängude ehitamises koos nende Cocos Code IDE-ga.
* [[Codea]], Lua redaktor [[iOS]]-i operatsioonisüsteemile.
* [[Creative Technology]] [[Creative ZEN#ZEN X-Fi2|Zen X-Fi2]] kohandatud rakendused nagu kaasaskantav meediamängija on loodud Lua keeles. 
* [[Damn Small Linux]], kasutab Lua keelt toetamaks ekraani-sõbraliku kasutajaliidese käsurea vahendeid ilma ohverdamata palju kettaruumi. 
* [[darktable]] avatud lähtekoodiga fotograafia töövoo rakendus, mis on skriptitav Lua'ga.
* [[Dolphin Computer Access]], kasutab Lua skriptimist, tegemaks ligipääsmatuid rakendusi ligipääsetavaks nägemiskahjustusega arvutikasutajatele ekraanilugereid – SuperNova.
* Eyeon'i [[Eyeon Fusion|Fusion]] komponeerija kasutab sisseehitatud Lua'd ja LuaJIT sisemist ja välimiste skriptide jaoks ning samuti laienduste prototüüpimiseks. 
* [[Nintendo Entertainment System|NES]] [[emulator]] [[FCE Ultra]] haru, mida kutsutakse FCEUX-iks, lubab laiendusteks ja mängumodifikatsioonideks kasutada Lua skripte.
* [[Flame (pahavara)|Flame]], suur ja kõrge keerukusega pahavara osa on kasutatud küberkuritegevuses.
* [[Foldit]] – teadusele orienteeritud proteiinide kokkupanemise mäng, mis kasutab Lua'd oma skriptides. Mõned selle rakenduse skriptidest on olnud artikli [[Proceedings of the National Academy of Sciences of the United States of America|PNAS]] eesmärk.
* [[FreePOPs]], meili vahendaja laiendus, mis kasutab Lua'd oma veebi front-end osa jõudluse parandamiseks. 
* [[Freeswitch]], avatud lähtekoodiga telefoniplatvorm, mis on disainitud hõlbustama heliloomingu loomist ja sõidu ajal rääkimist võimaldavaid tooteid, milles Lua'd kasutatakse kui skriptimiskeelt kõneprotokollide ja kõnevoogude ja teiste asjade jaoks. 
* [[Geany]], koodiredaktor, omab Lua pluginaid, GeanyLua.
* [[Ginga (SBTVD Middleware)|Ginga]], Brasiilia digitaaltelevisiooni süsteemi ([[ISDB-T International|SBTVD või ISDB-T]]) vahevara, kasutab Lua'd kui skriptimiskeelt oma deklaratiivses keskkonnas. Ginga-NCL. Ginga-NCL-is Lua on integreeritud kui meediaobjektid (kutsutakse NCLua) NCL-i (Nested Context Language) dokumentides.
* [[GrafX2]], piksel-joonistamise redaktor, saab käitada Lua skripte lihtsa pildi töötlemiseks või üldiseks illustreerimiseks.
* [[HAProxy]], [[pöördproksi]] tarkvara, võib olla laiendus koos Luaga alates versioonist 1.6.
* [[iClone]], reaalajas animeerimise 3D-stuudio loomaks animafilme, kasutab Lua'd oma uues füüsikasimulatsiooni juhtsüsteemis. 
* Joonistamisredaktor [[Ipe (program)|Ipe]] (peamiselt kasutatud jooniste töötlemiseks [[LaTeX|LaTeX-i]] märgistamisega). Kasutab Lua'd oma funktsionaalsuses ja skriptitud laiendustes. 
* [[Lego Mindstorms NXT]] ja [[Lego Mindstorms NXT 2.0|NXT 2.0]] saab skriptida Lua'ga kasutades kolmanda osapoole tarkvara.
* [[lighttpd]] veebiserver, kasutab Lua'd haakimaks skripte sama hästi kui tänapäevane asendus [[Cache Meta Language|Cache Meta Language'ks]].
* [[Logitech]]i profiili haldamise tarkvara versioon 2.01 [[Logitech G15|G15]] mänguklaviatuur kasutab Lua keelt kui oma skriptimiskeelt.
* [https://luakit.github.io/luakit/ luakit] püüab olla kiire ja lihtne [[WebKit]]i-põhine [[brauser]]i raamistik, Lua poolt laiendatav.
* [[LuaTeX]], määratud [[pdfTeX]]-i järglaseks, lubab laiendusi kirjutada Lua keeles.
* LuCI, vaikimisi brauseri kasutajaliides [[OpenWrt]]. See on kirjutatud peamiselt keeles Lua.
* [[MediaWiki]] kasutab Lua kui uut šabloonkeelt, mis on kasutusel [[Wikipedia]]s ja teistes vikides.
* [http://www.public-software-group.org/moonbridge Moonbridge Network Server for Lua Applications] kombinatsioonis [http://www.public-software-group.org/webmcp WebMCPiga], veebiarendamise raamistik, lubab keerulisi veebirakendusi kirjutada Lua keeles (kasutatud [[LiquidFeedback]]i poolt).
* [[MySQL Workbench]], kasutab Lua keelt oma laienduste jaoks.
* [[NetBSD]], omab Lua [[draiver]]it, mis saab luua ja kontrollida Lua seisundit [[kernel]]i sees. See lubab Lual olla kasutatud pakettide filtreerimiseks ja loomaks seadme draivereid.
* [[Nginx]], omab jõuliselt sisse kinnitatud Lua mooduleid, mis tagavad API ligipääsu Nginx abivahenditele nagu soketi käitlemine.
* [[nmap]], internetiturvalisuse kontrollija kasutab Lua keelt kui põhja oma skriptimiskeelele *nse''.
* NodeMCU, kasutab Lua keelt riistvaras. NodeMCU on open source riistvara platvorm, mis saab käitada Luad otse ESP8266 Wi-Fi SoC'd.
* Sierra Wireless AirLink ALEOS GSM / CDMA / LTE juurdepääs lubab kasutaja rakendustel olla kirjutatud Lua keeles. 
* OpenResty on dünaamiline veebiplatvorm, mis põhineb NGINX-il ja LuaJIT-l. https://openresty.org/en/.
* Perimeta seansipiirangukontroller Metaswitch Networksilt kasutab Lua keelt kui skriptimiskeelt, manipuleerimaks SDP andmetega lennult.
* PowerDNS pakub laiendatud Lua keeles skriptimist teenindamiseks ja DNS-i vastuste muutmiseks, parandamaks katkisi servereid ja DoS-i kaitset. 
* Project Dogwaffle Professional pakub Lua skriptimist tegemaks filtreid läbi DogLua filtri. Lua filtreid saab jagada Project Dogwaffle, GIMP, Pixarra Twistedbrush ja ArtWeaveri vahel. 
* Prosody on platvormiülene Jabber/XMPP server, mis on kirjutatud keeles Lua.
* QSC Audio Products toetab Lua keeles skriptimist väliste seadmete kontrollimisel ja teistel kõrgema funktsionaalsusega Q-SYS Designeris.
* Quartz Composer, visuaalse programmeerimise tööriist Apple'ilt, saab skriptida Lua keeles läbi tasuta plugina, mis on toodetud Boinx Software poolt.
* REAPER digitaalse audio tööjaam toetab laienduste funktsionaalsuse Lua keeles skriptimist.
* Reason digitaalse audio tööjaam, Lua keelt kasutatakse Remote codec'i kirjeldamiseks. 
* Redis, on avatud lähtekoodiga võtmeväärtusega andmebaas, milles Lua'd saab kasutada (alates versioonist 2.6) keeruliste funktsioonide kirjutamiseks, mis käitab serveris iseennast, seega laiendab oma funktsionaalsust.
* RetroShare krüptitud failijagamine, serverivaba e-post, hetketeated, jututuba ja BBS tarkvara, põhineb sõbralt-sõbrale võrgul, omab Lua pluginat automatiseerimiseks ja kontrollimiseks.

* Rockbox, avatud lähtekoodiga digitaalse audio püsivara, toetab pluginaid, mis on kirjutatud Lua keeles.

* RPM, tarkvarapakettide haldamise süsteem, kõigepealt välja töötatud Red Hat Linuxi jaoks.
* Uus versioon SciTE redaktorist saab laiendada kasutades Lua'd.
* SAS integreerib Lua PROC LUA seisundiga
* Snort sissetungi tuvastamise süsteem sisaldab Lua interpretaatorit alates 3.0 beetaväljalaskest.
* Squeezebox muusika mängijad Logitechilt toetavad pluginaid, mis on kirjutatud Lua'ga hiljutistele mudelitele (Kontroller, Raadio ja Puutuja).
* Tarantool kasutab Lua keelt kui salvestamise protseduuri keelt oma NoSQL-i andmebaasi haldamise süsteemiga ning tegutseb kui Lua rakenduste server. 
* TeamSpeak omab Lua keeles skriptimise pluginat modifikatsioonide jaoks.
* TI-Nspire kalkulaatorid sisaldavad Lua keeles kirjutatud rakendusi alates sellest ajast, kui TI lisas Lua skriptimise toe koos kalkulaatorispetsiifilise API-ga OS 3+'is.
* Torch on avatud lähtekoodiga süvaõppe teek Lua keeles.
* Transformice – iseseisev mitmikmäng tasuta mängitaval veebiplatvormil brauseri mäng, mis kasutab Lua keelt programmeerimaks minimänge.
* Varnish saab käitada Lua skripte nõutud protsessis, laiendades VCL läbi Lua VMOD (Varnish moodul).
* Vim omab Lua keeles skriptimise tuge alates versioonist 7.3.
* VLC media player kasutab Lua keelt tagamaks skriptimise toe.
* WeeChat IRC klient aktsepteerib skripte, mis on kirjutatud Lua keeles. 
* WinGate proksi server lubab sündmuste töötlemise ja Lua skriptide täitmise poliitika ligipääsuga sisemistele WinGate objektidele.
* Wiresharki võrgupaketi analüüsija lubatud protokolli lahutaja on kirjutatud Lua-ga.
* ZeroBrane Studio Lua IDE, mis on kirjutatud Lua keeles ja kasutab Lua'd oma laiendustes.

## Fakte Lua keele kohta
* Lua on ainus arengumaalt pärit programmeerimiskeel, mis on saavutanud globaalse tähtsuse.

## Vaata ka
* Programmeerimiskeel

## Viited

## Lisalugemist

### Raamatud
* 
* 
* 
* 
*  Chapters 6 and 7 are dedicated to Lua, while others look at software in Brazil more broadly.
* 
*  (The 1st ed. is available online.)

### Artiklid
* 
* 
* 
* 
*  Interview with Roberto Ierusalimschy.
*  How the embeddability of Lua impacted its design.
* Lua papers and theses

## Välislingid
* Lua ametlik veebileht
* Lua Users, kommuun
* eLua, Embedded Lua
* Projects in Lua
* SquiLu, Squirrel modifitseeritud koos Lua teekidega
* Ravi, Lua 5.3 derivatiiv koos limiteeritud valikulise staatilise tüüpimisega ja LLVM-il põhinev JIT kompilaator