Nec

Type of non-empty chains, and its functions.

enum Nec[t: Type]Source

case NecOne(t)

case Nec(Nec[t], Nec[t])

Type of non-empty chains.

A chain is a list represented as an unbalanced binary tree. It supports efficient append and "snoc" - appending elements at the tail of the list.

Note - the constructors NecOne and Nec should not be used directly.

Instances

Applicative, Eq, Foldable, ForEach, Formattable, Functor, Hash, Iterable, Monad, MonadZip, Order, Reducible, SemiGroup, ToJava, ToString, Traversable, UnorderedFoldable

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 equals(c1: Nec[a], c2: Nec[a]): Bool with Eq[a]§ 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.

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 with Monoid[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 with Monoid[b]§ 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 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.

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 get(i: Int32, c: Nec[a]): a§ Source

Returns the element at position i in the non-empty chain c.

Throws IndexOutOfBoundsException if the index is out of bounds.

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

Returns the first element of c.

def indexOf(a: a, c: Nec[a]): Option[Int32] with Eq[a]§ Source

Optionally returns the position of a in c.

def indices(c: Nec[a]): Range[Int32]§ Source

Returns a range of all valid indices of the non-empty chain c.

def indicesOf(x: a, c: Nec[a]): Vector[Int32] with Eq[a]§ Source

Returns the positions of all occurrences of x 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 with ToString[a]§ 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 number of elements in 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(0, x0) :: f(1, x1) :: ....

def maximum(c: Nec[a]): a with Order[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 with Eq[a]§ Source

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

def minimum(c: Nec[a]): a with Order[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 nth(i: Int32, c: Nec[a]): Option[a]§ Source

Optionally returns the element at position i in the non-empty chain c.

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 with SemiGroup[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: 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(src: { src = a }, dst: { dst = a }, l: Nec[a]): Nec[a] with Eq[a]§ Source

Returns l with every occurrence of src replaced by dst.

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

Returns the reverse of c.

def sequence(c: Nec[m[a]]): m[Nec[a]] with Applicative[m]§ Source

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

def shuffle(c: Nec[a]): Option[Nec[a]] \ Shuffle§ 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 size(c: Nec[a]): Int32§ Source

Returns the number of elements in c.

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] with Order[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] with Order[b]§ 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] with Order[a]§ 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] with Order[a]§ 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 toSet(c: Nec[a]): Set[a] with Order[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 with Applicative[m]§ 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 with Applicative[f]§ 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.