routine combinations

Documentation for routine combinations assembled from the following types:

class Any

From Any

(Any) method combinations

Defined As:

method combinations(--> Seq)

Treats the Any as a 1-item list and uses List.combinations on it.

say Any.combinations# OUTPUT: «(() ((Any)))␤» 

class List

From List

(List) routine combinations

Defined as:

multi sub    combinations($from$of = 0..*          --> Seq:D)
multi method combinations(List:D: Int() $of          --> Seq:D)
multi method combinations(List:D: Range:D $of = 0..* --> Seq:D)

Returns a Seq with all $of-combinations of the invocant list. $of can be a numeric Range, in which case combinations of the range of item numbers it represents will be returned (i.e. 2.6 .. 4 will return 2-, 3-, and 4-item combinations>). Otherwise, $of is coerced to an Int.

.say for <a b c>.combinations: 2;
# (a b) 
# (a c) 
# (b c) 

Above, there are three possible ways to combine the 2-items lists from the original list, which is what we receive in the output. See permutations if you want permutations instead of combinations.

With Range argument, we get both three 2-item combinations and one 3-item combination:

.say for <a b c>.combinations: 2..3;
# (a b) 
# (a c) 
# (b c) 
# (a b c) 

If $of is negative or is larger than there are items in the given list, an empty list will be returned. If $of is zero, a 1-item list containing an empty list will be returned (there's exactly 1 way to pick no items).

The subroutine form is equivalent to the method form called on the first argument ($from), with the exception that if $from is not an Iterable, it gets coerced to an Int and combinations are made from a Range constructed with 0..^$from instead:

.say for combinations 32
# (0 1) 
# (0 2) 
# (1 2) 

Note: some implementations may limit the maximum value of non-Iterable $from. On Rakudo, 64-bit systems have a limit of 2³¹-1 and 32-bit systems have a limit of 2²⁸-1.