Morgan-Stanley / morphir-elm / Morphir.IR.Value

This module contains the building blocks of values in the Morphir IR.

Value

Value is the top level building block for data and logic. See the constructor functions below for details on each node type.


type Value a
    = Literal a Morphir.IR.Literal.Literal
    | Constructor a Morphir.IR.FQName.FQName
    | Tuple a (List (Value a))
    | List a (List (Value a))
    | Record a (List ( Morphir.IR.Name.Name, Value a ))
    | Variable a Morphir.IR.Name.Name
    | Reference a Morphir.IR.FQName.FQName
    | Field a (Value a) Morphir.IR.Name.Name
    | FieldFunction a Morphir.IR.Name.Name
    | Apply a (Value a) (Value a)
    | Lambda a (Pattern a) (Value a)
    | LetDefinition a Morphir.IR.Name.Name (Definition a) (Value a)
    | LetRecursion a (Dict Morphir.IR.Name.Name (Definition a)) (Value a)
    | Destructure a (Pattern a) (Value a) (Value a)
    | IfThenElse a (Value a) (Value a) (Value a)
    | PatternMatch a (Value a) (List ( Pattern a, Value a ))
    | UpdateRecord a (Value a) (List ( Morphir.IR.Name.Name, Value a ))
    | Unit a

Type that represents a value.

literal : a -> Morphir.IR.Literal.Literal -> Value a

A literal represents a fixed value in the IR. We only allow values of basic types: bool, char, string, int, float.

True -- Literal (BoolLiteral True)

'a' -- Literal (CharLiteral 'a')

"foo" -- Literal (StringLiteral "foo")

13 -- Literal (IntLiteral 13)

15.4 -- Literal (FloatLiteral 15.4)

constructor : a -> Morphir.IR.FQName.FQName -> Value a

A reference to a constructor of a custom type.

Nothing -- Constructor ( ..., [ [ "maybe" ] ], [ "nothing" ] )

Foo.Bar -- Constructor ( ..., [ [ "foo" ] ], [ "bar" ] )

apply : a -> Value a -> Value a -> Value a

Represents a function invocation. We use currying to represent function invocations with multiple arguments.

Note: Operators are mapped to well-known function names.

not True -- Apply (Reference ( ..., [ [ "basics" ] ], [ "not" ])) (Literal (BoolLiteral True))

True || False -- Apply (Apply (Reference ( ..., [ [ "basics" ] ], [ "and" ]))) (Literal (BoolLiteral True)) (Literal (BoolLiteral True))

field : a -> Value a -> Morphir.IR.Name.Name -> Value a

Extracts the value of a record's field.

a.foo -- Field (Variable [ "a" ]) [ "foo" ]

fieldFunction : a -> Morphir.IR.Name.Name -> Value a

Represents a function that extract a field from a record value passed to it.

.foo -- FieldFunction [ "foo" ]

lambda : a -> Pattern a -> Value a -> Value a

Represents a lambda abstraction.

Note:

\a -> a -- Lambda (AsPattern WildcardPattern [ "a" ]) (Variable [ "a" ])

\a b -> a -- Lambda (AsPattern WildcardPattern [ "a" ]) (Lambda (AsPattern WildcardPattern [ "b" ]) (Variable [ "a" ]))

letDef : a -> Morphir.IR.Name.Name -> Definition a -> Value a -> Value a

Represents a let expression that assigns a value (and optionally type) to a name.

Note: We use currying to represent let expressions with multiple name bindings.

let
    a =
        b
in
a
-- LetDef [ "a" ]
--     (UntypedDefinition [] (Variable [ "b" ]))
--     (Variable [ "a" ])

let
    a : Bool
    a =
        b

    c x =
        a
in
c
-- LetDef [ "a" ]
--     (TypedDefinition (Basic BoolType) [] (Variable [ "b" ]))
--     (LetDef [ "c" ]
--         (UntypedDefinition [ [ "x" ] ] (Variable [ "a" ]))
--         (Variable [ "c" ])
--     )

letDestruct : a -> Pattern a -> Value a -> Value a -> Value a

Represents a let expression that extracts values using a pattern.

let
    ( a, b ) =
        c
in
a
-- LetDestruct
--     (TuplePattern [ AsPattern WildcardPattern ["a"], AsPattern WildcardPattern ["b"] ])
--     (Variable ["a"])

letRec : a -> Dict Morphir.IR.Name.Name (Definition a) -> Value a -> Value a

Represents a let expression with one or many recursive definitions.

let
    a =
        b

    b =
        a
in
a
-- LetRec
--     [ ( [ "a" ], UntypedDefinition [] (Variable [ "b" ]) )
--     , ( [ "b" ], UntypedDefinition [] (Variable [ "a" ]) )
--     ]
--     (Variable [ "a" ])

list : a -> List (Value a) -> Value a

A list represents an ordered list of values where every value has to be of the same type.

[ 1, 3, 5 ] -- List [ Literal (IntLiteral 1), Literal (IntLiteral 3), Literal (IntLiteral 5) ]

[] -- List []

record : a -> List ( Morphir.IR.Name.Name, Value a ) -> Value a

A record represents a list of fields where each field has a name and a value.

{ foo = "bar" } -- Record [ ( [ "foo" ], Literal (StringLiteral "bar") ) ]

{ foo = "bar", baz = 1 } -- Record [ ( [ "foo" ], Literal (StringLiteral "bar") ), ( [ "baz" ], Literal (IntLiteral 1) ) ]

{} -- Record []

reference : a -> Morphir.IR.FQName.FQName -> Value a

A reference that refers to a function or a value with its fully-qualified name.

List.map -- Reference ( [ ..., [ [ "list" ] ], [ "map" ] )

tuple : a -> List (Value a) -> Value a

A tuple represents an ordered list of values where each value can be of a different type.

Note: Tuples with zero values are considered to be the special value Unit

( 1, True ) -- Tuple [ Literal (IntLiteral 1), Literal (BoolLiteral True) ]

( "foo", True, 3 ) -- Tuple [ Literal (StringLiteral "foo"), Literal (BoolLiteral True), Literal (IntLiteral 3) ]

() -- Unit

variable : a -> Morphir.IR.Name.Name -> Value a

A variable represents a reference to a named value in the scope.

a -- Variable [ "a" ]

fooBar15 -- Variable [ "foo", "bar", "15" ]

ifThenElse : a -> Value a -> Value a -> Value a -> Value a

Represents and if/then/else expression.

if a then
    b
else
    c
-- IfThenElse (Variable ["a"])
--     (Variable ["b"])
--     (Variable ["c"])

patternMatch : a -> Value a -> List ( Pattern a, Value a ) -> Value a

Represents a pattern-match.

case a of
    1 ->
        "yea"

    _ ->
        "nay"
-- PatternMatch (Variable ["a"])
--     [ ( LiteralPattern (IntLiteral 1), Literal (StringLiteral "yea") )
--     , ( WildcardPattern, Literal (StringLiteral "nay") )
--     ]

update : a -> Value a -> List ( Morphir.IR.Name.Name, Value a ) -> Value a

Update one or many fields of a record value.

{ a | foo = 1 } -- Update (Variable ["a"]) [ ( ["foo"], Literal (IntLiteral 1) ) ]

unit : a -> Value a

Represents the unit value.

() -- Unit

mapValueAttributes : (a -> b) -> Value a -> Value b

Pattern

Patterns are used in multiple ways in the IR: they can take apart a structured value into smaller pieces (destructure) and they can also filter values. The combination of these two features creates a very powerful method tool that can be used in two ways: destructuring and pattern-matching. Pattern-matching is a combination of destructuring, filtering and branching.


type Pattern a
    = WildcardPattern a
    | AsPattern a (Pattern a) Morphir.IR.Name.Name
    | TuplePattern a (List (Pattern a))
    | ConstructorPattern a Morphir.IR.FQName.FQName (List (Pattern a))
    | EmptyListPattern a
    | HeadTailPattern a (Pattern a) (Pattern a)
    | LiteralPattern a Morphir.IR.Literal.Literal
    | UnitPattern a

Type that represents a pattern.

wildcardPattern : a -> Pattern a

Matches any value and ignores it (assigns no variable name).

_ -- WildcardPattern

asPattern : a -> Pattern a -> Morphir.IR.Name.Name -> Pattern a

Assigns a variable name to a pattern.

_ as foo -- AsPattern WildcardPattern ["foo"]

foo -- AsPattern WildcardPattern ["foo"]

[] as foo -- AsPattern EmptyListPattern ["foo"]

tuplePattern : a -> List (Pattern a) -> Pattern a

Destructures a tuple using a pattern for every element.

( _, foo ) -- TuplePattern [ WildcardPattern, AsPattern WildcardPattern ["foo"] ]

constructorPattern : a -> Morphir.IR.FQName.FQName -> List (Pattern a) -> Pattern a

Matches on a custom type's constructor.

Note: When the custom type has a single constructor this can be used for destructuring. When there are multiple constructors it also does filtering so it cannot be used in a LetDestruct but it can be used in a pattern-match.

Just _ -- ConstructorPattern ( ..., [["maybe"]], ["just"]) [ WildcardPattern ]

emptyListPattern : a -> Pattern a

Matches an empty list. Can be used standalon but frequently used as a terminal pattern in a HeadTailPattern.

[] -- EmptyListPattern

[ _ ]
-- HeadTailPattern
--     WildcardPattern
--     EmptyListPattern

headTailPattern : a -> Pattern a -> Pattern a -> Pattern a

Matches the head and the tail of a list. It can be used to match lists of at least N items by nesting this pattern N times and terminating with EmptyListPattern.

[ a ]
-- HeadTailPattern
--     (AsPattern WildcardPattern ["a"])
--     EmptyListPattern

a :: b
-- HeadTailPattern
--     (AsPattern WildcardPattern ["a"])
--     (AsPattern WildcardPattern ["b"])

[ a, b ]
-- HeadTailPattern
--     (AsPattern WildcardPattern ["a"])
--     (HeadTailPattern
--         (AsPattern WildcardPattern ["b"])
--         EmptyListPattern
--     )

literalPattern : a -> Morphir.IR.Literal.Literal -> Pattern a

Matches a specific literal value. This pattern can only be used in a pattern-match since it always filters.

True -- LiteralPattern (BoolLiteral True)

'a' -- LiteralPattern (CharLiteral 'a')

"foo" -- LiteralPattern (StringLiteral "foo")

13 -- LiteralPattern (IntLiteral 13)

15.4 -- LiteralPattern (FloatLiteral 15.4)

Specification

The specification of what the value or function is without the actual data or logic behind it.


type alias Specification a =
{ inputs : List ( Morphir.IR.Name.Name
, Morphir.IR.Type.Type a )
, output : Morphir.IR.Type.Type a 
}

Type that represents a value or function specification. The specification of what the value or function is without the actual data or logic behind it.

mapSpecificationAttributes : (a -> b) -> Specification a -> Specification b

Definition

A definition is the actual data or logic as opposed to a specification which is just the specification of those. Value definitions can be typed or untyped. Exposed values have to be typed.


type alias Definition a =
{ inputTypes : List ( Morphir.IR.Name.Name
, a
, Morphir.IR.Type.Type a )
, outputType : Morphir.IR.Type.Type a
, body : Value a 
}

Type that represents a value or function definition. A definition is the actual data or logic as opposed to a specification which is just the specification of those. Value definitions can be typed or untyped. Exposed values have to be typed.

mapDefinition : (Morphir.IR.Type.Type a -> Result e (Morphir.IR.Type.Type a)) -> (Value a -> Result e (Value a)) -> Definition a -> Result (List e) (Definition a)

mapDefinitionAttributes : (a -> b) -> Definition a -> Definition b

Utilities

uncurryApply : Value a -> Value a -> ( Value a, List (Value a) )

Extract the argument list from a curried apply tree. It takes the two arguments of an apply and returns a tuple of the function and a list of arguments.

uncurryApply (Apply () f a) b == ( f, [ a, b ] )