Safe Haskell	Safe-Inferred
Language	Haskell2010

Csound.Types

Contents

Primitive types
Tuples
- Logic functions
Instruments
Arrays
Pure Arrays (read-only)
- Spectral opcodes

Description

The Csound types.

There are several primitive types:

Sig - signals
D - numbers
Str - strings
Tab - 1-dimensional arrays
Spec and Wspec - sound spectrums

A signal is a stream of numbers. Signals carry sound or time varied control values. Numbers are constants. 1-dimensional arrays contain some useful data which is calculated at the initial run of the program.

There is only one compound type. It's a tuple of Csound values. The empty tuple is signified with special type called Unit.

Synopsis

data Sig
data D
data Tab
data Str
data Spec
data Wspec
data BoolSig
data BoolD
class Val a where
- fromGE :: GE E -> a
- toGE :: a -> GE E
- fromE :: E -> a
class (IsPrim a, RealFrac (PrimOf a), Val a, Floating a) => SigOrD a
type Sig2 = (Sig, Sig)
type Sig3 = (Sig, Sig, Sig)
type Sig4 = (Sig, Sig, Sig, Sig)
type Sig5 = (Sig, Sig, Sig, Sig, Sig)
type Sig6 = (Sig, Sig, Sig, Sig, Sig, Sig)
type Sig8 = (Sig, Sig, Sig, Sig, Sig, Sig, Sig, Sig)
type Sig2_2 = (Sig2, Sig2)
type Sig2_3 = (Sig2, Sig2, Sig2)
type Sig2_4 = (Sig2, Sig2, Sig2, Sig2)
type Sig2_5 = (Sig2, Sig2, Sig2, Sig2, Sig2)
type Sig2_6 = (Sig2, Sig2, Sig2, Sig2, Sig2, Sig2)
type Sig2_7 = (Sig2, Sig2, Sig2, Sig2, Sig2, Sig2, Sig2)
type Sig2_8 = (Sig2, Sig2, Sig2, Sig2, Sig2, Sig2, Sig2, Sig2)
double :: Double -> D
int :: Int -> D
text :: String -> Str
idur :: D
getSampleRate :: D
getControlRate :: D
getBlockSize :: D
getBpm :: Sig
setBpm :: Sig -> SE ()
syn :: Sig -> Sig
takt :: Sig -> Sig
ar :: Sig -> Sig
kr :: Sig -> Sig
ir :: Sig -> D
sig :: D -> Sig
withInits :: (Tuple a, Tuple b) => a -> b -> a
withDs :: Tuple a => a -> [D] -> a
withSigs :: Tuple a => a -> [Sig] -> a
withTabs :: Tuple a => a -> [Tab] -> a
withD :: Tuple a => a -> D -> a
withSig :: Tuple a => a -> Sig -> a
withTab :: Tuple a => a -> Tab -> a
withSeed :: SE Sig -> D -> Sig
quot' :: SigOrD a => a -> a -> a
rem' :: SigOrD a => a -> a -> a
div' :: SigOrD a => a -> a -> a
mod' :: SigOrD a => a -> a -> a
ceil' :: SigOrD a => a -> a
floor' :: SigOrD a => a -> a
round' :: SigOrD a => a -> a
int' :: SigOrD a => a -> a
frac' :: SigOrD a => a -> a
boolSig :: BoolD -> BoolSig
when1 :: BoolSig -> SE () -> SE ()
whens :: [(BoolSig, SE ())] -> SE () -> SE ()
whenElse :: BoolSig -> SE () -> SE () -> SE ()
whenD1 :: BoolD -> SE () -> SE ()
whenDs :: [(BoolD, SE ())] -> SE () -> SE ()
whileDo :: BoolSig -> SE () -> SE ()
untilDo :: BoolSig -> SE () -> SE ()
whileDoD :: BoolD -> SE () -> SE ()
untilDoD :: BoolD -> SE () -> SE ()
whenElseD :: BoolD -> SE () -> SE () -> SE ()
compareWhenD :: D -> [(D, SE ())] -> SE ()
equalsTo :: EqB a => a -> a -> BooleanOf a
notEqualsTo :: EqB a => a -> a -> BooleanOf a
lessThan :: OrdB a => a -> a -> BooleanOf a
greaterThan :: OrdB a => a -> a -> BooleanOf a
lessThanEquals :: OrdB a => a -> a -> BooleanOf a
greaterThanEquals :: OrdB a => a -> a -> BooleanOf 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)
class Tuple a where
- tupleMethods :: TupleMethods a
makeTupleMethods :: Tuple a => (a -> b) -> (b -> a) -> TupleMethods b
data Unit
unit :: Unit
atTuple :: Tuple a => [a] -> Sig -> a
ifTuple :: Tuple a => BoolSig -> a -> a -> a
guardedTuple :: Tuple b => [(BoolSig, b)] -> b -> b
caseTuple :: Tuple b => a -> [(a -> BoolSig, b)] -> b -> b
class Tuple a => Arg a
atArg :: Tuple a => [a] -> Sig -> a
ifArg :: (Arg a, Tuple a) => BoolSig -> a -> a -> a
guardedArg :: Tuple b => [(BoolSig, b)] -> b -> b
caseArg :: (Tuple b, Arg b) => a -> [(a -> BoolSig, b)] -> b -> b
data MonoArg = MonoArg {
- monoAmp :: Sig
- monoCps :: Sig
- monoGate :: Sig
- monoTrig :: Sig
}
type MonoAdsr = Sig -> Sig -> Sig -> Sig -> Sig
adsrMonoSynt :: (MonoAdsr -> (Sig, Sig) -> a) -> MonoArg -> a
monoAdsr :: MonoArg -> MonoAdsr
class (Tuple a, Num a, Fractional a, SigSpace a, BindSig a) => Sigs a
data Arr ix a
newLocalArr :: (Tuple a, Tuple ix) => [D] -> SE (Arr ix a)
newGlobalArr :: (Tuple a, Tuple ix) => [D] -> SE (Arr ix a)
newLocalCtrlArr :: (Tuple a, Tuple ix) => [D] -> SE (Arr ix a)
newGlobalCtrlArr :: (Tuple a, Tuple ix) => [D] -> SE (Arr ix a)
writeArr :: (Tuple ix, Tuple a) => Arr ix a -> ix -> a -> SE ()
readArr :: (Tuple a, Tuple ix) => Arr ix a -> ix -> SE a
modifyArr :: (Tuple a, Tuple ix) => Arr ix a -> ix -> (a -> a) -> SE ()
mixArr :: (Tuple ix, Tuple a, Num a) => Arr ix a -> ix -> a -> SE ()
type Arr1 a = Arr Sig a
type DArr1 a = Arr D a
type Arr2 a = Arr (Sig, Sig) a
type DArr2 a = Arr (D, D) a
type Arr3 a = Arr (Sig, Sig, Sig) a
type DArr3 a = Arr (D, D, D) a
arr1 :: SE (Arr Sig a) -> SE (Arr Sig a)
darr1 :: SE (Arr D a) -> SE (Arr D a)
arr2 :: SE (Arr (Sig, Sig) a) -> SE (Arr (Sig, Sig) a)
darr2 :: SE (Arr (D, D) a) -> SE (Arr (D, D) a)
arr3 :: SE (Arr (Sig, Sig, Sig) a) -> SE (Arr (Sig, Sig, Sig) a)
darr3 :: SE (Arr (D, D, D) a) -> SE (Arr (D, D, D) a)
foreachArr :: (Tuple ix, Tuple a) => Arr ix a -> ((ix, a) -> SE ()) -> SE ()
foreachArrD :: (Tuple ix, Tuple a) => Arr ix a -> ((ix, a) -> SE ()) -> SE ()
forRowArr :: Tuple a => Sig -> Arr Sig2 a -> ((Sig, a) -> SE ()) -> SE ()
forColumnArr :: Tuple a => Sig -> Arr Sig2 a -> ((Sig, a) -> SE ()) -> SE ()
forRowArrD :: Tuple a => D -> Arr D2 a -> ((D, a) -> SE ()) -> SE ()
forColumnArrD :: Tuple a => D -> Arr D2 a -> ((D, a) -> SE ()) -> SE ()
foldArr :: (Tuple ix, Tuple a, Tuple b) => ((ix, a) -> b -> SE b) -> b -> Arr ix a -> SE b
foldRowArr :: (Tuple a, Tuple b) => ((Sig, a) -> b -> SE b) -> b -> Sig -> Arr Sig2 a -> SE b
foldColumnArr :: (Tuple a, Tuple b) => ((Sig, a) -> b -> SE b) -> b -> Sig -> Arr Sig2 a -> SE b
foldRowsArrD :: (Tuple a, Tuple b) => ((D, a) -> b -> SE b) -> b -> D -> Arr D2 a -> SE b
foldColumnsArrD :: (Tuple a, Tuple b) => ((D, a) -> b -> SE b) -> b -> D -> Arr D2 a -> SE b
fillLocalArr :: (Tuple a, Tuple ix) => [Int] -> [a] -> SE (Arr ix a)
fillGlobalArr :: (Tuple a, Tuple ix) => [Int] -> [a] -> SE (Arr ix a)
fillLocalCtrlArr :: (Tuple a, Tuple ix) => [Int] -> [a] -> SE (Arr ix a)
fillGlobalCtrlArr :: (Tuple a, Tuple ix) => [Int] -> [a] -> SE (Arr ix a)
maparrayNew :: Arr a b -> Str -> SE (Arr a b)
lenarray :: SigOrD c => Arr a b -> c
copyf2array :: Arr Sig Sig -> Tab -> SE ()
copya2ftab :: Arr Sig Sig -> Tab -> SE ()
minarray :: (Tuple b, Num b) => Arr a b -> SE b
maxarray :: (Tuple b, Num b) => Arr a b -> SE b
sumarray :: (Tuple b, Num b) => Arr a b -> SE b
scalearray :: (Tuple b, Num b) => Arr a b -> (b, b) -> SE ()
slicearrayNew :: Arr D a -> (D, D) -> SE (Arr D a)
maparrayCopy :: Arr a b -> Str -> Arr a b -> SE ()
slicearrayCopy :: Arr D a -> (D, D) -> Arr D a -> SE ()
data PureArr a
newPureArr :: Tuple a => [a] -> PureArr a
readPureArr :: Tuple a => PureArr a -> Sig -> a
data PureArrD a
newPureArrD :: Arg a => [a] -> PureArrD a
readPureArrD :: Arg a => PureArrD a -> D -> a
type SpecArr = Arr Sig Sig
fftNew :: SpecArr -> SE SpecArr
fftinvNew :: SpecArr -> SE SpecArr
rfftNew :: SpecArr -> SE SpecArr
rifftNew :: SpecArr -> SE SpecArr
pvs2tab :: SpecArr -> Spec -> SE Sig
tab2pvs :: SpecArr -> SE Spec
cmplxprodNew :: SpecArr -> SpecArr -> SE SpecArr
rect2polNew :: SpecArr -> SE SpecArr
pol2rectNew :: SpecArr -> SE SpecArr
pol2rect2New :: SpecArr -> SpecArr -> SE SpecArr
windowArrayNew :: SpecArr -> SE SpecArr
r2cNew :: SpecArr -> SE SpecArr
c2rNew :: SpecArr -> SE SpecArr
magsArrayNew :: SpecArr -> SE SpecArr
phsArrayNew :: SpecArr -> SE SpecArr
fftCopy :: SpecArr -> SpecArr -> SE ()
fftinvCopy :: SpecArr -> SpecArr -> SE ()
rfftCopy :: SpecArr -> SpecArr -> SE ()
rifftCopy :: SpecArr -> SpecArr -> SE ()
cmplxprodCopy :: SpecArr -> SpecArr -> SpecArr -> SE ()
rect2polCopy :: SpecArr -> SpecArr -> SE ()
pol2rectCopy :: SpecArr -> SpecArr -> SE ()
pol2rect2Copy :: SpecArr -> SpecArr -> SpecArr -> SE ()
windowArrayCopy :: SpecArr -> SpecArr -> SE ()
r2cCopy :: SpecArr -> SpecArr -> SE ()
c2rCopy :: SpecArr -> SpecArr -> SE ()
magsArrayCopy :: SpecArr -> SpecArr -> SE ()
phsArrayCopy :: SpecArr -> SpecArr -> SE ()

Boolean BoolD
Instance details Defined in Csound.Typed.Types.Prim Methods true :: BoolD # false :: BoolD # notB :: BoolD -> BoolD # (&&) :: BoolD -> BoolD -> BoolD # (\|\|) :: BoolD -> BoolD -> BoolD #
IsPrim BoolD
Instance details Defined in Csound.Typed.Types.Prim Associated Types type PrimOf BoolD Methods getPrim :: BoolD -> Maybe (PrimOf BoolD) fromPrim :: PrimOf BoolD -> BoolD
Val BoolD
Instance details Defined in Csound.Typed.Types.Prim Methods fromGE :: GE E -> BoolD # toGE :: BoolD -> GE E # fromE :: E -> BoolD #
type PrimOf BoolD
Instance details Defined in Csound.Typed.Types.Prim type PrimOf BoolD = Bool

class Val a where #

Contains all Csound values.

Minimal complete definition

fromGE, toGE

Methods

fromGE :: GE E -> a #

toGE :: a -> GE E #

fromE :: E -> a #

Instances

Instances details

Val Sf
Instance details Defined in Csound.Typed.Control.Sf2 Methods fromGE :: GE E -> Sf # toGE :: Sf -> GE E # fromE :: E -> Sf #
Val BoolD
Instance details Defined in Csound.Typed.Types.Prim Methods fromGE :: GE E -> BoolD # toGE :: BoolD -> GE E # fromE :: E -> BoolD #
Val BoolSig
Instance details Defined in Csound.Typed.Types.Prim Methods fromGE :: GE E -> BoolSig # toGE :: BoolSig -> GE E # fromE :: E -> BoolSig #
Val D
Instance details Defined in Csound.Typed.Types.Prim Methods fromGE :: GE E -> D # toGE :: D -> GE E # fromE :: E -> D #
Val Sig
Instance details Defined in Csound.Typed.Types.Prim Methods fromGE :: GE E -> Sig # toGE :: Sig -> GE E # fromE :: E -> Sig #
Val Spec
Instance details Defined in Csound.Typed.Types.Prim Methods fromGE :: GE E -> Spec # toGE :: Spec -> GE E # fromE :: E -> Spec #
Val Str
Instance details Defined in Csound.Typed.Types.Prim Methods fromGE :: GE E -> Str # toGE :: Str -> GE E # fromE :: E -> Str #
Val Tab
Instance details Defined in Csound.Typed.Types.Prim Methods fromGE :: GE E -> Tab # toGE :: Tab -> GE E # fromE :: E -> Tab #
Val TabList
Instance details Defined in Csound.Typed.Types.Prim Methods fromGE :: GE E -> TabList # toGE :: TabList -> GE E # fromE :: E -> TabList #
Val Wspec
Instance details Defined in Csound.Typed.Types.Prim Methods fromGE :: GE E -> Wspec # toGE :: Wspec -> GE E # fromE :: E -> Wspec #

class (IsPrim a, RealFrac (PrimOf a), Val a, Floating a) => SigOrD a #

Instances

Instances details

SigOrD D
Instance details Defined in Csound.Typed.Types.Prim
SigOrD Sig
Instance details Defined in Csound.Typed.Types.Prim

type Sig2 = (Sig, Sig) #

type Sig3 = (Sig, Sig, Sig) #

type Sig4 = (Sig, Sig, Sig, Sig) #

type Sig5 = (Sig, Sig, Sig, Sig, Sig) #

type Sig6 = (Sig, Sig, Sig, Sig, Sig, Sig) #

type Sig8 = (Sig, Sig, Sig, Sig, Sig, Sig, Sig, Sig) #

type Sig2_2 = (Sig2, Sig2) #

type Sig2_3 = (Sig2, Sig2, Sig2) #

type Sig2_4 = (Sig2, Sig2, Sig2, Sig2) #

type Sig2_5 = (Sig2, Sig2, Sig2, Sig2, Sig2) #

type Sig2_6 = (Sig2, Sig2, Sig2, Sig2, Sig2, Sig2) #

type Sig2_7 = (Sig2, Sig2, Sig2, Sig2, Sig2, Sig2, Sig2) #

type Sig2_8 = (Sig2, Sig2, Sig2, Sig2, Sig2, Sig2, Sig2, Sig2) #

Constructors

double :: Double -> D #

Constructs a number.

int :: Int -> D #

Constructs an integer.

text :: String -> Str #

Constructs a string.

Constants

idur :: D #

Querries a total duration of the note. It's equivallent to Csound's p3 field.

getSampleRate :: D #

getControlRate :: D #

getBlockSize :: D #

BPM

getBpm :: Sig #

Gets the global BPM value.

setBpm :: Sig -> SE () #

Sets the global BPM value.

syn :: Sig -> Sig Source #

It's used to synchronize changes with BPM. Useful with LFO's or delay times.

takt :: Sig -> Sig Source #

Calculates seconditions in ratio to global BPM. It measures time according to changes in the BPM. It's reciprocal to syn.

Converters

ar :: Sig -> Sig #

Sets a rate of the signal to audio rate.

kr :: Sig -> Sig #

Sets a rate of the signal to control rate.

ir :: Sig -> D #

Converts a signal to the number (initial value of the signal).

sig :: D -> Sig #

Makes a constant signal from the number.

Init values

withInits :: (Tuple a, Tuple b) => a -> b -> a #

Appends initialisation arguments. It's up to user to supply arguments with the right types. For example:

oscil 0.5 440 sinWave `withInits` (0.5 :: D)

withDs :: Tuple a => a -> [D] -> a #

A special case of withInits. Here all inits are numbers.

withSigs :: Tuple a => a -> [Sig] -> a #

A special case of withInits. Here all inits are signals.

withTabs :: Tuple a => a -> [Tab] -> a #

A special case of withInits. Here all inits are arrays.

withD :: Tuple a => a -> D -> a #

Appends an init value which is a number.

withSig :: Tuple a => a -> Sig -> a #

Appends an init value which is a signal.

withTab :: Tuple a => a -> Tab -> a #

Appends an init value which is a table.

withSeed :: SE Sig -> D -> Sig #

Applies a seed to the random value. It's equivalent to the withD but it has a special meaning of canceling the side effect. When random opcode is provided with seed value it's no longer contains a side effect so we don't need to restrict it.

Numeric functions

quot' :: SigOrD a => a -> a -> a #

rem' :: SigOrD a => a -> a -> a #

div' :: SigOrD a => a -> a -> a #

mod' :: SigOrD a => a -> a -> a #

ceil' :: SigOrD a => a -> a #

floor' :: SigOrD a => a -> a #

round' :: SigOrD a => a -> a #

int' :: SigOrD a => a -> a #

frac' :: SigOrD a => a -> a #

Logic functions

boolSig :: BoolD -> BoolSig #

Creates a constant boolean signal.

when1 :: BoolSig -> SE () -> SE () #

Invokes the given procedure if the boolean signal is true.

whens :: [(BoolSig, SE ())] -> SE () -> SE () #

The chain of when1s. Tests all the conditions in sequence if everything is false it invokes the procedure given in the second argument.

whenElse :: BoolSig -> SE () -> SE () -> SE () Source #

whenD1 :: BoolD -> SE () -> SE () #

Invokes the given procedure if the boolean signal is true.

whenDs :: [(BoolD, SE ())] -> SE () -> SE () #

The chain of when1s. Tests all the conditions in sequence if everything is false it invokes the procedure given in the second argument.

whileDo :: BoolSig -> SE () -> SE () #

untilDo :: BoolSig -> SE () -> SE () #

whileDoD :: BoolD -> SE () -> SE () #

untilDoD :: BoolD -> SE () -> SE () #

whenElseD :: BoolD -> SE () -> SE () -> SE () Source #

compareWhenD :: D -> [(D, SE ())] -> SE () Source #

Performs tree search f the first argument lies within the interval it performs the corresponding procedure.

equalsTo :: EqB a => a -> a -> BooleanOf a infix 4 #

notEqualsTo :: EqB a => a -> a -> BooleanOf a infix 4 #

lessThan :: OrdB a => a -> a -> BooleanOf a infix 4 #

greaterThan :: OrdB a => a -> a -> BooleanOf a infix 4 #

lessThanEquals :: OrdB a => a -> a -> BooleanOf a infix 4 #

greaterThanEquals :: OrdB a => a -> a -> BooleanOf a infix 4 #

Aliases

Handy for functions that return tuples to specify the utput type

(aleft, aright) = ar2 $ diskin2 "file.wav" 1

or

asig = ar1 $ diskin2 "file.wav" 1

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) #

Tuples

class Tuple a where #

A tuple of Csound values.

Methods

tupleMethods :: TupleMethods a #

Instances

Instances details

Tuple Temp Source #
Instance details Defined in Csound.Tuning Methods tupleMethods :: TupleMethods Temp #
Tuple TempList Source #
Instance details Defined in Csound.Tuning Methods tupleMethods :: TupleMethods TempList #
Tuple MonoArg
Instance details Defined in Csound.Typed.Types.MonoArg Methods tupleMethods :: TupleMethods MonoArg #
Tuple D
Instance details Defined in Csound.Typed.Types.Tuple Methods tupleMethods :: TupleMethods D #
Tuple Sig
Instance details Defined in Csound.Typed.Types.Tuple Methods tupleMethods :: TupleMethods Sig #
Tuple Spec
Instance details Defined in Csound.Typed.Types.Tuple Methods tupleMethods :: TupleMethods Spec #
Tuple Str
Instance details Defined in Csound.Typed.Types.Tuple Methods tupleMethods :: TupleMethods Str #
Tuple Tab
Instance details Defined in Csound.Typed.Types.Tuple Methods tupleMethods :: TupleMethods Tab #
Tuple TabList
Instance details Defined in Csound.Typed.Types.Tuple Methods tupleMethods :: TupleMethods TabList #
Tuple Unit
Instance details Defined in Csound.Typed.Types.Tuple Methods tupleMethods :: TupleMethods Unit #
(Tuple a, Tuple b) => Tuple (a, b)
Instance details Defined in Csound.Typed.Types.Tuple Methods tupleMethods :: TupleMethods (a, b) #
(Tuple a, Tuple b, Tuple c) => Tuple (a, b, c)
Instance details Defined in Csound.Typed.Types.Tuple Methods tupleMethods :: TupleMethods (a, b, c) #
(Tuple a, Tuple b, Tuple c, Tuple d) => Tuple (a, b, c, d)
Instance details Defined in Csound.Typed.Types.Tuple Methods tupleMethods :: TupleMethods (a, b, c, d) #
(Tuple a, Tuple b, Tuple c, Tuple d, Tuple e) => Tuple (a, b, c, d, e)
Instance details Defined in Csound.Typed.Types.Tuple 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)
Instance details Defined in Csound.Typed.Types.Tuple 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)
Instance details Defined in Csound.Typed.Types.Tuple 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)
Instance details Defined in Csound.Typed.Types.Tuple Methods tupleMethods :: TupleMethods (a, b, c, d, e, f, g, h) #

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.

data Unit #

Csound's empty tuple.

Instances

Instances details

Monoid Unit
Instance details Defined in Csound.Typed.Types.Prim Methods mempty :: Unit # mappend :: Unit -> Unit -> Unit # mconcat :: [Unit] -> Unit #
Semigroup Unit
Instance details Defined in Csound.Typed.Types.Prim Methods (<>) :: Unit -> Unit -> Unit # sconcat :: NonEmpty Unit -> Unit # stimes :: Integral b => b -> Unit -> Unit #
Arg Unit
Instance details Defined in Csound.Typed.Types.Tuple Methods getArgRates :: [Rate]
Tuple Unit
Instance details Defined in Csound.Typed.Types.Tuple Methods tupleMethods :: TupleMethods Unit #
Default Unit
Instance details Defined in Csound.Typed.Types.Prim Methods def :: Unit #

unit :: Unit #

Constructs Csound's empty tuple.

atTuple :: Tuple a => [a] -> Sig -> a Source #

Gets an control/audio-rate value from the list by index.

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.

Instruments

An instrument is a function that takes a tpule of csound values as an argument and returns a tuple of signals as an output. The type of the instrument is:

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

Arguments

class Tuple a => Arg a #

Minimal complete definition

getArgRates

Instances

Instances details

Arg Temp Source #
Instance details Defined in Csound.Tuning Methods getArgRates :: [Rate]
Arg TempList Source #
Instance details Defined in Csound.Tuning Methods getArgRates :: [Rate]
Arg D
Instance details Defined in Csound.Typed.Types.Tuple Methods getArgRates :: [Rate]
Arg Str
Instance details Defined in Csound.Typed.Types.Tuple Methods getArgRates :: [Rate]
Arg Tab
Instance details Defined in Csound.Typed.Types.Tuple Methods getArgRates :: [Rate]
Arg TabList
Instance details Defined in Csound.Typed.Types.Tuple Methods getArgRates :: [Rate]
Arg Unit
Instance details Defined in Csound.Typed.Types.Tuple Methods getArgRates :: [Rate]
(Arg a, Arg b) => Arg (a, b)
Instance details Defined in Csound.Typed.Types.Tuple Methods getArgRates :: [Rate]
(Arg a, Arg b, Arg c) => Arg (a, b, c)
Instance details Defined in Csound.Typed.Types.Tuple Methods getArgRates :: [Rate]
(Arg a, Arg b, Arg c, Arg d) => Arg (a, b, c, d)
Instance details Defined in Csound.Typed.Types.Tuple Methods getArgRates :: [Rate]
(Arg a, Arg b, Arg c, Arg d, Arg e) => Arg (a, b, c, d, e)
Instance details Defined in Csound.Typed.Types.Tuple Methods getArgRates :: [Rate]
(Arg a, Arg b, Arg c, Arg d, Arg e, Arg f) => Arg (a, b, c, d, e, f)
Instance details Defined in Csound.Typed.Types.Tuple Methods getArgRates :: [Rate]
(Arg a, Arg b, Arg c, Arg d, Arg e, Arg f, Arg h) => Arg (a, b, c, d, e, f, h)
Instance details Defined in Csound.Typed.Types.Tuple Methods getArgRates :: [Rate]
(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)
Instance details Defined in Csound.Typed.Types.Tuple Methods getArgRates :: [Rate]

atArg :: Tuple a => [a] -> Sig -> a Source #

Gets an init-rate value from the list by index.

Logic functions

ifArg :: (Arg a, Tuple a) => BoolSig -> a -> a -> a #

ifB for constants.

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

guardedB for constants.

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

caseB for constants.

Monophonic arguments

data MonoArg #

Input argument for monophonic synthesizer. It includes signals for amplitude, frequency (Cycles Per second), gate, trigger. The gate equals to 1 when any note is pressed or zero when nothing is pressed. The trigger equals to 1 at the moment when new note is pressed otherwise it's 0.

Constructors

MonoArg
Fields monoAmp :: Sig monoCps :: Sig monoGate :: Sig monoTrig :: Sig

Instances

Instances details

Tuple MonoArg
Instance details Defined in Csound.Typed.Types.MonoArg Methods tupleMethods :: TupleMethods MonoArg #

type MonoAdsr = Sig -> Sig -> Sig -> Sig -> Sig #

ADSR that's used in monophonic instruments.

adsrMonoSynt :: (MonoAdsr -> (Sig, Sig) -> a) -> MonoArg -> a #

Turns the function that expects ADSR-function and amplitude and frequency to the function on monophonic argument.

monoAdsr :: MonoArg -> MonoAdsr #

Outputs

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

The tuples of signals.

Instances

Instances details

Sigs Sig
Instance details Defined in Csound.Typed.Types.Tuple
(Sigs a1, Sigs a2) => Sigs (a1, a2)
Instance details Defined in Csound.Typed.Types.Tuple
(Sigs a1, Sigs a2, Sigs a3) => Sigs (a1, a2, a3)
Instance details Defined in Csound.Typed.Types.Tuple
(Sigs a1, Sigs a2, Sigs a3, Sigs a4) => Sigs (a1, a2, a3, a4)
Instance details Defined in Csound.Typed.Types.Tuple
(Sigs a1, Sigs a2, Sigs a3, Sigs a4, Sigs a5) => Sigs (a1, a2, a3, a4, a5)
Instance details Defined in Csound.Typed.Types.Tuple
(Sigs a1, Sigs a2, Sigs a3, Sigs a4, Sigs a5, Sigs a6) => Sigs (a1, a2, a3, a4, a5, a6)
Instance details Defined in Csound.Typed.Types.Tuple
(Sigs a1, Sigs a2, Sigs a3, Sigs a4, Sigs a5, Sigs a6, Sigs a7) => Sigs (a1, a2, a3, a4, a5, a6, a7)
Instance details Defined in Csound.Typed.Types.Tuple
(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)
Instance details Defined in Csound.Typed.Types.Tuple

Arrays

data Arr ix a #

Arrays. The array data type is parametrized with type of the index and the type of the value. Note that the data tpyes for indices and values can be tuples.

newLocalArr :: (Tuple a, Tuple ix) => [D] -> SE (Arr ix a) #

Creates an array that is local to the body of Csound instrument where it's defined. The array contains audio signals.

newLocalArr sizes

newGlobalArr :: (Tuple a, Tuple ix) => [D] -> SE (Arr ix a) #

Creates a global array. The array contains audio signals.

newGlobalArr sizes

newLocalCtrlArr :: (Tuple a, Tuple ix) => [D] -> SE (Arr ix a) #

Creates an array that is local to the body of Csound instrument where it's defined. The array contains control signals.

newLocalCtrlArr sizes

newGlobalCtrlArr :: (Tuple a, Tuple ix) => [D] -> SE (Arr ix a) #

Creates a global array. The array contains control signals.

newGlobalCtrlArr sizes

writeArr :: (Tuple ix, Tuple a) => Arr ix a -> ix -> a -> SE () #

Writes data to the array.

readArr :: (Tuple a, Tuple ix) => Arr ix a -> ix -> SE a #

Reads data from the array.

modifyArr :: (Tuple a, Tuple ix) => Arr ix a -> ix -> (a -> a) -> SE () #

Updates the value of the array with pure function.

mixArr :: (Tuple ix, Tuple a, Num a) => Arr ix a -> ix -> a -> SE () #

Type inference helpers

type Arr1 a = Arr Sig a #

An array with single signal index.

type DArr1 a = Arr D a #

An array with single constant index.

type Arr2 a = Arr (Sig, Sig) a #

A matrix (2D array) with signal index.

type DArr2 a = Arr (D, D) a #

A matrix (2D array) with constant index.

type Arr3 a = Arr (Sig, Sig, Sig) a #

A 3D array with signal index.

type DArr3 a = Arr (D, D, D) a #

A 3D array with constant index.

arr1 :: SE (Arr Sig a) -> SE (Arr Sig a) #