Documentation

A (non-empty) alternating sequence of a's and sep's.

Given a separator, and some foldable structure, constructs an Alternating.

map some function changing the f into a g.

Map over the separators of the alterating together with the neighbours

Computes a b with all its neighbours

>>> withNeighbours (Alternating 0 [('a', 1), ('b', 2), ('c',3)])
[(0,'a',1),(1,'b',2),(2,'c',3)]

Generic merging scheme that merges two Alternating Lists and applies the function 'f', with the current/new value at every event. So note that if the alternating consists of 'Alternating a0 [(t1,a2)]' then the function is applied to a1, not to a0 (i.e. every value ai is considered alive on the interval [ti,t(i+1))

>>> let odds  = Alternating "a" [(3,"c"), (5,"e"), (7,"g")]
>>> let evens = Alternating "b" [(4,"d"), (6,"f"), (8,"h")]
>>> mergeAlternating (\_ a b -> a <> b) odds evens
[(3,"cb"),(4,"cd"),(5,"ed"),(6,"ef"),(7,"gf"),(8,"gh")]
>>> mergeAlternating (\t a b -> if t `mod` 2 == 0 then a else b) odds evens
[(3,"b"),(4,"c"),(5,"d"),(6,"e"),(7,"f"),(8,"g")]
>>> mergeAlternating (\_ a b -> a <> b) odds (Alternating "b" [(0,"d"), (5,"e"), (8,"h")])
[(0,"ad"),(3,"cd"),(5,"ee"),(7,"ge"),(8,"gh")]

Adds additional t-values in the alternating, (in sorted order). I.e. if we insert a "breakpoint" at time t the current 'a' value is used at that time.

>>> insertBreakPoints [0,2,4,6,8,10] $ Alternating "a" [(3, "c"), (5, "e"), (7,"g")]
Alternating "a" [(0,"a"),(2,"a"),(3,"c"),(4,"c"),(5,"e"),(6,"e"),(7,"g"),(8,"g"),(10,"g")]

Reverses an alternating list.

>>> reverse $ Alternating "a" [(3, "c"), (5, "e"), (7, "g")]
Alternating "g" [(7,"e"),(5,"c"),(3,"a")]

Given a function f that takes the new element y and the (current) first element x and computes the new separating element s, conses y and the the separator onto alternating list.

>>> consElemWith (\_ _ -> ".") 0 (fromNonEmptyWith @[] "," (NonEmpty.fromList [1..5]))
Alternating 0 [(".",1),(",",2),(",",3),(",",4),(",",5)]
>>> consElemWith (\_ _ -> ".") 0 (fromNonEmptyWith @[] "," (NonEmpty.fromList [1]))
Alternating 0 [(".",1)]

Uncons the Alternating, getting either just the first element (if there was only one), or the first element, the first separator, and the remaining alternating.

Given a function f that takes the (current) last element x, and the new element y, and computes the new separating element s, snocs the separator and y onto the alternating list.

>>> snocElemWith (\_ _ -> ".") (fromNonEmptyWith @[] "," (NonEmpty.fromList [1..5])) 6
Alternating 1 [(",",2),(",",3),(",",4),(",",5),(".",6)]
>>> snocElemWith (\_ _ -> ".") (fromNonEmptyWith @[] "," (NonEmpty.fromList [1])) 6
Alternating 1 [(".",6)]

Get the separators out of the alternating