Tree

abstract def rootLabel: A

The label at the root of this tree.

abstract def subForest: Stream[Tree[A]]

The child nodes of this tree.

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def cobind[B](f: (Tree[A]) ⇒ B): Tree[B]

Binds the given function across all the subtrees of this tree.

def drawTree(implicit sh: Show[A]): String

A 2D String representation of this Tree.

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

def flatMap[B](f: (A) ⇒ Tree[B]): Tree[B]

def flatten: Stream[A]

Pre-order traversal.

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

Maps the elements of the Tree into a Monoid and folds the resulting Tree.

def foldMapTrampoline[B](f: (A) ⇒ B)(implicit arg0: Monoid[B]): Trampoline[B]

def foldNode[Z](f: (A) ⇒ (Stream[Tree[A]]) ⇒ Z): Z

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

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

def levels: Stream[Stream[A]]

Breadth-first traversal.

def loc: TreeLoc[A]

A TreeLoc zipper of this tree, focused on the root node.

def map[B](f: (A) ⇒ B): Tree[B]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def scanr[B](g: (A, Stream[Tree[B]]) ⇒ B): Tree[B]

A histomorphic transform.

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

def toStrictTree: StrictTree[A]

def toString(): String

def traverse1[G[_], B](f: (A) ⇒ G[B])(implicit arg0: Apply[G]): G[Tree[B]]

def unzip[A1, A2](implicit p: (A) ⇒ (A1, A2)): (Tree[A1], Tree[A2])

Turns a tree of pairs into a pair of trees.

final def wait(): Unit

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

final def wait(arg0: Long): Unit