Csound.Typed.Types.Tuple

Tuple

class Tuple a where

A tuple of Csound values.

Minimal complete definition

tupleMethods

Methods

tupleMethods :: TupleMethods a

Instances

Tuple TabList

Methods

tupleMethods :: TupleMethods TabList

Tuple Tab

Methods

tupleMethods :: TupleMethods Tab

Tuple Unit

Methods

tupleMethods :: TupleMethods Unit

Tuple Spec

Methods

tupleMethods :: TupleMethods Spec

Tuple Str

Methods

tupleMethods :: TupleMethods Str

Tuple D

Methods

tupleMethods :: TupleMethods D

Tuple Sig

Methods

tupleMethods :: TupleMethods Sig

Tuple MonoArg

Methods

tupleMethods :: TupleMethods MonoArg

(Tuple a, Tuple b) => Tuple (a, b)

Methods

tupleMethods :: TupleMethods (a, b)

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

Methods

tupleMethods :: TupleMethods (a, b, c)

(Tuple a, Tuple b, Tuple c, Tuple d) => Tuple (a, b, c, d)

Methods

tupleMethods :: TupleMethods (a, b, c, d)

(Tuple a, Tuple b, Tuple c, Tuple d, Tuple e) => Tuple (a, b, c, d, e)

Methods

tupleMethods :: TupleMethods (a, b, c, d, e)

(Tuple a, Tuple b, Tuple c, Tuple d, Tuple e, Tuple f) => Tuple (a, b, c, d, e, f)

Methods

tupleMethods :: TupleMethods (a, b, c, d, e, f)

(Tuple a, Tuple b, Tuple c, Tuple d, Tuple e, Tuple f, Tuple g) => Tuple (a, b, c, d, e, f, g)

Methods

tupleMethods :: TupleMethods (a, b, c, d, e, f, g)

(Tuple a, Tuple b, Tuple c, Tuple d, Tuple e, Tuple f, Tuple g, Tuple h) => Tuple (a, b, c, d, e, f, g, h)

Methods

tupleMethods :: TupleMethods (a, b, c, d, e, f, g, h)

data TupleMethods a

makeTupleMethods :: Tuple a => (a -> b) -> (b -> a) -> TupleMethods b

Defines instance of type class Tuple for a new type in terms of an already defined one.

fromTuple :: Tuple a => a -> GE [E]

toTuple :: Tuple a => GE [E] -> a

tupleArity :: Tuple a => a -> Int

tupleRates :: Tuple a => a -> [Rate]

defTuple :: Tuple a => a

mapTuple :: Tuple a => (E -> E) -> a -> a

Outs

class (Tuple a, Num a, Fractional a, SigSpace a, BindSig a) => Sigs a

The tuples of signals.

Instances

Sigs Sig

(Sigs a1, Sigs a2) => Sigs (a1, a2)

(Sigs a1, Sigs a2, Sigs a3) => Sigs (a1, a2, a3)

(Sigs a1, Sigs a2, Sigs a3, Sigs a4) => Sigs (a1, a2, a3, a4)

(Sigs a1, Sigs a2, Sigs a3, Sigs a4, Sigs a5) => Sigs (a1, a2, a3, a4, a5)

(Sigs a1, Sigs a2, Sigs a3, Sigs a4, Sigs a5, Sigs a6) => Sigs (a1, a2, a3, a4, a5, a6)

(Sigs a1, Sigs a2, Sigs a3, Sigs a4, Sigs a5, Sigs a6, Sigs a7) => Sigs (a1, a2, a3, a4, a5, a6, a7)

(Sigs a1, Sigs a2, Sigs a3, Sigs a4, Sigs a5, Sigs a6, Sigs a7, Sigs a8) => Sigs (a1, a2, a3, a4, a5, a6, a7, a8)

outArity :: Tuple a => SE a -> Int

class (Sigs a, SigSpace2 a, BindSig2 a) => Sig2s a

Instances

Sig2s Sig8

Sig2s Sig6

Sig2s Sig4

Sig2s Sig2

Sig2s Sig

Multiple outs

multiOuts :: Tuple a => E -> a

ar1 :: Sig -> Sig

ar2 :: (Sig, Sig) -> (Sig, Sig)

ar4 :: (Sig, Sig, Sig, Sig) -> (Sig, Sig, Sig, Sig)

ar6 :: (Sig, Sig, Sig, Sig, Sig, Sig) -> (Sig, Sig, Sig, Sig, Sig, Sig)

ar8 :: (Sig, Sig, Sig, Sig, Sig, Sig, Sig, Sig) -> (Sig, Sig, Sig, Sig, Sig, Sig, Sig, Sig)

Arguments

class Tuple a => Arg a

Instances

Arg TabList

Arg Tab

Arg Unit

Arg Str

Arg D

(Arg a, Arg b) => Arg (a, b)

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

(Arg a, Arg b, Arg c, Arg d) => Arg (a, b, c, d)

(Arg a, Arg b, Arg c, Arg d, Arg e) => Arg (a, b, c, d, e)

(Arg a, Arg b, Arg c, Arg d, Arg e, Arg f) => Arg (a, b, c, d, e, f)

(Arg a, Arg b, Arg c, Arg d, Arg e, Arg f, Arg h) => Arg (a, b, c, d, e, f, h)

(Arg a, Arg b, Arg c, Arg d, Arg e, Arg f, Arg h, Arg g) => Arg (a, b, c, d, e, f, h, g)

arg :: Arg a => Int -> a

toNote :: Arg a => a -> GE [E]

argArity :: Arg a => a -> Int

toArg :: Arg a => a

Logic functions

ifTuple :: Tuple a => BoolSig -> a -> a -> a

ifB for tuples of csound values.

guardedTuple :: Tuple b => [(BoolSig, b)] -> b -> b

guardedB for tuples of csound values.

caseTuple :: Tuple b => a -> [(a -> BoolSig, b)] -> b -> b

caseB for tuples of csound values.

ifArg :: (Arg a, Tuple a) => BoolD -> a -> a -> a

ifB for constants.

guardedArg :: (Tuple b, Arg b) => [(BoolD, b)] -> b -> b

guardedB for constants.

caseArg :: (Tuple b, Arg b) => a -> [(a -> BoolD, b)] -> b -> b

caseB for constants.

Constructors

pureTuple :: Tuple a => GE (MultiOut [E]) -> a

dirtyTuple :: Tuple a => GE (MultiOut [E]) -> SE a