-- The `concat <$> sequence _` is to not run afoul of '-fconstraint-solver-iterations' -- temp?

{-# OPTIONS_HADDOCK show-extensions #-}

-- {-# LANGUAGE ConstraintKinds #-}
{-# LANGUAGE DataKinds #-}
{-# LANGUAGE ExistentialQuantification #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}
-- {-# LANGUAGE GADTs, NoMonoLocalBinds #-}
{-# LANGUAGE InstanceSigs #-}
{-# LANGUAGE KindSignatures #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE PolyKinds #-}
-- {-# LANGUAGE RankNTypes #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE TypeFamilies, NoMonoLocalBinds #-}
{-# LANGUAGE TypeOperators #-}
-- Needed for nested type family application:
{-# LANGUAGE UndecidableInstances #-}

{-# LANGUAGE NoIncoherentInstances #-}
{-# LANGUAGE NoMonomorphismRestriction #-}


--{-# LANGUAGE RankNTypes #-}

module Vivid.SynthDef.FromUA (
     FromUA(..)
   , fromUAWithDefaults
   , uaArgVal
   , uaArgValWDefault
   , DefaultArgs(..)
   , OverwritingArgs(..)
   , UA(..)
   , NoDefaults(..)
   , none
   , Args
   , SDBody

   , AllEqual
   ) where

-- import Vivid.SynthDef
import Vivid.SynthDef.ToSig
import Vivid.SynthDef.Types
-- import Vivid.SynthDef.TypesafeArgs

import qualified Data.List as L
import qualified Data.Map as Map
import Data.Monoid
import Data.Proxy
import GHC.Exts
import GHC.TypeLits

type SDBody a = SDBody' (SDBodyArgs a)

class FromUA (a :: *) where
   type UAsArgs a :: [Symbol]
   type SDBodyArgs a :: [Symbol]
   fromUA :: a -> SDBody a [(String, Signal)]

fromUAWithDefaults :: (
     FromUA a, FromUA b
   , SDBodyArgs a ~ SDBodyArgs b
   ) => DefaultArgs a -> OverwritingArgs b -> SDBody a [(String, Signal)]
fromUAWithDefaults :: DefaultArgs a -> OverwritingArgs b -> SDBody a [(String, Signal)]
fromUAWithDefaults (DefaultArgs a
defaultArgs) (OverwritingArgs b
overwritingArgs) = do
   [(String, Signal)]
defaultArgs' <- a -> SDBody a [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA a
defaultArgs
   [(String, Signal)]
overwritingArgs' <- b
-> StateT
     ([Int], SynthDef (SDBodyArgs b), VarSet (SDBodyArgs b))
     Identity
     [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA b
overwritingArgs
   [(String, Signal)]
-> StateT
     ([Int], SynthDef (SDBodyArgs b), VarSet (SDBodyArgs b))
     Identity
     [(String, Signal)]
forall (m :: * -> *) a. Monad m => a -> m a
return ([(String, Signal)]
 -> StateT
      ([Int], SynthDef (SDBodyArgs b), VarSet (SDBodyArgs b))
      Identity
      [(String, Signal)])
-> (Map String Signal -> [(String, Signal)])
-> Map String Signal
-> StateT
     ([Int], SynthDef (SDBodyArgs b), VarSet (SDBodyArgs b))
     Identity
     [(String, Signal)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Map String Signal -> [(String, Signal)]
forall k a. Map k a -> [(k, a)]
Map.toList (Map String Signal
 -> StateT
      ([Int], SynthDef (SDBodyArgs b), VarSet (SDBodyArgs b))
      Identity
      [(String, Signal)])
-> Map String Signal
-> StateT
     ([Int], SynthDef (SDBodyArgs b), VarSet (SDBodyArgs b))
     Identity
     [(String, Signal)]
forall a b. (a -> b) -> a -> b
$
      (Signal -> Signal -> Signal)
-> Map String Signal -> Map String Signal -> Map String Signal
forall k a. Ord k => (a -> a -> a) -> Map k a -> Map k a -> Map k a
Map.unionWith
         (\Signal
_defaultArg Signal
overwritingArg -> Signal
overwritingArg)
         ([(String, Signal)] -> Map String Signal
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList [(String, Signal)]
defaultArgs')
         ([(String, Signal)] -> Map String Signal
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList [(String, Signal)]
overwritingArgs')

-- Newtypes so we don't accidentally flip argument order:
newtype DefaultArgs a = DefaultArgs a
newtype OverwritingArgs a = OverwritingArgs a

data NoDefaults (args :: [Symbol])
   = NoDefaults
 deriving (Int -> NoDefaults args -> ShowS
[NoDefaults args] -> ShowS
NoDefaults args -> String
(Int -> NoDefaults args -> ShowS)
-> (NoDefaults args -> String)
-> ([NoDefaults args] -> ShowS)
-> Show (NoDefaults args)
forall (args :: [Symbol]). Int -> NoDefaults args -> ShowS
forall (args :: [Symbol]). [NoDefaults args] -> ShowS
forall (args :: [Symbol]). NoDefaults args -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [NoDefaults args] -> ShowS
$cshowList :: forall (args :: [Symbol]). [NoDefaults args] -> ShowS
show :: NoDefaults args -> String
$cshow :: forall (args :: [Symbol]). NoDefaults args -> String
showsPrec :: Int -> NoDefaults args -> ShowS
$cshowsPrec :: forall (args :: [Symbol]). Int -> NoDefaults args -> ShowS
Show, NoDefaults args -> NoDefaults args -> Bool
(NoDefaults args -> NoDefaults args -> Bool)
-> (NoDefaults args -> NoDefaults args -> Bool)
-> Eq (NoDefaults args)
forall (args :: [Symbol]).
NoDefaults args -> NoDefaults args -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: NoDefaults args -> NoDefaults args -> Bool
$c/= :: forall (args :: [Symbol]).
NoDefaults args -> NoDefaults args -> Bool
== :: NoDefaults args -> NoDefaults args -> Bool
$c== :: forall (args :: [Symbol]).
NoDefaults args -> NoDefaults args -> Bool
Eq, Eq (NoDefaults args)
Eq (NoDefaults args)
-> (NoDefaults args -> NoDefaults args -> Ordering)
-> (NoDefaults args -> NoDefaults args -> Bool)
-> (NoDefaults args -> NoDefaults args -> Bool)
-> (NoDefaults args -> NoDefaults args -> Bool)
-> (NoDefaults args -> NoDefaults args -> Bool)
-> (NoDefaults args -> NoDefaults args -> NoDefaults args)
-> (NoDefaults args -> NoDefaults args -> NoDefaults args)
-> Ord (NoDefaults args)
NoDefaults args -> NoDefaults args -> Bool
NoDefaults args -> NoDefaults args -> Ordering
NoDefaults args -> NoDefaults args -> NoDefaults args
forall (args :: [Symbol]). Eq (NoDefaults args)
forall (args :: [Symbol]).
NoDefaults args -> NoDefaults args -> Bool
forall (args :: [Symbol]).
NoDefaults args -> NoDefaults args -> Ordering
forall (args :: [Symbol]).
NoDefaults args -> NoDefaults args -> NoDefaults args
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: NoDefaults args -> NoDefaults args -> NoDefaults args
$cmin :: forall (args :: [Symbol]).
NoDefaults args -> NoDefaults args -> NoDefaults args
max :: NoDefaults args -> NoDefaults args -> NoDefaults args
$cmax :: forall (args :: [Symbol]).
NoDefaults args -> NoDefaults args -> NoDefaults args
>= :: NoDefaults args -> NoDefaults args -> Bool
$c>= :: forall (args :: [Symbol]).
NoDefaults args -> NoDefaults args -> Bool
> :: NoDefaults args -> NoDefaults args -> Bool
$c> :: forall (args :: [Symbol]).
NoDefaults args -> NoDefaults args -> Bool
<= :: NoDefaults args -> NoDefaults args -> Bool
$c<= :: forall (args :: [Symbol]).
NoDefaults args -> NoDefaults args -> Bool
< :: NoDefaults args -> NoDefaults args -> Bool
$c< :: forall (args :: [Symbol]).
NoDefaults args -> NoDefaults args -> Bool
compare :: NoDefaults args -> NoDefaults args -> Ordering
$ccompare :: forall (args :: [Symbol]).
NoDefaults args -> NoDefaults args -> Ordering
$cp1Ord :: forall (args :: [Symbol]). Eq (NoDefaults args)
Ord, ReadPrec [NoDefaults args]
ReadPrec (NoDefaults args)
Int -> ReadS (NoDefaults args)
ReadS [NoDefaults args]
(Int -> ReadS (NoDefaults args))
-> ReadS [NoDefaults args]
-> ReadPrec (NoDefaults args)
-> ReadPrec [NoDefaults args]
-> Read (NoDefaults args)
forall (args :: [Symbol]). ReadPrec [NoDefaults args]
forall (args :: [Symbol]). ReadPrec (NoDefaults args)
forall (args :: [Symbol]). Int -> ReadS (NoDefaults args)
forall (args :: [Symbol]). ReadS [NoDefaults args]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [NoDefaults args]
$creadListPrec :: forall (args :: [Symbol]). ReadPrec [NoDefaults args]
readPrec :: ReadPrec (NoDefaults args)
$creadPrec :: forall (args :: [Symbol]). ReadPrec (NoDefaults args)
readList :: ReadS [NoDefaults args]
$creadList :: forall (args :: [Symbol]). ReadS [NoDefaults args]
readsPrec :: Int -> ReadS (NoDefaults args)
$creadsPrec :: forall (args :: [Symbol]). Int -> ReadS (NoDefaults args)
Read)

none :: NoDefaults args
none :: NoDefaults args
none = NoDefaults args
forall (args :: [Symbol]). NoDefaults args
NoDefaults

uaArgVal :: (FromUA as, Elem aToLookUp (UAsArgs as), KnownSymbol aToLookUp) => as -> proxy aToLookUp -> SDBody as Signal
uaArgVal :: as -> proxy aToLookUp -> SDBody as Signal
uaArgVal as
uaArgs proxy aToLookUp
proxy = do
   [(String, Signal)]
allSigs <- as -> SDBody as [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA as
uaArgs
   Signal -> SDBody as Signal
forall (m :: * -> *) a. Monad m => a -> m a
return (Signal -> SDBody as Signal) -> Signal -> SDBody as Signal
forall a b. (a -> b) -> a -> b
$ case String -> [(String, Signal)] -> Maybe Signal
forall a b. Eq a => a -> [(a, b)] -> Maybe b
L.lookup (proxy aToLookUp -> String
forall (n :: Symbol) (proxy :: Symbol -> *).
KnownSymbol n =>
proxy n -> String
symbolVal proxy aToLookUp
proxy) ([(String, Signal)]
allSigs::[(String,Signal)]) of
      Just Signal
x -> Signal
x
      Maybe Signal
Nothing -> String -> Signal
forall a. HasCallStack => String -> a
error (String -> Signal) -> String -> Signal
forall a b. (a -> b) -> a -> b
$ String
"whaaaaaaaat?: " String -> ShowS
forall a. [a] -> [a] -> [a]
++ proxy aToLookUp -> String
forall (n :: Symbol) (proxy :: Symbol -> *).
KnownSymbol n =>
proxy n -> String
symbolVal proxy aToLookUp
proxy

-- Note a typo in this one won't be caught -- it'll just use the default value
uaArgValWDefault :: (FromUA as, KnownSymbol aToLookUp, ToSig defaultVal (SDBodyArgs as)) => defaultVal -> as -> proxy aToLookUp -> SDBody as Signal
uaArgValWDefault :: defaultVal -> as -> proxy aToLookUp -> SDBody as Signal
uaArgValWDefault defaultVal
defaultVal as
uaArgs proxy aToLookUp
proxy = do
   [(String, Signal)]
allSigs <- as
-> StateT
     ([Int], SynthDef (SDBodyArgs as), VarSet (SDBodyArgs as))
     Identity
     [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA as
uaArgs
   case String -> [(String, Signal)] -> Maybe Signal
forall a b. Eq a => a -> [(a, b)] -> Maybe b
L.lookup (proxy aToLookUp -> String
forall (n :: Symbol) (proxy :: Symbol -> *).
KnownSymbol n =>
proxy n -> String
symbolVal proxy aToLookUp
proxy) ([(String, Signal)]
allSigs::[(String,Signal)]) of
      Just Signal
x -> Signal -> SDBody as Signal
forall (m :: * -> *) a. Monad m => a -> m a
return Signal
x
      Maybe Signal
Nothing -> defaultVal -> SDBody as Signal
forall s (args :: [Symbol]).
ToSig s args =>
s -> SDBody' args Signal
toSig defaultVal
defaultVal

-- instance (args0 ~ args1) => FromUA (NoDefaults args0) args1 where
instance FromUA (NoDefaults args0) where
   type UAsArgs (NoDefaults args0) = '[]
   type SDBodyArgs (NoDefaults args0) = args0
   fromUA :: NoDefaults args0 -> SDBody (NoDefaults args0) [(String, Signal)]
fromUA NoDefaults args0
_ = [(String, Signal)]
-> StateT
     ([Int], SynthDef args0, VarSet args0) Identity [(String, Signal)]
forall (m :: * -> *) a. Monad m => a -> m a
return []

instance FromUA (UA a args) where
   type UAsArgs (UA a args) = '[a]
   type SDBodyArgs (UA a args) = args
   fromUA :: UA a args -> SDBody (UA a args) [(String, Signal)]
   fromUA :: UA a args -> SDBody (UA a args) [(String, Signal)]
fromUA (UA SDBody' args Signal
x) = do
      Signal
y <- SDBody' args Signal
x
      [(String, Signal)]
-> StateT
     ([Int], SynthDef args, VarSet args) Identity [(String, Signal)]
forall (m :: * -> *) a. Monad m => a -> m a
return [(Proxy a -> String
forall (n :: Symbol) (proxy :: Symbol -> *).
KnownSymbol n =>
proxy n -> String
symbolVal (Proxy a
forall k (t :: k). Proxy t
Proxy::Proxy a), Signal
y)]
      -- The LHS is like "freq" and the RHS is the value -- lhs isn't the 'foo' in 'A::A "foo"' ^^

instance (args0 ~ args1, KnownSymbol a {-, KnownSymbol b -}) => FromUA (UA a args0, UA b args1) where
   type UAsArgs (UA a args0, UA b args1) = '[a, b]
   type SDBodyArgs (UA a args0, UA b args1) = args0
   fromUA :: (UA a args0, UA b args1)
-> SDBody (UA a args0, UA b args1) [(String, Signal)]
fromUA (UA a args0
a, UA b args1
b) = [(String, Signal)] -> [(String, Signal)] -> [(String, Signal)]
forall a. Semigroup a => a -> a -> a
(<>) ([(String, Signal)] -> [(String, Signal)] -> [(String, Signal)])
-> StateT
     ([Int], SynthDef args1, VarSet args1) Identity [(String, Signal)]
-> StateT
     ([Int], SynthDef args1, VarSet args1)
     Identity
     ([(String, Signal)] -> [(String, Signal)])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> UA a args0 -> SDBody (UA a args0) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA UA a args0
a StateT
  ([Int], SynthDef args1, VarSet args1)
  Identity
  ([(String, Signal)] -> [(String, Signal)])
-> StateT
     ([Int], SynthDef args1, VarSet args1) Identity [(String, Signal)]
-> StateT
     ([Int], SynthDef args1, VarSet args1) Identity [(String, Signal)]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> UA b args1 -> SDBody (UA b args1) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA UA b args1
b

instance (AllEqual '[as0,as1,as2], KnownSymbol a, KnownSymbol b)
         => FromUA (UA a as0, UA b as1, UA c as2) where
   type UAsArgs (UA a as0, UA b as1, UA c as2) = '[a, b, c]
   type SDBodyArgs (UA a as0, UA b as1, UA c as2) = as0
   fromUA :: (UA a as0, UA b as1, UA c as2)
-> SDBody (UA a as0, UA b as1, UA c as2) [(String, Signal)]
fromUA (UA a as0
a, UA b as1
b, UA c as2
c) =
      -- (<>) <$> fromUA a <*> fromUA (b, c)
      [[(String, Signal)]] -> [(String, Signal)]
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat ([[(String, Signal)]] -> [(String, Signal)])
-> StateT
     ([Int], SynthDef as2, VarSet as2) Identity [[(String, Signal)]]
-> StateT
     ([Int], SynthDef as2, VarSet as2) Identity [(String, Signal)]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [StateT
   ([Int], SynthDef as2, VarSet as2) Identity [(String, Signal)]]
-> StateT
     ([Int], SynthDef as2, VarSet as2) Identity [[(String, Signal)]]
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
sequence [UA a as0 -> SDBody (UA a as0) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA UA a as0
a, UA b as1 -> SDBody (UA b as1) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA UA b as1
b, UA c as2 -> SDBody (UA c as2) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA UA c as2
c]


instance (AllEqual '[as0,as1,as2,as3,as4], AllKnownSymbols '[a, b, c])
         => FromUA (UA a as0, UA b as1, UA c as2, UA d as3) where
   type UAsArgs (UA a as0, UA b as1, UA c as2, UA d as3) = '[a, b, c, d]
   type SDBodyArgs (UA a as0, UA b as1, UA c as2, UA d as3) = as0
   fromUA :: (UA a as0, UA b as1, UA c as2, UA d as3)
-> SDBody
     (UA a as0, UA b as1, UA c as2, UA d as3) [(String, Signal)]
fromUA (UA a as0
a, UA b as1
b, UA c as2
c, UA d as3
d) =
      -- (<>) <$> fromUA (a,b) <*> fromUA (c,d)
      [[(String, Signal)]] -> [(String, Signal)]
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat ([[(String, Signal)]] -> [(String, Signal)])
-> StateT
     ([Int], SynthDef as4, VarSet as4) Identity [[(String, Signal)]]
-> StateT
     ([Int], SynthDef as4, VarSet as4) Identity [(String, Signal)]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [StateT
   ([Int], SynthDef as4, VarSet as4) Identity [(String, Signal)]]
-> StateT
     ([Int], SynthDef as4, VarSet as4) Identity [[(String, Signal)]]
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
sequence [UA a as0 -> SDBody (UA a as0) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA UA a as0
a,UA b as1 -> SDBody (UA b as1) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA UA b as1
b,UA c as2 -> SDBody (UA c as2) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA UA c as2
c, UA d as3 -> SDBody (UA d as3) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA UA d as3
d]



instance (AllEqual '[as0,as1,as2,as3,as4], AllKnownSymbols '[a,b,c,d] -- , KnownSymbol e --,
--     (SDBodyArgs (UA a as0)) ~ (UghRename (UA b as1, UA c as2, UA d as3, UA e as4))
          )
         => FromUA (UA a as0, UA b as1, UA c as2, UA d as3, UA e as4) where
   type UAsArgs (UA a as0, UA b as1, UA c as2, UA d as3, UA e as4) = '[a, b, c, d, e]
   type SDBodyArgs (UA a as0, UA b as1, UA c as2, UA d as3, UA e as4) = as0
   fromUA :: (UA a as0, UA b as1, UA c as2, UA d as3, UA e as4)
-> SDBody
     (UA a as0, UA b as1, UA c as2, UA d as3, UA e as4)
     [(String, Signal)]
fromUA (UA a as0
a, UA b as1
b, UA c as2
c, UA d as3
d, UA e as4
e) =
      -- (<>) <$> fromUA (a,b,c) <*> fromUA (d,e)
      [[(String, Signal)]] -> [(String, Signal)]
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat ([[(String, Signal)]] -> [(String, Signal)])
-> StateT
     ([Int], SynthDef as4, VarSet as4) Identity [[(String, Signal)]]
-> StateT
     ([Int], SynthDef as4, VarSet as4) Identity [(String, Signal)]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [StateT
   ([Int], SynthDef as4, VarSet as4) Identity [(String, Signal)]]
-> StateT
     ([Int], SynthDef as4, VarSet as4) Identity [[(String, Signal)]]
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
sequence [UA a as0 -> SDBody (UA a as0) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA UA a as0
a,UA b as1 -> SDBody (UA b as1) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA UA b as1
b,UA c as2 -> SDBody (UA c as2) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA UA c as2
c,UA d as3 -> SDBody (UA d as3) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA UA d as3
d,UA e as4 -> SDBody (UA e as4) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA UA e as4
e]

-- 6:
instance (AllEqual '[as0,as1,as2,as3,as4,as5], AllKnownSymbols '[a,b,c,d,e,f])
         => FromUA (UA a as0, UA b as1, UA c as2, UA d as3, UA e as4, UA f as5) where
   type UAsArgs (UA a as0, UA b as1, UA c as2, UA d as3, UA e as4, UA f as5) = '[a, b, c, d, e, f]
   type SDBodyArgs (UA a as0, UA b as1, UA c as2, UA d as3, UA e as4, UA f as5) = as0
   fromUA :: (UA a as0, UA b as1, UA c as2, UA d as3, UA e as4, UA f as5)
-> SDBody
     (UA a as0, UA b as1, UA c as2, UA d as3, UA e as4, UA f as5)
     [(String, Signal)]
fromUA (UA a as0
a, UA b as1
b, UA c as2
c, UA d as3
d, UA e as4
e, UA f as5
f) =
      -- (<>) <$> fromUA (a,b,c) <*> fromUA (d,e,f)
      [[(String, Signal)]] -> [(String, Signal)]
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat ([[(String, Signal)]] -> [(String, Signal)])
-> StateT
     ([Int], SynthDef as5, VarSet as5) Identity [[(String, Signal)]]
-> StateT
     ([Int], SynthDef as5, VarSet as5) Identity [(String, Signal)]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [StateT
   ([Int], SynthDef as5, VarSet as5) Identity [(String, Signal)]]
-> StateT
     ([Int], SynthDef as5, VarSet as5) Identity [[(String, Signal)]]
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
sequence [UA a as0 -> SDBody (UA a as0) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA UA a as0
a,UA b as1 -> SDBody (UA b as1) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA UA b as1
b,UA c as2 -> SDBody (UA c as2) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA UA c as2
c,UA d as3 -> SDBody (UA d as3) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA UA d as3
d,UA e as4 -> SDBody (UA e as4) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA UA e as4
e
         ,UA f as5 -> SDBody (UA f as5) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA UA f as5
f]

-- 7:
instance (AllEqual '[as0,as1,as2,as3,as4,as5,as6], AllKnownSymbols '[a,b,c,d,e,f,g])
         => FromUA (UA a as0, UA b as1, UA c as2, UA d as3, UA e as4, UA f as5, UA g as6) where
   type UAsArgs (UA a as0, UA b as1, UA c as2, UA d as3, UA e as4, UA f as5,UA g as6) = '[a, b, c, d, e, f, g]
   type SDBodyArgs (UA a as0, UA b as1, UA c as2, UA d as3, UA e as4, UA f as5,UA g as6) = as0
   fromUA :: (UA a as0, UA b as1, UA c as2, UA d as3, UA e as4, UA f as5,
 UA g as6)
-> SDBody
     (UA a as0, UA b as1, UA c as2, UA d as3, UA e as4, UA f as5,
      UA g as6)
     [(String, Signal)]
fromUA (UA a as0
a,UA b as1
b,UA c as2
c,UA d as3
d,UA e as4
e,UA f as5
f,UA g as6
g) =
      -- concat <$> sequence [fromUA (a,b,c),fromUA (d,e,f), fromUA g]
      -- (<>) <$> fromUA (a,b,c,d) <*> fromUA (e,f,g)
      [[(String, Signal)]] -> [(String, Signal)]
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat ([[(String, Signal)]] -> [(String, Signal)])
-> StateT
     ([Int], SynthDef as6, VarSet as6) Identity [[(String, Signal)]]
-> StateT
     ([Int], SynthDef as6, VarSet as6) Identity [(String, Signal)]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [StateT
   ([Int], SynthDef as6, VarSet as6) Identity [(String, Signal)]]
-> StateT
     ([Int], SynthDef as6, VarSet as6) Identity [[(String, Signal)]]
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
sequence [UA a as0 -> SDBody (UA a as0) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA UA a as0
a,UA b as1 -> SDBody (UA b as1) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA UA b as1
b,UA c as2 -> SDBody (UA c as2) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA UA c as2
c, UA d as3 -> SDBody (UA d as3) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA UA d as3
d,UA e as4 -> SDBody (UA e as4) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA UA e as4
e
         ,UA f as5 -> SDBody (UA f as5) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA UA f as5
f, UA g as6 -> SDBody (UA g as6) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA UA g as6
g]

-- 8
instance (AllEqual '[as0,as1,as2,as3,as4,as5,as6,as7]
         , AllKnownSymbols '[a,b,c,d,e,f,g,h])
         => FromUA (UA a as0, UA b as1, UA c as2, UA d as3, UA e as4, UA f as5
                   ,UA g as6,UA h as7) where
   type UAsArgs (UA a as0, UA b as1, UA c as2, UA d as3, UA e as4, UA f as5,UA g as6,UA h as7) = '[a, b, c, d, e, f, g, h]
   type SDBodyArgs (UA a as0, UA b as1, UA c as2, UA d as3, UA e as4, UA f as5,UA g as6,UA h as7) = as0
   fromUA :: (UA a as0, UA b as1, UA c as2, UA d as3, UA e as4, UA f as5,
 UA g as6, UA h as7)
-> SDBody
     (UA a as0, UA b as1, UA c as2, UA d as3, UA e as4, UA f as5,
      UA g as6, UA h as7)
     [(String, Signal)]
fromUA (UA a as0
a,UA b as1
b,UA c as2
c,UA d as3
d,UA e as4
e,UA f as5
f,UA g as6
g,UA h as7
h) =
      -- (<>) <$> fromUA (a,b,c,d) <*> fromUA (e,f,g,h)
      -- concat <$> sequence [fromUA (a,b,c), fromUA (d,e,f), fromUA (g,h)]
      [[(String, Signal)]] -> [(String, Signal)]
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat ([[(String, Signal)]] -> [(String, Signal)])
-> StateT
     ([Int], SynthDef as7, VarSet as7) Identity [[(String, Signal)]]
-> StateT
     ([Int], SynthDef as7, VarSet as7) Identity [(String, Signal)]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [StateT
   ([Int], SynthDef as7, VarSet as7) Identity [(String, Signal)]]
-> StateT
     ([Int], SynthDef as7, VarSet as7) Identity [[(String, Signal)]]
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
sequence [UA a as0 -> SDBody (UA a as0) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA UA a as0
a,UA b as1 -> SDBody (UA b as1) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA UA b as1
b,UA c as2 -> SDBody (UA c as2) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA UA c as2
c, UA d as3 -> SDBody (UA d as3) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA UA d as3
d,UA e as4 -> SDBody (UA e as4) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA UA e as4
e
         ,UA f as5 -> SDBody (UA f as5) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA UA f as5
f, UA g as6 -> SDBody (UA g as6) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA UA g as6
g, UA h as7 -> SDBody (UA h as7) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA UA h as7
h]

-- 9:
instance (AllEqual '[as0,as1,as2,as3,as4,as5,as6,as7,as8]
         ,AllKnownSymbols '[a,b,c,d,e,f,g,h,i])
         => FromUA (UA a as0, UA b as1, UA c as2, UA d as3, UA e as4, UA f as5
                   ,UA g as6,UA h as7,UA i as8) where
   type UAsArgs (UA a as0, UA b as1, UA c as2, UA d as3, UA e as4, UA f as5,UA g as6,UA h as7,UA i as8) = '[a, b, c, d, e, f, g, h, i]
   type SDBodyArgs (UA a as0, UA b as1, UA c as2, UA d as3, UA e as4, UA f as5,UA g as6,UA h as7,UA i as8) = as0
   fromUA :: (UA a as0, UA b as1, UA c as2, UA d as3, UA e as4, UA f as5,
 UA g as6, UA h as7, UA i as8)
-> SDBody
     (UA a as0, UA b as1, UA c as2, UA d as3, UA e as4, UA f as5,
      UA g as6, UA h as7, UA i as8)
     [(String, Signal)]
fromUA (UA a as0
a,UA b as1
b,UA c as2
c,UA d as3
d,UA e as4
e,UA f as5
f,UA g as6
g,UA h as7
h,UA i as8
i) =
      -- (<>) <$> fromUA (a,b,c,d,e) <*> fromUA (f,g,h,i)
      [[(String, Signal)]] -> [(String, Signal)]
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat ([[(String, Signal)]] -> [(String, Signal)])
-> StateT
     ([Int], SynthDef as8, VarSet as8) Identity [[(String, Signal)]]
-> StateT
     ([Int], SynthDef as8, VarSet as8) Identity [(String, Signal)]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [StateT
   ([Int], SynthDef as8, VarSet as8) Identity [(String, Signal)]]
-> StateT
     ([Int], SynthDef as8, VarSet as8) Identity [[(String, Signal)]]
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
sequence [(UA a as0, UA b as1, UA c as2)
-> SDBody (UA a as0, UA b as1, UA c as2) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA (UA a as0
a,UA b as1
b,UA c as2
c), (UA d as3, UA e as4, UA f as5)
-> SDBody (UA d as3, UA e as4, UA f as5) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA (UA d as3
d,UA e as4
e,UA f as5
f), (UA g as6, UA h as7, UA i as8)
-> SDBody (UA g as6, UA h as7, UA i as8) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA (UA g as6
g,UA h as7
h,UA i as8
i)]


instance (AllEqual '[as0,as1,as2,as3,as4,as5,as6,as7,as8,as9]
         ,AllKnownSymbols '[a,b,c,d,e,f,g,h,i,j])
         => FromUA (UA a as0, UA b as1, UA c as2, UA d as3, UA e as4, UA f as5
                   ,UA g as6,UA h as7,UA i as8,UA j as9) where
   type UAsArgs (UA a as0, UA b as1, UA c as2, UA d as3, UA e as4, UA f as5
                ,UA g as6,UA h as7,UA i as8,UA j as9) =
          '[a,b,c,d,e,f,g,h,i,j]
   type SDBodyArgs (UA a as0, UA b as1, UA c as2, UA d as3, UA e as4, UA f as5,UA g as6,UA h as7,UA i as8,UA j as9) = as0
   fromUA :: (UA a as0, UA b as1, UA c as2, UA d as3, UA e as4, UA f as5,
 UA g as6, UA h as7, UA i as8, UA j as9)
-> SDBody
     (UA a as0, UA b as1, UA c as2, UA d as3, UA e as4, UA f as5,
      UA g as6, UA h as7, UA i as8, UA j as9)
     [(String, Signal)]
fromUA (UA a as0
a,UA b as1
b,UA c as2
c,UA d as3
d,UA e as4
e,UA f as5
f,UA g as6
g,UA h as7
h,UA i as8
i,UA j as9
j) =
      -- (<>) <$> fromUA (a,b,c,d,e) <*> fromUA (f,g,h,i,j)
      [[(String, Signal)]] -> [(String, Signal)]
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat ([[(String, Signal)]] -> [(String, Signal)])
-> StateT
     ([Int], SynthDef as9, VarSet as9) Identity [[(String, Signal)]]
-> StateT
     ([Int], SynthDef as9, VarSet as9) Identity [(String, Signal)]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [StateT
   ([Int], SynthDef as9, VarSet as9) Identity [(String, Signal)]]
-> StateT
     ([Int], SynthDef as9, VarSet as9) Identity [[(String, Signal)]]
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
sequence [(UA a as0, UA b as1, UA c as2)
-> SDBody (UA a as0, UA b as1, UA c as2) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA (UA a as0
a,UA b as1
b,UA c as2
c), (UA d as3, UA e as4, UA f as5)
-> SDBody (UA d as3, UA e as4, UA f as5) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA (UA d as3
d,UA e as4
e,UA f as5
f), (UA g as6, UA h as7, UA i as8)
-> SDBody (UA g as6, UA h as7, UA i as8) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA (UA g as6
g,UA h as7
h,UA i as8
i), UA j as9 -> SDBody (UA j as9) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA (UA j as9
j)]

instance (AllEqual '[as0,as1,as2,as3,as4,as5,as6,as7,as8,as9,as10]
         ,AllKnownSymbols '[a,b,c,d,e,f,g,h,i,j,k])
         => FromUA (UA a as0, UA b as1, UA c as2, UA d as3, UA e as4, UA f as5
                   ,UA g as6,UA h as7,UA i as8,UA j as9,UA k as10) where
   type UAsArgs (UA a as0, UA b as1, UA c as2, UA d as3, UA e as4, UA f as5
                ,UA g as6,UA h as7,UA i as8,UA j as9,UA k as10) =
          '[a,b,c,d,e,f,g,h,i,j,k]
   type SDBodyArgs (UA a as0, UA b as1, UA c as2, UA d as3, UA e as4, UA f as5,UA g as6,UA h as7,UA i as8,UA j as9,UA k as10) = as0
   fromUA :: (UA a as0, UA b as1, UA c as2, UA d as3, UA e as4, UA f as5,
 UA g as6, UA h as7, UA i as8, UA j as9, UA k as10)
-> SDBody
     (UA a as0, UA b as1, UA c as2, UA d as3, UA e as4, UA f as5,
      UA g as6, UA h as7, UA i as8, UA j as9, UA k as10)
     [(String, Signal)]
fromUA (UA a as0
a,UA b as1
b,UA c as2
c,UA d as3
d,UA e as4
e,UA f as5
f,UA g as6
g,UA h as7
h,UA i as8
i,UA j as9
j,UA k as10
k) =
      -- (<>) <$> fromUA (a,b,c,d,e,f) <*> fromUA (g,h,i,j,k)
      [[(String, Signal)]] -> [(String, Signal)]
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat ([[(String, Signal)]] -> [(String, Signal)])
-> StateT
     ([Int], SynthDef as10, VarSet as10) Identity [[(String, Signal)]]
-> StateT
     ([Int], SynthDef as10, VarSet as10) Identity [(String, Signal)]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [StateT
   ([Int], SynthDef as10, VarSet as10) Identity [(String, Signal)]]
-> StateT
     ([Int], SynthDef as10, VarSet as10) Identity [[(String, Signal)]]
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
sequence [(UA a as0, UA b as1, UA c as2)
-> SDBody (UA a as0, UA b as1, UA c as2) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA (UA a as0
a,UA b as1
b,UA c as2
c), (UA d as3, UA e as4, UA f as5)
-> SDBody (UA d as3, UA e as4, UA f as5) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA (UA d as3
d,UA e as4
e,UA f as5
f), (UA g as6, UA h as7, UA i as8)
-> SDBody (UA g as6, UA h as7, UA i as8) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA (UA g as6
g,UA h as7
h,UA i as8
i), (UA j as9, UA k as10)
-> SDBody (UA j as9, UA k as10) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA (UA j as9
j,UA k as10
k)]


instance (AllEqual '[as0,as1,as2,as3,as4,as5,as6,as7,as8,as9,as10,as11]
         ,AllKnownSymbols '[a,b,c,d,e,f,g,h,i,j,k,l])
         => FromUA (UA a as0, UA b as1, UA c as2, UA d as3, UA e as4, UA f as5
                   ,UA g as6,UA h as7,UA i as8,UA j as9,UA k as10,UA l as11) where
   type UAsArgs (UA a as0, UA b as1, UA c as2, UA d as3, UA e as4, UA f as5
                ,UA g as6,UA h as7,UA i as8,UA j as9,UA k as10,UA l as11) =
          '[a,b,c,d,e,f,g,h,i,j,k,l]
   type SDBodyArgs (UA a as0, UA b as1, UA c as2, UA d as3, UA e as4, UA f as5,UA g as6,UA h as7,UA i as8,UA j as9,UA k as10,UA l as11) = as0
   fromUA :: (UA a as0, UA b as1, UA c as2, UA d as3, UA e as4, UA f as5,
 UA g as6, UA h as7, UA i as8, UA j as9, UA k as10, UA l as11)
-> SDBody
     (UA a as0, UA b as1, UA c as2, UA d as3, UA e as4, UA f as5,
      UA g as6, UA h as7, UA i as8, UA j as9, UA k as10, UA l as11)
     [(String, Signal)]
fromUA (UA a as0
a,UA b as1
b,UA c as2
c,UA d as3
d,UA e as4
e,UA f as5
f,UA g as6
g,UA h as7
h,UA i as8
i,UA j as9
j,UA k as10
k,UA l as11
l) =
      -- (<>) <$> fromUA (a,b,c,d,e,f) <*> fromUA (g,h,i,j,k,l)
      [[(String, Signal)]] -> [(String, Signal)]
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat ([[(String, Signal)]] -> [(String, Signal)])
-> StateT
     ([Int], SynthDef as11, VarSet as11) Identity [[(String, Signal)]]
-> StateT
     ([Int], SynthDef as11, VarSet as11) Identity [(String, Signal)]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [StateT
   ([Int], SynthDef as11, VarSet as11) Identity [(String, Signal)]]
-> StateT
     ([Int], SynthDef as11, VarSet as11) Identity [[(String, Signal)]]
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
sequence [(UA a as0, UA b as1, UA c as2)
-> SDBody (UA a as0, UA b as1, UA c as2) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA (UA a as0
a,UA b as1
b,UA c as2
c), (UA d as3, UA e as4, UA f as5)
-> SDBody (UA d as3, UA e as4, UA f as5) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA (UA d as3
d,UA e as4
e,UA f as5
f), (UA g as6, UA h as7, UA i as8)
-> SDBody (UA g as6, UA h as7, UA i as8) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA (UA g as6
g,UA h as7
h,UA i as8
i), (UA j as9, UA k as10, UA l as11)
-> SDBody (UA j as9, UA k as10, UA l as11) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA (UA j as9
j,UA k as10
k,UA l as11
l)]


instance (AllEqual '[as0,as1,as2,as3,as4,as5,as6,as7,as8,as9,as10,as11,as12]
         ,AllKnownSymbols '[a,b,c,d,e,f,g,h,i,j,k,l,m])
         => FromUA (UA a as0, UA b as1, UA c as2, UA d as3, UA e as4, UA f as5
                   ,UA g as6,UA h as7,UA i as8,UA j as9,UA k as10,UA l as11
                   ,UA m as12
                   ) where
   type UAsArgs (UA a as0, UA b as1, UA c as2, UA d as3, UA e as4, UA f as5
                ,UA g as6,UA h as7,UA i as8,UA j as9,UA k as10,UA l as11
                ,UA m as12) =
          '[a,b,c,d,e,f,g,h,i,j,k,l,m]
   type SDBodyArgs (UA a as0, UA b as1, UA c as2, UA d as3, UA e as4, UA f as5,UA g as6,UA h as7,UA i as8,UA j as9,UA k as10,UA l as11,UA m as12) = as0
   fromUA :: (UA a as0, UA b as1, UA c as2, UA d as3, UA e as4, UA f as5,
 UA g as6, UA h as7, UA i as8, UA j as9, UA k as10, UA l as11,
 UA m as12)
-> SDBody
     (UA a as0, UA b as1, UA c as2, UA d as3, UA e as4, UA f as5,
      UA g as6, UA h as7, UA i as8, UA j as9, UA k as10, UA l as11,
      UA m as12)
     [(String, Signal)]
fromUA (UA a as0
a,UA b as1
b,UA c as2
c,UA d as3
d,UA e as4
e,UA f as5
f,UA g as6
g,UA h as7
h,UA i as8
i,UA j as9
j,UA k as10
k,UA l as11
l,UA m as12
m) =
      -- (<>) <$> fromUA (a,b,c,d,e,f,g) <*> fromUA (h,i,j,k,l,m)
      [[(String, Signal)]] -> [(String, Signal)]
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat ([[(String, Signal)]] -> [(String, Signal)])
-> StateT
     ([Int], SynthDef as12, VarSet as12) Identity [[(String, Signal)]]
-> StateT
     ([Int], SynthDef as12, VarSet as12) Identity [(String, Signal)]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [StateT
   ([Int], SynthDef as12, VarSet as12) Identity [(String, Signal)]]
-> StateT
     ([Int], SynthDef as12, VarSet as12) Identity [[(String, Signal)]]
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
sequence [(UA a as0, UA b as1, UA c as2)
-> SDBody (UA a as0, UA b as1, UA c as2) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA (UA a as0
a,UA b as1
b,UA c as2
c), (UA d as3, UA e as4, UA f as5)
-> SDBody (UA d as3, UA e as4, UA f as5) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA (UA d as3
d,UA e as4
e,UA f as5
f), (UA g as6, UA h as7, UA i as8)
-> SDBody (UA g as6, UA h as7, UA i as8) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA (UA g as6
g,UA h as7
h,UA i as8
i), (UA j as9, UA k as10, UA l as11)
-> SDBody (UA j as9, UA k as10, UA l as11) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA (UA j as9
j,UA k as10
k,UA l as11
l), UA m as12 -> SDBody (UA m as12) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA (UA m as12
m)]


instance (AllEqual '[as0,as1,as2,as3,as4,as5,as6,as7,as8,as9,as10,as11,as12,as13]
         ,AllKnownSymbols '[a,b,c,d,e,f,g,h,i,j,k,l,m,n])
         => FromUA (UA a as0, UA b as1, UA c as2, UA d as3, UA e as4, UA f as5
                   ,UA g as6,UA h as7,UA i as8,UA j as9,UA k as10,UA l as11
                   ,UA m as12,UA n as13
                   ) where
   type UAsArgs (UA a as0, UA b as1, UA c as2, UA d as3, UA e as4, UA f as5
                ,UA g as6,UA h as7,UA i as8,UA j as9,UA k as10,UA l as11
                ,UA m as12,UA n as13) =
          '[a,b,c,d,e,f,g,h,i,j,k,l,m,n]
   type SDBodyArgs (UA a as0, UA b as1, UA c as2, UA d as3, UA e as4, UA f as5,UA g as6,UA h as7,UA i as8,UA j as9,UA k as10,UA l as11,UA m as12,UA n as13) = as0
   fromUA :: (UA a as0, UA b as1, UA c as2, UA d as3, UA e as4, UA f as5,
 UA g as6, UA h as7, UA i as8, UA j as9, UA k as10, UA l as11,
 UA m as12, UA n as13)
-> SDBody
     (UA a as0, UA b as1, UA c as2, UA d as3, UA e as4, UA f as5,
      UA g as6, UA h as7, UA i as8, UA j as9, UA k as10, UA l as11,
      UA m as12, UA n as13)
     [(String, Signal)]
fromUA (UA a as0
a,UA b as1
b,UA c as2
c,UA d as3
d,UA e as4
e,UA f as5
f,UA g as6
g,UA h as7
h,UA i as8
i,UA j as9
j,UA k as10
k,UA l as11
l,UA m as12
m,UA n as13
n) =
      -- (<>) <$> fromUA (a,b,c,d,e,f,g) <*> fromUA (h,i,j,k,l,m,n)
      [[(String, Signal)]] -> [(String, Signal)]
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat ([[(String, Signal)]] -> [(String, Signal)])
-> StateT
     ([Int], SynthDef as13, VarSet as13) Identity [[(String, Signal)]]
-> StateT
     ([Int], SynthDef as13, VarSet as13) Identity [(String, Signal)]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [StateT
   ([Int], SynthDef as13, VarSet as13) Identity [(String, Signal)]]
-> StateT
     ([Int], SynthDef as13, VarSet as13) Identity [[(String, Signal)]]
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
sequence [(UA a as0, UA b as1, UA c as2)
-> SDBody (UA a as0, UA b as1, UA c as2) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA (UA a as0
a,UA b as1
b,UA c as2
c), (UA d as3, UA e as4, UA f as5)
-> SDBody (UA d as3, UA e as4, UA f as5) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA (UA d as3
d,UA e as4
e,UA f as5
f), (UA g as6, UA h as7, UA i as8)
-> SDBody (UA g as6, UA h as7, UA i as8) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA (UA g as6
g,UA h as7
h,UA i as8
i), (UA j as9, UA k as10, UA l as11)
-> SDBody (UA j as9, UA k as10, UA l as11) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA (UA j as9
j,UA k as10
k,UA l as11
l), (UA m as12, UA n as13)
-> SDBody (UA m as12, UA n as13) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA (UA m as12
m,UA n as13
n)]


instance (AllEqual '[as0,as1,as2,as3,as4,as5,as6,as7,as8,as9,as10,as11,as12,as13,as14]
         ,AllKnownSymbols '[a,b,c,d,e,f,g,h,i,j,k,l,m,n,o])
         => FromUA (UA a as0, UA b as1, UA c as2, UA d as3, UA e as4, UA f as5
                   ,UA g as6,UA h as7,UA i as8,UA j as9,UA k as10,UA l as11
                   ,UA m as12,UA n as13,UA o as14
                   ) where
   type UAsArgs (UA a as0, UA b as1, UA c as2, UA d as3, UA e as4, UA f as5
                ,UA g as6,UA h as7,UA i as8,UA j as9,UA k as10,UA l as11
                ,UA m as12,UA n as13,UA o as14
                ) =
          '[a,b,c,d,e,f,g,h,i,j,k,l,m,n,o]
   type SDBodyArgs (UA a as0, UA b as1, UA c as2, UA d as3, UA e as4, UA f as5
                  ,UA g as6,UA h as7,UA i as8,UA j as9,UA k as10,UA l as11
                  ,UA m as12,UA n as13,UA o as14
                  ) = as0
   fromUA :: (UA a as0, UA b as1, UA c as2, UA d as3, UA e as4, UA f as5,
 UA g as6, UA h as7, UA i as8, UA j as9, UA k as10, UA l as11,
 UA m as12, UA n as13, UA o as14)
-> SDBody
     (UA a as0, UA b as1, UA c as2, UA d as3, UA e as4, UA f as5,
      UA g as6, UA h as7, UA i as8, UA j as9, UA k as10, UA l as11,
      UA m as12, UA n as13, UA o as14)
     [(String, Signal)]
fromUA (UA a as0
a,UA b as1
b,UA c as2
c,UA d as3
d,UA e as4
e,UA f as5
f,UA g as6
g,UA h as7
h,UA i as8
i,UA j as9
j,UA k as10
k,UA l as11
l,UA m as12
m,UA n as13
n,UA o as14
o) =
      -- (<>) <$> fromUA (a,b,c,d,e,f,g,h) <*> fromUA (i,j,k,l,m,n,o)
      [[(String, Signal)]] -> [(String, Signal)]
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat ([[(String, Signal)]] -> [(String, Signal)])
-> StateT
     ([Int], SynthDef as14, VarSet as14) Identity [[(String, Signal)]]
-> StateT
     ([Int], SynthDef as14, VarSet as14) Identity [(String, Signal)]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [StateT
   ([Int], SynthDef as14, VarSet as14) Identity [(String, Signal)]]
-> StateT
     ([Int], SynthDef as14, VarSet as14) Identity [[(String, Signal)]]
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
sequence [(UA a as0, UA b as1, UA c as2)
-> SDBody (UA a as0, UA b as1, UA c as2) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA (UA a as0
a,UA b as1
b,UA c as2
c), (UA d as3, UA e as4, UA f as5)
-> SDBody (UA d as3, UA e as4, UA f as5) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA (UA d as3
d,UA e as4
e,UA f as5
f), (UA g as6, UA h as7, UA i as8)
-> SDBody (UA g as6, UA h as7, UA i as8) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA (UA g as6
g,UA h as7
h,UA i as8
i), (UA j as9, UA k as10, UA l as11)
-> SDBody (UA j as9, UA k as10, UA l as11) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA (UA j as9
j,UA k as10
k,UA l as11
l), (UA m as12, UA n as13, UA o as14)
-> SDBody (UA m as12, UA n as13, UA o as14) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA (UA m as12
m,UA n as13
n,UA o as14
o)]


instance (AllEqual '[as0,as1,as2,as3,as4,as5,as6,as7,as8,as9,as10,as11,as12,as13,as14,as15]
         ,AllKnownSymbols '[a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p])
         => FromUA (UA a as0, UA b as1, UA c as2, UA d as3, UA e as4, UA f as5
                   ,UA g as6,UA h as7,UA i as8,UA j as9,UA k as10,UA l as11
                   ,UA m as12,UA n as13,UA o as14,UA p as15
                   ) where
   type UAsArgs (UA a as0, UA b as1, UA c as2, UA d as3, UA e as4, UA f as5
                ,UA g as6,UA h as7,UA i as8,UA j as9,UA k as10,UA l as11
                ,UA m as12,UA n as13,UA o as14,UA p as15
                ) =
          '[a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p]
   type SDBodyArgs (UA a as0, UA b as1, UA c as2, UA d as3, UA e as4, UA f as5
                  ,UA g as6,UA h as7,UA i as8,UA j as9,UA k as10,UA l as11
                  ,UA m as12,UA n as13,UA o as14,UA p as15
                  ) = as0
   fromUA :: (UA a as0, UA b as1, UA c as2, UA d as3, UA e as4, UA f as5,
 UA g as6, UA h as7, UA i as8, UA j as9, UA k as10, UA l as11,
 UA m as12, UA n as13, UA o as14, UA p as15)
-> SDBody
     (UA a as0, UA b as1, UA c as2, UA d as3, UA e as4, UA f as5,
      UA g as6, UA h as7, UA i as8, UA j as9, UA k as10, UA l as11,
      UA m as12, UA n as13, UA o as14, UA p as15)
     [(String, Signal)]
fromUA (UA a as0
a,UA b as1
b,UA c as2
c,UA d as3
d,UA e as4
e,UA f as5
f,UA g as6
g,UA h as7
h,UA i as8
i,UA j as9
j,UA k as10
k,UA l as11
l,UA m as12
m,UA n as13
n,UA o as14
o,UA p as15
p) =
      -- (<>) <$> fromUA (a,b,c,d,e,f,g,h) <*> fromUA (i,j,k,l,m,n,o,p)
      [[(String, Signal)]] -> [(String, Signal)]
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat ([[(String, Signal)]] -> [(String, Signal)])
-> StateT
     ([Int], SynthDef as15, VarSet as15) Identity [[(String, Signal)]]
-> StateT
     ([Int], SynthDef as15, VarSet as15) Identity [(String, Signal)]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [StateT
   ([Int], SynthDef as15, VarSet as15) Identity [(String, Signal)]]
-> StateT
     ([Int], SynthDef as15, VarSet as15) Identity [[(String, Signal)]]
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
sequence [(UA a as0, UA b as1, UA c as2)
-> SDBody (UA a as0, UA b as1, UA c as2) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA (UA a as0
a,UA b as1
b,UA c as2
c), (UA d as3, UA e as4, UA f as5)
-> SDBody (UA d as3, UA e as4, UA f as5) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA (UA d as3
d,UA e as4
e,UA f as5
f), (UA g as6, UA h as7, UA i as8)
-> SDBody (UA g as6, UA h as7, UA i as8) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA (UA g as6
g,UA h as7
h,UA i as8
i), (UA j as9, UA k as10, UA l as11)
-> SDBody (UA j as9, UA k as10, UA l as11) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA (UA j as9
j,UA k as10
k,UA l as11
l), (UA m as12, UA n as13, UA o as14)
-> SDBody (UA m as12, UA n as13, UA o as14) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA (UA m as12
m,UA n as13
n,UA o as14
o), UA p as15 -> SDBody (UA p as15) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA (UA p as15
p)]


instance (AllEqual '[as0,as1,as2,as3,as4,as5,as6,as7,as8,as9,as10,as11,as12,as13,as14,as15,as16]
         ,AllKnownSymbols '[a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q])
         => FromUA (UA a as0, UA b as1, UA c as2, UA d as3, UA e as4, UA f as5
                   ,UA g as6,UA h as7,UA i as8,UA j as9,UA k as10,UA l as11
                   ,UA m as12,UA n as13,UA o as14,UA p as15,UA q as16
                   ) where
   type UAsArgs (UA a as0, UA b as1, UA c as2, UA d as3, UA e as4, UA f as5
                ,UA g as6,UA h as7,UA i as8,UA j as9,UA k as10,UA l as11
                ,UA m as12,UA n as13,UA o as14,UA p as15,UA q as16
                ) =
          '[a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q]
   type SDBodyArgs (UA a as0, UA b as1, UA c as2, UA d as3, UA e as4, UA f as5
                  ,UA g as6,UA h as7,UA i as8,UA j as9,UA k as10,UA l as11
                  ,UA m as12,UA n as13,UA o as14,UA p as15,UA q as16
                  ) = as0
   fromUA :: (UA a as0, UA b as1, UA c as2, UA d as3, UA e as4, UA f as5,
 UA g as6, UA h as7, UA i as8, UA j as9, UA k as10, UA l as11,
 UA m as12, UA n as13, UA o as14, UA p as15, UA q as16)
-> SDBody
     (UA a as0, UA b as1, UA c as2, UA d as3, UA e as4, UA f as5,
      UA g as6, UA h as7, UA i as8, UA j as9, UA k as10, UA l as11,
      UA m as12, UA n as13, UA o as14, UA p as15, UA q as16)
     [(String, Signal)]
fromUA (UA a as0
a,UA b as1
b,UA c as2
c,UA d as3
d,UA e as4
e,UA f as5
f,UA g as6
g,UA h as7
h,UA i as8
i,UA j as9
j,UA k as10
k,UA l as11
l,UA m as12
m,UA n as13
n,UA o as14
o,UA p as15
p,UA q as16
q) =
      -- (<>) <$> fromUA (a,b,c,d,e,f,g,h,i) <*> fromUA (j,k,l,m,n,o,p,q)
      [[(String, Signal)]] -> [(String, Signal)]
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat ([[(String, Signal)]] -> [(String, Signal)])
-> StateT
     ([Int], SynthDef as16, VarSet as16) Identity [[(String, Signal)]]
-> StateT
     ([Int], SynthDef as16, VarSet as16) Identity [(String, Signal)]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [StateT
   ([Int], SynthDef as16, VarSet as16) Identity [(String, Signal)]]
-> StateT
     ([Int], SynthDef as16, VarSet as16) Identity [[(String, Signal)]]
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
sequence [(UA a as0, UA b as1, UA c as2)
-> SDBody (UA a as0, UA b as1, UA c as2) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA (UA a as0
a,UA b as1
b,UA c as2
c), (UA d as3, UA e as4, UA f as5)
-> SDBody (UA d as3, UA e as4, UA f as5) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA (UA d as3
d,UA e as4
e,UA f as5
f), (UA g as6, UA h as7, UA i as8)
-> SDBody (UA g as6, UA h as7, UA i as8) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA (UA g as6
g,UA h as7
h,UA i as8
i), (UA j as9, UA k as10, UA l as11)
-> SDBody (UA j as9, UA k as10, UA l as11) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA (UA j as9
j,UA k as10
k,UA l as11
l), (UA m as12, UA n as13, UA o as14)
-> SDBody (UA m as12, UA n as13, UA o as14) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA (UA m as12
m,UA n as13
n,UA o as14
o), (UA p as15, UA q as16)
-> SDBody (UA p as15, UA q as16) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA (UA p as15
p,UA q as16
q)]


instance (AllEqual '[as0,as1,as2,as3,as4,as5,as6,as7,as8,as9,as10,as11,as12,as13,as14,as15,as16,as17]
         ,AllKnownSymbols '[a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r])
         => FromUA (UA a as0, UA b as1, UA c as2, UA d as3, UA e as4, UA f as5
                   ,UA g as6,UA h as7,UA i as8,UA j as9,UA k as10,UA l as11
                   ,UA m as12,UA n as13,UA o as14,UA p as15,UA q as16
                   ,UA r as17
                   ) where
   type UAsArgs (UA a as0, UA b as1, UA c as2, UA d as3, UA e as4, UA f as5
                ,UA g as6,UA h as7,UA i as8,UA j as9,UA k as10,UA l as11
                ,UA m as12,UA n as13,UA o as14,UA p as15,UA q as16,UA r as17
                ) =
          '[a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r]
   type SDBodyArgs (UA a as0, UA b as1, UA c as2, UA d as3, UA e as4, UA f as5
                  ,UA g as6,UA h as7,UA i as8,UA j as9,UA k as10,UA l as11
                  ,UA m as12,UA n as13,UA o as14,UA p as15,UA q as16,UA r as17
                  ) = as0
   fromUA :: (UA a as0, UA b as1, UA c as2, UA d as3, UA e as4, UA f as5,
 UA g as6, UA h as7, UA i as8, UA j as9, UA k as10, UA l as11,
 UA m as12, UA n as13, UA o as14, UA p as15, UA q as16, UA r as17)
-> SDBody
     (UA a as0, UA b as1, UA c as2, UA d as3, UA e as4, UA f as5,
      UA g as6, UA h as7, UA i as8, UA j as9, UA k as10, UA l as11,
      UA m as12, UA n as13, UA o as14, UA p as15, UA q as16, UA r as17)
     [(String, Signal)]
fromUA (UA a as0
a,UA b as1
b,UA c as2
c,UA d as3
d,UA e as4
e,UA f as5
f,UA g as6
g,UA h as7
h,UA i as8
i,UA j as9
j,UA k as10
k,UA l as11
l,UA m as12
m,UA n as13
n,UA o as14
o,UA p as15
p,UA q as16
q,UA r as17
r) =
      -- (<>) <$> fromUA (a,b,c,d,e,f,g,h,i) <*> fromUA (j,k,l,m,n,o,p,q,r)
      [[(String, Signal)]] -> [(String, Signal)]
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat ([[(String, Signal)]] -> [(String, Signal)])
-> StateT
     ([Int], SynthDef as17, VarSet as17) Identity [[(String, Signal)]]
-> StateT
     ([Int], SynthDef as17, VarSet as17) Identity [(String, Signal)]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [StateT
   ([Int], SynthDef as17, VarSet as17) Identity [(String, Signal)]]
-> StateT
     ([Int], SynthDef as17, VarSet as17) Identity [[(String, Signal)]]
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
sequence [(UA a as0, UA b as1, UA c as2)
-> SDBody (UA a as0, UA b as1, UA c as2) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA (UA a as0
a,UA b as1
b,UA c as2
c), (UA d as3, UA e as4, UA f as5)
-> SDBody (UA d as3, UA e as4, UA f as5) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA (UA d as3
d,UA e as4
e,UA f as5
f), (UA g as6, UA h as7, UA i as8)
-> SDBody (UA g as6, UA h as7, UA i as8) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA (UA g as6
g,UA h as7
h,UA i as8
i), (UA j as9, UA k as10, UA l as11)
-> SDBody (UA j as9, UA k as10, UA l as11) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA (UA j as9
j,UA k as10
k,UA l as11
l), (UA m as12, UA n as13, UA o as14)
-> SDBody (UA m as12, UA n as13, UA o as14) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA (UA m as12
m,UA n as13
n,UA o as14
o), (UA p as15, UA q as16, UA r as17)
-> SDBody (UA p as15, UA q as16, UA r as17) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA (UA p as15
p,UA q as16
q,UA r as17
r)]


instance (AllEqual '[as0,as1,as2,as3,as4,as5,as6,as7,as8,as9,as10,as11,as12,as13,as14,as15,as16,as17,as18]
         ,AllKnownSymbols '[a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s])
         => FromUA (UA a as0, UA b as1, UA c as2, UA d as3, UA e as4, UA f as5
                   ,UA g as6,UA h as7,UA i as8,UA j as9,UA k as10,UA l as11
                   ,UA m as12,UA n as13,UA o as14,UA p as15,UA q as16
                   ,UA r as17, UA s as18
                   ) where
   type UAsArgs (UA a as0, UA b as1, UA c as2, UA d as3, UA e as4, UA f as5
                ,UA g as6,UA h as7,UA i as8,UA j as9,UA k as10,UA l as11
                ,UA m as12,UA n as13,UA o as14,UA p as15,UA q as16,UA r as17
                ,UA s as18) =
          '[a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s]
   type SDBodyArgs (UA a as0, UA b as1, UA c as2, UA d as3, UA e as4, UA f as5
                  ,UA g as6,UA h as7,UA i as8,UA j as9,UA k as10,UA l as11
                  ,UA m as12,UA n as13,UA o as14,UA p as15,UA q as16,UA r as17
                  ,UA s as18) = as0
   fromUA :: (UA a as0, UA b as1, UA c as2, UA d as3, UA e as4, UA f as5,
 UA g as6, UA h as7, UA i as8, UA j as9, UA k as10, UA l as11,
 UA m as12, UA n as13, UA o as14, UA p as15, UA q as16, UA r as17,
 UA s as18)
-> SDBody
     (UA a as0, UA b as1, UA c as2, UA d as3, UA e as4, UA f as5,
      UA g as6, UA h as7, UA i as8, UA j as9, UA k as10, UA l as11,
      UA m as12, UA n as13, UA o as14, UA p as15, UA q as16, UA r as17,
      UA s as18)
     [(String, Signal)]
fromUA (UA a as0
a,UA b as1
b,UA c as2
c,UA d as3
d,UA e as4
e,UA f as5
f,UA g as6
g,UA h as7
h,UA i as8
i,UA j as9
j,UA k as10
k,UA l as11
l,UA m as12
m,UA n as13
n,UA o as14
o,UA p as15
p,UA q as16
q,UA r as17
r,UA s as18
s) =
      -- (<>) <$> fromUA (a,b,c,d,e,f,g,h,i,j) <*> fromUA (k,l,m,n,o,p,q,r,s)
      [[(String, Signal)]] -> [(String, Signal)]
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat ([[(String, Signal)]] -> [(String, Signal)])
-> StateT
     ([Int], SynthDef as18, VarSet as18) Identity [[(String, Signal)]]
-> StateT
     ([Int], SynthDef as18, VarSet as18) Identity [(String, Signal)]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [StateT
   ([Int], SynthDef as18, VarSet as18) Identity [(String, Signal)]]
-> StateT
     ([Int], SynthDef as18, VarSet as18) Identity [[(String, Signal)]]
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
sequence [(UA a as0, UA b as1, UA c as2)
-> SDBody (UA a as0, UA b as1, UA c as2) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA (UA a as0
a,UA b as1
b,UA c as2
c), (UA d as3, UA e as4, UA f as5)
-> SDBody (UA d as3, UA e as4, UA f as5) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA (UA d as3
d,UA e as4
e,UA f as5
f), (UA g as6, UA h as7, UA i as8)
-> SDBody (UA g as6, UA h as7, UA i as8) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA (UA g as6
g,UA h as7
h,UA i as8
i), (UA j as9, UA k as10, UA l as11)
-> SDBody (UA j as9, UA k as10, UA l as11) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA (UA j as9
j,UA k as10
k,UA l as11
l), (UA m as12, UA n as13, UA o as14)
-> SDBody (UA m as12, UA n as13, UA o as14) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA (UA m as12
m,UA n as13
n,UA o as14
o), (UA p as15, UA q as16, UA r as17)
-> SDBody (UA p as15, UA q as16, UA r as17) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA (UA p as15
p,UA q as16
q,UA r as17
r), UA s as18 -> SDBody (UA s as18) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA (UA s as18
s)]

instance (AllEqual '[as0,as1,as2,as3,as4,as5,as6,as7,as8,as9,as10,as11,as12,as13,as14,as15,as16,as17,as18,as19]
         ,AllKnownSymbols '[a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t])
         => FromUA (UA a as0, UA b as1, UA c as2, UA d as3, UA e as4, UA f as5
                   ,UA g as6,UA h as7,UA i as8,UA j as9,UA k as10,UA l as11
                   ,UA m as12,UA n as13,UA o as14,UA p as15,UA q as16
                   ,UA r as17, UA s as18,UA t as19
                   ) where
   type UAsArgs (UA a as0, UA b as1, UA c as2, UA d as3, UA e as4, UA f as5
                ,UA g as6,UA h as7,UA i as8,UA j as9,UA k as10,UA l as11
                ,UA m as12,UA n as13,UA o as14,UA p as15,UA q as16,UA r as17
                ,UA s as18,UA t as19) =
          '[a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t]
   type SDBodyArgs (UA a as0, UA b as1, UA c as2, UA d as3, UA e as4, UA f as5
                  ,UA g as6,UA h as7,UA i as8,UA j as9,UA k as10,UA l as11
                  ,UA m as12,UA n as13,UA o as14,UA p as15,UA q as16,UA r as17
                  ,UA s as18,UA t as19) = as0
   fromUA :: (UA a as0, UA b as1, UA c as2, UA d as3, UA e as4, UA f as5,
 UA g as6, UA h as7, UA i as8, UA j as9, UA k as10, UA l as11,
 UA m as12, UA n as13, UA o as14, UA p as15, UA q as16, UA r as17,
 UA s as18, UA t as19)
-> SDBody
     (UA a as0, UA b as1, UA c as2, UA d as3, UA e as4, UA f as5,
      UA g as6, UA h as7, UA i as8, UA j as9, UA k as10, UA l as11,
      UA m as12, UA n as13, UA o as14, UA p as15, UA q as16, UA r as17,
      UA s as18, UA t as19)
     [(String, Signal)]
fromUA (UA a as0
a,UA b as1
b,UA c as2
c,UA d as3
d,UA e as4
e,UA f as5
f,UA g as6
g,UA h as7
h,UA i as8
i,UA j as9
j,UA k as10
k,UA l as11
l,UA m as12
m,UA n as13
n,UA o as14
o,UA p as15
p,UA q as16
q,UA r as17
r,UA s as18
s,UA t as19
t) =
      -- (<>) <$> fromUA (a,b,c,d,e,f,g,h,i,j) <*> fromUA (k,l,m,n,o,p,q,r,s,t)
      [[(String, Signal)]] -> [(String, Signal)]
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat ([[(String, Signal)]] -> [(String, Signal)])
-> StateT
     ([Int], SynthDef as19, VarSet as19) Identity [[(String, Signal)]]
-> StateT
     ([Int], SynthDef as19, VarSet as19) Identity [(String, Signal)]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [StateT
   ([Int], SynthDef as19, VarSet as19) Identity [(String, Signal)]]
-> StateT
     ([Int], SynthDef as19, VarSet as19) Identity [[(String, Signal)]]
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
sequence [(UA a as0, UA b as1, UA c as2)
-> SDBody (UA a as0, UA b as1, UA c as2) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA (UA a as0
a,UA b as1
b,UA c as2
c), (UA d as3, UA e as4, UA f as5)
-> SDBody (UA d as3, UA e as4, UA f as5) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA (UA d as3
d,UA e as4
e,UA f as5
f), (UA g as6, UA h as7, UA i as8)
-> SDBody (UA g as6, UA h as7, UA i as8) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA (UA g as6
g,UA h as7
h,UA i as8
i), (UA j as9, UA k as10, UA l as11)
-> SDBody (UA j as9, UA k as10, UA l as11) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA (UA j as9
j,UA k as10
k,UA l as11
l), (UA m as12, UA n as13, UA o as14)
-> SDBody (UA m as12, UA n as13, UA o as14) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA (UA m as12
m,UA n as13
n,UA o as14
o), (UA p as15, UA q as16, UA r as17)
-> SDBody (UA p as15, UA q as16, UA r as17) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA (UA p as15
p,UA q as16
q,UA r as17
r), (UA s as18, UA t as19)
-> SDBody (UA s as18, UA t as19) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA (UA s as18
s,UA t as19
t)]

instance (AllEqual '[as0,as1,as2,as3,as4,as5,as6,as7,as8,as9,as10,as11,as12,as13,as14,as15,as16,as17,as18,as19,as20]
         ,AllKnownSymbols '[a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u])
         => FromUA (UA a as0, UA b as1, UA c as2, UA d as3, UA e as4, UA f as5
                   ,UA g as6,UA h as7,UA i as8,UA j as9,UA k as10,UA l as11
                   ,UA m as12,UA n as13,UA o as14,UA p as15,UA q as16
                   ,UA r as17, UA s as18,UA t as19,UA u as20
                   ) where
   type UAsArgs (UA a as0, UA b as1, UA c as2, UA d as3, UA e as4, UA f as5
                ,UA g as6,UA h as7,UA i as8,UA j as9,UA k as10,UA l as11
                ,UA m as12,UA n as13,UA o as14,UA p as15,UA q as16,UA r as17
                ,UA s as18,UA t as19,UA u as20
                ) =
          '[a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u]
   type SDBodyArgs (UA a as0, UA b as1, UA c as2, UA d as3, UA e as4, UA f as5
                  ,UA g as6,UA h as7,UA i as8,UA j as9,UA k as10,UA l as11
                  ,UA m as12,UA n as13,UA o as14,UA p as15,UA q as16,UA r as17
                  ,UA s as18,UA t as19,UA u as20
                  ) = as0
   fromUA :: (UA a as0, UA b as1, UA c as2, UA d as3, UA e as4, UA f as5,
 UA g as6, UA h as7, UA i as8, UA j as9, UA k as10, UA l as11,
 UA m as12, UA n as13, UA o as14, UA p as15, UA q as16, UA r as17,
 UA s as18, UA t as19, UA u as20)
-> SDBody
     (UA a as0, UA b as1, UA c as2, UA d as3, UA e as4, UA f as5,
      UA g as6, UA h as7, UA i as8, UA j as9, UA k as10, UA l as11,
      UA m as12, UA n as13, UA o as14, UA p as15, UA q as16, UA r as17,
      UA s as18, UA t as19, UA u as20)
     [(String, Signal)]
fromUA (UA a as0
a,UA b as1
b,UA c as2
c,UA d as3
d,UA e as4
e,UA f as5
f,UA g as6
g,UA h as7
h,UA i as8
i,UA j as9
j,UA k as10
k,UA l as11
l,UA m as12
m,UA n as13
n,UA o as14
o,UA p as15
p,UA q as16
q,UA r as17
r,UA s as18
s,UA t as19
t,UA u as20
u) =
      -- (<>) <$> fromUA (a,b,c,d,e,f,g,h,i,j,k) <*> fromUA (l,m,n,o,p,q,r,s,t,u)
      [[(String, Signal)]] -> [(String, Signal)]
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat ([[(String, Signal)]] -> [(String, Signal)])
-> StateT
     ([Int], SynthDef as20, VarSet as20) Identity [[(String, Signal)]]
-> StateT
     ([Int], SynthDef as20, VarSet as20) Identity [(String, Signal)]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [StateT
   ([Int], SynthDef as20, VarSet as20) Identity [(String, Signal)]]
-> StateT
     ([Int], SynthDef as20, VarSet as20) Identity [[(String, Signal)]]
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
sequence [(UA a as0, UA b as1, UA c as2)
-> SDBody (UA a as0, UA b as1, UA c as2) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA (UA a as0
a,UA b as1
b,UA c as2
c), (UA d as3, UA e as4, UA f as5)
-> SDBody (UA d as3, UA e as4, UA f as5) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA (UA d as3
d,UA e as4
e,UA f as5
f), (UA g as6, UA h as7, UA i as8)
-> SDBody (UA g as6, UA h as7, UA i as8) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA (UA g as6
g,UA h as7
h,UA i as8
i), (UA j as9, UA k as10, UA l as11)
-> SDBody (UA j as9, UA k as10, UA l as11) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA (UA j as9
j,UA k as10
k,UA l as11
l), (UA m as12, UA n as13, UA o as14)
-> SDBody (UA m as12, UA n as13, UA o as14) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA (UA m as12
m,UA n as13
n,UA o as14
o), (UA p as15, UA q as16, UA r as17)
-> SDBody (UA p as15, UA q as16, UA r as17) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA (UA p as15
p,UA q as16
q,UA r as17
r), (UA s as18, UA t as19, UA u as20)
-> SDBody (UA s as18, UA t as19, UA u as20) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA (UA s as18
s,UA t as19
t,UA u as20
u)]

instance (AllEqual '[as0,as1,as2,as3,as4,as5,as6,as7,as8,as9,as10,as11,as12,as13,as14,as15,as16,as17,as18,as19,as20,as21]
         ,AllKnownSymbols '[a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v])
         => FromUA (UA a as0, UA b as1, UA c as2, UA d as3, UA e as4, UA f as5
                   ,UA g as6,UA h as7,UA i as8,UA j as9,UA k as10,UA l as11
                   ,UA m as12,UA n as13,UA o as14,UA p as15,UA q as16
                   ,UA r as17, UA s as18,UA t as19,UA u as20,UA v as21
                   ) where
   type UAsArgs (UA a as0, UA b as1, UA c as2, UA d as3, UA e as4, UA f as5
                ,UA g as6,UA h as7,UA i as8,UA j as9,UA k as10,UA l as11
                ,UA m as12,UA n as13,UA o as14,UA p as15,UA q as16,UA r as17
                ,UA s as18,UA t as19,UA u as20,UA v as21
                ) =
          '[a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v]
   type SDBodyArgs (UA a as0, UA b as1, UA c as2, UA d as3, UA e as4, UA f as5
                  ,UA g as6,UA h as7,UA i as8,UA j as9,UA k as10,UA l as11
                  ,UA m as12,UA n as13,UA o as14,UA p as15,UA q as16,UA r as17
                  ,UA s as18,UA t as19,UA u as20,UA v as21
                  ) = as0
   fromUA :: (UA a as0, UA b as1, UA c as2, UA d as3, UA e as4, UA f as5,
 UA g as6, UA h as7, UA i as8, UA j as9, UA k as10, UA l as11,
 UA m as12, UA n as13, UA o as14, UA p as15, UA q as16, UA r as17,
 UA s as18, UA t as19, UA u as20, UA v as21)
-> SDBody
     (UA a as0, UA b as1, UA c as2, UA d as3, UA e as4, UA f as5,
      UA g as6, UA h as7, UA i as8, UA j as9, UA k as10, UA l as11,
      UA m as12, UA n as13, UA o as14, UA p as15, UA q as16, UA r as17,
      UA s as18, UA t as19, UA u as20, UA v as21)
     [(String, Signal)]
fromUA (UA a as0
a,UA b as1
b,UA c as2
c,UA d as3
d,UA e as4
e,UA f as5
f,UA g as6
g,UA h as7
h,UA i as8
i,UA j as9
j,UA k as10
k,UA l as11
l,UA m as12
m,UA n as13
n,UA o as14
o,UA p as15
p,UA q as16
q,UA r as17
r,UA s as18
s,UA t as19
t,UA u as20
u,UA v as21
v) =
      -- (<>) <$> fromUA (a,b,c,d,e,f,g,h,i,j,k) <*> fromUA (l,m,n,o,p,q,r,s,t,u,v)
      [[(String, Signal)]] -> [(String, Signal)]
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat ([[(String, Signal)]] -> [(String, Signal)])
-> StateT
     ([Int], SynthDef as21, VarSet as21) Identity [[(String, Signal)]]
-> StateT
     ([Int], SynthDef as21, VarSet as21) Identity [(String, Signal)]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [StateT
   ([Int], SynthDef as21, VarSet as21) Identity [(String, Signal)]]
-> StateT
     ([Int], SynthDef as21, VarSet as21) Identity [[(String, Signal)]]
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
sequence [(UA a as0, UA b as1, UA c as2)
-> SDBody (UA a as0, UA b as1, UA c as2) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA (UA a as0
a,UA b as1
b,UA c as2
c), (UA d as3, UA e as4, UA f as5)
-> SDBody (UA d as3, UA e as4, UA f as5) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA (UA d as3
d,UA e as4
e,UA f as5
f), (UA g as6, UA h as7, UA i as8)
-> SDBody (UA g as6, UA h as7, UA i as8) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA (UA g as6
g,UA h as7
h,UA i as8
i), (UA j as9, UA k as10, UA l as11)
-> SDBody (UA j as9, UA k as10, UA l as11) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA (UA j as9
j,UA k as10
k,UA l as11
l), (UA m as12, UA n as13, UA o as14)
-> SDBody (UA m as12, UA n as13, UA o as14) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA (UA m as12
m,UA n as13
n,UA o as14
o), (UA p as15, UA q as16, UA r as17)
-> SDBody (UA p as15, UA q as16, UA r as17) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA (UA p as15
p,UA q as16
q,UA r as17
r), (UA s as18, UA t as19, UA u as20)
-> SDBody (UA s as18, UA t as19, UA u as20) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA (UA s as18
s,UA t as19
t,UA u as20
u), UA v as21 -> SDBody (UA v as21) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA (UA v as21
v)]

instance (AllEqual '[as0,as1,as2,as3,as4,as5,as6,as7,as8,as9,as10,as11,as12,as13,as14,as15,as16,as17,as18,as19,as20,as21,as22]
         ,AllKnownSymbols '[a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w])
         => FromUA (UA a as0, UA b as1, UA c as2, UA d as3, UA e as4, UA f as5
                   ,UA g as6,UA h as7,UA i as8,UA j as9,UA k as10,UA l as11
                   ,UA m as12,UA n as13,UA o as14,UA p as15,UA q as16
                   ,UA r as17, UA s as18,UA t as19,UA u as20,UA v as21
                   ,UA w as22
                   ) where
   type UAsArgs (UA a as0, UA b as1, UA c as2, UA d as3, UA e as4, UA f as5
                ,UA g as6,UA h as7,UA i as8,UA j as9,UA k as10,UA l as11
                ,UA m as12,UA n as13,UA o as14,UA p as15,UA q as16,UA r as17
                ,UA s as18,UA t as19,UA u as20,UA v as21,UA w as22
                ) =
          '[a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w]
   type SDBodyArgs (UA a as0, UA b as1, UA c as2, UA d as3, UA e as4, UA f as5
                  ,UA g as6,UA h as7,UA i as8,UA j as9,UA k as10,UA l as11
                  ,UA m as12,UA n as13,UA o as14,UA p as15,UA q as16,UA r as17
                  ,UA s as18,UA t as19,UA u as20,UA v as21,UA w as22
                  ) = as0
   fromUA :: (UA a as0, UA b as1, UA c as2, UA d as3, UA e as4, UA f as5,
 UA g as6, UA h as7, UA i as8, UA j as9, UA k as10, UA l as11,
 UA m as12, UA n as13, UA o as14, UA p as15, UA q as16, UA r as17,
 UA s as18, UA t as19, UA u as20, UA v as21, UA w as22)
-> SDBody
     (UA a as0, UA b as1, UA c as2, UA d as3, UA e as4, UA f as5,
      UA g as6, UA h as7, UA i as8, UA j as9, UA k as10, UA l as11,
      UA m as12, UA n as13, UA o as14, UA p as15, UA q as16, UA r as17,
      UA s as18, UA t as19, UA u as20, UA v as21, UA w as22)
     [(String, Signal)]
fromUA (UA a as0
a,UA b as1
b,UA c as2
c,UA d as3
d,UA e as4
e,UA f as5
f,UA g as6
g,UA h as7
h,UA i as8
i,UA j as9
j,UA k as10
k,UA l as11
l,UA m as12
m,UA n as13
n,UA o as14
o,UA p as15
p,UA q as16
q,UA r as17
r,UA s as18
s,UA t as19
t,UA u as20
u,UA v as21
v,UA w as22
w) =
      -- (<>) <$> fromUA (a,b,c,d,e,f,g,h,i,j,k,l) <*> fromUA (m,n,o,p,q,r,s,t,u,v,w)
      [[(String, Signal)]] -> [(String, Signal)]
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat ([[(String, Signal)]] -> [(String, Signal)])
-> StateT
     ([Int], SynthDef as22, VarSet as22) Identity [[(String, Signal)]]
-> StateT
     ([Int], SynthDef as22, VarSet as22) Identity [(String, Signal)]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [StateT
   ([Int], SynthDef as22, VarSet as22) Identity [(String, Signal)]]
-> StateT
     ([Int], SynthDef as22, VarSet as22) Identity [[(String, Signal)]]
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
sequence [(UA a as0, UA b as1, UA c as2)
-> SDBody (UA a as0, UA b as1, UA c as2) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA (UA a as0
a,UA b as1
b,UA c as2
c), (UA d as3, UA e as4, UA f as5)
-> SDBody (UA d as3, UA e as4, UA f as5) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA (UA d as3
d,UA e as4
e,UA f as5
f), (UA g as6, UA h as7, UA i as8)
-> SDBody (UA g as6, UA h as7, UA i as8) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA (UA g as6
g,UA h as7
h,UA i as8
i), (UA j as9, UA k as10, UA l as11)
-> SDBody (UA j as9, UA k as10, UA l as11) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA (UA j as9
j,UA k as10
k,UA l as11
l), (UA m as12, UA n as13, UA o as14)
-> SDBody (UA m as12, UA n as13, UA o as14) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA (UA m as12
m,UA n as13
n,UA o as14
o), (UA p as15, UA q as16, UA r as17)
-> SDBody (UA p as15, UA q as16, UA r as17) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA (UA p as15
p,UA q as16
q,UA r as17
r), (UA s as18, UA t as19, UA u as20)
-> SDBody (UA s as18, UA t as19, UA u as20) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA (UA s as18
s,UA t as19
t,UA u as20
u), (UA v as21, UA w as22)
-> SDBody (UA v as21, UA w as22) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA (UA v as21
v,UA w as22
w)]

instance (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]
         ,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])
         => FromUA (UA a as0, UA b as1, UA c as2, UA d as3, UA e as4, UA f as5
                   ,UA g as6,UA h as7,UA i as8,UA j as9,UA k as10,UA l as11
                   ,UA m as12,UA n as13,UA o as14,UA p as15,UA q as16
                   ,UA r as17, UA s as18,UA t as19,UA u as20,UA v as21
                   ,UA w as22,UA x as23
                   ) where
   type UAsArgs (UA a as0, UA b as1, UA c as2, UA d as3, UA e as4, UA f as5
                ,UA g as6,UA h as7,UA i as8,UA j as9,UA k as10,UA l as11
                ,UA m as12,UA n as13,UA o as14,UA p as15,UA q as16,UA r as17
                ,UA s as18,UA t as19,UA u as20,UA v as21,UA w as22,UA x as23
                ) =
          '[a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x]
   type SDBodyArgs (UA a as0, UA b as1, UA c as2, UA d as3, UA e as4, UA f as5
                  ,UA g as6,UA h as7,UA i as8,UA j as9,UA k as10,UA l as11
                  ,UA m as12,UA n as13,UA o as14,UA p as15,UA q as16,UA r as17
                  ,UA s as18,UA t as19,UA u as20,UA v as21,UA w as22,UA x as23
                  ) = as0
   fromUA :: (UA a as0, UA b as1, UA c as2, UA d as3, UA e as4, UA f as5,
 UA g as6, UA h as7, UA i as8, UA j as9, UA k as10, UA l as11,
 UA m as12, UA n as13, UA o as14, UA p as15, UA q as16, UA r as17,
 UA s as18, UA t as19, UA u as20, UA v as21, UA w as22, UA x as23)
-> SDBody
     (UA a as0, UA b as1, UA c as2, UA d as3, UA e as4, UA f as5,
      UA g as6, UA h as7, UA i as8, UA j as9, UA k as10, UA l as11,
      UA m as12, UA n as13, UA o as14, UA p as15, UA q as16, UA r as17,
      UA s as18, UA t as19, UA u as20, UA v as21, UA w as22, UA x as23)
     [(String, Signal)]
fromUA (UA a as0
a,UA b as1
b,UA c as2
c,UA d as3
d,UA e as4
e,UA f as5
f,UA g as6
g,UA h as7
h,UA i as8
i,UA j as9
j,UA k as10
k,UA l as11
l,UA m as12
m,UA n as13
n,UA o as14
o,UA p as15
p,UA q as16
q,UA r as17
r,UA s as18
s,UA t as19
t,UA u as20
u,UA v as21
v,UA w as22
w,UA x as23
x) =
      -- (<>) <$> fromUA (a,b,c,d,e,f,g,h,i,j,k,l) <*> fromUA (m,n,o,p,q,r,s,t,u,v,w,x)
      [[(String, Signal)]] -> [(String, Signal)]
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat ([[(String, Signal)]] -> [(String, Signal)])
-> StateT
     ([Int], SynthDef as23, VarSet as23) Identity [[(String, Signal)]]
-> StateT
     ([Int], SynthDef as23, VarSet as23) Identity [(String, Signal)]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [StateT
   ([Int], SynthDef as23, VarSet as23) Identity [(String, Signal)]]
-> StateT
     ([Int], SynthDef as23, VarSet as23) Identity [[(String, Signal)]]
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
sequence [(UA a as0, UA b as1, UA c as2)
-> SDBody (UA a as0, UA b as1, UA c as2) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA (UA a as0
a,UA b as1
b,UA c as2
c), (UA d as3, UA e as4, UA f as5)
-> SDBody (UA d as3, UA e as4, UA f as5) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA (UA d as3
d,UA e as4
e,UA f as5
f), (UA g as6, UA h as7, UA i as8)
-> SDBody (UA g as6, UA h as7, UA i as8) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA (UA g as6
g,UA h as7
h,UA i as8
i), (UA j as9, UA k as10, UA l as11)
-> SDBody (UA j as9, UA k as10, UA l as11) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA (UA j as9
j,UA k as10
k,UA l as11
l), (UA m as12, UA n as13, UA o as14)
-> SDBody (UA m as12, UA n as13, UA o as14) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA (UA m as12
m,UA n as13
n,UA o as14
o), (UA p as15, UA q as16, UA r as17)
-> SDBody (UA p as15, UA q as16, UA r as17) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA (UA p as15
p,UA q as16
q,UA r as17
r), (UA s as18, UA t as19, UA u as20)
-> SDBody (UA s as18, UA t as19, UA u as20) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA (UA s as18
s,UA t as19
t,UA u as20
u), (UA v as21, UA w as22, UA x as23)
-> SDBody (UA v as21, UA w as22, UA x as23) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA (UA v as21
v,UA w as22
w,UA x as23
x)]

instance (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]
         ,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])
         => FromUA (UA a as0, UA b as1, UA c as2, UA d as3, UA e as4, UA f as5
                   ,UA g as6,UA h as7,UA i as8,UA j as9,UA k as10,UA l as11
                   ,UA m as12,UA n as13,UA o as14,UA p as15,UA q as16
                   ,UA r as17, UA s as18,UA t as19,UA u as20,UA v as21
                   ,UA w as22,UA x as23,UA y as24
                   ) where
   type UAsArgs (UA a as0, UA b as1, UA c as2, UA d as3, UA e as4, UA f as5
                ,UA g as6,UA h as7,UA i as8,UA j as9,UA k as10,UA l as11
                ,UA m as12,UA n as13,UA o as14,UA p as15,UA q as16,UA r as17
                ,UA s as18,UA t as19,UA u as20,UA v as21,UA w as22,UA x as23
                ,UA y as24) =
          '[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]
   type SDBodyArgs (UA a as0, UA b as1, UA c as2, UA d as3, UA e as4, UA f as5
                  ,UA g as6,UA h as7,UA i as8,UA j as9,UA k as10,UA l as11
                  ,UA m as12,UA n as13,UA o as14,UA p as15,UA q as16,UA r as17
                  ,UA s as18,UA t as19,UA u as20,UA v as21,UA w as22,UA x as23
                  ,UA y as24) = as0
   fromUA :: (UA a as0, UA b as1, UA c as2, UA d as3, UA e as4, UA f as5,
 UA g as6, UA h as7, UA i as8, UA j as9, UA k as10, UA l as11,
 UA m as12, UA n as13, UA o as14, UA p as15, UA q as16, UA r as17,
 UA s as18, UA t as19, UA u as20, UA v as21, UA w as22, UA x as23,
 UA y as24)
-> SDBody
     (UA a as0, UA b as1, UA c as2, UA d as3, UA e as4, UA f as5,
      UA g as6, UA h as7, UA i as8, UA j as9, UA k as10, UA l as11,
      UA m as12, UA n as13, UA o as14, UA p as15, UA q as16, UA r as17,
      UA s as18, UA t as19, UA u as20, UA v as21, UA w as22, UA x as23,
      UA y as24)
     [(String, Signal)]
fromUA (UA a as0
a,UA b as1
b,UA c as2
c,UA d as3
d,UA e as4
e,UA f as5
f,UA g as6
g,UA h as7
h,UA i as8
i,UA j as9
j,UA k as10
k,UA l as11
l,UA m as12
m,UA n as13
n,UA o as14
o,UA p as15
p,UA q as16
q,UA r as17
r,UA s as18
s,UA t as19
t,UA u as20
u,UA v as21
v,UA w as22
w,UA x as23
x,UA y as24
y) =
      -- (<>) <$> fromUA (a,b,c,d,e,f,g,h,i,j,k,l,m) <*> fromUA (n,o,p,q,r,s,t,u,v,w,x,y)
      [[(String, Signal)]] -> [(String, Signal)]
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat ([[(String, Signal)]] -> [(String, Signal)])
-> StateT
     ([Int], SynthDef as24, VarSet as24) Identity [[(String, Signal)]]
-> StateT
     ([Int], SynthDef as24, VarSet as24) Identity [(String, Signal)]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [StateT
   ([Int], SynthDef as24, VarSet as24) Identity [(String, Signal)]]
-> StateT
     ([Int], SynthDef as24, VarSet as24) Identity [[(String, Signal)]]
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
sequence [(UA a as0, UA b as1, UA c as2)
-> SDBody (UA a as0, UA b as1, UA c as2) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA (UA a as0
a,UA b as1
b,UA c as2
c), (UA d as3, UA e as4, UA f as5)
-> SDBody (UA d as3, UA e as4, UA f as5) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA (UA d as3
d,UA e as4
e,UA f as5
f), (UA g as6, UA h as7, UA i as8)
-> SDBody (UA g as6, UA h as7, UA i as8) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA (UA g as6
g,UA h as7
h,UA i as8
i), (UA j as9, UA k as10, UA l as11)
-> SDBody (UA j as9, UA k as10, UA l as11) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA (UA j as9
j,UA k as10
k,UA l as11
l), (UA m as12, UA n as13, UA o as14)
-> SDBody (UA m as12, UA n as13, UA o as14) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA (UA m as12
m,UA n as13
n,UA o as14
o), (UA p as15, UA q as16, UA r as17)
-> SDBody (UA p as15, UA q as16, UA r as17) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA (UA p as15
p,UA q as16
q,UA r as17
r), (UA s as18, UA t as19, UA u as20)
-> SDBody (UA s as18, UA t as19, UA u as20) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA (UA s as18
s,UA t as19
t,UA u as20
u), (UA v as21, UA w as22, UA x as23)
-> SDBody (UA v as21, UA w as22, UA x as23) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA (UA v as21
v,UA w as22
w,UA x as23
x), UA y as24 -> SDBody (UA y as24) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA (UA y as24
y)]

instance (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]
         ,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])
         => FromUA (UA a as0, UA b as1, UA c as2, UA d as3, UA e as4, UA f as5
                   ,UA g as6,UA h as7,UA i as8,UA j as9,UA k as10,UA l as11
                   ,UA m as12,UA n as13,UA o as14,UA p as15,UA q as16
                   ,UA r as17, UA s as18,UA t as19,UA u as20,UA v as21
                   ,UA w as22,UA x as23,UA y as24,UA z as25
                   ) where
   type UAsArgs (UA a as0, UA b as1, UA c as2, UA d as3, UA e as4, UA f as5
                ,UA g as6,UA h as7,UA i as8,UA j as9,UA k as10,UA l as11
                ,UA m as12,UA n as13,UA o as14,UA p as15,UA q as16,UA r as17
                ,UA s as18,UA t as19,UA u as20,UA v as21,UA w as22,UA x as23
                ,UA y as24,UA z as25) =
          '[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]
   type SDBodyArgs (UA a as0, UA b as1, UA c as2, UA d as3, UA e as4, UA f as5
                  ,UA g as6,UA h as7,UA i as8,UA j as9,UA k as10,UA l as11
                  ,UA m as12,UA n as13,UA o as14,UA p as15,UA q as16,UA r as17
                  ,UA s as18,UA t as19,UA u as20,UA v as21,UA w as22,UA x as23
                  ,UA y as24,UA z as25) = as0
   fromUA :: (UA a as0, UA b as1, UA c as2, UA d as3, UA e as4, UA f as5,
 UA g as6, UA h as7, UA i as8, UA j as9, UA k as10, UA l as11,
 UA m as12, UA n as13, UA o as14, UA p as15, UA q as16, UA r as17,
 UA s as18, UA t as19, UA u as20, UA v as21, UA w as22, UA x as23,
 UA y as24, UA z as25)
-> SDBody
     (UA a as0, UA b as1, UA c as2, UA d as3, UA e as4, UA f as5,
      UA g as6, UA h as7, UA i as8, UA j as9, UA k as10, UA l as11,
      UA m as12, UA n as13, UA o as14, UA p as15, UA q as16, UA r as17,
      UA s as18, UA t as19, UA u as20, UA v as21, UA w as22, UA x as23,
      UA y as24, UA z as25)
     [(String, Signal)]
fromUA (UA a as0
a,UA b as1
b,UA c as2
c,UA d as3
d,UA e as4
e,UA f as5
f,UA g as6
g,UA h as7
h,UA i as8
i,UA j as9
j,UA k as10
k,UA l as11
l,UA m as12
m,UA n as13
n,UA o as14
o,UA p as15
p,UA q as16
q,UA r as17
r,UA s as18
s,UA t as19
t,UA u as20
u,UA v as21
v,UA w as22
w,UA x as23
x,UA y as24
y,UA z as25
z) =
      -- (<>) <$> fromUA (a,b,c,d,e,f,g,h,i,j,k,l,m) <*> fromUA (n,o,p,q,r,s,t,u,v,w,x,y,z)
      [[(String, Signal)]] -> [(String, Signal)]
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat ([[(String, Signal)]] -> [(String, Signal)])
-> StateT
     ([Int], SynthDef as25, VarSet as25) Identity [[(String, Signal)]]
-> StateT
     ([Int], SynthDef as25, VarSet as25) Identity [(String, Signal)]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [StateT
   ([Int], SynthDef as25, VarSet as25) Identity [(String, Signal)]]
-> StateT
     ([Int], SynthDef as25, VarSet as25) Identity [[(String, Signal)]]
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
sequence [(UA a as0, UA b as1, UA c as2)
-> SDBody (UA a as0, UA b as1, UA c as2) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA (UA a as0
a,UA b as1
b,UA c as2
c), (UA d as3, UA e as4, UA f as5)
-> SDBody (UA d as3, UA e as4, UA f as5) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA (UA d as3
d,UA e as4
e,UA f as5
f), (UA g as6, UA h as7, UA i as8)
-> SDBody (UA g as6, UA h as7, UA i as8) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA (UA g as6
g,UA h as7
h,UA i as8
i), (UA j as9, UA k as10, UA l as11)
-> SDBody (UA j as9, UA k as10, UA l as11) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA (UA j as9
j,UA k as10
k,UA l as11
l), (UA m as12, UA n as13, UA o as14)
-> SDBody (UA m as12, UA n as13, UA o as14) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA (UA m as12
m,UA n as13
n,UA o as14
o), (UA p as15, UA q as16, UA r as17)
-> SDBody (UA p as15, UA q as16, UA r as17) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA (UA p as15
p,UA q as16
q,UA r as17
r), (UA s as18, UA t as19, UA u as20)
-> SDBody (UA s as18, UA t as19, UA u as20) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA (UA s as18
s,UA t as19
t,UA u as20
u), (UA v as21, UA w as22, UA x as23)
-> SDBody (UA v as21, UA w as22, UA x as23) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA (UA v as21
v,UA w as22
w,UA x as23
x), (UA y as24, UA z as25)
-> SDBody (UA y as24, UA z as25) [(String, Signal)]
forall a. FromUA a => a -> SDBody a [(String, Signal)]
fromUA (UA y as24
y,UA z as25
z)]


-- | \"UGen Arg\"
data UA (name :: Symbol) (args :: [Symbol]) =
   KnownSymbol name => UA (SDBody' args Signal)


type family AllEqual (a :: [[Symbol]]) :: Constraint where
   AllEqual '[] = ()
   AllEqual (a ': '[b]) = (a ~ b)
   AllEqual (a ': b ': cs) = (a ~ b, (AllEqual (a ': cs)))

type family AllKnownSymbols (a :: [ks]) :: Constraint where
   AllKnownSymbols '[] = ()
   AllKnownSymbols (ks0 ': kss) = (KnownSymbol ks0, AllKnownSymbols kss)

type family EachElems (forEach :: [Symbol]) args :: Constraint where
   EachElems (x ': xs) args = (Elem x args, EachElems xs args)
   EachElems '[] args = ()

type family Args (required :: [Symbol])
                 (optional :: [Symbol])
                 args
            :: Constraint where
   Args required optional args =
      ( Subset required (UAsArgs args)
      , Subset (UAsArgs args) (SetUnion required optional)
      , FromUA args
      -- , EachElems required (UAsArgs args)
      -- , EachElems optional (UAsArgs args)
      )