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 nqp ops as if we are in the core
use nqp;

class ValuePair is Pair {
    proto method new(|) {*}
    multi method new( $key,   $value ) { self.Pair::new($key, $value) }
    multi method new(:$key!, :$value!) { self.Pair::new($key, $value) }

    multi method WHICH(ValuePair:D:) {
        nqp::box_s(
          nqp::concat(
            nqp::if(
              nqp::eqaddr(self.WHAT,ValuePair),
              'ValuePair|',
              nqp::concat(self.^name,'|')
            ),
            nqp::sha1(
              nqp::concat(
                self.key.Str,
                nqp::concat(
                  '|',
                  self.value.Str
                )
              )
            )
          ),
          ValueObjAt
        )
    }

    multi method raku(ValuePair:D:) {
        self.^name ~ '.new(' ~ self.key.raku ~ ',' ~ self.value.raku ~ ')'
    }
}

sub EXPORT() {
    CORE::.EXISTS-KEY('ValuePair')
      ?? Map.new
      !! Map.new( (ValuePair => ValuePair) )
}



ValuePair - Provide an immutable Pair value type


=begin code :lang<raku>

use ValuePair;

my $a = ValuePair.new("a",42);
my $b = ValuePair.new("a",42);

set($a, $b);  # elems == 1

=end code


The functionality provided by this module, will most likely be provided
in language level 6.e and higher.  If an implementation of ValuePair
is already available, loading this module becomes a no-op.


Raku provides a semi-immutable C<Pair> datatype, where the value of a Pair
object can be a container, and thus mutable.  Therefore, a standard Pair
is B<not> a value type.  The C<ValuePair> class provided by this module,
is a subclass of C<Pair>, and does not allow a mutable value.  And thus
it can be a value type.


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


If you like this module, or what I’m doing more generally, committing to a
L<small sponsorship|https://github.com/sponsors/lizmat/>  would mean a great
deal to me!


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


ValuePair

# Use nqp ops as if we are in the core
use nqp;

my constant &new   = Map.^lookup('new');
my constant &STORE = Map.^lookup('STORE');
my constant &raku  = Map.^lookup('raku');

my class ValueMap:ver<0.0.1>:auth<zef:lizmat> is Map {
    method new(|c) {
        my $valuemap = new(self, |c)  # need containerization for QuantHashes
    }
    method STORE(+@values, :INITIALIZE($)!) {
        STORE
          self,
          @values == 1
            && nqp::iscont(my $first := @values.head)
            && nqp::istype($first,ValueMap)
            ?? nqp::decont($first).iterator
            !! @values,
          :INITIALIZE, :DECONT
    }

    multi method WHICH(ValueMap:D:) {
        nqp::box_s(
          nqp::concat(
            nqp::if(
              nqp::eqaddr(self.WHAT,ValueMap),
              'ValueMap|',
              nqp::concat(self.^name,'|')
            ),
            nqp::sha1(
              nqp::join(
                '|',
                nqp::stmts(  # cannot use native str arrays early in setting
                  (my $keys    := nqp::list_s),
                  (my $storage := nqp::getattr(self,Map,'$!storage')),
                  (my $iter    := nqp::iterator($storage)),
                  nqp::while(
                    $iter,
                    nqp::push_s($keys,nqp::iterkey_s(nqp::shift($iter))),
                  ),
                  (my $sorted := Rakudo::Sorting.MERGESORT-str($keys)),
                  (my $strings := nqp::list_s),
                  nqp::while(
                    nqp::elems($sorted),
                    nqp::push_s(
                      $strings,
                      nqp::atkey(
                        $storage,
                        nqp::push_s($strings,nqp::shift_s($sorted))
                      ).Str
                    )
                  ),
                  $strings
                )
              )
            )
          ),
          ValueObjAt
        )
    }

    multi method raku(ValueMap:D:) { raku(self) }
    multi method Str(ValueMap:D:)  { raku(self) }
    multi method gist(ValueMap:D:) { raku(self) }
}

sub EXPORT() {
    CORE::.EXISTS-KEY('ValueMap')
      ?? Map.new
      !! Map.new( (ValueMap => ValueMap) )
}



ValueMap - Provide an immutable Map value type


=begin code :lang<raku>

use ValueMap;

=end code


The functionality provided by this module, will be provided in language
level 6.e and higher. If an implementation of ValueMap is already available,
loading this module becomes a no-op.


Raku provides a semi-immutable Associative datatype: Map. A Map can not have
any elements added or removed from it.  However, since a Map can contain
containers of which the value can be changed, it is B<not> a value type. So
you cannot use Maps in data structures such as Sets, because each Map is considered to be different from any other List, because they are not value types.


ValueMap

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

ValueMap v0.0.1

Authors

License

Dependencies

Test Dependencies

Provides

Documentation