head

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

# Only look up original postcircumfix[] once
my &cpcf := CORE::{'&postcircumfix:<[ ]>'};

proto sub postcircumfix:<[ ]> (|) is export {*}
multi sub postcircumfix:<[ ]>(Str:D $string, Int:D $pos, *%_) {
    %_
      ?? (nextsame)
      !! ($string.substr($pos, 1) || Nil)
}
multi sub postcircumfix:<[ ]>(Str:D $string, |c) is default {
    my $r := cpcf($string.comb.cache, |c);
    $r ~~ Failure || $r.flat.first({ $_ ~~ any Failure, none Nil, Str }) !=== Nil
        ?? $r
        !! $r.flat.grep(*.defined).join
}
multi sub postcircumfix:<[ ]>(|c) { cpcf(|c) }



Pythonic::Str - Index into strings like Pythonistas do!


code

=begin code :lang<raku>

use Pythonic::Str;

say 'foobar'[3];            # b
say 'foobar'[3..*];         # bar
say 'foobar'[^3];           # foo
say 'foobar'[3,5,6]:exists; # (True True False)

=end code


Provides C<&postcircumfix:<[ ]>> candidates to index into strings. Any
indexing operation you normally can use on lists is supported.


When multiple indices are given, the result will be calculated as if the
indexing were called on a list of individual characters that compose the given
string. B<If all the elements> nodally are of type C<Str> or C<Nil> (excluding
C<Failure>s), then the result will be joined together to form a single string.
Any other type of the output is returned as if it were called on a list
of individual characters that compose the given string.


In plainer language this means that you get a single string result for stuff
like:


=begin code :lang<raku>

say 'foobar'[^3];           # foo
say 'foobar'[0, 1, 2];      # foo
say 'foobar'[0, (1, (2,))]; # foo

=end code


... but will get the same result as if you called indexing on a list of
characters for stuff like:


=begin code :lang<raku>

say 'foobar'[^3]:p;           # (0 => f 1 => o 2 => o)
say 'foobar'[0, 1, 2]:exists; # (True True True)
say WHAT 'foobar'[1]:delete;  # (Failure)

=end code


This module does not provide C<Str.AT-POS> or make C<Str> type do
C<Positional> or C<Iterable> roles. The latter causes all sorts of fallout
with core and non-core code due to inherent assumptions that C<Str> type
does not do those roles. What this means in plain English is you can only
index your strings with C<[...]> postcircumfix operator and can't
willy-nilly treat them as lists of characters—simply.  Call
L<C<.comb>|https://docs.raku.org/routine/comb> if you need that.


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


use v6;
my $VERSION = "1.0.0";
unit module python::itertools;



A direct port of Python's itertools to perl6.


It provides all the functionality that python's itertools does, including lazy evaluation.  In the future, I'd like to maximize the performance of these
functions.  Function signatures may be a little different.


I needed a itertools.combinations_with_replacement and couldn't find an easy builtin or library to do it.  So why not write the library myself? It turns out
raku has most of these functions built in already. Unfortunatley, I did not realize that until after writing it. Oops.


accumulate(@iterable, $func=&[+])
Gathers accumulated sums, or accumulated results of other binary functions (specified via the optional $func argument). If $func is
supplied, it should be a function of two arguments.


=begin code
accumulate((1,2,3,4,5)) --> (1, 3, 6, 10, 15)
accumulate((1,2,3,4,5), &[*]) --> (1, 2, 6, 24, 120)
=end code


batched(@iterable, $n)
groups items of @iterable into lists of size $n. If there's not enough to create a list of size $n, then takes the remaining items.


=begin code
batched(('a','b','c','d','e','f','g'), 2) -> (('a', 'b'), ('c', 'd'), ('e', 'f'), ('g'))
=end code


combinations(@iterable, $r)
Gathers all combinations of length $r from @iterable, not allowing repeated elements


=begin code
combinations(('a','b','c','d'), 2) -> (('a','b'), ('a','c'), ('a','d'), ('b','c'), ('b','d'), ('c','d'));
=end code


combinations_with_replacement(@iterable, $r)
Gathers all combinations of length $r from @iterable, allowing elements to repeat.


=begin code
combinations_with_replacement(('a','b','c'), 2) -> (('a','a'), ('a','b'), ('a','c'), ('b','a'), ('b','b'), ('b','c'), ('c','a'), ('c','b'), ('c','c'));
=end code


chain(*@iterables)
Merges all of *@iterables into a single list. 


=begin code
chain(("A","B","C"), ("D","E","F")) --> ("A", "B", "C", "D", "E", "F")
=end code


count($start is copy, $step=1)
Gathers values from $start, increasing by $step each time. Infinte list.


=begin code
count(10)[^5] --> (10, 11, 12, 13, 14)
count(10, 2)[^5], (10,12,14,16,18);
=end code


compress(@elements, @selectors)
Returns all members of @elements where the corresponding ?@selector is True.


=begin code
compress(['a','b','c','d'], [True,False,True,False]) -> ['a','c']
=end code


cycle(@iterable )
Creates an infinite repeating List from @iterable


=begin code
cycle(['a','b','c','d'])[^6] -> ['a','b','c','d','a','b']
=end code


dropwhile(@elements, $predicate=Bool)
Shifts @elements until $predicate evaluates to False and gathers remaining elements


=begin code
dropwhile([1,4,6,4,1], {$_ < 5;}) --> [6,4,1];
=end code


filterfalse($predicate, @iterable)
Filters elements from @iterable where $predicate is False


=begin code
filterfalse({ $_ % 2 == 1}, 0..5) -> [0,2,4];
=end code


groupby(@iterable, $key={ $_} )
Groups elements into Lists by a function defined in $key. Default is the identity function.


=begin code
groupby(['a','b','a','a','a','b','b','c','a']) -> (('a','a','a','a','a'),('b','b','b'),('c'));
groupby(0..5, { $_ % 2 }) -> ((0, 2, 4),(1, 3, 5));
=end code


islice(@iterable, $start, $stop, :$step=1)
Slices @iterable from $start to $stop, skipping $step-1 elements. If only $stop is defined, starts from 0.
If $stop is Nil, uses the entire @iterable;


=begin code
islice(('a','b','c','d','e','f','g') , 2) -> ('a', 'b');
islice(('a','b','c','d','e','f','g') , 2, 4) -> ('c', 'd');
islice(('a','b','c','d','e','f','g') , 2, Nil) -> ('c', 'd', 'e', 'f', 'g');
islice(('a','b','c','d','e','f','g') , 0, Nil, step => 2) -> ('a', 'c', 'e', 'g');
=end code


pairwise(@iterable)
Creates sucessive overlapping pairs of elements from @iterable. If @iterable has less than 2 elements, returns empty list


=begin code
pairwise(('a','b','c','d','e','f','g')) -> (('a', 'b'), ('b', 'c'), ('c', 'd'), ('d', 'e'), ('e', 'f'), ('f', 'g'));
pairwise(['a']) -> ();
=end code


permutations(@iterable, $r)
Creates sucessive $r-length permutations from iterable. If $r is Nil, uses the length of @iterable as $r


=begin code
permutations(('A', 'B', 'C', 'D'), 2) -> (('A', 'B') , ('A', 'C'), ('A','D'), ('B', 'A'), ('B', 'C'), ('B', 'D'), ('C', 'A'), ('C', 'B'), ('C', 'D'), ('D', 'A'), ('D', 'B'), ('D', 'C'));
=end code


product(**@iterables, :$repeat=1)
Duplicates each item in @iterables $repeat times and then creates the cartesian product of all items.


=begin code
product([0,1], :repeat(3)) -> ((0,0,0), (0,0,1), (0,1,0), (0,1,1), (1,0,0), (1,0,1), (1,1,0), (1,1,1));
product([0,1], [0,1]) -> ((0,0), (0,1), (1,0), (1,1));
product([0,1], [0,1], :repeat(2)) -> ((0, 0, 0, 0), (0, 0, 0, 1), (0, 0, 1, 0), (0, 0, 1, 1), (0, 1, 0, 0), (0, 1, 0, 1), (0, 1, 1, 0), (0, 1, 1, 1), (1, 0, 0, 0), (1, 0, 0, 1), (1, 0, 1, 0), (1, 0, 1, 1), (1, 1, 0, 0), (1, 1, 0, 1), (1, 1, 1, 0), (1, 1, 1, 1));
=end code


repeat($obj, Int $times=0)
Gathers $obj $times times or Infintely if $times is 0.


=begin code
repeat("3")[^5] -> [3,3,3,3,3];  
repeat("3",3) -> [3,3,3];  
=end code


starmap($function, @iterable)
Gathers items where each item in @iterable is computed with $function. Used instead of map when argument parameters are already grouped in tuples from a single iterable (the data has been “pre-zipped"


=begin code
starmap(&sum, ((1,2,3), (4,5,6))) -> (6, 15)
=end code


tee(@iterable, $n)
Gathers $n independent @iterable;


=begin code
tee(1..5 ,3) -> (1..5, 1..5, 1..5);
=end code


takewhile(@elements, $predicate=Bool)
Gathers items from @elements until $predicate evaluates to False. 


=begin code
takewhile([1,4,6,4,1], {$_ < 5;}) -> [1,4];
=end code


zip_longest(@elements, :$fillvalue=Nil)
zips elements from each of @iterables. If the iterables are of uneven length, fillvalue replaces the missing values.
Iteration continues until the longest iterable is exhausted. 


=begin code
zip_longest((1,2,3,4),(1,2), (-1,-2,-3), :fillvalue("0")) -> ((1,1,-1), (2,2,-2), (3,"0",-3), (4, "0","0"));
=end code



sub accumulate(@iterable, :$func=&[+], :$initial


sub batched(@iterable, $n) is export {
  my $index = 0;
  die "n must be greater than 0." if $n < 1;
  gather {
    while $index < @iterable.elems {
      take (@iterable[$index..$index+$n-1].grep({ $_ !=== Nil }).List);
      $index += $n;
    }
  }
}

sub chain(*@iterables) is export { @iterables }

sub count($start is copy, $step=1) is export { $start, *+$step ... *; }

#TODO: combinations
sub combinations(@iterable, $r) is export {
    gather { combinations_helper(@iterable, [], $r, False); }
}

sub combinations_with_replacement(@iterable, $r) is export { 
    gather { combinations_helper(@iterable, [], $r, True); }
}

sub combinations_helper(@iterable, @state, $r, $replacement

False


sub compress(@elements, @selectors) is export {
    gather {
        for zip(@elements, @selectors) -> ($element, $selector) {
            take $element if (?$selector);
        }
    }
}

sub cycle(@iterable) is export {
    die "iterable must be a list" unless @iterable;
    gather {
        while True {
            take $_ for @iterable; 
        }
    }
}

sub dropwhile(@elements, $predicate

Bool


sub filterfalse($predicate, @iterable) is export {
  @iterable.grep({ not $predicate($_); }).List;
}

sub groupby(@iterable is copy, $key={ $_ }) is export {
    gather {
        my @rest = @iterable.Array;
        while ?@rest {
            my $head = $key(@rest.first);
            take (@rest ==> grep { $head eqv $key($_)}).List;
            @rest = (@rest ==> grep { not ($head eqv $key($_))});
        }
    }
}

multi sub islice(@iterable, $stop) is export {
  islice(@iterable, 0, $stop);
}

multi sub islice(@iterable, $start, $stop, :$step=1) is export {
  my $index = 0 ;
  gather {
    for @iterable {
      if ($index >= $start and ($stop === Nil or $index < $stop) and ($index - $start) % $step == 0) { take $_;}
      $index++;
    }
  }
  
}

sub pairwise(@iterable) is export {
  my $index = 0;
  return List if @iterable.elems < 2;
  gather {
    while $index < @iterable.elems - 1 {
      take @iterable[$index..$index+1];
      $index += 1;
    }
  }
}

sub permutations(@iterable, $r


sub permutations_helper(@iterable, @state, $r) {
    for 0..@iterable.elems-1 {
        @state.push(@iterable[$_]);
        if $r > 1 {
            if $_ == 0 {
              permutations_helper(@iterable[1..*-1], @state, $r-1);
            }
            elsif $_  == @iterable.elems - 1 {
              permutations_helper(@iterable[0..*-2], @state, $r-1);
            }
            else { 
              permutations_helper((|@iterable[0..$_-1], |@iterable[$_+1..*-1]), @state, $r-1);
            }
            @state.pop;
        } else {
            my @return = @state.List;
            @state.pop;
            take @return;
        }
    }
}


sub product(**@iterables, :$repeat=1) is export {
    die unless $repeat > 0;
    if $repeat > 1 { 
        my @repeated = ();
        @iterables = (@iterables ==> map -> @it {@it xx $repeat} );  
        for @iterables -> @it {
            for @it -> @r { @repeated.push(@r); }
        }
        @iterables = @repeated;
    } 
    gather {
         take $_ for ([X] @iterables);
    }
}

sub repeat($obj, Int $times=0) is export {
    die "times-repeated in repeats must be > -1." unless $times >= 0;
    gather {
        if $times == 0 {
            take $obj while True; 
        } else {
            take $obj for 1..$times;  
        }
    }
}

sub starmap($function, @iterable) is export { @iterable.map({.$function}) }

sub takewhile(@elements, $predicate


sub tee(@iterable is copy, Int $n) is export {
    gather { 
        take @iterable for 1..$n;
    }
}

sub zip_longest(**@iterables, :$fillvalue = Nil) is export {
    my $longest = (@iterables ==> map -> @it { @it.elems } ==> max);
    my $index = 0;
    gather {
        while $index < $longest {
            my @result = ();    
            for @iterables -> @it {
                if $index < @it.elems {
                    @result.push(@it[$index]);
                } else {
                    @result.push($fillvalue);
                }
            }
            take @result;
            ++$index;
        }
    }
}



itertools

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

Module

Description

Copying

Prerequisites

Build/Installation

Author

python::itertools v1.0.0

Authors

License

Dependencies

Test Dependencies

Provides

Documentation