Header menu logo Fabulous.AST

Function Bindings

Constructors

Constructors

Description

Function(name: string, parameters: WidgetBuilder, value: StringVariant)

Creates a function binding with name, parameters and value expression.

Function(name: string, parameters: WidgetBuilder, value: WidgetBuilder)

Creates a function binding with name, parameters and value expression.

Function(name: string, typeParams: string list, parameters: WidgetBuilder, value: WidgetBuilder)

Creates a function binding with name, type parameters, parameters and value expression.

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() {
        Function("x", ParameterPat("i"), ConstantExpr(ConstantUnit()))
        Function("x1", NamedPat("i"), ConstantExpr(ConstantUnit()))
        Function("x2", ParenPat(NamedPat("i")), ConstantExpr(ConstantUnit()))
        Function("x3", ParenPat(ParameterPat(NamedPat("i"), Int())), ConstantExpr(ConstantUnit()))

        Function("x4", TuplePat([ NamedPat("i"); NamedPat("j"); NamedPat("k") ]), ConstantExpr(ConstantUnit()))

        Function("x5", [ NamedPat("i"); NamedPat("j"); NamedPat("k") ], ConstantExpr(ConstantUnit()))

        Function(
            "x6",
            TuplePat(
                [ ParameterPat(NamedPat("i"), Int())
                  ParameterPat(NamedPat("j"), String())
                  ParameterPat(NamedPat("k"), Boolean()) ]
            ),
            ConstantExpr(ConstantUnit())
        )

        Open("System")

        Function("x7", NamedPat("i"), ConstantExpr(ConstantUnit()))
            .attribute (Attribute("Obsolete", ParenExpr(ConstantExpr(String "Use bar instead"))))

        Function("x8", NamedPat("i"), ConstantExpr(ConstantUnit())).xmlDocs [ "Im a function" ]

        Function("x9", NamedPat("i"), ConstantExpr(ConstantUnit())).returnType (Unit())

        Function(
            "foo",
            TuplePat([ ParameterPat("x", "'T"); ParameterPat(NamedPat("i"), "'U") ]),
            ConstantExpr(ConstantUnit())
        )
            .returnType (Unit())

        Function("x10", NamedPat("i"), ConstantExpr(ConstantUnit())).toInlined ()

        Function("x11", NamedPat("i"), ConstantExpr(ConstantUnit())).toPublic ()

        Function("y", NamedPat("i"), ConstantExpr(ConstantUnit())).toPrivate ()

        Function("z", NamedPat("i"), ConstantExpr(ConstantUnit())).toInternal ()
    }
}
|> Gen.mkOak
|> CodeFormatter.FormatOakAsync
|> Async.RunSynchronously
|> printfn "%s"

Will output the following code:

let x i = ()
let x1 i = ()
let x2 (i) = ()
let x3 (i: int) = ()
let x4 (i, j, k) = ()
let x5 i j k = ()
let x6 (i: int, j: string, k: bool) = ()

open System

[<Obsolete("Use bar instead")>]
let x7 i = ()

/// I'm a function
let x8 i = ()
let x9 i : unit = ()
let foo (x: 'T, i: 'U) : unit = ()
let inline x10 i = ()
let public x11 i = ()
let private y i = ()
let internal z i = ()
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.Function: name: string * parameters: string * bodyExpr: string -> WidgetBuilder<SyntaxOak.BindingNode>
   (+0 other overloads)
static member Ast.Function: name: string * parameters: string * bodyExpr: WidgetBuilder<SyntaxOak.Constant> -> WidgetBuilder<SyntaxOak.BindingNode>
   (+0 other overloads)
static member Ast.Function: name: string * parameters: string * bodyExpr: WidgetBuilder<SyntaxOak.Expr> -> WidgetBuilder<SyntaxOak.BindingNode>
   (+0 other overloads)
static member Ast.Function: name: string * parameters: WidgetBuilder<SyntaxOak.Pattern> * bodyExpr: string -> WidgetBuilder<SyntaxOak.BindingNode>
   (+0 other overloads)
static member Ast.Function: name: string * parameters: WidgetBuilder<SyntaxOak.Pattern> * bodyExpr: WidgetBuilder<SyntaxOak.Constant> -> WidgetBuilder<SyntaxOak.BindingNode>
   (+0 other overloads)
static member Ast.Function: name: string * parameters: WidgetBuilder<SyntaxOak.Pattern> * bodyExpr: WidgetBuilder<SyntaxOak.Expr> -> WidgetBuilder<SyntaxOak.BindingNode>
   (+0 other overloads)
static member Ast.Function: name: string * parameters: string list * bodyExpr: string -> WidgetBuilder<SyntaxOak.BindingNode>
   (+0 other overloads)
static member Ast.Function: name: string * parameters: string list * bodyExpr: WidgetBuilder<SyntaxOak.Constant> -> WidgetBuilder<SyntaxOak.BindingNode>
   (+0 other overloads)
static member Ast.Function: name: string * parameters: string list * bodyExpr: WidgetBuilder<SyntaxOak.Expr> -> WidgetBuilder<SyntaxOak.BindingNode>
   (+0 other overloads)
static member Ast.Function: name: string * parameters: WidgetBuilder<SyntaxOak.Pattern> list * bodyExpr: string -> WidgetBuilder<SyntaxOak.BindingNode>
   (+0 other overloads)
static member Ast.ParameterPat: name: string -> WidgetBuilder<SyntaxOak.Pattern>
static member Ast.ParameterPat: name: WidgetBuilder<SyntaxOak.Constant> -> WidgetBuilder<SyntaxOak.Pattern>
static member Ast.ParameterPat: name: WidgetBuilder<SyntaxOak.Pattern> -> WidgetBuilder<SyntaxOak.Pattern>
static member Ast.ParameterPat: name: string * pType: string -> WidgetBuilder<SyntaxOak.Pattern>
static member Ast.ParameterPat: name: string * pType: WidgetBuilder<SyntaxOak.Type> -> WidgetBuilder<SyntaxOak.Pattern>
static member Ast.ParameterPat: name: WidgetBuilder<SyntaxOak.Constant> * pType: string -> WidgetBuilder<SyntaxOak.Pattern>
static member Ast.ParameterPat: name: WidgetBuilder<SyntaxOak.Constant> * pType: WidgetBuilder<SyntaxOak.Type> -> WidgetBuilder<SyntaxOak.Pattern>
static member Ast.ParameterPat: name: WidgetBuilder<SyntaxOak.Pattern> * pType: string -> WidgetBuilder<SyntaxOak.Pattern>
static member Ast.ParameterPat: name: WidgetBuilder<SyntaxOak.Pattern> * pType: WidgetBuilder<SyntaxOak.Type> -> WidgetBuilder<SyntaxOak.Pattern>
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.ConstantUnit: unit -> WidgetBuilder<SyntaxOak.Constant>

--------------------
module ConstantUnit from Fabulous.AST
static member Ast.NamedPat: value: string -> WidgetBuilder<SyntaxOak.Pattern>
Multiple items
static member Ast.ParenPat: pat: string -> WidgetBuilder<SyntaxOak.Pattern>
static member Ast.ParenPat: pat: WidgetBuilder<SyntaxOak.Constant> -> WidgetBuilder<SyntaxOak.Pattern>
static member Ast.ParenPat: pat: WidgetBuilder<SyntaxOak.Pattern> -> WidgetBuilder<SyntaxOak.Pattern>

--------------------
module ParenPat from Fabulous.AST
static member Ast.Int: value: int -> WidgetBuilder<SyntaxOak.Constant>
static member Ast.Int: unit -> WidgetBuilder<SyntaxOak.Type>
Multiple items
static member Ast.TuplePat: values: string list -> WidgetBuilder<SyntaxOak.Pattern>
static member Ast.TuplePat: values: WidgetBuilder<SyntaxOak.Constant> list -> WidgetBuilder<SyntaxOak.Pattern>
static member Ast.TuplePat: value: WidgetBuilder<SyntaxOak.Pattern> list -> WidgetBuilder<SyntaxOak.Pattern>

--------------------
module TuplePat from Fabulous.AST
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.Boolean: unit -> WidgetBuilder<SyntaxOak.Type>
Multiple items
static member Ast.Open: name: string -> WidgetBuilder<SyntaxOak.OpenModuleOrNamespaceNode>

--------------------
module Open from Fabulous.AST
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>
Multiple items
static member Ast.ParenExpr: value: string -> WidgetBuilder<SyntaxOak.Expr>
static member Ast.ParenExpr: value: WidgetBuilder<SyntaxOak.Constant> -> WidgetBuilder<SyntaxOak.Expr>
static member Ast.ParenExpr: value: WidgetBuilder<SyntaxOak.Expr> -> WidgetBuilder<SyntaxOak.Expr>

--------------------
module ParenExpr from Fabulous.AST
static member Ast.Unit: unit -> WidgetBuilder<SyntaxOak.Type>
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: i: 'a -> unit
val i: 'a
val x1: i: 'a -> unit
val x2: i: 'a -> unit
val x3: i: int -> unit
val i: int
Multiple items
val int: value: 'T -> int (requires member op_Explicit)

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

--------------------
type int<'Measure> = int
val x4: i: 'a * j: 'b * k: 'c -> unit
val j: 'b
val k: 'c
val x5: i: 'a -> j: 'b -> k: 'c -> unit
val x6: i: int * j: string * k: bool -> unit
val j: string
Multiple items
val string: value: 'T -> string

--------------------
type string = System.String
val k: bool
type bool = System.Boolean
namespace System
Multiple items
type ObsoleteAttribute = inherit Attribute new: unit -> unit + 2 overloads member DiagnosticId: string member IsError: bool member Message: string member UrlFormat: string
<summary>Marks the program elements that are no longer in use. This class cannot be inherited.</summary>

--------------------
ObsoleteAttribute() : ObsoleteAttribute
ObsoleteAttribute(message: string) : ObsoleteAttribute
ObsoleteAttribute(message: string, error: bool) : ObsoleteAttribute
val x8: i: 'a -> unit
 I'm a function
val x9: i: 'a -> unit
type unit = Unit
val foo: x: 'T * i: 'U -> unit
val x: 'T
'T
val i: 'U
'U
val x10: i: 'a -> unit
val x11: i: 'a -> unit
val private y: i: 'a -> unit
val internal z: i: 'a -> unit

Type something to start searching.