Namespaces

Contents

• Overview
• Basic Usage
• Implicit Namespaces
• Global Namespace
• Multiple Modules in a Namespace
• Multiple Namespaces
• Recursive Namespaces

Overview

Namespaces in F# are a way to organize code by grouping related types and modules. They help prevent naming conflicts and provide a hierarchical structure for organizing code. Unlike modules, namespaces can be split across multiple files and assemblies.

Basic Usage

Create a namespace with the Namespace widget:

#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")) }
    }
}
|> Gen.mkOak
|> Gen.run
|> printfn "%s"

// produces the following code:

namespace Widgets

type MyWidget1 =
    member this.WidgetName = "Widget1"

module WidgetsModule =
    let widgetName = "Widget2"

Implicit Namespaces

Implicit namespaces are created using the toImplicit modifier:

Oak() {
    Namespace("Widgets.WidgetModule") {
        Function(
            "widgetFunction",
            [ ParameterPat("x"); ParameterPat("y") ],
            AppExpr("printfn", [ String("%A %A"); String("x"); String("y") ])
        )
    }
    |> _.toImplicit()
}
|> Gen.mkOak
|> Gen.run
|> printfn "%s"

// produces the following code:

module Widgets.WidgetModule

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

Global Namespace

The global namespace can be accessed using the GlobalNamespace widget:

Oak() { GlobalNamespace() { TypeDefn("MyClass", UnitPat()) { Member("this.Prop1", String("X")) } } }
|> Gen.mkOak
|> Gen.run
|> printfn "%s"

// produces the following code:

namespace global

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

Multiple Modules in a Namespace

A namespace can contain multiple modules:

Oak() {
    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) ]) ]
                )
            )
        }
    }
}
|> Gen.mkOak
|> Gen.run
|> printfn "%s"

// produces the following code:

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

Multiple Namespaces

Namespaces can be nested to create a hierarchical structure:

Oak() {
    Namespace("Outer") {
        TypeDefn("MyClass", UnitPat()) {
            Member("this.X", ParenPat(ParameterPat(ConstantPat(Constant "x"))), InfixAppExpr("p", "+", Int(1)))
        }
    }

    Namespace("Outer.Inner") { TypeDefn("MyClass", UnitPat()) { Member("this.Prop1", String("X")) } }
}
|> Gen.mkOak
|> Gen.run
|> printfn "%s"

// produces the following code:

namespace Outer

type MyClass() =
    member this.X(x) = p + 1
namespace Outer.Inner

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

Recursive Namespaces

Create recursive namespaces with the toRecursive method. This is useful when types and modules within need to reference each other:

Oak() {
    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" ]),
                returnType = LongIdent("PeelState list"),
                hasGetter = true,
                hasSetter = true
            )

            Member("self.Peel", UnitPat(), "BananaHelpers.peel")

            Member("self.SqueezeJuiceOut", UnitPat(), "raise (DontSqueezeTheBananaException self)")
        }

        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 ]
                )
            )
        }
    }
    |> _.toRecursive()
}
|> Gen.mkOak
|> Gen.run
|> printfn "%s"

// produces the following code:

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

    member self.SqueezeJuiceOut() =
        raise (DontSqueezeTheBananaException self)

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