Classes

Classes are types that represent objects that can have properties, methods, and events. For details on how the AST node works, please refer to the Fantomas Core documentation. See also official documentation for a comparison between the two.

Constructors

Modifiers

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

open Fabulous.AST
open type Fabulous.AST.Ast

Oak() {
    AnonymousModule() {
        TypeDefn(
            "MyClass1",
            Constructor(
                ParenPat(
                    TuplePat(
                        [ ParameterPat(ConstantPat(Constant("x")), Int())
                          ParameterPat(ConstantPat(Constant("y")), Int()) ]
                    )
                )
            )
        ) {
            DoExpr(AppExpr(" printfn", [ String("%d %d"); Constant("x"); Constant("y") ]))

            Constructor(
                ParenPat(TuplePat([ Constant("0"); Constant("0") ])),
                AppExpr("MyClass1", ParenExpr(TupleExpr([ Constant("0"); Constant("0") ])))
            )
        }
        |> _.triviaBefore(SingleLine("Constructors"))

        TypeDefn("MyClass2", Constructor(ParenPat(TuplePat([ ParameterPat(ConstantPat(Constant("dataIn")), Int()) ])))) {
            LetBindings([ Value("data", "dataIn") ])
            DoExpr(AppExpr(" self.PrintMessage", ConstantUnit()))

            Member(
                "this.PrintMessage()",
                AppExpr("printf", [ String("Creating MyClass2 with Data %d"); Constant("data") ])
            )
        }

        Open("System.IO")

        TypeDefn("Folder", ParenPat(ParameterPat("pathIn", String()))) {
            LetBindings(
                [ Value("path", "pathIn")
                  Value("filenameArray", AppExpr("Directory.GetFiles", ParenExpr("path")))
                      .returnType(Array(String())) ]
            )

            Member(
                "this.FileArray",
                AppExpr(
                    OptVarExpr("Array.map"),
                    [ ParenLambdaExpr("elem", NewExpr("File", ParenExpr(TupleExpr([ "elem"; "this" ]))))
                      ConstantExpr "filenameArray" ]
                )
            )
        }

        TypeDefn(
            "File",
            ParenPat(
                TuplePat(
                    [ ParameterPat("filename", String())
                      ParameterPat("containingFolder", "Folder") ]
                )
            )
        ) {
            LetBindings([ Value("name", "filename") ])
            Member("this.ContainingFolder", "containingFolder")
        }
        |> _.toRecursive()

        Value("folder1", NewExpr("Folder", ParenExpr("C:/")))

        ForEachDoExpr(
            "file",
            "folder1.FileArray",
            AppExpr("printfn", [ ConstantExpr(String("File: %s")); OptVarExpr("file.Name") ])
        )

        TypeDefn(
            "Person2",
            Constructor(
                ParenPat(
                    TuplePat(
                        [ ParameterPat(ConstantPat(Constant("name")), String())
                          ParameterPat(ConstantPat(Constant("lastName")), String())
                          ParameterPat(ConstantPat(Constant("?age")), Int()) ]
                    )
                )
            )
        ) {
            Member(ConstantPat(Constant("this.Name")), ConstantExpr(Constant "name"))
        }

        TypeDefn("Person3", UnitPat()) { Member(ConstantPat(Constant("this.Name")), ConstantExpr(String "")) }
        |> _.typeParams(PostfixList([ "'a"; "'b" ]))

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

// produces the following code:

// Constructors
type MyClass1(x: int, y: int) =
    do printfn "%d %d" x y
    new(0, 0) = MyClass1 (0, 0)

type MyClass2(dataIn: int) =
    let data = dataIn
    do self.PrintMessage ()
    member this.PrintMessage() = printf "Creating MyClass2 with Data %d" data

open System.IO

type Folder(pathIn: string) =
    let path = pathIn
    let filenameArray: string[] = Directory.GetFiles (path)

    member this.FileArray = Array.map (fun elem -> new File(elem, this)) filenameArray

and File(filename: string, containingFolder: Folder) =
    let name = filename
    member this.ContainingFolder = containingFolder

let folder1 = new Folder(C:/)

for file in folder1.FileArray do
    printfn "File: %s" file.Name

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

type Person3<'a, 'b>() =
    member this.Name = ""