Forest::Tree::Pure - An n-ary tree

nodechildrenget_child_at($index)
               Return the child at this position. (zero-base index)

           child_count
               Returns the number of children this tree has

       sizesizehas_sizeheightheighthas_height

       Yuval Kogman

       All  complex  software  has bugs lurking in it, and this module is no exception. If you find a bug please
       either email me, or add the bug to cpan-RT.

       Copyright 2008-2014 Infinity Interactive, Inc.

       <http://www.iinteractive.com>

       This library is free software; you can redistribute it and/or modify it under  the  same  terms  as  Perl
       itself.

perl v5.34.0                                       2022-06-14                            Forest::Tree::Pure(3pm)

       This module is a base class for Forest::Tree providing functionality for immutable trees.

       It can be used independently for trees that require sharing of children between parents.

       There is no single authoritative parent (no upward links at all), and changing of data is not supported.

       This class is appropriate when many tree roots share the same children (e.g. in a versioned tree).

       This class is strictly a DAG, wheras Forest::Tree produces a graph with back references

is_leaf
           True if the current tree has no children

       traverse(\&func)
           Takes  a  reference  to  a  subroutine  and  traverses  the  tree  applying  this subroutine to every
           descendant. (But not the root)

       visit(&func)
           Traverse the entire tree, including the root.

       fmap_cont(&func)
           A CPS form of "visit" that lets you control when and how data flows from the children.

           It takes a callback in the form:

               sub {
                   my ( $tree, $cont, @args ) = @_;

                   ...
               }

           and $cont is a code ref that when invoked will apply that same function to the children of $tree.

           This allows you to do things like computing the sum of all the node values in a tree, for instance:

               use List::Util qw(sum);

               my $sum = $tree->fmap_cont(sub {
                   my ( $tree, $cont ) = @_;

                   return sum( $tree->node, $cont->() );
               });

           And also allows one to stop traversal at a given point.

       add_children(@children)add_child($child)
           Create a new tree node with the children appended.

           The children must inherit "Forest::Tree::Pure"

           Note that this method does not mutate the tree, instead  it  clones  and  returns  a  tree  with  the
           augmented list of children.

       insert_child_at($index,$child)
           Insert a child at this position. (zero-base index)

           Returns a derived tree with overridden children.

       set_child_at($index,$child)
           Replaces the child at $index with $child.

       remove_child_at($index)
           Remove the child at this position. (zero-base index)

           Returns a derived tree with overridden children.

       locate(@path)
           Find a child using a path of child indexes. These two examples return the same object:

               $tree->get_child_at(0)->get_child_at(1)->get_child_at(0);

               $tree->locate(0, 1, 0);

       descend(@path)
           Like "lookup" except that it returns every object in the path, not just the leaf.

       "transform (\@path, $method, @args)"
           Performs a lookup on @path, applies the method $method with @args to the located node, and clones the
           path to the parent returning a derived tree.

           This  method  is  also  implemented  in  Forest::Tree by mutating the tree in place and returning the
           original tree, so the same transformations should work on both pure trees and mutable ones.

           This code:

               my $new = $root->transform([ 1, 3 ], insert_child_at => 3, $new_child);

           will locate the child at the path "[ 1, 3 ]", call "insert_child_at" on it, creating a new version of
           "[ 1, 3 ]", and then return a cloned version of "[ 1 ]" and the root node recursively, such that $new
           appears to be a mutated $root.

       set_node $new
           Returns a clone of the tree node with the node value changed.

       "replace $arg"
           Returns the argument. This is useful when used with "transform".

       clone
           Provided by MooseX::Clone.

           Deeply clones the entire tree.

           Subclasses should use MooseX::Clone traits to specify the correct  cloning  behavior  for  additional
           attributes if cloning is used.

       reconstruct_with_class$class
           Recursively recreates the tree by passing constructor arguments to $class.

           Does not use "clone".

       to_mutable_tree
           Invokes "reconstruct_with_class" with Forest::Tree as the argument.

       to_pure_tree
           Returns the invocant.

       get_child_index($child)
           Returns the index of $child in "children" or undef if it isn't a child of the current tree.

       Forest::Tree::Pure - An n-ary tree

         use Forest::Tree;

         my $t = Forest::Tree::Pure->new(
             node     => 1,
             children => [
                 Forest::Tree::Pure->new(
                     node     => 1.1,
                     children => [
                         Forest::Tree::Pure->new(node => 1.1.1),
                         Forest::Tree::Pure->new(node => 1.1.2),
                         Forest::Tree::Pure->new(node => 1.1.3),
                     ]
                 ),
                 Forest::Tree::Pure->new(node => 1.2),
                 Forest::Tree::Pure->new(
                     node     => 1.3,
                     children => [
                         Forest::Tree::Pure->new(node => 1.3.1),
                         Forest::Tree::Pure->new(node => 1.3.2),
                     ]
                 ),
             ]
         );

         $t->traverse(sub {
             my $t = shift;
             print(('    ' x $t->depth) . ($t->node || '\undef') . "\n");
         });