BinaryTree

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def allChildren: Iterator[BinaryTree[L]]

final def asInstanceOf[T0]: T0

def begin: Int

def children: IndexedSeq[BinarizedTree[L]]

def clone(): AnyRef

def cutLeaves: (Tree[L], IndexedSeq[L])

Useful for stripping the words out of a tree Returns (tree without leaves, leaves)

def end: Int

final def eq(arg0: AnyRef): Boolean

def extend[B](f: (Tree[L]) ⇒ B): BinaryTree[B]

def findSpan(begin: Int, end: Int): Option[Tree[L]]

final def getClass(): Class[_]

final def isInstanceOf[T0]: Boolean

def isLeaf: Boolean

def isValid: Boolean

A tree is valid if this' span contains all children's spans and each child abuts the next one.

val label: L

def leaves: Iterable[Tree[L]]

val leftChild: BinarizedTree[L]

def leftHeight: Int

def map[M](f: (L) ⇒ M): BinaryTree[M]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def postorder: Iterator[BinaryTree[L]]

def preorder: Iterator[BinaryTree[L]]

def relabelRoot[B >: L](f: (L) ⇒ B): BinarizedTree[B]

def render[W](words: Seq[W], newline: Boolean = true): String

val rightChild: BinarizedTree[L]

val span: Span

def splitPoint: Int

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

def toString(newline: Boolean): String

def toString(): String

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

final def wait(arg0: Long): Unit

final def wait(): Unit

def finalize(): Unit