final class NonEmptyChainOps[A] extends AnyVal with NonEmptyCollection[A, Chain, NonEmptyChain]
- Alphabetic
- By Inheritance
- NonEmptyChainOps
- NonEmptyCollection
- AnyVal
- Any
- Hide All
- Show All
- Public
- Protected
Instance Constructors
- new NonEmptyChainOps(value: NonEmptyChain[A])
Value Members
- final def !=(arg0: Any): Boolean
- Definition Classes
- Any
- final def ##: Int
- Definition Classes
- Any
- final def ++[A2 >: A](c: NonEmptyChain[A2]): NonEmptyChain[A2]
Alias for concat
- final def ++:[A2 >: A](c: Chain[A2]): NonEmptyChain[A2]
Alias for
prependChain
Alias for
prependChain
scala> import cats.data.NonEmptyChain scala> val nec = NonEmptyChain(4, 5, 6) scala> Chain(1, 2, 3) ++: nec res0: cats.data.NonEmptyChain[Int] = Chain(1, 2, 3, 4, 5, 6)
- final def +:[A2 >: A](a: A2): NonEmptyChain[A2]
Alias for prepend.
- final def :+[A2 >: A](a: A2): NonEmptyChain[A2]
Alias for append.
- final def :++[A2 >: A](c: Chain[A2]): NonEmptyChain[A2]
Alias for
appendChain
Alias for
appendChain
scala> import cats.data.NonEmptyChain scala> val nec = NonEmptyChain(1, 2, 4, 5) scala> nec :++ Chain(3, 6, 9) res0: cats.data.NonEmptyChain[Int] = Chain(1, 2, 4, 5, 3, 6, 9)
- final def ==(arg0: Any): Boolean
- Definition Classes
- Any
- final def append[A2 >: A](a: A2): NonEmptyChain[A2]
Returns a new Chain consisting of this followed by
a
.Returns a new Chain consisting of this followed by
a
. O(1) runtime.- Definition Classes
- NonEmptyChainOps → NonEmptyCollection
- final def appendChain[A2 >: A](c: Chain[A2]): NonEmptyChain[A2]
Appends the given chain in O(1) runtime.
- final def asInstanceOf[T0]: T0
- Definition Classes
- Any
- final def collect[B](pf: PartialFunction[A, B]): Chain[B]
Returns a new
Chain
containing all elements where the result ofpf
is final defined.Returns a new
Chain
containing all elements where the result ofpf
is final defined.scala> import cats.data.NonEmptyChain scala> import cats.implicits._ scala> val nec = NonEmptyChain(4, 5, 6).map(n => if (n % 2 == 0) Some(n) else None) scala> nec.collect { case Some(n) => n } res0: cats.data.Chain[Int] = Chain(4, 6)
- Definition Classes
- NonEmptyChainOps → NonEmptyCollection
- final def collectFirst[B](pf: PartialFunction[A, B]): Option[B]
Finds the first element of this
NonEmptyChain
for which the given partial function is defined, and applies the partial function to it. - final def collectFirstSome[B](f: (A) => Option[B]): Option[B]
Like
collectFirst
fromscala.collection.Traversable
but takesA => Option[B]
instead ofPartialFunction
s. - final def concat[A2 >: A](c: NonEmptyChain[A2]): NonEmptyChain[A2]
Concatenates this with
c
in O(1) runtime.Concatenates this with
c
in O(1) runtime.scala> import cats.data.NonEmptyChain scala> val nec = NonEmptyChain(1, 2, 4, 5) scala> nec ++ NonEmptyChain(7, 8) res0: cats.data.NonEmptyChain[Int] = Chain(1, 2, 4, 5, 7, 8)
- final def contains(a: A)(implicit A: kernel.Eq[A]): Boolean
Tests if some element is contained in this chain.
Tests if some element is contained in this chain.
scala> import cats.data.NonEmptyChain scala> import cats.implicits._ scala> val nec = NonEmptyChain(4, 5, 6) scala> nec.contains(5) res0: Boolean = true
- final def deleteFirst(f: (A) => Boolean): Option[(A, Chain[A])]
Yields to Some(a, Chain[A]) with
a
removed wheref
holds for the first time, otherwise yields None, ifa
was not found Traverses only untila
is found. - final def distinct[AA >: A](implicit O: kernel.Order[AA]): NonEmptyChain[AA]
Remove duplicates.
Remove duplicates. Duplicates are checked using
Order[_]
instance.- Definition Classes
- NonEmptyChainOps → NonEmptyCollection
- final def exists(f: (A) => Boolean): Boolean
Tests whether a predicate holds for at least one element of this chain.
Tests whether a predicate holds for at least one element of this chain.
- Definition Classes
- NonEmptyChainOps → NonEmptyCollection
- final def filter(p: (A) => Boolean): Chain[A]
Filters all elements of this chain that do not satisfy the given predicate.
Filters all elements of this chain that do not satisfy the given predicate.
- Definition Classes
- NonEmptyChainOps → NonEmptyCollection
- final def filterNot(p: (A) => Boolean): Chain[A]
Filters all elements of this chain that satisfy the given predicate.
Filters all elements of this chain that satisfy the given predicate.
- Definition Classes
- NonEmptyChainOps → NonEmptyCollection
- final def find(f: (A) => Boolean): Option[A]
Returns the first value that matches the given predicate.
Returns the first value that matches the given predicate.
- Definition Classes
- NonEmptyChainOps → NonEmptyCollection
- final def flatMap[B](f: (A) => NonEmptyChain[B]): NonEmptyChain[B]
Applies the supplied function to each element and returns a new NonEmptyChain from the concatenated results
- final def foldLeft[B](b: B)(f: (B, A) => B): B
Left-associative fold using f.
Left-associative fold using f.
- Definition Classes
- NonEmptyChainOps → NonEmptyCollection
- final def foldRight[B](z: B)(f: (A, B) => B): B
Right-associative fold using f.
- final def forall(p: (A) => Boolean): Boolean
Tests whether a predicate holds for all elements of this chain.
Tests whether a predicate holds for all elements of this chain.
- Definition Classes
- NonEmptyChainOps → NonEmptyCollection
- def getClass(): Class[_ <: AnyVal]
- Definition Classes
- AnyVal → Any
- final def groupBy[B](f: (A) => B)(implicit B: kernel.Order[B]): NonEmptyMap[B, NonEmptyChain[A]]
Groups elements inside this
NonEmptyChain
according to theOrder
of the keys produced by the given mapping function.Groups elements inside this
NonEmptyChain
according to theOrder
of the keys produced by the given mapping function.scala> import cats.data.{NonEmptyChain, NonEmptyMap} scala> import cats.implicits._ scala> val nec = NonEmptyChain(12, -2, 3, -5) scala> val expectedResult = NonEmptyMap.of(false -> NonEmptyChain(-2, -5), true -> NonEmptyChain(12, 3)) scala> val result = nec.groupBy(_ >= 0) scala> result === expectedResult res0: Boolean = true
- final def groupByNem[B](f: (A) => B)(implicit B: kernel.Order[B]): NonEmptyMap[B, NonEmptyChain[A]]
Groups elements inside this
NonEmptyChain
according to theOrder
of the keys produced by the given mapping function.Groups elements inside this
NonEmptyChain
according to theOrder
of the keys produced by the given mapping function.scala> import cats.data.{NonEmptyChain, NonEmptyMap} scala> import cats.implicits._ scala> val nec = NonEmptyChain(12, -2, 3, -5) scala> val expectedResult = NonEmptyMap.of(false -> NonEmptyChain(-2, -5), true -> NonEmptyChain(12, 3)) scala> val result = nec.groupByNem(_ >= 0) scala> result === expectedResult res0: Boolean = true
- Definition Classes
- NonEmptyChainOps → NonEmptyCollection
- final def groupMap[K, B](key: (A) => K)(f: (A) => B)(implicit K: kernel.Order[K]): NonEmptyMap[K, NonEmptyChain[B]]
Groups elements inside this
NonEmptyChain
according to theOrder
of the keys produced by the given key function.Groups elements inside this
NonEmptyChain
according to theOrder
of the keys produced by the given key function. And each element in a group is transformed into a value of type B using the mapping function.scala> import cats.data.{NonEmptyChain, NonEmptyMap} scala> import cats.implicits._ scala> val nec = NonEmptyChain(12, -2, 3, -5) scala> val expectedResult = NonEmptyMap.of(false -> NonEmptyChain("-2", "-5"), true -> NonEmptyChain("12", "3")) scala> val result = nec.groupMap(_ >= 0)(_.toString) scala> result === expectedResult res0: Boolean = true
- final def groupMapNem[K, B](key: (A) => K)(f: (A) => B)(implicit K: kernel.Order[K]): NonEmptyMap[K, NonEmptyChain[B]]
Groups elements inside this
NonEmptyChain
according to theOrder
of the keys produced by the given key function.Groups elements inside this
NonEmptyChain
according to theOrder
of the keys produced by the given key function. And each element in a group is transformed into a value of type B using the mapping function.scala> import cats.data.{NonEmptyChain, NonEmptyMap} scala> import cats.implicits._ scala> val nec = NonEmptyChain(12, -2, 3, -5) scala> val expectedResult = NonEmptyMap.of(false -> NonEmptyChain("-2", "-5"), true -> NonEmptyChain("12", "3")) scala> val result = nec.groupMapNem(_ >= 0)(_.toString) scala> result === expectedResult res0: Boolean = true
- final def groupMapReduce[K, B](key: (A) => K)(f: (A) => B)(implicit K: kernel.Order[K], B: kernel.Semigroup[B]): NonEmptyMap[K, B]
Groups elements inside this
NonEmptyChain
according to theOrder
of the keys produced by the given key function.Groups elements inside this
NonEmptyChain
according to theOrder
of the keys produced by the given key function. Then each element in a group is transformed into a value of type B using the mapping function. And finally they are all reduced into a single value using theirSemigroup
scala> import cats.data.{NonEmptyChain, NonEmptyMap} scala> import cats.implicits._ scala> val nec = NonEmptyChain("Hello", "World", "Goodbye", "World") scala> val expectedResult = NonEmptyMap.of("goodbye" -> 1, "hello" -> 1, "world" -> 2) scala> val result = nec.groupMapReduce(_.trim.toLowerCase)(_ => 1) scala> result === expectedResult res0: Boolean = true
- final def groupMapReduceNem[K, B](key: (A) => K)(f: (A) => B)(implicit K: kernel.Order[K], B: kernel.Semigroup[B]): NonEmptyMap[K, B]
Groups elements inside this
NonEmptyChain
according to theOrder
of the keys produced by the given key function.Groups elements inside this
NonEmptyChain
according to theOrder
of the keys produced by the given key function. Then each element in a group is transformed into a value of type B using the mapping function. And finally they are all reduced into a single value using theirSemigroup
scala> import cats.data.{NonEmptyChain, NonEmptyMap} scala> import cats.implicits._ scala> val nec = NonEmptyChain("Hello", "World", "Goodbye", "World") scala> val expectedResult = NonEmptyMap.of("goodbye" -> 1, "hello" -> 1, "world" -> 2) scala> val result = nec.groupMapReduceNem(_.trim.toLowerCase)(_ => 1) scala> result === expectedResult res0: Boolean = true
- final def groupMapReduceWith[K, B](key: (A) => K)(f: (A) => B)(combine: (B, B) => B)(implicit K: kernel.Order[K]): NonEmptyMap[K, B]
Groups elements inside this
NonEmptyChain
according to theOrder
of the keys produced by the given key function.Groups elements inside this
NonEmptyChain
according to theOrder
of the keys produced by the given key function. Then each element in a group is transformed into a value of type B using the mapping function. And finally they are all reduced into a single value using the provided combine function.scala> import cats.data.{NonEmptyChain, NonEmptyMap} scala> import cats.implicits._ scala> val nec = NonEmptyChain("Hello", "World", "Goodbye", "World") scala> val expectedResult = NonEmptyMap.of("goodbye" -> 1, "hello" -> 1, "world" -> 2) scala> val result = nec.groupMapReduceWith(_.trim.toLowerCase)(_ => 1)(_ + _) scala> result === expectedResult res0: Boolean = true
- final def groupMapReduceWithNem[K, B](key: (A) => K)(f: (A) => B)(combine: (B, B) => B)(implicit K: kernel.Order[K]): NonEmptyMap[K, B]
Groups elements inside this
NonEmptyChain
according to theOrder
of the keys produced by the given key function.Groups elements inside this
NonEmptyChain
according to theOrder
of the keys produced by the given key function. Then each element in a group is transformed into a value of type B using the mapping function. And finally they are all reduced into a single value using the provided combine function.scala> import cats.data.{NonEmptyChain, NonEmptyMap} scala> import cats.implicits._ scala> val nec = NonEmptyChain("Hello", "World", "Goodbye", "World") scala> val expectedResult = NonEmptyMap.of("goodbye" -> 1, "hello" -> 1, "world" -> 2) scala> val result = nec.groupMapReduceWithNem(_.trim.toLowerCase)(_ => 1)(_ + _) scala> result === expectedResult res0: Boolean = true
- final def grouped(size: Int): Iterator[NonEmptyChain[A]]
Partitions elements in fixed size
NonEmptyChain
s.Partitions elements in fixed size
NonEmptyChain
s.scala> import cats.data.NonEmptyChain scala> import cats.implicits._ scala> val nel = NonEmptyChain.of(12, -2, 3, -5) scala> val expectedResult = List(NonEmptyChain.of(12, -2), NonEmptyChain.of(3, -5)) scala> val result = nel.grouped(2) scala> result.toList === expectedResult res0: Boolean = true
- Definition Classes
- NonEmptyChainOps → NonEmptyCollection
- final def head: A
Returns the first element of this NonEmptyChain.
Returns the first element of this NonEmptyChain. Amortized O(1).
- Definition Classes
- NonEmptyChainOps → NonEmptyCollection
- final def init: Chain[A]
Returns all but the last element of this NonEmptyChain.
Returns all but the last element of this NonEmptyChain. Amortized O(1).
- Definition Classes
- NonEmptyChainOps → NonEmptyCollection
- final def initLast: (Chain[A], A)
Returns the init and last of this NonEmptyChain.
Returns the init and last of this NonEmptyChain. Amortized O(1).
- final def isInstanceOf[T0]: Boolean
- Definition Classes
- Any
- final def iterator: Iterator[A]
- Definition Classes
- NonEmptyChainOps → NonEmptyCollection
- final def last: A
Returns the last element of this NonEmptyChain.
Returns the last element of this NonEmptyChain. Amortized O(1).
- Definition Classes
- NonEmptyChainOps → NonEmptyCollection
- final def length: Long
Returns the number of elements in this chain.
- final def map[B](f: (A) => B): NonEmptyChain[B]
Applies the supplied function to each element and returns a new NonEmptyChain.
Applies the supplied function to each element and returns a new NonEmptyChain.
- Definition Classes
- NonEmptyChainOps → NonEmptyCollection
- final def prepend[A2 >: A](a: A2): NonEmptyChain[A2]
Returns a new NonEmptyChain consisting of
a
followed by this.Returns a new NonEmptyChain consisting of
a
followed by this. O(1) runtime.- Definition Classes
- NonEmptyChainOps → NonEmptyCollection
- final def prependChain[A2 >: A](c: Chain[A2]): NonEmptyChain[A2]
Prepends the given chain in O(1) runtime.
- final def reduce[AA >: A](implicit S: kernel.Semigroup[AA]): AA
Reduce using the Semigroup of A
Reduce using the Semigroup of A
- Definition Classes
- NonEmptyChainOps → NonEmptyCollection
- final def reduceLeft(f: (A, A) => A): A
Left-associative reduce using f.
Left-associative reduce using f.
scala> import cats.data.NonEmptyChain scala> val nec = NonEmptyChain(4, 5, 6) scala> nec.reduceLeft(_ + _) res0: Int = 15
- final def reduceLeftTo[B](f: (A) => B)(g: (B, A) => B): B
Apply
f
to the "initial element" of this chain and lazily combine it with every other value using the given functiong
.Apply
f
to the "initial element" of this chain and lazily combine it with every other value using the given functiong
.scala> import cats.data.NonEmptyChain scala> val nec = NonEmptyChain(4, 5, 6) scala> nec.reduceLeftTo(_.toString)((acc, cur) => acc + cur.toString) res0: String = 456
- final def reduceRight(f: (A, A) => A): A
Right-associative reduce using f.
Right-associative reduce using f.
scala> import cats.data.NonEmptyChain scala> val nec = NonEmptyChain(4, 5, 6) scala> nec.reduceRight(_ + _) res0: Int = 15
- final def reduceRightTo[B](f: (A) => B)(g: (A, B) => B): B
Apply
f
to the "initial element" of this chain and lazily combine it with every other value using the given functiong
.Apply
f
to the "initial element" of this chain and lazily combine it with every other value using the given functiong
.scala> import cats.data.NonEmptyChain scala> val nec = NonEmptyChain(4, 5, 6) scala> nec.reduceRightTo(_.toString)((cur, acc) => acc + cur.toString) res0: String = 654
- final def reverse: NonEmptyChain[A]
Reverses this
NonEmptyChain
Reverses this
NonEmptyChain
- Definition Classes
- NonEmptyChainOps → NonEmptyCollection
- final def reverseIterator: Iterator[A]
- final def show[AA >: A](implicit AA: Show[AA]): String
- Definition Classes
- NonEmptyChainOps → NonEmptyCollection
- final def sortBy[B](f: (A) => B)(implicit B: kernel.Order[B]): NonEmptyChain[A]
- Definition Classes
- NonEmptyChainOps → NonEmptyCollection
- final def sorted[AA >: A](implicit AA: kernel.Order[AA]): NonEmptyChain[AA]
- Definition Classes
- NonEmptyChainOps → NonEmptyCollection
- final def tail: Chain[A]
Returns all but the first element of this NonEmptyChain.
Returns all but the first element of this NonEmptyChain. Amortized O(1).
- Definition Classes
- NonEmptyChainOps → NonEmptyCollection
- final def toChain: Chain[A]
Converts this chain to a
Chain
- final def toNem[T, V](implicit ev: <:<[A, (T, V)], order: kernel.Order[T]): NonEmptyMap[T, V]
- Definition Classes
- NonEmptyChainOps → NonEmptyCollection
- final def toNes[B >: A](implicit order: kernel.Order[B]): NonEmptySet[B]
- Definition Classes
- NonEmptyChainOps → NonEmptyCollection
- final def toNonEmptyList: NonEmptyList[A]
Converts this chain to a
NonEmptyList
.Converts this chain to a
NonEmptyList
.scala> import cats.data.NonEmptyChain scala> val nec = NonEmptyChain(1, 2, 3, 4, 5) scala> nec.toNonEmptyList res0: cats.data.NonEmptyList[Int] = NonEmptyList(1, 2, 3, 4, 5)
- final def toNonEmptyVector: NonEmptyVector[A]
Converts this chain to a
NonEmptyVector
.Converts this chain to a
NonEmptyVector
.scala> import cats.data.NonEmptyChain scala> val nec = NonEmptyChain(1, 2, 3, 4, 5) scala> nec.toNonEmptyVector res0: cats.data.NonEmptyVector[Int] = NonEmptyVector(1, 2, 3, 4, 5)
- def toString(): String
- Definition Classes
- Any
- final def uncons: (A, Chain[A])
Returns the head and tail of this NonEmptyChain.
Returns the head and tail of this NonEmptyChain. Amortized O(1).
- final def zipWith[B, C](b: NonEmptyChain[B])(f: (A, B) => C): NonEmptyChain[C]
Zips this
NonEmptyChain
with anotherNonEmptyChain
and applies a function for each pair of elements.Zips this
NonEmptyChain
with anotherNonEmptyChain
and applies a function for each pair of elements.scala> import cats.data.NonEmptyChain scala> val as = NonEmptyChain(1, 2, 3) scala> val bs = NonEmptyChain("A", "B", "C") scala> as.zipWith(bs)(_.toString + _) res0: cats.data.NonEmptyChain[String] = Chain(1A, 2B, 3C)
- Definition Classes
- NonEmptyChainOps → NonEmptyCollection
- final def zipWithIndex: NonEmptyChain[(A, Int)]
- Definition Classes
- NonEmptyChainOps → NonEmptyCollection