Module

Tidy.Codegen

Package
purescript-tidy-codegen
Repository
natefaubion/purescript-tidy-codegen

#PrintOptions Source

type PrintOptions = { importWrap :: ImportWrapOption, indentUnit :: String, indentWidth :: Int, operators :: Lazy PrecedenceMap, pageWidth :: Int, ribbonRatio :: Number, typeArrowPlacement :: TypeArrowOption, unicode :: UnicodeOption }

#printModule Source

printModule :: Module Void -> String

Pretty-prints a module using default format options.

exampleSource = printModule myModule

#printModuleWithOptions Source

printModuleWithOptions :: PrintOptions -> Module Void -> String

Pretty-prints a module given a set of options. Use defaultPrintOptions and override as necessary.

exampleSource = printModule
  defaultPrintOptions
    { indentUnit = "    "
    , indentWidth = 4
    , unicode = UnicodeAlways
    }
  myModule

#DeclInstance Source

class DeclInstance a e | a -> e where

Members

  • declInstance :: forall className. ToQualifiedName className Proper => Maybe (Name Ident) -> Array (Type e) -> className -> Array (Type e) -> Array (InstanceBinding e) -> a

    An overloaded constructor for instances. Can be used to construct a declaration directly, or within an instance chain.

    exampleDecl =
  declInstance Nothing [] "Functor" [ typeApp (typeCtor "Maybe") [ typeVar "a" ] ]
    [ instValue "map" [ binderVar "f" ]
        ( exprCase [ exprSection ]
            [ caseBranch [ binderCtor "Just" [ binderVar "a" ] ]
                (exprApp (exprCtor "Just") [ exprApp (exprIdent "f") [ exprIdent "a" ] ])
            , caseBranch [ binderCtor "Nothing" [] ]
                (exprCtor "Nothing")
            ]
        )
    ]

Instances

#TypeVar Source

class TypeVar a e | a -> e where

Overloaded constructors for type variables. This can be used to construct not only CST.Type, but also type variable bindings in typeForall and data, newtype, type, and class declarations.

exampleDecl =
  declType "Id" [ typeVarKinded "a" (typeCtor "Type") ]
    (typeVar "a")

Members

Instances

#binaryOp Source

binaryOp :: forall name b. ToQualifiedName name Operator => name -> b -> BinaryOp b

An overloaded binary operator constructor. Use with exprOp, typeOp, or binderOp.

exampleExpr =
  exprOp (exprInt 4)
    [ binaryOp "+" (exprIdent "a")
    , binaryOp "/" (exprIdent "b")
    ]

#binderArray Source

binderArray :: forall e. Array (Binder e) -> Binder e

Constructs an array literal binding pattern.

#binderBool Source

binderBool :: forall e. Boolean -> Binder e

Constructs a boolean literal binding pattern.

#binderChar Source

binderChar :: forall e. Char -> Binder e

Constructs a char literal binding pattern.

#binderCtor Source

binderCtor :: forall e name. ToQualifiedName name Proper => name -> Array (Binder e) -> Binder e

Constructs a constructor binding pattern.

#binderInt Source

binderInt :: forall e. Int -> Binder e

Constructs an int literal binding pattern.

#binderNamed Source

binderNamed :: forall e name. ToName name Ident => name -> Binder e -> Binder e

Constructs a named binding pattern (@).

#binderNumber Source

binderNumber :: forall e. Number -> Binder e

Constructs a number literal binding pattern.

#binderOp Source

binderOp :: forall e. Binder e -> Array (BinaryOp (Binder e)) -> Binder e

Constructs an operator binding pattern.

#binderParens Source

binderParens :: forall e. Binder e -> Binder e

Wraps a binding pattern in parens.

#binderRecord Source

binderRecord :: forall e field. ToRecordLabeled field (Binder e) => Array field -> Binder e

Constructs a record literal binding pattern.

#binderString Source

binderString :: forall e. String -> Binder e

Constructs a string literal binding pattern.

#binderTyped Source

binderTyped :: forall e. Binder e -> Type e -> Binder e

Constructs a typed binding pattern.

#binderVar Source

binderVar :: forall e name. ToName name Ident => name -> Binder e

Constructs a variable binding pattern.

#binderWildcard Source

binderWildcard :: forall e. Binder e

Constructs a wildcard (_) binding pattern.

exampleExpr =
  exprLambda [ binderWildcard ]
    (exprApp (exprIdent "countDown") [ exprInt 100 ])

#blockComment Source

blockComment :: forall a. String -> Array (Comment a)

Constructs a block comment.

#caseBranch Source

caseBranch :: forall e f branch. ToNonEmptyArray f => ToGuarded branch e => f (Binder e) -> branch -> Tuple (Separated (Binder e)) (Guarded e)

Constructs a case branch for use with exprCase. See exprCase.

#classMember Source

classMember :: forall e name. ToName name Ident => name -> Type e -> ClassMember e

Constructs a class member signature. See declClass.

#dataCtor Source

dataCtor :: forall e name. ToName name Proper => name -> Array (Type e) -> DataCtor e

Constructs a data constructor variant. See declData.

#declClass Source

declClass :: forall e name. ToName name Proper => Array (Type e) -> name -> Array (TypeVarBinding (Name Ident) e) -> Array ClassFundep -> Array (ClassMember e) -> Declaration e

Constructs a class declaration.

exampleDecl =
  declClass [ typeApp (typeCtor "Eq") [ typeVar "a" ] ] "Ord" [ typeVar "a" ] []
    [ classMember "compare"
        (typeArrow [ typeVar "a", typeVar "a" ] (typeCtor "Ordering"))
    ]

#declClassSignature Source

declClassSignature :: forall e a. ToName a Proper => a -> Type e -> Declaration e

Constructs a kind signature for a class declaration.

#declData Source

declData :: forall e name. ToName name Proper => name -> Array (TypeVarBinding (Name Ident) e) -> Array (DataCtor e) -> Declaration e

Constructs a data declaration.

exampleDecl =
  declData "Either" [ typeVar "a", typeVar "b" ]
    [ dataCtor "Left" [ typeVar "a" ]
    , dataCtor "Right" [ typeVar "b" ]
    ]

#declDataSignature Source

declDataSignature :: forall e a. ToName a Proper => a -> Type e -> Declaration e

Constructs a kind signature for a data declaration.

#declDerive Source

declDerive :: forall e className. ToQualifiedName className Proper => Maybe (Name Ident) -> Array (Type e) -> className -> Array (Type e) -> Declaration e

Constructs an instance deriving declaration.

exampleDecl =
  declDerive Nothing [] "Eq" [ typeCtor "UserId" ]

#declDeriveNewtype Source

declDeriveNewtype :: forall e className. ToQualifiedName className Proper => Maybe (Name Ident) -> Array (Type e) -> className -> Array (Type e) -> Declaration e

Constructs a newtype instance deriving declaration.

exampleDecl =
  declDeriveNewtype Nothing [] "Eq" [ typeCtor "UserId" ]

#declForeign Source

declForeign :: forall e name. ToName name Ident => name -> Type e -> Declaration e

Constructs a foreign import declaration.

#declForeignData Source

declForeignData :: forall e name. ToName name Proper => name -> Type e -> Declaration e

Constructs a foreign data import declaration.

#declImport Source

declImport :: forall e name. ToName name ModuleName => name -> Array (Import e) -> ImportDecl e

Constructs an import declaration with selective imports. Providing no named imports results in an open import.

#declImportAs Source

declImportAs :: forall e as name. ToName name ModuleName => ToName as ModuleName => name -> Array (Import e) -> as -> ImportDecl e

Constructs a qualified import declaration.

#declImportHiding Source

declImportHiding :: forall e name. ToName name ModuleName => name -> Array (Import e) -> ImportDecl e

Constructs a hiding import declaration.

#declImportHidingAs Source

declImportHidingAs :: forall e as name. ToName name ModuleName => ToName as ModuleName => name -> Array (Import e) -> as -> ImportDecl e

Constructs a qualified hiding import declaration.

#declInfix Source

declInfix :: forall e name op. ToFixityName name => ToName op Operator => Fixity -> Int -> name -> op -> Declaration e

Constructs an fixity declaration for a value operator.

exampleDecl =
  declInfix Infixl 4 "map" "<$>"

#declInfixType Source

declInfixType :: forall e name op. ToQualifiedName name Proper => ToName op Operator => Fixity -> Int -> name -> op -> Declaration e

Constructs an fixity declaration for a type operator.

exampleDecl =
  declInfix Infixr 0 "RowApply" "+"

#declInstanceChain Source

declInstanceChain :: forall e f. ToNonEmptyArray f => f (Instance e) -> Declaration e

Constructs an instance chain.

exampleDecl =
  declInstanceChain
    [ declInstance Nothing [] "IsTypeEqual"
        [ typeVar "a", typeVar "a", typeCtor "True" ]
        []
    , declInstance Nothing [] "IsTypeEqual"
        [ typeVar "a", typeVar "b", typeCtor "False" ]
        []
    ]

#declNewtype Source

declNewtype :: forall e name ctor. ToName name Proper => ToName ctor Proper => name -> Array (TypeVarBinding (Name Ident) e) -> ctor -> Type e -> Declaration e

Constructs a newtype declaration.

exampleDecl =
  declNewtype "UserId" [] "UserId" (typeCtor "String")

#declNewtypeSignature Source

declNewtypeSignature :: forall e a. ToName a Proper => a -> Type e -> Declaration e

Constructs a kind signature for a newtype declaration.

#declRole Source

declRole :: forall e f name. ToName name Proper => ToNonEmptyArray f => name -> f Role -> Declaration e

Constructs a role declaration.

#declSignature Source

declSignature :: forall e a. ToName a Ident => a -> Type e -> Declaration e

Constructs a type signature for a value declaration.

#declType Source

declType :: forall e name. ToName name Proper => name -> Array (TypeVarBinding (Name Ident) e) -> Type e -> Declaration e

Constructs a type synonym declaration.

exampleDecl =
  declType "UserFields" [ typeVar "r" ]
    ( typeRow
        [ Tuple "id" (typeCtor "UserId")
        , Tuple "name" (typeCtor "String")
        , Tuple "age" (typeCtor "Int")
        ]
        (Just (typeVar "r"))
    )

#declTypeSignature Source

declTypeSignature :: forall e a. ToName a Proper => a -> Type e -> Declaration e

Constructs a kind signature for a type synonym declaration.

#declValue Source

declValue :: forall e name guards. ToName name Ident => ToGuarded guards e => name -> Array (Binder e) -> guards -> Declaration e

Constructs a value declaration.

exampleDecl =
  declValue "countDown" [ binderVar "n" ]
    [ guardBranch [ guardExpr (exprOp (exprIdent "n") [ binaryOp ">" (exprInt 0) ]) ]
        ( exprApp (exprIdent "countDown")
            [ exprOp (exprIdent "n") [ binaryOp "-" (exprInt 1) ] ]
        )
    , guardBranch [ guardExpr (exprIdent "otherwise") ]
        (exprIdent "n")
    ]

#doBind Source

doBind :: forall e. Binder e -> Expr e -> DoStatement e

Constructs a do statement which binds it's return value.

exampleExpr =
  exprDo
    [ doBind (binderRecord [ "followers" ])
        (exprApp (exprIdent "getUser") [ exprIdent "user" ])
    ]
    ( exprApp (exprIdent "pure")
        [ exprIdent "followers" ]
    )

#doDiscard Source

doDiscard :: forall e. Expr e -> DoStatement e

Constructs a do statement which has no binder.

exampleExpr =
  exprDo
    [ doDiscard
        ( exprApp (exprIdent "logoutUser")
            [ exprIdent "user" ]
        )
    ]
    ( exprApp (exprIdent "pure")
        [ exprApp (exprIdent "httpStatus")
            [ exprInt 200 ]
        ]
    )

#doLet Source

doLet :: forall e f. ToNonEmptyArray f => f (LetBinding e) -> DoStatement e

Constructs a let binding context within a do expression.

exampleExpr =
  exprDo
    [ doLet
        [ letBinder (binderRecord [ "age" ])
            (exprIdent "user")
        ]
    ]
    (exprIdent "age")

#docComments Source

docComments :: String -> Array (Comment LineFeed)

Constructs documentation line comments (-- |).

#exportClass Source

exportClass :: forall e name. ToName name Proper => name -> Export e

Constructs a class export.

#exportModule Source

exportModule :: forall e name. ToName name ModuleName => name -> Export e

Constructs a module re-export.

#exportOp Source

exportOp :: forall e name. ToName name SymbolName => name -> Export e

Constructs a value operator export.

#exportType Source

exportType :: forall e name. ToName name Proper => name -> Export e

Constructs a type export.

#exportTypeAll Source

exportTypeAll :: forall e name. ToName name Proper => name -> Export e

Constructs a type export with all data members.

#exportTypeMembers Source

exportTypeMembers :: forall e name member. ToName name Proper => ToName member Proper => name -> Array member -> Export e

Constructs a type export with selective data members.

#exportTypeOp Source

exportTypeOp :: forall e name. ToName name SymbolName => name -> Export e

Constructs a type operator export.

#exportValue Source

exportValue :: forall e name. ToName name Ident => name -> Export e

Constructs a value export.

#exprAdo Source

exprAdo :: forall e. Array (DoStatement e) -> Expr e -> Expr e

Constructs an ado expression. Works just like exprDo.

#exprApp Source

exprApp :: forall e. Expr e -> Array (Expr e) -> Expr e

Constructs left-associated applications.

exampleExpr =
  exprApp (exprIdent "Map.lookup")
    [ exprIdent "userId"
    , exprIdent "users"
    ]

#exprArray Source

exprArray :: forall e. Array (Expr e) -> Expr e

Constructs an Array literal.

exampleExpr = exprArray
  [ exprInt 1
  , exprInt 2
  , exprInt 3
  ]

#exprBool Source

exprBool :: forall e. Boolean -> Expr e

Constructs a Boolean literal.

exampleExpr = exprBool true

#exprCase Source

exprCase :: forall e f g. ToNonEmptyArray f => ToNonEmptyArray g => f (Expr e) -> g (Tuple (Separated (Binder e)) (Guarded e)) -> Expr e

Constructs a case expression.

exampleExpr =
  exprCase [ exprIdent "xs" ]
    [ caseBranch [ binderCtor "List.Cons" [ binderVar "x", binderWildcard ] ]
        ( exprApp (exprCtor "Just")
            [ exprIdent "x"
            ]
        )
    , caseBranch [ binderCtor "Nothing" [] ]
        (exprCtor "Nothing")
    ]

#exprChar Source

exprChar :: forall e. Char -> Expr e

Constructs a Char literal while handling escaping.

exampleExpr = exprChar 'A'

#exprCtor Source

exprCtor :: forall e name. ToQualifiedName name Proper => name -> Expr e

An overloaded constructor for a value constructor, which may be qualified.

exampleExpr =
  exprApp (exprCtor "List.Cons")
    [ exprIdent "a"
    , exprCtor "List.Nil"
    ]

#exprDo Source

exprDo :: forall e. Array (DoStatement e) -> Expr e -> Expr e

Constructs a do expression.

exampleExpr =
  exprDo
    [ doBind (binderVar "followers")
        (exprApp (exprIdent "getFollowers") [ exprIdent "user" ])
    , doBind (binderVar "favorites")
        (exprApp (exprIdent "getFavorites") [ exprIdent "user" ])
    ]
    ( exprApp (exprIdent "pure")
        [ exprRecord [ "followers", "favorites" ] ]
    )

#exprDot Source

exprDot :: forall e label. ToName label Label => Expr e -> Array label -> Expr e

Constructs a record dot-accessor.

exampleExpr = exprDot (exprIdent "response") [ "body", "users" ]

#exprIdent Source

exprIdent :: forall e name. ToQualifiedName name Ident => name -> Expr e

An overloaded constructor for a value identifier, which may be qualified.

exampleExpr =
  exprApp (exprIdent "Map.lookup")
    [ exprIdent "userId"
    , exprIdent "users"
    ]

#exprIf Source

exprIf :: forall e. Expr e -> Expr e -> Expr e -> Expr e

Constructs an if-then-else expression.

exampleExpr =
  exprIf (exprApp (exprIdent "isLoggedIn") [ exprIdent "user" ])
    (exprIdent "renderPage")
    (exprApp (exprIdent "httpError") [ exprInt 400 ])

#exprInfix Source

exprInfix :: forall e. Expr e -> Array (Tuple (Expr e) (Expr e)) -> Expr e

Constructs left-associative infix expression applications.

exampleExpr =
  exprInfix (exprIdent "a")
    [ Tuple (exprIdent "append") (exprIdent "b")
    , Tuple (exprIdent "append") (exprIdent "c")
    ]

#exprInt Source

exprInt :: forall e. Int -> Expr e

Constructs an Int literal.

exampleExpr = exprInt 42

#exprIntHex Source

exprIntHex :: forall e. Int -> Expr e

Constructs an Int literal using hex notation.

exampleExpr = exprIntHex 0xFF0000

#exprLambda Source

exprLambda :: forall e. Array (Binder e) -> Expr e -> Expr e

Constructs a lambda expression.

exampleExpr =
  exprLambda [ binderVar "a", binderVar "b" ]
    ( exprOp (exprIdent "a")
        [ binaryOp "<>" (exprIdent "b") ]
    )

#exprLet Source

exprLet :: forall e. Array (LetBinding e) -> Expr e -> Expr e

Constructs a let expression.

exampleExpr =
  exprLet
    [ letSignature "countDown" (typeArrow [ typeCtor "Int" ] (typeCtor "Int"))
    , letValue "countDown" [ binderVar "n" ]
        [ guardBranch [ guardExpr (exprOp (exprIdent "n") [ binaryOp ">" (exprInt 0) ]) ]
            ( exprApp (exprIdent "countDown")
                [ exprOp (exprIdent "n") [ binaryOp "-" (exprInt 1) ] ]
            )
        , guardBranch [ guardExpr (exprIdent "otherwise") ]
            (exprIdent "n")
        ]
    ]
    (exprApp (exprIdent "countDown") [ exprInt 100 ])

#exprNegate Source

exprNegate :: forall e. Expr e -> Expr e

Constructs unary negation.

#exprNumber Source

exprNumber :: forall e. Number -> Expr e

Constructs a Number literal.

exampleExpr = exprNumber 1.618

#exprOp Source

exprOp :: forall e. Expr e -> Array (BinaryOp (Expr e)) -> Expr e

Constructors binary operator applications. These may be grouped by the pretty-printer based on precedence.

exampleExpr =
  exprOp (exprString "string")
    [ binaryOp "/\\" (exprInt 42)
    , binaryOp "/\\" (exprBool false)
    ]

#exprOpName Source

exprOpName :: forall e name. ToQualifiedName name SymbolName => name -> Expr e

Overloaded constructor for an expression operator's symbolic identifier (wrapping it in parens).

exampleExpr = exprOpName "(<>)"

#exprParens Source

exprParens :: forall e. Expr e -> Expr e

Wraps an expression in parens.

#exprRecord Source

exprRecord :: forall e field. ToRecordLabeled field (Expr e) => Array field -> Expr e

Constructs a Record literal.

exampleExpr = exprRecord
  [ Tuple "id" (exprIdent "userId")
  , Tuple "name" (exprIdent "userName")
  , Tuple "age" (exprIdent "userAge")
  ]

#exprSection Source

exprSection :: forall e. Expr e

Constructs an expression section (_). This is meaningless and will produce invalid syntax when used arbitrarily. Pair with appropriate constructors like exprCase or exprDot.

#exprString Source

exprString :: forall e. String -> Expr e

Constructs a String literal while handling escaping.

exampleExpr = exprString "string"

#exprTypeApp Source

exprTypeApp :: forall e. Expr e -> Array (Type e) -> Array (Expr e) -> Expr e

Constructs left-associated applications, with optional type applications.

  exampleExpr =
    exprTypeApp (exprIdent "Map.lookup")
      [ typeCtor "String"
      , typeApp (typeCtor "Maybe") [ typeCtor "User" ]
      ]
      [ exprIdent "userId"
      , exprIdent "users"
      ]

#exprTyped Source

exprTyped :: forall e. Expr e -> Type e -> Expr e

Constructs an expression with a type annotation.

exampleExpr = exprTyped (exprInt 42) (typeCtor "Int")

#exprUpdate Source

exprUpdate :: forall e. Expr e -> Array (RecordUpdate e) -> Expr e

Constructs a record update.

exampleExpr =
  exprUpdate (exprIdent "user")
    [ update "age" (exprInt 42)
    , updateNested "phone"
        [ update "countryCode" (exprInt 1)
        ]
    ]

#exprWhere Source

exprWhere :: forall e. Expr e -> Array (LetBinding e) -> Where e

Constructs a where let binding context. This can be used anywhere that takes a ToWhere or ToGuarded constraint, such as in value bindings, case branches, and guards.

exampleDecl =
  declValue "getName" [ binderVar "user" ]
    ( exprWhere (exprIdent "name")
        [ letBinder (binderRecord [ "name" ])
            (exprIdent "user")
        ]
    )

#guardBinder Source

guardBinder :: forall e. Binder e -> Expr e -> PatternGuard e

Constructs a guard expression that binds a value.

#guardBranch Source

guardBranch :: forall e f expr. ToNonEmptyArray f => ToWhere expr e => f (PatternGuard e) -> expr -> GuardedBranch e

Constructs a guarded branch in a value binding or case expressions. This can be used anwhere that takes a ToGuarded constraint.

exampleDecl =
  declValue "countDown" [ binderVar "n" ]
    [ guardBranch [ guardExpr (exprOp (exprIdent "n") [ binaryOp ">" (exprInt 0) ]) ]
        ( exprApp (exprIdent "countDown")
            [ exprOp (exprIdent "n") [ binaryOp "-" (exprInt 1) ] ]
        )
    , guardBranch [ guardExpr (exprIdent "otherwise") ]
        (exprIdent "n")
    ]

#guardExpr Source

guardExpr :: forall e. Expr e -> PatternGuard e

Constructs a guard expression that does not bind anything.

#importClass Source

importClass :: forall e name. ToName name Proper => name -> Import e

Constructs a class import.

#importOp Source

importOp :: forall e name. ToName name SymbolName => name -> Import e

Constructs a value operator import.

#importType Source

importType :: forall e name. ToName name Proper => name -> Import e

Constructs a type import.

#importTypeAll Source

importTypeAll :: forall e name. ToName name Proper => name -> Import e

Constructs a type import with all data members.

#importTypeMembers Source

importTypeMembers :: forall e name member. ToName name Proper => ToName member Proper => name -> Array member -> Import e

Constructs a type import with selective data members.

#importTypeOp Source

importTypeOp :: forall e name. ToName name SymbolName => name -> Import e

Constructs a type operator import.

#importValue Source

importValue :: forall e name. ToName name Ident => name -> Import e

Constructs a value import.

#instSignature Source

instSignature :: forall e a. ToName a Ident => a -> Type e -> InstanceBinding e

Constructs an signature for an instance binding.

#instValue Source

instValue :: forall e a b. ToName a Ident => ToGuarded b e => a -> Array (Binder e) -> b -> InstanceBinding e

Constructs an instance value binding. See declInstance.

#leading Source

leading :: forall a. OverLeadingComments a => Array (Comment LineFeed) -> a -> a

Attaches leading comments to a CST node.

#letBinder Source

letBinder :: forall e rhs. ToWhere rhs e => Binder e -> rhs -> LetBinding e

Constructs a value binding with a left-hand-side pattern binder.

exampleExpr =
  exprLet
    [ letBinder (binderRecord [ "name" ])
        (exprIdent "user")
    ]
    (exprIdent "name")

#letSignature Source

letSignature :: forall e name. ToName name Ident => name -> Type e -> LetBinding e

Constructs a type signature in a let binding context. See exprLet.

#letValue Source

letValue :: forall e name rhs. ToName name Ident => ToGuarded rhs e => name -> Array (Binder e) -> rhs -> LetBinding e

Constructs a value binding in a let binding context. See exprLet.

#lineBreaks Source

lineBreaks :: Int -> Array (Comment LineFeed)

Constructs line break annotations.

#lineComments Source

lineComments :: String -> Array (Comment LineFeed)

Constructs line comments (--).

#module_ Source

module_ :: forall e name. ToName name ModuleName => name -> Array (Export e) -> Array (ImportDecl e) -> Array (Declaration e) -> Module e

Constructs a module.

#spaces Source

spaces :: forall a. Int -> Array (Comment a)

Constructs space annotations.

#trailing Source

trailing :: forall a trl. OverTrailingComments a trl => a -> Array (Comment trl) -> a

Attaches trailing comments to a CST node.

#typeApp Source

typeApp :: forall e. Type e -> Array (Type e) -> Type e

Constructs left-associated applications.

exampleType =
  typeApp (typeCtor "Map")
    [ typeCtor "UserId"
    , typeCtor "User"
    ]

#typeArrow Source

typeArrow :: forall e. Array (Type e) -> Type e -> Type e

Constructs right-associated function arrows.

exampleType =
  typeArrow
    [ typeCtor "UserId"
    , typeCtor "String"
    , typeCtor "Int"
    ]
    (typeCtor "User")

#typeArrowName Source

typeArrowName :: forall e. Type e

The function arrow's symbolic identifier ((->)).

#typeConstrained Source

typeConstrained :: forall e. Array (Type e) -> Type e -> Type e

Constructs right-associated constraint arrows.

exampleType =
  typeForall [ typeVar "f", typeVar "a" ]
    ( typeConstrained
        [ typeApp (typeCtor "Functor") [ typeVar "f" ]
        , typeApp (typeCtor "Show") [ typeVar "a" ]
        ]
        ( typeArrow
            [ typeApp (typeVar "f")
                [ typeVar "a" ]
            ]
            ( typeApp (typeVar "f")
                [ typeCtor "String" ]
            )
        )
    )

#typeCtor Source

typeCtor :: forall e name. ToQualifiedName name Proper => name -> Type e

An overloaded constructor for a proper type name.

exampleType = typeApp (typeCtor "Maybe") [ typeCtor "Int" ]

#typeForall Source

typeForall :: forall e. Array (TypeVarBinding (Prefixed (Name Ident)) e) -> Type e -> Type e

Constructs a forall given type variable bindings.

exampleType =
  typeForall [ typeVar "a" ]
    (typeArrow [ typeVar "a" ] (typeVar "a"))

#typeKinded Source

typeKinded :: forall e. Type e -> Type e -> Type e

Constructs a type with a kind annotation.

exampleType =
  typeKinded (typeCtor "Maybe")
    (typeArrow [ typeCtor "Type" ] (typeCtor "Type"))

#typeOp Source

typeOp :: forall e. Type e -> Array (BinaryOp (Type e)) -> Type e

Constructs binary operator applications. These may be grouped by the pretty-printer based on precedence.

exampleType =
  typeOp (typeCtor "String")
    [ binaryOp "/\\" (typeCtor "Int")
    , binaryOp "/\\" (typeCtor "Boolean")
    ]

#typeOpName Source

typeOpName :: forall e name. ToQualifiedName name SymbolName => name -> Type e

Overloaded constructor for a type operator's symbolic identifier (wrapping it in parens), which may be qualified.

exampleType = typeOpName "(~>)"

#typeParens Source

typeParens :: forall e. Type e -> Type e

Wraps a type in parens.

#typeRecord Source

typeRecord :: forall e label. ToName label Label => Array (Tuple label (Type e)) -> Maybe (Type e) -> Type e

An overloaded constructor for a record type.

exampleType = typeRecord
  [ Tuple "id" (typeCtor "UserId")
  , Tuple "name" (typeCtor "String")
  , Tuple "age" (typeCtor "Int")
  ]
  (Just (typeVar "r"))

#typeRecordEmpty Source

typeRecordEmpty :: forall e. Type e

The empty record type.

#typeRow Source

typeRow :: forall e label. ToName label Label => Array (Tuple label (Type e)) -> Maybe (Type e) -> Type e

An overloaded constructor for a row type.

exampleType = typeRow
  [ Tuple "id" (typeCtor "UserId")
  , Tuple "name" (typeCtor "String")
  , Tuple "age" (typeCtor "Int")
  ]
  (Just (typeVar "r"))

#typeRowEmpty Source

typeRowEmpty :: forall e. Type e

The empty row type.

#typeString Source

typeString :: forall e. String -> Type e

Constructs a type-level string while handling escaping.

exampleType = typeString "string"

#typeInt Source

typeInt :: forall e. Int -> Type e

Constructs a type-level int

exampleType = typeInt (-1)

#typeWildcard Source

typeWildcard :: forall e. Type e

A type wildcard (_).

#update Source

update :: forall e a. ToName a Label => a -> Expr e -> RecordUpdate e

Constructs an update for a field.

#updateNested Source

updateNested :: forall f e label. ToNonEmptyArray f => ToName label Label => label -> f (RecordUpdate e) -> RecordUpdate e

Constructs a nested update for a field.

Modules
Tidy.Codegen
Tidy.Codegen.Class
Tidy.Codegen.Common
Tidy.Codegen.Monad
Tidy.Codegen.Precedence
Tidy.Codegen.String
Tidy.Codegen.Types