Re: Changing sounds within Euclidean Rhythms ("great challenge")

Interesting problem! In functional reactive programming, there are accumulating functions, e.g., https://hackage.haskell.org/package/threepenny-gui-0.9.0.0/docs/Reactive-Threepenny.html#v:accumB

```
accumB :: MonadIO m => a -> Event (a -> a) -> m (Behavior a)
```

(let's assume, roughly, `Event = Behaviour = Pattern`

and `m = Identity`

) then we could theoretically hope for

```
accumB 0 (euclid 3 8 $ pure succ)
```

to mean the pattern that counts 0, 1, .. and changes value exactly at the Euclidean points.

But that's hard since we could have parallel events, e.g.,

```
accumB 0 (stack[pure pred, pure succ])
```

what should happen? In this specific case, "apply in any order" is probably fine,

as `pred . succ = succ . pred`

but for non-commutative operations?

So, this cannot exist in general? Because we'd have to allow some unspecified behaviour?

NB: a similar thing already happens with global effects (e.g., delay) that have their parameters overwritten seemingly randomly from different sub-expressions of `stack`

.