Sound.SC3.Lang.Pattern.List

List variants of SC3 pattern functions.

Data.Bool variants

bool :: (Ord n, Num n) => n -> Bool

> 0. Values greater than zero are True and zero and negative values are False.

Data.Functor variants

fbool :: (Ord a, Num a, Functor f) => f a -> f Bool

fmap of bool.

 fbool [2,1,0,-1] == [True,True,False,False]

ffold :: (Functor f, Num a, Ord a) => f a -> a -> a -> f a

SC3 pattern to fold values to lie within range (as opposed to wrap and clip). This is not related to Data.Foldable.

 ffold [10,11,12,-6,-7,-8] (-7) 11 == [10,11,10,-6,-7,-6]

The underlying primitive is the fold_ function.

 let f n = S.fold_ n (-7) 11
 in map f [10,11,12,-6,-7,-8] == [10,11,10,-6,-7,-6]

fwrap :: (Functor f, Ord a, Num a) => f a -> a -> a -> f a

SC3 pattern to constrain the range of output values by wrapping, the primitive is genericWrap.

 let p = fmap round (fwrap (geom 200 1.2 10) 200 1000)
 in p == [200,240,288,346,415,498,597,717,860,231]

Data.List variants

uncons :: [a] -> (Maybe a, [a])

Inverse of :.

 map uncons [[],1:[]] == [(Nothing,[]),(Just 1,[])]

lindex :: [a] -> Int -> Maybe a

Maybe variant of !!.

 map (lindex "str") [2,3] == [Just 'r',Nothing]

segment :: [a] -> Int -> (Int, Int) -> [a]

List section with wrapped indices.

 segment [0..4] 5 (3,5) == [3,4,0]

take_inf :: Int -> [a] -> [a]

If n is maxBound this is id, else it is take.

transpose_fw :: Int -> [[a]] -> [[Maybe a]]

Variant of transpose for fixed width interior lists. Holes are represented by Nothing.

 transpose_fw undefined [] == []

 transpose [[1,3],[2,4]] == [[1,2],[3,4]]
 transpose_fw 2 [[1,3],[2,4]] == [[Just 1,Just 2],[Just 3,Just 4]]

 transpose [[1,5],[2],[3,7]] == [[1,2,3],[5,7]]

 transpose_fw 2 [[1,4],[2],[3,6]] == [[Just 1,Just 2,Just 3]
                                     ,[Just 4,Nothing,Just 6]]

This function is more productive than transpose for the case of an infinite list of finite lists.

 map head (transpose_fw 4 (repeat [1..4])) == map Just [1,2,3,4]
 map head (transpose (repeat [1..4])) == _|_

transpose_fw_def :: a -> Int -> [[a]] -> [[a]]

Variant of transpose_fw with default value for holes.

transpose_fw_def' :: a -> [[a]] -> [[a]]

Variant of transpose_fw_def deriving width from first element.

transpose_st :: [[a]] -> [[a]]

A transpose variant, halting when first hole appears.

 trs [[1,2,3],[4,5,6],[7,8]] == [[1,4,7],[2,5,8]]

Data.Maybe variants

all_just :: [Maybe a] -> Maybe [a]

Variant of catMaybes that returns Nothing unless all elements are Just.

 map all_just [[Nothing,Just 1],[Just 0,Just 1]] == [Nothing,Just [0,1]]

Data.Monoid variants

mcycle :: Monoid a => a -> a

mconcat of repeat, for lists this is cycle.

 [1,2,3,1,2] `isPrefixOf` take 5 (mcycle [1,2,3])

Non-SC3 Patterns

countpost :: [Bool] -> [Int]

Count the number of False values following each True value.

 countpost (map bool [1,0,1,0,0,0,1,1]) == [1,3,0,0]

countpre :: [Bool] -> [Int]

Count the number of False values preceding each True value.

 countpre (fbool [0,0,1,0,0,0,1,1]) == [2,3,0]

hold :: [a] -> [a]

Sample and hold initial value.

 hold [] == []
 hold [1..5] == [1,1,1,1,1]
 hold [1,undefined] == [1,1]

interleave2 :: [a] -> [a] -> [a]

Interleave elements from two lists. If one list ends the other continues until it also ends.

 interleave2 [1,2,3,1,2,3] [4,5,6,7] == [1,4,2,5,3,6,1,7,2,3]
 [1..9] `isPrefixOf` interleave2 [1,3..] [2,4..]

interleave :: [[a]] -> [a]

N-ary variant of interleave2, ie. concat of transpose.

 interleave [whitei 'α' 0 4 3,whitei 'β' 5 9 3] == [3,7,0,8,1,6]
 [1..9] `isPrefixOf` interleave [[1,4..],[2,5..],[3,6..]]

rsd :: Eq a => [a] -> [a]

Remove successive duplicates.

 rsd (stutter (repeat 2) [1,2,3]) == [1,2,3]
 rsd [1,2,3,1,2,3] == [1,2,3,1,2,3]

trigger :: [Bool] -> [a] -> [Maybe a]

Pattern where the tr pattern determines the rate at which values are read from the x pattern. For each sucessive true value at tr the output is a (Just e) of each succesive element at x. False values at tr generate Nothing values.

 let l = trigger (map toEnum [0,1,0,0,1,1]) [1,2,3]
 in l == [Nothing,Just 1,Nothing,Nothing,Just 2,Just 3]

SC3 Patterns

brown :: (Enum e, Random n, Num n, Ord n) => e -> n -> n -> n -> [n]

Pbrown. SC3 pattern to generate psuedo-brownian motion.

 [4,4,1,8,5] `isPrefixOf` brown 'α' 0 9 15

durStutter :: Fractional a => [Int] -> [a] -> [a]

PdurStutter. SC3 pattern to partition a value into n equal subdivisions. Subdivides each duration by each stutter and yields that value stutter times. A stutter of 0 will skip the duration value, a stutter of 1 yields the duration value unaffected.

 let {s = [1,1,1,1,1,2,2,2,2,2,0,1,3,4,0]
     ;d = [0.5,1,2,0.25,0.25]}
 in durStutter s d == [0.5,1.0,2.0,0.25,0.25]

exprand :: (Enum e, Random a, Floating a) => e -> a -> a -> Int -> [a]

Pexprand. SC3 pattern of random values that follow a exponential distribution.

 exprand 'α' 0.0001 1 10

funcn :: Enum e => e -> (StdGen -> (n, StdGen)) -> Int -> [n]

Pfuncn. Variant of the SC3 pattern that evaluates a closure at each step that has a StdGen form.

geom :: Num a => a -> a -> Int -> [a]

Pgeom. geom with arguments re-ordered.

 geom 3 6 5 == [3,18,108,648,3888]

if_demand :: [Bool] -> [a] -> [a] -> [a]

Pif. Consume values from q or r according to p.

 if_demand [True,False,True] [1,3] [2] == [1,2,3]

rand' :: Enum e => e -> [a] -> Int -> [a]

Prand. Random elements of p.

 rand' 'α' [1..9] 9 == [3,9,2,9,4,7,4,3,8]

seq' :: [[a]] -> Int -> [a]

Pseq. concat of replicate of concat.

 seq' [return 1,[2,3],return 4] 2 == [1,2,3,4,1,2,3,4]

slide :: [a] -> Int -> Int -> Int -> Int -> Bool -> [a]

Pslide. SC3 pattern to slide over a list of values.

 slide [1,2,3,4] 4 3 1 0 True == [1,2,3,2,3,4,3,4,1,4,1,2]
 slide [1,2,3,4,5] 3 3 (-1) 0 True == [1,2,3,5,1,2,4,5,1]

stutter :: [Int] -> [a] -> [a]

Pstutter. Repeat each element of a pattern n times.

 stutter [1,2,3] [4,5,6] == [4,5,5,6,6,6]
 stutter (repeat 2) [4,5,6] == [4,4,5,5,6,6]

switch :: [[a]] -> [Int] -> [a]

Pswitch. SC3 pattern to select elements from a list of patterns by a pattern of indices.

 let r = switch [[1,2,3,1,2,3],[65,76],[800]] [2,2,0,1]
 in r == [800,800,1,2,3,1,2,3,65,76]

switch1 :: [[a]] -> [Int] -> [a]

Pswitch1. SC3 pattern that uses a pattern of indices to select which pattern to retrieve the next value from. Only one value is selected from each pattern. This is in comparison to switch, which embeds the pattern in its entirety.

 let p = switch1 [(cycle [1,2,3])
                 ,(cycle [65,76])
                 ,repeat 8] (concat (replicate 6 [2,2,0,1]))
 in p == [8,8,1,65,8,8,2,76,8,8,3,65,8,8,1,76,8,8,2,65,8,8,3,76]

white :: (Random n, Enum e) => e -> n -> n -> Int -> [n]

Pwhite. SC3 pattern to generate a uniform linear distribution in given range.

 white 'α' 0 9 5 == [3,0,1,6,6]

It is important to note that this structure is not actually indeterminate, so that the below is zero.

 white 'α' 1 9 5  == [3,9,2,9,4]
 let p = white 'α' 0.0 1.0 3 in zipWith (-) p p == [0,0,0]

wrand :: (Enum e, Fractional n, Ord n, Random n) => e -> [[a]] -> [n] -> Int -> [a]

Pwrand. SC3 pattern to embed values randomly chosen from a list. Returns one item from the list at random for each repeat, the probability for each item is determined by a list of weights which should sum to 1.0.

 let w = C.normalizeSum [1,3,5]
 in wrand 'ζ' [[1],[2],[3,4]] w 6 == [3,4,2,2,3,4,1,3,4]

xrand :: Enum e => e -> [[a]] -> Int -> [a]

Pxrand. SC3 pattern that is like rand but filters successive duplicates.

 xrand 'α' [return 1,[2,3],[4,5,6]] 9 == [4,5,6,2,3,4,5,6,1]

SC3 Variant Patterns

brown_ :: (RandomGen g, Random n, Num n, Ord n) => (n, n, n) -> (n, g) -> (n, g)

Underlying brown'.

brown' :: (Enum e, Random n, Num n, Ord n) => e -> [n] -> [n] -> [n] -> [n]

Brown noise with list inputs.

 let l = brown' 'α' (repeat 1) (repeat 700) (cycle [1,20])
 in [415,419,420,428] `isPrefixOf` l

if_rec :: ([Bool], [a], [a]) -> Maybe (a, ([Bool], [a], [a]))

Underlying if_demand.

if_zip :: [Bool] -> [a] -> [a] -> [a]

zip3 variant.

 if_zip [True,False,True] [1,3] [2] == [1]

funcn' :: RandomGen g => g -> (g -> (n, g)) -> Int -> [n]

Underlying funcn.

rorate_n' :: Num a => a -> a -> [a]

rorate_n :: Num a => [a] -> [a] -> [a]

rorate_l' :: Num a => [a] -> a -> [a]

rorate_l :: Num a => [[a]] -> [a] -> [a]

white' :: (Enum e, Random n) => e -> [n] -> [n] -> [n]

white with pattern inputs.

 white' 'α' (repeat 0) [9,19,9,19,9,19] == [3,0,1,6,6,15]

whitei' :: (Random n, Integral n, Enum e) => e -> n -> n -> Int -> [n]

Type-specialised (Integral) white.

 whitei' 'α' 1 9 5 == [3,9,2,9,4]

whitei :: (Random n, RealFracE n, Enum e) => e -> n -> n -> Int -> [n]

A variant of pwhite that generates integral (rounded) values.

 whitei 'α' 1 9 5 == [5,1,7,7,8]

wrand' :: (Enum e, Fractional n, Ord n, Random n) => e -> [[a]] -> [n] -> [[a]]

Underlying wrand.

xrand' :: Enum e => e -> [[a]] -> [a]

Underlying xrand.