//arrow-core/arrow.core/NonEmptyList
common class NonEmptyList<out A>(val head: A, val tail: List<A>) : AbstractList<A>
NonEmptyList
is a data type used in Λrrow to model ordered lists that guarantee to have at least one value. NonEmptyList
is available in the arrow-core
module under the import arrow.core.NonEmptyList
A NonEmptyList
guarantees the list always has at least 1 element.
import arrow.core.nonEmptyListOf
val value =
//sampleStart
// nonEmptyListOf() // does not compile
nonEmptyListOf(1, 2, 3, 4, 5) // NonEmptyList<Int>
//sampleEnd
fun main() {
println(value)
}
Unlike List[0]
, NonEmptyList.head
it’s a safe operation that guarantees no exception throwing.
import arrow.core.nonEmptyListOf
val value =
//sampleStart
nonEmptyListOf(1, 2, 3, 4, 5).head
//sampleEnd
fun main() {
println(value)
}
When we fold over a NonEmptyList
, we turn a NonEmptyList< A >
into B
by providing a seed value and a function that carries the state on each iteration over the elements of the list. The first argument is a function that addresses the seed value, this can be any object of any type which will then become the resulting typed value. The second argument is a function that takes the current state and element in the iteration and returns the new state after transformations have been applied.
import arrow.core.NonEmptyList
import arrow.core.nonEmptyListOf
//sampleStart
fun sumNel(nel: NonEmptyList<Int>): Int =
nel.foldLeft(0) { acc, n -> acc + n }
val value = sumNel(nonEmptyListOf(1, 1, 1, 1))
//sampleEnd
fun main() {
println("value = $value")
}
map
allows us to transform A
into B
in NonEmptyList< A >
import arrow.core.nonEmptyListOf
val value =
//sampleStart
nonEmptyListOf(1, 1, 1, 1).map { it + 1 }
//sampleEnd
fun main() {
println(value)
}
flatMap
allows us to compute over the contents of multiple NonEmptyList< * >
values
import arrow.core.NonEmptyList
import arrow.core.nonEmptyListOf
//sampleStart
val nelOne: NonEmptyList<Int> = nonEmptyListOf(1, 2, 3)
val nelTwo: NonEmptyList<Int> = nonEmptyListOf(4, 5)
val value = nelOne.flatMap { one ->
nelTwo.map { two ->
one + two
}
}
//sampleEnd
fun main() {
println("value = $value")
}
Λrrow contains methods that allow you to preserve type information when computing over different NonEmptyList
typed values.
import arrow.core.NonEmptyList
import arrow.core.nonEmptyListOf
import arrow.core.zip
import java.util.UUID
//sampleStart
data class Person(val id: UUID, val name: String, val year: Int)
// Note each NonEmptyList is of a different type
val nelId: NonEmptyList<UUID> = nonEmptyListOf(UUID.randomUUID(), UUID.randomUUID())
val nelName: NonEmptyList<String> = nonEmptyListOf("William Alvin Howard", "Haskell Curry")
val nelYear: NonEmptyList<Int> = nonEmptyListOf(1926, 1900)
val value = nelId.zip(nelName, nelYear) { id, name, year ->
Person(id, name, year)
}
//sampleEnd
fun main() {
println("value = $value")
}
NonEmptyList
is used to model lists that guarantee at least one elementNonEmptyList
with nonEmptyListOf
foldLeft
, map
, flatMap
and others are used to compute over the internal contents of a NonEmptyList
value.a.zip(b, c) { ... }
can be used to compute over multiple NonEmptyList
values preserving type information and abstracting over arity with zip
NonEmptyList | common fun <out A> NonEmptyList(head: A, tail: List<A>) |
Name | Summary |
---|---|
Companion | common object Companion |
Name | Summary |
---|---|
align | common fun <B> align(b: NonEmptyList<B>): NonEmptyList<Ior<A, B» |
coflatMap | common fun <B> coflatMap(f: (NonEmptyList<A>) -> B): NonEmptyList<B> |
contains | common open operator override fun contains(element: A): Boolean |
containsAll | common open override fun containsAll(elements: Collection<A>): Boolean |
equals | common open operator override fun equals(other: Any?): Boolean |
extract | common fun extract(): A |
flatMap | common inline fun <B> flatMap(f: (A) -> NonEmptyList<B>): NonEmptyList<B> |
foldLeft | common inline fun <B> foldLeft(b: B, f: (B, A) -> B): B |
get | common open operator override fun get(index: Int): A |
hashCode | common open override fun hashCode(): Int |
indexOf | common open override fun indexOf(element: A): Int |
isEmpty | common open override fun isEmpty(): Boolean |
iterator | common open operator override fun iterator(): Iterator<A> |
lastIndexOf | common open override fun lastIndexOf(element: A): Int |
listIterator | common open override fun listIterator(): ListIterator<A> open override fun listIterator(index: Int): ListIterator<A> |
map | common inline fun <B> map(f: (A) -> B): NonEmptyList<B> |
padZip | common fun <B> padZip(other: NonEmptyList<B>): NonEmptyList<Pair<A?, B?» |
plus | common operator fun plus(a: @UnsafeVarianceA): NonEmptyList<A> operator fun plus(l: NonEmptyList<@UnsafeVarianceA>): NonEmptyList<A> operator fun plus(l: List<@UnsafeVarianceA>): NonEmptyList<A> |
salign | common fun salign(SA: Semigroup<@UnsafeVarianceA>, b: NonEmptyList<@UnsafeVarianceA>): NonEmptyList<A> |
subList | common open override fun subList(fromIndex: Int, toIndex: Int): List<A> |
toList | common fun toList(): List<A> |
toString | common open override fun toString(): String |
zip | common fun <B> zip(fb: NonEmptyList<B>): NonEmptyList<Pair<A, B» inline fun <B, Z> zip(b: NonEmptyList<B>, map: (A, B) -> Z): NonEmptyList<Z> inline fun <B, C, Z> zip(b: NonEmptyList<B>, c: NonEmptyList<C>, map: (A, B, C) -> Z): NonEmptyList<Z> inline fun <B, C, D, Z> zip(b: NonEmptyList<B>, c: NonEmptyList<C>, d: NonEmptyList<D>, map: (A, B, C, D) -> Z): NonEmptyList<Z> inline fun <B, C, D, E, Z> zip(b: NonEmptyList<B>, c: NonEmptyList<C>, d: NonEmptyList<D>, e: NonEmptyList<E>, map: (A, B, C, D, E) -> Z): NonEmptyList<Z> inline fun <B, C, D, E, F, Z> zip(b: NonEmptyList<B>, c: NonEmptyList<C>, d: NonEmptyList<D>, e: NonEmptyList<E>, f: NonEmptyList<F>, map: (A, B, C, D, E, F) -> Z): NonEmptyList<Z> inline fun <B, C, D, E, F, G, Z> zip(b: NonEmptyList<B>, c: NonEmptyList<C>, d: NonEmptyList<D>, e: NonEmptyList<E>, f: NonEmptyList<F>, g: NonEmptyList<G>, map: (A, B, C, D, E, F, G) -> Z): NonEmptyList<Z> inline fun <B, C, D, E, F, G, H, Z> zip(b: NonEmptyList<B>, c: NonEmptyList<C>, d: NonEmptyList<D>, e: NonEmptyList<E>, f: NonEmptyList<F>, g: NonEmptyList<G>, h: NonEmptyList<H>, map: (A, B, C, D, E, F, G, H) -> Z): NonEmptyList<Z> inline fun <B, C, D, E, F, G, H, I, Z> zip(b: NonEmptyList<B>, c: NonEmptyList<C>, d: NonEmptyList<D>, e: NonEmptyList<E>, f: NonEmptyList<F>, g: NonEmptyList<G>, h: NonEmptyList<H>, i: NonEmptyList<I>, map: (A, B, C, D, E, F, G, H, I) -> Z): NonEmptyList<Z> inline fun <B, C, D, E, F, G, H, I, J, Z> zip(b: NonEmptyList<B>, c: NonEmptyList<C>, d: NonEmptyList<D>, e: NonEmptyList<E>, f: NonEmptyList<F>, g: NonEmptyList<G>, h: NonEmptyList<H>, i: NonEmptyList<I>, j: NonEmptyList<J>, map: (A, B, C, D, E, F, G, H, I, J) -> Z): NonEmptyList<Z> |
Name | Summary |
---|---|
all | common val all: List<A> |
head | common val head: A |
size | common open override val size: Int |
tail | common val tail: List<A> |
Do you like Arrow?
✖