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.d;

role ValueType:ver<0.0.4>:auth<zef:lizmat> {
    has $!WHICH;

    my @attributes = ::?CLASS.^attributes.grep: *.name ne 'WHICH';

    multi method WHICH(::?CLASS:D: --> ValueObjAt:D) {
        $!WHICH.defined
          ?? $!WHICH
          !! self!WHICH
    }

    method !WHICH() {
        my str @rest = self.^name;
        for @attributes -> $attribute {
            my $WHICH := $attribute.get_value(self).WHICH;
            $WHICH ~~ ValueObjAt
              ?? @rest.push($WHICH.Str)
              !! die "Attribute '$attribute.name()' is not a Value Type";
        }
        $!WHICH := ValueObjAt.new(@rest.join('|'))
    }
}



ValueType - A role to create Value Type classes


class Point does ValueType {
    has $.x = 0;
    has $.y = 0;
}


say Point.new.WHICH;  # Point|Int|0|Int|0


# fill a bag with random Points
my $bag = bag (^1000).map: {
  Point.new: x => (-10..10).roll, y => (-10..10).roll
}
say $bag.elems;  # less than 1000


The ValueType role mixes the logic of creating a proper ValueType into a
class.  A class is considered to be a value type if the C<.WHICH> method
returns an object of the C<ValueObjAt> class: that then indicates that
objects that return the same C<WHICH> value, are in fact identical and
can be used interchangeably.


This is specifically important when using set operators (such as C<(elem)>,
or C<Set>s, C<Bag>s or C<Mix>es, or any other functionality that is based
on the C<===> operator functionality, such as C<unique> and C<squish>.


The format of the value that is being returned by C<WHICH> is only valid
during a run of a process.  So it should B<not> be stored in any permanent
medium.


The first time the C<WHICH> method (mixed in by this role) is called, it
will check all of its attribute values for being a value type.  If they
all are, then it will construct a C<ValueObjAt> object for its C<WHICH>
value, save it for future reference, and return it.  If any of the attribute
values are B<not> a value type, then an exception will be thrown.


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


ValueType

# 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

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

ValuePair v0.0.1

Authors

License

Dependencies

Test Dependencies

Provides

Documentation