arrow-core-data / arrow.core / ListK

ListK

data class ~~ListK~~<out A> : ListKOf<A>, List<A> Deprecated: ListK is deprecated along side Higher Kinded Types in Arrow. Prefer to simply use kotlin.collections.List instead.Arrow provides extension functions on Iterable to cover all the behavior defined for ListK as extension functions

ListK wraps over the platform List type to make it a type constructor(/docs/0.12/patterns/glossary/#type-constructors).

It can be created from Kotlin List type with a convenient k() function.

import arrow.core.k

val value =
//sampleStart
 listOf(1, 2, 3).k()
//sampleEnd
fun main() {
  println(value)
}

For most use cases you will never use ListK directly but List directly with the extension functions that Arrow projects over it.

ListK implements operators from many useful typeclasses.

The @extension type class processor expands all type class combinators that ListK provides automatically over List

For instance, it has combineK from the SemigroupK(/docs/0.12/arrow/typeclasses/semigroupk/) typeclass.

It can be used to cheaply combine two lists:

import arrow.core.extensions.list.semigroupK.combineK

//sampleStart
val hello = listOf('h', 'e', 'l', 'l', 'o')
val commaSpace = listOf(',', ' ')
val world = listOf('w', 'o', 'r', 'l', 'd')

val combinedList = hello.combineK(commaSpace).combineK(world)
//sampleEnd
fun main() {
 println("combinedList = $combinedList")
}

The functions traverse and sequence come from Traverse(/docs/0.12/apidocs/arrow-core-data/arrow.typeclasses/-traverse/).

Traversing a list creates a new container KindF,A(/docs/0.12/patterns/glossary/#type-constructors) by combining the result of a function applied to each element:

import arrow.core.None
import arrow.core.Option
import arrow.core.Some
import arrow.core.extensions.list.traverse.traverse
import arrow.core.extensions.option.applicative.applicative

//sampleStart
val numbers = listOf(Math.random(), Math.random(), Math.random())
val traversedList = numbers.traverse(Option.applicative(), { if (it > 0.5) Some(it) else None })
//sampleEnd
fun main() {
  println("traversedList $traversedList")
}

and complements the convenient function sequence() that converts a list of ListK<Kind<F, A>> into a Kind<F, ListK<A>>:

import arrow.core.Option
import arrow.core.Some
import arrow.core.extensions.list.traverse.sequence
import arrow.core.extensions.option.applicative.applicative

//sampleStart
val requests = listOf(Some(Math.random()), Some(Math.random()), Some(Math.random()))
val sequenceList = requests.sequence(Option.applicative())
//sampleEnd
fun main() {
  println("sequenceList = $sequenceList")
}

If you want to aggregate the elements of a list into any other value you can use foldLeft and foldRight from Foldable(/docs/0.12/arrow/typeclasses/foldable).

Folding a list into a new value, String in this case, starting with an initial value and a combine function:

import arrow.core.k
import arrow.core.extensions.list.foldable.foldLeft
val value =
//sampleStart
 listOf('a', 'b', 'c', 'd', 'e').k().foldLeft("-> ") { x, y -> x + y }
//sampleEnd
fun main() {
 println(value)
}

Or you can apply a list of transformations using ap from Applicative(/docs/0.12/arrow/typeclasses/applicative/).

import arrow.core.extensions.list.apply.ap

val value =
//sampleStart
 listOf(1, 2, 3).ap(listOf({ x: Int -> x + 10 }, { x: Int -> x * 2 }))
//sampleEnd
fun main() {
 println(value)
}

Constructors

Functions

Companion Object Functions

Extension Functions