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

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

compileSignal :: T p () out -> T p out

class MakeArguments arg where

Methods

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

Instances

MakeArguments ()

MakeArguments (Value a)

MakeArguments (T a)

MakeArguments (T a)

MakeArguments (AnyArg a)

MakeArguments (T v)

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

Constructors

AnyArg

Fields

getAnyArg :: a

Instances

MakeArguments (AnyArg a)