Freigeben über

Ausführliche Syntax (F#)

  • Artikel

In F# sind für viele Konstrukte zwei Formen von Syntax verfügbar: ausführliche Syntax und einfache Syntax. Die ausführliche Syntax wird weniger häufig verwendet, sie bietet jedoch den Vorteil, dass Einzüge von geringerer Bedeutung sind. Die einfache Syntax ist kürzer und signalisiert Anfang und Ende von Konstrukten mithilfe von Einzügen statt mit zusätzlichen Schlüsselwörtern wie begin, end, in usw. Die Standardsyntax ist die einfache Syntax. In diesem Thema wird die Syntax für F#-Konstrukte beschrieben, wenn einfache Syntax nicht aktiviert ist. Ausführliche Syntax ist immer aktiviert. Deshalb können Sie auch bei aktivierter einfacher Syntax dennoch für einige Konstrukte ausführliche Syntax verwenden. Sie können einfache Syntax mit der #light "off"-Direktive deaktivieren.

Tabelle von Konstrukten

In der folgenden Tabelle werden die einfache und die ausführliche Syntax für F#-Sprachkonstrukte in Kontexten dargestellt, in denen sich die beiden Formen unterscheiden. In der Tabelle sind vom Benutzer angegebene Syntaxelemente in spitze Klammern (<>) eingeschlossen. Ausführlichere Informationen zu der Syntax in diesen Konstrukten finden Sie in der Dokumentation für die einzelnen Sprachkonstrukte.

Sprachkonstrukt

Einfache Syntax

Ausführliche Syntax

Zusammengesetzte Ausdrücke

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

Geschachtelte let-Bindungen

 
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

Codeblock

 
    <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

Datensatz

 
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

Struktur

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

Unterscheidungs-Union

 
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

Objektausdruck

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

Schnittstellenimplementierung

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

Typerweiterung

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

Modul

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

Siehe auch

Konzepte

Richtlinien für das Formatieren von Code (F#)

Weitere Ressourcen

F#-Sprachreferenz

Compilerdirektiven (F#)