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

(&|&) :: 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

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

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)

data Atom a

Constructors

Atom

Instances

MakeGuidedArguments (Atom 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

type family PatternArguments pat

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)