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


-- | Sound synthesis with SuperCollider
--   
--   Music and sound synthesis with SuperCollider.
--   
--   Example usage (after installing and booting SuperCollider):
--   
--   <pre>
--   {-# LANGUAGE DataKinds, ExtendedDefaultRules #-}
--   </pre>
--   
--   <pre>
--   import Vivid
--   
--   theSound = sd (0 ::I "note") $ do
--      wobble &lt;- sinOsc (freq_ 5) ? KR ~* 10 ~+ 10
--      s &lt;- 0.1 ~* sinOsc (freq_ $ midiCPS (V::V "note") ~+ wobble)
--      out 0 [s,s]
--   
--   playSong = do
--      fork $ do
--         s0 &lt;- synth theSound (36 ::I "note")
--         wait 1
--         free s0
--      s1 &lt;- synth theSound (60 ::I "note")
--      forM_ [62,66,64] $ \note -&gt; do
--         wait (1/4)
--         set s1 (note ::I "note")
--      wait (1/4)
--      free s1
--   
--   main = do
--      putStrLn "Simplest:"
--      playSong
--   
--      putStrLn "With precise timing:"
--      doScheduledIn 0.1 playSong
--      wait 1
--   
--      putStrLn "Written to a file, non-realtime synthesis:"
--      putStrLn "(Need to quit the running server for NRT)"
--      quitSCServer
--      writeNRT "/tmp/song.wav" playSong
--   </pre>
@package vivid
@version 0.3.0.2


-- | Vivid-specific OSC Bundle encoding
module Vivid.OSC.Bundles

-- | Encode OSC bundles, specifically for NRT synthesis. (It's more than
--   just "mconcat . map <a>encodeOSCBundle</a>").
--   
--   Note also that the last action is when the song ends - so if you want
--   e.g. a note to hold at the end you need to add a "wait"
encodeOSCBundles :: [OSCBundle] -> ByteString
initTreeCommand :: OSC

module Vivid.Randomness

-- | Picks a random element from the provided list
pick :: MonadRandom m => [a] -> m a

-- | Returns an infinite list of randomly-chosen elements from the provided
--   list
--   
--   e.g.
--   
--   <pre>
--   &gt; &gt; take 5 &lt;$&gt; picks [1,2,3,4]
--   &gt; [2,3,1,1,3]
--   </pre>
picks :: (MonadRandom m) => [a] -> m [a]
exprand :: (Fractional n, Floating n, MonadRandom m, Random n) => n -> n -> m n

module Vivid.SynthDef.TypesafeArgs

-- | <pre>
--   &gt;  &gt;  :kind! SetEqual '["bye", "hi","bye","bye"] '["bye","hi","hi"]
--   &gt; SetEqual '["bye","hi","bye","bye"] '["bye","hi","hi"] :: Bool
--   &gt; = 'True
--   </pre>

-- | So for example if you have:
--   
--   <pre>
--   foo = sd (440 ::I "freq") $ do
--      s &lt;- sinOsc (freq_ (A::A "freq!!!"))
--      out 0 [s,s]
--   
--   </pre>
--   
--   It'll tell you that you have an invalid synthdef with the error:
--   
--   <pre>
--   Couldn't match type ‘'False_IsSubsetOf’ with ‘'True_IsSubsetOf’
--                           In the first argument of ‘sinOsc’, namely
--     ‘(freq_ (V :: A "freq!!!"))’
--   
--   </pre>
data Bool_IsSubsetOf
True_IsSubsetOf :: Bool_IsSubsetOf
False_IsSubsetOf :: Bool_IsSubsetOf
data Bool_IsElemOf
True_IsElemOf :: Bool_IsElemOf
False_IsElemOf :: Bool_IsElemOf
class TagList from where {
    type family AllTags from :: [Symbol];
}
tagStrings :: TagList from => from -> [String]
class VarList from where {
    type family InnerVars from :: [Symbol];
}
makeTypedVarList :: VarList from => from -> TypedVarList (InnerVars from)
type V = Variable
data Vs (a :: [Symbol])
Vs :: Vs
data Variable (a :: Symbol)
V :: Variable
data I (x :: Symbol)
I :: Float -> I
data VarSet (s :: [Symbol])
VarSet :: VarSet
type TypedVarList (c :: [Symbol]) = ([(String, Float)], VarSet c)
emptyVarSet :: VarSet '[]
iToLiteralVar :: KnownSymbol s => I s -> (String, Float)
iToVar :: KnownSymbol s => I s -> V s

-- | Lets you combine sets of arguments. e.g.
--   
--   <pre>
--   (1 ::I "foo", 2 ::I "bar") `AddParams` (3 ::I "baz")
--   </pre>
--   
--   means the same thing as
--   
--   <pre>
--   (1 ::I "foo", 2 ::I "bar", 3 ::I "baz")
--   </pre>
--   
--   This is left-biased, just like <a>union</a>
--   
--   i.e. if you say:
--   
--   <pre>
--   (99 ::I "same") `AddParams` (0 ::I "same")
--   </pre>
--   
--   It'll mean the same as
--   
--   <pre>
--   (99 ::I "same")
--   </pre>
data AddParams a b
AddParams :: a -> b -> AddParams a b
toI :: (Real n, KnownSymbol a) => n -> I a
toF :: (Real n) => n -> Float
class GetSymbolVals x
getSymbolVals :: GetSymbolVals x => x -> [String]
instance GHC.TypeLits.KnownSymbol s => GHC.Classes.Eq (Vivid.SynthDef.TypesafeArgs.I s)
instance GHC.TypeLits.KnownSymbol s => GHC.Read.Read (Vivid.SynthDef.TypesafeArgs.I s)
instance GHC.TypeLits.KnownSymbol s => GHC.Classes.Ord (Vivid.SynthDef.TypesafeArgs.I s)
instance (GHC.Show.Show a, GHC.Show.Show b) => GHC.Show.Show (Vivid.SynthDef.TypesafeArgs.AddParams a b)
instance Vivid.SynthDef.TypesafeArgs.VarList (Vivid.SynthDef.TypesafeArgs.AddParams a b)
instance Vivid.SynthDef.TypesafeArgs.TagList ()
instance GHC.TypeLits.KnownSymbol a => Vivid.SynthDef.TypesafeArgs.TagList (Vivid.SynthDef.TypesafeArgs.V a)
instance (GHC.TypeLits.KnownSymbol a, GHC.TypeLits.KnownSymbol b) => Vivid.SynthDef.TypesafeArgs.TagList (Vivid.SynthDef.TypesafeArgs.V a, Vivid.SynthDef.TypesafeArgs.V b)
instance (GHC.TypeLits.KnownSymbol a, GHC.TypeLits.KnownSymbol b, GHC.TypeLits.KnownSymbol c) => Vivid.SynthDef.TypesafeArgs.TagList (Vivid.SynthDef.TypesafeArgs.V a, Vivid.SynthDef.TypesafeArgs.V b, Vivid.SynthDef.TypesafeArgs.V c)
instance (GHC.TypeLits.KnownSymbol a, GHC.TypeLits.KnownSymbol b, GHC.TypeLits.KnownSymbol c, GHC.TypeLits.KnownSymbol d) => Vivid.SynthDef.TypesafeArgs.TagList (Vivid.SynthDef.TypesafeArgs.V a, Vivid.SynthDef.TypesafeArgs.V b, Vivid.SynthDef.TypesafeArgs.V c, Vivid.SynthDef.TypesafeArgs.V d)
instance (GHC.TypeLits.KnownSymbol a, GHC.TypeLits.KnownSymbol b, GHC.TypeLits.KnownSymbol c, GHC.TypeLits.KnownSymbol d, GHC.TypeLits.KnownSymbol e) => Vivid.SynthDef.TypesafeArgs.TagList (Vivid.SynthDef.TypesafeArgs.V a, Vivid.SynthDef.TypesafeArgs.V b, Vivid.SynthDef.TypesafeArgs.V c, Vivid.SynthDef.TypesafeArgs.V d, Vivid.SynthDef.TypesafeArgs.V e)
instance (GHC.TypeLits.KnownSymbol a, GHC.TypeLits.KnownSymbol b, GHC.TypeLits.KnownSymbol c, GHC.TypeLits.KnownSymbol d, GHC.TypeLits.KnownSymbol e, GHC.TypeLits.KnownSymbol f) => Vivid.SynthDef.TypesafeArgs.TagList (Vivid.SynthDef.TypesafeArgs.V a, Vivid.SynthDef.TypesafeArgs.V b, Vivid.SynthDef.TypesafeArgs.V c, Vivid.SynthDef.TypesafeArgs.V d, Vivid.SynthDef.TypesafeArgs.V e, Vivid.SynthDef.TypesafeArgs.V f)
instance (GHC.TypeLits.KnownSymbol a, GHC.TypeLits.KnownSymbol b, GHC.TypeLits.KnownSymbol c, GHC.TypeLits.KnownSymbol d, GHC.TypeLits.KnownSymbol e, GHC.TypeLits.KnownSymbol f, GHC.TypeLits.KnownSymbol g) => Vivid.SynthDef.TypesafeArgs.TagList (Vivid.SynthDef.TypesafeArgs.V a, Vivid.SynthDef.TypesafeArgs.V b, Vivid.SynthDef.TypesafeArgs.V c, Vivid.SynthDef.TypesafeArgs.V d, Vivid.SynthDef.TypesafeArgs.V e, Vivid.SynthDef.TypesafeArgs.V f, Vivid.SynthDef.TypesafeArgs.V g)
instance (GHC.TypeLits.KnownSymbol a, GHC.TypeLits.KnownSymbol b, GHC.TypeLits.KnownSymbol c, GHC.TypeLits.KnownSymbol d, GHC.TypeLits.KnownSymbol e, GHC.TypeLits.KnownSymbol f, GHC.TypeLits.KnownSymbol g, GHC.TypeLits.KnownSymbol h) => Vivid.SynthDef.TypesafeArgs.TagList (Vivid.SynthDef.TypesafeArgs.V a, Vivid.SynthDef.TypesafeArgs.V b, Vivid.SynthDef.TypesafeArgs.V c, Vivid.SynthDef.TypesafeArgs.V d, Vivid.SynthDef.TypesafeArgs.V e, Vivid.SynthDef.TypesafeArgs.V f, Vivid.SynthDef.TypesafeArgs.V g, Vivid.SynthDef.TypesafeArgs.V h)
instance (GHC.TypeLits.KnownSymbol a, GHC.TypeLits.KnownSymbol b, GHC.TypeLits.KnownSymbol c, GHC.TypeLits.KnownSymbol d, GHC.TypeLits.KnownSymbol e, GHC.TypeLits.KnownSymbol f, GHC.TypeLits.KnownSymbol g, GHC.TypeLits.KnownSymbol h, GHC.TypeLits.KnownSymbol i) => Vivid.SynthDef.TypesafeArgs.TagList (Vivid.SynthDef.TypesafeArgs.V a, Vivid.SynthDef.TypesafeArgs.V b, Vivid.SynthDef.TypesafeArgs.V c, Vivid.SynthDef.TypesafeArgs.V d, Vivid.SynthDef.TypesafeArgs.V e, Vivid.SynthDef.TypesafeArgs.V f, Vivid.SynthDef.TypesafeArgs.V g, Vivid.SynthDef.TypesafeArgs.V h, Vivid.SynthDef.TypesafeArgs.V i)
instance (GHC.TypeLits.KnownSymbol a, GHC.TypeLits.KnownSymbol b, GHC.TypeLits.KnownSymbol c, GHC.TypeLits.KnownSymbol d, GHC.TypeLits.KnownSymbol e, GHC.TypeLits.KnownSymbol f, GHC.TypeLits.KnownSymbol g, GHC.TypeLits.KnownSymbol h, GHC.TypeLits.KnownSymbol i, GHC.TypeLits.KnownSymbol j) => Vivid.SynthDef.TypesafeArgs.TagList (Vivid.SynthDef.TypesafeArgs.V a, Vivid.SynthDef.TypesafeArgs.V b, Vivid.SynthDef.TypesafeArgs.V c, Vivid.SynthDef.TypesafeArgs.V d, Vivid.SynthDef.TypesafeArgs.V e, Vivid.SynthDef.TypesafeArgs.V f, Vivid.SynthDef.TypesafeArgs.V g, Vivid.SynthDef.TypesafeArgs.V h, Vivid.SynthDef.TypesafeArgs.V i, Vivid.SynthDef.TypesafeArgs.V j)
instance (GHC.TypeLits.KnownSymbol a, GHC.TypeLits.KnownSymbol b, GHC.TypeLits.KnownSymbol c, GHC.TypeLits.KnownSymbol d, GHC.TypeLits.KnownSymbol e, GHC.TypeLits.KnownSymbol f, GHC.TypeLits.KnownSymbol g, GHC.TypeLits.KnownSymbol h, GHC.TypeLits.KnownSymbol i, GHC.TypeLits.KnownSymbol j, GHC.TypeLits.KnownSymbol k) => Vivid.SynthDef.TypesafeArgs.TagList (Vivid.SynthDef.TypesafeArgs.V a, Vivid.SynthDef.TypesafeArgs.V b, Vivid.SynthDef.TypesafeArgs.V c, Vivid.SynthDef.TypesafeArgs.V d, Vivid.SynthDef.TypesafeArgs.V e, Vivid.SynthDef.TypesafeArgs.V f, Vivid.SynthDef.TypesafeArgs.V g, Vivid.SynthDef.TypesafeArgs.V h, Vivid.SynthDef.TypesafeArgs.V i, Vivid.SynthDef.TypesafeArgs.V j, Vivid.SynthDef.TypesafeArgs.V k)
instance (GHC.TypeLits.KnownSymbol a, GHC.TypeLits.KnownSymbol b, GHC.TypeLits.KnownSymbol c, GHC.TypeLits.KnownSymbol d, GHC.TypeLits.KnownSymbol e, GHC.TypeLits.KnownSymbol f, GHC.TypeLits.KnownSymbol g, GHC.TypeLits.KnownSymbol h, GHC.TypeLits.KnownSymbol i, GHC.TypeLits.KnownSymbol j, GHC.TypeLits.KnownSymbol k, GHC.TypeLits.KnownSymbol l) => Vivid.SynthDef.TypesafeArgs.TagList (Vivid.SynthDef.TypesafeArgs.V a, Vivid.SynthDef.TypesafeArgs.V b, Vivid.SynthDef.TypesafeArgs.V c, Vivid.SynthDef.TypesafeArgs.V d, Vivid.SynthDef.TypesafeArgs.V e, Vivid.SynthDef.TypesafeArgs.V f, Vivid.SynthDef.TypesafeArgs.V g, Vivid.SynthDef.TypesafeArgs.V h, Vivid.SynthDef.TypesafeArgs.V i, Vivid.SynthDef.TypesafeArgs.V j, Vivid.SynthDef.TypesafeArgs.V k, Vivid.SynthDef.TypesafeArgs.V l)
instance (GHC.TypeLits.KnownSymbol a, GHC.TypeLits.KnownSymbol b, GHC.TypeLits.KnownSymbol c, GHC.TypeLits.KnownSymbol d, GHC.TypeLits.KnownSymbol e, GHC.TypeLits.KnownSymbol f, GHC.TypeLits.KnownSymbol g, GHC.TypeLits.KnownSymbol h, GHC.TypeLits.KnownSymbol i, GHC.TypeLits.KnownSymbol j, GHC.TypeLits.KnownSymbol k, GHC.TypeLits.KnownSymbol l, GHC.TypeLits.KnownSymbol m) => Vivid.SynthDef.TypesafeArgs.TagList (Vivid.SynthDef.TypesafeArgs.V a, Vivid.SynthDef.TypesafeArgs.V b, Vivid.SynthDef.TypesafeArgs.V c, Vivid.SynthDef.TypesafeArgs.V d, Vivid.SynthDef.TypesafeArgs.V e, Vivid.SynthDef.TypesafeArgs.V f, Vivid.SynthDef.TypesafeArgs.V g, Vivid.SynthDef.TypesafeArgs.V h, Vivid.SynthDef.TypesafeArgs.V i, Vivid.SynthDef.TypesafeArgs.V j, Vivid.SynthDef.TypesafeArgs.V k, Vivid.SynthDef.TypesafeArgs.V l, Vivid.SynthDef.TypesafeArgs.V m)
instance (GHC.TypeLits.KnownSymbol a, GHC.TypeLits.KnownSymbol b, GHC.TypeLits.KnownSymbol c, GHC.TypeLits.KnownSymbol d, GHC.TypeLits.KnownSymbol e, GHC.TypeLits.KnownSymbol f, GHC.TypeLits.KnownSymbol g, GHC.TypeLits.KnownSymbol h, GHC.TypeLits.KnownSymbol i, GHC.TypeLits.KnownSymbol j, GHC.TypeLits.KnownSymbol k, GHC.TypeLits.KnownSymbol l, GHC.TypeLits.KnownSymbol m, GHC.TypeLits.KnownSymbol n) => Vivid.SynthDef.TypesafeArgs.TagList (Vivid.SynthDef.TypesafeArgs.V a, Vivid.SynthDef.TypesafeArgs.V b, Vivid.SynthDef.TypesafeArgs.V c, Vivid.SynthDef.TypesafeArgs.V d, Vivid.SynthDef.TypesafeArgs.V e, Vivid.SynthDef.TypesafeArgs.V f, Vivid.SynthDef.TypesafeArgs.V g, Vivid.SynthDef.TypesafeArgs.V h, Vivid.SynthDef.TypesafeArgs.V i, Vivid.SynthDef.TypesafeArgs.V j, Vivid.SynthDef.TypesafeArgs.V k, Vivid.SynthDef.TypesafeArgs.V l, Vivid.SynthDef.TypesafeArgs.V m, Vivid.SynthDef.TypesafeArgs.V n)
instance (GHC.TypeLits.KnownSymbol a, GHC.TypeLits.KnownSymbol b, GHC.TypeLits.KnownSymbol c, GHC.TypeLits.KnownSymbol d, GHC.TypeLits.KnownSymbol e, GHC.TypeLits.KnownSymbol f, GHC.TypeLits.KnownSymbol g, GHC.TypeLits.KnownSymbol h, GHC.TypeLits.KnownSymbol i, GHC.TypeLits.KnownSymbol j, GHC.TypeLits.KnownSymbol k, GHC.TypeLits.KnownSymbol l, GHC.TypeLits.KnownSymbol m, GHC.TypeLits.KnownSymbol n, GHC.TypeLits.KnownSymbol o) => Vivid.SynthDef.TypesafeArgs.TagList (Vivid.SynthDef.TypesafeArgs.V a, Vivid.SynthDef.TypesafeArgs.V b, Vivid.SynthDef.TypesafeArgs.V c, Vivid.SynthDef.TypesafeArgs.V d, Vivid.SynthDef.TypesafeArgs.V e, Vivid.SynthDef.TypesafeArgs.V f, Vivid.SynthDef.TypesafeArgs.V g, Vivid.SynthDef.TypesafeArgs.V h, Vivid.SynthDef.TypesafeArgs.V i, Vivid.SynthDef.TypesafeArgs.V j, Vivid.SynthDef.TypesafeArgs.V k, Vivid.SynthDef.TypesafeArgs.V l, Vivid.SynthDef.TypesafeArgs.V m, Vivid.SynthDef.TypesafeArgs.V n, Vivid.SynthDef.TypesafeArgs.V o)
instance Vivid.SynthDef.TypesafeArgs.VarList (Vivid.SynthDef.TypesafeArgs.TypedVarList a)
instance Vivid.SynthDef.TypesafeArgs.VarList ()
instance GHC.TypeLits.KnownSymbol a => Vivid.SynthDef.TypesafeArgs.VarList (Vivid.SynthDef.TypesafeArgs.I a)
instance (GHC.TypeLits.KnownSymbol a, GHC.TypeLits.KnownSymbol b) => Vivid.SynthDef.TypesafeArgs.VarList (Vivid.SynthDef.TypesafeArgs.I a, Vivid.SynthDef.TypesafeArgs.I b)
instance (GHC.TypeLits.KnownSymbol a, GHC.TypeLits.KnownSymbol b, GHC.TypeLits.KnownSymbol c) => Vivid.SynthDef.TypesafeArgs.VarList (Vivid.SynthDef.TypesafeArgs.I a, Vivid.SynthDef.TypesafeArgs.I b, Vivid.SynthDef.TypesafeArgs.I c)
instance (GHC.TypeLits.KnownSymbol a, GHC.TypeLits.KnownSymbol b, GHC.TypeLits.KnownSymbol c, GHC.TypeLits.KnownSymbol d) => Vivid.SynthDef.TypesafeArgs.VarList (Vivid.SynthDef.TypesafeArgs.I a, Vivid.SynthDef.TypesafeArgs.I b, Vivid.SynthDef.TypesafeArgs.I c, Vivid.SynthDef.TypesafeArgs.I d)
instance (GHC.TypeLits.KnownSymbol a, GHC.TypeLits.KnownSymbol b, GHC.TypeLits.KnownSymbol c, GHC.TypeLits.KnownSymbol d, GHC.TypeLits.KnownSymbol e) => Vivid.SynthDef.TypesafeArgs.VarList (Vivid.SynthDef.TypesafeArgs.I a, Vivid.SynthDef.TypesafeArgs.I b, Vivid.SynthDef.TypesafeArgs.I c, Vivid.SynthDef.TypesafeArgs.I d, Vivid.SynthDef.TypesafeArgs.I e)
instance (GHC.TypeLits.KnownSymbol a, GHC.TypeLits.KnownSymbol b, GHC.TypeLits.KnownSymbol c, GHC.TypeLits.KnownSymbol d, GHC.TypeLits.KnownSymbol e, GHC.TypeLits.KnownSymbol f) => Vivid.SynthDef.TypesafeArgs.VarList (Vivid.SynthDef.TypesafeArgs.I a, Vivid.SynthDef.TypesafeArgs.I b, Vivid.SynthDef.TypesafeArgs.I c, Vivid.SynthDef.TypesafeArgs.I d, Vivid.SynthDef.TypesafeArgs.I e, Vivid.SynthDef.TypesafeArgs.I f)
instance (GHC.TypeLits.KnownSymbol a, GHC.TypeLits.KnownSymbol b, GHC.TypeLits.KnownSymbol c, GHC.TypeLits.KnownSymbol d, GHC.TypeLits.KnownSymbol e, GHC.TypeLits.KnownSymbol f, GHC.TypeLits.KnownSymbol g) => Vivid.SynthDef.TypesafeArgs.VarList (Vivid.SynthDef.TypesafeArgs.I a, Vivid.SynthDef.TypesafeArgs.I b, Vivid.SynthDef.TypesafeArgs.I c, Vivid.SynthDef.TypesafeArgs.I d, Vivid.SynthDef.TypesafeArgs.I e, Vivid.SynthDef.TypesafeArgs.I f, Vivid.SynthDef.TypesafeArgs.I g)
instance (GHC.TypeLits.KnownSymbol a, GHC.TypeLits.KnownSymbol b, GHC.TypeLits.KnownSymbol c, GHC.TypeLits.KnownSymbol d, GHC.TypeLits.KnownSymbol e, GHC.TypeLits.KnownSymbol f, GHC.TypeLits.KnownSymbol g, GHC.TypeLits.KnownSymbol h) => Vivid.SynthDef.TypesafeArgs.VarList (Vivid.SynthDef.TypesafeArgs.I a, Vivid.SynthDef.TypesafeArgs.I b, Vivid.SynthDef.TypesafeArgs.I c, Vivid.SynthDef.TypesafeArgs.I d, Vivid.SynthDef.TypesafeArgs.I e, Vivid.SynthDef.TypesafeArgs.I f, Vivid.SynthDef.TypesafeArgs.I g, Vivid.SynthDef.TypesafeArgs.I h)
instance (GHC.TypeLits.KnownSymbol a, GHC.TypeLits.KnownSymbol b, GHC.TypeLits.KnownSymbol c, GHC.TypeLits.KnownSymbol d, GHC.TypeLits.KnownSymbol e, GHC.TypeLits.KnownSymbol f, GHC.TypeLits.KnownSymbol g, GHC.TypeLits.KnownSymbol h, GHC.TypeLits.KnownSymbol i) => Vivid.SynthDef.TypesafeArgs.VarList (Vivid.SynthDef.TypesafeArgs.I a, Vivid.SynthDef.TypesafeArgs.I b, Vivid.SynthDef.TypesafeArgs.I c, Vivid.SynthDef.TypesafeArgs.I d, Vivid.SynthDef.TypesafeArgs.I e, Vivid.SynthDef.TypesafeArgs.I f, Vivid.SynthDef.TypesafeArgs.I g, Vivid.SynthDef.TypesafeArgs.I h, Vivid.SynthDef.TypesafeArgs.I i)
instance (GHC.TypeLits.KnownSymbol a, GHC.TypeLits.KnownSymbol b, GHC.TypeLits.KnownSymbol c, GHC.TypeLits.KnownSymbol d, GHC.TypeLits.KnownSymbol e, GHC.TypeLits.KnownSymbol f, GHC.TypeLits.KnownSymbol g, GHC.TypeLits.KnownSymbol h, GHC.TypeLits.KnownSymbol i, GHC.TypeLits.KnownSymbol j) => Vivid.SynthDef.TypesafeArgs.VarList (Vivid.SynthDef.TypesafeArgs.I a, Vivid.SynthDef.TypesafeArgs.I b, Vivid.SynthDef.TypesafeArgs.I c, Vivid.SynthDef.TypesafeArgs.I d, Vivid.SynthDef.TypesafeArgs.I e, Vivid.SynthDef.TypesafeArgs.I f, Vivid.SynthDef.TypesafeArgs.I g, Vivid.SynthDef.TypesafeArgs.I h, Vivid.SynthDef.TypesafeArgs.I i, Vivid.SynthDef.TypesafeArgs.I j)
instance (GHC.TypeLits.KnownSymbol a, GHC.TypeLits.KnownSymbol b, GHC.TypeLits.KnownSymbol c, GHC.TypeLits.KnownSymbol d, GHC.TypeLits.KnownSymbol e, GHC.TypeLits.KnownSymbol f, GHC.TypeLits.KnownSymbol g, GHC.TypeLits.KnownSymbol h, GHC.TypeLits.KnownSymbol i, GHC.TypeLits.KnownSymbol j, GHC.TypeLits.KnownSymbol k) => Vivid.SynthDef.TypesafeArgs.VarList (Vivid.SynthDef.TypesafeArgs.I a, Vivid.SynthDef.TypesafeArgs.I b, Vivid.SynthDef.TypesafeArgs.I c, Vivid.SynthDef.TypesafeArgs.I d, Vivid.SynthDef.TypesafeArgs.I e, Vivid.SynthDef.TypesafeArgs.I f, Vivid.SynthDef.TypesafeArgs.I g, Vivid.SynthDef.TypesafeArgs.I h, Vivid.SynthDef.TypesafeArgs.I i, Vivid.SynthDef.TypesafeArgs.I j, Vivid.SynthDef.TypesafeArgs.I k)
instance (GHC.TypeLits.KnownSymbol a, GHC.TypeLits.KnownSymbol b, GHC.TypeLits.KnownSymbol c, GHC.TypeLits.KnownSymbol d, GHC.TypeLits.KnownSymbol e, GHC.TypeLits.KnownSymbol f, GHC.TypeLits.KnownSymbol g, GHC.TypeLits.KnownSymbol h, GHC.TypeLits.KnownSymbol i, GHC.TypeLits.KnownSymbol j, GHC.TypeLits.KnownSymbol k, GHC.TypeLits.KnownSymbol l) => Vivid.SynthDef.TypesafeArgs.VarList (Vivid.SynthDef.TypesafeArgs.I a, Vivid.SynthDef.TypesafeArgs.I b, Vivid.SynthDef.TypesafeArgs.I c, Vivid.SynthDef.TypesafeArgs.I d, Vivid.SynthDef.TypesafeArgs.I e, Vivid.SynthDef.TypesafeArgs.I f, Vivid.SynthDef.TypesafeArgs.I g, Vivid.SynthDef.TypesafeArgs.I h, Vivid.SynthDef.TypesafeArgs.I i, Vivid.SynthDef.TypesafeArgs.I j, Vivid.SynthDef.TypesafeArgs.I k, Vivid.SynthDef.TypesafeArgs.I l)
instance (GHC.TypeLits.KnownSymbol a, GHC.TypeLits.KnownSymbol b, GHC.TypeLits.KnownSymbol c, GHC.TypeLits.KnownSymbol d, GHC.TypeLits.KnownSymbol e, GHC.TypeLits.KnownSymbol f, GHC.TypeLits.KnownSymbol g, GHC.TypeLits.KnownSymbol h, GHC.TypeLits.KnownSymbol i, GHC.TypeLits.KnownSymbol j, GHC.TypeLits.KnownSymbol k, GHC.TypeLits.KnownSymbol l, GHC.TypeLits.KnownSymbol m) => Vivid.SynthDef.TypesafeArgs.VarList (Vivid.SynthDef.TypesafeArgs.I a, Vivid.SynthDef.TypesafeArgs.I b, Vivid.SynthDef.TypesafeArgs.I c, Vivid.SynthDef.TypesafeArgs.I d, Vivid.SynthDef.TypesafeArgs.I e, Vivid.SynthDef.TypesafeArgs.I f, Vivid.SynthDef.TypesafeArgs.I g, Vivid.SynthDef.TypesafeArgs.I h, Vivid.SynthDef.TypesafeArgs.I i, Vivid.SynthDef.TypesafeArgs.I j, Vivid.SynthDef.TypesafeArgs.I k, Vivid.SynthDef.TypesafeArgs.I l, Vivid.SynthDef.TypesafeArgs.I m)
instance (GHC.TypeLits.KnownSymbol a, GHC.TypeLits.KnownSymbol b, GHC.TypeLits.KnownSymbol c, GHC.TypeLits.KnownSymbol d, GHC.TypeLits.KnownSymbol e, GHC.TypeLits.KnownSymbol f, GHC.TypeLits.KnownSymbol g, GHC.TypeLits.KnownSymbol h, GHC.TypeLits.KnownSymbol i, GHC.TypeLits.KnownSymbol j, GHC.TypeLits.KnownSymbol k, GHC.TypeLits.KnownSymbol l, GHC.TypeLits.KnownSymbol m, GHC.TypeLits.KnownSymbol n) => Vivid.SynthDef.TypesafeArgs.VarList (Vivid.SynthDef.TypesafeArgs.I a, Vivid.SynthDef.TypesafeArgs.I b, Vivid.SynthDef.TypesafeArgs.I c, Vivid.SynthDef.TypesafeArgs.I d, Vivid.SynthDef.TypesafeArgs.I e, Vivid.SynthDef.TypesafeArgs.I f, Vivid.SynthDef.TypesafeArgs.I g, Vivid.SynthDef.TypesafeArgs.I h, Vivid.SynthDef.TypesafeArgs.I i, Vivid.SynthDef.TypesafeArgs.I j, Vivid.SynthDef.TypesafeArgs.I k, Vivid.SynthDef.TypesafeArgs.I l, Vivid.SynthDef.TypesafeArgs.I m, Vivid.SynthDef.TypesafeArgs.I n)
instance (GHC.TypeLits.KnownSymbol a, GHC.TypeLits.KnownSymbol b, GHC.TypeLits.KnownSymbol c, GHC.TypeLits.KnownSymbol d, GHC.TypeLits.KnownSymbol e, GHC.TypeLits.KnownSymbol f, GHC.TypeLits.KnownSymbol g, GHC.TypeLits.KnownSymbol h, GHC.TypeLits.KnownSymbol i, GHC.TypeLits.KnownSymbol j, GHC.TypeLits.KnownSymbol k, GHC.TypeLits.KnownSymbol l, GHC.TypeLits.KnownSymbol m, GHC.TypeLits.KnownSymbol n, GHC.TypeLits.KnownSymbol o) => Vivid.SynthDef.TypesafeArgs.VarList (Vivid.SynthDef.TypesafeArgs.I a, Vivid.SynthDef.TypesafeArgs.I b, Vivid.SynthDef.TypesafeArgs.I c, Vivid.SynthDef.TypesafeArgs.I d, Vivid.SynthDef.TypesafeArgs.I e, Vivid.SynthDef.TypesafeArgs.I f, Vivid.SynthDef.TypesafeArgs.I g, Vivid.SynthDef.TypesafeArgs.I h, Vivid.SynthDef.TypesafeArgs.I i, Vivid.SynthDef.TypesafeArgs.I j, Vivid.SynthDef.TypesafeArgs.I k, Vivid.SynthDef.TypesafeArgs.I l, Vivid.SynthDef.TypesafeArgs.I m, Vivid.SynthDef.TypesafeArgs.I n, Vivid.SynthDef.TypesafeArgs.I o)
instance (GHC.TypeLits.KnownSymbol a, GHC.TypeLits.KnownSymbol b, GHC.TypeLits.KnownSymbol c, GHC.TypeLits.KnownSymbol d, GHC.TypeLits.KnownSymbol e, GHC.TypeLits.KnownSymbol f, GHC.TypeLits.KnownSymbol g, GHC.TypeLits.KnownSymbol h, GHC.TypeLits.KnownSymbol i, GHC.TypeLits.KnownSymbol j, GHC.TypeLits.KnownSymbol k, GHC.TypeLits.KnownSymbol l, GHC.TypeLits.KnownSymbol m, GHC.TypeLits.KnownSymbol n, GHC.TypeLits.KnownSymbol o, GHC.TypeLits.KnownSymbol p) => Vivid.SynthDef.TypesafeArgs.VarList (Vivid.SynthDef.TypesafeArgs.I a, Vivid.SynthDef.TypesafeArgs.I b, Vivid.SynthDef.TypesafeArgs.I c, Vivid.SynthDef.TypesafeArgs.I d, Vivid.SynthDef.TypesafeArgs.I e, Vivid.SynthDef.TypesafeArgs.I f, Vivid.SynthDef.TypesafeArgs.I g, Vivid.SynthDef.TypesafeArgs.I h, Vivid.SynthDef.TypesafeArgs.I i, Vivid.SynthDef.TypesafeArgs.I j, Vivid.SynthDef.TypesafeArgs.I k, Vivid.SynthDef.TypesafeArgs.I l, Vivid.SynthDef.TypesafeArgs.I m, Vivid.SynthDef.TypesafeArgs.I n, Vivid.SynthDef.TypesafeArgs.I o, Vivid.SynthDef.TypesafeArgs.I p)
instance (GHC.TypeLits.KnownSymbol a, GHC.TypeLits.KnownSymbol b, GHC.TypeLits.KnownSymbol c, GHC.TypeLits.KnownSymbol d, GHC.TypeLits.KnownSymbol e, GHC.TypeLits.KnownSymbol f, GHC.TypeLits.KnownSymbol g, GHC.TypeLits.KnownSymbol h, GHC.TypeLits.KnownSymbol i, GHC.TypeLits.KnownSymbol j, GHC.TypeLits.KnownSymbol k, GHC.TypeLits.KnownSymbol l, GHC.TypeLits.KnownSymbol m, GHC.TypeLits.KnownSymbol n, GHC.TypeLits.KnownSymbol o, GHC.TypeLits.KnownSymbol p, GHC.TypeLits.KnownSymbol q) => Vivid.SynthDef.TypesafeArgs.VarList (Vivid.SynthDef.TypesafeArgs.I a, Vivid.SynthDef.TypesafeArgs.I b, Vivid.SynthDef.TypesafeArgs.I c, Vivid.SynthDef.TypesafeArgs.I d, Vivid.SynthDef.TypesafeArgs.I e, Vivid.SynthDef.TypesafeArgs.I f, Vivid.SynthDef.TypesafeArgs.I g, Vivid.SynthDef.TypesafeArgs.I h, Vivid.SynthDef.TypesafeArgs.I i, Vivid.SynthDef.TypesafeArgs.I j, Vivid.SynthDef.TypesafeArgs.I k, Vivid.SynthDef.TypesafeArgs.I l, Vivid.SynthDef.TypesafeArgs.I m, Vivid.SynthDef.TypesafeArgs.I n, Vivid.SynthDef.TypesafeArgs.I o, Vivid.SynthDef.TypesafeArgs.I p, Vivid.SynthDef.TypesafeArgs.I q)
instance (GHC.TypeLits.KnownSymbol a, GHC.TypeLits.KnownSymbol b, GHC.TypeLits.KnownSymbol c, GHC.TypeLits.KnownSymbol d, GHC.TypeLits.KnownSymbol e, GHC.TypeLits.KnownSymbol f, GHC.TypeLits.KnownSymbol g, GHC.TypeLits.KnownSymbol h, GHC.TypeLits.KnownSymbol i, GHC.TypeLits.KnownSymbol j, GHC.TypeLits.KnownSymbol k, GHC.TypeLits.KnownSymbol l, GHC.TypeLits.KnownSymbol m, GHC.TypeLits.KnownSymbol n, GHC.TypeLits.KnownSymbol o, GHC.TypeLits.KnownSymbol p, GHC.TypeLits.KnownSymbol q, GHC.TypeLits.KnownSymbol r) => Vivid.SynthDef.TypesafeArgs.VarList (Vivid.SynthDef.TypesafeArgs.I a, Vivid.SynthDef.TypesafeArgs.I b, Vivid.SynthDef.TypesafeArgs.I c, Vivid.SynthDef.TypesafeArgs.I d, Vivid.SynthDef.TypesafeArgs.I e, Vivid.SynthDef.TypesafeArgs.I f, Vivid.SynthDef.TypesafeArgs.I g, Vivid.SynthDef.TypesafeArgs.I h, Vivid.SynthDef.TypesafeArgs.I i, Vivid.SynthDef.TypesafeArgs.I j, Vivid.SynthDef.TypesafeArgs.I k, Vivid.SynthDef.TypesafeArgs.I l, Vivid.SynthDef.TypesafeArgs.I m, Vivid.SynthDef.TypesafeArgs.I n, Vivid.SynthDef.TypesafeArgs.I o, Vivid.SynthDef.TypesafeArgs.I p, Vivid.SynthDef.TypesafeArgs.I q, Vivid.SynthDef.TypesafeArgs.I r)
instance (GHC.TypeLits.KnownSymbol a, GHC.TypeLits.KnownSymbol b, GHC.TypeLits.KnownSymbol c, GHC.TypeLits.KnownSymbol d, GHC.TypeLits.KnownSymbol e, GHC.TypeLits.KnownSymbol f, GHC.TypeLits.KnownSymbol g, GHC.TypeLits.KnownSymbol h, GHC.TypeLits.KnownSymbol i, GHC.TypeLits.KnownSymbol j, GHC.TypeLits.KnownSymbol k, GHC.TypeLits.KnownSymbol l, GHC.TypeLits.KnownSymbol m, GHC.TypeLits.KnownSymbol n, GHC.TypeLits.KnownSymbol o, GHC.TypeLits.KnownSymbol p, GHC.TypeLits.KnownSymbol q, GHC.TypeLits.KnownSymbol r, GHC.TypeLits.KnownSymbol s) => Vivid.SynthDef.TypesafeArgs.VarList (Vivid.SynthDef.TypesafeArgs.I a, Vivid.SynthDef.TypesafeArgs.I b, Vivid.SynthDef.TypesafeArgs.I c, Vivid.SynthDef.TypesafeArgs.I d, Vivid.SynthDef.TypesafeArgs.I e, Vivid.SynthDef.TypesafeArgs.I f, Vivid.SynthDef.TypesafeArgs.I g, Vivid.SynthDef.TypesafeArgs.I h, Vivid.SynthDef.TypesafeArgs.I i, Vivid.SynthDef.TypesafeArgs.I j, Vivid.SynthDef.TypesafeArgs.I k, Vivid.SynthDef.TypesafeArgs.I l, Vivid.SynthDef.TypesafeArgs.I m, Vivid.SynthDef.TypesafeArgs.I n, Vivid.SynthDef.TypesafeArgs.I o, Vivid.SynthDef.TypesafeArgs.I p, Vivid.SynthDef.TypesafeArgs.I q, Vivid.SynthDef.TypesafeArgs.I r, Vivid.SynthDef.TypesafeArgs.I s)
instance (GHC.TypeLits.KnownSymbol a, GHC.TypeLits.KnownSymbol b, GHC.TypeLits.KnownSymbol c, GHC.TypeLits.KnownSymbol d, GHC.TypeLits.KnownSymbol e, GHC.TypeLits.KnownSymbol f, GHC.TypeLits.KnownSymbol g, GHC.TypeLits.KnownSymbol h, GHC.TypeLits.KnownSymbol i, GHC.TypeLits.KnownSymbol j, GHC.TypeLits.KnownSymbol k, GHC.TypeLits.KnownSymbol l, GHC.TypeLits.KnownSymbol m, GHC.TypeLits.KnownSymbol n, GHC.TypeLits.KnownSymbol o, GHC.TypeLits.KnownSymbol p, GHC.TypeLits.KnownSymbol q, GHC.TypeLits.KnownSymbol r, GHC.TypeLits.KnownSymbol s, GHC.TypeLits.KnownSymbol t) => Vivid.SynthDef.TypesafeArgs.VarList (Vivid.SynthDef.TypesafeArgs.I a, Vivid.SynthDef.TypesafeArgs.I b, Vivid.SynthDef.TypesafeArgs.I c, Vivid.SynthDef.TypesafeArgs.I d, Vivid.SynthDef.TypesafeArgs.I e, Vivid.SynthDef.TypesafeArgs.I f, Vivid.SynthDef.TypesafeArgs.I g, Vivid.SynthDef.TypesafeArgs.I h, Vivid.SynthDef.TypesafeArgs.I i, Vivid.SynthDef.TypesafeArgs.I j, Vivid.SynthDef.TypesafeArgs.I k, Vivid.SynthDef.TypesafeArgs.I l, Vivid.SynthDef.TypesafeArgs.I m, Vivid.SynthDef.TypesafeArgs.I n, Vivid.SynthDef.TypesafeArgs.I o, Vivid.SynthDef.TypesafeArgs.I p, Vivid.SynthDef.TypesafeArgs.I q, Vivid.SynthDef.TypesafeArgs.I r, Vivid.SynthDef.TypesafeArgs.I s, Vivid.SynthDef.TypesafeArgs.I t)
instance (GHC.TypeLits.KnownSymbol a, GHC.TypeLits.KnownSymbol b, GHC.TypeLits.KnownSymbol c, GHC.TypeLits.KnownSymbol d, GHC.TypeLits.KnownSymbol e, GHC.TypeLits.KnownSymbol f, GHC.TypeLits.KnownSymbol g, GHC.TypeLits.KnownSymbol h, GHC.TypeLits.KnownSymbol i, GHC.TypeLits.KnownSymbol j, GHC.TypeLits.KnownSymbol k, GHC.TypeLits.KnownSymbol l, GHC.TypeLits.KnownSymbol m, GHC.TypeLits.KnownSymbol n, GHC.TypeLits.KnownSymbol o, GHC.TypeLits.KnownSymbol p, GHC.TypeLits.KnownSymbol q, GHC.TypeLits.KnownSymbol r, GHC.TypeLits.KnownSymbol s, GHC.TypeLits.KnownSymbol t, GHC.TypeLits.KnownSymbol u) => Vivid.SynthDef.TypesafeArgs.VarList (Vivid.SynthDef.TypesafeArgs.I a, Vivid.SynthDef.TypesafeArgs.I b, Vivid.SynthDef.TypesafeArgs.I c, Vivid.SynthDef.TypesafeArgs.I d, Vivid.SynthDef.TypesafeArgs.I e, Vivid.SynthDef.TypesafeArgs.I f, Vivid.SynthDef.TypesafeArgs.I g, Vivid.SynthDef.TypesafeArgs.I h, Vivid.SynthDef.TypesafeArgs.I i, Vivid.SynthDef.TypesafeArgs.I j, Vivid.SynthDef.TypesafeArgs.I k, Vivid.SynthDef.TypesafeArgs.I l, Vivid.SynthDef.TypesafeArgs.I m, Vivid.SynthDef.TypesafeArgs.I n, Vivid.SynthDef.TypesafeArgs.I o, Vivid.SynthDef.TypesafeArgs.I p, Vivid.SynthDef.TypesafeArgs.I q, Vivid.SynthDef.TypesafeArgs.I r, Vivid.SynthDef.TypesafeArgs.I s, Vivid.SynthDef.TypesafeArgs.I t, Vivid.SynthDef.TypesafeArgs.I u)
instance (GHC.TypeLits.KnownSymbol a, GHC.TypeLits.KnownSymbol b, GHC.TypeLits.KnownSymbol c, GHC.TypeLits.KnownSymbol d, GHC.TypeLits.KnownSymbol e, GHC.TypeLits.KnownSymbol f, GHC.TypeLits.KnownSymbol g, GHC.TypeLits.KnownSymbol h, GHC.TypeLits.KnownSymbol i, GHC.TypeLits.KnownSymbol j, GHC.TypeLits.KnownSymbol k, GHC.TypeLits.KnownSymbol l, GHC.TypeLits.KnownSymbol m, GHC.TypeLits.KnownSymbol n, GHC.TypeLits.KnownSymbol o, GHC.TypeLits.KnownSymbol p, GHC.TypeLits.KnownSymbol q, GHC.TypeLits.KnownSymbol r, GHC.TypeLits.KnownSymbol s, GHC.TypeLits.KnownSymbol t, GHC.TypeLits.KnownSymbol u, GHC.TypeLits.KnownSymbol v) => Vivid.SynthDef.TypesafeArgs.VarList (Vivid.SynthDef.TypesafeArgs.I a, Vivid.SynthDef.TypesafeArgs.I b, Vivid.SynthDef.TypesafeArgs.I c, Vivid.SynthDef.TypesafeArgs.I d, Vivid.SynthDef.TypesafeArgs.I e, Vivid.SynthDef.TypesafeArgs.I f, Vivid.SynthDef.TypesafeArgs.I g, Vivid.SynthDef.TypesafeArgs.I h, Vivid.SynthDef.TypesafeArgs.I i, Vivid.SynthDef.TypesafeArgs.I j, Vivid.SynthDef.TypesafeArgs.I k, Vivid.SynthDef.TypesafeArgs.I l, Vivid.SynthDef.TypesafeArgs.I m, Vivid.SynthDef.TypesafeArgs.I n, Vivid.SynthDef.TypesafeArgs.I o, Vivid.SynthDef.TypesafeArgs.I p, Vivid.SynthDef.TypesafeArgs.I q, Vivid.SynthDef.TypesafeArgs.I r, Vivid.SynthDef.TypesafeArgs.I s, Vivid.SynthDef.TypesafeArgs.I t, Vivid.SynthDef.TypesafeArgs.I u, Vivid.SynthDef.TypesafeArgs.I v)
instance (GHC.TypeLits.KnownSymbol a, GHC.TypeLits.KnownSymbol b, GHC.TypeLits.KnownSymbol c, GHC.TypeLits.KnownSymbol d, GHC.TypeLits.KnownSymbol e, GHC.TypeLits.KnownSymbol f, GHC.TypeLits.KnownSymbol g, GHC.TypeLits.KnownSymbol h, GHC.TypeLits.KnownSymbol i, GHC.TypeLits.KnownSymbol j, GHC.TypeLits.KnownSymbol k, GHC.TypeLits.KnownSymbol l, GHC.TypeLits.KnownSymbol m, GHC.TypeLits.KnownSymbol n, GHC.TypeLits.KnownSymbol o, GHC.TypeLits.KnownSymbol p, GHC.TypeLits.KnownSymbol q, GHC.TypeLits.KnownSymbol r, GHC.TypeLits.KnownSymbol s, GHC.TypeLits.KnownSymbol t, GHC.TypeLits.KnownSymbol u, GHC.TypeLits.KnownSymbol v, GHC.TypeLits.KnownSymbol w) => Vivid.SynthDef.TypesafeArgs.VarList (Vivid.SynthDef.TypesafeArgs.I a, Vivid.SynthDef.TypesafeArgs.I b, Vivid.SynthDef.TypesafeArgs.I c, Vivid.SynthDef.TypesafeArgs.I d, Vivid.SynthDef.TypesafeArgs.I e, Vivid.SynthDef.TypesafeArgs.I f, Vivid.SynthDef.TypesafeArgs.I g, Vivid.SynthDef.TypesafeArgs.I h, Vivid.SynthDef.TypesafeArgs.I i, Vivid.SynthDef.TypesafeArgs.I j, Vivid.SynthDef.TypesafeArgs.I k, Vivid.SynthDef.TypesafeArgs.I l, Vivid.SynthDef.TypesafeArgs.I m, Vivid.SynthDef.TypesafeArgs.I n, Vivid.SynthDef.TypesafeArgs.I o, Vivid.SynthDef.TypesafeArgs.I p, Vivid.SynthDef.TypesafeArgs.I q, Vivid.SynthDef.TypesafeArgs.I r, Vivid.SynthDef.TypesafeArgs.I s, Vivid.SynthDef.TypesafeArgs.I t, Vivid.SynthDef.TypesafeArgs.I u, Vivid.SynthDef.TypesafeArgs.I v, Vivid.SynthDef.TypesafeArgs.I w)
instance (GHC.TypeLits.KnownSymbol a, GHC.TypeLits.KnownSymbol b, GHC.TypeLits.KnownSymbol c, GHC.TypeLits.KnownSymbol d, GHC.TypeLits.KnownSymbol e, GHC.TypeLits.KnownSymbol f, GHC.TypeLits.KnownSymbol g, GHC.TypeLits.KnownSymbol h, GHC.TypeLits.KnownSymbol i, GHC.TypeLits.KnownSymbol j, GHC.TypeLits.KnownSymbol k, GHC.TypeLits.KnownSymbol l, GHC.TypeLits.KnownSymbol m, GHC.TypeLits.KnownSymbol n, GHC.TypeLits.KnownSymbol o, GHC.TypeLits.KnownSymbol p, GHC.TypeLits.KnownSymbol q, GHC.TypeLits.KnownSymbol r, GHC.TypeLits.KnownSymbol s, GHC.TypeLits.KnownSymbol t, GHC.TypeLits.KnownSymbol u, GHC.TypeLits.KnownSymbol v, GHC.TypeLits.KnownSymbol w, GHC.TypeLits.KnownSymbol x) => Vivid.SynthDef.TypesafeArgs.VarList (Vivid.SynthDef.TypesafeArgs.I a, Vivid.SynthDef.TypesafeArgs.I b, Vivid.SynthDef.TypesafeArgs.I c, Vivid.SynthDef.TypesafeArgs.I d, Vivid.SynthDef.TypesafeArgs.I e, Vivid.SynthDef.TypesafeArgs.I f, Vivid.SynthDef.TypesafeArgs.I g, Vivid.SynthDef.TypesafeArgs.I h, Vivid.SynthDef.TypesafeArgs.I i, Vivid.SynthDef.TypesafeArgs.I j, Vivid.SynthDef.TypesafeArgs.I k, Vivid.SynthDef.TypesafeArgs.I l, Vivid.SynthDef.TypesafeArgs.I m, Vivid.SynthDef.TypesafeArgs.I n, Vivid.SynthDef.TypesafeArgs.I o, Vivid.SynthDef.TypesafeArgs.I p, Vivid.SynthDef.TypesafeArgs.I q, Vivid.SynthDef.TypesafeArgs.I r, Vivid.SynthDef.TypesafeArgs.I s, Vivid.SynthDef.TypesafeArgs.I t, Vivid.SynthDef.TypesafeArgs.I u, Vivid.SynthDef.TypesafeArgs.I v, Vivid.SynthDef.TypesafeArgs.I w, Vivid.SynthDef.TypesafeArgs.I x)
instance (GHC.TypeLits.KnownSymbol a, GHC.TypeLits.KnownSymbol b, GHC.TypeLits.KnownSymbol c, GHC.TypeLits.KnownSymbol d, GHC.TypeLits.KnownSymbol e, GHC.TypeLits.KnownSymbol f, GHC.TypeLits.KnownSymbol g, GHC.TypeLits.KnownSymbol h, GHC.TypeLits.KnownSymbol i, GHC.TypeLits.KnownSymbol j, GHC.TypeLits.KnownSymbol k, GHC.TypeLits.KnownSymbol l, GHC.TypeLits.KnownSymbol m, GHC.TypeLits.KnownSymbol n, GHC.TypeLits.KnownSymbol o, GHC.TypeLits.KnownSymbol p, GHC.TypeLits.KnownSymbol q, GHC.TypeLits.KnownSymbol r, GHC.TypeLits.KnownSymbol s, GHC.TypeLits.KnownSymbol t, GHC.TypeLits.KnownSymbol u, GHC.TypeLits.KnownSymbol v, GHC.TypeLits.KnownSymbol w, GHC.TypeLits.KnownSymbol x, GHC.TypeLits.KnownSymbol y) => Vivid.SynthDef.TypesafeArgs.VarList (Vivid.SynthDef.TypesafeArgs.I a, Vivid.SynthDef.TypesafeArgs.I b, Vivid.SynthDef.TypesafeArgs.I c, Vivid.SynthDef.TypesafeArgs.I d, Vivid.SynthDef.TypesafeArgs.I e, Vivid.SynthDef.TypesafeArgs.I f, Vivid.SynthDef.TypesafeArgs.I g, Vivid.SynthDef.TypesafeArgs.I h, Vivid.SynthDef.TypesafeArgs.I i, Vivid.SynthDef.TypesafeArgs.I j, Vivid.SynthDef.TypesafeArgs.I k, Vivid.SynthDef.TypesafeArgs.I l, Vivid.SynthDef.TypesafeArgs.I m, Vivid.SynthDef.TypesafeArgs.I n, Vivid.SynthDef.TypesafeArgs.I o, Vivid.SynthDef.TypesafeArgs.I p, Vivid.SynthDef.TypesafeArgs.I q, Vivid.SynthDef.TypesafeArgs.I r, Vivid.SynthDef.TypesafeArgs.I s, Vivid.SynthDef.TypesafeArgs.I t, Vivid.SynthDef.TypesafeArgs.I u, Vivid.SynthDef.TypesafeArgs.I v, Vivid.SynthDef.TypesafeArgs.I w, Vivid.SynthDef.TypesafeArgs.I x, Vivid.SynthDef.TypesafeArgs.I y)
instance (GHC.TypeLits.KnownSymbol a, GHC.TypeLits.KnownSymbol b, GHC.TypeLits.KnownSymbol c, GHC.TypeLits.KnownSymbol d, GHC.TypeLits.KnownSymbol e, GHC.TypeLits.KnownSymbol f, GHC.TypeLits.KnownSymbol g, GHC.TypeLits.KnownSymbol h, GHC.TypeLits.KnownSymbol i, GHC.TypeLits.KnownSymbol j, GHC.TypeLits.KnownSymbol k, GHC.TypeLits.KnownSymbol l, GHC.TypeLits.KnownSymbol m, GHC.TypeLits.KnownSymbol n, GHC.TypeLits.KnownSymbol o, GHC.TypeLits.KnownSymbol p, GHC.TypeLits.KnownSymbol q, GHC.TypeLits.KnownSymbol r, GHC.TypeLits.KnownSymbol s, GHC.TypeLits.KnownSymbol t, GHC.TypeLits.KnownSymbol u, GHC.TypeLits.KnownSymbol v, GHC.TypeLits.KnownSymbol w, GHC.TypeLits.KnownSymbol x, GHC.TypeLits.KnownSymbol y, GHC.TypeLits.KnownSymbol z) => Vivid.SynthDef.TypesafeArgs.VarList (Vivid.SynthDef.TypesafeArgs.I a, Vivid.SynthDef.TypesafeArgs.I b, Vivid.SynthDef.TypesafeArgs.I c, Vivid.SynthDef.TypesafeArgs.I d, Vivid.SynthDef.TypesafeArgs.I e, Vivid.SynthDef.TypesafeArgs.I f, Vivid.SynthDef.TypesafeArgs.I g, Vivid.SynthDef.TypesafeArgs.I h, Vivid.SynthDef.TypesafeArgs.I i, Vivid.SynthDef.TypesafeArgs.I j, Vivid.SynthDef.TypesafeArgs.I k, Vivid.SynthDef.TypesafeArgs.I l, Vivid.SynthDef.TypesafeArgs.I m, Vivid.SynthDef.TypesafeArgs.I n, Vivid.SynthDef.TypesafeArgs.I o, Vivid.SynthDef.TypesafeArgs.I p, Vivid.SynthDef.TypesafeArgs.I q, Vivid.SynthDef.TypesafeArgs.I r, Vivid.SynthDef.TypesafeArgs.I s, Vivid.SynthDef.TypesafeArgs.I t, Vivid.SynthDef.TypesafeArgs.I u, Vivid.SynthDef.TypesafeArgs.I v, Vivid.SynthDef.TypesafeArgs.I w, Vivid.SynthDef.TypesafeArgs.I x, Vivid.SynthDef.TypesafeArgs.I y, Vivid.SynthDef.TypesafeArgs.I z)
instance GHC.TypeLits.KnownSymbol s => GHC.Show.Show (Vivid.SynthDef.TypesafeArgs.I s)
instance GHC.TypeLits.KnownSymbol s => GHC.Num.Num (Vivid.SynthDef.TypesafeArgs.I s)
instance GHC.TypeLits.KnownSymbol s => GHC.Real.Fractional (Vivid.SynthDef.TypesafeArgs.I s)
instance GHC.TypeLits.KnownSymbol s => GHC.Enum.Enum (Vivid.SynthDef.TypesafeArgs.I s)
instance GHC.TypeLits.KnownSymbol s => GHC.Real.Real (Vivid.SynthDef.TypesafeArgs.I s)
instance GHC.TypeLits.KnownSymbol s => GHC.Real.RealFrac (Vivid.SynthDef.TypesafeArgs.I s)
instance GHC.TypeLits.KnownSymbol s => GHC.Float.Floating (Vivid.SynthDef.TypesafeArgs.I s)
instance GHC.TypeLits.KnownSymbol s => GHC.Float.RealFloat (Vivid.SynthDef.TypesafeArgs.I s)
instance GHC.TypeLits.KnownSymbol s => System.Random.Random (Vivid.SynthDef.TypesafeArgs.I s)
instance Vivid.SynthDef.TypesafeArgs.GetSymbolVals (Vivid.SynthDef.TypesafeArgs.VarSet xs) => GHC.Show.Show (Vivid.SynthDef.TypesafeArgs.VarSet xs)
instance forall k (proxy :: [k] -> *). Vivid.SynthDef.TypesafeArgs.GetSymbolVals (proxy '[])
instance (GHC.TypeLits.KnownSymbol x, Vivid.SynthDef.TypesafeArgs.GetSymbolVals (Data.Proxy.Proxy xs)) => Vivid.SynthDef.TypesafeArgs.GetSymbolVals (proxy (x : xs))
instance GHC.Show.Show (Vivid.SynthDef.TypesafeArgs.Variable a)


-- | Internal. Just use <a>Vivid.SynthDef</a>
module Vivid.SynthDef.Types
data Signal
Constant :: Float -> Signal
Param :: ByteString -> Signal
UGOut :: Int -> Int32 -> Signal

-- | Internal representation of Synth Definitions. Usually, use <a>sd</a>
--   instead of making these by hand.
--   
--   This representation (especially <a>_sdUGens</a>) might change in the
--   future.
data SynthDef (args :: [Symbol])
SynthDef :: SDName -> [(ByteString, Float)] -> Map Int UGen -> SynthDef
[_sdName] :: SynthDef -> SDName
[_sdParams] :: SynthDef -> [(ByteString, Float)]
[_sdUGens] :: SynthDef -> Map Int UGen
data SDName
SDName_Named :: ByteString -> SDName
SDName_Hash :: SDName

-- | State monad to construct SynthDefs
--   
--   The SynthDef is an under-construction synth definition The [Int] is
--   the id supply. Its type definitely could change in the future
type SDBody' (args :: [Symbol]) = State ([Int], SynthDef args, VarSet args)

-- | Given
--   
--   <pre>
--   good0 :: SDBody '["2"] ()
--   good0 = return ()
--   </pre>
--   
--   <pre>
--   good1 :: SDBody '["3","1","3","1"] ()
--   good1 = return ()
--   </pre>
--   
--   <pre>
--   bad0 :: SDBody '["bwahaha"] ()
--   bad0 = return ()
--   </pre>
--   
--   <pre>
--   outer :: SDBody '[ "1", "2", "3"]()
--   outer = do
--      zoomSDBody good0 -- works
--      zoomSDBody good1 -- works
--      -- zoomSDBody bad0 -- doesn't work - great!
--   </pre>
zoomSDBody :: (Subset inner outer) => SDBody' inner a -> SDBody' outer a
zoomSynthDef :: (Subset a b) => SynthDef a -> SynthDef b

-- | Representation of Unit Generators. You usually won't be creating these
--   by hand, but instead using things from the library in <a>UGens</a>
data UGen
UGen :: UGenName -> CalculationRate -> [Signal] -> Int -> UGen
[_ugenName] :: UGen -> UGenName
[_ugenCalculationRate] :: UGen -> CalculationRate
[_ugenIns] :: UGen -> [Signal]
[_ugenNumOuts] :: UGen -> Int
data UGenName
UGName_S :: ByteString -> UGenName
UGName_U :: UnaryOp -> UGenName
UGName_B :: BinaryOp -> UGenName
instance GHC.Show.Show (Vivid.SynthDef.Types.SynthDef args)
instance GHC.Classes.Eq Vivid.SynthDef.Types.UGen
instance GHC.Show.Show Vivid.SynthDef.Types.UGen
instance GHC.Classes.Eq Vivid.SynthDef.Types.UGenName
instance GHC.Show.Show Vivid.SynthDef.Types.UGenName
instance GHC.Classes.Ord Vivid.SynthDef.Types.SDName
instance GHC.Read.Read Vivid.SynthDef.Types.SDName
instance GHC.Classes.Eq Vivid.SynthDef.Types.SDName
instance GHC.Show.Show Vivid.SynthDef.Types.SDName
instance GHC.Classes.Eq Vivid.SynthDef.Types.Signal
instance GHC.Show.Show Vivid.SynthDef.Types.Signal

module Vivid.SynthDef.ToSig
class ToSig s (args :: [Symbol])
toSig :: ToSig s args => s -> SDBody' args Signal
instance Vivid.SynthDef.ToSig.ToSig Vivid.SynthDef.Types.Signal args
instance (GHC.TypeLits.KnownSymbol a, Vivid.SynthDef.TypesafeArgs.Subset '[a] args) => Vivid.SynthDef.ToSig.ToSig (Vivid.SynthDef.TypesafeArgs.Variable a) args
instance Vivid.SynthDef.ToSig.ToSig GHC.Integer.Type.Integer args
instance Vivid.SynthDef.ToSig.ToSig GHC.Types.Double args
instance Vivid.SynthDef.ToSig.ToSig GHC.Types.Float args
instance Vivid.SynthDef.ToSig.ToSig GHC.Types.Int args
instance Vivid.SynthDef.ToSig.ToSig Vivid.SC.Server.Types.BufferId args
instance a ~ args => Vivid.SynthDef.ToSig.ToSig (Vivid.SynthDef.Types.SDBody' a Vivid.SynthDef.Types.Signal) args

module Vivid.SynthDef.FromUA
class FromUA (a :: *) where {
    type family UAsArgs a :: [Symbol];
    type family SDBodyArgs a :: [Symbol];
}
fromUA :: FromUA a => a -> SDBody a [(String, Signal)]
fromUAWithDefaults :: (FromUA a, FromUA b, SDBodyArgs a ~ SDBodyArgs b) => DefaultArgs a -> OverwritingArgs b -> SDBody a [(String, Signal)]
uaArgVal :: (FromUA as, Elem aToLookUp (UAsArgs as), KnownSymbol aToLookUp) => as -> proxy aToLookUp -> SDBody as Signal
uaArgValWDefault :: (FromUA as, KnownSymbol aToLookUp, ToSig defaultVal (SDBodyArgs as)) => defaultVal -> as -> proxy aToLookUp -> SDBody as Signal
newtype DefaultArgs a
DefaultArgs :: a -> DefaultArgs a
newtype OverwritingArgs a
OverwritingArgs :: a -> OverwritingArgs a

-- | "UGen Arg"
data UA (name :: Symbol) (args :: [Symbol])
UA :: (SDBody' args Signal) -> UA
data NoDefaults (args :: [Symbol])
NoDefaults :: NoDefaults
none :: NoDefaults args
type SDBody a = SDBody' (SDBodyArgs a)
instance GHC.Read.Read (Vivid.SynthDef.FromUA.NoDefaults args)
instance GHC.Classes.Ord (Vivid.SynthDef.FromUA.NoDefaults args)
instance GHC.Classes.Eq (Vivid.SynthDef.FromUA.NoDefaults args)
instance GHC.Show.Show (Vivid.SynthDef.FromUA.NoDefaults args)
instance (Vivid.SynthDef.FromUA.AllEqual '[as0, as1, as2, as3, as4], Vivid.SynthDef.FromUA.AllKnownSymbols '[a, b, c]) => Vivid.SynthDef.FromUA.FromUA (Vivid.SynthDef.FromUA.UA a as0, Vivid.SynthDef.FromUA.UA b as1, Vivid.SynthDef.FromUA.UA c as2, Vivid.SynthDef.FromUA.UA d as3)
instance (Vivid.SynthDef.FromUA.AllEqual '[as0, as1, as2, as3, as4], Vivid.SynthDef.FromUA.AllKnownSymbols '[a, b, c, d]) => Vivid.SynthDef.FromUA.FromUA (Vivid.SynthDef.FromUA.UA a as0, Vivid.SynthDef.FromUA.UA b as1, Vivid.SynthDef.FromUA.UA c as2, Vivid.SynthDef.FromUA.UA d as3, Vivid.SynthDef.FromUA.UA e as4)
instance (Vivid.SynthDef.FromUA.AllEqual '[as0, as1, as2, as3, as4, as5], Vivid.SynthDef.FromUA.AllKnownSymbols '[a, b, c, d, e, f]) => Vivid.SynthDef.FromUA.FromUA (Vivid.SynthDef.FromUA.UA a as0, Vivid.SynthDef.FromUA.UA b as1, Vivid.SynthDef.FromUA.UA c as2, Vivid.SynthDef.FromUA.UA d as3, Vivid.SynthDef.FromUA.UA e as4, Vivid.SynthDef.FromUA.UA f as5)
instance (Vivid.SynthDef.FromUA.AllEqual '[as0, as1, as2, as3, as4, as5, as6], Vivid.SynthDef.FromUA.AllKnownSymbols '[a, b, c, d, e, f, g]) => Vivid.SynthDef.FromUA.FromUA (Vivid.SynthDef.FromUA.UA a as0, Vivid.SynthDef.FromUA.UA b as1, Vivid.SynthDef.FromUA.UA c as2, Vivid.SynthDef.FromUA.UA d as3, Vivid.SynthDef.FromUA.UA e as4, Vivid.SynthDef.FromUA.UA f as5, Vivid.SynthDef.FromUA.UA g as6)
instance (Vivid.SynthDef.FromUA.AllEqual '[as0, as1, as2, as3, as4, as5, as6, as7], Vivid.SynthDef.FromUA.AllKnownSymbols '[a, b, c, d, e, f, g, h]) => Vivid.SynthDef.FromUA.FromUA (Vivid.SynthDef.FromUA.UA a as0, Vivid.SynthDef.FromUA.UA b as1, Vivid.SynthDef.FromUA.UA c as2, Vivid.SynthDef.FromUA.UA d as3, Vivid.SynthDef.FromUA.UA e as4, Vivid.SynthDef.FromUA.UA f as5, Vivid.SynthDef.FromUA.UA g as6, Vivid.SynthDef.FromUA.UA h as7)
instance (Vivid.SynthDef.FromUA.AllEqual '[as0, as1, as2, as3, as4, as5, as6, as7, as8], Vivid.SynthDef.FromUA.AllKnownSymbols '[a, b, c, d, e, f, g, h, i]) => Vivid.SynthDef.FromUA.FromUA (Vivid.SynthDef.FromUA.UA a as0, Vivid.SynthDef.FromUA.UA b as1, Vivid.SynthDef.FromUA.UA c as2, Vivid.SynthDef.FromUA.UA d as3, Vivid.SynthDef.FromUA.UA e as4, Vivid.SynthDef.FromUA.UA f as5, Vivid.SynthDef.FromUA.UA g as6, Vivid.SynthDef.FromUA.UA h as7, Vivid.SynthDef.FromUA.UA i as8)
instance (Vivid.SynthDef.FromUA.AllEqual '[as0, as1, as2, as3, as4, as5, as6, as7, as8, as9], Vivid.SynthDef.FromUA.AllKnownSymbols '[a, b, c, d, e, f, g, h, i, j]) => Vivid.SynthDef.FromUA.FromUA (Vivid.SynthDef.FromUA.UA a as0, Vivid.SynthDef.FromUA.UA b as1, Vivid.SynthDef.FromUA.UA c as2, Vivid.SynthDef.FromUA.UA d as3, Vivid.SynthDef.FromUA.UA e as4, Vivid.SynthDef.FromUA.UA f as5, Vivid.SynthDef.FromUA.UA g as6, Vivid.SynthDef.FromUA.UA h as7, Vivid.SynthDef.FromUA.UA i as8, Vivid.SynthDef.FromUA.UA j as9)
instance (Vivid.SynthDef.FromUA.AllEqual '[as0, as1, as2, as3, as4, as5, as6, as7, as8, as9, as10], Vivid.SynthDef.FromUA.AllKnownSymbols '[a, b, c, d, e, f, g, h, i, j, k]) => Vivid.SynthDef.FromUA.FromUA (Vivid.SynthDef.FromUA.UA a as0, Vivid.SynthDef.FromUA.UA b as1, Vivid.SynthDef.FromUA.UA c as2, Vivid.SynthDef.FromUA.UA d as3, Vivid.SynthDef.FromUA.UA e as4, Vivid.SynthDef.FromUA.UA f as5, Vivid.SynthDef.FromUA.UA g as6, Vivid.SynthDef.FromUA.UA h as7, Vivid.SynthDef.FromUA.UA i as8, Vivid.SynthDef.FromUA.UA j as9, Vivid.SynthDef.FromUA.UA k as10)
instance (Vivid.SynthDef.FromUA.AllEqual '[as0, as1, as2, as3, as4, as5, as6, as7, as8, as9, as10, as11], Vivid.SynthDef.FromUA.AllKnownSymbols '[a, b, c, d, e, f, g, h, i, j, k, l]) => Vivid.SynthDef.FromUA.FromUA (Vivid.SynthDef.FromUA.UA a as0, Vivid.SynthDef.FromUA.UA b as1, Vivid.SynthDef.FromUA.UA c as2, Vivid.SynthDef.FromUA.UA d as3, Vivid.SynthDef.FromUA.UA e as4, Vivid.SynthDef.FromUA.UA f as5, Vivid.SynthDef.FromUA.UA g as6, Vivid.SynthDef.FromUA.UA h as7, Vivid.SynthDef.FromUA.UA i as8, Vivid.SynthDef.FromUA.UA j as9, Vivid.SynthDef.FromUA.UA k as10, Vivid.SynthDef.FromUA.UA l as11)
instance (Vivid.SynthDef.FromUA.AllEqual '[as0, as1, as2, as3, as4, as5, as6, as7, as8, as9, as10, as11, as12], Vivid.SynthDef.FromUA.AllKnownSymbols '[a, b, c, d, e, f, g, h, i, j, k, l, m]) => Vivid.SynthDef.FromUA.FromUA (Vivid.SynthDef.FromUA.UA a as0, Vivid.SynthDef.FromUA.UA b as1, Vivid.SynthDef.FromUA.UA c as2, Vivid.SynthDef.FromUA.UA d as3, Vivid.SynthDef.FromUA.UA e as4, Vivid.SynthDef.FromUA.UA f as5, Vivid.SynthDef.FromUA.UA g as6, Vivid.SynthDef.FromUA.UA h as7, Vivid.SynthDef.FromUA.UA i as8, Vivid.SynthDef.FromUA.UA j as9, Vivid.SynthDef.FromUA.UA k as10, Vivid.SynthDef.FromUA.UA l as11, Vivid.SynthDef.FromUA.UA m as12)
instance (Vivid.SynthDef.FromUA.AllEqual '[as0, as1, as2, as3, as4, as5, as6, as7, as8, as9, as10, as11, as12, as13], Vivid.SynthDef.FromUA.AllKnownSymbols '[a, b, c, d, e, f, g, h, i, j, k, l, m, n]) => Vivid.SynthDef.FromUA.FromUA (Vivid.SynthDef.FromUA.UA a as0, Vivid.SynthDef.FromUA.UA b as1, Vivid.SynthDef.FromUA.UA c as2, Vivid.SynthDef.FromUA.UA d as3, Vivid.SynthDef.FromUA.UA e as4, Vivid.SynthDef.FromUA.UA f as5, Vivid.SynthDef.FromUA.UA g as6, Vivid.SynthDef.FromUA.UA h as7, Vivid.SynthDef.FromUA.UA i as8, Vivid.SynthDef.FromUA.UA j as9, Vivid.SynthDef.FromUA.UA k as10, Vivid.SynthDef.FromUA.UA l as11, Vivid.SynthDef.FromUA.UA m as12, Vivid.SynthDef.FromUA.UA n as13)
instance (Vivid.SynthDef.FromUA.AllEqual '[as0, as1, as2, as3, as4, as5, as6, as7, as8, as9, as10, as11, as12, as13, as14], Vivid.SynthDef.FromUA.AllKnownSymbols '[a, b, c, d, e, f, g, h, i, j, k, l, m, n, o]) => Vivid.SynthDef.FromUA.FromUA (Vivid.SynthDef.FromUA.UA a as0, Vivid.SynthDef.FromUA.UA b as1, Vivid.SynthDef.FromUA.UA c as2, Vivid.SynthDef.FromUA.UA d as3, Vivid.SynthDef.FromUA.UA e as4, Vivid.SynthDef.FromUA.UA f as5, Vivid.SynthDef.FromUA.UA g as6, Vivid.SynthDef.FromUA.UA h as7, Vivid.SynthDef.FromUA.UA i as8, Vivid.SynthDef.FromUA.UA j as9, Vivid.SynthDef.FromUA.UA k as10, Vivid.SynthDef.FromUA.UA l as11, Vivid.SynthDef.FromUA.UA m as12, Vivid.SynthDef.FromUA.UA n as13, Vivid.SynthDef.FromUA.UA o as14)
instance (Vivid.SynthDef.FromUA.AllEqual '[as0, as1, as2, as3, as4, as5, as6, as7, as8, as9, as10, as11, as12, as13, as14, as15], Vivid.SynthDef.FromUA.AllKnownSymbols '[a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p]) => Vivid.SynthDef.FromUA.FromUA (Vivid.SynthDef.FromUA.UA a as0, Vivid.SynthDef.FromUA.UA b as1, Vivid.SynthDef.FromUA.UA c as2, Vivid.SynthDef.FromUA.UA d as3, Vivid.SynthDef.FromUA.UA e as4, Vivid.SynthDef.FromUA.UA f as5, Vivid.SynthDef.FromUA.UA g as6, Vivid.SynthDef.FromUA.UA h as7, Vivid.SynthDef.FromUA.UA i as8, Vivid.SynthDef.FromUA.UA j as9, Vivid.SynthDef.FromUA.UA k as10, Vivid.SynthDef.FromUA.UA l as11, Vivid.SynthDef.FromUA.UA m as12, Vivid.SynthDef.FromUA.UA n as13, Vivid.SynthDef.FromUA.UA o as14, Vivid.SynthDef.FromUA.UA p as15)
instance (Vivid.SynthDef.FromUA.AllEqual '[as0, as1, as2, as3, as4, as5, as6, as7, as8, as9, as10, as11, as12, as13, as14, as15, as16], Vivid.SynthDef.FromUA.AllKnownSymbols '[a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q]) => Vivid.SynthDef.FromUA.FromUA (Vivid.SynthDef.FromUA.UA a as0, Vivid.SynthDef.FromUA.UA b as1, Vivid.SynthDef.FromUA.UA c as2, Vivid.SynthDef.FromUA.UA d as3, Vivid.SynthDef.FromUA.UA e as4, Vivid.SynthDef.FromUA.UA f as5, Vivid.SynthDef.FromUA.UA g as6, Vivid.SynthDef.FromUA.UA h as7, Vivid.SynthDef.FromUA.UA i as8, Vivid.SynthDef.FromUA.UA j as9, Vivid.SynthDef.FromUA.UA k as10, Vivid.SynthDef.FromUA.UA l as11, Vivid.SynthDef.FromUA.UA m as12, Vivid.SynthDef.FromUA.UA n as13, Vivid.SynthDef.FromUA.UA o as14, Vivid.SynthDef.FromUA.UA p as15, Vivid.SynthDef.FromUA.UA q as16)
instance (Vivid.SynthDef.FromUA.AllEqual '[as0, as1, as2, as3, as4, as5, as6, as7, as8, as9, as10, as11, as12, as13, as14, as15, as16, as17], Vivid.SynthDef.FromUA.AllKnownSymbols '[a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r]) => Vivid.SynthDef.FromUA.FromUA (Vivid.SynthDef.FromUA.UA a as0, Vivid.SynthDef.FromUA.UA b as1, Vivid.SynthDef.FromUA.UA c as2, Vivid.SynthDef.FromUA.UA d as3, Vivid.SynthDef.FromUA.UA e as4, Vivid.SynthDef.FromUA.UA f as5, Vivid.SynthDef.FromUA.UA g as6, Vivid.SynthDef.FromUA.UA h as7, Vivid.SynthDef.FromUA.UA i as8, Vivid.SynthDef.FromUA.UA j as9, Vivid.SynthDef.FromUA.UA k as10, Vivid.SynthDef.FromUA.UA l as11, Vivid.SynthDef.FromUA.UA m as12, Vivid.SynthDef.FromUA.UA n as13, Vivid.SynthDef.FromUA.UA o as14, Vivid.SynthDef.FromUA.UA p as15, Vivid.SynthDef.FromUA.UA q as16, Vivid.SynthDef.FromUA.UA r as17)
instance (Vivid.SynthDef.FromUA.AllEqual '[as0, as1, as2, as3, as4, as5, as6, as7, as8, as9, as10, as11, as12, as13, as14, as15, as16, as17, as18], Vivid.SynthDef.FromUA.AllKnownSymbols '[a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s]) => Vivid.SynthDef.FromUA.FromUA (Vivid.SynthDef.FromUA.UA a as0, Vivid.SynthDef.FromUA.UA b as1, Vivid.SynthDef.FromUA.UA c as2, Vivid.SynthDef.FromUA.UA d as3, Vivid.SynthDef.FromUA.UA e as4, Vivid.SynthDef.FromUA.UA f as5, Vivid.SynthDef.FromUA.UA g as6, Vivid.SynthDef.FromUA.UA h as7, Vivid.SynthDef.FromUA.UA i as8, Vivid.SynthDef.FromUA.UA j as9, Vivid.SynthDef.FromUA.UA k as10, Vivid.SynthDef.FromUA.UA l as11, Vivid.SynthDef.FromUA.UA m as12, Vivid.SynthDef.FromUA.UA n as13, Vivid.SynthDef.FromUA.UA o as14, Vivid.SynthDef.FromUA.UA p as15, Vivid.SynthDef.FromUA.UA q as16, Vivid.SynthDef.FromUA.UA r as17, Vivid.SynthDef.FromUA.UA s as18)
instance (Vivid.SynthDef.FromUA.AllEqual '[as0, as1, as2, as3, as4, as5, as6, as7, as8, as9, as10, as11, as12, as13, as14, as15, as16, as17, as18, as19], Vivid.SynthDef.FromUA.AllKnownSymbols '[a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t]) => Vivid.SynthDef.FromUA.FromUA (Vivid.SynthDef.FromUA.UA a as0, Vivid.SynthDef.FromUA.UA b as1, Vivid.SynthDef.FromUA.UA c as2, Vivid.SynthDef.FromUA.UA d as3, Vivid.SynthDef.FromUA.UA e as4, Vivid.SynthDef.FromUA.UA f as5, Vivid.SynthDef.FromUA.UA g as6, Vivid.SynthDef.FromUA.UA h as7, Vivid.SynthDef.FromUA.UA i as8, Vivid.SynthDef.FromUA.UA j as9, Vivid.SynthDef.FromUA.UA k as10, Vivid.SynthDef.FromUA.UA l as11, Vivid.SynthDef.FromUA.UA m as12, Vivid.SynthDef.FromUA.UA n as13, Vivid.SynthDef.FromUA.UA o as14, Vivid.SynthDef.FromUA.UA p as15, Vivid.SynthDef.FromUA.UA q as16, Vivid.SynthDef.FromUA.UA r as17, Vivid.SynthDef.FromUA.UA s as18, Vivid.SynthDef.FromUA.UA t as19)
instance (Vivid.SynthDef.FromUA.AllEqual '[as0, as1, as2, as3, as4, as5, as6, as7, as8, as9, as10, as11, as12, as13, as14, as15, as16, as17, as18, as19, as20], Vivid.SynthDef.FromUA.AllKnownSymbols '[a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u]) => Vivid.SynthDef.FromUA.FromUA (Vivid.SynthDef.FromUA.UA a as0, Vivid.SynthDef.FromUA.UA b as1, Vivid.SynthDef.FromUA.UA c as2, Vivid.SynthDef.FromUA.UA d as3, Vivid.SynthDef.FromUA.UA e as4, Vivid.SynthDef.FromUA.UA f as5, Vivid.SynthDef.FromUA.UA g as6, Vivid.SynthDef.FromUA.UA h as7, Vivid.SynthDef.FromUA.UA i as8, Vivid.SynthDef.FromUA.UA j as9, Vivid.SynthDef.FromUA.UA k as10, Vivid.SynthDef.FromUA.UA l as11, Vivid.SynthDef.FromUA.UA m as12, Vivid.SynthDef.FromUA.UA n as13, Vivid.SynthDef.FromUA.UA o as14, Vivid.SynthDef.FromUA.UA p as15, Vivid.SynthDef.FromUA.UA q as16, Vivid.SynthDef.FromUA.UA r as17, Vivid.SynthDef.FromUA.UA s as18, Vivid.SynthDef.FromUA.UA t as19, Vivid.SynthDef.FromUA.UA u as20)
instance (Vivid.SynthDef.FromUA.AllEqual '[as0, as1, as2, as3, as4, as5, as6, as7, as8, as9, as10, as11, as12, as13, as14, as15, as16, as17, as18, as19, as20, as21], Vivid.SynthDef.FromUA.AllKnownSymbols '[a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v]) => Vivid.SynthDef.FromUA.FromUA (Vivid.SynthDef.FromUA.UA a as0, Vivid.SynthDef.FromUA.UA b as1, Vivid.SynthDef.FromUA.UA c as2, Vivid.SynthDef.FromUA.UA d as3, Vivid.SynthDef.FromUA.UA e as4, Vivid.SynthDef.FromUA.UA f as5, Vivid.SynthDef.FromUA.UA g as6, Vivid.SynthDef.FromUA.UA h as7, Vivid.SynthDef.FromUA.UA i as8, Vivid.SynthDef.FromUA.UA j as9, Vivid.SynthDef.FromUA.UA k as10, Vivid.SynthDef.FromUA.UA l as11, Vivid.SynthDef.FromUA.UA m as12, Vivid.SynthDef.FromUA.UA n as13, Vivid.SynthDef.FromUA.UA o as14, Vivid.SynthDef.FromUA.UA p as15, Vivid.SynthDef.FromUA.UA q as16, Vivid.SynthDef.FromUA.UA r as17, Vivid.SynthDef.FromUA.UA s as18, Vivid.SynthDef.FromUA.UA t as19, Vivid.SynthDef.FromUA.UA u as20, Vivid.SynthDef.FromUA.UA v as21)
instance (Vivid.SynthDef.FromUA.AllEqual '[as0, as1, as2, as3, as4, as5, as6, as7, as8, as9, as10, as11, as12, as13, as14, as15, as16, as17, as18, as19, as20, as21, as22], Vivid.SynthDef.FromUA.AllKnownSymbols '[a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w]) => Vivid.SynthDef.FromUA.FromUA (Vivid.SynthDef.FromUA.UA a as0, Vivid.SynthDef.FromUA.UA b as1, Vivid.SynthDef.FromUA.UA c as2, Vivid.SynthDef.FromUA.UA d as3, Vivid.SynthDef.FromUA.UA e as4, Vivid.SynthDef.FromUA.UA f as5, Vivid.SynthDef.FromUA.UA g as6, Vivid.SynthDef.FromUA.UA h as7, Vivid.SynthDef.FromUA.UA i as8, Vivid.SynthDef.FromUA.UA j as9, Vivid.SynthDef.FromUA.UA k as10, Vivid.SynthDef.FromUA.UA l as11, Vivid.SynthDef.FromUA.UA m as12, Vivid.SynthDef.FromUA.UA n as13, Vivid.SynthDef.FromUA.UA o as14, Vivid.SynthDef.FromUA.UA p as15, Vivid.SynthDef.FromUA.UA q as16, Vivid.SynthDef.FromUA.UA r as17, Vivid.SynthDef.FromUA.UA s as18, Vivid.SynthDef.FromUA.UA t as19, Vivid.SynthDef.FromUA.UA u as20, Vivid.SynthDef.FromUA.UA v as21, Vivid.SynthDef.FromUA.UA w as22)
instance (Vivid.SynthDef.FromUA.AllEqual '[as0, as1, as2, as3, as4, as5, as6, as7, as8, as9, as10, as11, as12, as13, as14, as15, as16, as17, as18, as19, as20, as21, as22, as23], Vivid.SynthDef.FromUA.AllKnownSymbols '[a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x]) => Vivid.SynthDef.FromUA.FromUA (Vivid.SynthDef.FromUA.UA a as0, Vivid.SynthDef.FromUA.UA b as1, Vivid.SynthDef.FromUA.UA c as2, Vivid.SynthDef.FromUA.UA d as3, Vivid.SynthDef.FromUA.UA e as4, Vivid.SynthDef.FromUA.UA f as5, Vivid.SynthDef.FromUA.UA g as6, Vivid.SynthDef.FromUA.UA h as7, Vivid.SynthDef.FromUA.UA i as8, Vivid.SynthDef.FromUA.UA j as9, Vivid.SynthDef.FromUA.UA k as10, Vivid.SynthDef.FromUA.UA l as11, Vivid.SynthDef.FromUA.UA m as12, Vivid.SynthDef.FromUA.UA n as13, Vivid.SynthDef.FromUA.UA o as14, Vivid.SynthDef.FromUA.UA p as15, Vivid.SynthDef.FromUA.UA q as16, Vivid.SynthDef.FromUA.UA r as17, Vivid.SynthDef.FromUA.UA s as18, Vivid.SynthDef.FromUA.UA t as19, Vivid.SynthDef.FromUA.UA u as20, Vivid.SynthDef.FromUA.UA v as21, Vivid.SynthDef.FromUA.UA w as22, Vivid.SynthDef.FromUA.UA x as23)
instance (Vivid.SynthDef.FromUA.AllEqual '[as0, as1, as2, as3, as4, as5, as6, as7, as8, as9, as10, as11, as12, as13, as14, as15, as16, as17, as18, as19, as20, as21, as22, as23, as24], Vivid.SynthDef.FromUA.AllKnownSymbols '[a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y]) => Vivid.SynthDef.FromUA.FromUA (Vivid.SynthDef.FromUA.UA a as0, Vivid.SynthDef.FromUA.UA b as1, Vivid.SynthDef.FromUA.UA c as2, Vivid.SynthDef.FromUA.UA d as3, Vivid.SynthDef.FromUA.UA e as4, Vivid.SynthDef.FromUA.UA f as5, Vivid.SynthDef.FromUA.UA g as6, Vivid.SynthDef.FromUA.UA h as7, Vivid.SynthDef.FromUA.UA i as8, Vivid.SynthDef.FromUA.UA j as9, Vivid.SynthDef.FromUA.UA k as10, Vivid.SynthDef.FromUA.UA l as11, Vivid.SynthDef.FromUA.UA m as12, Vivid.SynthDef.FromUA.UA n as13, Vivid.SynthDef.FromUA.UA o as14, Vivid.SynthDef.FromUA.UA p as15, Vivid.SynthDef.FromUA.UA q as16, Vivid.SynthDef.FromUA.UA r as17, Vivid.SynthDef.FromUA.UA s as18, Vivid.SynthDef.FromUA.UA t as19, Vivid.SynthDef.FromUA.UA u as20, Vivid.SynthDef.FromUA.UA v as21, Vivid.SynthDef.FromUA.UA w as22, Vivid.SynthDef.FromUA.UA x as23, Vivid.SynthDef.FromUA.UA y as24)
instance (Vivid.SynthDef.FromUA.AllEqual '[as0, as1, as2, as3, as4, as5, as6, as7, as8, as9, as10, as11, as12, as13, as14, as15, as16, as17, as18, as19, as20, as21, as22, as23, as24, as25], Vivid.SynthDef.FromUA.AllKnownSymbols '[a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z]) => Vivid.SynthDef.FromUA.FromUA (Vivid.SynthDef.FromUA.UA a as0, Vivid.SynthDef.FromUA.UA b as1, Vivid.SynthDef.FromUA.UA c as2, Vivid.SynthDef.FromUA.UA d as3, Vivid.SynthDef.FromUA.UA e as4, Vivid.SynthDef.FromUA.UA f as5, Vivid.SynthDef.FromUA.UA g as6, Vivid.SynthDef.FromUA.UA h as7, Vivid.SynthDef.FromUA.UA i as8, Vivid.SynthDef.FromUA.UA j as9, Vivid.SynthDef.FromUA.UA k as10, Vivid.SynthDef.FromUA.UA l as11, Vivid.SynthDef.FromUA.UA m as12, Vivid.SynthDef.FromUA.UA n as13, Vivid.SynthDef.FromUA.UA o as14, Vivid.SynthDef.FromUA.UA p as15, Vivid.SynthDef.FromUA.UA q as16, Vivid.SynthDef.FromUA.UA r as17, Vivid.SynthDef.FromUA.UA s as18, Vivid.SynthDef.FromUA.UA t as19, Vivid.SynthDef.FromUA.UA u as20, Vivid.SynthDef.FromUA.UA v as21, Vivid.SynthDef.FromUA.UA w as22, Vivid.SynthDef.FromUA.UA x as23, Vivid.SynthDef.FromUA.UA y as24, Vivid.SynthDef.FromUA.UA z as25)
instance (Vivid.SynthDef.FromUA.AllEqual '[as0, as1, as2], GHC.TypeLits.KnownSymbol a, GHC.TypeLits.KnownSymbol b) => Vivid.SynthDef.FromUA.FromUA (Vivid.SynthDef.FromUA.UA a as0, Vivid.SynthDef.FromUA.UA b as1, Vivid.SynthDef.FromUA.UA c as2)
instance Vivid.SynthDef.FromUA.FromUA (Vivid.SynthDef.FromUA.UA a args)
instance (args0 ~ args1, GHC.TypeLits.KnownSymbol a) => Vivid.SynthDef.FromUA.FromUA (Vivid.SynthDef.FromUA.UA a args0, Vivid.SynthDef.FromUA.UA b args1)
instance Vivid.SynthDef.FromUA.FromUA (Vivid.SynthDef.FromUA.NoDefaults args0)


-- | Synth Definitions in SuperCollider are how you define the way synths
--   should sound -- you describe parameters and a graph of sound
--   generators, add them to the server with <tt>defineSD</tt>, and then
--   create instances of the Synth Definition (called "synths"), which each
--   play separately. You can set parameters of the synth at any time while
--   they're playing
--   
--   Usually, you shouldn't be making <a>SynthDef</a>s explicitly --
--   there's a state monad <a>SDBody</a> which lets you construct synthdefs
--   like so:
--   
--   <pre>
--   test :: SynthDef
--   test = <a>sd</a> (0 ::I "note") $ do
--      s &lt;- 0.1 <a>~*</a> <a>sinOsc</a> (freq_ $ <a>midiCPS</a> (V::V "note"))
--      out 0 [s, s]
--   
--   </pre>
--   
--   You then optionally explicitly send the synth definition to the SC
--   server with
--   
--   <pre>
--   &gt;&gt;&gt; defineSD test
--   </pre>
--   
--   You then create a synth from the synthdef like:
--   
--   <pre>
--   &gt;&gt;&gt; s &lt;- synth test (45 ::I "note")
--   </pre>
--   
--   This returns a <tt>NodeId</tt> which is a reference to the synth,
--   which you can use to e.g. change the params of the running synth with
--   e.g.
--   
--   <pre>
--   &gt;&gt;&gt; set s (38 ::I "note")
--   </pre>
--   
--   Then you can free it (stop its playing) with
--   
--   <pre>
--   &gt;&gt;&gt; free s
--   </pre>
--   
--   (If you want interop with SClang, use "sdNamed" and "synthNamed")
module Vivid.SynthDef

-- | Internal representation of Synth Definitions. Usually, use <a>sd</a>
--   instead of making these by hand.
--   
--   This representation (especially <a>_sdUGens</a>) might change in the
--   future.
data SynthDef (args :: [Symbol])
SynthDef :: SDName -> [(ByteString, Float)] -> Map Int UGen -> SynthDef
[_sdName] :: SynthDef -> SDName
[_sdParams] :: SynthDef -> [(ByteString, Float)]
[_sdUGens] :: SynthDef -> Map Int UGen

-- | Representation of Unit Generators. You usually won't be creating these
--   by hand, but instead using things from the library in <a>UGens</a>
data UGen
UGen :: UGenName -> CalculationRate -> [Signal] -> Int -> UGen
[_ugenName] :: UGen -> UGenName
[_ugenCalculationRate] :: UGen -> CalculationRate
[_ugenIns] :: UGen -> [Signal]
[_ugenNumOuts] :: UGen -> Int

-- | Alias for <a>addMonoUGen</a>
addUGen :: UGen -> SDBody' args Signal

-- | Add a unit generator with one output
addMonoUGen :: UGen -> SDBody' args Signal

-- | Polyphonic -- returns a list of <a>Signal</a>s. In the future this
--   might be a tuple instead of a list
addPolyUGen :: UGen -> SDBody' args [Signal]
class ToSig s (args :: [Symbol])
toSig :: ToSig s args => s -> SDBody' args Signal
data Signal
Constant :: Float -> Signal
Param :: ByteString -> Signal
UGOut :: Int -> Int32 -> Signal
encodeSD :: SynthDef a -> ByteString

-- | Define a Synth Definition
sd :: VarList argList => argList -> SDBody' (InnerVars argList) [Signal] -> SynthDef (InnerVars argList)

-- | Define a Synth Definition and give it a name you can refer to from
--   e.g. sclang
sdNamed :: VarList argList => String -> argList -> SDBody' (InnerVars argList) [Signal] -> SynthDef (InnerVars argList)
sdPretty :: SynthDef a -> String

-- | Set the calculation rate of a UGen
--   
--   e.g.
--   
--   <pre>
--   play $ do
--      s0 &lt;- 1 ~+ (lfSaw (freq_ 1) ? KR)
--      s1 &lt;- 0.1 ~* lfSaw (freq_ $ 220 ~* s0)
--      out 0 [s1, s1]
--   </pre>
--   
--   Mnemonic: "?" is like thinking
--   
--   In the future, the representation of calculation rates may change
(?) :: SDBody' args Signal -> CalculationRate -> SDBody' args Signal

-- | Action to take with a UGen when it's finished
--   
--   This representation will change in the future
data DoneAction
DoNothing :: DoneAction
FreeEnclosing :: DoneAction
DoneAction_AsNum :: Int -> DoneAction
doneActionNum :: DoneAction -> Float
sdLitPretty :: LiteralSynthDef -> String
sdToLiteral :: SynthDef a -> LiteralSynthDef

-- | Evaluate a state computation with the given initial state and return
--   the final state, discarding the final value.
--   
--   <ul>
--   <li><pre><a>execState</a> m s = <a>snd</a> (<a>runState</a> m
--   s)</pre></li>
--   </ul>
execState :: () => State s a -> s -> s
getCalcRate :: Signal -> SDBody' args CalculationRate

-- | Unary signal operations. Many of these have functions so you don't
--   need to use this internal representation (e.g. <a>Neg</a> has
--   <tt>neg</tt>, etc).
--   
--   This type might not be exposed in the future.
data UnaryOp :: *
Neg :: UnaryOp
Not :: UnaryOp
IsNil :: UnaryOp
NotNil :: UnaryOp

-- | There's a bug in some SC versions where .bitNot isn't implemented
--   correctly. Vivid backfills it with a fix, so you can use BitNot with
--   any SC version
BitNot :: UnaryOp
Abs :: UnaryOp
AsFloat :: UnaryOp
AsInt :: UnaryOp
Ciel :: UnaryOp
Floor :: UnaryOp
Frac :: UnaryOp
Sign :: UnaryOp
Squared :: UnaryOp
Cubed :: UnaryOp
Sqrt :: UnaryOp
Exp :: UnaryOp
Recip :: UnaryOp
MIDICPS :: UnaryOp
CPSMIDI :: UnaryOp
MIDIRatio :: UnaryOp
RatioMIDI :: UnaryOp
DbAmp :: UnaryOp
AmpDb :: UnaryOp
OctCPS :: UnaryOp
CPSOct :: UnaryOp
Log :: UnaryOp
Log2 :: UnaryOp
Log10 :: UnaryOp
Sin :: UnaryOp
Cos :: UnaryOp
Tan :: UnaryOp
ArcSin :: UnaryOp
ArcCos :: UnaryOp
ArcTan :: UnaryOp
SinH :: UnaryOp
CosH :: UnaryOp
TanH :: UnaryOp
Rand :: UnaryOp
Rand2 :: UnaryOp
LinRand :: UnaryOp
BiLinRand :: UnaryOp
Sum3Rand :: UnaryOp
Distort :: UnaryOp
SoftClip :: UnaryOp
Coin :: UnaryOp
DigitValue :: UnaryOp
Silence :: UnaryOp
Thru :: UnaryOp
RectWindow :: UnaryOp
HanWindow :: UnaryOp
WelchWindow :: UnaryOp
TriWindow :: UnaryOp
Ramp :: UnaryOp
SCurve :: UnaryOp
NumUnarySelectors :: UnaryOp
uOpToSpecialI :: UnaryOp -> Int16
specialIToUOp :: Int16 -> UnaryOp

-- | Binary signal operations. For the simple ones (like <a>Add</a>,
--   <a>Mul</a>, etc.), there are functions (like <a>~+</a>, <a>~*</a>,
--   etc.) that wrap them up so you don't have to make a ugen for them
--   yourself.
--   
--   In the future these may not be exported -- we'll just have functions
--   for all of them.
data BinaryOp :: *
Add :: BinaryOp
Sub :: BinaryOp
Mul :: BinaryOp

-- | Integer division
IDiv :: BinaryOp

-- | Float division
FDiv :: BinaryOp
Mod :: BinaryOp
Eq :: BinaryOp
Ne :: BinaryOp
Lt :: BinaryOp
Gt :: BinaryOp
Le :: BinaryOp
Ge :: BinaryOp
Min :: BinaryOp
Max :: BinaryOp
BitAnd :: BinaryOp
BitOr :: BinaryOp
BitXor :: BinaryOp
Lcm :: BinaryOp
Gcd :: BinaryOp
Round :: BinaryOp
RoundUp :: BinaryOp
Trunc :: BinaryOp
Atan2 :: BinaryOp
Hypot :: BinaryOp
Hypotx :: BinaryOp
Pow :: BinaryOp
ShiftLeft :: BinaryOp
ShiftRight :: BinaryOp
UnsignedShift :: BinaryOp
Fill :: BinaryOp

-- | a * (b + 1) == a * b + a
Ring1 :: BinaryOp

-- | a * b + a + b
Ring2 :: BinaryOp

-- | a * a * b
Ring3 :: BinaryOp

-- | a * a * b - a * b * b
Ring4 :: BinaryOp

-- | a * a - b * b
DifSqr :: BinaryOp

-- | a * a + b * b
SumSqr :: BinaryOp

-- | (a + b) ^ 2
SqrSum :: BinaryOp

-- | (a - b) ^ 2
SqrDif :: BinaryOp

-- | abs(a - b)
AbsDif :: BinaryOp
Thresh :: BinaryOp
AMClip :: BinaryOp
ScaleNeg :: BinaryOp
Clip2 :: BinaryOp
Excess :: BinaryOp
Fold2 :: BinaryOp
Wrap2 :: BinaryOp
FirstArg :: BinaryOp
RandRange :: BinaryOp
ExpRandRange :: BinaryOp
NumBinarySelectors :: BinaryOp
biOpToSpecialI :: BinaryOp -> Int16
specialIToBiOp :: Int16 -> BinaryOp
getSDHashName :: SynthDef a -> ByteString
makeSynthDef :: VarList argList => SDName -> argList -> SDBody' (InnerVars argList) [Signal] -> SynthDef (InnerVars argList)

-- | Like <a>shrinkSynthArgs</a> but for <a>SynthDef</a>s
shrinkSDArgs :: Subset new old => SynthDef old -> SynthDef new
type SDBody a = SDBody' (SDBodyArgs a)
instance GHC.Classes.Eq Vivid.SynthDef.DoneAction
instance GHC.Show.Show Vivid.SynthDef.DoneAction
instance Data.Hashable.Class.Hashable (Vivid.SynthDef.Types.SynthDef a)

module Vivid.SCServer.State
newtype BufferId :: *
BufferId :: Int32 -> BufferId
[_unBufferId] :: BufferId -> Int32
newtype NodeId :: *
NodeId :: Int32 -> NodeId
[_unNodeId] :: NodeId -> Int32
newtype SyncId :: *
SyncId :: Int32 -> SyncId
[_unSyncId] :: SyncId -> Int32
scServerState :: SCServerState
data SCServerState
SCServerState :: TVar Bool -> !(TMVar Socket) -> !(TMVar ThreadId) -> !(TVar [BufferId]) -> !(TVar Int32) -> !(TVar [NodeId]) -> !(TVar [SyncId]) -> !(TVar (Map SyncId (MVar ()))) -> !(TVar (OSC -> IO ())) -> !(TVar (Set (SDName, Int))) -> SCServerState
[_scServerState_socketConnectStarted] :: SCServerState -> TVar Bool
[_scServerState_socket] :: SCServerState -> !(TMVar Socket)
[_scServerState_listener] :: SCServerState -> !(TMVar ThreadId)
[_scServerState_availableBufferIds] :: SCServerState -> !(TVar [BufferId])
[_scServerState_maxBufIds] :: SCServerState -> !(TVar Int32)
[_scServerState_availableNodeIds] :: SCServerState -> !(TVar [NodeId])
[_scServerState_availableSyncIds] :: SCServerState -> !(TVar [SyncId])
[_scServerState_syncIdMailboxes] :: SCServerState -> !(TVar (Map SyncId (MVar ())))
[_scServerState_serverMessageFunction] :: SCServerState -> !(TVar (OSC -> IO ()))
[_scServerState_definedSDs] :: SCServerState -> !(TVar (Set (SDName, Int)))
setClientId :: Int32 -> IO ()

-- | If you've started the SC server with a non-default number of buffer
--   ids, (e.g. with the "-b" argument), you can reflect that here
--   
--   Note that the buffer ids start at 512, to not clash with any that
--   another client (e.g. sclang) has allocated
setMaxBufferIds :: Int32 -> IO ()
getNextAvailable :: (SCServerState -> TVar [a]) -> IO a
numberOfSyncIdsToDrop :: Int

module Vivid.SCServer.Connection

-- | <b>You usually don't need to call this function</b>
--   
--   Use this if to connect on a non-default port or to a server not at
--   localhost
--   
--   Otherwise the connection is created when it's needed. You can also use
--   this to explicitly create the connection, so the computation is done
--   upfront
--   
--   The <a>HostName</a> is the ip address or "localhost". The
--   <a>ServiceName</a> is the port
createSCServerConnection :: SCConnectConfig -> IO (Either String Socket)

-- | The default _scConnectConfig_clientId is 1, and sclang's is 0, so you
--   should be able to run vivid side-by-side with the SC IDE out of the
--   box.
defaultConnectConfig :: SCConnectConfig

-- | Print all messages other than "/done"s
defaultMessageFunction :: OSC -> IO ()

-- | If you don't want to hear what the server has to say
ignoreMessagesFunction :: OSC -> IO ()
data SCConnectConfig
SCConnectConfig :: HostName -> ServiceName -> Int32 -> ConnProtocol -> (OSC -> IO ()) -> SCConnectConfig
[_scConnectConfig_hostName] :: SCConnectConfig -> HostName
[_scConnectConfig_port] :: SCConnectConfig -> ServiceName

-- | To prevent NodeId clashes when multiple clients are connected to the
--   same server, each client should have a separate clientId, which keeps
--   the nodeId separate. Sclang's default clientId is 0, and ours is 1, so
--   you can run both at the same time without config.
[_scConnectConfig_clientId] :: SCConnectConfig -> Int32
[_scConnectConfig_connProtocol] :: SCConnectConfig -> ConnProtocol
[_scConnectConfig_serverMessageFunction] :: SCConnectConfig -> OSC -> IO ()

-- | Explicitly close Vivid's connection to a SC server.
--   
--   Day-to-day, you can usually just let your program run without using
--   this.
--   
--   For example though, if you're running code that uses Vivid in ghci,
--   and you ":r", you'll want to disconnect first -- there are processes
--   running which can step on the toes of your new instance
--   
--   Also if you want to change the params of your connection (e.g. to
--   connect to a different server), you'll want to disconnect from the
--   other connection first
closeSCServerConnection :: IO ()
data ConnProtocol
ConnProtocol_UDP :: ConnProtocol
getMailboxForSyncId :: SyncId -> IO (MVar ())
getSCServerSocket :: IO Socket
waitForSync_io :: SyncId -> IO ()
waitForSync_io_noGC :: SyncId -> IO ()
instance GHC.Classes.Ord Vivid.SCServer.Connection.ConnProtocol
instance GHC.Classes.Eq Vivid.SCServer.Connection.ConnProtocol
instance GHC.Read.Read Vivid.SCServer.Connection.ConnProtocol
instance GHC.Show.Show Vivid.SCServer.Connection.ConnProtocol


-- | Envelopes. **This module is the least mature in vivid and is likely to
--   change a lot in the future!**
module Vivid.Envelopes
data EnvLiterally (args :: [Symbol])
EnvLiterally :: initial -> Maybe Int -> Float -> Maybe Int -> [EnvSegment] -> EnvLiterally
[_envLiterally_initialVal] :: EnvLiterally -> initial
[_envLiterally_releaseNode] :: EnvLiterally -> Maybe Int
[_envLiterally_offset] :: EnvLiterally -> Float
[_envLiterally_loopNode] :: EnvLiterally -> Maybe Int
[_envLiterally_curveSegments] :: EnvLiterally -> [EnvSegment]
envLiterallyToSignals :: EnvLiterally (b :: [Symbol]) -> SDBody' b [Signal]
env :: Float -> [(Float, Float)] -> EnvCurve -> EnvLiterally a
data EnvCurve
Curve_Step :: EnvCurve
Curve_Linear :: EnvCurve
Curve_Lin :: EnvCurve
Curve_Exponential :: EnvCurve
Curve_Exp :: EnvCurve
Curve_Sine :: EnvCurve
Curve_Sin :: EnvCurve
Curve_Welch :: EnvCurve
Curve_Wel :: EnvCurve
Curve_Squared :: EnvCurve
Curve_Sqr :: EnvCurve
Curve_Cubed :: EnvCurve
Curve_Cub :: EnvCurve

-- | 0 is linear, positive curves up, negative curves down
Curve_Curve :: Float -> EnvCurve
data EnvSegment
EnvSegment :: Signal -> Signal -> EnvCurve -> EnvSegment
[_envSegment_targetVal] :: EnvSegment -> Signal
[_envSegment_timeToGetThere] :: EnvSegment -> Signal
[_envSegment_curve] :: EnvSegment -> EnvCurve

-- | Same as "Env.shapeNumber" in SC.
--   
--   This is useful if you want to set a the env shape of a running synth
shapeNumber :: EnvCurve -> Float

-- | "shapeNumber" with a name I like better
curveNumber :: EnvCurve -> Float
instance GHC.Classes.Eq Vivid.Envelopes.EnvSegment
instance GHC.Show.Show Vivid.Envelopes.EnvSegment
instance GHC.Classes.Eq Vivid.Envelopes.EnvCurve
instance GHC.Show.Show Vivid.Envelopes.EnvCurve


-- | A <tt>VividAction m =&gt; m a</tt> can either be run immediately, be
--   scheduled to run at a precise future time, or be used for non-realtime
--   synthesis.
--   
--   Note that at the moment VividAction has MonadIO, but this won't be
--   true in upcoming versions (as early as the next release) - so don't
--   get used to it!
module Vivid.Actions.Class
class (Monad m, MonadIO m) => VividAction (m :: * -> *)

-- | Send an <a>OSC</a> message to the SuperCollider server
callOSC :: VividAction m => OSC -> m ()

-- | Send a ByteString to the SuperCollider server. You usually want to use
--   <tt>call</tt> instead.
callBS :: VividAction m => ByteString -> m ()

-- | Blocks until the server finishes processing commands
sync :: VividAction m => m ()

-- | As the user, you probably don't want to use this:
--   
--   Many commands already include a "sync" -- e.g. <tt>makeBuffer</tt>
--   already syncs.
--   
--   When you do want to do an explicit sync you probably want to use
--   <a>sync</a> instead, or <a>callOSCAndSync</a>
waitForSync :: VividAction m => SyncId -> m ()

-- | Wait, in seconds
wait :: (VividAction m, Real n) => n -> m ()
getTime :: VividAction m => m Timestamp
newBufferId :: VividAction m => m BufferId
newNodeId :: VividAction m => m NodeId
newSyncId :: VividAction m => m SyncId
fork :: VividAction m => m () -> m ()

-- | Send a synth definition to be loaded on the SC server
--   
--   Note that this is sort of optional -- if you don't call it, it'll be
--   called the first time you call <tt>synth</tt> with the SynthDef
defineSD :: VividAction m => SynthDef a -> m ()

-- | Send an OSC message and wait for it to complete before returning
callOSCAndSync :: VividAction m => OSC -> m ()

-- | Maybe can dedupe with <a>callOSCAndSync</a>
oscWSync :: VividAction m => (SyncId -> m ()) -> m ()


-- | This is unscheduled - the server will do what you tell it to as soon
--   as it can. That can mean there'll be slight delays because of time it
--   took to compute what to do or because of network latency. If you want
--   more precise timing look at <a>Scheduled</a>
--   
--   Doing "VividAction"s in IO can be like a sketchpad: it's the quickest
--   way to get an idea out. The cool thing is you can take an action that
--   you're sketching and put a function in front of it to get more precise
--   timing E.g. if you have the function:
--   
--   <pre>
--   playTone = do
--      synth &lt;- play $ 0.1 ~* sinOsc (freq_ 440)
--      wait 1
--      free synth
--   
--   </pre>
--   
--   You can play it quickly with just:
--   
--   <pre>
--   playTone
--   </pre>
--   
--   But if you want precise timing all you need to do is say e.g.:
--   
--   <pre>
--   playScheduledIn 0.01 playTone
--   </pre>
module Vivid.Actions.IO

-- | Synchronous
defineSDFromFile :: SynthDef a -> IO ()
instance Vivid.Actions.Class.VividAction GHC.Types.IO

module Vivid.SCServer.Types

-- | This enforces type safety of the arguments -- e.g. if you have a
--   synthdef
--   
--   <pre>
--   &gt; let x = sd (3 ::I "foo") bar
--   &gt; s &lt;- synth x ()
--   </pre>
--   
--   Then this won't typecheck (because "bar" isn't an argument to x):
--   
--   <pre>
--   &gt; set s (4 ::I "bar")
--   </pre>
--   
--   Note that if you don't want this type safety, you can e.g.
--   
--   <pre>
--   &gt; Synth n &lt;- synth foo ()
--   &gt; setG n (0.1 ::I "vol")
--   </pre>
--   
--   Or:
--   
--   <pre>
--   &gt; ns &lt;- mapM (flip synth ()) [foo, bar, baz]
--   &gt; map (setG (0::I "asdf") . unSynth) ns
--   </pre>
--   
--   Or:
--   
--   <pre>
--   &gt; n &lt;- synthG foo ()
--   </pre>
--   
--   (You also may want to look at <a>shrinkSynthArgs</a> if you want to
--   construct a list which has synthdefs or nodes of different types)
newtype Synth (args :: [Symbol])
Synth :: NodeId -> Synth
[_unSynth] :: Synth -> NodeId

-- | So let's say you have a node:
--   
--   <pre>
--   foo :: Synth '["amp", "freq", "phase"]
--   </pre>
--   
--   and you want to add it to a list of nodes:
--   
--   <pre>
--   ns :: [Synth '["freq", "phase"]]
--   </pre>
--   
--   If you don't plan on setting the "amp" argument, you can "shrink" to
--   the compatible arguments:
--   
--   <pre>
--   ns' = shrinkSynthArgs foo : ns
--   </pre>
--   
--   (The same thing exists for SynthDefs -- <a>shrinkSDArgs</a>)
shrinkSynthArgs :: (Subset new old) => Synth old -> Synth new
class IsNode a
getNodeId :: IsNode a => a -> NodeId

-- | For gradually-typed <tt>free</tt>
class IsNode a => SynthOrNodeId a

-- | <a>Group</a> and <a>ParGroup</a>
class IsNode g => IsGroup g
instance GHC.Classes.Ord (Vivid.SCServer.Types.Synth args)
instance GHC.Classes.Eq (Vivid.SCServer.Types.Synth args)
instance GHC.Read.Read (Vivid.SCServer.Types.Synth args)
instance GHC.Show.Show (Vivid.SCServer.Types.Synth args)
instance Vivid.SCServer.Types.IsGroup Vivid.SC.Server.Types.Group
instance Vivid.SCServer.Types.IsGroup Vivid.SC.Server.Types.ParGroup
instance Vivid.SCServer.Types.SynthOrNodeId (Vivid.SCServer.Types.Synth x)
instance Vivid.SCServer.Types.SynthOrNodeId Vivid.SC.Server.Types.NodeId
instance Vivid.SCServer.Types.IsNode Vivid.SC.Server.Types.NodeId
instance Vivid.SCServer.Types.IsNode (Vivid.SCServer.Types.Synth a)
instance Vivid.SCServer.Types.IsNode Vivid.SC.Server.Types.Group
instance Vivid.SCServer.Types.IsNode Vivid.SC.Server.Types.ParGroup


-- | Library for interacting with the SuperCollider server.
--   
--   You don't need to use much of this day-to-day
--   
--   There's a toplevel <a>scServerState</a> that stores the current state
--   of the SC server
module Vivid.SCServer

-- | Your "emergency" button. Run this and everything playing on the SC
--   server will be freed -- silence!
--   
--   Corresponds to the cmd-. / ctrl-. key command in the SuperCollider IDE
cmdPeriod :: (VividAction m) => m ()

-- | Alias of <a>cmdPeriod</a>
freeAll :: VividAction m => m ()

-- | This is stored as the number of seconds since Jan 1 1900. You can get
--   it with <a>getTime</a>
newtype Timestamp :: *
Timestamp :: Double -> Timestamp
newtype NodeId :: *
NodeId :: Int32 -> NodeId
[_unNodeId] :: NodeId -> Int32

-- | This enforces type safety of the arguments -- e.g. if you have a
--   synthdef
--   
--   <pre>
--   &gt; let x = sd (3 ::I "foo") bar
--   &gt; s &lt;- synth x ()
--   </pre>
--   
--   Then this won't typecheck (because "bar" isn't an argument to x):
--   
--   <pre>
--   &gt; set s (4 ::I "bar")
--   </pre>
--   
--   Note that if you don't want this type safety, you can e.g.
--   
--   <pre>
--   &gt; Synth n &lt;- synth foo ()
--   &gt; setG n (0.1 ::I "vol")
--   </pre>
--   
--   Or:
--   
--   <pre>
--   &gt; ns &lt;- mapM (flip synth ()) [foo, bar, baz]
--   &gt; map (setG (0::I "asdf") . unSynth) ns
--   </pre>
--   
--   Or:
--   
--   <pre>
--   &gt; n &lt;- synthG foo ()
--   </pre>
--   
--   (You also may want to look at <a>shrinkSynthArgs</a> if you want to
--   construct a list which has synthdefs or nodes of different types)
newtype Synth (args :: [Symbol])
Synth :: NodeId -> Synth
[_unSynth] :: Synth -> NodeId
newtype Group :: *
Group :: NodeId -> Group
[_unGroup] :: Group -> NodeId
defaultGroup :: Group
newtype BufferId :: *
BufferId :: Int32 -> BufferId
[_unBufferId] :: BufferId -> Int32
makeBuffer :: (VividAction m) => Int32 -> m BufferId
makeBufferFromFile :: (VividAction m) => FilePath -> m BufferId

-- | Make an empty buffer
--   
--   The Int32 is the buffer length <i>in samples</i>. Multiply seconds by
--   the default sample rate of the server (usually 48000) to get the
--   number of samples
--   
--   Note that this is synchronous -- it doesn't return until the buffer is
--   allocated (in theory, this could hang if e.g. the UDP packet is lost)
newBuffer :: VividAction m => Int32 -> m BufferId

-- | Make a buffer and fill it with sound data from a file
--   
--   The file path should be absolute (not relative), and if you're
--   connecting to a non-localhost server don't expect it to be able to
--   read files from your hard drive!
--   
--   Note that like "makeBuffer" this is synchronous
newBufferFromFile :: (VividAction m) => FilePath -> m BufferId

-- | Write a buffer to a file
--   
--   Alias of <a>writeBuffer</a>
--   
--   Synchronous.
saveBuffer :: (VividAction m) => BufferId -> FilePath -> m ()
writeBuffer :: VividAction m => BufferId -> FilePath -> m ()
writeBufferWith :: VividAction m => WriteBufArgs -> BufferId -> FilePath -> m ()

-- | We may add arguments in the future ; to future-proof your code, just
--   update fields of <a>defaultWBArgs</a>
data WriteBufArgs
WriteBufArgs :: Bool -> WriteBufArgs
[_wb_keepOpen] :: WriteBufArgs -> Bool
defaultWBArgs :: WriteBufArgs
closeBuf :: VividAction m => BufferId -> m ()

-- | Close an open soundfile and write header information
--   
--   Synchronous
closeBuffer :: VividAction m => BufferId -> m ()

-- | Zero the sample data in a buffer
--   
--   Synchronous
zeroBuf :: VividAction m => BufferId -> m ()

-- | <b>You usually don't need to call this function</b>
--   
--   Use this if to connect on a non-default port or to a server not at
--   localhost
--   
--   Otherwise the connection is created when it's needed. You can also use
--   this to explicitly create the connection, so the computation is done
--   upfront
--   
--   The <a>HostName</a> is the ip address or "localhost". The
--   <a>ServiceName</a> is the port
createSCServerConnection :: SCConnectConfig -> IO (Either String Socket)

-- | Explicitly close Vivid's connection to a SC server.
--   
--   Day-to-day, you can usually just let your program run without using
--   this.
--   
--   For example though, if you're running code that uses Vivid in ghci,
--   and you ":r", you'll want to disconnect first -- there are processes
--   running which can step on the toes of your new instance
--   
--   Also if you want to change the params of your connection (e.g. to
--   connect to a different server), you'll want to disconnect from the
--   other connection first
closeSCServerConnection :: IO ()
data SCConnectConfig
SCConnectConfig :: HostName -> ServiceName -> Int32 -> ConnProtocol -> (OSC -> IO ()) -> SCConnectConfig
[_scConnectConfig_hostName] :: SCConnectConfig -> HostName
[_scConnectConfig_port] :: SCConnectConfig -> ServiceName

-- | To prevent NodeId clashes when multiple clients are connected to the
--   same server, each client should have a separate clientId, which keeps
--   the nodeId separate. Sclang's default clientId is 0, and ours is 1, so
--   you can run both at the same time without config.
[_scConnectConfig_clientId] :: SCConnectConfig -> Int32
[_scConnectConfig_connProtocol] :: SCConnectConfig -> ConnProtocol
[_scConnectConfig_serverMessageFunction] :: SCConnectConfig -> OSC -> IO ()

-- | The default _scConnectConfig_clientId is 1, and sclang's is 0, so you
--   should be able to run vivid side-by-side with the SC IDE out of the
--   box.
defaultConnectConfig :: SCConnectConfig

-- | So let's say you have a node:
--   
--   <pre>
--   foo :: Synth '["amp", "freq", "phase"]
--   </pre>
--   
--   and you want to add it to a list of nodes:
--   
--   <pre>
--   ns :: [Synth '["freq", "phase"]]
--   </pre>
--   
--   If you don't plan on setting the "amp" argument, you can "shrink" to
--   the compatible arguments:
--   
--   <pre>
--   ns' = shrinkSynthArgs foo : ns
--   </pre>
--   
--   (The same thing exists for SynthDefs -- <a>shrinkSDArgs</a>)
shrinkSynthArgs :: (Subset new old) => Synth old -> Synth new
instance GHC.Classes.Ord Vivid.SCServer.WriteBufArgs
instance GHC.Classes.Eq Vivid.SCServer.WriteBufArgs
instance GHC.Read.Read Vivid.SCServer.WriteBufArgs
instance GHC.Show.Show Vivid.SCServer.WriteBufArgs


-- | This is for timing of actions that's more precise than IO
--   
--   It tells the server when to perform the actions, so musical timing
--   won't be affected by e.g. network latency or the time it took to
--   compute a value
--   
--   If you're running vivid on a different computer than the SC synth,
--   make sure the clocks agree
module Vivid.Actions.Scheduled
type Scheduled = StateT Timestamp IO

-- | Schedule an action to happen n seconds from now
doScheduledIn :: Double -> Scheduled a -> IO a

-- | Schedule an action to happen at the given time
doScheduledAt :: Timestamp -> Scheduled a -> IO a

-- | Schedule an action to happen right now. Because of server latency this
--   could arrive late, so you might want to do something like
--   <tt>doScheduledIn 0.01</tt> instead:
doScheduledNow :: Scheduled a -> IO a
instance Vivid.Actions.Class.VividAction Vivid.Actions.Scheduled.Scheduled


-- | Non-realtime synthesis. Create a sound file from the same instructions
--   you use to perform live!
--   
--   <ul>
--   <li>*Note** we don't currently support redefining Synthdefs midway --
--   e.g. you can't explicitly define a SynthDef "foo" (with
--   <a>defineSD</a>), then make a synth from it, then explicitly define it
--   again with a new definition, and then make a new synth with the new
--   definition</li>
--   </ul>
module Vivid.Actions.NRT
type NRT = StateT (Timestamp, Maximum Timestamp, Map Timestamp [Either ByteString OSC]) IO

-- | Generate an audio file from an NRT action -- this can write songs far
--   faster than it would take to play them.
--   
--   This uses <a>defaultNRTArgs</a> for its sample rate, number of
--   channels, etc. If you want to use args other than the default, use
--   <a>writeNRTWith</a>.
--   
--   The file type is detected from its extension. The extensions supported
--   at the moment are .aif, .aiff, and .wav
--   
--   (Mac OS X users will need to make sure <tt>scsynth</tt> is in their
--   $PATH)
--   
--   (And I apologize, but I really don't know what Windows users will need
--   to do)
--   
--   Currently doesn't work with single quotes in the filename
writeNRT :: FilePath -> NRT a -> IO ()

-- | Generate a file of actions that SC can use to do NRT with.
--   
--   <b>If you just want the .aiff file, you probably want <a>writeNRT</a>
--   instead.</b>
--   
--   Usage: this will create a file at "<i>tmp</i>NRTout.aiff" with your
--   <tt>sound :: NRT a</tt>:
--   
--   <pre>
--   writeNRT "/tmp/foo.osc" test
--   scsynth -N /tmp/foo.osc _ /tmp/NRTout.aiff 44100 AIFF int16
--   </pre>
writeNRTScore :: FilePath -> NRT a -> IO ()
runNRT :: NRT a -> IO [OSCBundle]
writeNRTWith :: NRTArgs -> FilePath -> NRT a -> IO ()
data NRTArgs
NRTArgs :: Int -> Int -> NRTArgs
[_nrtArgs_sampleRate] :: NRTArgs -> Int
[_nrtArgs_numChans] :: NRTArgs -> Int
defaultNRTArgs :: NRTArgs
instance GHC.Classes.Ord Vivid.Actions.NRT.NRTArgs
instance GHC.Classes.Eq Vivid.Actions.NRT.NRTArgs
instance GHC.Read.Read Vivid.Actions.NRT.NRTArgs
instance GHC.Show.Show Vivid.Actions.NRT.NRTArgs
instance Vivid.Actions.Class.VividAction Vivid.Actions.NRT.NRT
instance (GHC.Classes.Eq a, GHC.Classes.Ord a) => GHC.Classes.Ord (Vivid.Actions.NRT.Maximum a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Vivid.Actions.NRT.Maximum a)


-- | The fixities of the operators ("~+", "~*", "~&lt;", etc) are the same
--   as those of their non-'~' equivalents (+, *, &lt; etc)
--   
--   (So you can e.g. multiply then add without parens!)
module Vivid.UGens.Algebraic

-- | Add signals
(~+) :: (ToSig i0 a, ToSig i1 a) => i0 -> i1 -> SDBody' a Signal
infixl 6 ~+

-- | Subtract signals
(~-) :: (ToSig i0 a, ToSig i1 a) => i0 -> i1 -> SDBody' a Signal
infixl 6 ~-

-- | Multiply signals
(~*) :: (ToSig i0 a, ToSig i1 a) => i0 -> i1 -> SDBody' a Signal
infixl 7 ~*

-- | Exponentiation of signals
(~**) :: (ToSig i0 a, ToSig i1 a) => i0 -> i1 -> SDBody' a Signal
infixr 8 ~**

-- | Divide signals
(~/) :: (ToSig i0 a, ToSig i1 a) => i0 -> i1 -> SDBody' a Signal
infixl 7 ~/

-- | Build your own!
--   
--   The calculation rate of the result is the larger (more frequent) of
--   the 2 input signals (So you shouldn't need to use "?" very much!)
binaryOp :: (ToSig s0 a, ToSig s1 a) => BinaryOp -> s0 -> s1 -> SDBody' a Signal

-- | Alias of <a>binaryOp</a>. Shorter, fer livecodin
biOp :: (ToSig s0 a, ToSig s1 a) => BinaryOp -> s0 -> s1 -> SDBody' a Signal

-- | Build your own, from <a>UnaryOp</a>s
unaryOp :: (ToSig sig a) => UnaryOp -> sig -> SDBody' a Signal

-- | Alias of <a>unaryOp</a>
uOp :: (ToSig sig a) => UnaryOp -> sig -> SDBody' a Signal

-- | Convert from a midi note number (0-127, each representing a musical
--   half step) to a frequency in hz (cycles per second)
midiCPS :: (ToSig i a) => i -> SDBody' a Signal

-- | Inverse of <a>midiCPS</a>
cpsMIDI :: (ToSig i a) => i -> SDBody' a Signal

-- | The prime is to not conflict with "abs" in the prelude. May just use
--   "uOp Abs" in the future
abs' :: (ToSig i a) => i -> SDBody' a Signal
neg :: (ToSig i a) => i -> SDBody' a Signal

-- | The prime, like <a>abs'</a>, is to not conflict with a prelude
--   definition.
--   
--   Remember you can always just use:
--   
--   <pre>
--   uOp TanH
--   </pre>
tanh' :: ToSig i a => i -> SDBody' a Signal

-- | Like <a>clip</a> but the lo value is always negative the hi value
clip2 :: (ToSig s0 a, ToSig s1 a) => s0 -> s1 -> SDBody' a Signal

-- | Bitwise xor. Short for <tt>biOp BitXor</tt>
xor :: (ToSig s0 a, ToSig s1 a) => s0 -> s1 -> SDBody' a Signal


-- | UGen argument labels
--   
--   These are named the same as their SC counterparts, usually.
module Vivid.UGens.Args
a_ :: ToSig s as => s -> UA "a" as
a0_ :: ToSig s as => s -> UA "a0" as
a1_ :: ToSig s as => s -> UA "a1" as
a2_ :: ToSig s as => s -> UA "a2" as
active_ :: ToSig s as => s -> UA "active" as
add_ :: ToSig s as => s -> UA "add" as
ampThreshold_ :: ToSig s as => s -> UA "ampThreshold" as
aReal_ :: ToSig s as => s -> UA "aReal" as

-- | SC compatibility
areal_ :: ToSig s as => s -> UA "aReal" as
aImag_ :: ToSig s as => s -> UA "aImag" as

-- | SC compatibility
aimag_ :: ToSig s as => s -> UA "aImag" as
attackSecs_ :: ToSig s as => s -> UA "attackSecs" as

-- | Alias of <a>attackSecs_</a>, for SC compatibility
attackTime_ :: ToSig s as => s -> UA "attackSecs" as
b_ :: ToSig s as => s -> UA "b" as
b1_ :: ToSig s as => s -> UA "b1" as
b2_ :: ToSig s as => s -> UA "b2" as
bias_ :: ToSig s as => s -> UA "bias" as
bins_ :: ToSig s as => s -> UA "bins" as
bits_ :: ToSig s as => s -> UA "bits" as
buf_ :: ToSig s as => s -> UA "buf" as

-- | For SC compatibility -- alias of <a>buf_</a>
buffer_ :: ToSig s as => s -> UA "buf" as
bus_ :: ToSig s as => s -> UA "bus" as
bw_ :: ToSig s as => s -> UA "bw" as
bwFreq_ :: ToSig s as => s -> UA "bwFreq" as
bwr_ :: ToSig s as => s -> UA "bwr" as
c_ :: ToSig s as => s -> UA "c" as

-- | Alias of <a>numChans_</a>
chans_ :: ToSig s as => s -> UA "numChans" as
clampSecs_ :: ToSig s as => s -> UA "clampSecs" as

-- | Alias of <a>clampSecs_</a>, for SC compatibility
clampTime_ :: ToSig s as => s -> UA "clampSecs" as
clar_ :: ToSig s as => s -> UA "clar" as
coef_ :: ToSig s as => s -> UA "coef" as
control_ :: ToSig s as => s -> UA "control" as
crossFade_ :: ToSig s as => s -> UA "crossFade" as

-- | For SC compatibility -- alias of <a>crossFade_</a>
crossfade_ :: ToSig s as => s -> UA "crossFade" as

-- | <ul>
--   <li>*This may change in the future**</li>
--   </ul>
curve_curve :: Int -> UA "curve" as
damp_ :: ToSig s as => s -> UA "damp" as
db_ :: ToSig s as => s -> UA "db" as
decaySecs_ :: ToSig s as => s -> UA "decaySecs" as

-- | Alias of <a>decaySecs_</a> for SC compatibility
decayTime_ :: ToSig s as => s -> UA "decaySecs" as

-- | Alias of <a>decaySecs_</a> for SC compatibility
decaytime_ :: ToSig s as => s -> UA "decaySecs" as
default_ :: ToSig s as => s -> UA "default" as

-- | Alias of <a>delaySecs_</a> for SC compatibility
delay_ :: ToSig s as => s -> UA "delaySecs" as
delaySecs_ :: ToSig s as => s -> UA "delaySecs" as

-- | Alias of <a>delaySecs_</a> for SC compatibility
delayTime_ :: ToSig s as => s -> UA "delaySecs" as

-- | Alias of <a>delaySecs_</a> for SC compatibility
delaytime_ :: ToSig s as => s -> UA "delaySecs" as
density_ :: ToSig s as => s -> UA "density" as
depth_ :: ToSig s as => s -> UA "depth" as
depthVariation_ :: ToSig s as => s -> UA "depthVariation" as
div_ :: ToSig s as => s -> UA "div" as
dn_ :: ToSig s as => s -> UA "dn" as
doneAction_ :: ToSig s as => s -> UA "doneAction" as
downSample_ :: ToSig s as => s -> UA "downSample" as
dsthi_ :: ToSig s as => s -> UA "dsthi" as
dstlo_ :: ToSig s as => s -> UA "dstlo" as

-- | Alias of <a>duration_</a>
dur_ :: ToSig s as => s -> UA "duration" as
duration_ :: ToSig s as => s -> UA "duration" as
end_ :: ToSig s as => s -> UA "end" as
execFreq_ :: ToSig s as => s -> UA "execFreq" as

-- | Alias of <a>exponent_</a>
exp_ :: ToSig s as => s -> UA "exponent" as
exponent_ :: ToSig s as => s -> UA "exponent" as
fftSize_ :: ToSig s as => s -> UA "fftSize" as

-- | For SC compatibility -- alias of <a>fftSize_</a>
fftsize_ :: ToSig s as => s -> UA "fftSize" as
formFreq_ :: ToSig s as => s -> UA "formFreq" as
frames_ :: ToSig s as => s -> UA "numFrames" as
frameSize_ :: ToSig s as => s -> UA "frameSize" as

-- | For SC compatibility -- alias of <a>frameSize_</a>
framesize_ :: ToSig s as => s -> UA "frameSize" as
freeze_ :: ToSig s as => s -> UA "freeze" as
freq_ :: ToSig s as => s -> UA "freq" as
friction_ :: ToSig s as => s -> UA "friction" as
fundFreq_ :: ToSig s as => s -> UA "fundFreq" as
g_ :: ToSig s as => s -> UA "g" as
gain_ :: ToSig s as => s -> UA "gain" as
gate_ :: ToSig s as => s -> UA "gate" as
hi_ :: ToSig s as => s -> UA "hi" as
hop_ :: ToSig s as => s -> UA "hop" as
id_ :: ToSig s as => s -> UA "id" as
in_ :: ToSig s as => s -> UA "in" as
initFreq_ :: ToSig s as => s -> UA "initFreq" as
integrate_ :: ToSig s as => s -> UA "integrate" as

-- | Interpolation
interp_ :: ToSig s as => s -> UA "interp" as

-- | For SC compatibility -- alias of <a>interp_</a>
interpolation_ :: ToSig s as => s -> UA "interp" as
iphase_ :: ToSig s as => s -> UA "iphase" as
irBufNum_ :: ToSig s as => s -> UA "irBufNum" as

-- | For SC compatibility -- alias of <tt>irBufSize_</tt>
irbufnum_ :: ToSig s as => s -> UA "irBufNum" as
kernel_ :: ToSig s as => s -> UA "kernel" as

-- | Alias, for SC compatibility
lag_ :: ToSig s as => s -> UA "lagSecs" as
lagSecs_ :: ToSig s as => s -> UA "lagSecs" as

-- | For SC compatibility:
lagTime_ :: ToSig s as => s -> UA "lagSecs" as
length_ :: ToSig s as => s -> UA "length" as
level_ :: ToSig s as => s -> UA "level" as
lo_ :: ToSig s as => s -> UA "lo" as
loop_ :: ToSig s as => s -> UA "loop" as
m_ :: ToSig s as => s -> UA "m" as
max_ :: ToSig s as => s -> UA "max" as
maxBinsPerOctave_ :: ToSig s as => s -> UA "maxBinsPerOctave" as
maxDelaySecs_ :: ToSig s as => s -> UA "maxDelaySecs" as

-- | Alias of <a>maxDelaySecs_</a> for SC compatibility
maxDelayTime_ :: ToSig s as => s -> UA "maxDelaySecs" as

-- | Alias of <a>maxDelaySecs_</a> for SC compatibility
maxdelaytime_ :: ToSig s as => s -> UA "maxDelaySecs" as
maxFreq_ :: ToSig s as => s -> UA "maxFreq" as

-- | Alias of <a>max_</a>, for SC compatibility
maxVal_ :: ToSig s as => s -> UA "max" as
median_ :: ToSig s as => s -> UA "median" as
min_ :: ToSig s as => s -> UA "min" as
minFreq_ :: ToSig s as => s -> UA "minFreq" as
minmax_ :: ToSig s as => s -> UA "minmax" as

-- | Alias of <a>min_</a>, for SC compatibility
minVal_ :: ToSig s as => s -> UA "min" as
mix_ :: ToSig s as => s -> UA "mix" as
mul_ :: ToSig s as => s -> UA "mul" as
numChans_ :: ToSig s as => s -> UA "numChans" as
numFrames_ :: ToSig s as => s -> UA "numFrames" as
numTeeth_ :: ToSig s as => s -> UA "numTeeth" as
offset_ :: ToSig s as => s -> UA "offset" as
onset_ :: ToSig s as => s -> UA "onset" as
peakLevel_ :: ToSig s as => s -> UA "peakLevel" as
peakThreshold_ :: ToSig s as => s -> UA "peakThreshold" as
phase_ :: ToSig s as => s -> UA "phase" as
pitchDispersion_ :: ToSig s as => s -> UA "pitchDispersion" as
pos_ :: ToSig s as => s -> UA "pos" as
post_ :: ToSig s as => s -> UA "post" as
preLevel_ :: ToSig s as => s -> UA "preLevel" as
rate_ :: ToSig s as => s -> UA "rate" as
rateVariation_ :: ToSig s as => s -> UA "rateVariation" as
radius_ :: ToSig s as => s -> UA "radius" as
ratio_ :: ToSig s as => s -> UA "ratio" as
recLevel_ :: ToSig s as => s -> UA "recLevel" as
relaxSecs_ :: ToSig s as => s -> UA "relaxSecs" as

-- | Alias of <a>relaxSecs_</a> for SC compatibility
relaxTime_ :: ToSig s as => s -> UA "relaxSecs" as
releaseSecs_ :: ToSig s as => s -> UA "releaseSecs" as

-- | Alias of <a>releaseSecs_</a>, for SC compatibility
releaseTime_ :: ToSig s as => s -> UA "releaseSecs" as
repeats_ :: ToSig s as => s -> UA "repeats" as

-- | Shorter alias for <a>repeats_</a>
reps_ :: ToSig s as => s -> UA "repeats" as
reset_ :: ToSig s as => s -> UA "reset" as
resetPos_ :: ToSig s as => s -> UA "resetPos" as
room_ :: ToSig s as => s -> UA "room" as
root_ :: ToSig s as => s -> UA "root" as
rq_ :: ToSig s as => s -> UA "rq" as
rs_ :: ToSig s as => s -> UA "rs" as
run_ :: ToSig s as => s -> UA "run" as
sawFreq_ :: ToSig s as => s -> UA "sawFreq" as
secs_ :: ToSig s as => s -> UA "secs" as
shift_ :: ToSig s as => s -> UA "shift" as
slopeAbove_ :: ToSig s as => s -> UA "slopeAbove" as
slopeBelow_ :: ToSig s as => s -> UA "slopeBelow" as
spring_ :: ToSig s as => s -> UA "spring" as
srchi_ :: ToSig s as => s -> UA "srchi" as
srclo_ :: ToSig s as => s -> UA "srclo" as
startPos_ :: ToSig s as => s -> UA "startPos" as
start_ :: ToSig s as => s -> UA "start" as
step_ :: ToSig s as => s -> UA "step" as
stretch_ :: ToSig s as => s -> UA "stretch" as
susLevel_ :: ToSig s as => s -> UA "susLevel" as
syncFreq_ :: ToSig s as => s -> UA "syncFreq" as
threshold_ :: ToSig s as => s -> UA "threshold" as

-- | Alias for "threshold_"
thresh_ :: ToSig s as => s -> UA "threshold" as
timeDispersion_ :: ToSig s as => s -> UA "timeDispersion" as
trig_ :: ToSig s as => s -> UA "trigger" as

-- | You can use "trig_" instead
trigger_ :: ToSig s as => s -> UA "trigger" as
trigid_ :: ToSig s as => s -> UA "trigid" as

-- | Short alias for <a>ugen_</a>
ug_ :: ToSig s as => s -> UA "ugen" as
ugen_ :: ToSig s as => s -> UA "ugen" as
up_ :: ToSig s as => s -> UA "up" as
warp_ :: ToSig s as => s -> UA "warp" as
width_ :: ToSig s as => s -> UA "width" as
wipe_ :: (ToSig s as) => s -> UA "wipe" as

-- | Alias of <a>windowSize_</a>
winsize_ :: ToSig s as => s -> UA "windowSize" as
windowSize_ :: ToSig s as => s -> UA "windowSize" as
wintype_ :: ToSig s as => s -> UA "windowType" as
windowType_ :: ToSig s as => s -> UA "windowType" as
xi_ :: ToSig s as => s -> UA "xi" as
makeMakeUGen :: (GetSymbolVals (Vs tags), FromUA optional, FromUA userSupplied, SDBodyArgs optional ~ SDBodyArgs userSupplied, SDBodyArgs optional ~ args) => (UGen -> SDBody' args x) -> Int -> String -> CalculationRate -> Vs tags -> optional -> (userSupplied -> SDBody' args x)
makeMonoUGen :: (GetSymbolVals (Vs tags), FromUA optional, FromUA userSupplied, SDBodyArgs optional ~ SDBodyArgs userSupplied, SDBodyArgs optional ~ args) => String -> CalculationRate -> Vs tags -> optional -> (userSupplied -> SDBody' args Signal)
makeUGen :: (GetSymbolVals (Vs tags), FromUA optional, FromUA userSupplied, SDBodyArgs optional ~ SDBodyArgs userSupplied, SDBodyArgs optional ~ args) => String -> CalculationRate -> Vs tags -> optional -> (userSupplied -> SDBody' args Signal)
makePolyUGen :: (GetSymbolVals (Vs tags), FromUA optional, FromUA userSupplied, SDBodyArgs optional ~ SDBodyArgs userSupplied, SDBodyArgs optional ~ args) => Int -> String -> CalculationRate -> Vs tags -> optional -> (userSupplied -> SDBody' args [Signal])

module Vivid.UGens.Analysis

-- | "Implements the (optimized) formula:
--   
--   compensationFactor = (root / freq) ** exp
--   
--   Higher frequencies are normally perceived as louder, which AmpComp
--   compensates."
--   
--   "Note that for frequencies very much smaller than root the amplitudes
--   can become very high. In this case limit the freq with
--   freq.max(minval), or use AmpCompA."
--   
--   Computed at <a>AR</a>, <a>KR</a>, or <a>IR</a>
ampComp :: (Args '["freq", "root"] '["exponent"] a) => a -> SDBody a Signal

-- | "Higher frequencies are normally perceived as louder, which AmpCompA
--   compensates. Following the measurings by Fletcher and Munson, the ANSI
--   standard describes a function for loudness vs. frequency. Note that
--   this curve is only valid for standardized amplitude."
--   
--   _NOTE_ "Apart from freq, the values are not modulatable"
--   
--   "This is a better pitch follower than ZeroCrossing, but more costly of
--   CPU. For most purposes the default settings can be used and only in
--   needs to be supplied."
--   
--   "[This function] returns two values [...], a freq which is the pitch
--   estimate and hasFreq, which tells whether a pitch was found."
--   
--   Note -- as this returns a 2-tuple of <a>Signal</a>s -- that you may
--   need to be careful not to accidentally use functions from the Foldable
--   instance for (,) with the return value of <a>pitch</a>.
--   
--   "Some vowels are still problematic, for instance a wide open mouth
--   sound somewhere between a low pitched short <tt>a</tt> sound as in
--   <tt>sat</tt>, and long <tt>i</tt> sound as in <tt>fire</tt>, contains
--   enough overtone energy to confuse the algorithm."
--   
--   "None of these settings are time variable."
--   
--   Can only run at <a>KR</a>
pitch :: (Args '["in"] '["initFreq", "minFreq", "maxFreq", "execFreq", "maxBinsPerOctave", "median", "ampThreshold", "peakThreshold", "downSample", "clar"] a) => a -> SDBody a (Signal, Signal)

module Vivid.UGens.Buffer

-- | Defaults to <a>KR</a>. Can be <a>IR</a> too but be careful that the
--   buffer doesn't change if so!
bufChannels :: (Args '["buf"] '[] a) => a -> SDBody a Signal

-- | Defaults to <a>KR</a>. Can be <a>IR</a> too but be careful that the
--   buffer doesn't change if so!
bufDur :: (Args '["buf"] '[] a) => a -> SDBody a Signal

-- | Defaults to <a>KR</a>. Can be <a>IR</a> too but be careful that the
--   buffer doesn't change if so!
--   
--   Note you don't need to use "buf_" when you use this
bufFrames :: ToSig s as => s -> SDBody' as Signal

-- | Defaults to <a>KR</a>. Can be <a>IR</a> too but be careful that the
--   buffer doesn't change if so!
--   
--   Note you don't need to use "buf_" when you use this
bufRateScale :: ToSig s as => s -> SDBody' as Signal

-- | Defaults to <a>KR</a>. Can be <a>IR</a> too but be careful that the
--   buffer doesn't change if so!
--   
--   Note you don't need to use "buf_" when you use this
bufSampleRate :: ToSig s as => s -> SDBody' as Signal

-- | Defaults to <a>KR</a>. Can be <a>IR</a> too but be careful that the
--   buffer doesn't change if so!
--   
--   Note you don't need to use "buf_" when you use this
bufSamples :: ToSig s as => s -> SDBody' as Signal

-- | "phase" must be at audio rate (<a>AR</a>)
--   
--   "numChans" can't be set after the synth is created, and must be a
--   fixed integer
bufRd :: Args '["numChans", "buf", "phase"] '["loop", "interp"] a => a -> SDBody a [Signal]

-- | "phase" must be at audio rate (<a>AR</a>)
bufWr :: (Args '["in", "buf", "phase"] '["loop"] a) => a -> SDBody a Signal

-- | Add a single LocalBuf for FFT
--   
--   Can use <a>chans_</a> for "numChans" and <a>frames_</a> for
--   "Vivid.UGens.Args.numFrames"
localBuf :: Args '["numChans", "numFrames"] '[] a => a -> SDBody a Signal

-- | "phase" must be the output of <tt>delTapWr</tt> delTapRd :: (Args
--   '["buf", "phase", "delSecs"] '["interp"] a) =&gt; s -&gt; SDBody a
--   Signal
phasor :: (Args '[] '["trigger", "rate", "start", "end", "resetPos"] a) => a -> SDBody a Signal

-- | Unlike in SC, "doneAction\" defaults to 2
--   
--   Also, the default rate is the <a>bufRateScale</a> of the buffer
playBuf :: (Args '["buf"] '["rate", "trigger", "startPos", "loop", "doneAction"] a) => a -> SDBody a Signal

-- | Unlike in SC, "doneAction" defaults to 2 and "loop" defaults to 0
recordBuf :: (Args '["buf", "in"] '["offset", "recLevel", "preLevel", "run", "loop", "trigger", "doneAction"] a) => a -> SDBody a Signal

module Vivid.UGens.Conversion

-- | Convert an audio rate signal to a control rate signal
a2k :: ToSig s a => s -> SDBody' a Signal

-- | Convert a control rate signal to an audio rate signal
k2a :: ToSig s a => s -> SDBody' a Signal


-- | Most of these only run at audio rate (<a>AR</a>)
module Vivid.UGens.Convolution
convolution :: (Args '["in", "kernel"] '["frameSize"] a) => a -> SDBody a Signal
convolution2 :: (Args '["in", "kernel"] '["trigger", "frameSize"] a) => a -> SDBody a Signal
convolution2L :: (Args '["in", "kernel"] '["trigger", "frameSize", "crossFade"] a) => a -> SDBody a Signal

-- | This one can run at control rate (<a>KR</a>). It's inefficient so only
--   useful for very small kernels or control rate.
convolution3 :: (Args '["in", "kernel"] '["trigger", "frameSize"] a) => a -> SDBody a Signal
partConv :: (Args '["in", "fftSize", "irBufNum"] '[] a) => a -> SDBody a Signal

module Vivid.UGens.Delays
allpassC :: (Args '["in"] ["maxDelaySecs", "delaySecs", "decaySecs"] a) => a -> SDBody a Signal
allpassL :: (Args '["in"] ["maxDelaySecs", "delaySecs", "decaySecs"] a) => a -> SDBody a Signal
allpassN :: (Args '["in"] ["maxDelaySecs", "delaySecs", "decaySecs"] a) => a -> SDBody a Signal
combC :: (Args '["in"] ["maxDelaySecs", "delaySecs", "decaySecs"] a) => a -> SDBody a Signal
combL :: (Args '["in"] ["maxDelaySecs", "delaySecs", "decaySecs"] a) => a -> SDBody a Signal
combN :: (Args '["in"] ["maxDelaySecs", "delaySecs", "decaySecs"] a) => a -> SDBody a Signal
delay1 :: (Args '["in"] '[] a) => a -> SDBody a Signal
delay2 :: (Args '["in"] '[] a) => a -> SDBody a Signal
delayC :: (Args '["in"] '["maxDelaySecs", "delaySecs"] a) => a -> SDBody a Signal
delayL :: (Args '["in"] '["maxDelaySecs", "delaySecs"] a) => a -> SDBody a Signal
delayN :: (Args '["in"] '["maxDelaySecs", "delaySecs"] a) => a -> SDBody a Signal
pluck :: Args '[] '["in", "trigger", "maxDelaySecs", "delaySecs", "decaySecs", "coef"] a => a -> SDBody a Signal

module Vivid.UGens.Demand

-- | This correctly decodes/encodes to OSC:
inf :: Float

-- | "Dbrown returns numbers in the continuous range between lo and hi ,
--   Dibrown returns integer values."
--   
--   "The arguments can be a number or any other UGen."
--   
--   "See Pbrown, BrownNoise for structurally related equivalents."
dbrown :: Args '[] '["lo", "hi", "step", "length"] a => a -> SDBody a Signal

-- | Defaults to <a>KR</a>
demand :: Args '["trigger", "reset", "ugen"] '[] a => a -> SDBody a Signal
dibrown :: Args '[] '["lo", "hi", "step", "length"] a => a -> SDBody a Signal
diwhite :: Args '[] '["lo", "hi", "length"] a => a -> SDBody a Signal

-- | "<a>dxrand</a> never plays the same value twice, whereas drand chooses
--   any value in the list"
drand :: (Args '[] '["repeats"] a, ToSig s (SDBodyArgs a)) => a -> [s] -> SDBody a Signal

-- | The list come second so you can curry the repeats and use
--   <a>=&lt;&lt;</a> or <a>&gt;&gt;=</a>
dseq :: (Args '[] '["repeats"] a, ToSig s (SDBodyArgs a)) => a -> [s] -> SDBody a Signal
dser :: (Args '[] '["repeats"] a, ToSig s (SDBodyArgs a)) => a -> [s] -> SDBody a Signal
dshuf :: (Args '[] '["repeats"] a, ToSig s (SDBodyArgs a)) => a -> [s] -> SDBody a Signal
dwhite :: Args '[] '["lo", "hi", "length"] a => a -> SDBody a Signal

-- | "dxrand never plays the same value twice, whereas <a>drand</a> chooses
--   any value in the list"
dxrand :: (Args '[] '["repeats"] a, ToSig s (SDBodyArgs a)) => a -> [s] -> SDBody a Signal

module Vivid.UGens.Dynamics
compander :: (Args '["in"] '["control", "threshold", "slopeBelow", "slopeAbove", "clampSecs", "relaxSecs"] a) => a -> SDBody a Signal

-- | Note this can only run at <a>AR</a>
--   
--   "secs" is the lookahead time -- if you're coming from SC you can use
--   <a>dur_</a> for consistency
limiter :: (Args '["in"] '["level", "secs"] a) => a -> SDBody a Signal

-- | Note this can only run at <a>AR</a>
--   
--   "secs" is the lookahead time -- if you're coming from SC you can use
--   <a>dur_</a>
normalizer :: (Args '["in"] '["level", "secs"] a) => a -> SDBody a Signal


-- | <ul>
--   <li>*Note:** The argument format for these is a little rough, and is
--   likely to change in the future</li>
--   </ul>
module Vivid.UGens.Envelopes

-- | Defaults to <a>AR</a>
adsrGen :: (Args '[] '["peakLevel", "bias", "gate", "doneAction"] as, ToSig attackTime (SDBodyArgs as), ToSig decayTime (SDBodyArgs as), ToSig sustainLevel (SDBodyArgs as), ToSig releaseTime (SDBodyArgs as)) => attackTime -> decayTime -> sustainLevel -> releaseTime -> EnvCurve -> as -> SDBody as Signal
envGate :: Subset '["gate", "fadeSecs"] a => SDBody' a Signal

-- | Defaults to <a>AR</a>
envGen :: EnvLiterally a -> DoneAction -> SDBody' a Signal
envGen_wGate :: (ToSig gate a, ToSig timeScale a) => gate -> timeScale -> EnvLiterally a -> DoneAction -> SDBody' a Signal

-- | "Generates a line from the start value to the end value."
--   
--   Note this won't change after it's created, so if you'd like to e.g. be
--   able to change the "freq" in
--   
--   <pre>
--   line (start_ 0, end_ (V::V "freq"))
--   </pre>
--   
--   you should write
--   
--   <pre>
--   (V::V "freq") ~* line (start_ 0, end_ 1)
--   </pre>
--   
--   instead.
--   
--   Defaults to KR
line :: (Args '[] '["start", "end", "duration", "doneAction"] a) => a -> SDBody a Signal

-- | "Simple linear envelope generator"
--   
--   Can't change after it's created -- see the note about <a>line</a> if
--   you want it to
--   
--   Only computes at <a>KR</a>
linen :: (Args '[] '["gate", "attackSecs", "susLevel", "releaseSecs", "doneAction"] a) => a -> SDBody a Signal

-- | Percussive hit
--   
--   <tt>doneAction</tt> is currently 2 but may either be 0 or 2 in future
--   versions
percGen :: (Args '[] '["attackSecs", "releaseSecs", "level", "curve", "doneAction"] a) => a -> SDBody a Signal

-- | "Generates an exponential curve from the start value to the end value.
--   Both the start and end values must be non-zero and have the same
--   sign."
--   
--   Defaults to KR
xLine :: (Args '[] '["start", "end", "duration", "doneAction"] a) => a -> SDBody a Signal

module Vivid.UGens.FFT

-- | You can use "wintype_" and "winsize_" if you're used to the SC args:
fft :: (Args '["buf"] '["in", "hop", "windowType", "active", "windowSize"] a) => a -> SDBody a Signal

-- | You can use "wintype_" and "winsize_" if you're used to the SC args:
ifft :: (Args '["buf"] '["windowType", "windowSize"] a) => a -> SDBody a Signal
pv_binScramble :: (Args '["buf"] '["wipe", "width", "trigger"] a) => a -> SDBody a Signal
pv_binShift :: (Args '["buf"] '["stretch", "shift", "interp"] a) => a -> SDBody a Signal
pv_brickWall :: (Args '["buf"] '["wipe"] a) => a -> SDBody a Signal
pv_conformalMap :: (Args '["buf"] '["aReal", "aImag"] a) => a -> SDBody a Signal
pv_conj :: (Args '["buf"] '[] a) => a -> SDBody a Signal
pv_diffuser :: (Args '["buf"] '["trigger"] a) => a -> SDBody a Signal
pv_localMax :: (Args '["buf"] '["threshold"] a) => a -> SDBody a Signal
pv_magAbove :: (Args '["buf", "threshold"] '[] a) => a -> SDBody a Signal
pv_magBelow :: (Args '["buf", "threshold"] '[] a) => a -> SDBody a Signal
pv_magClip :: (Args '["buf", "threshold"] '[] a) => a -> SDBody a Signal
pv_magFreeze :: (Args '["buf"] '["freeze"] a) => a -> SDBody a Signal
pv_magNoise :: (Args '["buf"] '[] a) => a -> SDBody a Signal
pv_magShift :: (Args '["buf"] '["stretch", "shift"] a) => a -> SDBody a Signal

-- | "As [the number of bins] rises, so will CPU usage."
pv_magSmear :: (Args '["buf"] '["bins"] a) => a -> SDBody a Signal
pv_magSquared :: (Args '["buf"] '[] a) => a -> SDBody a Signal
pv_phaseShift :: (Args '["buf", "shift"] '["integrate"] a) => a -> SDBody a Signal
pv_phaseShift270 :: (Args '["buf"] '[] a) => a -> SDBody a Signal
pv_phaseShift90 :: (Args '["buf"] '[] a) => a -> SDBody a Signal
pv_randComb :: (Args '["buf"] '["wipe", "trigger"] a) => a -> SDBody a Signal

-- | "Alternates blocks of bins between the two inputs."
pv_rectComb :: (Args '["buf"] '["numTeeth", "phase", "width"] a) => a -> SDBody a Signal

module Vivid.UGens.Filters.Linear
apf :: (Args '["in"] '["freq", "radius"] a) => a -> SDBody a Signal

-- | Band-pass filter
--   
--   Rq: bandwidth / cutofffreq
bpf :: (Args '["in"] '["freq", "rq"] a) => a -> SDBody a Signal
bpz2 :: (Args '["in"] '[] a) => a -> SDBody a Signal
brf :: (Args '["in"] '["freq", "rq"] a) => a -> SDBody a Signal
brz2 :: (Args '["in"] '[] a) => a -> SDBody a Signal
decay :: (Args '["in"] '["decaySecs"] a) => a -> SDBody a Signal
decay2 :: (Args '["in"] '["attackSecs", "decaySecs"] a) => a -> SDBody a Signal
fos :: (Args '["in"] '["a0", "a1", "b1"] a) => a -> SDBody a Signal
formlet :: (Args '["in"] '["freq", "attackSecs", "decaySecs"] a) => a -> SDBody a Signal

-- | High-pass filter
hpf :: (Args '["in"] '["freq"] a) => a -> SDBody a Signal
hpz1 :: (Args '["in"] '[] a) => a -> SDBody a Signal
hpz2 :: Args '["in"] '[] a => a -> SDBody a Signal
integrator :: Args '["in"] '["coef"] a => a -> SDBody a Signal

-- | "Klank is a bank of fixed frequency resonators which can be used to
--   simulate the resonant modes of an object. Each mode is given a ring
--   time, which is the time for the mode to decay by 60 dB"
--   
--   The <a>in_</a> argument is "the excitation input to the resonant
--   filter bank"
--   
--   Each tuple in the list argument is a triple of frequency, amplitude,
--   and ring time
--   
--   Can only run in <a>AR</a>
klank :: Args '["in"] '[] a => a -> [(Float, Float, Float)] -> SDBody a Signal

-- | The "lagSecs" arg is the same as the "lagTime" arg in SC (you can use
--   <a>lagTime_</a> if you like)
--   
--   The calculation rate of this is whatever its "in" is (cool, right?)
lag :: Args '["in"] '["lagSecs"] a => a -> SDBody a Signal

-- | 'lag2 (in_ x)' is equal to 'lag (in_ (lag (in_ x)))'
--   
--   The calculation rate of this is whatever its "in" is
lag2 :: (Args '["in"] '["lagSecs"] a) => a -> SDBody a Signal

-- | 'lag3 (in_ x)' is equal to 'lag (in_ $ lag (in_ $ lag (in_ x)))'
--   
--   The calculation rate of this is whatever its "in" is
lag3 :: (Args '["in"] '["lagSecs"] a) => a -> SDBody a Signal

-- | Note the default for both AR and KR are the same: 0.995. In SC lang,
--   the KR one defaults to 0.9.
leakDC :: (Args '["in"] '["coef"] a) => a -> SDBody a Signal

-- | Low-pass filter
lpf :: (Args '["in"] '["freq"] a) => a -> SDBody a Signal
lpz1 :: (Args '["in"] '[] a) => a -> SDBody a Signal
lpz2 :: (Args '["in"] '[] a) => a -> SDBody a Signal

-- | <tt>Db</tt> is the boost or attenuation of the signal in decibels
midEQ :: (Args '["in", "freq", "db"] '["rq"] a) => a -> SDBody a Signal
onePole :: (Args '["in"] '["coef"] a) => a -> SDBody a Signal
oneZero :: (Args '["in"] '["coef"] a) => a -> SDBody a Signal
rhpf :: (Args '["in"] '["freq", "rq"] a) => a -> SDBody a Signal
rlpf :: (Args '["in"] '["freq", "rq"] a) => a -> SDBody a Signal
ramp :: (Args '["in"] '["lagSecs"] a) => a -> SDBody a Signal
resonz :: (Args '["in"] '["freq", "bwr"] a) => a -> SDBody a Signal
ringz :: (Args '["in"] '["freq", "decaySecs"] a) => a -> SDBody a Signal
sos :: (Args '["in"] '["a0", "a1", "a2", "b1", "b2"] a) => a -> SDBody a Signal
slope :: (Args '["in"] '[] a) => a -> SDBody a Signal
twoPole :: (Args '["in"] '["freq", "radius"] a) => a -> SDBody a Signal
twoZero :: (Args '["in"] '["freq", "radius"] a) => a -> SDBody a Signal

module Vivid.UGens.Filters.Nonlinear
ball :: (Args '["in"] '["g", "damp", "friction"] a) => a -> SDBody a Signal
hasher :: (Args '["in"] '[] a) => a -> SDBody a Signal
mantissaMask :: (Args '["in"] '["bits"] a) => a -> SDBody a Signal
median :: (Args '["in"] '["length"] a) => a -> SDBody a Signal
slew :: (Args '["in"] '["up", "dn"] a) => a -> SDBody a Signal
spring :: (Args '["in"] '["spring", "damp"] a) => a -> SDBody a Signal
tBall :: (Args '["in"] '["g", "damp", "friction"] a) => a -> SDBody a Signal

module Vivid.UGens.Filters.Pitch

-- | "Moves all the components of a signal by a fixed amount but does not
--   preserve the original harmonic relationships." You might want
--   <a>pitchShift</a> instead.
freqShift :: (Args '["in"] '["freq", "phase"] a) => a -> SDBody a Signal
pitchShift :: (Args '["in", "ratio"] '["windowSize", "pitchDispersion", "timeDispersion"] a) => a -> SDBody a Signal
vibrato :: (Args '[] '["freq", "rate", "depth", "delaySecs", "onset", "rateVariation", "depthVariation", "iphase"] a) => a -> SDBody a Signal

module Vivid.UGens.Generators.Chaotic

-- | "A linear-interpolating sound generator based on the difference
--   equation:
--   
--   x[n+1] = a - b * sqrt(abs(x[n]))"
--   
--   Only has an AR instance
cuspL :: (Args '[] '["freq", "a", "b", "xi"] a) => a -> SDBody a Signal

-- | "A non-interpolating sound generator based on the difference equation:
--   
--   x[n+1] = a - b * sqrt(abs(x[n]))"
--   
--   Only has an AR instance.
cuspN :: (Args '[] '["freq", "a", "b", "xi"] a) => a -> SDBody a Signal

-- | "A cubic-interpolating sound generator based on the difference
--   equation:
--   
--   x[n+1] = (a * x[n] + c) % m
--   
--   The output signal is automatically scaled to a range of [-1, 1]."
--   
--   Only has a <a>AR</a> method
linCongC :: (Args '[] '["freq", "a", "c", "m", "xi"] a) => a -> SDBody a Signal

-- | "A linear-interpolating sound generator based on the difference
--   equation:
--   
--   x[n+1] = (a * x[n] + c) % m
--   
--   The output signal is automatically scaled to a range of [-1, 1]."
--   
--   Only has a <a>AR</a> method
linCongL :: (Args '[] '["freq", "a", "c", "m", "xi"] a) => a -> SDBody a Signal

-- | "A non-interpolating sound generator based on the difference equation:
--   
--   x[n+1] = (a * x[n] + c) % m
--   
--   The output signal is automatically scaled to a range of [-1, 1]."
--   
--   Only has a <a>AR</a> method
linCongN :: (Args '[] '["freq", "a", "c", "m", "xi"] a) => a -> SDBody a Signal

module Vivid.UGens.Generators.Deterministic
fSinOsc :: (Args '["freq"] '["phase"] a) => a -> SDBody a Signal

-- | Only runs at audio rate. All arguments must be at control rate or
--   constant. "bwFreq" must be greater than or equal to "fundFreq".
formant :: Args '["fundFreq", "formFreq", "bwFreq"] '[] a => a -> SDBody a Signal
impulse :: (Args '["freq"] '["phase"] a) => a -> SDBody a Signal
lfCub :: (Args '["freq"] '["iphase"] a) => a -> SDBody a Signal
lfGauss :: (Args '[] '["duration", "width", "iphase", "loop", "doneAction"] a) => a -> SDBody a Signal
lfPar :: (Args '["freq"] '["iphase"] a) => a -> SDBody a Signal
lfPulse :: (Args '["freq"] '["iphase", "width"] a) => a -> SDBody a Signal

-- | "A non-band-limited sawtooth oscillator. Output ranges from -1 to +1."
lfSaw :: (Args '["freq"] '["iphase"] a) => a -> SDBody a Signal

-- | "A non-band-limited triangle oscillator. Output ranges from -1 to +1."
lfTri :: (Args '["freq"] '["iphase"] a) => a -> SDBody a Signal
pulse :: (Args '["freq"] '["width"] a) => a -> SDBody a Signal
saw :: (Args '["freq"] '[] a) => a -> SDBody a Signal

-- | Sine wave
sinOsc :: (Args '["freq"] '["phase"] a) => a -> SDBody a Signal
syncSaw :: (Args '["syncFreq", "sawFreq"] '[] a) => a -> SDBody a Signal

-- | Width is "duty cycle from 0 to 1"
varSaw :: (Args '["freq"] '["iphase", "width"] a) => a -> SDBody a Signal

module Vivid.UGens.Generators.Granular

module Vivid.UGens.Generators.SingleValue

-- | "This UGen simply outputs the initial value you give it"
dc :: Float -> SDBody' a Signal

module Vivid.UGens.Generators.Stochastic

-- | "Generates noise whose spectrum falls off in power by 6 dB per
--   octave."
brownNoise :: SDBody' a Signal

-- | "Generates noise whose values are either -1 or 1. This produces the
--   maximum energy for the least peak to peak amplitude."
clipNoise :: SDBody' a Signal

-- | "Generates random impulses from -1 to +1."
dust :: (Args '["density"] '[] a) => a -> SDBody a Signal

-- | "Generates random impulses from -1 to +1."
dust2 :: (Args '["density"] '[] a) => a -> SDBody a Signal

-- | "Generates noise which results from flipping random bits in a word.
--   This type of noise has a high RMS level relative to its peak to peak
--   level. The spectrum is emphasized towards lower frequencies."
grayNoise :: SDBody' a Signal

-- | E.g.
--   
--   <pre>
--   play $ 0.1 ~* lfClipNoise (freq_ $ xLine (start_ 1e3, end_ 1e4, secs_ 10))
--   </pre>
lfClipNoise :: (Args '[] '["freq"] a) => a -> SDBody a Signal

-- | "Like LFClipNoise, it generates the values -1 or +1 at a rate given by
--   the freq argument, with two differences: " - no time quantization " -
--   fast recovery from low freq values " If you don't need very high or
--   very low freqs, or use fixed freqs, LFDClipNoise is more efficient."
lfdClipNoise :: (Args '[] '["freq"] a) => a -> SDBody a Signal
lfdNoise0 :: (Args '[] '["freq"] a) => a -> SDBody a Signal
lfdNoise1 :: (Args '[] '["freq"] a) => a -> SDBody a Signal
lfdNoise3 :: (Args '[] '["freq"] a) => a -> SDBody a Signal

-- | Freq is "approximate rate at which to generate random values"
lfNoise0 :: (Args '[] '["freq"] a) => a -> SDBody a Signal

-- | Freq is "approximate rate at which to generate random values"
lfNoise1 :: (Args '[] '["freq"] a) => a -> SDBody a Signal

-- | Freq is "approximate rate at which to generate random values"
lfNoise2 :: (Args '[] '["freq"] a) => a -> SDBody a Signal

-- | "Generates noise whose spectrum falls off in power by 3 dB per octave.
--   This gives equal power over the span of each octave. This version
--   gives 8 octaves of pink noise."
pinkNoise :: SDBody' a Signal

-- | "Generates noise whose spectrum has equal power at all frequencies."
whiteNoise :: SDBody' a Signal

module Vivid.UGens.InOut

-- | <tt>buf</tt> is a temporary buffer to accumulate before writing.
--   
--   "NOTE: The Buffer's numFrames must be a power of two and is
--   recommended to be at least 65536 -- preferably 131072 or 262144.
--   Smaller buffer sizes mean more frequent disk access, which can cause
--   glitches."
--   
--   65536 == 2 ^ 16 131072 == 2 ^ 17 262144 == 2 ^ 18
--   
--   For ease of use with <a>sd</a> this has output type "[Signal]", but
--   the list is always empty
diskOut :: ToSig s a => BufferId -> [s] -> SDBody' a [Signal]
aIn :: Args '["bus"] '[] a => a -> SDBody a Signal
kIn :: Args '["bus"] '[] a => a -> SDBody a Signal
localIn :: Int -> SDBody' a [Signal]
localOut :: ToSig s as => [s] -> SDBody' as ()
out :: (ToSig i a, ToSig busNum a) => busNum -> [i] -> SDBody' a [Signal]
out' :: (Elem "out" a, ToSig i a) => [i] -> SDBody' a [Signal]
aOut :: (ToSig i a, ToSig busNum a) => busNum -> [i] -> SDBody' a [Signal]
replaceOut :: (ToSig i a, ToSig busNum a) => busNum -> [i] -> SDBody' a [Signal]

-- | Audio bus input (usually mic)
soundIn :: Args '["bus"] '[] a => a -> SDBody a Signal


-- | Actions. <a>VividAction</a> has 3 instances:
--   
--   <ul>
--   <li><a>Vivid.Actions.IO</a> : happens right here, right now</li>
--   <li><a>Vivid.Actions.Scheduled</a> : happens at some point in the
--   (maybe near) future. The timing is precise, unlike IO</li>
--   <li><a>Vivid.Actions.NRT</a> : non-realtime. Writes to an audio
--   file</li>
--   </ul>
module Vivid.Actions

-- | Create a real live music-playing synth from a boring, dead SynthDef.
--   
--   If you haven't defined the SynthDef on the server, this will do it
--   automatically (Note that this may cause jitters in musical timing)
--   
--   Given...
--   
--   <pre>
--   &gt;&gt;&gt; let foo = sd () $ out 0 [0.1 ~* whiteNoise]
--   </pre>
--   
--   ...you can create a synth with...
--   
--   <pre>
--   &gt;&gt;&gt; synth foo ()
--   </pre>
--   
--   Careful!: The SC server doesn't keep track of your nodes for you, so
--   if you do something like...
--   
--   <pre>
--   &gt;&gt;&gt; s &lt;- synth someSynth ()
--   
--   &gt;&gt;&gt; s &lt;- synth oops ()           -- 's' is overwritten
--   </pre>
--   
--   ...you've got no way to refer to the first synth you've created, and
--   if you want to stop it you have to <tt>cmdPeriod</tt>
--   
--   (If you want to interop with SC's language (or other SC clients), use
--   <tt>sdNamed</tt> and <a>synthNamed</a>)
synth :: (VividAction m, VarList params, Subset (InnerVars params) args) => SynthDef args -> params -> m (Synth args)

-- | Make a synth, "G"radually typed -- doesn't check that _ is a subset of
--   _ Useful e.g. if you want to send a bunch of args, some of which may
--   be discarded
--   
--   (Personally I'd recommend not using this function)
--   
--   <pre>
--   &gt;&gt;&gt; let s = undefined :: SynthDef '["ok"]
--   
--   &gt;&gt;&gt; synth s (4::I "ok", 5::I "throwaway")
--   
--   &gt;&gt;&gt; &lt;interactive&gt;:
--   
--   &gt;&gt;&gt; Could not deduce (Elem "ignore" '[]) arising from a use of ‘synth’
--   
--   &gt;&gt;&gt; synthG s (4::I "ok", 5::I "throwaway")
--   
--   &gt;&gt;&gt; (works)
--   </pre>
synthG :: (VividAction m, VarList params) => SynthDef a -> params -> m NodeId
synthNamed :: (VividAction m, VarList params) => String -> params -> m (Synth a)
synthNamedG :: (VividAction m, VarList params) => String -> params -> m NodeId

-- | Create a synth just before the target node (see "Order of Execution")
newSynthBefore :: (VividAction m, VarList params, Subset (InnerVars params) args, IsNode node) => node -> SynthDef args -> params -> m (Synth args)

-- | Alias for <a>newSynthBefore</a>
--   
--   Create a synth just before the target node (see "Order of Execution")
synthBefore :: (VividAction m, VarList params, Subset (InnerVars params) args, IsNode node) => node -> SynthDef args -> params -> m (Synth args)

-- | Create a synth just after the target node (see "Order of Execution")
--   
--   Create a synth just before the target node (see "Order of Execution")
newSynthAfter :: (VividAction m, VarList params, Subset (InnerVars params) args, IsNode node) => node -> SynthDef args -> params -> m (Synth args)

-- | Alias for <a>newSynthAfter</a>
--   
--   Create a synth just before the target node (see "Order of Execution")
synthAfter :: (VividAction m, VarList params, Subset (InnerVars params) args, IsNode node) => node -> SynthDef args -> params -> m (Synth args)

-- | Create a synth at the head of the target group (see "Order of
--   Execution")
newSynthAtHead :: (VividAction m, VarList params, Subset (InnerVars params) args, IsGroup group) => group -> SynthDef args -> params -> m (Synth args)

-- | Alias for <a>newSynthAtHead</a>
--   
--   Create a synth at the head of the target group (see "Order of
--   Execution")
synthHead :: (VividAction m, VarList params, Subset (InnerVars params) args, IsGroup group) => group -> SynthDef args -> params -> m (Synth args)

-- | Alias for <a>newSynthAtHead</a>
--   
--   Create a synth at the head of the target group (see "Order of
--   Execution")
synthOn :: (VividAction m, VarList params, Subset (InnerVars params) args, IsGroup group) => group -> SynthDef args -> params -> m (Synth args)

-- | Create a synth at the tail of the target group (see "Order of
--   Execution")
--   
--   Create a synth at the head of the target group (see "Order of
--   Execution")
newSynthAtTail :: (VividAction m, VarList params, Subset (InnerVars params) args, IsGroup group) => group -> SynthDef args -> params -> m (Synth args)

-- | Alias for <a>newSynthAtTail</a>
--   
--   Create a synth at the head of the target group (see "Order of
--   Execution")
synthTail :: (VividAction m, VarList params, Subset (InnerVars params) args, IsGroup group) => group -> SynthDef args -> params -> m (Synth args)
newGroup :: VividAction m => m Group
newGroupBefore :: (IsNode node, VividAction m) => node -> m Group
newGroupAfter :: (IsNode node, VividAction m) => node -> m Group
newGroupAtHead :: (IsGroup group, VividAction m) => group -> m Group
newGroupAtTail :: (IsGroup group, VividAction m) => group -> m Group
newParGroup :: VividAction m => m ParGroup
newParGroupBefore :: (IsNode node, VividAction m) => node -> m ParGroup
newParGroupAfter :: (IsNode node, VividAction m) => node -> m ParGroup
newParGroupAtHead :: (IsGroup group, VividAction m) => group -> m ParGroup
newParGroupAtTail :: (IsGroup group, VividAction m) => group -> m ParGroup

-- | Set the given parameters of a running synth
--   
--   e.g.
--   
--   <pre>
--   &gt;&gt;&gt; let setTest = sd (0.05 ::I "pan") $ out 0 =&lt;&lt; pan2 (in_ $ 0.1 ~* whiteNoise, pos_ (A::A "pan"))
--   
--   &gt;&gt;&gt; s &lt;- synth setTest ()
--   
--   &gt;&gt;&gt; set s (-0.05 ::I "pan")
--   </pre>
--   
--   Any parameters not referred to will be unaffected, and any you specify
--   that don't exist will be (silently) ignored
set :: (VividAction m, Subset (InnerVars params) sdArgs, VarList params) => Synth sdArgs -> params -> m ()

-- | Given a UGen graph, just start playing it right away.
--   
--   e.g.
--   
--   <pre>
--   play $ do
--      s &lt;- 0.2 ~* lpf (in_ whiteNoise, freq_ 440)
--      out 0 [s, s]
--   </pre>
--   
--   The "out" is optional, too -- so you can write
--   
--   <pre>
--   play $ 0.2 ~* lpf (in_ whiteNoise, freq_ 440)
--   </pre>
--   
--   and an "out" will be added, in stereo
play :: (VividAction m, MonoOrPoly s) => SDBody' '[] s -> m (Synth '[])

-- | Shorter name for <a>freeSynth</a>
free :: VividAction m => Synth a -> m ()

-- | Immediately stop a synth playing
--   
--   This can create a "clipping" artifact if the sound goes from a high
--   amplitude to 0 in an instant -- you can avoid that with e.g.
--   <a>lag</a> or with an envelope (especially <tt>envGate</tt>)
freeSynth :: VividAction m => Synth a -> m ()

-- | Assuming your "gate" argument is on an EnvGen or similar, will release
--   the synth over the EnvGen-specified fade time
--   
--   If you'd like to specify a fade time in the moment, check out
--   <a>releaseIn</a>
release :: (Elem "gate" args, VividAction m) => Synth args -> m ()

-- | Assumes your "gate" is on an EnvGen or related
--   
--   Specify a fade time and release
releaseIn :: (Elem "gate" args, VividAction m, Real n) => n -> Synth args -> m ()

-- | Synchronous
freeBuf :: VividAction m => BufferId -> m ()

-- | Stop the SuperCollider server
quitSCServer :: IO ()
makeSynth :: (VividAction m, VarList params, IsNode node) => ByteString -> params -> AddAction -> node -> m NodeId
instance Vivid.Actions.MonoOrPoly [Vivid.SynthDef.Types.Signal]
instance Vivid.Actions.MonoOrPoly Vivid.SynthDef.Types.Signal

module Vivid.UGens.Info
checkBadValues :: (Args '["in"] '["id", "post"] a) => a -> SDBody a Signal

-- | The (current) duration of a control block on the server in seconds
--   
--   Equal to <tt>1 ~/ controlRate</tt>
controlDur :: SDBody' a Signal

-- | The current control rate of the server
--   
--   Equal to <tt>1 ~/ controlDur</tt>
controlRate :: SDBody' a Signal

-- | The number of audio buses
numAudioBuses :: SDBody' a Signal

-- | The number of open buffers
numBuffers :: SDBody' a Signal
numControlBuses :: SDBody' a Signal
numInputBuses :: SDBody' a Signal
numOutputBuses :: SDBody' a Signal
numRunningSynths :: SDBody' a Signal
poll :: Float -> String -> SDBody' a Signal -> SDBody' a Signal
radiansPerSample :: SDBody' a Signal
sampleDur :: SDBody' a Signal
sampleRate :: SDBody' a Signal
subsampleOffset :: SDBody' a Signal


-- | These UGens only run at audio rate (<a>AR</a>)
--   
--   They also can cause CPU spikes when their parameters are changed!
module Vivid.UGens.Filters.BEQSuite
bAllpass :: (Args '["in"] '["freq", "rq"] a) => a -> SDBody a Signal

-- | Band-pass filter
bBandPass :: (Args '["in"] '["freq", "bw"] a) => a -> SDBody a Signal
bBandStop :: (Args '["in"] '["freq", "bw"] a) => a -> SDBody a Signal

-- | This is only in AR
bHiPass :: (Args '["in"] '["freq", "rq"] a) => a -> SDBody a Signal
bHiShelf :: (Args '["in"] '["freq", "rs", "db"] a) => a -> SDBody a Signal
bLowPass :: (Args '["in"] '["freq", "rq"] a) => a -> SDBody a Signal
bLowPass4 :: (Args '["in"] '["freq", "rq"] a) => a -> SDBody a Signal
bLowShelf :: (Args '["in"] '["freq", "rs", "db"] a) => a -> SDBody a Signal
bPeakEQ :: (Args '["in"] '["freq", "rq", "db"] a) => a -> SDBody a Signal

module Vivid.UGens.Filters
moogFF :: (Args '["in"] '["freq", "gain", "reset"] a) => a -> SDBody a Signal

module Vivid.UGens.Maths

-- | <ul>
--   <li>*Note this has different behavior than 0.1!** "lo" is not implied
--   by "hi".</li>
--   </ul>
--   
--   If you know you always want "lo" to be negative "hi" (like -1 to 1)
--   you can use <tt><tt>biOp</tt> <a>Clip2</a></tt>
clip :: (Args '["in"] '["lo", "hi"] a) => a -> SDBody a Signal

-- | Returns 1.0 if "in" is between "lo" and "hi" (including equalling "lo"
--   or "hi"). Else 0.0.
--   
--   Can be audio rate (AR), control rate (KR), or fixed (IR)
--   
--   Lo and hi default to 0 and 1
inRange :: (Args '["in"] '["lo", "hi"] a) => a -> SDBody a Signal

-- | Returns the value of whichever of the 2 signals is changing least
--   
--   Its default calculation rate is the highest of its 2 inputs
leastChange :: (ToSig s0 as, ToSig s1 as) => s0 -> s1 -> SDBody' as Signal

-- | "Converts a linear range of values to an exponential range of values."
--   
--   Args:
--   
--   <ul>
--   <li>*in* - The input signal to convert.</li>
--   <li>*srclo* - Lower limit of input range.</li>
--   <li>*srchi* - Upper limit of input range.</li>
--   <li>*dstlo* - Lower limit of output range.</li>
--   <li>*dsthi* - Upper limit of output range.</li>
--   <li>*"The dstlo and dsthi arguments must be nonzero and have the same
--   sign."**</li>
--   </ul>
--   
--   This will have the same calculation rate as its "in" argument
linExp :: Args '["in"] '["srclo", "srchi", "dstlo", "dsthi"] a => a -> SDBody a Signal

-- | Opposite of <a>leastChange</a>
mostChange :: (ToSig s0 as, ToSig s1 as) => s0 -> s1 -> SDBody' as Signal
mulAdd :: (Args '["in"] '["mul", "add"] a) => a -> SDBody a Signal

module Vivid.UGens.Multichannel

-- | <tt>pos</tt> is -1 to 1
--   
--   <tt>level</tt> is "a control-rate level input"
pan2 :: Args '["in", "pos"] '["level"] a => a -> SDBody a [Signal]

-- | "Spreads [a list] of channels across the stereo field."
splay :: ToSig s a => [s] -> SDBody' a [Signal]

-- | "Spreads [a list] of channels across the stereo field. Optional
--   arguments are spread and center, and equal power levelCompensation.
--   The formula for the stereo position is:
--   
--   <pre>
--   ((0 .. (n - 1)) * (2 / (n - 1) - 1) * spread + center
--   </pre>
select :: ToSig s as => s -> [SDBody' as Signal] -> SDBody' as Signal

-- | Mixes down a list of audio rate inputs to one.
--   
--   This is more efficient than e.g. <tt>foldl1 (~+)</tt>
--   
--   If the list is empty this is the same as <tt>dc 0</tt>
mix :: ToSig s a => [s] -> SDBody' a Signal

-- | Like <a>zipWithM</a> but if the lists are of different lengths,
--   doesn't shorten the longer one
addChannels :: (ToSig s0 a, ToSig s1 a) => [s0] -> [s1] -> SDBody' a [Signal]


-- | For if you want a SynthDef where each Synth instance has a new random
--   number.
--   
--   Creates a random value between "lo" and "hi". The value never changes
--   in the synth.
--   
--   These compute at <a>IR</a>
module Vivid.UGens.Random
expRand :: (Args '[] '["lo", "hi"] a) => a -> SDBody a Signal
linRand :: (Args '[] '["lo", "hi", "minmax"] a) => a -> SDBody a Signal
rand :: (Args '[] '["lo", "hi"] a) => a -> SDBody a Signal

module Vivid.UGens.Reverbs

-- | "mix", "room", and "damp" params range from 0 to1
freeVerb :: (Args '["in"] '["mix", "room", "damp"] a) => a -> SDBody a Signal

module Vivid.UGens.SynthControl

-- | Frees the synth when the trigger changes from non-positive to positive
--   
--   Runs at <a>KR</a>
freeSelf :: Args '["trigger"] '[] a => a -> SDBody a Signal

module Vivid.UGens.Triggers
latch :: (Args '["in", "trigger"] '[] a) => a -> SDBody a Signal
pulseCount :: Args '[] '["trigger", "reset"] a => a -> SDBody a Signal

-- | "Outputs one inpulse each time it receives a certain number of
--   triggers at its input"
--   
--   The trigger "can be any signal. A trigger happens when the signal
--   changes from non-positive to positive"
--   
--   "div" is the number of pulses to divide by. Default is 2.
--   
--   "start" is the starting value of the count
--   
--   Can be <a>AR</a> or <a>KR</a>
pulseDivider :: Args '["trigger"] '["div", "start"] a => a -> SDBody a Signal
sweep :: Args '["trigger"] '["rate"] a => a -> SDBody a Signal


-- | Not exported by default because many of these have the same names as
--   in <a>Control.Arrow</a>
module Vivid.ByteBeat

-- | Bitwise <tt>and</tt>
(&&&) :: (ToSig s0 a, ToSig s1 a) => s0 -> s1 -> SDBody' a Signal

-- | Bitwise <tt>or</tt>
(|||) :: (ToSig s0 a, ToSig s1 a) => s0 -> s1 -> SDBody' a Signal

-- | Bit shift right
(>>>) :: (ToSig s0 a, ToSig s1 a) => s0 -> s1 -> SDBody' a Signal

-- | Bit shift left
(<<<) :: (ToSig s0 a, ToSig s1 a) => s0 -> s1 -> SDBody' a Signal

-- | Bitwise xor. Short for <tt>biOp BitXor</tt>
xor :: (ToSig s0 a, ToSig s1 a) => s0 -> s1 -> SDBody' a Signal

-- | E.g.
--   
--   <pre>
--   play byteBeatFromHelpFile
--   </pre>
byteBeatFromHelpFile :: SDBody' a Signal

-- | E.g.
--   
--   <pre>
--   play $ baseThing $ \t -&gt; t &amp;&amp;&amp; (t &gt;&gt;&gt; 8)
--   </pre>
baseThing :: (Signal -> SDBody' a Signal) -> SDBody' a Signal

module Vivid.UGens.Undocumented

module Vivid.UGens.UserInteraction

-- | Only runs at <a>KR</a>
--   
--   Args: - warp -- "Mapping curve. 0 is linear, 1 is exponential (e. g.
--   for freq or times)" - lag -- "Lag factor to dezpipper cursor movement"
mouseX :: Args '[] '["min", "max", "warp", "lagSecs"] a => a -> SDBody a Signal

-- | Only runs at <a>KR</a>
--   
--   Args: - warp -- "Mapping curve. 0 is linear, 1 is exponential (e. g.
--   for freq or times)" - lag -- "Lag factor to dezpipper cursor movement"
mouseY :: Args '[] '["min", "max", "warp", "lagSecs"] a => a -> SDBody a Signal


-- | Unit Generators, which are the signal-generating/processing components
--   of synths.
--   
--   Most of your time reading documentation will probably be in these
--   modules
--   
--   <ul>
--   <li>*In ghci, get the type with ":i" instead of ":t"**</li>
--   </ul>
--   
--   In "Args '[foos] '[bars]", "foos" are the required arguments, "bars"
--   are the optional ones (ones which have a default value provided)
--   
--   E.g. to make a lowpass filter which filters whitenoise at 440hz, you'd
--   write:
--   
--   <pre>
--   lpf (in_ whiteNoise, freq_ 440)
--   </pre>
--   
--   Not all UGens from SC are here, so I've exposed the internals so you
--   can make your own. Some exports may disappear in future versions.
--   
--   These modules are organized in the same way as the "Browse UGens"
--   pages are
--   
--   You can find them in:
--   
--   <ul>
--   <li>The SC IDE: In the Help Browser, click "Browse" -&gt; "UGens"</li>
--   <li>Linux:
--   ~<i>.local</i>share<i>SuperCollider</i>Help/Browse.html#UGens</li>
--   <li>Other OSes: tbd!</li>
--   </ul>
module Vivid.UGens


-- | Exports everything from Vivid (and some helpful reexports) except
--   <a>Plugins</a>
module Vivid.NoPlugins
addSecs :: Timestamp -> Double -> Timestamp

-- | This is stored as the number of seconds since Jan 1 1900. You can get
--   it with <a>getTime</a>
newtype Timestamp :: *
Timestamp :: Double -> Timestamp

-- | <a>&amp;</a> is a reverse application operator. This provides
--   notational convenience. Its precedence is one higher than that of the
--   forward application operator <a>$</a>, which allows <a>&amp;</a> to be
--   nested in <a>$</a>.
(&) :: () => a -> (a -> b) -> b
infixl 1 &
bufToI :: KnownSymbol a => BufferId -> I a
bToI :: KnownSymbol a => BufferId -> I a
b2i :: KnownSymbol a => BufferId -> I a

module Vivid

module Vivid.UGens.Examples

-- | <tt>Dbrown</tt> example from the SC help file HERE:
dbrown_example :: SDBody' a [Signal]
