quotable6

query

/^ ‘bisect: ’ /

result

bisect: m: my @f = <1 2 3 4>; dd @f.map(-> \x --> Str { x.Str })
bisect: old=2016.10 new=HEAD m: dd (($++ ?? 42 !! |()) xx *)[^3]
bisect: callframe(1).annotations<line>
bisect: old=2016.07 say ^∞ .grep: { last }
bisect: old=2016.11 say (^∞ .grep: { last })[^5]
bisect: (<2/1> + <2/1>).ceiling.say
bisect: (<1/2> + <3/2>).ceiling.say
bisect: m: say slip().defined
bisect: HEAD $++ for '/home/bisectable/.bash_history'.IO.lines.batch(30)
bisect: $++ for '/home/bisectable/.bash_history'.IO.lines.batch(30)
bisect: old=2016.10 $++ for '/home/bisectable/.bash_history'.IO.lines.batch(30)
bisect: old=2016.12 new=HEAD $++ for '/home/bisectable/.bash_history'.IO.lines.batch(30)
bisect: old=2016.12 new=HEAD $++ for '/home/bisectable/.bash_history'.IO.lines.rotor(30, :partial)
bisect: 1 <= *.chars <= 4
bisect: (1,2,3).Array[0]++
bisect: use lib </home/bisectable/test>; use B; use A
bisect: for dir(‘foo’) { .slurp.say }
bisect: for dir(‘foo’) { .slurp.say }; exit 0
bisect: use nqp; my int $a = 2; if nqp::isint($a) { say($a) }
bisect: 'hello' [&say] 'world'
bisect: multi infix:<-> (Str $, Str $) { say "hi" }; say "start"; quietly "x" - "x"
bisect: multi infix:<-> (Str $, Str $) { say "hi" }; say "start"; "x" - "x"
bisect: say (1,2).map({ LAST { say "DONE" } })[2]
bisect: old=2015.11 class MyInt is Any is Int { }
bisect: say 255.base(16, -100)
bisect: old=2015.07 say 255.base(16, -100)
bisect: class C { our method m {}; method n { $.m } }; say C.new.n
bisect: old=2016.03 say ^1000 .grep: -> $n {([+] ^$n .grep: -> $m {$m and $n %% $m}) == $n }
bisect: new=2016.03 say ^1000 .grep: -> $n {([+] ^$n .grep: -> $m {$m and $n %% $m}) == $n }
bisect: {class Test::Builder::Test { };}; {role Test::Builder::Plan::Generic { }; class Test::Builder::Plan does Test::Builder::Plan::Generic { };}; {class Test::Builder { has Test::Builder::Plan::Generic $!plan; };};
bisect: *...‘WAT’
bisect: %*ENV<RAKUDO_BACKTRACE_SETTING> = 1; say 1/0
bisect: %*ENV<RAKUDO_VERBOSE_STACKFRAME> = 2; say 1/0
bisect: for 42 { say "foo".match(/foo/); say $/ }
bisect: constant $R = /f(oo)/; say so "foo" ~~ $R; say ~$0  # RT #126969
bisect: good=fc47bbf bad=631e2f770e constant $R = /f(oo)/; say so "foo" ~~ $R; say ~$0  # RT #126969
bisect: good=631e2f770e bad=fc47bbf constant $R = /f(oo)/; say so "foo" ~~ $R; say ~$0  # RT #126969
bisect: say 1**NaN
bisect: sub foo (*@what) { @what[*-1] ~= 42; dd @what }; foo 'foo', 'bar', 'ber'
bisect: 2016.04 use Test; "ac" ~~ /(.)(.)?(.)/;  is-deeply $/.perl.EVAL, $/
bisect: use Test; "ac" ~~ /(.)(.)?(.)/;  is-deeply $/.perl.EVAL, $/
bisect: sub aa (Int @a) { say "hi"; }; my @a of Int; aa(@a)
bisect: bad=2015.12.25,good=HEAD sub aa (Int @a) { say "hi"; }; my @a of Int; aa(@a)
bisect: bad=2015.12,good=HEAD sub aa (Int @a) { say "hi"; }; my @a of Int; aa(@a)
bisect: bad=2016.01,good=HEAD sub aa (Int @a) { say "hi"; }; my @a of Int; aa(@a)
bisect: good=2015.12 bad=2016.08.1 sub aa (Int @a) { say "hi"; }; my @a of Int; aa(@a)
bisect: good 2016.07 Scalar.new
bisect: good 2016.07 bad HEAD~40 Scalar.new
bisect: good 2016.07 bad HEAD~40 Scalar.new
bisect: good 2016.07 bad Scalar.new
bisect: good 2016.07 Scalar.new
bisect: say ∞.Rat.nude
bisect: my @a = 1; for (@a xx 1) { }
bisect: m: say (1 ... *).grep(*.is-prime).is-lazy;
bisect: multi cross() {};
bisect: my $list = (1,2,3); $list[1] := 4; dd $list
bisect: use Test; subtest "Foo", { ok 1 }
bisect: my @a is List = 1,2,3; dd @a
bisect: good=2015.10 my @a is List = 1,2,3; dd @a # just for fun
bisect: good=2015.11 bad=2015.12 my @a is List = 1,2,3; dd @a # just for fun
bisect: 'á' ~~ m:g:ignoremark/ <[a]> /
bisect: Bool::False // die
bisect: use NativeCall; sub system (Str) is native {}; system 'ls'
bisect: use NativeCall; sub system (Str) is native {}; system 'hostname'
bisect: say (^∞).grep({ last })[5]
bisect: say ‘hello world’
bisect: .say for ^200
bisect: good=2016.03 bad 2016.02 say (^∞).grep({ last })[5] # swapped good and bad revisions
bisect: good 2015.10 my $p1 = start die "I’m dead"; my $p2 = start ~"I’m alive"; try await Promise.allof($p1, $p2); say .result for grep { .status ~~ ‘Kept’}, $p1, $p2;
bisect: "Foo".comb.count-only
bisect: good=053729c bad=HEAD "Foo".comb.count-only
bisect: " ".Int
bisect: say " ".Int
bisect: " ".Int == 0 or die
bisect: bad=7cff429 say " ".Int
bisect: bad=7cff429,good=66a592 say " ".Int
bisect: bad=7cff429 good=HEAD say " ".Int
bisect: good=HEAD bad=7cff429 say " ".Int
bisect: good=7cff429 bad=HEAD my $x; try $x = " ".Int; say $x.defined and die
bisect: https://gist.github.com/Tux/aad6d6ee389a5a19ee26e580071b6521
bisect: https://gist.githubusercontent.com/Tux/aad6d6ee389a5a19ee26e580071b6521/raw/f3b033c98e99b34215863d6e851cfd9320ca2515/gistfile1.txt
bisect: Promise.in(1).then({exit 1}); say (0..10).rotor(1,2 xx *);
bisect: run($*EXECUTABLE, "--rxtrace", "-e", q/say "hello world"/, :out).out.slurp-rest.say
bisect: 2 ** 99999999999999999999999999999999999
bisect: use nqp; die if nqp::atkey(CompUnit::Loader.load-source(q<package Qux { BEGIN say "eval!"; BEGIN EVAL q<>; BEGIN say "eval done!" }; class Foo {};>.encode).unit, q<$?PACKAGE>).^name eq "Qux";
bisect: use nqp; die if nqp::atkey(CompUnit::Loader.load-source(q<package Qux { BEGIN EVAL q<>; };>.encode).unit, q<$?PACKAGE>).^name eq "Qux";
bisect: good=2015.10 2 ** 99999999999999999999999999999999999
bisect: ++.++
bisect: bad=HEAD~200 ++.++
bisect: bad=HEAD~100 ++.++
bisect: bad=HEAD~50 ++.++
bisect: try EVAL '++.++'; say "Error: $!"
bisect: my $supplier = Supplier.new; my $supply = $supplier.Supply; my @seen; $supply.act: { .say }; await (1..5).map: { start { $supplier.emit($_) } }
bisect: my uint8 $test = 0; $test--; say $test
bisect: sub foo { return 42 }; for ^158 { foo }
bisect: 2 ∈ <2> or die
bisect: sub foo() { return 42 }; for ^158 { foo }
bisect: my @list = 1; say @list.permutations
bisect: Inf.Rat == 1/0 or die
bisect: use Test; exit 1 if throws-like { EVAL ‘my Str where 'foo' $test’ }, X::Syntax::Malformed
bisect: use Test; exit 1 if throws-like { EVAL ‘my Str where 'foo' $test’ }, X::Syntax::Malformed; exit 0
bisect: exit 1 if (^∞).grep({ last })[5] // 0 == 4 # RT 128181
bisect: old=2015.07 42 . say
bisect: old=2015.11 say True ~~ Int
bisect: say qw|! @ # $ % ^ & * \| < > | eqv '! @ # $ % ^ & * | < >'.words
bisect: old=2015.07 say sum ^10 .grep: *.is-prime
bisect: old=2015.07 say ^10 .sum
bisect: old=2015.07 say 5 .Int
bisect: old=e0201f1 $++ for $*PROGRAM.IO.lines.batch(30)
bisect: old=2016.12 new=HEAD $++ for '/home/bisectable/.bash_history'.IO.lines.rotor(30, :partial)
bisect: old=4a295dc5 $++ for '/home/bisectable/.bash_history'.IO.lines.rotor(30, :partial)
bisect: say 2 ≤ 50
bisect: say 5 ≤ 10
bisect: old=26e6993bd82 say "aaaastaaa" ~~ m:i/st/;
bisect: my $x = 1,$_
bisect: old=2015.10 my $x = 1,$_
bisect: old=2017.01 new=HEAD my Rat @nums = (1.0, 1/2+1/2)».norm; say @nums.unique;
bisect: old=2015.07 say ½
bisect: old=2015.07 my $s = Supplier.new; my $tap = $s.Supply.tap(-> $v { say "the value is $v" }, done    => { say "Supply is done" }, done => { say "Tap done" }, quit    => -> $ex { say "Supply finished with error $ex" }, ); $tap.close
bisect: old=6bd80ec9cc my $s = Supplier.new; my $tap = $s.Supply.tap(-> $v { say "the value is $v" }, done    => { say "Supply is done" }, done => { say "Tap done" }, quit    => -> $ex { say "Supply finished with error $ex" }, ); $tap.close
bisect: Buf.new ~ Buf.new
bisect: say WHY 'Life, the Universe, and Everything':
bisect: old=HEAD~300 say "ø".uniprop: $_ for <Numeric Alphabetic>;
bisect: role R { multi method foo( :$a!, ) { }; multi method foo( :$b!, ) { } };  class C does R {}
bisect: say '⽝'.uniprop('East_Asian_Width')
bisect: old=HEAD~500 say '⽝'.uniprop('East_Asian_Width')
bisect: old=HEAD~200 my @x = 1, 3 … *; say @x.flat.flat
bisect: use NativeCall; use nqp; my $anchor; my $c = nativecast(Pointer[uint8], Buf.new(1,2,3,4,5,6)); class f is repr("CStruct") { has uint16 $.a; has uint32 $.b }; my $d = nativecast(f,$c); my $f = $d.a; nqp::force_gc; $d = nativecast(f,$c); say $f == $d.a
bisect: my $p = Promise.new; my $b = 0; my $w = start { await($p); CATCH { default { $b = 1; .resume } } }; $p.break; await($w); $b.say
bisect: my $p = Promise.new; my $b = 0; my $w = start { await($p); CATCH { default { $b = 1; } } }; $p.break; await($w); $b.say
bisect: old=abf6caf06eb7e48674d4e22a4ad6b580e5efecbf my $p = Promise.new; my $b = 0; my $w = start { await($p); CATCH { default { $b = 1; .resume } } }; $p.break; await($w); $b.say
bisect: old=b8df3a613125f17e9cbc59488326187bcfed8e2c my $p = Promise.new; my $b = 0; my $w = start { await($p); CATCH { default { $b = 1; .resume } } }; $p.break; await($w); $b.say
bisect: my $x := (my $y := $x); say $x.WHAT
bisect: my @a = @a
bisect: old=2015.07 my @a = @a
bisect: 50 . say
bisect: ^0 . pick . say
bisect: ^1 .pick.say
bisect: old=2015.09 50 . say
bisect: old=2015.09 50 . say
bisect: -> *@a { @a.is-lazy.say }(1…∞)
bisect: m: my \SCALE = 3; my \FANOUT = 2; sub divide-and-conquer($n, $depth) { say "$depth: $n" if 0; $depth <= 0 ?? $n !! [+] await do for ^FANOUT { start { divide-and-conquer($n / FANOUT, $depth - 1) } } }; say divide-and-conquer(1.0, SCALE);
bisect: old=2015.07 say ($ = 42) ~~ S/4/2/; say $/; say $_
bisect: old=f54ff833 say ($ = 42) ~~ S/4/2/; say $/; say $_
bisect: old=2014.01 new=2015.12 S/4/2/.VAR.name.say given "x"
bisect: old=587f700e9 say ($ = 42) ~~ S/4/2/; say $/; say $_
bisect: old=2015.05 new=2015.06 S/4/2/.VAR.name.say given "x"
bisect: class C { method defined { True } }; say ?C
bisect: m: my IO::Path $a .= new: "."
bisect: old=2017.01 new=HEAD my IO::Path $a .= new: "."
bisect: old=0c89292 new=HEAD my IO::Path $a .= new: "."
bisect: two novels and several short stories, and his debut novel 'The
bisect: say <one two>.categorize({ ( m:g/<[aeiou]>/ )».Str })
bisect: say <one two>.classify({ ( m:g/<[aeiou]>/ )».Str })
bisect: old=2016.01 new=2016.10 <one two>.classify({ ( m:g/<[aeiou]>/ )».Str })
bisect: old=2016.01 new=2016.12 say <one two>.classify({ ( m:g/<[aeiou]>/ )».Str })
bisect: old=5f1249e8 sub foo { supply { emit($_) for 1..10; }; }; react { whenever foo() { next if $_ > 3; say $_; }; };
bisect: sub foo { supply { emit($_) for 1..10; }; }; react { whenever foo() { next if $_ > 3; CATCH { default { exit 1 } } }; }; exit 0
bisect: sub clip-to ($min, $v is rw, $max) { $v = ($min max $v) min $max }; sub blah ( Array() :$rgbd ) { clip-to 0, $_, 255 for @$rgbd; }; blah(rgbd => <.086, .165, .282> );
bisect: old=ed5c866 new=HEAD use lib </home/bisectable/test/DBIish/lib /home/bisectable/test/Blob/lib>; use DBIish; DBIish.install-driver(<Pg>)
bisect: old=ed5c866 new=HEAD use lib </home/bisectable/test/DBIish/lib /home/bisectable/test/Blob/lib>; use DBIish; DBIish.install-driver(<Pg>)
bisect: my @x = lazy 1..3; say (@x X 4..7)[^10]
bisect: my @x = 6,8,9,3,42,5,-5,0,2; say @x.minpairs
bisect: say list '!' ^..^ '&';
bisect: multi a($a is rw) { say "writable" }; multi a($a) { $a = 99 }; a my $; a 42
bisect: old=HEAD~300 my @array[2;2;2]; for @array.pairs { say .perl }
bisect: old=2015.07 <a b c d e f g h i>».say
bisect: 2015.12,HEAD dd my $b = Blob.new(1,2,3); dd subbuf-rw($b,2,1) = Buf.new(42); dd $b
bisect: dd my $b = Blob.new(1,2,3); dd subbuf-rw($b,2,1) = Buf.new(42); dd $b
bisect: 2015.12,HEAD my %f := Map.new; %f.WHICH.say
bisect: my %f := Map.new; %f.WHICH.say
bisect: my %f := Map.new; exit %f.WHICH.gist.ends-with(‘|’)
bisect: say [-] [+] 1,2,3
bisect: multi regex-dispatch(/fo+/) { }; multi regex-dispatch(/ba+/)  {}; regex-dispatch("foo");
bisect: class A { has $.wut = [] }; my $a = A.new; $a.wut = [1,2,3]; say $a.wut
bisect: class Foo { submethod BUILD { fail "noway" } } ; dd Foo.new
bisect: old=2014.07 say Rakudo::Internals.PROPCODE('space'); say Rakudo::Internals.PROPCODE('White_Space'),
bisect: sub foo(--> 123) { }
bisect: old=2015.10 sub foo(--> 123) { }
bisect: old=2015.09 sub foo(--> 123) { }
bisect: say Dateish.is-leap-year(2016);
bisect: new=f4bda35^ say Dateish.is-leap-year(2016);
bisect: my @x; say @x»<xxx>
bisect: say WHAT ‘hello’.comb(/./)
bisect: my $x = do while (1) { LAST { exit }; };
bisect: my $i = 30; say permutations( +(^$i).join.comb ).elems
bisect: new=ab3a59c3^ my $i = 30; say permutations( +(^$i).join.comb ).elems
bisect: all Rakudo::Internals.PROPCODE('Space')
bisect: all say Rakudo::Internals.PROPCODE('Space')
bisect: 0xF.uniprop-bool('space').say
bisect: 0xF.uniprop-bool('Space').say
bisect: my @a = 1,2; say @a =:= @a.item;
bisect: my @a = 1,2; say @a.WHERE === @a.item.WHERE;
bisect: all say 0xD800.chr
bisect: multi sub cross() { }
bisect: class foo { method TWEAK { say ‘hi’ } }; foo.new
bisect: my $a = Pointer[int32].new(10); $a.deref.say;
bisect: use NativeCall; my $a = Pointer[int32].new(10); $a.deref.say;
bisect: (^42).^lookup('max').file.say
bisect: old=2016.11 say 2**-999999
bisect: old=2015.11 my &block = { say 'returning from &block'; return }; sub returned-from(&code) { say 'enter returned-from'; code; say 'leave returned-from' }; sub forcing-a-return { returned-from &block }; forcing-a-return;
bisect: my $xs = map({ $_² }, (1…Inf)); say $xs.grep({last if $_ > 100; True})[^100]
bisect: say <a1 a2 a3>.map({S/a/x/}).perl
bisect: say ‘abc’.trans(‘a’ => ‘X’, ‘a’ => ‘Z’, ‘c’ => ‘C’)
bisect: "<ciao>mamma</ciao>" ~~ /:r '<' (<[\w\W]>+?) '>'/
bisect: .say for Inf..0
bisect: 2015.07 .say for Inf..0
bisect: old=2015.07 .say for Inf..0
bisect: old=2015.07 .say for (Inf..0)[^2000]
bisect: old=2015.07 .say for (Inf..0)[2000]
bisect: [SR-]
bisect: old=2016.09 say (4,5,6).head(-9999999999999999999)
bisect: old=2016.09 say (4,5,6).tail(-9999999999999999999)
bisect: say ‘hi’.indent(9999999999999999999)
bisect: say S:g/d// given 'abc'
bisect: https://gist.github.com/dogbert17/41042137f44394a0094c1cc1c05055bb
bisect: https://gist.githubusercontent.com/dogbert17/41042137f44394a0094c1cc1c05055bb/raw/fa0236369e6d8ca5c3eccf8a0a6fddac1f85f616/gistfile1.txt
bisect: m: my $x = "meow" but role { method ^name($) { dd "heh" } }
bisect: say 42 x Nil
bisect: old=2016.10 say 42 x Nil
bisect: old=2015.10 say 42.roll(-1)
bisect: say ().rotor(1)
bisect: q'test'
bisect: dd (^10).lazy.iterator.can("count-only")
bisect: dd (^10).lazy.iterator.count-only
bisect: old=2015.10 say ½
bisect: old=2015.07 sub (+abc){}(42, 69)
bisect: use MONKEY-SHINE;
bisect: use MONKEY-BARS;
bisect: role Fooish { method fooey {...} }.WHY.say
bisect: #|{ a Fooish thingy }; role Fooish { method fooey {...} }
bisect: old=2016.10 new=2016.11 dd '789'.comb(/ . <?{ say $/; False }> /)
bisect: sub foo(True) { dd 'meow' }; foo False
bisect: old=2016.10 my $errors = 3; my @stuff = flat ("abc" xx 255) Z ("12" xx 128+$errors); for @stuff -> $line { unless $line ~~ m/1/ { say "seen: $line" if $line.index("2") }; if $line ~~ m/9/ { } }
bisect: my $errors = 3; my @stuff = flat ("abc" xx 255) Z ("12" xx 128+$errors); for @stuff -> $line { unless $line ~~ m/1/ { say "seen: $line" if $line.index("2") }; if $line ~~ m/9/ { } }
bisect: sub f(::T $a) { sub(T $b) { $a ~ $b } }; f(2)(3).say
bisect: my $a = "john.doe@perl6.org"; my $b = / <:L>+\.<:L>+\@<:L+:N>+\.<:L>+ /; say $/ if $a ~~ $b;
bisect: old=2016.10 my $a = "john.doe@perl6.org"; my $b = / <:L>+\.<:L>+\@<:L+:N>+\.<:L>+ /; say $/ if $a ~~ $b;
bisect: sort: 1...3; say sort.gist
bisect: sort unique (2, 12, 1, 2): :
bisect: class { has $.x! }.new
bisect: my int $a = -10; say $a % 12
bisect: sub foo { loop (my $i = 0; $i < 5; ++$i) { say $i; } }; foo  # RT #127238
bisect: sub infix:<j>{$^l.comb.tail eq $^r.comb.head??(|$l,$r)!!|@};say [Xj] <te tt>,<fg et>,<wd td>; # usually you'll do this
bisect: open 'foo' orelse say "Something happened $!"
bisect: sub t { say $*d }; my $*d = 1; await  do { start { t() } }
bisect: my $*A = 42; do { start { $*A++ } }; sleep 1; say $*A
bisect: [*] set(1,2,3),
bisect: say [*] set(1,2,3),
bisect: old=2015.10 ((1,2,3),(4,5,6)).map(&join).say
bisect: old=2015.10 put()
bisect: old=2015.10 put() # oh come on
bisect: "foo".IO.modified
bisect: m: my $var = 5; say "aaaaa" ~~ / "a" ** $var /
bisect: good=2016.04,bad=HEAD m: my $var = 5; say "aaaaa" ~~ / "a" ** $var /
bisect: m: say "7\x[308]" ~~ /^ \d+ $/
bisect: my @a = 5, 6; END dd @a; @a.push: 42
bisect: m: sub foo ( *@what ) { say @what.is-lazy }( 1...* )
bisect: m: Promise.in(2).then: {exit}; sub foo ( *@what ) { say @what.is-lazy }( 1...* )
bisect: my regex fú { \. }; say 'w00t' if 'a.b' ~~ / <fú> /
bisect: :१x
bisect: say DateTime.now.Str.chars
bisect: my $foo = True; END say $foo
bisect: good=2015.12 bad=HEAD say ^1000 .grep: -> $n {([+] ^$n .grep: -> $m {$m and $n %% $m}) == $n }
bisect: m: my $awesome-int = 42 but role { method is-even { self %% 2 } }; 42.is-even.say;
bisect: class WorkingInt is Int {}; my $awesome-int = WorkingInt.new(42) but role { method is-even { self %% 2 } }; 42.is-even.say;
bisect: m: say Any.^can("push")[0] ~~ Callable;
bisect: m: fail.^name.say
bisect: fail.^name.say
bisect: my $x; ($x) = (42, 69); say $x
bisect: sub foo { { LEAVE { say ‘block left’ }; return 42; }; say ‘end’ }; say foo
bisect: say WHAT ‘.’.IO.abspath
bisect: module Foo { multi MAIN($, $) is export { } }; import Foo; multi MAIN($) { };
bisect: good=HEAD bad=2016.01 module Foo { multi MAIN($, $) is export { } }; import Foo; multi MAIN($) { };
bisect: m: sub infix:<↑>($a, $b) is assoc<right> {$a ** $b}; sub infix:<↑↑>($a, $b) is assoc<right> { [↑] $a xx $b }; sub infix:<↑↑↑>($a, $b) is assoc<right> { [↑↑] $a xx $b }; sub infix:<↑↑↑↑>($a, $b) is assoc<right> { [↑↑↑] $a xx $b }; say 3↑↑3
bisect: m: sub foo (:$what = 42) { dd $what }; sub bar (:$what) { foo (:$what if $what) }; bar
bisect: ++blah++
bisect: for 1..100 -> $i { say (((^$i).map: {^$_}) <<(-)>> ((^($i+1)).map: {$_ xx $i})) }
bisect: 2+2
bisect: for 1..100 -> $i { say (((^$i).map: {^$_}) <<(-)>> ((^($i+1)).map: {$_ xx $i})) }
bisect: m: use MONKEY-TYPING; augment class IO::Path { multi method basename (:$ext!) { $.basename.substr: 0, *-$.extension } }; "foo.txt.bak".IO.basename(:!ext).say
bisect: my @ends; for ^0x00ff -> $i { my $c = try { $i.chr }; next if !$c.defined or $c eq "("; next unless $c ~~ /<:Ps>|<:Pi>/; my $end = :16(uniprop($c, "Bidi_Mirroring_Glyph")); next unless $end.defined; $end = $end.chr; say("'$c' {uniname($c)} ~ '$end' {uniname($end)}") }
bisect: https://gist.github.com/ugexe/7ce08d3ad4cfd36f275c437ba9713471
bisect: https://gist.githubusercontent.com/ugexe/7ce08d3ad4cfd36f275c437ba9713471/raw/e1deedcbc120a53757d8dd78602bb8bf51b21c3b/gistfile1.txt
bisect: https://gist.githubusercontent.com/zoffixznet/1b371fb8c4624aa662d622e685d6e950/raw/d42b6046679b369cbb0faa4dcefde97b5f66d0f5/gistfile1.txt
bisect: say ^10 .grep: { last if * > 2 }
bisect: say ^10 .grep({ last if $_ > 4; $_ })
bisect: min(+'a', +'a').say
bisect: good=2015.10 min(+'a', +'a').say
bisect: good=2015.10 try { min(+‘a’, +‘a’).say; CATCH { exit 1 } }
bisect: say chr 9999999999999999999999
bisect: good=2015.10 say chr 9999999999999999999999
bisect: try { say chr 9999999999999999999999; CATCH { default { exit 1 if $_ ~~ /Cannot\sunbox/; exit 0 } } }
bisect: good=2015.10 try { say chr 9999999999999999999999; CATCH { default { exit 1 if $_ ~~ /Cannot\sunbox/; exit 0 } } }
bisect: good=2015.10 bad=7f30326^ try { say chr 9999999999999999999999; CATCH { default { exit 1 if $_ ~~ /Cannot\sunbox/; exit 0 } } }
bisect: good=2015.10 bad=7f30326^ say chr 9999999999999999999999
bisect: say List.^name
bisect: good=2015.10 my $p1 = start die "I’m dead"; my $p2 = start ~"I’m alive"; try await Promise.allof($p1, $p2); say .result for grep { .status ~~ ‘Kept’}, $p1, $p2;
bisect: #| THIS IS A CLASS FOR SHOUTING THINGS␤ class MY-CLASSES-ARE-ALL-CAPS { method WHY { "I DON'T KNOW" } } my $c = MY-CLASSES-ARE-ALL-CAPS.new; say $c.WHY say $c."WHY"()
bisect: good=2015.10 #| THIS IS A CLASS FOR SHOUTING THINGS␤ class MY-CLASSES-ARE-ALL-CAPS { method WHY { "I DON'T KNOW" } } my $c = MY-CLASSES-ARE-ALL-CAPS.new; say $c.WHY say $c."WHY"()
bisect: #| THIS IS A CLASS FOR SHOUTING THINGS␤ class MY-CLASSES-ARE-ALL-CAPS { method WHY { "I DON'T KNOW" } } my $c = MY-CLASSES-ARE-ALL-CAPS.new; say $c.WHY; say $c."WHY"()
bisect: #| THIS IS A CLASS FOR SHOUTING THINGS␤ class MY-CLASSES-ARE-ALL-CAPS { method WHY { "I DON'T KNOW" } }; my $c = MY-CLASSES-ARE-ALL-CAPS.new; say $c.WHY; say $c."WHY"()
bisect: good=2015.10 #| THIS IS A CLASS FOR SHOUTING THINGS␤ class MY-CLASSES-ARE-ALL-CAPS { method WHY { "I DON'T KNOW" } }; my $c = MY-CLASSES-ARE-ALL-CAPS.new; say $c.WHY; say $c."WHY"()
bisect: good=2015.09 #| THIS IS A CLASS FOR SHOUTING THINGS␤ class MY-CLASSES-ARE-ALL-CAPS { method WHY { "I DON'T KNOW" } }; my $c = MY-CLASSES-ARE-ALL-CAPS.new; say $c.WHY; say $c."WHY"()
bisect: https://gist.github.com/atweiden/9d1dfe825ade18a7db54d8e0733ca2e4
bisect: # newline test␤exit 42
bisect: class Foo { method new { self.bless: *, :foo<bar> } }.new
bisect: good=2016.01.1 class Foo { method new { self.bless: *, :foo<bar> } }.new
bisect: good=2016.02 class Foo { method new { self.bless: *, :foo<bar> } }.new
bisect: good=2d9202c class Foo { method new { self.bless: *, :foo<bar> } }.new
bisect: use REPL; say 1
bisect: EVAL “use REPL” if 1; CATCH { exit 0 if $_ ~~ /builtin/; exit 1 }
bisect: my $p1 = start die "I’m dead"; my $p2 = start ~"I’m alive"; try await Promise.allof($p1, $p2); say .result for grep { .status ~~ ‘Kept’}, $p1, $p2;
bisect: class Foo { method new { self.bless: *, :foo<bar> } }.new
bisect: use REPL; say 1
bisect: bad=HEAD~1 use REPL; say 1
bisect: use REPL; say 1
bisect: my @h = :foo; sub bar (@h) { say @h; @h[0] = 42; say @h }; bar @h; say @h
bisect: class User { has $.username is required; method new(*%args) { my $obj = self.bless(*, |%args); return $obj; } }; User.new(username => 'foo');
bisect: class MY-CLASSES-ARE-ALL-CAPS { method WHY { "I DONT KNOW" } }; my $c = MY-CLASSES-ARE-ALL-CAPS.new; say $c.WHY; say $c."WHY"()
bisect: #| THIS IS A CLASS FOR SHOUTING THINGS␤ class MY-CLASSES-ARE-ALL-CAPS { method WHY { "I DON'T KNOW" } } my $c = MY-CLASSES-ARE-ALL-CAPS.new; say $c.WHY say $c."WHY"() # /o\
bisect: #| THIS IS A CLASS FOR SHOUTING THINGS␤ class MY-CLASSES-ARE-ALL-CAPS { method WHY { "I DON'T KNOW" } } my $c = MY-CLASSES-ARE-ALL-CAPS.new; say $c.WHY say $c."WHY"() # /o\
bisect: use experimental :macros; macro polo ($ast) { quasi { say 42; say {{{ $ast }}} } }; polo 11
bisect: bad=HEAD~10 use experimental :macros; macro polo ($ast) { quasi { say 42; say {{{ $ast }}} } }; polo 11
bisect: use experimental :macros; macro polo ($ast) { quasi { say 42; say {{{ $ast }}} } }; polo 11
bisect: use experimental :macros; macro a { quasi {{{ 42 }}} }; a
bisect: react { whenever Supply.interval: 1 -> $ { done } }
bisect: exit 42
bisect: exit 999999999999999
bisect: exit -99999999
bisect: exit -999999999
bisect: exit -999999
bisect: exit -99999
bisect: [1..99].map:{[$_%%5&&'fizz', $_%%3&&'buzz'].grep:Str}
bisect: my $b = bag <bacon eggs>; my $p = $b.pairs; say $p.WHAT; for $p { .say }; for $p { .say }
bisect: m: class Bar { ... }; class Foo { trusts Bar; has $!meths = <foo bar ber>;  }; class Bar { method do ($z) { .say for $z!meths } }; Bar.new.do: Foo.new
bisect: m: class Bar { ... }; class Foo { trusts Bar; has $!meths = <foo bar ber>;  method !meths { $!meths } }; class Bar { method do ($z) { .say for $z!meths } }; Bar.new.do: Foo.new
bisect: my $*TOLERANCE = 0.1; say .9 =~= 1
bisect: my @a = ^4; my @b = ^6; (@a Z @b)».Slip[0].^name eq 'Slip' or die
bisect: say “p̷̢̖̤̙̬̞̙͉͕̲̺̮͎͖̆̄͒͛́͊̋ͣ͢ͅe͙͕̖͌͛̐ͨ̍ͬͮ̑̊̕͟​̥̜͚͕̥̮̹͓̥͇̯̫̺̯̹r̅ͪ̌̑̾̄ͬ̈҉̨̩̬̤̭̰̮͎̹̦̩̮̞̘̳͜͢​͈̩̠͉ḷ̡̦̳̹̻̪͇͈͕̼̙̦̞̝̬͎͚̙̿͌ͨ̽̂́6̊ͣ͌͋ͦͣ҉̛͓͔͘​̤̞̤͇͇̗̣̖͔͓̗̗͓”.comb.map(*.NFD[0].chr).join
bisect: exit “p̷̢̖̤̙̬̞̙͉͕̲̺̮͎͖̆̄͒͛́͊̋ͣ͢ͅe͙͕̖͌͛̐ͨ̍ͬͮ̑̊̕͟​̥̜͚͕̥̮̹͓̥͇̯̫̺̯̹r̅ͪ̌̑̾̄ͬ̈҉̨̩̬̤̭̰̮͎̹̦̩̮̞̘̳͜͢​͈̩̠͉ḷ̡̦̳̹̻̪͇͈͕̼̙̦̞̝̬͎͚̙̿͌ͨ̽̂́6̊ͣ͌͋ͦͣ҉̛͓͔͘​̤̞̤͇͇̗̣̖͔͓̗̗͓”.comb.map(*.NFD[0].chr).join eq 'perl6'
bisect: class Foo { submethod BUILD { fail "noway" } } ; Foo.new ~~ Failure;
bisect: my $numFactors = 500;my$sum=0;for (1...*) -> $term {$sum+=$term;my$factors=(1..floor(sqrt($sum))).grep(-> $x { $sum % $x == 0} ).elems * 2;$factors-- if floor(sqrt($sum)) == sqrt($sum);if $factors > $numFactors {say "$sum";last;}}
bisect: my $sum = 10082800;for (4601...4900) -> $term {   $sum += $term;   my $sq = floor(sqrt($sum));   my $factors = (1..$sq).grep(-> $x { $sum % $x == 0} ).elems * 2; }
bisect: good=6bb23a my $sum = 10082800;for (4601...4900) -> $term {   $sum += $term;   my $sq = floor(sqrt($sum));   my $factors = (1..$sq).grep(-> $x { $sum % $x == 0} ).elems * 2; }
bisect: good=6bb23a my $sum = 10082800;for (4601...4900) -> $term {   $sum += $term;   my $sq = floor(sqrt($sum));   my $factors = (1..$sq).grep(-> $x { $sum % $x == 0} ).elems * 2; }; say ‘hi’
bisect: my $sum = 10082800;for (4601...4900) -> $term {   $sum += $term;   my $sq = floor(sqrt($sum));   my $factors = (1..$sq).grep(-> $x { $sum % $x == 0} ).elems * 2; }; say ‘hi’
bisect: good=HEAD~150 my $sum = 10082800;for (4601...4900) -> $term {   $sum += $term;   my $sq = floor(sqrt($sum));   my $factors = (1..$sq).grep(-> $x { $sum % $x == 0} ).elems * 2; }; say ‘hi’
bisect: class A { has $.wut = [] }; my $a = A.new; $a.wut = [1,2,3]; $a.wut.say
bisect: for ‘q b c d’.words -> $a, $b { }
bisect: class A { has $.wut = [] }; my $a = A.new; $a.wut = [1,2,3]; $a.wut.say
bisect: good=2016.03 bad 2016.02 say (^∞).grep({ last })[5]
bisect: say (^∞).grep({ last })[5]
bisect: exit 42
bisect: say $*VM.version
bisect: exit 42
bisect: exit 42
bisect: exit 42
bisect: exit 1 if (^∞).grep({ last })[5] // 0 == 4 # RT 128181
bisect: say (^∞).grep({ last })[5]
bisect: good=2016.03 bad 2016.02 say (^∞).grep({ last })[5]
bisect: for ‘q b c d’.words -> $a, $b { }
bisect: class A { has $.wut = [] }; my $a = A.new; $a.wut = [1,2,3]; $a.wut.say
bisect: Scalar.new = 5
bisect: m: (^100).pick(*).map: { start { sleep $_; .say } }
bisect: use nqp; nqp::const::just_a_test;
bisect: m: my $x := (my $y := $x); say $x.WHAT;
bisect: my int $x = 0; my $y = ($x - 1) % 8; exit 1 if $y == -1
bisect: my int $x = 0; my $y = ($x - 1) % 8; exit 1 if $y != -1
bisect: exit 1 if (^∞).grep({ last })[5] // 0 == 4
bisect: exit 1 if (^∞).grep({ last })[5] // 0 == 4
bisect: exit 1 if (^∞).grep({ last })[5] // 0 == 4
bisect: exit 1 if (^∞).grep({ last })[5] // 0 == 4
bisect: exit 1 if (^∞).grep({ last })[5] // 0 == 4
bisect: try { NaN.Rat == NaN; exit 0 }; exit 1
bisect: for ‘q b c d’.words -> $a, $b { }; CATCH { exit 0 }; exit 1
bisect: 1/0; exit 0
bisect: try { 1/0 }; exit $! ?? 1 !! 0
bisect: try { 1/0 }; exit $! ?? 0 !! 1
bisect: say 1/0; CATCH { exit 0 }; exit 1
bisect: exit 1 if (^∞).grep({ last })[5] // 0 == 4 # RT 128181
bisect: for ‘q b c d’.words -> $a, $b { }; CATCH { exit 0 }; exit
bisect: for ‘q b c d’.words -> $a, $b { }; CATCH { exit 0 }; exit 1
bisect: good=v6.c bad=HEAD exit 1 if (^∞).grep({ last })[5] // 0 == 4 # RT 128181
bisect: exit 1
bisect: exit 0
bisect: try { NaN.Rat == NaN; exit 0 }; exit 1
bisect: try { say NaN.Rat == NaN; exit 0 }; exit 1
bisect: exit 125
bisect: exit 1 if 10.polymod(lazy 2, 2) eqv (0, 1, 2); exit 0
bisect: exit 0
bisect: old=Xͫ⃝ say 42
bisect: (Scalar).unique