Safe Haskell  None 

 data T p a
 ($#) :: (T p a > b) > a > b
 get :: T p a > p > a
 value :: (MakeValueTuple tuple, ValueTuple tuple ~ value) => T p tuple > value > value
 with :: (Storable tuple, MakeValueTuple tuple, ValueTuple tuple ~ value, C value) => T p tuple > (forall parameters. (Storable parameters, MakeValueTuple parameters, C (ValueTuple parameters)) => (p > parameters) > (ValueTuple parameters > value) > a) > a
 class Tuple tuple where
 withTuple :: (Tuple tuple, Source tuple ~ p, Composed tuple ~ p) => (tuple > f p) > f p
 withTuple1 :: (Tuple tuple, Source tuple ~ p, Composed tuple ~ p) => (tuple > f p a) > f p a
 withTuple2 :: (Tuple tuple, Source tuple ~ p, Composed tuple ~ p) => (tuple > f p a b) > f p a b
 word32 :: T p Int > T p Word32
Documentation
This data type is for parameters of parameterized signal generators and causal processes.
It is better than using plain functions of type p > a
since it allows for numeric instances
and we can make explicit,
whether a parameter is constant.
We recommend to use parameters for atomic types.
Although a parameter of type T p (a,b)
is possible,
it means that the whole parameter is variable
if only one of the pair elements is variable.
This way you may miss optimizations.
Arrow T 

Category T 

Monad (T p)  
Functor (T p)  Useful for splitting 
Applicative (T p)  Useful for combining 
Eq a => Eq (T p a)  
Floating a => Floating (T p a)  
Fractional a => Fractional (T p a)  
Num a => Num (T p a)  
Show a => Show (T p a)  
C a => C (T p a)  
C a => C (T p a)  
C a => C (T p a)  
C a => C (T p a)  
C a => C (T p a)  
Tuple (T p a) 
value :: (MakeValueTuple tuple, ValueTuple tuple ~ value) => T p tuple > value > valueSource
The call value param v
requires
that v
represents the same value as valueTupleOf (get param p)
for some p
.
However v
might be the result of a load operation
and param
might be a constant.
In this case it is more efficient to use valueTupleOf (get param undefined)
since the constant is translated to an LLVM constant
that allows for certain optimizations.
This is the main function for taking advantage of a constant parameter
in lowlevel implementations.
For simplicity we do not omit constant parameters in the parameter struct
since this would mean to construct types at runtime and might become ugly.
Instead we just check using value
at the according places in LLVM code
whether a parameter is constant
and ignore the parameter from the struct in this case.
In many cases there will be no speed benefit
because the parameter will be loaded to a register anyway.
It can only lead to speedup if subsequent optimizations
can precompute constant expressions.
Another example is drop
where a loop with constant loop count can be generated.
For small loop counts and simple loop bodies the loop might get unrolled.
with :: (Storable tuple, MakeValueTuple tuple, ValueTuple tuple ~ value, C value) => T p tuple > (forall parameters. (Storable parameters, MakeValueTuple parameters, C (ValueTuple parameters)) => (p > parameters) > (ValueTuple parameters > value) > a) > aSource
withTuple :: (Tuple tuple, Source tuple ~ p, Composed tuple ~ p) => (tuple > f p) > f pSource
Provide all elements of a nested tuple as separate parameters.
If you do not use one of the tuple elements,
you will get a type error like
Couldn't match type `Param.Composed t0' with
.
The problem is that the type checker cannot infer
that an element is a Int
Parameter.T
if it remains unused.
withTuple1 :: (Tuple tuple, Source tuple ~ p, Composed tuple ~ p) => (tuple > f p a) > f p aSource
withTuple2 :: (Tuple tuple, Source tuple ~ p, Composed tuple ~ p) => (tuple > f p a b) > f p a bSource