Synthesizer.LLVM.Frame.Stereo

Re-export functions from Sound.Frame.Stereo and add (orphan) instances for various LLVM type classes. If you want to use the Stereo datatype with synthesizer-llvm we recommend to import this module instead of Sound.Frame.Stereo or Sound.Frame.NumericPrelude.Stereo.

Documentation

data T a :: * -> *

Instances

Functor T

Applicative T

Foldable T

Traversable T

(C a, C a v) => C a (T v)

(Ord a, C a v) => C a (T v)

Sqr a v => Sqr a (T v)

(C a, Sqr a v) => C a (T v)

C a v => C a (T v)

Eq a => Eq (T a)

Show a => Show (T a)

Arbitrary a => Arbitrary (T a)

Storable a => Storable (T a)

C l => C (T l)

Additive a => Additive (T a)

C v => C (T v)

Simple v => Simple (T v)

Undefined a => Undefined (T a)

Zero a => Zero (T a)

MakeValueTuple h => MakeValueTuple (T h)

Select a => Select (T a)

Phi a => Phi (T a)

C a => C (T a)

C a => C (T a)

C a => C (T a)

Sized value => Sized (T value)

Zero v => Zero (T v)

C v => C (T v)

Read v => Read (T v)

Flatten a => Flatten (T a)

MakeGuidedArguments a => MakeGuidedArguments (T a)

MakeArguments a => MakeArguments (T a)

(Arithmetic a, IsConst a, C (Value (State a))) => C (Parameter a) (T (Value a)) (T (Value a))

(PseudoRing a, RationalConstant a, C a) => C (Parameter a) (T a) (T a)

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

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 Struct (T l)

type Size (T v) = Size v

type Element (T v) = T (Element v)

type ValueTuple (T h) = T (ValueTuple h)

type Size (T value) = Size value

type WriteIt (T v) = T (WriteIt v)

type Element (T v) = T (Element v)

type ReadIt (T v) = T (ReadIt v)

type Registers (T a) = T (Registers a)

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

type Input (Parameter a) (T (Value a)) = T (Value a)

type Input (Parameter a) (T a) = T a

type Output (Parameter a) (T (Value a)) = T (Value a)

type Output (Parameter a) (T a) = T a

cons :: a -> a -> T a

left :: T a -> a

right :: T a -> a

data Channel :: *

Constructors

Left

Right

select :: T a -> Channel -> a

arrowFromMono :: Arrow arrow => arrow a b -> arrow (T a) (T b)

Run a causal process independently on each stereo channel.

arrowFromMonoControlled :: Arrow arrow => arrow (c, a) b -> arrow (c, T a) (T b)

arrowFromChannels :: Arrow arrow => arrow a b -> arrow a b -> arrow (T a) (T b)

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

sequence :: Functor f => f (T a) -> T (f a)

liftApplicative :: Applicative f => (f a -> f b) -> f (T a) -> f (T b)