stream

Type Members

1. sealed trait Cause extends AnyRef

   

   Defines termination cause for the process.

   Defines termination cause for the process. Cause is always wrapped in Halt and controls process flow.

2. type Channel[+F[_], -I, O] = Process[F, (I) ⇒ F[O]]

   

   An effectful channel, to which we can send values and get back responses.

   An effectful channel, to which we can send values and get back responses. Modeled as a source of effectful functions.

3. final class ChannelSyntax[F[_], I, O] extends AnyVal

   

4. final case class Exchange[I, W](read: Process[Task, I], write: Sink[Task, W]) extends Product with Serializable

   

   Exchange represents interconnection between two systems.

   Exchange represents interconnection between two systems. So called remote is resource from which program receives messages of type I and can send to it messages of type O.

   Typically this can be sort of connection to external system, like for example tcp connection to internet server.

   Exchange allows combining this pattern with Processes and allows to use different combinators to specify the Exchange behaviour.

   Exchange is currently specialized to scalaz.concurrent.Task

   I

   values read from remote system

   W

   values written to remote system

   read

   Process reading values from remote system

   write

   Process writing values to remote system

5. sealed trait Process[+F[_], +O] extends Process1Ops[F, O] with TeeOps[F, O]

   

   An effectful stream of O values.

   An effectful stream of O values. In between emitting values a Process may request evaluation of F effects. A Process[Nothing,A] is a pure Process with no effects. A Process[Task,A] may have Task effects. A Process halts due to some Cause, generally End (indicating normal termination) or Error(t) for some t: Throwable indicating abnormal termination due to some uncaught error.

6. type Process0[+O] = Process[Nothing, O]

   

7. type Process1[-I, +O] = Process[Is, O]

   

   A single input stream transducer.

   A single input stream transducer. Accepts input of type I, and emits values of type O.

8. final class Process1Syntax[I, O] extends AnyVal

   

9. sealed trait ReceiveY[+A, +B] extends AnyRef

   

10. type Sink[+F[_], -O] = Process[F, (O) ⇒ F[Unit]]

    

    An effectful sink, to which we can send values.

    An effectful sink, to which we can send values. Modeled as a source of effectful functions.

11. final class SinkSyntax[F[_], I] extends AnyVal

    

12. final class SinkTaskSyntax[I] extends AnyVal

    

13. type Tee[-I, -I2, +O] = Process[T, O]

    

    A stream transducer that can read from one of two inputs, the 'left' (of type I) or the 'right' (of type I2).

    A stream transducer that can read from one of two inputs, the 'left' (of type I) or the 'right' (of type I2). Process1[I,O] <: Tee[I,I2,O].

14. final class TeeSyntax[I, I2, O] extends AnyVal

    

    This class provides infix syntax specific to Tee.

    This class provides infix syntax specific to Tee. We put these here rather than trying to cram them into Process itself using implicit equality witnesses. This doesn't work out so well due to variance issues.

15. type TeeW[+W, -I, -I2, +O] = Process[T, \/[W, O]]

    

    A Tee that writes values of type W.

16. type Writer[+F[_], +W, +O] = Process[F, \/[W, O]]

    

    A Writer[F,W,O] is a Process[F, W \/ O].

    A Writer[F,W,O] is a Process[F, W \/ O]. See WriterSyntax for convenience functions for working with either the written values (the W) or the output values (the O).

    This is useful for logging or other situations where we want to emit some values 'on the side' while doing something else with the main output of a Process.

17. type Writer1[+W, -I, +O] = Process[Is, \/[W, O]]

    

    A Process1 that writes values of type W.

18. final class WriterSyntax[F[_], W, O] extends AnyVal

    

    Infix syntax for working with Writer[F,W,O].

    Infix syntax for working with Writer[F,W,O]. We call the W parameter the 'write' side of the Writer and O the 'output' side. Many method in this class end with either W or O, depending on what side they operate on.

19. final class WriterTaskSyntax[W, O] extends AnyVal

    

20. type Wye[-I, -I2, +O] = Process[Y, O]

    

    A stream transducer that can read from one of two inputs, non-deterministically.

21. trait WyeOps[+O] extends AnyRef

    

    Attributes

    protected

22. final class WyeSyntax[I, I2, O] extends AnyVal

    

    This class provides infix syntax specific to Wye.

    This class provides infix syntax specific to Wye. We put these here rather than trying to cram them into Process itself using implicit equality witnesses. This doesn't work out so well due to variance issues.

23. type WyeW[+W, -I, -I2, +O] = Process[Y, \/[W, O]]

    

    A Wye that writes values of type W.