module Sound.SC3.UGen.UId where
import Control.Monad
import Data.Functor.Identity
import Data.List
import qualified Data.Unique as U
import qualified Control.Monad.Trans.Reader as R
import qualified Control.Monad.Trans.State as S
import Sound.SC3.UGen.Type
class (Functor m,Applicative m,Monad m) => UId m where
generateUId :: m Int
type UId_ST = S.State Int
uid_st_eval :: UId_ST t -> t
uid_st_eval x = S.evalState x 0
uid_st_seq :: [UId_ST t] -> ([t],Int)
uid_st_seq =
let swap (p,q) = (q,p)
step_f n x = swap (S.runState x n)
in swap . mapAccumL step_f 0
uid_st_seq_ :: [UId_ST t] -> [t]
uid_st_seq_ = fst . uid_st_seq
instance UId (S.StateT Int Identity) where
generateUId = S.get >>= \n -> S.put (n + 1) >> return n
instance UId IO where
generateUId = liftM U.hashUnique U.newUnique
instance UId m => UId (R.ReaderT t m) where
generateUId = R.ReaderT (const generateUId)
type Fn1 a b = a -> b
type Fn2 a b c = a -> b -> c
type Fn3 a b c d = a -> b -> c -> d
type Fn4 a b c d e = a -> b -> c -> d -> e
liftUId :: UId m => (Int -> Fn1 a b) -> Fn1 a (m b)
liftUId f a = do
n <- generateUId
return (f n a)
liftUId2 :: UId m => (Int -> Fn2 a b c) -> Fn2 a b (m c)
liftUId2 f a b = do
n <- generateUId
return (f n a b)
liftUId3 :: UId m => (Int -> Fn3 a b c d) -> Fn3 a b c (m d)
liftUId3 f a b c = do
n <- generateUId
return (f n a b c)
liftUId4 :: UId m => (Int -> Fn4 a b c d e) -> Fn4 a b c d (m e)
liftUId4 f a b c d = do
n <- generateUId
return (f n a b c d)
clone :: (UId m) => Int -> m UGen -> m UGen
clone n = liftM mce . replicateM n