Shorthand form for ZTransducer.identity. Use as:

ZTransducer[Int].filter(_ % 2 != 0)

Reads the first n values from the stream and uses them to choose the transducer that will be used for the remainder of the stream. If the stream ends before it has collected n values the partial chunk will be provided to f.

Creates a transducer accumulating incoming values into maps of up to n keys. Elements are mapped to keys using the function key; elements mapped to the same key will be merged with the function f.

Compresses stream with 'deflate' method described in https://tools.ietf.org/html/rfc1951. Each incoming chunk is compressed at once, so it can utilize thread for long time if chunks are big.

Creates a transducer by folding over a structure of type O for as long as contFn results in true. The transducer will emit a value when contFn evaluates to false and then restart the folding.

Creates a transducer by folding over a structure of type O. The transducer will fold the inputs until the stream ends, resulting in a stream with one element.

Creates a transducer by effectfully folding over a structure of type O. The transducer will fold the inputs until the stream ends, resulting in a stream with one element.

Creates a transducer that folds elements of type I into a structure of type O until max elements have been folded.

Like foldWeighted, but with a constant cost function of 1.

Creates a transducer that effectfully folds elements of type I into a structure of type O until max elements have been folded.

Like foldWeightedM, but with a constant cost function of 1.

Creates a transducer that folds elements of type I into a structure of type O, until max worth of elements (determined by the costFn) have been folded.

Creates a transducer that folds elements of type I into a structure of type O, until max worth of elements (determined by the costFn) have been folded.

The decompose function will be used for decomposing elements that cause an O aggregate to cross max into smaller elements. For example:

Stream(1, 5, 1)
 .aggregate(
   ZTransducer
     .foldWeightedDecompose(List[Int]())((_, i: Int) => i.toLong, 4,
       (i: Int) => if (i > 1) Chunk(i - 1, 1) else Chunk(i)) { (acc, el) =>
       el :: acc
     }
     .map(_.reverse)
 )
 .runCollect

The stream would emit the elements List(1), List(4), List(1, 1).

Be vigilant with this function, it has to generate "simpler" values or the fold may never end. A value is considered indivisible if decompose yields the empty chunk or a single-valued chunk. In these cases, there is no other choice than to yield a value that will cross the threshold.

The foldWeightedDecomposeM allows the decompose function to return a ZIO value, and consequently it allows the transducer to fail.

Creates a transducer that effectfully folds elements of type I into a structure of type S, until max worth of elements (determined by the costFn) have been folded.

The decompose function will be used for decomposing elements that cause an S aggregate to cross max into smaller elements. Be vigilant with this function, it has to generate "simpler" values or the fold may never end. A value is considered indivisible if decompose yields the empty chunk or a single-valued chunk. In these cases, there is no other choice than to yield a value that will cross the threshold.

See foldWeightedDecompose for an example.

Creates a transducer that effectfully folds elements of type I into a structure of type S, until max worth of elements (determined by the costFn) have been folded.

Creates a transducer that groups on adjacent keys, calculated by function f.
With this transducer we can mimic fs2 groupAdjacentBy.
This can be used like e.g. zstream.aggregate(groupAdjacentBy(_._1))

Decompresses gzipped stream. Compression method is described in https://tools.ietf.org/html/rfc1952.

The identity transducer. Passes elements through.

Decompresses deflated stream. Compression method is described in https://tools.ietf.org/html/rfc1951.

Decodes chunks of ISO/IEC 8859-1 bytes into strings.

This transducer uses the String constructor's behavior when handling malformed byte sequences.

Splits strings on newlines. Handles both Windows newlines (\r\n) and UNIX newlines (\n).

Decodes chunks of US-ASCII bytes into strings.

This transducer uses the String constructor's behavior when handling malformed byte sequences.

Decodes chunks of UTF-16BE bytes into strings.

This transducer uses the String constructor's behavior when handling malformed byte sequences.

Decodes chunks of UTF-16 bytes into strings. If no byte order mark is found big-endianness is assumed.

This transducer uses the endisn-specific String constructor's behavior when handling malformed byte sequences.

Decodes chunks of UTF-16LE bytes into strings.

This transducer uses the String constructor's behavior when handling malformed byte sequences.

Decodes chunks of UTF-32BE bytes into strings.

This transducer uses the String constructor's behavior when handling malformed byte sequences.

Decodes chunks of UTF-32 bytes into strings. If no byte order mark is found big-endianness is assumed.

Decodes chunks of UTF-32LE bytes into strings.

This transducer uses the String constructor's behavior when handling malformed byte sequences.

Decodes chunks of UTF-8 bytes into strings.

This transducer uses the String constructor's behavior when handling malformed byte sequences.

Decodes chunks of Unicode bytes into strings.

Detects byte order marks for UTF-8, UTF-16BE, UTF-16LE, UTF-32BE, UTF-32LE or defaults to UTF-8 if no BOM is detected.

Accumulates incoming elements into a chunk as long as they verify effectful predicate p.

Creates a transducer that starts consuming values as soon as one fails the effectful predicate p.

Creates a transducer by effectfully folding over a structure of type O. The transducer will fold the inputs until the stream ends, resulting in a stream with one element.

Creates a sink by effectfully folding over a structure of type S.

Creates a transducer that effectfully folds elements of type I into a structure of type O until max elements have been folded.

Like foldWeightedM, but with a constant cost function of 1.

Creates a transducer that effectfully folds elements of type I into a structure of type S, until max worth of elements (determined by the costFn) have been folded.

The decompose function will be used for decomposing elements that cause an S aggregate to cross max into smaller elements. Be vigilant with this function, it has to generate "simpler" values or the fold may never end. A value is considered indivisible if decompose yields the empty chunk or a single-valued chunk. In these cases, there is no other choice than to yield a value that will cross the threshold.

See foldWeightedDecompose for an example.

Creates a transducer that effectfully folds elements of type I into a structure of type S, until max worth of elements (determined by the costFn) have been folded.

Creates a transducer that always evaluates the specified effect.

Creates a transducer that effectfully transforms incoming values.