-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | library to make electronic music
--   
--   Let's make music with text! We can use Csound to describe our music.
--   Csound has so many fantastic sound generators. It's very efficient.
--   But sometimes Csound is too low level. So many details: integer
--   identifiers for instruments and arrays, should I use control rate or
--   audio rate signals, lack of abstractions, no nested expressions and it
--   has limited set of types. This library embeds Csound in Haskell. We
--   can use powerful Csound's primitives and glue them together with
--   Haskell abstractions. The module <a>Csound.Base</a> exports all types
--   and functions.
--   
--   Tutorials:
--   
--   <ul>
--   <li>Quickstart guide
--   <a>http://github.com/anton-k/csound-expression/blob/master/tutorial/QuickStart.markdown</a></li>
--   <li>Overview of the library
--   <a>http://github.com/anton-k/csound-expression/blob/master/tutorial/Overview.markdown</a></li>
--   <li>Introduction to Csound and library for Haskell users
--   <a>http://github.com/anton-k/csound-expression/blob/master/tutorial/CsoundInstro.markdown</a></li>
--   <li>There are examples in the source code archive
--   <a>http://github.com/anton-k/csound-expression/tree/master/examples</a>.</li>
--   </ul>
--   
--   Key principles
--   
--   <ul>
--   <li>Keep it simple and compact (as functional as possible).</li>
--   <li>Make it open (No dependency on Score-generation libraries. Score
--   (or list of events) is represented with type class. You can use your
--   favorite Score-generation library if you provide an instance for the
--   CsdSco type class. Currently there is support for
--   temporal-music-notation library (see temporal-csound package).</li>
--   </ul>
--   
--   How to install (for Csound and Haskell users)
--   
--   To use the library we need:
--   
--   <ul>
--   <li>GHC - haskell compiler. This library uses GHC-specific features
--   (<a>www.haskell.org/ghc</a>).</li>
--   <li>cabal-install to install haskell packages
--   (<a>www.haskell.org/cabal</a>).</li>
--   <li>Csound compiler (version 5.13 or higher). You must get it
--   installed on your system. Since we are going to generate the csound
--   code we need to compile it to sound somehow. We can find out how to
--   install the Csound on <a>www.csounds.com</a>. To test whether csound
--   is installed open the command line and type:</li>
--   </ul>
--   
--   <pre>
--   csound
--   </pre>
--   
--   It should print a long message with version and available flags and
--   libraries.
--   
--   If everything is installed to install the library we can open the
--   command line terminal and type:
--   
--   <pre>
--   cabal install csound-expression
--   </pre>
--   
--   Acknowledgements (I'd like to mention those who supported me a lot
--   with their music and ideas):
--   
--   <ul>
--   <li>music: entertainment for the braindead, ann<a>s</a>annat &amp;
--   alizbar, toe, iamthemorning, atoms for piece / radiohead, loscil,
--   boards of canada, Hozan Yamamoto, Tony Scott and Shinichi Yuize.</li>
--   <li>ideas: Conal Elliott, Oleg Kiselyov, Paul Hudak, Gabriel Gonzalez,
--   Rich Hickey and Csound's community.</li>
--   </ul>
--   
--   WARNING: the library works best within ghci. The real-time sound
--   rendering function dac spawns a child process in the background which
--   may continue to execute after you stop the main process that runs the
--   programm. It's not so in vim but it happens in the Sublime Editor and
--   when you invoke runhaskell. So the best is to write you program in the
--   separate file and then load it in the ghci and invoke the function
--   main (which runs the sound rendering with the function dac).
@package csound-expression
@version 3.2.3


-- | Properties that specify the appearance of the GUI elements. The
--   specification is inspired by CSS. All properties are set in the
--   cascade manner. For example, if you want to change the font type for
--   all elements you should set this property only for the top-most GUI
--   element. If the property is set on the lower level it wins versus
--   property that is set on the higher level.
module Csound.Control.Gui.Props

-- | Sets the properties for a GUI element.
props :: [Prop] -> Gui -> Gui

-- | Sets the properties for a GUI element on all levels.
forceProps :: [Prop] -> Gui -> Gui

-- | Properties of the widgets.
data Prop :: *
SetLabel :: String -> Prop
SetMaterial :: Material -> Prop
SetBoxType :: BoxType -> Prop
SetColor1 :: Color -> Prop
SetColor2 :: Color -> Prop
SetTextColor :: Color -> Prop
SetFontSize :: Int -> Prop
SetFontType :: FontType -> Prop
SetEmphasis :: Emphasis -> Prop
SetSliderType :: SliderType -> Prop
SetTextType :: TextType -> Prop
SetButtonType :: ButtonType -> Prop
SetOrient :: Orient -> Prop
SetKnobType :: KnobType -> Prop
SetLabelType :: LabelType -> Prop
data BorderType :: *
NoBorder :: BorderType
DownBoxBorder :: BorderType
UpBoxBorder :: BorderType
EngravedBorder :: BorderType
EmbossedBorder :: BorderType
BlackLine :: BorderType
ThinDown :: BorderType
ThinUp :: BorderType

-- | The Csound colours.
type Color = Colour Double

-- | A rectangle.
data Rect :: *
Rect :: Int -> Int -> Int -> Int -> Rect
px :: Rect -> Int
py :: Rect -> Int
width :: Rect -> Int
height :: Rect -> Int
data FontType :: *
Helvetica :: FontType
Courier :: FontType
Times :: FontType
Symbol :: FontType
Screen :: FontType
Dingbats :: FontType
data Emphasis :: *
NoEmphasis :: Emphasis
Italic :: Emphasis
Bold :: Emphasis
BoldItalic :: Emphasis

-- | The type of the material of the element. It affects sliders and
--   buttons.
data Material :: *
NoPlastic :: Material
Plastic :: Material

-- | The orientation of the widget (slider, roller). This property is never
--   needs to be set in practice. If this property is not set then default
--   orientation is calculated from the bounding box of the widget. If the
--   width is greater than the height then we need to use a horizontal
--   widget otherwise it should be a vertical one.
data Orient :: *
Hor :: Orient
Ver :: Orient
setBorder :: BorderType -> Gui -> Gui
setLabel :: String -> Gui -> Gui
setMaterial :: Material -> Gui -> Gui
setColor1 :: Color -> Gui -> Gui
setColor2 :: Color -> Gui -> Gui
setColors :: Color -> Color -> Gui -> Gui
setTextColor :: Color -> Gui -> Gui
setFontSize :: Int -> Gui -> Gui
setFontType :: FontType -> Gui -> Gui
setEmphasis :: Emphasis -> Gui -> Gui
setOrient :: Orient -> Gui -> Gui


-- | The functions from this module specify the geometry of the
--   GUI-elements. They tell where to render the elements.
--   
--   Every element is rectangular. To know where to place the element is to
--   know the parameters of the bounding rectangle. All rectangles are
--   relative and automatically aligned.
--   
--   We have two functions for grouping. They construct horizontal and
--   vertical groups of the elements. Within the group we can change the
--   relative size of the rectangles (by scaling one side of the
--   rectangle). In place of rectangle we can put an empty space.
module Csound.Control.Gui.Layout

-- | Horizontal groupping of the elements. All elements are placed in the
--   stright horizontal line and aligned by Y-coordinate and height.
hor :: [Gui] -> Gui

-- | Vertical groupping of the elements. All elements are placed in the
--   stright vertical line and aligned by X-coordinate and width.
ver :: [Gui] -> Gui

-- | An empty space.
space :: Gui

-- | Scales an element within the group. It depends on the type of the
--   alignment (horizontal or vertical) which side of the bounding box is
--   scaled. If it's a horizontal group then the width is scaled and height
--   is scaled otherwise.
--   
--   Every element in the group has a scaling factor. By default it equals
--   to one. During rendering all scaling factors are summed and divided on
--   the sum of all factors. So that factors become weights or proportions.
--   This process is called normalization. Scaling one element affects not
--   only this element but all other elements in the group!
--   
--   An example:
--   
--   One element is twice as large as the other two:
--   
--   <pre>
--   hor [a, b, sca 2 c]
--   </pre>
--   
--   Why is it so? Let's look at the hidden scaling factors:
--   
--   <pre>
--   hor [sca 1 a, sca 1 b, sca 2 c]
--   </pre>
--   
--   During rendering we scale all the scaling fators so that total sum
--   equals to one:
--   
--   <pre>
--   hor [sca 0.25 a, sca 0.25 b, sca 0.5 c]
--   </pre>
sca :: Double -> Gui -> Gui

-- | Weighted horizontal grouping. It takes a list of scaling factors and
--   elements.
horSca :: [(Double, Gui)] -> Gui

-- | Weighted vertical grouping. It takes a list of scaling factors and
--   elements.
verSca :: [(Double, Gui)] -> Gui

-- | Sets the padding of the element. How much empty space to reserve
--   outside the element.
padding :: Int -> Gui -> Gui

-- | Sets the margin of the element. How much empty space to reserve
--   between the elements within the group. It affects only compound
--   elements.
margin :: Int -> Gui -> Gui

module Csound.Control.SE

-- | The Csound's <tt>IO</tt>-monad. All values that produce side effects
--   are wrapped in the <tt>SE</tt>-monad.
data SE a :: * -> *

-- | It describes a reference to mutable values.
data SERef a :: * -> *
SERef :: (a -> SE ()) -> SE a -> SERef a
writeSERef :: SERef a -> a -> SE ()
readSERef :: SERef a -> SE a

-- | Allocates a new mutable value and initializes it with value. A
--   reference can contain a tuple of variables.
newSERef :: Tuple a => a -> SE (SERef a)

-- | An alias for the function <tt>newSERef</tt>. It returns not the
--   reference to mutable value but a pair of reader and writer functions.
sensorsSE :: Tuple a => a -> SE (SE a, a -> SE ())

module Csound.Control.Evt

-- | A stream of events. We can convert a stream of events to the procedure
--   with the function <tt>runEvt</tt>. It waits for events and invokes the
--   given procedure when the event happens.
data Evt a :: * -> *
Evt :: (Bam a -> SE ()) -> Evt a
runEvt :: Evt a -> Bam a -> SE ()

-- | A procedure. Something that takes a value and suddenly bams with it.
type Bam a = a -> SE ()

-- | Converts booleans to events.
boolToEvt :: BoolSig -> Evt Unit

-- | Converts an event to boolean signal. It forgets everything about the
--   event values. Signal equals to one when an event happens and zero
--   otherwise.
evtToBool :: Evt a -> SE BoolSig

-- | Triggers an event when signal equals to 1.
sigToEvt :: Sig -> Evt Unit

-- | Converts events to signals.
stepper :: Tuple a => a -> Evt a -> SE a

-- | Filters events with predicate.
filterE :: (a -> BoolD) -> Evt a -> Evt a

-- | Filters events with effectful predicate.
filterSE :: (a -> SE BoolD) -> Evt a -> Evt a

-- | Accumulator for events with side effects.
accumSE :: Tuple s => s -> (a -> s -> SE (b, s)) -> Evt a -> Evt b

-- | Accumulator for events.
accumE :: Tuple s => s -> (a -> s -> (b, s)) -> Evt a -> Evt b

-- | Accumulator with filtering. It can skip the events from the event
--   stream. If the third element of the triple equals to 1 then we should
--   include the event in the resulting stream. If the element equals to 0
--   we skip the event.
filterAccumE :: Tuple s => s -> (a -> s -> (BoolD, b, s)) -> Evt a -> Evt b

-- | Accumulator for events with side effects and filtering. Event triggers
--   only if the first element in the tripplet is true.
filterAccumSE :: Tuple s => s -> (a -> s -> SE (BoolD, b, s)) -> Evt a -> Evt b

-- | A snapshot of the signal. It converts a type of the signal to the type
--   of the value in the given moment. Instances:
--   
--   <pre>
--   type instance Snap D   = D
--   type instance Snap Str = Str
--   type instance Snap Tab = Tab
--   
--   type instance Snap Sig = D
--   
--   type instance Snap (a, b) = (Snap a, Snap b)
--   type instance Snap (a, b, c) = (Snap a, Snap b, Snap c)
--   type instance Snap (a, b, c, d) = (Snap a, Snap b, Snap c, Snap d)
--   type instance Snap (a, b, c, d, e) = (Snap a, Snap b, Snap c, Snap d, Snap e)
--   type instance Snap (a, b, c, d, e, f) = (Snap a, Snap b, Snap c, Snap d, Snap e, Snap f)
--   </pre>

-- | Get values of some signal at the given events.
snapshot :: (Tuple a, Tuple (Snap a)) => (Snap a -> b -> c) -> a -> Evt b -> Evt c

-- | Constructs an event stream that contains values from the given signal.
--   Events happens only when the signal changes.
snaps :: Sig -> Evt D

-- | Executes actions synchronized with global tempo (in Hz).
--   
--   <pre>
--   runEvtSync tempoCps evt proc
--   </pre>
sync :: (Default a, Tuple a) => D -> Evt a -> Evt a

-- | the sync function but time is measured in beats per minute.
syncBpm :: (Default a, Tuple a) => D -> Evt a -> Evt a

-- | Behaves like <a>metro</a>, but returns an event stream.
metroE :: Sig -> Evt Unit

-- | Behaves like <a>changed</a>, but returns an event stream.
changedE :: [Sig] -> Evt Unit

-- | Behaves like <a>trigger</a>, but returns an event stream.
triggerE :: Sig -> Sig -> Sig -> Evt Unit

-- | Constructs an event stream that contains an infinite repetition values
--   from the given list. When an event happens this function takes the
--   next value from the list, if there is no values left it starts from
--   the beggining of the list.
cycleE :: (Tuple a, Arg a) => [a] -> Evt b -> Evt a

-- | When something happens on the given event stream resulting event
--   stream contains an application of some unary function to the given
--   initial value. So the event stream contains the values:
--   
--   <pre>
--   [s0, f s0, f (f s0), f (f (f s0)), ...]
--   </pre>
iterateE :: Tuple a => a -> (a -> a) -> Evt b -> Evt a

-- | Substitutes all values in the input stream with the given constant
--   value.
repeatE :: Tuple a => a -> Evt b -> Evt a

-- | Accumulates a values from the given event stream with binary function.
--   It's a variant of the fold for event streams.
--   
--   <pre>
--   appendE z f evt
--   </pre>
--   
--   When value <tt>a</tt> happens with <tt>evt</tt>, the resulting event
--   stream contains a value (z <tt>f</tt> a) and in the next time
--   <tt>z</tt> equals to this value.
appendE :: Tuple a => a -> (a -> a -> a) -> Evt a -> Evt a

-- | A special variant of the function <a>appendE</a> for the monoids.
--   Initial value is <a>mempty</a> and binary function is <a>mappend</a>
--   which belong to the instance of the class <a>Monoid</a>.
mappendE :: (Monoid a, Tuple a) => Evt a -> Evt a

-- | Splits event stream on two streams with predicate.
partitionE :: (a -> BoolD) -> Evt a -> (Evt a, Evt a)

-- | Splits a toggle event stream on on-events and off-events.
splitToggle :: Evt D -> (Evt D, Evt D)

-- | Constructs an event stream that contains values from the given list
--   which are taken in the random order.
oneOf :: (Tuple a, Arg a) => [a] -> Evt b -> Evt a

-- | Constructs an event stream that contains values from the given list
--   which are taken in the random order. In the list we specify not only
--   values but the frequencies of occurrence. Sum of the frequencies
--   should be equal to one.
freqOf :: (Tuple a, Arg a) => Rnds a -> Evt b -> Evt a

-- | This function combines the functions <a>accumE</a> and <a>freqOf</a>.
--   We transform the values of the event stream with stateful function
--   that produce not just values but the list of values with frequencies
--   of occurrence. We apply this function to the current state and the
--   value and then at random pick one of the values.
freqAccum :: (Tuple s, Tuple (b, s), Arg (b, s)) => s -> (a -> s -> Rnds (b, s)) -> Evt a -> Evt b

-- | An event stream of the random values in the interval <tt>(0, 1)</tt>.
randDs :: Evt b -> Evt D

-- | An event stream of the integers taken from the given diapason.
randInts :: (D, D) -> Evt b -> Evt D

-- | Skips elements at random.
--   
--   <pre>
--   randSkip prob
--   </pre>
--   
--   where <tt>prob</tt> is probability of includinng the element in the
--   output stream.
randSkip :: D -> Evt a -> Evt a

-- | Skips elements at random.
--   
--   <pre>
--   randSkip probFun
--   </pre>
--   
--   It behaves just like <tt>randSkip</tt>, but probability depends on the
--   value.
randSkipBy :: (a -> D) -> Evt a -> Evt a

-- | <pre>
--   range (xMin, xMax) === cycleE [xMin .. pred xMax]
--   </pre>
range :: (D, D) -> Evt b -> Evt D

-- | Turns an event of indices to the event of the values from the list. A
--   value is taken with index.
listAt :: (Tuple a, Arg a) => [a] -> Evt D -> Evt a

-- | Specialization of the function <a>masked</a>.
--   
--   <pre>
--   every n [a, b, c, ..] evt
--   </pre>
--   
--   constructs a mask that skips first <tt>n</tt> elements and then
--   produces an event and skips next (a - 1) events, then produces an
--   event and skips next (b - 1) events and so on. It's useful for
--   construction of the percussive beats. For example
--   
--   <pre>
--   every 0 [2] (metroE 2)
--   </pre>
--   
--   triggers an event on the odd beats. With this function we can create a
--   complex patterns of cyclic events.
every :: (Tuple a, Arg a) => Int -> [Int] -> Evt a -> Evt a

-- | Filters events with the mask. A mask is a list of ones and zeroes.
--   n'th element from the given list should be included in the resulting
--   stream if the n'th element from the list equals to one or skipped if
--   the element equals to zero.
masked :: (Tuple a, Arg a) => [D] -> Evt a -> Evt a


-- | We can convert notes to sound signals with instruments. An instrument
--   is a function:
--   
--   <pre>
--   (Arg a, Sigs b) =&gt; a -&gt; SE b
--   </pre>
--   
--   It takes a tuple of primitive Csound values (number, string or array)
--   and converts it to the tuple of signals and it makes some side effects
--   along the way so the output is wrapped in the <a>SE</a>-monad.
--   
--   There are only three ways of making a sound with an instrument:
--   
--   <ul>
--   <li>Suplpy an instrument with notes (<tt>Mix</tt>-section).</li>
--   <li>Trigger an instrument with event stream
--   (<tt>Evt</tt>-section).</li>
--   <li>By using midi-instruments (<tt>Midi</tt>-section).</li>
--   </ul>
--   
--   Sometimes we don't want to produce any sound. Our instrument is just a
--   procedure that makes something useful without being noisy about it.
--   It's type is:
--   
--   <pre>
--   (Arg a) =&gt; a -&gt; SE ()
--   </pre>
--   
--   To invoke the procedures there are functions with trailing underscore.
--   For example we have the function <tt>trig</tt> to convert event stream
--   to sound:
--   
--   <pre>
--   trig :: (Arg a, Sigs b) =&gt; (a -&gt; SE b) -&gt; Evts (D, D, a) -&gt; b 
--   </pre>
--   
--   and we have a <tt>trig</tt> with underscore to convert the event
--   stream to the sequence of the procedure invkations:
--   
--   <pre>
--   trig_ :: (Arg a) =&gt; (a -&gt; SE ()) -&gt; Evts (D, D, a) -&gt; SE () 
--   </pre>
--   
--   To invoke instruments from another instrumetnts we use artificial
--   closures made with functions with trailing xxxBy. For example:
--   
--   <pre>
--   trigBy :: (Arg a, Arg c, Sigs b) =&gt; (a -&gt; SE b) -&gt; (c -&gt; Evts (D, D, a)) -&gt; (c -&gt; b)
--   </pre>
--   
--   Notice that the event stream depends on the argument of the type c.
--   Here goes all the parameters that we want to pass from the outer
--   instrument. Unfortunately we can not just create the closure, because
--   our values are not the real values. It's a text of the programm (a
--   tiny snippet of it) to be executed. For a time being I don't know how
--   to make it better. So we need to pass the values explicitly.
--   
--   For example, if we want to make an arpeggiator:
--   
--   <pre>
--   pureTone :: D -&gt; SE Sig
--   pureTone cps = return $ mul env $ osc $ sig cps
--      where env = linseg [0, 0.01, 1, 0.25, 0]
--   
--   majArpeggio :: D -&gt; SE Sig
--   majArpeggio = return . schedBy pureTone evts
--       where evts cps = withDur 0.5 $ fmap (* cps) $ cycleE [1, 5/3, 3/2, 2] $ metroE 5
--   
--   main = dac $ mul 0.5 $ midi $ onMsg majArpeggio
--   </pre>
--   
--   We should use <a>schedBy</a> to pass the frequency as a parameter to
--   the event stream.
module Csound.Control.Instr

-- | A class that represents Csound scores. All functions that use score
--   are defined in terms of this class. If you want to use your own score
--   representation, just define two methods of the class.
--   
--   The properties:
--   
--   <pre>
--   forall a . toCsdEventList (singleCsdEvent a) === CsdEventList 1 [(0, 1, a)]
--   </pre>
class Functor f => CsdSco (f :: * -> *)
toCsdEventList :: CsdSco f => f a -> CsdEventList a
singleCsdEvent :: CsdSco f => CsdEvent a -> f a

-- | Special type that represents a scores of sound signals. If an
--   instrument is triggered with the scores the result is wrapped in the
--   value of this type.
data Mix a :: * -> *

-- | Plays a bunch of notes with the given instrument.
--   
--   <pre>
--   res = sco instrument scores 
--   </pre>
sco :: (CsdSco f, Arg a, Sigs b) => (a -> SE b) -> f a -> f (Mix b)

-- | Renders a scores to the sound signals. we can use it inside the other
--   instruments. Warning: if we use a score that lasts for an hour in the
--   note that lasts for 5 seconds all the events would be generated,
--   though we will hear only first five seconds. So the semantics is good
--   but implementation is inefficient for such a cases (consider event
--   streams for such cases).
mix :: (Sigs a, CsdSco f) => f (Mix a) -> a

-- | Applies an effect to the sound. Effect is applied to the sound on the
--   give track.
--   
--   <pre>
--   res = eff effect sco 
--   </pre>
--   
--   <ul>
--   <li><tt>effect</tt> - a function that takes a tuple of signals and
--   produces a tuple of signals.</li>
--   <li><tt>sco</tt> - something that is constructed with <a>sco</a> or
--   <a>eff</a>.</li>
--   </ul>
--   
--   With the function <a>eff</a> you can apply a reverb or adjust the
--   level of the signal. It functions like a mixing board but unlike
--   mixing board it produces the value that you can arrange with functions
--   from your favorite Score-generation library. You can delay it or mix
--   with some other track and apply some another effect on top of it!
eff :: (CsdSco f, Sigs a, Sigs b) => (a -> SE b) -> f (Mix a) -> f (Mix b)

-- | <a>CsdEventList</a> is a canonical representation of the Csound
--   scores. A scores is a list of events and we should know the total
--   duration of the scores. It's not meant to be used directly. We can use
--   a better alternative. More convenient type that belongs to
--   <a>CsdSco</a> type class (see temporal-csound package).
data CsdEventList a :: * -> *
CsdEventList :: Double -> [CsdEvent a] -> CsdEventList a
csdEventListDur :: CsdEventList a -> Double
csdEventListNotes :: CsdEventList a -> [CsdEvent a]

-- | The Csound note. It's a triple of
--   
--   <pre>
--   (startTime, duration, parameters)
--   </pre>
type CsdEvent a = (Double, Double, a)

-- | Mixes the scores and plays them in the loop.
mixLoop :: (CsdSco f, Sigs a) => f (Mix a) -> a

-- | Invokes a procedure for the given bunch of events.
sco_ :: (CsdSco f, Arg a) => (a -> SE ()) -> f a -> f (Mix Unit)

-- | Converts a bunch of procedures scheduled with scores to a single
--   procedure.
mix_ :: CsdSco f => f (Mix Unit) -> SE ()

-- | Mixes the procedures and plays them in the loop.
mixLoop_ :: CsdSco f => f (Mix Unit) -> SE ()

-- | Imitates a closure for a bunch of notes to be played within another
--   instrument.
mixBy :: (Arg a, Sigs b, CsdSco f) => (a -> f (Mix b)) -> a -> b
data Msg :: *
type Channel = Int

-- | Triggers a midi-instrument (aka Csound's massign) for all channels.
--   It's useful to test a single instrument.
midi :: Sigs a => (Msg -> SE a) -> a

-- | Triggers a midi-instrument (aka Csound's massign) on the specified
--   channel.
midin :: Sigs a => Channel -> (Msg -> SE a) -> a

-- | Triggers a midi-instrument (aka Csound's pgmassign) on the specified
--   programm bank.
pgmidi :: Sigs a => Maybe Int -> Channel -> (Msg -> SE a) -> a
ampCps :: Msg -> (D, D)

-- | Triggers a midi-procedure (aka Csound's massign) for all channels.
midi_ :: (Msg -> SE ()) -> SE ()

-- | Triggers a midi-procedure (aka Csound's pgmassign) on the given
--   channel.
midin_ :: Channel -> (Msg -> SE ()) -> SE ()

-- | Triggers a midi-procedure (aka Csound's pgmassign) on the given
--   programm bank.
pgmidi_ :: Maybe Int -> Channel -> (Msg -> SE ()) -> SE ()

-- | Get the note number of the current MIDI event, expressed in
--   cycles-per-second.
--   
--   <pre>
--   icps  cpsmidi  
--   </pre>
--   
--   csound doc: <a>http://www.csounds.com/manual/html/cpsmidi.html</a>
cpsmidi :: Msg -> D

-- | Get the velocity of the current MIDI event.
--   
--   <pre>
--   iamp  ampmidi  iscal [, ifn]
--   </pre>
--   
--   csound doc: <a>http://www.csounds.com/manual/html/ampmidi.html</a>
ampmidi :: Msg -> D -> D

-- | Triggers an instrument with an event stream. The event stream contains
--   triples:
--   
--   <pre>
--   (delay_after_event_is_fired, duration_of_the_event, argument_for_the_instrument)
--   </pre>
trig :: (Arg a, Sigs b) => (a -> SE b) -> Evt (D, D, a) -> b

-- | It's like the function <tt>trig</tt>, but delay is set to zero.
sched :: (Arg a, Sigs b) => (a -> SE b) -> Evt (D, a) -> b

-- | An instrument is triggered with event stream and delay time is set to
--   zero (event fires immediately) and duration is set to inifinite time.
--   The note is held while the instrument is producing something. If the
--   instrument is silent for some seconds (specified in the first
--   argument) then it's turned off.
schedHarp :: (Arg a, Sigs b) => D -> (a -> SE b) -> Evt a -> b

-- | Invokes an instrument with first event stream and holds the note until
--   the second event stream is active.
schedUntil :: (Arg a, Sigs b) => (a -> SE b) -> Evt a -> Evt c -> b

-- | Invokes an instrument with toggle event stream (1 stands for on and 0
--   stands for off).
schedToggle :: Sigs b => SE b -> Evt D -> b

-- | Triggers a procedure on the event stream.
trig_ :: Arg a => (a -> SE ()) -> Evt (D, D, a) -> SE ()

-- | Triggers a procedure on the event stream. A delay time is set to zero.
sched_ :: Arg a => (a -> SE ()) -> Evt (D, a) -> SE ()

-- | Invokes an instrument with first event stream and holds the note until
--   the second event stream is active.
schedUntil_ :: Arg a => (a -> SE ()) -> Evt a -> Evt c -> SE ()

-- | A closure to trigger an instrument inside the body of another
--   instrument.
trigBy :: (Arg a, Sigs b, Arg c) => (a -> SE b) -> (c -> Evt (D, D, a)) -> c -> b

-- | A closure to trigger an instrument inside the body of another
--   instrument.
schedBy :: (Arg a, Sigs b, Arg c) => (a -> SE b) -> (c -> Evt (D, a)) -> c -> b

-- | A closure to trigger an instrument inside the body of another
--   instrument.
schedHarpBy :: (Arg a, Sigs b, Arg c) => D -> (a -> SE b) -> (c -> Evt a) -> c -> b

-- | Sets the same duration for all events. It's useful with the functions
--   <tt>sched</tt>, <tt>schedBy</tt>, <tt>sched_</tt>.
--   
--   <pre>
--   withDur dur events === fmap (\x -&gt; (dur, x)) events
--   </pre>
withDur :: D -> Evt a -> Evt (D, a)
class Sigs (SigOuts a) => Outs a where type family SigOuts a :: *
toOuts :: Outs a => a -> SE (SigOuts a)
onArg :: Outs b => (a -> b) -> (a -> SE (SigOuts b))

-- | Converts a value to the midi-instrument. It's used with the functions
--   <a>midi</a>, <a>midin</a>.
class MidiInstr a where type family MidiInstrOut a :: *
onMsg :: MidiInstr a => a -> Msg -> SE (MidiInstrOut a)

-- | Constructs a drum-like instrument. Drum like instrument has a single
--   argument that signifies an amplitude.
class AmpInstr a where type family AmpInstrOut a :: *
onAmp :: AmpInstr a => a -> D -> SE (AmpInstrOut a)

-- | Constructs a simple instrument that takes in a tuple of two arguments.
--   They are amplitude and the frequency (in Hz or cycles per second).
class CpsInstr a where type family CpsInstrOut a :: *
onCps :: CpsInstr a => a -> (D, D) -> SE (CpsInstrOut a)


-- | Primitive GUI elements.
--   
--   There is a convention that constructors take only parameters that
--   specify the logic of the widget. The view is set for GUI-elements with
--   other functions.
module Csound.Control.Gui.Widget

-- | The diapason of the continuous value.
data ValDiap :: *
ValDiap :: Double -> Double -> ValDiap
valDiapMin :: ValDiap -> Double
valDiapMax :: ValDiap -> Double
type ValStep = Double
data ValScaleType :: *
Linear :: ValScaleType
Exponential :: ValScaleType

-- | A value span is a diapason of the value and a type of the scale (can
--   be linear or exponential).
data ValSpan :: *
ValSpan :: ValDiap -> ValScaleType -> ValSpan
valSpanDiap :: ValSpan -> ValDiap
valSpanScale :: ValSpan -> ValScaleType

-- | Makes a linear <tt>ValSpan</tt> with specified boundaries.
--   
--   <pre>
--   linSpan minVal maxVal
--   </pre>
linSpan :: Double -> Double -> ValSpan

-- | Makes an exponential <tt>ValSpan</tt> with specified boundaries.
--   
--   <pre>
--   expSpan minVal maxVal
--   </pre>
expSpan :: Double -> Double -> ValSpan

-- | Unit span. A special case:
--   
--   <pre>
--   uspan = linSpan 0 1
--   </pre>
uspan :: ValSpan

-- | Bipolar unit span. A special case:
--   
--   <pre>
--   uspan = linSpan (-1) 1
--   </pre>
bspan :: ValSpan

-- | An exponential unit span. A special case:
--   
--   <pre>
--   uspan = expSpan 0 1
--   </pre>
uspanExp :: ValSpan

-- | Allows the user to increase/decrease a value with mouse clicks on a
--   corresponding arrow button. Output is an event stream that contains
--   values when counter changes.
--   
--   <pre>
--   count diapason fineValStep maybeCoarseValStep initValue 
--   </pre>
--   
--   doc: http:<i></i>www.csounds.com<i>manual</i>html/FLcount.html
count :: ValDiap -> ValStep -> Maybe ValStep -> Double -> Source (Evt D)

-- | A variance on the function <a>count</a>, but it produces a signal of
--   piecewise constant function.
countSig :: ValDiap -> ValStep -> Maybe ValStep -> Double -> Source Sig

-- | It is a squared area that allows the user to modify two output values
--   at the same time. It acts like a joystick.
--   
--   <pre>
--   joy valueSpanX valueSpanY (initX, initY) 
--   </pre>
--   
--   doc: <a>http://www.csounds.com/manual/html/FLjoy.html</a>
joy :: ValSpan -> ValSpan -> (Double, Double) -> Source (Sig, Sig)

-- | A FLTK widget opcode that creates a knob.
--   
--   <pre>
--   knob valueSpan initValue
--   </pre>
--   
--   doc: <a>http://www.csounds.com/manual/html/FLknob.html</a>
knob :: String -> ValSpan -> Double -> Source Sig
data KnobType :: *
ThreeD :: Maybe Int -> KnobType
Pie :: KnobType
Clock :: KnobType
Flat :: KnobType
setKnobType :: KnobType -> Gui -> Gui

-- | FLroller is a sort of knob, but put transversally.
--   
--   <pre>
--   roller valueSpan step initVal
--   </pre>
--   
--   doc: <a>http://www.csounds.com/manual/html/FLroller.html</a>
roller :: String -> ValSpan -> ValStep -> Double -> Source Sig

-- | FLslider puts a slider into the corresponding container.
--   
--   <pre>
--   slider valueSpan initVal 
--   </pre>
--   
--   doc: <a>http://www.csounds.com/manual/html/FLslider.html</a>
slider :: String -> ValSpan -> Double -> Source Sig

-- | Constructs a list of linear unit sliders (ranges in [0, 1]). It takes
--   a list of init values.
sliderBank :: String -> [Double] -> Source [Sig]
data SliderType :: *
Fill :: SliderType
Engraved :: SliderType
Nice :: SliderType
setSliderType :: SliderType -> Gui -> Gui

-- | numeric (originally FLtext in the Csound) allows the user to modify a
--   parameter value by directly typing it into a text field.
--   
--   <pre>
--   numeric diapason step initValue 
--   </pre>
--   
--   doc: <a>http://www.csounds.com/manual/html/FLtext.html</a>
numeric :: String -> ValDiap -> ValStep -> Double -> Source Sig
data TextType :: *
NormalText :: TextType
NoDrag :: TextType
NoEdit :: TextType
setTextType :: TextType -> Gui -> Gui

-- | A FLTK widget that displays text inside of a box. If the text is
--   longer than 255 characters the text is split on several parts (Csound
--   limitations).
--   
--   <pre>
--   box text
--   </pre>
--   
--   doc: <a>http://www.csounds.com/manual/html/FLbox.html</a>
box :: String -> Display

-- | The type of the box. Some values are not implemented on the Csound
--   level.
data BoxType :: *
FlatBox :: BoxType
UpBox :: BoxType
DownBox :: BoxType
ThinUpBox :: BoxType
ThinDownBox :: BoxType
EngravedBox :: BoxType
EmbossedBox :: BoxType
BorderBox :: BoxType
ShadowBox :: BoxType
Roundedbox :: BoxType
RoundedShadowBox :: BoxType
RoundedFlatBox :: BoxType
RoundedUpBox :: BoxType
RoundedDownBox :: BoxType
DiamondUpBox :: BoxType
DiamondDownBox :: BoxType
OvalBox :: BoxType
OvalShadowBox :: BoxType
OvalFlatBox :: BoxType
setBoxType :: BoxType -> Gui -> Gui

-- | A FLTK widget opcode that creates a button.
--   
--   <pre>
--   button text
--   </pre>
--   
--   doc: <a>http://www.csounds.com/manual/html/FLbutton.html</a>
button :: String -> Source (Evt Unit)

-- | The type of the button. It affects toggle buttons and button banks.
--   
--   In Csound buttons and toggle buttons are constructed with the same
--   function (but with different button types). But in this library they
--   are contructed by different functions (<tt>button</tt> and
--   <tt>toggle</tt>). Normal button is a plain old button, but other
--   values specify toggle buttons. So this property doesn't affect the
--   buttons (since they could be only normal buttons).
data ButtonType :: *
NormalButton :: ButtonType
LightButton :: ButtonType
CheckButton :: ButtonType
RoundButton :: ButtonType
setButtonType :: ButtonType -> Gui -> Gui

-- | A FLTK widget opcode that creates a toggle button.
--   
--   <pre>
--   button text
--   </pre>
--   
--   doc: <a>http://www.csounds.com/manual/html/FLbutton.html</a>
toggle :: String -> Source (Evt D)

-- | A FLTK widget opcode that creates a bank of buttons. Result is (x, y)
--   coordinate of the triggered button.
--   
--   <pre>
--   butBank xNumOfButtons yNumOfButtons
--   </pre>
--   
--   doc: <a>http://www.csounds.com/manual/html/FLbutBank.html</a>
butBank :: String -> Int -> Int -> (Int, Int) -> Source (Evt (D, D))

-- | A variance on the function <a>toggle</a>, but it produces a signal of
--   piecewise constant function.
toggleSig :: String -> Source Sig

-- | A variance on the function <a>butBank</a>, but it produces a signal of
--   piecewise constant function. Result is (x, y) coordinate of the
--   triggered button.
butBankSig :: String -> Int -> Int -> (Int, Int) -> Source (Sig, Sig)

-- | A FLTK widget opcode that creates a bank of buttons.
--   
--   <pre>
--   butBank xNumOfButtons yNumOfButtons
--   </pre>
--   
--   doc: <a>http://www.csounds.com/manual/html/FLbutBank.html</a>
butBank1 :: String -> Int -> Int -> (Int, Int) -> Source (Evt D)
butBankSig1 :: String -> Int -> Int -> (Int, Int) -> Source Sig

-- | A radio button. It takes a list of values with labels.
radioButton :: Arg a => String -> [(String, a)] -> Int -> Source (Evt a)

-- | A matrix of values.
matrixButton :: Arg a => String -> Int -> Int -> [a] -> (Int, Int) -> Source (Evt a)

-- | Radio button that returns functions. Useful for picking a waveform or
--   type of filter.
funnyRadio :: Tuple b => String -> [(String, a -> b)] -> Int -> Source (a -> b)

-- | Matrix of functional values.
funnyMatrix :: Tuple b => String -> Int -> Int -> [(a -> b)] -> (Int, Int) -> Source (a -> b)

-- | FLvalue shows current the value of a valuator in a text field.
--   
--   <pre>
--   value initVal
--   </pre>
--   
--   doc: <a>http://www.csounds.com/manual/html/FLvalue.html</a>
value :: String -> Double -> Sink Sig

-- | A slider that serves as indicator. It consumes values instead of
--   producing.
--   
--   <pre>
--   meter valueSpan initValue
--   </pre>
meter :: String -> ValSpan -> Double -> Sink Sig

-- | Appends a title to a group of widgets.
setTitle :: String -> Gui -> SE Gui

-- | Keyboard events.
data KeyEvt :: *
Press :: Key -> KeyEvt
Release :: Key -> KeyEvt

-- | Keys.
data Key :: *
CharKey :: Char -> Key
F1 :: Key
F2 :: Key
F3 :: Key
F4 :: Key
F5 :: Key
F6 :: Key
F7 :: Key
F8 :: Key
F9 :: Key
F10 :: Key
F11 :: Key
F12 :: Key
Scroll :: Key
CapsLook :: Key
LeftShift :: Key
RightShift :: Key
LeftCtrl :: Key
RightCtrl :: Key
Enter :: Key
LeftAlt :: Key
RightAlt :: Key
LeftWinKey :: Key
RightWinKey :: Key
Backspace :: Key
ArrowUp :: Key
ArrowLeft :: Key
ArrowRight :: Key
ArrowDown :: Key
Insert :: Key
Home :: Key
PgUp :: Key
Delete :: Key
End :: Key
PgDown :: Key
NumLock :: Key
NumDiv :: Key
NumMul :: Key
NumSub :: Key
NumHome :: Key
NumArrowUp :: Key
NumPgUp :: Key
NumArrowLeft :: Key
NumSpace :: Key
NumArrowRight :: Key
NumEnd :: Key
NumArrowDown :: Key
NumPgDown :: Key
NumIns :: Key
NumDel :: Key
NumEnter :: Key
NumPlus :: Key
Num7 :: Key
Num8 :: Key
Num9 :: Key
Num4 :: Key
Num5 :: Key
Num6 :: Key
Num1 :: Key
Num2 :: Key
Num3 :: Key
Num0 :: Key
NumDot :: Key

-- | The stream of keyboard press/release events.
keyIn :: KeyEvt -> Evt Unit

-- | Shortcut for press <a>CharKey</a> events.
charOn :: Char -> Evt Unit

-- | Shortcut for release <a>CharKey</a> events.
charOff :: Char -> Evt Unit


-- | GUI (Graphical User Interface) elements are handy to change the
--   parameters of the sound in real time. It includes sliders, knobs,
--   rollers, buttons and other widgets.
--   
--   A GUI element consists of two parts. They are view (how it looks) and
--   logic (what's going on with it). For example a slider can be
--   horizontal or vertical or green or yellow or small or big. It's the
--   view of the slider. And a slider can produce a continuous signal
--   within the given interval. It's a logic of the slider.
--   
--   Let's talk about the view. The view is divided on two parts:
--   
--   <ul>
--   <li>where element is placed or Layout.</li>
--   <li>all other properties or just Properties.</li>
--   </ul>
--   
--   The layout is defined with very simple functions. There are vertical
--   and horizontal grouping of the elements. We can scale the element
--   within the group and include an empty space in the group. Everything
--   is aligned (see <a>Csound.Gui.Layout</a>). Other properties include
--   colors, fonts (size and type), borders, specific properties of the
--   widgets (see <a>Csound.Gui.Props</a>).
--   
--   Let's consider the logic. The logic consists of three parts:
--   
--   <ul>
--   <li>what is consumed (<a>Output</a>)</li>
--   <li>what is produced (<a>Input</a>)</li>
--   <li>what's going on inside (<a>Inner</a>)</li>
--   </ul>
--   
--   A widget can react on values, produce values or do something useful.
--   There are special types of widgets:
--   
--   <ul>
--   <li><a>Source</a> - they produce values only</li>
--   <li><a>Sink</a> - they consume values only</li>
--   <li><a>Display</a> - something is going on inside them (for example,
--   it can show a <a>hello world</a> message)</li>
--   </ul>
--   
--   Widgets can be simple and compound. Simple widgets are primitive
--   elements (sliders, knobs, rollers, buttons). We have a special
--   constructors that produce simple widgets (see
--   <a>Csound.Gui.Widget</a>). Compound widgets glue together several
--   widgets. That is the view contains several elements and all of them
--   involved in the logic of the widget.
module Csound.Control.Gui

-- | A visual representation of the GUI-element.
data Gui :: *

-- | A widget consists of visible element (Gui), value consumer (Output)
--   and producer (Input) and an inner state (Inner).
type Widget a b = SE (Gui, Output a, Input b, Inner)

-- | Widgets that produce something has inputs.
type Input a = a

-- | Widgets that consume something has outputs.
type Output a = a -> SE ()

-- | Widgets that just do something inside them or have an inner state.
type Inner = SE ()

-- | A consumer of the values.
type Sink a = SE (Gui, Output a)

-- | A producer of the values.
type Source a = SE (Gui, Input a)

-- | A static element. We can only look at it.
type Display = SE Gui

-- | A widget constructor.
widget :: SE (Gui, Output a, Input b, Inner) -> Widget a b

-- | A consumer constructor.
sink :: SE (Gui, Output a) -> Sink a

-- | A producer constructor.
source :: SE (Gui, Input a) -> Source a

-- | A display constructor.
display :: SE Gui -> Display

-- | Renders the GUI elements on the window. Rectangle is calculated
--   automatically (window doesn't listens for keyboard events).
panel :: Gui -> SE ()

-- | Renders a list of panels.
panels :: [Gui] -> SE ()

-- | Renders the GUI elements on the window. We can specify the window
--   title and rectangle of the window.
panelBy :: String -> Maybe Rect -> Gui -> SE ()

-- | Renders the GUI elements on the window. Rectangle is calculated
--   automatically (window listens for keyboard events).
keyPanel :: Gui -> SE ()

-- | Renders a list of panels. Panels are sensitive to keyboard events.
keyPanels :: [Gui] -> SE ()

-- | Renders the GUI elements on the window. We can specify the window
--   title and rectangle of the window. Panesls are sensitive to keyboard
--   events.
keyPanelBy :: String -> Maybe Rect -> Gui -> SE ()

module Csound.SigSpace

-- | A class for easy way to process the outputs of the instruments.
class Num a => SigSpace a
mapSig :: SigSpace a => (Sig -> Sig) -> a -> a
bindSig :: SigSpace a => (Sig -> SE Sig) -> a -> SE a

-- | Scaling the sound.
mul :: SigSpace a => Sig -> a -> a

-- | Crossfade.
--   
--   <pre>
--   cfd coeff sig1 sig2
--   </pre>
--   
--   If coeff equals 0 then we get the first signal and if it equals 1 we
--   get the second signal.
cfd :: SigSpace a => Sig -> a -> a -> a

-- | Generic crossfade for n coefficients and n+1 signals.
--   
--   <pre>
--   cfds coeffs sigs
--   </pre>
cfds :: SigSpace a => [Sig] -> [a] -> a

-- | Spectral crossfade.
cfdSpec :: Sig -> Spec -> Spec -> Spec

-- | Generic spectral crossfade.
cfdsSpec :: [Sig] -> [Spec] -> Spec

-- | Weighted sum.
wsum :: SigSpace a => [(Sig, a)] -> a
instance Fractional (a -> (Sig, Sig, Sig, Sig))
instance Fractional (a -> (Sig, Sig, Sig))
instance Fractional (a -> (Sig, Sig))
instance Fractional (a -> Sig)
instance Fractional (a -> SE (Sig, Sig, Sig, Sig))
instance Fractional (a -> SE (Sig, Sig, Sig))
instance Fractional (a -> SE (Sig, Sig))
instance Fractional (a -> SE Sig)
instance Fractional (SE (Sig, Sig, Sig, Sig))
instance Fractional (SE (Sig, Sig, Sig))
instance Fractional (SE (Sig, Sig))
instance Fractional (SE Sig)
instance Fractional (Sig, Sig, Sig, Sig)
instance Fractional (Sig, Sig, Sig)
instance Fractional (Sig, Sig)
instance Num (a -> SE (Sig, Sig, Sig, Sig))
instance Num (a -> SE (Sig, Sig, Sig))
instance Num (a -> SE (Sig, Sig))
instance Num (a -> SE Sig)
instance Num (a -> (Sig, Sig, Sig, Sig))
instance Num (a -> (Sig, Sig, Sig))
instance Num (a -> (Sig, Sig))
instance Num (a -> Sig)
instance Num (SE (Sig, Sig, Sig, Sig))
instance Num (SE (Sig, Sig, Sig))
instance Num (SE (Sig, Sig))
instance Num (SE Sig)
instance Num (Sig, Sig, Sig, Sig)
instance Num (Sig, Sig, Sig)
instance Num (Sig, Sig)
instance SigSpace (SE (Sig, Sig, Sig, Sig))
instance SigSpace (SE (Sig, Sig, Sig))
instance SigSpace (SE (Sig, Sig))
instance SigSpace (SE Sig)
instance SigSpace (Sig, Sig, Sig, Sig)
instance SigSpace (Sig, Sig, Sig)
instance SigSpace (Sig, Sig)
instance SigSpace Sig

module Csound.Options

-- | Csound options. The default values are
--   
--   <pre>
--   flags      = def     -- the only flag set by default is "no-displays" 
--                        -- to supress the display of the tables
--   sampleRate = 44100
--   blockSize  = 64
--   gain       = 0.5
--   tabFi      = fineFi 13 [(idLins, 11), (idExps, 11), (idConsts, 9), (idSplines, 11), (idStartEnds, 12)] }
--   </pre>
data Options :: *
Options :: Flags -> Maybe Int -> Maybe Int -> Maybe Double -> Maybe TabFi -> Options

-- | Csound command line flags
csdFlags :: Options -> Flags

-- | The sample rate
csdSampleRate :: Options -> Maybe Int

-- | The number of audio samples in one control step
csdBlockSize :: Options -> Maybe Int

-- | A gain of the final output
csdGain :: Options -> Maybe Double

-- | Default fidelity of the arrays
csdTabFi :: Options -> Maybe TabFi

-- | Sets sample rate and block size
--   
--   <pre>
--   setRates sampleRate blockSize
--   </pre>
setRates :: Int -> Int -> Options

-- | Sets hardware and software buffers.
--   
--   <pre>
--   setBufs hardwareBuf ioBuf
--   </pre>
setBufs :: Int -> Int -> Options
setGain :: Double -> Options
setJack :: String -> Options
setOutput :: String -> Options
setInput :: String -> Options
setDac :: Options
setAdc :: Options
setDacBy :: String -> Options
setAdcBy :: String -> Options
setThru :: Options
data Flags :: *
Flags :: AudioFileOutput -> IdTags -> Maybe Rtaudio -> Maybe PulseAudio -> MidiIO -> MidiRT -> Maybe Rtmidi -> Displays -> Config -> Maybe String -> Flags
audioFileOutput :: Flags -> AudioFileOutput
idTags :: Flags -> IdTags
rtaudio :: Flags -> Maybe Rtaudio
pulseAudio :: Flags -> Maybe PulseAudio
midiIO :: Flags -> MidiIO
midiRT :: Flags -> MidiRT
rtmidi :: Flags -> Maybe Rtmidi
displays :: Flags -> Displays
config :: Flags -> Config
flagsVerbatim :: Flags -> Maybe String
data AudioFileOutput :: *
AudioFileOutput :: Maybe FormatSamples -> Maybe FormatType -> Maybe String -> Maybe String -> Bool -> Bool -> Maybe Dither -> AudioFileOutput
formatSamples :: AudioFileOutput -> Maybe FormatSamples
formatType :: AudioFileOutput -> Maybe FormatType
output :: AudioFileOutput -> Maybe String
input :: AudioFileOutput -> Maybe String
nosound :: AudioFileOutput -> Bool
nopeaks :: AudioFileOutput -> Bool
dither :: AudioFileOutput -> Maybe Dither
data FormatHeader :: *
NoHeader :: FormatHeader
RewriteHeader :: FormatHeader
data FormatSamples :: *
Bit24 :: FormatSamples
Alaw :: FormatSamples
Uchar :: FormatSamples
Schar :: FormatSamples
FloatSamples :: FormatSamples
Ulaw :: FormatSamples
Short :: FormatSamples
Long :: FormatSamples
data FormatType :: *
Aiff :: FormatType
Au :: FormatType
Avr :: FormatType
Caf :: FormatType
Flac :: FormatType
Htk :: FormatType
Ircam :: FormatType
Mat4 :: FormatType
Mat5 :: FormatType
Nis :: FormatType
Paf :: FormatType
Pvf :: FormatType
Raw :: FormatType
Sd2 :: FormatType
Sds :: FormatType
Svx :: FormatType
Voc :: FormatType
W64 :: FormatType
Wav :: FormatType
Wavex :: FormatType
Xi :: FormatType
data Dither :: *
Triangular :: Dither
Uniform :: Dither
data IdTags :: *
IdTags :: Maybe String -> Maybe String -> Maybe String -> Maybe String -> Maybe String -> Maybe String -> IdTags
idArtist :: IdTags -> Maybe String
idComment :: IdTags -> Maybe String
idCopyright :: IdTags -> Maybe String
idDate :: IdTags -> Maybe String
idSoftware :: IdTags -> Maybe String
idTitle :: IdTags -> Maybe String
data Rtaudio :: *
PortAudio :: Rtaudio
Alsa :: Rtaudio
Jack :: String -> String -> String -> Rtaudio
jackClient :: Rtaudio -> String
jackInport :: Rtaudio -> String
jackOutport :: Rtaudio -> String
Mme :: Rtaudio
CoreAudio :: Rtaudio
NoRtaudio :: Rtaudio
data PulseAudio :: *
PulseAudio :: String -> String -> String -> PulseAudio
paServer :: PulseAudio -> String
paOutput :: PulseAudio -> String
paInput :: PulseAudio -> String
data MidiIO :: *
MidiIO :: Maybe String -> Maybe String -> Maybe String -> Bool -> Bool -> MidiIO
midiFile :: MidiIO -> Maybe String
midiOutFile :: MidiIO -> Maybe String
muteTracks :: MidiIO -> Maybe String
rawControllerMode :: MidiIO -> Bool
terminateOnMidi :: MidiIO -> Bool
data MidiRT :: *
MidiRT :: Maybe String -> Maybe Int -> Maybe Int -> Maybe Int -> Maybe Int -> Maybe Int -> Maybe Int -> Maybe String -> MidiRT
midiDevice :: MidiRT -> Maybe String
midiKey :: MidiRT -> Maybe Int
midiKeyCps :: MidiRT -> Maybe Int
midiKeyOct :: MidiRT -> Maybe Int
midiKeyPch :: MidiRT -> Maybe Int
midiVelocity :: MidiRT -> Maybe Int
midiVelocityAmp :: MidiRT -> Maybe Int
midiOutDevice :: MidiRT -> Maybe String
data Rtmidi :: *
PortMidi :: Rtmidi
AlsaMidi :: Rtmidi
MmeMidi :: Rtmidi
WinmmMidi :: Rtmidi
VirtualMidi :: Rtmidi
NoRtmidi :: Rtmidi
data Displays :: *
Displays :: Maybe Int -> Maybe DisplayMode -> Maybe Int -> Maybe Int -> Maybe Int -> Maybe Int -> Maybe Int -> Maybe Int -> Maybe Int -> Maybe Int -> Bool -> Bool -> Maybe Int -> Displays
csdLineNums :: Displays -> Maybe Int
displayMode :: Displays -> Maybe DisplayMode
displayHeartbeat :: Displays -> Maybe Int
messageLevel :: Displays -> Maybe Int
mAmps :: Displays -> Maybe Int
mRange :: Displays -> Maybe Int
mWarnings :: Displays -> Maybe Int
mDb :: Displays -> Maybe Int
mColours :: Displays -> Maybe Int
mBenchmarks :: Displays -> Maybe Int
msgColor :: Displays -> Bool
displayVerbose :: Displays -> Bool
listOpcodes :: Displays -> Maybe Int
data DisplayMode :: *
NoDisplay :: DisplayMode
PostScriptDisplay :: DisplayMode
AsciiDisplay :: DisplayMode
data Config :: *
Config :: Maybe Int -> Maybe Int -> Maybe Int -> Maybe Int -> Maybe String -> Maybe (String, String) -> Maybe (String, String) -> Bool -> Maybe Int -> Maybe (Int, String) -> Maybe Double -> Maybe Int -> Config
hwBuf :: Config -> Maybe Int
ioBuf :: Config -> Maybe Int
newKr :: Config -> Maybe Int
newSr :: Config -> Maybe Int
scoreIn :: Config -> Maybe String
omacro :: Config -> Maybe (String, String)
smacro :: Config -> Maybe (String, String)
setSched :: Config -> Bool
schedNum :: Config -> Maybe Int
strsetN :: Config -> Maybe (Int, String)
skipSeconds :: Config -> Maybe Double
setTempo :: Config -> Maybe Int


-- | Rendering of Csound files and playing the music in real time.
--   
--   How are we going to get the sound out of Haskell code? Instruments are
--   ready and we have written all the scores for them. Now, it's time to
--   use the rendering functions. We can render haskell expressions to
--   Csound code. A rendering function takes a value that represents a
--   sound (it's a tuple of signals) and produces a string with Csound
--   code. It can take a value that represents the flags for the csound
--   compiler and global settings (<a>Options</a>). Then we can save this
--   string to file and convert it to sound with csound compiler
--   
--   <pre>
--   csound -o music.wav music.csd
--   </pre>
--   
--   Or we can play it in real time with -odac flag. It sends the sound
--   directly to soundcard. It's usefull when we are using midi or tweek
--   the parameters in real time with sliders or knobs.
--   
--   <pre>
--   csound -odac music.csd
--   </pre>
--   
--   The main function of this module is <a>renderCsdBy</a>. Other function
--   are nothing but wrappers that produce the Csound code and make
--   something useful with it (saving to file, playing with specific player
--   or in real time).
module Csound.IO
class RenderCsd a
renderCsdBy :: RenderCsd a => Options -> a -> IO String

-- | Renders Csound file.
renderCsd :: RenderCsd a => a -> IO String

-- | Render Csound file and save it to the give file.
writeCsd :: RenderCsd a => String -> a -> IO ()

-- | Render Csound file with options and save it to the give file.
writeCsdBy :: RenderCsd a => Options -> String -> a -> IO ()

-- | Renders Csound file, saves it to the given file, renders with csound
--   command and plays it with the given program.
--   
--   <pre>
--   playCsd program file csd 
--   </pre>
--   
--   Produces files <tt>file.csd</tt> (with <a>renderCsd</a>) and
--   <tt>file.wav</tt> (with <tt>csound</tt>) and then invokes:
--   
--   <pre>
--   program "file.wav"
--   </pre>
playCsd :: RenderCsd a => (String -> IO ()) -> String -> a -> IO ()

-- | Works just like <a>playCsd</a> but you can supply csound options.
playCsdBy :: RenderCsd a => Options -> (String -> IO ()) -> String -> a -> IO ()

-- | Renders to tmp.csd and tmp.wav and plays with mplayer.
mplayer :: RenderCsd a => a -> IO ()

-- | Renders to tmp.csd and tmp.wav and plays with mplayer.
mplayerBy :: RenderCsd a => Options -> a -> IO ()

-- | Renders to tmp.csd and tmp.wav and plays with totem player.
totem :: RenderCsd a => a -> IO ()

-- | Renders to tmp.csd and tmp.wav and plays with totem player.
totemBy :: RenderCsd a => Options -> a -> IO ()

-- | Renders csound code to file <tt>tmp.csd</tt> and plays it with
--   <tt>-odac</tt> option (sound output goes to soundcard in real time).
dac :: RenderCsd a => a -> IO ()

-- | <a>dac</a> with options.
dacBy :: RenderCsd a => Options -> a -> IO ()

-- | Output to dac with virtual midi keyboard.
vdac :: RenderCsd a => a -> IO ()

-- | Output to dac with virtual midi keyboard with specified options.
vdacBy :: RenderCsd a => Options -> a -> IO ()

-- | Renders to file <tt>tmp.csd</tt> and invokes the csound on it.
csd :: RenderCsd a => a -> IO ()

-- | Renders to file <tt>tmp.csd</tt> and invokes the csound on it.
csdBy :: RenderCsd a => Options -> a -> IO ()
instance (Sigs a, Sigs b) => RenderCsd (a -> SE b)
instance (Sigs a, Sigs b) => RenderCsd (a -> b)
instance RenderCsd (SE ((Sig, Sig, Sig, Sig, Sig, Sig, Sig, Sig), (Sig, Sig, Sig, Sig, Sig, Sig, Sig, Sig), (Sig, Sig, Sig, Sig, Sig, Sig, Sig, Sig), (Sig, Sig, Sig, Sig, Sig, Sig, Sig, Sig)))
instance RenderCsd (SE ((Sig, Sig, Sig, Sig, Sig, Sig, Sig, Sig), (Sig, Sig, Sig, Sig, Sig, Sig, Sig, Sig)))
instance RenderCsd (SE (Sig, Sig, Sig, Sig, Sig, Sig, Sig, Sig))
instance RenderCsd (SE (Sig, Sig, Sig, Sig, Sig, Sig))
instance RenderCsd (SE (Sig, Sig, Sig, Sig))
instance RenderCsd (SE (Sig, Sig))
instance RenderCsd (SE Sig)
instance RenderCsd ((Sig, Sig, Sig, Sig, Sig, Sig, Sig, Sig), (Sig, Sig, Sig, Sig, Sig, Sig, Sig, Sig), (Sig, Sig, Sig, Sig, Sig, Sig, Sig, Sig), (Sig, Sig, Sig, Sig, Sig, Sig, Sig, Sig))
instance RenderCsd ((Sig, Sig, Sig, Sig, Sig, Sig, Sig, Sig), (Sig, Sig, Sig, Sig, Sig, Sig, Sig, Sig))
instance RenderCsd (Sig, Sig, Sig, Sig, Sig, Sig, Sig, Sig)
instance RenderCsd (Sig, Sig, Sig, Sig, Sig, Sig)
instance RenderCsd (Sig, Sig, Sig, Sig)
instance RenderCsd (Sig, Sig)
instance RenderCsd Sig
instance RenderCsd (SE ())


-- | The module contains the modules that are responsible for converting
--   events to signals
module Csound.Control


-- | The Csound types.
--   
--   There are several primitive types:
--   
--   <ul>
--   <li><tt>Sig</tt> - signals</li>
--   <li><tt>D</tt> - numbers</li>
--   <li><tt>Str</tt> - strings</li>
--   <li><tt>Tab</tt> - 1-dimensional arrays</li>
--   <li><tt>Spec</tt> and <tt>Wspec</tt> - sound spectrums</li>
--   </ul>
--   
--   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 <tt>Unit</tt>.
module Csound.Types

-- | Signals
data Sig :: *

-- | Constant numbers
data D :: *

-- | Tables (or arrays)
data Tab :: *

-- | Strings
data Str :: *

-- | Spectrum. It's <tt>fsig</tt> in the Csound.
data Spec :: *

-- | Another type for spectrum. It's <tt>wsig</tt> in the Csound.
data Wspec :: *

-- | A signal of booleans.
data BoolSig :: *

-- | A constant boolean value.
data BoolD :: *

-- | Contains all Csound values.
class Val a
fromGE :: Val a => GE E -> a
toGE :: Val a => a -> GE E
fromE :: Val a => E -> a
class Val a => SigOrD a

-- | Constructs a number.
double :: Double -> D

-- | Constructs an integer.
int :: Int -> D

-- | Constructs a string.
text :: String -> Str

-- | Querries a total duration of the note. It's equivallent to Csound's
--   <tt>p3</tt> field.
idur :: D
getSampleRate :: D
getControlRate :: D
getBlockSize :: D

-- | Sets a rate of the signal to audio rate.
ar :: Sig -> Sig

-- | Sets a rate of the signal to control rate.
kr :: Sig -> Sig

-- | Converts a signal to the number (initial value of the signal).
ir :: Sig -> D

-- | Makes a constant signal from the number.
sig :: D -> Sig

-- | Appends initialisation arguments. It's up to user to supply arguments
--   with the right types. For example:
--   
--   <pre>
--   oscil 0.5 440 sinWave `withInits` (0.5 :: D)
--   </pre>
withInits :: (Tuple a, Tuple b) => a -> b -> a

-- | A special case of <tt>withInits</tt>. Here all inits are numbers.
withDs :: Tuple a => a -> [D] -> a

-- | A special case of <tt>withInits</tt>. Here all inits are signals.
withSigs :: Tuple a => a -> [Sig] -> a

-- | A special case of <tt>withInits</tt>. Here all inits are arrays.
withTabs :: Tuple a => a -> [Tab] -> a

-- | Appends an init value which is a number.
withD :: Tuple a => a -> D -> a

-- | Appends an init value which is a signal.
withSig :: Tuple a => a -> Sig -> a

-- | Appends an init value which is a table.
withTab :: Tuple a => a -> Tab -> a

-- | Applies a seed to the random value. It's equivalent to the
--   <tt>withD</tt> 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.
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

-- | Creates a constant boolean signal.
boolSig :: BoolD -> BoolSig

-- | Invokes the given procedure if the boolean signal is true.
when1 :: BoolSig -> SE () -> SE ()

-- | The chain of <tt>when1</tt>s. Tests all the conditions in sequence if
--   everything is false it invokes the procedure given in the second
--   argument.
whens :: [(BoolSig, SE ())] -> SE () -> SE ()
type Sig2 = (Sig, Sig)
type Sig4 = (Sig, Sig, Sig, Sig)
type Sig6 = (Sig, Sig, Sig, Sig, Sig, Sig)
type Sig8 = (Sig, Sig, Sig, Sig, Sig, Sig, Sig, Sig)
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)

-- | A tuple of Csound values.
class Tuple a
tupleMethods :: Tuple a => TupleMethods a

-- | Defines instance of type class <a>Tuple</a> for a new type in terms of
--   an already defined one.
makeTupleMethods :: Tuple a => (a -> b) -> (b -> a) -> TupleMethods b

-- | Csound's empty tuple.
data Unit :: *

-- | Constructs Csound's empty tuple.
unit :: Unit

-- | <tt>ifB</tt> for tuples of csound values.
ifTuple :: Tuple a => BoolSig -> a -> a -> a

-- | <tt>guardedB</tt> for tuples of csound values.
guardedTuple :: Tuple b => [(BoolSig, b)] -> b -> b

-- | <tt>caseB</tt> for tuples of csound values.
caseTuple :: Tuple b => a -> [(a -> BoolSig, b)] -> b -> b
class Tuple a => Arg a

-- | <tt>ifB</tt> for constants.
ifArg :: (Arg a, Tuple a) => BoolD -> a -> a -> a

-- | <tt>guardedB</tt> for constants.
guardedArg :: (Tuple b, Arg b) => [(BoolD, b)] -> b -> b

-- | <tt>caseB</tt> for constants.
caseArg :: (Tuple b, Arg b) => a -> [(a -> BoolD, b)] -> b -> b

-- | The tuples of signals.
class Tuple a => Sigs a


-- | Creating Function Tables (Buffers)
module Csound.Tab

-- | Tables (or arrays)
data Tab :: *

-- | Table size fidelity (how many points in the table by default).
data TabFi :: *

-- | Sets different table size for different GEN-routines.
--   
--   <pre>
--   fineFi n ps 
--   </pre>
--   
--   where
--   
--   <ul>
--   <li><tt>n</tt> is the default value for table size (size is a
--   <tt>n</tt> power of 2) for all gen routines that are not listed in the
--   next argument <tt>ps</tt>.</li>
--   <li><tt>ps</tt> is a list of pairs <tt>(genRoutineId,
--   tableSizeDegreeOf2)</tt> that sets the given table size for a given
--   GEN-routine.</li>
--   </ul>
--   
--   with this function we can set lower table sizes for tables that are
--   usually used in the envelopes.
fineFi :: Int -> [(Int, Int)] -> TabFi

-- | Sets the same table size for all tables.
--   
--   <pre>
--   coarseFi n
--   </pre>
--   
--   where <tt>n</tt> is a degree of 2. For example, <tt>n = 10</tt> sets
--   size to 1024 points for all tables by default.
coarseFi :: Int -> TabFi

-- | Table contains all provided values (table is extended to contain all
--   values and to be of the power of 2 or the power of two plus one). (by
--   default it skips normalization).
doubles :: [Double] -> Tab
wavs :: String -> Double -> Int -> Tab
mp3s :: String -> Double -> Tab
type PartialStrength = Double
type PartialNumber = Double
type PartialPhase = Double
type PartialDC = Double

-- | Series of harmonic partials:
--   
--   <pre>
--   sine = sines [1]
--   </pre>
--   
--   <pre>
--   saw = sines $ fmap (1 / ) [1 .. 10]
--   </pre>
--   
--   <pre>
--   square = sines $ fmap (1 / ) [1, 3 .. 11]
--   </pre>
--   
--   <pre>
--   triangle = sines $ zipWith (\a b -&gt; a / (b ** 2)) (cycle [1, -1]) [1, 3 .. 11]
--   </pre>
sines :: [PartialStrength] -> Tab

-- | Specifies series of possibly inharmonic partials.
sines3 :: [(PartialNumber, PartialStrength, PartialPhase)] -> Tab

-- | Just like <a>sines3</a> but phases are set to zero.
sines2 :: [(PartialNumber, PartialStrength)] -> Tab

-- | Just like <a>sines2</a> but partial strength is set to one.
sines1 :: [PartialNumber] -> Tab

-- | Specifies series of possibly inharmonic partials with direct current.
sines4 :: [(PartialNumber, PartialStrength, PartialPhase, PartialDC)] -> Tab

-- | Generates values similar to the opcode <a>buzz</a>.
--   
--   <pre>
--   buzzes numberOfHarmonics [lowestHarmonic, coefficientOfAttenuation]
--   </pre>
--   
--   With <tt>buzzes n [l, r]</tt> you get <tt>n</tt> harmonics from
--   <tt>l</tt> that are attenuated by the factor of <tt>r</tt> on each
--   step.
buzzes :: Double -> [Double] -> Tab

-- | Table for pure sine wave.
sine :: Tab

-- | Table for pure cosine wave.
cosine :: Tab

-- | Table for sigmoid wave.
sigmoid :: Tab

-- | Constant segments (sample and hold).
--   
--   <pre>
--   consts [a, n1, b, n2, c, ...]
--   </pre>
--   
--   where
--   
--   <ul>
--   <li>a, b, c .. - are ordinate values</li>
--   <li><tt>n1, n2, ...</tt> are lengths of the segments relative to the
--   total number of the points in the table</li>
--   </ul>
consts :: [Double] -> Tab

-- | Segments of straight lines.
--   
--   <pre>
--   lins [a, n1, b, n2, c, ...]
--   </pre>
--   
--   where
--   
--   <ul>
--   <li>a, b, c .. - are ordinate values</li>
--   <li><tt>n1, n2, ...</tt> are lengths of the segments relative to the
--   total number of the points in the table</li>
--   </ul>
lins :: [Double] -> Tab

-- | Segments of cubic polynomials.
--   
--   <pre>
--   cubes [a, n1, b, n2, c, ...]
--   </pre>
--   
--   where
--   
--   <ul>
--   <li>a, b, c .. - are ordinate values</li>
--   <li><tt>n1, n2, ...</tt> are lengths of the segments relative to the
--   total number of the points in the table</li>
--   </ul>
cubes :: [Double] -> Tab

-- | Segments of the exponential curves.
--   
--   <pre>
--   exps [a, n1, b, n2, c, ...]
--   </pre>
--   
--   where
--   
--   <ul>
--   <li><tt>a, b, c, ...</tt> are ordinate values</li>
--   <li><tt>n1, n2, ...</tt> are lengths of the segments relative to the
--   total number of the points in the table</li>
--   </ul>
exps :: [Double] -> Tab

-- | Cubic spline curve.
--   
--   <pre>
--   splines [a, n1, b, n2, c, ...]
--   </pre>
--   
--   where
--   
--   <ul>
--   <li>a, b, c .. - are ordinate values</li>
--   <li><tt>n1, n2, ...</tt> are lengths of the segments relative to the
--   total number of the points in the table</li>
--   </ul>
splines :: [Double] -> Tab

-- | Creates a table from a starting value to an ending value.
--   
--   <pre>
--   startEnds [val1, dur1, type1, val2, dur2, type2, val3, ... typeX, valN]
--   </pre>
--   
--   <ul>
--   <li>val1, val2 ... -- end points of the segments</li>
--   <li>dur1, dur2 ... -- durations of the segments</li>
--   <li>type1, type2 ... -- if 0, a straight line is produced. If
--   non-zero, then it creates the following curve, for dur steps:</li>
--   </ul>
--   
--   <pre>
--   beg + (end - beg) * (1 - exp( i*type)) / (1 - exp(
--   </pre>
--   
--   <ul>
--   <li>beg, end - end points of the segment</li>
--   <li>dur - duration of the segment</li>
--   </ul>
startEnds :: [Double] -> Tab

-- | Equally spaced constant segments.
--   
--   <pre>
--   econsts [a, b, c, ...] 
--   </pre>
--   
--   is the same as
--   
--   <pre>
--   consts [a, 1, b, 1, c, ...]
--   </pre>
econsts :: [Double] -> Tab

-- | Equally spaced segments of straight lines.
--   
--   <pre>
--   elins [a, b, c, ...] 
--   </pre>
--   
--   is the same as
--   
--   <pre>
--   lins [a, 1, b, 1, c, ...]
--   </pre>
elins :: [Double] -> Tab

-- | Equally spaced segments of cubic polynomials.
--   
--   <pre>
--   ecubes [a, b, c, ...] 
--   </pre>
--   
--   is the same as
--   
--   <pre>
--   cubes [a, 1, b, 1, c, ...]
--   </pre>
ecubes :: [Double] -> Tab

-- | Equally spaced segments of exponential curves.
--   
--   <pre>
--   eexps [a, b, c, ...] 
--   </pre>
--   
--   is the same as
--   
--   <pre>
--   exps [a, 1, b, 1, c, ...]
--   </pre>
eexps :: [Double] -> Tab

-- | Equally spaced spline curve.
--   
--   <pre>
--   esplines [a, b, c, ...] 
--   </pre>
--   
--   is the same as
--   
--   <pre>
--   splines [a, 1, b, 1, c, ...]
--   </pre>
esplines :: [Double] -> Tab

-- | Equally spaced interpolation for the function <tt>startEnds</tt>
--   
--   <pre>
--   estartEnds [val1, type1, val2, typ2, ...]
--   </pre>
--   
--   is the same as
--   
--   <pre>
--   estartEnds [val1, 1, type1, val2, 1, type2, ...]
--   </pre>
estartEnds :: [Double] -> Tab

-- | Polynomials.
--   
--   <pre>
--   polys xl xr [c0, c1, c2, ..]
--   </pre>
--   
--   where
--   
--   <ul>
--   <li>xl, xr - left and right values of the interval over wich
--   polynomial is defined</li>
--   <li>[c0, c1, c2, ...] -- coefficients of the polynomial</li>
--   </ul>
--   
--   <pre>
--   c0 + c1 * x + c2 * x * x + ...
--   </pre>
polys :: Double -> Double -> [Double] -> Tab

-- | Chebyshev polynomials of the first kind.
--   
--   <pre>
--   polys xl xr [h0, h1, h2, ..]
--   </pre>
--   
--   where
--   
--   <ul>
--   <li>xl, xr - left and right values of the interval over wich
--   polynomial is defined</li>
--   <li>[h0, h1, h2, ...] -- relative strength of the partials</li>
--   </ul>
chebs1 :: Double -> Double -> [Double] -> Tab

-- | Chebyshev polynomials of the second kind.
--   
--   <pre>
--   polys xl xr [h0, h1, h2, ..]
--   </pre>
--   
--   where
--   
--   <ul>
--   <li>xl, xr - left and right values of the interval over wich
--   polynomial is defined</li>
--   <li>[h0, h1, h2, ...] -- relative strength of the partials</li>
--   </ul>
chebs2 :: Double -> Double -> [Double] -> Tab

-- | Modified Bessel function of the second kind, order 0 (for amplitude
--   modulated FM).
--   
--   <pre>
--   bessels xint
--   </pre>
--   
--   the function is defined within the interval <tt>[0, xint]</tt>.
bessels :: Double -> Tab
winHamming :: [Double] -> Tab
winHanning :: [Double] -> Tab
winBartlett :: [Double] -> Tab
winBlackman :: [Double] -> Tab
winHarris :: [Double] -> Tab
winGaussian :: [Double] -> Tab
winKaiser :: [Double] -> Tab
winRectangle :: [Double] -> Tab
winSync :: [Double] -> Tab

-- | Creates a table of doubles (It's f-table in Csound). Arguments are:
--   
--   <ul>
--   <li>identificator of the GEN routine</li>
--   <li>GEN routine arguments</li>
--   </ul>
--   
--   All tables are created at 0 and memory is never released.
gen :: Int -> [Double] -> Tab

-- | Skips normalization (sets table size to negative value)
skipNorm :: Tab -> Tab

-- | Force normalization (sets table size to positive value). Might be
--   useful to restore normalization for table <a>doubles</a>.
forceNorm :: Tab -> Tab

-- | Sets an absolute size value. As you can do it in the Csound files.
setSize :: Int -> Tab -> Tab

-- | Sets the relative size value. You can set the base value in the
--   options (see <a>tabResolution</a> at <a>CsdOptions</a>, with
--   tabResolution you can easily change table sizes for all your tables).
--   Here zero means the base value. 1 is the base value multiplied by 2, 2
--   is the base value multiplied by 4 and so on. Negative values mean
--   division by the specified degree.
setDegree :: Int -> Tab -> Tab

-- | Adds guard point to the table size (details of the interpolation
--   schemes: you do need guard point if your intention is to read the
--   table once but you don't need the guard point if you read table in
--   many cycles, the guard point is the the first point of your table).
guardPoint :: Tab -> Tab

-- | Shortcut for <a>guardPoint</a>.
gp :: Tab -> Tab

-- | Sets degrees from -3 to 3.
lllofi :: Tab -> Tab

-- | Sets degrees from -3 to 3.
llofi :: Tab -> Tab

-- | Sets degrees from -3 to 3.
lofi :: Tab -> Tab

-- | Sets degrees from -3 to 3.
midfi :: Tab -> Tab

-- | Sets degrees from -3 to 3.
hifi :: Tab -> Tab

-- | Sets degrees from -3 to 3.
hhifi :: Tab -> Tab

-- | Sets degrees from -3 to 3.
hhhifi :: Tab -> Tab
idWavs :: Int
idMp3s :: Int
idDoubles :: Int
idSines :: Int
idSines3 :: Int
idSines2 :: Int
idPartials :: Int
idSines4 :: Int
idBuzzes :: Int
idConsts :: Int
idLins :: Int
idCubes :: Int
idExps :: Int
idSplines :: Int
idStartEnds :: Int
idPolys :: Int
idChebs1 :: Int
idChebs2 :: Int
idBessels :: Int
idWins :: Int

module Csound.Air

-- | A pure tone (sine wave).
osc :: Sig -> Sig

-- | An oscillator with user provided waveform.
oscBy :: Tab -> Sig -> Sig

-- | A sawtooth.
saw :: Sig -> Sig

-- | Integrated sawtooth: 4 * x * (1 - x).
isaw :: Sig -> Sig

-- | Pulse (not normalized).
pulse :: Sig -> Sig

-- | A square wave.
sqr :: Sig -> Sig

-- | A triangle wave.
tri :: Sig -> Sig

-- | A band-limited oscillator with user defined waveform (it's stored in
--   the table).
blosc :: Tab -> Sig -> Sig

-- | Turns a bipolar sound (ranges from -1 to 1) to unipolar (ranges from 0
--   to 1)
unipolar :: Sig -> Sig

-- | Turns an unipolar sound (ranges from 0 to 1) to bipolar (ranges from
--   -1 to 1)
bipolar :: Sig -> Sig

-- | Rescaling of the bipolar signal (-1, 1) -&gt; (a, b)
--   
--   <pre>
--   on a b biSig
--   </pre>
on :: Sig -> Sig -> Sig -> Sig

-- | Rescaling of the unipolar signal (0, 1) -&gt; (a, b)
--   
--   <pre>
--   on a b uniSig
--   </pre>
uon :: Sig -> Sig -> Sig -> Sig

-- | Unipolar pure tone.
uosc :: Sig -> Sig

-- | Unipolar <a>oscBy</a>.
uoscBy :: Tab -> Sig -> Sig

-- | Unipolar sawtooth.
usaw :: Sig -> Sig

-- | Unipolar integrated sawtooth.
uisaw :: Sig -> Sig

-- | Unipolar pulse.
upulse :: Sig -> Sig

-- | Unipolar square wave.
usqr :: Sig -> Sig

-- | Unipolar triangle wave.
utri :: Sig -> Sig

-- | Unipolar band-limited oscillator.
ublosc :: Tab -> Sig -> Sig

-- | Makes time intervals relative to the note's duration. So that:
--   
--   <pre>
--   onIdur [a, t1, b, t2, c]
--   </pre>
--   
--   becomes:
--   
--   <pre>
--   [a, t1 * idur, b, t2 * idur, c]
--   </pre>
onIdur :: [D] -> [D]

-- | The opcode <a>linseg</a> with time intervals relative to the total
--   duration of the note.
lindur :: [D] -> Sig

-- | The opcode <a>expseg</a> with time intervals relative to the total
--   duration of the note.
expdur :: [D] -> Sig

-- | The opcode <a>linen</a> with time intervals relative to the total
--   duration of the note. Total time is set to the value of idur.
--   
--   <pre>
--   linendur asig rise decay
--   </pre>
linendur :: Sig -> D -> D -> Sig

-- | Makes time intervals relative to the note's duration. So that:
--   
--   <pre>
--   onDur dt [a, t1, b, t2, c]
--   </pre>
--   
--   becomes:
--   
--   <pre>
--   [a, t1 * dt, b, t2 * dt, c]
--   </pre>
onDur :: D -> [D] -> [D]

-- | The opcode <a>linseg</a> with time intervals relative to the total
--   duration of the note given by the user.
lindurBy :: D -> [D] -> Sig

-- | The opcode <a>expseg</a> with time intervals relative to the total
--   duration of the note given by the user.
expdurBy :: D -> [D] -> Sig

-- | The opcode <a>linen</a> with time intervals relative to the total
--   duration of the note. Total time is set to the value of the first
--   argument.
--   
--   <pre>
--   linendurBy dt asig rise decay
--   </pre>
linendurBy :: D -> Sig -> D -> D -> Sig

-- | Reads table once during the note length.
once :: Tab -> Sig

-- | Reads table once during a given period of time.
onceBy :: D -> Tab -> Sig

-- | Reads table several times during the note length.
several :: Tab -> Sig -> Sig

-- | Loops over line segments with the given rate.
--   
--   <pre>
--   oscLins [a, durA, b, durB, c, durC ..] cps
--   </pre>
--   
--   where
--   
--   <ul>
--   <li><tt>a</tt>, <tt>b</tt>, <tt>c</tt> ... -- values</li>
--   <li>durA, durB, durC -- durations of the segments relative to the
--   current frequency.</li>
--   </ul>
oscLins :: [D] -> Sig -> Sig

-- | Loops over equally spaced line segments with the given rate.
--   
--   <pre>
--   oscElins [a, b, c] === oscLins [a, 1, b, 1, c]
--   </pre>
oscElins :: [D] -> Sig -> Sig

-- | Loops over exponential segments with the given rate.
--   
--   <pre>
--   oscLins [a, durA, typeA, b, durB, typeB, c, durC, typeC ..] cps
--   </pre>
--   
--   where
--   
--   <ul>
--   <li><tt>a</tt>, <tt>b</tt>, <tt>c</tt> ... -- values</li>
--   <li>durA, durB, durC -- durations of the segments relative to the
--   current frequency.</li>
--   <li>typeA, typeB, typeC, ... -- shape of the envelope. If the value is
--   0 then the shap eis linear; otherwise it is an concave exponential
--   (positive type) or a convex exponential (negative type).</li>
--   </ul>
oscExps :: [D] -> Sig -> Sig

-- | Loops over equally spaced exponential segments with the given rate.
--   
--   <pre>
--   oscLins [a, typeA, b, typeB, c, typeC ..] === oscLins [a, 1, typeA, b, 1, typeB, c, 1, typeC ..]
--   </pre>
oscEexps :: [D] -> Sig -> Sig

-- | <pre>
--   oscLine a b cps
--   </pre>
--   
--   Goes from <tt>a</tt> to <tt>b</tt> and back by line segments. One
--   period is equal to <tt>2/cps</tt> so that one period is passed by
--   <tt>1/cps</tt> seconds.
oscLine :: D -> D -> Sig -> Sig

-- | Fades in with the given attack time.
fadeIn :: D -> Sig

-- | Fades out with the given attack time.
fadeOut :: D -> Sig

-- | A combination of fade in and fade out.
--   
--   <pre>
--   fades attackDuration decayDuration
--   </pre>
fades :: D -> D -> Sig

-- | Fades in by exponent with the given attack time.
expFadeIn :: D -> Sig

-- | Fades out by exponent with the given attack time.
expFadeOut :: D -> Sig

-- | A combination of exponential fade in and fade out.
--   
--   <pre>
--   expFades attackDuration decayDuration
--   </pre>
expFades :: D -> D -> Sig

-- | Low-pass filter.
--   
--   <pre>
--   lp cutoff sig
--   </pre>
lp :: Sig -> Sig -> Sig

-- | High-pass filter.
--   
--   <pre>
--   hp cutoff sig
--   </pre>
hp :: Sig -> Sig -> Sig

-- | Band-pass filter.
--   
--   <pre>
--   bp cutoff bandwidth sig
--   </pre>
bp :: Sig -> Sig -> Sig -> Sig

-- | Band-regect filter.
--   
--   <pre>
--   br cutoff bandwidth sig
--   </pre>
br :: Sig -> Sig -> Sig -> Sig

-- | Low-pass filter.
--   
--   <pre>
--   blp cutoff sig
--   </pre>
blp :: Sig -> Sig -> Sig

-- | High-pass filter.
--   
--   <pre>
--   bhp cutoff sig
--   </pre>
bhp :: Sig -> Sig -> Sig

-- | Band-pass filter.
--   
--   <pre>
--   bbp cutoff bandwidth sig
--   </pre>
bbp :: Sig -> Sig -> Sig -> Sig

-- | Band-regect filter.
--   
--   <pre>
--   bbr cutoff bandwidth sig
--   </pre>
bbr :: Sig -> Sig -> Sig -> Sig

-- | Balanced low-pass filter.
lpb :: Sig -> Sig -> Sig

-- | Balanced high-pass filter.
hpb :: Sig -> Sig -> Sig

-- | Balanced band-pass filter.
bpb :: Sig -> Sig -> Sig -> Sig

-- | Balanced band-reject filter.
brb :: Sig -> Sig -> Sig -> Sig

-- | Balanced butterworth low-pass filter.
blpb :: Sig -> Sig -> Sig

-- | Balanced butterworth high-pass filter.
bhpb :: Sig -> Sig -> Sig

-- | Balanced butterworth band-pass filter.
bbpb :: Sig -> Sig -> Sig -> Sig

-- | Balanced butterworth band-reject filter.
bbrb :: Sig -> Sig -> Sig -> Sig

-- | Moog's low-pass filter.
--   
--   <pre>
--   mlp centerFrequency qResonance signal
--   </pre>
mlp :: Sig -> Sig -> Sig -> Sig
readSnd :: String -> (Sig, Sig)
loopSnd :: String -> (Sig, Sig)
loopSndBy :: D -> String -> (Sig, Sig)
readWav :: Sig -> String -> (Sig, Sig)
loopWav :: Sig -> String -> (Sig, Sig)
readSnd1 :: String -> Sig
loopSnd1 :: String -> Sig
loopSndBy1 :: D -> String -> Sig
readWav1 :: Sig -> String -> Sig
loopWav1 :: Sig -> String -> Sig
takeSnd :: Sigs a => Double -> a -> a
repeatSnd :: Sigs a => D -> a -> a
lengthSnd :: String -> D
toMono :: (Sig, Sig) -> Sig
segments :: D -> Evt (D, Unit)

-- | Mean value.
mean :: Fractional a => [a] -> a

-- | Adds vibrato to the sound unit. Sound units is a function that takes
--   in a frequency.
vibrate :: Sig -> Sig -> (Sig -> a) -> (Sig -> a)

-- | Adds a random vibrato to the sound unit. Sound units is a function
--   that takes in a frequency.
randomPitch :: Sig -> Sig -> (Sig -> a) -> (Sig -> SE a)

-- | Chorus takes a list of displacments from the base frequencies and a
--   sound unit. Output is mean of signals with displacments that is
--   applied to the base frequency.
chorus :: Fractional a => [Sig] -> (Sig -> a) -> Sig -> a

-- | Applies a resonator to the signals. A resonator is a list of band pass
--   filters. A list contains the parameters for the filters:
--   
--   <pre>
--   [(centerFrequency, bandWidth)]
--   </pre>
resons :: [(Sig, Sig)] -> Sig -> Sig

-- | A resonator with user defined band pass filter. Warning: a filter
--   takes in a center frequency, band width and the signal. The signal
--   comes last (this order is not standard in the Csound but it's more
--   convinient to use with Haskell).
resonsBy :: (cps -> bw -> Sig -> Sig) -> [(cps, bw)] -> Sig -> Sig

-- | Chain of mass-spring-damping filters.
--   
--   <pre>
--   modes params baseCps exciter 
--   </pre>
--   
--   <ul>
--   <li>params - a list of pairs <tt>(resonantFrequencyRatio,
--   filterQuality)</tt></li>
--   <li><tt>baseCps</tt> - base frequency of the resonator</li>
--   <li>exciter - an impulse that starts a resonator.</li>
--   </ul>
modes :: [(Sig, Sig)] -> Sig -> Sig -> Sig

-- | Mixes dry and wet signals.
--   
--   <pre>
--   dryWet ratio effect asig
--   </pre>
--   
--   <ul>
--   <li><tt>ratio</tt> - of dry signal to wet</li>
--   <li><tt>effect</tt> - means to wet the signal</li>
--   <li><tt>asig</tt> -- processed signal</li>
--   </ul>
dryWet :: Sig -> (Sig -> Sig) -> Sig -> Sig

-- | Selects odd elements from the list.
odds :: [a] -> [a]

-- | Selects even elements from the list.
evens :: [a] -> [a]
data AdsrBound
AdsrBound :: Double -> Double -> Double -> AdsrBound
attBound :: AdsrBound -> Double
decBound :: AdsrBound -> Double
relBound :: AdsrBound -> Double
data AdsrInit
AdsrInit :: Double -> Double -> Double -> Double -> AdsrInit
attInit :: AdsrInit -> Double
decInit :: AdsrInit -> Double
susInit :: AdsrInit -> Double
relInit :: AdsrInit -> Double
linAdsr :: String -> AdsrBound -> AdsrInit -> Source Sig
expAdsr :: String -> AdsrBound -> AdsrInit -> Source Sig

-- | A widget with four standard waveforms: pure tone, triangle, square and
--   sawtooth. The last parameter is a default waveform (it's set at init
--   time).
classicWaves :: String -> Int -> Source (Sig -> Sig)

-- | Slider for master volume
masterVolume :: Source Sig

-- | Knob for master volume
masterVolumeKnob :: Source Sig

-- | Mono version of the cool reverberation opcode reverbsc.
--   
--   <pre>
--   reverbsc1 asig feedbackLevel cutOffFreq
--   </pre>
reverbsc1 :: Sig -> Sig -> Sig -> Sig

-- | Mono reverb (based on reverbsc)
--   
--   <pre>
--   rever1 feedback asig
--   </pre>
rever1 :: Sig -> Sig -> (Sig, Sig)

-- | Mono reverb (based on reverbsc)
--   
--   <pre>
--   rever2 feedback asigLeft asigRight
--   </pre>
rever2 :: Sig -> Sig -> Sig -> (Sig, Sig)

-- | Reverb with given time.
reverTime :: Sig -> Sig -> Sig

-- | Mono reverb for small room.
smallRoom :: Sig -> (Sig, Sig)

-- | Mono reverb for small hall.
smallHall :: Sig -> (Sig, Sig)

-- | Mono reverb for large hall.
largeHall :: Sig -> (Sig, Sig)

-- | The magic cave reverb (mono).
magicCave :: Sig -> (Sig, Sig)

-- | Stereo reverb for small room.
smallRoom2 :: Sig -> Sig -> (Sig, Sig)

-- | Stereo reverb for small hall.
smallHall2 :: Sig -> Sig -> (Sig, Sig)

-- | Stereo reverb for large hall.
largeHall2 :: Sig -> Sig -> (Sig, Sig)

-- | The magic cave reverb (stereo).
magicCave2 :: Sig -> Sig -> (Sig, Sig)


-- | Basic types and functions.
--   
--   This module re-exports everything.
--   
--   WARNING (for Csound users): the maximum amplitude is 1.0. There is no
--   way to alter it. Don't define your amplitudes with 9000 or 11000. But
--   the good news are: all signals are clipped by 1 so that you can not
--   damage your ears and your speakers by a little typo.
module Csound.Base