Partager via

Syntaxe détaillée

  • Article

Il existe deux formes de syntaxe disponibles pour de nombreuses constructions en F# : la syntaxe détaillée et la syntaxe simplifiée. La syntaxe détaillée n’est pas aussi couramment utilisée, mais elle présente l’avantage d’être moins sensible à la mise en retrait. La syntaxe simplifiée est plus courte et utilise la mise en retrait pour signaler le début et la fin des constructions, plutôt que des mots clés supplémentaires comme begin, end, in et ainsi de suite. La syntaxe par défaut est la syntaxe simplifiée. Cette rubrique décrit la syntaxe des constructions F# quand la syntaxe simplifiée n’est pas activée. La syntaxe détaillée est toujours activée. Par conséquent, même si vous activez la syntaxe simplifiée, vous pouvez toujours utiliser la syntaxe détaillée pour certaines constructions.

Tableau des constructions

Le tableau suivant montre la syntaxe simplifiée et la syntaxe détaillée de constructions du langage F# dans des contextes où il existe une différence entre les deux formes. Dans ce tableau, les éléments de syntaxe fournis par l’utilisateur sont entourés de crochets (<>). Pour plus d’informations sur la syntaxe utilisée dans ces constructions, consultez la documentation de chaque construction de langage.

Construction de langage Syntaxe simplifiée Syntaxe détaillée
expressions composées 
<expression1>
<expression2>

<expression1>; <expression2>

liaisons let imbriquées

 
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
bloc de code 
(
    <expression1>
    <expression2>
)

begin
    <expression1>;
    <expression2>;
end
`for...do` 
for counter = start to finish do
    ...

for counter = start to 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
structure 
[<StructAttribute>]
type <structure-name> =
    ...

type <structure-name> =
    struct
        ...
    end
union discriminée 
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
expression d’objet 
{ new <type-name>
    with
        <value-or-member-definitions>
        <interface-implementations>
}

{ new <type-name>
    with
        <value-or-member-definitions>
    end
    <interface-implementations>
}
implémentation de l'interface 
interface <interface-name>
    with
        <value-or-member-definitions>

interface <interface-name>
    with
        <value-or-member-definitions>
    end
extension de type 
type <type-name>
    with
        <value-or-member-definitions>

type <type-name>
    with
        <value-or-member-definitions>
    end
module 
module <module-name> =
    ...

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

Voir aussi