title | category |
---|---|
fit |
pattern_transformers |
fit :: Int -> [a] -> Pattern Int -> Pattern a
The fit
function takes a pattern of integer numbers, which are used to select values from the given list. What makes this a bit strange is that only a given number of values are selected each cycle. For example:
d1 $ sound (fit 3 ["bd", "sn", "arpy", "arpy:1", "casio"] "0 [~ 1] 2 1")
{: .render }
The above fits three samples into the pattern, i.e. for the first cycle this will be "bd"
, "sn"
and "arpy"
, giving the result "bd [~ sn] arpy sn"
(note that we start counting at zero, so that 0
picks the first value). The following cycle the next three values in the list will be picked, i.e. "arpy:1"
, "casio"
and "bd"
, giving the pattern "arpy:1 [~ casio] bd casio"
(note that the list wraps round here).
fit' :: Time -> Int -> Pattern Int -> Pattern Int -> Pattern a -> Pattern a
fit'
is a generalization of fit
, where the list is instead constructed by using another integer pattern to slice up a given pattern. The first argument is the number of cycles of that latter pattern to use when slicing. It's easier to understand this with a few examples:
d1 $ sound (fit' 1 2 "0 1" "1 0" "bd sn")
{: .render }
So what does this do? The first 1
just tells it to slice up a single cycle of "bd sn"
. The 2
tells it to select two values each cycle, just like the first argument to fit
. The next pattern "0 1"
is the "from" pattern which tells it how to slice, which in this case means "0"
maps to "bd"
, and "1"
maps to "sn"
. The next pattern "1 0"
is the "to" pattern, which tells it how to rearrange those slices. So the final result is the pattern "sn bd"
.
A more useful example might be something like
d1 $ fit' 1 4 (run 4) "[0 3*2 2 1 0 3*2 2 [1*8 ~]]/2" $ chop 4 $ (sound "breaks152" # unit "c")
{: .render }
which uses chop
to break a single sample into individual pieces, which fit'
then puts into a list (using the run 4
pattern) and reassembles according to the complicated integer pattern.