FlatMap converts all values of a slice using the provided function. As the function returns slices, all of them are appended to a single long slice.

Flatten simplifies option of option to just Option[A].

Fold pattern matches Either with two given pattern match handlers

FoldLeft aggregates stream in a more simple way than StateFlatMap.

FoldToGoResult converts a stream into a stream of go results. All go results will be non-error except probably the last one.

ForEach calls the provided callback after IO is completed.

FromChannel reads a single value from the channel

FromStepResult constructs a stream from an IO that returns StepResult.

GetLeft returns left if it's defined.

GroupBy groups elements by a function that returns a key.

GroupByEval collects group by a user-provided key (which is evaluated as IO). Whenever a new key is encountered, the previous group is emitted. When t

IndexOf returns the index of the first occurrence of a in the slice or -1 if not found.

IsEmpty checks whether the option is empty.

IsEqualTo compares two arguments for equality.

Map applies a function to the value inside option if any.

MapToStrings converts stream of bytes to strings.

Memoize returns a function that will remember the original function in a map. It's thread safe, however, not super performant.

Notify starts a separate thread that will call the given callback after the specified time.

PairBoth returns both parts of the pair.

PairSequentially runs two IOs sequentially and returns both results.

ReadByteChunks reads chunks from the reader.

ReadLines reads text file line-by-line. If there is a last line that is not terminated by '\n', it is ignored.

RecoverToLog in case of error just logs it.

Repeat appends the same stream infinitely.

Retry performs the same operation a few times based on the retry strategy.

RetryS performs the same operation a few times based on the retry strategy. Also returns the last state of the error-handling strategy.

Sleep makes the IO sleep the specified time.

SplitBySeparator splits byte-chunk stream by the given separator.

Start will start the IO in a separate go-routine (actually in the global unbounded execution context). It'll establish a channel with callbacks, so th

StateFlatMapWithFinishAndFailureHandling maintains state along the way. When the source stream finishes, it invokes onFinish with the last state. If t

ThroughExecutionContextUnordered runs a stream of tasks through an ExecutionContext. The order of results is not preserved! This operation recovers Go

ToChannel saves the value to the channel

ToChannels sends each stream element to every given channel. Failure or completion of the stream leads to closure of all channels. TODO: Send failure

UnfoldGoResult represents GoResult back to ordinary IO.

Wrapf wraps an error with additional context information

ZipWithIndex prepends the index to each element.

AddSeparatorAfterEachElement adds a separator after each stream element

AfterTimeout sleeps the given time and then starts the other IO.

AndThen appends another stream after the end of the first one.

AppendAll concatenates all slices.

AppendToSlice executes the stream and appends it's results to the slice.

Pair.Both returns both parts of the pair.

BoundedExecutionContextResource returns a resource that is a bounded execution context.

CastAsInterface casts a value of an arbitrary type as interface {}.

ClosableFlatMap flatmaps the closable. Allows to construct have more than one resource in scope.

ClosableIOTransform transforms a closable of io closable to just io closable.

Collect collects all element from the stream and for each element invokes the provided function

ConcurrentlyFirst - runs all IOs in parallel. returns the very first result. TODO: after obtaining result - cancel the other IOs.

Count counts the number of elements that satisfy the given predicate.

Curry takes a function that has two arguments and returns a function with two argument lists.

DropWhile removes the beginning of the stream so that the new stream starts with an element that falsifies the predicate.

EmitMany returns a stream with all the given values.

Exists returns a predicate on slices. The predicate is true if there is an element that satisfy the given element-wise predicate. It's false for an em

Filter leaves in the stream only the elements that do not satisfy the given predicate.

FlatMap allows to add another resource to scope. Both will be released in reverse order.

FlatMap converts an internal value if it is present using the provided function.

FlatMapPipe creates a pipe that flatmaps one stream through the provided function.

FoldLeft folds all values in the slice using the combination function.

FoldLeftEval aggregates stream in a more simple way than StateFlatMap. It takes `zero` as the initial accumulator value and then combines one element

ForEach executes the given function for each element of the slice.

ForEach invokes a simple function for each element of the stream.

FromBackpressureChannel forms a stream[A] that will be consumed by `f`. The result of `f` will be used to report back failures and finish signals. thi

FromClosableIO constructs a new resource from some value that itself supports method Close.

FromConstantGoResult converts an existing GoResult value into a fake IO. NB! This is not for normal delayed IO execution!

FromSlice constructs a stream from the slice.

Generate constructs an infinite stream of values using the production function.

GetRight returns left if it's defined.

GroupBy collects group by a user-provided key. Whenever a new key is encountered, the previous group is emitted. When the original stream finishes, th

GroupByMap is a convenience function that groups and then maps the subslices.

GroupByMapCount for each key counts how often it is seen.

Grouped partitions the slice into groups of the given size. Last partition might be smaller.

HappyPathReceive forms a stream of a happy path.

Head returns head of the slice. panics with ErrHeadOfEmptySlice when slice is empty.

HeadAndTail returns the very first element of the stream and the rest of the stream.

IOFuncToGoResult converts a function that returns IO to a function that will return GoResult.

Identity function returns the given value unchanged.

Intersection leaves only elements that are both in as and as2.

IsDefined checks whether the option contains a value.

JoinFiberAsGoResult joins the fiber synchronously and returns GoResult.

JoinWithTimeout joins the given fiber and waits no more than the given duration.

Keys returns keys of the map.

Len is a pipe that returns a stream of 1 element that is the count of elements of the original stream.

LiftFunc wraps the result of function into IO.

Map maps the resource value using the provided conversion function.

MapConst ignores the result and replaces it with the given constant.

MapKeys converts original keys to new keys.

MapSlice converts each element of the slice inside IO[[]A] using the provided function that cannot fail.

MapStringToBytes converts stream of strings to stream of byte chunks.

MapValues converts values in the map using the provided function.

Max - returns the maximum value. See https://go.dev/blog/intro-generics

Memoize returns a function that will remember the original function in a map. It's thread safe, however, not super performant.

Merge combines two maps. Function `combine` is invoked when the same key is available in both maps.

Nats returns an infinite stream of ints starting from 1.

NewGoResult constructs a GoResult.