Riferimento rapido al linguaggio Verse

commento a riga singola: tutto ciò che viene visualizzato tra # e la fine della riga fa parte del commento sul codice.

commento di blocco in linea: tutto ciò che viene visualizzato tra <# e #> fa parte del commento sul codice. I commenti di blocco in linea possono trovarsi tra espressioni su una singola riga e non modificano le espressioni.

commento di blocco su più righe: tutto ciò che viene visualizzato tra <# e #> fa parte del commento sul codice. I commenti blocco su più righe possono estendersi su più righe.

commento di blocco annidato: tutto ciò che viene visualizzato tra <# e #> fa parte del commento sul codice e può essere annidato. Può essere utile per aggiungere commenti ad alcune espressioni in una riga a scopo di test e debug, senza modificare un commento sul codice esistente.

commento rientrato: tutto ciò viene visualizzato sulle nuove righe dopo <#> ed è rientrato di quattro spazi fa parte del commento sul codice. La prima riga che non è rientrata di quattro spazi non fa parte del commento sul codice e termina il commento.

Creazione di una costante: il valore di una costante non può essere modificato mentre il programma è in esecuzione. Puoi creare una costante identificandone nome, tipo e valore.

Fai clic sull'immagine per ingrandirla.

Creazione di una variabile: il valore di una variabile può essere modificato mentre il programma è in esecuzione. Per creare una variabile devi aggiungere la parola chiave var prima del nome e devi identificarne il nome, il tipo e (facoltativo) il valore iniziale.

Fai clic sull'immagine per ingrandirla.

Modifica del valore di una variabile: è possibile modificare il valore di una variabile mentre il programma è in esecuzione utilizzando la parola chiave set =.

Fai clic sull'immagine per ingrandirla.

logic: logic in Verse rappresenta il tipo per i valori booleani, il che significa che logic può avere solo due valori possibili: true e false. Per ulteriori informazioni sul tipo logic, vedi Logic.

int: un int in Verse può contenere un numero positivo, un numero negativo o zero e non ha una componente frazionaria. I valori interi possono essere compresi tra i seguenti valori, inclusi:

• Min: -9,223,372,036,854,775,808

• Max: 9,223,372,036,854,775,807 Per saperne di più sul tipo int, vedi Int.

float: un float in Verse può contenere un numero positivo o negativo con un punto decimale, uno zero o il valore NaN (Not a Number). I valori a virgola mobile possono essere compresi tra i seguenti valori, inclusi:

• Min: -2^1023 * (1 + (1 - 2^(-52)))

• Max: -2^1023 * (1 + (1 - 2^(-52))) Per saperne di più sul tipo float, vedi Float.

string: una string in Verse può contenere lettere, numeri, punteggiatura, spazi ed emoji 🐈. Una stringa che non contiene caratteri "" è chiamata stringa vuota.

Puoi inserire il risultato di un'espressione in una stringa utilizzando {} all'interno di "". Questa operazione è chiamata interpolazione delle stringhe.

Per saperne di più sul tipo string, vedi String.

message: un message in Verse può contenere testo indipendente dalle impostazioni locali. Quando inizializzi una variabile message con un valore string, questa stringa rappresenta il testo e la lingua predefiniti per il messaggio. Lo specificatore localizes è necessario quando si definisce un nuovo message per produrre testo localizzabile.

Puoi trasformare il testo in una stringa visualizzabile in fase di runtime utilizzando la funzione Localize(), che formatta il testo in base alle impostazioni locali attuali.

Attualmente, l'unico testo che può essere restituito dalla funzione Localize() è il testo predefinito che hai fornito al momento della creazione del messaggio.

locale: questo tipo rappresenta il contesto in cui un valore di message deve essere localizzato. Ciò influisce sulla lingua del testo e sulla rappresentazione dei numeri che sono comuni nelle impostazioni locali.

Attualmente, il tipo locale non è completamente implementato, quindi la funzione Localize() restituisce solo il testo predefinito che hai fornito al momento della creazione del messaggio.

rational: il tipo rational è il risultato della divisione tra numeri interi e si può utilizzare solo come argomento delle seguenti funzioni:

• Floor(): arrotonda per difetto il valore razionale al numero intero più vicino.

• Ceil(): arrotonda per eccesso il valore razionale al numero intero più vicino. Per saperne di più sul tipo rational, vedi Rational.

void: il tipo void è utile nei seguenti scenari:

• Come tipo di restituzione di una funzione, indica che il risultato della funzione non è utile.

• Come tipo per le costanti o i parametri delle funzioni, indicando che il valore non è utile. Ad esempio, utilizza void per le costanti o i parametri delle funzioni quando esegui l'override di una definizione di funzione.

Per saperne di più sul tipo void, vedi Void.

any: il tipo any è il supertipo di tutti i tipi. Per saperne di più sul tipo any, vedi Any.

comparable: il tipo comparable ha il requisito che qualsiasi valore di questo tipo può essere confrontato per l'uguaglianza con qualsiasi altro valore di questo tipo. Il tipo comparable è il supertipo di tutti i tipi di cui è possibile il confronto di uguaglianza. Per saperne di più sul tipo comparable, vedi Comparable.

Creazione di un'opzione: puoi inizializzare un'opzione con quanto segue:

• Nessun valore: assegna false all'opzione per contrassegnarla come non impostata.

• Valore iniziale: utilizza la parola chiave option seguita da {} e un'espressione racchiusa tra {}. Se l'espressione non riesce, l'opzione non verrà impostata e avrà il valore di false.

Specifica il tipo aggiungendo ? prima del tipo di valore che si prevede sia memorizzato nell'opzione. Ad esempio ?int.

Accesso a un elemento di un'opzione: utilizza l'operatore query ? con l'opzione, come MaybeANumber?. L'accesso al valore memorizzato in un opzione è un espressione fallibile perché potrebbe non esserci un valore nell'opzione e quindi deve essere utilizzata in un contesto di fallimento.

Creazione di un intervallo: l'inizio dell'intervallo è il primo valore nell'espressione e la fine è il valore che segue .. nell'espressione. L'intervallo contiene tutti i valori interi compresi tra i valori iniziali e finali.

Iterare un intervallo: è possibile utilizzare l'espressione for per iterare la sequenza di numeri. Per saperne di più, vedi for.

Creazione di un array: utilizza la parola chiave array seguita da {}. Per specificare gli elementi iniziali dell'array, aggiungi le espressioni tra {}, separate da ,. Specifica il tipo aggiungendo [] prima del tipo di valore che prevedi di memorizzare nell'array, ad esempio []int.

Accesso a un elemento in un array: utilizza [] con l'indice dell'elemento a cui vuoi accedere, come ad esempio ExampleArray[0]. L'accesso al valore memorizzato in un array è un espressione fallibile perché potrebbe non esserci un elemento a quell'indice, quindi deve essere utilizzata in un contesto di fallimento.

Modifica di un elemento in un array: è possibile modificare il valore memorizzato in una variabile di array a livello di indice utilizzando la parola chiave set =.

Iterare un array: è possibile accedere a ogni elemento di un array, in ordine, dal primo all'ultimo, utilizzando l'espressione for. Con l'espressione for, puoi ottenere l'elemento con la sintassi (Item : ExampleArray), oppure l'elemento e il suo indice con la sintassi (Index -> Item : ExampleArray).

Ottenere il numero di elementi di un array: utilizza .Length sull'array e il risultato sarà il numero di elementi dell'array.

Concatenazione degli array: è possibile unire gli array utilizzando l'operatore +.

Creazione di una tupla: utilizza () e specifica due o più elementi, separati da ,. Specifica il tipo utilizzando la parola chiave tuple seguita da (), con il tipo di ogni elemento specificato esplicitamente tra (). Ad esempio, tuple(int, float, string).

Accesso a un elemento in una tupla: utilizza () con l'indice dell'elemento a cui vuoi accedere, come ad esempio ExampleTuple(0). L'accesso al valore memorizzato in una tupla non è un'espressione fallibile.

Espansione di tupla: quando utilizzi una tupla come argomento di una funzione, invece di specificare ogni singolo argomento, la funzione sarà chiamata con ogni elemento della tupla utilizzato come argomento nell'ordine in cui è specificato nella tupla.

Coercizione array di tupla: le tuple si possono passare ovunque sia previsto un array, purché i tipi degli elementi della tupla siano dello stesso tipo dell'array. Non si possono passare array dove è prevista una tupla.

Creazione di una mappa: utilizza la parola chiave map seguita da {}. Per specificare gli elementi iniziali nella mappa, aggiungi le coppie chiave-valore tra {}, separate da ,. Specifica il tipo aggiungendo [key-type], dove key-type è il tipo utilizzato per le chiavi prima del tipo di valore che si prevede sia memorizzato nella mappa. Ad esempio, [string]int.

Accesso a un elemento in una mappa: utilizza [] con la chiave dell'elemento a cui vuoi accedere, come ad esempio ExampleMap[Key].

Iterare una mappa: è possibile accedere a ogni elemento di una mappa, in ordine, dal primo inserito all'ultimo, utilizzando l'espressione for. Con l'espressione for, puoi ottenere l'elemento con la sintassi (Value : ExampleMap) oppure l'elemento e la sua chiave con la sintassi (Key -> Value: ExampleMap).

Ottenere il numero di coppie chiave-valore in una mappa: utilizza .Length sulla mappa e il risultato sarà il numero di elementi nella mappa.

Creazione di un enum: utilizza la parola chiave enum seguita da {}. Se desideri specificare gli elementi iniziali nell'enum, aggiungi gli enumeratori tra {}, separati da ,.

Accesso a un enumeratore: utilizza . sull'enum, seguito dall'enumeratore da utilizzare. Ad esempio direction.Up.

Creazione di una struct: utilizza la parola chiave struct seguita da un blocco di codice. Le definizioni nel blocco di codice della struct specificano i campi della struct.

*Creazione di un'istanza di una struct: è possibile costruire un'istanza di una struct da un archetipo. Un archetipo definisce i valori dei campi di una struct.

Accesso ai campi di una struct: puoi accedere ai campi di una struct per ottenerne il valore aggiungendo . tra l'istanza della struct e il nome del campo.

Creazione di una classe: le definizioni annidate all'interno di una classe ne definiscono i campi. Le funzioni definite come campi di una classe sono chiamate anche metodi.

Creazione di un'istanza di una classe: è possibile costruire un'istanza della classe utilizzando il nome della classe seguito da {} (l'archetipo). Un archetipo definisce i valori dei campi di una classe.

Accesso ai campi di una classe: è possibile accedere ai campi di una classe per ottenerne il valore aggiungendo . tra l'istanza della classe e il nome del campo.

Accesso ai metodi di una classe: è possibile accedere ai metodi di una classe per chiamarli aggiungendo . tra l'istanza della classe e il nome del metodo.

Self: è possibile utilizzare Self in un metodo di classe per fare riferimento all'istanza della classe su cui il metodo è stato chiamato. È possibile fare riferimento ad altri campi dell'istanza da cui è stato chiamato il metodo senza utilizzare Self, ma se si desidera fare riferimento all'istanza nel suo complesso, è necessario utilizzare Self.

Creazione di una sottoclasse: specifica una classe come sottoclasse di un'altra, aggiungendo l'altra classe tra () in class().

Override dei campi in una superclasse: è possibile modificare i valori di un campo definito nella superclasse per la sottoclasse soltanto aggiungendo lo specificatore <override> al nome del campo.

Metodi di esecuzione dell'override sulla superclasse: [INCLUDE:#overriding_methods_on_superclass_description]

Super: come per Self, è possibile utilizzare (super:) per accedere alle implementazioni di campi e metodi della superclasse. Per poter utilizzare (super:), il campo o il metodo deve essere implementato nella definizione della superclasse.

Definizione di un costruttore di una classe: è possibile aggiungere un costruttore di una classe aggiungendo lo specificatore <constructor> al nome della funzione. Invece di specificare un tipo restituito sulla funzione, questa viene assegnata al nome della classe, seguito da un'inizializzazione dei campi. Una classe può avere più di un costruttore.

Aggiunta di variabili ed esecuzione del codice nel costruttore: è possibile eseguire le espressioni all'interno di un costruttore con l'espressione block e introdurre nuove variabili con la parola chiave let.

Chiamata di altri costruttori in un costruttore: è possibile chiamare altri costruttori da un costruttore. Inoltre, puoi chiamare costruttori per la superclasse della classe da un costruttore della classe, purché tutti i campi siano inizializzati. Quando un costruttore chiama un altro costruttore ed entrambi i costruttori inizializzano i campi, per i campi vengono utilizzati soltanto i valori forniti al primo costruttore. L'ordine di valutazione di espressioni tra i due costruttori sarà nell'ordine in cui le espressioni sono scritte (per quanto riguarda gli effetti collaterali), ma vengono utilizzati soltanto i valori forniti al primo costruttore.

Creazione di un'interfaccia: è possibile definire l'interfaccia in modo simile a una classe, ma utilizzando la parola chiave interface. Nella definizione, puoi specificare i metodi associati all'interfaccia.

Estensione di un'interfaccia: un'interfaccia può estendere la definizione di un'altra interfaccia specificando quale estendere tra le() di interface().

Implementazione di un'interfaccia: è possibile implementare l'interfaccia con una classe, semplicemente specificando l'interfaccia tra le () di class(). La classe deve eseguire l'override e implementare ogni metodo definito nell'interfaccia.

Implementazione di più interfacce: una classe può implementare più interfacce. Le varie interfacce sono separate da , tra le () di class().

Ereditare da un'interfaccia e da un'altra classe: una classe può implementare un'interfaccia ed essere una sottoclasse di un'altra classe. L'interfaccia e la superclasse sono separate da , tra le () di class().

Aliasing tipo: è possibile assegnare a un tipo un nome diverso nel codice e farvi riferimento con quel nuovo nome. La sintassi è simile a quella dell'inizializzazione delle costanti. Puoi anche assegnare un alias tipo a un tipo di funzione. Per ulteriori informazioni, vedi Aliasing tipo.

Tipo parametrico come argomento di tipo esplicito: Verse supporta i tipi parametrici (tipi previsti come argomenti). Ciò funziona solo con le classi e le funzioni. Per ulteriori informazioni, vedi Tipi parametrici.

Tipo parametrico come argomento implicito di tipo alle funzioni: il motivo per utilizzare i tipi parametrici impliciti con le funzioni è che consente di scrivere una volta sola il codice invariante per un particolare tipo, anziché doverlo scrivere per ogni tipo con cui la funzione viene utilizzata. Per ulteriori informazioni, vedi Tipi parametrici.

Macro di tipo: Verse ha un costrutto speciale che può essere utilizzato per ottenere il tipo di un'espressione arbitraria. Si può utilizzare ovunque sia possibile utilizzare un tipo. Per ulteriori informazioni, vedi Macro di tipo.

sottotipo: è possibile utilizzare subtype per dare un vincolo a una variabile tipo. Richiede che il tipo che può sostituire una variabile di tipo che è un sottotipo dell'argomento da sottotipizzare. Tutto ciò che può sostituire t in una chiamata a Filter deve essere un sottotipo di comparable.

Query ?

L'operatore ? verifica se un valore logic è true. Per maggiori dettagli vediQuery.

operatore postfisso

9

TargetLocked?

Not not

L'operatore not nega l'esito positivo o negativo di un'espressione. Per maggiori dettagli, vedi Not.

Prefisso

8

not TargetLocked?

Positivo +

È possibile utilizzare l'operatore + come prefisso a un numero per aiutare l'allineamento visivo del codice, ma ciò non modificherà il valore del numero. Per maggiori dettagli, vedi Matematica.

Prefisso

8

+1

Negativo -

È possibile utilizzare l'operatore - come prefisso a un numero per negarne il valore. Per maggiori dettagli, vedi Matematica.

Prefisso

8

-1

Moltiplicazione *

L'operatore * moltiplica due valori numerici. Per maggiori dettagli, vedi Matematica.

operatore infisso

7

2 * 3

Divisione /

L'operatore / divide il primo operando numerico per il secondo. La divisione degli interi è fallibile. Per maggiori dettagli, vedi Matematica.

operatore infisso

7

6 / 3

Somma +

L'operatore + somma due valori numerici. Quando viene utilizzato con stringhe e array, i due valori vengono concatenati. Per maggiori dettagli, vedi Matematica.

operatore infisso

6

2 + 3

Sottrazione -

L'operatore - sottrae il secondo operando numerico dal primo. Per maggiori dettagli, vedi Matematica.

operatore infisso

6

2 - 3

Assegnazione di addizione +=

Con questo operatore è possibile combinare l'addizione e l'assegnazione nella stessa operazione per aggiornare il valore di una variabile. Per maggiori dettagli, vedi Matematica.

operatore infisso

5

set VariableName += 1

Assegnazione di sottrazione -=

Con questo operatore è possibile combinare la sottrazione e l'assegnazione nella stessa operazione per aggiornare il valore di una variabile. Per maggiori dettagli, vedi Matematica.

operatore infisso

5

set VariableName -= 1

Assegnazione di moltiplicazione *=

Con questo operatore è possibile combinare la moltiplicazione e l'assegnazione nella stessa operazione per aggiornare il valore di una variabile. Per maggiori dettagli, vedi Matematica.

operatore infisso

5

set VariableName *= 1

Assegnazione di divisione /=

Con questo operatore è possibile combinare la divisione e l'assegnazione nella stessa operazione per aggiornare il valore di una variabile, a meno che la variabile non sia un numero intero. Per maggiori dettagli, vedi Matematica.

operatore infisso

5

set VariableName /= 2

Uguale a =

L'operatore = riesce quando l'operando di sinistra è uguale all'operando di destra. In caso contrario non riesce. Per maggiori dettagli, vedi Confronto.

operatore infisso

4

MyScore = HighScore

Diverso da <>

L'operatore <> riesce quando l'operando di sinistra è diverso dall'operando di destra. In caso contrario non riesce. Per maggiori dettagli, vedi Confronto.

operatore infisso

4

MyScore <> HighScore

Minore di <

L'operatore < riesce quando l'operando di sinistra è minore dell'operando di destra. In caso contrario non riesce. Per maggiori dettagli, vedi Confronto.

operatore infisso

4

MyScore < HighScore

Minore o uguale a <=

L'operatore <= riesce quando l'operando di sinistra è minore o uguale all'operando di destra. In caso contrario non riesce. Per maggiori dettagli, vedi Confronto.

operatore infisso

4

Score <= HighScore

Maggiore di >

L'operatore > riesce quando l'operando di sinistra è maggiore dell'operando di destra. In caso contrario non riesce. Per maggiori dettagli, vedi Confronto.

operatore infisso

4

MyScore > HighScore

Maggiore o uguale a >=

L'operatore >= riesce quando l'operando di sinistra è maggiore o uguale all'operando di destra. In caso contrario non riesce. Per maggiori dettagli, vedi Confronto.

operatore infisso

4

MyScore >= HighScore

E and

L'operatore and riesce solo quando tutti gli operandi hanno esito positivo. Per maggiori dettagli, vedi Operatori And/Or.

operatore infisso

3

Value1 and Value2

O o

L'operatore or riesce se almeno uno degli operandi ha esito positivo. Per maggiori dettagli, vedi Operatori And/Or.

operatore infisso

2

Value1 or Value2

Inizializzazione variabile e costante : =

Con questo operatore è possibile memorizzare i valori in una costante o in una variabile. Per maggiori dettagli, vedi Costante e variabili.

operatore infisso

1

ConstantName := 5

Assegnazione variabile set =

Con questo operatore è possibile aggiornare i valori memorizzati in una variabile. Per maggiori dettagli, vedi Costante e variabili.

operatore infisso

1

set VariableName = 5

Distanziato: inizia con : e ogni nuova riga del blocco di codice è rientrata uniformemente di quattro spazi.

Multiriga tra parentesi graffe: racchiuso da {}, con ogni espressione su una nuova riga.

Riga singola tra parentesi graffe: racchiuso da {}, con ogni espressione separata da ;.

Ultima espressione restituita con un valore: per impostazione predefinita, l'ultima espressione nel blocco di codice della funzione è il risultato della funzione e il suo valore deve corrispondere al tipo restituito della funzione.

Ritorno esplicito con un valore: è possibile anche definire esplicitamente cosa restituirà la funzione utilizzando return seguito da un valore, come return HighScore. L'espressione return esce immediatamente dalla funzione, anche se ci sono altre espressioni dopo di essa nel blocco di codice.

Chiamata di funzione non fallibile: una chiamata di funzione che non può essere fallibile ha la forma FunctionName().

Chiamata di funzione fallibile: una chiamata di funzione fallibile ha la forma FunctionName[]. Una funzione è contrassegnata come fallibile quando la sua definizione ha lo specificatore decides.

Chiamate di funzione: solo quando la chiamata di funzione ha il formato FunctionName[] e la definizione di funzione ha lo specificatore decides.

Confronto: un'espressione di confronto confronta due elementi utilizzando uno degli operatori di confronto. Per maggiori informazioni, vedi operatori.

Divisione di interi: per gli interi, l'operatore di divisione / è fallibile e il risultato è di tipo rational, se riesce. Per maggiori informazioni, vedi operatori.

Decisione: un'espressione decisionale utilizza gli operatori not, and o or per controllare il flusso decisionale con esito positivo e negativo. Per maggiori informazioni, vedi operatori.

Query: un'espressione di query utilizza l'operatore ? e controlla se un valore logic o option è true. In caso contrario, l'espressione non riesce. Per maggiori informazioni, vedi operatori.

Accesso a un elemento in un array: l'accesso al valore memorizzato in un array è un espressione fallibile perché potrebbe non esserci un elemento a quell'indice, quindi deve essere utilizzata in un contesto di fallimento. Per maggiori dettagli, vedi array.

La condizione nelle espressioni if.

Le espressioni di iterazione e le espressioni di filtro nelle espressioni for.

Il corpo di una funzione che include lo specificatore di effetto decides.

L'operando per l'operatore not.

L'operando di sinistra per l'operatore or.

Inizializza una variabile con il tipo option.

no_rollback: è l'effetto predefinito quando non viene specificato un effetto esclusivo. L'effetto no_rollback indica che qualsiasi azione eseguita dalla funzione non può essere annullata e quindi la funzione non può essere utilizzata in un contesto di fallimento. Questo effetto non può essere specificato manualmente.

Effetti esclusivi

transacts: questo effetto indica che può essere eseguito il rollback di qualsiasi azione eseguita dalla funzione. L'effetto transacts è richiesto ogni volta che viene scritta una variabile modificabile (var). Se l'effetto transacts è stato aggiunto a una funzione di cui non può essere eseguito il rollback, riceverai una notifica quando compilerai il tuo codice. Tieni presente che questo controllo non viene effettuato per le funzioni con lo specificatore native.

varies: questo effetto indica che lo stesso input della funzione potrebbe non generare sempre lo stesso output. L'effetto varies indica anche che non c'è alcuna garanzia che il comportamento della funzione rimanga invariato con le nuove versioni del pacchetto che la contiene.

computes: questo effetto richiede che la funzione non abbia effetti collaterali e non è garantito che venga completata. Esiste un requisito non controllato che la funzione, se fornita con gli stessi argomenti, generi lo stesso risultato. Qualsiasi funzione che non disponga dello specificatore native e che altrimenti avrebbe l'effetto converges è un buon esempio di utilizzo dell'effetto computes.

converges: questo effetto garantisce non solo che non ci siano effetti collaterali dall'esecuzione della funzione correlata, ma anche che la funzione si completi definitivamente (non sia ricorsiva all'infinito). Questo effetto può essere visualizzato solo nelle funzioni che hanno lo specificatore native, ma ciò non viene controllato dal compilatore. Il codice utilizzato per fornire valori predefiniti di classi o valori per variabili globali deve avere questo effetto. Le funzioni sin(), cos() e tan() sono esempi di funzioni che hanno l'effetto converges.

Effetti additivi

decides: indica che la funzione può non riuscire e che la chiamata a questa funzione è un'espressione fallibile. Le definizioni di funzioni con l'effetto decides devono avere anche l'effetto transacts, il che significa che è possibile eseguire il rollback delle azioni eseguite da questa funzione (come se non fossero mai state effettuate), se si verifica un errore in qualche punto della funzione.

suspends: indica che la funzione è asincrona. Crea un contesto asincrono per il corpo della funzione.

abstract: quando una classe o un metodo di classe ha lo specificatore abstract, non è possibile creare un'istanza della classe. Le classi astratte sono destinate a essere utilizzate come superclassi con implementazione parziale o come interfaccia comune. È utile quando non ha senso avere istanze di una superclasse, ma non si vogliono duplicare proprietà e comportamenti di classi simili.

concrete: quando una classe ha lo specificatore concrete, deve essere possibile costruirla con un archetipo vuoto, il che significa che ogni campo della classe deve avere un valore predefinito. Ogni sottoclasse di una classe concreta è implicitamente concreta. Una classe concreta può ereditare direttamente da una classe astratta, solo se entrambe le classi sono definite nello stesso modulo.

unique: lo specificatore unique può essere applicato a una classe per renderla univoca. Per costruire un'istanza di una classe univoca, Verse alloca un'identità univoca per l'istanza risultante. Ciò consente di verificare l'uguaglianza tra istanze di classi univoche confrontando le loro identità con gli operatori =, < e >, il che le rende sottotipi del tipo confrontable. Le classi prive dello specificatore univoco non hanno tale identità e quindi si possono confrontare solo per l'uguaglianza in base ai valori dei loro campi. Ciò significa che le classi univoche si possono confrontare con gli operatori = e <> e sono sottotipi del tipo confrontabile.

native_callable: indica che un metodo di istanza è nativo (implementato in C++) e può essere richiamato da altro codice C++. Puoi vedere questo specificatore utilizzato su un metodo di istanza. Questo specificatore non si propaga alle sottoclassi e quindi non è necessario aggiungerlo a una definizione, quando esegui l'override di un metodo che include lo specificatore stesso.

Risultato: ultima espressione nel blocco di codice block. In questo esempio, il risultato dell'espressione block è il risultato di expression2.

Risultato: ultima espressione nel blocco di codice if. In questo esempio, il risultato dell'espressione if è il risultato di expression1.

Risultato: ultima espressione nel blocco di codice if. In questo esempio, il risultato dell'espressione if è il risultato di expression1.

Risultato: il risultato di un'espressione loop è void, il che significa che non genera un risultato utile.

Risultato: il risultato di un'espressione loop è void, il che significa che non genera un risultato utile.

Risultato: il risultato di un'espressione loop è void, il che significa che non genera un risultato utile.

Risultato: il risultato di un'espressione loop è void, il che significa che non genera un risultato utile.

Risultato: il risultato di un'espressione for è un array contenente il risultato di ogni blocco di codice dell'iterazione.

Risultato: il risultato di un'espressione for è un array contenente il risultato di ogni blocco di codice dell'iterazione.

Risultato: il risultato di un'espressione for è un array contenente il risultato di ogni blocco di codice dell'iterazione.

Risultato: il risultato di un'espressione for che ha un'espressione for annidata è un array contenente l'array dei risultati di ogni iterazione del blocco di codice del loop interno.

Risultato: l'espressione defer non ha alcun risultato.

Risultato: l'espressione defer non ha alcun risultato.

Risultato: l'espressione defer non ha alcun risultato.

Risultato: l'espressione defer non ha alcun risultato.

Risultato: l'espressione defer non ha alcun risultato.

Risultato: l'espressione defer non ha alcun risultato.

Esegue contemporaneamente tutte le espressioni nel suo blocco di codice e attende che finiscano tutte prima di eseguire l'espressione successiva dopo la sync.

Il corpo dell'espressione branch viene avviato non appena viene incontrato. Il corpo dell'espressione branch continua a essere valutato fino al completamento del blocco di codice o del contesto asincrono che lo racchiude, a seconda di quale dei due eventi si verifichi per primo, a quel punto l'attività del blocco di codice branch viene annullata.

Risultato: il risultato di un'espressione sync è una tupla di risultati di ogni espressione nell'ordine in cui sono state specificate le espressioni di primo livello. I tipi di risultato delle espressioni possono essere di qualsiasi tipo e ogni elemento della tupla avrà il tipo della sua espressione corrispondente.

Risultato: un'espressione branch non ha risultati, quindi il suo tipo di risultato è void.

Simile a sync, ma cancella tutto tranne la sottoespressione vincente. Se altre espressioni si completano nello stesso tempo di simulazione dell'espressione precedente, la prima espressione (precedente) "vince" e rompe qualsiasi parità. Eventuali attività di espressione perdenti vengono annullate.

Simile a race, ma le espressioni che vengono completate dopo il termine della prima espressione continuano a essere eseguite. Se alcune espressioni vengono effettivamente completate durante lo stesso aggiornamento della simulazione, l'espressione che viene completata per prima interrompe la parità. Le espressioni incomplete continuano a essere valutate fino al loro completamento o fino al completamento del contesto asincrono che le racchiude, a questo punto, le espressioni perdenti rimanenti vengono annullate, a seconda di quale situazione si verifichi per prima.

Risultato: il risultato di un'espressione race è il risultato della prima espressione completata. Il tipo di risultato è il tipo compatibile più comune di tutte le espressioni del blocco di codice.

Risultato: il risultato di un'espressione rush è il risultato della prima espressione completata. Il tipo di risultato è il tipo compatibile più comune di tutte le espressioni del blocco di codice.

Il corpo di spawn crea un contesto asincrono come il corpo di una funzione asincrona. Tuttavia, è consentita solo una singola chiamata di funzione asincrona all'interno del corpo di spawn. La funzione asincrona di spawn viene avviata non appena viene incontrata e valuta il più possibile fino a quando non incontra qualcosa che la sospende o la blocca. La funzione asincrona generata continua a valutare fino al completamento, senza ulteriori connessioni alla posizione in cui è stata generata.

Risultato: spawn ha un risultato attività (task(type)).

utilizzo: per utilizzare il contenuto di un modulo Verse, devi specificare il modulo con il relativo percorso.

modulo: oltre ai moduli introdotti dalle cartelle in un progetto, i moduli si possono introdurre all'interno di un file .verse utilizzando la parola chiave module.