Image

head

code

root

para

L<Examples| file:../examples/index.podlite>


L<Download |file:../download/index.podlite>


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


HEADER

FOOTER

README

Array::Sorted::Util - Raku utilities for (native) sorted arrays


=begin code :lang<raku>

use Array::Sorted::Util;  # imports finds, inserts, deletes

my @a;
inserts(@a,$_) for <d c f e g h a b j i>;
say @a;               # [a b c d e f g h i j]

.say with finds(@a,"h");    # 7
.say with finds(@a,"z");    # (no output)

say deletes(@a,"e");  # e
say @a;               # [a b c d f g h i j]

=end code


Array::Sorted::Util exports a set of subroutines that create and manipulate
sorted arrays.


=begin code :lang<raku>

my @a;
my $pos = inserts(@a, "foo", :cmp(&[coll]));

inserts(@a, "foo");  # use infix:<cmp> by default

my @b;
my @c;
inserts(@b, 'foo', @c, 'bar');  # multiple associated lists

my @d = <a c e g i>;
my $pos = finds(@d,"d");
if $pos {
    say "Found at $pos";
}
else {
    inserts(@d,"d",:$pos);
}
say @d;  # (a c d e g i)

=end code


Insert the given object (the second argument) into the correct location in
the given array (the first argument).  Takes a named argument C<cmp> to
indicate the logic that should be used to determine order (defaults
to C<infix:<cmp>>).  Additionally takes array, object arguments to insert
the given object in the associated array at the same location.  Returns the
position at which the object(s) were actually inserted.


Can also take an optional named argument C<pos> from a previously unsuccessful
call to C<finds> as a shortcut to prevent needing to search for the object
again.


=begin code :lang<raku>

my @a = <a b c d e f g h i j>;
.say with finds(@a, "h");   # 7, use infix:<cmp> by default
say "could not be found" without finds(@a, "z", :cmp(&[coll]));

=end code


Attempt to find the given object (the second argument) in the given
sorted array (the first argument).  Takes a named argument C<cmp> to
indicate the logic that should be used to determine order (defaults
to C<infix:<cmp>>).  Returns a special B<undefined> value if the object
could not be found.


=begin code :lang<raku>

my @a = <a b c d e f g h i j>;
say nexts(@a, "g");  # h
say nexts(@a, "j");  # Nil

=end code


Return the object B<after> the given object (the second argument) in the
given sorted array (the first argument).  Takes a named argument C<cmp> to
indicate the logic that should be used to determine order (defaults to
C<infix:<cmp>>).  Returns Nil if no object could be found.


=begin code :lang<raku>

my @a = <a b c d e f g h i j>;
say prevs(@a, "g");  # f
say prevs(@a, "a");  # Nil

=end code


Return the object B<before> the given object (the second argument) in the
given sorted array (the first argument).  Takes a named argument C<cmp> to
indicate the logic that should be used to determine order (defaults to
C<infix:<cmp>>).  Returns Nil if no object could be found.


=begin code :lang<raku>

my @a = <a b c d e f g h i j>;
say deletes(@a, "e");                 # e, use &infix:<cmp> by default
say deletes(@a, "z", :cmp(&[coll]));  # Nil

=end code


Attempt to remove the given object (the second argument) from the given
sorted array (the first argument).  Takes a named argument C<cmp> to
indicate the logic that should be used to determine order (defaults
to C<infix:<cmp>>).  Additionally takes array arguments to delete elements
in the associated array at the same location.  Returns the value of
the primary removed object.


The inspiration for these names is from the TUTOR Programming Language,
which had C<finds>, C<inserts> and C<deletes> commands.


See https://files.eric.ed.gov/fulltext/ED208879.pdf for more information
(pages C16 and C17).


Source can be located at: https://github.com/lizmat/Array-Sorted-Util .
Comments and Pull Requests are welcome.


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


Util

use Array::Sorted::Util:ver<0.0.7>:auth<zef:lizmat>;

class Array::Sorted::Map:ver<0.0.1>:auth<zef:lizmat> does Associative {
    has $.keys   is built(:bind) is required;
    has $.values is built(:bind) is required;

    method AT-KEY(\key) {
        (my $pos := finds($!keys, key)).defined
          ?? $!values[$pos]
          !! Nil
    }

    method kv() {
        gather for ^$!keys.elems {
            take $!keys[$_];
            take $!values[$_];
        }
    }
    method anti-pairs() {
        (^$!keys.elems).map: -> int $i { $!values[$i] => $!keys[$i] }
    }
    method pairs() {
        (^$!keys.elems).map: -> int $i { $!keys[$i] => $!values[$i] }
    }
    method iterator() {
        self.pairs.iterator
    }
}



Array::Sorted::Map - Provide a Map interface for 2 sorted lists


=begin code :lang<raku>

use Array::Sorted::Util;
use Array::Sorted::Map;

my @keys;
my @values;

inserts(@keys, "a", @values, 42);  # "inserts" from Array::Sorted::Util
inserts(@keys, "b", @values, 666);

my %map := Array::Sorted::Map.new(:$keys, :$values);

say %map<a>;  # 42;
say %map<b>;  # 666;
say %map<c>;  # Nil

say %map.keys;    # (a b)
say %map.values;  # (42 666)

=end code


Array::Sorted::Map provides a class that can be used to provide a C<Map>
interface to two sorted lists: one for keys, and one for values, such as
typically created / maintained by the subroutines offered by the
C<Array::Sorted::Util> distribution.


Source can be located at: https://github.com/lizmat/Array-Sorted-Map .
Comments and Pull Requests are welcome.


The Raku Knowledge Base


=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


README

NAME

SYNOPSIS

DESCRIPTION

AUTHOR

COPYRIGHT AND LICENSE

Array::Sorted::Map v0.0.1

Authors

License

Dependencies

Test Dependencies

Provides

Documentation