Generator

Provides the geny.Gen data type, A Generator of elements of type A.

Generator is basically the inverse of a scala.Iterator: instead of the core functionality being the pull-based hasNext and next: T methods, the core is based around the push-based generate method. generate is basically an extra-customizable version of foreach, which allows the person calling it to provide basic control-flow instructions to the upstream Gens.

Unlike a scala.Iterator, subclasses of Generator can guarantee any clean up logic is performed by placing it after the generate call is made.

Transformations on a Generator are lazy: calling methods like filter or map do not evaluate the entire Gen, but instead construct a new Gen that delegates to the original. The only methods that evaluate the Generator are the "Action" methods like generate/foreach/find, or the "Conversion" methods like toArray or similar.

generate takes a function returning Gen.Action rather that Unit. This allows a downstream Gen to provide basic control commands to the upstream Gens: i.e. Generator.End to cease enumeration of the upstream Gen. This allows it to avoid traversing and processing elements that the downstream Gen doesn't want/need to see anyway.

Linear Supertypes

AnyRef, Any

Abstract Value Members

abstract def generate(handleItem: (A) ⇒ Action): Action

The core abstract method that defines the Generator trait.
The core abstract method that defines the Generator trait. It is essentially the same as .foreach, but with additional configurability.
handleItem
How to handle a single item: performs any desired side effects, and returns a Generator.Action that determines how to continue the enumeration.
returns
an integer stating how many skipped elements from the startingSkipped input remain to be skipped after this generate call has completed.

Concrete Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

Definition Classes
AnyRef → Any
def ++[B >: A](other: Generator[B]): Generator[B]
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def asInstanceOf[T0]: T0

Definition Classes
Any
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def collect[B](func: PartialFunction[A, B]): Generator[B]
def collectFirst[B](func: PartialFunction[A, B]): Option[B]
def contains(a: Any): Boolean
def count(f: (A) ⇒ Boolean = (_: Any) => true): Int
def drop(n: Int): Generator[A]
def dropWhile(pred: (A) ⇒ Boolean): Generator[A]
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def exists(f: (A) ⇒ Boolean): Boolean
def filter(pred: (A) ⇒ Boolean): Generator[A]
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
def find(f: (A) ⇒ Boolean): Option[A]
def flatMap[B](func: (A) ⇒ Generator[B]): Generator[B]
def flatten[V](implicit f: (A) ⇒ Generator[V]): Generator[V]
def fold[B](start: B)(f: (B, A) ⇒ B): B
def foldLeft[B](start: B)(f: (B, A) ⇒ B): B
def forall(f: (A) ⇒ Boolean): Boolean
def foreach(f: (A) ⇒ Unit): Unit
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def hashCode(): Int

Definition Classes
AnyRef → Any
def head: A
def headOption: Option[A]
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def map[B](func: (A) ⇒ B): Generator[B]
def max[B >: A](implicit cmp: Ordering[B]): A
def maxBy[B](f: (A) ⇒ B)(implicit cmp: Ordering[B]): A
def min[B >: A](implicit cmp: Ordering[B]): A
def minBy[B](f: (A) ⇒ B)(implicit cmp: Ordering[B]): A
def mkString: String
def mkString(sep: String): String
def mkString(start: String, sep: String, end: String): String
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def product[B >: A](implicit num: Numeric[B]): B
def reduce[B >: A](f: (B, A) ⇒ B): B
def reduceLeft[B >: A](f: (B, A) ⇒ B): B
def slice(start: Int, end: Int): Generator[A]
def sum[B >: A](implicit num: Numeric[B]): B
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def take(n: Int): Generator[A]
def takeWhile(pred: (A) ⇒ Boolean): Generator[A]
def toArray[B >: A](implicit arg0: ClassTag[B]): Array[B]
def toBuffer[B >: A]: Buffer[B]
def toList: List[A]
def toSeq: Seq[A]
def toSet[B >: A]: Set[B]
def toString(): String

Definition Classes
AnyRef → Any
def toVector: Vector[A]
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
def withFilter(pred: (A) ⇒ Boolean): Generator[A]
def zip[B](other: Iterable[B]): Generator[(A, B)]
def zipWithIndex: Generator[(A, Int)]

Related Docs: object Generator | package geny

trait Generator[+A] extends AnyRef

Abstract Value Members

abstract def generate(handleItem: (A) ⇒ Action): Action

Concrete Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

def ++[B >: A](other: Generator[B]): Generator[B]

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def collect[B](func: PartialFunction[A, B]): Generator[B]

def collectFirst[B](func: PartialFunction[A, B]): Option[B]

def contains(a: Any): Boolean

def count(f: (A) ⇒ Boolean = (_: Any) => true): Int

def drop(n: Int): Generator[A]

def dropWhile(pred: (A) ⇒ Boolean): Generator[A]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def exists(f: (A) ⇒ Boolean): Boolean

def filter(pred: (A) ⇒ Boolean): Generator[A]

def finalize(): Unit

def find(f: (A) ⇒ Boolean): Option[A]

def flatMap[B](func: (A) ⇒ Generator[B]): Generator[B]

def flatten[V](implicit f: (A) ⇒ Generator[V]): Generator[V]

def fold[B](start: B)(f: (B, A) ⇒ B): B

def foldLeft[B](start: B)(f: (B, A) ⇒ B): B

def forall(f: (A) ⇒ Boolean): Boolean

def foreach(f: (A) ⇒ Unit): Unit

final def getClass(): Class[_]

def hashCode(): Int

def head: A

def headOption: Option[A]

final def isInstanceOf[T0]: Boolean

def map[B](func: (A) ⇒ B): Generator[B]

def max[B >: A](implicit cmp: Ordering[B]): A

def maxBy[B](f: (A) ⇒ B)(implicit cmp: Ordering[B]): A

def min[B >: A](implicit cmp: Ordering[B]): A

def minBy[B](f: (A) ⇒ B)(implicit cmp: Ordering[B]): A

def mkString: String

def mkString(sep: String): String

def mkString(start: String, sep: String, end: String): String

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def product[B >: A](implicit num: Numeric[B]): B

def reduce[B >: A](f: (B, A) ⇒ B): B

def reduceLeft[B >: A](f: (B, A) ⇒ B): B

def slice(start: Int, end: Int): Generator[A]

def sum[B >: A](implicit num: Numeric[B]): B

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

def take(n: Int): Generator[A]

def takeWhile(pred: (A) ⇒ Boolean): Generator[A]

def toArray[B >: A](implicit arg0: ClassTag[B]): Array[B]

def toBuffer[B >: A]: Buffer[B]

def toList: List[A]

def toSeq: Seq[A]

def toSet[B >: A]: Set[B]

def toString(): String

def toVector: Vector[A]

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def withFilter(pred: (A) ⇒ Boolean): Generator[A]

def zip[B](other: Iterable[B]): Generator[(A, B)]

def zipWithIndex: Generator[(A, Int)]

Inherited from AnyRef

Inherited from Any

Ungrouped