axle

Type Members

case class Combinations[E](pool: IndexedSeq[E], r: Int)(implicit evidence$1: Manifest[E]) extends Iterable[IndexedSeq[E]] with Product with Serializable
case class CombinationsFast[E](pool: IndexedSeq[E], r: Int)(implicit evidence$1: Manifest[E]) extends Iterable[IndexedSeq[E]] with Product with Serializable
case class CrossProduct[E](collections: IndexedSeq[IndexedSeq[E]]) extends Iterable[List[E]] with Product with Serializable
case class EnrichedArray[T](arr: Array[T])(implicit evidence$1: Manifest[T]) extends Product with Serializable
case class EnrichedByteArray(barr: Array[Byte]) extends Product with Serializable
case class EnrichedGenSeq[T](genSeq: GenSeq[T]) extends Product with Serializable
case class EnrichedGenTraversable[+T](gt: GenTraversable[T])(implicit evidence$1: Manifest[T]) extends Product with Serializable
case class EnrichedIndexedSeq[T](is: IndexedSeq[T])(implicit evidence$1: Manifest[T]) extends Product with Serializable
case class EnrichedInt(n: Int) extends Product with Serializable
class EnrichedIterator[T] extends AnyRef
case class EnrichedMutableBuffer[T](buffer: Buffer[T]) extends Product with Serializable
trait HtmlFrom[T] extends AnyRef

Annotations
@implicitNotFound( ... )
case class IndexedCrossProduct[E](lists: Seq[IndexedSeq[E]]) extends Iterable[Seq[E]] with Product with Serializable
case class IndexedPowerSet[E](all: IndexedSeq[E]) extends Iterable[Set[E]] with Product with Serializable

A ℘ (IndexedPowerSet) constructed with a collection with elements of type E can construct an Iterator which enumerates all possible subsets (of type Collection<E>) of the collection used to construct the PowerSet.
case class Permutations[E](pool: IndexedSeq[E], r: Int)(implicit evidence$1: Manifest[E]) extends Iterable[IndexedSeq[E]] with Product with Serializable

Based on Python's itertools.permutations function
Based on Python's itertools.permutations function
http://docs.python.org/library/itertools.html#itertools.permutations
Permutations("ABCD".toIndexedSeq, 2) Permutations(0 until 3)
case class PermutationsFast[E](pool: IndexedSeq[E], r: Int)(implicit evidence$1: Manifest[E]) extends Iterable[IndexedSeq[E]] with Product with Serializable

Value Members

object HtmlFrom
package algebra
def applyForever[N](f: (N) ⇒ N, x0: N): Iterator[N]
def applyK[N](f: (N) ⇒ N, x0: N, k: Int): N
package ast
implicit def enrichArray[T](arr: Array[T])(implicit arg0: Manifest[T]): EnrichedArray[T]
implicit def enrichByteArray(barr: Array[Byte]): EnrichedByteArray
implicit def enrichGenSeq[T](genSeq: GenSeq[T]): EnrichedGenSeq[T]
implicit def enrichGenTraversable[T](gt: GenTraversable[T])(implicit arg0: Manifest[T]): EnrichedGenTraversable[T]
implicit def enrichIndexedSeq[T](is: IndexedSeq[T])(implicit arg0: Manifest[T]): EnrichedIndexedSeq[T]
implicit def enrichInt(n: Int): EnrichedInt
implicit def enrichIterator[T](it: Iterator[T]): EnrichedIterator[T]
implicit def enrichMutableBuffer[T](buffer: Buffer[T]): EnrichedMutableBuffer[T]
implicit def eqIterable[T](implicit eqT: Eq[T]): Eq[Iterable[T]]
implicit def eqSeq[T](implicit eqT: Eq[T]): Eq[Seq[T]]
implicit def eqTreeMap[K, V](implicit eqK: Eq[K], eqV: Eq[V]): Eq[TreeMap[K, V]]
def filterOut[T](stream: Stream[T], toRemove: Stream[T])(implicit orderT: Order[T]): Stream[T]
object forall
package game
def gaps[T](xs: Seq[T])(implicit ringT: Ring[T]): Seq[(T, T)]

gaps
gaps
assumes that the input xs are already sorted
def getLine(): String
def html[T](t: T)(implicit arg0: HtmlFrom[T]): Node
def id[A](x: A): A
def ignore[T]: (T) ⇒ Unit
def intersperse[T](d: T)(l: List[T]): List[T]
package logic
def mergeStreams[T](streams: Seq[Stream[T]])(implicit eqT: Eq[T], orderT: Order[T]): Stream[T]

mergeStreams takes streams that are ordered w.r.t.
mergeStreams takes streams that are ordered w.r.t. Order[T]
def orbit[N](f: (N) ⇒ N, x0: N, close: (N) ⇒ (N) ⇒ Boolean): List[N]
def prefixedDisplay(prefix: String)(display: (String) ⇒ Unit): (String) ⇒ Unit
def print[T](t: T)(implicit arg0: Show[T]): Unit
package quanta
def replicate[T](n: Int)(v: T): List[T]
def reverse[T](l: List[T]): List[T]
def runs[T](xs: Seq[T])(implicit ringT: Ring[T], orderT: Order[T]): Seq[(T, T)]

runs
runs
assumes xs is already sorted
def runs[T](xs: Seq[T], breaks: Set[T]): Seq[(T, T)]
def show[T](t: T)(implicit arg0: Show[T]): String
def showDoubleWithPrecision(p: Int = 6): Show[Double]
implicit val showNode: Show[Node]
implicit val showRational: Show[Rational]
package stats
def streamFrom[N](n: N)(implicit orderN: Order[N], ringN: Ring[N]): Stream[N]
def string[T](t: T)(implicit arg0: Show[T]): String
package syntax
object thereexists
def trace[N](f: (N) ⇒ N, x0: N): Iterator[(N, Set[N])]
object ℘
val ∀: forall.type
val ∃: thereexists.type

package axle

Type Members

case class Combinations[E](pool: IndexedSeq[E], r: Int)(implicit evidence$1: Manifest[E]) extends Iterable[IndexedSeq[E]] with Product with Serializable

case class CombinationsFast[E](pool: IndexedSeq[E], r: Int)(implicit evidence$1: Manifest[E]) extends Iterable[IndexedSeq[E]] with Product with Serializable

case class CrossProduct[E](collections: IndexedSeq[IndexedSeq[E]]) extends Iterable[List[E]] with Product with Serializable

case class EnrichedArray[T](arr: Array[T])(implicit evidence$1: Manifest[T]) extends Product with Serializable

case class EnrichedByteArray(barr: Array[Byte]) extends Product with Serializable

case class EnrichedGenSeq[T](genSeq: GenSeq[T]) extends Product with Serializable

case class EnrichedGenTraversable[+T](gt: GenTraversable[T])(implicit evidence$1: Manifest[T]) extends Product with Serializable

case class EnrichedIndexedSeq[T](is: IndexedSeq[T])(implicit evidence$1: Manifest[T]) extends Product with Serializable

case class EnrichedInt(n: Int) extends Product with Serializable

class EnrichedIterator[T] extends AnyRef

case class EnrichedMutableBuffer[T](buffer: Buffer[T]) extends Product with Serializable

trait HtmlFrom[T] extends AnyRef

case class IndexedCrossProduct[E](lists: Seq[IndexedSeq[E]]) extends Iterable[Seq[E]] with Product with Serializable

case class IndexedPowerSet[E](all: IndexedSeq[E]) extends Iterable[Set[E]] with Product with Serializable

case class Permutations[E](pool: IndexedSeq[E], r: Int)(implicit evidence$1: Manifest[E]) extends Iterable[IndexedSeq[E]] with Product with Serializable

case class PermutationsFast[E](pool: IndexedSeq[E], r: Int)(implicit evidence$1: Manifest[E]) extends Iterable[IndexedSeq[E]] with Product with Serializable

Value Members

object HtmlFrom

package algebra

def applyForever[N](f: (N) ⇒ N, x0: N): Iterator[N]

def applyK[N](f: (N) ⇒ N, x0: N, k: Int): N

package ast

implicit def enrichArray[T](arr: Array[T])(implicit arg0: Manifest[T]): EnrichedArray[T]

implicit def enrichByteArray(barr: Array[Byte]): EnrichedByteArray

implicit def enrichGenSeq[T](genSeq: GenSeq[T]): EnrichedGenSeq[T]

implicit def enrichGenTraversable[T](gt: GenTraversable[T])(implicit arg0: Manifest[T]): EnrichedGenTraversable[T]

implicit def enrichIndexedSeq[T](is: IndexedSeq[T])(implicit arg0: Manifest[T]): EnrichedIndexedSeq[T]

implicit def enrichInt(n: Int): EnrichedInt

implicit def enrichIterator[T](it: Iterator[T]): EnrichedIterator[T]

implicit def enrichMutableBuffer[T](buffer: Buffer[T]): EnrichedMutableBuffer[T]

implicit def eqIterable[T](implicit eqT: Eq[T]): Eq[Iterable[T]]

implicit def eqSeq[T](implicit eqT: Eq[T]): Eq[Seq[T]]

implicit def eqTreeMap[K, V](implicit eqK: Eq[K], eqV: Eq[V]): Eq[TreeMap[K, V]]

def filterOut[T](stream: Stream[T], toRemove: Stream[T])(implicit orderT: Order[T]): Stream[T]

object forall

package game

def gaps[T](xs: Seq[T])(implicit ringT: Ring[T]): Seq[(T, T)]

def getLine(): String

def html[T](t: T)(implicit arg0: HtmlFrom[T]): Node

def id[A](x: A): A

def ignore[T]: (T) ⇒ Unit

def intersperse[T](d: T)(l: List[T]): List[T]

package logic

def mergeStreams[T](streams: Seq[Stream[T]])(implicit eqT: Eq[T], orderT: Order[T]): Stream[T]

def orbit[N](f: (N) ⇒ N, x0: N, close: (N) ⇒ (N) ⇒ Boolean): List[N]

def prefixedDisplay(prefix: String)(display: (String) ⇒ Unit): (String) ⇒ Unit

def print[T](t: T)(implicit arg0: Show[T]): Unit

package quanta

def replicate[T](n: Int)(v: T): List[T]

def reverse[T](l: List[T]): List[T]

def runs[T](xs: Seq[T])(implicit ringT: Ring[T], orderT: Order[T]): Seq[(T, T)]

def runs[T](xs: Seq[T], breaks: Set[T]): Seq[(T, T)]

def show[T](t: T)(implicit arg0: Show[T]): String

def showDoubleWithPrecision(p: Int = 6): Show[Double]

implicit val showNode: Show[Node]

implicit val showRational: Show[Rational]

package stats

def streamFrom[N](n: N)(implicit orderN: Order[N], ringN: Ring[N]): Stream[N]

def string[T](t: T)(implicit arg0: Show[T]): String

package syntax

object thereexists

def trace[N](f: (N) ⇒ N, x0: N): Iterator[(N, Set[N])]

object ℘

val ∀: forall.type

val ∃: thereexists.type

Inherited from AnyRef

Inherited from Any

Ungrouped