StateRules

val factory : Rules

def != (arg0: AnyRef): Boolean

def != (arg0: Any): Boolean

def ## (): Int

def == (arg0: AnyRef): Boolean

def == (arg0: Any): Boolean

def allOf [A, X] (rules: Seq[Rule[A, X]]): (S) ⇒ Result[S, List[A], X]

Create a rule that succeeds if all of the given rules succeed.

def anyOf [A, X] (rules: Seq[Rule[A, X]]): Rule[S, S, List[A], X]

Create a rule that succeeds with a list of all the provided rules that succeed.

def apply [A, X] (f: (S) ⇒ Result[S, A, X]): Rule[S, S, A, X]

def asInstanceOf [T0] : T0

def clone (): AnyRef

def cond (f: (S) ⇒ Boolean): Rule[S, S, S, Nothing]

Create a rule that identities if f(in) is true.

def eq (arg0: AnyRef): Boolean

def equals (arg0: Any): Boolean

def finalize (): Unit

def get : Rule[S, S, S, Nothing]

def getClass (): java.lang.Class[_]

def hashCode (): Int

def isInstanceOf [T0] : Boolean

def ne (arg0: AnyRef): Boolean

def nil : Rule[S, S, scala.collection.immutable.Nil.type, Nothing]

def none : Rule[S, S, None.type, Nothing]

def notify (): Unit

def notifyAll (): Unit

def read [A] (f: (S) ⇒ A): Rule[S, S, A, Nothing]

def repeatUntil [T, X] (rule: Rule[(T) ⇒ T, X])(finished: (T) ⇒ Boolean)(initial: T): Rule[S, S, T, X]

Repeatedly apply a rule from initial value until finished condition is met.

def set (s: ⇒ S): Rule[S, S, S, Nothing]

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

def toString (): String

def unit [A] (a: ⇒ A): Rule[S, S, A, Nothing]

def update (f: (S) ⇒ S): Rule[S, S, S, Nothing]

def wait (): Unit

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

def wait (arg0: Long): Unit