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

use v6.c;

use Map::Agnostic:ver<0.0.6>:auth<zef:lizmat>;

role Map::Ordered:ver<0.0.6>:auth<zef:lizmat>
  does Map::Agnostic
{
    has %!indices;  # handles <EXISTS-KEY>   # alas, not supported for role yet
    has Str @!keys;
    has Mu  @!values;

#--- Mandatory method required by Map::Agnostic --------------------------------
    method INIT-KEY(Str() $key, \value) {
        my int $index = @!values.elems;
        %!indices.BIND-KEY(  $key, $index);
        @!keys   .BIND-POS($index, $key);
        @!values .BIND-POS($index, value<>);
    }
    method AT-KEY(\key) {
        with %!indices.AT-KEY(key) {
            @!values.AT-POS($_)
        }
        else {
            Nil
        }
    }
    method EXISTS-KEY(\key) { %!indices.EXISTS-KEY(key) }

    method keys() { @!keys }

#---- Methods needed for consistency -------------------------------------------
    method gist() {
        '{' ~ self.pairs.map( *.gist).join(", ") ~ '}'
    }

    method Str() {
        self.pairs.join(" ")
    }

    method perl() {
        self.perlseen(self.^name, {
          ~ self.^name
          ~ '.new('
          ~ self.pairs.map({$_<>.perl}).join(',')
          ~ ')'
        })
    }

#---- Optional methods for performance -----------------------------------------
    method values()   { @!values }
    method pairs() {
        @!keys.map: { Pair.new($_, @!values.AT-POS(%!indices.AT-KEY($_))) }
    }
}



my %m is Map::Ordered = a => 42, b => 666;


Exports a C<Map::Ordered> role that can be used to indicate the implementation
of a C<Map> in which the keys are ordered the way the C<Map> got initialized.


Since C<Map::Ordered> is a role, you can also use it as a base for creating
your own custom implementations of maps.


Source can be located at: https://github.com/lizmat/Map-Ordered .
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.


Ordered

use Map::Agnostic:ver<0.0.6>:auth<zef:lizmat>;

class Map::Match:ver<0.0.1>:auth<zef:lizmat> does Map::Agnostic {
    has     %!map handles <keys values kv pairs anti-pairs iterator>;
    has Str $!keys;

    my $cursor-init := Match.^lookup("!cursor_init");

    method !keys() {
        $!keys || ($!keys := "\0" ~ %!map.keys.join("\0") ~ "\0")
    }

    my sub key(        %map, str $key) { $key                              }
    my sub value(      %map, str $key) { %map.AT-KEY($key)                 }
    my sub pair(       %map, str $key) { Pair.new: $key, %map.AT-KEY($key) }
    my sub exists(     %map, str $key) { True                              }
    my sub pair-exists(%map, str $key) { Pair.new: $key, True              }

    my sub nogo(@nogo) {
        -> %, $ { Failure.new(X::Adverb.new: :what<slice>, :@nogo) }
    }

    method mapper($exists, $p, $k) is implementation-detail {
        $exists
          ?? $p
            ?? $k
              ?? nogo(<exists p k>)
              !! &pair-exists
            !! &exists
          !! $p
            ?? $k
              ?? nogo(<p k>)
              !! &pair
            !! $k
              ?? &key
              !! &value
    }

    proto method lookup(|) {*}
    multi method lookup(Regex:D $key, &mapper) is implementation-detail {
        my $found := IterationBuffer.CREATE;
        my $keys := self!keys;
        my int $this;
        my int $left;
        my int $right;

        my int $c;
        while ($this = $key($cursor-init(Match, $keys, :$c)).pos) > -1 {
            --$this;
            $left  = $keys.rindex("\0",$this) + 1;
            $right = $keys.index("\0", $this);
            $found.push: mapper(%!map, $keys.substr($left, $right - $left));
            $c = $right + 1;
        }
        $found
    }
    multi method lookup(Str:D $key, &mapper) is implementation-detail {
        my $found := IterationBuffer.CREATE;
        my $keys := self!keys;
        my int $left;
        my int $right;

        my int $index;
        while $keys.index($key,$index) -> int $this {  # cannot be 0
            $left  = $keys.rindex("\0",$this) + 1;
            $right = $keys.index("\0", $this);
            $found.push: mapper(%!map, $keys.substr($left, $right - $left));
            $index = $right + 1;
        }
        $found
    }

    method INIT-KEY($key,$value) { %!map.BIND-KEY($key, $value) }

    proto method AT-KEY(|) {*}
    multi method AT-KEY(Regex:D $key) { self.lookup($key, &value).Slip }
    multi method AT-KEY(Str()   $key) { self.lookup($key, &value).Slip }

    proto method EXISTS-KEY(|) {*}
    multi method EXISTS-KEY(Regex:D $key) { self!keys.contains($key) }
    multi method EXISTS-KEY(Str()   $key) { self!keys.contains($key) }
}

multi sub postcircumfix:<{ }>(Map::Match:D $map,
  \keys,
  :$exists,
  :$p,
  :$k,
  :$v
) is export {
    my &mapper := $map.mapper($exists, $p, $k);
    if keys ~~ Iterable {
        my $found := IterationBuffer.CREATE;
        my $iterator := keys.iterator;
        my $key;

        until ($key := $iterator.pull-one) =:= IterationEnd {
            $found.append: $map.lookup($key, &mapper)
        }

        $found.Slip
    }
    else {
        $map.lookup(keys, &mapper).Slip
    }
}



Map::Match - Provide a Map where keys are regular expressions


=begin code :lang<raku>

use Map::Match;

my %m is Map::Match = foo => 42, b16ar => 666, baz18 => 137;

.say for %m<a>;  # 666␤137␤, same as / a /

.say for %m{ / \d >> / };    # 137␤

.say for %m{ / \d >> / }:k;  # baz18␤

=end code


Map::Match provides an implementation of the C<Map> interface where key values
are interpreted as regular expressions.  This has the following implications
with regards to the normal behaviour of C<Map>s:


Since a regular expression can match multiple times, you can receive more than
one value back from a single key.  Therefore, a C<Slip> will always be returned
as the value.


The value returned from any C<Map> access is B<always> a C<Slip>, albeit
potentially empty.  This is different from a normal C<Map> where C<Nil> would
be returned when specifying a key that does not exist in the C<Map>.


If you specify a C<Str> as a key, or something that can be coerced to a C<Str>,
it will be interpreted as being interpolated in a C<Regex>.


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


Match

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

CAN RETURN MORE THAN ONE

ALWAYS A SLIP

NON-REGEX KEY ASSUMED TO BE REGEX

AUTHOR

COPYRIGHT AND LICENSE

Map::Match v0.0.1

Authors

License

Dependencies

Test Dependencies

Provides

Documentation