Maps over a Traversable, with additional parameters indicating whether an item is the first or last (or both) in the list.

>>> let f x isFirst isLast = star isFirst ++ x ++ star isLast; star b = if b then "*" else "" in withFirstLast f ["foo", "bar", "baz"]
["*foo", "bar", "baz*"]

andFirstLast = withFirstLast (,,)

Maps over a Traversable, with additional parameters indicating the previous and next elements.

The second (or third) parameter to the map function is Nothing when called for the first (or last) item, otherwise it's Just the previous (or next) item.

>>> let f x prvMay nxtMay = maybe "*" (cmp x) prvMay ++ x ++ maybe "*" (cmp x) nxtMay; cmp x y = show $ compare x y in withPrevNext f ["foo", "bar", "baz"]
["*fooGT","LTbarLT","GTbaz*"]

andPrevNext = withPrevNext (,,)

maps an InjectedFn over a Traversable type t, turning a t a into a t b and preserving the structure of t.

Parameters (as defined in the InjectedFn) are passed to a map function (embedded in the InjectedFn), in addition to the elements of the Traversable.

like mapM, but with an InjectedFn.

like mapM_ (which is like mapM but ignores the results), but with an InjectedFn.

like foldMap, but with an InjectedFn

Represents a function from a, plus a number of injected values, to b.

Used by mapWith (& related), which maps over a Traversable, injecting the additional values as it goes.

Constructed by combining a map function with Injectors using the ^-> and <-^ operators.

The sequence:

(a -> i1 -> i2 -> ... -> in -> b) op1 inj1 op2 inj2 ... opn injn

where:

• each op is ^-> or <-^; and
• each inj is an Injector

produces an InjectedFn a b, with n injected values.

An Injectable is (recursively) either:

• a function (a -> i -> b); or
• an InjectedFn a (i -> b), created by Injectable op Injector

inject True if the item is at the limit:

• from the left: if it's the first item
• from the right: if it's the last item

else inject False.

inject Just the adjacent item:

• from the left: the previous item, except for the first item
• from the right: the next item, except for the last item. (The "previous from the right" is the "next".)

inject Nothing if there is no adjacent item (i.e. for the first / last).

inject the item index:

• from the left: the first item is 0, the second 1, etc.
• from the right: the last item is 0, the penultimate 1, etc.

Inject each given element in turn:

• from the left: the first element will be injected for the first item in the Traversable.
• from the right: the first element will be injected for the last item in the Traversable.

As a result of laziness, it is not always an error if there are not enough elements, for example:

>>> drop 1 $ mapWith ((\_ i -> i) <-^ eltFrom [8,2]) "abc"
[2,8]

a safe version of eltFrom. Injects Just each given element in turn, or Nothing after they've been exhausted.

a safe version of eltFrom. Injects each given element in turn, or the default after they've been exhausted.

isLim, from the left.

isLim, from the right.

adjElt, from the left.

adjElt, from the right.

Injectors have an initial state and a generate function.

For each item in the Traversable, the generate function can use both:

• the item from the Traversable, and
• the current state

to determine both:

• the injection value, and
• the new state.

The first value to inject is determined by a first call to the generate function. The first call to the generate function is with the first (if combined with ^->) or last (if combined with <-^) item from the Traversable and the initial state.

For example:

>>> funnyNext a s = (a + s, a + 1)
>>> funnyInjector = Injector funnyNext 17
>>> mapWith ((\_ i -> i) ^-> funnyInjector) [4,8,3]
[21,13,12]

>>> mapWith ((\_ i -> i) <-^ funnyInjector) [4,8,3]
[13,12,20]

More usefully, this would allow for e.g. the prior two elements:

prev2Inj = Injector (\x i@(prev1May, prev2May) -> (i, (Just x, prev1May))) (Nothing, Nothing)

or random values, etc.