head

Image

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

use Hash::Agnostic:ver<0.0.10>:auth<zef:lizmat>;

role Map::Agnostic:ver<0.0.6>:auth<zef:lizmat>
  does Hash::Agnostic
{
    has int $!initialized;

#---- Methods supplied by Map::Agnostic needed by Hash::Agnostic ---------------
    method ASSIGN-KEY(::?ROLE:D: \key, \value) {
        $!initialized
          ?? (die "Cannot change key '{key}' in an immutable {self.^name}")
          !! self.INIT-KEY(key, value)
    }

    method BIND-KEY(::?ROLE:D: \key, \value) {
        X::Bind.new(target => self.^name).throw;
    }

    method DELETE-KEY(::?ROLE:D: \key) {
        die "Can not remove values from a {self.^name}";
    }

    multi method STORE(::?ROLE:D: \iterable, :$INITIALIZE!) {
        callsame;
        $!initialized = 1;
        self
    }

#---- Methods needed by Map::Agnostic ------------------------------------------
    method INIT-KEY(\key, \value) { ... }

#---- Methods not allowed by Maps ----------------------------------------------
    method append(|) {
        die "Can not append values to a {self.^name}";
    }
    method grab(|) {
        die "Can not grab values from a {self.^name}";
    }
    method push(|) {
        die "Can not push values to a {self.^name}";
    }
}



Map::Agnostic - be a map without knowing how


use Map::Agnostic;
class MyMap does Map::Agnostic {
    method INIT-KEY($key,$value) { ... }
    method AT-KEY($key)          { ... }
    method EXISTS-KEY($key)      { ... }
    method keys()                { ... }
}


This module makes a C<Map::Agnostic> role available for those classes that
wish to implement the C<Associative> role as an immutable C<Map>.  It
provides all of the C<Map> functionality while only needing to implement
4 methods:


Bind the given value to the given key in the map, and return the value.
This will only be called during initialization of the C<Map>.  The functioality
is the same as the C<BIND-KEY> method, but it will only be called at
initialization time, whereas C<BIND-KEY> can be called at any time and will
fail.


Return the value at the given key in the map.


Return C<Bool> indicating whether the key exists in the map.


Return the keys that currently exist in the map, in any order that is
most convenient.


You may implement these methods out of performance reasons yourself, but you
don't have to as an implementation is provided by this role.  They follow the
same semantics as the methods on the
L<Map object|https://docs.perl6.org/type/Map>.


In alphabetical order:
C<elems>, C<end>, C<gist>, C<Hash>, C<iterator>, C<kv>, C<list>, C<List>,
C<new>, C<pairs>, C<perl>, C<Slip>, C<STORE>, C<Str>, C<values>


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


Agnostic

Manifesto - Make a supply of the results of Promises


=begin code

use Manifesto;

my $manifesto = Manifesto.new;

for (^10).pick(*).map( -> $i { Promise.in($i + 0.5).then({ $i })}) -> $p {
    $manifesto.add-promise($p);
}

my $channel = Channel.new;

react {
    whenever $manifesto -> $v {
        $channel.send: $v;
    }
    whenever $manifesto.empty {
        $channel.close;
        done;
    }
}

say $channel.list;

=end code


This manages a collection of Promise objects and provides a Supply
of the result of the kept Promises.


This is useful to aggregate a number of Promises to a single stream
of results, which may then be used in, a C<react> or C<supply> block
or othewise tapped.


This returns the Supply on which will be emited the results of the
kept managed Promises, (it is named C<Supply> so the Manifesto object
can be 'coerced' into a Supply in for instance a C<whenever>.


method add-promise(Promise $promise) returns Bool


This adds a Promise to be managed by this object, it will return True if
the Promise was successfully added, it will not be added if it is not in
state C<Planned>.


This returns a Supply which will emit an event (with the value of True,)
whenever the list of C<Planned> Promises is exhausted.


This returns a Supply onto which the exceptions from broken Promises are
emitted.


method promises() returns Array[Promise]


This is a list of the Promises that are yet to be kept, when they are kept
(or broken,) then they will be removed.



class Manifesto {
    has Supplier $!supplier;
    has Promise  %!promises;

    has Supplier $!empty;
    has Supplier $!exception;

    has Lock $!promises-lock;



    submethod TWEAK() {
        $!supplier  = Supplier.new;
        $!empty     = Supplier.new;
        $!exception = Supplier.new;
        $!promises-lock = Lock.new;
    }

    method Supply( --> Supply ) {
        $!supplier.Supply;
    }

    method add-promise(Promise() $promise --> Bool ) {
        my Bool $rc;
        my $which = $promise.WHICH;
        if  $promise.status ~~ Planned {
            $promise.then(sub ($p ) {
                CATCH {
                    default {
                        $!exception.emit: $_;
                    }
                }
                $!supplier.emit: $p.result;
                $p;
            }).then( {
                $!promises-lock.protect({
                    %!promises{$which}:delete;
                    if %!promises.keys.elems == 0 {
                        $!empty.emit: True;
                    }
                });
            });
            $!promises-lock.protect({
                %!promises{$which} = $promise;
            });
            $rc = True;
        }
        $rc;
    }

    method empty( --> Supply ) {
        $!empty.Supply;
    }

    method exception( --> Supply ) {
        $!exception.Supply;
    }

    method promises() {
        %!promises.values;
    }
}
# vim: expandtab shiftwidth=4 ft=raku


Manifesto

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

Manifesto

image i_github_com_jonathanstowe_manifesto_workflows_ci_badge_svg not found

Synopsis

Description

Installation

Support

Copyright and Licence

Manifesto v0.0.6

Authors

License

Dependencies

Test Dependencies

Provides

Documentation