repeat x is the infinite list x, x, x, ….

iterate f x is x, f x, f (f x), ….

The integers from n upward: n, n+1, n+2, ….

Turn a finite strict List into a LazyList.

[lo .. hi] : lo, succ lo, …, hi. enumDist lo hi (unit steps from lo up to hi) is 0 both for [a .. a] and for an empty [b .. a] ; the two are told apart by enumDist hi lo, 0 only when hi == lo.

[lo .. hi[ (or [lo .. hi)) : up to but EXCLUDING hi ; empty when hi <= lo.

[a, b .. c] : a, then a step of b - a at a time, while within the bound c (inclusive). Direction from a vs b ; step 0 refused, as for List.

[a, b .. c[ (or [a, b .. c)) : as enumFromThenTo, EXCLUDING c.

[e ..] : the range e, succ e, … with no bound — only a LazyList can hold it. It stops where the TYPE stops (KB-200) : never on Int or Nat, at U+10FFFF on Char.

[a, b ..] : the stepped range a, a + (b - a), … with no bound. Step 0 is refused as for List ; the direction is read from a vs b, and the range stops where the type stops — [5, 3 ..] : LazyList Nat is 5, 3, 1 then ends, [10, 8 ..] : LazyList Int never ends.

The first element, if any.

Everything after the first element, if any.

take n xs is the first n elements (fewer if the list is shorter), still LAZY: elements are produced one by one as the result is consumed (head (take 1000000 xs) forces ONE cell). Like Haskell's take and Idris's lazy operations — a take that returned a strict List would force n cells at the call, defeating the point of a lazy pipeline. For a strict List, convert with toList. n : Nat, the same count type as length.

drop n xs discards the first n elements (forcing them to reach the suffix), and returns the still-lazy remainder.

The longest prefix whose elements satisfy p, still LAZY (produced as consumed, like take).

Force the WHOLE lazy list into a strict List — the explicit conversion (diverges on an infinite list; pair it with take/takeWhile first).

Apply f to every element, lazily.

Keep the elements satisfying p, lazily.

Concatenate two LazyLists (the first should be finite).

The single-element LazyList.

The empty LazyList.

Map each element to a LazyList and concatenate the results, lazily. List comprehensions [ e | x <- xs, … ] over a LazyList use this, so they stay lazy and may SHORT-CIRCUIT: consuming only head (or take 1) of the result forces only as much of the input as needed to produce the first element.

STACK-SAFE: skipping arbitrarily many empty mappings (the deep search of an [ e | … ] that short-circuits late) runs in O(1) stack instead of overflowing.

Flatten a LazyList of LazyLists, lazily (same short-circuit behaviour).

zipWith f xs ys combines elements pairwise, stopping at the shorter list.

Right fold, STRICT in the accumulator: oppi evaluates arguments before the call, so f receives the already-folded rest — this ALWAYS traverses the whole list and DIVERGES on an infinite one (unlike Haskell's foldr, whose laziness lets f stop early). For an early-exit fold, use foldrLazy.

Right fold that can stop (the twin of List.foldrLazy, and the LazyList definition of the Foldable method): f receives the fold of the tail suspended (Lazy b), so the fold stops as soon as f does not read it, and terminates on an infinite list; the seed z is read only if the fold reaches the end. foldrLazy (&&) True (repeat False) is False.

Is p true of SOME element? Stops at the first hit — any p xs on an infinite xs terminates as soon as a witness appears.

Is p true of EVERY element? Stops at the first counter-example.

The first element satisfying p, if any (stops there).

Is x an element? Stops at the first occurrence.

The number of elements, as a Nat — FORCES the whole list (diverges on an infinite one); observe an infinite list through take first.

Left fold. Diverges on an infinite list (it must reach the end).

Is the list empty? Forces only the first cell.

The list in reverse order — FORCES the whole list.

The remainder after the longest prefix whose elements satisfy p (the companion of takeWhile).

Split after the first n elements: (take n xs, drop n xs).

The element at position n (0-based), or Nothing when out of range.

Pair up elements of two lists, lazily (truncating to the shorter).

Zip three lists with a function, lazily (truncating to the shortest).

n copies of a value.

Sum of the elements (0 for the empty list) — FORCES the whole list.

Product of the elements (1 for the empty list) — FORCES the whole list.

Largest element, or Nothing if empty — FORCES the whole list.

Smallest element, or Nothing if empty — FORCES the whole list.

Is an element present, using a supplied equality test? Stops at the first occurrence.

Look up a key in an association list (stops at the first match).

Apply a partial function to every element, keeping the successes, lazily.

Drop the Nothings, keeping the Just values, lazily.

The last element, or Nothing if empty — FORCES the whole list.

All but the last element, or Nothing if empty, lazily.

Insert sep between consecutive elements, lazily.

Join monoid values, inserting sep between consecutive elements — FORCES the whole list.

The 0-based index of the first element satisfying the predicate (stops there).

The 0-based index of the first occurrence of a value (stops there).

Split into (elements satisfying p, the rest), each LAZY and in order.

(longest prefix all satisfying p, the remainder) = (takeWhile p xs, dropWhile p xs).

The prefix up to the first element satisfying p, and the rest: break p = span (not . p).

Insert into a sorted list, keeping it sorted (lazily past the insertion).

Insert with a supplied comparator, keeping the list sorted.

Sort into ascending order (stable insertion sort) — FORCES the whole list.

Sort by a supplied comparator (stable) — FORCES the whole list.

Sort by a key projection, computing each key once — FORCES the whole list.

Remove duplicates using a supplied equality, keeping the first occurrence, lazily.

Remove duplicates (by ==), keeping the first occurrence, lazily.

Group consecutive elements deemed equal by the predicate, lazily.

Group consecutive equal elements (by ==), lazily.

Left scan: the running accumulator after each step, seeded with z, lazily (one longer than the input).

Right scan (always non-empty) — FORCES the whole list.

Build a list from a seed, lazily: f returns Just (element, next seed) to emit, or Nothing to stop (it may never stop).

Left fold over a NON-empty list, seeded with its first element; Nothing for the empty list — FORCES the whole list.

Right fold over a NON-empty list; Nothing for the empty list — FORCES the whole list.

All suffixes, longest first, lazily: tails [1, 2] = [[1, 2], [2], []].

Is the first list a prefix of the second? Stops at the first difference.

Is the first list a suffix of the second? FORCES both lists.

Is the first list a contiguous sub-sequence of the second? Stops at the first occurrence.

The head as a Maybe (Nothing for the empty list).

A Just becomes a one-element list, a Nothing the empty list.

Keep only the Left values, lazily.

Keep only the Right values, lazily.

Split a list of Eithers into (the Lefts, the Rights), each lazy.

Safe subscript xs[i]? — Nothing if i is out of range.

Direct subscript xs[i] — panics if i is out of range.

set xs i v — the list with position i set to v (unchanged if i is out of range), lazily.