Expressions

Expressions are the building blocks of values, member bodies, and statements. The DSL exposes one widget per F# expression form — this page groups them by family.

Contents

• Identifiers and Literals
• Collections and Tuples
• Application and Operators
• Lambdas
• Conditionals and Pattern Matching
• Loops
• Exception Handling
• Other Expressions

#r "../../src/Fabulous.AST/bin/Release/netstandard2.1/publish/Fantomas.Core.dll"
#r "../../src/Fabulous.AST/bin/Release/netstandard2.1/publish/Fabulous.AST.dll"
#r "../../src/Fabulous.AST/bin/Release/netstandard2.1/publish/Fantomas.FCS.dll"

open Fabulous.AST
open type Fabulous.AST.Ast

Identifiers and Literals

IdentExpr references an identifier and InterpolatedStringExpr builds an interpolated string (optionally verbatim, or with extra $ for nested braces):

Oak() {
    AnonymousModule() {
        IdentExpr("value")

        InterpolatedStringExpr(ConstantExpr("12"))

        InterpolatedStringExpr([ "a"; "b"; "c" ], isVerbatim = true)

        InterpolatedStringExpr([ ConstantExpr("12"); ConstantExpr("12") ], isVerbatim = true, dollars = 1)
    }
}
|> Gen.mkOak
|> Gen.run
|> printfn "%s"

// produces the following code:

value
$"{12}"
$"""{a}{b}{c}"""
$"""{12}{12}"""

Collections and Tuples

Lists, arrays, sequences, tuples (and their struct variants), and anonymous records:

Oak() {
    AnonymousModule() {
        ListExpr([ String("a"); String("b"); String("c") ])

        ArrayExpr([ String("a"); String("b"); String("c") ])

        SeqExpr([ String("a"); String("b") ])

        TupleExpr([ ConstantExpr(Int 1); ConstantExpr(Int 2); ConstantExpr(Int 3) ])

        StructTupleExpr([ ConstantExpr(Int 1); ConstantExpr(Int 2) ])

        AnonRecordExpr([ RecordFieldExpr("A", Int(1)); RecordFieldExpr("B", Int(2)) ])

        AnonStructRecordExpr([ RecordFieldExpr("A", Int(1)); RecordFieldExpr("B", Int(2)) ])
    }
}
|> Gen.mkOak
|> Gen.run
|> printfn "%s"

// produces the following code:

[ "a"; "b"; "c" ]
[| "a"; "b"; "c" |]

seq {
    "a"
    "b"
}

1, 2, 3
struct (1, 2)
{| A = 1; B = 2 |}
struct {| A = 1; B = 2 |}

Application and Operators

AppExpr applies a function, InfixAppExpr applies a binary operator, and ChainExpr builds a dotted call chain:

Oak() {
    AnonymousModule() {
        AppExpr("printfn", String("Hello, World!"))

        InfixAppExpr(Int(1), "+", Int(2))

        ChainExpr(
            [ ChainLinkExpr(String("string"))
              ChainLinkDot()
              ChainLinkExpr(OptVarExpr("Length")) ]
        )
    }
}
|> Gen.mkOak
|> Gen.run
|> printfn "%s"

// produces the following code:

printfn "Hello, World!"
1 + 2
"string".Length

Lambdas

LambdaExpr for a bare lambda, ParenLambdaExpr for a parenthesized one, and MatchLambdaExpr for the function form:

Oak() {
    AnonymousModule() {
        LambdaExpr(UnitPat(), Int(1))

        ParenLambdaExpr([ ConstantPat("a"); ConstantPat("b") ], ConstantExpr("a"))

        MatchLambdaExpr([ MatchClauseExpr("a", Int(3)) ])
    }
}
|> Gen.mkOak
|> Gen.run
|> printfn "%s"

// produces the following code:

fun () -> 1
(fun a b -> a)

function
| a -> 3

Conditionals and Pattern Matching

IfThenElseExpr, the multi-branch IfThenElifExpr, and MatchExpr with a list of MatchClauseExpr:

Oak() {
    AnonymousModule() {
        IfThenElseExpr(Bool(true), String("a"), String("b"))

        IfThenElifExpr(
            [ IfThenExpr(
                  InfixAppExpr(ConstantExpr(Constant "x"), "=", ConstantExpr(Int 1)),
                  ConstantExpr(String("one"))
              )
              ElIfThenExpr(
                  InfixAppExpr(ConstantExpr(Constant "x"), "=", ConstantExpr(Int 2)),
                  ConstantExpr(String("two"))
              ) ],
            ConstantExpr(String("other"))
        )

        MatchExpr(
            Int(1),
            [ MatchClauseExpr(Int(1), String("a"))
              MatchClauseExpr(WildPat(), String("b")) ]
        )
    }
}
|> Gen.mkOak
|> Gen.run
|> printfn "%s"

// produces the following code:

if true then "a" else "b"

if x = 1 then "one"
elif x = 2 then "two"
else "other"

match 1 with
| 1 -> "a"
| _ -> "b"

Loops

ForEachDoExpr, the counted ForToExpr / ForDownToExpr, and WhileExpr:

Oak() {
    AnonymousModule() {
        ForEachDoExpr("i", ListExpr([ Int(1); Int(2); Int(3) ]), AppExpr("printf", String("%i")))

        ForToExpr("i", ConstantExpr("1"), ConstantExpr("10"), ConstantExpr(ConstantUnit()))

        ForDownToExpr("i", ConstantExpr("10"), ConstantExpr("1"), ConstantExpr(ConstantUnit()))

        WhileExpr(ConstantExpr(Bool(true)), ConstantExpr(Int(0)))
    }
}
|> Gen.mkOak
|> Gen.run
|> printfn "%s"

// produces the following code:

for i in [ 1; 2; 3 ] do
    printf "%i"

for i = 1 to 10 do
    ()

for i = 10 downto 1 do
    ()

while true do
    0

Exception Handling

TryWithExpr (and the single-clause TryWithSingleClauseExpr) and TryFinallyExpr:

Oak() {
    AnonymousModule() {
        TryWithSingleClauseExpr(Int(12), MatchClauseExpr(WildPat(), FailWithExpr(String("Not implemented"))))

        TryFinallyExpr(Int(12), Int(12))
    }
}
|> Gen.mkOak
|> Gen.run
|> printfn "%s"

// produces the following code:

try
    12
with _ ->
    failwith "Not implemented"

try
    12
finally
    12

Other Expressions

LazyExpr, QuotedExpr, the object expression ObjExpr, and named computation expressions such as task { ... }:

Oak() {
    AnonymousModule() {
        LazyExpr(Int(12))

        QuotedExpr(InfixAppExpr(Int(1), "+", Int(2)))

        NamedComputationExpr(ConstantExpr(Constant "task"), String("a"))

        ObjExpr(LongIdent("System.Object"), ConstantExpr(ConstantUnit())) {
            Member("x.ToString()", ConstantExpr(String("F#")))
        }
    }
}
|> Gen.mkOak
|> Gen.run
|> printfn "%s"

// produces the following code: