Nec

enum Nec[t: Type]Source

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

The NonEmpty Chain type.

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

instance Applicative[Nec]Source

instance Eq[Nec[a]] with Eq[a]Source

instance Foldable[Nec]Source

instance Functor[Nec]Source

instance Hash[Nec[a]] with Hash[a]Source

instance Iterable[Nec[a]]Source

instance Monad[Nec]Source

instance MonadZip[Nec]Source

instance Order[Nec[a]] with Order[a]Source

instance Reducible[Nec]Source

instance SemiGroup[Nec[a]]Source

instance ToJava[Nec[a]]Source

instance ToString[Nec[a]] with ToString[a]Source

instance Traversable[Nec]Source

instance UnorderedFoldable[Nec]Source

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 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.

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 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 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] with Eq[a] 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 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(x1, 0) :: f(x2, 1) :: ....

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 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: 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(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]] \ NonDet 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 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] 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.