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)]

Unsnoc the alternating, getting either just the last element (if there was only one), or the "init" of the alternating, the last separator, and the last element the init would be the alternating without its last element.

Given a function that computes the new separator, combinges the two alternatings.

>>> let alt1 = fromNonEmptyWith "," (NonEmpty.fromList [1..2]) :: Alternating [] String Int
>>> let alt2 = fromNonEmptyWith "," (NonEmpty.fromList [3..4])
>>> concatAlternatingsWith (\x y -> "new sep " <> show x <> show y) alt1 alt2
Alternating 1 [(",",2),("new sep 23",3),(",",4)]

Get the separators out of the alternating