Rule

abstract def apply(v1: In): Result[Out, A, X]

abstract val factory: Rules

final def !=(arg0: Any): Boolean

def !^[Y](fx2y: (X) ⇒ Y): Rule[In, Out, A, Y]

Maps an Error

final def ##(): Int

def -[In2 <: In](exclude: ⇒ Rule[In2, Any, Any, Any]): Rule[In2, Out, A, X]

def -^[B](b: B): Rule[In, Out, B, X]

def -~[Out2, B, X2 >: X](next: ⇒ Rule[Out, Out2, B, X2]): Rule[In, Out2, B, X2]

def -~: Rule[In, Out2, B, Any]

def <~:[InPrev, B, X2 >: X](prev: ⇒ Rule[InPrev, In, (A) ⇒ B, X2]): Rule[InPrev, Out, B, X2]

Apply the result of this rule to the function returned by the previous rule

final def ==(arg0: Any): Boolean

def >->[Out2, B, X2 >: X](fa2resultb: (A) ⇒ Result[Out2, B, X2]): Rule[In, Out2, B, X2]

def >>[Out2, B, X2 >: X](fa2ruleb: (A) ⇒ (Out) ⇒ Result[Out2, B, X2]): Rule[In, Out2, B, X2]

def >>&[B, X2 >: X](fa2ruleb: (A) ⇒ (Out) ⇒ Result[Any, B, X2]): Rule[In, Out, B, X2]

def >>?[Out2, B, X2 >: X](pf: PartialFunction[A, Rule[Out, Out2, B, X2]]): Rule[In, Out2, B, X2]

def >~>[Out2, B1, B2, B >: A, C, X2 >: X](f: (B1, B2) ⇒ (Out) ⇒ Result[Out2, C, X2])(implicit arg0: (B) ⇒ ~[B1, B2]): Rule[In, Out2, C, X2]

>~>(f) is equivalent to >> { case b1 ~ b2 => f(b1, b2) }

def ??(pf: PartialFunction[A, Any]): Rule[In, Out, A, X]

def ^-^[B1, B2 >: A, C](f: (B1, B2) ⇒ C): Rule[In, Out, (B1) ⇒ C, X]

^-(f) is equivalent to ^^ { b2 => b1 => f(b1, b2) }

def ^^[B](fa2b: (A) ⇒ B): Rule[In, Out, B, X]

def ^^?[B](pf: PartialFunction[A, B]): Rule[In, Out, B, X]

def ^~>~^[B1, B2, B3, B >: A, C](f: (B1, B2, B3) ⇒ C)(implicit arg0: (B) ⇒ ~[B2, B3]): Rule[In, Out, (B1) ⇒ C, X]

^~>~(f) is equivalent to ^^ { case b2 ~ b3 => b1 => f(b1, b2, b3) }

def ^~^[B1, B2, B >: A, C](f: (B1, B2) ⇒ C)(implicit arg0: (B) ⇒ ~[B1, B2]): Rule[In, Out, C, X]

^~(f) is equivalent to ^^ { case b1 ~ b2 => f(b1, b2) }

def ^~~^[B1, B2, B3, B >: A, C](f: (B1, B2, B3) ⇒ C)(implicit arg0: (B) ⇒ ~[~[B1, B2], B3]): Rule[In, Out, C, X]

^~~(f) is equivalent to ^^ { case b1 ~ b2 ~ b3 => f(b1, b2, b3) }

def ^~~~^[B1, B2, B3, B4, B >: A, C](f: (B1, B2, B3, B4) ⇒ C)(implicit arg0: (B) ⇒ ~[~[~[B1, B2], B3], B4]): Rule[In, Out, C, X]

^~~~(f) is equivalent to ^^ { case b1 ~ b2 ~ b3 ~ b4 => f(b1, b2, b3, b4) }

def ^~~~~^[B1, B2, B3, B4, B5, B >: A, C](f: (B1, B2, B3, B4, B5) ⇒ C)(implicit arg0: (B) ⇒ ~[~[~[~[B1, B2], B3], B4], B5]): Rule[In, Out, C, X]

^~~~~(f) is equivalent to ^^ { case b1 ~ b2 ~ b3 ~ b4 ~ b5 => f(b1, b2, b3, b4, b5) }

def ^~~~~~^[B1, B2, B3, B4, B5, B6, B >: A, C](f: (B1, B2, B3, B4, B5, B6) ⇒ C)(implicit arg0: (B) ⇒ ~[~[~[~[~[B1, B2], B3], B4], B5], B6]): Rule[In, Out, C, X]

^~~~~~(f) is equivalent to ^^ { case b1 ~ b2 ~ b3 ~ b4 ~ b5 ~ b6 => f(b1, b2, b3, b4, b5, b6) }

def ^~~~~~~^[B1, B2, B3, B4, B5, B6, B7, B >: A, C](f: (B1, B2, B3, B4, B5, B6, B7) ⇒ C)(implicit arg0: (B) ⇒ ~[~[~[~[~[~[B1, B2], B3], B4], B5], B6], B7]): Rule[In, Out, C, X]

^~~~~~~(f) is equivalent to ^^ { case b1 ~ b2 ~ b3 ~ b4 ~ b5 ~ b6 => f(b1, b2, b3, b4, b5, b6) }

def andThen[A](g: (Result[Out, A, X]) ⇒ A): (In) ⇒ A

def as(name: String): Rule[In, Out, A, X] with Name

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def compose[A](g: (A) ⇒ In): (A) ⇒ Result[Out, A, X]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def filter(f: (A) ⇒ Boolean): Rule[In, Out, A, X]

def finalize(): Unit

def flatMap[Out2, B, X2 >: X](fa2ruleb: (A) ⇒ (Out) ⇒ Result[Out2, B, X2]): Rule[In, Out2, B, X2]

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

def map[B](fa2b: (A) ⇒ B): Rule[In, Out, B, X]

def mapResult[Out2, B, Y](f: (Result[Out, A, X]) ⇒ Result[Out2, B, Y]): Rule[In, Out2, B, Y]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def orElse[In2 <: In, Out2 >: Out, A2 >: A, X2 >: X](other: ⇒ Rule[In2, Out2, A2, X2]): Rule[In2, Out2, A2, X2]

def orError[In2 <: In]: Rule[In2, Out, A, Any]

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

def toString(): String

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def |[In2 <: In, Out2 >: Out, A2 >: A, X2 >: X](other: ⇒ Rule[In2, Out2, A2, X2]): Rule[In2, Out2, A2, X2]

def ~[Out2, B, X2 >: X](next: ⇒ Rule[Out, Out2, B, X2]): Rule[In, Out2, ~[A, B], X2]

def ~: Rule[In, Out2, ~[A, B], Any]

def ~++[Out2, B >: A, X2 >: X](next: ⇒ Rule[Out, Out2, Seq[B], X2]): Rule[In, Out2, List[B], X2]

def ~-[Out2, B, X2 >: X](next: ⇒ Rule[Out, Out2, B, X2]): Rule[In, Out2, A, X2]

def ~-: Rule[In, Out2, A, Any]

def ~>[Out2, B, X2 >: X](next: ⇒ Rule[Out, Out2, (A) ⇒ B, X2]): Rule[In, Out2, B, X2]

Apply the result of this rule to the function returned by the next rule