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

>>> render (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

>>> render (Op "+" (Int 5) (Int 6))
"5 + 6"

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

A let...in block

>>> render (let_ (var "a") [(var "a", Int 5)])
"let
     a = 5
 in
     a"

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

A case...of block

>>> render (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

>>> render (tvar "Nothing")
"Nothing"

>>> render (tvar "a")
"a"

tparam :: String -> Type -> Type

A type with a single paramater

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

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

A type with multiple paramaters

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

tapp :: [Type] -> Type

Type application

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

tunit :: Type

A zero item tuple type

>>> render tunit
"()"

ttuple :: [Type] -> Type

A multiple item tuple

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

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

A record type

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

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

A paramaterized record type

>>> render (trecord "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