»ö« Welcome to Perl 6! | perl6.org/ | evalbot usage: 'p6: say 3;' or rakudo:, std:, or /msg camelia p6: ... | irclog: irc.perl6.org | UTF-8 is our friend!
Set by masak on 12 May 2015.
00:11 tinyblak joined 00:21 Peter_R left 00:45 tadzik left, tadzik joined 00:48 llfourn joined 00:53 llfourn left 01:00 llfourn joined, skids joined, skids left, skids joined 01:03 cognominal joined 01:04 llfourn left
timotimo it seems like "use trace" damages something in this script 01:06
so i'll try to golf a little test
01:12 BenGoldberg joined 01:35 dj_goku left
timotimo ah, seems to be glr-only 01:38
so i'll gist it rather than rakudobugging it
gist.github.com/timo/0b64637e8b7bda922bea 01:40
dha So, out of curiosity, where would be the best place to look for info on the GLR? 01:42
timotimo the gist jnthn worked inside of at the beginning has a whole lot of comments and also some short test cases at the bottom 01:43
01:44 AlexDaniel joined
dha Ah. And where's that? 01:45
timotimo gimme a sec 01:46
gist.github.com/jnthn/aa370f8b32ef98e4e7c9
dha Thanks. 01:47
timotimo yw
AlexDaniel m: say 2 ** 268435456; 01:48
camelia rakudo-moar ab73b0: OUTPUT«(timeout)»
AlexDaniel oh really
timotimo does that surprise you? :)
AlexDaniel it does 01:49
because
m: say 2 ** 99999999999999999999999999999999999
camelia rakudo-moar ab73b0: OUTPUT«0␤»
timotimo interesting
could be something libtommath does
AlexDaniel the interesting part that 268435456 prints 0 on my pc
but I'm on 32-bit, I guess
ShimmerFairy timotimo: I found an issue the other day where nqp::pow_n return Inf, and then I did nqp::mul_n(0, Inf) -> NaN :P 01:50
timotimo poor you; rakudo-m isn't so hot on 32bit
AlexDaniel why that?
timotimo no jit 01:51
AlexDaniel besides the lack of JIT?
ok, well, it is not so bad without JIT
timotimo all our integer registers are 64bit, too
AlexDaniel I care about startup time more
timotimo not 100% sure how x86_32 performance gets hit by using 64 bit numbers all over the place
AlexDaniel I tell you, it's OK 01:52
timotimo OK
i don't mean to bother you
i'd also say we may have a bit of a lack of testing for 32bit platforms, but i don't know that for sure
AlexDaniel
.oO(“how to find a bug in rakudo? Well, just take a huge number and put it into any function. Do you see any bugs? No? Increase the number!”)
 01:55
dha TEST TO FAILURE! 01:56
AlexDaniel exactly 01:57
well, that's how I found this one: rt.perl.org/Public/Bug/Display.html?id=125784
although it is about really small numbers
so it should be “increase the number of digits” 01:58
02:00 telex left 02:02 telex joined
AlexDaniel It also feels like regression 02:02
what was the command to run something on older versions? 02:03
ugexe fetch, precompile, and test working on a glr branch with some help from json::tiny where json::pretty doesnt work yet. install/smoke tomorrow
AlexDaniel I feel like we will get something different if we try the same code on 3-month old rakudo
ugexe from json::fast rather
timotimo star: say "hi" 02:04
camelia star-m 2015.03: OUTPUT«hi␤»
timotimo this is a bit older
AlexDaniel star: say 2 ** 99999999999999999999999999999999999
camelia star-m 2015.03: OUTPUT«0␤»
AlexDaniel okay, whatever
I was just stupid enough not to try that earlier 02:05
it was probably the first thing that I ever tried running in perl6
with a smaller amount of digits, of course… 02:06
ugexe you could find some 3 month old commit and do `rakudobrew build moar 34afwhatever` if youre feeling frisky 02:08
AlexDaniel no-no, 2015.03 is good enough
thanks
02:10 abaugher left
AlexDaniel m: say 'x' if; 02:12
camelia rakudo-moar ab73b0: OUTPUT«5===SORRY!5===␤Whitespace required after keyword 'if'␤at /tmp/ix2__2_iKj:1␤------> 3say 'x' if7⏏5;␤Whitespace required after keyword 'if'␤at /tmp/ix2__2_iKj:1␤------> 3say 'x' if7⏏5;␤Whitespace required after keyword 'if'␤at…»
AlexDaniel m: say 1 if ;
camelia rakudo-moar ab73b0: OUTPUT«5===SORRY!5=== Error while compiling /tmp/3E2OrviEss␤Missing semicolon␤at /tmp/3E2OrviEss:1␤------> 3say 1 if 7⏏5;␤»
AlexDaniel m: say 1 with ;
camelia rakudo-moar ab73b0: OUTPUT«5===SORRY!5=== Error while compiling /tmp/cP049uzzzc␤Confused␤at /tmp/cP049uzzzc:1␤------> 3say 1 with 7⏏5;␤»
AlexDaniel I wonder why the errors are so different 02:13
ShimmerFairy "Missing semicolon" is interesting, and "Confused" isn't helpful. In both cases I think a "missing conditional" message would be nicer. 02:14
AlexDaniel sure, but I think that I already submitted the if thing a few weeks ago
02:15 MadcapJake left
AlexDaniel I mean, opened a ticket about it 02:15
ShimmerFairy The if; thing is because immediately after that keyword the parser checks for whitespace (which is required to avoid issues with doing, say, if(cond) ), so that for me is an expected error. 02:29
AlexDaniel with(cond) ?
m: with(1) { say 42 } 02:30
camelia rakudo-moar ab73b0: OUTPUT«5===SORRY!5=== Error while compiling /tmp/NSTfLdeQlZ␤Unexpected block in infix position (missing statement control word before the expression?)␤at /tmp/NSTfLdeQlZ:1␤------> 3with(1)7⏏5 { say 42 }␤ expecting any of:␤ infix␤ …»
AlexDaniel what?
ShimmerFairy m: if(1) { say 42 } 02:31
camelia rakudo-moar ab73b0: OUTPUT«5===SORRY!5===␤Word 'if' interpreted as 'if()' function call; please use whitespace instead of parens␤at /tmp/mo_ocs6Nzp:1␤------> 3if7⏏5(1) { say 42 }␤Unexpected block in infix position (two terms in a row)␤at /tmp/mo_ocs6Nzp:1␤-----…»
ShimmerFairy m: unless(1) { say 42 }
camelia rakudo-moar ab73b0: OUTPUT«5===SORRY!5===␤Word 'unless' interpreted as 'unless()' function call; please use whitespace instead of parens␤at /tmp/WptPdxZ9Ua:1␤------> 3unless7⏏5(1) { say 42 }␤Unexpected block in infix position (two terms in a row)␤at /tmp/WptPdxZ9…»
ShimmerFairy m: without(1) { say 42 }
camelia rakudo-moar ab73b0: OUTPUT«5===SORRY!5=== Error while compiling /tmp/7JkqB4q4vp␤Unexpected block in infix position (missing statement control word before the expression?)␤at /tmp/7JkqB4q4vp:1␤------> 3without(1)7⏏5 { say 42 }␤ expecting any of:␤ infix…»
AlexDaniel well-well…
ShimmerFairy Looks like with/without are missing some () checks :)
02:33 noganex_ joined 02:36 noganex left 02:39 dha left
AlexDaniel m: say '../../../../../../../../../../../../test'.IO.dir 02:46
camelia rakudo-moar ab73b0: OUTPUT«Failed to get the directory contents of '/home/camelia/../../../../../../../../../../../../test': chdir failed: Unknown system error␤ in any at /home/camelia/rakudo-inst-1/share/perl6/runtime/CORE.setting.moarvm:1␤ in block <unit> at /tmp/gmjoxJFInQ…»
AlexDaniel oh 02:47
it does not even need that sort of trickery
m: say 'test'.IO.dir 02:48
camelia rakudo-moar ab73b0: OUTPUT«Failed to get the directory contents of '/home/camelia/test': chdir failed: Unknown system error␤ in any at /home/camelia/rakudo-inst-1/share/perl6/runtime/CORE.setting.moarvm:1␤ in block <unit> at /tmp/YAVrapeOSz:1␤␤Actually thrown at:␤ in b…»
AlexDaniel is that trace LTA or not?
ShimmerFairy well, camelia runs under RESTRICTED if I recall correctly, so IO-ish stuff can't really be tested on camelia. 02:49
AlexDaniel well, I get the same thing on my machine 02:51
haha, here is a fun one 02:53
m: say ('a' x 970).IO.open;
camelia rakudo-moar ab73b0: OUTPUT«Failed to open file /home/camelia/aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa…»
AlexDaniel well, it is not visible here
but really it says “name too l” 02:54
should be “long”, but it does not fit
so if we go even further…
m: say ('a' x 1000).IO.open;
camelia rakudo-moar ab73b0: OUTPUT«Failed to open file /home/camelia/aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa…»
ShimmerFairy I get a malformed UTF-8 error :)
AlexDaniel yea
surprisingly, camelia has no problem with that 02:55
m: say ('a' x 10000).IO.open;
camelia rakudo-moar ab73b0: OUTPUT«Malformed UTF-8 at line 1 col 1033␤ in block <unit> at /tmp/8ss2h3ctqB:1␤␤»
AlexDaniel oh ok, it always needs more digits
02:58 aborazmeh joined, aborazmeh left, aborazmeh joined 03:01 llfourn joined
AlexDaniel interesting how it is col 1033 on camelia, but col 1029 on my pc 03:01
same code
aaah
different path!!
ok, obvious
03:05 llfourn left
AlexDaniel m: say 'foo foo foo'.subst(/foo/, "bar", :nth(Inf)); 03:06
camelia rakudo-moar ab73b0: OUTPUT«Cannot coerce Inf or NaN to an Int␤ in block <unit> at /tmp/jO66bXi3eN:1␤␤Actually thrown at:␤ in block <unit> at /tmp/jO66bXi3eN:1␤␤»
AlexDaniel cannot coerce Inf or NaN, yeah. What about -Inf? 03:07
m: say 'foo foo foo'.subst(/foo/, "bar", :nth(-Inf));
camelia rakudo-moar ab73b0: OUTPUT«foo foo foo␤»
AlexDaniel is it a bug?
03:15 aborazmeh left
BenGoldberg m: (-Inf).Int.say 03:17
camelia rakudo-moar ab73b0: OUTPUT«Cannot coerce Inf or NaN to an Int␤ in block <unit> at /tmp/m4c2HYJg9f:1␤␤Actually thrown at:␤ in block <unit> at /tmp/m4c2HYJg9f:1␤␤»
ShimmerFairy Inf and NaN have never really worked as Ints.
AlexDaniel BenGoldberg: ok, but why -Inf works? 03:18
BenGoldberg m: my $minf = -Inf; 'foo foo foo'.subst(/foo/, "bar", :nth($minf)).say;
camelia rakudo-moar ab73b0: OUTPUT«foo foo foo␤»
BenGoldberg I would guess that subst is testing whether the arg is less than zero, and if so, not coercing to Int. 03:19
AlexDaniel hmmmm that actually makes sense
not a bug then 03:20
m: say ''.succ.succ.succ.succ;
camelia rakudo-moar ab73b0: OUTPUT«␤»
AlexDaniel I'm not sure that this one is correct
BenGoldberg m: ''.pred.say 03:21
camelia rakudo-moar ab73b0: OUTPUT«Decrement out of range␤ in block <unit> at /tmp/kN7mqD7hDm:1␤␤Actually thrown at:␤ in block <unit> at /tmp/kN7mqD7hDm:1␤␤»
AlexDaniel but I can't say that it is incorrect…
I'm a bit worried that it might cause infinite loops
ShimmerFairy m: 'foo foo foo'.subst(/foo/, "bar", :nth(-2)).say;
camelia rakudo-moar ab73b0: OUTPUT«foo foo foo␤»
AlexDaniel since some code can expect that a string will be changing
BenGoldberg m: my $i = i; 'foo foo foo'.subst(/foo/, "bar", :nth($i)).say; 03:22
camelia rakudo-moar ab73b0: OUTPUT«Earlier failures:␤ Can not convert 0+1i to Real: imaginary part not zero␤ in block <unit> at /tmp/hMtcNLxfpk:1␤␤Final error:␤ Cannot call Real(Failure: ); none of these signatures match:␤ (Mu:U \v: *%_)␤ in block <unit> at /tmp/hMtcNLxfp…»
AlexDaniel ha! That's a good one
I've not tried that anywhere
BenGoldberg . o O (please replace the (0+i)th occurance of /foo/ with "bar" --> totally funny) 03:24
03:25 cognominal left
AlexDaniel and I bet that there is a function somewhere that will actually attempt to do something like that 03:25
PerlJam weird 03:28
:nth($negative_number) should die 03:29
AlexDaniel m: say "x".indent: 9999999999999999999999999999999999999999999999 03:31
camelia rakudo-moar ab73b0: OUTPUT«repeat count > 1073741824 arbitrarily unsupported...␤ in block <unit> at /tmp/DyvYVeDRDt:1␤␤»
AlexDaniel oooh, riight! Let's add more digits!!!
ShimmerFairy PerlJam: yeah, I saw a check for it in Str.match , but I guess it's not getting caught?
AlexDaniel m: say "x".indent: 9999999999999999999999999999999999999999999999999999999999999999999999999;
camelia rakudo-moar ab73b0: OUTPUT«repeat count (-1) cannot be negative␤ in block <unit> at /tmp/Tt_fkQcA_f:1␤␤»
03:32 gfldex left
AlexDaniel m: say 'xx'.chop(10) 03:36
camelia rakudo-moar ab73b0: OUTPUT«␤»
AlexDaniel m: say 'xx'.chop(9999999999999999999999999999999999999999999999999999999);
camelia rakudo-moar ab73b0: OUTPUT«xx␤»
PerlJam AlexDaniel: are you rakudobugging these if they're not already? 03:41
AlexDaniel PerlJam: most of it 03:42
PerlJam AlexDaniel++ 03:43
AlexDaniel PerlJam: I did not report :nth that should actually die, should I do that?
PerlJam probably
AlexDaniel PerlJam: can you point me to the relevant source code? 03:44
PerlJam For what exactly?
AlexDaniel the check for negative numbers in subst
PerlJam src/core/Str.pm line 606 is where the check is that should catch it IMHO 03:46
(though it's slightly erroneous in that the conditional is checking for < 1, but the fialure says "negative match". It forgets about 0)
03:47 lizmat joined
ShimmerFairy PerlJam: then it should talk about only allowing positive values :P 03:47
AlexDaniel PerlJam: thanks
ShimmerFairy (since :0th doesn't mean anything with the :st/:nd/:rd/:th adverbs) 03:48
03:51 kaare_ left 03:53 tinyblak left, BenGoldberg left 03:55 inokenty left 04:06 aborazmeh joined, aborazmeh left, aborazmeh joined
AlexDaniel m: say chr 999999999999999999999999999; 04:10
camelia rakudo-moar ab73b0: OUTPUT«chr codepoint cannot be negative␤ in block <unit> at /tmp/TVBVh1Yy8e:1␤␤»
labster AlexDaniel: quit finding integer overflow errors, you're making us look bad :P 04:17
AlexDaniel I'm making us look good
I bet that today or tomorrow someone will pick these tickets 04:18
labster Yeah, they're pretty obvious. And great test candidates.
AlexDaniel I keep thinking though 04:19
WHY AM I THE FIRST ONE TO TRY ALL THAT STUFF?
but yeah, it happens :)
labster :T in signatures is dead right, and :U refers to a type object (not undefined) now?
AlexDaniel no idea 04:20
labster You're the first one to to try it because the domain of a programming language is huge, and we're just trying to get correct stuff to work right.
ShimmerFairy labster: yeah, :U and :D have had a type object/object instance distinction for a long time now 04:21
labster: the only spec'd difference was that Int:U would accept Failures and Int:T wouldn't, but the Failure type (at least nowadays) would never pass an 'Int' constraint regardless of the smiley. Which meant :T was NYI and redundant. 04:22
AlexDaniel m: say Inf.base(16); 04:23
camelia rakudo-moar ab73b0: OUTPUT«Type check failed in assignment to '$int_part'; expected 'Int' but got 'Failure'␤ in block <unit> at /tmp/6tEXSrGnv0:1␤␤»
labster Oh good, RT#114442 is closable. "<jnthn> I'm hoping if I ignore the spec change enough it may change back :P" jnthn++ 04:24
synbot6 Link: rt.perl.org/rt3/Public/Bug/Display...?id=114442
AlexDaniel that's the weirdest error message
expected Int but got Failure :D 04:25
sounds like Inf is a Failure
labster Yeah, it's erroring in an assignment which you're not doing... LTA error for sure. 04:27
AlexDaniel yup
labster m: my Int $int_part = (Inf).Int; 04:29
camelia rakudo-moar ab73b0: OUTPUT«Type check failed in assignment to '$int_part'; expected 'Int' but got 'Failure'␤ in block <unit> at /tmp/smW6yhbeTR:1␤␤»
labster What should that return, anyway? Failure or Inf? 04:34
AlexDaniel valid hex number or failure 04:35
Inf does not sound like a hex number
ShimmerFairy labster: Inf and NaN have been an interesting thorn in our numerics for a long time
labster: for now at least, Failure is the better choice. 04:36
labster Inf is a decimal number, isn't it?
ShimmerFairy m: say Inf.WHAT; say NaN.WHAT
camelia rakudo-moar ab73b0: OUTPUT«(Num)␤(Num)␤»
ShimmerFairy They're (Num)s, but since Int !~~ Num, they can't be used with Ints. 04:37
And you can't coerce them to Ints either, since there's nothing Int-y to coerce them to.
labster m: 1.05.base(16).say 04:38
ShimmerFairy m: 1.05.base(16).say 04:39
camelia rakudo-moar ab73b0: OUTPUT«1.0CCCCD␤»
AlexDaniel huh?
ShimmerFairy labster accidentally typed an italic formatting code in front of the m:
labster well, accidentally copied. 04:40
AlexDaniel m: say 9e-99.base(10).say 04:41
camelia rakudo-moar ab73b0: OUTPUT«0.00000000␤True␤»
AlexDaniel oops 04:42
but yea, it is a little bit weird
04:44 aborazmeh left
labster m: 9e-99.base(10, 100).say 04:44
camelia rakudo-moar ab73b0: OUTPUT«0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000090␤»
AlexDaniel m: say 255.base(16, -100); 04:49
camelia rakudo-moar ab73b0: OUTPUT«FF.␤»
AlexDaniel From the docs: “The optional $digits argument asks for that many digits of fraction (which may not be negative).”
m: say 255.base(16, 99999999999999999999999999999999999999999999999999999999999999999999999999999); 04:50
camelia rakudo-moar ab73b0: OUTPUT«repeat count (-1) cannot be negative␤ in block <unit> at /tmp/XnmR6Ud6gb:1␤␤»
04:51 khw left
AlexDaniel ok, enough for today 05:01
05:02 llfourn joined 05:06 llfourn left, cognominal joined
labster AlexDaniel's 9-9-9 plan for Perl 6. 05:06
05:07 baest joined
AlexDaniel 1999--14035828--4570789517646521952 plan 05:07
05:09 baest_ left
AlexDaniel m: say <a b c d e>.roll(-999999999999999999999999999999999999999999999999999999).perl; 05:16
camelia rakudo-moar ab73b0: OUTPUT«(timeout)»
AlexDaniel m: say <a b c d e>.roll(-999999999999999999999999999999999999999999999999999999999999999999999999999999).perl;
camelia rakudo-moar ab73b0: OUTPUT«("c",)␤»
lizmat m: use nqp; say nqp::unbox_i(-99999999999999999999999999999999999999999999999999999999999999999) # the underlying issue to all these tickets 05:24
camelia rakudo-moar ab73b0: OUTPUT«1␤»
lizmat if we get nqp::unbox_i to complain about this in a sensible way, all of these tickets can be closed
AlexDaniel sounds very promising 05:28
good night
05:32 breinbaas left 05:36 rurban joined 05:40 jack_rabbit joined 05:44 dayangkun joined 05:53 AlexDaniel left 06:04 domidumont joined 06:09 domidumont left, domidumont joined
dalek kudo/glr: 1c63a75 | PerlJam++ | src/core/List.pm:
Utilize is-lazy
 06:10
kudo/glr: 2ba1973 | PerlJam++ | src/core/List.pm:
Make List.rotate work again
06:26 tinyblak joined 06:29 RabidGravy joined 06:33 bin_005 left
RabidGravy marning! 06:33
06:37 cognominal left 06:46 skids left 06:49 skids joined 06:50 skids left 07:01 rurban left 07:03 llfourn joined 07:06 brrt joined 07:08 llfourn left 07:15 rurban joined 07:16 virtualsue joined, rurban_ joined 07:20 TEttinger left 07:21 rindolf joined
brrt good morning again 07:25
RabidGravy erp 07:27
07:34 breinbaas joined
[Tux] test 50000 44.301 44.209 07:51
test-t 50000 43.254 43.163
[Tux] did not expect any speedup with all tuits flowing into GLR 07:52
hmm, that could be read both ways. it actually is slower than yesterday 07:53
RabidGravy :) 08:00
_itz_ I did see a slight apparent speed up with a script just using scalars on glr branch (maybe 1 s off a ~12s test) 08:09
maybe because less code is running with sections commented out however 08:10
08:11 rindolf left 08:15 darutoko joined
nine |Tux|: have you tried it on the GLR? 08:50
_itz_ ^ clarification to above - I meant commented out sections in rakudo not my simple script 08:52
nine |Tux|: since Inline::Perl5 already works (at least its glr branch), maybe your test will too :)
RabidGravy adds a paragraph to a README to get over the Saturday commit hump ;-) 09:03
09:04 llfourn joined 09:08 llfourn left 09:12 rurban left 09:23 RabidGravy left, rurban_ left
[Tux] rakudobrew build glr? 09:36
and for the timeing, I do not need/use Inline::Perl5
jdv79 [Tux]: where are your tests? 09:38
09:41 itz joined, itz left 09:43 dayangkun left 09:45 FROGGS_ joined 09:48 FROGGS left 09:58 espadrine joined 09:59 rindolf joined 10:01 domidumont left
jnthn "Oh look, if I give a function a stupid value something stupid happens!" <loads of checks added> "Hey, why is Rakudo slow???" 10:05
I suspect putting the check in unbox_i will be the cheapest place, though, since it already has the fast-path for smaller values, so it's only when there's something stored in a real bigint that you need to do the extra checking. 10:06
10:08 llfourn joined 10:11 brrt left 10:12 llfourn left 10:13 llfourn joined
jdv79 whats the alternative to hardening the surfaces? 10:14
jnthn jdv79: "Garbage In, Garbage Out"? :) 10:15
I'm all for good errors and checks on things people run into
jdv79 so p6bwill be like C?
haha
ShimmerFairy jnthn: it would be sufficient to check if the number of the limbs is greater than can be stored, wouldn't it? (at least on moar)
jnthn But if you find a string of things and say "How come nobody noticed this in years?" it's because you're observing something that doesn't actually happen.
In normal code. 10:16
jdv79 ok
10:16 tinyblak left
jdv79 more like hasnt happened yet:) 10:17
10:22 orafu left
nine Well chances of the examples happening in real world code are rather slimm I'd guess 10:22
jnthn nine: Yes, my feeling exactly 10:23
ShimmerFairy I think bigint -> int overflow is worth protecting against, but in general I agree with the principle of "Well, what were you expecting would happen?" :)
jdv79 yeah. seems all minor.
ShimmerFairy (aka GIGO)
jnthn ShimmerFairy: Yeah, I think we can protect against that, but I don't want to see extra checks scattered through all the functions in question. 10:24
jdv79 any clue as to when real world code can try the glrized rakudo? 10:26
nine depends on the code
ShimmerFairy jnthn: of course not. I for example only put in a check against against overflow-related issues when nqp::mul_n(0, nqp::pow_n($base, $exp)) could result in 0 * Inf -> NaN .
jdv79 ok 10:28
10:28 tinyblak joined
dalek kudo/glr: ad13342 | jnthn++ | src/core/Seq.pm:
AT-POS and EXISTS-POS on Seq delegate to .list.

We may tighten the exact semantics of this at some point, but for now this is close enough. Makes it so you can do things like .words[1], which is hugely common. Note that obtaining the memoized list counts as doing the one-shot iteration of the Seq.		 10:29
10:29 breinbaas left
jnthn ShimmerFairy: On the ** one, the deep problem is that both Moar and JVM's bigint library can only cope with a 32-bit (or maybe 64-bit) exponent 10:29
Probably because you can't ever have enough memory to store anything other than 1 ** [huge huge thing] :) 10:30
m: say (2 ** 10000).chars 10:31
camelia rakudo-moar ab73b0: OUTPUT«3011␤»
jnthn m: say (2 ** 100000).chars
camelia rakudo-moar ab73b0: OUTPUT«30103␤»
jnthn m: say (2 ** 1000000000).chars
10:31 pmurias joined
dalek p/js: 43700ac | (Pawel Murias)++ | src/vm/js/ (3 files):
Implement nqp::knowhow()
 10:31
nqp/js: eaf6114 | (Pawel Murias)++ | src/vm/js/nqp-runtime/bootstrap.js:
nqp/js: Add a new_type method to knowhows
10:31 dalek left
camelia rakudo-moar ab73b0: OUTPUT«(timeout)» 10:31
jnthn Well, maybe that one was a little ambitious :)
m: say (2 ** 10000000).chars 10:32
10:32 dalek joined, ChanServ sets mode: +v dalek
camelia rakudo-moar ab73b0: OUTPUT«(timeout)» 10:32
jnthn Even that one :)
m: say <0x01/0x03> / (0x01/0x03) == 1 10:33
camelia rakudo-moar ab73b0: OUTPUT«True␤»
jnthn How on earth has glr busted *that*...
m: say <0x01/0x03>; say (0x01/0x03); 10:34
camelia rakudo-moar ab73b0: OUTPUT«0.333333␤0.333333␤»
jnthn Hm, it's the first one that fails
m: say <0x01/0x03>.nude 10:35
camelia rakudo-moar ab73b0: OUTPUT«1 3␤»
pmurias jnthn: re checking for stupid values, having them cause weird things to happen silently makes debugging harder
timotimo error: cowardly refusing to allocate 5tb of nulled memory to store the result of this operation" 10:38
ShimmerFairy jnthn: sure, I don't blame the implementation for saying "eh, it's practically infinity, right?", I just had to correct for the fact that 0 * anything should for sanity always return 0 (esp. when you can't write 'Inf' in a numeric literal :P) 10:40
nine Huh? I though I fixed the hangs in S03-operators/assign.t? 10:47
dalek kudo/glr: 295e65d | jnthn++ | src/core/List.pm:
Remove XXX GLR comments on completed things.
 10:48
nine Oh, I'm in the wrong roast branch on this machine 10:51
jdv79: oh, real world code may benefit immensely from having panda work again before testing. 10:52
jnthn nine: Is all Inline::Perl5 working again on glr? :) 10:53
nine jnthn: well, excluding one test file that's failing because I can't install File::Temp, yes :)
jnthn Nice :) 10:55
I don't see how the failure in numeric.t that I have is related to glr at all
But I see that test is marked as bust on JVM too
And I'm wondering if it works on some platforms only
'cus now I think about it, I had a Windows failure in numeric.t for a while 10:56
nine Maybe the glr just uncovered the fail on moar?
jnthn No, I think it just confused me into spending time hunting a bug that was only there on some platforms, including mine :)
nine jnthn: both t/spec/S02-literals/numeric.t and t/spec/S32-str/numeric.rakudo.moar pass for me on glr 10:57
jnthn nine: OK, then it's not glr at all, but a platform-o :) 10:59
nine That's...intriguing. Str.trans hangs in $!first_substitution //= @!substitutions[0]; in LSM::next_substitution 11:09
jnthn Curious... 11:10
nine @!substitutions[0] seems to be a Pair, just like it should
Oh, no. It doesn't hang there, it's just that warn $!first_substitution afterwards would hang. Smells like another self referencing data structure. 11:11
11:12 gfldex joined
dalek kudo/glr: 8fe549c | jnthn++ | src/core/Array.pm:
Mostly re-instate typed Array support.

Toss no-longer-needed specialized AT-POS along the way.		 11:15
kudo/glr: 6ae42ca | jnthn++ | src/Perl6/Actions.nqp:
Make <0x01/0x03> work reliably across platforms.

Fixes it on Windows, and probably on JVM too.
nine Oh, yes, there's our little self referencer: @to = @to, $padding xx @from - @to; 11:16
jnthn Odd 11:17
huh 11:18
ShimmerFairy So if you wanted to do something silly like @a = @a, @a , would you have to call clone on the assigned @a vars in GLR? (and could @a = @b suffer from similar problems?)
nine @to = flat @to, $padding xx $from - @to; works better
jnthn Darn, the @a = 1, @a; case wasn't covered in my tests in glr.p6 11:19
@a = @a was, along with @a = @a.map(...)
nine: I think the flat is actually needed there also 11:20
11:20 dayangkun joined
jnthn The reason taht kind of things worked before now is exactly because we flattened automatically there 11:22
I think it's quite clear that option isn't available to us
(implicitly, I mean)
Oh, it's worse
TimToady even was thinking about @a = 1, @a; or similar being a way to get an array of all 1s 11:23
That won't work at least without adding a slip for lazy somewhere, I suspect
ShimmerFairy could a self-referential assignment be detected, and possibly be made lazy?
jnthn But yeah, with that working in mind I even explicitly made sure you get into circular references there 11:24
dalek kudo/glr: 940c99b | (Stefan Seifert)++ | src/core/Str.pm:
Fix hang in Str.trans caused by self referencing array
ShimmerFairy or perhaps not all self-referential assignments, but at least the ones that make for a circular list (i.e. @a = foo, bar, ..., @a) 11:25
jnthn ShimmerFairy: It guess that one could be detected in STORE
I'm not sure that lazy fixes it
And further, @a = 1, @a; magically becoming @a = 1, lazy @a; suddenly gives you an @a that is lazy, so you could no longer push to it, for example 11:26
ShimmerFairy Hm, now that I'm thinking about it, maybe an ability to make circular lists would be helpful for things like 1 xx Inf (unless Seq already takes care of that) 11:27
nine Huh? There's suddenly a hang in S02-types/array-shapes.rakudo.moar
That wasn't there before
May be because of the new typed array support
l 11:28
jnthn maybe, yes
It was crashing before I think 11:29
urgh, I think the next blocker I really need to take on is the for %h.kv -> $k, $v { ... } bustage
On @a = 1, @a; maybe it should just be an error 11:30
"Probable unintended assignment of array into an element of itself; consider using |@a or flat" 11:31
TimToady and company now in Kyoto 11:32
jnthn \o/
TimToady: Hope the journey was fine :)
TimToady kinda bumpy from SEA to YVR, but otherwise uneventful
nine jnthn: this is what hangs: use Test; my int @arr = 1, 2, 3; is @arr, <1 2 3>; 11:33
jnthn nine: ah
nine: Half of native array code is still commented out, I think :)
nine looks like :)
So, afk now. Weekend at my parents'. 11:34
jnthn Have fun
nine++ # glr hacking 11:35
dalek kudo/glr: b5dc2c5 | jnthn++ | src/core/Array.pm:
Fix my @a = $thing (used to bind by accident).
 11:42
11:43 beastd left 11:45 isBEKaml joined
jnthn Damn, the meta-ops are going to need a good looking at 11:53
They went out of their way to work against the previous list implementation, leaving a good bit to untangle 11:54
isBEKaml jnthn: the GLR?
jnthn aye
[Tux] jdv github.com/Tux/CSV
jdv79, github.com/Tux/CSV
make time
isBEKaml jnthn: Oh.. weren't they caught by tests? 11:55
jnthn isBEKaml: Very caught by the tests
11:55 dayangkun left
jnthn (glr branch has 200 failing test files or so at present) 11:55
isBEKaml doesn't know if we should be relieved or worried 11:56
11:57 cognominal joined
jnthn Relieved that it's not more. 11:58
isBEKaml jnthn++ # keepin' it real 11:59
ShimmerFairy I think people not working on glr should only really be concerned about the tests if we were failing more than existed :P 12:01
12:02 tinyblak left 12:12 dalek left 12:13 dalek joined, ChanServ sets mode: +v dalek 12:17 dalek left, dalek joined, ChanServ sets mode: +v dalek
isBEKaml ShimmerFairy: fair enough :-) 12:18
dalek kudo/glr: 3526378 | jnthn++ | src/core/Any-iterable-methods.pm:
Fix map with > 1 arg closure.
 12:27
jnthn That should unbust another good number of things :)
Going to lunch, relax, etc. & 12:29
jdv79 [Tux]: ah. its Text::CSV. cool. 12:31
12:37 dalek left 12:38 dalek joined, ChanServ sets mode: +v dalek
dalek kudo-star-daily: a6da8d3 | coke++ | log/MoarVM- (4 files):
today (automated commit)
 12:38
rl6-roast-data: 65970cd | coke++ | / (8 files):
today (automated commit)
12:42 [Sno] joined 12:49 dalek left 12:50 dalek joined, ChanServ sets mode: +v dalek 12:56 AlexDaniel joined 12:57 cognominal left
AlexDaniel jnthn: well, feel free to close some of these tickets 13:00
however, number ** hugenumber = 0 is a math problem…
[Coke] my connection to p6c keeps dropping. wonder how to diagnose that. 13:01
AlexDaniel and a couple of others are LTAs anyway, because you cannot say that the argument was negative when it actually wasn't 13:02
13:02 tinyblak joined
AlexDaniel at least it should mention possible overflow 13:02
13:06 cognominal joined 13:08 tinyblak left 13:12 rmgk left 13:13 rmgk joined 13:15 isBEKaml_ joined 13:16 mr_ron joined 13:17 tinyblak joined 13:18 isBEKaml left 13:20 smls joined
nine jnthn: thanks for fixing up my sequential-map implementation :) 13:20
13:21 isBEKaml_ is now known as isBEKaml
nine [Tux]: looks like there's still too much brokenness to get CSV benchmark results. But I'm sure we'll be getting there soon :) 13:21
13:21 espadrine left
[Coke] (seriously, I've been disconnected like 20 times and can only type a few characters each time before I get kicked. it took me 4 disconnects to type this line. *:( AIGH FIVE 13:23
13:26 mr_ron left
timotimo [Coke]: argh! 13:29
[Coke]: did you try ssh -v or -vv or -vvv or -vvvv or -vvvvv or -vvvvvv or -vvvvvvv or -vvvvvvvv? 13:30
m: .print for "-" >>~>> ("v" x 1..*) >>~>> ' or '
camelia rakudo-moar ab73b0: OUTPUT«List on right side of hyperop of infix:<~> is known to be infinite␤ in block <unit> at /tmp/XvT_yP5e5d:1␤␤»
timotimo oh, of course 13:31
m: .print for "-" >>~>> ("v" x 1..50) >>~>> ' or '
camelia rakudo-moar ab73b0: OUTPUT«Cannot find method 'Range'␤ in block <unit> at /tmp/FFO2zc4qGD:1␤␤»
timotimo m: .print for "-" >>~>> ("v" Zx 1..50) >>~>> ' or '
camelia rakudo-moar ab73b0: OUTPUT«-v or »
timotimo m: .print for "-" >>~>> ("v" Zx @(1..50)) >>~>> ' or '
camelia rakudo-moar ab73b0: OUTPUT«-v or »
[Coke] timotimo: -v gives lots of diagnostics on connect, but not on disconnect.
timotimo derp
[Coke] might be due to screen formatting wonkery
timotimo m: .print for "-" >>~>> ("v" Xx 1..50) >>~>> ' or '
camelia rakudo-moar ab73b0: OUTPUT«Lists on either side of non-dwimmy hyperop of infix:<~> are not of the same length␤left: 1 elements, right: 50 elements␤ in block <unit> at /tmp/oQjiUAbI8D:1␤␤»
timotimo m: .print for "-" <<~>> ("v" Xx 1..50) <<~>> ' or '
camelia rakudo-moar ab73b0: OUTPUT«-v or -vv or -vvv or -vvvv or -vvvvv or -vvvvvv or -vvvvvvv or -vvvvvvvv or -vvvvvvvvv or -vvvvvvvvvv or -vvvvvvvvvvv or -vvvvvvvvvvvv or -vvvvvvvvvvvvv or -vvvvvvvvvvvvvv or -vvvvvvvvvvvvvvv or -vvvvvvvvvvvvvvvv or -vvvvvvvvvvvvvvvvv or -vvvvvvvvvvvvvvvvv…»
timotimo that took me longer than i would have deemed appropriate for a perl6 "core developer" :S 13:32
[Coke] also, login seems to be taking longer and longer on hack.
13:35 aborazmeh joined, aborazmeh left, aborazmeh joined
bartolin_ [Coke]: I had no problems logging in to hack just now 13:36
timotimo i can connect and log in very quickly to hack, as well
[Coke] Probably my local wifi. 13:37
timotimo d'oh
lizmat .tell jnthn if nqp::unbox_i gets some overflow test/exception, I can remove as well some of the tests in functions I added recently
yoleaux lizmat: I'll pass your message to jnthn.
timotimo maybe we want to install the bad-connection-resistant ssh thingie
what was it called? mosh?
bartolin_ [Coke]: I don't see something unusual in sshd logs as well. so probably no problem on hack 13:39
[Coke] heh. you are the second person to mention mosh in relation to my issue here. :) 13:42
timotimo the thing about mosh is it needs cooperation from the server admins :| 13:43
AlexDaniel lizmat: good point 13:47
bartolin_ timotimo: hmm, I could connect to hack with mosh just fine. (have never used it before) 13:50
timotimo uh, huh? 13:51
perhaps mosh falls back to regular ssh if the server doesn't provide it? or perhaps it's installed on hack 13:52
bartolin_ yeah, it's installed.
timotimo coool
bartolin_ moritz++ 13:53
13:53 Peter_R joined 13:57 laben joined
laben hello p6'ers! 13:57
timotimo ohai laben 13:58
are you at all related to gaben? 13:59
laben you mean Gabe Newell? i wish! i would ask him a preview of HL3
timotimo hehe 14:00
laben so, i tracked down a build failure in 2 modules to an issue between precompilation and delegations, are you interested? 14:02
timotimo me? oof
how tight is the golf?
isBEKaml In other news, pugs seems to be back! github.com/perl6/Pugs.hs/pull/30 14:03
Sorry if you guys already know this 14:04
laben timotimo: you personally interested? sweet, i'm making a gist right now!
timotimo ugh 14:05
14:05 telex left
timotimo precompilation is really tough 14:05
my mood is kind of down in the dumps right now, not sure i'll be able to be productive at all
14:06 telex joined
laben here it is: gist.github.com/anonymous/f7d4c489df5fc5eecda3 14:07
from what i gathered myself, the issue is that delegate of delegate works fine when not precompiled, but crashes when precompiling FILE C.pm6 14:08
timotimo you know gist has multi-file support? :P
laben timotimo: sorry, did not know
14:09 MadcapJake joined
timotimo no worries :) 14:11
laben want me to create a new multi file gist? 14:12
timotimo no need
also, you can edit the gist and add files after the first submit 14:13
dalek p: 52b7ced | ShimmerFairy++ | src/HLL/Grammar.nqp:
Add support for Unicode hexints, octints, and binints.

This removes the range checks for octal and binary numbers, but as a bonus Perl 6 will now report a number like 0o78 as "'78' is not a valid number", instead of previously saying "Confused". The underlying radix conversion functions properly check digits against the radix anyway
  (which is how the "not a valid number" error now pops up).
p: 4e374ec | ShimmerFairy++ | src/HLL/Grammar.nqp:
Merge branch 'uninum'

Enable Unicode numeral support in NQP.
p: 733bf22 | ShimmerFairy++ | tools/build/MOAR_REVISION:
Bump MOAR_REVISION
lizmat .tell FROGGS re #125796, it looks like EOF is not set in the same way for an IO::Handle coming from open or from run :out
yoleaux lizmat: I'll pass your message to FROGGS.
synbot6 Link: rt.perl.org/rt3/Public/Bug/Display...?id=125796
dalek kudo/nom: 2a9ab2b | ShimmerFairy++ | t/spectest.data:
Add S15-literals tests to spectest.data
rakudo/nom: 0217016 | ShimmerFairy++ | src/Perl6/Grammar.nqp:
rakudo/nom: Add Unicode support to :radix[] style numbers.
14:13 dalek left 14:14 dalek joined, ChanServ sets mode: +v dalek
timotimo laben: do you have the commandline invocation you're using to show this error? 14:17
perl6 --target=mbc --outfile=B.moarvm B.pm6 # like this?
lizmat ShimmerFairy: does that mean an NQP_REVISION bump is immiment?
laben yea but remember '_i.'
-I. i meant
lizmat *imminent
ShimmerFairy lizmat: there was one, dalek just gave out before it could show it 14:18
timotimo ah, --output
lizmat ah, ok
lizmat pulls and rebuilds
timotimo laben: When pre-compiling a module, its dependencies must be pre-compiled first.
is this the error you're seeing?
14:18 khw joined
laben timotimo: ofc not, fisrt you precompile B.pm6 14:19
then when precompileing C.pm6 you get "Cannot invoke object..."
timotimo i'm failing here. 14:20
dalek ast: 9717b4f | ShimmerFairy++ | S15-literals/numbers.t:
Unfudge Unicode numbers tests for moar
laben timotimo: better now? gist.github.com/anonymous/89624af3959c7fb86c62
14:21 aborazmeh left
timotimo i tried perl6 --target=mbc --output=B.moarvm B.pm6 and then perl6 -I. --target=mbc --output=C.moarvm C.pm6 14:21
laben did it work? i get an error precompiling C.pm6, saying "SORRY Cannot invoke this object (REPR: Null, cs = 0)" 14:23
timotimo no
Please pre-compile /tmp/laben_gist/B.pm6
laben timotimo: ofc before i precompile B.pm6, that gives me no error 14:24
timotimo: btw i confirmed that not precompiling, everything works fine
timotimo wait, you mean you don't precompile B?
laben timotimo: no, i do precompile B then C, it's C which gives me error 14:25
timotimo i can precompile B, then run C without problems 14:26
laben timotimo: if you want i can gist the --ll-exception output, maybe it's more useful for you: gist.github.com/anonymous/35df72696ef1aa6d79a8 14:27
ugexe sounds like he is using old precompiled code
laben no, i rm'ed it every time
timotimo but i just deleted the .moarvm file
ugexe means me 14:28
laben C needs to be precomp'ed since it's a module which i then call from code
it's somewhat golfed down from Flower and Template6 14:29
i can confirm that if i dont precompile, everything works
14:29 isBEKaml left
laben that's why i thought it to be a precomp bug 14:30
timotimo right
i'm just apparently incompetent when it comes to precompiling modules
laben i use $ perl6 -I. --target=mbc --output=B.pm6.moarvm B.pm6 14:31
ugexe sometimes such problems can be solved by putting say, class A, in A.pm6. not the ideal solution, but sometimes you dont care
laben ugexe: it was originally like that, doesn't change anything
timotimo that's what i did, too :(
laben it is skipped if i put everything in C.pm6 14:32
but while it's possible with golfed code, it is not with real code
ugexe what do you see when you do RAKUDO_MODULE_DEBUG=1 perl6 whatever 14:33
that might show you if the module is at least being loaded
laben gist.github.com/anonymous/c4823f4c34688fbf2f19 14:35
ugexe ah i missed the --ll-exception bit. 14:36
laben ugexe: i put it in anyway
ugexe are you looking for a workaround, or trying to figure out why 14:38
laben figure out why and fix it, seem quite the bug 14:39
unfortunately i was not able to debug the issue easily
dont know much of the internals
ugexe indeed. i used to get similar bugs using roles applied at runtime (to do the same thing) but they went away 14:40
dalek kudo/glr: 2a9ab2b | ShimmerFairy++ | t/spectest.data:
Add S15-literals tests to spectest.data
rakudo/glr: 0217016 | ShimmerFairy++ | src/Perl6/Grammar.nqp:
rakudo/glr: Add Unicode support to :radix[] style numbers.
14:40 dalek left
laben that is also why i gave up the direct debug approach and went with the reproduce the issue with reduced code way 14:40
14:41 dalek joined, ChanServ sets mode: +v dalek
ugexe the internals are much easier to work on than you may think. in fact they must be if i have looked at it 14:41
laben ugexe: maybe but now i am faced with precomp and i dont even know where to start
ugexe thats where i started too i think. my first thing was adding a bunch of debug statements in ModuleLoader.nqp or something 14:42
that was before RAKUDO_MODULE_DEBUG but still 14:43
lizmat FWIW, I just merged nom into glr again: spectest failures now: gist.github.com/lizmat/33cf14b669293742c319
there are still about 10 test-files that are hanging
ugexe timotimo: an alternative to the pr for json_fast is adding JSON::Tiny to test-depends 14:47
14:47 skids joined
dalek p/js: f97b5e9 | (Pawel Murias)++ | src/vm/js/ (2 files):
Pass test 72.

Set WHAT on STables when creating type objects.		 14:50
skids Oh yay typed arrays unlock a lot in GLR. 14:51
I was playing with them last night but got hung up on the mystery of why $!descriptor isn't set during the call to STORE in Array[Int].new 14:53
timotimo ugexe: i didn't even see that pull request!
lizmat $ 6 'my $a = "foo bar baz".words; say $a[2,1,0]; say $a[2,1,0]' 14:54
baz bar foo
14:54 tinyblak left
lizmat feels to me the second one should fail because of fetching the iterator for the second time ? 14:54
skids Isn't the assignment supposed to memoize? 14:55
dalek ast/glr: 4fabc1e | hoelzro++ | S26-documentation/why- (3 files):
Fix S26 WHY tests for GLR
 14:56
timotimo without glr i also get the error laben sees
hoelzro morning #perl6 14:58
ugexe i havent noticed any precompiling problems specific to glr yet
would there be much of any difference between a FatPacked p5 module vs a custom CURLI? 15:00
lizmat in the future there would be, I think, because of things like %?RESOURCES 15:01
the FatPacked module wouldn't have that, I would tihnk 15:02
15:02 [TuxCM] joined
lizmat is too tired to get into the zone and decides to call it a day 15:02
jnthn Please don't merge nom into glr 15:03
yoleaux 13:37Z <lizmat> jnthn: if nqp::unbox_i gets some overflow test/exception, I can remove as well some of the tests in functions I added recently
rjbs you think you're tired? my brain just decided that "The zone" meant "the zone of alienation"
jnthn Until we're about done
Otherwise we have to keep merging spectest branch too
lizmat jnthn: ok, will refrain from now on
jnthn lizmat: It's the AT-POS that memoizes
timotimo did anybody try json_fast with glr yet?
jnthn lizmat: Otherwise .[0, 1] would fail also :)
lizmat yeah, was wondering about that 15:04
ugexe timotimo: yes
jnthn lizmat: Though I did that mostly as the expedient thing...
We could of course try to do something cleverer...
ugexe 1 failure in test 2, but is fixed by doing [{}] to [{},] in a string, and test 4 hangs
lizmat I think we would be best served with a specific postcircumfix [] handler for Seq
ugexe BUT from-json works on META files (package managers)
the core from-json in glr does not 15:05
timotimo neato. did you compare speeds?
ugexe nothing to compare it to. i think its the only one that works in glr right now
lizmat jnthn:
$ 6 '"words".IO.lines.elems.say'
235886
real0m1.870s
jnthn lizmat: We could go that way also, but it's maybe not going to be too easy to write
timotimo you could compare it to pre-glr ;)
lizmat $ 6 '"words".IO.lines(:eager).elems.say'
235886
real0m0.851s
so how would we get the .elems force the :eager in .lines ? 15:06
jnthn How do those compare to nom? :)
We don't do it that way
We toss the :eager candidates
lizmat lemme compare nom 15:07
15:07 brrt joined
jnthn And change things to use more appropriate constructs :) 15:07
ugexe true... i have one to-json that is particularly slow
that would be a good benchmark
jnthn For example, we have lazy loops now, not to mention you can just implement the iterator API directly if you really have Need For Speed.
skids $ ./perl6-m -e 'Array[Int].new(1,"a").say' # GLR (the $!descriptor mystery remains) 15:08
1 a
lizmat jnthn: well, I'm not seeing that yet :-(
then again, I'm pretty tired 15:09
skids I spent like an hour trying to figure out what actually initializes $!descriptor and still can't :-)
lizmat jnthn: I just merged nom, should I merge master in roast as well to get them in sync ?
(and then stop merging? :-)
jnthn lizmat: Yeah, please
15:10 TEttinger joined
jnthn skids: Compiler guts 15:10
dalek ast/glr: 17d9681 | usev6++ | S02-types/range.t:
Make test for RT #125791 pass on JVM
ast/glr: bbe6a8c | FROGGS++ | S04-declarations/implicit-parameter.t:
add tests for RT #125767, { .sqrt => .sqrt }
synbot6 Link: rt.perl.org/rt3/Public/Bug/Display...?id=125791
Link: rt.perl.org/rt3/Public/Bug/Display...?id=125767
ast/glr: 9717b4f | ShimmerFairy++ | S15-literals/numbers.t:
Unfudge Unicode numbers tests for moar
ast/glr: 40d5917 | lizmat++ | S (3 files):
Merge branch 'master' into glr
jnthn skids: But note the typed array new is still commented out
15:10 [TuxCM] left
lizmat nom with words counr: 0.952s / 2.764s 15:11
on glr it's now 0.851s / 1.870s 15:12
jnthn Nice. Improvement before we even changed words/lines to take advantage of GLR things. :) 15:13
lizmat yup
even the eager one :-)
jnthn At the point I'd like to focus on getting things working again, and then we can go optimizing. :)
lizmat ok 15:14
15:14 zakharyas joined
jnthn But I suspect we can squeeze a good bit more out on that benchmark :) 15:14
lizmat so, you were serious about just tossing the :eager candidates... the code in there is basically no god in the GLR ?
*good
jnthn lizmat: Well, you don't have to immediately toss it, but basically the new iterator API has a mechanism for conveying (transitively) "we want all the things" 15:15
15:15 [TuxCM] joined
jnthn my @a = $foo.words; # conveys exactly that 15:15
lizmat ok, so lines returns a Seq, the .elems on it says "give me all" 15:16
jnthn Right
So at that point it knows it can go faster
lizmat needs to look at iterators more at some point
15:16 [TuxCM] left, xinming joined
lizmat ok, gotcha 15:16
jnthn Additionally, in:
my @a = $foo.words;
It actually works such that it passes the slot array of @a down the iterator chain 15:17
So .words doesn't have to produce a bunch of things to store into the array
Instead, the things in produces can be shoved (via creating a Scalar container) directly into place.
Which gets rid of a good bunch of copying we've done in the past. 15:18
lizmat that is a good thing :-)
jnthn src/core/Iterator.pm has the API and explanations of the different parts, btw 15:19
So it's a good place to start reading
lizmat in any case, it's good to see glr bare startup is around 100 msecs again, wheres nom is at 112 msecs 15:21
jnthn yeah, I thought we'd shaved a bit off there too :) 15:22
15:26 MilkmanDan left, MilkmanDan joined
jnthn bbl & 15:26
15:31 rurban joined 15:57 raiph joined
AlexDaniel m: my @a = 1, 5, -7, 2; say @a.sin; 16:01
camelia rakudo-moar 44e3b4: OUTPUT«-0.756802495307928␤»
AlexDaniel this is so Cool!
not sure why would anybody need that though 16:03
cognominal what the sin of an array is supposed to mean? 16:04
laben probably the array of sin of each element
a la MAtlab 16:05
AlexDaniel I kinda like the way it works now
just because of the consistency 16:06
laben m: my @a = 1, 5, -7, 2; say @a.map(&sin)
camelia rakudo-moar 44e3b4: OUTPUT«0.841470984807897 -0.958924274663138 -0.656986598718789 0.909297426825682␤»
laben wait where did your result ocme from?
come*
-0.75 isnt in any of these 16:07
cognominal say 4.sin
m: say 4.sin
camelia rakudo-moar 44e3b4: OUTPUT«-0.756802495307928␤»
laben ah it took the sin of elems
AlexDaniel sure
cognominal does not make any sense to me 16:08
timotimo huh?
laben coerced @a to Num then did sin?
timotimo oh
right, that's what it does 16:09
laben seems a bit strange though, i agree
cognominal yes, this is what Perl 6 is supposed to do but I would expect something different in that case.
AlexDaniel cognominal: like? 16:10
laben will List inherit from Cool after glr?
cognominal like returning an array of sin as said earlier.
laben i would prefer if it gave me warning or error and required .map(&sin) to do that, but maybe that's too strict 16:11
AlexDaniel to save 4 characters because of map: ?
map is short and explicit, so I don't see any problem
you might say that there is more than one way to do it, yeah, there is more than one way to break consistency, I guess 16:12
cognominal say (1, 5, -7, 5)>>.sin;
m: say (1, 5, -7, 5)>>.sin;
camelia rakudo-moar 44e3b4: OUTPUT«0.841470984807897 -0.958924274663138 -0.656986598718789 -0.958924274663138␤»
AlexDaniel but if that is done, then every method from Cool should be overriden
ugexe you lose order
AlexDaniel ugexe: order? 16:13
cognominal indeed
ugexe m: my @a = 1,2,3; @a>>.say
camelia rakudo-moar 44e3b4: OUTPUT«3␤1␤2␤»
AlexDaniel ugexe: I thought that it is free to execute it in any order as long as the resulted list is composed in the original order 16:14
laben AlexDaniel: if you need order, use .map
AlexDaniel ugexe: your example is not equivalent
laben m: my @a = 1,2,3; @a.map(&say);
camelia rakudo-moar 44e3b4: OUTPUT«1␤2␤3␤»
AlexDaniel ugexe: because say is part of the execution
ugexe afaik >> forces the results to *not* be in order so that people wont assume thats what it does 16:16
AlexDaniel m: say (1, 2, 3, 4, 5, 6)>>.sin;
camelia rakudo-moar 44e3b4: OUTPUT«0.841470984807897 0.909297426825682 0.141120008059867 -0.756802495307928 -0.958924274663138 -0.279415498198926␤»
AlexDaniel m: say (1, 2, 3, 4, 5, 6).map(&sin)
camelia rakudo-moar 44e3b4: OUTPUT«0.841470984807897 0.909297426825682 0.141120008059867 -0.756802495307928 -0.958924274663138 -0.279415498198926␤»
AlexDaniel what forcing are you talking about?
the resulted list is still in order 16:17
I don't get it
laben m: my @a=1,2,3; say @a>>.++
camelia rakudo-moar 44e3b4: OUTPUT«1 2 3␤»
laben m: my @a=1,2,3; say @a>>+=1 16:18
camelia rakudo-moar 44e3b4: OUTPUT«5===SORRY!5=== Error while compiling /tmp/8HFDg8uznl␤Malformed postfix␤at /tmp/8HFDg8uznl:1␤------> 3my @a=1,2,3; say @a>>7⏏5+=1␤ expecting any of:␤ postfix␤»
laben m: my @a=1,2,3; say @a>>{*++}
camelia rakudo-moar 44e3b4: OUTPUT«postcircumfix:<{ }> not defined for type Int␤ in block <unit> at /tmp/hwoVv4jb8d:1␤␤Actually thrown at:␤ in block <unit> at /tmp/hwoVv4jb8d:1␤␤»
laben m: my @a=1,2,3; say @a>>{*+=1}
camelia rakudo-moar 44e3b4: OUTPUT«postcircumfix:<{ }> not defined for type Int␤ in block <unit> at /tmp/Sqrfz0GpJ0:1␤␤Actually thrown at:␤ in block <unit> at /tmp/Sqrfz0GpJ0:1␤␤»
laben m: my @a=1,2,3; say @a.map(&++);
camelia rakudo-moar 44e3b4: OUTPUT«Type check failed in assignment to '&'; expected 'Callable' but got 'Int'␤ in block <unit> at /tmp/V_8jh4fbp1:1␤␤»
laben m: my @a=1,2,3; say @a.map({.++}) 16:19
camelia rakudo-moar 44e3b4: OUTPUT«1 2 3␤»
laben m: my @a=1,2,3; say @a.map({*+=1})
camelia rakudo-moar 44e3b4: OUTPUT«5===SORRY!5=== Error while compiling /tmp/EjmWxxi82f␤Malformed double closure; WhateverCode is already a closure without curlies, so either remove the curlies or use valid parameter syntax instead of *␤at /tmp/EjmWxxi82f:1␤------> 3my @a=1,2,3; …»
laben m: my @a=1,2,3; say @a.map(*+=1) 16:20
camelia rakudo-moar 44e3b4: OUTPUT«2 3 4␤»
laben m: my @a=1,2,3; say @a>>*+=1
camelia rakudo-moar 44e3b4: OUTPUT«5===SORRY!5=== Error while compiling /tmp/U5w3dkqVqJ␤Malformed postfix␤at /tmp/U5w3dkqVqJ:1␤------> 3my @a=1,2,3; say @a>>7⏏5*+=1␤ expecting any of:␤ postfix␤»
laben m: my @a=1,2,3; say @a>>({*+=1})
camelia rakudo-moar 44e3b4: OUTPUT«5===SORRY!5=== Error while compiling /tmp/qcnfmKXKPD␤Malformed double closure; WhateverCode is already a closure without curlies, so either remove the curlies or use valid parameter syntax instead of *␤at /tmp/qcnfmKXKPD:1␤------> 3my @a=1,2,3; …»
laben m: my @a=1,2,3; say @a>>(*+=1)
camelia rakudo-moar 44e3b4: OUTPUT«Too many positionals passed; expected 1 argument but got 2␤ in block <unit> at /tmp/QK3LX4b8Ne:1␤␤»
laben ok i give up, im not gonna use >>
AlexDaniel So, can anybody confirm my thoughts about >> ? 16:21
or maybe I'm wrong
laben m: my @a=1.1,2.2,3.3,4.4,5.5; say @a>>.floor 16:24
camelia rakudo-moar 44e3b4: OUTPUT«1 2 3 4 5␤»
laben m: my @a=1.1,2.2,3.3,4.4,5.5; @a>>.floor.say
camelia rakudo-moar 44e3b4: OUTPUT«1 2 3 4 5␤»
skids Hrm. The hang (as opposed to expected NYI failure) in S02-types/array-shapes is an infinite recursion between array.list and Any.join.
laben AlexDaniel: i dont know enough to tell you, sorry
16:24 brrt left
skids But removing array's .list method does not fix it even though it does not seem to inherit from List. 16:25
And yet, Array inherits from List, and Array.list ~~ Array, but it does not ae the problem.
laben skids: doesnt .list come from Any? 16:26
skids List has a method .list
(In GLR)
laben ah you speak of glr, sorry man, im not that brave yet 16:27
skids OIC. List has its own .join too. 16:29
Thought I was going crazy. 16:30
jnthn The key thing about @a>>.foo is that it gives you back the results ordered relative to the inputs, but it may call .foo on multiple threads and so any side-effects may execute out of order or in parallel. 16:31
Generally, you should not use >>.foo if foo has side-effects
16:33 rurban left 16:41 TEttinger left
laben .tell grondilu the sha256 function hangs in test sha.t of your Digest module, can you check it please? 16:41
yoleaux laben: I'll pass your message to grondilu.
16:56 pmurias left
japhb *yawn* 17:00
Good morning, #perl6
japhb has been up for a while, but just now feeling like hacking 17:01
17:08 domidumont joined, domidumont left
jnthn o/ japhb 17:08
17:09 domidumont joined 17:16 domidumont1 joined, zakharyas left
dalek kudo/glr: 1ee1808 | hoelzro++ | src/core/Pod.pm:
Flatten Pod::Block contents array

Due to new GLR changes, the contents attribute is handed an Array that doesn't want to flatten.		 17:17
hoelzro could someone close to the GLR changes check out that commit I just made, and verify that it makes sense? 17:18
I finally was able to fix a bunch of POD tests, but the way I managed it feels LTA
17:19 domidumont left
cognominal c'est vrai qu'avec l'Europe, on est passé au niveau méta et avec Tafta au méta secret. 17:20
wrong channel
laben hoelzro: i dont know about glr, but couldn't you do @!contents.map(&flat)? 17:22
hoelzro laben: that might work! I think what's bothering me about it is all of the explicit flattening 17:23
laben hoelzro: other way is to make sure the callers flatten it themselves...
hoelzro yeah, I was trying to make that work; I don't know if I couldn't because GLR is WIP, or because I was doing something wrong
laben is there documentation to learn (part of) the internals of Rakudo? 17:26
hoelzro laben: github.com/edumentab/rakudo-and-nq...als-course 17:27
laben hoelzro: thanks! a ton of things to read 17:28
hoelzro I also gave a talk at (Chicago.pm&Milwaukee.pm) about it: docs.google.com/presentation/d/1JV...slide=id.p
that's more things I've learned while working on it, though 17:29
laben turns out pandoc has quite the heavy deps, would be a dream to have it in p6... 17:36
skids m: sub b (*@a) { }; sub a (*@a) { b(|@a); }; my $b = Failure.new("foo"); a(1,$b,3); # throws the failure on GLR, should it? 17:38
camelia ( no output )
17:44 rurban joined
skids m: sub a (*@a) { }; my @a = (1,Failure.new("foo"),3); a(|@a); # golf 17:45
camelia ( no output )
jnthn hoelzro: My first resort would probably be to fix the thing passing @!contents rather than trying to fix it up there 17:57
hoelzro jnthn: makes sense; what I'm seeing passed in is something like [$[Pod::Block::Para, Pod::Block::Para]], and I couldn't seem to figure out how to flatten that in NQP land 17:58
any pointers?
jnthn hoelzro: Do you know where the NQP code doing the pushing is? 17:59
hoelzro jnthn: github.com/rakudo/rakudo/blob/nom/...od.nqp#L34 18:00
jnthn Hm, I wonder what serialize_array does... :)
hoelzro yeah, that seems to make an itemized Array 18:01
and I couldn't figure out how to get it to flatten
jnthn Well, arrays are by definition itemized...
hoelzro I thought that with GLR they aren't anymore? or they just flatten now, unless made with $[...] 18:02
jnthn An Array is (always has been) a bunch of Scalars 18:03
Hm, I can't see where on earth the extra itemization is going on though 18:04
hoelzro ok, so I'm not (entirely) crazy then =)
I think it's happening in Array.new somehow
that's my guess 18:05
jnthn Yeah, I can't manage to create an isolated example, alas
hoelzro I think it has something to do with the way that the $<pod_content> match has an AST that is also a serialized array? 18:06
jnthn Oh...I was assuming we pushed that twice 18:07
That is, that @children.push($_.ast); was running twice
If it's running once and you've a nested array then...yeah, that'll be some fun 18:08
nine skids++ # investigating roast/glr hangs
jnthn 'cus Array.new(@a, @b) now gets you an Array of two things
nine Should we revert the extra .list calls in roast, now that Seq supports AT-POS? 18:10
jnthn nine: Can do, yes 18:11
jnthn away for a bit
18:13 rurban left
skids nine: well, my PR only takes care of the one new one. The S03 assignment one I think nobody figured out exactly how GLR-only-fudging should be handled. 18:14
18:14 zakharyas joined
nine 279/1036 test files failing in roast/glr 18:15
laben hoelzro: your talk was super interesting and educative, i had to rewatch some parts twice to understand what you were doing. btw congrats for your typing speed and skillz, makes me seem so sloppy
skids BTW maybe consider having the GLR rakudo "make spectest" pull from glr roast branch for now?
hoelzro oh, thank you laben!
jnthn: yeah, that's what I'm observing =/
18:16 rurban joined
dalek ast/glr: 59bc6a6 | hoelzro++ | S26-documentation/why- (3 files):
Revert "Fix S26 WHY tests for GLR"

This reverts commit 4fabc1edb14e2b75f4d88c2882f526f33903649b.		 18:17
nine skids: yes, I put the one into S03/assign.t. I don't think we really need GLR-only-fudging. Just fudging and mentioning the GL should be enough. I just wanted to get rid of the hang. I left it there because it may happen that we declare the case hopeless like we did with xx=
S-26/why* pass for me :0 18:18
:) 18:19
hoelzro nine: I probably should've edited that message =)
nine hoelzro: well you could have mentioned, that we do actually support the previous code now. But not many people will notice the commits anyway ;) 18:20
hoelzro right, I thought about that...after I pushed =/
18:24 rurban left 18:26 RabidGravy joined
hoelzro is there a way to iterate over a P6 array in NQP? I'm thinking maybe I should explicitly flatten $_.ast in Pod.nqp 18:26
18:27 kernel joined, kernel is now known as Guest6532 18:30 Guest94770 left
AlexDaniel m: loop my $i=0; $i < 25; $i++ { say 'hello' } 18:36
camelia rakudo-moar 44e3b4: OUTPUT«5===SORRY!5=== Error while compiling /tmp/rRzc1UgSR9␤Missing block␤at /tmp/rRzc1UgSR9:1␤------> 3loop7⏏5 my $i=0; $i < 25; $i++ { say 'hello' }␤ expecting any of:␤ scoped block␤»
18:36 bin_005 joined 18:41 MadcapJake left 18:45 jack_rabbit left
skids Is Array.STORE eager for any deep semantic reason? I'm wondering if we couldn't just put things on $!todo and make $!todo.reification-target vivify itself (and $!reified if needed) when unset. 18:45
Oh, maybe for compile-time typechecks? 18:47
18:48 FROGGS_ is now known as FROGGS
FROGGS good evening dear sir or madam 18:50
yoleaux 14:13Z <lizmat> FROGGS: re #125796, it looks like EOF is not set in the same way for an IO::Handle coming from open or from run :out
synbot6 Link: rt.perl.org/rt3/Public/Bug/Display...?id=125796
hoelzro ahoy FROGGS 18:51
18:54 llfourn left 18:55 xinming left 19:00 mr_ron joined
skids wonders if .plan should just ignore laziness/infinity entirely and just keep adding to a bunch of Slips in $!todo, and if they are unreachable, ohwelltoobad. 19:02
19:10 diana_olhovik joined 19:13 kaare_ joined
dalek kudo/glr: 6d76d88 | hoelzro++ | src/core/Pod.pm:
Revert "Flatten Pod::Block contents array"

This reverts commit 1ee18086dd11a807b8940c242a6e7c0842b5c356.		 19:21
kudo/glr: 919ef9d | hoelzro++ | src/Perl6/Pod.nqp:
Manually unpack POD childrens' content when creating parent

A fresh look on what I tried to fix in 1ee18086dd11a807b8940c242a6e7c0842b5c356.
hoelzro ok, that *should* be better
and it doesn't break table tests!
19:25 rurban joined 19:26 domidumont1 left 19:31 yqt joined
FROGGS since I was quite inactive... is the glr branch faster than nom in some cases? 19:33
laben [17:12] <lizmat> nom with words counr: 0.952s / 2.764s
[17:13] <lizmat> on glr it's now 0.851s / 1.870s
FROGGS ohh, that sounds like something 19:34
laben jnthn said that's only the beginning, no work was done specifically to make this faster 19:35
FROGGS yes yes, that is how I know how development works
laben i was trying to instill hope for more speed :/ 19:36
FROGGS more speed will come
laben and startup was a lil faster too
DrForr briefly pokes his nse in - I understand the breakage I found was fixed. 19:37
*nose
dalek kudo/nom: 383db01 | FROGGS++ | src/core/IO/Pipe.pm:
implement IO::Pipe.lines in terms of repeated .get

This solves RT #125796. There is no EOF when read lines from a subprocess, so we cannot cheat here and have to call .get repeatedly.		 19:41
synbot6 Link: rt.perl.org/rt3/Public/Bug/Display...?id=125796
hoelzro FROGGS++ 19:44
dalek ast: 3a8ec6e | FROGGS++ | S32-io/pipe.t:
add test for RT #125796, IO::Pipe.lines
 19:46
synbot6 Link: rt.perl.org/rt3/Public/Bug/Display...?id=125796
19:46 bin_005_g joined 19:47 bin_005 left
FROGGS hoelzro: can you comment here? blogs.perl.org/users/aaron_baugher/...erl-6.html 19:47
hoelzro sure can!
FROGGS hoelzro++ 19:48
dalek pan style="color: #395be5">perl6-examples: 321e5fd | paultcochrane++ | lib/Pod/Htmlify.pm6:
Instantiate Text::VimColour correctly if installed
 19:49
hoelzro done 19:51
FROGGS nice :o)
m: for ^2 { NEXT .say } 19:52
camelia rakudo-moar 44e3b4: OUTPUT«Cannot call method 'say' on a null object␤ in block <unit> at /tmp/pwZz_LeAce:1␤␤»
19:53 AlexDaniel left 19:58 AlexDaniel joined 20:19 darutoko left 20:24 camelia left 20:26 camelia joined 20:27 ChanServ sets mode: +v camelia 20:34 kaare_ left 20:37 diana_olhovik left 20:51 llfourn joined 20:55 llfourn left 21:04 bin_005_g left, bin_005_g_c joined 21:06 zakharyas left 21:08 rindolf left 21:19 laben left
skids m: my $a = Array[Int].new(1,2,3); $a[0] := 1; $a[0] = 3; $a.say; # wondering the disposition of the GLR design to this... does Array really "ensure" containers? 21:20
camelia rakudo-moar 383db0: OUTPUT«Cannot modify an immutable Int␤ in block <unit> at /tmp/xNHzEBdctM:1␤␤»
skids Or just that *assignment* means "new container"
dalek pan style="color: #395be5">perl6-examples: b2f5c43 | paultcochrane++ | categories/euler/prob008-duff2.pl:
Improve list markup for prob008-duff2

For some reason the S26 numbered item syntax doesn't work yet, however at present fixing the original numbered list to use a pod6 list is a bit of an improvement.		 21:28
smls skids: I think the whole point of the "binding to an array/hash element" feature is to replace the container that would be normally there.
if you replace it with an immutable value rather than another container, you can obviously not assign to it... :P 21:29
skids Right so you should be able to bind an "Int $a" into an Array[Int] but not a 3.
smls I guess that's a case of DIHWIDT... 21:30
skids Well, I'm not sure it's that simple... optimizers having to throw container checks in everywhere is probably not pretty. 21:32
skids wonders how much breaks if he "fixes" that. 21:35
dalek kudo-star-daily: d15f796 | coke++ | log/MoarVM- (5 files):
today (automated commit)
 21:40
rl6-roast-data: dca9dac | coke++ | / (9 files):
today (automated commit)
[Coke] can't build Resurrected pugs on hack - no cabal. 21:48
21:51 llfourn joined 21:55 llfourn left 21:59 ecocode joined 22:06 TEttinger joined 22:15 BenGoldberg joined, mr_ron left 22:16 RabidGravy left 22:31 smls left 22:37 Peter_R left 22:43 yqt left 22:49 telex left 22:50 telex joined 22:52 Peter_R joined
ugexe FROGGS: maybe i won't need to soon, but right now i use the following with lines: $proc.out.lines(:!eager, :close); 22:53
i can easily change my code, just wanted to point it out in case it was actually important 22:56
23:10 ecocode left 23:13 virtualsue left 23:16 cognominal left 23:19 rurban left 23:41 BenGoldberg left 23:42 BenGoldberg joined 23:52 llfourn joined, inokenty joined 23:56 llfourn left

Powered by Cro and the Raku® Programming Language.

Please report any issues / comments / feature requests as an issue on App::Raku::Log.

Thank you!