Safe Haskell | None |
---|
- 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 Ground f a = Ground (f a)
- withGroundArgs :: (MakeGroundArguments (T p inp) args, GroundArguments args ~ inp) => (args -> T p inp out) -> T p inp out
- class Functor f => MakeGroundArguments f args where
- makeGroundArgs :: f (GroundArguments args) -> args
- type family GroundArguments args
- 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
- newtype PrepareArguments f merged separated = PrepareArguments (f merged -> separated)
- withPreparedArgs :: PrepareArguments (T p inp) inp a -> (a -> T p inp out) -> T p inp out
- withPreparedArgs2 :: PrepareArguments (T p (inp0, inp1)) inp0 a -> PrepareArguments (T p (inp0, inp1)) inp1 b -> (a -> b -> T p (inp0, inp1) out) -> T p (inp0, inp1) out
- atomArg :: PrepareArguments f a (f a)
- stereoArgs :: Functor f => PrepareArguments f a b -> PrepareArguments f (T a) (T b)
- pairArgs :: Functor f => PrepareArguments f a0 b0 -> PrepareArguments f a1 b1 -> PrepareArguments f (a0, a1) (b0, b1)
- tripleArgs :: Functor f => PrepareArguments f a0 b0 -> PrepareArguments f a1 b1 -> PrepareArguments f a2 b2 -> PrepareArguments f (a0, a1, a2) (b0, b1, b2)
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 outSource
compileSignal :: T p () out -> T p outSource
withArgs :: MakeArguments inp => (Arguments (T p inp) inp -> T p inp out) -> T p inp outSource
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 whereSource
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) |
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) |
Ground (f a) |
(Functor f, ~ (* -> *) f g) => MakeGroundArguments f (Ground g a) |
withGroundArgs :: (MakeGroundArguments (T p inp) args, GroundArguments args ~ inp) => (args -> T p inp out) -> T p inp outSource
This is similar to withArgs
but it requires to specify the decomposition depth
using constructors in the arguments.
class Functor f => MakeGroundArguments f args whereSource
makeGroundArgs :: f (GroundArguments args) -> argsSource
Functor f => MakeGroundArguments f () | |
MakeGroundArguments f a => MakeGroundArguments f (T a) | |
(MakeGroundArguments f a, MakeGroundArguments f b) => MakeGroundArguments f (a, b) | |
(Functor f, ~ (* -> *) f g) => MakeGroundArguments f (Ground g a) | |
(MakeGroundArguments f a, MakeGroundArguments f b, MakeGroundArguments f c) => MakeGroundArguments f (a, b, c) |
type family GroundArguments args Source
withGuidedArgs :: (MakeGuidedArguments pat, PatternArguments pat ~ inp) => pat -> (GuidedArguments (T p inp) pat -> T p inp out) -> T p inp outSource
This is similar to withArgs
but it allows to specify the decomposition depth using a pattern.
class MakeGuidedArguments pat whereSource
makeGuidedArgs :: Functor f => pat -> f (PatternArguments pat) -> GuidedArguments f patSource
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 family PatternArguments pat Source
newtype PrepareArguments f merged separated Source
PrepareArguments (f merged -> separated) |
withPreparedArgs :: PrepareArguments (T p inp) inp a -> (a -> T p inp out) -> T p inp outSource
Alternative to withGuidedArgs. This way of pattern construction is even Haskell 98.
withPreparedArgs2 :: PrepareArguments (T p (inp0, inp1)) inp0 a -> PrepareArguments (T p (inp0, inp1)) inp1 b -> (a -> b -> T p (inp0, inp1) out) -> T p (inp0, inp1) outSource
atomArg :: PrepareArguments f a (f a)Source
stereoArgs :: Functor f => PrepareArguments f a b -> PrepareArguments f (T a) (T b)Source
pairArgs :: Functor f => PrepareArguments f a0 b0 -> PrepareArguments f a1 b1 -> PrepareArguments f (a0, a1) (b0, b1)Source
tripleArgs :: Functor f => PrepareArguments f a0 b0 -> PrepareArguments f a1 b1 -> PrepareArguments f a2 b2 -> PrepareArguments f (a0, a1, a2) (b0, b1, b2)Source