Safe Haskell | None |
---|---|
Language | Haskell98 |
- data T p inp out
- lift :: T p inp out -> T p inp out
- fromSignal :: T p out -> T p inp out
- ($&) :: T p b c -> T p a b -> T p a c
- (&|&) :: T p a b -> T p a c -> T p a (b, c)
- compile :: T p inp out -> T p inp out
- compileSignal :: T p () out -> T p out
- withArgs :: MakeArguments inp => (Arguments (T p inp) inp -> T p inp out) -> T p inp out
- class MakeArguments arg where
- type family Arguments f arg
- newtype AnyArg a = AnyArg {
- getAnyArg :: a
- data Atom a = Atom
- atom :: Atom a
- withGuidedArgs :: (MakeGuidedArguments pat, PatternArguments pat ~ inp) => pat -> (GuidedArguments (T p inp) pat -> T p inp out) -> T p inp out
- class MakeGuidedArguments pat where
- makeGuidedArgs :: Functor f => pat -> f (PatternArguments pat) -> GuidedArguments f pat
- type family GuidedArguments f pat
- type family PatternArguments pat
Documentation
Functor (T p inp) | |
Applicative (T p inp) | |
(Field b, Real b, RationalConstant b) => Fractional (T p a b) | |
(PseudoRing b, Real b, IntegerConstant b) => Num (T p a b) | |
(Transcendental b, RationalConstant b) => C (T p a b) | |
(Transcendental b, RationalConstant b) => C (T p a b) | |
(Field b, RationalConstant b) => C (T p a b) | |
(PseudoRing b, IntegerConstant b) => C (T p a b) | |
Additive b => C (T p a b) |
fromSignal :: T p out -> T p inp out Source
compileSignal :: T p () out -> T p out Source
withArgs :: MakeArguments inp => (Arguments (T p inp) inp -> T p inp out) -> T p inp out Source
Using withArgs
you can simplify
let x = F.lift (arr fst) y = F.lift (arr (fst.snd)) z = F.lift (arr (snd.snd)) in F.compile (f x y z)
to
withArgs $ \(x,(y,z)) -> f x y z
class MakeArguments arg where Source
MakeArguments () | |
MakeArguments (Value a) | |
MakeArguments a => MakeArguments (T a) | |
MakeArguments (T a) | |
MakeArguments (T v) | |
MakeArguments (AnyArg a) | |
MakeArguments (ParameterPacked a) | |
(MakeArguments a, MakeArguments b) => MakeArguments (a, b) | |
MakeArguments (Value n a) | |
MakeArguments (CascadeParameter n a) | |
MakeArguments (ParameterValue n a) | |
(MakeArguments a, MakeArguments b, MakeArguments c) => MakeArguments (a, b, c) |
type family Arguments f arg Source
type Arguments f () = f () | |
type Arguments f (AnyArg a) = f a | |
type Arguments f (T v) = f (T v) | |
type Arguments f (T a) = T (Arguments f a) | Consistent with pair instance.
You may use |
type Arguments f (Value a) = f (Value a) | |
type Arguments f (T a) = f (T a) | |
type Arguments f (ParameterPacked a) = f (ParameterPacked a) | |
type Arguments f (a, b) = (Arguments f a, Arguments f b) | |
type Arguments f (Value n a) = f (Value n a) | |
type Arguments f (CascadeParameter n a) = f (CascadeParameter n a) | |
type Arguments f (ParameterValue n a) = f (ParameterValue n a) | |
type Arguments f (a, b, c) = (Arguments f a, Arguments f b, Arguments f c) |
You can use this to explicitly stop breaking of composed data types.
It might be more comfortable to do this using withGuidedArgs
.
MakeArguments (AnyArg a) | |
type Arguments f (AnyArg a) = f a |
MakeGuidedArguments (Atom a) | |
type GuidedArguments f (Atom a) = f a | |
type PatternArguments (Atom a) = a |
withGuidedArgs :: (MakeGuidedArguments pat, PatternArguments pat ~ inp) => pat -> (GuidedArguments (T p inp) pat -> T p inp out) -> T p inp out Source
This is similar to withArgs
but it allows to specify the decomposition depth using a pattern.
class MakeGuidedArguments pat where Source
makeGuidedArgs :: Functor f => pat -> f (PatternArguments pat) -> GuidedArguments f pat Source
MakeGuidedArguments () | |
MakeGuidedArguments a => MakeGuidedArguments (T a) | |
MakeGuidedArguments (Atom a) | |
(MakeGuidedArguments a, MakeGuidedArguments b) => MakeGuidedArguments (a, b) | |
(MakeGuidedArguments a, MakeGuidedArguments b, MakeGuidedArguments c) => MakeGuidedArguments (a, b, c) |
type family GuidedArguments f pat Source
type GuidedArguments f () = f () | |
type GuidedArguments f (T a) = T (GuidedArguments f a) | |
type GuidedArguments f (Atom a) = f a | |
type GuidedArguments f (a, b) = (GuidedArguments f a, GuidedArguments f b) | |
type GuidedArguments f (a, b, c) = (GuidedArguments f a, GuidedArguments f b, GuidedArguments f c) |
type family PatternArguments pat Source
type PatternArguments () = () | |
type PatternArguments (T a) = T (PatternArguments a) | |
type PatternArguments (Atom a) = a | |
type PatternArguments (a, b) = (PatternArguments a, PatternArguments b) | |
type PatternArguments (a, b, c) = (PatternArguments a, PatternArguments b, PatternArguments c) |