{-# OPTIONS_GHC -fno-warn-orphans #-}
{-# Language
        TypeFamilies,
        FlexibleContexts,
        FlexibleInstances,
        RankNTypes,
        ScopedTypeVariables,
        InstanceSigs,
        AllowAmbiguousTypes,
        CPP #-}
module Csound.Typed.Types.Tuple(
    -- ** Tuple
    Tuple(..), TupleMethods, makeTupleMethods,
    fromTuple, toTuple, tupleArity, tupleRates, defTuple, mapTuple,

    -- ** Outs
    Sigs, outArity, Sig2s,

    -- *** Multiple outs
    multiOuts,
    ar1, ar2, ar4, ar6, ar8,

    -- ** Arguments
    Arg, arg, toNote, argArity, toArg,

    -- ** Logic functions
    ifTuple, guardedTuple, caseTuple,
    ifArg, guardedArg, caseArg,

    -- ** Constructors
    pureTuple
) where


import Control.Arrow
import Control.Applicative
import Control.Monad
import Data.Default
import Data.Boolean
import Data.Proxy

import Csound.Dynamic
import Csound.Typed.Types.Prim
import Csound.Typed.Types.SigSpace
import Csound.Typed.GlobalState.GE
import Csound.Typed.GlobalState.SE
import Csound.Typed.Types.TupleHelpers

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

data TupleMethods a = TupleMethods
    { forall a. TupleMethods a -> a -> GE [E]
fromTuple_  :: a -> GE [E]
    , forall a. TupleMethods a -> GE [E] -> a
toTuple_    :: GE [E] -> a
    , forall a. TupleMethods a -> Proxy a -> Int
tupleArity_ :: Proxy a -> Int
    , forall a. TupleMethods a -> Proxy a -> [Rate]
tupleRates_ :: Proxy a -> [Rate]
    , forall a. TupleMethods a -> a
defTuple_   :: a }

fromTuple :: Tuple a => a -> GE [E]
fromTuple :: forall a. Tuple a => a -> GE [E]
fromTuple = TupleMethods a -> a -> GE [E]
forall a. TupleMethods a -> a -> GE [E]
fromTuple_ TupleMethods a
forall a. Tuple a => TupleMethods a
tupleMethods

toTuple :: Tuple a => GE [E] -> a
toTuple :: forall a. Tuple a => GE [E] -> a
toTuple = TupleMethods a -> GE [E] -> a
forall a. TupleMethods a -> GE [E] -> a
toTuple_ TupleMethods a
forall a. Tuple a => TupleMethods a
tupleMethods

tupleArity :: Tuple a => Proxy a -> Int
tupleArity :: forall a. Tuple a => Proxy a -> Int
tupleArity = TupleMethods a -> Proxy a -> Int
forall a. TupleMethods a -> Proxy a -> Int
tupleArity_ TupleMethods a
forall a. Tuple a => TupleMethods a
tupleMethods

tupleRates :: Tuple a => Proxy a -> [Rate]
tupleRates :: forall a. Tuple a => Proxy a -> [Rate]
tupleRates = TupleMethods a -> Proxy a -> [Rate]
forall a. TupleMethods a -> Proxy a -> [Rate]
tupleRates_ TupleMethods a
forall a. Tuple a => TupleMethods a
tupleMethods

defTuple :: Tuple a => a
defTuple :: forall a. Tuple a => a
defTuple = TupleMethods a -> a
forall a. TupleMethods a -> a
defTuple_ TupleMethods a
forall a. Tuple a => TupleMethods a
tupleMethods

mapTuple :: Tuple a => (E -> E) -> a -> a
mapTuple :: forall a. Tuple a => (E -> E) -> a -> a
mapTuple E -> E
f a
a = GE [E] -> a
forall a. Tuple a => GE [E] -> a
toTuple (([E] -> [E]) -> GE [E] -> GE [E]
forall a b. (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((E -> E) -> [E] -> [E]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap E -> E
f) (GE [E] -> GE [E]) -> GE [E] -> GE [E]
forall a b. (a -> b) -> a -> b
$ a -> GE [E]
forall a. Tuple a => a -> GE [E]
fromTuple a
a)

-- | Defines instance of type class 'Tuple' for a new type in terms of an already defined one.
makeTupleMethods :: (Tuple a) => (a -> b) -> (b -> a) -> TupleMethods b
makeTupleMethods :: forall a b. Tuple a => (a -> b) -> (b -> a) -> TupleMethods b
makeTupleMethods a -> b
to b -> a
from = TupleMethods
    { fromTuple_ :: b -> GE [E]
fromTuple_  = a -> GE [E]
forall a. Tuple a => a -> GE [E]
fromTuple (a -> GE [E]) -> (b -> a) -> b -> GE [E]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. b -> a
from
    , toTuple_ :: GE [E] -> b
toTuple_    = a -> b
to (a -> b) -> (GE [E] -> a) -> GE [E] -> b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. GE [E] -> a
forall a. Tuple a => GE [E] -> a
toTuple
    , tupleArity_ :: Proxy b -> Int
tupleArity_ = Int -> Proxy b -> Int
forall a b. a -> b -> a
const (Int -> Proxy b -> Int) -> Int -> Proxy b -> Int
forall a b. (a -> b) -> a -> b
$ Proxy a -> Int
forall a. Tuple a => Proxy a -> Int
tupleArity (Proxy a -> Int) -> Proxy a -> Int
forall a b. (a -> b) -> a -> b
$ (a -> b) -> Proxy a
forall a b. (a -> b) -> Proxy a
proxy a -> b
to
    , tupleRates_ :: Proxy b -> [Rate]
tupleRates_ = [Rate] -> Proxy b -> [Rate]
forall a b. a -> b -> a
const ([Rate] -> Proxy b -> [Rate]) -> [Rate] -> Proxy b -> [Rate]
forall a b. (a -> b) -> a -> b
$ Proxy a -> [Rate]
forall a. Tuple a => Proxy a -> [Rate]
tupleRates (Proxy a -> [Rate]) -> Proxy a -> [Rate]
forall a b. (a -> b) -> a -> b
$ (a -> b) -> Proxy a
forall a b. (a -> b) -> Proxy a
proxy a -> b
to
    , defTuple_ :: b
defTuple_   = a -> b
to a
forall a. Tuple a => a
defTuple }
    where
      proxy :: (a -> b) -> Proxy a
      proxy :: forall a b. (a -> b) -> Proxy a
proxy = Proxy a -> (a -> b) -> Proxy a
forall a b. a -> b -> a
const Proxy a
forall {k} (t :: k). Proxy t
Proxy


-- Tuple instances

primTupleMethods :: (Val a, Default a) => Rate -> TupleMethods a
primTupleMethods :: forall a. (Val a, Default a) => Rate -> TupleMethods a
primTupleMethods Rate
rate = TupleMethods
        { fromTuple_ :: a -> GE [E]
fromTuple_ = (E -> [E]) -> GE E -> GE [E]
forall a b. (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap E -> [E]
forall a. a -> [a]
forall (m :: * -> *) a. Monad m => a -> m a
return (GE E -> GE [E]) -> (a -> GE E) -> a -> GE [E]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> GE E
forall a. Val a => a -> GE E
toGE
        , toTuple_ :: GE [E] -> a
toTuple_ = GE E -> a
forall a. Val a => GE E -> a
fromGE (GE E -> a) -> (GE [E] -> GE E) -> GE [E] -> a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ([E] -> E) -> GE [E] -> GE E
forall a b. (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap [E] -> E
forall a. HasCallStack => [a] -> a
head
        , tupleArity_ :: Proxy a -> Int
tupleArity_ = Int -> Proxy a -> Int
forall a b. a -> b -> a
const Int
1
        , tupleRates_ :: Proxy a -> [Rate]
tupleRates_ = [Rate] -> Proxy a -> [Rate]
forall a b. a -> b -> a
const [Rate
rate]
        , defTuple_ :: a
defTuple_   = a
forall a. Default a => a
def }

instance Tuple Unit where
    tupleMethods :: TupleMethods Unit
tupleMethods = TupleMethods
        { fromTuple_ :: Unit -> GE [E]
fromTuple_  = \Unit
x -> Unit -> GE ()
unUnit Unit
x GE () -> GE [E] -> GE [E]
forall a b. GE a -> GE b -> GE b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ([E] -> GE [E]
forall a. a -> GE a
forall (m :: * -> *) a. Monad m => a -> m a
return [])
        , toTuple_ :: GE [E] -> Unit
toTuple_    = \GE [E]
es -> GE () -> Unit
Unit (GE () -> Unit) -> GE () -> Unit
forall a b. (a -> b) -> a -> b
$ GE [E]
es GE [E] -> GE () -> GE ()
forall a b. GE a -> GE b -> GE b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> () -> GE ()
forall a. a -> GE a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
        , tupleArity_ :: Proxy Unit -> Int
tupleArity_ = Int -> Proxy Unit -> Int
forall a b. a -> b -> a
const Int
0
        , tupleRates_ :: Proxy Unit -> [Rate]
tupleRates_ = [Rate] -> Proxy Unit -> [Rate]
forall a b. a -> b -> a
const []
        , defTuple_ :: Unit
defTuple_   = GE () -> Unit
Unit (GE () -> Unit) -> GE () -> Unit
forall a b. (a -> b) -> a -> b
$ () -> GE ()
forall a. a -> GE a
forall (m :: * -> *) a. Monad m => a -> m a
return () }

instance Tuple Sig   where tupleMethods :: TupleMethods Sig
tupleMethods = Rate -> TupleMethods Sig
forall a. (Val a, Default a) => Rate -> TupleMethods a
primTupleMethods Rate
Ar
instance Tuple D     where tupleMethods :: TupleMethods D
tupleMethods = Rate -> TupleMethods D
forall a. (Val a, Default a) => Rate -> TupleMethods a
primTupleMethods Rate
Kr
instance Tuple Tab   where tupleMethods :: TupleMethods Tab
tupleMethods = Rate -> TupleMethods Tab
forall a. (Val a, Default a) => Rate -> TupleMethods a
primTupleMethods Rate
Kr
instance Tuple Str   where tupleMethods :: TupleMethods Str
tupleMethods = Rate -> TupleMethods Str
forall a. (Val a, Default a) => Rate -> TupleMethods a
primTupleMethods Rate
Sr
instance Tuple Spec  where tupleMethods :: TupleMethods Spec
tupleMethods = Rate -> TupleMethods Spec
forall a. (Val a, Default a) => Rate -> TupleMethods a
primTupleMethods Rate
Fr

instance Tuple TabList where tupleMethods :: TupleMethods TabList
tupleMethods = Rate -> TupleMethods TabList
forall a. (Val a, Default a) => Rate -> TupleMethods a
primTupleMethods Rate
Kr

instance (Tuple a, Tuple b) => Tuple (a, b) where
    tupleMethods :: TupleMethods (a, b)
tupleMethods = TupleMethods
        { fromTuple_ :: (a, b) -> GE [E]
fromTuple_ = \(a
a, b
b) -> ([E] -> [E] -> [E]) -> GE [E] -> GE [E] -> GE [E]
forall a b c. (a -> b -> c) -> GE a -> GE b -> GE c
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 [E] -> [E] -> [E]
forall a. [a] -> [a] -> [a]
(++) (a -> GE [E]
forall a. Tuple a => a -> GE [E]
fromTuple a
a) (b -> GE [E]
forall a. Tuple a => a -> GE [E]
fromTuple b
b)
        , tupleArity_ :: Proxy (a, b) -> Int
tupleArity_ = \Proxy (a, b)
x -> let (Proxy a
a, Proxy b
b) = Proxy (a, b) -> (Proxy a, Proxy b)
forall a b. Proxy (a, b) -> (Proxy a, Proxy b)
splitProxy Proxy (a, b)
x in Proxy a -> Int
forall a. Tuple a => Proxy a -> Int
tupleArity Proxy a
a Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Proxy b -> Int
forall a. Tuple a => Proxy a -> Int
tupleArity Proxy b
b
        , toTuple_ :: GE [E] -> (a, b)
toTuple_ = \GE [E]
xs ->
                let a :: a
a = GE [E] -> a
forall a. Tuple a => GE [E] -> a
toTuple (GE [E] -> a) -> GE [E] -> a
forall a b. (a -> b) -> a -> b
$ ([E] -> [E]) -> GE [E] -> GE [E]
forall a b. (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Int -> [E] -> [E]
forall a. Int -> [a] -> [a]
take (Proxy a -> Int
forall a. Tuple a => Proxy a -> Int
tupleArity (Proxy a -> Int) -> Proxy a -> Int
forall a b. (a -> b) -> a -> b
$ a -> Proxy a
forall a. a -> Proxy a
proxyAsType a
a)) GE [E]
xs
                    xsb :: GE [E]
xsb = ([E] -> [E]) -> GE [E] -> GE [E]
forall a b. (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Int -> [E] -> [E]
forall a. Int -> [a] -> [a]
drop (Proxy a -> Int
forall a. Tuple a => Proxy a -> Int
tupleArity (Proxy a -> Int) -> Proxy a -> Int
forall a b. (a -> b) -> a -> b
$ a -> Proxy a
forall a. a -> Proxy a
proxyAsType a
a)) GE [E]
xs
                    b :: b
b = GE [E] -> b
forall a. Tuple a => GE [E] -> a
toTuple (GE [E] -> b) -> GE [E] -> b
forall a b. (a -> b) -> a -> b
$ ([E] -> [E]) -> GE [E] -> GE [E]
forall a b. (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Int -> [E] -> [E]
forall a. Int -> [a] -> [a]
take (Proxy b -> Int
forall a. Tuple a => Proxy a -> Int
tupleArity (Proxy b -> Int) -> Proxy b -> Int
forall a b. (a -> b) -> a -> b
$ b -> Proxy b
forall a. a -> Proxy a
proxyAsType b
b)) GE [E]
xsb
                in (a
a, b
b)

        , tupleRates_ :: Proxy (a, b) -> [Rate]
tupleRates_ = \Proxy (a, b)
x -> let (Proxy a
a, Proxy b
b) = Proxy (a, b) -> (Proxy a, Proxy b)
forall a b. Proxy (a, b) -> (Proxy a, Proxy b)
splitProxy Proxy (a, b)
x in Proxy a -> [Rate]
forall a. Tuple a => Proxy a -> [Rate]
tupleRates Proxy a
a [Rate] -> [Rate] -> [Rate]
forall a. [a] -> [a] -> [a]
++ Proxy b -> [Rate]
forall a. Tuple a => Proxy a -> [Rate]
tupleRates Proxy b
b
        , defTuple_ :: (a, b)
defTuple_ = (a
forall a. Tuple a => a
defTuple, b
forall a. Tuple a => a
defTuple)
        }

proxyAsType :: a -> Proxy a
proxyAsType :: forall a. a -> Proxy a
proxyAsType = Proxy a -> a -> Proxy a
forall a b. a -> b -> a
const Proxy a
forall {k} (t :: k). Proxy t
Proxy

splitProxy :: Proxy (a, b) -> (Proxy a, Proxy b)
splitProxy :: forall a b. Proxy (a, b) -> (Proxy a, Proxy b)
splitProxy = (Proxy a, Proxy b) -> Proxy (a, b) -> (Proxy a, Proxy b)
forall a b. a -> b -> a
const (Proxy a
forall {k} (t :: k). Proxy t
Proxy, Proxy b
forall {k} (t :: k). Proxy t
Proxy)

instance (Tuple a, Tuple b, Tuple c) => Tuple (a, b, c) where tupleMethods :: TupleMethods (a, b, c)
tupleMethods = ((a, (b, c)) -> (a, b, c))
-> ((a, b, c) -> (a, (b, c))) -> TupleMethods (a, b, c)
forall a b. Tuple a => (a -> b) -> (b -> a) -> TupleMethods b
makeTupleMethods (a, (b, c)) -> (a, b, c)
forall a b c. (a, (b, c)) -> (a, b, c)
cons3 (a, b, c) -> (a, (b, c))
forall a b c. (a, b, c) -> (a, (b, c))
split3
instance (Tuple a, Tuple b, Tuple c, Tuple d) => Tuple (a, b, c, d) where tupleMethods :: TupleMethods (a, b, c, d)
tupleMethods = ((a, (b, c, d)) -> (a, b, c, d))
-> ((a, b, c, d) -> (a, (b, c, d))) -> TupleMethods (a, b, c, d)
forall a b. Tuple a => (a -> b) -> (b -> a) -> TupleMethods b
makeTupleMethods (a, (b, c, d)) -> (a, b, c, d)
forall a b c d. (a, (b, c, d)) -> (a, b, c, d)
cons4 (a, b, c, d) -> (a, (b, c, d))
forall a b c d. (a, b, c, d) -> (a, (b, c, d))
split4
instance (Tuple a, Tuple b, Tuple c, Tuple d, Tuple e) => Tuple (a, b, c, d, e) where tupleMethods :: TupleMethods (a, b, c, d, e)
tupleMethods = ((a, (b, c, d, e)) -> (a, b, c, d, e))
-> ((a, b, c, d, e) -> (a, (b, c, d, e)))
-> TupleMethods (a, b, c, d, e)
forall a b. Tuple a => (a -> b) -> (b -> a) -> TupleMethods b
makeTupleMethods (a, (b, c, d, e)) -> (a, b, c, d, e)
forall a b c d e. (a, (b, c, d, e)) -> (a, b, c, d, e)
cons5 (a, b, c, d, e) -> (a, (b, c, d, e))
forall a b c d e. (a, b, c, d, e) -> (a, (b, c, d, e))
split5
instance (Tuple a, Tuple b, Tuple c, Tuple d, Tuple e, Tuple f) => Tuple (a, b, c, d, e, f) where tupleMethods :: TupleMethods (a, b, c, d, e, f)
tupleMethods = ((a, (b, c, d, e, f)) -> (a, b, c, d, e, f))
-> ((a, b, c, d, e, f) -> (a, (b, c, d, e, f)))
-> TupleMethods (a, b, c, d, e, f)
forall a b. Tuple a => (a -> b) -> (b -> a) -> TupleMethods b
makeTupleMethods (a, (b, c, d, e, f)) -> (a, b, c, d, e, f)
forall a b c d e f. (a, (b, c, d, e, f)) -> (a, b, c, d, e, f)
cons6 (a, b, c, d, e, f) -> (a, (b, c, d, e, f))
forall a b c d e f. (a, b, c, d, e, f) -> (a, (b, c, d, e, f))
split6
instance (Tuple a, Tuple b, Tuple c, Tuple d, Tuple e, Tuple f, Tuple g) => Tuple (a, b, c, d, e, f, g) where tupleMethods :: TupleMethods (a, b, c, d, e, f, g)
tupleMethods = ((a, (b, c, d, e, f, g)) -> (a, b, c, d, e, f, g))
-> ((a, b, c, d, e, f, g) -> (a, (b, c, d, e, f, g)))
-> TupleMethods (a, b, c, d, e, f, g)
forall a b. Tuple a => (a -> b) -> (b -> a) -> TupleMethods b
makeTupleMethods (a, (b, c, d, e, f, g)) -> (a, b, c, d, e, f, g)
forall a b c d e f g.
(a, (b, c, d, e, f, g)) -> (a, b, c, d, e, f, g)
cons7 (a, b, c, d, e, f, g) -> (a, (b, c, d, e, f, g))
forall a b c d e f g.
(a, b, c, d, e, f, g) -> (a, (b, c, d, e, f, g))
split7
instance (Tuple a, Tuple b, Tuple c, Tuple d, Tuple e, Tuple f, Tuple g, Tuple h) => Tuple (a, b, c, d, e, f, g, h) where tupleMethods :: TupleMethods (a, b, c, d, e, f, g, h)
tupleMethods = ((a, (b, c, d, e, f, g, h)) -> (a, b, c, d, e, f, g, h))
-> ((a, b, c, d, e, f, g, h) -> (a, (b, c, d, e, f, g, h)))
-> TupleMethods (a, b, c, d, e, f, g, h)
forall a b. Tuple a => (a -> b) -> (b -> a) -> TupleMethods b
makeTupleMethods (a, (b, c, d, e, f, g, h)) -> (a, b, c, d, e, f, g, h)
forall a b c d e f g h.
(a, (b, c, d, e, f, g, h)) -> (a, b, c, d, e, f, g, h)
cons8 (a, b, c, d, e, f, g, h) -> (a, (b, c, d, e, f, g, h))
forall a b c d e f g h.
(a, b, c, d, e, f, g, h) -> (a, (b, c, d, e, f, g, h))
split8

-------------------------------------------------------------------------------
-- multiple outs

multiOuts :: forall a . Tuple a => E -> a
multiOuts :: forall a. Tuple a => E -> a
multiOuts E
expr =
  GE [E] -> a
forall a. Tuple a => GE [E] -> a
toTuple (GE [E] -> a) -> GE [E] -> a
forall a b. (a -> b) -> a -> b
$ [E] -> GE [E]
forall a. a -> GE a
forall (m :: * -> *) a. Monad m => a -> m a
return ([E] -> GE [E]) -> [E] -> GE [E]
forall a b. (a -> b) -> a -> b
$ [Rate] -> E -> [E]
mo (Proxy a -> [Rate]
forall a. Tuple a => Proxy a -> [Rate]
tupleRates (Proxy a
forall {k} (t :: k). Proxy t
Proxy :: Proxy a)) E
expr

ar1 :: Sig -> Sig
ar2 :: (Sig, Sig) -> (Sig, Sig)
ar4 :: (Sig, Sig, Sig, Sig) -> (Sig, Sig, Sig, Sig)
ar6 :: (Sig, Sig, Sig, Sig, Sig, Sig) -> (Sig, Sig, Sig, Sig, Sig, Sig)
ar8 :: (Sig, Sig, Sig, Sig, Sig, Sig, Sig, Sig) -> (Sig, Sig, Sig, Sig, Sig, Sig, Sig, Sig)

ar1 :: Sig -> Sig
ar1 = Sig -> Sig
forall a. a -> a
id;   ar2 :: (Sig, Sig) -> (Sig, Sig)
ar2 = (Sig, Sig) -> (Sig, Sig)
forall a. a -> a
id;   ar4 :: (Sig, Sig, Sig, Sig) -> (Sig, Sig, Sig, Sig)
ar4 = (Sig, Sig, Sig, Sig) -> (Sig, Sig, Sig, Sig)
forall a. a -> a
id;   ar6 :: (Sig, Sig, Sig, Sig, Sig, Sig) -> (Sig, Sig, Sig, Sig, Sig, Sig)
ar6 = (Sig, Sig, Sig, Sig, Sig, Sig) -> (Sig, Sig, Sig, Sig, Sig, Sig)
forall a. a -> a
id;   ar8 :: (Sig, Sig, Sig, Sig, Sig, Sig, Sig, Sig)
-> (Sig, Sig, Sig, Sig, Sig, Sig, Sig, Sig)
ar8 = (Sig, Sig, Sig, Sig, Sig, Sig, Sig, Sig)
-> (Sig, Sig, Sig, Sig, Sig, Sig, Sig, Sig)
forall a. a -> a
id

---------------------------------------------------------------------------------
-- out instances

-- | The tuples of signals.
class (Tuple a, Num a, Fractional a, SigSpace a, BindSig a) => Sigs a where
class (Sigs a, SigSpace2 a, BindSig2 a) => Sig2s a where

instance Sigs Sig

#if __GLASGOW_HASKELL__ >= 710
instance (Sigs a1, Sigs a2) => Sigs (a1, a2)
instance (Sigs a1, Sigs a2, Sigs a3) => Sigs (a1, a2, a3)
instance (Sigs a1, Sigs a2, Sigs a3, Sigs a4) => Sigs (a1, a2, a3, a4)
instance (Sigs a1, Sigs a2, Sigs a3, Sigs a4, Sigs a5) => Sigs (a1, a2, a3, a4, a5)
instance (Sigs a1, Sigs a2, Sigs a3, Sigs a4, Sigs a5, Sigs a6) => Sigs (a1, a2, a3, a4, a5, a6)
instance (Sigs a1, Sigs a2, Sigs a3, Sigs a4, Sigs a5, Sigs a6, Sigs a7) => Sigs (a1, a2, a3, a4, a5, a6, a7)
instance (Sigs a1, Sigs a2, Sigs a3, Sigs a4, Sigs a5, Sigs a6, Sigs a7, Sigs a8) => Sigs (a1, a2, a3, a4, a5, a6, a7, a8)
#else
instance Sigs (Sig, Sig)
instance Sigs (Sig, Sig, Sig)
instance Sigs (Sig, Sig, Sig, Sig)
instance Sigs (Sig, Sig, Sig, Sig, Sig)
instance Sigs (Sig, Sig, Sig, Sig, Sig, Sig)
instance Sigs (Sig, Sig, Sig, Sig, Sig, Sig, Sig)
instance Sigs (Sig, Sig, Sig, Sig, Sig, Sig, Sig, Sig)
#endif

instance Sig2s Sig
instance Sig2s Sig2
instance Sig2s Sig4
instance Sig2s Sig6
instance Sig2s Sig8

outArity :: forall a . Tuple a => SE a -> Int
outArity :: forall a. Tuple a => SE a -> Int
outArity = Int -> SE a -> Int
forall a b. a -> b -> a
const (Int -> SE a -> Int) -> Int -> SE a -> Int
forall a b. (a -> b) -> a -> b
$ Proxy a -> Int
forall a. Tuple a => Proxy a -> Int
tupleArity (Proxy a
forall {k} (t :: k). Proxy t
Proxy :: Proxy a)

---------------------------------------------------------------------------
-- Arguments

class (Tuple a) => Arg a where
  getArgRates :: [Rate]

instance Arg Unit where
  getArgRates :: [Rate]
getArgRates = []

instance Arg D where
  getArgRates :: [Rate]
getArgRates = [Rate
Ir]

instance Arg Str where
  getArgRates :: [Rate]
getArgRates = [Rate
Sr]

instance Arg Tab where
  getArgRates :: [Rate]
getArgRates = [Rate
Ir]

instance Arg TabList where
  getArgRates :: [Rate]
getArgRates = [Rate
Ir]

instance (Arg a, Arg b) => Arg (a, b) where
  getArgRates :: [Rate]
getArgRates = forall a. Arg a => [Rate]
getArgRates @a [Rate] -> [Rate] -> [Rate]
forall a. Semigroup a => a -> a -> a
<> forall a. Arg a => [Rate]
getArgRates @b

instance (Arg a, Arg b, Arg c) => Arg (a, b, c) where
  getArgRates :: [Rate]
getArgRates = forall a. Arg a => [Rate]
getArgRates @a [Rate] -> [Rate] -> [Rate]
forall a. Semigroup a => a -> a -> a
<> forall a. Arg a => [Rate]
getArgRates @b [Rate] -> [Rate] -> [Rate]
forall a. Semigroup a => a -> a -> a
<> forall a. Arg a => [Rate]
getArgRates @c
instance (Arg a, Arg b, Arg c, Arg d) => Arg (a, b, c, d) where
  getArgRates :: [Rate]
getArgRates = forall a. Arg a => [Rate]
getArgRates @a [Rate] -> [Rate] -> [Rate]
forall a. Semigroup a => a -> a -> a
<> forall a. Arg a => [Rate]
getArgRates @b [Rate] -> [Rate] -> [Rate]
forall a. Semigroup a => a -> a -> a
<> forall a. Arg a => [Rate]
getArgRates @c [Rate] -> [Rate] -> [Rate]
forall a. Semigroup a => a -> a -> a
<> forall a. Arg a => [Rate]
getArgRates @d
instance (Arg a, Arg b, Arg c, Arg d, Arg e) => Arg (a, b, c, d, e) where
  getArgRates :: [Rate]
getArgRates = forall a. Arg a => [Rate]
getArgRates @a [Rate] -> [Rate] -> [Rate]
forall a. Semigroup a => a -> a -> a
<> forall a. Arg a => [Rate]
getArgRates @b [Rate] -> [Rate] -> [Rate]
forall a. Semigroup a => a -> a -> a
<> forall a. Arg a => [Rate]
getArgRates @c [Rate] -> [Rate] -> [Rate]
forall a. Semigroup a => a -> a -> a
<> forall a. Arg a => [Rate]
getArgRates @d [Rate] -> [Rate] -> [Rate]
forall a. Semigroup a => a -> a -> a
<> forall a. Arg a => [Rate]
getArgRates @e
instance (Arg a, Arg b, Arg c, Arg d, Arg e, Arg f) => Arg (a, b, c, d, e, f) where
  getArgRates :: [Rate]
getArgRates = forall a. Arg a => [Rate]
getArgRates @a [Rate] -> [Rate] -> [Rate]
forall a. Semigroup a => a -> a -> a
<> forall a. Arg a => [Rate]
getArgRates @b [Rate] -> [Rate] -> [Rate]
forall a. Semigroup a => a -> a -> a
<> forall a. Arg a => [Rate]
getArgRates @c [Rate] -> [Rate] -> [Rate]
forall a. Semigroup a => a -> a -> a
<> forall a. Arg a => [Rate]
getArgRates @d [Rate] -> [Rate] -> [Rate]
forall a. Semigroup a => a -> a -> a
<> forall a. Arg a => [Rate]
getArgRates @e [Rate] -> [Rate] -> [Rate]
forall a. Semigroup a => a -> a -> a
<> forall a. Arg a => [Rate]
getArgRates @f
instance (Arg a, Arg b, Arg c, Arg d, Arg e, Arg f, Arg h) => Arg (a, b, c, d, e, f, h) where
  getArgRates :: [Rate]
getArgRates = forall a. Arg a => [Rate]
getArgRates @a [Rate] -> [Rate] -> [Rate]
forall a. Semigroup a => a -> a -> a
<> forall a. Arg a => [Rate]
getArgRates @b [Rate] -> [Rate] -> [Rate]
forall a. Semigroup a => a -> a -> a
<> forall a. Arg a => [Rate]
getArgRates @c [Rate] -> [Rate] -> [Rate]
forall a. Semigroup a => a -> a -> a
<> forall a. Arg a => [Rate]
getArgRates @d [Rate] -> [Rate] -> [Rate]
forall a. Semigroup a => a -> a -> a
<> forall a. Arg a => [Rate]
getArgRates @e [Rate] -> [Rate] -> [Rate]
forall a. Semigroup a => a -> a -> a
<> forall a. Arg a => [Rate]
getArgRates @f [Rate] -> [Rate] -> [Rate]
forall a. Semigroup a => a -> a -> a
<> forall a. Arg a => [Rate]
getArgRates @h
instance (Arg a, Arg b, Arg c, Arg d, Arg e, Arg f, Arg h, Arg g) => Arg (a, b, c, d, e, f, h, g) where
  getArgRates :: [Rate]
getArgRates = forall a. Arg a => [Rate]
getArgRates @a [Rate] -> [Rate] -> [Rate]
forall a. Semigroup a => a -> a -> a
<> forall a. Arg a => [Rate]
getArgRates @b [Rate] -> [Rate] -> [Rate]
forall a. Semigroup a => a -> a -> a
<> forall a. Arg a => [Rate]
getArgRates @c [Rate] -> [Rate] -> [Rate]
forall a. Semigroup a => a -> a -> a
<> forall a. Arg a => [Rate]
getArgRates @d [Rate] -> [Rate] -> [Rate]
forall a. Semigroup a => a -> a -> a
<> forall a. Arg a => [Rate]
getArgRates @e [Rate] -> [Rate] -> [Rate]
forall a. Semigroup a => a -> a -> a
<> forall a. Arg a => [Rate]
getArgRates @f [Rate] -> [Rate] -> [Rate]
forall a. Semigroup a => a -> a -> a
<> forall a. Arg a => [Rate]
getArgRates @h [Rate] -> [Rate] -> [Rate]
forall a. Semigroup a => a -> a -> a
<> forall a. Arg a => [Rate]
getArgRates @g

arg :: forall a . Arg a => Int -> a
arg :: forall a. Arg a => Int -> a
arg Int
n = GE [E] -> a
forall a. Tuple a => GE [E] -> a
toTuple (GE [E] -> a) -> GE [E] -> a
forall a b. (a -> b) -> a -> b
$ [E] -> GE [E]
forall a. a -> GE a
forall (m :: * -> *) a. Monad m => a -> m a
return ([E] -> GE [E]) -> [E] -> GE [E]
forall a b. (a -> b) -> a -> b
$ (Rate -> Int -> E) -> [Rate] -> [Int] -> [E]
forall a b c. (a -> b -> c) -> [a] -> [b] -> [c]
zipWith Rate -> Int -> E
pn (forall a. Arg a => [Rate]
getArgRates @a) [Int
n ..]

toArg :: Arg a => a
toArg :: forall a. Arg a => a
toArg = Int -> a
forall a. Arg a => Int -> a
arg Int
4

argArity :: forall a . Arg a => a -> Int
argArity :: forall a. Arg a => a -> Int
argArity = Int -> a -> Int
forall a b. a -> b -> a
const (Proxy a -> Int
forall a. Tuple a => Proxy a -> Int
tupleArity (Proxy a
forall {k} (t :: k). Proxy t
Proxy :: Proxy a))

toNote :: forall a . Arg a => a -> GE [E]
toNote :: forall a. Arg a => a -> GE [E]
toNote a
a = (Rate -> E -> GE E) -> [Rate] -> [E] -> GE [E]
forall (m :: * -> *) a b c.
Applicative m =>
(a -> b -> m c) -> [a] -> [b] -> m [c]
zipWithM Rate -> E -> GE E
phi (Proxy a -> [Rate]
forall a. Tuple a => Proxy a -> [Rate]
tupleRates (Proxy a
forall {k} (t :: k). Proxy t
Proxy :: Proxy a)) ([E] -> GE [E]) -> GE [E] -> GE [E]
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< a -> GE [E]
forall a. Tuple a => a -> GE [E]
fromTuple a
a
    where
        phi :: Rate -> E -> GE E
phi Rate
rate E
x = case Rate
rate of
            Rate
Sr -> Text -> GE E
saveStr (Text -> GE E) -> Text -> GE E
forall a b. (a -> b) -> a -> b
$ E -> Text
getStringUnsafe E
x
            Rate
_  -> E -> GE E
forall a. a -> GE a
forall (m :: * -> *) a. Monad m => a -> m a
return E
x

        getStringUnsafe :: E -> Text
getStringUnsafe E
x = case E -> Prim
getPrimUnsafe E
x of
            PrimString Text
y    -> Text
y
            Prim
_               -> [Char] -> Text
forall a. HasCallStack => [Char] -> a
error [Char]
"Arg(Str):getStringUnsafe value is not a string"

-------------------------------------------------------------------------
-- logic functions

-- tuples

newtype BoolTuple = BoolTuple { BoolTuple -> GE [E]
unBoolTuple :: GE [E] }

toBoolTuple :: Tuple a => a -> BoolTuple
toBoolTuple :: forall a. Tuple a => a -> BoolTuple
toBoolTuple   = GE [E] -> BoolTuple
BoolTuple (GE [E] -> BoolTuple) -> (a -> GE [E]) -> a -> BoolTuple
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> GE [E]
forall a. Tuple a => a -> GE [E]
fromTuple

fromBoolTuple :: Tuple a => BoolTuple -> a
fromBoolTuple :: forall a. Tuple a => BoolTuple -> a
fromBoolTuple = GE [E] -> a
forall a. Tuple a => GE [E] -> a
toTuple (GE [E] -> a) -> (BoolTuple -> GE [E]) -> BoolTuple -> a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. BoolTuple -> GE [E]
unBoolTuple

type instance BooleanOf BoolTuple = BoolSig

instance IfB BoolTuple where
    ifB :: forall bool.
(bool ~ BooleanOf BoolTuple) =>
bool -> BoolTuple -> BoolTuple -> BoolTuple
ifB bool
mp (BoolTuple GE [E]
mas) (BoolTuple GE [E]
mbs) = GE [E] -> BoolTuple
BoolTuple (GE [E] -> BoolTuple) -> GE [E] -> BoolTuple
forall a b. (a -> b) -> a -> b
$
        (E -> [E] -> [E] -> [E]) -> GE E -> GE [E] -> GE [E] -> GE [E]
forall (f :: * -> *) a b c d.
Applicative f =>
(a -> b -> c -> d) -> f a -> f b -> f c -> f d
liftA3 (\E
p [E]
as [E]
bs -> (E -> E -> E) -> [E] -> [E] -> [E]
forall a b c. (a -> b -> c) -> [a] -> [b] -> [c]
zipWith (IfRate -> E -> E -> E -> E
ifExp IfRate
IfKr E
p) [E]
as [E]
bs) (bool -> GE E
forall a. Val a => a -> GE E
toGE bool
mp) GE [E]
mas GE [E]
mbs

-- | @ifB@ for tuples of csound values.
ifTuple :: (Tuple a) => BoolSig -> a -> a -> a
ifTuple :: forall a. Tuple a => BoolSig -> a -> a -> a
ifTuple BoolSig
p a
a a
b = BoolTuple -> a
forall a. Tuple a => BoolTuple -> a
fromBoolTuple (BoolTuple -> a) -> BoolTuple -> a
forall a b. (a -> b) -> a -> b
$ BoolSig -> BoolTuple -> BoolTuple -> BoolTuple
forall bool.
(bool ~ BooleanOf BoolTuple) =>
bool -> BoolTuple -> BoolTuple -> BoolTuple
forall a bool. (IfB a, bool ~ BooleanOf a) => bool -> a -> a -> a
ifB BoolSig
p (a -> BoolTuple
forall a. Tuple a => a -> BoolTuple
toBoolTuple a
a) (a -> BoolTuple
forall a. Tuple a => a -> BoolTuple
toBoolTuple a
b)

-- | @guardedB@ for tuples of csound values.
guardedTuple :: (Tuple b) => [(BoolSig, b)] -> b -> b
guardedTuple :: forall b. Tuple b => [(BoolSig, b)] -> b -> b
guardedTuple [(BoolSig, b)]
bs b
b = BoolTuple -> b
forall a. Tuple a => BoolTuple -> a
fromBoolTuple (BoolTuple -> b) -> BoolTuple -> b
forall a b. (a -> b) -> a -> b
$ BoolSig -> [(BoolSig, BoolTuple)] -> BoolTuple -> BoolTuple
forall b bool.
(IfB b, bool ~ BooleanOf b) =>
bool -> [(bool, b)] -> b -> b
guardedB BoolSig
forall a. HasCallStack => a
undefined (((BoolSig, b) -> (BoolSig, BoolTuple))
-> [(BoolSig, b)] -> [(BoolSig, BoolTuple)]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((b -> BoolTuple) -> (BoolSig, b) -> (BoolSig, BoolTuple)
forall b c d. (b -> c) -> (d, b) -> (d, c)
forall (a :: * -> * -> *) b c d.
Arrow a =>
a b c -> a (d, b) (d, c)
second b -> BoolTuple
forall a. Tuple a => a -> BoolTuple
toBoolTuple) [(BoolSig, b)]
bs) (b -> BoolTuple
forall a. Tuple a => a -> BoolTuple
toBoolTuple b
b)

-- | @caseB@ for tuples of csound values.
caseTuple :: (Tuple b) => a -> [(a -> BoolSig, b)] -> b -> b
caseTuple :: forall b a. Tuple b => a -> [(a -> BoolSig, b)] -> b -> b
caseTuple a
a [(a -> BoolSig, b)]
bs b
other = BoolTuple -> b
forall a. Tuple a => BoolTuple -> a
fromBoolTuple (BoolTuple -> b) -> BoolTuple -> b
forall a b. (a -> b) -> a -> b
$ a -> [(a -> BoolSig, BoolTuple)] -> BoolTuple -> BoolTuple
forall b bool a.
(IfB b, bool ~ BooleanOf b) =>
a -> [(a -> bool, b)] -> b -> b
caseB a
a (((a -> BoolSig, b) -> (a -> BoolSig, BoolTuple))
-> [(a -> BoolSig, b)] -> [(a -> BoolSig, BoolTuple)]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((b -> BoolTuple) -> (a -> BoolSig, b) -> (a -> BoolSig, BoolTuple)
forall b c d. (b -> c) -> (d, b) -> (d, c)
forall (a :: * -> * -> *) b c d.
Arrow a =>
a b c -> a (d, b) (d, c)
second b -> BoolTuple
forall a. Tuple a => a -> BoolTuple
toBoolTuple) [(a -> BoolSig, b)]
bs) (b -> BoolTuple
forall a. Tuple a => a -> BoolTuple
toBoolTuple b
other)

-- arguments

newtype BoolArg = BoolArg { BoolArg -> GE [E]
unBoolArg :: GE [E] }

toBoolArg :: (Tuple a) => a -> BoolArg
toBoolArg :: forall a. Tuple a => a -> BoolArg
toBoolArg   = GE [E] -> BoolArg
BoolArg (GE [E] -> BoolArg) -> (a -> GE [E]) -> a -> BoolArg
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> GE [E]
forall a. Tuple a => a -> GE [E]
fromTuple

fromBoolArg :: (Tuple a) => BoolArg -> a
fromBoolArg :: forall a. Tuple a => BoolArg -> a
fromBoolArg = GE [E] -> a
forall a. Tuple a => GE [E] -> a
toTuple (GE [E] -> a) -> (BoolArg -> GE [E]) -> BoolArg -> a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. BoolArg -> GE [E]
unBoolArg

type instance BooleanOf BoolArg = BoolSig

instance IfB BoolArg where
    ifB :: forall bool.
(bool ~ BooleanOf BoolArg) =>
bool -> BoolArg -> BoolArg -> BoolArg
ifB bool
mp (BoolArg GE [E]
mas) (BoolArg GE [E]
mbs) = GE [E] -> BoolArg
BoolArg (GE [E] -> BoolArg) -> GE [E] -> BoolArg
forall a b. (a -> b) -> a -> b
$
        (E -> [E] -> [E] -> [E]) -> GE E -> GE [E] -> GE [E] -> GE [E]
forall (f :: * -> *) a b c d.
Applicative f =>
(a -> b -> c -> d) -> f a -> f b -> f c -> f d
liftA3 (\E
p [E]
as [E]
bs -> (E -> E -> E) -> [E] -> [E] -> [E]
forall a b c. (a -> b -> c) -> [a] -> [b] -> [c]
zipWith (IfRate -> E -> E -> E -> E
ifExp IfRate
IfKr E
p) [E]
as [E]
bs) (bool -> GE E
forall a. Val a => a -> GE E
toGE bool
mp) GE [E]
mas GE [E]
mbs

-- | @ifB@ for constants.
ifArg :: (Arg a, Tuple a) => BoolSig -> a -> a -> a
ifArg :: forall a. (Arg a, Tuple a) => BoolSig -> a -> a -> a
ifArg BoolSig
p a
a a
b = BoolArg -> a
forall a. Tuple a => BoolArg -> a
fromBoolArg (BoolArg -> a) -> BoolArg -> a
forall a b. (a -> b) -> a -> b
$ BoolSig -> BoolArg -> BoolArg -> BoolArg
forall bool.
(bool ~ BooleanOf BoolArg) =>
bool -> BoolArg -> BoolArg -> BoolArg
forall a bool. (IfB a, bool ~ BooleanOf a) => bool -> a -> a -> a
ifB BoolSig
p (a -> BoolArg
forall a. Tuple a => a -> BoolArg
toBoolArg a
a) (a -> BoolArg
forall a. Tuple a => a -> BoolArg
toBoolArg a
b)

-- | @guardedB@ for constants.
guardedArg :: (Tuple b) => [(BoolSig, b)] -> b -> b
guardedArg :: forall b. Tuple b => [(BoolSig, b)] -> b -> b
guardedArg [(BoolSig, b)]
bs b
b = BoolArg -> b
forall a. Tuple a => BoolArg -> a
fromBoolArg (BoolArg -> b) -> BoolArg -> b
forall a b. (a -> b) -> a -> b
$ BoolSig -> [(BoolSig, BoolArg)] -> BoolArg -> BoolArg
forall b bool.
(IfB b, bool ~ BooleanOf b) =>
bool -> [(bool, b)] -> b -> b
guardedB BoolSig
forall a. HasCallStack => a
undefined (((BoolSig, b) -> (BoolSig, BoolArg))
-> [(BoolSig, b)] -> [(BoolSig, BoolArg)]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((b -> BoolArg) -> (BoolSig, b) -> (BoolSig, BoolArg)
forall b c d. (b -> c) -> (d, b) -> (d, c)
forall (a :: * -> * -> *) b c d.
Arrow a =>
a b c -> a (d, b) (d, c)
second b -> BoolArg
forall a. Tuple a => a -> BoolArg
toBoolArg) [(BoolSig, b)]
bs) (b -> BoolArg
forall a. Tuple a => a -> BoolArg
toBoolArg b
b)

-- | @caseB@ for constants.
caseArg :: (Tuple b, Arg b) => a -> [(a -> BoolSig, b)] -> b -> b
caseArg :: forall b a. (Tuple b, Arg b) => a -> [(a -> BoolSig, b)] -> b -> b
caseArg a
a [(a -> BoolSig, b)]
bs b
other = BoolArg -> b
forall a. Tuple a => BoolArg -> a
fromBoolArg (BoolArg -> b) -> BoolArg -> b
forall a b. (a -> b) -> a -> b
$ a -> [(a -> BoolSig, BoolArg)] -> BoolArg -> BoolArg
forall b bool a.
(IfB b, bool ~ BooleanOf b) =>
a -> [(a -> bool, b)] -> b -> b
caseB a
a (((a -> BoolSig, b) -> (a -> BoolSig, BoolArg))
-> [(a -> BoolSig, b)] -> [(a -> BoolSig, BoolArg)]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((b -> BoolArg) -> (a -> BoolSig, b) -> (a -> BoolSig, BoolArg)
forall b c d. (b -> c) -> (d, b) -> (d, c)
forall (a :: * -> * -> *) b c d.
Arrow a =>
a b c -> a (d, b) (d, c)
second b -> BoolArg
forall a. Tuple a => a -> BoolArg
toBoolArg) [(a -> BoolSig, b)]
bs) (b -> BoolArg
forall a. Tuple a => a -> BoolArg
toBoolArg b
other)

-----------------------------------------------------------
-- tuple constructors

pureTuple :: forall a . Tuple a => GE (MultiOut [E]) -> a
pureTuple :: forall a. Tuple a => GE (MultiOut [E]) -> a
pureTuple GE (MultiOut [E])
a =
  GE [E] -> a
forall a. Tuple a => GE [E] -> a
toTuple (GE [E] -> a) -> GE [E] -> a
forall a b. (a -> b) -> a -> b
$ (MultiOut [E] -> [E]) -> GE (MultiOut [E]) -> GE [E]
forall a b. (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (MultiOut [E] -> MultiOut [E]
forall a b. (a -> b) -> a -> b
$ Proxy a -> Int
forall a. Tuple a => Proxy a -> Int
tupleArity (Proxy a
forall {k} (t :: k). Proxy t
Proxy :: Proxy a)) GE (MultiOut [E])
a