NewSink constructs the sink from the provided function.

NewStepResultFinished constructs a finished StepResult. The continuation will be empty as well.

Not negates the given predicate.

NotifyToChannel sends message to channel after specified duration.

OnError executes a side effect when there is an error.

PairParallel runs two IOs in parallel and returns both results.

PairSwap returns a pair with swapped parts.

Partition separates elements in as according to the predicate.

Partition divides the stream into two that are handled independently.

PipeToPairOfChannels converts a streaming pipe to a pair of channels that could be used to interact with external systems.

ReadOnlyFile returns a resource for the specified filename.

Reduce aggregates all elements pairwise. Only works for non empty slices.

Remove removes any elements in r from as.

RequestOneItem - sends notification to backpressure channel and receives one item from data channel.

RunAlso runs the other IO in parallel, but returns only the result of the first IO.

SideEval executes a computation for each element for it's side effect. Could be used for logging, for instance.

Start returns an IO which will return immediately when executed. It'll place the runnable into this execution context.

StateFlatMap maintains state along the way.

Swap returns a curried function with swapped order of arguments.

Tail returns tail of the slice.

Take returns at most n elements.

TakeAndTail collects n leading elements of the stream and returns them along with the tail of the stream. If the stream is shorter, then only availabl

TakeWhile returns the beginning of the stream such that all elements satisfy the predicate.

Through passes the stream data through the pipe. Technically it applies the pipe function to this stream.

ToBackPressureChannels sends each element to all channels.

ToSink streams all data from the stream to the sink.

ToString converts the value to string using `Sprintf` `%v`.

UnboundedExecutionContext runs each task in a new go routine.

Union returns elements that are either in as or in as2.

Wrapf wraps errors produced by this stream with additional context info.

WriteByteChunks writes byte chunks to writer.

WriteLines creates a sink that receives strings and saves them to writer. It adds \n after each line.

ZipWith returns a slice of pairs made of elements of the two slices. The length of the result is min of both.

ZipWithIndex prepends the index to each element.

splitBy returns at least one part when separator is not found. Even if len(data) == 0.

Bracket executes user computation with transactional guarantee. If user computation is successful - commit is executed. Otherwise - rollback.

Cast converts interface {} to ordinary type A. It'a simple operation i.(A) represented as a function. In case the conversion is not possible, returns

ChannelBufferPipe puts incoming values into a buffer of the given size and then reads from that same buffer. This buffer allows to decouple producer a

ChunkN groups elements by n and produces a stream of slices.

ChunksResize rebuffers chunks to the given size.

Close stops receiving new tasks. Subsequent start invocations will fail.

CoMap changes the input argument of the consumer.

Compose executes the given functions in sequence.

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

EmptyUnit returns an empty stream of units. It's more performant because the same instance is being used.

Fail[A] constructs an IO[A] that fails with the given error.

Fail creates a resource that will fail during acquisition.

Fail returns a stream that fails immediately.

FailedFiber creates a fiber that will fail on Join or Close with the given error.

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

FlatMapErr converts IO[A] result using a function that might fail. It seems to be identical to MapErr.

Flatten simplifies a stream of streams to just the stream of values by concatenating all inner streams.

FoldErr folds IO using simple Go-style functions that might fail.

FromSideEffectfulFunction constructs a stream from a Go-style function. It is expected that this function is not pure and can return different results

IsRight checks whether the provided Either is right or not.

JoinManyFibers starts a separate go-routine for each incoming Fiber. As soon as result is ready it is sent to output. At any point in time at most cap

LazyFinishedStepResult returns

Left constructs Either that is left.

Len returns the length of the slice. This is a normal function that can be passed around unlike the built-in `len`.

MakeUnbufferedChannel allocates a new unbufered channel.

Never is a simple IO that never returns.

NewFailedGoResult constructs a GoResult with an error.

Pool is a pipe capable of running tasks in parallel. type Pool[A any] Pipe[io.IO[A], io.GoResult[A]] NewPool creates an execution pool that will execu

NewPoolFromExecutionContext creates an execution pool that will execute tasks concurrently. After the execution context a buffer is created to allow a

NewResourceFromIOClosable - is an internal function that constructs a resource from closable IO.

NewUnorderedPoolFromExecutionContext creates an execution pool that will execute tasks concurrently. Each task's result will be passed to a channel as

None constructs an option without value.

Nothing panics. However, can be used anywhere where type A is needed.

PairV1 returns the first element of the pair.

PairV2 returns the second element of the pair.

ParallelInExecutionContext starts the given IOs in the provided `ExecutionContext` and waits for all results.

PrependPipeToSink changes the input of a sink.

ReadLinesWithLastNonFinishedLine reads text file line-by-line. Also returns the last line that is not terminated by '\n'

Right constructs Either that is right.

SequenceUnit takes a slice of IO units and returns IO that executes all of them. It'll fail if any of the internal computations fail.

Start returns an IO which will return immediately when executed. It'll place the runnable into this execution context.