libretto/libretto/CoreStreams/LPollable

LPollable

object LPollable
class Object
trait Matchable
class Any

Value members

Methods

def close[A]: LPollable[A] -⚬ Done
def concatenate[A]: LPollable[A] |*| Delayed[LPollable[A]] -⚬ LPollable[A]

The second LPollable is "delayed" because that gives flexibility in how the Done signal resulting from the exhaustion of the first LPollable is awaited. For example, if polling of the second LPollable should be delayed until the first LPollable is completely shut down, we can use delay to delay the second LPollable. If polling of the second LPollable should start as soon as it is known that there are no more elements in the first LPollable, we can use delayClosed to delay the second LPollable.

def cons[A](A: PAffine[A]): A |*| LPollable[A] -⚬ LPollable[A]
def delay[A](`evidence$2`: Positive[A]): LPollable[A] -⚬ Delayed[LPollable[A]]

Delays the first action (poll or close) on this LPollable.

def delayBy[A](ev: Positive[A]): Done |*| LPollable[A] -⚬ LPollable[A]

Delays the first action (poll or close) until the Done signal completes.

def delayClosed[A]: LPollable[A] -⚬ Delayed[LPollable[A]]

Delays the final Done signal resulting from close or end of stream.

def delayClosedBy[A]: Done |*| LPollable[A] -⚬ LPollable[A]

Delays the final Done signal (signaling end of stream or completed close) until the given Done signal completes.

def delayedPoll[A](`evidence$1`: Positive[A]): Done |*| LPollable[A] -⚬ LPolled[A]
def drain[A](A: PComonoid[A]): LPollable[A] -⚬ Done

Polls and discards all elements.

def empty[A]: Done -⚬ LPollable[A]
def forEachSequentially[A](f: A -⚬ Done)(`evidence$3`: Positive[A]): LPollable[A] -⚬ Done
def from[A, B](onClose: A -⚬ Done, onPoll: A -⚬ LPolled[B]): A -⚬ LPollable[B]
def fromLList[A](A: PAffine[A]): LList[A] -⚬ LPollable[A]
def map[A, B](f: A -⚬ B): LPollable[A] -⚬ LPollable[B]
def merge[A](A1: Positive[A], A2: PComonoid[A]): LPollable[A] |*| LPollable[A] -⚬ LPollable[A]

Merges two LPollables into one. Left-biased: when there is a value available from both upstreams, favors the first one.

def mergeAll[A](A1: Positive[A], A2: PComonoid[A]): LList[LPollable[A]] -⚬ LPollable[A]

Merges a list of LPollables into a single LPollable. Head-biased: when there is an element available from multiple upstreams, favors the upstream closest to the head of the input list.

def of[A](as: One -⚬ A*)(A: PAffine[A]): One -⚬ LPollable[A]
def partition[A, B]: LPollable[A |+| B] -⚬ LPollable[A] |*| LPollable[B]

Splits a stream of "A or B" to a stream of A and a stream of B.

Polls the upstream only after ''both'' downstreams poll. When either of the downstreams closes, the other downstream and the upstream are closed as well.

def poll[A]: LPollable[A] -⚬ LPolled[A]
def signalAction[A]: Need |*| LPollable[A] -⚬ LPollable[A]

Signals the first action (i.e. poll or close) via a negative (i.e. Need) signal.

Implicits

Implicits

implicit def negativeLPollable[A](A: Positive[A]): Negative[LPollable[A]]
implicit def negativeSignaling[A]: Negative[LPollable[A]]
implicit def pAffineLPollable[A]: PAffine[LPollable[A]]
implicit def positiveJunction[A](A: Positive[A]): Positive[LPollable[A]]