trait
Rule[-In, +Out, +A, +X] extends (In) ⇒ Result[Out, A, X]
Abstract Value Members
-
abstract
def
apply(v1: In): Result[Out, A, X]
-
abstract
val
factory: Rules
Concrete Value Members
-
final
def
!=(arg0: Any): Boolean
-
def
!^[Y](fx2y: (X) ⇒ Y): Rule[In, Out, A, Y]
-
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
-~![Out2, B, X2 >: X](next: ⇒ Rule[Out, Out2, B, X2]): Rule[In, Out2, B, Any]
-
def
<~:[InPrev, B, X2 >: X](prev: ⇒ Rule[InPrev, In, (A) ⇒ B, X2]): Rule[InPrev, Out, B, X2]
-
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 A: (A) ⇒ ~[B1, B2]): Rule[In, Out2, C, X2]
-
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]
-
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 A: (A) ⇒ ~[B2, B3]): Rule[In, Out, (B1) ⇒ C, X]
-
def
^~^[B1, B2, B >: A, C](f: (B1, B2) ⇒ C)(implicit A: (A) ⇒ ~[B1, B2]): Rule[In, Out, C, X]
-
def
^~~^[B1, B2, B3, B >: A, C](f: (B1, B2, B3) ⇒ C)(implicit A: (A) ⇒ ~[~[B1, B2], B3]): Rule[In, Out, C, X]
-
def
^~~~^[B1, B2, B3, B4, B >: A, C](f: (B1, B2, B3, B4) ⇒ C)(implicit A: (A) ⇒ ~[~[~[B1, B2], B3], B4]): Rule[In, Out, C, X]
-
def
^~~~~^[B1, B2, B3, B4, B5, B >: A, C](f: (B1, B2, B3, B4, B5) ⇒ C)(implicit A: (A) ⇒ ~[~[~[~[B1, B2], B3], B4], B5]): Rule[In, Out, C, X]
-
def
^~~~~~^[B1, B2, B3, B4, B5, B6, B >: A, C](f: (B1, B2, B3, B4, B5, B6) ⇒ C)(implicit A: (A) ⇒ ~[~[~[~[~[B1, B2], B3], B4], B5], B6]): Rule[In, Out, C, X]
-
def
^~~~~~~^[B1, B2, B3, B4, B5, B6, B7, B >: A, C](f: (B1, B2, B3, B4, B5, B6, B7) ⇒ C)(implicit A: (A) ⇒ ~[~[~[~[~[~[B1, B2], B3], B4], B5], B6], B7]): Rule[In, Out, C, X]
-
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[In, 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
~![Out2, B, X2 >: X](next: ⇒ Rule[Out, Out2, B, X2]): 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
~-![Out2, B, X2 >: X](next: ⇒ Rule[Out, Out2, B, X2]): Rule[In, Out2, A, Any]
-
def
~>[Out2, B, X2 >: X](next: ⇒ Rule[Out, Out2, (A) ⇒ B, X2]): Rule[In, Out2, B, X2]
Inherited from (In) ⇒ Result[Out, A, X]
Inherited from AnyRef
Inherited from Any
A Rule is a function from some input to a Result. The result may be: