Feldspar.Run.Marshal

Documentation

newtype Parser a

Constructors

Parser

Fields

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

Instances

Monad Parser

Methods

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

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

return :: a -> Parser a

fail :: String -> Parser a

Functor Parser

Methods

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

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

Applicative Parser

Methods

pure :: a -> Parser a

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

(*>) :: 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

Methods

fromHaskell :: a -> String

Serialize a Haskell value

fromHaskell :: Show a => a -> String

Serialize a Haskell value

toHaskell :: Parser a

Deserialize a Haskell value

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

Deserialize a Haskell value

Instances

MarshalHaskell Double

Methods

fromHaskell :: Double -> String

toHaskell :: Parser Double

MarshalHaskell Float

Methods

fromHaskell :: Float -> String

toHaskell :: Parser Float

MarshalHaskell Int

Methods

fromHaskell :: Int -> String

toHaskell :: Parser Int

MarshalHaskell Int8

Methods

fromHaskell :: Int8 -> String

toHaskell :: Parser Int8

MarshalHaskell Int16

Methods

fromHaskell :: Int16 -> String

toHaskell :: Parser Int16

MarshalHaskell Int32

Methods

fromHaskell :: Int32 -> String

toHaskell :: Parser Int32

MarshalHaskell Int64

Methods

fromHaskell :: Int64 -> String

toHaskell :: Parser Int64

MarshalHaskell Word8

Methods

fromHaskell :: Word8 -> String

toHaskell :: Parser Word8

MarshalHaskell Word16

Methods

fromHaskell :: Word16 -> String

toHaskell :: Parser Word16

MarshalHaskell Word32

Methods

fromHaskell :: Word32 -> String

toHaskell :: Parser Word32

MarshalHaskell Word64

Methods

fromHaskell :: Word64 -> String

toHaskell :: Parser Word64

MarshalHaskell a => MarshalHaskell [a]

Methods

fromHaskell :: [a] -> String

toHaskell :: Parser [a]

MarshalHaskell (Complex Double)

Methods

fromHaskell :: Complex Double -> String

toHaskell :: Parser (Complex Double)

MarshalHaskell (Complex Float)

Methods

fromHaskell :: Complex Float -> String

toHaskell :: Parser (Complex Float)

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

Methods

fromHaskell :: (a, b) -> String

toHaskell :: Parser (a, b)

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

Methods

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

toHaskell :: Parser (a, b, c)

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

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

Associated Types

type HaskellRep a

The Haskell representation of a Feldspar value

Methods

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

Serialize a Feldspar value to a handle

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

Serialize a Feldspar value to a handle

fread :: Handle -> Run a

Deserialize a Feldspar value from a handle

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

Deserialize a Feldspar value from a handle

Instances

MarshalFeld (Data Double)

Associated Types

type HaskellRep (Data Double) :: *

Methods

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

fread :: Handle -> Run (Data Double)

MarshalFeld (Data Float)

Associated Types

type HaskellRep (Data Float) :: *

Methods

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

fread :: Handle -> Run (Data Float)

MarshalFeld (Data Int8)

Associated Types

type HaskellRep (Data Int8) :: *

Methods

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

fread :: Handle -> Run (Data Int8)

MarshalFeld (Data Int16)

Associated Types

type HaskellRep (Data Int16) :: *

Methods

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

fread :: Handle -> Run (Data Int16)

MarshalFeld (Data Int32)

Associated Types

type HaskellRep (Data Int32) :: *

Methods

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

fread :: Handle -> Run (Data Int32)

MarshalFeld (Data Int64)

Associated Types

type HaskellRep (Data Int64) :: *

Methods

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

fread :: Handle -> Run (Data Int64)

MarshalFeld (Data Word8)

Associated Types

type HaskellRep (Data Word8) :: *

Methods

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

fread :: Handle -> Run (Data Word8)

MarshalFeld (Data Word16)

Associated Types

type HaskellRep (Data Word16) :: *

Methods

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

fread :: Handle -> Run (Data Word16)

MarshalFeld (Data Word32)

Associated Types

type HaskellRep (Data Word32) :: *

Methods

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

fread :: Handle -> Run (Data Word32)

MarshalFeld (Data Word64)

Associated Types

type HaskellRep (Data Word64) :: *

Methods

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

fread :: Handle -> Run (Data Word64)

MarshalFeld (Data (Complex Double))

Associated Types

type HaskellRep (Data (Complex Double)) :: *

Methods

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

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

MarshalFeld (Data (Complex Float))

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)

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)

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 [[...]].

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)

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)

Associated Types

type HaskellRep (Pull a) :: *

Methods

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

fread :: Handle -> Run (Pull a)

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

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)

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)

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)

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)

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)

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.