Std.Tree

40 public declarations

• at&Std.Tree.Tree[T] -> &Array[Int] -> Option[Std.Tree.Tree[T]]

  The subtree at a path, or `None` when the path leads nowhere.

  fn
• breadthFirst&Std.Tree.Tree[T] -> Array[T]

  Every value, nearest the root first, level by level.

  fn
• childrenOf&Std.Tree.Tree[T] -> Array[Std.Tree.Tree[T]]

  The children of a node, in order.

  fn
• contains&Std.Tree.Tree[T] -> T -> Bool where T: Eq

  Whether any node carries this value.

  fn
• count&Std.Tree.Tree[T] -> fn(T) -> Bool -> Int

  How many nodes the test accepts.

  fn
• degree&Std.Tree.Tree[T] -> Int

  How many children a node has directly.

  fn
• find&Std.Tree.Tree[T] -> fn(T) -> Bool -> Option[T]

  The first value the test accepts, in preorder, or `None`.

  fn
• flatMap&Std.Tree.Tree[A] -> fn(A) -> Std.Tree.Tree[B] -> Std.Tree.Tree[B]

  Each value replaced by a whole tree, grafted where the value stood.

  fn
• fold&Std.Tree.Tree[T] -> fn(A, T) -> A -> A -> A

  Every value combined into one, each node before its children.

  fn
• foldTree&Std.Tree.Tree[A] -> fn(A, Array[B]) -> B -> B

  Each node combined with what its children answered.

  fn
• Forest

  A sequence of trees standing side by side.

  type
• height&Std.Tree.Tree[T] -> Int

  How many nodes lie on the longest path from the root, the root included.

  fn
• isLeaf&Std.Tree.Tree[T] -> Bool

  Whether a node has nothing beneath it.

  fn
• leafT -> Std.Tree.Tree[T]

  A node with nothing beneath it.

  fn
• leaves&Std.Tree.Tree[T] -> Array[T]

  Every value that has nothing beneath it, in preorder.

  fn
• levels&Std.Tree.Tree[T] -> Array[Array[T]]

  The values at each depth, nearest the root first.

  fn
• map&Std.Tree.Tree[A] -> fn(A) -> B -> Std.Tree.Tree[B]

  Every value transformed, keeping the shape and the order.

  fn
• mapOption&Std.Tree.Tree[A] -> fn(A) -> Option[B] -> Option[Std.Tree.Tree[B]]

  Every value transformed, keeping the shape, where transforming may answer

  fn
• mapResult&Std.Tree.Tree[A] -> fn(A) -> Result[B, E] -> Result[Std.Tree.Tree[B], E]

  Every value transformed, keeping the shape, where transforming may fail.

  fn
• mapWithPath&Std.Tree.Tree[A] -> fn(Array[Int], A) -> B -> Std.Tree.Tree[B]

  Every value transformed, told where in the tree it sits.

  fn
• nodeT -> &Array[Std.Tree.Tree[T]] -> Std.Tree.Tree[T]

  A node with the given children, in the order given.

  fn
• outline&Std.Tree.Tree[T] -> Array[Str]

  The tree drawn as indented lines, each value shown as the session shows it.

  fn
• pathTo&Std.Tree.Tree[T] -> fn(T) -> Bool -> Option[Array[Int]]

  The path to the first node the test accepts, in preorder, or `None`.

  fn
• postorder&Std.Tree.Tree[T] -> Array[T]

  Every value, each node after its children, children in order.

  fn
• preorder&Std.Tree.Tree[T] -> Array[T]

  Every value, each node before its children, children in order.

  fn
• prune&Std.Tree.Tree[T] -> fn(T) -> Bool -> Option[Std.Tree.Tree[T]]

  The tree with every node the test rejects removed, along with everything

  fn
• reversed&Std.Tree.Tree[T] -> Std.Tree.Tree[T]

  The tree with its children in the reverse of their order, at every depth.

  fn
• sameShape&Std.Tree.Tree[A] -> &Std.Tree.Tree[B] -> Bool

  Whether two trees hold the same values in the same shape and order.

  fn
• sequenceOption&Std.Tree.Tree[Option[T]] -> Option[Std.Tree.Tree[T]]

  A tree of options turned into an option holding a tree.

  fn
• sequenceResult&Std.Tree.Tree[Result[T, E]] -> Result[Std.Tree.Tree[T], E]

  A tree of results turned into a result holding a tree.

  fn
• size&Std.Tree.Tree[T] -> Int

  How many nodes the tree holds, the root included.

  fn
• trailTo&Std.Tree.Tree[T] -> fn(T) -> Bool -> Option[Array[T]]

  The values from the root down to the first node the test accepts.

  fn
• Tree

  A value with a sequence of trees beneath it.

  type
• unfoldS -> fn(S) -> (T, Array[S]) -> Std.Tree.Tree[T]

  A tree grown from a starting value.

  fn
• unfoldForest&Array[S] -> fn(S) -> (T, Array[S]) -> Array[Std.Tree.Tree[T]]

  A forest grown from several starting values.

  fn
• unfoldResultS -> fn(S) -> Result[(T, Array[S]), E] -> Result[Std.Tree.Tree[T], E]

  A tree grown from a starting value, where growing may fail.

  fn
• unfoldToS -> fn(S) -> (T, Array[S]) -> Int -> Std.Tree.Tree[T]

  A tree grown from a starting value, stopping at a given depth.

  fn
• valueOf&Std.Tree.Tree[T] -> T

  The value a node carries.

  fn
• withChild&Std.Tree.Tree[T] -> &Std.Tree.Tree[T] -> Std.Tree.Tree[T]

  The tree with a child added after the ones already there.

  fn
• zipWith&Std.Tree.Tree[A] -> &Std.Tree.Tree[B] -> fn(A, B) -> C -> Std.Tree.Tree[C]

  Two trees combined node by node, as far as both go.

  fn