Feldspar.Run.Marshal

Documentation

newtype Parser a

Constructors

Parser

Fields

• runParser :: String -> (a, String)

Instances

Monad Parser

Defined in Feldspar.Run.Marshal

Methods

(>>=) :: Parser a -> (a -> Parser b) -> Parser b

(>>) :: Parser a -> Parser b -> Parser b

return :: a -> Parser a

Functor Parser

Defined in Feldspar.Run.Marshal

Methods

fmap :: (a -> b) -> Parser a -> Parser b

(<$) :: a -> Parser b -> Parser a

Applicative Parser

Defined in Feldspar.Run.Marshal

Methods

pure :: a -> Parser a

(<*>) :: Parser (a -> b) -> Parser a -> Parser b

liftA2 :: (a -> b -> c) -> Parser a -> Parser b -> Parser c

(*>) :: Parser a -> Parser b -> Parser b

(<*) :: Parser a -> Parser b -> Parser a

readParser :: forall a. (Read a, Typeable a) => Parser a

parse :: Parser a -> String -> a

class MarshalHaskell a where

Serialization/deserialization of Haskell values

The following property must hold for all a:

a = parse toHaskell (fromHaskell a) Prelude.== a

Minimal complete definition

Nothing

Methods

fromHaskell :: a -> String

Serialize a Haskell value

default fromHaskell :: Show a => a -> String

toHaskell :: Parser a

Deserialize a Haskell value

default toHaskell :: (Read a, Typeable a) => Parser a

Instances

MarshalHaskell Double

Defined in Feldspar.Run.Marshal

Methods

fromHaskell :: Double -> String

toHaskell :: Parser Double

MarshalHaskell Float

Defined in Feldspar.Run.Marshal

Methods

fromHaskell :: Float -> String

toHaskell :: Parser Float

MarshalHaskell Int

Defined in Feldspar.Run.Marshal

Methods

fromHaskell :: Int -> String

toHaskell :: Parser Int

MarshalHaskell Int8

Defined in Feldspar.Run.Marshal

Methods

fromHaskell :: Int8 -> String

toHaskell :: Parser Int8

MarshalHaskell Int16

Defined in Feldspar.Run.Marshal

Methods

fromHaskell :: Int16 -> String

toHaskell :: Parser Int16

MarshalHaskell Int32

Defined in Feldspar.Run.Marshal

Methods

fromHaskell :: Int32 -> String

toHaskell :: Parser Int32

MarshalHaskell Int64

Defined in Feldspar.Run.Marshal

Methods

fromHaskell :: Int64 -> String

toHaskell :: Parser Int64

MarshalHaskell Word8

Defined in Feldspar.Run.Marshal

Methods

fromHaskell :: Word8 -> String

toHaskell :: Parser Word8

MarshalHaskell Word16

Defined in Feldspar.Run.Marshal

Methods

fromHaskell :: Word16 -> String

toHaskell :: Parser Word16

MarshalHaskell Word32

Defined in Feldspar.Run.Marshal

Methods

fromHaskell :: Word32 -> String

toHaskell :: Parser Word32

MarshalHaskell Word64

Defined in Feldspar.Run.Marshal

Methods

fromHaskell :: Word64 -> String

toHaskell :: Parser Word64

MarshalHaskell a => MarshalHaskell [a]

Defined in Feldspar.Run.Marshal

Methods

fromHaskell :: [a] -> String

toHaskell :: Parser [a]

MarshalHaskell (Complex Double)

Defined in Feldspar.Run.Marshal

Methods

fromHaskell :: Complex Double -> String

toHaskell :: Parser (Complex Double)

MarshalHaskell (Complex Float)

Defined in Feldspar.Run.Marshal

Methods

fromHaskell :: Complex Float -> String

toHaskell :: Parser (Complex Float)

(MarshalHaskell a, MarshalHaskell b) => MarshalHaskell (a, b)

Defined in Feldspar.Run.Marshal

Methods

fromHaskell :: (a, b) -> String

toHaskell :: Parser (a, b)

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

Defined in Feldspar.Run.Marshal

Methods

fromHaskell :: (a, b, c) -> String

toHaskell :: Parser (a, b, c)

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

Defined in Feldspar.Run.Marshal

Methods

fromHaskell :: (a, b, c, d) -> String

toHaskell :: Parser (a, b, c, d)

class MarshalHaskell (HaskellRep a) => MarshalFeld a where

Serialization/deserialization of Feldspar values

Minimal complete definition

Nothing

Associated Types

type HaskellRep a

The Haskell representation of a Feldspar value

Methods

fwrite :: Handle -> a -> Run ()

Serialize a Feldspar value to a handle

default fwrite :: (PrimType b, Formattable b, a ~ Data b) => Handle -> a -> Run ()

fread :: Handle -> Run a

Deserialize a Feldspar value from a handle

default fread :: (PrimType b, Formattable b, a ~ Data b) => Handle -> Run a

Instances

MarshalFeld (Data Double)

Defined in Feldspar.Run.Marshal

Associated Types

type HaskellRep (Data Double)

Methods

fwrite :: Handle -> Data Double -> Run ()

fread :: Handle -> Run (Data Double)

MarshalFeld (Data Float)

Defined in Feldspar.Run.Marshal

Associated Types

type HaskellRep (Data Float)

Methods

fwrite :: Handle -> Data Float -> Run ()

fread :: Handle -> Run (Data Float)

MarshalFeld (Data Int8)

Defined in Feldspar.Run.Marshal

Associated Types

type HaskellRep (Data Int8)

Methods

fwrite :: Handle -> Data Int8 -> Run ()

fread :: Handle -> Run (Data Int8)

MarshalFeld (Data Int16)

Defined in Feldspar.Run.Marshal

Associated Types

type HaskellRep (Data Int16)

Methods

fwrite :: Handle -> Data Int16 -> Run ()

fread :: Handle -> Run (Data Int16)

MarshalFeld (Data Int32)

Defined in Feldspar.Run.Marshal

Associated Types

type HaskellRep (Data Int32)

Methods

fwrite :: Handle -> Data Int32 -> Run ()

fread :: Handle -> Run (Data Int32)

MarshalFeld (Data Int64)

Defined in Feldspar.Run.Marshal

Associated Types

type HaskellRep (Data Int64)

Methods

fwrite :: Handle -> Data Int64 -> Run ()

fread :: Handle -> Run (Data Int64)

MarshalFeld (Data Word8)

Defined in Feldspar.Run.Marshal

Associated Types

type HaskellRep (Data Word8)

Methods

fwrite :: Handle -> Data Word8 -> Run ()

fread :: Handle -> Run (Data Word8)

MarshalFeld (Data Word16)

Defined in Feldspar.Run.Marshal

Associated Types

type HaskellRep (Data Word16)

Methods

fwrite :: Handle -> Data Word16 -> Run ()

fread :: Handle -> Run (Data Word16)

MarshalFeld (Data Word32)

Defined in Feldspar.Run.Marshal

Associated Types

type HaskellRep (Data Word32)

Methods

fwrite :: Handle -> Data Word32 -> Run ()

fread :: Handle -> Run (Data Word32)

MarshalFeld (Data Word64)

Defined in Feldspar.Run.Marshal

Associated Types

type HaskellRep (Data Word64)

Methods

fwrite :: Handle -> Data Word64 -> Run ()

fread :: Handle -> Run (Data Word64)

MarshalFeld (Data (Complex Double))

Defined in Feldspar.Run.Marshal

Associated Types

type HaskellRep (Data (Complex Double))

Methods

fwrite :: Handle -> Data (Complex Double) -> Run ()

fread :: Handle -> Run (Data (Complex Double))

MarshalFeld (Data (Complex Float))

Defined in Feldspar.Run.Marshal

Associated Types

type HaskellRep (Data (Complex Float))

Methods

fwrite :: Handle -> Data (Complex Float) -> Run ()

fread :: Handle -> Run (Data (Complex Float))

(MarshalHaskell (Internal a), MarshalFeld a, Syntax a) => MarshalFeld (IArr a)

Defined in Feldspar.Run.Marshal

Associated Types

type HaskellRep (IArr a)

Methods

fwrite :: Handle -> IArr a -> Run ()

fread :: Handle -> Run (IArr a)

(MarshalHaskell (Internal a), MarshalFeld a, Syntax a) => MarshalFeld (Arr a)

Defined in Feldspar.Run.Marshal

Associated Types

type HaskellRep (Arr a)

Methods

fwrite :: Handle -> Arr a -> Run ()

fread :: Handle -> Run (Arr a)

MarshalFeld a => MarshalFeld (Nest a)

Note that HaskellRep (Nest a) = (Length, Length, HaskellRep a) rather than [HaskellRep a]. This means that e.g. Nest (Nest (Fin (IArr a))) is represented as (Length,Length,(Length,Length,(Length,[...]))) instead of the more convenient [[...]].

Defined in Feldspar.Data.Array

Associated Types

type HaskellRep (Nest a)

Methods

fwrite :: Handle -> Nest a -> Run ()

fread :: Handle -> Run (Nest a)

(Syntax a, MarshalHaskell (Internal a), MarshalFeld a) => MarshalFeld (Pull2 a)

Defined in Feldspar.Data.Vector

Associated Types

type HaskellRep (Pull2 a)

Methods

fwrite :: Handle -> Pull2 a -> Run ()

fread :: Handle -> Run (Pull2 a)

(Syntax a, MarshalHaskell (Internal a), MarshalFeld a) => MarshalFeld (Pull a)

Defined in Feldspar.Data.Vector

Associated Types

type HaskellRep (Pull a)

Methods

fwrite :: Handle -> Pull a -> Run ()

fread :: Handle -> Run (Pull a)

(MarshalFeld a, MarshalFeld b) => MarshalFeld (a, b)

Defined in Feldspar.Run.Marshal

Associated Types

type HaskellRep (a, b)

Methods

fwrite :: Handle -> (a, b) -> Run ()

fread :: Handle -> Run (a, b)

(Syntax a, MarshalHaskell (Internal a), MarshalFeld a, m ~ Run) => MarshalFeld (Seq m a)

Defined in Feldspar.Data.Vector

Associated Types

type HaskellRep (Seq m a)

Methods

fwrite :: Handle -> Seq m a -> Run ()

fread :: Handle -> Run (Seq m a)

(Syntax a, MarshalHaskell (Internal a), MarshalFeld a, m ~ Run) => MarshalFeld (Push2 m a)

Defined in Feldspar.Data.Vector

Associated Types

type HaskellRep (Push2 m a)

Methods

fwrite :: Handle -> Push2 m a -> Run ()

fread :: Handle -> Run (Push2 m a)

(Syntax a, MarshalHaskell (Internal a), MarshalFeld a, m ~ Run) => MarshalFeld (Push m a)

Defined in Feldspar.Data.Vector

Associated Types

type HaskellRep (Push m a)

Methods

fwrite :: Handle -> Push m a -> Run ()

fread :: Handle -> Run (Push m a)

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

Defined in Feldspar.Run.Marshal

Associated Types

type HaskellRep (a, b, c)

Methods

fwrite :: Handle -> (a, b, c) -> Run ()

fread :: Handle -> Run (a, b, c)

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

Defined in Feldspar.Run.Marshal

Associated Types

type HaskellRep (a, b, c, d)

Methods

fwrite :: Handle -> (a, b, c, d) -> Run ()

fread :: Handle -> Run (a, b, c, d)

writeStd :: MarshalFeld a => a -> Run ()

Write a value to stdout

readStd :: MarshalFeld a => Run a

Read a value from stdin

connectStdIO :: (MarshalFeld a, MarshalFeld b) => (a -> Run b) -> Run ()

Connect a Feldspar function between serializable types to stdin/stdout

streamStdIO :: (MarshalFeld a, MarshalFeld b) => (a -> Run b) -> Run ()

Connect a Feldspar function between serializable types to stdin/stdout. The inputoutput will be in the form of a list as recognized by toHaskell fromHaskell (i.e. the length followed by the elements in sequence).

The function will be mapped over the input list in a lazy manner.

marshalled'

Arguments

:: (MarshalFeld a, MarshalFeld b)

=> CompilerOpts

-> ExternalCompilerOpts

-> (a -> Run b)

Function to compile

-> ((HaskellRep a -> IO (HaskellRep b)) -> IO c)

Function that has access to the compiled executable as a function

-> IO c

A version of marshalled that takes ExternalCompilerOpts as additional argument

marshalled

Arguments

:: (MarshalFeld a, MarshalFeld b)

=> (a -> Run b)

Function to compile

-> ((HaskellRep a -> IO (HaskellRep b)) -> IO c)

Function that has access to the compiled executable as a function

-> IO c

Compile a function and make it available as an IO function. Note that compilation only happens once, even if the function is used many times in the body.

For example, given the following Feldspar function:

sumArr :: DIArr Int32 -> Run (Data Int32)
sumArr arr = do
    r <- initRef 0
    for (0,1,Excl $ length arr) $ \i -> modifyRef r (+ arrIx arr i)
    unsafeFreezeRef r

marshalled can be used as follows:

*Main> marshalled sumArr $ \f -> (f [3,4,5] >>= print) >> (f [6,7,8,9] >>= print)

marshalledStream'

Arguments

:: (MarshalFeld a, MarshalFeld b)

=> CompilerOpts

-> ExternalCompilerOpts

-> (a -> Run b)

Function to compile

-> (([HaskellRep a] -> IO [HaskellRep b]) -> IO c)

Function that has access to the compiled executable as a function

-> IO c

A version of marshalledStream that takes ExternalCompilerOpts as additional argument

marshalledStream

Arguments

:: (MarshalFeld a, MarshalFeld b)

=> (a -> Run b)

Function to compile

-> (([HaskellRep a] -> IO [HaskellRep b]) -> IO c)

Function that has access to the compiled executable as a function

-> IO c

Compile a function and make it available as an IO function. The compiled function will be applied repeatedly over the list of inputs producing a list of outputs. Note that compilation only happens once, even if the function is used many times in the body.