Partager via

Syntaxe détaillée (F#)

  • Article

Deux formes de syntaxe sont disponibles pour de nombreuses constructions dans le langage F# : la syntaxe détaillée et la syntaxe simplifiée.La syntaxe détaillée n'est pas autant utilisée, mais elles 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 de constructions au lieu de mots clés supplémentaires comme begin, end, in, etc.La syntaxe par défaut est la syntaxe simplifiée.Cette rubrique décrit la syntaxe des constructions F# lorsque la syntaxe simplifiée n'est pas activée.La syntaxe détaillée est toujours activée ; ainsi, même si vous activez la syntaxe simplifiée, vous pouvez toujours utiliser la syntaxe détaillée pour certaines constructions.Vous pouvez désactiver la syntaxe simplifiée à l'aide de la directive #light "off".

Tableau de constructions

Le tableau suivant indique la syntaxe simplifiée et détaillée pour les constructions en langage F# dans les contextes où les deux formes de syntaxe présentent des différences.Dans ce tableau, les crochets pointus (<>) encadrent les éléments de syntaxe fournis par l'utilisateur.Reportez-vous à la documentation pour chaque construction de langage pour plus d'informations sur la syntaxe utilisée dans ces constructions.

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 .. 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

enregistrement

 
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

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 d'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

Concepts

Indications pour la mise en forme du code (F#)

Autres ressources

Référence du langage F#

Directives de compilateur (F#)