Header menu logo Fabulous.AST

Classes

Constructors

Constructors

Description

Class(name: string)

Creates a new class with the specified name.

Class(name: string, constructor: WidgetBuilder)

Creates a new class with the specified name and constructor.

Properties

Properties

Description

xmlDocs(xmlDocs: string list)

Adds XML documentation to the class.

typeParams(typeParams: string list)

Adds type parameters to the class.

attributes(attributes: WidgetBuilder list)

Adds attributes to the class.

attributes(attributes: string list)

Adds attributes to the class.

attribute(attribute: WidgetBuilder)

Adds an attribute to the class.

attribute(attribute: string)

Adds an attribute to the class.

toPrivate()

Makes the class private.

toInternal()

Makes the class internal.

toPublic()

Makes the class 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() {
        Class("Person") { Property("this.Name", String("")) }

        Class("Person2", ImplicitConstructor(ParenPat(TuplePat([ ParameterPat("name") ])))) {
            Property("this.Name", ConstantExpr("name"))
        }

        Class(
            "Person3",
            ImplicitConstructor(ParenPat(TuplePat([ ParameterPat("name", String()); ParameterPat("?age", Int()) ])))
        ) {
            Property("this.Name", ConstantExpr("name"))
        }

        (Class("Person4", ImplicitConstructor(ParenPat(ParameterPat("name", String())))) {
            Property("this.Name", ConstantExpr("name"))
        })
            .attribute (Attribute("Struct"))

        (Class("Person5") { Property("this.Name", ConstantExpr(String(""))) })
            .typeParams (PostfixList([ "'a"; "'b" ]))
    }
}
|> Gen.mkOak
|> CodeFormatter.FormatOakAsync
|> Async.RunSynchronously
|> printfn "%s"

Will output the following code:

type Person() =
    member this.Name = ""

type Person2(name) =
    member this.Name = name

type Person3(name: string, ?age: int) =
    member this.Name = name

[<Struct>]
type Person4(name: string) =
    member this.Name = name

type Person5<'a, 'b>() =
    member this.Name = ""
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.Class: name: string * constructor: WidgetBuilder<SyntaxOak.ImplicitConstructorNode> -> CollectionBuilder<SyntaxOak.TypeDefnRegularNode,SyntaxOak.MemberDefn>
static member Ast.Class: name: string -> CollectionBuilder<SyntaxOak.TypeDefnRegularNode,SyntaxOak.MemberDefn>

--------------------
module Class from Fabulous.AST

--------------------
type ClassAttribute = inherit Attribute new: unit -> ClassAttribute

--------------------
new: unit -> ClassAttribute
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)
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
Multiple items
static member Ast.ImplicitConstructor: unit -> WidgetBuilder<SyntaxOak.ImplicitConstructorNode>
static member Ast.ImplicitConstructor: pattern: string -> WidgetBuilder<SyntaxOak.ImplicitConstructorNode>
static member Ast.ImplicitConstructor: pattern: WidgetBuilder<SyntaxOak.Constant> -> WidgetBuilder<SyntaxOak.ImplicitConstructorNode>
static member Ast.ImplicitConstructor: pattern: WidgetBuilder<SyntaxOak.Pattern> -> WidgetBuilder<SyntaxOak.ImplicitConstructorNode>

--------------------
module ImplicitConstructor from Fabulous.AST
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
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.ConstantExpr: value: string -> WidgetBuilder<SyntaxOak.Expr>
static member Ast.ConstantExpr: value: WidgetBuilder<SyntaxOak.Constant> -> WidgetBuilder<SyntaxOak.Expr>
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>
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
type Person = new: unit -> Person member Name: string

--------------------
new: unit -> Person
val this: Person
Multiple items
type Person2 = new: name: obj -> Person2 member Name: obj

--------------------
new: name: obj -> Person2
val name: obj
val this: Person2
Multiple items
type Person3 = new: name: string * ?age: int -> Person3 member Name: string

--------------------
new: name: string * ?age: int -> Person3
val name: string
Multiple items
val string: value: 'T -> string

--------------------
type string = System.String
val age: int option
Multiple items
val int: value: 'T -> int (requires member op_Explicit)

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

--------------------
type int<'Measure> = int
val this: Person3
Multiple items
union case TypeDefn.Struct: TypeDefn

--------------------
type StructAttribute = inherit Attribute new: unit -> StructAttribute

--------------------
new: unit -> StructAttribute
Multiple items
[<Struct>] type Person4 = new: name: string -> Person4 member Name: string

--------------------
Person4 ()
new: name: string -> Person4
val this: inref<Person4>
Multiple items
type Person5<'a,'b> = new: unit -> Person5<'a,'b> member Name: string

--------------------
new: unit -> Person5<'a,'b>
'a
'b
val this: Person5<'a,'b>

Type something to start searching.