Untitled

enum Event <Exit Enter Quit Last Last-Phaser>;

role SupplyInspector {
    method event(
        Event:D  :$event!,
        Str:D    :$spec!,
                 :$value, # only present in Enter
        Numeric  :$elapsed, # not present in Enter
        Exception :$exception, # only present in Quit
        Str      :$phaser-spec, # only present in Quit and Last-Phaser
        Bool     :$has-phaser, # only present in Quit, Last and Last-Phaser
    ) { ... }
}

class SupplyInspector::Print does SupplyInspector {
    method event(Event:D :$event!, Str:D :$spec!, :$value,
                 Numeric :$elapsed, Exception :$exception,
                 Str :$phaser-spec, Bool :$has-phaser) {
        my $ts   = (now - INIT now).round(0.001) ~ 's';
        my sub c(Int $c, Str $t) { "\e[{$c}m{$t}\e[0m" }
        my $tag = c(31 + $event, $event.uc);

        say qq:to/END/.indent(4);
			[$ts]{
				$has-phaser eqv False ?? c(35, " NO PHASER") !! ""
			} $tag {$spec}{ 
				$value // ""
			}{
				$elapsed ?? " ({$elapsed.round(0.001)}s)" !! ""
			}{
				$exception ?? "\n{c(38, "Exception")}:\n{$exception.gist.indent(4)}" !! ""
			}{
				$phaser-spec ?? " [phaser: $phaser-spec]" !! ""
			}
			END
    }
}

sub INSPECT-SUPPLY(SupplyInspector :$inspector = SupplyInspector::Print.new) {
    use nqp;
    my &OLD := nqp::getlexdyn('&*ADD-WHENEVER');

    my &NEW := sub (Supply $s, &block) {
        my $spec  = "{&block.file}:{&block.line}";
        my $q     = &block.phasers('QUIT')[0];
        my $qspec = $q.DEFINITE ?? "{$q.file}:{$q.line}" !! Str;
        my $has-q = $q.DEFINITE;

        my @lasts = &block.phasers('LAST').map: -> &l {
            ("{&l.file}:{&l.line}", &l)
        }

        OLD($s, -> $value {
            my $enter = now;

            $inspector.event(:event(Enter), :$spec, :$value);

            LEAVE $inspector.event(:event(Exit), :$spec,
                                 :elapsed(now - $enter));

            QUIT {
                default {
                    my $enter = now;
                    $q($_) if $has-q;

                    $inspector.event(
                        :event(Quit), :$spec,
                        :exception($_),
                        :phaser-spec($qspec),
                        :has-phaser($has-q),
                        :elapsed(now - $enter),
                    );
                }
            }

            &block($value);

            LAST {
                my $enter = now;
                for @lasts -> ($lspec, $lphaser) {
                    my $enter = now;
                    $lphaser();
                    $inspector.event(
                        :event(Last-Phaser), :$spec,
                        :phaser-spec($lspec),
                        :has-phaser(True),
                        :elapsed(now - $enter),
                    );
                }
                $inspector.event(
                    :event(Last), :$spec,
                    :elapsed(now - $enter),
                    :has-phaser(@lasts.so),
                );
            }
        });
    }

    nqp::bindlexdyn('&*ADD-WHENEVER', &NEW);
}

sub foo($n) { 
    supply { 
        INSPECT-SUPPLY; 
        whenever Promise.in(1) { whenever ^3 { "$n: $_".say; sleep .2; } } } 
    };
await supply { 
    INSPECT-SUPPLY;
    for ^3 -> $n { 
        whenever foo($n) { LAST { say "end" } } 
    }
} # suddenly multithreaded