Lift[A] constructs an IO[A] from a constant value.

Map converts the IO[A] result using the provided function that cannot fail.

NewPair constructs the pair.

UnsafeRunSync runs the given IO[A] synchronously and returns the result.

FlatMap converts the result of IO[A] using a function that itself returns an IO[B]. It'll fail if any of IO[A] or IO[B] fail.

Pure[A] constructs an IO[A] from a function that cannot fail.

Range starts at `from` and progresses until `to` exclusive.

Head returns the first element of the stream. It'll fail if the stream is empty.

ToSlice executes the stream and collects all results to a slice.

Lift returns a stream of one value.

Map converts values of the stream.

NewStepResult constructs StepResult that has one value.

Fold performs different calculations based on whether IO[A] failed or succeeded.

Map converts all values of a slice using the provided function.

Take cuts the stream after n elements.

Eval[A] constructs an IO[A] from a simple function that might fail. If there is panic in the function, it's recovered from and represented as an error

NewStepResultEmpty constructs an empty StepResult.

AndThen runs the first IO, ignores it's result and then runs the second one.

Empty returns an empty stream.

FromPureEffect constructs IO from the simplest function signature.

DrainAll executes the stream and throws away all values.

Eval returns a stream of one value that is the result of IO.

MapEval maps the values of the stream. The provided function returns an IO.

Parallel starts the given IOs in Go routines and waits for all results.

SleepA sleeps and then returns the constant value.

Some constructs an option with value.

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

NewResource constructs a resource given two functions - acquire and release.

RecoverToErrorVar recovers and places the recovered error into the given variable

ToSet converts a slice to a set.

BoundedExecutionContext creates an execution context that will execute tasks concurrently. Simultaneously there could be as many as size executions. I

FanOut distributes the same element to all handlers. Stream failure is also distribured to all handlers.

FlatMap constructs a new stream by concatenating all substreams, produced by f from elements of the original stream.

Fold transforms all possible values of OptionA using two provided functions.

FromUnit consturcts IO[fun.Unit] from a simple function that might fail.

Use is a only way to access the resource instance. It guarantees that the resource instance will be closed after use regardless of the failure/success

FromChannel constructs a stream that reads from the given channel until the channel is open. When channel is closed, the stream is also closed.

Nats return slice []int{1, 2, ..., n}

Recover handles a potential error from IO. It does not fail itself.

Sum sums numbers.

Sum is a pipe that returns a stream of 1 element that is sum of all elements of the original stream.

AndThenLazy appends another stream. The other stream is constructed lazily.

Contains creates a predicate that will check if an element is in this set.

Delay[A] wraps a function that will then return an IO.

Emit returns a stream of a single element

Last keeps track of the current element of the stream and returns it when the stream completes.

LiftMany returns a stream with all the given values.

LiftPair[A] constructs an IO from constant values.

CloseChannel is an IO that closes the given channel.

FireAndForget runs the given IO in a go routine and ignores the result It uses Fiber underneath.

Get is an unsafe function that unwraps the value from the option.

Ignore throws away the result of IO.

MapErr maps the result of IO[A] using a function that might fail.

MapPipe creates a pipe that maps one stream through the provided function.

ObtainResult executes continuation until final result is obtained.

PairOfChannelsToPipe - takes two channels that are being used to talk to some external process and convert them into a single pipe. It first starts a

RetryStrategyMaxCount is a strategy that retries n times immediately.

SetSize returns the size of the set.

StreamFold performs arbitrary processing of a stream's single step result.

UnfoldGoResult converts a stream of GoResults back to normal stream. On the first encounter of Error, the stream fails. default value for `onFailure`

Async[A] constructs an IO given a function that will eventually call a callback. Internally this function creates a channel and blocks on it until the

Closes the fiber and stops sending callbacks. After closing, the respective go routine may complete This is not Cancel, it does not send any signals t

ConstUnit creates a function that will ignore it's Unit input and return the specified value.

Filter filters slice values.

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

FilterNot filters slice values inverting the condition.

Finally runs the finalizer regardless of the success of the IO. In case finalizer fails as well, the second error is printed to log.

Flatten simplifies a slice of slices to just a slice.

FoldToGoResult converts either value or error to go result typically it should never fail.

ForEach runs the given function on the value if it's available.

Forall returns a predicate on slices. The predicate is true if all elements satisfy the given element-wise predicate. It's true for an empty slice.

HeadTail returns head, tail. panics with ErrHeadOfEmptySlice when slice is empty.

IsLeft checks whether the provided Either is left or not.

Join waits for results of the fiber. When fiber completes, this IO will complete and return the result. After this fiber is closed, all join IOs fail

MeasureDuration captures the wall time that was needed to evaluate the given IO.

Min - returns the minimum value. See https://go.dev/blog/intro-generics

Reverse creates a new slice with elements reversed.

RunSync is the same as UnsafeRunSync but returns GoResult[A].

Send receives readiness signal from `back`. If ready, sends data to `data`.

Sequence takes a slice of IOs and returns an IO that will contain a slice of results. It'll fail if any of the internal computations fail.

Sliding splits the provided slice into windows. Each window will have the given size. The first window starts from offset = 0. Each consecutive window

ThroughExecutionContext runs a stream of tasks through an ExecutionContext. NB! This operation recovers GoResults. This will lead to lost of good elem

ThroughPipeEval runs the given stream through pipe that is returned by the provided pipeIO.

ToChannel sends all stream elements to the given channel. When stream is completed, channel is closed. The IO blocks until the stream is exhausted. If

ToStreamEvent converts the given stream to a stream of StreamEvents. Each normal element will become a StreamEvent with data. On a failure or finish a

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

ClosableMap is an internal function to map closable using the provided function.

Collect runs through the slice, executes the given function and only keeps good returned values.

ConcatPipes connects two pipes into one.

Drop removes initial n elements.

Drop skips n elements in the stream.

Filter leaves the value inside option only if predicate is true.