class Slip

A kind of List that automatically flattens into an outer container

class Slip is List {}

A Slip is a List that automatically flattens into an outer List (or other list-like container or iterable).

For example it allows you to write a map that produces more than one value into the result without nesting:

say <a b c>.map({ ($_, $_.uc).Slip }).join('|');        # OUTPUT: «a|A|b|B|c|C␤» 

In contrast, when returning an ordinary List, the resulting list is nested:

say <a b c>.map({ $_, $_.uc }).join('|');               # OUTPUT: «a A|b B|c C␤» 

To create a Slip, either coerce another list-like type to it by calling the Slip method, or use the slip subroutine:

# This says "1" and then says "2", rather than saying "(1 2)" 
.say for gather {
    take slip(1, 2);
}

A Slip may also be created by using the prefix:<|> operator. This differs from the slip subroutine in both precedence and treatment of single arguments. In fact, prefix:<|> only takes a single argument, so in that way, it behaves closer to the .Slip method than the slip subroutine.

my $l = (1, 2, 3);
say (1, slip 2, 3).raku;  # says (1, 2, 3)          , slips 2, 3 into (1, …) 
say (0, slip $l, 4).raku; # says (0, $(1, 2, 3), 4) , $l does not break apart 
say (0, slip $l).raku;    # says (0, 1, 2, 3)       , slips from $l into (0, …) 
say (0, $l.Slip).raku;    # says (0, 1, 2, 3)       , slips from $l into (0, …) 
say (0, $l.Slip, 4).raku; # says (0, 1, 2, 3, 4)    , slips from $l into (0, …, 4) 
say (|$l).raku;           # says slip(1, 2, 3)      , breaks apart $l 
say (0, (|$l, 4), 5);     # says (0 (1 2 3 4) 5)    , slips from $l into (…, 4) 
say (0, ($l.Slip, 4), 5); # says (0 (1 2 3 4) 5)    , slips from $l into (…, 4) 
say (0, (slip $l, 4), 5); # says (0 (1 2 3) 4 5)    , slips ($l, 4) into (0, …, 5) 
say (0, ($l, 4).Slip, 5); # says (0 (1 2 3) 4 5)    , slips ($l, 4) into (0, …, 5) 

Loops that do not want to produce a value for an iteration use Slips, rather than empty Lists to do so, as do if statements that do not run their blocks.

Please note that prefix:<|> will also apply parameters in a slippy manner to a routine call. It does not forward a Slip to the called routine, that includes return and take.

my \l = gather for 1..10 -> $a, $b { take |($a, $b) }; say l.raku;
# OUTPUT: «((1, 2), (3, 4), (5, 6), (7, 8), (9, 10)).Seq␤» 
my \m= gather for 1..10 -> $a, $b { take ($a, $b).Slip }; say m.raku;
# OUTPUT: «(1, 2, 3, 4, 5, 6, 7, 8, 9, 10).Seq␤»

Methods§

method List§

multi method List(Slip:D: --> List:D)

Turns it into a list.

sub slip§

multi slip(--> Empty)
multi slip(@args --> Slip:D)
multi slip(+args --> Slip:D)

Creates a Slip from its arguments by calling .Slip on the object formed by them. Returns Empty if called with void arguments.

Constants§

constant Empty§

Empty is a Slip of the empty List.

say "".comb ~~ Empty;
# OUTPUT: «True␤»

For example, these constructs with a failing test return Empty:

do if 0 {};
(42 if 0);
do with Any {};
(42 with Any);

Typegraph§

Type relations for Slip
raku-type-graph Slip Slip List List Slip->List Mu Mu Any Any Any->Mu Cool Cool Cool->Any Positional Positional Iterable Iterable List->Cool List->Positional List->Iterable

Expand chart above