StateRules

abstract val factory: Rules

final def !=(arg0: Any): Boolean

final def ##(): Int

def +(other: String): String

def ->[B](y: B): (StateRules, B)

final 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]]): rules.Rule[S, S, collection.immutable.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]): rules.Rule[S, S, A, X]

final def asInstanceOf[T0]: T0

def clone(): AnyRef

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

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

def ensuring(cond: (StateRules) ⇒ Boolean, msg: ⇒ Any): StateRules

def ensuring(cond: (StateRules) ⇒ Boolean): StateRules

def ensuring(cond: Boolean, msg: ⇒ Any): StateRules

def ensuring(cond: Boolean): StateRules

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

def formatted(fmtstr: String): String

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

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

final def ne(arg0: AnyRef): Boolean

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

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

final def notify(): Unit

final def notifyAll(): Unit

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

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

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

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

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

def toString(): String

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

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

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def →[B](y: B): (StateRules, B)