para

head

C<Data::Reshapers::ToPrettyTable> package module has data transformation functions over
different data structures coercible to full-arrays.


use Data::Reshapers;
use Data::Reshapers::ToPrettyTable;


my @tbl = get-titanic-dataset(headers => "auto");
say ToPrettyTable(@tbl);



use Pretty::Table;
use Data::Reshapers::Adapters;
use Data::TypeSystem::Predicates;
use Hash::Merge;

unit module Data::Reshapers::ToPrettyTable;

constant %tblParamDefaults =
horizontal-char => '-', # |'─',
vertical-char => '|', #'│',
junction-char => '+', #'O', # '┼',
float-format=> '.6f';

#===========================================================
#| Complete column names
our proto CompleteColumnNames(|) is export {*}

multi sub CompleteColumnNames($dataset, :$missing-value = '') {

    my @allColnames;
    if is-array-of-hashes($dataset) {

        @allColnames = $dataset>>.keys.flat.unique;
        my %emptyRow = @allColnames X=> $missing-value;
        return $dataset.map({ merge-hash(%emptyRow, $_) }).Array;

    } elsif is-hash-of-hashes($dataset) {

        @allColnames = $dataset.values>>.keys.flat.unique;
        my %emptyRow = @allColnames X=> $missing-value;
        return $dataset.map({ $_.key => merge-hash(%emptyRow, $_.value) }).Hash;

    } else {
        warn 'Do not know how to process the dataset argument.';
        return $dataset;
    }
}

#===========================================================
#| Convert into a pretty table object.
our proto ToPrettyTable(|) is export {*}

my Str $hashArgErrMsg =
        'If the first argument is a hash then it is expected that it can be coerced into a' ~
        ' hash-of-hashes or hash-of-positionals,' ~
        ' which in turn can be coerced into a full two dimensional array.';;

my Str $arrayArgErrMsg =
        'If the first argument is an array then it is expected that it can be coerced into a' ~
        ' array-of-hashes, array-of-positionals, or hash-of-hashes,' ~
        ' which in turn can be coerced into a full two dimensional array.';

#-----------------------------------------------------------
multi ToPrettyTable(%tbl, *%args) {

    my $missing-value = %args<missing-value>:exists ?? %args<missing-value> !! '';

    my Hash %hash-of-hashes;
    my Positional %hash-of-arrays;

    # Coerces into hash of hashes
    try {
        %hash-of-hashes = %tbl;
    }

    if $! {

        # Coerce into array-of-hashes
        try {
            %hash-of-arrays = %tbl
        }

        if $! {
            #fail $hashArgErrMsg;
            return ToPrettyTable( %tbl.map({ %( Key => $_.key, Value => $_.value ) }).Array, |%args);
        }
    }

    if %hash-of-hashes.defined and %hash-of-hashes {

        %hash-of-hashes = CompleteColumnNames(%hash-of-hashes, :$missing-value);

        # Column names of the pretty table
        my @colnames = %hash-of-hashes{%hash-of-hashes.keys[0]}.keys;
        if %args<field-names>:exists {
            if ! %args<field-names>.isa(Whatever) {
                @colnames = %args<field-names>.grep({ $_ ∈ @colnames }).List;

                if @colnames.elems == 0 {
                    warn 'None of the specified field names are known.'
                } elsif @colnames.elems < %args<field-names>.elems {
                    warn 'Some of the specified field names are not known.'
                }
            }
        }

        # Initialize the pretty table object
        my $tableObj = Pretty::Table.new:
                field-names => ['', |@colnames],
                sort-by => '',
                align => %('' => 'l'),
                |%tblParamDefaults,
                |%args.grep({ $_.key ne 'field-names' }).Hash;

        # Add each hash into the pretty table as table row
        %hash-of-hashes.map({ $tableObj.add-row([$_.key, |$_.value{|@colnames}]) });

        # Result
        return $tableObj;

    } else {

        # Column names of the pretty table
        my @colnames = ^%hash-of-arrays{%hash-of-arrays.keys[0]}.elems;

        # Initialize the pretty table object
        my $tableObj = Pretty::Table.new:
                field-names => ['', |@colnames>>.Str],
                sort-by => '',
                align => %('' => 'l'),
                |%tblParamDefaults,
                |%args;

        # Add each hash into the pretty table as table row
        %hash-of-arrays.map({ $tableObj.add-row([$_.key, |$_.value[|@colnames]]) });

        # Result
        return $tableObj;

    }

    return Nil;
}

#-----------------------------------------------------------
multi ToPrettyTable(@tbl, *%args) {

    my $missing-value = %args<missing-value>:exists ?? %args<missing-value> !! '';

    my Hash @arr-of-hashes;
    my Positional @arr-of-arrays;

    # Coerce into array-of-hashes
    try {
        @arr-of-hashes = @tbl
    }

    if $! {

        # Coerce into array-of-hashes
        try {
            @arr-of-arrays = @tbl;

            if not has-homogeneous-shape(@arr-of-arrays) {
                fail $arrayArgErrMsg;
            }
        }

        if $! {
            # Check for an array of key-array pairs
            if is-array-of-key-array-pairs(@tbl) or is-array-of-key-hash-pairs(@tbl) {

                # Convert an array of key-[array|hash] pairs into a hash of hashes
                my %res = convert-to-hash-of-hashes(@tbl);

                return ToPrettyTable(%res, |%args)
            } elsif is-array-of-pairs(@tbl) {
                return ToPrettyTable(@tbl.map({ %( Key => $_.key, Value => $_.value ) }).Array, |%args)
            }

            fail $arrayArgErrMsg;
        }
    }

    # Convert to table
    if @arr-of-hashes.defined and @arr-of-hashes {

        @arr-of-hashes = CompleteColumnNames(@arr-of-hashes, :$missing-value);

        # Column names of the pretty table
        my @colnames = @arr-of-hashes[0].keys;
        if %args<field-names>:exists {
            if ! %args<field-names>.isa(Whatever) {
                @colnames = %args<field-names>.grep({ $_ ∈ @colnames }).List;

                if @colnames.elems == 0 {
                    warn 'None of the specified field names are known.'
                } elsif @colnames.elems < %args<field-names>.elems {
                    warn 'Some of the specified field names are not known.'
                }
            }
        }


        # Initialize the pretty table object
        my $tableObj = Pretty::Table.new:
                field-names => @colnames,
                |%tblParamDefaults,
                |%args.grep({ $_.key ne 'field-names' }).Hash;

        # Add each hash into the pretty table as table row
        @arr-of-hashes.map({ $tableObj.add-row($_{|@colnames}) });

        return $tableObj;

    } else {

        # Column names of the pretty table
        my @colnames = ^@arr-of-arrays.values[0].elems;

        # Initialize the pretty table object
        my $tableObj = Pretty::Table.new:
                field-names => @colnames>>.Str,
                |%tblParamDefaults,
                |%args;

        # Add each hash into the pretty table as table row
        @arr-of-arrays.map({ $tableObj.add-row($_[|@colnames]>>.gist) });

        return $tableObj;

    }

    # Result
    return Nil;
}

root

Transpose

CrossTabulate

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<AI|file:../mcp/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<Download | file:../download/index.podlite>
    =item2 L<Raku cheat sheet|https://github.com/Raku/mu/blob/master/docs/Perl6/Cheatsheet/cheatsheet.txt>
    =item2 L<Raku on Exercism|https://exercism.org/tracks/raku>
    =item2 L<Wikipedia|https://en.wikipedia.org/wiki/Raku_(programming_language)>

=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>
    =item2 L<Hand these documents to an AI assistant|file:../mcp/index.podlite>

=end nested
=begin nested :!nested
=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/>

=end nested
=end React


Built with L<Podlite|https://podlite.org> — the markup and publishing tools behind this site.


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


ToPrettyTable

Data::Reshapers::ToPrettyTable

Synopsis

Data::Reshapers v0.3.8

Authors

License

Dependencies

Test Dependencies

Provides

Documentation