Condividi tramite

Sintassi dettagliata (F#)

  • Articolo

Per numerosi costrutti nel linguaggio F# sono disponibili due forme di sintassi: la sintassi dettagliata e la sintassi leggera.La sintassi dettagliata non viene comunemente utilizzata, ma offre il vantaggio di essere meno sensibile al rientro.La sintassi leggera è più breve e prevede l'utilizzo del rientro per segnalare l'inizio e la fine dei costrutti, anziché utilizzare parole chiave aggiuntive come begin, end, in e così via.La sintassi predefinita è quella leggera.In questo argomento viene descritta la sintassi per i costrutti F# quando la sintassi leggera non è abilitata.La sintassi dettagliata è sempre abilitata, pertanto anche se si abilita la sintassi leggera, è comunque possibile utilizzare la sintassi dettagliata per alcuni costrutti.È possibile disabilitare la sintassi leggera utilizzando la direttiva #light "off".

Tabella dei costrutti

Nella tabella seguente vengono illustrate la sintassi leggera e la sintassi dettagliata per i costrutti di linguaggio F# nei contesti che prevedono una differenza tra le due forme.In questa tabella, le parentesi acute (<>) racchiudono gli elementi della sintassi forniti dall'utente.Per informazioni più dettagliate sulla sintassi utilizzata nei costrutti, fare riferimento alla documentazione relativa a ogni costrutto di linguaggio.

Costrutto di linguaggio

Sintassi leggera

Sintassi dettagliata

espressioni composte

 
<expression1>
<expression2>
 
<expression1>; <expression2>

associazioni let annidate

 
let f x =
    let a = 1
    let b = 2
    x + a + b
 
let f x =
    let a = 1 in
    let b = 2 in
    x + a + b

blocco di codice

 
    <expression1>
    <expression2>
    ...
 
    begin
        <expression1>;
        <expression2>;
    end

for...do

 
for counter = start to finish do
    ...
 
for counter = start .. finish do
    ...
    done

while...do

 
while <condition> do
    ...
 
while <condition> do
    ...
    done

for...in

 
for var in start .. finish do
    ...
 
for var in start .. finish do
    ...
    done

do

 
do ...
 
do ... in

record

 
type <record-name> =
    {
        <field-declarations>
    }
    <value-or-member-definitions>
 
type <record-name> =
    {
        <field-declarations>
    }
    with
        <value-or-member-definitions>
    end

class

 
type <class-name>(<params>) =
    ...
 
type <class-name>(<params>) =
    class
        ...
    end

struttura

 
[<StructAttribute>]
type <structure-name> =
    ...
 
type <structure-name> =
    struct
        ...
    end

unione discriminata

 
type <union-name> =
    | ...
    | ...
    ...
    <value-or-member definitions>
 
type <union-name> =
    | ...
    | ...
    ...
    with
         <value-or-member-definitions>

end

interface

 
type <interface-name> =
    ...
 
type <interface-name> =
    interface
        ...
    end

espressione di oggetto

 
{ new <type-name>
    with
        <value-or-member-definitions>
    <interface-implementations>
}
 
{ new <type-name>
    with
        <value-or-member-definitions>
    end
    <interface-implementations>
}

implementazione di interfaccia

 
interface <interface-name>
    with
        <value-or-member-definitions>
 
interface <interface-name>
    with
        <value-or-member-definitions>
    end

estensione di tipo

 
type <type-name>
    with
        <value-or-member-definitions>
 
type <type-name>
    with
        <value-or-member-definitions>
    end

modulo

 
module <module-name> =
    ...
 
module <module-name> =
    begin
        ...
    end

Vedere anche

Concetti

Linee guida per la formattazione del codice (F#)

Altre risorse

Riferimenti per il linguaggio F#

Direttive per il compilatore (F#)