synthesizer-dimensional-0.7: Audio signal processing with static physical dimensions

Portabilityrequires multi-parameter type classes and local universal quantification
Safe HaskellNone



Light-weight sample parameter inference which will fit most needs. We only do "poor man's inference", only for sample rates. The sample rate will be provided as an argument of a special type T. This argument will almost never be passed explicitly but should be handled by operators analogous to '($)' and '(.)'.

In contrast to the run-time inference approach, we have the static guarantee that the sample rate is fixed before passing a signal to the outside world. However we still need to make it safe that signals that are rendered for one sample rate are not processed with another sample rate.



newtype T s u t a Source

This wraps a function which computes a sample rate dependent result. Sample rate tells how many values per unit are stored for representation of a signal.

The process is labeled with a type variable s which is part the signals. This way we can ensure that signals are only used with the sample rate they are created for.




process :: T (Recip u) t -> a


Monad (T s u t) 
Functor (T s u t) 
MonadFix (T s u t) 
Applicative (T s u t) 

run :: C u => T (Recip u) t -> (forall s. T s u t a) -> aSource

Get results from the Process monad. You can obtain only signals (or other values) that do not implicitly depend on the sample rate, that is value without the s type parameter.

withParam :: (a -> T s u t b) -> T s u t (a -> b)Source

getSampleRate :: C u => T s u t (T (Recip u) t)Source

toTimeScalar :: (C t, C u) => T u t -> T s u t tSource

toFrequencyScalar :: (C t, C u) => T (Recip u) t -> T s u t tSource

toTimeDimension :: (C t, C u) => t -> T s u t (T u t)Source

toFrequencyDimension :: (C t, C u) => t -> T s u t (T (Recip u) t)Source

intFromTime :: (C t, C u) => String -> T u t -> T s u t IntSource

intFromTime98 :: (C t, RealFrac t, C u) => String -> T u t -> T s u t IntSource

toGradientScalar :: (C q, C u, C v) => T v q -> T (DimensionGradient u v) q -> T s u q qSource

loop :: Functor f => f (a -> a) -> f a

pure :: a -> T s u t aSource

($:) :: Applicative f => f (a -> b) -> f a -> f b

($::) :: (Applicative f, Traversable t) => f (t a -> b) -> t (f a) -> f b

($^) :: Functor f => (a -> b) -> f a -> f b

($#) :: Functor f => f (a -> b) -> a -> f b

(.:) :: (Applicative f, Arrow arrow) => f (arrow b c) -> f (arrow a b) -> f (arrow a c)

(.^) :: (Functor f, Arrow arrow) => arrow b c -> f (arrow a b) -> f (arrow a c)

liftP :: Applicative f => f (a -> b) -> f a -> f b

liftP2 :: Applicative f => f (a -> b -> c) -> f a -> f b -> f c

liftP3 :: Applicative f => f (a -> b -> c -> d) -> f a -> f b -> f c -> f d

liftP4 :: Applicative f => f (a -> b -> c -> d -> e) -> f a -> f b -> f c -> f d -> f e