ParallelEither

Instance Constructors

new ParallelEither(left: Transformer[A, L], right: Transformer[A, R])

left
The "left" transformer
right
The "right" transformer

Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

Definition Classes
AnyRef → Any
def +(other: String): String

Implicit information
This member is added by an implicit conversion from ParallelEither[A, L, R] to any2stringadd[ParallelEither[A, L, R]] performed by method any2stringadd in scala.Predef.
Definition Classes
any2stringadd
def ->[B](y: B): (ParallelEither[A, L, R], B)

Implicit information
This member is added by an implicit conversion from ParallelEither[A, L, R] to ArrowAssoc[ParallelEither[A, L, R]] performed by method ArrowAssoc in scala.Predef. This conversion will take place only if A is a superclass of XMLEvent (A >: XMLEvent).
Definition Classes
ArrowAssoc
Annotations
@inline()
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def >>[Out](end: Consumer[Either[L, R], Out]): Consumer[A, Out]

Definition Classes
Transformer
def >>[C](nextT: Transformer[Either[L, R], C]): Transformer[A, C]

Definition Classes
Transformer
def andThen[Out](end: Consumer[Either[L, R], Out]): Consumer[A, Out]

Definition Classes
Transformer
def andThen[C](nextT: Transformer[Either[L, R], C]): Transformer[A, C]

Definition Classes
Transformer
final def asInstanceOf[T0]: T0

Definition Classes
Any
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def collect[C](pf: PartialFunction[Either[L, R], C]): Transformer[A, C]

Definition Classes
Transformer
def consumeAsFold[R](init: R)(f: (R, Either[L, R]) ⇒ R): Consumer[A, R]

Definition Classes
Transformer
def consumeFirst: Consumer[A, Either[L, R]]

Definition Classes
Transformer
def consumeFirstOption: Consumer[A, Option[Either[L, R]]]

Definition Classes
Transformer
def consumeForEach(f: (Either[L, R]) ⇒ Any): Consumer[A, Unit]

Definition Classes
Transformer
def consumeToList: Consumer[A, List[Either[L, R]]]

Definition Classes
Transformer
def drop(n: Int): Transformer[A, Either[L, R]]

Definition Classes
Transformer
def dropWhile(p: (Either[L, R]) ⇒ Boolean): Transformer[A, Either[L, R]]

Definition Classes
Transformer
def ensuring(cond: (ParallelEither[A, L, R]) ⇒ Boolean, msg: ⇒ Any): ParallelEither[A, L, R]

Implicit information
This member is added by an implicit conversion from ParallelEither[A, L, R] to Ensuring[ParallelEither[A, L, R]] performed by method Ensuring in scala.Predef.
Definition Classes
Ensuring
def ensuring(cond: (ParallelEither[A, L, R]) ⇒ Boolean): ParallelEither[A, L, R]

Implicit information
This member is added by an implicit conversion from ParallelEither[A, L, R] to Ensuring[ParallelEither[A, L, R]] performed by method Ensuring in scala.Predef.
Definition Classes
Ensuring
def ensuring(cond: Boolean, msg: ⇒ Any): ParallelEither[A, L, R]

Implicit information
This member is added by an implicit conversion from ParallelEither[A, L, R] to Ensuring[ParallelEither[A, L, R]] performed by method Ensuring in scala.Predef.
Definition Classes
Ensuring
def ensuring(cond: Boolean): ParallelEither[A, L, R]

Implicit information
This member is added by an implicit conversion from ParallelEither[A, L, R] to Ensuring[ParallelEither[A, L, R]] performed by method Ensuring in scala.Predef.
Definition Classes
Ensuring
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def filter(p: (Either[L, R]) ⇒ Boolean): Transformer[A, Either[L, R]]

Definition Classes
Transformer
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
def formatted(fmtstr: String): String

Implicit information
This member is added by an implicit conversion from ParallelEither[A, L, R] to StringFormat[ParallelEither[A, L, R]] performed by method StringFormat in scala.Predef.
Definition Classes
StringFormat
Annotations
@inline()
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
val left: Transformer[A, L]

The "left" transformer
def makeHandler[Out](next: Handler[Either[L, R], Out]): Handler[A, Out]

Definition Classes
ParallelEither → Transformer
def map[C](f: (Either[L, R]) ⇒ C): Transformer[A, C]

Definition Classes
Transformer
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def parallel[In2 <: A, B2 >: Either[L, R]](other: Transformer[In2, B2]): Transformer[In2, B2]

Definition Classes
Transformer
def parallelEither[In2 <: A, C](other: Transformer[In2, C]): Transformer[In2, Either[Either[L, R], C]]

Definition Classes
Transformer
def parseAsFold[R](init: R)(f: (R, Either[L, R]) ⇒ R): Parser[R]

Implicit information
This member is added by an implicit conversion from ParallelEither[A, L, R] to spac.TransformerParsingOps[Either[L, R]] performed by method TransformerParsingOps in io.dylemma.spac.syntax.TransformerSyntax. This conversion will take place only if A is a superclass of XMLEvent (A >: XMLEvent).
Definition Classes
TransformerParsingOps
def parseFirst: Parser[Either[L, R]]

Implicit information
This member is added by an implicit conversion from ParallelEither[A, L, R] to spac.TransformerParsingOps[Either[L, R]] performed by method TransformerParsingOps in io.dylemma.spac.syntax.TransformerSyntax. This conversion will take place only if A is a superclass of XMLEvent (A >: XMLEvent).
Definition Classes
TransformerParsingOps
def parseFirstOption: Parser[Option[Either[L, R]]]

Implicit information
This member is added by an implicit conversion from ParallelEither[A, L, R] to spac.TransformerParsingOps[Either[L, R]] performed by method TransformerParsingOps in io.dylemma.spac.syntax.TransformerSyntax. This conversion will take place only if A is a superclass of XMLEvent (A >: XMLEvent).
Definition Classes
TransformerParsingOps
def parseToList: Parser[List[Either[L, R]]]

Implicit information
This member is added by an implicit conversion from ParallelEither[A, L, R] to spac.TransformerParsingOps[Either[L, R]] performed by method TransformerParsingOps in io.dylemma.spac.syntax.TransformerSyntax. This conversion will take place only if A is a superclass of XMLEvent (A >: XMLEvent).
Definition Classes
TransformerParsingOps
def parseWith[B](consumer: Consumer[Either[L, R], Try[B]]): Parser[B]

Attach a Consumer to this transformer to create a Parser.
Attach a Consumer to this transformer to create a Parser.
B
The type of the Results emitted by the consumer
consumer
All events passed through this transformer will be passed through the given consumer.
returns
A Parser whose result is the result of the consumer after receiving events from this transformer.

Implicit information
This member is added by an implicit conversion from ParallelEither[A, L, R] to spac.TransformerParsingOps[Either[L, R]] performed by method TransformerParsingOps in io.dylemma.spac.syntax.TransformerSyntax. This conversion will take place only if A is a superclass of XMLEvent (A >: XMLEvent).
Definition Classes
TransformerParsingOps
val right: Transformer[A, R]

The "right" transformer
def scan[S](init: S)(f: (S, Either[L, R]) ⇒ S): Transformer[A, S]

Definition Classes
Transformer
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def take(n: Int): Transformer[A, Either[L, R]]

Definition Classes
Transformer
def takeWhile(p: (Either[L, R]) ⇒ Boolean): Transformer[A, Either[L, R]]

Definition Classes
Transformer
def unwrapSafe[T](implicit ev: <:<[Either[L, R], Try[T]]): Transformer[A, T]

Definition Classes
Transformer
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( ... )
def withFilter(p: (Either[L, R]) ⇒ Boolean): Transformer[A, Either[L, R]]

Definition Classes
Transformer
def withSideEffect(effect: (Either[L, R]) ⇒ Any): Transformer[A, Either[L, R]]

Definition Classes
Transformer
def wrapSafe: Transformer[A, Try[Either[L, R]]]

Definition Classes
Transformer
def →[B](y: B): (ParallelEither[A, L, R], B)

Implicit information
This member is added by an implicit conversion from ParallelEither[A, L, R] to ArrowAssoc[ParallelEither[A, L, R]] performed by method ArrowAssoc in scala.Predef. This conversion will take place only if A is a superclass of XMLEvent (A >: XMLEvent).
Definition Classes
ArrowAssoc

Inherited from Serializable

Inherited from Product

Inherited from Equals

Inherited from Transformer[A, Either[L, R]]

Inherited from AnyRef

Inherited from Any

Inherited by implicit conversion TransformerParsingOps from ParallelEither[A, L, R] to spac.TransformerParsingOps[Either[L, R]]

Inherited by implicit conversion any2stringadd from ParallelEither[A, L, R] to any2stringadd[ParallelEither[A, L, R]]

Inherited by implicit conversion StringFormat from ParallelEither[A, L, R] to StringFormat[ParallelEither[A, L, R]]

Inherited by implicit conversion Ensuring from ParallelEither[A, L, R] to Ensuring[ParallelEither[A, L, R]]

Inherited by implicit conversion ArrowAssoc from ParallelEither[A, L, R] to ArrowAssoc[ParallelEither[A, L, R]]

Ungrouped

Related Doc: package Transformer

case class ParallelEither[A, L, R](left: Transformer[A, L], right: Transformer[A, R]) extends Transformer[A, Either[L, R]] with Product with Serializable

Instance Constructors

new ParallelEither(left: Transformer[A, L], right: Transformer[A, R])

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

def +(other: String): String

def ->[B](y: B): (ParallelEither[A, L, R], B)

final def ==(arg0: Any): Boolean

def >>[Out](end: Consumer[Either[L, R], Out]): Consumer[A, Out]

def >>[C](nextT: Transformer[Either[L, R], C]): Transformer[A, C]

def andThen[Out](end: Consumer[Either[L, R], Out]): Consumer[A, Out]

def andThen[C](nextT: Transformer[Either[L, R], C]): Transformer[A, C]

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def collect[C](pf: PartialFunction[Either[L, R], C]): Transformer[A, C]

def consumeAsFold[R](init: R)(f: (R, Either[L, R]) ⇒ R): Consumer[A, R]

def consumeFirst: Consumer[A, Either[L, R]]

def consumeFirstOption: Consumer[A, Option[Either[L, R]]]

def consumeForEach(f: (Either[L, R]) ⇒ Any): Consumer[A, Unit]

def consumeToList: Consumer[A, List[Either[L, R]]]

def drop(n: Int): Transformer[A, Either[L, R]]

def dropWhile(p: (Either[L, R]) ⇒ Boolean): Transformer[A, Either[L, R]]

def ensuring(cond: (ParallelEither[A, L, R]) ⇒ Boolean, msg: ⇒ Any): ParallelEither[A, L, R]

def ensuring(cond: (ParallelEither[A, L, R]) ⇒ Boolean): ParallelEither[A, L, R]

def ensuring(cond: Boolean, msg: ⇒ Any): ParallelEither[A, L, R]

def ensuring(cond: Boolean): ParallelEither[A, L, R]

final def eq(arg0: AnyRef): Boolean

def filter(p: (Either[L, R]) ⇒ Boolean): Transformer[A, Either[L, R]]

def finalize(): Unit

def formatted(fmtstr: String): String

final def getClass(): Class[_]

final def isInstanceOf[T0]: Boolean

val left: Transformer[A, L]

def makeHandler[Out](next: Handler[Either[L, R], Out]): Handler[A, Out]

def map[C](f: (Either[L, R]) ⇒ C): Transformer[A, C]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def parallel[In2 <: A, B2 >: Either[L, R]](other: Transformer[In2, B2]): Transformer[In2, B2]

def parallelEither[In2 <: A, C](other: Transformer[In2, C]): Transformer[In2, Either[Either[L, R], C]]

def parseAsFold[R](init: R)(f: (R, Either[L, R]) ⇒ R): Parser[R]

def parseFirst: Parser[Either[L, R]]

def parseFirstOption: Parser[Option[Either[L, R]]]

def parseToList: Parser[List[Either[L, R]]]

def parseWith[B](consumer: Consumer[Either[L, R], Try[B]]): Parser[B]

val right: Transformer[A, R]

def scan[S](init: S)(f: (S, Either[L, R]) ⇒ S): Transformer[A, S]

final def synchronized[T0](arg0: ⇒ T0): T0

def take(n: Int): Transformer[A, Either[L, R]]

def takeWhile(p: (Either[L, R]) ⇒ Boolean): Transformer[A, Either[L, R]]

def unwrapSafe[T](implicit ev: <:<[Either[L, R], Try[T]]): Transformer[A, T]

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def withFilter(p: (Either[L, R]) ⇒ Boolean): Transformer[A, Either[L, R]]

def withSideEffect(effect: (Either[L, R]) ⇒ Any): Transformer[A, Either[L, R]]

def wrapSafe: Transformer[A, Try[Either[L, R]]]

def →[B](y: B): (ParallelEither[A, L, R], B)

Inherited from Serializable

Inherited from Serializable

Inherited from Product

Inherited from Equals

Inherited from Transformer[A, Either[L, R]]

Inherited from AnyRef

Inherited from Any

Inherited by implicit conversion TransformerParsingOps from ParallelEither[A, L, R] to spac.TransformerParsingOps[Either[L, R]]

Inherited by implicit conversion any2stringadd from ParallelEither[A, L, R] to any2stringadd[ParallelEither[A, L, R]]

Inherited by implicit conversion StringFormat from ParallelEither[A, L, R] to StringFormat[ParallelEither[A, L, R]]

Inherited by implicit conversion Ensuring from ParallelEither[A, L, R] to Ensuring[ParallelEither[A, L, R]]

Inherited by implicit conversion ArrowAssoc from ParallelEither[A, L, R] to ArrowAssoc[ParallelEither[A, L, R]]

Ungrouped