Cats core/cats.data/NonEmptyList

NonEmptyList

final case class NonEmptyList[+A](head: A, tail: List[A]) extends NonEmptyCollection[A, List, [A] =>> NonEmptyList[A]]

A data type which represents a non empty list of A, with single element (head) and optional structure (tail).

A data type which represents a non empty list of A, with single element (head) and optional structure (tail).

Companion
object
trait Serializable
trait Product
trait Equals
trait NonEmptyCollection[A, List, [A] =>> NonEmptyList[A]]
class Object
trait Matchable
class Any

Value members

Concrete methods

def ++[AA >: A](l: List[AA]): NonEmptyList[AA]
def :+[AA >: A](a: AA): NonEmptyList[AA]

Alias for append

Alias for append

scala> import cats.data.NonEmptyList
scala> val nel = NonEmptyList.of(1, 2, 3)
scala> nel :+ 4
res0: cats.data.NonEmptyList[Int] = NonEmptyList(1, 2, 3, 4)
def ::[AA >: A](a: AA): NonEmptyList[AA]
def :::[AA >: A](other: NonEmptyList[AA]): NonEmptyList[AA]

Alias for concatNel

Alias for concatNel

scala> import cats.data.NonEmptyList
scala> val nel = NonEmptyList.of(1, 2, 3)
scala> nel ::: NonEmptyList.of(4, 5)
res0: cats.data.NonEmptyList[Int] = NonEmptyList(1, 2, 3, 4, 5)
def ===[AA >: A](o: NonEmptyList[AA])(AA: Eq[AA]): Boolean
def append[AA >: A](a: AA): NonEmptyList[AA]
def coflatMap[B](f: NonEmptyList[A] => B): NonEmptyList[B]
def collect[B](pf: PartialFunction[A, B]): List[B]

Builds a new List by applying a partial function to all the elements from this NonEmptyList on which the function is defined

Builds a new List by applying a partial function to all the elements from this NonEmptyList on which the function is defined

scala> import cats.data.NonEmptyList
scala> val nel = NonEmptyList.of(1, 2, 3, 4, 5)
scala> nel.collect { case v if v < 3 => v }
res0: scala.collection.immutable.List[Int] = List(1, 2)
scala> nel.collect {
    |  case v if v % 2 == 0 => "even"
    |  case _ => "odd"
    | }
res1: scala.collection.immutable.List[String] = List(odd, even, odd, even, odd)
def concat[AA >: A](other: List[AA]): NonEmptyList[AA]
def concatNel[AA >: A](other: NonEmptyList[AA]): NonEmptyList[AA]

Append another NonEmptyList

Append another NonEmptyList

def distinct[AA >: A](O: Order[AA]): NonEmptyList[AA]

Remove duplicates. Duplicates are checked using Order[_] instance.

Remove duplicates. Duplicates are checked using Order[_] instance.

def exists(p: A => Boolean): Boolean

Check whether at least one element satisfies the predicate

Check whether at least one element satisfies the predicate

def filter(p: A => Boolean): List[A]

Remove elements not matching the predicate

Remove elements not matching the predicate

scala> import cats.data.NonEmptyList
scala> val nel = NonEmptyList.of(1, 2, 3, 4, 5)
scala> nel.filter(_ < 3)
res0: scala.collection.immutable.List[Int] = List(1, 2)
def filterNot(p: A => Boolean): List[A]

Remove elements matching the predicate

Remove elements matching the predicate

scala> import cats.data.NonEmptyList
scala> val nel = NonEmptyList.of(1, 2, 3, 4, 5)
scala> nel.filterNot(_ < 3)
res0: scala.collection.immutable.List[Int] = List(3, 4, 5)
def find(p: A => Boolean): Option[A]

Find the first element matching the predicate, if one exists

Find the first element matching the predicate, if one exists

def flatMap[B](f: A => NonEmptyList[B]): NonEmptyList[B]
def foldLeft[B](b: B)(f: (B, A) => B): B

Left-associative fold on the structure using f.

Left-associative fold on the structure using f.

def foldRight[B](lb: Eval[B])(f: (A, Eval[B]) => Eval[B]): Eval[B]

Right-associative fold on the structure using f.

Right-associative fold on the structure using f.

def forall(p: A => Boolean): Boolean

Check whether all elements satisfy the predicate

Check whether all elements satisfy the predicate

def groupBy[B](f: A => B)(B: Order[B]): SortedMap[B, NonEmptyList[A]]

Groups elements inside this NonEmptyList according to the Order of the keys produced by the given mapping function.

Groups elements inside this NonEmptyList according to the Order of the keys produced by the given mapping function.

scala> import scala.collection.immutable.SortedMap
scala> import cats.data.NonEmptyList
scala> import cats.implicits._
scala> val nel = NonEmptyList.of(12, -2, 3, -5)
scala> val expectedResult = SortedMap(false -> NonEmptyList.of(-2, -5), true -> NonEmptyList.of(12, 3))
scala> val result = nel.groupBy(_ >= 0)
scala> result === expectedResult
res0: Boolean = true
def groupByNem[B](f: A => B)(B: Order[B]): Type[B, NonEmptyList[A]]

Groups elements inside this NonEmptyList according to the Order of the keys produced by the given mapping function.

Groups elements inside this NonEmptyList according to the Order of the keys produced by the given mapping function.

scala> import cats.data.{NonEmptyList, NonEmptyMap}
scala> import cats.implicits._
scala> val nel = NonEmptyList.of(12, -2, 3, -5)
scala> val expectedResult = NonEmptyMap.of(false -> NonEmptyList.of(-2, -5), true -> NonEmptyList.of(12, 3))
scala> val result = nel.groupByNem(_ >= 0)
scala> result === expectedResult
res0: Boolean = true
def groupMap[K, B](key: A => K)(f: A => B)(K: Order[K]): SortedMap[K, NonEmptyList[B]]

Groups elements inside this NonEmptyList according to the Order 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.

Groups elements inside this NonEmptyList according to the Order 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 scala.collection.immutable.SortedMap
scala> import cats.data.NonEmptyList
scala> import cats.implicits._
scala> val nel = NonEmptyList.of(12, -2, 3, -5)
scala> val expectedResult = SortedMap(false -> NonEmptyList.of("-2", "-5"), true -> NonEmptyList.of("12", "3"))
scala> val result = nel.groupMap(_ >= 0)(_.toString)
scala> result === expectedResult
res0: Boolean = true
def groupMapNem[K, B](key: A => K)(f: A => B)(K: Order[K]): Type[K, NonEmptyList[B]]

Groups elements inside this NonEmptyList according to the Order 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.

Groups elements inside this NonEmptyList according to the Order 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.{NonEmptyList, NonEmptyMap}
scala> import cats.implicits._
scala> val nel = NonEmptyList.of(12, -2, 3, -5)
scala> val expectedResult = NonEmptyMap.of(false -> NonEmptyList.of("-2", "-5"), true -> NonEmptyList.of("12", "3"))
scala> val result = nel.groupMapNem(_ >= 0)(_.toString)
scala> result === expectedResult
res0: Boolean = true
def groupMapReduce[K, B](key: A => K)(f: A => B)(K: Order[K], B: Semigroup[B]): SortedMap[K, B]

Groups elements inside this NonEmptyList according to the Order 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 their Semigroup.

Groups elements inside this NonEmptyList according to the Order 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 their Semigroup.

scala> import scala.collection.immutable.SortedMap
scala> import cats.data.NonEmptyList
scala> import cats.implicits._
scala> val nel = NonEmptyList.of("Hello", "World", "Goodbye", "World")
scala> val expectedResult = SortedMap("goodbye" -> 1, "hello" -> 1, "world" -> 2)
scala> val result = nel.groupMapReduce(_.trim.toLowerCase)(_ => 1)
scala> result === expectedResult
res0: Boolean = true
def groupMapReduceNem[K, B](key: A => K)(f: A => B)(K: Order[K], B: Semigroup[B]): Type[K, B]

Groups elements inside this NonEmptyList according to the Order 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 their Semigroup.

Groups elements inside this NonEmptyList according to the Order 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 their Semigroup.

scala> import cats.data.{NonEmptyList, NonEmptyMap}
scala> import cats.implicits._
scala> val nel = NonEmptyList.of("Hello", "World", "Goodbye", "World")
scala> val expectedResult = NonEmptyMap.of("goodbye" -> 1, "hello" -> 1, "world" -> 2)
scala> val result = nel.groupMapReduceNem(_.trim.toLowerCase)(_ => 1)
scala> result === expectedResult
res0: Boolean = true
def groupMapReduceWith[K, B](key: A => K)(f: A => B)(combine: (B, B) => B)(K: Order[K]): SortedMap[K, B]

Groups elements inside this NonEmptyList according to the Order 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.

Groups elements inside this NonEmptyList according to the Order 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 scala.collection.immutable.SortedMap
scala> import cats.data.NonEmptyList
scala> import cats.implicits._
scala> val nel = NonEmptyList.of("Hello", "World", "Goodbye", "World")
scala> val expectedResult = SortedMap("goodbye" -> 1, "hello" -> 1, "world" -> 2)
scala> val result = nel.groupMapReduceWith(_.trim.toLowerCase)(_ => 1)(_ + _)
scala> result === expectedResult
res0: Boolean = true
def groupMapReduceWithNem[K, B](key: A => K)(f: A => B)(combine: (B, B) => B)(K: Order[K]): Type[K, B]

Groups elements inside this NonEmptyList according to the Order 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.

Groups elements inside this NonEmptyList according to the Order 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.{NonEmptyList, NonEmptyMap}
scala> import cats.implicits._
scala> val nel = NonEmptyList.of("Hello", "World", "Goodbye", "World")
scala> val expectedResult = NonEmptyMap.of("goodbye" -> 1, "hello" -> 1, "world" -> 2)
scala> val result = nel.groupMapReduceWithNem(_.trim.toLowerCase)(_ => 1)(_ + _)
scala> result === expectedResult
res0: Boolean = true
def grouped(size: Int): Iterator[NonEmptyList[A]]

Partitions elements in fixed size NonEmptyLists.

Partitions elements in fixed size NonEmptyLists.

scala> import cats.data.NonEmptyList
scala> import cats.implicits._
scala> val nel = NonEmptyList.of(12, -2, 3, -5)
scala> val expectedResult = List(NonEmptyList.of(12, -2), NonEmptyList.of(3, -5))
scala> val result = nel.grouped(2)
scala> result.toList === expectedResult
res0: Boolean = true
def init: List[A]

Selects all elements except the last

Selects all elements except the last

scala> import cats.data.NonEmptyList
scala> val nel = NonEmptyList.of(1, 2, 3, 4, 5)
scala> nel.init
res0: scala.collection.immutable.List[Int] = List(1, 2, 3, 4)
final def iterator: Iterator[A]
def last: A

Selects the last element

Selects the last element

scala> import cats.data.NonEmptyList
scala> val nel = NonEmptyList.of(1, 2, 3, 4, 5)
scala> nel.last
res0: Int = 5
def length: Int
def map[B](f: A => B): NonEmptyList[B]

Applies f to all the elements of the structure

Applies f to all the elements of the structure

def prepend[AA >: A](a: AA): NonEmptyList[AA]
def reduce[AA >: A](S: Semigroup[AA]): AA

Reduce using the Semigroup of AA.

Reduce using the Semigroup of AA.

def reduceLeft[AA >: A](f: (AA, AA) => AA): AA

Left-associative reduce using f.

Left-associative reduce using f.

def reverse: NonEmptyList[A]

Reverse this NonEmptyList.

Reverse this NonEmptyList.

scala> import cats.data.NonEmptyList
scala> val nel = NonEmptyList.of(1, 2, 3)
scala> nel.reverse
res0: cats.data.NonEmptyList[Int] = NonEmptyList(3, 2, 1)
def show[AA >: A](AA: Show[AA]): String
def size: Int

The size of this NonEmptyList

The size of this NonEmptyList

scala> import cats.data.NonEmptyList
scala> val nel = NonEmptyList.of(1, 2, 3, 4, 5)
scala> nel.size
res0: Int = 5
def sortBy[B](f: A => B)(B: Order[B]): NonEmptyList[A]

Sorts this NonEmptyList according to an Order on transformed B from A

Sorts this NonEmptyList according to an Order on transformed B from A

scala> import cats.data.NonEmptyList
scala> import cats.instances.int._
scala> val nel = NonEmptyList.of(('a', 4), ('z', 1), ('e', 22))
scala> nel.sortBy(_._2)
res0: cats.data.NonEmptyList[(Char, Int)] = NonEmptyList((z,1), (a,4), (e,22))
def sorted[AA >: A](AA: Order[AA]): NonEmptyList[AA]

Sorts this NonEmptyList according to an Order

Sorts this NonEmptyList according to an Order

scala> import cats.data.NonEmptyList
scala> import cats.instances.int._
scala> val nel = NonEmptyList.of(12, 4, 3, 9)
scala> nel.sorted
res0: cats.data.NonEmptyList[Int] = NonEmptyList(3, 4, 9, 12)
def take(n: Int): List[A]

Returns the first n elements of this NonEmptyList as a List.

Returns the first n elements of this NonEmptyList as a List.

scala> import cats.data.NonEmptyList
scala> val nel = NonEmptyList.of(1, 2, 3, 4, 5)
scala> nel.take(3)
res0: scala.collection.immutable.List[Int] = List(1, 2, 3)
def toList: List[A]

Return the head and tail into a single list

Return the head and tail into a single list

scala> import cats.data.NonEmptyList
scala> val nel = NonEmptyList.of(1, 2, 3, 4, 5)
scala> nel.toList
res0: scala.collection.immutable.List[Int] = List(1, 2, 3, 4, 5)
def toNem[T, U](ev: A <:< (T, U), order: Order[T]): Type[T, U]

Creates new NonEmptyMap, similarly to List#toMap from scala standard library.

Creates new NonEmptyMap, similarly to List#toMap from scala standard library.

scala> import cats.data.{NonEmptyList, NonEmptyMap}
scala> import cats.implicits._
scala> val nel = NonEmptyList((0, "a"), List((1, "b"),(0, "c"), (2, "d")))
scala> val expectedResult = NonEmptyMap.of(0 -> "c", 1 -> "b", 2 -> "d")
scala> val result = nel.toNem
scala> result === expectedResult
res0: Boolean = true
def toNes[B >: A](order: Order[B]): Type[B]

Creates new NonEmptySet, similarly to List#toSet from scala standard library.

Creates new NonEmptySet, similarly to List#toSet from scala standard library.

scala> import cats.data._
scala> import cats.instances.int._
scala> val nel = NonEmptyList(1, List(2,2,3,4))
scala> nel.toNes
res0: cats.data.NonEmptySet[Int] = TreeSet(1, 2, 3, 4)
def toNev[B >: A]: NonEmptyVector[B]

Creates new NonEmptyVector, similarly to List#toVector from scala standard library.

Creates new NonEmptyVector, similarly to List#toVector from scala standard library.

scala> import cats.data._
scala> import cats.instances.int._
scala> val nel = NonEmptyList(1, List(2,3,4))
scala> val expectedResult = NonEmptyVector.fromVectorUnsafe(Vector(1,2,3,4))
scala> val result = nel.toNev
scala> result === expectedResult
res0: Boolean = true
override def toString: String
Definition Classes
Any
def traverse[G[_], B](f: A => G[B])(G: Applicative[G]): G[NonEmptyList[B]]
def zip[B](nel: NonEmptyList[B]): NonEmptyList[(A, B)]

Zips this NonEmptyList with another NonEmptyList and returns the pairs of elements.

Zips this NonEmptyList with another NonEmptyList and returns the pairs of elements.

scala> import cats.data.NonEmptyList
scala> val as = NonEmptyList.of(1, 2, 3)
scala> val bs = NonEmptyList.of("A", "B", "C")
scala> as.zip(bs)
res0: cats.data.NonEmptyList[(Int, String)] = NonEmptyList((1,A), (2,B), (3,C))
def zipWith[B, C](b: NonEmptyList[B])(f: (A, B) => C): NonEmptyList[C]

Zips this NonEmptyList with another NonEmptyList and applies a function for each pair of elements.

Zips this NonEmptyList with another NonEmptyList and applies a function for each pair of elements.

scala> import cats.data.NonEmptyList
scala> val as = NonEmptyList.of(1, 2, 3)
scala> val bs = NonEmptyList.of("A", "B", "C")
scala> as.zipWith(bs)(_.toString + _)
res0: cats.data.NonEmptyList[String] = NonEmptyList(1A, 2B, 3C)
def zipWithIndex: NonEmptyList[(A, Int)]

Zips each element of this NonEmptyList with its index.

Zips each element of this NonEmptyList with its index.

scala> import cats.data.NonEmptyList
scala> val nel = NonEmptyList.of("a", "b", "c")
scala> nel.zipWithIndex
res0: cats.data.NonEmptyList[(String, Int)] = NonEmptyList((a,0), (b,1), (c,2))

Inherited methods

def productElementNames: Iterator[String]
Inherited from
Product
def productIterator: Iterator[Any]
Inherited from
Product