Accumulation over patterns (why we cannot have it)?

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.