»ö« 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.
timotimo it seems like "use trace" damages something in this script 01:06
so i'll try to golf a little test
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
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
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
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
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 :)
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
AlexDaniel interesting how it is col 1033 on camelia, but col 1029 on my pc 03:01
same code
aaah
different path!!
ok, obvious
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?
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
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␤␤»
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)
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
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
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␤␤»
AlexDaniel ok, enough for today 05:01
labster AlexDaniel's 9-9-9 plan for Perl 6. 05:06
AlexDaniel 1999--14035828--4570789517646521952 plan 05:07
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
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
RabidGravy marning! 06:33
brrt good morning again 07:25
RabidGravy erp 07:27
[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
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
[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
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
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
jdv79 more like hasnt happened yet:) 10:17
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
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
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
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
camelia rakudo-moar ab73b0: OUTPUT«(timeout)» 10:31
jnthn Well, maybe that one was a little ambitious :)
m: say (2 ** 10000000).chars 10:32
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
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
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
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
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
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
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
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)
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
AlexDaniel at least it should mention possible overflow 13:02
nine jnthn: thanks for fixing up my sequential-map implementation :) 13:20
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
[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
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.
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
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
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
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
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.
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?
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
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
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.
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
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
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
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
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
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
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
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
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
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
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
jnthn bbl & 15:26
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
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
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.
japhb *yawn* 17:00
Good morning, #perl6
japhb has been up for a while, but just now feeling like hacking 17:01
jnthn o/ japhb 17:08
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
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 )
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
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
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 =/
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 =/
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
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␤»
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
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
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
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!
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
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␤␤»
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
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