Header menu logo Fabulous.AST

Enums

Contents

#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.FCS.dll"

open Fabulous.AST
open type Fabulous.AST.Ast

Overview

An enumeration is a type with a fixed set of named integer constants. Build one with Enum and one EnumCase per value.

Basic Usage

Oak() {
    AnonymousModule() {
        Enum("Color") {
            EnumCase("Red", Int(0))
            EnumCase("Green", Int(1))
            EnumCase("Blue", Int(2))
        }
    }
}
|> Gen.mkOak
|> Gen.run
|> printfn "%s"

// produces the following code:
type Color =
    | Red = 0
    | Green = 1
    | Blue = 2

Enum Cases

Each case pairs a name with a constant value. The value can be a constant widget (Int, Char, ...) or a full ConstantExpr:

Oak() {
    AnonymousModule() {
        Enum("FileAccess") {
            EnumCase("Read", Int(1))
            EnumCase("Write", Int(2))
            EnumCase("ReadWrite", ConstantExpr(Int 3))
        }
    }
}
|> Gen.mkOak
|> Gen.run
|> printfn "%s"

// produces the following code:
type FileAccess =
    | Read = 1
    | Write = 2
    | ReadWrite = 3

Attributes and XML Documentation

Add attributes and documentation with the unified modifiers:

Oak() {
    AnonymousModule() {
        Enum("Color") {
            EnumCase("Red", Int(0))
            EnumCase("Green", Int(1))
            EnumCase("Blue", Int(2))
        }
        |> _.attribute(Attribute("Flags"))
        |> _.xmlDocs([ "The primary colors" ])
    }
}
|> Gen.mkOak
|> Gen.run
|> printfn "%s"

// produces the following code:
/// The primary colors
[<Flags>]
type Color =
    | Red = 0
    | Green = 1
    | Blue = 2
namespace Fabulous
namespace Fabulous.AST
type Ast = class end
Multiple items
static member Ast.Oak: unit -> CollectionBuilder<Fantomas.Core.SyntaxOak.Oak,'marker>

--------------------
module Oak from Fabulous.AST
static member Ast.AnonymousModule: unit -> CollectionBuilder<Fantomas.Core.SyntaxOak.ModuleOrNamespaceNode,Fantomas.Core.SyntaxOak.ModuleDecl>
Multiple items
static member Ast.Enum: name: string -> CollectionBuilder<Fantomas.Core.SyntaxOak.TypeDefn,Fantomas.Core.SyntaxOak.EnumCaseNode>

--------------------
module Enum from Fabulous.AST
Multiple items
static member Ast.EnumCase: name: string * field: string -> WidgetBuilder<Fantomas.Core.SyntaxOak.EnumCaseNode>
static member Ast.EnumCase: name: string * field: WidgetBuilder<Fantomas.Core.SyntaxOak.Constant> -> WidgetBuilder<Fantomas.Core.SyntaxOak.EnumCaseNode>
static member Ast.EnumCase: name: string * field: WidgetBuilder<Fantomas.Core.SyntaxOak.Expr> -> WidgetBuilder<Fantomas.Core.SyntaxOak.EnumCaseNode>

--------------------
module EnumCase from Fabulous.AST
static member Ast.Int: value: int -> WidgetBuilder<Fantomas.Core.SyntaxOak.Constant>
static member Ast.Int: unit -> WidgetBuilder<Fantomas.Core.SyntaxOak.Type>
type Gen = static member mkOak: root: WidgetBuilder<'node> -> 'node static member parse: source: string -> string + 1 overload static member run: oak: Oak -> string + 1 overload
<summary> Renders a widget tree to F# source and verifies the result. <c>mkOak</c> turns the root widget into a Fantomas node (recursively building its children), <c>run</c> formats that node to source (optionally with a config), and <c>parse</c> round-trips the source back through the parser to confirm it is syntactically valid. Designed for pipeline use, e.g. <c>widget |&gt; Gen.parse</c> or <c>widget |&gt; Gen.mkOak |&gt; Gen.run |&gt; Gen.parse</c>. </summary>
static member Gen.mkOak: root: WidgetBuilder<'node> -> 'node
static member Gen.run: oak: Fantomas.Core.SyntaxOak.Oak -> string
static member Gen.run: oak: Fantomas.Core.SyntaxOak.Oak * config: Fantomas.Core.FormatConfig -> string
val printfn: format: Printf.TextWriterFormat<'T> -> 'T
static member Ast.ConstantExpr: value: string -> WidgetBuilder<Fantomas.Core.SyntaxOak.Expr>
static member Ast.ConstantExpr: value: WidgetBuilder<Fantomas.Core.SyntaxOak.Constant> -> WidgetBuilder<Fantomas.Core.SyntaxOak.Expr>
static member Ast.Attribute: value: string * expr: string -> WidgetBuilder<Fantomas.Core.SyntaxOak.AttributeNode>
static member Ast.Attribute: value: string * expr: WidgetBuilder<Fantomas.Core.SyntaxOak.Constant> -> WidgetBuilder<Fantomas.Core.SyntaxOak.AttributeNode>
static member Ast.Attribute: value: string * expr: WidgetBuilder<Fantomas.Core.SyntaxOak.Expr> -> WidgetBuilder<Fantomas.Core.SyntaxOak.AttributeNode>
static member Ast.Attribute: value: string -> WidgetBuilder<Fantomas.Core.SyntaxOak.AttributeNode>

Type something to start searching.