object ZTransducer extends ZTransducerPlatformSpecificConstructors
- Alphabetic
- By Inheritance
- ZTransducer
- ZTransducerPlatformSpecificConstructors
- AnyRef
- Any
- Hide All
- Show All
- Public
- All
Value Members
-
final
def
!=(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
final
def
##(): Int
- Definition Classes
- AnyRef → Any
-
final
def
==(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
def
apply[I]: ZTransducer[Any, Nothing, I, I]
Shorthand form for ZTransducer.identity.
Shorthand form for ZTransducer.identity. Use as:
ZTransducer[Int].filter(_ % 2 != 0)
- def apply[R, E, I, O](push: ZManaged[R, Nothing, (Option[Chunk[I]]) ⇒ ZIO[R, E, Chunk[O]]]): ZTransducer[R, E, I, O]
-
final
def
asInstanceOf[T0]: T0
- Definition Classes
- Any
-
def
branchAfter[R, E, I, O](n: Int)(f: (Chunk[I]) ⇒ ZTransducer[R, E, I, O]): ZTransducer[R, E, I, O]
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.
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.
-
def
clone(): AnyRef
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( ... ) @native()
-
def
collectAllN[I](n: Int): ZTransducer[Any, Nothing, I, Chunk[I]]
Creates a transducer accumulating incoming values into chunks of maximum size
n
. -
def
collectAllToMapN[K, I](n: Long)(key: (I) ⇒ K)(f: (I, I) ⇒ I): ZTransducer[Any, Nothing, I, Map[K, I]]
Creates a transducer accumulating incoming values into maps of up to
n
keys.Creates a transducer accumulating incoming values into maps of up to
n
keys. Elements are mapped to keys using the functionkey
; elements mapped to the same key will be merged with the functionf
. -
def
collectAllToSetN[I](n: Long): ZTransducer[Any, Nothing, I, Set[I]]
Creates a transducer accumulating incoming values into sets of maximum size
n
. -
def
collectAllWhile[I](p: (I) ⇒ Boolean): ZTransducer[Any, Nothing, I, List[I]]
Accumulates incoming elements into a chunk as long as they verify predicate
p
. -
def
collectAllWhileZIO[R, E, I](p: (I) ⇒ ZIO[R, E, Boolean]): ZTransducer[R, E, I, List[I]]
Accumulates incoming elements into a chunk as long as they verify effectful predicate
p
. -
def
die(e: ⇒ Throwable): ZTransducer[Any, Nothing, Any, Nothing]
Creates a transducer that always dies with the specified exception.
-
def
dropWhile[I](p: (I) ⇒ Boolean): ZTransducer[Any, Nothing, I, I]
Creates a transducer that starts consuming values as soon as one fails the predicate
p
. -
def
dropWhileZIO[R, E, I](p: (I) ⇒ ZIO[R, E, Boolean]): ZTransducer[R, E, I, I]
Creates a transducer that starts consuming values as soon as one fails the effectful predicate
p
. -
final
def
eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
def
equals(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
def
fail[E](e: ⇒ E): ZTransducer[Any, E, Any, Nothing]
Creates a transducer that always fails with the specified failure.
-
def
finalize(): Unit
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( classOf[java.lang.Throwable] )
-
def
fold[I, O](z: O)(contFn: (O) ⇒ Boolean)(f: (O, I) ⇒ O): ZTransducer[Any, Nothing, I, O]
Creates a transducer by folding over a structure of type
O
for as long ascontFn
results intrue
.Creates a transducer by folding over a structure of type
O
for as long ascontFn
results intrue
. The transducer will emit a value whencontFn
evaluates tofalse
and then restart the folding. -
def
foldLeft[I, O](z: O)(f: (O, I) ⇒ O): ZTransducer[Any, Nothing, I, O]
Creates a transducer by folding over a structure of type
O
.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. -
def
foldLeftZIO[R, E, I, O](z: O)(f: (O, I) ⇒ ZIO[R, E, O]): ZTransducer[R, E, I, O]
Creates a transducer by effectfully folding over a structure of type
O
.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. -
def
foldUntil[I, O](z: O, max: Long)(f: (O, I) ⇒ O): ZTransducer[Any, Nothing, I, O]
Creates a transducer that folds elements of type
I
into a structure of typeO
untilmax
elements have been folded.Creates a transducer that folds elements of type
I
into a structure of typeO
untilmax
elements have been folded.Like foldWeighted, but with a constant cost function of 1.
-
def
foldUntilZIO[R, E, I, O](z: O, max: Long)(f: (O, I) ⇒ ZIO[R, E, O]): ZTransducer[R, E, I, O]
Creates a transducer that effectfully folds elements of type
I
into a structure of typeO
untilmax
elements have been folded.Creates a transducer that effectfully folds elements of type
I
into a structure of typeO
untilmax
elements have been folded.Like foldWeightedM, but with a constant cost function of 1.
-
def
foldWeighted[I, O](z: O)(costFn: (O, I) ⇒ Long, max: Long)(f: (O, I) ⇒ O): ZTransducer[Any, Nothing, I, O]
Creates a transducer that folds elements of type
I
into a structure of typeO
, untilmax
worth of elements (determined by thecostFn
) have been folded.Creates a transducer that folds elements of type
I
into a structure of typeO
, untilmax
worth of elements (determined by thecostFn
) have been folded.- Note
Elements that have an individual cost larger than
max
will force the transducer to cross themax
cost. See foldWeightedDecompose for a variant that can handle these cases.
-
def
foldWeightedDecompose[I, O](z: O)(costFn: (O, I) ⇒ Long, max: Long, decompose: (I) ⇒ Chunk[I])(f: (O, I) ⇒ O): ZTransducer[Any, Nothing, I, O]
Creates a transducer that folds elements of type
I
into a structure of typeO
, untilmax
worth of elements (determined by thecostFn
) have been folded.Creates a transducer that folds elements of type
I
into a structure of typeO
, untilmax
worth of elements (determined by thecostFn
) have been folded.The
decompose
function will be used for decomposing elements that cause anO
aggregate to crossmax
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. -
def
foldWeightedDecomposeZIO[R, E, I, O](z: O)(costFn: (O, I) ⇒ ZIO[R, E, Long], max: Long, decompose: (I) ⇒ ZIO[R, E, Chunk[I]])(f: (O, I) ⇒ ZIO[R, E, O]): ZTransducer[R, E, I, O]
Creates a transducer that effectfully folds elements of type
I
into a structure of typeS
, untilmax
worth of elements (determined by thecostFn
) have been folded.Creates a transducer that effectfully folds elements of type
I
into a structure of typeS
, untilmax
worth of elements (determined by thecostFn
) have been folded.The
decompose
function will be used for decomposing elements that cause anS
aggregate to crossmax
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 ifdecompose
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.
-
def
foldWeightedZIO[R, E, I, O](z: O)(costFn: (O, I) ⇒ ZIO[R, E, Long], max: Long)(f: (O, I) ⇒ ZIO[R, E, O]): ZTransducer[R, E, I, O]
Creates a transducer that effectfully folds elements of type
I
into a structure of typeS
, untilmax
worth of elements (determined by thecostFn
) have been folded.Creates a transducer that effectfully folds elements of type
I
into a structure of typeS
, untilmax
worth of elements (determined by thecostFn
) have been folded.- Note
Elements that have an individual cost larger than
max
will force the transducer to cross themax
cost. See foldWeightedDecomposeM for a variant that can handle these cases.
-
def
foldZIO[R, E, I, O](z: O)(contFn: (O) ⇒ Boolean)(f: (O, I) ⇒ ZIO[R, E, O]): ZTransducer[R, E, I, O]
Creates a sink by effectfully folding over a structure of type
S
. -
def
fromFunction[I, O](f: (I) ⇒ O): ZTransducer[Any, Nothing, I, O]
Creates a transducer that purely transforms incoming values.
-
def
fromFunctionZIO[R, E, I, O](f: (I) ⇒ ZIO[R, E, O]): ZTransducer[R, E, I, O]
Creates a transducer that effectfully transforms incoming values.
-
def
fromPush[R, E, I, O](push: (Option[Chunk[I]]) ⇒ ZIO[R, E, Chunk[O]]): ZTransducer[R, E, I, O]
Creates a transducer from a chunk processing function.
-
def
fromZIO[R, E, A](zio: ZIO[R, E, A]): ZTransducer[R, E, Any, A]
Creates a transducer that always evaluates the specified effect.
-
final
def
getClass(): Class[_]
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
-
def
hashCode(): Int
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
-
def
head[O]: ZTransducer[Any, Nothing, O, Option[O]]
Creates a transducer that returns the first element of the stream, if it exists.
-
def
identity[I]: ZTransducer[Any, Nothing, I, I]
The identity transducer.
The identity transducer. Passes elements through.
-
final
def
isInstanceOf[T0]: Boolean
- Definition Classes
- Any
-
val
iso_8859_1Decode: ZTransducer[Any, Nothing, Byte, String]
Decodes chunks of ISO/IEC 8859-1 bytes into strings.
Decodes chunks of ISO/IEC 8859-1 bytes into strings.
This transducer uses the String constructor's behavior when handling malformed byte sequences.
-
def
last[O]: ZTransducer[Any, Nothing, O, Option[O]]
Creates a transducer that returns the last element of the stream, if it exists.
-
final
def
ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
final
def
notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
-
final
def
notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
-
def
prepend[A](values: Chunk[A]): ZTransducer[Any, Nothing, A, A]
Emits the provided chunk before emitting any other value.
-
val
splitLines: ZTransducer[Any, Nothing, String, String]
Splits strings on newlines.
Splits strings on newlines. Handles both Windows newlines (
\r\n
) and UNIX newlines (\n
). -
def
splitOn(delimiter: String): ZTransducer[Any, Nothing, String, String]
Splits strings on a delimiter.
-
def
splitOnChunk[A](delimiter: Chunk[A]): ZTransducer[Any, Nothing, A, Chunk[A]]
Splits elements on a delimiter and transforms the splits into desired output.
-
final
def
synchronized[T0](arg0: ⇒ T0): T0
- Definition Classes
- AnyRef
-
def
toString(): String
- Definition Classes
- AnyRef → Any
-
def
unwrap[R, E, I, O](zio: ZIO[R, E, ZTransducer[R, E, I, O]]): ZTransducer[R, E, I, O]
Creates a transducer produced from an effect.
-
def
unwrapManaged[R, E, I, O](managed: ZManaged[R, E, ZTransducer[R, E, I, O]]): ZTransducer[R, E, I, O]
Creates a transducer produced from a managed effect.
-
val
usASCIIDecode: ZTransducer[Any, Nothing, Byte, String]
Decodes chunks of US-ASCII bytes into strings.
Decodes chunks of US-ASCII bytes into strings.
This transducer uses the String constructor's behavior when handling malformed byte sequences.
-
val
utf16BEDecode: ZTransducer[Any, Nothing, Byte, String]
Decodes chunks of UTF-16BE bytes into strings.
Decodes chunks of UTF-16BE bytes into strings.
This transducer uses the String constructor's behavior when handling malformed byte sequences.
-
val
utf16Decode: ZTransducer[Any, Nothing, Byte, String]
Decodes chunks of UTF-16 bytes into strings.
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.
-
val
utf16LEDecode: ZTransducer[Any, Nothing, Byte, String]
Decodes chunks of UTF-16LE bytes into strings.
Decodes chunks of UTF-16LE bytes into strings.
This transducer uses the String constructor's behavior when handling malformed byte sequences.
-
lazy val
utf32BEDecode: ZTransducer[Any, Nothing, Byte, String]
Decodes chunks of UTF-32BE bytes into strings.
Decodes chunks of UTF-32BE bytes into strings.
This transducer uses the String constructor's behavior when handling malformed byte sequences.
-
lazy val
utf32Decode: ZTransducer[Any, Nothing, Byte, String]
Decodes chunks of UTF-32 bytes into strings.
Decodes chunks of UTF-32 bytes into strings. If no byte order mark is found big-endianness is assumed.
-
lazy val
utf32LEDecode: ZTransducer[Any, Nothing, Byte, String]
Decodes chunks of UTF-32LE bytes into strings.
Decodes chunks of UTF-32LE bytes into strings.
This transducer uses the String constructor's behavior when handling malformed byte sequences.
-
val
utf8Decode: ZTransducer[Any, Nothing, Byte, String]
Decodes chunks of UTF-8 bytes into strings.
Decodes chunks of UTF-8 bytes into strings.
This transducer uses the String constructor's behavior when handling malformed byte sequences.
-
val
utfDecode: ZTransducer[Any, Nothing, Byte, String]
Decodes chunks of Unicode bytes into strings.
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.
-
final
def
wait(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
final
def
wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
final
def
wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... ) @native()
- object Push
Deprecated Value Members
-
def
collectAllWhileM[R, E, I](p: (I) ⇒ ZIO[R, E, Boolean]): ZTransducer[R, E, I, List[I]]
Accumulates incoming elements into a chunk as long as they verify effectful predicate
p
.Accumulates incoming elements into a chunk as long as they verify effectful predicate
p
.- Annotations
- @deprecated
- Deprecated
(Since version 2.0.0) use collectAllWhileZIO
-
def
dropWhileM[R, E, I](p: (I) ⇒ ZIO[R, E, Boolean]): ZTransducer[R, E, I, I]
Creates a transducer that starts consuming values as soon as one fails the effectful predicate
p
.Creates a transducer that starts consuming values as soon as one fails the effectful predicate
p
.- Annotations
- @deprecated
- Deprecated
(Since version 2.0.0) use dropWhileZIO
-
def
foldLeftM[R, E, I, O](z: O)(f: (O, I) ⇒ ZIO[R, E, O]): ZTransducer[R, E, I, O]
Creates a transducer by effectfully folding over a structure of type
O
.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.- Annotations
- @deprecated
- Deprecated
(Since version 2.0.0) use foldLeftZIO
-
def
foldM[R, E, I, O](z: O)(contFn: (O) ⇒ Boolean)(f: (O, I) ⇒ ZIO[R, E, O]): ZTransducer[R, E, I, O]
Creates a sink by effectfully folding over a structure of type
S
.Creates a sink by effectfully folding over a structure of type
S
.- Annotations
- @deprecated
- Deprecated
(Since version 2.0.0) use foldZIO
-
def
foldUntilM[R, E, I, O](z: O, max: Long)(f: (O, I) ⇒ ZIO[R, E, O]): ZTransducer[R, E, I, O]
Creates a transducer that effectfully folds elements of type
I
into a structure of typeO
untilmax
elements have been folded.Creates a transducer that effectfully folds elements of type
I
into a structure of typeO
untilmax
elements have been folded.Like foldWeightedM, but with a constant cost function of 1.
- Annotations
- @deprecated
- Deprecated
(Since version 2.0.0) use foldUntilZIO
-
def
foldWeightedDecomposeM[R, E, I, O](z: O)(costFn: (O, I) ⇒ ZIO[R, E, Long], max: Long, decompose: (I) ⇒ ZIO[R, E, Chunk[I]])(f: (O, I) ⇒ ZIO[R, E, O]): ZTransducer[R, E, I, O]
Creates a transducer that effectfully folds elements of type
I
into a structure of typeS
, untilmax
worth of elements (determined by thecostFn
) have been folded.Creates a transducer that effectfully folds elements of type
I
into a structure of typeS
, untilmax
worth of elements (determined by thecostFn
) have been folded.The
decompose
function will be used for decomposing elements that cause anS
aggregate to crossmax
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 ifdecompose
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.
- Annotations
- @deprecated
- Deprecated
(Since version 2.0.0) use foldWeightedDecomposeZIO
-
def
foldWeightedM[R, E, I, O](z: O)(costFn: (O, I) ⇒ ZIO[R, E, Long], max: Long)(f: (O, I) ⇒ ZIO[R, E, O]): ZTransducer[R, E, I, O]
Creates a transducer that effectfully folds elements of type
I
into a structure of typeS
, untilmax
worth of elements (determined by thecostFn
) have been folded.Creates a transducer that effectfully folds elements of type
I
into a structure of typeS
, untilmax
worth of elements (determined by thecostFn
) have been folded.- Annotations
- @deprecated
- Deprecated
(Since version 2.0.0) use foldWeightedZIO
- Note
Elements that have an individual cost larger than
max
will force the transducer to cross themax
cost. See foldWeightedDecomposeM for a variant that can handle these cases.
-
def
fromEffect[R, E, A](zio: ZIO[R, E, A]): ZTransducer[R, E, Any, A]
Creates a transducer that always evaluates the specified effect.
Creates a transducer that always evaluates the specified effect.
- Annotations
- @deprecated
- Deprecated
(Since version 2.0.0) use fromZIO
-
def
fromFunctionM[R, E, I, O](f: (I) ⇒ ZIO[R, E, O]): ZTransducer[R, E, I, O]
Creates a transducer that effectfully transforms incoming values.
Creates a transducer that effectfully transforms incoming values.
- Annotations
- @deprecated
- Deprecated
(Since version 2.0.0) use fromFunctionZIO