Condividi tramite

Sintassi dettagliata

  • Articolo

Esistono due forme di sintassi disponibili per molti costrutti in F#: sintassi dettagliata e sintassi leggera. La sintassi dettagliata non è così comunemente usata, ma ha il vantaggio di essere meno sensibile al rientro. La sintassi leggera è più breve e usa il rientro per segnalare l'inizio e la fine dei costrutti, anziché parole chiave aggiuntive come begin, endin, e così via. La sintassi predefinita è la sintassi leggera. In questo argomento viene descritta la sintassi per i costrutti F# quando la sintassi leggera non è abilitata. La sintassi dettagliata è sempre abilitata, quindi anche se si abilita la sintassi leggera, è comunque possibile usare la sintassi dettagliata per alcuni costrutti.

Tabella dei costrutti

La tabella seguente illustra la sintassi leggera e dettagliata per i costrutti di linguaggio F# nei contesti in cui esiste una differenza tra le due forme. In questa tabella le parentesi angolari (<>) racchiudono gli elementi della sintassi forniti dall'utente. Per informazioni più dettagliate sulla sintassi usata all'interno di questi costrutti, vedere la documentazione relativa a ogni costrutto di linguaggio.

Costrutto di linguaggio La sintassi leggera Sintassi dettagliata
espressioni composte 
<expression1>
<expression2>

<expression1>; <expression2>

associazioni annidate let

 
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
'per... do' 
for counter = start to finish do
    ...

for counter = start to finish do
    ...
done
'while... do' 
while <condition> do
    ...

while <condition> do
    ...
done
'per... in' 
for var in start .. finish do
    ...

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

do
    ...
in
Registrazione 
type <record-name> =
    {
        <field-declarations>
    }
    <value-or-member-definitions>

type <record-name> =
    {
        <field-declarations>
    }
    with
        <value-or-member-definitions>
    end
Classe 
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 dell'oggetto 
{ new <type-name>
    with
        <value-or-member-definitions>
        <interface-implementations>
}

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

interface <interface-name>
    with
        <value-or-member-definitions>
    end
estensione del 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

Vedi anche