Records

Constructors

Constructors	Description
Record(name: string)	Creates a new record with the specified name.

Properties

Properties	Description
members()	Sets the members of the record.
xmlDocs(xmlDocs: string list)	Adds XML documentation to the record.
typeParams(typeParams: string list)	Adds type parameters to the record.
attributes(attributes: WidgetBuilder list)	Adds attributes to the record.
attributes(attributes: string list)	Adds attributes to the record.
attribute(attribute: WidgetBuilder)	Adds an attribute to the record.
attribute(attribute: string)	Adds an attribute to the record.
toPrivate()	Makes the record private.
toInternal()	Makes the record internal.
toPublic()	Makes the record public.

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() {
        (Record("Person") {
            Field("Name", "string")
            Field("Age", "int")
            Field("Address", "string")
        })
            .xmlDocs([ "Normal record" ])
            .members () {
            let parameters =
                TuplePat(
                    [ ParameterPat("name", "string")
                      ParameterPat("age", "int")
                      ParameterPat("address", "string") ]
                )

            Method(
                "Create",
                parameters,
                RecordExpr(
                    [ RecordFieldExpr("Name", ConstantExpr("name"))
                      RecordFieldExpr("Age", ConstantExpr("age"))
                      RecordFieldExpr("Address", ConstantExpr("address")) ]
                )
            )
                .toStatic ()

            Property("this.NameValue", ConstantExpr("this.Name"))
        }

        (Record("Person") {
            Field("Name", "string")
            Field("Age", "int")
            Field("Address", "string")
        })
            .typeParams(PostfixList([ "'T" ]))
            .xmlDocs ([ "Generic record" ])
    }
}
|> Gen.mkOak
|> CodeFormatter.FormatOakAsync
|> Async.RunSynchronously
|> printfn "%s"

Will output the following code:

/// Normal record
type Person =
    { Name: string
      Age: int
      Address: string }

    static member Create(name: string, age: int, address: string) =
        { Name = name
          Age = age
          Address = address }

    member this.NameValue = this.Name

/// Generic record
type Person<'T> =
    { Name: string
      Age: int
      Address: string }

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

Multiple items
static member Ast.Record: name: string -> CollectionBuilder<SyntaxOak.TypeDefnRecordNode,SyntaxOak.FieldNode>

--------------------
module Record from Fabulous.AST

Multiple items
static member Ast.Field: name: string * filedType: string -> WidgetBuilder<SyntaxOak.FieldNode>
static member Ast.Field: name: string * filedType: WidgetBuilder<SyntaxOak.Type> -> WidgetBuilder<SyntaxOak.FieldNode>
static member Ast.Field: filedType: string -> WidgetBuilder<SyntaxOak.FieldNode>
static member Ast.Field: filedType: WidgetBuilder<SyntaxOak.Type> -> WidgetBuilder<SyntaxOak.FieldNode>

--------------------
module Field from Fabulous.AST

val parameters: WidgetBuilder<SyntaxOak.Pattern>

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

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.Method: name: string * parameters: string * bodyExpr: string -> WidgetBuilder<SyntaxOak.BindingNode>
static member Ast.Method: name: string * parameters: string * bodyExpr: WidgetBuilder<SyntaxOak.Constant> -> WidgetBuilder<SyntaxOak.BindingNode>
static member Ast.Method: name: string * parameters: WidgetBuilder<SyntaxOak.Pattern> * bodyExpr: string -> WidgetBuilder<SyntaxOak.BindingNode>
static member Ast.Method: name: string * parameters: string list * bodyExpr: string -> WidgetBuilder<SyntaxOak.BindingNode>
static member Ast.Method: name: string * parameters: string list * bodyExpr: WidgetBuilder<SyntaxOak.Constant> -> WidgetBuilder<SyntaxOak.BindingNode>
static member Ast.Method: name: string * parameters: WidgetBuilder<SyntaxOak.Pattern> list * bodyExpr: string -> WidgetBuilder<SyntaxOak.BindingNode>
static member Ast.Method: name: string * parameters: WidgetBuilder<SyntaxOak.Pattern> list * bodyExpr: WidgetBuilder<SyntaxOak.Constant> -> WidgetBuilder<SyntaxOak.BindingNode>
static member Ast.Method: name: string * parameter: WidgetBuilder<SyntaxOak.Pattern> * body: WidgetBuilder<SyntaxOak.Expr> -> WidgetBuilder<SyntaxOak.BindingNode>
static member Ast.Method: name: string * parameters: WidgetBuilder<SyntaxOak.Pattern> list * body: WidgetBuilder<SyntaxOak.Expr> -> WidgetBuilder<SyntaxOak.BindingNode>

Multiple items
static member Ast.RecordExpr: fields: WidgetBuilder<SyntaxOak.RecordFieldNode> list -> WidgetBuilder<SyntaxOak.Expr>
static member Ast.RecordExpr: copyInfo: string * fields: WidgetBuilder<SyntaxOak.RecordFieldNode> list -> WidgetBuilder<SyntaxOak.Expr>
static member Ast.RecordExpr: copyInfo: WidgetBuilder<SyntaxOak.Constant> * fields: WidgetBuilder<SyntaxOak.RecordFieldNode> list -> WidgetBuilder<SyntaxOak.Expr>
static member Ast.RecordExpr: copyInfo: WidgetBuilder<SyntaxOak.Expr> * fields: WidgetBuilder<SyntaxOak.RecordFieldNode> list -> WidgetBuilder<SyntaxOak.Expr>

--------------------
module RecordExpr from Fabulous.AST

static member Ast.RecordFieldExpr: name: string * expr: string -> WidgetBuilder<SyntaxOak.RecordFieldNode>
static member Ast.RecordFieldExpr: name: string * expr: WidgetBuilder<SyntaxOak.Constant> -> WidgetBuilder<SyntaxOak.RecordFieldNode>
static member Ast.RecordFieldExpr: name: string * expr: WidgetBuilder<SyntaxOak.Expr> -> WidgetBuilder<SyntaxOak.RecordFieldNode>

static member Ast.ConstantExpr: value: string -> WidgetBuilder<SyntaxOak.Expr>
static member Ast.ConstantExpr: value: WidgetBuilder<SyntaxOak.Constant> -> WidgetBuilder<SyntaxOak.Expr>

static member Ast.Property: name: string * body: string -> WidgetBuilder<SyntaxOak.BindingNode>
   (+0 other overloads)
static member Ast.Property: name: string * body: WidgetBuilder<SyntaxOak.Constant> -> WidgetBuilder<SyntaxOak.BindingNode>
   (+0 other overloads)
static member Ast.Property: name: WidgetBuilder<SyntaxOak.Constant> * body: string -> WidgetBuilder<SyntaxOak.BindingNode>
   (+0 other overloads)
static member Ast.Property: name: string * body: WidgetBuilder<SyntaxOak.Expr> -> WidgetBuilder<SyntaxOak.BindingNode>
   (+0 other overloads)
static member Ast.Property: name: WidgetBuilder<SyntaxOak.Constant> * body: WidgetBuilder<SyntaxOak.Constant> -> WidgetBuilder<SyntaxOak.BindingNode>
   (+0 other overloads)
static member Ast.Property: name: WidgetBuilder<SyntaxOak.Constant> * body: WidgetBuilder<SyntaxOak.Expr> -> WidgetBuilder<SyntaxOak.BindingNode>
   (+0 other overloads)
static member Ast.Property: name: WidgetBuilder<SyntaxOak.Pattern> * body: string -> WidgetBuilder<SyntaxOak.BindingNode>
   (+0 other overloads)
static member Ast.Property: name: WidgetBuilder<SyntaxOak.Pattern> * body: WidgetBuilder<SyntaxOak.Constant> -> WidgetBuilder<SyntaxOak.BindingNode>
   (+0 other overloads)
static member Ast.Property: name: WidgetBuilder<SyntaxOak.Pattern> * body: WidgetBuilder<SyntaxOak.Expr> -> WidgetBuilder<SyntaxOak.BindingNode>
   (+0 other overloads)
static member Ast.Property: identifier: string * getter: WidgetBuilder<SyntaxOak.PropertyGetSetBindingNode> * setter: WidgetBuilder<SyntaxOak.PropertyGetSetBindingNode> -> WidgetBuilder<SyntaxOak.MemberDefnPropertyGetSetNode>
   (+0 other overloads)

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>

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

Multiple items
val string: value: 'T -> string

--------------------
type string = System.String

Multiple items
val int: value: 'T -> int (requires member op_Explicit)

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

--------------------
type int<'Measure> = int

val name: string

val age: int

val address: string

val this: Person

Person.Name: string

Multiple items
type Person = { Name: string Age: int Address: string } static member Create: name: string * age: int * address: string -> Person member NameValue: string
Normal record

--------------------
type Person<'T> = { Name: string Age: int Address: string }
Generic record