Synthesizer.LLVM.Causal.Functional

Documentation

data T inp out

Instances

Applicative (T inp)

Defined in Synthesizer.LLVM.Causal.Functional

Methods

pure :: a -> T inp a

(<*>) :: T inp (a -> b) -> T inp a -> T inp b

liftA2 :: (a -> b -> c) -> T inp a -> T inp b -> T inp c

(*>) :: T inp a -> T inp b -> T inp b

(<*) :: T inp a -> T inp b -> T inp a

Functor (T inp)

Defined in Synthesizer.LLVM.Causal.Functional

Methods

fmap :: (a -> b) -> T inp a -> T inp b

(<$) :: a -> T inp b -> T inp a

(PseudoRing b, Real b, IntegerConstant b) => Num (T a b)

Defined in Synthesizer.LLVM.Causal.Functional

Methods

(+) :: T a b -> T a b -> T a b

(-) :: T a b -> T a b -> T a b

(*) :: T a b -> T a b -> T a b

negate :: T a b -> T a b

abs :: T a b -> T a b

signum :: T a b -> T a b

fromInteger :: Integer -> T a b

(Field b, Real b, RationalConstant b) => Fractional (T a b)

Defined in Synthesizer.LLVM.Causal.Functional

Methods

(/) :: T a b -> T a b -> T a b

recip :: T a b -> T a b

fromRational :: Rational -> T a b

Additive b => C (T a b)

Defined in Synthesizer.LLVM.Causal.Functional

Methods

zero :: T a b

(+) :: T a b -> T a b -> T a b

(-) :: T a b -> T a b -> T a b

negate :: T a b -> T a b

(Transcendental b, RationalConstant b) => C (T a b)

Defined in Synthesizer.LLVM.Causal.Functional

Methods

sqrt :: T a b -> T a b

root :: Integer -> T a b -> T a b

(^/) :: T a b -> Rational -> T a b

(Field b, RationalConstant b) => C (T a b)

Defined in Synthesizer.LLVM.Causal.Functional

Methods

(/) :: T a b -> T a b -> T a b

recip :: T a b -> T a b

fromRational' :: Rational -> T a b

(^-) :: T a b -> Integer -> T a b

(PseudoRing b, IntegerConstant b) => C (T a b)

Defined in Synthesizer.LLVM.Causal.Functional

Methods

(*) :: T a b -> T a b -> T a b

one :: T a b

fromInteger :: Integer -> T a b

(^) :: T a b -> Integer -> T a b

(Transcendental b, RationalConstant b) => C (T a b)

Defined in Synthesizer.LLVM.Causal.Functional

Methods

pi :: T a b

exp :: T a b -> T a b

log :: T a b -> T a b

logBase :: T a b -> T a b -> T a b

(**) :: T a b -> T a b -> T a b

sin :: T a b -> T a b

cos :: T a b -> T a b

tan :: T a b -> T a b

asin :: T a b -> T a b

acos :: T a b -> T a b

atan :: T a b -> T a b

sinh :: T a b -> T a b

cosh :: T a b -> T a b

tanh :: T a b -> T a b

asinh :: T a b -> T a b

acosh :: T a b -> T a b

atanh :: T a b -> T a b

lift :: T inp out -> T inp out

fromSignal :: T out -> T inp out

($&) :: T b c -> T a b -> T a c infixr 0

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

compile :: T inp out -> T inp out

compileSignal :: T () out -> T out

withArgs :: MakeArguments inp => (Arguments (T inp) inp -> T inp out) -> T 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

Minimal complete definition

makeArgs

Instances

MakeArguments ()

Defined in Synthesizer.LLVM.Causal.Functional

Methods

makeArgs :: Functor f => f () -> Arguments f ()

MakeArguments (T a)

Defined in Synthesizer.LLVM.Causal.Functional

Methods

makeArgs :: Functor f => f (T a) -> Arguments f (T a)

MakeArguments (Value a)

Defined in Synthesizer.LLVM.Causal.Functional

Methods

makeArgs :: Functor f => f (Value a) -> Arguments f (Value a)

MakeArguments a => MakeArguments (T a)

Defined in Synthesizer.LLVM.Causal.Functional

Methods

makeArgs :: Functor f => f (T a) -> Arguments f (T a)

MakeArguments (Parameter a)

Defined in Synthesizer.LLVM.Filter.Allpass

Methods

makeArgs :: Functor f => f (Parameter a) -> Arguments f (Parameter a)

MakeArguments (ParameterPacked a)

Defined in Synthesizer.LLVM.Causal.Exponential2

Methods

makeArgs :: Functor f => f (ParameterPacked a) -> Arguments f (ParameterPacked a)

MakeArguments (AnyArg a)

Defined in Synthesizer.LLVM.Causal.Functional

Methods

makeArgs :: Functor f => f (AnyArg a) -> Arguments f (AnyArg a)

MakeArguments (T a)

Defined in Synthesizer.LLVM.MIDI.BendModulation

Methods

makeArgs :: Functor f => f (T a) -> Arguments f (T a)

MakeArguments (CascadeParameter n a)

Defined in Synthesizer.LLVM.Filter.Allpass

Methods

makeArgs :: Functor f => f (CascadeParameter n a) -> Arguments f (CascadeParameter n a)

MakeArguments (ParameterValue n a)

Defined in Synthesizer.LLVM.Filter.SecondOrderCascade

Methods

makeArgs :: Functor f => f (ParameterValue n a) -> Arguments f (ParameterValue n a)

MakeArguments (Constant n a)

Defined in Synthesizer.LLVM.Causal.Functional

Methods

makeArgs :: Functor f => f (Constant n a) -> Arguments f (Constant n a)

(MakeArguments a, MakeArguments b) => MakeArguments (a, b)

Defined in Synthesizer.LLVM.Causal.Functional

Methods

makeArgs :: Functor f => f (a, b) -> Arguments f (a, b)

(MakeArguments a, MakeArguments b, MakeArguments c) => MakeArguments (a, b, c)

Defined in Synthesizer.LLVM.Causal.Functional

Methods

makeArgs :: Functor f => f (a, b, c) -> Arguments f (a, b, c)

type family Arguments (f :: * -> *) arg

Instances

type Arguments f ()

Defined in Synthesizer.LLVM.Causal.Functional

type Arguments f () = f ()

type Arguments f (T a)

Defined in Synthesizer.LLVM.Causal.Functional

type Arguments f (T a) = f (T a)

type Arguments f (Value a)

Defined in Synthesizer.LLVM.Causal.Functional

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

type Arguments f (T a)

Consistent with pair instance. You may use AnyArg or withGuidedArgs to stop descending into the stereo channels.

Defined in Synthesizer.LLVM.Causal.Functional

type Arguments f (T a) = T (Arguments f a)

type Arguments f (Parameter a)

Defined in Synthesizer.LLVM.Filter.Allpass

type Arguments f (Parameter a) = f (Parameter a)

type Arguments f (ParameterPacked a)

Defined in Synthesizer.LLVM.Causal.Exponential2

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

type Arguments f (AnyArg a)

Defined in Synthesizer.LLVM.Causal.Functional

type Arguments f (AnyArg a) = f a

type Arguments f (T a)

Defined in Synthesizer.LLVM.MIDI.BendModulation

type Arguments f (T a) = f (T a)

type Arguments f (CascadeParameter n a)

Defined in Synthesizer.LLVM.Filter.Allpass

type Arguments f (CascadeParameter n a) = f (CascadeParameter n a)

type Arguments f (ParameterValue n a)

Defined in Synthesizer.LLVM.Filter.SecondOrderCascade

type Arguments f (ParameterValue n a) = f (ParameterValue n a)

type Arguments f (Constant n a)

Defined in Synthesizer.LLVM.Causal.Functional

type Arguments f (Constant n a) = f (Constant n a)

type Arguments f (a, b)

Defined in Synthesizer.LLVM.Causal.Functional

type Arguments f (a, b) = (Arguments f a, Arguments f b)

type Arguments f (a, b, c)

Defined in Synthesizer.LLVM.Causal.Functional

type Arguments f (a, b, c) = (Arguments f a, Arguments f b, Arguments f c)

makeArgs :: (MakeArguments arg, Functor f) => f arg -> 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)

Defined in Synthesizer.LLVM.Causal.Functional

Methods

makeArgs :: Functor f => f (AnyArg a) -> Arguments f (AnyArg a)

type Arguments f (AnyArg a)

Defined in Synthesizer.LLVM.Causal.Functional

type Arguments f (AnyArg a) = f a

newtype Ground f a

Constructors

Ground (f a)

Instances

(Functor f, f ~ g) => MakeGroundArguments f (Ground g a)

Defined in Synthesizer.LLVM.Causal.Functional

Methods

makeGroundArgs :: f (GroundArguments (Ground g a)) -> Ground g a

type GroundArguments (Ground f a)

Defined in Synthesizer.LLVM.Causal.Functional

type GroundArguments (Ground f a) = a

withGroundArgs :: (MakeGroundArguments (T inp) args, GroundArguments args ~ inp) => (args -> T inp out) -> T inp out

This is similar to withArgs but it requires to specify the decomposition depth using constructors in the arguments.

class Functor f => MakeGroundArguments f args

Minimal complete definition

makeGroundArgs

Instances

Functor f => MakeGroundArguments f ()

Defined in Synthesizer.LLVM.Causal.Functional

Methods

makeGroundArgs :: f (GroundArguments ()) -> ()

MakeGroundArguments f a => MakeGroundArguments f (T a)

Defined in Synthesizer.LLVM.Causal.Functional

Methods

makeGroundArgs :: f (GroundArguments (T a)) -> T a

(Functor f, f ~ g) => MakeGroundArguments f (Ground g a)

Defined in Synthesizer.LLVM.Causal.Functional

Methods

makeGroundArgs :: f (GroundArguments (Ground g a)) -> Ground g a

(MakeGroundArguments f a, MakeGroundArguments f b) => MakeGroundArguments f (a, b)

Defined in Synthesizer.LLVM.Causal.Functional

Methods

makeGroundArgs :: f (GroundArguments (a, b)) -> (a, b)

(MakeGroundArguments f a, MakeGroundArguments f b, MakeGroundArguments f c) => MakeGroundArguments f (a, b, c)

Defined in Synthesizer.LLVM.Causal.Functional

Methods

makeGroundArgs :: f (GroundArguments (a, b, c)) -> (a, b, c)

type family GroundArguments args

Instances

type GroundArguments ()

Defined in Synthesizer.LLVM.Causal.Functional

type GroundArguments () = ()

type GroundArguments (T a)

Defined in Synthesizer.LLVM.Causal.Functional

type GroundArguments (T a) = T (GroundArguments a)

type GroundArguments (Ground f a)

Defined in Synthesizer.LLVM.Causal.Functional

type GroundArguments (Ground f a) = a

type GroundArguments (a, b)

Defined in Synthesizer.LLVM.Causal.Functional

type GroundArguments (a, b) = (GroundArguments a, GroundArguments b)

type GroundArguments (a, b, c)

Defined in Synthesizer.LLVM.Causal.Functional

type GroundArguments (a, b, c) = (GroundArguments a, GroundArguments b, GroundArguments c)

makeGroundArgs :: MakeGroundArguments f args => f (GroundArguments args) -> args

data Atom a

Constructors

Atom

Instances

MakeGuidedArguments (Atom a)

Defined in Synthesizer.LLVM.Causal.Functional

Methods

makeGuidedArgs :: Functor f => Atom a -> f (PatternArguments (Atom a)) -> GuidedArguments f (Atom a)

type GuidedArguments f (Atom a)

Defined in Synthesizer.LLVM.Causal.Functional

type GuidedArguments f (Atom a) = f a

type PatternArguments (Atom a)

Defined in Synthesizer.LLVM.Causal.Functional

type PatternArguments (Atom a) = a

atom :: Atom a

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

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

class MakeGuidedArguments pat

Minimal complete definition

makeGuidedArgs

Instances

MakeGuidedArguments ()

Defined in Synthesizer.LLVM.Causal.Functional

Methods

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

MakeGuidedArguments a => MakeGuidedArguments (T a)

Defined in Synthesizer.LLVM.Causal.Functional

Methods

makeGuidedArgs :: Functor f => T a -> f (PatternArguments (T a)) -> GuidedArguments f (T a)

MakeGuidedArguments (Atom a)

Defined in Synthesizer.LLVM.Causal.Functional

Methods

makeGuidedArgs :: Functor f => Atom a -> f (PatternArguments (Atom a)) -> GuidedArguments f (Atom a)

(MakeGuidedArguments a, MakeGuidedArguments b) => MakeGuidedArguments (a, b)

Defined in Synthesizer.LLVM.Causal.Functional

Methods

makeGuidedArgs :: Functor f => (a, b) -> f (PatternArguments (a, b)) -> GuidedArguments f (a, b)

(MakeGuidedArguments a, MakeGuidedArguments b, MakeGuidedArguments c) => MakeGuidedArguments (a, b, c)

Defined in Synthesizer.LLVM.Causal.Functional

Methods

makeGuidedArgs :: Functor f => (a, b, c) -> f (PatternArguments (a, b, c)) -> GuidedArguments f (a, b, c)

type family GuidedArguments (f :: * -> *) pat

Instances

type GuidedArguments f ()

Defined in Synthesizer.LLVM.Causal.Functional

type GuidedArguments f () = f ()

type GuidedArguments f (T a)

Defined in Synthesizer.LLVM.Causal.Functional

type GuidedArguments f (T a) = T (GuidedArguments f a)

type GuidedArguments f (Atom a)

Defined in Synthesizer.LLVM.Causal.Functional

type GuidedArguments f (Atom a) = f a

type GuidedArguments f (a, b)

Defined in Synthesizer.LLVM.Causal.Functional

type GuidedArguments f (a, b) = (GuidedArguments f a, GuidedArguments f b)

type GuidedArguments f (a, b, c)

Defined in Synthesizer.LLVM.Causal.Functional

type GuidedArguments f (a, b, c) = (GuidedArguments f a, GuidedArguments f b, GuidedArguments f c)

type family PatternArguments pat

Instances

type PatternArguments ()

Defined in Synthesizer.LLVM.Causal.Functional

type PatternArguments () = ()

type PatternArguments (T a)

Defined in Synthesizer.LLVM.Causal.Functional

type PatternArguments (T a) = T (PatternArguments a)

type PatternArguments (Atom a)

Defined in Synthesizer.LLVM.Causal.Functional

type PatternArguments (Atom a) = a

type PatternArguments (a, b)

Defined in Synthesizer.LLVM.Causal.Functional

type PatternArguments (a, b) = (PatternArguments a, PatternArguments b)

type PatternArguments (a, b, c)

Defined in Synthesizer.LLVM.Causal.Functional

type PatternArguments (a, b, c) = (PatternArguments a, PatternArguments b, PatternArguments c)

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

newtype PrepareArguments f merged separated

Constructors

PrepareArguments (f merged -> separated)

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

Alternative to withGuidedArgs. This way of pattern construction is even Haskell 98.

withPreparedArgs2 :: PrepareArguments (T (inp0, inp1)) inp0 a -> PrepareArguments (T (inp0, inp1)) inp1 b -> (a -> b -> T (inp0, inp1) out) -> T (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)