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

my multi sub trait_mod:<is>(Method:D $method, :$protected!) is export {
    my $package := $method.package;

    # Did not install lock logic yet
    unless $package.^attributes.first(*.name eq '$!LOCK') {
        my $attribute := Attribute.new(:name<$!LOCK>, :type(Lock), :$package);
        $package.^add_attribute: $attribute;

        $package.^add_method: 'LOCK', my method LOCK() {
            $attribute.get_value(self)
              // $attribute.set_value(self, Lock.new)
        }
    }

    # Install the wrapper
    my $name := $method.name;
    $method.wrap: my method (|c) {
        my &original = nextcallee;
        self.LOCK.protect: { original(self, |c) }
    }

    # Make the adapted method self-identify with the correct name
    $method.^set_name($name);
}



Method::Protected - add "is protected" trait to methods


=begin code :lang<raku>

use Method::Protected;

my @words = "/usr/share/dict/words".IO.lines;

class Frobnicate {
    has %!hash;
    method pick() is protected { %!hash{@words.pick}++ }
    method hash() is protected { %!hash.clone          }
}

# Set up 2 threads massively updating a single hash
my $frobnicator = Frobnicate.new;
start { loop { $frobnicator.pick }
start { loop { $frobnicator.pick }

# Start reporter
await start {
    until $frobnicator.hash.elems == @words.elems {
        say $frobnicator.hash.elems;
        sleep .1;
    }
}

=end code


Method::Protected provides an C<is protected> trait to methods in a class.
If applied to a method, all calls to that method will be protected by a
L<Lock|https://docs.raku.org/type/Lock>, making sure that any other method
call to this method (or any other method protected by the trait) from
another thread, will block until the call is finished.


Functionally this is similar to what the
L<OO::Monitor|https://raku.land/cpan:JNTHN/OO::Monitors> does, except that
with this module this logic is only applied to methods that actuall have
the C<is protected> trait applied.


When the trait is applied on a method, the class of the method id checked
whether it already has a C<$!LOCK> attribute.  If not, then that attribute
is added, and the associated accessor method C<LOCK> is also added.  Then
the method will be L<wrapped|https://docs.raku.org/routine/wrap> with code
that will protect the execution of the original body of the method.


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


Protected

use v6.d;

module Method::Also:ver<0.0.6>:auth<zef:lizmat> {
    my %aliases;
    my %aliases-composed;

    role AliasableClassHOW {

        method compose (Mu \o, :$compiler_services) is hidden-from-backtrace {
          for %aliases{o.^name}[] {
            o.^add_method(.key, .value) if $_;
          }
          nextsame;
        }

    }

    role AliasableRoleHOW {

        method specialize(Mu \r, Mu:U \obj, *@pos_args, *%named_args)
            is hidden-from-backtrace
        {
            obj.HOW does AliasableClassHOW unless obj.HOW ~~ AliasableClassHOW;

            my $*TYPE-ENV;
            my $r := callsame;
            unless %aliases-composed{r.^name} {
                for %aliases{r.^name}[] -> $p {
                    # cw: This should never happen, but somehow it is... 
                    next unless $p;
                    next unless $p.value.is_dispatcher;

                    obj.^add_method($p.key, $p.value);
                    for r.^multi_methods_to_incorporate {
                        obj.^add_multi_method(
                            $p.key,
                            .code.instantiate_generic($*TYPE-ENV)
                        );
                    }
                }
                %aliases-composed{r.^name} = True;
            }
            $r;
        }

        method specialize_with(Mu $, Mu \old_type_env, Mu \type_env, |) {
            $*TYPE-ENV := old_type_env.^name eq 'BOOTContext'
              ?? old_type_env
              !! type_env;
            nextsame;
        }

    }

    multi sub trait_mod:<is>(Method:D \meth, :$also!) is export {
        if $*PACKAGE.HOW ~~ Metamodel::ClassHOW {
            $*PACKAGE.HOW does AliasableClassHOW
                unless $*PACKAGE.HOW ~~ AliasableClassHOW
        }

        if $*PACKAGE.HOW ~~ Metamodel::ParametricRoleHOW {
            $*PACKAGE.HOW does AliasableRoleHOW
                unless $*PACKAGE.HOW does AliasableRoleHOW
        }

        if $also {
            if $also ~~ List {
                %aliases{$*PACKAGE.^name}.push: Pair.new(.Str, meth) for @$also;
            }
            else {
                %aliases{$*PACKAGE.^name}.push: Pair.new($also.Str, meth);
            }
        }
    }
}



Method::Also - add "is also" trait to Methods


class Foo {
    has $.foo;
    method foo() is also<bar bazzy> { $!foo }
}


Foo.new(foo => 42).bar;       # 42
Foo.new(foo => 42).bazzy;     # 42


# separate multi methods can have different aliases
class Bar {
    multi method foo()     is also<bar>   { 42 }
    multi method foo($foo) is also<bazzy> { $foo }
}


Bar.foo;        # 42
Bar.foo(666);   # 666
Bar.bar;        # 42
Bar.bazzy(768); # 768


This module adds a C<is also> trait to C<Method>s, allowing you to specify
other names for the same method.


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


Also

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

Method::Also v0.0.6

Authors

License

Dependencies

Test Dependencies

Provides

Documentation