Stg.Marshal

Convert Haskell values to STG values and back.

This module is what users should be using - it reexports only the safe classes.

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 :: Var -> value -> Program

Instances

ToStg Bool

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

Methods

toStg :: Var -> Bool -> Program

toStgWithGlobals :: Var -> Bool -> Writer Program Program

ToStg Int

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

Methods

toStg :: Var -> Int -> Program

toStgWithGlobals :: Var -> Int -> Writer Program Program

ToStg Integer

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

Methods

toStg :: Var -> Integer -> Program

toStgWithGlobals :: Var -> Integer -> Writer Program Program

ToStg ()

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

Methods

toStg :: Var -> () -> Program

toStgWithGlobals :: Var -> () -> Writer Program Program

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

Methods

toStg :: Var -> [a] -> Program

toStgWithGlobals :: Var -> [a] -> Writer Program Program

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

Methods

toStg :: Var -> Maybe a -> Program

toStgWithGlobals :: Var -> Maybe a -> Writer Program Program

(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

Methods

toStg :: Var -> Either a b -> Program

toStgWithGlobals :: Var -> Either a b -> Writer Program Program

(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

Methods

toStg :: Var -> (a, b) -> Program

toStgWithGlobals :: Var -> (a, b) -> Writer Program Program

(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

Methods

toStg :: Var -> (a, b, c) -> Program

toStgWithGlobals :: Var -> (a, b, c) -> Writer Program Program

(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

Methods

toStg :: Var -> (a, b, c, d) -> Program

toStgWithGlobals :: Var -> (a, b, c, d) -> Writer Program Program

(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

Methods

toStg :: Var -> (a, b, c, d, e) -> Program

toStgWithGlobals :: Var -> (a, b, c, d, e) -> Writer Program Program

class FromStg value where

Look up the value of a global variable.

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

Minimal complete definition

fromStgAddr

Methods

fromStg :: StgState -> Var -> Either FromStgError value

Retrieve the value of a global variable.

Instances

FromStg Bool

Methods

fromStg :: StgState -> Var -> Either FromStgError Bool

fromStgAddr :: StgState -> MemAddr -> Either FromStgError Bool

fromStgPrim :: Integer -> Either FromStgError Bool

FromStg Integer

Works for both boxed (Int# 1#) and unboxed (1#) integers.

Methods

fromStg :: StgState -> Var -> Either FromStgError Integer

fromStgAddr :: StgState -> MemAddr -> Either FromStgError Integer

fromStgPrim :: Integer -> Either FromStgError Integer

FromStg ()

Methods

fromStg :: StgState -> Var -> Either FromStgError ()

fromStgAddr :: StgState -> MemAddr -> Either FromStgError ()

fromStgPrim :: Integer -> Either FromStgError ()

FromStg a => FromStg [a]

Methods

fromStg :: StgState -> Var -> Either FromStgError [a]

fromStgAddr :: StgState -> MemAddr -> Either FromStgError [a]

fromStgPrim :: Integer -> Either FromStgError [a]

FromStg a => FromStg (Maybe a)

Methods

fromStg :: StgState -> Var -> Either FromStgError (Maybe a)

fromStgAddr :: StgState -> MemAddr -> Either FromStgError (Maybe a)

fromStgPrim :: Integer -> Either FromStgError (Maybe a)

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

Methods

fromStg :: StgState -> Var -> Either FromStgError (Either a b)

fromStgAddr :: StgState -> MemAddr -> Either FromStgError (Either a b)

fromStgPrim :: Integer -> Either FromStgError (Either a b)

(FromStg a, FromStg b) => FromStg (a, b)

Methods

fromStg :: StgState -> Var -> Either FromStgError (a, b)

fromStgAddr :: StgState -> MemAddr -> Either FromStgError (a, b)

fromStgPrim :: Integer -> Either FromStgError (a, b)

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

Methods

fromStg :: StgState -> Var -> Either FromStgError (a, b, c)

fromStgAddr :: StgState -> MemAddr -> Either FromStgError (a, b, c)

fromStgPrim :: Integer -> Either FromStgError (a, b, c)

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

Methods

fromStg :: StgState -> Var -> Either FromStgError (a, b, c, d)

fromStgAddr :: StgState -> MemAddr -> Either FromStgError (a, b, c, d)

fromStgPrim :: Integer -> Either FromStgError (a, b, c, d)

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

Methods

fromStg :: StgState -> Var -> Either FromStgError (a, b, c, d, e)

fromStgAddr :: StgState -> MemAddr -> Either FromStgError (a, b, c, d, e)

fromStgPrim :: Integer -> Either FromStgError (a, b, c, d, e)

data FromStgError

Classifies the different errors that can happen when extracting a value from an STG state.

Constructors

TypeMismatch

e.g. asking for an Int# at an address that contains a Cons

IsWrongLambdaType LambdaType

Tried retrieving a non-constructor

IsBlackhole

Tried retrieving a black hole

BadArity

e.g. Cons x y z

NotFound NotInScope

An unsuccessful variable lookup

AddrNotOnHeap

NoConstructorMatch

None of the given alternatives matched the given constructor, e.g. when trying to receive a Left as a Just

Instances

Eq FromStgError

Methods

(==) :: FromStgError -> FromStgError -> Bool

(/=) :: FromStgError -> FromStgError -> Bool

Ord FromStgError

Methods

compare :: FromStgError -> FromStgError -> Ordering

(<) :: FromStgError -> FromStgError -> Bool

(<=) :: FromStgError -> FromStgError -> Bool

(>) :: FromStgError -> FromStgError -> Bool

(>=) :: FromStgError -> FromStgError -> Bool

max :: FromStgError -> FromStgError -> FromStgError

min :: FromStgError -> FromStgError -> FromStgError

Show FromStgError

Methods

showsPrec :: Int -> FromStgError -> ShowS

show :: FromStgError -> String

showList :: [FromStgError] -> ShowS