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;

class Interval:ver<0.0.5>:auth<zef:lizmat> is DateTime {
    my \interval = Duration.new(3600);
    method succ(::?CLASS:D:) { self + interval }
    method pred(::?CLASS:D:) { self - interval }
    method seconds(--> 3600) { }

    my role Intervaller[\seconds] {
        my \interval = Duration.new(seconds);
        method succ(::?CLASS:D:) { self + interval }
        method pred(::?CLASS:D:) { self - interval }
        method seconds() { seconds }
    }

    method ^parameterize(\type, \seconds) {
        my \mixed-in = type.^mixin(Intervaller[seconds]);
        mixed-in.^set_name(type.^name ~ '[' ~ seconds ~ ']');
        mixed-in
    }
}

my multi sub infix:<+>(Interval:D \a, Int:D \b) is export(:DEFAULT, :refine) {
    a + Duration.new(a.seconds * b)
}
my multi sub infix:<->(Interval:D \a, Int:D \b) is export(:DEFAULT, :refine) {
    a - Duration.new(a.seconds * b)
}

BEGIN EXPORT::refine::<DateTime> := Interval;



Interval - a DateTime that has intervals


=begin code :lang<raku>

use Interval;          # just export the Interval class

my $a = Interval.new(2020,1,1,0,0,0);   # from 2020, interval of 1 hour
say $a;  # 2020-01-01T00:00:00Z
$a++;    # 2020-01-01T01:00:00Z         # one hour later
say $a.seconds;  # 3600

my $b = Interval[60].new(time);         # from now, interval of 1 minute
say $b;  # 2020-04-03T11:42:09Z
$b += 10;
say $b;  # 2020-04-03T11:52:09Z         # ten minutes later

use Interval :refine;   # lexical refinement of the DateTime class

my $c = DateTime[60].new(time);         # from now, interval of 1 minute
say $c;  # 2020-04-03T11:42:09Z
$c += 10;
say $c;  # 2020-04-03T11:52:09Z         # ten minutes later

=end code


The C<Interval> class is a parameterizable subclass of C<DateTime> that
incorporates interval information (in seconds), and the C<.succ> and C<.pred>
methods, which allow it to be used as endpoints in C<Range> (aka C<..>) or
series (aka C<...>).  Or allow it to be incremented or decremented to get
to after the interval.  Or add / subtract a given number of intervals.


The parameterization value is in seconds and defaults to C<3600>, aka 1 hour.


You can also use the C<Interval> class with the C<:refine> parameter.  This
will "augment" the C<DateTime> class in the lexical scope in which the C<use>
statement is located.  This allows one to not to have to change existing code
using the C<DateTime> class, while still having the added functionality of
the C<Interval> class.


Please note that the use of lexical refinement is an experiment for now, until
it has proven its worth.


Produces the "previous" C<Interval> object.


Returns the number of seconds of the interval.


=begin code :lang<raku>

my $b = Interval[60].new(time);         # from now, interval of 1 minute
say $b;  # 2020-04-03T11:42:09Z
$b += 10;
say $b;  # 2020-04-03T11:52:09Z         # ten minutes later

=end code


Allows adding a number of steps of the interval;


Allows subtracting a number of steps of the interval;


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


Interval

use v6.d;

# https://stackoverflow.com/questions/51031264/how-to-create-a-class-that-doesnt-inherit-from-any-other-class
class InterceptAllMethods:ver<0.0.2>:auth<zef:lizmat> is Metamodel::ClassHOW {
    method publish_method_cache(|) { }
}
package EXPORTHOW {
    constant class = InterceptAllMethods;
}



InterceptAllMethods - export ClassHOW to intercept all method calls


class FooBar {
    method ^find_method(Mu $obj, Str $name) {
        return -> | { say "calling $name" }
    }
}


Change the ClassHOW of the compilation unit so that you can create a class
that has a C<^find_method> that will be called for B<any> method call to that
class.  This method should then return a C<Callable> that will called as if
it were the method.


This allows one to implement one's own caching methods, or not have any caching
method at all.


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


InterceptAllMethods

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

InterceptAllMethods v0.0.2

Authors

License

Dependencies

Test Dependencies

Provides

Documentation