terse Raku `transduce`

sub transduce ($stream, |transducers ) {

my ($stream-iterator, $input);

# Step through specified transducers:

gather transducer: for transducers -> $transducer {

# Start pulling from $stream.

# Code written here inside the `for transducers` iteration for right scoping of the `last` in &pull-one.

# Next line is called once when `transduce` sub execution begins, BEFORE `for transducers` loop begins.

FIRST { $stream-iterator = $stream .iterator; $input = pull-one }

# `last` out of the `for transducers` iteration above if stream's IterationEnd reached:

sub pull-one { my $element := $stream-iterator .pull-one; last if $element =:= IterationEnd; $element }

my role Keep {}

# Extract or construct transducer (consumer => producer pair) given each transducer's rule type.

# This transducer `given`/`when` must be in sync with the consumer & producer ones further down.

my ($consumer, $producer) = do given $transducer { # eg transducer rule: does this transduction:

when Array[Code] { .[0], Keep } # `[* %% 2]` Keeps while number is even

when [] { Keep, Keep } # `[]` Keeps entire rest of stream

when Pair { .key[0], .value[0] } # `[] => Nil` Skips entire rest of stream

# `10 => Nil` Skips 10 elements of stream

# `[*.Int] => [++*]` Adds 1 to input while Int

default { .[0], Keep } # `* %% 2` Keeps until number not even

# `10` Keeps 10 elements of stream

}

# Step through stream:

loop {

# All consumers except Keep (`[]`) have a test. If test fails, time for next transducer:

given $consumer {

when Code { next transducer unless .($input) }

when Int { next transducer unless $consumer-- }

}

# A Keep producer always outputs (takes) the input (aka keep).

# A `Nil` producer always outputs nothing (aka skip).

# A code producer that returns an undefined value when run outputs nothing (aka conditional skip).

# A code producer that returns a defined value outputs that value.

# Any other producer value outputs the producer as the value.

given $producer {

when Keep { take $input } # If no explicit producer (or `[]` CONSUMER) then Keep

when Any:U { } # `=> Nil` producer means take nothing (aka skip it)

when Code { .($input) andthen .take if *.defined } # $producer($input) is taken unless result is Empty

default { .take } # If none of the above, take $producer as is as value

}

$input = pull-one

}

}

}

say transduce ^20, 3 => 'strings', [* < 6] => Nil, [* < 10] => [++*], [* %% 5] => 'divisible by 5', [] => -1;