Synthesizer.Frame.Stereo

Documentation

data T a :: * -> *

Instances

Functor T

Methods

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

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

Applicative T

Methods

pure :: a -> T a

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

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

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

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

Foldable T

Methods

fold :: Monoid m => T m -> m

foldMap :: Monoid m => (a -> m) -> T a -> m

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

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

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

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

foldr1 :: (a -> a -> a) -> T a -> a

foldl1 :: (a -> a -> a) -> T a -> a

toList :: T a -> [a]

null :: T a -> Bool

length :: T a -> Int

elem :: Eq a => a -> T a -> Bool

maximum :: Ord a => T a -> a

minimum :: Ord a => T a -> a

sum :: Num a => T a -> a

product :: Num a => T a -> a

Traversable T

Methods

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

sequenceA :: Applicative f => T (f a) -> f (T a)

mapM :: Monad m => (a -> m b) -> T a -> m (T b)

sequence :: Monad m => T (m a) -> m (T a)

C a v => C a (T v)

Methods

scaleAndAccumulate :: (a, T v) -> (T v, T v -> T v)

Eq a => Eq (T a)

Methods

(==) :: T a -> T a -> Bool

(/=) :: T a -> T a -> Bool

Show a => Show (T a)

Methods

showsPrec :: Int -> T a -> ShowS

show :: T a -> String

showList :: [T a] -> ShowS

Arbitrary a => Arbitrary (T a)

Methods

arbitrary :: Gen (T a)

shrink :: T a -> [T a]

Storable a => Storable (T a)

Methods

sizeOf :: T a -> Int

alignment :: T a -> Int

peekElemOff :: Ptr (T a) -> Int -> IO (T a)

pokeElemOff :: Ptr (T a) -> Int -> T a -> IO ()

peekByteOff :: Ptr b -> Int -> IO (T a)

pokeByteOff :: Ptr b -> Int -> T a -> IO ()

peek :: Ptr (T a) -> IO (T a)

poke :: Ptr (T a) -> T a -> IO ()

C a => C (T a)

Methods

numberOfChannels :: T a -> Int

sizeOfElement :: T a -> Int

C a => C (T a)

Methods

format :: T a -> T

C a => C (T a)

Methods

outputFromCanonical :: (Bounded int, C int, Monoid out) => (int -> out) -> T a -> out

numberOfChannels :: T a -> Int

left :: T a -> a

right :: T a -> a

cons :: a -> a -> T a

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

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)

data Channel :: *

Constructors

Left

Right

select :: T a -> Channel -> a

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)