FingerTree

Finger trees with leaves of type A and Nodes that are annotated with type V.

Finger Trees provide a base for implementations of various collection types, as described in "Finger trees: a simple general-purpose data structure", by Ralf Hinze and Ross Paterson. A gentle introduction is presented in the blog post "Monoids and Finger Trees" by Heinrich Apfelmus.

This is done by choosing a a suitable type to annotate the nodes. For example, a binary tree can be implemented by annotating each node with the size of its subtree, while a priority queue can be implemented by labelling the nodes by the minimum priority of its children.

The operations on FingerTree enforce the constraint measured (in the form of a Reducer instance).

Finger Trees have excellent (amortized) asymptotic performance:

Access to the first and last elements is O(1)
Appending/prepending a single value is O(1)
Concatenating two trees is (O lg min(l1, l2)) where l1 and l2 are their sizes
Random access to an element at n is O(lg min(n, l - n)), where l is the size of the tree.
Constructing a tree with n copies of a value is O(lg n).

V: The type of the annotations of the nodes (the measure)
A: The type of the elements stored at the leaves

Source: FingerTree.scala
See also: http://apfelmus.nfshost.com/articles/monoid-fingertree.html
Finger trees: a simple general-purpose data structure

Linear Supertypes

AnyRef, Any

Instance Constructors

new FingerTree()(implicit measurer: Reducer[A, V])

Abstract Value Members

abstract def fold[B](empty: (V) ⇒ B, single: (V, A) ⇒ B, deep: (V, Finger[V, A], ⇒ FingerTree[V, Node[V, A]], Finger[V, A]) ⇒ B): B

Fold over the structure of the tree.
Fold over the structure of the tree. The given functions correspond to the three possible variations of the finger tree.
empty
if the tree is empty, convert the measure to a B
single
if the tree contains a single element, convert the measure and this element to a B
deep
otherwise, convert the measure, the two fingers, and the sub tree to a B.

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 +:(a: ⇒ A): FingerTree[V, A]

Prepends an element to the left of the tree.
Prepends an element to the left of the tree. O(1).
def :+(a: ⇒ A): FingerTree[V, A]

Appends an element to the right of the tree.
Appends an element to the right of the tree. O(1).
def :-|(a: ⇒ A): FingerTree[V, A]

Replace the last element of the tree with the given value.
Replace the last element of the tree with the given value. O(1)
def <++>(right: FingerTree[V, A]): FingerTree[V, A]

Appends the given finger tree to the right of this tree.
final def ==(arg0: AnyRef): Boolean

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

Definition Classes
Any
def add1(n: A, right: ⇒ ATree): ATree
def add2(n1: ⇒ A, n2: ⇒ A, right: ⇒ ATree): ATree
def add3(n1: ⇒ A, n2: ⇒ A, n3: ⇒ A, right: ⇒ ATree): ATree
def add4(n1: ⇒ A, n2: ⇒ A, n3: ⇒ A, n4: ⇒ A, right: ⇒ ATree): ATree
def addDigits0(m1: ⇒ NodeTree, dig1: ⇒ AFinger, dig2: ⇒ AFinger, m2: ⇒ NodeTree): NodeTree
def addDigits1(m1: ⇒ NodeTree, d1: ⇒ AFinger, x: ⇒ A, d2: ⇒ AFinger, m2: ⇒ NodeTree): NodeTree
def addDigits2(m1: ⇒ NodeTree, d1: ⇒ AFinger, x: ⇒ A, y: ⇒ A, d2: ⇒ AFinger, m2: ⇒ NodeTree): NodeTree
def addDigits3(m1: ⇒ NodeTree, d1: ⇒ AFinger, x: ⇒ A, y: ⇒ A, z: ⇒ A, d2: ⇒ AFinger, m2: ⇒ NodeTree): NodeTree
def addDigits4(m1: ⇒ NodeTree, d1: ⇒ AFinger, x: ⇒ A, y: ⇒ A, z: ⇒ A, w: ⇒ A, d2: ⇒ AFinger, m2: ⇒ NodeTree): NodeTree
final def asInstanceOf[T0]: T0

Definition Classes
Any
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws()
final def eq(arg0: AnyRef): Boolean

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

Definition Classes
AnyRef → Any
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws()
def foldLeft[B](b: B)(f: (B, A) ⇒ B): B
def foldMap[B](f: (A) ⇒ B)(implicit s: Monoid[B]): B
def foldRight[B](z: ⇒ B)(f: (A, ⇒ B) ⇒ B): B
def foreach(f: (A) ⇒ Unit): Unit

Execute the provided side effect for each element in the tree.
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def hashCode(): Int

Definition Classes
AnyRef → Any
def head: A

Selects the first element in the tree.
Selects the first element in the tree.

Exceptions thrown
if
the tree is empty
def init: FingerTree[V, A]

Selects a subtree containing all elements except the last
Selects a subtree containing all elements except the last

Exceptions thrown
if
the tree is empty
def isEmpty: Boolean
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def iterator: Iterator[A]

An iterator that visits each element in the tree.
def last: A

Selects the last element in the tree.
Selects the last element in the tree.

Exceptions thrown
if
the tree is empty
def map[B, V2](f: (A) ⇒ B)(implicit m: Reducer[B, V2]): FingerTree[V2, B]

Maps the given function across the tree, annotating nodes in the resulting tree according to the provided Reducer.
def measure: V
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def reverseIterator: Iterator[A]

An iterator that visits each element in the tree in reverse order.
def split(pred: (V) ⇒ Boolean): (FingerTree[V, A], FingerTree[V, A])

Splits this tree into a pair of subtrees at the point where the given predicate, based on the measure, changes from true to false.
Splits this tree into a pair of subtrees at the point where the given predicate, based on the measure, changes from true to false. O(log(min(i,n-i)))
returns
(as, bs) as: the subtree containing elements before the point where pred first holds fs the subtree containing element at and after the point where pred first holds. Empty if pred never holds.
def split1(pred: (V) ⇒ Boolean): (FingerTree[V, A], A, FingerTree[V, A])

Like split, but returns the element where pred first holds separately
Like split, but returns the element where pred first holds separately

Exceptions thrown
if
the tree is empty.
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def tail: FingerTree[V, A]

Selects a subtree containing all elements except the first
Selects a subtree containing all elements except the first

Exceptions thrown
if
the tree is empty
def toList: List[A]

Convert the leaves of the tree to a scala.List
def toStream: Stream[A]

Convert the leaves of the tree to a scala.Stream
def toString(): String

Convert the tree to a String.
Convert the tree to a String. Unsafe: this uses Any#toString for types V and A

Definition Classes
FingerTree → AnyRef → Any
def traverseTree[F[_], V2, B](f: (A) ⇒ F[B])(implicit ms: Reducer[B, V2], F: Applicative[F]): F[FingerTree[V2, B]]

Like traverse, but with a more constraint type: we need the additional measure to construct the new tree.
def viewl: ViewL[[α]FingerTree[V, α], A]
def viewr: ViewR[[α]FingerTree[V, α], 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 |-:(a: ⇒ A): FingerTree[V, A]

Replace the first element of the tree with the given value.
Replace the first element of the tree with the given value. O(1)

sealed abstract class FingerTree[V, A] extends AnyRef

Instance Constructors

new FingerTree()(implicit measurer: Reducer[A, V])

Abstract Value Members

abstract def fold[B](empty: (V) ⇒ B, single: (V, A) ⇒ B, deep: (V, Finger[V, A], ⇒ FingerTree[V, Node[V, A]], Finger[V, A]) ⇒ B): B

Concrete Value Members

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

def +:(a: ⇒ A): FingerTree[V, A]

def :+(a: ⇒ A): FingerTree[V, A]

def :-|(a: ⇒ A): FingerTree[V, A]

def <++>(right: FingerTree[V, A]): FingerTree[V, A]

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

def add1(n: A, right: ⇒ ATree): ATree

def add2(n1: ⇒ A, n2: ⇒ A, right: ⇒ ATree): ATree

def add3(n1: ⇒ A, n2: ⇒ A, n3: ⇒ A, right: ⇒ ATree): ATree

def add4(n1: ⇒ A, n2: ⇒ A, n3: ⇒ A, n4: ⇒ A, right: ⇒ ATree): ATree

def addDigits0(m1: ⇒ NodeTree, dig1: ⇒ AFinger, dig2: ⇒ AFinger, m2: ⇒ NodeTree): NodeTree

def addDigits1(m1: ⇒ NodeTree, d1: ⇒ AFinger, x: ⇒ A, d2: ⇒ AFinger, m2: ⇒ NodeTree): NodeTree

def addDigits2(m1: ⇒ NodeTree, d1: ⇒ AFinger, x: ⇒ A, y: ⇒ A, d2: ⇒ AFinger, m2: ⇒ NodeTree): NodeTree

def addDigits3(m1: ⇒ NodeTree, d1: ⇒ AFinger, x: ⇒ A, y: ⇒ A, z: ⇒ A, d2: ⇒ AFinger, m2: ⇒ NodeTree): NodeTree

def addDigits4(m1: ⇒ NodeTree, d1: ⇒ AFinger, x: ⇒ A, y: ⇒ A, z: ⇒ A, w: ⇒ A, d2: ⇒ AFinger, m2: ⇒ NodeTree): NodeTree

final def asInstanceOf[T0]: T0

def clone(): AnyRef

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

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

def foldMap[B](f: (A) ⇒ B)(implicit s: Monoid[B]): B

def foldRight[B](z: ⇒ B)(f: (A, ⇒ B) ⇒ B): B

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

final def getClass(): Class[_]

def hashCode(): Int

def head: A

def init: FingerTree[V, A]

def isEmpty: Boolean

final def isInstanceOf[T0]: Boolean

def iterator: Iterator[A]

def last: A

def map[B, V2](f: (A) ⇒ B)(implicit m: Reducer[B, V2]): FingerTree[V2, B]

def measure: V

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def reverseIterator: Iterator[A]

def split(pred: (V) ⇒ Boolean): (FingerTree[V, A], FingerTree[V, A])

def split1(pred: (V) ⇒ Boolean): (FingerTree[V, A], A, FingerTree[V, A])

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

def tail: FingerTree[V, A]

def toList: List[A]

def toStream: Stream[A]

def toString(): String

def traverseTree[F[_], V2, B](f: (A) ⇒ F[B])(implicit ms: Reducer[B, V2], F: Applicative[F]): F[FingerTree[V2, B]]

def viewl: ViewL[[α]FingerTree[V, α], A]

def viewr: ViewR[[α]FingerTree[V, α], A]

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def |-:(a: ⇒ A): FingerTree[V, A]

Inherited from AnyRef

Inherited from Any

Ungrouped