Transformer

abstract def makeHandler[Out](next: Handler[B, Out]): Handler[In, Out]

final def !=(arg0: Any): Boolean

final def ##(): Int

def +(other: String): String

def ->[B](y: B): (Transformer[In, B], B)

final def ==(arg0: Any): Boolean

def >>[Out](end: Parser[B, Out]): Parser[In, Out]

def >>[C](nextT: Transformer[B, C]): Transformer[In, C]

def andThen[Out](end: Parser[B, Out]): Parser[In, Out]

def andThen[C](nextT: Transformer[B, C]): Transformer[In, C]

def andThen[A](g: (Transformer[In, B]) ⇒ A): (Any) ⇒ A

def apply(v1: Any): Transformer[In, B]

Transformers count as functions that return themselves, so they can be used easily with Splitter's throughT method.

final def asInstanceOf[T0]: T0

def cast[B2](implicit ev: <:<[B, B2]): Transformer[In, B2]

def clone(): AnyRef

def collect[C](pf: PartialFunction[B, C]): Transformer[In, C]

def compose[A](g: (A) ⇒ Any): (A) ⇒ Transformer[In, B]

def drop(n: Int): Transformer[In, B]

def dropWhile(p: (B) ⇒ Boolean): Transformer[In, B]

def ensuring(cond: (Transformer[In, B]) ⇒ Boolean, msg: ⇒ Any): Transformer[In, B]

def ensuring(cond: (Transformer[In, B]) ⇒ Boolean): Transformer[In, B]

def ensuring(cond: Boolean, msg: ⇒ Any): Transformer[In, B]

def ensuring(cond: Boolean): Transformer[In, B]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def filter(p: (B) ⇒ Boolean): Transformer[In, B]

def finalize(): Unit

def flatten[B2](implicit ev: <:<[B, Iterable[B2]]): Transformer[In, B2]

def formatted(fmtstr: String): String

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

def map[C](f: (B) ⇒ C): Transformer[In, C]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def parallel[In2 <: In, B2 >: B](other: Transformer[In2, B2]): Transformer[In2, B2]

def parallelEither[In2 <: In, C](other: Transformer[In2, C]): Transformer[In2, Either[B, C]]

def parseAsFold[Out](init: Out)(f: (Out, B) ⇒ Out): Parser[In, Out]

def parseFirst: Parser[In, B]

def parseFirstOption: Parser[In, Option[B]]

def parseForeach(f: (B) ⇒ Any): Parser[In, Unit]

def parseToList: Parser[In, List[B]]

def parseToMap[K, V](implicit ev: <:<[B, (K, V)]): Parser[In, Map[K, V]]

def parseWith[Out](consumer: Parser[B, Out], setDebugName: Option[String] = None): Parser[In, Out]

def scan[S](init: S)(f: (S, B) ⇒ S): Transformer[In, S]

def sink: Parser[In, Unit]

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

def take(n: Int): Transformer[In, B]

def takeWhile(p: (B) ⇒ Boolean): Transformer[In, B]

def toString(): String

def transform[R](src: R)(implicit cl: ConsumableLike[R, In]): Iterator[B] with Closeable

Transform a src resource with this transformer, yielding an iterator which will lazily consume the resource stream.

def unwrapSafe[T](implicit ev: <:<[B, Try[T]]): Transformer[In, T]

def upcast[In2 <: In, B2 >: B]: Transformer[In2, B2]

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def withFilter(p: (B) ⇒ Boolean): Transformer[In, B]

def withSideEffect(effect: (B) ⇒ Any): Transformer[In, B]

def wrapSafe: Transformer[In, Try[B]]

def →[B](y: B): (Transformer[In, B], B)