Header menu logo Fabulous.AST

Value Bindings

Constructors

Constructors

Description

Value(name: string, value: string)

Creates a value binding with name and value, and optionally specifies if the value should be quoted.

Value(name: string, value: WidgetBuilder)

Creates a value binding with name and value expression.

Value(name: WidgetBuilder, value: WidgetBuilder)

Creates a value binding with name pattern and value expression.

Value(name: WidgetBuilder, value: string)

Creates a value binding with name pattern and value expression, and optionally specifies if the value should be quoted.

Properties

Properties

Description

xmlDocs(xmlDocs: string list)

Adds XML documentation to the value binding.

attributes(attributes: WidgetBuilder list)

Adds attributes of the value binding.

attributes(attributes: string list)

Adds attributes to the value binding.

attribute(attribute: WidgetBuilder)

Adds an attribute to the value binding.

attribute(attribute: string)

Adds an attribute to the value binding.

toPrivate()

Makes the value binding private.

toInternal()

Makes the value binding internal.

toPublic()

Makes the value binding public.

returnType(returnType: WidgetBuilder)

Sets the return type of the value binding.

returnType(returnType: string)

Sets the return type of the value binding.

toMutable()

Makes the value binding mutable.

toInlined()

Makes the value binding inlined.

toStatic()

Makes the value binding static.

hasQuotes()

Specifies if the value should be quoted.

typeParameters(typeParams: string list)

Adds type parameters to the value binding.

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("value", String "12")

        Value("value1", "12")

        Value(
            "value3",
            IfThenElseExpr(
                InfixAppExpr(ConstantExpr("0"), "=", ConstantExpr(Constant("12"))),
                ConstantExpr(ConstantUnit()),
                ConstantExpr(ConstantUnit())
            )
        )

        Value(
            NamedPat("value4"),
            IfThenElseExpr(
                InfixAppExpr(ConstantExpr("0"), "=", ConstantExpr(Constant("12"))),
                ConstantExpr(ConstantUnit()),
                ConstantExpr(ConstantUnit())
            )
        )

        Value(NamedPat("value5"), String "12")

        Value(NamedPat("value6"), "12")

        Value("value7", String "12").typeParams (PostfixList([ "'a" ]))

        Value("value8", ConstantExpr(String "12")).typeParams (PostfixList([ "'a" ]))

        Value(NamedPat("value9"), ConstantExpr(String "12"))
            .typeParams (PostfixList([ "'a" ]))

        Value("value10", "12").returnType (Int())

        Value("value11", "12").returnType(Int()).toPrivate ()

        Value("value12", String "12").attribute (Attribute "Literal")

        Value("value13", "12").returnType(Int()).toMutable ()

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

Will output the following code:

let value = "12"
let value1 = 12
let value3 = if 0 = 12 then () else ()
let value4 = if 0 = 12 then () else ()
let value5 = "12"
let value6 = 12
let value7<'a> = "12"
let value8<'a> = "12"
let value9<'a> = "12"
let value10: int = 12
let private value11: int = 12

[<Literal>]
let value12 = "12"

let mutable value13: int = 12
namespace Fabulous
namespace Fabulous.AST
namespace Fantomas
namespace Fantomas.Core
type Ast = class end
Multiple items
static member Ast.Oak: unit -> CollectionBuilder<SyntaxOak.Oak,SyntaxOak.ModuleOrNamespaceNode>

--------------------
module Oak from Fabulous.AST
static member Ast.AnonymousModule: unit -> CollectionBuilder<SyntaxOak.ModuleOrNamespaceNode,SyntaxOak.ModuleDecl>
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>
Multiple items
static member Ast.String: value: WidgetBuilder<SyntaxOak.Constant> -> WidgetBuilder<SyntaxOak.Constant>
static member Ast.String: value: string -> WidgetBuilder<SyntaxOak.Constant>
static member Ast.String: unit -> WidgetBuilder<SyntaxOak.Type>

--------------------
module String from Fantomas.Core

--------------------
module String from Microsoft.FSharp.Core
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>
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>
static member Ast.ConstantExpr: value: string -> WidgetBuilder<SyntaxOak.Expr>
static member Ast.ConstantExpr: value: WidgetBuilder<SyntaxOak.Constant> -> WidgetBuilder<SyntaxOak.Expr>
Multiple items
static member Ast.Constant: value: string -> WidgetBuilder<SyntaxOak.Constant>

--------------------
module Constant from Fabulous.AST
Multiple items
static member Ast.ConstantUnit: unit -> WidgetBuilder<SyntaxOak.Constant>

--------------------
module ConstantUnit from Fabulous.AST
static member Ast.NamedPat: value: string -> WidgetBuilder<SyntaxOak.Pattern>
static member Ast.PostfixList: decls: string * constraints: WidgetBuilder<SyntaxOak.TypeConstraint> -> WidgetBuilder<SyntaxOak.TyparDecls>
static member Ast.PostfixList: decls: WidgetBuilder<SyntaxOak.TyparDeclNode> * constraints: WidgetBuilder<SyntaxOak.TypeConstraint> -> WidgetBuilder<SyntaxOak.TyparDecls>
static member Ast.PostfixList: constraints: WidgetBuilder<SyntaxOak.TypeConstraint> -> WidgetBuilder<SyntaxOak.TyparDecls>
static member Ast.PostfixList: constraints: WidgetBuilder<SyntaxOak.TypeConstraint> list -> WidgetBuilder<SyntaxOak.TyparDecls>
static member Ast.PostfixList: decl: string -> WidgetBuilder<SyntaxOak.TyparDecls>
static member Ast.PostfixList: decl: WidgetBuilder<SyntaxOak.TyparDeclNode> -> WidgetBuilder<SyntaxOak.TyparDecls>
static member Ast.PostfixList: decls: string list -> WidgetBuilder<SyntaxOak.TyparDecls>
static member Ast.PostfixList: decls: WidgetBuilder<SyntaxOak.TyparDeclNode> list -> WidgetBuilder<SyntaxOak.TyparDecls>
static member Ast.PostfixList: decls: string list * constraints: WidgetBuilder<SyntaxOak.TypeConstraint> list -> WidgetBuilder<SyntaxOak.TyparDecls>
static member Ast.PostfixList: decls: WidgetBuilder<SyntaxOak.TyparDeclNode> list * constraints: WidgetBuilder<SyntaxOak.TypeConstraint> list -> WidgetBuilder<SyntaxOak.TyparDecls>
static member Ast.Int: value: int -> WidgetBuilder<SyntaxOak.Constant>
static member Ast.Int: unit -> WidgetBuilder<SyntaxOak.Type>
static member Ast.Attribute: value: string * expr: string -> WidgetBuilder<SyntaxOak.AttributeNode>
static member Ast.Attribute: value: string * expr: WidgetBuilder<SyntaxOak.Constant> -> WidgetBuilder<SyntaxOak.AttributeNode>
static member Ast.Attribute: value: string * expr: WidgetBuilder<SyntaxOak.Expr> -> WidgetBuilder<SyntaxOak.AttributeNode>
static member Ast.Attribute: value: string -> WidgetBuilder<SyntaxOak.AttributeNode>
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 value: string
val value1: int
val value3: unit
val value4: unit
val value5: string
val value6: int
val value7<'a> : string
'a
val value8<'a> : string
val value9<'a> : string
val value10: int
Multiple items
val int: value: 'T -> int (requires member op_Explicit)

--------------------
type int = int32

--------------------
type int<'Measure> = int
val private value11: int
Multiple items
type LiteralAttribute = inherit Attribute new: unit -> LiteralAttribute

--------------------
new: unit -> LiteralAttribute
[<Literal>] val value12: string = "12"
val mutable value13: int

Type something to start searching.