Header menu logo Fabulous.AST

Conditionals

The if...then...else expression runs different branches of code and also evaluates to a different value depending on the Boolean expression given.

Constructors

Constructors

Description

IfThenExpr(ifExpr: WidgetBuilder, thenExpr: WidgetBuilder)

Creates a new if...then expression.

IfThenExpr(ifExpr: StringVariant, thenExpr: StringVariant)

Creates a new if...then expression with string variants.

ElIfThenExpr(elIfExpr: WidgetBuilder, thenExpr: WidgetBuilder)

Creates a new elif...then expression.

ElIfThenExpr(elIfExpr: StringVariant, thenExpr: StringVariant)

Creates a new elif...then expression with string variants.

ElseIfThenExpr(elseIfExpr: WidgetBuilder, thenExpr: WidgetBuilder)

Creates a new else if...then expression.

ElseIfThenExpr(elseIfExpr: StringVariant, thenExpr: StringVariant)

Creates a new else if...then expression with string variants.

IfThenElifExpr(branches: WidgetBuilder list, elseExpr: WidgetBuilder)

Creates a new if...then...elif expression.

IfThenElifExpr(branches: WidgetBuilder list, elseExpr: StringVariant)

Creates a new if...then...elif expression with string variants.

IfThenElifExpr(branches: WidgetBuilder list)

Creates a new if...then...elif expression.

IfThenElseExpr(ifExpr: WidgetBuilder, thenExpr: WidgetBuilder, elseExpr: WidgetBuilder)

Creates a new if...then...else expression.

IfThenElseExpr(ifExpr: StringVariant, thenExpr: StringVariant, elseExpr: StringVariant)

Creates a new if...then...else expression with string variants.

Usage

#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.Core.dll"
#r "../../src/Fabulous.AST/bin/Release/netstandard2.1/publish/Fantomas.FCS.dll"

open Fabulous.AST
open Fantomas.Core
open type Fabulous.AST.Ast

Oak() {
    AnonymousModule() {
        Value("x", ConstantExpr("12"))
        IfThenExpr(InfixAppExpr("x", "=", "12"), ConstantExpr(ConstantUnit()))
        ElIfThenExpr(InfixAppExpr("x", "=", "12"), ConstantExpr(ConstantUnit()))

        IfThenElseExpr(InfixAppExpr("x", "=", "12"), ConstantExpr(ConstantUnit()), ConstantExpr(ConstantUnit()))


    }
}
|> Gen.mkOak
|> CodeFormatter.FormatOakAsync
|> Async.RunSynchronously
|> printfn "%s"

Will output the following code:

let x = 12

if x = 12 then
    ()

elif x = 12 then
    ()

if x = 12 then () else ()
namespace Fabulous
namespace Fabulous.AST
namespace Fantomas
namespace Fantomas.Core
type Ast = class end
Multiple items
static member Ast.Oak: unit -> CollectionBuilder<SyntaxOak.Oak,'marker>

--------------------
module Oak from Fabulous.AST
Multiple items
static member Ast.AnonymousModule: unit -> CollectionBuilder<AnonymousModuleNode,SyntaxOak.ModuleDecl>

--------------------
module AnonymousModule from Fabulous.AST
static member Ast.Value: name: string * value: string -> WidgetBuilder<SyntaxOak.BindingNode>
static member Ast.Value: name: string * value: WidgetBuilder<SyntaxOak.Constant> -> WidgetBuilder<SyntaxOak.BindingNode>
static member Ast.Value: name: string * value: WidgetBuilder<SyntaxOak.Expr> -> WidgetBuilder<SyntaxOak.BindingNode>
static member Ast.Value: name: WidgetBuilder<SyntaxOak.Constant> * value: WidgetBuilder<SyntaxOak.Constant> -> WidgetBuilder<SyntaxOak.BindingNode>
static member Ast.Value: name: WidgetBuilder<SyntaxOak.Pattern> * value: string -> WidgetBuilder<SyntaxOak.BindingNode>
static member Ast.Value: name: WidgetBuilder<SyntaxOak.Pattern> * value: WidgetBuilder<SyntaxOak.Constant> -> WidgetBuilder<SyntaxOak.BindingNode>
static member Ast.Value: name: WidgetBuilder<SyntaxOak.Pattern> * value: WidgetBuilder<SyntaxOak.Expr> -> WidgetBuilder<SyntaxOak.BindingNode>
static member Ast.ConstantExpr: value: string -> WidgetBuilder<SyntaxOak.Expr>
static member Ast.ConstantExpr: value: WidgetBuilder<SyntaxOak.Constant> -> WidgetBuilder<SyntaxOak.Expr>
static member Ast.IfThenExpr: ifExpr: string * thenExpr: string -> WidgetBuilder<SyntaxOak.Expr>
static member Ast.IfThenExpr: ifExpr: string * thenExpr: WidgetBuilder<SyntaxOak.Constant> -> WidgetBuilder<SyntaxOak.Expr>
static member Ast.IfThenExpr: ifExpr: WidgetBuilder<SyntaxOak.Constant> * thenExpr: WidgetBuilder<SyntaxOak.Constant> -> WidgetBuilder<SyntaxOak.Expr>
static member Ast.IfThenExpr: ifExpr: string * thenExpr: WidgetBuilder<SyntaxOak.Expr> -> WidgetBuilder<SyntaxOak.Expr>
static member Ast.IfThenExpr: ifExpr: WidgetBuilder<SyntaxOak.Constant> * thenExpr: WidgetBuilder<SyntaxOak.Expr> -> WidgetBuilder<SyntaxOak.Expr>
static member Ast.IfThenExpr: ifExpr: WidgetBuilder<SyntaxOak.Expr> * thenExpr: WidgetBuilder<SyntaxOak.Expr> -> WidgetBuilder<SyntaxOak.Expr>
static member Ast.InfixAppExpr: lhs: string * operator: string * rhs: string -> WidgetBuilder<SyntaxOak.Expr>
static member Ast.InfixAppExpr: lhs: string * operator: string * rhs: WidgetBuilder<SyntaxOak.Constant> -> WidgetBuilder<SyntaxOak.Expr>
static member Ast.InfixAppExpr: lhs: WidgetBuilder<SyntaxOak.Constant> * operator: string * rhs: WidgetBuilder<SyntaxOak.Constant> -> WidgetBuilder<SyntaxOak.Expr>
static member Ast.InfixAppExpr: lhs: string * operator: string * rhs: WidgetBuilder<SyntaxOak.Expr> -> WidgetBuilder<SyntaxOak.Expr>
static member Ast.InfixAppExpr: lhs: WidgetBuilder<SyntaxOak.Constant> * operator: string * rhs: WidgetBuilder<SyntaxOak.Expr> -> WidgetBuilder<SyntaxOak.Expr>
static member Ast.InfixAppExpr: lhs: WidgetBuilder<SyntaxOak.Expr> * operator: string * rhs: WidgetBuilder<SyntaxOak.Expr> -> WidgetBuilder<SyntaxOak.Expr>
Multiple items
static member Ast.ConstantUnit: unit -> WidgetBuilder<SyntaxOak.Constant>

--------------------
module ConstantUnit from Fabulous.AST
static member Ast.ElIfThenExpr: elIfExpr: string * thenExpr: string -> WidgetBuilder<SyntaxOak.Expr>
static member Ast.ElIfThenExpr: elIfExpr: string * thenExpr: WidgetBuilder<SyntaxOak.Constant> -> WidgetBuilder<SyntaxOak.Expr>
static member Ast.ElIfThenExpr: elIfExpr: WidgetBuilder<SyntaxOak.Constant> * thenExpr: WidgetBuilder<SyntaxOak.Constant> -> WidgetBuilder<SyntaxOak.Expr>
static member Ast.ElIfThenExpr: elIfExpr: string * thenExpr: WidgetBuilder<SyntaxOak.Expr> -> WidgetBuilder<SyntaxOak.Expr>
static member Ast.ElIfThenExpr: elIfExpr: WidgetBuilder<SyntaxOak.Constant> * thenExpr: WidgetBuilder<SyntaxOak.Expr> -> WidgetBuilder<SyntaxOak.Expr>
static member Ast.ElIfThenExpr: elIfExpr: WidgetBuilder<SyntaxOak.Expr> * thenExpr: WidgetBuilder<SyntaxOak.Expr> -> WidgetBuilder<SyntaxOak.Expr>
static member Ast.IfThenElseExpr: ifExpr: string * thenExpr: string * elseExpr: string -> WidgetBuilder<SyntaxOak.Expr>
static member Ast.IfThenElseExpr: ifExpr: string * thenExpr: string * elseExpr: WidgetBuilder<SyntaxOak.Constant> -> WidgetBuilder<SyntaxOak.Expr>
static member Ast.IfThenElseExpr: ifExpr: string * thenExpr: WidgetBuilder<SyntaxOak.Constant> * elseExpr: WidgetBuilder<SyntaxOak.Constant> -> WidgetBuilder<SyntaxOak.Expr>
static member Ast.IfThenElseExpr: ifExpr: string * thenExpr: WidgetBuilder<SyntaxOak.Constant> * elseExpr: WidgetBuilder<SyntaxOak.Expr> -> WidgetBuilder<SyntaxOak.Expr>
static member Ast.IfThenElseExpr: ifExpr: string * thenExpr: string * elseExpr: WidgetBuilder<SyntaxOak.Expr> -> WidgetBuilder<SyntaxOak.Expr>
static member Ast.IfThenElseExpr: ifExpr: WidgetBuilder<SyntaxOak.Constant> * thenExpr: WidgetBuilder<SyntaxOak.Constant> * elseExpr: WidgetBuilder<SyntaxOak.Constant> -> WidgetBuilder<SyntaxOak.Expr>
static member Ast.IfThenElseExpr: ifExpr: WidgetBuilder<SyntaxOak.Constant> * thenExpr: WidgetBuilder<SyntaxOak.Constant> * elseExpr: WidgetBuilder<SyntaxOak.Expr> -> WidgetBuilder<SyntaxOak.Expr>
static member Ast.IfThenElseExpr: ifExpr: string * thenExpr: WidgetBuilder<SyntaxOak.Expr> * elseExpr: WidgetBuilder<SyntaxOak.Expr> -> WidgetBuilder<SyntaxOak.Expr>
static member Ast.IfThenElseExpr: ifExpr: WidgetBuilder<SyntaxOak.Constant> * thenExpr: WidgetBuilder<SyntaxOak.Expr> * elseExpr: WidgetBuilder<SyntaxOak.Expr> -> WidgetBuilder<SyntaxOak.Expr>
static member Ast.IfThenElseExpr: ifExpr: WidgetBuilder<SyntaxOak.Expr> * thenExpr: WidgetBuilder<SyntaxOak.Expr> * elseExpr: WidgetBuilder<SyntaxOak.Expr> -> WidgetBuilder<SyntaxOak.Expr>
module Gen from Fabulous.AST
<summary> It takes the root of the widget tree and create the corresponding Fantomas node, and recursively creating all children nodes </summary>
val mkOak: root: WidgetBuilder<'node> -> 'node
type CodeFormatter = static member FormatASTAsync: ast: ParsedInput -> Async<string> + 2 overloads static member FormatDocumentAsync: isSignature: bool * source: string -> Async<FormatResult> + 2 overloads static member FormatOakAsync: oak: Oak -> Async<string> + 1 overload static member FormatSelectionAsync: isSignature: bool * source: string * selection: range -> Async<string * range> + 1 overload static member GetVersion: unit -> string static member IsValidFSharpCodeAsync: isSignature: bool * source: string -> Async<bool> static member MakePosition: line: int * column: int -> pos static member MakeRange: fileName: string * startLine: int * startCol: int * endLine: int * endCol: int -> range static member ParseAsync: isSignature: bool * source: string -> Async<(ParsedInput * string list) array> static member ParseOakAsync: isSignature: bool * source: string -> Async<(Oak * string list) array> ...
static member CodeFormatter.FormatOakAsync: oak: SyntaxOak.Oak -> Async<string>
static member CodeFormatter.FormatOakAsync: oak: SyntaxOak.Oak * config: FormatConfig -> Async<string>
Multiple items
module Async from Fantomas.Core

--------------------
type Async = static member AsBeginEnd: computation: ('Arg -> Async<'T>) -> ('Arg * AsyncCallback * obj -> IAsyncResult) * (IAsyncResult -> 'T) * (IAsyncResult -> unit) static member AwaitEvent: event: IEvent<'Del,'T> * ?cancelAction: (unit -> unit) -> Async<'T> (requires delegate and 'Del :> Delegate) static member AwaitIAsyncResult: iar: IAsyncResult * ?millisecondsTimeout: int -> Async<bool> static member AwaitTask: task: Task<'T> -> Async<'T> + 1 overload static member AwaitWaitHandle: waitHandle: WaitHandle * ?millisecondsTimeout: int -> Async<bool> static member CancelDefaultToken: unit -> unit static member Catch: computation: Async<'T> -> Async<Choice<'T,exn>> static member Choice: computations: Async<'T option> seq -> Async<'T option> static member FromBeginEnd: beginAction: (AsyncCallback * obj -> IAsyncResult) * endAction: (IAsyncResult -> 'T) * ?cancelAction: (unit -> unit) -> Async<'T> + 3 overloads static member FromContinuations: callback: (('T -> unit) * (exn -> unit) * (OperationCanceledException -> unit) -> unit) -> Async<'T> ...

--------------------
type Async<'T>
static member Async.RunSynchronously: computation: Async<'T> * ?timeout: int * ?cancellationToken: System.Threading.CancellationToken -> 'T
val printfn: format: Printf.TextWriterFormat<'T> -> 'T
val x: int

Type something to start searching.