unit package Tree;

use Tree::Binary::PrettyTree;
use Tree::Binary::Role::Renderer;
use Tree::Binary::Grammar;

class BasicStrRenderer does Tree::Binary::Role::Renderer {
    has Tree::Binary $.tree;

    method render {
        ( $.tree.value , |$.tree.nodes.map( { "({$_})" } ) ).join("");
    }
}



head

Tree::Binary - Simple Binary Tree Role with pretty printing


code

=begin code :lang<raku>

use Tree::Binary;
class IntTree does Tree::Binary[Int] {};
my IntTree(Str) $tree = "1(2)(3)";
say $tree;

=end code


=begin code

 1 
┌┴┐
2 3

=end code


Tree::Binary is intended to be a simple role that can be used to represent binary 
trees. It's intended to be a basis for a series of different types for trees. 


Tree::Binary does not include code for inserting or deleting nodes as this is 
dependent on the concreate class using it. 


=begin code :lang<raku>
role Tree::Binary[
    ::ValueType=Any,
    Tree::Binary::Role::Renderer :$gist-renderer=Tree::Binary::PrettyTree,
    Tree::Binary::Role::Renderer :$Str-renderer=BasicStrRenderer,
]
=end code


The Tree::Binary C<Role> accepts one postional and two named parameters : 


defn

The default constructor takes two named arguments :


The role also allows for basic string coercion where a tree can be represented
with the following structure.


=begin code

value(node1)(node2)

=end code


Where C<value> is a C<Str> that can be coerced into a C<ValueType> and C<node1> 
and C<node2> another C<Tree::Binary> representation. The C<Str> method should produce
a value that can be coered into a Tree::Binary of the appropriate C<ValueType>.


Alternate construction options using C<Str> coercion are :


=begin code :lang<raku>

# Coercion from a Str to a Tree::Binary
my Tree::Binary(Str) $tree1 = "1(a)(£)";

# Using the from-Str constructor
my $tree2 = Tree::Binary.from-Str("1(a)(£)");

=end code



role Binary:ver<0.0.3>:auth<zef:Scimon>[
    ::ValueType = Any, 
    Tree::Binary::Role::Renderer :$gist-renderer = PrettyTree,
    Tree::Binary::Role::Renderer :$Str-renderer  = BasicStrRenderer, 
] is export {

    #| The current nodes value
    has ValueType $.value is required;
    #| The child nodes
    has Tree::Binary @!nodes[2];




    #| The child nodes of this node, undefined nodes will not be returned.
    method nodes(--> Array[Tree::Binary]) {
       my Tree::Binary @out = @!nodes.grep({defined $_});
    }

    submethod BUILD ( ValueType() :$value, :@nodes ) {
        $!value = $value;
        @!nodes = @nodes;
    }
    

    #|( Returns the number of defined nodes for the current node.
    Note that the elems method does NOT return the count of all nodes 
    in the tree just the current nodes children. 
    )
    multi method elems(--> UInt) {
        @.nodes.elems;
    }

    multi method elems( Bool :$leaf!, Bool :$all! --> UInt ) {
        die "The :all and :leaf flags in elems are incompatible";
    }

    #|( With the :all flag returns the total number of nodes in the tree 
    including the current one but not any undefined ones.
    )
    multi method elems( Bool :$all! --> UInt ) {
        [+] 1, |self.nodes().map( *.elems(:all) );
    }

    #|( With the :leaf flag returns the total number of leaf nodes )
    multi method elems( Bool :$leaf! --> UInt ) {
        given self.nodes.elems {
            when 0 {
                return 1;
            }
            default {
                return [+] |self.nodes().map( *.elems(:leaf) );
            }
        }
    }

    #| Returns a Str representation of the tree using the :$Str-renderer parameter 
    method Str(--> Str ) {
        $Str-renderer.new( tree=>self ).render();
    }

    #| Returns the gist for this tree using the defined $gist-renderer parameter
    method gist(--> Str) {
        $gist-renderer.new( tree=>self ).render();
    }
    
    #| Returns a raku representation of the tree
    method raku(--> Str) {
        "{self.^name}.new( {("value => {$!value}", self.nodes ?? "nodes => {(self.nodes.map(*.raku)).join(", ")}" !! Empty).join(", ")} )";
    }

    method routes() {
        gather {
            if ( self.elems ) {
                for @.nodes -> $n {
                    for $n.routes -> @t {
                        take ($!value, |@t);
                    }
                }
            } else {
                take ( $!value, );
            }
        }
    }
    
    #|( Returns a new Tree::Binary where the node pairs have been swapped at each level )
    multi method reverse( ::?CLASS:D: --> Tree::Binary ) {
        self.new(
            value => $!value,
            nodes => @.nodes.reverse.map( *.reverse )
        )
    }

    multi method reverse( ::?CLASS:U: ) { Tree::Binary }
    
    method COERCE( Str:D $str --> Tree::Binary ) {
        return ::?CLASS.from-Str( $str );
    }

    multi method from-Str('' --> Tree::Binary ) { Tree::Binary }
    
    #| Object creation method using the Str coercion rules.
    multi method from-Str( ::?CLASS:U: Str $in --> Tree::Binary ) {
        my $match = Tree::Binary::Grammar.parse( $in );
        if ( $match ) {
            self.new(
                value => $match<tree><value>.Str,
                nodes => [
                          self.from-Str( $match<tree><left> ?? $match<tree><left>.Str !! '' ),
                          self.from-Str( $match<tree><right> ?? $match<tree><right>.Str !! '' )
                      ]
            );
        } else {
            die "Unable to Parse $in";
        }
        
    }

}



Scimon Proctor <simon.proctor@gmail.com>


This library is free software; you can redistribute it and/or modify it under the Artistic License 2.0.


root

README

React

=begin React :component<HeaderCol> :id<menu> 
=para L<Documentation|/doc/introduction>
=para L<Modules| /mods>
=para L<Examples| file:../examples/index.podlite>
=para L<Download |file:../download/index.podlite>
=para L<About|file:../about/index.podlite>
=para 🔍 K<⌘K>/K<ctrl-K>
=end React


=begin React :component<HeaderCol> :id<footer>  
=begin nested :!nested
=item1 B<Language>
    =item2 L<Get started|file:../getting-started/getting-started.podlite>
    =item2 L<Why Raku?|/doc/language/faq#Why-should-I-learn-Raku-What's-so-great-about-it>
    =item2 L<Try Raku|https://glot.io/new/raku>
    =item2 L<Raku cheat sheet|https://github.com/Raku/mu/blob/master/docs/Perl6/Cheatsheet/cheatsheet.txt>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<Raku on Exercism|https://exercism.org/tracks/raku>
    =item2 L<Wikipedia|https://en.wikipedia.org/wiki/Raku_(programming_language)>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>

=end nested
=begin nested :!nested

=item1 B<L<Documentation|/doc>>
    =item2 L<Getting started, Migration guides from other languages, & Tutorials | file:../doc/introduction.podlite>
    =item2 L<Language References|file:../doc/reference.podlite>
    =item2 L<Type Reference| file:../doc/types.podlite>
    =item2 L<Miscellaneous| file:../doc/miscellaneous.podlite>
    =item2 L<FAQs (Frequently Asked Questions)|/doc/language/faq>
    =item2 L<Community|/doc/language/community>
    =item2 L<The list of all documents|file:../doc/index.podlite>

=item1 B<Resources>
    =item2 L<The Raku Guide|https://raku.guide/>
    =item2 L<Books |https://perl6book.com/>
    =item2 L<Rosetta Code | https://www.raku.org/community/rosettacode>

=end nested
=begin nested :!nested

=item1 B<Resoures>
    =item2 L<Download | file:../download/index.podlite>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>

=item1 B<Learning>
    =item2 L<The Raku Guide|https://raku.guide/>
    =item2 L<Wikibook |https://en.wikibooks.org/wiki/Raku_Programming>
    =item2 L<Books |https://perl6book.com/>
    =item2 L<Rosetta Code | https://www.raku.org/community/rosettacode>
    =item2 L<Learn Raku in Y minutes|https://learnxinyminutes.com/docs/raku/>
    =item2 L<Golfing |https://github.com/AlexDaniel/raku-golf-cheatsheet>
=end nested
=begin nested :!nested

=item1 B<Explore>
    =item2 L<Raku Blog Aggregator|https://planet.raku.org/>
    =item2 L<Rakudo Weekly|https://rakudoweekly.blog/>
    =item2 L<The Weekly Challenge |https://perlweeklychallenge.org/>
    =item2 L<Raku Advent Calendar|https://raku-advent.blog/>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>

=end nested
=end React


=begin React :component<CookieConsent> :id<CookieConsent> :buttonCaption("Got it!")
=para
This website uses cookies for analytics.
=end React


Binary

NAME

SYNOPSIS

DESCRIPTION

Tree::Binary

Construction

Attributes

Methods

AUTHOR

COPYRIGHT AND LICENSE

Tree::Binary v0.0.3

Authors

License

Dependencies

Test Dependencies

Provides

Documentation