Value Members

1.  final def !=(arg0: Any): Boolean

   Definition Classes

   AnyRef → Any

2.  final def ##(): Int

   Definition Classes

   AnyRef → Any

3.  final def ==(arg0: Any): Boolean

   Definition Classes

   AnyRef → Any

4.  final def asInstanceOf[T0]: T0

   Definition Classes

   Any

5.  def clone(): AnyRef

   Attributes

   protected[java.lang]

   Definition Classes

   AnyRef

   Annotations

   @throws( ... )

6.  def disconnectL[I, I2, O](cause: EarlyCause)(tee: Tee[I, I2, O]): Tee[Nothing, I2, O]

   Signals, that _left_ side of tee terminated.

   Signals, that _left_ side of tee terminated. That causes all succeeding AwaitL to terminate with cause giving chance to emit any values or read on right.

7.  def disconnectR[I, I2, O](cause: EarlyCause)(tee: Tee[I, I2, O]): Tee[I, Nothing, O]

   Signals, that _right_ side of tee terminated.

   Signals, that _right_ side of tee terminated. That causes all succeeding AwaitR to terminate with cause giving chance to emit any values or read on left.

8.  def drainL[I]: Tee[Any, I, I]

   Alternate pulling from the left, then right, repeatedly, starting on the left, and emitting only values from the right.

   Alternate pulling from the left, then right, repeatedly, starting on the left, and emitting only values from the right. When the left is exhausted, behaves like passR.

9.  def drainR[I]: Tee[I, Any, I]

   Alternate pulling from the left, then right, repeatedly, starting on the left, and emitting only values from the left.

   Alternate pulling from the left, then right, repeatedly, starting on the left, and emitting only values from the left. When the right is exhausted, behaves like passL.

10.  final def eq(arg0: AnyRef): Boolean

    Definition Classes

    AnyRef

11.  def equals(arg0: Any): Boolean

    Definition Classes

    AnyRef → Any

12.  def feed1L[I, I2, O](i: I)(t: Tee[I, I2, O]): Tee[I, I2, O]

    Feed one input to the left branch of this Tee.

13.  def feed1R[I, I2, O](i2: I2)(t: Tee[I, I2, O]): Tee[I, I2, O]

    Feed one input to the right branch of this Tee.

14.  def feedL[I, I2, O](i: Seq[I])(p: Tee[I, I2, O]): Tee[I, I2, O]

    Feed a sequence of inputs to the left side of a Tee.

15.  def feedR[I, I2, O](i: Seq[I2])(p: Tee[I, I2, O]): Tee[I, I2, O]

    Feed a sequence of inputs to the right side of a Tee.

16.  def finalize(): Unit

    Attributes

    protected[java.lang]

    Definition Classes

    AnyRef

    Annotations

    @throws( classOf[java.lang.Throwable] )

17.  final def getClass(): Class[_]

    Definition Classes

    AnyRef → Any

18.  def hashCode(): Int

    Definition Classes

    AnyRef → Any

19.  def interleave[I]: Tee[I, I, I]

    A Tee which alternates between emitting values from the left input and the right input.

20.  final def isInstanceOf[T0]: Boolean

    Definition Classes

    Any

21.  final def ne(arg0: AnyRef): Boolean

    Definition Classes

    AnyRef

22.  final def notify(): Unit

    Definition Classes

    AnyRef

23.  final def notifyAll(): Unit

    Definition Classes

    AnyRef

24.  def passL[I]: Tee[I, Any, I]

    A Tee which ignores all input from the right.

25.  def passR[I2]: Tee[Any, I2, I2]

    A Tee which ignores all input from left.

26.  def receiveL[I, I2, O](rcv: (I) ⇒ Tee[I, I2, O]): Tee[I, I2, O]

    Awaits to receive input from Left side, than if that request terminates with End or is terminated abnormally runs the supplied continue or cleanup.

    Awaits to receive input from Left side, than if that request terminates with End or is terminated abnormally runs the supplied continue or cleanup. Otherwise rcv is run to produce next state.

    If you don't need continue or cleanup use rather awaitL.flatMap

27.  def receiveLOr[I, I2, O](fb: ⇒ Tee[I, I2, O])(rcvL: (I) ⇒ Tee[I, I2, O]): Tee[I, I2, O]

    syntax sugar for receiveL

28.  def receiveR[I, I2, O](rcv: (I2) ⇒ Tee[I, I2, O]): Tee[I, I2, O]

    Awaits to receive input from Right side, than if that request terminates with End or is terminated abnormally runs the supplied continue.

    Awaits to receive input from Right side, than if that request terminates with End or is terminated abnormally runs the supplied continue. Otherwise rcv is run to produce next state.

    If you don't need continue or cleanup use rather awaitR.flatMap

29.  def receiveROr[I, I2, O](fb: ⇒ Tee[I, I2, O])(rcvR: (I2) ⇒ Tee[I, I2, O]): Tee[I, I2, O]

    syntax sugar for receiveR

30.  final def synchronized[T0](arg0: ⇒ T0): T0

    Definition Classes

    AnyRef

31.  def toString(): String

    Definition Classes

    AnyRef → Any

32.  def until[I]: Tee[Boolean, I, I]

    Echoes the right branch until the left branch becomes true, then halts.

33.  final def wait(): Unit

    Definition Classes

    AnyRef

    Annotations

    @throws( ... )

34.  final def wait(arg0: Long, arg1: Int): Unit

    Definition Classes

    AnyRef

    Annotations

    @throws( ... )

35.  final def wait(arg0: Long): Unit

    Definition Classes

    AnyRef

    Annotations

    @throws( ... )

36.  def when[I]: Tee[Boolean, I, I]

    Echoes the right branch when the left branch is true.

37.  def zip[I, I2]: Tee[I, I2, (I, I2)]

    Defined as zipWith((_,_))

38.  def zipAll[I, I2](padI: I, padI2: I2): Tee[I, I2, (I, I2)]

    A version of zip that pads the shorter stream with values.

39.  def zipApply[I, I2]: Tee[I, (I) ⇒ I2, I2]

    Defined as zipWith((arg,f) => f(arg)

40.  def zipWith[I, I2, O](f: (I, I2) ⇒ O): Tee[I, I2, O]

    Zip together two inputs, then apply the given function, halting as soon as either input is exhausted.

    Zip together two inputs, then apply the given function, halting as soon as either input is exhausted. This implementation reads from the left, then the right.

41.  def zipWithAll[I, I2, O](padI: I, padI2: I2)(f: (I, I2) ⇒ O): Tee[I, I2, O]

    A version of zipWith that pads the shorter stream with values.

42.  object AwaitL
43.  object AwaitR