Value Members

1.  def applyForever[N](f: (N) => N, x0: N): Iterator[N]
2.  def applyK[N](f: (N) => N, x0: N, k: Int): N
3.  def dummy[T]: T

   dummy is not to be used widely, but is used for for scanLeft, where it's often desirable to provide a throw-away value as the first argument without using an Option type for an already complicated method signature.

   dummy is not to be used widely, but is used for for scanLeft, where it's often desirable to provide a throw-away value as the first argument without using an Option type for an already complicated method signature. A better work-around would be an alternate version of scanLeft that had this behavior built in.

   Something like this:

   def scanLeftDropFirst[A, Repr, B, C, That]( tl: scala.collection.TraversableLike[A, Repr])(z: C)(op: ((B, C), A) ⇒ (B, C))( implicit bf: scala.collection.generic.CanBuildFrom[Repr, (B, C), That]) = tl.scanLeft((axle.dummy[B], z))(op) // Caller should .drop(1). TODO do that here

4.  implicit def enrichArray[T](arr: Array[T])(implicit arg0: ClassTag[T]): EnrichedArray[T]
5.  implicit def enrichByteArray(barr: Array[Byte]): EnrichedByteArray
6.  implicit def enrichIndexedSeq[T](is: IndexedSeq[T]): EnrichedIndexedSeq[T]
7.  implicit def enrichInt(n: Int): EnrichedInt
8.  implicit def enrichIterable[T](ita: Iterable[T]): EnrichedIterable[T]
9.  implicit def enrichIterator[T](it: Iterator[T]): EnrichedIterator[T]
10.  implicit def enrichMutableBuffer[T](buffer: Buffer[T]): EnrichedMutableBuffer[T]
11.  implicit def eqIterable[T](implicit eqT: Eq[T]): Eq[Iterable[T]]
12.  implicit def eqSeq[T](implicit eqT: Eq[T]): Eq[Seq[T]]
13.  implicit val eqSymbol: Eq[Symbol]
14.  implicit def eqTreeMap[K, V](implicit eqK: Eq[K], eqV: Eq[V]): Eq[TreeMap[K, V]]
15.  def filterOut[T](stream: LazyList[T], toRemove: LazyList[T])(implicit orderT: Order[T]): LazyList[T]
16.  def gaps[T](xs: Seq[T])(implicit ringT: Ring[T]): Seq[(T, T)]

    gaps

    gaps

    assumes that the input xs are already sorted

17.  def id[A](x: A): A
18.  def ignore[T]: (T) => Unit
19.  def intersperse[T](d: T)(l: List[T]): List[T]
20.  def lazyListsFrom[N](n: N)(implicit orderN: Order[N], ringN: Ring[N]): LazyList[N]
21.  def mergeStreams[T](streams: Seq[LazyList[T]])(implicit orderT: Order[T]): LazyList[T]

    mergeStreams takes streams that are ordered w.r.t.

    mergeStreams takes streams that are ordered w.r.t. Order[T]

22.  def orbit[N](f: (N) => N, x0: N, close: (N) => (N) => Boolean): List[N]
23.  def print[T](t: T)(implicit arg0: Show[T]): Unit
24.  def replicate[T](n: Int)(v: T): List[T]
25.  def reverse[T](l: List[T]): List[T]
26.  def runs[T](xs: Seq[T])(implicit ringT: Ring[T], orderT: Order[T]): Seq[(T, T)]

    runs

    runs

    assumes xs is already sorted

27.  def runs[T](xs: Seq[T], breaks: Set[T]): Seq[(T, T)]
28.  implicit val showChar: Show[Char]
29.  def showDoubleWithPrecision(p: Int = 6): Show[Double]
30.  implicit val showNode: Show[Node]
31.  implicit val showRational: Show[Rational]
32.  implicit def showSymbol: Show[Symbol]
33.  def shuffle[T](xs: List[T])(gen: Generator): List[T]

    shuffle

34.  def trace[N](f: (N) => N, x0: N): Iterator[(N, Set[N])]
35.  val ∀: forall.type
36.  val ∃: thereexists.type
37.  object IO
38.  object forall
39.  object thereexists
40.  object ℘