molecule.stream.ichan

TestableIChan

trait TestableIChan[+A] extends IChan[A]

IChan that can be tested for the availability of data in memory.

Source
TestableIChan.scala
Linear Supertypes
IChan[A], AnyRef, Any
Known Subclasses
Ordering
  1. Alphabetic
  2. By inheritance
Inherited
  1. Hide All
  2. Show all
  1. TestableIChan
  2. IChan
  3. AnyRef
  4. Any
Visibility
  1. Public
  2. All

Abstract Value Members

  1. abstract def add[B](t: (IChan[A]) ⇒ IChan[B])(implicit arg0: Message[B]): IChan[B]

    Add a transformer to this channel.

    Add a transformer to this channel.

    t

    the transformer

    returns

    the transformed channel

    Definition Classes
    IChan
  2. abstract def poison(signal: Signal): Unit

    Poison this channel.

    Poison this channel. Any pending read continuation will be invoked with Seg.Nil and NilIChan(signal) as argument.

    signal

    the signal

    Definition Classes
    IChan
  3. abstract def read(t: UThread, k: (Seg[A], IChan[A]) ⇒ Unit): Unit

    Read a segment on this channel.

    Read a segment on this channel.

    t

    the user-level thread

    k

    the continuation invoked if there is a message

    Definition Classes
    IChan
  4. abstract def test(t: UThread, ready: (IChan[A]) ⇒ Unit): Unit

    The test operation is idempotent meaning that it can be invoked multiple times.

    The test operation is idempotent meaning that it can be invoked multiple times.

    A test extracts data from its underlying ichan and invokes the ready function on a buffered ichan if a segment is available or on the NilIChan if the underlying ichan is closed.

    The contract is the following: - Any channel buffering a non-empty segment is ready - A channel that contains an empty segment followed by a terminated channel is ready - A channel that contains an empty segment followed by a live channel is NOT ready

Concrete Value Members

  1. final def !=(arg0: AnyRef): Boolean

    Definition Classes
    AnyRef
  2. final def !=(arg0: Any): Boolean

    Definition Classes
    Any
  3. final def ##(): Int

    Definition Classes
    AnyRef → Any
  4. abstract def ++:[B](s: Seg[B]): IChan[B]

    [use case] Prepend a segment.

    [use case]

    Prepend a segment.

    returns

    an input which produces the segment and which continues with the remaining of the stream.

    Definition Classes
    IChan
  5. def ++:[B >: A](seg: Seg[B])(implicit arg0: Message[B]): IChan[B]

    Prepend a segment.

    Prepend a segment.

    seg

    the segment to prepend.

    returns

    an input which produces the segment and which continues with the remaining of the stream.

    Definition Classes
    IChan
  6. abstract def +:(x: A): IChan[A]

    [use case] Prepend a message on this channel.

    [use case]

    Prepend a message on this channel.

    x

    the message to prepend.

    returns

    an input which produces x as first message and which continues with the remaining of the stream.

    Definition Classes
    IChan
  7. def +:[B >: A](b: B)(implicit arg0: Message[B]): IChan[B]

    Prepend a message on this channel.

    Prepend a message on this channel.

    returns

    an input which produces x as first message and which continues with the remaining of the stream.

    Definition Classes
    IChan
  8. abstract def ::(x: A): IChan[A]

    [use case] Prepend a message on this channel.

    [use case]

    Prepend a message on this channel.

    x

    the message to prepend.

    returns

    an input which produces x as first message and which continues with the remaining of the stream.

    Definition Classes
    IChan
  9. def ::[B >: A](b: B)(implicit arg0: Message[B]): IChan[B]

    Prepend a message on this channel.

    Prepend a message on this channel.

    returns

    an input which produces x as first message and which continues with the remaining of the stream.

    Definition Classes
    IChan
  10. final def ==(arg0: AnyRef): Boolean

    Definition Classes
    AnyRef
  11. final def ==(arg0: Any): Boolean

    Definition Classes
    Any
  12. def >>\[B](f: (A, IChan[A]) ⇒ IChan[B])(implicit ma: Message[A], mb: Message[B]): IChan[B]

    Operator equivalent to flatMap

    Operator equivalent to flatMap

    Definition Classes
    IChan
  13. def append[B >: A](next: ⇒ IChan[B]): IChan[B]

    Append a stream after this stream only if this stream terminates normally with EOS.

    Append a stream after this stream only if this stream terminates normally with EOS.

    next

    the stream to append.

    returns

    the appended stream.

    Definition Classes
    IChan
  14. final def asInstanceOf[T0]: T0

    Definition Classes
    Any
  15. def clone(): AnyRef

    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws()
  16. abstract def collect[B](pf: PartialFunction[A, B]): IChan[B]

    [use case] Builds a new input by applying a partial function to all messages of this input on which the function is defined.

    [use case]

    Builds a new input by applying a partial function to all messages of this input on which the function is defined.

    B

    the message type of the returned input channel.

    pf

    the partial function which filters and maps the stream elements.

    returns

    a new input resulting from applying the partial function pf to each message on which it is defined. The order of the messages is preserved.

    Definition Classes
    IChan
  17. def collect[B](f: PartialFunction[A, B])(implicit ma: Message[A], mb: Message[B]): IChan[B]

    Builds a new input by applying a partial function to all messages of this input on which the function is defined.

    Builds a new input by applying a partial function to all messages of this input on which the function is defined.

    B

    the message type of the returned input channel.

    returns

    a new input resulting from applying the partial function pf to each message on which it is defined. The order of the messages is preserved.

    Definition Classes
    IChan
  18. def compress[B](f: (Seg[A]) ⇒ B)(implicit arg0: Message[B]): IChan[B]

    Builds a new input that compresses the content of each segment into a single value.

    Builds a new input that compresses the content of each segment into a single value.

    f

    A function converting segments to a single value.

    returns

    The compressed input.

    Definition Classes
    IChan
  19. def connect[B >: A](ochan: OChan[B]): Process[Either[Signal, Signal]]

    Transfer the content of this input to an output.

    Transfer the content of this input to an output. The input/output will be closed with the same signal as the output/input.

    returns

    stream whose result indicates which channel was closed first (Left for ichan, Right for ochan)

    Definition Classes
    IChan
  20. def debug(label: String, f: (A) ⇒ String = _.toString)(implicit ma: Message[A]): IChan[A]

    Builds a new debugging input that prints every message received.

    Builds a new debugging input that prints every message received.

    label

    the label to put in front of each debug line.

    f

    A function converting messages to a string (defaults to _.toString).

    returns

    The same input excepted each message will be printed.

    Definition Classes
    IChan
  21. def drop(n: Int)(implicit ma: Message[A]): IChan[A]

    Selects all elements except first n ones.

    Selects all elements except first n ones.

    n

    the number of elements to drop from this stream.

    returns

    an input consisting of all elements of this input except the first n ones.

    Definition Classes
    IChan
  22. def dropWhile(p: (A) ⇒ Boolean)(implicit ma: Message[A]): IChan[A]

    Skips longest sequence of elements of this input which satisfy given predicate p, and returns an input of the remaining elements.

    Skips longest sequence of elements of this input which satisfy given predicate p, and returns an input of the remaining elements.

    p

    the predicate used to skip elements.

    returns

    an input producing the remaining elements

    Definition Classes
    IChan
  23. final def eq(arg0: AnyRef): Boolean

    Definition Classes
    AnyRef
  24. def equals(arg0: Any): Boolean

    Definition Classes
    AnyRef → Any
  25. def filter(p: (A) ⇒ Boolean)(implicit ma: Message[A]): IChan[A]

    Selects all messages of this input which satisfy a predicate.

    Selects all messages of this input which satisfy a predicate.

    p

    the predicate used to test messages.

    returns

    a new input consisting of all messages of this input that satisfy the given predicate p. The order of the messages is preserved.

    Definition Classes
    IChan
  26. def finalize(): Unit

    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws()
  27. abstract def flatMap[B](f: (A, IChan[A]) ⇒ IChan[B]): IChan[B]

    [use case] Builds a new input by applying a function to the first message parsed in a stream and the seed of remaining stream.

    [use case]

    Builds a new input by applying a function to the first message parsed in a stream and the seed of remaining stream. The new input will then behave like the stream reurned by that function.

    B

    the element produced by the parser.

    f

    the function.

    returns

    a new input channel resulting from applying the function f.

    Definition Classes
    IChan
  28. def flatMap[C >: A, B, D](parser: Parser[C, B], f: (B, IChan[C]) ⇒ IChan[D])(implicit mb: Message[C]): IChan[D]

    Builds a new input by applying a function to the first message parsed in a stream and the seed of remaining stream.

    Builds a new input by applying a function to the first message parsed in a stream and the seed of remaining stream. The new input will then behave like the stream reurned by that function.

    B

    the element produced by the parser.

    D

    the message type of the returned input channel.

    parser

    the parser used to parse the first message.

    f

    the function.

    returns

    a new input channel resulting from applying the function f.

    Definition Classes
    IChan
  29. abstract def flatMap[B](f: (A, IChan[A]) ⇒ IChan[B]): IChan[B]

    [use case] Builds a new input by applying a function to the first message in a stream and the seed of remaining stream.

    [use case]

    Builds a new input by applying a function to the first message in a stream and the seed of remaining stream. The new input will then behave like the stream returned by that function.

    B

    the message type of the returned input channel.

    f

    the function.

    returns

    a new input channel resulting from applying the function f.

    Definition Classes
    IChan
  30. def flatMap[B](f: (A, IChan[A]) ⇒ IChan[B])(implicit ma: Message[A], mb: Message[B]): IChan[B]

    Builds a new input by applying a function to the first message in a stream and the seed of remaining stream.

    Builds a new input by applying a function to the first message in a stream and the seed of remaining stream. The new input will then behave like the stream returned by that function.

    B

    the message type of the returned input channel.

    f

    the function.

    returns

    a new input channel resulting from applying the function f.

    Definition Classes
    IChan
  31. abstract def flatMapSeg[B](f: (A) ⇒ Seg[B]): Seg[B]

    [use case] Builds a new collection by applying a function to all messages of this channel and concatenating the results.

    [use case]

    Builds a new collection by applying a function to all messages of this channel and concatenating the results.

    B

    the message type of the returned collection.

    f

    the function to apply to each message.

    returns

    a new channel resulting from applying the given collection-valued function f to each message of this channel and concatenating the results.

    Definition Classes
    IChan
  32. def flatMapSeg[B](f: (A) ⇒ Seg[B])(implicit ma: Message[A], mb: Message[B]): IChan[B]

    Builds a new collection by applying a function to all messages of this channel and concatenating the results.

    Builds a new collection by applying a function to all messages of this channel and concatenating the results.

    B

    the message type of the returned collection.

    f

    the function to apply to each message.

    returns

    a new channel resulting from applying the given collection-valued function f to each message of this channel and concatenating the results.

    Definition Classes
    IChan
  33. abstract def flatten[B]: IChan[B]

    [use case] Converts this input stream of traversable collections into an input stream in which all message collections are concatenated.

    [use case]

    Converts this input stream of traversable collections into an input stream in which all message collections are concatenated.

    B

    the type of the messages of each traversable collection.

    returns

    a new input resulting from concatenating all the Traversable collections.

    Definition Classes
    IChan
  34. def flatten[B](implicit asTraversable: (A) ⇒ Traversable[B], message: Message[B]): IChan[B]

    Converts this input stream of traversable collections into an input stream in which all message collections are concatenated.

    Converts this input stream of traversable collections into an input stream in which all message collections are concatenated.

    B

    the type of the messages of each traversable collection.

    asTraversable

    an implicit conversion which asserts that the message type of this input channel is a Traversable.

    message

    an implicit message definition for the message type of the Traversable.

    returns

    a new input resulting from concatenating all the Traversable collections.

    Definition Classes
    IChan
  35. def fold[B](z: B)(op: (B, A) ⇒ B)(implicit arg0: Message[B]): Process[B]

    Applies a binary operator to a start value and all messages of this channel, going left to right.

    Applies a binary operator to a start value and all messages of this channel, going left to right.

    B

    the result type of the binary operator.

    z

    the start value.

    op

    the binary operator.

    returns

    the result of inserting op between consecutive messages of this channel, going left to right with the start value z on the left:

                op(...op(z, x,,1,,), x,,2,,, ..., x,,n,,)
    

    where x1, ..., xn are the messages of this segment.

    Definition Classes
    IChan
  36. def foreach[B](f: (A) ⇒ B): Process[Unit]

    Apply sequentially a side effectful function to each message in the stream.

    Apply sequentially a side effectful function to each message in the stream.

    f

    the effectful function that will be applied to each element of the sequence

    returns

    stream whose result indicates the termination of the foreach operation.

    Definition Classes
    IChan
  37. def forward[B >: A](ochan: OChan[B]): Process[(IChan[B], OChan[B])]

    Forward asynchronously the content of this input to an output.

    Forward asynchronously the content of this input to an output. It stops as soon as one of the two channel is poisoned and it does not propagate the poison signal.

    returns

    A stream that returns the channels after the forward operation. If the stream completed successfully the input channel will be closed, otherwise the output channel is poisoned.

    Definition Classes
    IChan
  38. final def getClass(): java.lang.Class[_]

    Definition Classes
    AnyRef → Any
  39. def grouped(size: Int)(implicit ma: Message[A]): IChan[Seg[A]]

    Returns an input which groups messages produced by this input into fixed size blocks.

    Returns an input which groups messages produced by this input into fixed size blocks. The last group may contain less messages the number of messages receives is not a multiple of the group size.

    size

    the size of the groups.

    returns

    an input producing the groups

    Definition Classes
    IChan
  40. def hashCode(): Int

    Definition Classes
    AnyRef → Any
  41. def interleave[B](right: IChan[B], closeIfLeftClosed: Boolean, closeIfRightClosed: Boolean)(implicit ma: Message[A], mb: Message[B]): IChan[Either[A, B]]

    Interleave the messages produced asynchronously on this channel with the messages produced on an other channel.

    Interleave the messages produced asynchronously on this channel with the messages produced on an other channel. This builds a new input channel that produces one message of type Either[A, B] for every message produce on this or the other channel, where A is the type of messages produced on this channel and B is the type of messages produced on the other channel. By default, the resulting channel is closed when both input channels are closed.

    right

    the other input channel

    closeIfLeftClosed

    flag that indicating if the resulting channel must be closed if this channel is closed.

    closeIfRightClosed

    flag that indicating if the resulting channel must be closed if the other channel is closed.

    returns

    a new input channel that produces messages of type Either[A, B] for every message produced on this or the other channel

    Definition Classes
    IChan
  42. final def isInstanceOf[T0]: Boolean

    Definition Classes
    Any
  43. abstract def join[B]: IChan[B]

    [use case] Monadic 'join' operator M[M[A]] => M[A].

    [use case]

    Monadic 'join' operator M[M[A]] => M[A]. Converts this stream of stream into an stream, which merges messages from all the sub-streams.

    B

    the type of the messages of sub-streams.

    returns

    a new input resulting from merging all the sub-streams.

    Definition Classes
    IChan
  44. def join[B](implicit asIChan: (A) ⇒ IChan[B], ma: Message[A], mb: Message[B]): IChan[B]

    Monadic 'join' operator M[M[A]] => M[A].

    Monadic 'join' operator M[M[A]] => M[A]. Converts this stream of stream into an stream, which merges messages from all the sub-streams.

    B

    the type of the messages of sub-streams.

    asIChan

    an implicit conversion which asserts that the message type of this input channel is an IChan.

    ma

    an implicit message definition for the message type of this stream.

    mb

    an implicit message definition for the message type of the sub-stream.

    returns

    a new input resulting from merging all the sub-streams.

    Definition Classes
    IChan
  45. def join[B](right: IChan[B])(implicit ma: Message[A], mb: Message[B]): IChan[(A, B)]

    Join the messages produced asynchronously on this channel with the messages produced on an other channel.

    Join the messages produced asynchronously on this channel with the messages produced on an other channel. This builds a new input channel that produces tuples of type (A, B) each time a new message of type A or B is available, where A is the type of messages produced on this channel and B is the type of messages produced on the other channel. The resulting channel is closed both input channels are closed.

    right

    the other input channel

    returns

    a new input channel that produces messages of type (A, B) for every message produced on this or the other channel

    Definition Classes
    IChan
  46. abstract def map[B](f: (A) ⇒ B): IChan[B]

    [use case] Builds a new input by applying a function to all messages of this input.

    [use case]

    Builds a new input by applying a function to all messages of this input.

    B

    the message type of the returned input.

    f

    the function to apply to each message.

    returns

    a new input resulting from applying the given function f to each message of this input.

    Definition Classes
    IChan
  47. def map[B](f: (A) ⇒ B)(implicit arg0: Message[B]): IChan[B]

    Builds a new input by applying a function to all messages of this input.

    Builds a new input by applying a function to all messages of this input.

    B

    the message type of the returned input.

    f

    the function to apply to each message.

    returns

    a new input resulting from applying the given function f to each message of this input.

    Definition Classes
    IChan
  48. abstract def mapMany[B](f: (A) ⇒ IChan[B]): IChan[B]

    [use case] Create an input stream by merging all the input streams created by applying the function f to all the elements of this input stream.

    [use case]

    Create an input stream by merging all the input streams created by applying the function f to all the elements of this input stream.

    B

    the type of the messages of input streams created by f.

    f

    a function that creates new input streams from each element of this stream.

    returns

    a new input resulting from merging all the streams created by applying f to each elements of this stream.

    Definition Classes
    IChan
  49. def mapMany[B](f: (A) ⇒ IChan[B])(implicit ma: Message[A], mb: Message[B]): IChan[B]

    Create an input stream by merging all the input streams created by applying the function f to all the elements of this input stream.

    Create an input stream by merging all the input streams created by applying the function f to all the elements of this input stream.

    B

    the type of the messages of input streams created by f.

    f

    a function that creates new input streams from each element of this stream.

    ma

    an implicit message definition for the message type of this input.

    mb

    an implicit message definition for the message type of the new streams.

    returns

    a new input resulting from merging all the streams created by applying f to each elements of this stream.

    Definition Classes
    IChan
  50. abstract def mapP[B](f: (A) ⇒ Process[B]): IChan[B]

    [use case] Builds a new input by applying a function that returns a process to all messages of this input.

    [use case]

    Builds a new input by applying a function that returns a process to all messages of this input.

    B

    the message type of the returned input.

    f

    the function to apply to each message.

    returns

    a new input resulting from applying the given function f to each message of this input.

    Definition Classes
    IChan
  51. def mapP[B](f: (A) ⇒ Process[B])(implicit ma: Message[A], mb: Message[B]): IChan[B]

    Builds a new input by applying a function that returns a process to all messages of this input.

    Builds a new input by applying a function that returns a process to all messages of this input.

    B

    the message type of the returned input.

    f

    the function to apply to each message.

    returns

    a new input resulting from applying the given function f to each message of this input.

    Definition Classes
    IChan
  52. abstract def mapSeg[B](f: (Seg[A]) ⇒ Seg[B]): IChan[B]

    [use case] Builds a new input by applying a function to all segments of this input.

    [use case]

    Builds a new input by applying a function to all segments of this input.

    B

    the message type of the returned input.

    f

    the function to apply to each message.

    returns

    a new input resulting from applying the given function f to each segment of this input.

    Definition Classes
    IChan
  53. def mapSeg[B](f: (Seg[A]) ⇒ Seg[B])(implicit arg0: Message[B]): IChan[B]

    Builds a new input by applying a function to all segments of this input.

    Builds a new input by applying a function to all segments of this input.

    B

    the message type of the returned input.

    f

    the function to apply to each message.

    returns

    a new input resulting from applying the given function f to each segment of this input.

    Definition Classes
    IChan
  54. def merge[B >: A](right: IChan[B])(implicit mb: Message[B]): IChan[B]

    Merge the streams of two channels.

    Merge the streams of two channels. This builds a new input channel that produces messages from this channel and the other channel.

    right

    the other input channel

    returns

    a new input channel that produces messages coming on both input channels

    Definition Classes
    IChan
  55. final def ne(arg0: AnyRef): Boolean

    Definition Classes
    AnyRef
  56. final def notify(): Unit

    Definition Classes
    AnyRef
  57. final def notifyAll(): Unit

    Definition Classes
    AnyRef
  58. def onError[B >: A](next: ⇒ IChan[B]): IChan[B]

    Append a stream after this stream only if this stream terminates abnormally with a signal that is not EOS.

    Append a stream after this stream only if this stream terminates abnormally with a signal that is not EOS.

    next

    the stream to append in case of an error signal.

    returns

    the appended stream.

    Definition Classes
    IChan
  59. def onSignal[B >: A](next: PartialFunction[Signal, IChan[B]]): IChan[B]

    Append a stream after this stream if this stream terminates with the signal for which the partial function is defined.

    Append a stream after this stream if this stream terminates with the signal for which the partial function is defined.

    next

    the partial function returning the stream to append if the signal matches the signal(s) for which it is defined.

    returns

    the appended stream.

    Definition Classes
    IChan
  60. def parse[C >: A, B](parse: Parser[C, B])(implicit arg0: Message[C], arg1: Message[B]): IChan[B]

    Produces an input resulting from applying a repeatedly a parser combinator to this input stream.

    Produces an input resulting from applying a repeatedly a parser combinator to this input stream.

    C

    the type of the messages parsed

    B

    the type of the messages in the resulting input

    returns

    input with parsed results

    Definition Classes
    IChan
  61. def scan[B](z: B)(f: (B, A) ⇒ B)(implicit arg0: Message[B]): IChan[B]

    Produces a collection containing cummulative results of applying the operator going first to last message.

    Produces a collection containing cummulative results of applying the operator going first to last message.

    B

    the type of the messages in the resulting input

    z

    the initial value

    returns

    input with intermediate results

    Definition Classes
    IChan
  62. def smap[S, B](z: S)(fsm: (S, A) ⇒ (S, B))(implicit arg0: Message[B]): IChan[B]

    Produces an input containing cummulative results of applying the operator going first to last message.

    Produces an input containing cummulative results of applying the operator going first to last message.

    B

    the type of the messages in the resulting input

    z

    the initial state

    returns

    input with intermediate results

    Definition Classes
    IChan
  63. def span(p: (A) ⇒ Boolean)(implicit ma: Message[A]): IChan[A]

    Create an input that produces longest sequence of this input that satisfy predicate p.

    Create an input that produces longest sequence of this input that satisfy predicate p. The input stream is poisoned after the the conforming messages have been consumed.

    p

    the predicate to satisfy

    returns

    an input producing only of the first messages that satisfy the predicate.

    Definition Classes
    IChan
  64. def span[B >: A](p: (B) ⇒ Boolean, tailK: (IChan[B]) ⇒ IChan[B])(implicit ma: Message[B]): IChan[B]

    Create an input that produces longest sequence of this input that satisfy predicate p.

    Create an input that produces longest sequence of this input that satisfy predicate p.

    p

    the predicate to satisfy

    tailK

    a function that takes the remaining of the stream as argument

    returns

    an input producing only of the first messages that satisfy the predicate.

    Definition Classes
    IChan
  65. def step(t: UThread)(more: (A, IChan[A]) ⇒ Unit)(empty: (Signal) ⇒ Unit)(implicit m: Message[A]): Unit

    Read one message on this channel.

    Read one message on this channel.

    t

    the user-level thread

    more

    the continuation invoked if there is a message

    empty

    the continuation invoked if the channel is closed

    Definition Classes
    IChan
  66. final def synchronized[T0](arg0: ⇒ T0): T0

    Definition Classes
    AnyRef
  67. def take(size: Int)(implicit ma: Message[A]): IChan[A]

    Create an input that produces first n messages of this input.

    Create an input that produces first n messages of this input. The input stream is poisoned after the n messages have been consumed.

    returns

    an input producing only of the first n messages of this input, or less than n messages if the input produces less messages.

    Definition Classes
    IChan
  68. def take[B >: A](n: Int, tailK: (IChan[B]) ⇒ IChan[B])(implicit ma: Message[B]): IChan[B]

    Create an input that produces first n messages of this input.

    Create an input that produces first n messages of this input.

    n

    the number of messages to take

    tailK

    a function that takes the remaining of the stream as argument if it is not terminated

    returns

    an input producing only of the first n messages of this input, or less than n messages if the input produces less messages.

    Definition Classes
    IChan
  69. def takeUntil[B](splitter: IChan[B])(implicit ma: Message[A], mb: Message[B]): IChan[A]

    Create an input that produces messages of this input until an event occurs.

    Create an input that produces messages of this input until an event occurs. The input stream is poisoned after the n messages have been consumed.

    splitter

    a channel that delivers the message that will split the current channel.

    returns

    an input producing messages of this input until the splitter produces and event, or all the messages if the splitter never delivers an event.

    Definition Classes
    IChan
  70. def takeUntil[B >: A, C](splitter: IChan[C], tailK: (Either[Signal, (C, IChan[C], IChan[B])]) ⇒ IChan[B])(implicit ma: Message[B], mc: Message[C]): IChan[B]

    Create an input that produces messages of this input until an event occurs.

    Create an input that produces messages of this input until an event occurs.

    splitter

    a channel that delivers the message that will split the current channel

    tailK

    a function that takes the remaining of the stream as argument if it is not terminated. tailK is invoked with the signal from the splitter if it is terminated.

    returns

    an input producing messages of this input until the splitter produces and event, or all the messages if the splitter never delivers an event.

    Definition Classes
    IChan
  71. def testable(implicit ma: Message[A]): TestableIChan[A]

    Definition Classes
    IChan
  72. def toString(): String

    Definition Classes
    AnyRef → Any
  73. final def wait(): Unit

    Definition Classes
    AnyRef
    Annotations
    @throws()
  74. final def wait(arg0: Long, arg1: Int): Unit

    Definition Classes
    AnyRef
    Annotations
    @throws()
  75. final def wait(arg0: Long): Unit

    Definition Classes
    AnyRef
    Annotations
    @throws()
  76. def zip[B](right: IChan[B])(implicit ma: Message[A], mb: Message[B]): IChan[(A, B)]

    Zip and hence synchronize the streams of two channels.

    Zip and hence synchronize the streams of two channels. This builds a new input channel that produces pair of messages from this channel and the other channel.

    right

    the other input channel

    returns

    a new input channel that produces pairs of messages coming on both input channels

    Definition Classes
    IChan
  77. abstract def zipWithBigIndex: IChan[(A, BigDecimal)]

    [use case] Zips a stream with its indices.

    [use case]

    Zips a stream with its indices.

    returns

    A new stream containing pairs consisting of all elements of this stream paired with their index. Indices start at 0.

    Definition Classes
    IChan
  78. def zipWithBigIndex(implicit ma: Message[A]): IChan[(A, BigDecimal)]

    Zips a stream with its indices.

    Zips a stream with its indices.

    returns

    A new stream containing pairs consisting of all elements of this stream paired with their index. Indices start at 0.

    Definition Classes
    IChan
  79. abstract def zipWithIndex: IChan[(A, Long)]

    [use case] Zips a stream with its indices.

    [use case]

    Zips a stream with its indices.

    returns

    A new stream containing pairs consisting of all elements of this stream paired with their index. Indices start at 0.

    Definition Classes
    IChan
  80. def zipWithIndex(implicit ma: Message[A]): IChan[(A, Long)]

    Zips a stream with its indices.

    Zips a stream with its indices.

    returns

    A new stream containing pairs consisting of all elements of this stream paired with their index. Indices start at 0.

    Definition Classes
    IChan

Inherited from IChan[A]

Inherited from AnyRef

Inherited from Any