arrow-analysis-common/arrow.meta.continuations/ContSeq

ContSeq

sealed class ContSeq<out A>

ContSeq is multi-shot control-flow streaming type. It can emit 0..n elements, and it has ability to abort processing elements at any given time in the stream without aborting the whole stream.

It's lazy, and thus allows for passing it around for composition.

It requires explicit running by using a terminal operator such as drain, forEach, toList or toSet.

Besides that ContSeq exposes APIs that you mind find on any other Monad.

Types

Builder

class Builder<A>(block: suspend ContSeqSyntax<A>.() -> Unit) : ContSeq<A>

Companion

object Companion

Smart-constructors

Iterable

class Iterable<A>(aas: ContSeq.Iterable<A>) : ContSeq<A>

VarArg

class VarArg<A>(aas: Array<out A>) : ContSeq<A>

Functions

drain

fun drain()

Runs the sequence of computations, but ignore the output of every computation

flatMap

fun flatMap(f: (A) -> ContSeq): ContSeq

forEach

inline fun forEach(f: (A) -> Unit)

Alias for for-looping over all elements. Most efficient way to derive combinators.

iterator

abstract operator fun iterator(): Iterator<A>

map

fun map(f: suspend ContSyntax.(A) -> B): ContSeq

Maps every element in the sequence with f, and allows for aborting the mapped value using ContSyntax.abort or ContSyntax.ensure.

onEach

inline fun onEach(crossinline f: (A) -> Unit): ContSeq<A>

Side-effecting version of map

toList

fun toList(): List<A>

Turns ContSeq into an in-memory representation as a List

toSet

fun toSet(): Set<A>

Turns ContSeq into an in-memory representation as a Set

void

fun void(): ContSeq<Unit>

Throws away the output of every emission

zip

inline fun <B, C> zip(fb: ContSeq, crossinline f: (A, B) -> C): ContSeq<C>

Inheritors

VarArg

Iterable

Builder