Conc

Generalized conc-lists.

These are trees representing sequences that have the following properties:

each node is either a Zero, Single, Chunk or <>
Zero represents an empty tree and is a leaf at level 0
Single represents a tree with a single element and is a leaf at level 0
Chunk represents many elements with a single node and is a leaf at level 0
<> represents an internal node -- it has a left and a right child
<> is at level math.max(left.level, right.level) + 1
<> is such that math.abs(right.level - left.level) <= 1

Note that the last property ensures that the tree is balanced.

Chunk nodes can be used for the conc lists to serve as ropes. Note that these ropes are balanced only if the chunk sizes differ up to a constant factor.

Linear Supertypes

Traversable[T], GenTraversable[T], GenericTraversableTemplate[T, Traversable], TraversableLike[T, Traversable[T]], GenTraversableLike[T, Traversable[T]], Parallelizable[T, ParIterable[T]], TraversableOnce[T], GenTraversableOnce[T], FilterMonadic[T, Traversable[T]], HasNewBuilder[T, Traversable[T]], AnyRef, Any

Known Subclasses

<>, Append, Chunk, Lazy, Leaf, Prepend, Single, Zero

Instance Constructors

new Conc()

Type Members

type Self = Traversable[T]

Attributes
protected[this]
Definition Classes
TraversableLike
class WithFilter extends FilterMonadic[A, Repr]

Definition Classes
TraversableLike

Abstract Value Members

abstract def foreach[U](f: (T) ⇒ U): Unit

Definition Classes
Conc → GenericTraversableTemplate → TraversableLike → GenTraversableLike → TraversableOnce → GenTraversableOnce → FilterMonadic
abstract def left: Conc[T]
abstract def level: Int
abstract def right: Conc[T]

Concrete Value Members

final def !=(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def !=(arg0: Any): Boolean

Definition Classes
Any
final def ##(): Int

Definition Classes
AnyRef → Any
def ++[B >: T, That](that: GenTraversableOnce[B])(implicit bf: CanBuildFrom[Traversable[T], B, That]): That

Definition Classes
TraversableLike → GenTraversableLike
def ++:[B >: T, That](that: Traversable[B])(implicit bf: CanBuildFrom[Traversable[T], B, That]): That

Definition Classes
TraversableLike
def ++:[B >: T, That](that: TraversableOnce[B])(implicit bf: CanBuildFrom[Traversable[T], B, That]): That

Definition Classes
TraversableLike
def /:[B](z: B)(op: (B, T) ⇒ B): B

Definition Classes
TraversableOnce → GenTraversableOnce
def :\[B](z: B)(op: (T, B) ⇒ B): B

Definition Classes
TraversableOnce → GenTraversableOnce
final def ==(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def ==(arg0: Any): Boolean

Definition Classes
Any
def addString(b: StringBuilder): StringBuilder

Definition Classes
TraversableOnce
def addString(b: StringBuilder, sep: String): StringBuilder

Definition Classes
TraversableOnce
def addString(b: StringBuilder, start: String, sep: String, end: String): StringBuilder

Definition Classes
TraversableOnce
def aggregate[B](z: ⇒ B)(seqop: (B, T) ⇒ B, combop: (B, B) ⇒ B): B

Definition Classes
TraversableOnce → GenTraversableOnce
final def asInstanceOf[T0]: T0

Definition Classes
Any
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def collect[B, That](pf: PartialFunction[T, B])(implicit bf: CanBuildFrom[Traversable[T], B, That]): That

Definition Classes
TraversableLike → GenTraversableLike
def collectFirst[B](pf: PartialFunction[T, B]): Option[B]

Definition Classes
TraversableOnce
def companion: GenericCompanion[Traversable]

Definition Classes
Traversable → GenTraversable → GenericTraversableTemplate
def copyToArray[B >: T](xs: Array[B], start: Int, len: Int): Unit

Definition Classes
TraversableLike → TraversableOnce → GenTraversableOnce
def copyToArray[B >: T](xs: Array[B]): Unit

Definition Classes
TraversableOnce → GenTraversableOnce
def copyToArray[B >: T](xs: Array[B], start: Int): Unit

Definition Classes
TraversableOnce → GenTraversableOnce
def copyToBuffer[B >: T](dest: Buffer[B]): Unit

Definition Classes
TraversableOnce
def count(p: (T) ⇒ Boolean): Int

Definition Classes
TraversableOnce → GenTraversableOnce
def drop(n: Int): Traversable[T]

Definition Classes
TraversableLike → GenTraversableLike
def dropWhile(p: (T) ⇒ Boolean): Traversable[T]

Definition Classes
TraversableLike → GenTraversableLike
final def eq(arg0: AnyRef): Boolean

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

Definition Classes
AnyRef → Any
def exists(p: (T) ⇒ Boolean): Boolean

Definition Classes
TraversableLike → TraversableOnce → GenTraversableOnce
def filter(p: (T) ⇒ Boolean): Traversable[T]

Definition Classes
TraversableLike → GenTraversableLike
def filterNot(p: (T) ⇒ Boolean): Traversable[T]

Definition Classes
TraversableLike → GenTraversableLike
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
def find(p: (T) ⇒ Boolean): Option[T]

Definition Classes
TraversableLike → TraversableOnce → GenTraversableOnce
def flatMap[B, That](f: (T) ⇒ GenTraversableOnce[B])(implicit bf: CanBuildFrom[Traversable[T], B, That]): That

Definition Classes
TraversableLike → GenTraversableLike → FilterMonadic
def flatten[B](implicit asTraversable: (T) ⇒ GenTraversableOnce[B]): Traversable[B]

Definition Classes
GenericTraversableTemplate
def fold[A1 >: T](z: A1)(op: (A1, A1) ⇒ A1): A1

Definition Classes
TraversableOnce → GenTraversableOnce
def foldLeft[B](z: B)(op: (B, T) ⇒ B): B

Definition Classes
TraversableOnce → GenTraversableOnce
def foldRight[B](z: B)(op: (T, B) ⇒ B): B

Definition Classes
TraversableOnce → GenTraversableOnce
def forall(p: (T) ⇒ Boolean): Boolean

Definition Classes
TraversableLike → TraversableOnce → GenTraversableOnce
def genericBuilder[B]: Builder[B, Traversable[B]]

Definition Classes
GenericTraversableTemplate
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def groupBy[K](f: (T) ⇒ K): immutable.Map[K, Traversable[T]]

Definition Classes
TraversableLike → GenTraversableLike
def hasDefiniteSize: Boolean

Definition Classes
TraversableLike → TraversableOnce → GenTraversableOnce
def hashCode(): Int

Definition Classes
AnyRef → Any
def head: T

Definition Classes
TraversableLike → GenTraversableLike
def headOption: Option[T]

Definition Classes
TraversableLike → GenTraversableLike
def init: Traversable[T]

Definition Classes
TraversableLike → GenTraversableLike
def inits: Iterator[Traversable[T]]

Definition Classes
TraversableLike
def isEmpty: Boolean

Definition Classes
TraversableLike → TraversableOnce → GenTraversableOnce
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
final def isTraversableAgain: Boolean

Definition Classes
TraversableLike → GenTraversableLike → GenTraversableOnce
def last: T

Definition Classes
TraversableLike → GenTraversableLike
def lastOption: Option[T]

Definition Classes
TraversableLike → GenTraversableLike
def length: Int
def map[B, That](f: (T) ⇒ B)(implicit bf: CanBuildFrom[Traversable[T], B, That]): That

Definition Classes
TraversableLike → GenTraversableLike → FilterMonadic
def max[B >: T](implicit cmp: Ordering[B]): T

Definition Classes
TraversableOnce → GenTraversableOnce
def maxBy[B](f: (T) ⇒ B)(implicit cmp: Ordering[B]): T

Definition Classes
TraversableOnce → GenTraversableOnce
def min[B >: T](implicit cmp: Ordering[B]): T

Definition Classes
TraversableOnce → GenTraversableOnce
def minBy[B](f: (T) ⇒ B)(implicit cmp: Ordering[B]): T

Definition Classes
TraversableOnce → GenTraversableOnce
def mkString: String

Definition Classes
TraversableOnce → GenTraversableOnce
def mkString(sep: String): String

Definition Classes
TraversableOnce → GenTraversableOnce
def mkString(start: String, sep: String, end: String): String

Definition Classes
TraversableOnce → GenTraversableOnce
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def newBuilder: Builder[T, Traversable[T]]

Attributes
protected[this]
Definition Classes
GenericTraversableTemplate → HasNewBuilder
def nonEmpty: Boolean

Definition Classes
TraversableOnce → GenTraversableOnce
def normalized: Conc[T]
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def par: ParIterable[T]

Definition Classes
Parallelizable
def parCombiner: Combiner[T, ParIterable[T]]

Attributes
protected[this]
Definition Classes
TraversableLike → Parallelizable
def partition(p: (T) ⇒ Boolean): (Traversable[T], Traversable[T])

Definition Classes
TraversableLike → GenTraversableLike
def product[B >: T](implicit num: Numeric[B]): B

Definition Classes
TraversableOnce → GenTraversableOnce
def reduce[A1 >: T](op: (A1, A1) ⇒ A1): A1

Definition Classes
TraversableOnce → GenTraversableOnce
def reduceLeft[B >: T](op: (B, T) ⇒ B): B

Definition Classes
TraversableOnce
def reduceLeftOption[B >: T](op: (B, T) ⇒ B): Option[B]

Definition Classes
TraversableOnce → GenTraversableOnce
def reduceOption[A1 >: T](op: (A1, A1) ⇒ A1): Option[A1]

Definition Classes
TraversableOnce → GenTraversableOnce
def reduceRight[B >: T](op: (T, B) ⇒ B): B

Definition Classes
TraversableOnce → GenTraversableOnce
def reduceRightOption[B >: T](op: (T, B) ⇒ B): Option[B]

Definition Classes
TraversableOnce → GenTraversableOnce
def repr: Traversable[T]

Definition Classes
TraversableLike → GenTraversableLike
def reversed: List[T]

Attributes
protected[this]
Definition Classes
TraversableOnce
def scan[B >: T, That](z: B)(op: (B, B) ⇒ B)(implicit cbf: CanBuildFrom[Traversable[T], B, That]): That

Definition Classes
TraversableLike → GenTraversableLike
def scanLeft[B, That](z: B)(op: (B, T) ⇒ B)(implicit bf: CanBuildFrom[Traversable[T], B, That]): That

Definition Classes
TraversableLike → GenTraversableLike
def scanRight[B, That](z: B)(op: (T, B) ⇒ B)(implicit bf: CanBuildFrom[Traversable[T], B, That]): That

Definition Classes
TraversableLike → GenTraversableLike
Annotations
@migration
Migration
(Changed in version 2.9.0) The behavior of scanRight has changed. The previous behavior can be reproduced with scanRight.reverse.
def seq: Traversable[T]

Definition Classes
Traversable → GenTraversable → Parallelizable → TraversableOnce → GenTraversableOnce
def size: Int

Definition Classes
TraversableOnce → GenTraversableOnce
def slice(from: Int, until: Int): Traversable[T]

Definition Classes
TraversableLike → GenTraversableLike
def span(p: (T) ⇒ Boolean): (Traversable[T], Traversable[T])

Definition Classes
TraversableLike → GenTraversableLike
def splitAt(n: Int): (Traversable[T], Traversable[T])

Definition Classes
TraversableLike → GenTraversableLike
def stringPrefix: String

Definition Classes
TraversableLike → GenTraversableLike
def sum[B >: T](implicit num: Numeric[B]): B

Definition Classes
TraversableOnce → GenTraversableOnce
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def tail: Traversable[T]

Definition Classes
TraversableLike → GenTraversableLike
def tails: Iterator[Traversable[T]]

Definition Classes
TraversableLike
def take(n: Int): Traversable[T]

Definition Classes
TraversableLike → GenTraversableLike
def takeWhile(p: (T) ⇒ Boolean): Traversable[T]

Definition Classes
TraversableLike → GenTraversableLike
def thisCollection: Traversable[T]

Attributes
protected[this]
Definition Classes
TraversableLike
def to[Col[_]](implicit cbf: CanBuildFrom[Nothing, T, Col[T]]): Col[T]

Definition Classes
TraversableLike → TraversableOnce → GenTraversableOnce
def toArray[B >: T](implicit arg0: ClassTag[B]): Array[B]

Definition Classes
TraversableOnce → GenTraversableOnce
def toBuffer[B >: T]: Buffer[B]

Definition Classes
TraversableOnce → GenTraversableOnce
def toCollection(repr: Traversable[T]): Traversable[T]

Attributes
protected[this]
Definition Classes
TraversableLike
def toIndexedSeq: immutable.IndexedSeq[T]

Definition Classes
TraversableOnce → GenTraversableOnce
def toIterable: Iterable[T]

Definition Classes
TraversableOnce → GenTraversableOnce
def toIterator: Iterator[T]

Definition Classes
TraversableLike → GenTraversableOnce
def toList: List[T]

Definition Classes
TraversableOnce → GenTraversableOnce
def toMap[T, U](implicit ev: <:<[T, (T, U)]): immutable.Map[T, U]

Definition Classes
TraversableOnce → GenTraversableOnce
def toSeq: Seq[T]

Definition Classes
TraversableOnce → GenTraversableOnce
def toSet[B >: T]: immutable.Set[B]

Definition Classes
TraversableOnce → GenTraversableOnce
def toStream: Stream[T]

Definition Classes
TraversableLike → GenTraversableOnce
def toString(depth: Int): String
def toString(): String

Definition Classes
TraversableLike → Any
def toTraversable: Traversable[T]

Definition Classes
TraversableLike → TraversableOnce → GenTraversableOnce
Annotations
@deprecatedOverriding( ... , "2.11.0" )
def toVector: Vector[T]

Definition Classes
TraversableOnce → GenTraversableOnce
def transpose[B](implicit asTraversable: (T) ⇒ GenTraversableOnce[B]): Traversable[Traversable[B]]

Definition Classes
GenericTraversableTemplate
Annotations
@migration
Migration
(Changed in version 2.9.0) transpose throws an IllegalArgumentException if collections are not uniformly sized.
def unzip[A1, A2](implicit asPair: (T) ⇒ (A1, A2)): (Traversable[A1], Traversable[A2])

Definition Classes
GenericTraversableTemplate
def unzip3[A1, A2, A3](implicit asTriple: (T) ⇒ (A1, A2, A3)): (Traversable[A1], Traversable[A2], Traversable[A3])

Definition Classes
GenericTraversableTemplate
def view(from: Int, until: Int): TraversableView[T, Traversable[T]]

Definition Classes
TraversableLike
def view: TraversableView[T, Traversable[T]]

Definition Classes
TraversableLike
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(p: (T) ⇒ Boolean): FilterMonadic[T, Traversable[T]]

Definition Classes
TraversableLike → FilterMonadic

sealed abstract class Conc[+T] extends scala.Traversable[T]

Instance Constructors

new Conc()

Type Members

type Self = Traversable[T]

class WithFilter extends FilterMonadic[A, Repr]

Abstract Value Members

abstract def foreach[U](f: (T) ⇒ U): Unit

abstract def left: Conc[T]

abstract def level: Int

abstract def right: Conc[T]

Concrete Value Members

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

def ++[B >: T, That](that: GenTraversableOnce[B])(implicit bf: CanBuildFrom[Traversable[T], B, That]): That

def ++:[B >: T, That](that: Traversable[B])(implicit bf: CanBuildFrom[Traversable[T], B, That]): That

def ++:[B >: T, That](that: TraversableOnce[B])(implicit bf: CanBuildFrom[Traversable[T], B, That]): That

def /:[B](z: B)(op: (B, T) ⇒ B): B

def :\[B](z: B)(op: (T, B) ⇒ B): B

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

def addString(b: StringBuilder): StringBuilder

def addString(b: StringBuilder, sep: String): StringBuilder

def addString(b: StringBuilder, start: String, sep: String, end: String): StringBuilder

def aggregate[B](z: ⇒ B)(seqop: (B, T) ⇒ B, combop: (B, B) ⇒ B): B

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def collect[B, That](pf: PartialFunction[T, B])(implicit bf: CanBuildFrom[Traversable[T], B, That]): That

def collectFirst[B](pf: PartialFunction[T, B]): Option[B]

def companion: GenericCompanion[Traversable]

def copyToArray[B >: T](xs: Array[B], start: Int, len: Int): Unit

def copyToArray[B >: T](xs: Array[B]): Unit

def copyToArray[B >: T](xs: Array[B], start: Int): Unit

def copyToBuffer[B >: T](dest: Buffer[B]): Unit

def count(p: (T) ⇒ Boolean): Int

def drop(n: Int): Traversable[T]

def dropWhile(p: (T) ⇒ Boolean): Traversable[T]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def exists(p: (T) ⇒ Boolean): Boolean

def filter(p: (T) ⇒ Boolean): Traversable[T]

def filterNot(p: (T) ⇒ Boolean): Traversable[T]

def finalize(): Unit

def find(p: (T) ⇒ Boolean): Option[T]

def flatMap[B, That](f: (T) ⇒ GenTraversableOnce[B])(implicit bf: CanBuildFrom[Traversable[T], B, That]): That

def flatten[B](implicit asTraversable: (T) ⇒ GenTraversableOnce[B]): Traversable[B]

def fold[A1 >: T](z: A1)(op: (A1, A1) ⇒ A1): A1

def foldLeft[B](z: B)(op: (B, T) ⇒ B): B

def foldRight[B](z: B)(op: (T, B) ⇒ B): B

def forall(p: (T) ⇒ Boolean): Boolean

def genericBuilder[B]: Builder[B, Traversable[B]]

final def getClass(): Class[_]

def groupBy[K](f: (T) ⇒ K): immutable.Map[K, Traversable[T]]

def hasDefiniteSize: Boolean

def hashCode(): Int

def head: T

def headOption: Option[T]

def init: Traversable[T]

def inits: Iterator[Traversable[T]]

def isEmpty: Boolean

final def isInstanceOf[T0]: Boolean

final def isTraversableAgain: Boolean

def last: T

def lastOption: Option[T]

def length: Int

def map[B, That](f: (T) ⇒ B)(implicit bf: CanBuildFrom[Traversable[T], B, That]): That

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

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

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

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

def mkString: String

def mkString(sep: String): String

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

final def ne(arg0: AnyRef): Boolean

def newBuilder: Builder[T, Traversable[T]]

def nonEmpty: Boolean

def normalized: Conc[T]

final def notify(): Unit