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

module vars:ver<0.0.6>:auth<zef:lizmat> { }

sub EXPORT(*@vars) {
    my %export;
    my @huh;
    for @vars -> $name {
        %export{$name} := $name.starts-with('$')
          ?? my $
          !! $name.starts-with('@')
            ?? []
            !! $name.starts-with('%')
              ?? %()
              !! @huh.push($name)
    }
    die "Don't know how to export: @huh[]" if @huh;

    %export
}



This module tries to mimic the behaviour of Perl's C<vars> pragma
as closely as possible in the Raku Programming Language.


This will predeclare all the subroutine whose names are in the list,
allowing you to use them without parentheses even before they're declared.


Unlike pragmas that affect the $^H hints variable, the "use vars" declarations
are not BLOCK-scoped. They are thus effective for the entire package in which
they appear. You may not rescind such declarations with "no vars".


See "Pragmatic Modules" in perlmodlib and "strict vars" in strict.


Due to the nature of the export mechanism in raku, it is impossible (at the
moment of this writing: 2018.05) to export to the OUR:: stash from a module.
Therefore the raku version of this module exports to the B<lexical> scope
in which the C<use> command occurs.  For most standard uses, this is equivalent
to the Perl behaviour.


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


Re-imagined from Perl as part of the CPAN Butterfly Plan.


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


vars

use v6.d;

# Using nqp for optimal performance
use nqp;

role ValueTypeCache:ver<0.0.5>:auth<zef:lizmat>[&args2str] {
    has $!WHICH;

    my $cache     := nqp::hash;
    my $lock      := Lock.new;
    my str $prefix = nqp::concat(::?CLASS.^name,'|');

    method !SET-WHICH(\WHICH) {
        $!WHICH := nqp::box_s(WHICH,ValueObjAt);
        self
    }
    multi method WHICH(::?CLASS:D:) { $!WHICH }

    method bless(*%_) {
        my str $WHICH = nqp::concat($prefix,args2str(%_));
        $lock.protect: {
            nqp::ifnull(
              nqp::atkey($cache,$WHICH),
              nqp::bindkey(
                $cache,
                $WHICH,
                self.Mu::bless(|%_)!SET-WHICH($WHICH)
              )
            )
        }
    }
}



ValueTypeCache - A role to cache Value Type classes


sub id(%h --> Str:D) {
    %h<x> //= 0;
    %h<y> //= 0;
    "%h<x>,%h<y>"
}


class Point does ValueTypeCache[&id] {
    has $.x;
    has $.y;
}


# 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 ValueTypeCache role mixes the logic of creating a proper ValueType class
B<and> making sure that each unique ValueType only exists once in memory, into
a class.


The role takes a C<Callable> parameterization to indicate how a unique ID
should be created from the parameters given (as a hash) with the call to the
C<new> method.  You can also adapt the given hash making sure any default
values are properly applied.  If there's already an object created with the
returned ID, then no new object will be created but the one from the cache
will be returned.


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.


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


ValueTypeCache

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

ValueTypeCache v0.0.5

Authors

License

Dependencies

Test Dependencies

Provides

Documentation