


Description 
This module gives a representation core programs as typed expressions (see
Expr / Data).


Synopsis 

  data Data a = Typeable a => Data {}   data a :> b = Typeable a => Lambda (Data a > Data b) (Data a) (Data b)   dataType :: forall a. Data a > Tuple StorableType   dataId :: Data a > Unique   dataToExpr :: Data a > Expr a   exprToData :: Typeable a => Size a > Expr a > Data a   freshVar :: Typeable a => Size a > Data a   lambda :: Typeable a => Size a > (Data a > Data b) > a :> b   apply :: (a :> b) > Data a > Data b   resultSize :: (a :> b) > Size b   ($) :: Expr (a > b) > Data a > Expr b   _function :: Typeable b => String > (Size a > Size b) > (a > b) > Data a > Data b   _function2 :: Typeable c => String > (Size a > Size b > Size c) > (a > b > c) > Data a > Data b > Data c   _function3 :: Typeable d => String > (Size a > Size b > Size c > Size d) > (a > b > c > d) > Data a > Data b > Data c > Data d   _function4 :: Typeable e => String > (Size a > Size b > Size c > Size d > Size e) > (a > b > c > d > e) > Data a > Data b > Data c > Data d > Data e   tup2 :: (Typeable a, Typeable b) => Data a > Data b > Data (a, b)   tup3 :: (Typeable a, Typeable b, Typeable c) => Data a > Data b > Data c > Data (a, b, c)   tup4 :: (Typeable a, Typeable b, Typeable c, Typeable d) => Data a > Data b > Data c > Data d > Data (a, b, c, d)   get21 :: Typeable a => Data (a, b) > Data a   get22 :: Typeable b => Data (a, b) > Data b   get31 :: Typeable a => Data (a, b, c) > Data a   get32 :: Typeable b => Data (a, b, c) > Data b   get33 :: Typeable c => Data (a, b, c) > Data c   get41 :: Typeable a => Data (a, b, c, d) > Data a   get42 :: Typeable b => Data (a, b, c, d) > Data b   get43 :: Typeable c => Data (a, b, c, d) > Data c   get44 :: Typeable d => Data (a, b, c, d) > Data d   class Typeable (Internal a) => Computable a where    lowerFun :: (Computable a, Computable b) => (a > b) > Data (Internal a) > Data (Internal b)   liftFun :: (Computable a, Computable b) => (Data (Internal a) > Data (Internal b)) > a > b   evalE :: Expr a > a   evalD :: Data a > a   evalF :: (a :> b) > a > b   eval :: Computable a => a > Internal a   value :: Storable a => a > Data a   array :: Storable a => Size a > a > Data a   arrayLen :: Storable a => Data Length > [a] > Data [a]   unit :: Data ()   true :: Data Bool   false :: Data Bool   size :: forall a. Storable a => Data [a] > [Range Length]   cap :: (Storable a, Size a ~ Range b, Ord b) => Range b > Data a > Data a   function :: (Storable a, Storable b) => String > (Size a > Size b) > (a > b) > Data a > Data b   function2 :: (Storable a, Storable b, Storable c) => String > (Size a > Size b > Size c) > (a > b > c) > Data a > Data b > Data c   function3 :: (Storable a, Storable b, Storable c, Storable d) => String > (Size a > Size b > Size c > Size d) > (a > b > c > d) > Data a > Data b > Data c > Data d   function4 :: (Storable a, Storable b, Storable c, Storable d, Storable e) => String > (Size a > Size b > Size c > Size d > Size e) > (a > b > c > d > e) > Data a > Data b > Data c > Data d > Data e   getIx :: Storable a => Data [a] > Data Int > Data a   setIx :: Storable a => Data [a] > Data Int > Data a > Data [a]   class RandomAccess a where    noInline :: (Computable a, Computable b) => String > (a > b) > a > b   ifThenElse :: (Computable a, Computable b) => Data Bool > (a > b) > (a > b) > a > b   whileSized :: Computable state => Size (Internal state) > Size (Internal state) > (state > Data Bool) > (state > state) > state > state   while :: Computable state => (state > Data Bool) > (state > state) > state > state   parallel :: Storable a => Data Length > (Data Int > Data a) > Data [a] 


Documentation 


Typed core language expressions. A value of type Expr a is a
representation of a program that computes a value of type a.
 Constructors  



A wrapper around Expr to allow observable sharing (see
Feldspar.Core.Ref) and for memoizing size information.
 Constructors   Instances  
























































Computable types. A computable value completely represents a core program,
in such a way that internalize . externalize preserves semantics, but
not necessarily syntax.
The terminology used in this class comes from thinking of the Data type as
the "internal" core language and the Feldspar.Core API as the
"external" core language.
  Associated Types   Data (Internal a) is the internal representation of the type a.


  Methods   Convert to internal representation
   Convert to external representation

  Instances  Storable a => Computable (Data a)  Storable a => Computable (Vector (Data a))  Storable a => Computable (Vector (Vector (Data a)))  (Computable a, Computable b) => Computable (a, b)  (Computable a, Computable b, Computable c) => Computable (a, b, c)  (Computable a, Computable b, Computable c, Computable d) => Computable (a, b, c, d) 




Lower a function to operate on internal representation.



Lift a function to operate on external representation.



The semantics of expressions



The semantics of Data





The semantics of any Computable type



A program that computes a constant value



Like value but with an extra Size argument that can be used to increase
the size beyond the given data.
Example 1:
array (10 :> 20 :> universal) [] :: Data [[Int]]
gives an uninitialized 10x20 array of Int elements.
Example 2:
array (10 :> 20 :> universal) [[1,2,3]] :: Data [[Int]]
gives a 10x20 array whose first row is initialized to [1,2,3].











Returns the size of each level of a multidimensional array, starting with
the outermost level.





Constructs a oneargument primitive function.
function fun szf f:
 fun is the name of the function.
 szf computes the output size from the input size.
 f gives the evaluation semantics.



A twoargument primitive function



A threeargument primitive function



A fourargument primitive function



Look up an index in an array (see also !)



setIx arr i a:
Replaces the value at index i in the array arr with the value a.


class RandomAccess a where  Source 

 Associated Types   The type of elements in a random access structure


  Methods   Index lookup in a random access structure

  Instances  



Constructs a nonprimitive, noninlined function.
The normal way to make a nonprimitive function is to use an ordinary Haskell
function, for example:
myFunc x = x * 4 + 5
However, such functions are inevitably inlined into the program expression
when applied. noInline can be thought of as a way to protect a function
against inlining (but later transformations may choose to inline anyway).
Ideally, it should be posssible to reuse such a function several times, but
at the moment this does not work. Every application of a noInline function
results in a new copy of the function in the core program.



ifThenElse cond thenFunc elseFunc:
Selects between the two functions thenFunc and elseFunc depending on
whether the condition cond is true or false.





Whileloop
while cont body :: state > state:
 state is the type of the state.
 cont determines whether or not to continue based on the current state.
 body computes the next state from the current state.
 The result is a function from initial state to final state.



Parallel array
parallel l ixf:
 l is the length of the resulting array (outermost level).
 ifx is a function that maps each index in the range [0 .. l1] to its
element.
Since there are no dependencies between the elements, the compiler is free to
compute the elements in any order, or even in parallel.


Produced by Haddock version 2.6.1 