head

code

item

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

ParaSeq - Parallel execution of Iterables


=begin code :lang<raku>

use ParaSeq;

=end code


ParaSeq provides the functional equivalent of
L<C<hyper>|https://docs.raku.org/type/Iterable#method_hyper> and
L<C<race>|https://docs.raku.org/type/Iterable#method_race>, but
re-implemented from scratch with all of the experience from the
initial implementation of C<hyper> and <race> in 2014, and using
features that have since been added to the Raku Programming Language.


As such it exports two subroutines C<hyperize> and C<racify>, to
make them plug-in compatible with the
L<C<hyperize>|https://raku.land/zef:lizmat/hyperize> distribution.


One of the main issues with the current implemementation of C<.hyper>
and C<.race> in the Rakudo core is that the batch size is fixed.  Worse,
there is no way to dynamically adapt the batch size depending on the
load.


Batch sizes that are too big, have a tendency to not use all of
the CPUs (because they have a tendency to eat all of the source items
too soon, thus removing the chance to start up more threads).


Batch sizes that are too small, have a tendency to have their resource
usage drowned out by the overhead of batching and dispatching to
threads.


This implementation aims to adapt batch sizes from the originally
(implicitely) specified one for better throughput and resource usage.


If the C<degree> specified is B<1>, then there is no point in batching
or parallelization.  In that case, this implementation will take itself
completely out of the flow.


Alternately, if the initial batch size is large enough to exhaust the
source, it is clearly too large.  Which is interpreted as not making
any sense at parallelization either.  So it won't.


Note that the default initial batch size is B<10>, rather than B<64>
in the current implementation of C<.hyper> and C<.race>, making the
chance smaller that parallelization is abandoned too soon.


The C<.serial> method or C<.Seq> coercer can be typically be used to
"unhyper" a hypered sequence.  However many other interface methods do
the same in the current implementation of C<.hyper> and C<.race>,
thereby giving the impression that the flow is still parallelized.
When in fact they aren't anymore.


Also, hyperized sequences in the current implementation are considered
to be non-lazy, even if the source B<is> lazy.


This implementation aims to make all interface methods pass on the
hypered nature and laziness of the sequence.


Some loop control statements may affect the final result.  Specifically
the C<last> statement does.  In the current implementation of C<.hyper>
and C<.race>, this will only affect the batch in which it occurs.


This implementation aims to make C<last> stop any processing of current
and not create anymore batches.


Currently only the C<.map> and C<.grep> methods are completely supported
by the current implementation of C<.hyper> and C<.race>.  Other methods,
such as C<.first>, will also be supported.


When an interface method takes a C<Callable>, then that C<Callable>
can contain phasers that may need to be called (or not called) depending
on the situation.  The current implementation of C<.hyper> and C<.race>
do not allow phasers at all.


This implementation aims to support phasers in a sensible manner:


Called on the first iteration in the first batch.


Called on the last iteration in the last batch.  Note that this can be
short-circuited with a C<last> control statement.


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


ParaSeq

class Parameterizable is Mu {
    method ^parameterize(Mu:U \obj, **@pos is raw) {
        my \ROLE = try obj.MIXIN(|@pos);
        if $! {
            die "Can not parameterize {obj.^name} with "
              ~ @pos.map(*.raku).join(', ');
        }

        my $what := obj.^mixin(ROLE);
        $what.^set_name("{obj.^name}[{@pos.map(*.^name).join(',')}]");
        $what;
    }
}



Parameterizable - Make a class parameterizable


=begin code :lang<raku>
use Parameterizable;

role Fooey[::Type] {
    method of() { Type }
}

class Foo is Parameterizable {
    method MIXIN(Mu:U \type) { Fooey[type] }
}

my $obj = Foo[Int].new;
say $obj.of; # OUTPUT: «(Int)␤»
=end code

Roles can be parameterized, and in almost all cases such a role can be used as
if it were a class because Raku supports L<automatic role
punning|https://docs.raku.org/language/objects#Automatic_role_punning>. One
unsupported use case is a method that assigns to the invocant, for example to
support autovivification. If a type wants to support that, it must be a class.
But classes are not parameterizable... or are they?


Class C<Parameterizable> uses an undocumented Rakudo feature that allows classes
to be parameterized. To support parameterization, a class may simply inherit
from C<Parameterizable> and define a method C<MIXIN> that maps positional
arguments to a role definition. The class can then be parameterized with
arguments that are accepted by a C<.MIXIN> candidate.


Class parameterization works by mixing in the role returned by C<.MIXIN>. The
parameterized class is given a name that includes the types of arguments it was
parameterized with.


Source can be located at: https://github.com/dumarchie/raku-parameterizable


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


Parameterizable

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

SEE ALSO

AUTHOR

COPYRIGHT AND LICENSE

Parameterizable v0.0.2

Authors

License

Dependencies

Test Dependencies

Provides

Documentation