Whateverable/query

## query
SCHEDULER

## result.md

      
    Raw
  

              result.md
            
          
File
Code


FRITH/Hash-Timeout
…/Timeout.pm6 :21:
    %!cancel{key} := $*SCHEDULER.cue({ %!hash{key}:delete }, :in($timeout));


FRITH/Hash-Timeout
…/Timeout.pm6 :26:
    %!cancel{key} := $*SCHEDULER.cue({ %!hash{key}:delete }, :in($timeout));


HANENKAMP/HTTP-Request-Supply
…/Test.pm6 :43:
            # note "CURRENT LOADS PRE-CHUNKING = ", $*SCHEDULER.loads;


HANENKAMP/HTTP-Supply
…/Test.pm6 :43:
            # note "CURRENT LOADS PRE-CHUNKING = ", $*SCHEDULER.loads;


JNTHN/Cro-HTTP
…/http-request-parser.t :30:
    $testee.transformer($fake-in.Supply).schedule-on($*SCHEDULER).tap:


JNTHN/Cro-HTTP
…/http-response-parser.t :27:
    $testee.transformer($fake-in.Supply).schedule-on($*SCHEDULER).tap:


JNTHN/Cro-HTTP
…/http2-frame-parser.t :21:
    $parser.transformer($fake-in.Supply, :$connection-state).schedule-on($*SCHEDULER).tap: -> $frame {},


JNTHN/Cro-HTTP
…/http2-frame-parser.t :66:
    $parser.transformer($fake-in-p.Supply, :$connection-state).schedule-on($*SCHEDULER).tap: -> $frame {


JNTHN/Cro-HTTP
…/http2-frame-parser.t :68:
        $serializer.transformer($fake-in-s.Supply, :$connection-state).schedule-on($*SCHEDULER).tap: -> $message {


JNTHN/Cro-HTTP
…/http2-frame-serializer.t :29:
    $serializer.transformer($fake-in-s.Supply, :$connection-state).schedule-on($*SCHEDULER).tap: -> $message {


JNTHN/Cro-HTTP
…/http2-frame-serializer.t :33:
            $parser.transformer($fake-in-p.Supply, :$connection-state).schedule-on($*SCHEDULER).tap: -> $newframe {


JNTHN/Cro-WebSocket
…/websocket-frame-parser.t :17:
    $parser.transformer($fake-in.Supply).schedule-on($*SCHEDULER).tap: -> $frame {


JNTHN/Cro-WebSocket
…/websocket-frame-serializer.t :20:
    $serializer.transformer($fake-in-s.Supply).schedule-on($*SCHEDULER).tap: -> $message {


JNTHN/Cro-WebSocket
…/websocket-frame-serializer.t :21:
        $parser.transformer($fake-in-p.Supply).schedule-on($*SCHEDULER).tap: -> $newframe {


JNTHN/Cro-WebSocket
…/websocket-message-parser.t :8:
    $parser.transformer($fake-in.Supply).schedule-on($*SCHEDULER).tap: -> $message {


JNTHN/IO-Socket-Async-SSL
…/README.md :127:
  the underlying `IO::Socket::Async` instance. The default is `$*SCHEDULER`.


JNTHN/IO-Socket-Async-SSL
…/SSL.pm6 :260:
                   :$enc = 'utf8', :$scheduler = $*SCHEDULER,


JNTHN/IO-Socket-Async-SSL
…/SSL.pm6 :342:
                  :$enc = 'utf8', :$scheduler = $*SCHEDULER,


JNTHN/IO-Socket-Async-SSL
…/SSL.pm6 :793:
    method Supply(:$bin, :$enc = $!enc, :$scheduler = $*SCHEDULER) {


JNTHN/IO-Socket-Async-SSL
…/SSL.pm6 :810:
    method print(IO::Socket::Async::SSL:D: Str() $str, :$scheduler = $*SCHEDULER) {


JNTHN/IO-Socket-Async-SSL
…/SSL.pm6 :814:
    method write(IO::Socket::Async::SSL:D: Blob $b, :$scheduler = $*SCHEDULER) {


JNTHN/cro
…/Services.pm6 :108:
            whenever tap-on(self!scan(), $*SCHEDULER) {


JSTOWE/Manifesto
…/030-failures.t :8:
my $*SCHEDULER = ThreadPoolScheduler.new(max_threads => 1);


MARTIMM/BSON
…/EDC.pm6 :136:
              $*SCHEDULER.cue( {


FCO/test-time
…/README.md :10:
    $*SCHEDULER = mock-time :auto-advance;


FCO/test-time
…/README.md :25:
Or you can use `$*SCHEDULER.advance-by: 10` as you would when using **Test::Scheduler**


FCO/test-time
…/Time.pm6 :9:
$*SCHEDULER = mock-time :auto-advance;


FCO/test-time
…/Time.pm6 :24:
Or you can use C<$*SCHEDULER.advance-by: 10> as you would when using B<Test::Scheduler>


FCO/test-time
…/Time.pm6 :35:
    my $*SCHEDULER = Test::Scheduler.new: :virtual-time($now);


FCO/test-time
…/Time.pm6 :43:
    %wraps<now>     = &term:<now>.wrap:  { $*SCHEDULER.virtual-time }


FCO/test-time
…/Time.pm6 :56:
            $*SCHEDULER.advance-by: $interval


FCO/test-time
…/Time.pm6 :60:
    $*SCHEDULER


FCO/test-time
…/01-tdd.t :7:
    my $*SCHEDULER;


FCO/test-time
…/01-tdd.t :17:
    $*SCHEDULER = mock-time $tai;


FCO/test-time
…/01-tdd.t :28:
    $*SCHEDULER = mock-time;


FCO/test-time
…/01-tdd.t :47:
    $*SCHEDULER.advance-by: 10;


FCO/test-time
…/01-tdd.t :48:
    $*SCHEDULER.advance-by: 20;


FCO/test-time
…/01-tdd.t :49:
    $*SCHEDULER.advance-by: 20;


FCO/test-time
…/01-tdd.t :54:
    $*SCHEDULER = mock-time :auto-advance;


FCO/test-time
…/01-tdd.t :74:
    $*SCHEDULER = mock-time;


FCO/test-time
…/01-tdd.t :86:
    $*SCHEDULER.advance-by: 50;


MARTIMM/BSON
…/EDC.pm6 :136:
              $*SCHEDULER.cue( {


finanalyst/pod-cached
…/Cached.pm6 :141:
    PROCESS::<$SCHEDULER> = ThreadPoolScheduler.new(initial_threads => 0, max_threads => MAX-COMPILATIONS);


jnthn/p6-concurrent-progress
…/min-interval.t :6:
    my $*SCHEDULER = Test::Scheduler.new;


jnthn/p6-concurrent-progress
…/min-interval.t :11:
    $*SCHEDULER.advance;


jnthn/p6-concurrent-progress
…/min-interval.t :19:
    $*SCHEDULER.advance-by(0.5);


jnthn/p6-concurrent-progress
…/min-interval.t :23:
    $*SCHEDULER.advance-by(1);


jnthn/p6-concurrent-progress
…/min-interval.t :29:
    $*SCHEDULER.advance-by(1);


jnthn/p6-concurrent-progress
…/min-interval.t :32:
    $*SCHEDULER.advance-by(0.1);


jnthn/p6-concurrent-progress
…/min-interval.t :39:
    $*SCHEDULER.advance-by(0.1);


jnthn/p6-concurrent-progress
…/min-interval.t :41:
    $*SCHEDULER.advance-by(0.2);


jnthn/p6-concurrent-progress
…/min-interval.t :44:
    $*SCHEDULER.advance-by(0.6);


jnthn/p6-concurrent-progress
…/min-interval.t :52:
    my $*SCHEDULER = Test::Scheduler.new;


jnthn/p6-concurrent-progress
…/min-interval.t :57:
    $*SCHEDULER.advance;


jnthn/p6-concurrent-progress
…/min-interval.t :66:
    $*SCHEDULER.advance-by(0.5);


jnthn/p6-concurrent-progress
…/min-interval.t :70:
    $*SCHEDULER.advance-by(0.25);


jnthn/p6-concurrent-progress
…/min-interval.t :74:
    $*SCHEDULER.advance-by(0.25);


jnthn/p6-concurrent-progress
…/min-interval.t :81:
    $*SCHEDULER.advance-by(0.25);


jnthn/p6-concurrent-progress
…/min-interval.t :85:
    $*SCHEDULER.advance-by(0.25);


jnthn/p6-concurrent-progress
…/min-interval.t :93:
    $*SCHEDULER.advance-by(0.5);


jnthn/p6-ssh-libssh
…/LibSSH.pm6 :233:
        method connect(:$scheduler = $*SCHEDULER --> Promise) {


jnthn/p6-ssh-libssh
…/LibSSH.pm6 :851:
        method !std-reader($is-stderr, :$bin, :$enc, :$scheduler = $*SCHEDULER) {


jnthn/p6-test-scheduler
…/README.md :31:
    my $*SCHEDULER = Test::Scheduler.new;


jnthn/p6-test-scheduler
…/README.md :48:
    $*SCHEDULER.advance-by(1);


jnthn/p6-test-scheduler
…/README.md :52:
    $*SCHEDULER.advance-by(1);


jnthn/p6-test-scheduler
…/README.md :56:
    $*SCHEDULER.advance-by(1);


jnthn/p6-test-scheduler
…/README.md :60:
    $*SCHEDULER.advance-by(1);


jnthn/p6-test-scheduler
…/Scheduler.pm6 :3:
my $original-scheduler = INIT $*SCHEDULER;


jnthn/p6-test-scheduler
…/Scheduler.pm6 :53:
                                my $*SCHEDULER = self;


jnthn/p6-test-scheduler
…/Scheduler.pm6 :60:
                                my $*SCHEDULER = self;


jnthn/p6-test-scheduler
…/Scheduler.pm6 :79:
                                my $*SCHEDULER = self;


jnthn/p6-test-scheduler
…/Scheduler.pm6 :84:
                                my $*SCHEDULER = self;


jnthn/p6-test-scheduler
…/Scheduler.pm6 :100:
                    my $*SCHEDULER = self;


jnthn/p6-test-scheduler
…/Scheduler.pm6 :105:
                    my $*SCHEDULER = self;


jnthn/p6-test-scheduler
…/Scheduler.pm6 :119:
            with @*TEST-SCHEDULER-NESTED -> @nested {


jnthn/p6-test-scheduler
…/Scheduler.pm6 :127:
                            my $*SCHEDULER = self;


jnthn/p6-test-scheduler
…/Scheduler.pm6 :134:
                            my $*SCHEDULER = self;


jnthn/p6-test-scheduler
…/Scheduler.pm6 :144:
                            my $*SCHEDULER = self;


jnthn/p6-test-scheduler
…/Scheduler.pm6 :150:
                            my $*SCHEDULER = self;


jnthn/p6-test-scheduler
…/Scheduler.pm6 :208:
                        my @*TEST-SCHEDULER-NESTED = ();


jnthn/p6-test-scheduler
…/Scheduler.pm6 :210:
                        await @*TEST-SCHEDULER-NESTED;


jnthn/p6-test-scheduler
…/not-time-based.t :5:
    my $*SCHEDULER = Test::Scheduler.new();


jnthn/p6-test-scheduler
…/not-time-based.t :8:
    $*SCHEDULER.advance;


jnthn/p6-test-scheduler
…/not-time-based.t :13:
    my $*SCHEDULER = Test::Scheduler.new();


jnthn/p6-test-scheduler
…/not-time-based.t :18:
    $*SCHEDULER.advance;


jnthn/p6-test-scheduler
…/synopsis.t :21:
    my $*SCHEDULER = Test::Scheduler.new;


jnthn/p6-test-scheduler
…/synopsis.t :38:
    $*SCHEDULER.advance-by(1);


jnthn/p6-test-scheduler
…/synopsis.t :42:
    $*SCHEDULER.advance-by(1);


jnthn/p6-test-scheduler
…/synopsis.t :46:
    $*SCHEDULER.advance-by(1);


jnthn/p6-test-scheduler
…/synopsis.t :50:
    $*SCHEDULER.advance-by(1);


jnthn/p6-test-scheduler
…/virtualized-time.t :5:
    my $*SCHEDULER = Test::Scheduler.new;


jnthn/p6-test-scheduler
…/virtualized-time.t :11:
    $*SCHEDULER.advance-by(0.001);


jnthn/p6-test-scheduler
…/virtualized-time.t :17:
    my $*SCHEDULER = Test::Scheduler.new;


jnthn/p6-test-scheduler
…/virtualized-time.t :21:
        $*SCHEDULER.advance-by(20);


jnthn/p6-test-scheduler
…/virtualized-time.t :25:
    $*SCHEDULER.advance-by(20);


jnthn/p6-test-scheduler
…/virtualized-time.t :32:
    my $*SCHEDULER = Test::Scheduler.new;


jnthn/p6-test-scheduler
…/virtualized-time.t :36:
    $*SCHEDULER.advance-by(20);


jnthn/p6-test-scheduler
…/virtualized-time.t :43:
    $*SCHEDULER.advance-by(10);


jnthn/p6-test-scheduler
…/virtualized-time.t :48:
    $*SCHEDULER.advance-by(10);


jnthn/p6-test-scheduler
…/virtualized-time.t :52:
    throws-like { $*SCHEDULER.advance-by(-1) }, X::Test::Scheduler::BackInTime;


jnthn/p6-test-scheduler
…/virtualized-time.t :56:
    $*SCHEDULER.advance();


jnthn/p6-test-scheduler
…/virtualized-time.t :63:
    my $*SCHEDULER = Test::Scheduler.new(virtual-time => $sim-time);


jnthn/p6-test-scheduler
…/virtualized-time.t :64:
    is $*SCHEDULER.virtual-time, $sim-time, 'Can set virtual time in constructor';


jnthn/p6-test-scheduler
…/virtualized-time.t :65:
    $*SCHEDULER.advance-by(10);


jnthn/p6-test-scheduler
…/virtualized-time.t :66:
    is $*SCHEDULER.virtual-time, $sim-time + 10, 'Virtual time advances';


jnthn/p6-test-scheduler
…/virtualized-time.t :70:
    $*SCHEDULER.cue: { $p1.keep(42) }, :at($sim-time + 40);


jnthn/p6-test-scheduler
…/virtualized-time.t :71:
    $*SCHEDULER.cue: { $p2.keep(101) }, :at($sim-time + 30);


jnthn/p6-test-scheduler
…/virtualized-time.t :72:
    $*SCHEDULER.advance-by(20);


jnthn/p6-test-scheduler
…/virtualized-time.t :76:
    $*SCHEDULER.advance-by(10);


jnthn/p6-test-scheduler
…/virtualized-time.t :80:
    $*SCHEDULER.cue: { $p3.keep(22) }, :at($sim-time + 40);


jnthn/p6-test-scheduler
…/virtualized-time.t :81:
    $*SCHEDULER.advance;


jnthn/p6-test-scheduler
…/virtualized-time.t :85:
    $*SCHEDULER.cue: { $p4.keep(69) }, :at($sim-time + 35);


jnthn/p6-test-scheduler
…/virtualized-time.t :86:
    $*SCHEDULER.advance;


jnthn/p6-test-scheduler
…/virtualized-time.t :92:
    my $*SCHEDULER = Test::Scheduler.new;


jnthn/p6-test-scheduler
…/virtualized-time.t :93:
    $*SCHEDULER.cue: { $c.send('x') }, :in(10), :times(3);


jnthn/p6-test-scheduler
…/virtualized-time.t :94:
    $*SCHEDULER.advance-by(1);


jnthn/p6-test-scheduler
…/virtualized-time.t :96:
    $*SCHEDULER.advance-by(4);


jnthn/p6-test-scheduler
…/virtualized-time.t :98:
    $*SCHEDULER.advance-by(5);


jnthn/p6-test-scheduler
…/virtualized-time.t :105:
    my $*SCHEDULER = Test::Scheduler.new;


jnthn/p6-test-scheduler
…/virtualized-time.t :106:
    $*SCHEDULER.cue: { $c.send('x') }, :times(4);


jnthn/p6-test-scheduler
…/virtualized-time.t :107:
    $*SCHEDULER.advance;


jnthn/p6-test-scheduler
…/virtualized-time.t :114:
    my $*SCHEDULER = Test::Scheduler.new(virtual-time => $sim-time);


jnthn/p6-test-scheduler
…/virtualized-time.t :118:
    $*SCHEDULER.advance-to($sim-time + 20);


jnthn/p6-test-scheduler
…/virtualized-time.t :125:
    $*SCHEDULER.advance-to($sim-time + 30);


jnthn/p6-test-scheduler
…/virtualized-time.t :130:
    $*SCHEDULER.advance-to($sim-time + 40);


jnthn/p6-test-scheduler
…/virtualized-time.t :134:
    throws-like { $*SCHEDULER.advance-to($sim-time + 39) },


jnthn/p6-test-scheduler
…/virtualized-time.t :140:
    my $*SCHEDULER = Test::Scheduler.new(virtual-time => $sim-time);


jnthn/p6-test-scheduler
…/virtualized-time.t :141:
    $*SCHEDULER.advance-to($sim-time + 10);


jnthn/p6-test-scheduler
…/virtualized-time.t :142:
    is $*SCHEDULER.virtual-time, $sim-time + 10,


jnthn/p6-test-scheduler
…/virtualized-time.t :147:
    $*SCHEDULER.cue: { $p1.keep(42) }, :at($sim-time + 40);


jnthn/p6-test-scheduler
…/virtualized-time.t :148:
    $*SCHEDULER.cue: { $p2.keep(101) }, :at($sim-time + 30);


jnthn/p6-test-scheduler
…/virtualized-time.t :149:
    $*SCHEDULER.advance-to($sim-time + 30);


jnthn/p6-test-scheduler
…/virtualized-time.t :153:
    $*SCHEDULER.advance-to($sim-time + 40);


jnthn/p6-test-scheduler
…/virtualized-time.t :158:
    $*SCHEDULER.cue: { $p3.keep(22) }, :at($sim-time + 40);


jnthn/p6-test-scheduler
…/virtualized-time.t :159:
    $*SCHEDULER.advance;


jnthn/p6-test-scheduler
…/virtualized-time.t :164:
    $*SCHEDULER.cue: { $p4.keep(69) }, :at($sim-time + 35);


jnthn/p6-test-scheduler
…/virtualized-time.t :165:
    $*SCHEDULER.advance;


jnthn/p6-test-scheduler
…/virtualized-time.t :171:
    my $*SCHEDULER = Test::Scheduler.new;


jnthn/p6-test-scheduler
…/virtualized-time.t :175:
    $*SCHEDULER.advance;


jnthn/p6-test-scheduler
…/virtualized-time.t :180:
    $*SCHEDULER.advance-by(10);


jnthn/p6-test-scheduler
…/virtualized-time.t :184:
    $*SCHEDULER.advance-by(20);


jnthn/p6-test-scheduler
…/virtualized-time.t :192:
    my $*SCHEDULER = Test::Scheduler.new();


jnthn/p6-test-scheduler
…/virtualized-time.t :194:
    my $canc = $*SCHEDULER.cue: { $p.keep(42) }, :in(20);


jnthn/p6-test-scheduler
…/virtualized-time.t :196:
    $*SCHEDULER.advance-by(20);


jnthn/p6-test-scheduler
…/virtualized-time.t :203:
    my $*SCHEDULER = Test::Scheduler.new;


jnthn/p6-test-scheduler
…/virtualized-time.t :205:
    my $canc = $*SCHEDULER.cue: { state $i = 0; $c.send($i++) }, :every(10);


jnthn/p6-test-scheduler
…/virtualized-time.t :206:
    $*SCHEDULER.advance;


jnthn/p6-test-scheduler
…/virtualized-time.t :210:
    $*SCHEDULER.advance-by(10);


jnthn/p6-test-scheduler
…/virtualized-time.t :215:
    $*SCHEDULER.advance-by(10);


jnthn/p6-test-scheduler
…/virtualized-time.t :217:
    $*SCHEDULER.advance-by(10);


jnthn/p6-test-scheduler
…/virtualized-time.t :224:
    my $*SCHEDULER = Test::Scheduler.new;


jnthn/p6-test-scheduler
…/virtualized-time.t :227:
    my $canc = $*SCHEDULER.cue: { state $i = 0; $c.send($i++) },


jnthn/p6-test-scheduler
…/virtualized-time.t :230:
    $*SCHEDULER.advance;


jnthn/p6-test-scheduler
…/virtualized-time.t :234:
    $*SCHEDULER.advance-by(10);


jnthn/p6-test-scheduler
…/virtualized-time.t :239:
    $*SCHEDULER.advance-by(10);


jnthn/p6-test-scheduler
…/virtualized-time.t :241:
    $*SCHEDULER.advance-by(10);


jnthn/p6-test-scheduler
…/virtualized-time.t :248:
    my $*SCHEDULER = Test::Scheduler.new;


jnthn/p6-test-scheduler
…/virtualized-time.t :250:
    $*SCHEDULER.cue: { state $i = 0; $c.send($i++) }, :every(10), :times(3);


jnthn/p6-test-scheduler
…/virtualized-time.t :251:
    $*SCHEDULER.advance;


jnthn/p6-test-scheduler
…/virtualized-time.t :255:
    $*SCHEDULER.advance-by(10);


jnthn/p6-test-scheduler
…/virtualized-time.t :259:
    $*SCHEDULER.advance-by(10);


jnthn/p6-test-scheduler
…/virtualized-time.t :263:
    $*SCHEDULER.advance-by(10);


jnthn/p6-test-scheduler
…/virtualized-time.t :265:
    $*SCHEDULER.advance-by(10);


jnthn/p6-test-scheduler
…/virtualized-time.t :272:
    my $*SCHEDULER = Test::Scheduler.new;


jnthn/p6-test-scheduler
…/virtualized-time.t :277:
    $*SCHEDULER.advance-by(20);


jnthn/p6-test-scheduler
…/virtualized-time.t :282:
    my $*SCHEDULER = Test::Scheduler.new;


jnthn/p6-test-scheduler
…/virtualized-time.t :287:
    $*SCHEDULER.advance-by(4);


perl6/doc
…/concurrency.pod6 :708:
C<$*SCHEDULER>.


perl6/doc
…/concurrency.pod6 :720:
     my $cancellation = $*SCHEDULER.cue({ say $i++}, every => 2 );


perl6/doc
…/concurrency.pod6 :723:
Assuming that the C<$*SCHEDULER> hasn't been changed from the default,


perl6/doc
…/concurrency.pod6 :731:
     my $cancellation = $*SCHEDULER.cue({ say $i++}, every => 2 );


perl6/doc
…/variables.pod6 :1498:
X<|$*SCHEDULER>


perl6/doc
…/variables.pod6 :1499:
=head4 C<$*SCHEDULER>


perl6/doc
…/variables.pod6 :1511:
    my $*SCHEDULER = ThreadPoolScheduler.new( max_threads => 128 );


perl6/doc
…/Notification.pod6 :47:
method watch-path(IO::Notification: Str() $path, :$scheduler = $*SCHEDULER)


perl6/doc
…/Async.pod6 :261:
    method start(Proc::Async:D: :$scheduler = $*SCHEDULER, :$ENV, :$cwd = $*CWD)


perl6/doc
…/Async.pod6 :266:
scheduler instead of the default C<$*SCHEDULER>, or change the environment the


perl6/doc
…/Async.pod6 :350:
    method write(Proc::Async:D: Blob:D $b, :$scheduler = $*SCHEDULER --> Promise:D)


perl6/doc
…/Async.pod6 :367:
    method print(Proc::Async:D: Str(Any) $str, :$scheduler = $*SCHEDULER)


perl6/doc
…/Async.pod6 :384:
    method say(Proc::Async:D: $output, :$scheduler = $*SCHEDULER)


perl6/doc
…/Promise.pod6 :56:
    method start(Promise:U: &code, :$scheduler = $*SCHEDULER --> Promise:D)


perl6/doc
…/Promise.pod6 :112:
    method in(Promise:U: $seconds, :$scheduler = $*SCHEDULER --> Promise:D)


perl6/doc
…/Promise.pod6 :137:
    method at(Promise:U: $at, :$scheduler = $*SCHEDULER --> Promise:D)


perl6/doc
…/Supply.pod6 :292:
    method interval(Supply:U: $interval, $delay = 0, :$scheduler = $*SCHEDULER --> Supply:D)


perl6/doc
…/Supply.pod6 :372:
    method delayed(Supply:D: $seconds, :$scheduler = $*SCHEDULER --> Supply:D)


perl6/doc
…/Supply.pod6 :388:
  :$scheduler,            # scheduler to use, default $*SCHEDULER


perl6/doc
…/Supply.pod6 :434:
to C<$*SCHEDULER>.


perl6/doc
…/Supply.pod6 :528:
    method stable(Supply:D: $time, :$scheduler = $*SCHEDULER --> Supply:D)


perl6/doc
…/Supply.pod6 :765:
    sub signal(*@signals, :$scheduler = $*SCHEDULER)


perl6/perl6-pod-to-bigpage
…/pod2onepage :33:
    PROCESS::<$SCHEDULER> = ThreadPoolScheduler.new(initial_threads => 0, max_threads => $threads);


whity/perl6-hematite
…/Context.pm6 :326:
    my $scheduler = $*SCHEDULER.cue(


zostay/HTTP-Supply
…/Test.pm6 :43:
            # note "CURRENT LOADS PRE-CHUNKING = ", $*SCHEDULER.loads;
File	Code
FRITH/Hash-Timeout `…/Timeout.pm6` :21:	`%!cancel{key} := $*SCHEDULER.cue({ %!hash{key}:delete }, :in($timeout));`
FRITH/Hash-Timeout `…/Timeout.pm6` :26:	`%!cancel{key} := $*SCHEDULER.cue({ %!hash{key}:delete }, :in($timeout));`
HANENKAMP/HTTP-Request-Supply `…/Test.pm6` :43:	`# note "CURRENT LOADS PRE-CHUNKING = ", $*SCHEDULER.loads;`
HANENKAMP/HTTP-Supply `…/Test.pm6` :43:	`# note "CURRENT LOADS PRE-CHUNKING = ", $*SCHEDULER.loads;`
JNTHN/Cro-HTTP `…/http-request-parser.t` :30:	`$testee.transformer($fake-in.Supply).schedule-on($*SCHEDULER).tap:`
JNTHN/Cro-HTTP `…/http-response-parser.t` :27:	`$testee.transformer($fake-in.Supply).schedule-on($*SCHEDULER).tap:`
JNTHN/Cro-HTTP `…/http2-frame-parser.t` :21:	`$parser.transformer($fake-in.Supply, :$connection-state).schedule-on($*SCHEDULER).tap: -> $frame {},`
JNTHN/Cro-HTTP `…/http2-frame-parser.t` :66:	`$parser.transformer($fake-in-p.Supply, :$connection-state).schedule-on($*SCHEDULER).tap: -> $frame {`
JNTHN/Cro-HTTP `…/http2-frame-parser.t` :68:	`$serializer.transformer($fake-in-s.Supply, :$connection-state).schedule-on($*SCHEDULER).tap: -> $message {`
JNTHN/Cro-HTTP `…/http2-frame-serializer.t` :29:	`$serializer.transformer($fake-in-s.Supply, :$connection-state).schedule-on($*SCHEDULER).tap: -> $message {`
JNTHN/Cro-HTTP `…/http2-frame-serializer.t` :33:	`$parser.transformer($fake-in-p.Supply, :$connection-state).schedule-on($*SCHEDULER).tap: -> $newframe {`
JNTHN/Cro-WebSocket `…/websocket-frame-parser.t` :17:	`$parser.transformer($fake-in.Supply).schedule-on($*SCHEDULER).tap: -> $frame {`
JNTHN/Cro-WebSocket `…/websocket-frame-serializer.t` :20:	`$serializer.transformer($fake-in-s.Supply).schedule-on($*SCHEDULER).tap: -> $message {`
JNTHN/Cro-WebSocket `…/websocket-frame-serializer.t` :21:	`$parser.transformer($fake-in-p.Supply).schedule-on($*SCHEDULER).tap: -> $newframe {`
JNTHN/Cro-WebSocket `…/websocket-message-parser.t` :8:	`$parser.transformer($fake-in.Supply).schedule-on($*SCHEDULER).tap: -> $message {`
JNTHN/IO-Socket-Async-SSL `…/README.md` :127:	the underlying `IO::Socket::Async` instance. The default is `$*SCHEDULER`.
JNTHN/IO-Socket-Async-SSL `…/SSL.pm6` :260:	`:$enc = 'utf8', :$scheduler = $*SCHEDULER,`
JNTHN/IO-Socket-Async-SSL `…/SSL.pm6` :342:	`:$enc = 'utf8', :$scheduler = $*SCHEDULER,`
JNTHN/IO-Socket-Async-SSL `…/SSL.pm6` :793:	`method Supply(:$bin, :$enc = $!enc, :$scheduler = $*SCHEDULER) {`
JNTHN/IO-Socket-Async-SSL `…/SSL.pm6` :810:	`method print(IO::Socket::Async::SSL:D: Str() $str, :$scheduler = $*SCHEDULER) {`
JNTHN/IO-Socket-Async-SSL `…/SSL.pm6` :814:	`method write(IO::Socket::Async::SSL:D: Blob $b, :$scheduler = $*SCHEDULER) {`
JNTHN/cro `…/Services.pm6` :108:	`whenever tap-on(self!scan(), $*SCHEDULER) {`
JSTOWE/Manifesto `…/030-failures.t` :8:	`my $*SCHEDULER = ThreadPoolScheduler.new(max_threads => 1);`
MARTIMM/BSON `…/EDC.pm6` :136:	`$*SCHEDULER.cue( {`
FCO/test-time `…/README.md` :10:	`$*SCHEDULER = mock-time :auto-advance;`
FCO/test-time `…/README.md` :25:	Or you can use `$SCHEDULER.advance-by: 10` as you would when using Test::Scheduler*
FCO/test-time `…/Time.pm6` :9:	`$*SCHEDULER = mock-time :auto-advance;`
FCO/test-time `…/Time.pm6` :24:	`Or you can use C<$*SCHEDULER.advance-by: 10> as you would when using B<Test::Scheduler>`
FCO/test-time `…/Time.pm6` :35:	`my $*SCHEDULER = Test::Scheduler.new: :virtual-time($now);`
FCO/test-time `…/Time.pm6` :43:	`%wraps<now> = &term:<now>.wrap: { $*SCHEDULER.virtual-time }`
FCO/test-time `…/Time.pm6` :56:	`$*SCHEDULER.advance-by: $interval`
FCO/test-time `…/Time.pm6` :60:	`$*SCHEDULER`
FCO/test-time `…/01-tdd.t` :7:	`my $*SCHEDULER;`
FCO/test-time `…/01-tdd.t` :17:	`$*SCHEDULER = mock-time $tai;`
FCO/test-time `…/01-tdd.t` :28:	`$*SCHEDULER = mock-time;`
FCO/test-time `…/01-tdd.t` :47:	`$*SCHEDULER.advance-by: 10;`
FCO/test-time `…/01-tdd.t` :48:	`$*SCHEDULER.advance-by: 20;`
FCO/test-time `…/01-tdd.t` :49:	`$*SCHEDULER.advance-by: 20;`
FCO/test-time `…/01-tdd.t` :54:	`$*SCHEDULER = mock-time :auto-advance;`
FCO/test-time `…/01-tdd.t` :74:	`$*SCHEDULER = mock-time;`
FCO/test-time `…/01-tdd.t` :86:	`$*SCHEDULER.advance-by: 50;`
MARTIMM/BSON `…/EDC.pm6` :136:	`$*SCHEDULER.cue( {`
finanalyst/pod-cached `…/Cached.pm6` :141:	`PROCESS::<$SCHEDULER> = ThreadPoolScheduler.new(initial_threads => 0, max_threads => MAX-COMPILATIONS);`
jnthn/p6-concurrent-progress `…/min-interval.t` :6:	`my $*SCHEDULER = Test::Scheduler.new;`
jnthn/p6-concurrent-progress `…/min-interval.t` :11:	`$*SCHEDULER.advance;`
jnthn/p6-concurrent-progress `…/min-interval.t` :19:	`$*SCHEDULER.advance-by(0.5);`
jnthn/p6-concurrent-progress `…/min-interval.t` :23:	`$*SCHEDULER.advance-by(1);`
jnthn/p6-concurrent-progress `…/min-interval.t` :29:	`$*SCHEDULER.advance-by(1);`
jnthn/p6-concurrent-progress `…/min-interval.t` :32:	`$*SCHEDULER.advance-by(0.1);`
jnthn/p6-concurrent-progress `…/min-interval.t` :39:	`$*SCHEDULER.advance-by(0.1);`
jnthn/p6-concurrent-progress `…/min-interval.t` :41:	`$*SCHEDULER.advance-by(0.2);`
jnthn/p6-concurrent-progress `…/min-interval.t` :44:	`$*SCHEDULER.advance-by(0.6);`
jnthn/p6-concurrent-progress `…/min-interval.t` :52:	`my $*SCHEDULER = Test::Scheduler.new;`
jnthn/p6-concurrent-progress `…/min-interval.t` :57:	`$*SCHEDULER.advance;`
jnthn/p6-concurrent-progress `…/min-interval.t` :66:	`$*SCHEDULER.advance-by(0.5);`
jnthn/p6-concurrent-progress `…/min-interval.t` :70:	`$*SCHEDULER.advance-by(0.25);`
jnthn/p6-concurrent-progress `…/min-interval.t` :74:	`$*SCHEDULER.advance-by(0.25);`
jnthn/p6-concurrent-progress `…/min-interval.t` :81:	`$*SCHEDULER.advance-by(0.25);`
jnthn/p6-concurrent-progress `…/min-interval.t` :85:	`$*SCHEDULER.advance-by(0.25);`
jnthn/p6-concurrent-progress `…/min-interval.t` :93:	`$*SCHEDULER.advance-by(0.5);`
jnthn/p6-ssh-libssh `…/LibSSH.pm6` :233:	`method connect(:$scheduler = $*SCHEDULER --> Promise) {`
jnthn/p6-ssh-libssh `…/LibSSH.pm6` :851:	`method !std-reader($is-stderr, :$bin, :$enc, :$scheduler = $*SCHEDULER) {`
jnthn/p6-test-scheduler `…/README.md` :31:	`my $*SCHEDULER = Test::Scheduler.new;`
jnthn/p6-test-scheduler `…/README.md` :48:	`$*SCHEDULER.advance-by(1);`
jnthn/p6-test-scheduler `…/README.md` :52:	`$*SCHEDULER.advance-by(1);`
jnthn/p6-test-scheduler `…/README.md` :56:	`$*SCHEDULER.advance-by(1);`
jnthn/p6-test-scheduler `…/README.md` :60:	`$*SCHEDULER.advance-by(1);`
jnthn/p6-test-scheduler `…/Scheduler.pm6` :3:	`my $original-scheduler = INIT $*SCHEDULER;`
jnthn/p6-test-scheduler `…/Scheduler.pm6` :53:	`my $*SCHEDULER = self;`
jnthn/p6-test-scheduler `…/Scheduler.pm6` :60:	`my $*SCHEDULER = self;`
jnthn/p6-test-scheduler `…/Scheduler.pm6` :79:	`my $*SCHEDULER = self;`
jnthn/p6-test-scheduler `…/Scheduler.pm6` :84:	`my $*SCHEDULER = self;`
jnthn/p6-test-scheduler `…/Scheduler.pm6` :100:	`my $*SCHEDULER = self;`
jnthn/p6-test-scheduler `…/Scheduler.pm6` :105:	`my $*SCHEDULER = self;`
jnthn/p6-test-scheduler `…/Scheduler.pm6` :119:	`with @*TEST-SCHEDULER-NESTED -> @nested {`
jnthn/p6-test-scheduler `…/Scheduler.pm6` :127:	`my $*SCHEDULER = self;`
jnthn/p6-test-scheduler `…/Scheduler.pm6` :134:	`my $*SCHEDULER = self;`
jnthn/p6-test-scheduler `…/Scheduler.pm6` :144:	`my $*SCHEDULER = self;`
jnthn/p6-test-scheduler `…/Scheduler.pm6` :150:	`my $*SCHEDULER = self;`
jnthn/p6-test-scheduler `…/Scheduler.pm6` :208:	`my @*TEST-SCHEDULER-NESTED = ();`
jnthn/p6-test-scheduler `…/Scheduler.pm6` :210:	`await @*TEST-SCHEDULER-NESTED;`
jnthn/p6-test-scheduler `…/not-time-based.t` :5:	`my $*SCHEDULER = Test::Scheduler.new();`
jnthn/p6-test-scheduler `…/not-time-based.t` :8:	`$*SCHEDULER.advance;`
jnthn/p6-test-scheduler `…/not-time-based.t` :13:	`my $*SCHEDULER = Test::Scheduler.new();`
jnthn/p6-test-scheduler `…/not-time-based.t` :18:	`$*SCHEDULER.advance;`
jnthn/p6-test-scheduler `…/synopsis.t` :21:	`my $*SCHEDULER = Test::Scheduler.new;`
jnthn/p6-test-scheduler `…/synopsis.t` :38:	`$*SCHEDULER.advance-by(1);`
jnthn/p6-test-scheduler `…/synopsis.t` :42:	`$*SCHEDULER.advance-by(1);`
jnthn/p6-test-scheduler `…/synopsis.t` :46:	`$*SCHEDULER.advance-by(1);`
jnthn/p6-test-scheduler `…/synopsis.t` :50:	`$*SCHEDULER.advance-by(1);`
jnthn/p6-test-scheduler `…/virtualized-time.t` :5:	`my $*SCHEDULER = Test::Scheduler.new;`
jnthn/p6-test-scheduler `…/virtualized-time.t` :11:	`$*SCHEDULER.advance-by(0.001);`
jnthn/p6-test-scheduler `…/virtualized-time.t` :17:	`my $*SCHEDULER = Test::Scheduler.new;`
jnthn/p6-test-scheduler `…/virtualized-time.t` :21:	`$*SCHEDULER.advance-by(20);`
jnthn/p6-test-scheduler `…/virtualized-time.t` :25:	`$*SCHEDULER.advance-by(20);`
jnthn/p6-test-scheduler `…/virtualized-time.t` :32:	`my $*SCHEDULER = Test::Scheduler.new;`
jnthn/p6-test-scheduler `…/virtualized-time.t` :36:	`$*SCHEDULER.advance-by(20);`
jnthn/p6-test-scheduler `…/virtualized-time.t` :43:	`$*SCHEDULER.advance-by(10);`
jnthn/p6-test-scheduler `…/virtualized-time.t` :48:	`$*SCHEDULER.advance-by(10);`
jnthn/p6-test-scheduler `…/virtualized-time.t` :52:	`throws-like { $*SCHEDULER.advance-by(-1) }, X::Test::Scheduler::BackInTime;`
jnthn/p6-test-scheduler `…/virtualized-time.t` :56:	`$*SCHEDULER.advance();`
jnthn/p6-test-scheduler `…/virtualized-time.t` :63:	`my $*SCHEDULER = Test::Scheduler.new(virtual-time => $sim-time);`
jnthn/p6-test-scheduler `…/virtualized-time.t` :64:	`is $*SCHEDULER.virtual-time, $sim-time, 'Can set virtual time in constructor';`
jnthn/p6-test-scheduler `…/virtualized-time.t` :65:	`$*SCHEDULER.advance-by(10);`
jnthn/p6-test-scheduler `…/virtualized-time.t` :66:	`is $*SCHEDULER.virtual-time, $sim-time + 10, 'Virtual time advances';`
jnthn/p6-test-scheduler `…/virtualized-time.t` :70:	`$*SCHEDULER.cue: { $p1.keep(42) }, :at($sim-time + 40);`
jnthn/p6-test-scheduler `…/virtualized-time.t` :71:	`$*SCHEDULER.cue: { $p2.keep(101) }, :at($sim-time + 30);`
jnthn/p6-test-scheduler `…/virtualized-time.t` :72:	`$*SCHEDULER.advance-by(20);`
jnthn/p6-test-scheduler `…/virtualized-time.t` :76:	`$*SCHEDULER.advance-by(10);`
jnthn/p6-test-scheduler `…/virtualized-time.t` :80:	`$*SCHEDULER.cue: { $p3.keep(22) }, :at($sim-time + 40);`
jnthn/p6-test-scheduler `…/virtualized-time.t` :81:	`$*SCHEDULER.advance;`
jnthn/p6-test-scheduler `…/virtualized-time.t` :85:	`$*SCHEDULER.cue: { $p4.keep(69) }, :at($sim-time + 35);`
jnthn/p6-test-scheduler `…/virtualized-time.t` :86:	`$*SCHEDULER.advance;`
jnthn/p6-test-scheduler `…/virtualized-time.t` :92:	`my $*SCHEDULER = Test::Scheduler.new;`
jnthn/p6-test-scheduler `…/virtualized-time.t` :93:	`$*SCHEDULER.cue: { $c.send('x') }, :in(10), :times(3);`
jnthn/p6-test-scheduler `…/virtualized-time.t` :94:	`$*SCHEDULER.advance-by(1);`
jnthn/p6-test-scheduler `…/virtualized-time.t` :96:	`$*SCHEDULER.advance-by(4);`
jnthn/p6-test-scheduler `…/virtualized-time.t` :98:	`$*SCHEDULER.advance-by(5);`
jnthn/p6-test-scheduler `…/virtualized-time.t` :105:	`my $*SCHEDULER = Test::Scheduler.new;`
jnthn/p6-test-scheduler `…/virtualized-time.t` :106:	`$*SCHEDULER.cue: { $c.send('x') }, :times(4);`
jnthn/p6-test-scheduler `…/virtualized-time.t` :107:	`$*SCHEDULER.advance;`
jnthn/p6-test-scheduler `…/virtualized-time.t` :114:	`my $*SCHEDULER = Test::Scheduler.new(virtual-time => $sim-time);`
jnthn/p6-test-scheduler `…/virtualized-time.t` :118:	`$*SCHEDULER.advance-to($sim-time + 20);`
jnthn/p6-test-scheduler `…/virtualized-time.t` :125:	`$*SCHEDULER.advance-to($sim-time + 30);`
jnthn/p6-test-scheduler `…/virtualized-time.t` :130:	`$*SCHEDULER.advance-to($sim-time + 40);`
jnthn/p6-test-scheduler `…/virtualized-time.t` :134:	`throws-like { $*SCHEDULER.advance-to($sim-time + 39) },`
jnthn/p6-test-scheduler `…/virtualized-time.t` :140:	`my $*SCHEDULER = Test::Scheduler.new(virtual-time => $sim-time);`
jnthn/p6-test-scheduler `…/virtualized-time.t` :141:	`$*SCHEDULER.advance-to($sim-time + 10);`
jnthn/p6-test-scheduler `…/virtualized-time.t` :142:	`is $*SCHEDULER.virtual-time, $sim-time + 10,`
jnthn/p6-test-scheduler `…/virtualized-time.t` :147:	`$*SCHEDULER.cue: { $p1.keep(42) }, :at($sim-time + 40);`
jnthn/p6-test-scheduler `…/virtualized-time.t` :148:	`$*SCHEDULER.cue: { $p2.keep(101) }, :at($sim-time + 30);`
jnthn/p6-test-scheduler `…/virtualized-time.t` :149:	`$*SCHEDULER.advance-to($sim-time + 30);`
jnthn/p6-test-scheduler `…/virtualized-time.t` :153:	`$*SCHEDULER.advance-to($sim-time + 40);`
jnthn/p6-test-scheduler `…/virtualized-time.t` :158:	`$*SCHEDULER.cue: { $p3.keep(22) }, :at($sim-time + 40);`
jnthn/p6-test-scheduler `…/virtualized-time.t` :159:	`$*SCHEDULER.advance;`
jnthn/p6-test-scheduler `…/virtualized-time.t` :164:	`$*SCHEDULER.cue: { $p4.keep(69) }, :at($sim-time + 35);`
jnthn/p6-test-scheduler `…/virtualized-time.t` :165:	`$*SCHEDULER.advance;`
jnthn/p6-test-scheduler `…/virtualized-time.t` :171:	`my $*SCHEDULER = Test::Scheduler.new;`
jnthn/p6-test-scheduler `…/virtualized-time.t` :175:	`$*SCHEDULER.advance;`
jnthn/p6-test-scheduler `…/virtualized-time.t` :180:	`$*SCHEDULER.advance-by(10);`
jnthn/p6-test-scheduler `…/virtualized-time.t` :184:	`$*SCHEDULER.advance-by(20);`
jnthn/p6-test-scheduler `…/virtualized-time.t` :192:	`my $*SCHEDULER = Test::Scheduler.new();`
jnthn/p6-test-scheduler `…/virtualized-time.t` :194:	`my $canc = $*SCHEDULER.cue: { $p.keep(42) }, :in(20);`
jnthn/p6-test-scheduler `…/virtualized-time.t` :196:	`$*SCHEDULER.advance-by(20);`
jnthn/p6-test-scheduler `…/virtualized-time.t` :203:	`my $*SCHEDULER = Test::Scheduler.new;`
jnthn/p6-test-scheduler `…/virtualized-time.t` :205:	`my $canc = $*SCHEDULER.cue: { state $i = 0; $c.send($i++) }, :every(10);`
jnthn/p6-test-scheduler `…/virtualized-time.t` :206:	`$*SCHEDULER.advance;`
jnthn/p6-test-scheduler `…/virtualized-time.t` :210:	`$*SCHEDULER.advance-by(10);`
jnthn/p6-test-scheduler `…/virtualized-time.t` :215:	`$*SCHEDULER.advance-by(10);`
jnthn/p6-test-scheduler `…/virtualized-time.t` :217:	`$*SCHEDULER.advance-by(10);`
jnthn/p6-test-scheduler `…/virtualized-time.t` :224:	`my $*SCHEDULER = Test::Scheduler.new;`
jnthn/p6-test-scheduler `…/virtualized-time.t` :227:	`my $canc = $*SCHEDULER.cue: { state $i = 0; $c.send($i++) },`
jnthn/p6-test-scheduler `…/virtualized-time.t` :230:	`$*SCHEDULER.advance;`
jnthn/p6-test-scheduler `…/virtualized-time.t` :234:	`$*SCHEDULER.advance-by(10);`
jnthn/p6-test-scheduler `…/virtualized-time.t` :239:	`$*SCHEDULER.advance-by(10);`
jnthn/p6-test-scheduler `…/virtualized-time.t` :241:	`$*SCHEDULER.advance-by(10);`
jnthn/p6-test-scheduler `…/virtualized-time.t` :248:	`my $*SCHEDULER = Test::Scheduler.new;`
jnthn/p6-test-scheduler `…/virtualized-time.t` :250:	`$*SCHEDULER.cue: { state $i = 0; $c.send($i++) }, :every(10), :times(3);`
jnthn/p6-test-scheduler `…/virtualized-time.t` :251:	`$*SCHEDULER.advance;`
jnthn/p6-test-scheduler `…/virtualized-time.t` :255:	`$*SCHEDULER.advance-by(10);`
jnthn/p6-test-scheduler `…/virtualized-time.t` :259:	`$*SCHEDULER.advance-by(10);`
jnthn/p6-test-scheduler `…/virtualized-time.t` :263:	`$*SCHEDULER.advance-by(10);`
jnthn/p6-test-scheduler `…/virtualized-time.t` :265:	`$*SCHEDULER.advance-by(10);`
jnthn/p6-test-scheduler `…/virtualized-time.t` :272:	`my $*SCHEDULER = Test::Scheduler.new;`
jnthn/p6-test-scheduler `…/virtualized-time.t` :277:	`$*SCHEDULER.advance-by(20);`
jnthn/p6-test-scheduler `…/virtualized-time.t` :282:	`my $*SCHEDULER = Test::Scheduler.new;`
jnthn/p6-test-scheduler `…/virtualized-time.t` :287:	`$*SCHEDULER.advance-by(4);`
perl6/doc `…/concurrency.pod6` :708:	`C<$*SCHEDULER>.`
perl6/doc `…/concurrency.pod6` :720:	`my $cancellation = $*SCHEDULER.cue({ say $i++}, every => 2 );`
perl6/doc `…/concurrency.pod6` :723:	`Assuming that the C<$*SCHEDULER> hasn't been changed from the default,`
perl6/doc `…/concurrency.pod6` :731:	`my $cancellation = $*SCHEDULER.cue({ say $i++}, every => 2 );`
perl6/doc `…/variables.pod6` :1498:	`X<\|$*SCHEDULER>`
perl6/doc `…/variables.pod6` :1499:	`=head4 C<$*SCHEDULER>`
perl6/doc `…/variables.pod6` :1511:	`my $*SCHEDULER = ThreadPoolScheduler.new( max_threads => 128 );`
perl6/doc `…/Notification.pod6` :47:	`method watch-path(IO::Notification: Str() $path, :$scheduler = $*SCHEDULER)`
perl6/doc `…/Async.pod6` :261:	`method start(Proc::Async:D: :$scheduler = $SCHEDULER, :$ENV, :$cwd = $CWD)`
perl6/doc `…/Async.pod6` :266:	`scheduler instead of the default C<$*SCHEDULER>, or change the environment the`
perl6/doc `…/Async.pod6` :350:	`method write(Proc::Async:D: Blob:D $b, :$scheduler = $*SCHEDULER --> Promise:D)`
perl6/doc `…/Async.pod6` :367:	`method print(Proc::Async:D: Str(Any) $str, :$scheduler = $*SCHEDULER)`
perl6/doc `…/Async.pod6` :384:	`method say(Proc::Async:D: $output, :$scheduler = $*SCHEDULER)`
perl6/doc `…/Promise.pod6` :56:	`method start(Promise:U: &code, :$scheduler = $*SCHEDULER --> Promise:D)`
perl6/doc `…/Promise.pod6` :112:	`method in(Promise:U: $seconds, :$scheduler = $*SCHEDULER --> Promise:D)`
perl6/doc `…/Promise.pod6` :137:	`method at(Promise:U: $at, :$scheduler = $*SCHEDULER --> Promise:D)`
perl6/doc `…/Supply.pod6` :292:	`method interval(Supply:U: $interval, $delay = 0, :$scheduler = $*SCHEDULER --> Supply:D)`
perl6/doc `…/Supply.pod6` :372:	`method delayed(Supply:D: $seconds, :$scheduler = $*SCHEDULER --> Supply:D)`
perl6/doc `…/Supply.pod6` :388:	`:$scheduler, # scheduler to use, default $*SCHEDULER`
perl6/doc `…/Supply.pod6` :434:	`to C<$*SCHEDULER>.`
perl6/doc `…/Supply.pod6` :528:	`method stable(Supply:D: $time, :$scheduler = $*SCHEDULER --> Supply:D)`
perl6/doc `…/Supply.pod6` :765:	`sub signal(@signals, :$scheduler = $SCHEDULER)`
perl6/perl6-pod-to-bigpage `…/pod2onepage` :33:	`PROCESS::<$SCHEDULER> = ThreadPoolScheduler.new(initial_threads => 0, max_threads => $threads);`
whity/perl6-hematite `…/Context.pm6` :326:	`my $scheduler = $*SCHEDULER.cue(`
zostay/HTTP-Supply `…/Test.pm6` :43:	`# note "CURRENT LOADS PRE-CHUNKING = ", $*SCHEDULER.loads;`