diff --git a/csound-expression.cabal b/csound-expression.cabal --- a/csound-expression.cabal +++ b/csound-expression.cabal @@ -1,12 +1,12 @@ Name: csound-expression -Version: 0.0 +Version: 0.0.1 Cabal-Version: >= 1.2 License: BSD3 License-File: LICENSE Author: Anton Kholomiov Maintainer: Synopsis: Csound combinator library -Description: Csound code generator +Description: Csound code generator. See "CsoundExpr.Tutorial" for guides and examples. Category: Sound, Music Stability: Experimental Tested-With: GHC==6.12.1 @@ -15,14 +15,14 @@ Library Build-Depends: - base >= 4, base < 5, containers, mtl, pretty, temporal-media == 0.0 + base >= 4, base < 5, containers, mtl, pretty, filepath, directory, haskell98, temporal-media == 0.0 Hs-Source-Dirs: src/ Exposed-Modules: CsoundExpr -- Base CsoundExpr.Base CsoundExpr.Base.Types - CsoundExpr.Base.Literal + CsoundExpr.Base.Imperative CsoundExpr.Base.MultiOut CsoundExpr.Base.SideEffect CsoundExpr.Base.Arithmetic @@ -31,6 +31,14 @@ CsoundExpr.Base.Gens CsoundExpr.Base.Pitch CsoundExpr.Base.UserDefined + CsoundExpr.Base.Pretty +-- Tutorial + CsoundExpr.Tutorial + CsoundExpr.Tutorial.Intro + CsoundExpr.Tutorial.Composition + CsoundExpr.Tutorial.Orchestra + CsoundExpr.Tutorial.Limits + -- Opcodes CsoundExpr.Opcodes CsoundExpr.Opcodes.Siggen diff --git a/src/CsoundExpr/Base.hs b/src/CsoundExpr/Base.hs --- a/src/CsoundExpr/Base.hs +++ b/src/CsoundExpr/Base.hs @@ -5,23 +5,25 @@ -- and "CsoundExpr.Base.Pitch". module CsoundExpr.Base ( module CsoundExpr.Base.Types, - module CsoundExpr.Base.Literal, + module CsoundExpr.Base.Imperative, module CsoundExpr.Base.MultiOut, module CsoundExpr.Base.Arithmetic, module CsoundExpr.Base.SideEffect, module CsoundExpr.Base.Header, module CsoundExpr.Base.Score, - module CsoundExpr.Base.Gens + module CsoundExpr.Base.Gens, + module CsoundExpr.Base.Pretty ) where import CsoundExpr.Base.Types -import CsoundExpr.Base.Literal +import CsoundExpr.Base.Imperative import CsoundExpr.Base.MultiOut import CsoundExpr.Base.Arithmetic import CsoundExpr.Base.SideEffect import CsoundExpr.Base.Header import CsoundExpr.Base.Score import CsoundExpr.Base.Gens +import CsoundExpr.Base.Pretty diff --git a/src/CsoundExpr/Base/Arithmetic.hs b/src/CsoundExpr/Base/Arithmetic.hs --- a/src/CsoundExpr/Base/Arithmetic.hs +++ b/src/CsoundExpr/Base/Arithmetic.hs @@ -1,12 +1,12 @@ {-# LANGUAGE MultiParamTypeClasses, TypeSynonymInstances, - FlexibleContexts #-} + FlexibleContexts #-} -- | Arithmetic operators module CsoundExpr.Base.Arithmetic - (Opr2, (<+>), neg, (<->), (<*>), ()) + (Opr2, (<+>), neg, (<->), (<*>), (), (<*)) where import Prelude hiding (div) @@ -14,12 +14,14 @@ import Control.Applicative(liftA2, (<$>)) import Data.Function(on) -import CsoundExpr.Base.Types +import CsoundExpr.Translator.Types import CsoundExpr.Translator.Cs.CsTree import CsoundExpr.Translator.ExprTree.ExprTree import CsoundExpr.Base.UserDefined +import CsoundExpr.Base.Types (Irate(..), Krate(..), Arate(..)) +infixr 8 <* infixr 7 <*>, infixr 6 <+>, <-> @@ -68,10 +70,56 @@ neg :: (X a) => a -> a neg = opr1 "-" negate . to +-- | Scaling +(<*) :: X a => Irate -> a -> a +(<*) = subst $ opr2 "*" (*) + ---------------------------------------------------------- --- Irates +-- Num instances +-- +instance Eq Arate where + (==) = error "(==) is undefined" + (/=) = error "(/=) is undefined" +instance Eq Krate where + (==) = error "(==) is undefined" + (/=) = error "(/=) is undefined" + +instance Eq Irate where + (==) = error "(==) is undefined" + (/=) = error "(/=) is undefined" + + + +instance Num Arate where + (+) = (<+>) + (*) = (<*>) + abs = opr1p "abs" abs . to + signum = error "is undefined" + (-) = (<->) + fromInteger = double . fromInteger + + +instance Fractional Arate where + (/) = () + fromRational = double . fromRational + + +instance Num Krate where + (+) = (<+>) + (*) = (<*>) + abs = opr1p "abs" abs . to + signum = error "is undefined" + (-) = (<->) + fromInteger = double . fromInteger + + +instance Fractional Krate where + (/) = () + fromRational = double . fromRational + + instance Num Irate where (+) = (<+>) (*) = (<*>) @@ -84,4 +132,5 @@ instance Fractional Irate where (/) = () fromRational = double . fromRational + diff --git a/src/CsoundExpr/Base/Gens.hs b/src/CsoundExpr/Base/Gens.hs --- a/src/CsoundExpr/Base/Gens.hs +++ b/src/CsoundExpr/Base/Gens.hs @@ -2,9 +2,10 @@ MultiParamTypeClasses, FlexibleContexts #-} --- | Gen routines +-- | Gen routines. First argument is ftable's size, load time is set to zero. +-- -- - +-- module CsoundExpr.Base.Gens ( skipNorm, @@ -27,7 +28,40 @@ -- * Amplitude Scaling GEN Routines gen04, gen12, gen24, -- * Mixing GEN Routines - gen18, gen31, gen32 + gen18, gen31, gen32, + +-- * genXX'2 + + -- | Gens size is power of two + -- + -- >genXX'2 = genXX . (2^) + + + gen09'2, gen10'2, gen11'2, gen19'2, gen30'2, gen33'2, gen34'2, + gen05'2, gen06'2, gen07'2, gen08'2, gen16'2, gen25'2, gen27'2, + gen01'2, gen23'2, gen28'2, + gen02'2, gen17'2, + gen20'2, + gen21'2, gen40'2, gen41'2, gen42'2, gen43'2, + gen03'2, gen13'2, gen14'2, gen15'2, + gen04'2, gen12'2, gen24'2, + gen18'2, gen31'2, gen32'2, +-- * genXX'12 + + -- | Gens size is power of two plus one + -- + -- >genXX'12 = genXX . (+1) . (2^) + gen09'12, gen10'12, gen11'12, gen19'12, gen30'12, gen33'12, gen34'12, + gen05'12, gen06'12, gen07'12, gen08'12, gen16'12, gen25'12, gen27'12, + gen01'12, gen23'12, gen28'12, + gen02'12, gen17'12, + gen20'12, + gen21'12, gen40'12, gen41'12, gen42'12, gen43'12, + gen03'12, gen13'12, gen14'12, gen15'12, + gen04'12, gen12'12, gen24'12, + gen18'12, gen31'12, gen32'12 + + ) where @@ -73,32 +107,46 @@ -- phsX - phase -- | GEN09 - Composite waveforms made up of weighted sums of simple sinusoids. +-- +-- url : gen09 :: Int -> [Double] -> Irate gen09 = genD 9 -- | GEN10 - Composite waveforms made up of weighted sums of simple sinusoids. +-- +-- url : gen10 :: Int -> [Double] -> Irate gen10 = genD 10 -- | GEN11 - Additive set of cosine partials. +-- +-- url : gen11 :: Int -> [Double] -> Irate gen11 = genD 11 -- | GEN19 - Composite waveforms made up of weighted sums of simple sinusoids. +-- +-- url : gen19 :: Int -> [Double] -> Irate gen19 = genD 19 -- | GEN30 - Generates harmonic partials by analyzing an existing table. +-- +-- url : gen30 :: Int -> Irate -> [Double] -> Irate gen30 = gen3x 30 -- | GEN33 - Generate composite waveforms by mixing simple sinusoids. +-- +-- url : gen33 :: Int -> Irate -> [Double] -> Irate gen33 = gen3x 33 -- | GEN34 - Generate composite waveforms by mixing simple sinusoids. +-- +-- url : gen34 :: Int -> Irate -> [Double] -> Irate gen34 = gen3x 34 @@ -116,30 +164,44 @@ -- n1, n2,... -- length of segment -- | GEN05 - Constructs functions from segments of exponential curves. +-- +-- url : gen05 :: Int -> [Double] -> Irate gen05 = genD 5 -- | GEN06 - Generates a function comprised of segments of cubic polynomials. +-- +-- url : gen06 :: Int -> [Double] -> Irate gen06 = genD 6 -- | GEN07 - Constructs functions from segments of straight lines. +-- +-- url : gen07 :: Int -> [Double] -> Irate gen07 = genD 7 -- | GEN08 - Generate a piecewise cubic spline curve. +-- +-- url : gen08 :: Int -> [Double] -> Irate gen08 = genD 8 -- | GEN16 - Creates a table from a starting value to an ending value. +-- +-- url : gen16 :: Int -> [Double] -> Irate gen16 = genD 16 -- | GEN25 - Construct functions from segments of exponential curves in breakpoint fashion. +-- +-- url : gen25 :: Int -> [Double] -> Irate gen25 = genD 25 -- | GEN27 - Construct functions from segments of straight lines in breakpoint fashion. +-- +-- url : gen27 :: Int -> [Double] -> Irate gen27 = genD 27 @@ -148,14 +210,20 @@ -- gen01, gen23, gen28, -- | GEN01 - Transfers data from a soundfile into a function table. +-- +-- url : gen01 :: Int -> String -> [Double] -> Irate gen01 n file xs = gen 1 n $ [ftvalS file] ++ map ftvalD xs -- | GEN23 - Reads numeric values from a text file. +-- +-- url : gen23 :: Int -> String -> Irate gen23 n file = gen 23 n [ftvalS file] -- | GEN28 - Reads a text file which contains a time-tagged trajectory. +-- +-- url : gen28 :: Int -> String -> Irate gen28 n file = gen 28 n [ftvalS file] @@ -164,10 +232,14 @@ -- gen02, gen17, -- | GEN02 - Transfers data from immediate pfields into a function table. +-- +-- url : gen02 :: Int -> [Double] -> Irate gen02 = genD 2 -- | GEN17 - Creates a step function from given x-y pairs. +-- +-- url : gen17 :: Int -> [Double] -> Irate gen17 = genD 17 @@ -175,6 +247,8 @@ -- gen20, -- | GEN20 - Generates functions of different windows. +-- +-- url : gen20 :: Int -> [Double] -> Irate gen20 = genD 20 @@ -183,22 +257,32 @@ -- gen21, gen40, gen41, gen42, gen43, -- | GEN21 - Generates tables of different random distributions. +-- +-- url : gen21 :: Int -> [Double] -> SideEffect Irate gen21 = gen21 -- | GEN41 - Generates a random list of numerical pairs. +-- +-- url : gen41 :: Int -> [Double] -> SideEffect Irate gen41 = gen41 -- | GEN42 - Generates a random distribution of discrete ranges of values. +-- +-- url : gen42 :: Int -> [Double] -> SideEffect Irate gen42 = gen42 -- | GEN40 - Generates a random distribution using a distribution histogram. +-- +-- url : gen40 :: Int -> Irate -> SideEffect Irate gen40 n ft = gen 40 n [ftvalF ft] -- | GEN43 - Loads a PVOCEX file containing a PV analysis. +-- +-- url : gen43 :: Int -> String -> [Double] -> Irate gen43 n file vs = gen 43 n $ [ftvalS file] ++ map ftvalD vs @@ -208,18 +292,26 @@ -- | GEN03 - Generates a stored function table by evaluating a polynomial. +-- +-- url : gen03 :: Int -> [Double] -> Irate gen03 = genD 3 -- | GEN13 - Stores a polynomial whose coefficients derive from the Chebyshev polynomials of the first kind. +-- +-- url : gen13 :: Int -> [Double] -> Irate gen13 = genD 13 -- | GEN14 - Stores a polynomial whose coefficients derive from Chebyshevs of the second kind. +-- +-- url : gen14 :: Int -> [Double] -> Irate gen14 = genD 14 -- | GEN15 - Creates two tables of stored polynomial functions. +-- +-- url : gen15 :: Int -> [Double] -> Irate gen15 = genD 15 @@ -227,14 +319,20 @@ -- gen04, gen12, gen24, -- | GEN12 - Generates the log of a modified Bessel function of the second kind. +-- +-- url : gen12 :: Int -> [Double] -> Irate gen12 = genD 12 -- | GEN04 - Generates a normalizing function. +-- +-- url : gen04 :: Int -> Irate -> [Double] -> Irate gen04 n ft vs = gen 4 n $ [ftvalF ft] ++ map ftvalD vs -- | GEN24 - Reads numeric values from another allocated function-table and rescales them. +-- +-- url : gen24 :: Int -> Irate -> [Double] -> Irate gen24 n ft vs = gen 24 n $ [ftvalF ft] ++ map ftvalD vs @@ -243,15 +341,142 @@ -- gen18, gen31, gen32 -- | GEN18 - Writes composite waveforms made up of pre-existing waveforms. +-- +-- url : gen18 :: Int -> [(Irate, Double, Int, Int)] -> Irate gen18 n xs = gen 18 n (f =<< xs) where f (x1, x2, x3, x4) = [ftvalF x1, ftvalD x2, ftvalI x3, ftvalI x4] -- | GEN31 - Mixes any waveform specified in an existing table. +-- +-- url : gen31 :: Int -> Irate -> [Double] -> Irate gen31 n ft vs = gen 31 n $ [ftvalF ft] ++ map ftvalD vs -- | GEN32 - Mixes any waveform, resampled with either FFT or linear interpolation. +-- +-- url : gen32 :: Int -> [(Irate, Int, Double, Double)] -> Irate gen32 n xs = gen 32 n (f =<< xs) where f (x1, x2, x3, x4) = [ftvalF x1, ftvalI x2, ftvalD x3, ftvalD x4] + +-------------------------------------------------------------- +-- + +-- genXX'(12|2) generation program + +{- +import Text.PrettyPrint + +ids = [9, 10, 11, 19, 30, 33, 34] ++ + [5 .. 8] ++ [16, 25, 27] ++ + [1, 23, 28] ++ + [2, 17] ++ + [20] ++ + [21] ++ [40 .. 43] ++ + [3] ++ [13 .. 15] ++ + [4, 12, 24] ++ + [18, 31, 32] + + +toStr x + | length s == 1 = "0" ++ s + | otherwise = s + where s = show x + +-- genXX'2 = genXX . (^2) +toGen'2 x = show $ name <> text "'2" <+> equals <+> name <+> text ". (^2)" + where name = text "gen" <> text (toStr x) + + +-- genXX'12 = genXX . (+1) . (^2) +toGen'12 x = show $ name <> text "'12" <+> equals <+> name <+> text ". (+1) . (^2)" + where name = text "gen" <> text (toStr x) + + + +main = do + mapM_ (putStrLn . toGen'12) ids + +-} + +-------------------------------------------------------------- +-- genXX'2 +-- + +gen09'2 = gen09 . (2^) +gen10'2 = gen10 . (2^) +gen11'2 = gen11 . (2^) +gen19'2 = gen19 . (2^) +gen30'2 = gen30 . (2^) +gen33'2 = gen33 . (2^) +gen34'2 = gen34 . (2^) +gen05'2 = gen05 . (2^) +gen06'2 = gen06 . (2^) +gen07'2 = gen07 . (2^) +gen08'2 = gen08 . (2^) +gen16'2 = gen16 . (2^) +gen25'2 = gen25 . (2^) +gen27'2 = gen27 . (2^) +gen01'2 = gen01 . (2^) +gen23'2 = gen23 . (2^) +gen28'2 = gen28 . (2^) +gen02'2 = gen02 . (2^) +gen17'2 = gen17 . (2^) +gen20'2 = gen20 . (2^) +gen21'2 = gen21 . (2^) +gen40'2 = gen40 . (2^) +gen41'2 = gen41 . (2^) +gen42'2 = gen42 . (2^) +gen43'2 = gen43 . (2^) +gen03'2 = gen03 . (2^) +gen13'2 = gen13 . (2^) +gen14'2 = gen14 . (2^) +gen15'2 = gen15 . (2^) +gen04'2 = gen04 . (2^) +gen12'2 = gen12 . (2^) +gen24'2 = gen24 . (2^) +gen18'2 = gen18 . (2^) +gen31'2 = gen31 . (2^) +gen32'2 = gen32 . (2^) + +-------------------------------------------------------------- +-- genXX'12 +-- + +gen09'12 = gen09 . (+1) . (2^) +gen10'12 = gen10 . (+1) . (2^) +gen11'12 = gen11 . (+1) . (2^) +gen19'12 = gen19 . (+1) . (2^) +gen30'12 = gen30 . (+1) . (2^) +gen33'12 = gen33 . (+1) . (2^) +gen34'12 = gen34 . (+1) . (2^) +gen05'12 = gen05 . (+1) . (2^) +gen06'12 = gen06 . (+1) . (2^) +gen07'12 = gen07 . (+1) . (2^) +gen08'12 = gen08 . (+1) . (2^) +gen16'12 = gen16 . (+1) . (2^) +gen25'12 = gen25 . (+1) . (2^) +gen27'12 = gen27 . (+1) . (2^) +gen01'12 = gen01 . (+1) . (2^) +gen23'12 = gen23 . (+1) . (2^) +gen28'12 = gen28 . (+1) . (2^) +gen02'12 = gen02 . (+1) . (2^) +gen17'12 = gen17 . (+1) . (2^) +gen20'12 = gen20 . (+1) . (2^) +gen21'12 = gen21 . (+1) . (2^) +gen40'12 = gen40 . (+1) . (2^) +gen41'12 = gen41 . (+1) . (2^) +gen42'12 = gen42 . (+1) . (2^) +gen43'12 = gen43 . (+1) . (2^) +gen03'12 = gen03 . (+1) . (2^) +gen13'12 = gen13 . (+1) . (2^) +gen14'12 = gen14 . (+1) . (2^) +gen15'12 = gen15 . (+1) . (2^) +gen04'12 = gen04 . (+1) . (2^) +gen12'12 = gen12 . (+1) . (2^) +gen24'12 = gen24 . (+1) . (2^) +gen18'12 = gen18 . (+1) . (2^) +gen31'12 = gen31 . (+1) . (2^) +gen32'12 = gen32 . (+1) . (2^) + diff --git a/src/CsoundExpr/Base/Header.hs b/src/CsoundExpr/Base/Header.hs --- a/src/CsoundExpr/Base/Header.hs +++ b/src/CsoundExpr/Base/Header.hs @@ -1,21 +1,32 @@ -- | Header section module CsoundExpr.Base.Header - (Header, SignalInit, + ( + -- * Types + Header, SignalInit, + -- * Setup variables gSr, gKr, gKsmps, gNchnls, g0dbfs, - massign, pgmassign, instrOrder, + -- * midi instruments + massign, pgmassign, + -- * Setting instrument order + instrOrder, + -- * Header opcodes instr0, initA, initK, initI, - seed, ctrlinit, ftgen + seed, ctrlinit, ftgen, + -- * Constants + + -- | (gSr = 44100, gKr = 4410, gKsmps = 10) + headerMono, headerStereo ) where -import CsoundExpr.Translator.Cs.CsTree (int, argIn, Rate(..)) +import CsoundExpr.Translator.Cs.CsTree (int, double, argIn, Rate(..)) import CsoundExpr.Translator.Types import CsoundExpr.Base.UserDefined +import CsoundExpr.Base.Imperative((<=>)) --- | Header section -type Header = [SignalInit] +import CsoundExpr.Base.Arithmetic gSr, gKr, gKsmps, gNchnls, g0dbfs :: Irate @@ -47,10 +58,11 @@ -- Example : -- -- > header = [ --- > gSr 44100, --- > gKr 4410, --- > gKsmps 10, --- > gNchnls 1, +-- > instr0 [ +-- > gSr <=> 44100, +-- > gKr <=> 4410, +-- > gKsmps <=> 10, +-- > gNchnls <=> 1], -- > instrOrder [instr1 (0, 0), instr2 ""] -- > ] -- @@ -126,3 +138,24 @@ ftgen :: Irate -> Irate -> Irate -> [Irate] -> Irate ftgen itime isize igen inits = opcode "ftgen" args where args = [int 0, to itime, to isize, to igen] ++ map to inits + + + +headerMono :: Header +headerMono = + return $ instr0 [ + gSr <=> 44100, + gKr <=> 4410, + gKsmps <=> 10, + gNchnls <=> 1] + + +headerStereo :: Header +headerStereo = + return $ instr0 [ + gSr <=> 44100, + gKr <=> 4410, + gKsmps <=> 10, + gNchnls <=> 1] + + diff --git a/src/CsoundExpr/Base/Imperative.hs b/src/CsoundExpr/Base/Imperative.hs new file mode 100644 --- /dev/null +++ b/src/CsoundExpr/Base/Imperative.hs @@ -0,0 +1,727 @@ +{-# LANGUAGE FlexibleInstances, MultiParamTypeClasses, + TypeSynonymInstances, FlexibleContexts #-} + +-- | Functions to write imperative style csound code + +module CsoundExpr.Base.Imperative ( + outList, + ar, + kr, + ir, + gar, + gkr, + gir, + Assign(..)) +where + +import CsoundExpr.Translator.Types +import CsoundExpr.Translator.Cs.IM +import CsoundExpr.Translator.Cs.CsTree +import CsoundExpr.Translator.ExprTree.ExprTree + + +ar :: Name -> Arate +ar = argIn A + + +kr :: Name -> Krate +kr = argIn K + + +ir :: Name -> Irate +ir = argIn I + + +gar :: Name -> Arate +gar = argIn GA + + +gkr :: Name -> Krate +gkr = argIn GK + + +gir :: Name -> Irate +gir = argIn GI + + +fromArgIn :: (IM CsTree a) => a -> (Rate, Name) +fromArgIn a + | isArg e = (argRate e, argName e) + | otherwise = + error "left hand side of <=> should be named expression" + where e = exprOp $ exprTreeTag t + t = to a :: CsTree + +-- Assign Class + + +infixr 0 <=> + + +class Assign a where + + (<=>) :: a -> a -> SignalOut + + +instance Assign Arate where + sig <=> expr + = let (rate, name) = fromArgIn sig in + SignalOut $ return $ argOut rate name expr + + +instance Assign Krate where + sig <=> expr + = let (rate, name) = fromArgIn sig in + SignalOut $ return $ argOut rate name expr + + +instance Assign Irate where + sig <=> expr + = let (rate, name) = fromArgIn sig in + SignalOut $ return $ argOut rate name expr + + +instance (Assign a) => Assign [a] where + sigs <=> exprs = outList $ zipWith (<=>) sigs exprs + + +instance (Assign a0, Assign a1) => Assign (a0, a1) where + (sig0, sig1) <=> (exprs0, exprs1) + = outList [sig0 <=> exprs0, sig1 <=> exprs1] + + +instance (Assign a0, Assign a1, Assign a2) => Assign (a0, a1, a2) + where + (sig0, sig1, sig2) <=> (exprs0, exprs1, exprs2) + = outList [sig0 <=> exprs0, sig1 <=> exprs1, sig2 <=> exprs2] + + +instance (Assign a0, Assign a1, Assign a2, Assign a3) => Assign + (a0, a1, a2, a3) where + (sig0, sig1, sig2, sig3) <=> (exprs0, exprs1, exprs2, exprs3) + = outList + [sig0 <=> exprs0, sig1 <=> exprs1, sig2 <=> exprs2, + sig3 <=> exprs3] + + +instance (Assign a0, Assign a1, Assign a2, Assign a3, Assign a4) => + Assign (a0, a1, a2, a3, a4) where + (sig0, sig1, sig2, sig3, sig4) <=> + (exprs0, exprs1, exprs2, exprs3, exprs4) + = outList + [sig0 <=> exprs0, sig1 <=> exprs1, sig2 <=> exprs2, + sig3 <=> exprs3, sig4 <=> exprs4] + + +instance (Assign a0, Assign a1, Assign a2, Assign a3, Assign a4, + Assign a5) => + Assign (a0, a1, a2, a3, a4, a5) where + (sig0, sig1, sig2, sig3, sig4, sig5) <=> + (exprs0, exprs1, exprs2, exprs3, exprs4, exprs5) + = outList + [sig0 <=> exprs0, sig1 <=> exprs1, sig2 <=> exprs2, + sig3 <=> exprs3, sig4 <=> exprs4, sig5 <=> exprs5] + + +instance (Assign a0, Assign a1, Assign a2, Assign a3, Assign a4, + Assign a5, Assign a6) => + Assign (a0, a1, a2, a3, a4, a5, a6) where + (sig0, sig1, sig2, sig3, sig4, sig5, sig6) <=> + (exprs0, exprs1, exprs2, exprs3, exprs4, exprs5, exprs6) + = outList + [sig0 <=> exprs0, sig1 <=> exprs1, sig2 <=> exprs2, + sig3 <=> exprs3, sig4 <=> exprs4, sig5 <=> exprs5, sig6 <=> exprs6] + + +instance (Assign a0, Assign a1, Assign a2, Assign a3, Assign a4, + Assign a5, Assign a6, Assign a7) => + Assign (a0, a1, a2, a3, a4, a5, a6, a7) where + (sig0, sig1, sig2, sig3, sig4, sig5, sig6, sig7) <=> + (exprs0, exprs1, exprs2, exprs3, exprs4, exprs5, exprs6, exprs7) + = outList + [sig0 <=> exprs0, sig1 <=> exprs1, sig2 <=> exprs2, + sig3 <=> exprs3, sig4 <=> exprs4, sig5 <=> exprs5, sig6 <=> exprs6, + sig7 <=> exprs7] + + +instance (Assign a0, Assign a1, Assign a2, Assign a3, Assign a4, + Assign a5, Assign a6, Assign a7, Assign a8) => + Assign (a0, a1, a2, a3, a4, a5, a6, a7, a8) where + (sig0, sig1, sig2, sig3, sig4, sig5, sig6, sig7, sig8) <=> + (exprs0, exprs1, exprs2, exprs3, exprs4, exprs5, exprs6, exprs7, + exprs8) + = outList + [sig0 <=> exprs0, sig1 <=> exprs1, sig2 <=> exprs2, + sig3 <=> exprs3, sig4 <=> exprs4, sig5 <=> exprs5, sig6 <=> exprs6, + sig7 <=> exprs7, sig8 <=> exprs8] + + +instance (Assign a0, Assign a1, Assign a2, Assign a3, Assign a4, + Assign a5, Assign a6, Assign a7, Assign a8, Assign a9) => + Assign (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) where + (sig0, sig1, sig2, sig3, sig4, sig5, sig6, sig7, sig8, sig9) <=> + (exprs0, exprs1, exprs2, exprs3, exprs4, exprs5, exprs6, exprs7, + exprs8, exprs9) + = outList + [sig0 <=> exprs0, sig1 <=> exprs1, sig2 <=> exprs2, + sig3 <=> exprs3, sig4 <=> exprs4, sig5 <=> exprs5, sig6 <=> exprs6, + sig7 <=> exprs7, sig8 <=> exprs8, sig9 <=> exprs9] + + +instance (Assign a0, Assign a1, Assign a2, Assign a3, Assign a4, + Assign a5, Assign a6, Assign a7, Assign a8, Assign a9, + Assign a10) => + Assign (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) where + (sig0, sig1, sig2, sig3, sig4, sig5, sig6, sig7, sig8, sig9, sig10) + <=> + (exprs0, exprs1, exprs2, exprs3, exprs4, exprs5, exprs6, exprs7, + exprs8, exprs9, exprs10) + = outList + [sig0 <=> exprs0, sig1 <=> exprs1, sig2 <=> exprs2, + sig3 <=> exprs3, sig4 <=> exprs4, sig5 <=> exprs5, sig6 <=> exprs6, + sig7 <=> exprs7, sig8 <=> exprs8, sig9 <=> exprs9, + sig10 <=> exprs10] + + +instance (Assign a0, Assign a1, Assign a2, Assign a3, Assign a4, + Assign a5, Assign a6, Assign a7, Assign a8, Assign a9, Assign a10, + Assign a11) => + Assign (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11) where + (sig0, sig1, sig2, sig3, sig4, sig5, sig6, sig7, sig8, sig9, sig10, + sig11) + <=> + (exprs0, exprs1, exprs2, exprs3, exprs4, exprs5, exprs6, exprs7, + exprs8, exprs9, exprs10, exprs11) + = outList + [sig0 <=> exprs0, sig1 <=> exprs1, sig2 <=> exprs2, + sig3 <=> exprs3, sig4 <=> exprs4, sig5 <=> exprs5, sig6 <=> exprs6, + sig7 <=> exprs7, sig8 <=> exprs8, sig9 <=> exprs9, + sig10 <=> exprs10, sig11 <=> exprs11] + + +instance (Assign a0, Assign a1, Assign a2, Assign a3, Assign a4, + Assign a5, Assign a6, Assign a7, Assign a8, Assign a9, Assign a10, + Assign a11, Assign a12) => + Assign (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12) + where + (sig0, sig1, sig2, sig3, sig4, sig5, sig6, sig7, sig8, sig9, sig10, + sig11, sig12) + <=> + (exprs0, exprs1, exprs2, exprs3, exprs4, exprs5, exprs6, exprs7, + exprs8, exprs9, exprs10, exprs11, exprs12) + = outList + [sig0 <=> exprs0, sig1 <=> exprs1, sig2 <=> exprs2, + sig3 <=> exprs3, sig4 <=> exprs4, sig5 <=> exprs5, sig6 <=> exprs6, + sig7 <=> exprs7, sig8 <=> exprs8, sig9 <=> exprs9, + sig10 <=> exprs10, sig11 <=> exprs11, sig12 <=> exprs12] + + +instance (Assign a0, Assign a1, Assign a2, Assign a3, Assign a4, + Assign a5, Assign a6, Assign a7, Assign a8, Assign a9, Assign a10, + Assign a11, Assign a12, Assign a13) => + Assign (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13) + where + (sig0, sig1, sig2, sig3, sig4, sig5, sig6, sig7, sig8, sig9, sig10, + sig11, sig12, sig13) + <=> + (exprs0, exprs1, exprs2, exprs3, exprs4, exprs5, exprs6, exprs7, + exprs8, exprs9, exprs10, exprs11, exprs12, exprs13) + = outList + [sig0 <=> exprs0, sig1 <=> exprs1, sig2 <=> exprs2, + sig3 <=> exprs3, sig4 <=> exprs4, sig5 <=> exprs5, sig6 <=> exprs6, + sig7 <=> exprs7, sig8 <=> exprs8, sig9 <=> exprs9, + sig10 <=> exprs10, sig11 <=> exprs11, sig12 <=> exprs12, + sig13 <=> exprs13] + + +instance (Assign a0, Assign a1, Assign a2, Assign a3, Assign a4, + Assign a5, Assign a6, Assign a7, Assign a8, Assign a9, Assign a10, + Assign a11, Assign a12, Assign a13, Assign a14) => + Assign + (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14) + where + (sig0, sig1, sig2, sig3, sig4, sig5, sig6, sig7, sig8, sig9, sig10, + sig11, sig12, sig13, sig14) + <=> + (exprs0, exprs1, exprs2, exprs3, exprs4, exprs5, exprs6, exprs7, + exprs8, exprs9, exprs10, exprs11, exprs12, exprs13, exprs14) + = outList + [sig0 <=> exprs0, sig1 <=> exprs1, sig2 <=> exprs2, + sig3 <=> exprs3, sig4 <=> exprs4, sig5 <=> exprs5, sig6 <=> exprs6, + sig7 <=> exprs7, sig8 <=> exprs8, sig9 <=> exprs9, + sig10 <=> exprs10, sig11 <=> exprs11, sig12 <=> exprs12, + sig13 <=> exprs13, sig14 <=> exprs14] + + +instance (Assign a0, Assign a1, Assign a2, Assign a3, Assign a4, + Assign a5, Assign a6, Assign a7, Assign a8, Assign a9, Assign a10, + Assign a11, Assign a12, Assign a13, Assign a14, Assign a15) => + Assign + (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, + a15) + where + (sig0, sig1, sig2, sig3, sig4, sig5, sig6, sig7, sig8, sig9, sig10, + sig11, sig12, sig13, sig14, sig15) + <=> + (exprs0, exprs1, exprs2, exprs3, exprs4, exprs5, exprs6, exprs7, + exprs8, exprs9, exprs10, exprs11, exprs12, exprs13, exprs14, + exprs15) + = outList + [sig0 <=> exprs0, sig1 <=> exprs1, sig2 <=> exprs2, + sig3 <=> exprs3, sig4 <=> exprs4, sig5 <=> exprs5, sig6 <=> exprs6, + sig7 <=> exprs7, sig8 <=> exprs8, sig9 <=> exprs9, + sig10 <=> exprs10, sig11 <=> exprs11, sig12 <=> exprs12, + sig13 <=> exprs13, sig14 <=> exprs14, sig15 <=> exprs15] + + +instance (Assign a0, Assign a1, Assign a2, Assign a3, Assign a4, + Assign a5, Assign a6, Assign a7, Assign a8, Assign a9, Assign a10, + Assign a11, Assign a12, Assign a13, Assign a14, Assign a15, + Assign a16) => + Assign + (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, + a15, a16) + where + (sig0, sig1, sig2, sig3, sig4, sig5, sig6, sig7, sig8, sig9, sig10, + sig11, sig12, sig13, sig14, sig15, sig16) + <=> + (exprs0, exprs1, exprs2, exprs3, exprs4, exprs5, exprs6, exprs7, + exprs8, exprs9, exprs10, exprs11, exprs12, exprs13, exprs14, + exprs15, exprs16) + = outList + [sig0 <=> exprs0, sig1 <=> exprs1, sig2 <=> exprs2, + sig3 <=> exprs3, sig4 <=> exprs4, sig5 <=> exprs5, sig6 <=> exprs6, + sig7 <=> exprs7, sig8 <=> exprs8, sig9 <=> exprs9, + sig10 <=> exprs10, sig11 <=> exprs11, sig12 <=> exprs12, + sig13 <=> exprs13, sig14 <=> exprs14, sig15 <=> exprs15, + sig16 <=> exprs16] + + +instance (Assign a0, Assign a1, Assign a2, Assign a3, Assign a4, + Assign a5, Assign a6, Assign a7, Assign a8, Assign a9, Assign a10, + Assign a11, Assign a12, Assign a13, Assign a14, Assign a15, + Assign a16, Assign a17) => + Assign + (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, + a15, a16, a17) + where + (sig0, sig1, sig2, sig3, sig4, sig5, sig6, sig7, sig8, sig9, sig10, + sig11, sig12, sig13, sig14, sig15, sig16, sig17) + <=> + (exprs0, exprs1, exprs2, exprs3, exprs4, exprs5, exprs6, exprs7, + exprs8, exprs9, exprs10, exprs11, exprs12, exprs13, exprs14, + exprs15, exprs16, exprs17) + = outList + [sig0 <=> exprs0, sig1 <=> exprs1, sig2 <=> exprs2, + sig3 <=> exprs3, sig4 <=> exprs4, sig5 <=> exprs5, sig6 <=> exprs6, + sig7 <=> exprs7, sig8 <=> exprs8, sig9 <=> exprs9, + sig10 <=> exprs10, sig11 <=> exprs11, sig12 <=> exprs12, + sig13 <=> exprs13, sig14 <=> exprs14, sig15 <=> exprs15, + sig16 <=> exprs16, sig17 <=> exprs17] + + +instance (Assign a0, Assign a1, Assign a2, Assign a3, Assign a4, + Assign a5, Assign a6, Assign a7, Assign a8, Assign a9, Assign a10, + Assign a11, Assign a12, Assign a13, Assign a14, Assign a15, + Assign a16, Assign a17, Assign a18) => + Assign + (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, + a15, a16, a17, a18) + where + (sig0, sig1, sig2, sig3, sig4, sig5, sig6, sig7, sig8, sig9, sig10, + sig11, sig12, sig13, sig14, sig15, sig16, sig17, sig18) + <=> + (exprs0, exprs1, exprs2, exprs3, exprs4, exprs5, exprs6, exprs7, + exprs8, exprs9, exprs10, exprs11, exprs12, exprs13, exprs14, + exprs15, exprs16, exprs17, exprs18) + = outList + [sig0 <=> exprs0, sig1 <=> exprs1, sig2 <=> exprs2, + sig3 <=> exprs3, sig4 <=> exprs4, sig5 <=> exprs5, sig6 <=> exprs6, + sig7 <=> exprs7, sig8 <=> exprs8, sig9 <=> exprs9, + sig10 <=> exprs10, sig11 <=> exprs11, sig12 <=> exprs12, + sig13 <=> exprs13, sig14 <=> exprs14, sig15 <=> exprs15, + sig16 <=> exprs16, sig17 <=> exprs17, sig18 <=> exprs18] + + +instance (Assign a0, Assign a1, Assign a2, Assign a3, Assign a4, + Assign a5, Assign a6, Assign a7, Assign a8, Assign a9, Assign a10, + Assign a11, Assign a12, Assign a13, Assign a14, Assign a15, + Assign a16, Assign a17, Assign a18, Assign a19) => + Assign + (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, + a15, a16, a17, a18, a19) + where + (sig0, sig1, sig2, sig3, sig4, sig5, sig6, sig7, sig8, sig9, sig10, + sig11, sig12, sig13, sig14, sig15, sig16, sig17, sig18, sig19) + <=> + (exprs0, exprs1, exprs2, exprs3, exprs4, exprs5, exprs6, exprs7, + exprs8, exprs9, exprs10, exprs11, exprs12, exprs13, exprs14, + exprs15, exprs16, exprs17, exprs18, exprs19) + = outList + [sig0 <=> exprs0, sig1 <=> exprs1, sig2 <=> exprs2, + sig3 <=> exprs3, sig4 <=> exprs4, sig5 <=> exprs5, sig6 <=> exprs6, + sig7 <=> exprs7, sig8 <=> exprs8, sig9 <=> exprs9, + sig10 <=> exprs10, sig11 <=> exprs11, sig12 <=> exprs12, + sig13 <=> exprs13, sig14 <=> exprs14, sig15 <=> exprs15, + sig16 <=> exprs16, sig17 <=> exprs17, sig18 <=> exprs18, + sig19 <=> exprs19] + + +instance (Assign a0, Assign a1, Assign a2, Assign a3, Assign a4, + Assign a5, Assign a6, Assign a7, Assign a8, Assign a9, Assign a10, + Assign a11, Assign a12, Assign a13, Assign a14, Assign a15, + Assign a16, Assign a17, Assign a18, Assign a19, Assign a20) => + Assign + (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, + a15, a16, a17, a18, a19, a20) + where + (sig0, sig1, sig2, sig3, sig4, sig5, sig6, sig7, sig8, sig9, sig10, + sig11, sig12, sig13, sig14, sig15, sig16, sig17, sig18, sig19, + sig20) + <=> + (exprs0, exprs1, exprs2, exprs3, exprs4, exprs5, exprs6, exprs7, + exprs8, exprs9, exprs10, exprs11, exprs12, exprs13, exprs14, + exprs15, exprs16, exprs17, exprs18, exprs19, exprs20) + = outList + [sig0 <=> exprs0, sig1 <=> exprs1, sig2 <=> exprs2, + sig3 <=> exprs3, sig4 <=> exprs4, sig5 <=> exprs5, sig6 <=> exprs6, + sig7 <=> exprs7, sig8 <=> exprs8, sig9 <=> exprs9, + sig10 <=> exprs10, sig11 <=> exprs11, sig12 <=> exprs12, + sig13 <=> exprs13, sig14 <=> exprs14, sig15 <=> exprs15, + sig16 <=> exprs16, sig17 <=> exprs17, sig18 <=> exprs18, + sig19 <=> exprs19, sig20 <=> exprs20] + + +instance (Assign a0, Assign a1, Assign a2, Assign a3, Assign a4, + Assign a5, Assign a6, Assign a7, Assign a8, Assign a9, Assign a10, + Assign a11, Assign a12, Assign a13, Assign a14, Assign a15, + Assign a16, Assign a17, Assign a18, Assign a19, Assign a20, + Assign a21) => + Assign + (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, + a15, a16, a17, a18, a19, a20, a21) + where + (sig0, sig1, sig2, sig3, sig4, sig5, sig6, sig7, sig8, sig9, sig10, + sig11, sig12, sig13, sig14, sig15, sig16, sig17, sig18, sig19, + sig20, sig21) + <=> + (exprs0, exprs1, exprs2, exprs3, exprs4, exprs5, exprs6, exprs7, + exprs8, exprs9, exprs10, exprs11, exprs12, exprs13, exprs14, + exprs15, exprs16, exprs17, exprs18, exprs19, exprs20, exprs21) + = outList + [sig0 <=> exprs0, sig1 <=> exprs1, sig2 <=> exprs2, + sig3 <=> exprs3, sig4 <=> exprs4, sig5 <=> exprs5, sig6 <=> exprs6, + sig7 <=> exprs7, sig8 <=> exprs8, sig9 <=> exprs9, + sig10 <=> exprs10, sig11 <=> exprs11, sig12 <=> exprs12, + sig13 <=> exprs13, sig14 <=> exprs14, sig15 <=> exprs15, + sig16 <=> exprs16, sig17 <=> exprs17, sig18 <=> exprs18, + sig19 <=> exprs19, sig20 <=> exprs20, sig21 <=> exprs21] + + +instance (Assign a0, Assign a1, Assign a2, Assign a3, Assign a4, + Assign a5, Assign a6, Assign a7, Assign a8, Assign a9, Assign a10, + Assign a11, Assign a12, Assign a13, Assign a14, Assign a15, + Assign a16, Assign a17, Assign a18, Assign a19, Assign a20, + Assign a21, Assign a22) => + Assign + (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, + a15, a16, a17, a18, a19, a20, a21, a22) + where + (sig0, sig1, sig2, sig3, sig4, sig5, sig6, sig7, sig8, sig9, sig10, + sig11, sig12, sig13, sig14, sig15, sig16, sig17, sig18, sig19, + sig20, sig21, sig22) + <=> + (exprs0, exprs1, exprs2, exprs3, exprs4, exprs5, exprs6, exprs7, + exprs8, exprs9, exprs10, exprs11, exprs12, exprs13, exprs14, + exprs15, exprs16, exprs17, exprs18, exprs19, exprs20, exprs21, + exprs22) + = outList + [sig0 <=> exprs0, sig1 <=> exprs1, sig2 <=> exprs2, + sig3 <=> exprs3, sig4 <=> exprs4, sig5 <=> exprs5, sig6 <=> exprs6, + sig7 <=> exprs7, sig8 <=> exprs8, sig9 <=> exprs9, + sig10 <=> exprs10, sig11 <=> exprs11, sig12 <=> exprs12, + sig13 <=> exprs13, sig14 <=> exprs14, sig15 <=> exprs15, + sig16 <=> exprs16, sig17 <=> exprs17, sig18 <=> exprs18, + sig19 <=> exprs19, sig20 <=> exprs20, sig21 <=> exprs21, + sig22 <=> exprs22] + + +instance (Assign a0, Assign a1, Assign a2, Assign a3, Assign a4, + Assign a5, Assign a6, Assign a7, Assign a8, Assign a9, Assign a10, + Assign a11, Assign a12, Assign a13, Assign a14, Assign a15, + Assign a16, Assign a17, Assign a18, Assign a19, Assign a20, + Assign a21, Assign a22, Assign a23) => + Assign + (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, + a15, a16, a17, a18, a19, a20, a21, a22, a23) + where + (sig0, sig1, sig2, sig3, sig4, sig5, sig6, sig7, sig8, sig9, sig10, + sig11, sig12, sig13, sig14, sig15, sig16, sig17, sig18, sig19, + sig20, sig21, sig22, sig23) + <=> + (exprs0, exprs1, exprs2, exprs3, exprs4, exprs5, exprs6, exprs7, + exprs8, exprs9, exprs10, exprs11, exprs12, exprs13, exprs14, + exprs15, exprs16, exprs17, exprs18, exprs19, exprs20, exprs21, + exprs22, exprs23) + = outList + [sig0 <=> exprs0, sig1 <=> exprs1, sig2 <=> exprs2, + sig3 <=> exprs3, sig4 <=> exprs4, sig5 <=> exprs5, sig6 <=> exprs6, + sig7 <=> exprs7, sig8 <=> exprs8, sig9 <=> exprs9, + sig10 <=> exprs10, sig11 <=> exprs11, sig12 <=> exprs12, + sig13 <=> exprs13, sig14 <=> exprs14, sig15 <=> exprs15, + sig16 <=> exprs16, sig17 <=> exprs17, sig18 <=> exprs18, + sig19 <=> exprs19, sig20 <=> exprs20, sig21 <=> exprs21, + sig22 <=> exprs22, sig23 <=> exprs23] + + +instance (Assign a0, Assign a1, Assign a2, Assign a3, Assign a4, + Assign a5, Assign a6, Assign a7, Assign a8, Assign a9, Assign a10, + Assign a11, Assign a12, Assign a13, Assign a14, Assign a15, + Assign a16, Assign a17, Assign a18, Assign a19, Assign a20, + Assign a21, Assign a22, Assign a23, Assign a24) => + Assign + (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, + a15, a16, a17, a18, a19, a20, a21, a22, a23, a24) + where + (sig0, sig1, sig2, sig3, sig4, sig5, sig6, sig7, sig8, sig9, sig10, + sig11, sig12, sig13, sig14, sig15, sig16, sig17, sig18, sig19, + sig20, sig21, sig22, sig23, sig24) + <=> + (exprs0, exprs1, exprs2, exprs3, exprs4, exprs5, exprs6, exprs7, + exprs8, exprs9, exprs10, exprs11, exprs12, exprs13, exprs14, + exprs15, exprs16, exprs17, exprs18, exprs19, exprs20, exprs21, + exprs22, exprs23, exprs24) + = outList + [sig0 <=> exprs0, sig1 <=> exprs1, sig2 <=> exprs2, + sig3 <=> exprs3, sig4 <=> exprs4, sig5 <=> exprs5, sig6 <=> exprs6, + sig7 <=> exprs7, sig8 <=> exprs8, sig9 <=> exprs9, + sig10 <=> exprs10, sig11 <=> exprs11, sig12 <=> exprs12, + sig13 <=> exprs13, sig14 <=> exprs14, sig15 <=> exprs15, + sig16 <=> exprs16, sig17 <=> exprs17, sig18 <=> exprs18, + sig19 <=> exprs19, sig20 <=> exprs20, sig21 <=> exprs21, + sig22 <=> exprs22, sig23 <=> exprs23, sig24 <=> exprs24] + + +instance (Assign a0, Assign a1, Assign a2, Assign a3, Assign a4, + Assign a5, Assign a6, Assign a7, Assign a8, Assign a9, Assign a10, + Assign a11, Assign a12, Assign a13, Assign a14, Assign a15, + Assign a16, Assign a17, Assign a18, Assign a19, Assign a20, + Assign a21, Assign a22, Assign a23, Assign a24, Assign a25) => + Assign + (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, + a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25) + where + (sig0, sig1, sig2, sig3, sig4, sig5, sig6, sig7, sig8, sig9, sig10, + sig11, sig12, sig13, sig14, sig15, sig16, sig17, sig18, sig19, + sig20, sig21, sig22, sig23, sig24, sig25) + <=> + (exprs0, exprs1, exprs2, exprs3, exprs4, exprs5, exprs6, exprs7, + exprs8, exprs9, exprs10, exprs11, exprs12, exprs13, exprs14, + exprs15, exprs16, exprs17, exprs18, exprs19, exprs20, exprs21, + exprs22, exprs23, exprs24, exprs25) + = outList + [sig0 <=> exprs0, sig1 <=> exprs1, sig2 <=> exprs2, + sig3 <=> exprs3, sig4 <=> exprs4, sig5 <=> exprs5, sig6 <=> exprs6, + sig7 <=> exprs7, sig8 <=> exprs8, sig9 <=> exprs9, + sig10 <=> exprs10, sig11 <=> exprs11, sig12 <=> exprs12, + sig13 <=> exprs13, sig14 <=> exprs14, sig15 <=> exprs15, + sig16 <=> exprs16, sig17 <=> exprs17, sig18 <=> exprs18, + sig19 <=> exprs19, sig20 <=> exprs20, sig21 <=> exprs21, + sig22 <=> exprs22, sig23 <=> exprs23, sig24 <=> exprs24, + sig25 <=> exprs25] + + +instance (Assign a0, Assign a1, Assign a2, Assign a3, Assign a4, + Assign a5, Assign a6, Assign a7, Assign a8, Assign a9, Assign a10, + Assign a11, Assign a12, Assign a13, Assign a14, Assign a15, + Assign a16, Assign a17, Assign a18, Assign a19, Assign a20, + Assign a21, Assign a22, Assign a23, Assign a24, Assign a25, + Assign a26) => + Assign + (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, + a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26) + where + (sig0, sig1, sig2, sig3, sig4, sig5, sig6, sig7, sig8, sig9, sig10, + sig11, sig12, sig13, sig14, sig15, sig16, sig17, sig18, sig19, + sig20, sig21, sig22, sig23, sig24, sig25, sig26) + <=> + (exprs0, exprs1, exprs2, exprs3, exprs4, exprs5, exprs6, exprs7, + exprs8, exprs9, exprs10, exprs11, exprs12, exprs13, exprs14, + exprs15, exprs16, exprs17, exprs18, exprs19, exprs20, exprs21, + exprs22, exprs23, exprs24, exprs25, exprs26) + = outList + [sig0 <=> exprs0, sig1 <=> exprs1, sig2 <=> exprs2, + sig3 <=> exprs3, sig4 <=> exprs4, sig5 <=> exprs5, sig6 <=> exprs6, + sig7 <=> exprs7, sig8 <=> exprs8, sig9 <=> exprs9, + sig10 <=> exprs10, sig11 <=> exprs11, sig12 <=> exprs12, + sig13 <=> exprs13, sig14 <=> exprs14, sig15 <=> exprs15, + sig16 <=> exprs16, sig17 <=> exprs17, sig18 <=> exprs18, + sig19 <=> exprs19, sig20 <=> exprs20, sig21 <=> exprs21, + sig22 <=> exprs22, sig23 <=> exprs23, sig24 <=> exprs24, + sig25 <=> exprs25, sig26 <=> exprs26] + + +instance (Assign a0, Assign a1, Assign a2, Assign a3, Assign a4, + Assign a5, Assign a6, Assign a7, Assign a8, Assign a9, Assign a10, + Assign a11, Assign a12, Assign a13, Assign a14, Assign a15, + Assign a16, Assign a17, Assign a18, Assign a19, Assign a20, + Assign a21, Assign a22, Assign a23, Assign a24, Assign a25, + Assign a26, Assign a27) => + Assign + (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, + a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27) + where + (sig0, sig1, sig2, sig3, sig4, sig5, sig6, sig7, sig8, sig9, sig10, + sig11, sig12, sig13, sig14, sig15, sig16, sig17, sig18, sig19, + sig20, sig21, sig22, sig23, sig24, sig25, sig26, sig27) + <=> + (exprs0, exprs1, exprs2, exprs3, exprs4, exprs5, exprs6, exprs7, + exprs8, exprs9, exprs10, exprs11, exprs12, exprs13, exprs14, + exprs15, exprs16, exprs17, exprs18, exprs19, exprs20, exprs21, + exprs22, exprs23, exprs24, exprs25, exprs26, exprs27) + = outList + [sig0 <=> exprs0, sig1 <=> exprs1, sig2 <=> exprs2, + sig3 <=> exprs3, sig4 <=> exprs4, sig5 <=> exprs5, sig6 <=> exprs6, + sig7 <=> exprs7, sig8 <=> exprs8, sig9 <=> exprs9, + sig10 <=> exprs10, sig11 <=> exprs11, sig12 <=> exprs12, + sig13 <=> exprs13, sig14 <=> exprs14, sig15 <=> exprs15, + sig16 <=> exprs16, sig17 <=> exprs17, sig18 <=> exprs18, + sig19 <=> exprs19, sig20 <=> exprs20, sig21 <=> exprs21, + sig22 <=> exprs22, sig23 <=> exprs23, sig24 <=> exprs24, + sig25 <=> exprs25, sig26 <=> exprs26, sig27 <=> exprs27] + + +instance (Assign a0, Assign a1, Assign a2, Assign a3, Assign a4, + Assign a5, Assign a6, Assign a7, Assign a8, Assign a9, Assign a10, + Assign a11, Assign a12, Assign a13, Assign a14, Assign a15, + Assign a16, Assign a17, Assign a18, Assign a19, Assign a20, + Assign a21, Assign a22, Assign a23, Assign a24, Assign a25, + Assign a26, Assign a27, Assign a28) => + Assign + (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, + a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, + a28) + where + (sig0, sig1, sig2, sig3, sig4, sig5, sig6, sig7, sig8, sig9, sig10, + sig11, sig12, sig13, sig14, sig15, sig16, sig17, sig18, sig19, + sig20, sig21, sig22, sig23, sig24, sig25, sig26, sig27, sig28) + <=> + (exprs0, exprs1, exprs2, exprs3, exprs4, exprs5, exprs6, exprs7, + exprs8, exprs9, exprs10, exprs11, exprs12, exprs13, exprs14, + exprs15, exprs16, exprs17, exprs18, exprs19, exprs20, exprs21, + exprs22, exprs23, exprs24, exprs25, exprs26, exprs27, exprs28) + = outList + [sig0 <=> exprs0, sig1 <=> exprs1, sig2 <=> exprs2, + sig3 <=> exprs3, sig4 <=> exprs4, sig5 <=> exprs5, sig6 <=> exprs6, + sig7 <=> exprs7, sig8 <=> exprs8, sig9 <=> exprs9, + sig10 <=> exprs10, sig11 <=> exprs11, sig12 <=> exprs12, + sig13 <=> exprs13, sig14 <=> exprs14, sig15 <=> exprs15, + sig16 <=> exprs16, sig17 <=> exprs17, sig18 <=> exprs18, + sig19 <=> exprs19, sig20 <=> exprs20, sig21 <=> exprs21, + sig22 <=> exprs22, sig23 <=> exprs23, sig24 <=> exprs24, + sig25 <=> exprs25, sig26 <=> exprs26, sig27 <=> exprs27, + sig28 <=> exprs28] + + +instance (Assign a0, Assign a1, Assign a2, Assign a3, Assign a4, + Assign a5, Assign a6, Assign a7, Assign a8, Assign a9, Assign a10, + Assign a11, Assign a12, Assign a13, Assign a14, Assign a15, + Assign a16, Assign a17, Assign a18, Assign a19, Assign a20, + Assign a21, Assign a22, Assign a23, Assign a24, Assign a25, + Assign a26, Assign a27, Assign a28, Assign a29) => + Assign + (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, + a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, + a28, a29) + where + (sig0, sig1, sig2, sig3, sig4, sig5, sig6, sig7, sig8, sig9, sig10, + sig11, sig12, sig13, sig14, sig15, sig16, sig17, sig18, sig19, + sig20, sig21, sig22, sig23, sig24, sig25, sig26, sig27, sig28, + sig29) + <=> + (exprs0, exprs1, exprs2, exprs3, exprs4, exprs5, exprs6, exprs7, + exprs8, exprs9, exprs10, exprs11, exprs12, exprs13, exprs14, + exprs15, exprs16, exprs17, exprs18, exprs19, exprs20, exprs21, + exprs22, exprs23, exprs24, exprs25, exprs26, exprs27, exprs28, + exprs29) + = outList + [sig0 <=> exprs0, sig1 <=> exprs1, sig2 <=> exprs2, + sig3 <=> exprs3, sig4 <=> exprs4, sig5 <=> exprs5, sig6 <=> exprs6, + sig7 <=> exprs7, sig8 <=> exprs8, sig9 <=> exprs9, + sig10 <=> exprs10, sig11 <=> exprs11, sig12 <=> exprs12, + sig13 <=> exprs13, sig14 <=> exprs14, sig15 <=> exprs15, + sig16 <=> exprs16, sig17 <=> exprs17, sig18 <=> exprs18, + sig19 <=> exprs19, sig20 <=> exprs20, sig21 <=> exprs21, + sig22 <=> exprs22, sig23 <=> exprs23, sig24 <=> exprs24, + sig25 <=> exprs25, sig26 <=> exprs26, sig27 <=> exprs27, + sig28 <=> exprs28, sig29 <=> exprs29] + + +instance (Assign a0, Assign a1, Assign a2, Assign a3, Assign a4, + Assign a5, Assign a6, Assign a7, Assign a8, Assign a9, Assign a10, + Assign a11, Assign a12, Assign a13, Assign a14, Assign a15, + Assign a16, Assign a17, Assign a18, Assign a19, Assign a20, + Assign a21, Assign a22, Assign a23, Assign a24, Assign a25, + Assign a26, Assign a27, Assign a28, Assign a29, Assign a30) => + Assign + (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, + a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, + a28, a29, a30) + where + (sig0, sig1, sig2, sig3, sig4, sig5, sig6, sig7, sig8, sig9, sig10, + sig11, sig12, sig13, sig14, sig15, sig16, sig17, sig18, sig19, + sig20, sig21, sig22, sig23, sig24, sig25, sig26, sig27, sig28, + sig29, sig30) + <=> + (exprs0, exprs1, exprs2, exprs3, exprs4, exprs5, exprs6, exprs7, + exprs8, exprs9, exprs10, exprs11, exprs12, exprs13, exprs14, + exprs15, exprs16, exprs17, exprs18, exprs19, exprs20, exprs21, + exprs22, exprs23, exprs24, exprs25, exprs26, exprs27, exprs28, + exprs29, exprs30) + = outList + [sig0 <=> exprs0, sig1 <=> exprs1, sig2 <=> exprs2, + sig3 <=> exprs3, sig4 <=> exprs4, sig5 <=> exprs5, sig6 <=> exprs6, + sig7 <=> exprs7, sig8 <=> exprs8, sig9 <=> exprs9, + sig10 <=> exprs10, sig11 <=> exprs11, sig12 <=> exprs12, + sig13 <=> exprs13, sig14 <=> exprs14, sig15 <=> exprs15, + sig16 <=> exprs16, sig17 <=> exprs17, sig18 <=> exprs18, + sig19 <=> exprs19, sig20 <=> exprs20, sig21 <=> exprs21, + sig22 <=> exprs22, sig23 <=> exprs23, sig24 <=> exprs24, + sig25 <=> exprs25, sig26 <=> exprs26, sig27 <=> exprs27, + sig28 <=> exprs28, sig29 <=> exprs29, sig30 <=> exprs30] + + +instance (Assign a0, Assign a1, Assign a2, Assign a3, Assign a4, + Assign a5, Assign a6, Assign a7, Assign a8, Assign a9, Assign a10, + Assign a11, Assign a12, Assign a13, Assign a14, Assign a15, + Assign a16, Assign a17, Assign a18, Assign a19, Assign a20, + Assign a21, Assign a22, Assign a23, Assign a24, Assign a25, + Assign a26, Assign a27, Assign a28, Assign a29, Assign a30, + Assign a31) => + Assign + (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, + a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, + a28, a29, a30, a31) + where + (sig0, sig1, sig2, sig3, sig4, sig5, sig6, sig7, sig8, sig9, sig10, + sig11, sig12, sig13, sig14, sig15, sig16, sig17, sig18, sig19, + sig20, sig21, sig22, sig23, sig24, sig25, sig26, sig27, sig28, + sig29, sig30, sig31) + <=> + (exprs0, exprs1, exprs2, exprs3, exprs4, exprs5, exprs6, exprs7, + exprs8, exprs9, exprs10, exprs11, exprs12, exprs13, exprs14, + exprs15, exprs16, exprs17, exprs18, exprs19, exprs20, exprs21, + exprs22, exprs23, exprs24, exprs25, exprs26, exprs27, exprs28, + exprs29, exprs30, exprs31) + = outList + [sig0 <=> exprs0, sig1 <=> exprs1, sig2 <=> exprs2, + sig3 <=> exprs3, sig4 <=> exprs4, sig5 <=> exprs5, sig6 <=> exprs6, + sig7 <=> exprs7, sig8 <=> exprs8, sig9 <=> exprs9, + sig10 <=> exprs10, sig11 <=> exprs11, sig12 <=> exprs12, + sig13 <=> exprs13, sig14 <=> exprs14, sig15 <=> exprs15, + sig16 <=> exprs16, sig17 <=> exprs17, sig18 <=> exprs18, + sig19 <=> exprs19, sig20 <=> exprs20, sig21 <=> exprs21, + sig22 <=> exprs22, sig23 <=> exprs23, sig24 <=> exprs24, + sig25 <=> exprs25, sig26 <=> exprs26, sig27 <=> exprs27, + sig28 <=> exprs28, sig29 <=> exprs29, sig30 <=> exprs30, + sig31 <=> exprs31] diff --git a/src/CsoundExpr/Base/Literal.hs b/src/CsoundExpr/Base/Literal.hs deleted file mode 100644 --- a/src/CsoundExpr/Base/Literal.hs +++ /dev/null @@ -1,726 +0,0 @@ -{-# LANGUAGE FlexibleInstances, MultiParamTypeClasses, - TypeSynonymInstances, FlexibleContexts #-} - --- | Functions to write imperative style csound code - -module CsoundExpr.Base.Literal( - ar, - kr, - ir, - gar, - gkr, - gir, - Assign(..)) -where - -import CsoundExpr.Translator.Types -import CsoundExpr.Translator.Cs.IM -import CsoundExpr.Translator.Cs.CsTree -import CsoundExpr.Translator.ExprTree.ExprTree - - -ar :: Name -> Arate -ar = argIn A - - -kr :: Name -> Krate -kr = argIn K - - -ir :: Name -> Irate -ir = argIn I - - -gar :: Name -> Arate -gar = argIn GA - - -gkr :: Name -> Krate -gkr = argIn GK - - -gir :: Name -> Irate -gir = argIn GI - - -fromArgIn :: (IM CsTree a) => a -> (Rate, Name) -fromArgIn a - | isArg e = (argRate e, argName e) - | otherwise = - error "left hand side of <=> should be named expression" - where e = exprOp $ exprTreeTag t - t = to a :: CsTree - --- Assign Class - - -infixr 0 <=> - - -class Assign a where - - (<=>) :: a -> a -> SignalOut - - -instance Assign Arate where - sig <=> expr - = let (rate, name) = fromArgIn sig in - SignalOut $ return $ argOut rate name expr - - -instance Assign Krate where - sig <=> expr - = let (rate, name) = fromArgIn sig in - SignalOut $ return $ argOut rate name expr - - -instance Assign Irate where - sig <=> expr - = let (rate, name) = fromArgIn sig in - SignalOut $ return $ argOut rate name expr - - -instance (Assign a) => Assign [a] where - sigs <=> exprs = outList $ zipWith (<=>) sigs exprs - - -instance (Assign a0, Assign a1) => Assign (a0, a1) where - (sig0, sig1) <=> (exprs0, exprs1) - = outList [sig0 <=> exprs0, sig1 <=> exprs1] - - -instance (Assign a0, Assign a1, Assign a2) => Assign (a0, a1, a2) - where - (sig0, sig1, sig2) <=> (exprs0, exprs1, exprs2) - = outList [sig0 <=> exprs0, sig1 <=> exprs1, sig2 <=> exprs2] - - -instance (Assign a0, Assign a1, Assign a2, Assign a3) => Assign - (a0, a1, a2, a3) where - (sig0, sig1, sig2, sig3) <=> (exprs0, exprs1, exprs2, exprs3) - = outList - [sig0 <=> exprs0, sig1 <=> exprs1, sig2 <=> exprs2, - sig3 <=> exprs3] - - -instance (Assign a0, Assign a1, Assign a2, Assign a3, Assign a4) => - Assign (a0, a1, a2, a3, a4) where - (sig0, sig1, sig2, sig3, sig4) <=> - (exprs0, exprs1, exprs2, exprs3, exprs4) - = outList - [sig0 <=> exprs0, sig1 <=> exprs1, sig2 <=> exprs2, - sig3 <=> exprs3, sig4 <=> exprs4] - - -instance (Assign a0, Assign a1, Assign a2, Assign a3, Assign a4, - Assign a5) => - Assign (a0, a1, a2, a3, a4, a5) where - (sig0, sig1, sig2, sig3, sig4, sig5) <=> - (exprs0, exprs1, exprs2, exprs3, exprs4, exprs5) - = outList - [sig0 <=> exprs0, sig1 <=> exprs1, sig2 <=> exprs2, - sig3 <=> exprs3, sig4 <=> exprs4, sig5 <=> exprs5] - - -instance (Assign a0, Assign a1, Assign a2, Assign a3, Assign a4, - Assign a5, Assign a6) => - Assign (a0, a1, a2, a3, a4, a5, a6) where - (sig0, sig1, sig2, sig3, sig4, sig5, sig6) <=> - (exprs0, exprs1, exprs2, exprs3, exprs4, exprs5, exprs6) - = outList - [sig0 <=> exprs0, sig1 <=> exprs1, sig2 <=> exprs2, - sig3 <=> exprs3, sig4 <=> exprs4, sig5 <=> exprs5, sig6 <=> exprs6] - - -instance (Assign a0, Assign a1, Assign a2, Assign a3, Assign a4, - Assign a5, Assign a6, Assign a7) => - Assign (a0, a1, a2, a3, a4, a5, a6, a7) where - (sig0, sig1, sig2, sig3, sig4, sig5, sig6, sig7) <=> - (exprs0, exprs1, exprs2, exprs3, exprs4, exprs5, exprs6, exprs7) - = outList - [sig0 <=> exprs0, sig1 <=> exprs1, sig2 <=> exprs2, - sig3 <=> exprs3, sig4 <=> exprs4, sig5 <=> exprs5, sig6 <=> exprs6, - sig7 <=> exprs7] - - -instance (Assign a0, Assign a1, Assign a2, Assign a3, Assign a4, - Assign a5, Assign a6, Assign a7, Assign a8) => - Assign (a0, a1, a2, a3, a4, a5, a6, a7, a8) where - (sig0, sig1, sig2, sig3, sig4, sig5, sig6, sig7, sig8) <=> - (exprs0, exprs1, exprs2, exprs3, exprs4, exprs5, exprs6, exprs7, - exprs8) - = outList - [sig0 <=> exprs0, sig1 <=> exprs1, sig2 <=> exprs2, - sig3 <=> exprs3, sig4 <=> exprs4, sig5 <=> exprs5, sig6 <=> exprs6, - sig7 <=> exprs7, sig8 <=> exprs8] - - -instance (Assign a0, Assign a1, Assign a2, Assign a3, Assign a4, - Assign a5, Assign a6, Assign a7, Assign a8, Assign a9) => - Assign (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) where - (sig0, sig1, sig2, sig3, sig4, sig5, sig6, sig7, sig8, sig9) <=> - (exprs0, exprs1, exprs2, exprs3, exprs4, exprs5, exprs6, exprs7, - exprs8, exprs9) - = outList - [sig0 <=> exprs0, sig1 <=> exprs1, sig2 <=> exprs2, - sig3 <=> exprs3, sig4 <=> exprs4, sig5 <=> exprs5, sig6 <=> exprs6, - sig7 <=> exprs7, sig8 <=> exprs8, sig9 <=> exprs9] - - -instance (Assign a0, Assign a1, Assign a2, Assign a3, Assign a4, - Assign a5, Assign a6, Assign a7, Assign a8, Assign a9, - Assign a10) => - Assign (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) where - (sig0, sig1, sig2, sig3, sig4, sig5, sig6, sig7, sig8, sig9, sig10) - <=> - (exprs0, exprs1, exprs2, exprs3, exprs4, exprs5, exprs6, exprs7, - exprs8, exprs9, exprs10) - = outList - [sig0 <=> exprs0, sig1 <=> exprs1, sig2 <=> exprs2, - sig3 <=> exprs3, sig4 <=> exprs4, sig5 <=> exprs5, sig6 <=> exprs6, - sig7 <=> exprs7, sig8 <=> exprs8, sig9 <=> exprs9, - sig10 <=> exprs10] - - -instance (Assign a0, Assign a1, Assign a2, Assign a3, Assign a4, - Assign a5, Assign a6, Assign a7, Assign a8, Assign a9, Assign a10, - Assign a11) => - Assign (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11) where - (sig0, sig1, sig2, sig3, sig4, sig5, sig6, sig7, sig8, sig9, sig10, - sig11) - <=> - (exprs0, exprs1, exprs2, exprs3, exprs4, exprs5, exprs6, exprs7, - exprs8, exprs9, exprs10, exprs11) - = outList - [sig0 <=> exprs0, sig1 <=> exprs1, sig2 <=> exprs2, - sig3 <=> exprs3, sig4 <=> exprs4, sig5 <=> exprs5, sig6 <=> exprs6, - sig7 <=> exprs7, sig8 <=> exprs8, sig9 <=> exprs9, - sig10 <=> exprs10, sig11 <=> exprs11] - - -instance (Assign a0, Assign a1, Assign a2, Assign a3, Assign a4, - Assign a5, Assign a6, Assign a7, Assign a8, Assign a9, Assign a10, - Assign a11, Assign a12) => - Assign (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12) - where - (sig0, sig1, sig2, sig3, sig4, sig5, sig6, sig7, sig8, sig9, sig10, - sig11, sig12) - <=> - (exprs0, exprs1, exprs2, exprs3, exprs4, exprs5, exprs6, exprs7, - exprs8, exprs9, exprs10, exprs11, exprs12) - = outList - [sig0 <=> exprs0, sig1 <=> exprs1, sig2 <=> exprs2, - sig3 <=> exprs3, sig4 <=> exprs4, sig5 <=> exprs5, sig6 <=> exprs6, - sig7 <=> exprs7, sig8 <=> exprs8, sig9 <=> exprs9, - sig10 <=> exprs10, sig11 <=> exprs11, sig12 <=> exprs12] - - -instance (Assign a0, Assign a1, Assign a2, Assign a3, Assign a4, - Assign a5, Assign a6, Assign a7, Assign a8, Assign a9, Assign a10, - Assign a11, Assign a12, Assign a13) => - Assign (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13) - where - (sig0, sig1, sig2, sig3, sig4, sig5, sig6, sig7, sig8, sig9, sig10, - sig11, sig12, sig13) - <=> - (exprs0, exprs1, exprs2, exprs3, exprs4, exprs5, exprs6, exprs7, - exprs8, exprs9, exprs10, exprs11, exprs12, exprs13) - = outList - [sig0 <=> exprs0, sig1 <=> exprs1, sig2 <=> exprs2, - sig3 <=> exprs3, sig4 <=> exprs4, sig5 <=> exprs5, sig6 <=> exprs6, - sig7 <=> exprs7, sig8 <=> exprs8, sig9 <=> exprs9, - sig10 <=> exprs10, sig11 <=> exprs11, sig12 <=> exprs12, - sig13 <=> exprs13] - - -instance (Assign a0, Assign a1, Assign a2, Assign a3, Assign a4, - Assign a5, Assign a6, Assign a7, Assign a8, Assign a9, Assign a10, - Assign a11, Assign a12, Assign a13, Assign a14) => - Assign - (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14) - where - (sig0, sig1, sig2, sig3, sig4, sig5, sig6, sig7, sig8, sig9, sig10, - sig11, sig12, sig13, sig14) - <=> - (exprs0, exprs1, exprs2, exprs3, exprs4, exprs5, exprs6, exprs7, - exprs8, exprs9, exprs10, exprs11, exprs12, exprs13, exprs14) - = outList - [sig0 <=> exprs0, sig1 <=> exprs1, sig2 <=> exprs2, - sig3 <=> exprs3, sig4 <=> exprs4, sig5 <=> exprs5, sig6 <=> exprs6, - sig7 <=> exprs7, sig8 <=> exprs8, sig9 <=> exprs9, - sig10 <=> exprs10, sig11 <=> exprs11, sig12 <=> exprs12, - sig13 <=> exprs13, sig14 <=> exprs14] - - -instance (Assign a0, Assign a1, Assign a2, Assign a3, Assign a4, - Assign a5, Assign a6, Assign a7, Assign a8, Assign a9, Assign a10, - Assign a11, Assign a12, Assign a13, Assign a14, Assign a15) => - Assign - (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, - a15) - where - (sig0, sig1, sig2, sig3, sig4, sig5, sig6, sig7, sig8, sig9, sig10, - sig11, sig12, sig13, sig14, sig15) - <=> - (exprs0, exprs1, exprs2, exprs3, exprs4, exprs5, exprs6, exprs7, - exprs8, exprs9, exprs10, exprs11, exprs12, exprs13, exprs14, - exprs15) - = outList - [sig0 <=> exprs0, sig1 <=> exprs1, sig2 <=> exprs2, - sig3 <=> exprs3, sig4 <=> exprs4, sig5 <=> exprs5, sig6 <=> exprs6, - sig7 <=> exprs7, sig8 <=> exprs8, sig9 <=> exprs9, - sig10 <=> exprs10, sig11 <=> exprs11, sig12 <=> exprs12, - sig13 <=> exprs13, sig14 <=> exprs14, sig15 <=> exprs15] - - -instance (Assign a0, Assign a1, Assign a2, Assign a3, Assign a4, - Assign a5, Assign a6, Assign a7, Assign a8, Assign a9, Assign a10, - Assign a11, Assign a12, Assign a13, Assign a14, Assign a15, - Assign a16) => - Assign - (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, - a15, a16) - where - (sig0, sig1, sig2, sig3, sig4, sig5, sig6, sig7, sig8, sig9, sig10, - sig11, sig12, sig13, sig14, sig15, sig16) - <=> - (exprs0, exprs1, exprs2, exprs3, exprs4, exprs5, exprs6, exprs7, - exprs8, exprs9, exprs10, exprs11, exprs12, exprs13, exprs14, - exprs15, exprs16) - = outList - [sig0 <=> exprs0, sig1 <=> exprs1, sig2 <=> exprs2, - sig3 <=> exprs3, sig4 <=> exprs4, sig5 <=> exprs5, sig6 <=> exprs6, - sig7 <=> exprs7, sig8 <=> exprs8, sig9 <=> exprs9, - sig10 <=> exprs10, sig11 <=> exprs11, sig12 <=> exprs12, - sig13 <=> exprs13, sig14 <=> exprs14, sig15 <=> exprs15, - sig16 <=> exprs16] - - -instance (Assign a0, Assign a1, Assign a2, Assign a3, Assign a4, - Assign a5, Assign a6, Assign a7, Assign a8, Assign a9, Assign a10, - Assign a11, Assign a12, Assign a13, Assign a14, Assign a15, - Assign a16, Assign a17) => - Assign - (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, - a15, a16, a17) - where - (sig0, sig1, sig2, sig3, sig4, sig5, sig6, sig7, sig8, sig9, sig10, - sig11, sig12, sig13, sig14, sig15, sig16, sig17) - <=> - (exprs0, exprs1, exprs2, exprs3, exprs4, exprs5, exprs6, exprs7, - exprs8, exprs9, exprs10, exprs11, exprs12, exprs13, exprs14, - exprs15, exprs16, exprs17) - = outList - [sig0 <=> exprs0, sig1 <=> exprs1, sig2 <=> exprs2, - sig3 <=> exprs3, sig4 <=> exprs4, sig5 <=> exprs5, sig6 <=> exprs6, - sig7 <=> exprs7, sig8 <=> exprs8, sig9 <=> exprs9, - sig10 <=> exprs10, sig11 <=> exprs11, sig12 <=> exprs12, - sig13 <=> exprs13, sig14 <=> exprs14, sig15 <=> exprs15, - sig16 <=> exprs16, sig17 <=> exprs17] - - -instance (Assign a0, Assign a1, Assign a2, Assign a3, Assign a4, - Assign a5, Assign a6, Assign a7, Assign a8, Assign a9, Assign a10, - Assign a11, Assign a12, Assign a13, Assign a14, Assign a15, - Assign a16, Assign a17, Assign a18) => - Assign - (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, - a15, a16, a17, a18) - where - (sig0, sig1, sig2, sig3, sig4, sig5, sig6, sig7, sig8, sig9, sig10, - sig11, sig12, sig13, sig14, sig15, sig16, sig17, sig18) - <=> - (exprs0, exprs1, exprs2, exprs3, exprs4, exprs5, exprs6, exprs7, - exprs8, exprs9, exprs10, exprs11, exprs12, exprs13, exprs14, - exprs15, exprs16, exprs17, exprs18) - = outList - [sig0 <=> exprs0, sig1 <=> exprs1, sig2 <=> exprs2, - sig3 <=> exprs3, sig4 <=> exprs4, sig5 <=> exprs5, sig6 <=> exprs6, - sig7 <=> exprs7, sig8 <=> exprs8, sig9 <=> exprs9, - sig10 <=> exprs10, sig11 <=> exprs11, sig12 <=> exprs12, - sig13 <=> exprs13, sig14 <=> exprs14, sig15 <=> exprs15, - sig16 <=> exprs16, sig17 <=> exprs17, sig18 <=> exprs18] - - -instance (Assign a0, Assign a1, Assign a2, Assign a3, Assign a4, - Assign a5, Assign a6, Assign a7, Assign a8, Assign a9, Assign a10, - Assign a11, Assign a12, Assign a13, Assign a14, Assign a15, - Assign a16, Assign a17, Assign a18, Assign a19) => - Assign - (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, - a15, a16, a17, a18, a19) - where - (sig0, sig1, sig2, sig3, sig4, sig5, sig6, sig7, sig8, sig9, sig10, - sig11, sig12, sig13, sig14, sig15, sig16, sig17, sig18, sig19) - <=> - (exprs0, exprs1, exprs2, exprs3, exprs4, exprs5, exprs6, exprs7, - exprs8, exprs9, exprs10, exprs11, exprs12, exprs13, exprs14, - exprs15, exprs16, exprs17, exprs18, exprs19) - = outList - [sig0 <=> exprs0, sig1 <=> exprs1, sig2 <=> exprs2, - sig3 <=> exprs3, sig4 <=> exprs4, sig5 <=> exprs5, sig6 <=> exprs6, - sig7 <=> exprs7, sig8 <=> exprs8, sig9 <=> exprs9, - sig10 <=> exprs10, sig11 <=> exprs11, sig12 <=> exprs12, - sig13 <=> exprs13, sig14 <=> exprs14, sig15 <=> exprs15, - sig16 <=> exprs16, sig17 <=> exprs17, sig18 <=> exprs18, - sig19 <=> exprs19] - - -instance (Assign a0, Assign a1, Assign a2, Assign a3, Assign a4, - Assign a5, Assign a6, Assign a7, Assign a8, Assign a9, Assign a10, - Assign a11, Assign a12, Assign a13, Assign a14, Assign a15, - Assign a16, Assign a17, Assign a18, Assign a19, Assign a20) => - Assign - (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, - a15, a16, a17, a18, a19, a20) - where - (sig0, sig1, sig2, sig3, sig4, sig5, sig6, sig7, sig8, sig9, sig10, - sig11, sig12, sig13, sig14, sig15, sig16, sig17, sig18, sig19, - sig20) - <=> - (exprs0, exprs1, exprs2, exprs3, exprs4, exprs5, exprs6, exprs7, - exprs8, exprs9, exprs10, exprs11, exprs12, exprs13, exprs14, - exprs15, exprs16, exprs17, exprs18, exprs19, exprs20) - = outList - [sig0 <=> exprs0, sig1 <=> exprs1, sig2 <=> exprs2, - sig3 <=> exprs3, sig4 <=> exprs4, sig5 <=> exprs5, sig6 <=> exprs6, - sig7 <=> exprs7, sig8 <=> exprs8, sig9 <=> exprs9, - sig10 <=> exprs10, sig11 <=> exprs11, sig12 <=> exprs12, - sig13 <=> exprs13, sig14 <=> exprs14, sig15 <=> exprs15, - sig16 <=> exprs16, sig17 <=> exprs17, sig18 <=> exprs18, - sig19 <=> exprs19, sig20 <=> exprs20] - - -instance (Assign a0, Assign a1, Assign a2, Assign a3, Assign a4, - Assign a5, Assign a6, Assign a7, Assign a8, Assign a9, Assign a10, - Assign a11, Assign a12, Assign a13, Assign a14, Assign a15, - Assign a16, Assign a17, Assign a18, Assign a19, Assign a20, - Assign a21) => - Assign - (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, - a15, a16, a17, a18, a19, a20, a21) - where - (sig0, sig1, sig2, sig3, sig4, sig5, sig6, sig7, sig8, sig9, sig10, - sig11, sig12, sig13, sig14, sig15, sig16, sig17, sig18, sig19, - sig20, sig21) - <=> - (exprs0, exprs1, exprs2, exprs3, exprs4, exprs5, exprs6, exprs7, - exprs8, exprs9, exprs10, exprs11, exprs12, exprs13, exprs14, - exprs15, exprs16, exprs17, exprs18, exprs19, exprs20, exprs21) - = outList - [sig0 <=> exprs0, sig1 <=> exprs1, sig2 <=> exprs2, - sig3 <=> exprs3, sig4 <=> exprs4, sig5 <=> exprs5, sig6 <=> exprs6, - sig7 <=> exprs7, sig8 <=> exprs8, sig9 <=> exprs9, - sig10 <=> exprs10, sig11 <=> exprs11, sig12 <=> exprs12, - sig13 <=> exprs13, sig14 <=> exprs14, sig15 <=> exprs15, - sig16 <=> exprs16, sig17 <=> exprs17, sig18 <=> exprs18, - sig19 <=> exprs19, sig20 <=> exprs20, sig21 <=> exprs21] - - -instance (Assign a0, Assign a1, Assign a2, Assign a3, Assign a4, - Assign a5, Assign a6, Assign a7, Assign a8, Assign a9, Assign a10, - Assign a11, Assign a12, Assign a13, Assign a14, Assign a15, - Assign a16, Assign a17, Assign a18, Assign a19, Assign a20, - Assign a21, Assign a22) => - Assign - (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, - a15, a16, a17, a18, a19, a20, a21, a22) - where - (sig0, sig1, sig2, sig3, sig4, sig5, sig6, sig7, sig8, sig9, sig10, - sig11, sig12, sig13, sig14, sig15, sig16, sig17, sig18, sig19, - sig20, sig21, sig22) - <=> - (exprs0, exprs1, exprs2, exprs3, exprs4, exprs5, exprs6, exprs7, - exprs8, exprs9, exprs10, exprs11, exprs12, exprs13, exprs14, - exprs15, exprs16, exprs17, exprs18, exprs19, exprs20, exprs21, - exprs22) - = outList - [sig0 <=> exprs0, sig1 <=> exprs1, sig2 <=> exprs2, - sig3 <=> exprs3, sig4 <=> exprs4, sig5 <=> exprs5, sig6 <=> exprs6, - sig7 <=> exprs7, sig8 <=> exprs8, sig9 <=> exprs9, - sig10 <=> exprs10, sig11 <=> exprs11, sig12 <=> exprs12, - sig13 <=> exprs13, sig14 <=> exprs14, sig15 <=> exprs15, - sig16 <=> exprs16, sig17 <=> exprs17, sig18 <=> exprs18, - sig19 <=> exprs19, sig20 <=> exprs20, sig21 <=> exprs21, - sig22 <=> exprs22] - - -instance (Assign a0, Assign a1, Assign a2, Assign a3, Assign a4, - Assign a5, Assign a6, Assign a7, Assign a8, Assign a9, Assign a10, - Assign a11, Assign a12, Assign a13, Assign a14, Assign a15, - Assign a16, Assign a17, Assign a18, Assign a19, Assign a20, - Assign a21, Assign a22, Assign a23) => - Assign - (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, - a15, a16, a17, a18, a19, a20, a21, a22, a23) - where - (sig0, sig1, sig2, sig3, sig4, sig5, sig6, sig7, sig8, sig9, sig10, - sig11, sig12, sig13, sig14, sig15, sig16, sig17, sig18, sig19, - sig20, sig21, sig22, sig23) - <=> - (exprs0, exprs1, exprs2, exprs3, exprs4, exprs5, exprs6, exprs7, - exprs8, exprs9, exprs10, exprs11, exprs12, exprs13, exprs14, - exprs15, exprs16, exprs17, exprs18, exprs19, exprs20, exprs21, - exprs22, exprs23) - = outList - [sig0 <=> exprs0, sig1 <=> exprs1, sig2 <=> exprs2, - sig3 <=> exprs3, sig4 <=> exprs4, sig5 <=> exprs5, sig6 <=> exprs6, - sig7 <=> exprs7, sig8 <=> exprs8, sig9 <=> exprs9, - sig10 <=> exprs10, sig11 <=> exprs11, sig12 <=> exprs12, - sig13 <=> exprs13, sig14 <=> exprs14, sig15 <=> exprs15, - sig16 <=> exprs16, sig17 <=> exprs17, sig18 <=> exprs18, - sig19 <=> exprs19, sig20 <=> exprs20, sig21 <=> exprs21, - sig22 <=> exprs22, sig23 <=> exprs23] - - -instance (Assign a0, Assign a1, Assign a2, Assign a3, Assign a4, - Assign a5, Assign a6, Assign a7, Assign a8, Assign a9, Assign a10, - Assign a11, Assign a12, Assign a13, Assign a14, Assign a15, - Assign a16, Assign a17, Assign a18, Assign a19, Assign a20, - Assign a21, Assign a22, Assign a23, Assign a24) => - Assign - (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, - a15, a16, a17, a18, a19, a20, a21, a22, a23, a24) - where - (sig0, sig1, sig2, sig3, sig4, sig5, sig6, sig7, sig8, sig9, sig10, - sig11, sig12, sig13, sig14, sig15, sig16, sig17, sig18, sig19, - sig20, sig21, sig22, sig23, sig24) - <=> - (exprs0, exprs1, exprs2, exprs3, exprs4, exprs5, exprs6, exprs7, - exprs8, exprs9, exprs10, exprs11, exprs12, exprs13, exprs14, - exprs15, exprs16, exprs17, exprs18, exprs19, exprs20, exprs21, - exprs22, exprs23, exprs24) - = outList - [sig0 <=> exprs0, sig1 <=> exprs1, sig2 <=> exprs2, - sig3 <=> exprs3, sig4 <=> exprs4, sig5 <=> exprs5, sig6 <=> exprs6, - sig7 <=> exprs7, sig8 <=> exprs8, sig9 <=> exprs9, - sig10 <=> exprs10, sig11 <=> exprs11, sig12 <=> exprs12, - sig13 <=> exprs13, sig14 <=> exprs14, sig15 <=> exprs15, - sig16 <=> exprs16, sig17 <=> exprs17, sig18 <=> exprs18, - sig19 <=> exprs19, sig20 <=> exprs20, sig21 <=> exprs21, - sig22 <=> exprs22, sig23 <=> exprs23, sig24 <=> exprs24] - - -instance (Assign a0, Assign a1, Assign a2, Assign a3, Assign a4, - Assign a5, Assign a6, Assign a7, Assign a8, Assign a9, Assign a10, - Assign a11, Assign a12, Assign a13, Assign a14, Assign a15, - Assign a16, Assign a17, Assign a18, Assign a19, Assign a20, - Assign a21, Assign a22, Assign a23, Assign a24, Assign a25) => - Assign - (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, - a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25) - where - (sig0, sig1, sig2, sig3, sig4, sig5, sig6, sig7, sig8, sig9, sig10, - sig11, sig12, sig13, sig14, sig15, sig16, sig17, sig18, sig19, - sig20, sig21, sig22, sig23, sig24, sig25) - <=> - (exprs0, exprs1, exprs2, exprs3, exprs4, exprs5, exprs6, exprs7, - exprs8, exprs9, exprs10, exprs11, exprs12, exprs13, exprs14, - exprs15, exprs16, exprs17, exprs18, exprs19, exprs20, exprs21, - exprs22, exprs23, exprs24, exprs25) - = outList - [sig0 <=> exprs0, sig1 <=> exprs1, sig2 <=> exprs2, - sig3 <=> exprs3, sig4 <=> exprs4, sig5 <=> exprs5, sig6 <=> exprs6, - sig7 <=> exprs7, sig8 <=> exprs8, sig9 <=> exprs9, - sig10 <=> exprs10, sig11 <=> exprs11, sig12 <=> exprs12, - sig13 <=> exprs13, sig14 <=> exprs14, sig15 <=> exprs15, - sig16 <=> exprs16, sig17 <=> exprs17, sig18 <=> exprs18, - sig19 <=> exprs19, sig20 <=> exprs20, sig21 <=> exprs21, - sig22 <=> exprs22, sig23 <=> exprs23, sig24 <=> exprs24, - sig25 <=> exprs25] - - -instance (Assign a0, Assign a1, Assign a2, Assign a3, Assign a4, - Assign a5, Assign a6, Assign a7, Assign a8, Assign a9, Assign a10, - Assign a11, Assign a12, Assign a13, Assign a14, Assign a15, - Assign a16, Assign a17, Assign a18, Assign a19, Assign a20, - Assign a21, Assign a22, Assign a23, Assign a24, Assign a25, - Assign a26) => - Assign - (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, - a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26) - where - (sig0, sig1, sig2, sig3, sig4, sig5, sig6, sig7, sig8, sig9, sig10, - sig11, sig12, sig13, sig14, sig15, sig16, sig17, sig18, sig19, - sig20, sig21, sig22, sig23, sig24, sig25, sig26) - <=> - (exprs0, exprs1, exprs2, exprs3, exprs4, exprs5, exprs6, exprs7, - exprs8, exprs9, exprs10, exprs11, exprs12, exprs13, exprs14, - exprs15, exprs16, exprs17, exprs18, exprs19, exprs20, exprs21, - exprs22, exprs23, exprs24, exprs25, exprs26) - = outList - [sig0 <=> exprs0, sig1 <=> exprs1, sig2 <=> exprs2, - sig3 <=> exprs3, sig4 <=> exprs4, sig5 <=> exprs5, sig6 <=> exprs6, - sig7 <=> exprs7, sig8 <=> exprs8, sig9 <=> exprs9, - sig10 <=> exprs10, sig11 <=> exprs11, sig12 <=> exprs12, - sig13 <=> exprs13, sig14 <=> exprs14, sig15 <=> exprs15, - sig16 <=> exprs16, sig17 <=> exprs17, sig18 <=> exprs18, - sig19 <=> exprs19, sig20 <=> exprs20, sig21 <=> exprs21, - sig22 <=> exprs22, sig23 <=> exprs23, sig24 <=> exprs24, - sig25 <=> exprs25, sig26 <=> exprs26] - - -instance (Assign a0, Assign a1, Assign a2, Assign a3, Assign a4, - Assign a5, Assign a6, Assign a7, Assign a8, Assign a9, Assign a10, - Assign a11, Assign a12, Assign a13, Assign a14, Assign a15, - Assign a16, Assign a17, Assign a18, Assign a19, Assign a20, - Assign a21, Assign a22, Assign a23, Assign a24, Assign a25, - Assign a26, Assign a27) => - Assign - (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, - a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27) - where - (sig0, sig1, sig2, sig3, sig4, sig5, sig6, sig7, sig8, sig9, sig10, - sig11, sig12, sig13, sig14, sig15, sig16, sig17, sig18, sig19, - sig20, sig21, sig22, sig23, sig24, sig25, sig26, sig27) - <=> - (exprs0, exprs1, exprs2, exprs3, exprs4, exprs5, exprs6, exprs7, - exprs8, exprs9, exprs10, exprs11, exprs12, exprs13, exprs14, - exprs15, exprs16, exprs17, exprs18, exprs19, exprs20, exprs21, - exprs22, exprs23, exprs24, exprs25, exprs26, exprs27) - = outList - [sig0 <=> exprs0, sig1 <=> exprs1, sig2 <=> exprs2, - sig3 <=> exprs3, sig4 <=> exprs4, sig5 <=> exprs5, sig6 <=> exprs6, - sig7 <=> exprs7, sig8 <=> exprs8, sig9 <=> exprs9, - sig10 <=> exprs10, sig11 <=> exprs11, sig12 <=> exprs12, - sig13 <=> exprs13, sig14 <=> exprs14, sig15 <=> exprs15, - sig16 <=> exprs16, sig17 <=> exprs17, sig18 <=> exprs18, - sig19 <=> exprs19, sig20 <=> exprs20, sig21 <=> exprs21, - sig22 <=> exprs22, sig23 <=> exprs23, sig24 <=> exprs24, - sig25 <=> exprs25, sig26 <=> exprs26, sig27 <=> exprs27] - - -instance (Assign a0, Assign a1, Assign a2, Assign a3, Assign a4, - Assign a5, Assign a6, Assign a7, Assign a8, Assign a9, Assign a10, - Assign a11, Assign a12, Assign a13, Assign a14, Assign a15, - Assign a16, Assign a17, Assign a18, Assign a19, Assign a20, - Assign a21, Assign a22, Assign a23, Assign a24, Assign a25, - Assign a26, Assign a27, Assign a28) => - Assign - (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, - a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, - a28) - where - (sig0, sig1, sig2, sig3, sig4, sig5, sig6, sig7, sig8, sig9, sig10, - sig11, sig12, sig13, sig14, sig15, sig16, sig17, sig18, sig19, - sig20, sig21, sig22, sig23, sig24, sig25, sig26, sig27, sig28) - <=> - (exprs0, exprs1, exprs2, exprs3, exprs4, exprs5, exprs6, exprs7, - exprs8, exprs9, exprs10, exprs11, exprs12, exprs13, exprs14, - exprs15, exprs16, exprs17, exprs18, exprs19, exprs20, exprs21, - exprs22, exprs23, exprs24, exprs25, exprs26, exprs27, exprs28) - = outList - [sig0 <=> exprs0, sig1 <=> exprs1, sig2 <=> exprs2, - sig3 <=> exprs3, sig4 <=> exprs4, sig5 <=> exprs5, sig6 <=> exprs6, - sig7 <=> exprs7, sig8 <=> exprs8, sig9 <=> exprs9, - sig10 <=> exprs10, sig11 <=> exprs11, sig12 <=> exprs12, - sig13 <=> exprs13, sig14 <=> exprs14, sig15 <=> exprs15, - sig16 <=> exprs16, sig17 <=> exprs17, sig18 <=> exprs18, - sig19 <=> exprs19, sig20 <=> exprs20, sig21 <=> exprs21, - sig22 <=> exprs22, sig23 <=> exprs23, sig24 <=> exprs24, - sig25 <=> exprs25, sig26 <=> exprs26, sig27 <=> exprs27, - sig28 <=> exprs28] - - -instance (Assign a0, Assign a1, Assign a2, Assign a3, Assign a4, - Assign a5, Assign a6, Assign a7, Assign a8, Assign a9, Assign a10, - Assign a11, Assign a12, Assign a13, Assign a14, Assign a15, - Assign a16, Assign a17, Assign a18, Assign a19, Assign a20, - Assign a21, Assign a22, Assign a23, Assign a24, Assign a25, - Assign a26, Assign a27, Assign a28, Assign a29) => - Assign - (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, - a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, - a28, a29) - where - (sig0, sig1, sig2, sig3, sig4, sig5, sig6, sig7, sig8, sig9, sig10, - sig11, sig12, sig13, sig14, sig15, sig16, sig17, sig18, sig19, - sig20, sig21, sig22, sig23, sig24, sig25, sig26, sig27, sig28, - sig29) - <=> - (exprs0, exprs1, exprs2, exprs3, exprs4, exprs5, exprs6, exprs7, - exprs8, exprs9, exprs10, exprs11, exprs12, exprs13, exprs14, - exprs15, exprs16, exprs17, exprs18, exprs19, exprs20, exprs21, - exprs22, exprs23, exprs24, exprs25, exprs26, exprs27, exprs28, - exprs29) - = outList - [sig0 <=> exprs0, sig1 <=> exprs1, sig2 <=> exprs2, - sig3 <=> exprs3, sig4 <=> exprs4, sig5 <=> exprs5, sig6 <=> exprs6, - sig7 <=> exprs7, sig8 <=> exprs8, sig9 <=> exprs9, - sig10 <=> exprs10, sig11 <=> exprs11, sig12 <=> exprs12, - sig13 <=> exprs13, sig14 <=> exprs14, sig15 <=> exprs15, - sig16 <=> exprs16, sig17 <=> exprs17, sig18 <=> exprs18, - sig19 <=> exprs19, sig20 <=> exprs20, sig21 <=> exprs21, - sig22 <=> exprs22, sig23 <=> exprs23, sig24 <=> exprs24, - sig25 <=> exprs25, sig26 <=> exprs26, sig27 <=> exprs27, - sig28 <=> exprs28, sig29 <=> exprs29] - - -instance (Assign a0, Assign a1, Assign a2, Assign a3, Assign a4, - Assign a5, Assign a6, Assign a7, Assign a8, Assign a9, Assign a10, - Assign a11, Assign a12, Assign a13, Assign a14, Assign a15, - Assign a16, Assign a17, Assign a18, Assign a19, Assign a20, - Assign a21, Assign a22, Assign a23, Assign a24, Assign a25, - Assign a26, Assign a27, Assign a28, Assign a29, Assign a30) => - Assign - (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, - a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, - a28, a29, a30) - where - (sig0, sig1, sig2, sig3, sig4, sig5, sig6, sig7, sig8, sig9, sig10, - sig11, sig12, sig13, sig14, sig15, sig16, sig17, sig18, sig19, - sig20, sig21, sig22, sig23, sig24, sig25, sig26, sig27, sig28, - sig29, sig30) - <=> - (exprs0, exprs1, exprs2, exprs3, exprs4, exprs5, exprs6, exprs7, - exprs8, exprs9, exprs10, exprs11, exprs12, exprs13, exprs14, - exprs15, exprs16, exprs17, exprs18, exprs19, exprs20, exprs21, - exprs22, exprs23, exprs24, exprs25, exprs26, exprs27, exprs28, - exprs29, exprs30) - = outList - [sig0 <=> exprs0, sig1 <=> exprs1, sig2 <=> exprs2, - sig3 <=> exprs3, sig4 <=> exprs4, sig5 <=> exprs5, sig6 <=> exprs6, - sig7 <=> exprs7, sig8 <=> exprs8, sig9 <=> exprs9, - sig10 <=> exprs10, sig11 <=> exprs11, sig12 <=> exprs12, - sig13 <=> exprs13, sig14 <=> exprs14, sig15 <=> exprs15, - sig16 <=> exprs16, sig17 <=> exprs17, sig18 <=> exprs18, - sig19 <=> exprs19, sig20 <=> exprs20, sig21 <=> exprs21, - sig22 <=> exprs22, sig23 <=> exprs23, sig24 <=> exprs24, - sig25 <=> exprs25, sig26 <=> exprs26, sig27 <=> exprs27, - sig28 <=> exprs28, sig29 <=> exprs29, sig30 <=> exprs30] - - -instance (Assign a0, Assign a1, Assign a2, Assign a3, Assign a4, - Assign a5, Assign a6, Assign a7, Assign a8, Assign a9, Assign a10, - Assign a11, Assign a12, Assign a13, Assign a14, Assign a15, - Assign a16, Assign a17, Assign a18, Assign a19, Assign a20, - Assign a21, Assign a22, Assign a23, Assign a24, Assign a25, - Assign a26, Assign a27, Assign a28, Assign a29, Assign a30, - Assign a31) => - Assign - (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, - a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, - a28, a29, a30, a31) - where - (sig0, sig1, sig2, sig3, sig4, sig5, sig6, sig7, sig8, sig9, sig10, - sig11, sig12, sig13, sig14, sig15, sig16, sig17, sig18, sig19, - sig20, sig21, sig22, sig23, sig24, sig25, sig26, sig27, sig28, - sig29, sig30, sig31) - <=> - (exprs0, exprs1, exprs2, exprs3, exprs4, exprs5, exprs6, exprs7, - exprs8, exprs9, exprs10, exprs11, exprs12, exprs13, exprs14, - exprs15, exprs16, exprs17, exprs18, exprs19, exprs20, exprs21, - exprs22, exprs23, exprs24, exprs25, exprs26, exprs27, exprs28, - exprs29, exprs30, exprs31) - = outList - [sig0 <=> exprs0, sig1 <=> exprs1, sig2 <=> exprs2, - sig3 <=> exprs3, sig4 <=> exprs4, sig5 <=> exprs5, sig6 <=> exprs6, - sig7 <=> exprs7, sig8 <=> exprs8, sig9 <=> exprs9, - sig10 <=> exprs10, sig11 <=> exprs11, sig12 <=> exprs12, - sig13 <=> exprs13, sig14 <=> exprs14, sig15 <=> exprs15, - sig16 <=> exprs16, sig17 <=> exprs17, sig18 <=> exprs18, - sig19 <=> exprs19, sig20 <=> exprs20, sig21 <=> exprs21, - sig22 <=> exprs22, sig23 <=> exprs23, sig24 <=> exprs24, - sig25 <=> exprs25, sig26 <=> exprs26, sig27 <=> exprs27, - sig28 <=> exprs28, sig29 <=> exprs29, sig30 <=> exprs30, - sig31 <=> exprs31] diff --git a/src/CsoundExpr/Base/Pretty.hs b/src/CsoundExpr/Base/Pretty.hs new file mode 100644 --- /dev/null +++ b/src/CsoundExpr/Base/Pretty.hs @@ -0,0 +1,85 @@ +module CsoundExpr.Base.Pretty( + Cs.CsoundFile, Cs.Flags, + Player, FileName, + csd, play) +where + + +import Temporal.Media(EventList) +import qualified CsoundExpr.Translator.Cs.CsoundFile as Cs +import CsoundExpr.Translator.Csd +import CsoundExpr.Base.Header +import CsoundExpr.Translator.Types(Dur, SignalOut) + +import System +import System.Directory +import qualified System.FilePath as FP + + +--------------------------------------------------- +--------------------------------------------------- +-- translator + +-- | Generate csound code +-- +-- Csound code consists of flags, header section, instruments, +-- ftables and score. Flags are represeted by @String@. See +-- "CsoundExpr.Base.Header" for more details on header +-- section. Instruments, ftables and score are generated from +-- 'EventList' 'Dur' 'SignalOut'. From list of 'SignalOut' notes list +-- of instruments is derived. Expression-tree structures of +-- instruments are different from one another. An instrument +-- can't be transformed into another one only with substitution +-- of values in lists of expression-tree. +-- +-- Example (d minor) : +-- +-- >import CsoundExpr +-- >import CsoundExpr.Opcodes +-- >import CsoundExpr.Base.Pitch +-- > +-- >flags = "-o dm.wav" +-- > +-- >setup = instr0 [ +-- > gSr <=> 44100, +-- > gKr <=> 4410, +-- > gKsmps <=> 10, +-- > gNchnls <=> 1] +-- > +-- >header = [setup] +-- > +-- >sinWave = gen10 4096 [1] +-- > +-- >instr :: Irate -> SignalOut +-- >instr x = out $ oscilA [] (num 1000) (cpspch x) sinWave +-- > +-- >sco = fmap instr $ line $ map (note 1) [d 0, f 0, a 0, d 1] +-- > +-- >main = print $ csd flags header $ toList sco +-- + +csd :: Cs.Flags -- ^ flags + -> Header -- ^ header section + -> EventList Dur SignalOut -- ^ score section + -> Cs.CsoundFile -- ^ csd file +csd = toCsd + + + +type Player = String +type FileName = String + +-- | 'play' writes 'CsoundFile' to file in temporal direcory, +-- executes csound on it, saves to .wav file, and invokes player +-- +-- >play "totem" "~/temp" "song" $ csd flags header $ toList scores +play :: Player -> FP.FilePath -> FileName -> Cs.CsoundFile -> IO ExitCode +play playerCode tmpdir tmpfile csoundCode = do + writeFile fileCsd (show csoundCode) + system $ csound fileCsd + system $ player fileWav + where fileCsd = (tmpdir FP. tmpfile ++ ".csd") + fileWav = (tmpdir FP. tmpfile ++ ".wav") + csound = (("csound -o " ++ fileWav ++ " ") ++ ) + player = ((playerCode ++ " ") ++ ) + diff --git a/src/CsoundExpr/Base/Types.hs b/src/CsoundExpr/Base/Types.hs --- a/src/CsoundExpr/Base/Types.hs +++ b/src/CsoundExpr/Base/Types.hs @@ -1,76 +1,43 @@ module CsoundExpr.Base.Types - (X, K, - Cs.CsoundFile, Cs.Flags, - Arate, Krate, Irate, - SignalOut, outList, - ToSignal(..), - itime, idur, num, string, - csd) + (X(..), K, + Arate, Krate, Irate, SignalOut, + itime, idur, num, double, string) where import Text.PrettyPrint(Doc, vcat, text, space) -import Temporal.Media(EventList) +import qualified CsoundExpr.Translator.Cs.CsTree as La -import qualified CsoundExpr.Translator.Cs.CsoundFile as Cs -import CsoundExpr.Translator.Cs.CsTree import CsoundExpr.Translator.Cs.IM - import CsoundExpr.Translator.Types -import CsoundExpr.Translator.Csd -import CsoundExpr.Base.Header - -import CsoundExpr.Base.Literal +import CsoundExpr.Base.Imperative import CsoundExpr.Base.UserDefined(opcode, prefixOperation) - ------------------------------------------- --- Rate conversion - --- | Rate conversion -class ToSignal a where - arate :: a -> Arate - krate :: a -> Krate - irate :: a -> Irate - - -instance ToSignal Arate where - arate = id - krate = opcode "downsamp" . return . to - irate = prefixOperation "i" . return . to . krate - -instance ToSignal Krate where - arate = opcode "upsamp" . return . to - krate = id - irate = prefixOperation "i" . return . to - -instance ToSignal Irate where - arate = opcode "upsamp" . return . to - krate = prefixOperation "k" . return . to - irate = id - -instance ToSignal Double where - arate = arate . irate - krate = krate . irate - irate = double - +import CsoundExpr.Translator.Csd ------------------------------------------- -- constructors -- | @p2@ p-field itime :: Irate -itime = param 2 +itime = La.param 2 -- | @p3@ p-field idur :: Irate -idur = param 3 +idur = La.param 3 -- | auxiliary function, to write (num n) instead of (n :: Irate) num :: Irate -> Irate num = id +-- | Lift 'Double' to 'Irate' +double :: Double -> Irate +double = La.double +-- | Lift 'String' to 'Irate' +string :: String -> Irate +string = La.string + --------------------------------------------- -- show instances @@ -89,144 +56,5 @@ instance Show SignalOut where show x = show $ vcat [title , ppCsTrees $ fromSignalOut x] where title = text "; SignalOut expression :" - ---------------------------------------------------- ---------------------------------------------------- --- translator --- | Generate csound code --- --- Csound code consists of flags, header section, instruments, --- ftables and score. Flags are represeted by @String@. See --- "CsoundExpr.Orchestra.Header" for more details on header --- section. Instruments, ftables and score are generated from --- 'EventList' 'Dur' 'SignalOut'. From list of 'SignalOut' notes list --- of instruments is derived. Expression-tree structures of --- instruments are different from one another. An instrument --- can't be transformed into another one only with substitution --- of values in lists of expression-tree. --- --- Example (d minor) : --- --- >import CsoundExpr --- >import CsoundExpr.Opcodes --- >import CsoundExpr.Base.Pitch --- > --- >flags = "-o dm.wav" --- > --- >setup = instr0 [ --- > gSr <=> 44100, --- > gKr <=> 4410, --- > gKsmps <=> 10, --- > gNchnls <=> 1] --- > --- >header = [setup] --- > --- >sinWave = gen10 4096 [1] --- > --- >instr :: Irate -> SignalOut --- >instr x = out $ oscilA [] (num 1000) (cpspch x) sinWave --- > --- >sco = fmap instr $ line $ map (note 1) [d 0, f 0, a 0, d 1] --- > --- >main = print $ csd flags header $ toList sco --- --- --- Example (radiohead - weird fishes, intro) : --- --- >import CsoundExpr --- >import CsoundExpr.Opcodes hiding (delay) --- >import CsoundExpr.Base.Pitch --- > --- > --- > --- >mapSnd f (a, b) = (a, f b) --- > --- > --- >flags = "-d" --- > --- >setupMono = instr0 [ --- > gSr <=> 44100, --- > gKr <=> 4410, --- > gKsmps <=> 10, --- > gNchnls <=> 1 ] --- > --- >headerMono = [setupMono] --- > --- >-- volume levels --- > --- >v1 = 1.3 * v0 --- >v0 = 7000 --- --- >-- instruments --- > --- >pluckInstr :: (Irate, Irate) -> SignalOut --- >pluckInstr (amp, pch) = outList [ --- > out $ env <*> wgpluck2 0.75 amp (cpspch pch) (num 0.75) (num 0.5), --- > xtratim 1] --- > where env = linsegrK [0, idur * 0.05, 1, idur * 0.9, 1] 1 0 --- > --- >guitar = pluckInstr . mapSnd (+ (-1)) --- > --- > --- >--chords --- > --- >guitarChord1, guitarChord2, guitarChord3 :: [Irate] -> Score (Irate, Irate) --- > --- >-- volumes 4/4 --- >vs x = map ( * x) $ cycle [v1, v0, v0, v0] --- > --- >-- guitar 1 --- >guitarChord1 = line . map return . zip (vs 1) . concat . replicate 10 --- > --- >ch11 = [d 1, g 0, e 0] --- >ch12 = map ( + 0.02) ch11 --- >ch13 = [a 1, a 0, cs 1] --- >ch14 = [fs 1, b 0, g 0] --- > --- >chSeq1 = line $ map return $ [ch11, ch12, ch13, ch14] --- > --- >-- guitar 2 --- >guitarChord2 = line . map return . zip (vs 0.5) . concat . replicate 6 . arpeggi --- > where arpeggi x = x ++ take 2 x --- > --- > --- >ch21 = [g 0, d 1, e 1] --- >ch22 = map (+ 0.02) ch21 --- >ch23 = [cs 1, e 1, a 1] --- >ch24 = [d 1, g 1, e 1] --- > --- >chSeq2 = line $ map return $ [ch21, ch22, ch23, ch24] --- > --- >-- guitar 3 --- >guitarChord3 = line . map return . zip (vs 0.2) . concat . replicate 6 . arpeggi --- > where arpeggi x = take 2 x ++ x --- > --- >ch31 = [e 1, g 1, b 1] --- >ch32 = map (+ 0.02) ch31 --- >ch33 = [fs 1, a 1, cs 2] --- >ch34 = [d 2, g 1, b 1] --- > --- >chSeq3 = line $ map return $ [ch31, ch32, ch33, ch34] --- > --- >-- scores --- > --- >scoG1 = fmap guitar $ chSeq1 >>= guitarChord1 --- >scoG2 = fmap guitar $ chSeq2 >>= guitarChord2 --- >scoG3 = fmap guitar $ chSeq3 >>= guitarChord3 --- > --- >scoG2intro = cut (3*30) (4*30) scoG2 --- > --- >intro = chord [scoG1, scoG3, delay (3*30) scoG2intro] --- >chords = loop 3 $ chord [scoG1, scoG2, scoG3] --- > --- >sco = stretch 0.17 $ intro +:+ chords --- > --- >main = print $ csd flags headerMono $ toList sco --- --- -csd :: Cs.Flags -- ^ flags - -> Header -- ^ header section - -> EventList Dur SignalOut -- ^ score section - -> Cs.CsoundFile -- ^ csd file -csd = toCsd + diff --git a/src/CsoundExpr/Opcodes/Siggen/Lineexp.hs b/src/CsoundExpr/Opcodes/Siggen/Lineexp.hs --- a/src/CsoundExpr/Opcodes/Siggen/Lineexp.hs +++ b/src/CsoundExpr/Opcodes/Siggen/Lineexp.hs @@ -3,8 +3,8 @@ (exponA, exponK, expcurve, - transegA, - transegK, + expsegA, + expsegK, expsega, expsegrA, expsegrK, @@ -24,7 +24,9 @@ lpsholdp, rsplineA, rsplineK, - scale) + scale, + transegA, + transegK) where @@ -116,8 +118,8 @@ -- -- * url : -transegA :: [Irate] -> Arate -transegA i0vals = opcode "transeg" args +expsegA :: [Irate] -> Arate +expsegA i0vals = opcode "expseg" args where args = map to i0vals @@ -137,8 +139,8 @@ -- -- * url : -transegK :: [Irate] -> Krate -transegK i0vals = opcode "transeg" args +expsegK :: [Irate] -> Krate +expsegK i0vals = opcode "expseg" args where args = map to i0vals @@ -585,3 +587,45 @@ scale :: (K k0, K k1, K k2) => k0 -> k1 -> k2 -> Krate scale k0input k1max k2min = opcode "scale" args where args = [to k0input, to k1max, to k2min] + + +-- | * opcode : transeg +-- +-- +-- * syntax : +-- +-- > ares transeg ia, idur, itype, ib [, idur2] [, itype] [, ic]... +-- > kres transeg ia, idur, itype, ib [, idur2] [, itype] [, ic]... +-- +-- +-- * description : +-- +-- Constructs a user-definable envelope. +-- +-- +-- * url : + +transegA :: [Irate] -> Arate +transegA i0vals = opcode "transeg" args + where args = map to i0vals + + +-- | * opcode : transeg +-- +-- +-- * syntax : +-- +-- > ares transeg ia, idur, itype, ib [, idur2] [, itype] [, ic]... +-- > kres transeg ia, idur, itype, ib [, idur2] [, itype] [, ic]... +-- +-- +-- * description : +-- +-- Constructs a user-definable envelope. +-- +-- +-- * url : + +transegK :: [Irate] -> Krate +transegK i0vals = opcode "transeg" args + where args = map to i0vals diff --git a/src/CsoundExpr/Translator/Header.hs b/src/CsoundExpr/Translator/Header.hs --- a/src/CsoundExpr/Translator/Header.hs +++ b/src/CsoundExpr/Translator/Header.hs @@ -19,7 +19,6 @@ import CsoundExpr.Translator.Types import CsoundExpr.Translator.Instr -import CsoundExpr.Base.Header --------------------------------------------------------------- --------------------------------------------------------------- diff --git a/src/CsoundExpr/Translator/Types.hs b/src/CsoundExpr/Translator/Types.hs --- a/src/CsoundExpr/Translator/Types.hs +++ b/src/CsoundExpr/Translator/Types.hs @@ -13,7 +13,7 @@ Instr, MidiInstr, InstrOrder, InstrOrderInfo, Note, ValueId, SignalOut(..), outList, fromSignalOut, - SignalInit(..), + Header, SignalInit(..), Arate(..), Krate(..), Irate(..), X(..), K(..), MO(..), toValue, toCsRate, gRate, isArgOut, toOprType ) @@ -79,7 +79,6 @@ -- | init variable data Irate = Irate La.CsTree - deriving (Eq) -- rate classes @@ -121,15 +120,33 @@ -- X, K -- | 'X' = 'Arate' | 'Krate' | 'Irate' -class (IM La.CsTree a, MO a) => X a +class (IM La.CsTree a, MO a) => X a where + arate :: a -> Arate + krate :: a -> Krate + irate :: a -> Irate + -- | 'K' = 'Krate' | 'Irate' class X a => K a -instance X Arate -instance X Krate -instance X Irate +instance X Arate where + arate = id + krate = from . pure (La.opc "downsamp") . return . toCsTree + irate = from . pure (La.oprPrefix "i") . return . toCsTree . krate +instance X Krate where + arate = from . pure (La.opc "upsamp") . return . toCsTree + krate = id + irate = from . pure (La.oprPrefix "i") . return . toCsTree + +instance X Irate where + arate = from . pure (La.opc "upsamp") . return . toCsTree + krate = from . pure (La.oprPrefix "k") . return . toCsTree + irate = id + +toCsTree :: X a => a -> La.CsTree +toCsTree = to + instance K Krate instance K Irate @@ -160,6 +177,9 @@ fromSignalOut (SignalOut x) = x -- signal init + +-- | Header section +type Header = [SignalInit] data SignalInit = Instr0 SignalOut | Massign [Int] Int SignalOut diff --git a/src/CsoundExpr/Tutorial.hs b/src/CsoundExpr/Tutorial.hs new file mode 100644 --- /dev/null +++ b/src/CsoundExpr/Tutorial.hs @@ -0,0 +1,37 @@ + +{-| + Csound-expression allows csound code construction in functional way. + + It has two parts "CsoundExpr.Base" and "CsoundExpr.Opcodes". + "Csound.Base" contains essential functionality of the package. Csound code + can be produced with "Csound.Base". "Csound.Opcodes" contains auxillary + functions to build csound instruments. + + + Tutorial contents : + + * "CsoundExpr.Tutorial.Intro" + + + * "CsoundExpr.Tutorial.Composition" + + score section + + * "CsoundExpr.Tutorial.Orchestra" + + orchestra section + + * "CsoundExpr.Tutorial.Limits" + + explains hack-features, limitations + + + Note : + + Feel free to report english-language bugs in tutorial or in docs. + +-} + + + +module CsoundExpr.Tutorial where diff --git a/src/CsoundExpr/Tutorial/Composition.hs b/src/CsoundExpr/Tutorial/Composition.hs new file mode 100644 --- /dev/null +++ b/src/CsoundExpr/Tutorial/Composition.hs @@ -0,0 +1,280 @@ +{-| + Module "CsoundExpr.Base.Score" provides functions to + construct csound's score section + + * Prev : "CsoundExpr.Tutorial.Intro" + + * Next : "CsoundExpr.Tutorial.Orchestra" +-} + + +module CsoundExpr.Tutorial.Composition ( + -- * EventList + {-| + 'EventList' contains values with time marks. + Value begins at some time and lasts for some time (see temporal-media package) + 'EventList' can be constructed from 'Score' with 'toList' function. + -} + exmpEventList, + + -- * Score + + {-| + 'Score' is tree structure that represents music. Lists contain notes and nodes + contain information about how subtrees relate to each other in time. + Subtrees can be sequential or parallel. 'csd' function takes in 'EventList' + 'Double' 'SignalOut'. 'Double' is type of time-marks. 'SignalOut' represents + instrument structure. + -} + exmpScore, + + -- * Score's instances + -- | Score is a Functor, Monad, Temporal, Stretchable, Arrangeable and TemporalFunctor + + -- ** Functor + -- | It makes possible to represent csound's instrument as + -- a function from note representation to 'SignalOut'. + -- + -- To play on instrument means to apply instrument to 'Score' + -- of its notes. + -- + -- >-- oscillator instrument + -- >instr :: Irate -> SignalOut + -- >instr x = out $ oscilA [] (num 1000) (cpspch x) $ gen10 4096 [1] + -- > + -- >exmpScoFunctor = fmap instr $ line $ map (note 1) [d 0, f 0, a 0, d 1] + + exmpScoFunctor, + -- ** Monad + + {-| + Gives way to more structured composition. + + + @return a@ makes note of @a@ that lasts for 1 sec. + @ma >>= f@ is better understood by its @join@ function. + + >ma >>= f = joinScore $ fmap f ma + > + >joinScore :: Score (Score a) -> Score a + + @'Score' a@ is a tree. Nodes represent sequent/parallel + composition and leaves represent value @a@ or rest that lasts + for some time @t@. 'joinScore' takes in 'Score' that contains some more + 'Score' 's in its leaves, and builds one tree by substituting + values of Scores by Scores. Note that while substituting it stretches + duration of 'Score' by duration of value. + + >type ChordType = [Irate] + > + >majC, minC :: ChordType + > + >majC = [0, 0.04, 0.07] -- in csound 0.01 is one half-tone + >minC = [0, 0.03, 0.07] + > + >arpeggi :: (Irate, ChordType) -> Score Irate + >arpeggi baseNote chordType = line $ map return (pchs ++ pchs) + > where pchs = map ((+ baseNote) . (chordType !! )) [0, 1, 2, 1, 2, 1] + > + >harmony = line $ map return + > [(e 0, minC), (a (-1), minC), (d 0, majC), (g 0, majC), + > (c 0, majC), (f 0, minC), (b (-1), majC), (e 0, minC)] + > + >sco = harmony >>= arpeggi + -} + + exmpScoMonad, + -- ** Temporal + + {-| There are two methods defined on 'Temporal' objects. + + >none :: Dur -> a -- construct rest + >dur :: a -> Dur -- ask for duration + -} + + exmpScoTemporal, + -- ** Stretchable + + {-| Stretching things in time domain with 'stretch' method. + + > stretch :: Dur -> a -> a + -} + + exmpScoStretchable, + -- ** Arrangeable + -- + exmpScoArrangeable, + + -- | Constructing things in sequent '(+:+)' and parallel ways '(=:=)' + + -- ** TemporalFunctor + {-| + There is class called 'TemporalFunctor' with method 'tmap'. + First argument of tmap's function means function from duration + of value @t@ and value itself @a@ to new value @b@. + + >class Dur t => TemporalFunctor f where + > tmap :: (t -> a -> b) -> f a -> f b + + It allows to construct instruments that can rely on note duration. + + >instr :: Dur -> Irate -> SignalOut + >instr t vol = out $ (env t <*> ) $ fst $ se1 $ unirandA vol + > where env t + > | t < 1 = lineK 1 idur 0 + > | otherwise = exponK 1 idur 0 + > + >v1 = 1.5 * v0 + >v0 = 5000 + > + >sco = tmap instr $ line [note 0.5 v1, note 0.5 v0, rest 1, note 2 v1] + + Note : + + >stretch t (tmap instr sco) =/= tmap instr (stretch t sco) + + -} + + exmpScoTemporalFunctor, + + -- * Example + + -- | radiohead - weird fishes (intro), see src + main + + )where + +import Temporal.Media(EventList) + +import CsoundExpr.Base +import CsoundExpr.Base.Pitch +import CsoundExpr.Opcodes hiding (delay) + +exmpEventList :: EventList Double Irate +exmpEventList = toList $ line $ map (note 1) [c 0, d 0, e 0, f 0, g 0, a 0, b 0, c 1] + + +exmpScore :: Score String +exmpScore = note 1 "hello" +:+ rest 1 +:+ note 1 "world" + +-- oscilator instrument +instr :: Irate -> SignalOut +instr x = out $ oscilA [] (num 1000) (cpspch x) $ gen10 4096 [1] + +exmpScoFunctor = fmap instr $ line $ map (note 1) [d 0, f 0, a 0, d 1] + + +type ChordType = [Irate] + +majC, minC :: ChordType + +majC = [0, 0.04, 0.07] -- in csound 0.01 is one half-tone +minC = [0, 0.03, 0.07] + +arpeggi :: Irate -> ChordType -> Score Irate +arpeggi baseNote chordType = line $ map return (pchs ++ pchs) + where pchs = map ((+ baseNote) . (chordType !! )) [0, 1, 2, 1, 2, 1] + +harmony = line $ map return + [(e 0, minC), (a (-1), minC), (d 0, majC), (g 0, majC), + (c 0, majC), (f 0, minC), (b (-1), majC), (e 0, minC)] + +exmpScoMonad = harmony >>= uncurry arpeggi + +exmpScoTemporal = dur exmpScoMonad + +exmpScoStretchable = stretch 2 exmpScoMonad + +exmpScoArrangeable = exmpScore + + +instrT :: Dur -> Irate -> SignalOut +instrT t vol = out $ (env t <*> ) $ fst $ se1 $ unirandA vol + where env t + | t < 1 = lineK 1 idur 0 + | otherwise = exponK 1 idur 0 + +exmpScoTemporalFunctor = tmap instrT $ line [note 0.5 v1, note 0.5 v0, rest 1, note 2 v1] + + +-------------------------------------------------------- +-- example +-- +-- radiohead - weird fishes (intro) + +mapSnd f (a, b) = (a, f b) + + +flags = "-d" + +-- volume levels + +v1 = 1.3 * v0 +v0 = 7000 + +-- instruments + +pluckInstr :: (Irate, Irate) -> SignalOut +pluckInstr (amp, pch) = outList [ + out $ env <*> wgpluck2 0.75 amp (cpspch pch) (num 0.75) (num 0.5), + xtratim 1] + where env = linsegrK [0, idur * 0.05, 1, idur * 0.9, 1] 1 0 + +guitar = pluckInstr . mapSnd (+ (-1)) + + +--chords + +guitarChord1, guitarChord2, guitarChord3 :: [Irate] -> Score (Irate, Irate) + +-- volumes 4/4 +vs x = map ( * x) $ cycle [v1, v0, v0, v0] + +-- guitar 1 +guitarChord1 = line . map return . zip (vs 1) . concat . replicate 10 + +ch11 = [d 1, g 0, e 0] +ch12 = map ( + 0.02) ch11 +ch13 = [a 1, a 0, cs 1] +ch14 = [fs 1, b 0, g 0] + +chSeq1 = line $ map return $ [ch11, ch12, ch13, ch14] + +-- guitar 2 +guitarChord2 = line . map return . zip (vs 0.5) . concat . replicate 6 . arpeggi + where arpeggi x = x ++ take 2 x + + +ch21 = [g 0, d 1, e 1] +ch22 = map (+ 0.02) ch21 +ch23 = [cs 1, e 1, a 1] +ch24 = [d 1, g 1, e 1] + +chSeq2 = line $ map return $ [ch21, ch22, ch23, ch24] + +-- guitar 3 +guitarChord3 = line . map return . zip (vs 0.2) . concat . replicate 6 . arpeggi + where arpeggi x = take 2 x ++ x + +ch31 = [e 1, g 1, b 1] +ch32 = map (+ 0.02) ch31 +ch33 = [fs 1, a 1, cs 2] +ch34 = [d 2, g 1, b 1] + +chSeq3 = line $ map return $ [ch31, ch32, ch33, ch34] + +-- scores + +scoG1 = fmap guitar $ chSeq1 >>= guitarChord1 +scoG2 = fmap guitar $ chSeq2 >>= guitarChord2 +scoG3 = fmap guitar $ chSeq3 >>= guitarChord3 + +scoG2intro = cut (3*30) (4*30) scoG2 + +intro = chord [scoG1, scoG3, delay (3*30) scoG2intro] +chords = loop 3 $ chord [scoG1, scoG2, scoG3] + +sco = stretch 0.17 $ intro +:+ chords + +main = print $ csd flags headerMono $ toList sco + diff --git a/src/CsoundExpr/Tutorial/Intro.hs b/src/CsoundExpr/Tutorial/Intro.hs new file mode 100644 --- /dev/null +++ b/src/CsoundExpr/Tutorial/Intro.hs @@ -0,0 +1,128 @@ +{-| + Csound-expression is csound code generator. Program produces value of 'CsoundFile' type. + 'CsoundFile' is 'Show'. So that is the way to get csound code. 'csd' function can be invoked + to make value of 'CsoundFile' type. + + >csd :: Flags -> Header -> EventList Dur SignalOut -> CsoundFile + + * 'Flags' is 'String'. It's pasted in place of csounds flags. + + * 'Header' is csound header declaration. + See "CsoundExpr.Base.Header" for more details. + + * 'EventList' represents csound orchestra and score sections. + This tutorial is all about how to construct 'EventList'. + + + 'EventList' + + + 'EventList' contains values with time marks. + Value begins at some time and lasts for some time (see temporal-media package) + 'EventList' can be constructed from 'Score' with 'toList' function. + + 'Score' + + + 'Score' is tree structure that represents music. Lists contain notes and nodes + contain information about how subtrees relate to each other in time. + Subtrees can be sequential or parallel. Module "CsoundExpr.Base.Score" exposes + combinators for 'EventList' / 'Score' building. + 'csd' function takes in 'EventList' 'Double' 'SignalOut'. 'Double' is type + of time-marks. 'SignalOut' represents instrument structure. + + + Let's make first simple csound code block. + It plays d minor chord wih oscilator. + + >import CsoundExpr + >import CsoundExpr.Opcodes(out, oscilA, cpspch) + >import CsoundExpr.Base.Pitch + > + >flags = "-d -o dm.wav" + > + >-- (<=>) - assignment operator + >-- instr0 - packs assignent statements in header statement + >setup :: SignalInit + >setup = instr0 [ + > gSr <=> 44100, + > gKr <=> 4410, + > gKsmps <=> 10, + > gNchnls <=> 1] + > + >header :: Header + >header = [setup] + > + >-- gen routine (see CsoundExpr.Base.Gens) + >sinWave :: Irate + >sinWave = gen10 4096 [1] + > + >-- oscilator instrument + >instr :: Irate -> SignalOut + >instr x = out $ oscilA [] (num 1000) (cpspch x) sinWave + > + >-- line, note - Score constructors (see CsoundExpr.Base.Score) + >-- Score is a Functor, so it's possible to use instruments as + >-- functions on abstract note representation. + >-- here note is represented with pitch value of type Irate + >-- (Irate is csound's init value) + >-- + >sco = fmap instr $ line $ map (note 1) [d 0, f 0, a 0, d 1] + > + > + >-- toList - converts Score to EventList (see CsoundExpr.Base.Score) + >dmCode = csd flags header $ toList sco + + + * Prev : "CsoundExpr.Tutorial" + + * Next : "CsoundExpr.Tutorial.Composition" +-} + +-- +-- +module CsoundExpr.Tutorial.Intro ( + dmCode + ) +where + + + +import CsoundExpr +import CsoundExpr.Opcodes +import CsoundExpr.Base.Pitch + +flags = "-o dm.wav" + +-- (<=>) - assignment operator +-- instr0 - packs assignent statements in header statement +setup = instr0 [ + gSr <=> 44100, + gKr <=> 4410, + gKsmps <=> 10, + gNchnls <=> 1] + +header = [setup] + +-- gen routine +sinWave = gen10 4096 [1] + +-- oscilator instrument +instr :: Irate -> SignalOut +instr x = out $ oscilA [] (num 1000) (cpspch x) sinWave + +-- line, note - Score constructors (see CsoundExpr.Base.Score) +-- Score is a Functor, so it's possible to use instruments as +-- functions on abstract note representation. +-- here note is represented with pitch value of type Irate +-- (Irate is csound's init value) +-- +sco = fmap instr $ line $ map (note 1) [d 0, f 0, a 0, d 1] + + +-- toList - converts Score to EventList +dmCode = csd flags header $ toList sco + + + + diff --git a/src/CsoundExpr/Tutorial/Limits.hs b/src/CsoundExpr/Tutorial/Limits.hs new file mode 100644 --- /dev/null +++ b/src/CsoundExpr/Tutorial/Limits.hs @@ -0,0 +1,83 @@ + +-- | This chapter explains some limitations and hack-features of library. +-- +-- +-- * Prev : "CsoundExpr.Tutorial.Orchestra" +-- +-- * Next : + + +module CsoundExpr.Tutorial.Limits ( + -- * What can not be expressed + + + -- ** ids + {-| + The major benefit and major problem of csound-expression is + abscense of ids for p-fields, ftables, notes and instruments. + + + no ids for ... means ... no + + p-fields/notes - opcodes that rely on p-fields or invoke instruments + + ftables - k-rate ftables + + instruments - convenient way to specify order of instruments + -} + + -- ** program flow control + + -- | there is no program flow control opcodes (like if, then, goto) + + -- ** Srate + + -- | i've decided to represent csound's S-rate with 'String'. + -- + -- Signal is represented with tree and it means i can't include + -- opcodes that produce Srate + + -- * hack-way around (what somehow can be expressed) + + -- ** instrument order + {-| + Orchestra section is generated from 'EventList'. Different instruments + have different tree structure and one instrument's tree can't be + transformed into another one by replacing leaf-values only. + + You can point to instrument by its structure. There is opcode in + "CsoundExpr.Base.Header" that specifies order of instruments by + list of notes. 'instrOrder' takes in list of notes, if instrument's + tree is equivalent to note it is placed in relation to list of notes. + + There are ways to make mistake. Sometimes it's unpredictable. + + + In example below + + @q1 =/= q2@ + + @sco@ contains two instruments (one with @x@, and another one with @cpspch x@) + + > + >osc x = oscilA [] (num 1000) x $ gen10 4096 [1] + >env = lineK 1 idur 0 + > + >q1 x = osc x <*> env + >q2 x = env <*> osc x + > + >sco1 = note 1 440 + >sco2 = note 1 $ cpspch 8.00 + > + >sco = fmap q1 $ sco1 +:+ sco2 + + I think maybe it's worthwhile to introduce some way of instrument id + assignment. + -} + + + ) + +where + + diff --git a/src/CsoundExpr/Tutorial/Orchestra.hs b/src/CsoundExpr/Tutorial/Orchestra.hs new file mode 100644 --- /dev/null +++ b/src/CsoundExpr/Tutorial/Orchestra.hs @@ -0,0 +1,315 @@ +-- | Guide to instrument-making +-- +-- * Prev : "CsoundExpr.Tutorial.Composition" +-- +-- * Next : "CsoundExpr.Tutorial.Limits" + + +module CsoundExpr.Tutorial.Orchestra ( + + -- * Instruments + + {-| + Instruments are functions from some signal representation to signal. + 'Score' is a 'Functor', so to play on instrument means to apply instrument + to 'Score' of its notes. Instrument can be made with opcodes. + Translator derives p-fields from instrument structure. There are only + two explicit p-fields 'itime' and 'idur' (@p2@ and @p3@ in csound). + -} + + exmpInstr, + + -- * Signals / Types + + {-| + Signals are represented with trees. Tree contains information about how + signal was build. + + There are four types for signals ("CsoundExpr.Base.Types"). + + 'Arate' is audio rate signal + + 'Krate' is control rate signal + + 'Irate' is init value + + 'SignalOut' is no output at all (it's produced by opcodes like out, outs, xtratim) + + + There are two classes to allow csound's polymorphism : 'X' and 'K' + + 'X' = 'Arate' | 'Krate' | 'Irate' + + 'K' = 'Krate' | 'Irate' + + + Csound's S - signal is represented with 'String'. + Ftable is represented with 'Irate'. + + + There are two special types 'MultiOut' + (for opcodes that may produce several outputs, see "CsoundExpr.Base.MultiOut") + and 'SideEffect' + (for opcodes that rely on number of appearances in csound code, + like @unirand@, see "CsoundExpr.Base.SideEffect") + -} + + -- * Opcodes + + {-| + Naming conventions : Opcodes are named after csound's counterparts usually. + Some opcodes in csound can produce signals of different rates by request (oscil, linseg). + Those opcodes are labelled with suffix. Suffix defines output rate of signal (oscilA, oscilK). + Some opcodes in csound have unfixed number of inputs due to setup parameters, almost all of them. + Those opcodes have first argument that is list of setup parameters. + + example + + >oscilA :: (X a, X b) => [Irate] -> a -> b -> Irate -> Arate + >oscilK :: (K a, K b) => [Irate] -> a -> b -> Irate -> Krate + -} + + + -- * Imperative style csound code + + {-| + Most of csound opcodes can be used in functional way. You can plug them in one another, + and make expressions, but some of them behave like procedures and rely on order + of execution in instrument. Module "CsoundExpr.Base.Imperative" provides functions + to write imperative csound code. + + 'outList' - to sequence procedures + + '(/<=/>)' - Assignment + + 'ar', 'kr', 'ir', 'gar', 'gkr', 'gir' - named values, to produce signal with specified name and rate. + + + Functional style : + + >exmpInstr :: Irate -> SignalOut + >exmpInstr pch = out $ oscilA [] (num 1000) (cpspch pch) $ gen10 4096 [1] + + + Imperative style : + + >exmpImper :: Irate -> SignalOut + >exmpImper pch = outList [ + > ir "amp" <=> num 1000, + > ir "cps" <=> cpspch pch, + > ir "ft" <=> gen10 4096 [1], + > ar "sig" <=> oscilA [] (ir "amp") (ir "cps") (ir "ft"), + > out (ar "sig")] + + -} + + exmpImper, + -- * Arithmetic + {-| + You can use polymorphic operations to do some arihmetic on signals + from "CsoundExpr.Base.Arithmetic". And Signal is 'Num'. 'Eq' is undefined though. + -} + + exmpArith, + -- * Preview + + {-| + To see what will come out of an expression you can print it. Signal is 'Show'. + -} + exmpPreview, + + + -- * User Defined opcodes + + {-| + You can add your own opcodes to library, see "CsoundExpr.Base.UserDefined" + -} + + -- * MIDI + + {-| + There are two ways to tell 'csd' to include instrument in csound file. + Instrument can be a part of 'Score' or it can be midi instrument, then it should + be mentioned in 'massign' or 'pgmassign' function. If you want to play midi-instr + for some time @t@, you can tell it to 'csd' function by invoking 'csd' with @'rest' t@ + in place of 'EventList' value. + + >flags = "-odac -iadc -+rtmidi=virtual -M0" + > + >header = [massign [] 1 instrMidi] + > + >instrMidi :: SignalOut + >instrMidi = out $ oscilA [] (num 1000) cpsmidi $ gen10 4096 [1] + > + >-- play instrMidi for 2 minutes + >exmpMidi = print $ csd flags header (rest 120) + + -} + exmpMidi, + + -- * Example + -- | Song, see src + + main +) + + where + +import CsoundExpr.Base +import CsoundExpr.Base.Pitch +import CsoundExpr.Opcodes hiding (delay) + +------------------------------------ + +exmpInstr :: Irate -> SignalOut +exmpInstr pch = out $ oscilA [] (num 1000) (cpspch pch) $ gen10 4096 [1] + +exmpImper :: Irate -> SignalOut +exmpImper pch = outList [ + ir "amp" <=> num 1000, + ir "cps" <=> cpspch pch, + ir "ft" <=> gen10 4096 [1], + ar "sig" <=> oscilA [] (ir "amp") (ir "cps") (ir "ft"), + out (ar "sig")] + + +exmpArith pch = out $ (env <*>) $ oscilA [] (num 1000) (cpspch pch) $ gen10 4096 [1] + where env = lineK 1 idur 0 + + +exmpPreview = mapM_ print $ map ( $ (a 1)) [exmpInstr, exmpImper, exmpArith] + +flagsMidi = "-odac -iadc -+rtmidi=virtual -M0" + +header = [massign [] 1 instrMidi] + +instrMidi :: SignalOut +instrMidi = out $ oscilA [] (num 1000) cpsmidi $ gen10 4096 [1] + +-- play instrMidi for 2 minutes +exmpMidi = print $ csd flagsMidi header (rest 120) + +---------------------------------------------------------------- +---------------------------------------------------------------- +-- Example +-- +-- Song +-- + +mapSnd f (a, b) = (a, f b) + +flags = "-d" + +dot = stretch 1.5 + +wn = note 1 +hn = note 0.5 +qn = note 0.25 +en = note 0.125 + + +sinWave = gen10 4096 [1] +expWave = gen05 4096 [0.01, 4070, 1, 26, 0.01] + +-- volume levels +-- + +v1 = 1.3 * v0 +v0 = 10000 + +-- instruments +-- + +-- plucked + +pluckInstr :: (Irate, Irate) -> SignalOut +pluckInstr (amp, pch) = outList [ + out $ env <*> wgpluck2 0.75 amp (cpspch pch) (num 0.75) (num 0.5), + xtratim 1] + where env = linsegrK [0, idur * 0.05, 1, idur * 0.9, 1] 1 0 + +guitar = pluckInstr . mapSnd (+ (-1)) +bass = pluckInstr . mapSnd (+ (-2)) + +-- drums + +qCabasa = out $ cabasa [] 9000 0.01 +qBamboo = out $ bamboo [] (num 2500) 0.01 + +shh = out $ (env <*> ) $ fst $ se1 $ unirandA (num 1000) + where env = exponK 1 idur 0.001 + +-- aahs + +aahs :: Dur -> (Irate, Irate) -> SignalOut +aahs t (amp, pch) + | t < tShort = out $ env1 <*> osc pch + | otherwise = outList [out $ env2 <*> osc pch, xtratim 1] + where osc x = oscilA [] amp (cpspch x) tab + env1 = linsegK $ norm (ps ++ [0.025, 0]) + env2 = linsegrK (norm $ ps ++ [0.025, 1]) 1 0 + norm = zipWith (<*>) (cycle [1, idur]) + tab = gen10 4096 [1, 0.7, 0.2, 0.7] + tShort = 0.6/2 + ps = [0, 0.5, 0.2, 0.25, 0.3, 0.125, 0.5, 0.1, 1 :: Irate] + + +-- piece +-- + +-- chords + +bassChord, guitarChord :: (Irate, Irate, Irate, Irate) -> Score (Irate, Irate) + +bassChord (n1, _, _, _) = loop 4 $ line $ map en [(v1, n1), (v0, n1), (v0, n1), (v0, n1)] + +guitarChord (n1, n2, n3, n4) = line $ [qn (v1, n1)] ++ + map (dot . qn) [(v0, n3), (v0, n2), (v1, n4), (v0, n3)] ++ [qn (v0, n4)] + + +ch1 = (b (-1), d 0, a 0, cs 1) +ch2 = ( d 0, fs 0, cs 1, d 1) +ch3 = (g (-1), a (-1), fs 0, g 0) + +chordSeq = line $ map wn [ch1, ch2, ch1, ch3] + +-- solo + +soloNotes :: [Irate] -> Score (Irate, Irate) +soloNotes notes = stretch 2 $ + (line $ map return notes) >>= pulse + +pulse :: Irate -> Score (Irate, Irate) +pulse = line . zipWith note durs . zip vols . repeat + where vols = map ((0.3 * v0) *) [0.2, 0.4, 0.6, 0.8, 0.6, 0.4] + durs = norm [1, 1.2 , 1, 1, 1, 1.5] + norm xs = map ( /sum xs) xs + +-- scores + +scoBamboo = stretch 0.5 $ loop 15 $ delay 1 $ line $ map (note 1) $ replicate 3 qBamboo +scoCabasa = loop (4*16) $ line [rest 0.25, qn qCabasa] +scoShh = delay 2 $ loop 8 $ line [wn shh, rest 3] + +scoDrums = chord [scoBamboo, delay 12 scoCabasa, delay 12 scoShh] + +scoGuitar = fmap guitar $ chordSeq >>= guitarChord +scoBass = fmap bass $ chordSeq >>= bassChord + +accomp = chord [ + delay 4 $ loop 5 scoGuitar, + delay 12 $ loop 4 scoBass, + scoDrums] + +scoAahs1 = loop 2 $ tmap aahs $ soloNotes [d 1, cs 1, e 0, fs 0] +scoAahs2 = loop 2 $ tmap aahs $ soloNotes [d 1, cs 1, a 0, d 0] +scoAahs3 = loop 2 $ tmap aahs $ soloNotes [a 0, cs 1, g 0, fs 0] + +solo = delay 20 $ chord [ + scoAahs1, + delay 5 $ stretch 1.3 scoAahs2, + delay 7 $ stretch 1.5 scoAahs3] + +sco = stretch 2.0 $ chord [solo, accomp] + +main = print $ csd flags headerMono $ toList sco