Syntax::Keyword::Junction - Comparisons against multiple values

       You cannot alter junctions.  Instead, you can create new junctions out of old junctions.  You can do this
       by calling the "values" method on a junction.

         my $numbers = any(qw/1 2 3 4 5/);
         print $numbers == 3 ? 'Yes' : 'No';   # Yes

         $numbers = any( grep { $_ != 3 } $numbers->values );
         print $numbers == 3 ? 'Yes' : 'No';   # No

       You can also use the "map" method:

         my $numbers = any(qw/1 2 3 4 5/);
         my $prime   = $numbers->map( \&is_prime );

         say for $prime->values; # prints 0, 1, 1, 0, 1

       •   Arthur Axel "fREW" Schmidt <frioux+cpan@gmail.com>

       •   Carl Franks

       Please report any bugs or feature requests on the bugtracker website
       <https://github.com/haarg/Syntax-Keyword-Junction/issues>

       When submitting a bug or request, please include a test-file or a patch to an existing test-file that
       illustrates the bug or desired feature.

       •   Arthur Axel 'fREW' Schmidt <frioux@gmail.com>

       •   Carl Franks <cpan@fireartist.com>

       •   David Steinbrunner <dsteinbrunner@pobox.com>

       •   Graham Knop <haarg@haarg.org>

       •   Maxime Soulé <btik-cpan@scoubidou.com>

       •   Michael Schout <schoutm@gmail.com>

       •   Olivier Mengué <dolmen@cpan.org>

       •   Paul Cochrane <paul.cochrane@posteo.de>

       •   Ricardo Signes <rjbs@cpan.org>

       •   Rob Hoelz <rob@hoelz.ro>

       This software is copyright (c) 2024 by Arthur Axel "fREW" Schmidt.

       This  is  free  software;  you  can  redistribute  it and/or modify it under the same terms as the Perl 5
       programming language system itself.

perl v5.40.0                                       2024-08-24                     Syntax::Keyword::Junction(3pm)

       This is a lightweight module which provides 'Junction' operators, the most commonly used being "any" and
       "all".

       Inspired by the Perl 6 design docs,
       <https://web.archive.org/web/20230922160729/https://raku.org/archive/doc/design/exe/E06.html#The%20Wonderful%20World%20of%20Junctions>.

       Provides a limited subset of the functionality of Quantum::Superpositions, see "SEE ALSO" for comment.

       Notice in the "SYNOPSIS" above, that if you want to match against a regular expression, you must use "=="
       or "!=". Not "=~" or "!~". You must also use a regex object, such as "qr/\d/", not a plain regex such as
       "/\d/".

       'all', 'any', 'none', 'one', as requested.

       All subroutines can be called by its fully qualified name, if you don't want to export them.

         use Syntax::Keyword::Junction;

         if (Syntax::Keyword::Junction::any( @questions )) {
           ...
         }

       Syntax::Keyword::Junction - Comparisons against multiple values

       This module is actually a fork of Perl6::Junction with very few (initial) changes.  The reason being that
       we want to avoid the incendiary name containing Perl 6.

       Quantum::Superpositions provides the same functionality as this, and more. However, this module provides
       this limited functionality at a much greater runtime speed, with my benchmarks showing between 500% and
       6000% improvement.

       <https://web.archive.org/web/20230922160729/https://raku.org/archive/doc/design/exe/E06.html#The%20Wonderful%20World%20of%20Junctions>
       - "The Wonderful World of Junctions".

all()
       Returns an object which overloads the following operators:

         '<',  '<=', '>',  '>=', '==', '!=',
         'lt', 'le', 'gt', 'ge', 'eq', 'ne',
         '~~'

       Returns true only if all arguments test true according to the operator used.

   any()
       Returns an object which overloads the following operators:

         '<',  '<=', '>',  '>=', '==', '!=',
         'lt', 'le', 'gt', 'ge', 'eq', 'ne',
         '~~'

       Returns true if any argument tests true according to the operator used.

   none()
       Returns an object which overloads the following operators:

         '<',  '<=', '>',  '>=', '==', '!=',
         'lt', 'le', 'gt', 'ge', 'eq', 'ne',
         '~~'

       Returns true only if no argument tests true according to the operator used.

   one()
       Returns an object which overloads the following operators:

         '<',  '<=', '>',  '>=', '==', '!=',
         'lt', 'le', 'gt', 'ge', 'eq', 'ne',
         '~~'

       Returns true only if oneandonlyone argument tests true according to the operator used.

         use Syntax::Keyword::Junction qw/ all any none one /;

         if (any(@grant) eq 'su') {
           ...
         }

         if (all($foo, $bar) >= 10) {
           ...
         }

         if (qr/^\d+$/ == all(@answers)) {
           ...
         }

         if (all(@input) <= scalar @limits) {
           ...
         }

         if (none(@pass) eq 'password') {
           ...
         }

         if (one(@answer) == 42) {
           ...
         }

       or if you want to rename an export, use Sub::Exporter options:

         use Syntax::Keyword::Junction any => { -as => 'robot_any' };

         if (robot_any(@grant) eq 'su') {
           ...
         }

       Add overloading for arithmetic operators, such that this works:

         $result = any(2,3,4) * 2;

         if ($result == 8) {...}

       When comparing against a regular expression, you must remember to use a regular expression object:
       "qr/\d/" Not "/d/". You must also use either "==" or "!=". This is because "=~" and "!~" cannot be
       overridden.