stanford-oval/wikipedia huggingface dataset:
מטמורוס
היסטוריה

הספרדים הגיעו לאזור צפון טמאוליפס לראשונה ב-1519, כאשר הגיעה למקום משלחת של אלונסו אלברס דה פינדה. עם זאת האזור הספציפי בו נמצאת כיום מטמורוס נחקר באופן פרטני רק ב-1686, כאשר משלחת של אלונסו דה לאון שטה במעלה נהר ריו גראנדה.
ב-1774 התיישבו באזור מספר משפחות מערים שונות באזור כמו ריינוסה והקימו בו חוות. התיישבות זו היא המקור של העיר של היום.
ב-1826, לאחר מלחמת העצמאות של מקסיקו, ההתיישבות נקראה מטמורוס על שמו של מריאנו מטמורוס, מורד מקסיקני שנהרג במהלך המלחמה. העיר שימשה כבסיס לכוחות המקסיקניים במהלך המהפכה הטקסנית שפרצה ב-1835. ב-1846 וב-1851 העיר עמדה מול התקפותיהם של מתנגדי שלטון אנטוניו לופס דה סנטה אנה, ועקב כך הוחלט להוסיף לשמה ב-1852 את התואר ארואיקה ("הרואית").
ב-1858 מטמורוס הוכרזה כמתחם סחר חופשי (אנ'). הדבר גרם לעיור ותיעוש נרחב של העיר ולהגדלת עיירת הנמל פוארטו בגדאד בקרבת העיר, שהייתה שער כניסה חשוב לקונפדרציית המדינות של אמריקה במהלך מלחמת האזרחים האמריקנית שפרצה ב-1860. עם זאת, לאחר ההפסד של הקונפדרציה במלחמה ב-1865 העיר ירדה מגדולתה ונכנסה למשבר כלכלי. ב-1866, במהלך הניסיון של צרפת להשתלט על מקסיקו, התרחש קרב בפוארטו בגדאד בו ניצחו המקסיקנים.
שורה של הוריקנים הרסניים הכתה באזור בעשורים שלאחר מכן והחריבה כליל את פוארטו בגדאד. בעקבות ההוריקנים כמחצית מאוכלוסיית מטמורוס עזבה את העיר ונגרם משבר כלכלי נוסף.
במאה ה-20 העיר החלה להתאושש ולשגשג והיא נהפכה למרכז לייצוא כותנה. במחצית השנייה של המאה ה-20, ובמיוחד מאז חתימת הסכם הסחר החופשי של צפון אמריקה, כלכלת העיר המשיכה לשגשג ואוכלוסייתה גדלה ממהגרים רבים מאזורים שונים במקסיקו.
כלכלה

כלכלת העיר מסתמכת על מסחר עם ארצות הברית מצפון, תעשייה, חקלאות, גידול מקנה ודיג.
ארצות הברית מקיימת קונסוליה כללית בעיר, בנוסף ל-שגרירות ארצות הברית במקסיקו סיטי
תחבורה

ארבעה גשרים בינלאומיים מקשרים בין מטמורוס וארצות הברית: הגשר הבינלאומי בראונסוויל ומטמורוס, הגשר הבינלאומי גייטוויי (Gateway), גשר הווטרנים הבינלאומי והגשר הבינלאומי "סחר חופשי".
את העיר משרת נמל התעופה הבינלאומי חנרל סרבנדו קנלס, הנמצא במרחק של 9 קילומטרים מהעיר.
ערים תאומות

ארצות הברית בראונסוויל, טקסס, ארצות הברית
הערות שוליים

↑  קונסוליות ארצות הברית במקסיקו Locations". U.S. Department of State, United States Diplomatic Mission to Italy. Archived from the original on 18 June 2015. Retrieved 20 June 2015.
| --- | --- |
בקרת זהויות :  NLI: 987007489436605171  BnF: cb123566510 (data)  MusicBrainz: ad3ef3fd-3a7b-4712-97bf-6712376545df  NARA: 10037334  VIAF: 145144648537774718529   WorldCat (עם VIAF): 145144648537774718529
לואה (שפת תכנות)

| --- | --- |


מדריך השפה מאת רוברטו ירוסלמשי
 פרדיגמות:  תכנות מונחה דגמי אב, תכנות אימפרטיבי, תכנות פרוצדורלי, תכנות פונקציונלי
 תאריך השקה:  1993 
 מתכנן:  רוברטו ירוסלמשי, לואיז הנריק דה פיגרדו, ו־ולדמר סלס
 מפתח:  אוניברסיטה הקתולית (PUC Rio) שבריו דה ז'ניירו
 טיפוסיות:  דינמית
 מימושים:  Lua, LuaJIT
 ניבים:  Metalua, Idle, GSL Shell
 הושפעה על ידי:  C++, CLU, Modula-2, Scheme, SNOBOL
 השפיעה על:  GameMonkey, Io, JavaScript, Julia, MiniD, Red, Ring, Ruby, Squirrel, MoonScript
 רישיון:  רישיון MIT
 סיומת:  .lua
 https://www.lua.org
 
לוּאה (Lua, מפורטוגזית: ירח) היא שפת תכנות דינמית שפותחה על ידי רוברטו ירוסלמשי, לואיז הנריק דה פיגרדו, ו־ולדמר סלס בשנת 1993 באוניברסיטה הקתולית (PUC Rio) שבריו דה ז'ניירו. הגרסה הציבורית הראשונה של לואה פורסמה בשנת 1994. לואה משמשת בעיקר כשפת תכנות מוטמעת בתוכניות אחרות. המפרש הסטנדרטי של השפה כתוב בשפת C ומופץ כתוכנה חופשית ברישיון MIT בקשת רחבה של פלטפורמות.
היסטוריה > TECGRAF

TECGRAF היא המעבדה לגרפיקה ממוחשבת של האוניברסיטה הקתולית שבריו דה ז'ניירו. המעבדה נוסדה בשנת 1987. המעבדה פיתחה ספריות ממשק גרפיות ומנהלי התקנים גרפיים כדי לספק ללקוחות שלה תוכנות עם ממשקים ידידותיים למשתמש.
בין השנים 1977–1992 לברזיל הייתה מדיניות מסחר שהקשתה מאוד על ייבוא מוצרי חומרה ותוכנה מתוך מחשבה לאומנית שברזיל יכולה וחייבת לפתח חומרה ותוכנה משלה. על רקע מצב זה המעבדה TECGRAF נאלצה לפתח את הספריות והשפות המקוריות שלה במקום להישען על מוצרים טכנולוגיים קיימים.
אחת מהלקוחות הכי חשובים של TECGRAF היה חברת הנפט הברזילאית פטרוברז. TECGRAF פיתחה סך הכול שלוש שפות תכנות עבור הצרכים של פטרוברז. שתי שפות התכנות הראשונות, DEL ו־SOL, הובילו לפיתוחה של לואה.
היסטוריה > DEL

Data-entry Language (בראשי תיבות: DEL, בעברית: שפה לקליטת נתונים) הייתה שפת תכנות הצהרתית קטנה שפותחה על ידי TECGRAF עבור פטרוברז. בשנת 1992 פטרוברז פנתה ל־TECGRAF בבקשה לפתח לה ממשק משתמש ידידותי עבור המהנדסים בחברה שנאלצו עד כה להשתמש בכרטיסים מנוקבים כדי להזין נתונים מספריים למחשבים. DEL הייתה שפה מוצלחת מאוד אך די מוגבלת; בעקבות זאת, נדרשו עוד ועוד יכולות חדשות לשפה כגון בקרת זרימה, מה שהוביל את המעבדה למסקנה שנדרש פיתוח של שפת תכנות חדשה.
היסטוריה > SOL

Simple Object Language (בראשי תיבות SOL, בעברית: שפת עצמים פשוטה) הייתה שפת תכנות הצהרתית עם טיפוסיות חזקה שפותחה על ידי TECGRAF עבור פטרוברז. SOL הושפעה רבות מ־BibTeX ו־UIL, שפה ששימשה לעיצוב ממשקים גרפיים במערכות יוניקס. הפיתוח של SOL הושלם בשנת 1993, אך השפה מעולם לא הושקה בפועל. בפטרוברז כבר דרשו תמיכה בתכנות פרוצדורלי; בעקבות כך, TECGRAF החליטו להחליף את שתי השפות באחת שתתן מענה מקיף לכל הדרישות של פטרוברז, וכך נולדה לואה.
היסטוריה > PUC Rio Lua

הפיתוח של לואה החל בשנת 1993 על ידי מדען המחשב רוברטו ירוסלמשי, המתמטיקאי לואיז הנריק דה פיגרדו, ומהנדס התוכנה ולדמר סלס; השלושה עבדו יחד ב־TECGRAF.‏ משמעות השם "Lua" בפורטוגזית היא ירח; השם נבחר בעקבות שמה של שפת התכנות SOL שקדמה ללואה, מכיוון שמשמעות המילה "Sol" בפורטוגזית היא שמש. לואה ירשה מ־SOL את יעודה כשפה לתיאור נתונים, ומ־DEL את יעודה כשפה משובצת. בנוסף ל־SOL ו־DEL, לואה הושפעה גם ממודולה־2, CLU, Scheme, C++, ו־SNOBOL. מודולה־2 תרמה את רוב התחביר והמילים השמורות בשפה. Scheme הייתה מקור להשראה עבור הסמנטיקה בשפה; לדוגמה, התייחסות לפונקציות כערכים והמעבר ההדרגתי לתחום הכרזה לקסיקלי. CLU נתנה השראה לריבוי החזרות והקצאות מפונקציות. ++C נתנה השראה למשתנים מקומיים. SNOBOL נתנה השראה לטבלאות בשפה.
היסטוריה > PUC Rio Lua > Lua 1.0–1.1

בשנת 1993 הסתיים הפיתוח של Lua 1.0, אבל גרסה זו לא שוחררה לציבור באותו הזמן. המנתח הלקסיקלי הראשון של השפה פותח באמצעות Lex ו־Yacc.
בשנת 1994 שוחררה Lua 1.1 וזמן קצר לאחר מכן פורסם המאמר שהציג לראשונה את השפה לקהל הרחב. גרסה זאת הייתה חופשית לשימוש אקדמי אך לא לשימוש מסחרי. בגרסה זו פותח מנתח לקסיקלי חדש לשפה שהכפיל את מהירות הניתוח התחבירי.
היסטוריה > PUC Rio Lua > Lua 2.1–2.5

בשנת 1995 פורסמה Lua 2.1. בגרסה זו הופיע לראשונה התחביר שאפשר חיקוי של תכנות מונחה עצמים בשפה, ונוסף מנגנון למצבי נסיגה. החל מגרסה זאת היישום המרכזי של לואה הפך להיות חופשי גם לשימוש מסחרי. בגרסה הקודמת, לואה הציעה שלוש דרכים ליצירת טבלאות: בסוגריים עגולים () לטבלה ריקה, בסוגריים מרובעים [] למערך מספרים, ובסוגריים מסולסלים {} לרשומה. בגרסה זו התחביר ליצירת טבלאות אוחד לסוגריים מסולסלים ופעולת ההשוואה שונתה מ־= ל־== כדי לאפשר את האיחוד בתחביר הטבלאות. באותה שנה פורסמה Lua 2.2, בגרסה זו התחביר לפונקציות הורחב ונוסף ממשק חדש לניפוי שגיאות.
בשנת 1996 פורסמה Lua 2.5. בגרסה זו נוספו ממשק בשפה לחיפוש ביטויים במחרוזות, ואפשרות לריבוי פרמטרים בפונקציות באמצעות ....
היסטוריה > PUC Rio Lua > Lua 3.0–3.2

בשנת 1997 פורסמה Lua 3.0. בגרסה זו הטיפוסיות של פונקציות שהוגדרו בלואה ופונקציות שהוגדרו בשפת C אוחדה לטיפוסיות אחת עבור שני סוגי הפונקציות. בגרסה זו המנגנון למצבי נסיגה בשפה התחיל לקבל פרמטר נוסף לסוג האירוע: תג.
בשנת 1998 פורסמה Lua 3.1. בגרסה זו לואה אימצה תחום הכרזה לקסיקלי חלקי, פונקציות אנונימיות, וייצוג מספרים בשפה באמצעות נקודה צפה באורך כפול. לאור המחסור בלולאת for, חוסר שביעות רצון מלולאות while, ומחלוקת על התחביר האפשרי עבור לולאת for, הוחלט בסוף לספק פונקציה כללית מסדר גבוה מהצורה foreach(t, print) שתבצע עבודה בלולאה מתוך פרמטר של פונקציה. החל מגרסה זו, ניתן להגדיר מפתח בטבלה באמצעות סוגריים מרובעים כך: t={["key"]=value}. באותה שנה הושק הסמליל הנוכחי של השפה.
בשנת 1999 פורסמה Lua 3.2. בגרסה זו נוספה ספרייה חדשה בשפה לניפוי שגיאות, ומטא פונקציות חדשות עבור טבלאות. גרסה זו נחשבה לאחת הגרסאות היציבות של לואה, רבים דילגו כליל על Lua 4.0 ועברו מ־Lua 3.2 הישר אל Lua 5.0.
היסטוריה > PUC Rio Lua > Lua 4.0–4.1

בשנת 2000 פורסמה Lua 4.0. מגרסה זו ניפוי השגיאות בשפה הפך להיות זמין בכל רגע נתון בזמן ריצה ונוספו לולאות מסוג for. כמו כן, נוספה בשפה ספרייה לאינטראקציה עם מערכות הפעלה וממשק ה־C של השפה ידע להתמודד עם ריבוי מצבים.
בשנת 2001 פורסמה גרסת אלפא של Lua 4.1. גרסה זאת הייתה בפועל Lua 5.0 תוך כדי הליך הפיתוח שלה; הקפיצה במספר ל־5.0 התרחשה בשנת 2002 לאחר פיתוח מנגנון חדש לניהול מודולריות בשפה.
היסטוריה > PUC Rio Lua > Lua 5.0–5.4

בשנת 2003 פורסמה Lua 5.0. בגרסה זו לואה אימצה תחום הכרזה לקסיקלי מלא וזנחה את מנגנון היקף המשתנים הקודם, נוספו שגרות המשך, תהליכונים, מטא טבלאות, משתנים בוליאניים, מיטוב לרקורסיית זנב, טבלאות עם ייחוס משתנים חלש (ייחוס מתירני לאיסוף זבל), והרחבות נוספות. החל מגרסה זו לואה שוחררה תחת רישיון MIT. החל מגרסה זו, ניתן לערבב בטבלאות באופן חופשי בין רשומות ופריטים. באותה שנה פורסמה המהדורה הראשונה של מדריך השפה. בחודש יולי באותה שנה Lua 1.0 שוחררה לציבור לרגל חגיגת עשור לשפה.
בשנת 2005 פורסמה הגרסה הראשונה של המהדר LuaJIT.
בשנת 2006 פורסמה Lua 5.1. בגרסה זו הופיע מנגנון חדש לאיסוף זבל, תחביר חדש למודולריות, מנגנון חדש לריבוי פרמטרים בפונקציות, קינון הערות ומחרוזות בעזרת [==[...]==], שתי פעולות חדשות: אורך ומודולו, מטא טבלאות לכל הטיפוסים, והרחבות נוספות. באותה שנה פורסמה המהדורה השנייה של מדריך השפה.
בשנת 2011 פורסמה Lua 5.2. בגרסה זו נוספה ספרייה לפעולות על סיביות (פעולות ביטים), יכולת קידוד UTF-8 במחרוזות, פעולת goto, והרחבות נוספות.
בשנת 2012 ויקיפדיה אימצה את לואה כשפת תסריט לתבניות.
בשנת 2013 פורסמה המהדורה השלישית של מדריך השפה.
בשנת 2015 פורסמה Lua 5.3. בגרסה זו נוסף טיפוס חדש למספרים שלמים, נוספו סימנים חדשים לשפה לפעולות על ביטים, ספרייה חדשה למחרוזות בקידוד UTF-8, ותמיכה במערכות מסוג 32 ביטים ו־64 ביטים.
בשנת 2016 פורסמה המהדורה הרביעית של מדריך השפה.
בשנת 2020 פורסמה Lua 5.4. בגרסה זו מנגנון חדש לאיסוף זבל, תמיכה במשתנים קבועים באמצעות <const> ותחביר חדש לסגירת משתנים.
דוגמאות > שלום עולם!

print("Hello world!")
דוגמאות > מחלק משותף מקסימלי

local function GCD(a, b)
    while a ~= b do
        if a > b then
            a = a - b
        else
            b = b - a
        end
    end
    return a
end
דוגמאות > עצרת

שגרה רקורסיבית נאיבית לחישוב עצרת בלי אופטימיזציה:
local function factorial(n)
    if n == 0 then
        return 1
    end
    return n * factorial(n - 1)
end
שגרה רקורסיבית לחישוב עצרת עם אופטימיזציה:
local cache = {
    [0] = 0,
    [1] = 1
}
local function factorial(n)
    if not cache[n] then
        cache[n] = n * factorial(n - 1)
    end
    return cache[n]
end
עיצוב

עקרונותיה המעצבים של לואה הם בהירות תחבירית, הצעת מנגנונים בסיסיים במקום מבני שפה מורכבים למקרים ייחודיים, והשימוש בטבלה כמבנה נתונים אוניברסלי. מאפיינים בולטים נוספים של השפה הם ניידות בין מערכות הפעלה וסוגי מעבדים שונים (מפרש השפה כתוב בשפת C והוא שוקל פחות ממגה בייט אחד), תכנות פונקציונלי, ויעילות ביצועית בזמן ובזיכרון. היסטורית, לואה עוצבה להיות שפה מוטמעת לתיאור נתונים. לואה מצוידת במנגנון אוטומטי לאיסוף זבל. בלואה, משתנים שלא יוגדרו במפורש כמשתנים מקומיים באמצעות local יוגדרו להיות משתנים גלובליים. גישה למשתנים לא קיימים אינה נחשבת לשגיאה בשפה, אלא משתנה לא קיים תמיד יחזיר ערך nil.
עיצוב > סמנטיקה

מבחינה סמנטית, לואה שואבת השראה משפת התכנות Scheme. ההשפעה של Scheme על לואה הייתה ניכרת באופן הדרגתי עם ההתפחות של לואה, במיוחד עם הופעתן של פונקציות אנונימיות ותחום הכרזה לקסיקלי ב־Lua 3.1. באופן דומה ל־Scheme, למשתנים אין טיפוסיות, אלא רק לערכים יש טיפוסיות; משתנים לעולם לא מעתיקים מבנה נתונים בהקצאה, אלא רק מעתיקים את המצביע לאותו מבנה נתונים; לפונקציה אין מעמד מיוחד בשפה, היא ככל שאר טיפוסי הנתונים וניתן להקצות אותה למשתנה כלשהו; למעשה לכל המבנים בשפה יש מעמד שווה, ואת כולם ניתן להקצות לתוך משתנים. עם זאת, קיים הבדל סמנטי מרכזי בין לואה ל־Scheme, בכך שטבלאות הן מבנה הנתונים היחידי בלואה, ומהן המתכנת מרכיב מבני נתונים מורכבים יותר כגון מחסניות, קבוצות, ורשימות.
עיצוב > טיפוסי נתונים

בלואה, למשתנים אין טיפוסיות, אלא רק לערכים יש טיפוסיות. ניתן לבדוק את הטיפוסיות של הערכים באמצעות הפונקציה הגלובלית type כך:
type(print) -- function
| סוג | סוג | שם | שם | דוגמה | דוגמה | דוגמה | פעולות | טווח ערכים |
| --- | --- | --- | --- | --- | --- | --- | --- | --- |
| ערך ריק | ערך ריק | nil | nil | nil | nil | nil | שלילה not, וגם and, או or | nil |
| בוליאני | בוליאני | boolean | boolean | true | true | true | שלילה not, וגם and, או or | true או false |
| טבלה | טבלה | table | table | {} | {} | {} | גישה והקצאה עם t["key"] או t.key, אורך # | טבלה |
| פונקציה | פונקציה | function | function | f = function(x) end | f = function(x) end | f = function(x) end | קריאה | פונקציה |
| פונקציה | פונקציה | function | function | function f(x) end | function f(x) end | function f(x) end | קריאה | פונקציה |
| מספר | ממשי | number | float | 1.0- | 1.0- | 1.0- | ארבע פעולות חשבון: +, -, *, / פעולות השוואה: ==, ~=, <, >, <=, >=, מודולו %, העלאה בחזקה ^ |  -10^{308}\leq x\in \mathbb {R} \leq 10^{308} |
| מספר | ממשי | number | float | 1.0- | 1.0- | 1.0- | ארבע פעולות חשבון: +, -, *, / פעולות השוואה: ==, ~=, <, >, <=, >=, מודולו %, העלאה בחזקה ^ |  -2^{53}\leq x\in \mathbb {R} \leq 2^{53} |
| מספר | שלם | number | integer | 1.0- | 1.0- | 1.0- | ארבע פעולות חשבון: +, -, *, / פעולות השוואה: ==, ~=, <, >, <=, >=, מודולו %, העלאה בחזקה ^ |  -2^{63}\leq x\in \mathbb {Z} \leq 2^{63}-1 |
| מחרוזת | מחרוזת | string | string | "..." | '...' | [[...]] | חיבור מחרוזות .., אורך # | מחרוזת |
| תהליכון | תהליכון | thread | thread |  |  |  |  | תהליכון |
| ערך בשפת C | ערך בשפת C | userdata | userdata | (ערכים בשפת C) | (ערכים בשפת C) | (ערכים בשפת C) | (ערכים בשפת C) | (ערכים בשפת C) |
↑  לא כולל פונקציות מובנות בשפה
↑  בלואה, כל ערך שאינו nil או false נחשב ל־true, כולל 0 או מחרוזת ריקה.
↑  הפונקציה type לא מבדילה בין מספרים ממשים ומספרים שלמים, אבל הפונקציה math.type מחזירה float עבור מספרים ממשים ו־integer עבור מספרים שלמים.
↑  בפועל מדובר בנקודה צפה באורך כפול (double).
↑  פעולות ההשוואה == ו־~= זמינות לכל סוגי הערכים.
↑  טווח שמאפשר הצגה מדויקת של מספרים שלמים
↑  נוסף בלואה 5.3
עיצוב > מחרוזות

בלואה, מחרוזות הן רצף תווים עם קידוד לא מוגדר. לדוגמה, פעולת אורך של מחרוזת לא מתחשבת בסוג הקידוד, אלא בסכום הבתים בלבד. עם זאת, נהוג להשתמש בקידוד UTF-8, והחל מגרסה 5.3 קיימת ספרייה קטנה בשפה שיודעת להתמודד עם מחרוזות בקידוד UTF-8. מחרוזות בלואה לא ניתנות לשינוי, במקום זאת, יוצרים כל פעם מחרוזת חדשה עם השינויים רצויים. כשנעשית פעולה מספרית על מחרוזת (כגון חיבור מספרים +), או פעולת מחרוזת על מספר (כגון שרשור ..) לואה מנסה לבצע המרה בין מחרוזות ומספרים באופן אוטומטי. בשפה זמינה ספרייה נרחבת להתאמת דפוסים, חיפוש, והחלפה בתוך מחרוזות באמצעות ביטויים דומים לביטויים רגולריים.
עיצוב > טבלאות

בלואה, טבלאות פשוטות מתנהגות כמילונים והן משמשות להרכבת מבני נתונים מכל הסוגים, כולל מערכים, מטריצות, רשימות מקושרות, קבוצות, ועוד. בניגוד לשפות רבות אחרות, הספירה בלואה תמיד מתחילה ב־1 ולא ב־0; כלומר, הפריט הראשון בטבלה מקומו הוא 1 ולא 0. ניתן להקצות ערך מכל סוג של טיפוס נתונים (למעט nil המציין פריט חסר) הן למפתח בטבלה והן לערך אליו המפתח מוביל. בנוסף, לא קיימת אכיפה של אחידות בטיפוסיות בטבלה, לא במפתחות ולא בערכים. הפעולה לבדיקת אורך טבלה (#) מתאימה אך ורק לטבלאות רצופות היטב (ללא מקומות ריקים); ומכיוון שאין כל אכיפה בשפה על מיקום פריט בטבלה, ספירת הפריטים בטבלאות היא בדרך כלל באחריות המתכנת. מיקומם של הפריטים בטבלה לא משפיע כלל על גודל הטבלה, מכיוון שטבלאות בשפה הן מילונים ולא מערכים.
עיצוב > פונקציות

למרות היותה שפה אימפרטיבית, ללואה תמיכה מלאה בתכנות פונקציונלי. בלואה, פונקציות הן ערכים לכל דבר ועניין וניתן להקצות אותן לתוך משתנים וטבלאות או להגדיר אותן בתוך ביטויים כתחשיב למדא. כמו כן, פונקציות בשפה מתנהגות כ־סְגוֹר; לדוגמה, פונקציות יודעות להחזיר פונקציות חדשות ולהנחיל להן גישה למשתנים מקומיים שהוגדרו מחוצה להן. כשאר הערכים בשפה, פונקציות הן אנונימיות בהגדרה, ורק למשתנים שמחזיקים אותן יש שמות. בקריאה לפונקציה, פרמטרים חסרים ייחשבו כ־nil ופרמטרים עודפים יושלכו. בלואה, פונקציות יכולות להחזיר ריבוי של ערכים. כמו כן, לפונקציות אין אכיפה של טיפוסיות לפרמטרים או לערכים שהיא מחזירה; על המתכנת לדאוג לכך באמצעות בדיקות ידניות. במקרים מתאימים, לואה מבצעת אופטימיזציית רקורסיית זנב.
עיצוב > קלט ופלט

מהיותה שפה ניידת עם תלות מינימלית במערכות הפעלה או חומרה, ללואה ישנן יכולות מעטות בניהול קבצים וקלט נתונים. השפה מציעה אך ורק מה שתקן ISO C מציע עבור צורכי קלט ופלט (IO), וניהול קבצים מתקדם יותר בדרך כלל כרוך בשימוש בספריות צד שלישי או בשיבוץ השפה עם שפה אחרת. בין היכולות של לואה הן לכתוב ולקרוא בקבצים, ליצור ולמחוק קבצים, לגשת למשתני ENV, להריץ תוכנה, ולבדוק זמן ותאריך.
עיצוב > ניפוי שגיאות

לואה מצוידת בספרייה לניפוי שגיאות וטיפול בחריגות בזמן ריצה. הפונקציות assert ו־error משמשות לזריקת שגיאות. טיפול בחריגות בשפה נעשה באמצעות הפונקציה pcall, הפונקציה מאפשרת להריץ קוד אקראי, לתפוס שגיאות בתוכו, ולמנוע קריסה של התוכנית באירוע שגיאה. הספרייה debug נותנת למתכנת כלים כדי לבדוק את סדר קריאת השגרות ומצב התוכנית בכל נקודת זמן בקוד לבירור הנסיבות של שגיאה כלשהי.
עיצוב > מודולים

לואה היא שפה מודולרית. מודול ניטען באמצעות הפונקציה require אך ורק פעם אחת בזמן ריצה של תוכנית. ניתן לשנות את האופן בו לואה מחפשת או טוענת מודולים באמצעות הספרייה package. כמו בשפות דינמיות אחרות, לואה מאפשרת לטעון ולפרש קוד חדש בזמן ריצה לא רק מתוך מודולים, אלא גם מתוך מחרוזת. קוד מקור בלואה תמיד עובר הידור למצב ביניים בזמן ריצה, ניתן להדר קובץ קוד מקור בלואה ולשמור אותו באמצעות הפקודה luac במסוף. כל יחידת קוד שעוברת פירוש, כגון קובץ קוד מקור או פקודה תקנית במסוף, נקראת חתיכה.
תחביר

מבחינה תחבירית, לואה שואבת השראה משפת התכנות מודולה־2. בניגוד למודולה־2, לואה מבדילה בין אותיות גדולות ואותיות קטנות. הסימן נקודה ופסיק (;) מפריד בין פקודות, אך אין חובה להשתמש בו, אפילו בין שתי פקודות צמודות.
תחביר > אסימוני השפה

| סיווג | סיווג | סיווג | הגדרה | דוגמה |
| --- | --- | --- | --- | --- |
| מזהה | שם משתנה | שם משתנה | רצף תווי אותיות אלפבית לטיניות, ספרות עשרוניות, והתו _, כשהתו הראשון מוכרח להיות אות | x |
| ערך | מספר שלם | עשרוני | רצף ספרות עשרוניות | 42 |
| ערך | מספר שלם | הקסדצימלי | רצף תווים שנפתח ב־0X וממשיך בספרות עשרוניות או באותיות מ־A עד F | 0XFFFFFF |
| ערך | מספר ממשי | שבר עשרוני | רצף ספרות עשרוניות עם נקודה עשרונית | 1.25 |
| ערך | מספר ממשי | כתיב מדעי | רצף ספרות עשרוניות עם נקודה עשרונית, התו E, סימן שלילה - ורצף ספרות עשרוניות נוסף. | 4.0E-10 |
| ערך | מספר ממשי | הקסדצימלי | רצף תווים שנפתח במספר הקסדצימלי (ראו במספר שלם), נקודה ., ומספר הקסדצמלי עוקב | 0x0.1E |
| ערך | מחרוזת | שורה | רצף תווים מוקף בתו ", או בתו ' | "ABC" |
| ערך | מחרוזת | קטע | רצף תווים מוקף ב־[[ ו־]] | [[ABC]] |
| תחביר | פעולה | פעולה | כל הופעה של תו המייצג פעולה בשפה | + |
| תחביר | מילה שמורה | מילה שמורה | כל רצף תווים שיוצר מילה מרשימת המילים השמורות | local |
| תחביר | הערה | שורה | רצף תווים שנפתח בזוג מקפים -- ונגמר בסוף השורה | -- |
| תחביר | הערה | קטע | רצף תווים בנפתח בזוג מקפים -- ובזוג סוגריים מרובעים ונגמר בזוג סוגריים מרובעים כמו במחרוזת; ניתן לקונן קטעים באמצעות מספר מאוזן של התו = בין הסוגריים המרובעים בכל צד. | דוגמה בהמשך |
תחביר > מילים שמורות

בלואה 5.3 קיימות 22 מילים שמורות, ולא ניתן להשתמש בהן כמזהים. המילים השמורות שהופיעו עם הגרסה הציבורית הראשונה של לואה:
local – יצירת משתנה מקומי חדש
nil – ערך ריק
function – הגדרת פונקציה חדשה
do – פתיחת קטע פקודות בלולאה או תחום הכרזה
else – נסיגת תנאי
elseif – שרשור תנאי
end – סגירת קטע פקודות או תחום הכרזה
if – פתיחת תנאי
repeat – פתיחת לולאה מסוג repeat
return – להחזיר ערך ולצאת מפונקציה. בלואה הפקודה return חייבת להיות הפקודה האחרונה בתוך קטע של פקודות (קטע פקודות מסתיים במילה end).
until – תנאי למחזור בלולאה מסוג repeat
then – פתיחת קטע פקודות לביצוע בתנאי חיובי
while – פתיחת לולאה מסוג while והגדרת תנאי למחזור
and – קשר לוגי: וגם
not – קשר לוגי: לא
or – קשר לוגי: או
מילים שמורות שנוספו בגרסה 4.0:
break – עצירת לולאה ויציאה ממנה
for – פתיחת לולאה מסוג for
in – קריאה לפונקציית איטרציה בתחילת מחזור של לולאה מסוג for
מילים שמורות שנוספו בגרסה 5.0:
true – ערך אמת
false – ערך שקר
מילים שמורות שנוספו בגרסה 5.2:
goto – קפיצה לתווית בקוד. תוויות מסומנות באמצעות זוג נקודתיים לפני ואחרי התווית כך: ::label:: בנוסף, לא ניתן לקפוץ מחוץ לפונקציה, וכללי הנראות של משתנים חלים גם על תוויות.
תחביר > טבלאות

טבלה מוגדרת באמצעות זוג סוגריים מסולסלים {}.
local point = {}
ניתן להכניס פריטים חדשים לטבלה בשתי דרכים: בתוך הסוגריים המסולסלים בפקודה אחת, או מחוץ לסוגריים המסולסלים באמצעות פקודה נפרדת לכל פריט. שתי הדרכים הן שקולות, אך הדרך הראשונה היא מהירה יותר מהיבט ביצועי של המפרש.
local point = {x = 0, y = 0}
local point = {}
point.x = 0
point.y = 0
בנוסף, ניתן לגשת לפריט בטבלה בשתי דרכים: באמצעות נקודה ומזהה או באמצעות זוג סוגריים מרובעים וערך. מפתחות שהוגדרו עם מזהים הם בפועל מיוצגים באמצעות ערך של מחרוזת, וכן ההפך. בניגוד למזהים (שהם תמיד מיוצגים באמצעות מחרוזת), סוגריים מרובעים יודעים לקבל ערך מכל טיפוס נתונים ולא רק מחרוזות.
local point = {}
point["x"] = 0
point["y"] = 0
print(point.x, point.y) -- 0    0
ניתן לבטא מבני נתונים מורכבים יותר באמצעות קינון טבלאות.
local style = {
    font = {
        size = 12,
        family = "sans-serif",
        bold = false,
        italic = false
    },
    foreground_color = {R = 0, G = 0, B = 0},
    background_color = {R = 255, G = 255, B = 255}
}
print(style.font.family) -- sans-serif
ניתן גם ליצור מבנה שקול אך ללא כל מזהים. במקרה הזה, ניתן לגשת לנתונים בטבלה באמצעות תחביר המערך.
local style = {
    {12, "sans-serif", false, false},
    {0, 0, 0},
    {255, 255, 255}
}
print(style[1][2]) -- sans-serif
הסרת פריט מהטבלה תתבצע באמצעות הקצאת הערך nil לפריט.
local point = {x = 0, y = 0, z = 0}
point.z = nil
בפועל, גם ספריות הליבה של לואה מורכבות מטבלאות. לדוגמה, הפונקציה math.sin נמצאת בתוך הפריט sin בטבלה math שנמצאת בהיקף המשתנים הגלובלי כך:
print(math.sin(math.pi/2))                      -- 1
print(_G["math"]["sin"](_G["math"]["pi"]/2))    -- 1
לואה מאפשרת לסימן פסיק , אחד מיותר להופיע אחרי הפריט האחרון בהגדרת טבלה. מצורכי תאימות לאחור עם גרסאות קודמות של השפה, לואה מאפשרת גם שימוש בסימן נקודה ופסיק ; במקום פסיק , על מנת להפריד בין פריטים בטבלה.
תחביר > פונקציות > הגדרה

בלואה פונקציה מוגדרת באמצעות שם מזהה וזוג סוגריים עגולים (), כשהפרמטרים מוגדרים בתוך הסוגריים העגולים. קיימים שני תחבירים להגדרת פונקציה, שני התחבירים שקולים. לדוגמה, נגדיר את הפרבולה  f(x)=x^{2} על ידי הקצאת פונקציה אנונימית לתוך המשתנה f:
local f = function(x)
    return x^2
end
או על ידי הכרזת משתנה f מסוג פונקציה:
local function f(x)
    return x^2
end
תחביר > פונקציות > קריאה

ניתן להשמיט את הסוגריים העגולים בקריאה לפונקציה אך ורק אם יש פרמטר בודד שמגדיר טבלה חדשה (בתוך זוג סוגריים מסולסלים {}) או מחרוזת חדשה (בתוך זוג מירכאות ""). לדוגמה, הפונקציה require לטעינת מודולים יכולה לקבל פרמטר מסוג מחרוזת של שם מודול ללא זוג סוגריים עגולים:
local lfs = require "lfs" -- LuaFleSystem
תחביר > פונקציות > תכנות מונחה עצמים

בלואה קיים תחביר נוסף להגדרת וקריאת פונקציות באמצעות נקודתיים : שמאפשר חיקוי של תכנות מונחה עצמים. במקרים כאלה, הפרמטר הראשון יהיה אוטומטית הטבלה שמכילה את הפונקציה, והייצוג שלה בתוך הפונקציה יהיה באמצעות המשתנה המקומי self. לדוגמה:
local vector = {x = 1, y = 2, z = 3}
function vector:scale(scalar)
    self.x = self.x * scalar
    self.y = self.y * scalar
    self.z = self.z * scalar
end
function vector:print()
    print(self.x, self.y, self.z)
end
vector:print()      --  1       2       3
vector:scale(1.5)
vector:print()      --  1.5     3       4.5
תחביר > פונקציות > ריבוי פרמטרים

ניתן להגדיר פונקציה עם הסימן המיוחד ... שקולט מספר שרירותי של פרמטרים אנונימיים. ניתן להעביר את אותם ערכים הלאה באמצעות ... בגוף הפונקציה. לדגמה, פונקציית שתחשב סכום של מספר לא מוגדר של פרמטרים תכתב כך:
local function sum(...)
    local result = 0
    for _, value in ipairs{...} do
        result = result + value
    end
    return result
end
print(sum(1, 2, 3)) -- 6
תחביר > בקרת זרימה > תחום הכרזה

בלואה ניתן ליצור תחום הכרזה חדש עבור משתנים מקומיים באמצעות do כך:
do
    local print = nil
    -- print("Hello world!") --> Error
end
print("Hello world!") --> Hello world!