# Nec

## Enums

`enum ViewLeft[a: Type] with Eq`Source
`case OneLeft(a)``case SomeLeft(a, Nec[a])`
`enum ViewRight[a: Type] with Eq`Source
`case OneRight(a)``case SomeRight(Nec[a], a)`

A datatype for pattern matching on a Nec (traversing right-to-left).

## Definitions

`def ap(f: Nec[a -> b \ ef], c: Nec[a]): Nec[b] \ ef`Source

Apply every function from `f` to every argument from `x` and return a Nec with all results. For `f = f1, f2, ...` and `x = x1, x2, ...` the results appear in the order `f1(x1), f1(x2), ..., f2(x1), f2(x2), ...`.

`def append(c1: Nec[a], c2: Nec[a]): Nec[a]`Source

Returns a new Nec formed by appending the Necs `c1` and `c2`.

`def cons(x: a, c: Nec[a]): Nec[a]`Source

Add element `x` to the left end of Nec `c`.

`def count(f: a -> Bool \ ef, c: Nec[a]): Int32 \ ef`Source

Returns the number of elements in `c` that satisfy the predicate `f`.

`def dropWhileLeft(f: a -> Bool \ ef, c: Nec[a]): List[a] \ ef`Source

Returns `c` without the longest prefix that satisfies the predicate `f`.

`def dropWhileRight(f: a -> Bool \ ef, c: Nec[a]): List[a] \ ef`Source

Returns `c` without the longest sufffix that satisfies the predicate `f`.

`def enumerator(rc: Region[r], c: Nec[a]): Iterator[(Int32, a), r, r] \ r`Source

Returns an iterator over `c` zipped with the indices of the elements.

`def equals(c1: Nec[a], c2: Nec[a]): Bool`Source

Returns `true` if and only if `c1` and `c2` and equal.

`def exists(f: a -> Bool \ ef, c: Nec[a]): Bool \ ef`Source

Returns `true` if and only if at least one element in `c` satisfies the predicate `f`.

Returns `false` if `c` is empty.

`def filter(f: a -> Bool \ ef, c: Nec[a]): List[a] \ ef`Source

Returns a list of every element in `c` that satisfies the predicate `f`.

`def filterMap(f: a -> Option[b] \ ef, c: Nec[a]): List[b] \ ef`Source

Collects the results of applying the partial function `f` to every element in `c`.

`def find(f: a -> Bool \ ef, c: Nec[a]): Option[a] \ ef`Source

Alias for `findLeft`.

`def findLeft(f: a -> Bool \ ef, c: Nec[a]): Option[a] \ ef`Source

Optionally returns the first element of `c` that satisfies the predicate `f` when searching from left to right.

`def findMap(f: a -> Option[b] \ ef, c: Nec[a]): Option[b] \ ef`Source

Returns the first non-None result of applying the partial function `f` to each element of `c`.

Returns `None` if f(c) for every element of c is `None`.

`def findRight(f: a -> Bool \ ef, c: Nec[a]): Option[a] \ ef`Source

Optionally returns the first element of `c` that satisfies the predicate `f` when searching from right to left.

`def flatMap(f: a -> Nec[b] \ ef, c: Nec[a]): Nec[b] \ ef`Source

Returns the result of applying `f` to every element in `c` and concatenating the results.

`def flatten(c: Nec[Nec[a]]): Nec[a]`Source

Returns the concatenation of the elements in `c`.

`def fold(l: Nec[a]): a`Source

Returns the result of applying `combine` to all the elements in `l`, using `empty` as the initial value.

`def foldLeft(f: b -> (a -> b \ ef), acc: b, c: Nec[a]): b \ ef`Source

Applies `f` to a start value `s` and all elements in `c` going from left to right.

That is, the result is of the form: `f(...f(f(s, x1), x2)..., xn)`.

`def foldMap(f: a -> b \ ef, c: Nec[a]): b \ ef`Source

Returns the result of mapping each element and combining the results.

`def foldRight(f: a -> (b -> b \ ef), s: b, c: Nec[a]): b \ ef`Source

Applies `f` to a start value `s` and all elements in `c` going from right to left.

That is, the result is of the form: `f(x1, ...f(xn-1, f(xn, s))...)`.

`def foldRightWithCont(f: a -> ((Unit -> b \ ef) -> b \ ef), z: b, c: Nec[a]): b \ ef`Source

Applies `f` to a start value `z` and all elements in `c` going from right to left.

That is, the result is of the form: `f(x1, ...f(xn-1, f(xn, z))...)`. A `foldRightWithCont` allows early termination by not calling the continuation.

`def forAll(f: a -> Bool \ ef, c: Nec[a]): Bool \ ef`Source

Returns `true` if and only if all elements in `c` satisfy the predicate `f`.

Returns `true` if `c` is empty.

`def forEach(f: a -> Unit \ ef, c: Nec[a]): Unit \ ef`Source

Applies `f` to every element of `c`.

`def forEachWithIndex(f: Int32 -> (a -> Unit \ ef), c: Nec[a]): Unit \ ef`Source

Applies `f` to every element of `c` along with that element's index.

`def head(c: Nec[a]): a`Source

Returns the first element of `c`.

`def indexOf(a: a, c: Nec[a]): Option[Int32]`Source

Optionally returns the position of `a` in `c`.

`def init(c: Nec[a]): List[a]`Source

Returns the list of elements in `c` without the last element.

`def intersperse(sep: a, c: Nec[a]): Nec[a]`Source

Returns `c` with `a` inserted between every two adjacent elements.

`def isSingleton(c: Nec[a]): Bool`Source

Returns true if and only if `c` is a single element Nec.

`def iterator(rc: Region[r], c: Nec[a]): Iterator[a, r, r] \ r`Source

Returns an iterator over `c`.

`def join(sep: String, c: Nec[a]): String`Source

Returns the concatenation of the string representation of each element in `c` with `sep` inserted between each element.

`def joinWith(f: a -> String \ ef, sep: String, c: Nec[a]): String \ ef`Source

Returns the concatenation of the string representation of each element in `c` according to `f` with `sep` inserted between each element.

`def last(c: Nec[a]): a`Source

Returns the last element of `c`.

`def length(c: Nec[a]): Int32`Source

Returns the length of `c`.

`def map(f: a -> b \ ef, c: Nec[a]): Nec[b] \ ef`Source

Returns the result of applying `f` to every element in `c`.

That is, the result is of the form: `f(x1) :: f(x2) :: ...`.

`def mapAccumLeft(f: s -> (a -> (s, b) \ ef), start: s, c: Nec[a]): (s, Nec[b]) \ ef`Source

`mapAccumLeft` is a stateful version of `map`. The accumulating parameter `s` is updated at each step in a left-to-right traversal.

`def mapAccumRight(f: s -> (a -> (s, b) \ ef), start: s, c: Nec[a]): (s, Nec[b]) \ ef`Source

`mapAccumRight` is a stateful version of `map`. The accumulating parameter `s` is updated at each step in a right-to-left traversal.

`def mapWithIndex(f: Int32 -> (a -> b \ ef), c: Nec[a]): Nec[b] \ ef`Source

Returns the result of applying `f` to every element in `c` along with that element's index.

That is, the result is of the form: `f(x1, 0) :: f(x2, 1) :: ...`.

`def maximum(c: Nec[a]): a`Source

Finds the largest element of `c` according to the `Order` on `a`.

`def maximumBy(cmp: a -> (a -> Comparison), c: Nec[a]): a`Source

Finds the largest element of `c` according to the given comparator `cmp`.

`def memberOf(a: a, c: Nec[a]): Bool`Source

Returns `true` if and only if `c` contains the element `a`.

`def minimum(c: Nec[a]): a`Source

Finds the smallest element of `c` according to the `Order` on `a`.

`def minimumBy(cmp: a -> (a -> Comparison), c: Nec[a]): a`Source

Finds the smallest element of `c` according to the given comparator `cmp`.

`def permutations(c: Nec[a]): Nec[List[a]]`Source

Returns all permutations of `c` in lexicographical order by element indices in `c`.

That is, `c` is the first permutation and `reverse(c)` is the last permutation.

`def range(b: Int32, e: Int32): Option[Nec[Int32]]`Source

Returns a list of all integers between `b` (inclusive) and `e` (exclusive) wrapped in `Some`.

Returns `None` if `b >= e`.

`def reduce(c: Nec[a]): a`Source

Applies `combine` to all elements in `c` until a single value is obtained.

`def reduceLeft(f: a -> (a -> a \ ef), c: Nec[a]): a \ ef`Source

Applies `f` to all elements in `c` going from left to right until a single value `v` is obtained.

That is, the result is of the form: `f(...f(f(x1, x2), x3)..., xn)`

`def reduceLeftTo(f: b -> (a -> b \ ef1), g: a -> b \ ef2, c: Nec[a]): b \ ef1 + ef2`Source

Left-associative reduction of a structure. Applies `g` to the initial element of `c` and combines it with the remainder of `c` using `f` going from left to right.

`def reduceRight(f: a -> (a -> a \ ef), c: Nec[a]): a \ ef`Source

Applies `f` to all elements in `c` going from right to left until a single value `v` is obtained.

That is, the result is of the form: `Some(f(x1, ...f(xn-2, f(xn-1, xn))...))`

`def reduceRightTo(f: a -> (b -> b \ ef1), g: a -> b \ ef2, c: Nec[a]): b \ ef1 + ef2`Source

Right-associative reduction of a structure. Applies `g` to the initial element of `c` and combines it with the remainder of `c` using `f` going from right to left.

`def replace(from: { from = a }, to: { to = a }, l: Nec[a]): Nec[a]`Source

Returns `l` with every occurrence of `from` replaced by `to`.

`def reverse(c: Nec[a]): Nec[a]`Source

Returns the reverse of `c`.

`def sequence(c: Nec[m[a]]): m[Nec[a]]`Source

Returns the result of running all the actions in the Nec `c`.

`def shuffle(rnd: Random, c: Nec[a]): Option[Nec[a]] \ IO`Source

Optionally returns the Nec `c` shuffled using the Fisher–Yates shuffle.

`def singleton(x: a): Nec[a]`Source

Return the singleton Nec with element `x`.

`def snoc(c: Nec[a], x: a): Nec[a]`Source

Add element `x` to the right end of Nec `c`.

`def sort(c: Nec[a]): Nec[a]`Source

Sort Nec `c` so that elements are ordered from low to high according to their `Order` instance.

The sort is not stable, i.e., equal elements may appear in a different order than in the input `c`.

The sort implementation is a Quicksort.

`def sortBy(f: a -> b, c: Nec[a]): Nec[a]`Source

Sort Nec `c` so that elements are ordered from low to high according to the `Order` instance for the values obtained by applying `f` to each element.

The sort is not stable, i.e., equal elements may appear in a different order than in the input `c`.

The sort implementation is a Quicksort.

`def sortWith(cmp: a -> (a -> Comparison), c: Nec[a]): Nec[a]`Source

Sort Nec `c` so that elements are ordered from low to high according to the comparison function `cmp`.

The sort is not stable, i.e., equal elements may appear in a different order than in the input `c`.

The sort implementation is a Quicksort.

`def subsequences(c: Nec[a]): Nec[List[a]]`Source

Returns all subsequences of `l` in lexicographical order by element indices in `l`.

That is, `l` is the first subsequence and `Nil` is the last subsequence.

`def sum(c: Nec[Int32]): Int32`Source

Returns the sum of all elements in the Nec `c`.

`def sumWith(f: a -> Int32 \ ef, c: Nec[a]): Int32 \ ef`Source

Returns the sum of all elements in the Nec `c` according to the function `f`.

`def tail(c: Nec[a]): List[a]`Source

Returns all elements in `c` without the first element.

`def takeWhileLeft(f: a -> Bool \ ef, c: Nec[a]): List[a] \ ef`Source

Returns the longest prefix of `c` that satisfies the predicate `f`.

`def takeWhileRight(f: a -> Bool \ ef, c: Nec[a]): List[a] \ ef`Source

Returns the longest prefix of `c` that satisfies the predicate `f`.

`def toArray(rc: Region[r], c: Nec[a]): Array[a, r] \ r`Source

Returns the Nec `c` as an array.

`def toList(c: Nec[a]): List[a]`Source

Returns `c` as a list.

`def toMap(c: Nec[(a, b)]): Map[a, b]`Source

Returns the Nec of pairs `c` that represents an association list as a map.

If `c` contains multiple mappings with the same key, `toMap` does not make any guarantees about which mapping will be in the resulting map.

`def toMapWith(f: a -> b, l: Nec[a]): Map[a, b]`Source

Returns a map with elements of `l` as keys and `f` applied as values.

If `l` contains multiple mappings with the same key, `toMapWith` does not make any guarantees about which mapping will be in the resulting map.

`def toMutDeque(rc: Region[r], c: Nec[a]): MutDeque[a, r] \ r`Source

Returns `c` as a MutDeque.

`def toMutList(rc1: Region[r], c: Nec[a]): MutList[a, r] \ r`Source

Returns `c` as a mutable list.

`def toSet(c: Nec[a]): Set[a]`Source

Returns the list `c` as a set.

`def toVector(c: Nec[a]): Vector[a]`Source

Returns the Nec `c` as a vector.

`def traverse(f: a -> m[b] \ ef, c: Nec[a]): m[Nec[b]] \ ef`Source

Returns the result of applying the applicative mapping function `f` to all the elements of the Nec `c`.

`def unzip(c: Nec[(a, b)]): (Nec[a], Nec[b])`Source

Returns a pair of Necs, the first containing all first components in `c` and the second containing all second components in `c`.

`def viewLeft(c: Nec[a]): ViewLeft[a]`Source

Deconstruct a Nec from left-to-right.

Returns `ViewLeft.SomeLeft(x, rs)` if the Nec has at least two elements, where `x` is the leftmost element of the Nec `c`, and `rs` is the rest of the Nec.

Returns `ViewLeft.OneLeft` if the Nec has a single element.

`def viewRight(c: Nec[a]): ViewRight[a]`Source

Deconstruct a Nec from right-to-left.

Returns `ViewRight.SomeRight(rs, x)` if the Nec has at least two elements, where `x` is the rightmost element of the Nec `c`, and `rs` is the front of the Nec.

Returns `ViewRight.OneRight` if the Nec has a single element.

`def zip(c1: Nec[a], c2: Nec[b]): Nec[(a, b)]`Source

Returns a Nec where the element at index `i` is `(a, b)` where `a` is the element at index `i` in `c1` and `b` is the element at index `i` in `c2`.

If either `c1` or `c2` becomes depleted, then no further elements are added to the resulting Nec.

`def zipWith(f: a -> (b -> c \ ef), c1: Nec[a], c2: Nec[b]): Nec[c] \ ef`Source

Returns a Nec where the element at index `i` is `f(a, b)` where `a` is the element at index `i` in `c1` and `b` is the element at index `i` in `c2`.

If either `c1` or `c2` becomes depleted, then no further elements are added to the resulting Nec.

`def zipWithA(f: a -> (b -> f[c] \ ef), xs: Nec[a], ys: Nec[b]): f[Nec[c]] \ ef`Source

Generalize `zipWith` to an applicative functor `f`.

`def zipWithIndex(c: Nec[a]): Nec[(Int32, a)]`Source

Returns a Nec where each element `e` is mapped to `(i, e)` where `i` is the index of `e`.