3. Struttura lessicale

La struttura lessicale di MALDA definisce i mattoni di base del linguaggio: commenti, identificatori, keyword, letterali, operatori e delimitatori.

3.1 Commenti

MALDA supporta due tipi di commenti:

Commenti su una riga

I commenti su una riga iniziano con // e continuano fino a fine riga:

// This is a single-line comment
var x = 10; // Comments can also appear after code

Commenti su più righe

I commenti su più righe sono racchiusi tra /* e */:

/* This is a
   multi-line comment
   that spans multiple lines */

3.2 Identificatori

Gli identificatori sono i nomi usati per variabili, funzioni, classi e altre entità definite dall'utente.

Regole per gli identificatori

• Devono iniziare con una lettera (a-z, A-Z) o un underscore (_)
• Possono contenere lettere, cifre (0-9) e underscore
• Sono case-sensitive
• Non possono essere una keyword

Esempi

var x = 10;           // Valid
var myVar = 20;       // Valid
var _temp = 30;       // Valid
var counter1 = 40;    // Valid
var 2invalid = 50;   // Invalid: starts with digit
var my-var = 60;     // Invalid: contains hyphen

3.3 Keyword

Le keyword sono parole riservate che hanno un significato speciale in MALDA. Non possono essere usate come identificatori. L'elenco autorevole è in MaldaLang/Lexer.cs; lo stesso insieme compare in Appendice A: parole riservate.

Elenco completo delle keyword

if, else, while, for, foreach, function, return, var, const, print, input,
true, false, and, or, not, break, continue, try, catch, finally, throw,
match, case, default, defer,
class, new, this, super, extends, public, private, static, null, type, schema, api,
prompt, async, await,
actor, spawn, send, receive, self, on, then, timeout, message,
workflow, step, approval, wait, retry, backoff, delay, maxDelay, compensate, onReject,
component, property,
dict, graph, directed, undirected, in,
using, include, import, export

fn e def non sono keyword; il parser le rifiuta a favore di function. reply è una funzione built-in, non una keyword.

using ha due scopi non correlati: un alias di pacchetto top-level (using json = System.Text.Json;) e un blocco di risorsa con scope (using conn = openDb() { ... }). Vedi rispettivamente 1. Introduzione e 8. Strutture di controllo.

Categorie di keyword

• Flusso di controllo: if, else, while, for, foreach, break, continue, match, case, default
• Funzioni: function, return
• Prompt: prompt
• Moduli: include, using, import, export
• Tipi somma: type
• Schema: schema
• API chiuse: api
• Variabili: var, const
• Pulizia delle risorse: defer, using (forma risorsa)
• I/O: print / io.print, input / io.input (file, path e env sono nello stesso capitolo)
• Booleani: true, false
• Operatori logici: and (&&), or (||), not (!)
• Gestione delle eccezioni: try, catch, finally, throw
• Classi: class, new, this, super, extends
• Modificatori di accesso: public, private
• Static: static
• Null: null
• Actor: actor, message, spawn, send, receive, self, on, then, timeout
• Workflow: workflow, step, approval, wait, retry, backoff, delay, maxDelay, compensate, onReject
• Web UI: component, property
• Operazioni async: async, await
• Strutture dati: dict, graph, directed, undirected, in

3.4 Letterali

I letterali sono valori costanti scritti direttamente nel codice.

Letterali interi

I letterali interi sono sequenze di cifre, opzionalmente prefissate da un segno meno:

42
-10
0
12345

Letterali float

I letterali float contengono un punto decimale o usano la notazione scientifica:

3.14
-0.5
2.0
1e-5
1.5e10

Letterali stringa

I letterali stringa possono essere racchiusi tra virgolette doppie ("...") o virgolette singole ('...'). Le due forme sono equivalenti e supportano le sequenze di escape:

"Hello, World!"
'Hello, World!'
"Line 1\nLine 2"
'Line 1\nLine 2'
"Tab\tseparated"
"CRLF line\r\n"
"Quote: \"Hello\""
'Quote: \'Hello\''
"He said 'hello'"
'He said "hello"'
"Backslash: \\"

Puoi usare le virgolette singole quando la stringa contiene virgolette doppie, o le virgolette doppie quando la stringa contiene virgolette singole, per evitare l'escaping:

var msg1 = "It's a test";        // No escaping needed
var msg2 = 'He said "hello"';    // No escaping needed
var msg3 = 'It\'s a test';       // Escaping needed
var msg4 = "He said \"hello\"";  // Escaping needed

Sequenze di escape

Nota: sia \" sia \' funzionano in entrambi i tipi di stringa, quindi puoi includere entrambi i tipi di virgolette in qualsiasi stringa. Le sequenze di escape sconosciute (per esempio \x) sono un errore del lexer — non vengono convertite in silenzio nella lettera nuda.

Stringhe multilinea (triple quote)

I letterali stringa multilinea usano tre virgolette doppie (""") come delimitatore di apertura e chiusura. Possono estendersi su più righe e conservano i newline. Dentro una stringa tra triple quote, le virgolette singole e doppie non vanno escaped, il che le rende comode per testi lunghi, prompt o contenuti con molte virgolette.

Stringa multilinea semplice — """...""":

var text = """
First line.
Second line with "quotes" and 'apostrophes'.
No escaping needed.
""";

La """ di chiusura deve comparire da sola (eventualmente dopo contenuto sulla stessa riga). Tutto ciò che sta tra la """ di apertura e quella di chiusura è incluso letteralmente; l'unica sequenza speciale è la """ di chiusura stessa.

Stringa multilinea interpolata — $"""...""":

Usa $""" per avviare una stringa multilinea interpolata. Si comporta come una stringa tra triple quote ma consente espressioni incorporate con {expression}. Sono supportate le sequenze di escape (es. \n, \t, \", \\).

var name = "Alice";
var greeting = $"""
Hello, {name}.
Welcome to line 2.
""";

Riepilogo:

• """ — stringa multilinea, senza escaping di virgolette o backslash
• $""" — stringa multilinea interpolata con {expr} e sequenze di escape

Letterali booleani

I letterali booleani sono le keyword true e false:

true
false

3.5 Operatori

Gli operatori sono simboli o keyword che eseguono operazioni sugli operandi.

Operatori aritmetici

Operatori di confronto

Nota: gli operatori relazionali (<, >, <=, >=) funzionano sia con i numeri sia con le stringhe. Per le stringhe i confronti sono lessicografici (ordine alfabetico). Entrambi gli operandi devono essere dello stesso tipo (entrambi numeri o entrambe stringhe).

Operatori logici

Operatori di assegnamento

L'operatore = assegna un valore a una variabile. Le forme composte combinano un'operazione aritmetica con l'assegnamento:

var x = 10;
x = 20;

x += 5;    // equivalent to x = x + 5
x -= 3;    // x = x - 3
x *= 2;    // x = x * 2
x /= 4;    // x = x / 4

Assegnare a un nome dichiarato con const è un errore a runtime. Vedi 5. Variabili.

Incremento e decremento

++ e -- modificano di uno una variabile numerica, in posizione prefissa o postfissa:

var i = 0;
i++;      // postfix: yields 0, then i becomes 1
++i;      // prefix: i becomes 2, yields 2
i--;
--i;

Operatore freccia lambda

L'operatore => si usa nelle espressioni lambda (funzioni anonime):

var add = (a, b) => a + b;
var square = x => x * x;
var process = (x) => { return x * 2; };

Vedi 9.6 Espressioni lambda per i dettagli.

Lo stesso token indica anche il tipo di ritorno informativo di una funzione, dove -> e => sono intercambiabili: function parse(text) -> Result { ... }.

Pipe forward

L'operatore |> passa il valore alla sua sinistra come primo argomento della chiamata alla sua destra:

var result = "  hello  " |> trim |> upper;

Vedi 7. Espressioni per precedenza e regole di concatenazione.

Marcatore di decoratore

@ introduce un decoratore su una dichiarazione, per esempio @Tool, @PAGE o @Route:

@Tool("Adds two numbers")
function add(a, b) {
    return a + b;
}

Vedi 9. Funzioni per le forme dei decoratori.

Concatenazione di stringhe

L'operatore + concatena le stringhe quando entrambi gli operandi sono stringhe:

"Hello, " + "World!"  // "Hello, World!"

Ripetizione di stringhe

L'operatore * ripete le stringhe quando un operando è una stringa e l'altro è un numero:

"*" * 20        // "********************"
5 * "-"         // "-----"
"abc" * 3       // "abcabcabc"

Sia string * number sia number * string funzionano allo stesso modo. Il valore numerico viene convertito a intero. Se il conteggio è 0 o negativo, viene restituita una stringa vuota.

Accesso ai membri

L'operatore . (punto) accede ai membri degli oggetti:

object.field
object.method()

Accesso null-conditional

?. e ?[ accedono a un membro o a un indice solo quando il ricevente non è null, altrimenti l'accesso valuta a null invece di sollevare un errore:

var user = null;
print(user?.name);      // null, no error
print(user?["name"]);   // null, no error

Vedi 7. Espressioni per il comportamento in catene più lunghe.

3.6 Delimitatori

I delimitatori sono segni di punteggiatura che strutturano il codice: