Namespaces

For details on how the AST node works, please refer to the Fantomas documentation. See also official documentation for a comparison between the two.

Constructors

Modifier Functions

#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

Oak() {
    Namespace("Widgets") {
        TypeDefn("MyWidget1") { Member("this.WidgetName", String("Widget1")) }

        Module("WidgetsModule") { Value("widgetName", String("Widget2")) }
    }
    |> _.triviaBefore(SingleLine("Namespace"))
    |> _.triviaAfter(Newline())

    Namespace("Widgets.WidgetModule") {
        Function(
            "widgetFunction",
            [ ParameterPat("x"); ParameterPat("y") ],
            AppExpr("printfn", [ String("%A %A"); String("x"); String("y") ])
        )
    }
    |> _.toImplicit()
    |> _.triviaBefore(SingleLine("Implicit Namespace"))
    |> _.triviaAfter(Newline())

    Namespace("Widgets") {
        Module("WidgetModule1") {
            Function(
                "widgetFunction",
                [ ParameterPat("x"); ParameterPat("y") ],
                AppExpr("printfn", [ String("Module1 %A %A"); String("x"); String("y") ])
            )
        }

        Module("WidgetModule2") {
            Function(
                "widgetFunction",
                [ ParameterPat("x"); ParameterPat("y") ],
                AppExpr("printfn", [ String("Module2 %A %A"); String("x"); String("y") ])
            )
        }

        Module("useWidgets") {
            SingleExpr(
                "do",
                CompExprBodyExpr(
                    [ AppExpr("WidgetModule1.widgetFunction", [ Int(10); Int(20) ])
                      AppExpr("WidgetModule2.widgetFunction", [ Int(5); Int(6) ]) ]
                )
            )
        }
    }
    |> _.triviaBefore(SingleLine("Multiple Modules"))
    |> _.triviaAfter(Newline())

    Namespace("Widgets") {
        TypeDefn("MyWidget1") { Member("this.WidgetName", String("Widget1")) }

        Module("WidgetsModule") { Value("widgetName", String("Widget2")) }
    }
    |> _.triviaBefore(SingleLine("Namespace"))
    |> _.triviaAfter(Newline())

    Namespace("Outer") {
        TypeDefn("MyClass", UnitPat()) {
            Member("this.X", ParenPat(ParameterPat(ConstantPat(Constant "x"))), InfixAppExpr("p", "+", Int(1)))
        }
        |> _.triviaBefore(SingleLine("Full name: Outer.MyClass"))
    }
    |> _.triviaBefore(SingleLine("Nested Namespaces"))
    |> _.triviaAfter(Newline())

    Namespace("Outer.Inner") { TypeDefn("MyClass", UnitPat()) { Member("this.Prop1", String("X")) } }
    |> _.triviaBefore(SingleLine("Full name: Outer.Inner.MyClass"))
    |> _.triviaAfter(Newline())

    GlobalNamespace() { TypeDefn("MyClass", UnitPat()) { Member("this.Prop1", String("X")) } }
    |> _.triviaBefore(SingleLine("Global Namespace"))
    |> _.triviaAfter(Newline())

    AnonymousModule() { Value("x", ConstantExpr(Int(3))) }
    |> _.triviaBefore(SingleLine("Anonymous Module"))
    |> _.triviaAfter(Newline())

    Namespace("MutualReferences") {
        Union("Orientation") {
            UnionCase("Up")
            UnionCase("Down")
        }

        Union("PeelState") {
            UnionCase("Peeled")
            UnionCase("Unpeeled")
        }

        ExceptionDefn("DontSqueezeTheBananaException", Field("Banana"))

        TypeDefn("Banana", Constructor(ParenPat(ParameterPat("orientation", LongIdent("Orientation"))))) {
            MemberVal("IsPeeled", Bool(false), true, true)
            MemberVal("Orientation", "orientation", true, true)

            MemberVal("Sides", ListExpr([ "PeelState"; "Unpeeled" ]), true, true)
                .returnType(LongIdent "PeelState list")

            Member("self.Peel", UnitPat(), "BananaHelpers.peel")
                .triviaAfter(LineCommentAfterSourceCode("Note the dependency on the BananaHelpers module."))

            Member("self.SqueezeJuiceOut", UnitPat(), "raise (DontSqueezeTheBananaException self)")
                .triviaAfter(LineCommentAfterSourceCode("This member depends on the exception above."))
        }

        Module("BananaHelpers") {
            Function(
                "peel",
                [ ParenPat(ParameterPat("b", "Banana")) ],
                CompExprBodyExpr(
                    [ Function(
                          "flip",
                          [ ParenPat(ParameterPat("banana", "Banana")) ],
                          MatchExpr(
                              "banana.Orientation",
                              [ MatchClauseExpr(
                                    "Up",
                                    CompExprBodyExpr(
                                        [ LongIdentSetExpr("banana.Orientation", "Down"); ConstantExpr("banana") ]
                                    )
                                )

                                MatchClauseExpr("Down", "banana") ]
                          )
                      )
                      |> LetOrUseExpr

                      Function(
                          "peelSides",
                          [ ParenPat(ParameterPat("banana", "Banana")) ],
                          InfixAppExpr(
                              "banana.Sides",
                              "|>",
                              MatchLambdaExpr(
                                  [ MatchClauseExpr("Unpeeled", "Peeled"); MatchClauseExpr("Peeled", "Peeled") ]
                              )
                          )
                      )
                      |> LetOrUseExpr

                      MatchExpr(
                          "b.Orientation",
                          [ MatchClauseExpr("Up", SameInfixAppsExpr("b", [ ("|>", "flip"); ("|>", "peelSides") ]))

                            MatchClauseExpr("Down", InfixAppExpr("b", "|>", "peelSides")) ]
                      )
                      |> OtherExpr ]
                )
            )
        }
        |> _.triviaBefore(Newline())
        |> _.triviaBefore(SingleLine("Mutual References"))
        |> _.triviaAfter(Newline())
        |> _.triviaAfter(
            BlockComment(
                """
Note that the exception DontSqueezeTheBananaException and the class Banana both refer to each other.
Additionally, the module BananaHelpers and the class Banana also refer to each other.
This wouldn't be possible to express in F# if you removed the rec keyword from the MutualReferences namespace.
"""
            )
        )

    }
    |> _.toRecursive()
    |> _.triviaBefore(SingleLine("Recursive Namespace"))
    |> _.triviaAfter(Newline())

}
|> Gen.mkOak
|> Gen.run
|> printfn "%s"

// produces the following code:

// Namespace
namespace Widgets

type MyWidget1 =
    member this.WidgetName = "Widget1"

module WidgetsModule =
    let widgetName = "Widget2"


// Implicit Namespace
module Widgets.WidgetModule

let widgetFunction x y = printfn "%A %A" "x" "y"


// Multiple Modules
namespace Widgets

module WidgetModule1 =
    let widgetFunction x y = printfn "Module1 %A %A" "x" "y"

module WidgetModule2 =
    let widgetFunction x y = printfn "Module2 %A %A" "x" "y"

module useWidgets =
    do
        WidgetModule1.widgetFunction 10 20
        WidgetModule2.widgetFunction 5 6


// Namespace
namespace Widgets

type MyWidget1 =
    member this.WidgetName = "Widget1"

module WidgetsModule =
    let widgetName = "Widget2"


// Nested Namespaces
namespace Outer
// Full name: Outer.MyClass
type MyClass() =
    member this.X(x) = p + 1


// Full name: Outer.Inner.MyClass
namespace Outer.Inner

type MyClass() =
    member this.Prop1 = "X"


// Global Namespace
namespace global

type MyClass() =
    member this.Prop1 = "X"


// Anonymous Module
let x = 3


// Recursive Namespace
namespace rec MutualReferences

type Orientation =
    | Up
    | Down

type PeelState =
    | Peeled
    | Unpeeled

exception DontSqueezeTheBananaException of Banana

type Banana(orientation: Orientation) =
    member val IsPeeled = false with get, set
    member val Orientation = orientation with get, set
    member val Sides: PeelState list = [ PeelState; Unpeeled ] with get, set
    member self.Peel() = BananaHelpers.peel // Note the dependency on the BananaHelpers module.

    member self.SqueezeJuiceOut() =
        raise (DontSqueezeTheBananaException self) // This member depends on the exception above.

// Mutual References
module BananaHelpers =
    let peel (b: Banana) =
        let flip (banana: Banana) =
            match banana.Orientation with
            | Up ->
                banana.Orientation <- Down
                banana
            | Down -> banana

        let peelSides (banana: Banana) =
            banana.Sides
            |> function
                | Unpeeled -> Peeled
                | Peeled -> Peeled

        match b.Orientation with
        | Up -> b |> flip |> peelSides
        | Down -> b |> peelSides

(*
Note that the exception DontSqueezeTheBananaException and the class Banana both refer to each other.
Additionally, the module BananaHelpers and the class Banana also refer to each other.
This wouldn't be possible to express in F# if you removed the rec keyword from the MutualReferences namespace.
*)