Elm

Expressions

bool :: Bool -> Expr

A boolean literal

string :: String -> Expr

A string literal

int :: Int -> Expr

An integer literal

float :: Float -> Expr

A float literal

under :: Expr

An _ literal

var :: String -> Expr

A variable

app :: [Expr] -> Expr

Function application

>>> genStr (app [var "a", var "b", var "c"])
"a b c"

list :: [Expr] -> Expr

A list literal

op :: String -> Expr -> Expr -> Expr

Apply an operator to two sub expressions

>>> genStr (op "+" (int 5) (int 6))
"5 + 6"

let_ :: Expr -> [(Expr, Expr)] -> Expr

A let...in block

>>> putStrLn $ genStr (let_ (var "a") [(var "a", int 5)])
let
    a = 5
in
    a

case_ :: Expr -> [(Expr, Expr)] -> Expr

A case...of block

>>> :{
 putStrLn $ genStr
     (case_ (var "m")
         [ (app [var "Just", var "x"], var "x")
         , (var "Nothing", var "default")
         ])
:}
case m of
    Just x ->
        x

    Nothing ->
        default

parens :: Expr -> Expr

Wrap a sub expression in parens

Types

tvar :: String -> Type

A type or type variable

>>> genStr (tvar "Nothing")
"Nothing"

>>> genStr (tvar "a")
"a"

tparam :: String -> Type -> Type

A type with a single paramater

>>> genStr (tparam "Just" (tvar "a"))
"Just a"

tparams :: String -> [Type] -> Type

A type with multiple paramaters

>>> genStr (tparams "Result" [tvar "String", tvar "Int"])
"Result String Int"

tapp :: [Type] -> Type

Type application

>>> genStr (tapp [tvar "a", tvar "b", tvar "c"])
"a -> b -> c"

tunit :: Type

A zero item tuple type

>>> genStr tunit
"()"

ttuple :: [Type] -> Type

A multiple item tuple

>>> genStr (ttuple [tvar "a", tvar "b"])
"(a, b)"

trecord :: [(String, Type)] -> Type

A record type

>>> genStr (trecord [("a", tvar "Int"), ("b", tvar "String")])
"{ a : Int, b : String }"

trecordParam :: String -> [(String, Type)] -> Type

A paramaterized record type

>>> genStr (trecordParam "a" [("b", tvar "Int")])
"{ a | b : Int }"

Declerations

decVariable

Arguments

:: String

The variable name

-> Type

The variable's type

-> Expr

The variable's value

-> Dec

Declare a variable

decFunction

Arguments

:: String

The function name

-> Type

The function's type

-> [Expr]

The fuction's paramaters

-> Expr

The function's value

-> Dec

Declare a function

decType

Arguments

:: String

The type name

-> [String]

The type's type paramaters

-> [(String, [Type])]

The type's constructors

-> Dec

Declare a type

decTypeAlias

Arguments

:: String

The type alias' name

-> [String]

The type alias's type paramaters

-> Type

The type alias's type

-> Dec

Declare a type alias

Imports

select :: String -> ImportItem

Import an item

subSelect :: String -> [String] -> ImportItem

Import an item and some constructors

subSelectEvery :: String -> ImportItem

Import an item and all constructors

importSome :: [ImportItem] -> ImportExpr

Import all exports of a module

importEvery :: ImportExpr

Import some exports of a module

import_

Arguments

:: String

The name of the module to import

-> Maybe String

A possible alias to import the module as

-> Maybe ImportExpr

A possible set of items to expose

-> Import

Import a module

Module

module_

Arguments

:: String

The module name

-> ImportExpr

The module exports

-> [Import]

The module imports

-> [Dec]

The module decleration

-> Module

Generate a full module

Generation

renderModule :: Module -> (String, GenError)

Render a module, returning possible errors or warnings

render :: Module -> String

Render a module, throwing an error if there is an error or warnings