Synthesizer.LLVM.CausalParameterized.Functional

Documentation

data T p inp out

Instances

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)

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 infixr 0

(&|&) :: T p a b -> T p a c -> T p a (b, c) infixr 3

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

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

Methods

makeArgs :: Functor f => f arg -> Arguments f arg

Instances

MakeArguments ()

MakeArguments (Value a)

MakeArguments 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

Instances

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 AnyArg or withGuidedArgs to stop descending into the stereo channels.

type Arguments f (Value a) = f (Value a)

type Arguments f (ParameterPacked a) = f (ParameterPacked a)

type Arguments f (T a) = f (T 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)

newtype AnyArg a

You can use this to explicitly stop breaking of composed data types. It might be more comfortable to do this using withGuidedArgs.

Constructors

AnyArg

Fields

getAnyArg :: a

Instances

MakeArguments (AnyArg a)

type Arguments f (AnyArg a) = f a

data Atom a

Constructors

Atom

Instances

MakeGuidedArguments (Atom a)

type GuidedArguments f (Atom a) = f a

type PatternArguments (Atom a) = a

atom :: Atom a

withGuidedArgs :: (MakeGuidedArguments pat, PatternArguments pat ~ inp) => pat -> (GuidedArguments (T p inp) pat -> T p inp out) -> T p inp out

This is similar to withArgs but it allows to specify the decomposition depth using a pattern.

class MakeGuidedArguments pat where

Methods

makeGuidedArgs :: Functor f => pat -> f (PatternArguments pat) -> GuidedArguments f pat

Instances

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

Instances

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

Instances

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)

data PrepareArguments f merged separated

withPreparedArgs :: PrepareArguments (T p inp) inp a -> (a -> T p inp out) -> T p inp out

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) 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)