Stg.Marshal.ToStg

Convert Haskell values to STG values.

Documentation

class ToStg value where

Convert a Haskell value to an STG binding.

Instances of this class should have a corresponding FromStg instance to retrieve a value fom the program, with the two being inverse to each other (up to forcing the generated thunks).

This class contains a helper function, toStgWithGlobals, this is hidden from the outside. If you want to write your own instance, have a look at the source for documentation.

Minimal complete definition

toStg | toStgWithGlobals

Methods

toStg

Arguments

:: Var

Name of the binding

-> value

-> Program

toStgWithGlobals

Arguments

:: Var

Name of the binding

-> value

-> Writer Program Program

Log: globals; value: value definition itself

Some definitions, such as the one for lists, require certain global values to be present (such as nil). In order to avoid duplicate definitions, this function allows defining top-level elements using Writers tell function.

Instances

ToStg Bool

>>> ppr (toStg "bool" True)
bool = \ -> True

ToStg Int

Same as the Integer instance, but makes for shorter type annotations

ToStg Integer

>>> ppr (toStg "int" (1 :: Integer))
int = \ -> Int# 1#

ToStg ()

>>> ppr (toStg "unit" ())
unit = \ -> Unit

ToStg a => ToStg [a]

>>> ppr (toStg "list" ([] :: [Int]))
list = \ => nil;
nil = \ -> Nil

>>> ppr (toStg "list" [1, 2, 3 :: Int])
list = \ =>
    letrec __0_value = \ -> Int# 1#;
           __1_cons = \(__1_value __2_cons) -> Cons __1_value __2_cons;
           __1_value = \ -> Int# 2#;
           __2_cons = \(__2_value) -> Cons __2_value nil;
           __2_value = \ -> Int# 3#
    in Cons __0_value __1_cons;
nil = \ -> Nil

ToStg a => ToStg (Maybe a)

>>> ppr (toStg "maybe" (Nothing :: Maybe Int))
maybe = \ => nothing;
nothing = \ -> Nothing

>>> ppr (toStg "maybe" (Just 1 :: Maybe Int))
maybe = \ =>
    let __justVal = \ -> Int# 1#
    in Just __justVal

(ToStg a, ToStg b) => ToStg (Either a b)

>>> ppr (toStg "either" (Left 1 :: Either Int [Int]))
either = \ =>
    let __leftval = \ -> Int# 1#
    in Left __leftval

>>> ppr (toStg "either" (Right 2 :: Either [Int] Int))
either = \ =>
    let __rightval = \ -> Int# 2#
    in Right __rightval

(ToStg a, ToStg b) => ToStg (a, b)

>>> ppr (toStg "pair" ((1,2) :: (Int,Int)))
pair = \ =>
    let __fst = \ -> Int# 1#;
        __snd = \ -> Int# 2#
    in Pair __fst __snd

(ToStg a, ToStg b, ToStg c) => ToStg (a, b, c)

>>> ppr (toStg "triple" ((1,2,3) :: (Int,Int,Int)))
triple = \ =>
    let __x = \ -> Int# 1#;
        __y = \ -> Int# 2#;
        __z = \ -> Int# 3#
    in Triple __x __y __z

(ToStg a, ToStg b, ToStg c, ToStg d) => ToStg (a, b, c, d)

>>> ppr (toStg "quadruple" ((1,2,3,4) :: (Int,Int,Int,Int)))
quadruple = \ =>
    let __w = \ -> Int# 1#;
        __x = \ -> Int# 2#;
        __y = \ -> Int# 3#;
        __z = \ -> Int# 4#
    in Quadruple __w __x __y __z

(ToStg a, ToStg b, ToStg c, ToStg d, ToStg e) => ToStg (a, b, c, d, e)

>>> ppr (toStg "quintuple" ((1,2,3,4,5) :: (Int,Int,Int,Int,Int)))
quintuple = \ =>
    let __v = \ -> Int# 1#;
        __w = \ -> Int# 2#;
        __x = \ -> Int# 3#;
        __y = \ -> Int# 4#;
        __z = \ -> Int# 5#
    in Quintuple __v __w __x __y __z