»ö« 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:14
yqt left
00:27
rangerprice left
00:29
laouji joined
00:40
laouji left
00:41
laouji joined
00:47
BenGoldberg joined
00:53
BenGoldberg left
00:55
BenGoldberg joined
01:03
BenGoldberg left
01:15
BenGoldberg joined
01:21
llfourn joined
01:26
llfourn left,
Averna joined
01:27
Averna left
01:28
Averna joined
01:39
gfldex left
01:44
mr-foobar left
01:45
ilbot3 left
01:46
ilbot3 joined
02:02
skids left
02:04
rangerprice joined
02:05
xxx left
02:09
dayangkun joined
02:10
xxx joined
02:15
kaare__ joined
02:17
noganex joined
02:20
noganex_ left
02:21
araujo left
02:22
araujo joined
02:23
raiph left
02:31
ab5tract joined
02:32
smls left
02:33
Averna left
02:34
jordman left
02:35
adu joined
02:40
yeahnoob joined
02:42
jordman joined
|
|||
dalek | ast: cf775d3 | ShimmerFairy++ | S02-literals/numeric.t: Fix S02-literals/numeric.t Some of the tests for different forms of Rat literals did so in a way that calls will call .Numeric on Str (as well as any other non-Numeric argument). Since a Rat literal that's not parsed correctly will be interpreted as a Str, then as long as Str.Numeric can handle the given Rat form any issues with Rat literals for those forms were hidden. These tests were changed to ensure we don't numify any strings. Also updated some of the tests to use the new 'does-ok' to check roles, and replaced a smartmatch against Str with an 'isa-ok' check. |
02:44 | |
02:51
araujo_ joined
02:54
araujo left
03:05
CQ_ joined
03:07
CQ left,
CQ_ is now known as CQ,
AlexDaniel left
03:12
bin_005 joined
03:22
llfourn joined
03:27
ggherdov left,
llfourn left,
preyalone left
03:28
pnu left
03:29
pnu joined
03:31
ggherdov joined
03:33
preyalone joined,
adu left
03:44
prevost joined
03:45
BenGoldberg left
03:46
bin_005 left
03:56
laouji left
03:59
telex left
04:00
telex joined
04:06
llfourn joined,
cognominal joined
04:16
rurban joined
|
|||
colomon | m: say (1..5)[1..*] | 04:19 | |
camelia | rakudo-moar 30d6fe: OUTPUT«2 3 4 5» | ||
GLRelia | rakudo-moar 087a6c: OUTPUT«2345» | ||
04:27
laouji joined
|
|||
colomon | do we have something in GLR for list concatenation? | 04:28 | |
04:31
pflanze left
04:35
domm left
04:37
Sqirrel left
|
|||
ShimmerFairy | you mean besides .join() ? | 04:45 | |
colomon: or are you talking about the stuff Slip() was meant for? (As I recall, jnthn's exploration gist mentioned that Slip() took care of various calls for some kind of "list concatenation" operator) | 04:48 | ||
colomon | err… join is string concatenation on lists. I’m looking for list concatenation on lists. | 04:49 | |
though yeah, slip ought to help a lot. hmm. | |||
ShimmerFairy | colomon: I was think of the (probably somewhat outdated) S07 draft in specs: "Pm's Answer: I think that the conjectured Slip type above eliminates much of the need for a list concatenation operator, since given two lists, one can do a join by wrapping one or both in Slip objects:" | 04:51 | |
*thinking of | |||
colomon | hmmm, that gist was one of the tabs I was keeping open when my browser crashed hard repeatedly at the hackathon yesterday. :) | ||
m: say [1..5].slip | 04:52 | ||
GLRelia | rakudo-moar 087a6c: OUTPUT«Method 'slip' not found for invocant of class 'Array' in block <unit> at /tmp/fXsXQpTv2H:1» | ||
camelia | rakudo-moar 30d6fe: OUTPUT«Method 'slip' not found for invocant of class 'Array' in block <unit> at /tmp/bUEuLeuVRn:1» | ||
colomon | m: say slip([1..5]) | ||
GLRelia | rakudo-moar 087a6c: OUTPUT«[1 2 3 4 5]» | ||
camelia | rakudo-moar 30d6fe: OUTPUT«5===SORRY!5=== Error while compiling /tmp/L_0skvjs38Undeclared routine: slip used at line 1. Did you mean 'flip'?» | ||
colomon | m: say slip(1..5) | ||
GLRelia | rakudo-moar 087a6c: OUTPUT«1..5» | ||
camelia | rakudo-moar 30d6fe: OUTPUT«5===SORRY!5=== Error while compiling /tmp/5qGVEKkwQqUndeclared routine: slip used at line 1. Did you mean 'flip'?» | ||
ShimmerFairy | .Slip, since it's a type :) | 04:53 | |
m: say [1..5].Slip | |||
GLRelia | rakudo-moar 087a6c: OUTPUT«12345» | ||
camelia | rakudo-moar 30d6fe: OUTPUT«Method 'Slip' not found for invocant of class 'Array' in block <unit> at /tmp/QNaGJESMN0:1» | ||
04:59
khw left
|
|||
colomon | m: my @a = 1..3; my @b = 2, 5, 3; say (@a, @b).perl; say (@a.Slip, @b.Slip).perl | 05:00 | |
camelia | rakudo-moar 30d6fe: OUTPUT«([1, 2, 3]<>, [2, 5, 3]<>)Method 'Slip' not found for invocant of class 'Array' in block <unit> at /tmp/JRpvpvTXe4:1» | ||
GLRelia | rakudo-moar 087a6c: OUTPUT«([1, 2, 3], [2, 5, 3])(1, 2, 3, 2, 5, 3)» | ||
ShimmerFairy | colomon: note that prefix:<|> can also be used to Slip-ify something | 05:01 | |
m: say (1,2,3).Slip.perl | |||
GLRelia | rakudo-moar 087a6c: OUTPUT«(1, 2, 3)» | ||
camelia | rakudo-moar 30d6fe: OUTPUT«Method 'Slip' not found for invocant of class 'Parcel' in block <unit> at /tmp/WxtRKIbuoF:1» | ||
ShimmerFairy | m: say (|(1,2,3)).perl | ||
GLRelia | rakudo-moar 087a6c: OUTPUT«(1, 2, 3)» | ||
camelia | rakudo-moar 30d6fe: OUTPUT«5===SORRY!5=== Error while compiling /tmp/bPhfVd6072Arg-flattening | is only valid in an argument listat /tmp/bPhfVd6072:1------> 3say (|7⏏5(1,2,3)).perl» | ||
colomon | ShimmerFairy++ | ||
ShimmerFairy | m: my @a = 1..3; my @b = 2, 5, 3; say (@a, @b).perl; say (|@a, |@b).perl | 05:02 | |
GLRelia | rakudo-moar 087a6c: OUTPUT«([1, 2, 3], [2, 5, 3])(1, 2, 3, 2, 5, 3)» | ||
camelia | rakudo-moar 30d6fe: OUTPUT«5===SORRY!5===Arg-flattening | is only valid in an argument listat /tmp/3LWC_lp1aX:1------> 3 @b = 2, 5, 3; say (@a, @b).perl; say (|7⏏5@a, |@b).perlArg-flattening | is only valid in an argument listat /tmp/3LWC_lp1aX:1------> …» | ||
colomon | m: say ([]).map({ 1 }) | 05:04 | |
GLRelia | rakudo-moar 087a6c: OUTPUT«» | ||
camelia | rakudo-moar 30d6fe: OUTPUT«» | ||
05:06
RabidGravy joined
05:14
prevost left
|
|||
colomon | m: say (Array.new).map({ 1 }) | 05:24 | |
camelia | rakudo-moar 30d6fe: OUTPUT«» | ||
GLRelia | rakudo-moar 087a6c: OUTPUT«» | ||
05:24
rangerprice left
|
|||
colomon | m: say [[]].map({ 1 }) | 05:24 | |
camelia | rakudo-moar 30d6fe: OUTPUT«1» | ||
GLRelia | rakudo-moar 087a6c: OUTPUT«» | ||
colomon | okay, so under GLR, how does one return a list consisting of exactly one empty array? | 05:29 | |
ShimmerFairy | m: say [[],].perl | 05:31 | |
camelia | rakudo-moar 30d6fe: OUTPUT«[[]]» | ||
GLRelia | rakudo-moar 087a6c: OUTPUT«[[],]» | ||
ShimmerFairy | m: say ((1,2,3),).perl | ||
camelia | rakudo-moar 30d6fe: OUTPUT«((1, 2, 3),)» | ||
GLRelia | rakudo-moar 087a6c: OUTPUT«((1, 2, 3))» | ||
ShimmerFairy | m: say ((1,2,3),).map: {1} | ||
GLRelia | rakudo-moar 087a6c: OUTPUT«1» | ||
camelia | rakudo-moar 30d6fe: OUTPUT«1» | ||
ShimmerFairy | m: say ((1,2,3)).map: {1} | 05:32 | |
camelia | rakudo-moar 30d6fe: OUTPUT«1 1 1» | ||
GLRelia | rakudo-moar 087a6c: OUTPUT«111» | ||
colomon | m: say [[]].perl; say [[],].perl | ||
camelia | rakudo-moar 30d6fe: OUTPUT«[[]][[]]» | ||
GLRelia | rakudo-moar 087a6c: OUTPUT«[][[],]» | ||
ShimmerFairy | colomon: you have to explicitly add a comma, like how in pre-GLR you have to add a comma to force a Parcel | 05:33 | |
m: say (42).perl; say (42,).perl | |||
camelia | rakudo-moar 30d6fe: OUTPUT«42(42,)» | ||
GLRelia | rakudo-moar 087a6c: OUTPUT«42(42)» | ||
ShimmerFairy | m: say (42).WHAT; say (42,).WHAT | ||
camelia | rakudo-moar 30d6fe: OUTPUT«(Int)(Parcel)» | ||
GLRelia | rakudo-moar 087a6c: OUTPUT«Use of uninitialized value of type Int in string context in block <unit> at /tmp/vHIwTjkdrC:1Use of uninitialized value of type List in string context in block <unit> at /tmp/vHIwTjkdrC:1» | ||
colomon | m: [[],].map({ 1 }).say | ||
camelia | rakudo-moar 30d6fe: OUTPUT«1» | ||
GLRelia | rakudo-moar 087a6c: OUTPUT«1» | ||
colomon | ShimmerFairy++ | 05:34 | |
ShimmerFairy | m: say 42.WHAT | ||
camelia | rakudo-moar 30d6fe: OUTPUT«(Int)» | ||
GLRelia | rakudo-moar 087a6c: OUTPUT«Use of uninitialized value of type Int in string context in block <unit> at /tmp/axPsCAQUP7:1» | ||
ShimmerFairy | m: say Any | ||
camelia | rakudo-moar 30d6fe: OUTPUT«(Any)» | ||
GLRelia | rakudo-moar 087a6c: OUTPUT«Use of uninitialized value of type Any in string context in block <unit> at /tmp/VdN99AQ1rz:1» | ||
ShimmerFairy | looks like GLR doesn't like :U objects on say atm :P | 05:35 | |
m: print Mu | |||
camelia | rakudo-moar 30d6fe: OUTPUT«Use of uninitialized value <element> of type Mu in string context in block <unit> at /tmp/3OUWV7s8aN:1» | ||
GLRelia | rakudo-moar 087a6c: OUTPUT«Use of uninitialized value <element> of type Mu in string context in block <unit> at /tmp/nGH3YXR3uL:1» | ||
ShimmerFairy | m: print Mu.gist | ||
camelia | rakudo-moar 30d6fe: OUTPUT«(Mu)» | ||
GLRelia | rakudo-moar 087a6c: OUTPUT«(Mu)» | ||
ShimmerFairy | m: say Int.gist | ||
camelia | rakudo-moar 30d6fe: OUTPUT«(Int)» | ||
GLRelia | rakudo-moar 087a6c: OUTPUT«(Int)» | ||
colomon | m: ([],).map({ 1 }).say | 05:36 | |
GLRelia | rakudo-moar 087a6c: OUTPUT«1» | ||
camelia | rakudo-moar 30d6fe: OUTPUT«1» | ||
05:45
rurban left
05:58
rurban joined
05:59
colomon left
06:02
colomon joined
|
|||
colomon | O/ from hotel breakfast | 06:02 | |
nine | m: [$[]].perl.say | 06:04 | |
camelia | rakudo-moar 30d6fe: OUTPUT«[Any]» | ||
GLRelia | rakudo-moar 087a6c: OUTPUT«[[],]» | ||
nine | colomon: ^^^ | ||
m: [$[]].map(say $_.perl) | |||
camelia | rakudo-moar 30d6fe: OUTPUT«AnyCannot call map(Array: Bool); none of these signatures match: ($: Whatever, *%_) ($: &block, :$label, *%_) in block <unit> at /tmp/Y7dK4aPPL8:1» | ||
GLRelia | rakudo-moar 087a6c: OUTPUT«AnyCannot call map(Array: Bool); none of these signatures match: ($: &block, :$label, *%_) (HyperIterable:D $: &block, :$label, *%_) in block <unit> at /tmp/S2pegLq2Tf:1» | ||
nine | m: [$[]].map({say $_.perl}) | ||
camelia | rakudo-moar 30d6fe: OUTPUT«Any» | ||
GLRelia | rakudo-moar 087a6c: OUTPUT«[]» | ||
06:05
colomon left,
Woodi left
|
|||
ShimmerFairy | oh yeah | 06:06 | |
m: ($()).perl.say | |||
camelia | rakudo-moar 30d6fe: OUTPUT«Use of Nil in string context in block <unit> at /tmp/fDruYzXKAY:1""» | ||
GLRelia | rakudo-moar 087a6c: OUTPUT«Use of Nil in string context in block <unit> at /tmp/yhdkXixgPd:1""» | ||
06:06
Woodi joined
|
|||
ShimmerFairy | since [] enforces scalar containers, it should suffice to use $ inside a [] :) | 06:06 | |
m: [$()].perl.say | |||
camelia | rakudo-moar 30d6fe: OUTPUT«Use of Nil in string context in block <unit> at /tmp/0ONHQXvll5:1[""]» | ||
GLRelia | rakudo-moar 087a6c: OUTPUT«Use of Nil in string context in block <unit> at /tmp/x7jFzMM_CP:1[""]» | ||
ShimmerFairy | derp, $() is something else :P | ||
m: [$( )].perl.say | |||
camelia | rakudo-moar 30d6fe: OUTPUT«[]» | ||
GLRelia | rakudo-moar 087a6c: OUTPUT«[(),]» | ||
ShimmerFairy | m: ($( )).perl.say | 06:07 | |
camelia | rakudo-moar 30d6fe: OUTPUT«$( )» | ||
GLRelia | rakudo-moar 087a6c: OUTPUT«()» | ||
JimmyZ | bug! | ||
06:07
colomon joined
|
|||
colomon | nine++ | 06:08 | |
ShimmerFairy | JimmyZ: no, $() is specific to Matches | ||
m: "A" ~~ /A/; say $() | |||
camelia | rakudo-moar 30d6fe: OUTPUT«A» | ||
GLRelia | rakudo-moar 087a6c: OUTPUT«A» | ||
ShimmerFairy | m: "A" ~~ /A {make "B"}/; say $() | ||
camelia | rakudo-moar 30d6fe: OUTPUT«B» | ||
GLRelia | rakudo-moar 087a6c: OUTPUT«B» | ||
ShimmerFairy | m: "A" ~~ /A {make "B"}/; say $/.ast // ~$/ | ||
camelia | rakudo-moar 30d6fe: OUTPUT«B» | ||
GLRelia | rakudo-moar 087a6c: OUTPUT«B» | ||
ShimmerFairy | m: "A" ~~ /A/; say $/.ast // ~$/ | 06:09 | |
camelia | rakudo-moar 30d6fe: OUTPUT«A» | ||
GLRelia | rakudo-moar 087a6c: OUTPUT«A» | ||
nine | ShimmerFairy: but $( ).perl.say should print $(), not (). That's the remaining t/spec/S02-types/list.t failure | ||
JimmyZ | m: "A" ~~ /A {make "B"}/; say $( ) | ||
camelia | rakudo-moar 30d6fe: OUTPUT«» | ||
GLRelia | rakudo-moar 087a6c: OUTPUT«» | ||
ShimmerFairy | nine: oh, that's the bug :) | ||
nine: so [$()].perl should be '[$(),]' IIUC. | 06:10 | ||
nine | For some reason the nqp::iscont check on SELF in List.Perl returns 0 | ||
ShimmerFairy: yes | |||
JimmyZ | SELF or self? | ||
nine | SELF | 06:11 | |
self would be decont'ed in any case | |||
ShimmerFairy | ( and for the record, I only learned about $() a couple days ago, and I personally wouldn't mind if it went away. I don't see where it's useful enough to have a short form of {$/.ast // ~$/} ) | ||
JimmyZ wish $() and $( ) is the same thing | 06:12 | ||
*are | |||
ShimmerFairy | JimmyZ: I've never seen it used, except for a few spots in nqp and/or rakudo, and it doesn't seem like it has anything to do with regexes. I'm inclined to agree :) | 06:13 | |
JimmyZ: and on top of it, $() feels to me like a case of creeping "punctuation scalars" that I know existed in Perl 5, and we worked to get rid of :) (that is, Perl 5's $=, $', and probably everything else that could match /'$' <:Punct>/ :P) | 06:15 | ||
JimmyZ | well, at least, for consistency, they should be same thing | 06:16 | |
TimToady agrees that $() can go | |||
JimmyZ | $[] vs $[ ] vs $() vs $( ) | ||
06:16
colomon_ joined
06:17
colomon left,
colomon_ is now known as colomon
|
|||
ShimmerFairy | TimToady: for what it's worth, I kinda like the idea of something that automatically picks the right thing like that, but I think in most cases you're not working off $/ in the first place, and it's not worth a magical-variable-looking thing. | 06:18 | |
in most cases where you're interested in C<.ast>s, is what I meant. | |||
TimToady | it would make more sense to use $<> for that anyway | 06:19 | |
colomon | What time are people starting to go to the hackathon? | 06:20 | |
dalek | ast/glr: fe7a750 | (Stefan Seifert)++ | S03-operators/assign.t: Add explicit flattening, to fix array assignment tests |
06:21 | |
TimToady | registration is at 9, program starts at 9:45, so I have no idea when people will actually go :) | ||
JimmyZ | specs git:(master) grep -r '$()' * | wc -l | ||
13 | |||
colomon | TimToady: think the building is open yet? I’m getting sick of sitting on a footstool thing…. :) | 06:22 | |
TimToady | yesterday opened at 9 | ||
colomon | TimToady++ | 06:23 | |
06:26
diana_olhovik_ joined,
salv0 joined
|
|||
ShimmerFairy | m: "A" ~~ /$<xyzzy>=(A {make "B"})/; say $<> | 06:27 | |
camelia | rakudo-moar 30d6fe: OUTPUT«「A」 xyzzy => 「A」» | ||
GLRelia | rakudo-moar 087a6c: OUTPUT«» | ||
ShimmerFairy | $<> predictably returns $/ (at least on nom. huh.). In that case, it might not be a bad thing to make $() actually be $<>, since current $<> is redundant (and then also $<xyzzy><> and so on) | 06:29 | |
m: "A" ~~ /$<xyzzy>=(A {make "B"})/; say $/ === $<> | |||
camelia | rakudo-moar 30d6fe: OUTPUT«True» | ||
GLRelia | rakudo-moar 087a6c: OUTPUT«True» | ||
ShimmerFairy | m: "A" ~~ /$<xyzzy>=(A {make "B"})/; say $/ | ||
camelia | rakudo-moar 30d6fe: OUTPUT«「A」 xyzzy => 「A」» | ||
GLRelia | rakudo-moar 087a6c: OUTPUT«» | ||
ShimmerFairy | that's not good for glr | ||
m: "A" ~~ /$<xyzzy>=(A {make "B"})/; print $/ | 06:30 | ||
camelia | rakudo-moar 30d6fe: OUTPUT«A» | ||
GLRelia | rakudo-moar 087a6c: OUTPUT«A» | ||
ShimmerFairy | m: "A" ~~ /$<xyzzy>=(A {make "B"})/; say $/.perl | ||
camelia | rakudo-moar 30d6fe: OUTPUT«Match.new(ast => Any, list => (), hash => EnumMap.new(:xyzzy(Match.new(ast => "B", list => (), hash => EnumMap.new(), orig => "A", to => 1, from => 0))), orig => "A", to => 1, from => 0)» | ||
GLRelia | rakudo-moar 087a6c: OUTPUT«Match.new(ast => Any, list => (), hash => EnumMap.new(:xyzzy(Match.new(ast => "B", list => (), hash => EnumMap.new(), orig => "A", to => 1, from => 0))), orig => "A", to => 1, from => 0)» | ||
ShimmerFairy | m: "A" ~~ /$<xyzzy>=(A {make "B"})/; say $/.gist | ||
camelia | rakudo-moar 30d6fe: OUTPUT«「A」 xyzzy => 「A」» | ||
GLRelia | rakudo-moar 087a6c: OUTPUT«「A」 xyzzy => 「A」» | ||
ShimmerFairy | yeah, seems glr's &say fails to call .gist on things now, for some reason | ||
m: say Int | |||
camelia | rakudo-moar 30d6fe: OUTPUT«(Int)» | ||
GLRelia | rakudo-moar 087a6c: OUTPUT«Use of uninitialized value of type Int in string context in block <unit> at /tmp/4qyPWrfzNo:1» | ||
ShimmerFairy | m: class Foo { method Str { "fail" }; method gist { "win" } }; say Foo | 06:33 | |
GLRelia | rakudo-moar 087a6c: OUTPUT«fail» | ||
camelia | rakudo-moar 30d6fe: OUTPUT«win» | ||
06:33
salva is now known as Guest54260,
Guest54260 left,
salv0 is now known as salva
06:34
Guest54260 joined
|
|||
moritz | m: say "foo" | 06:34 | |
camelia | rakudo-moar 30d6fe: OUTPUT«foo» | ||
GLRelia | rakudo-moar 087a6c: OUTPUT«foo» | ||
moritz | ShimmerFairy: spectesting a fix | ||
ShimmerFairy | moritz++ :) | 06:35 | |
m: "A" ~~ /$<xyzzy>=(A {make "B"})/; say $/.Str | |||
camelia | rakudo-moar 30d6fe: OUTPUT«A» | ||
GLRelia | rakudo-moar 087a6c: OUTPUT«A» | ||
ShimmerFairy | m: "A" ~~ /$<xyzzy>=(A {make "B"})/; say $/ | ||
camelia | rakudo-moar 30d6fe: OUTPUT«「A」 xyzzy => 「A」» | ||
GLRelia | rakudo-moar 087a6c: OUTPUT«» | ||
ShimmerFairy | that's a bit weirder though O_o | ||
m: "A" ~~ /$<xyzzy>=(A {make "B"})/; say $_ for $/; say $/ ~~ Iterable | |||
camelia | rakudo-moar 30d6fe: OUTPUT«「A」 xyzzy => 「A」False» | ||
GLRelia | rakudo-moar 087a6c: OUTPUT«False» | ||
ShimmerFairy | Capture may not do Iterable (at least in the nom branch), but it does have AT-POS and friends (as well as AT-KEY and friends) | 06:37 | |
moritz | m: say Capture ~~ Positional | ||
camelia | rakudo-moar 30d6fe: OUTPUT«False» | ||
GLRelia | rakudo-moar 087a6c: OUTPUT«False» | ||
ShimmerFairy | and Match is Capture, so I'm guessing glr's &say accidentally doesn't treat $/ as a singular thing. Whether that's say's fault, or Capture not doing Iterable, I don't know. | ||
06:39
domidumont joined
|
|||
dalek | kudo/glr: 64cbc0d | moritz++ | src/core/io_operators.pm: say must use .gist, not .Str this way, say(Int) prints "(Int)\n" again |
06:39 | |
ShimmerFairy | My guess is that Capture should be doing Positional, Associative, and Iterable anyway. | 06:41 | |
JimmyZ | moritz: note needs too | ||
one is Str and one is Gist :) | |||
m: note Int | 06:42 | ||
camelia | rakudo-moar 30d6fe: OUTPUT«(Int)» | ||
GLRelia | rakudo-moar 087a6c: OUTPUT«» | ||
ShimmerFairy wishes often that the core roles weren't just empty things that are basically glorified annotations :/ | |||
dalek | ast/glr: d2c7d71 | (Stefan Seifert)++ | S03-operators/assign.t: Fix remaining failures in S03-operators/assign.t Need to take more care when to flatten now. Scalar assignment needs flattening of the whole expression while list assignment needs flattening of the input lists. |
06:43 | |
06:43
domidumont left
06:44
domidumont joined
|
|||
dalek | kudo/glr: 48ecd4d | moritz++ | src/core/io_operators.pm: note needs to .gist its arguments too, JimmyY++ |
06:47 | |
JimmyZ wishes we have is-output($Code, $expectet, $msg) | 06:49 | ||
06:49
domidumont left
|
|||
JimmyZ | so I can added a bit more test about say/note | 06:50 | |
*add | |||
06:53
colomon left
|
|||
[Tux] | test 50000 44.456 44.364 | 06:55 | |
test-t 50000 45.259 45.167 | |||
nom | |||
TravisCi has a panda problem: travis-ci.org/Tux/CSV/builds/77634324 | 07:03 | ||
test 50000 48.296 48.212 | |||
test-t 50000 45.212 45.128 | |||
glr | |||
masak | morning, #perl6 | ||
[Tux] | m: class C{method foo{gather { take 3..Inf}}};C.new.foo[^9].perl.say | 07:06 | |
camelia | rakudo-moar 30d6fe: OUTPUT«(3, 4, 5, 6, 7, 8, 9, 10, 11)» | ||
GLRelia | rakudo-moar 48ecd4: OUTPUT«(3..Inf)» | ||
[Tux] | I got no answer on that yet | ||
07:09
Sqirrel joined
07:10
domidumont joined
07:12
xinming joined,
xinming_ left
07:18
darutoko joined,
larion joined
07:19
luiz_lha joined
07:20
luiz_lha is now known as Guest76846
07:28
zakharyas joined
07:30
araujo_ left
|
|||
dalek | ast/glr: 388b0df | (Stefan Seifert)++ | S02-types/hash.t: Adopt GLRR semantics in S02-types/hash.t |
07:30 | |
07:31
Ven joined,
llfourn left
|
|||
JimmyZ | m: my %hash = %('a'..'d' Z 1..4); say %hash.elems; | 07:31 | |
camelia | rakudo-moar 30d6fe: OUTPUT«4» | ||
GLRelia | rakudo-moar 48ecd4: OUTPUT«2» | ||
dalek | kudo/nom: 28850d9 | (Tim Smith)++ | src/core/Exception.pm: Perl5Var $. maps to .ins method, not .line |
||
kudo/nom: 70f6519 | FROGGS++ | src/core/Exception.pm: Merge pull request #517 from softmoth/patch-1 Perl5Var $. maps to .ins method, not .line |
|||
07:31
FROGGS left
|
|||
nine | m: my %hash = %(flat 'a'..'d' Z 1..4); say %hash; | 07:32 | |
camelia | rakudo-moar 30d6fe: OUTPUT«a => 1, b => 2, c => 3, d => 4» | ||
GLRelia | rakudo-moar 48ecd4: OUTPUT«a => 1d => 4c => 3b => 2» | ||
07:32
Guest76846 is now known as luiz_lha
|
|||
nine | JimmyZ: ^^^ | 07:32 | |
JimmyZ | well, I didn't the segfault | ||
nine | JimmyZ: Z creates a list of lists | 07:33 | |
JimmyZ | see | ||
dalek | kudo/nom: cd9580f | (Jimmy Zhuo)++ | src/core/Int.pm: add native int version of pow |
||
kudo/nom: 906ca06 | FROGGS++ | src/core/Int.pm: Merge pull request #506 from zhuomingliang/patch-4 add native int version of pow |
|||
07:33
abraxxa joined
|
|||
JimmyZ | nine: I'd like to see the segfault :P | 07:33 | |
nine | JimmyZ: I think that's long gone | ||
07:34
FROGGS joined
|
|||
JimmyZ | ok, so no need to fix moarvm | 07:34 | |
FROGGS | o/ | 07:35 | |
07:36
brrt joined
07:39
lizmat joined
|
|||
FROGGS | JimmyZ: note that is-output might want to be more like: is-output($Code, $expectet-out, $expected-err, $msg) | 07:40 | |
JimmyZ: unless merging out+err is implicit, which makes it less useful | 07:41 | ||
JimmyZ | we can do $*ERR = $*OUT before testing | 07:42 | |
07:42
Ven left
|
|||
FROGGS | JimmyZ: then you do you test that something does (not) warn? | 07:43 | |
you need the distinction sometimes | |||
JimmyZ: is_run is good enough for me I think | 07:44 | ||
JimmyZ | oh | 07:45 | |
FROGGS | look at this for example: t/spec/S06-other/main-usage.t:13 | ||
07:46
lizmat left
07:47
lizmat joined,
lizmat left
|
|||
nine | Someone needs to rewrite S16-io/say.t to use is_run to check the output. The old, clever way just doesn't work anymore since array .gists contain the brackets now | 07:47 | |
FROGGS | nine: yeah, I think so too | 07:48 | |
07:48
colomon joined
|
|||
FROGGS | but I won't do it now, since I'm running a spectest, reapplying a patch and respectest afterwards | 07:49 | |
07:51
lizmat joined
|
|||
tadzik | good morning #perl6 | 07:55 | |
mfw my battery is at 5% but will still last for a 40-minute talk (´ー` ) | 07:56 | ||
07:57
rindolf joined
|
|||
nine | tadzik: you can't be running many spectest then ;) | 07:57 | |
tadzik | oh no I'm not :) | ||
nine probably needs to move inside within two hours | |||
08:05
xnrand left
08:07
xnrand joined
|
|||
tadzik | m: sub foo { my ($a, $b) = 1, 2; return :$a, :$b }; say foo().perl | 08:08 | |
GLRelia | rakudo-moar 48ecd4: OUTPUT«(:a(Mu), :b(Mu))» | ||
camelia | rakudo-moar 906ca0: OUTPUT«(:a(Mu), :b(Mu))» | ||
tadzik | ...how did it work before :o | ||
nine | m: sub foo { my ($a, $b) = 1, 2; return :$a, :$b }; my (:$a, :$b) = foo; say $a; say $b; | ||
GLRelia | rakudo-moar 48ecd4: OUTPUT«a => (Mu)b => (Mu)» | 08:09 | |
camelia | rakudo-moar 906ca0: OUTPUT«a => (Mu)b => (Mu)» | ||
nine | m: sub foo { my ($a, $b) = 1, 2; return :$a, :$b }; my (:$a, :$b) := foo; say $a; say $b; | ||
camelia | rakudo-moar 906ca0: OUTPUT«(Mu)(Mu)» | ||
GLRelia | rakudo-moar 48ecd4: OUTPUT«Too many positionals passed; expected 0 arguments but got 2 in block <unit> at /tmp/56MotrnerV:1» | ||
dalek | kudo-star-daily: d390db3 | coke++ | log/ (9 files): today (automated commit) |
||
08:11
domm_holiday joined
|
|||
timotimo | Timo super tired. Timo sleep a little more | 08:15 | |
dalek | ast/glr: cca514e | (Jimmy Zhuo)++ | S16-io/print.t: update S16-io/print.t to use is-run |
||
FROGGS | timotimo will miss the Q&A with Larry | 08:16 | |
lizmat | timotimo will miss Larry Wall Q&A ? | ||
:-) | |||
moritz | JimmyZ: I'm working on S16-io/say.t | ||
nine | JimmyZ++ | ||
moritz++ | |||
lizmat | moritz++ JimmyZ++ nine++ timotimo++ | 08:17 | |
:-) | |||
JimmyZ | :) | ||
lizmat | FROGGS++ :-) | ||
FROGGS | O.o | 08:18 | |
08:20
domidumont left
|
|||
dalek | ast/glr: f11010e | moritz++ | S16-io/say.t: Rewrite say.t by faking $*OUT |
08:21 | |
nine | my $foo = "FOO"; my $gorch = "foo bar"; my @q := «a b c "$foo" f g $gorch m n '$bar' x y z»; say @q.perl; | 08:22 | |
m: my $foo = "FOO"; my $gorch = "foo bar"; my @q := «a b c "$foo" f g $gorch m n '$bar' x y z»; say @q.perl; | 08:23 | ||
camelia | rakudo-moar 906ca0: OUTPUT«("a", "b", "c", "FOO", "f", "g", ("foo", "bar"), "m", "n", "\$bar", "x", "y", "z")» | ||
GLRelia | rakudo-moar 48ecd4: OUTPUT«("a", "b", "c", "FOO", "f", "g", ("foo", "bar"), "m", "n", "\$bar", "x", "y", "z")» | ||
lizmat | ah, so it didn't flatten before either ? | ||
moritz | no, but it didn't matter that much before | ||
lizmat | yeah | ||
nine | m: my $foo = "FOO"; my $bar = "BAR"; my $gorch = "foo bar"; @q1 = «$foo $gorch $bar»; | ||
camelia | rakudo-moar 906ca0: OUTPUT«5===SORRY!5=== Error while compiling /tmp/e7U2MLHwfiVariable '@q1' is not declaredat /tmp/e7U2MLHwfi:1------> 3my $bar = "BAR"; my $gorch = "foo bar"; 7⏏5@q1 = «$foo $gorch $bar»;» | ||
GLRelia | rakudo-moar 48ecd4: OUTPUT«5===SORRY!5=== Error while compiling /tmp/QDfc5hGAYEVariable '@q1' is not declaredat /tmp/QDfc5hGAYE:1------> 3my $bar = "BAR"; my $gorch = "foo bar"; 7⏏5@q1 = «$foo $gorch $bar»;» | ||
dalek | ast/glr: d663fb5 | (Jimmy Zhuo)++ | S16-io/print.t: add more test to print.t |
08:24 | |
nine | m: my $foo = "FOO"; my $bar = "BAR"; my $gorch = "foo bar"; my @q1 = «$foo $gorch $bar»; say @q1.perl; | ||
camelia | rakudo-moar 906ca0: OUTPUT«["FOO", "foo", "bar", "BAR"]<>» | ||
GLRelia | rakudo-moar 48ecd4: OUTPUT«["FOO", ("foo", "bar"), "BAR"]» | ||
08:24
domidumont joined
|
|||
nine | But in this case it did flatten ^^^^ | 08:24 | |
Which does not make sense to me | |||
moritz | if I knew where it was constructed, I'd just stick in a "flat" and be done | ||
nine | Test descriptions are "4 elements in unquoted «» list" vs. "13 elements in mixed quoted/unquoted «» list, non-flattened" | ||
moritz: I already have a pach. It just happens to break the cases where it did not flatten before. And I don't understand why it should not flatten in those cases. | 08:25 | ||
moritz | nine: IMHO it should always flatten, and every test assuming otherwise is a vicitim of Stockholm Syndrome | 08:26 | |
nine | moritz: ok, I think it's really just a bug in the spec test. | 08:27 | |
Test description is: "second quote is both parts of $gorch interpolated as sublist in non-flat context" | |||
Point is: there is no second quote. | |||
So I assume $gorch was meant to be quoted there. | 08:28 | ||
moritz | m: my $a = 'a b'; say <<x "$a" y>>.perl | ||
camelia | rakudo-moar 906ca0: OUTPUT«("x", "a b", "y")» | ||
GLRelia | rakudo-moar 48ecd4: OUTPUT«("x", "a b", "y")» | ||
moritz | yes, then it's a single element, not a sublist | ||
FROGGS | with my patch that makes Any.elems == 1 it still does not iterate over Any | 08:29 | |
:/ | |||
lizmat | :-( | ||
FROGGS | I guess it is an issue in MapIterCommon or so, but I don't see it yet | ||
dalek | kudo/glr: 3e83f87 | FROGGS++ | src/core/Any-iterable-methods.pm: remove comment about missing label support |
08:31 | |
08:32
domidumont left
|
|||
dalek | ast/glr: 3177163 | (Stefan Seifert)++ | S02-literals/quoting.t: Fix missing quotes in S02-literals/quoting.t The test description talks about a "second" quote involving $gorch, but $gorch was not quoted. This did not matter before GLR due to implicit flattening. |
08:32 | |
08:33
llfourn joined
|
|||
dalek | kudo/glr: bf1307e | (Stefan Seifert)++ | src/Perl6/Actions.nqp: Fix my $g = "a b"; <<c $g d>> not interpolating the sublist $g gets turned into ('a', 'b') which does no longer interpolate implicitly. Have to create explicit code to do that to keep << >> semantics. |
08:33 | |
08:34
Ven joined
|
|||
lizmat | nine++ | 08:35 | |
08:35
lizmat left
08:42
lizmat joined
|
|||
FROGGS | hmmm, I could bet I tried the very same thing :o) | 08:44 | |
08:45
domidumont joined
|
|||
ShimmerFairy | nine: that's actually not how it's supposed to work in the first place | 08:47 | |
domm_holiday | Hey, I could use some feedback on a small Perl 6 script I will give a talk on at YAPC::Europe: | ||
github.com/domm/potd/blob/master/potd.p6 | |||
ShimmerFairy | ah, I misread the section on S02 :) | ||
domm_holiday | It's a more or less straightforward port of github.com/domm/potd/blob/master/potd.pl (but the actual Image-resizing etc is still done in Perl5)It's a more or less straightforward port of github.com/domm/potd/blob/master/potd.pl (but the actual Image-resizing etc is still done in Perl5) | ||
I'd appreciate any hints on how to make the code more Perl6ish | |||
As I'm currently traveling through Morocco, my Internet is rather flaky, so feedback via email would work best, although I've got my irssi running in screen :-) | |||
Thanks for any help! | |||
some more context ist linked from here: github.com/domm/potd | 08:48 | ||
nine | ShimmerFairy: it is how it's supposed to work _now_ because the spec tests are the authorative source ;) | ||
ShimmerFairy | nine: thinking about it, I kinda want «1 $a» to be equivalent to «1 "$a"» | ||
despite what S02's section on <> and «» says :) | 08:49 | ||
Ven | domm_holiday: our `if` doesn't need parentheses :) | ||
08:49
lizmat left
|
|||
moritz | domm_holiday: in post_template you can indent the heredoct (both contents and end marker) | 08:49 | |
Ven | domm_holiday: I think instead "shell" it's usually recommended to use the quoting construct (to prevent injection etc) | 08:50 | |
moritz | domm_holiday: also most people tend to put a space between the subroutine and the signature | ||
ah yes, run() if you don't actually need shell interpretation | 08:51 | ||
08:52
bin_005 joined
|
|||
domm_holiday | wow, thanks, see the last few commits in the repo :-) | 08:52 | |
ok, gotta leave now, but any more feedback is of course appreciated :-) | |||
08:54
colomon left
|
|||
moritz | domm_holiday: you can actually indent the contents of the heredoc, and Perl 6 will strip the leading whitespace for you (at most as much as the delimiter is indented) | 08:55 | |
08:55
colomon joined
|
|||
domm_holiday | moritz: ok, so even if I need the file content to start without any spaces, I can indent the heredoc in the code, and perl6 will strip the leading spaces? | 08:56 | |
nice, will have to give this a try | 08:57 | ||
now off for real... | |||
dalek | ast/glr: 60232eb | colomon++ | integration/99problems-21-to-30.t: Move combination sub to the GLR. |
||
Ven | I opened a PR for GTK::Simple, maybe somebody can look at it? :) | ||
tadzik | Thanks to laben++ and nine++ panda master now works on GLR | ||
colomon | \o/ | ||
Ven: it works, right? | |||
Ven | The tests definitely pass, at least :) | 08:58 | |
colomon | Merged. | ||
dalek | k-simple: 64f1603 | vendethiel++ | / (3 files): Remove duplicate `is repr`, add a missing `my` and fix the test deprecation warnings |
||
k-simple: ffe5757 | colomon++ | / (3 files): Merge pull request #13 from vendethiel/master Bring GTK::Simple up to date |
|||
Ven | colomon++ | ||
colomon | Ven++ | ||
hoelzro | o/ # | 08:59 | |
08:59
adu joined
|
|||
tadzik | Looking for `rakudobrew triple` users | 08:59 | |
colomon | tadzik: errr, me, sort of. :) | ||
tadzik | colomon: will you be willing to maintain it as a rakudobrew plugin if I were to split it? | ||
colomon | …. yes? | 09:00 | |
tadzik | k :) | ||
dalek | kudo/glr: 94e6d13 | (Stefan Seifert)++ | src/core/metaops.pm: Allow DWIM RHS of infix HYPER to be lazy If the right hand side of an infix hyper like >>+>> is DWIM (the pointy end points outwards), it may actually be lazy (even infinite) because we shorten it to the length of the left hand side anyway. Fixes (0,0,0,0,0,0) >>+>> (Slip(1,2) xx *) |
||
09:00
AlexDaniel joined
|
|||
JimmyZ | m: note Int | 09:01 | |
camelia | rakudo-moar 906ca0: OUTPUT«(Int)» | ||
GLRelia | rakudo-moar bf1307: OUTPUT«» | ||
09:01
espadrine joined
|
|||
dalek | ast/glr: fd0153c | (Jimmy Zhuo)++ | S16-io/ (2 files): add more test to say.t, update note.t to use Fake IO |
09:02 | |
colomon | m: say ([1, 2], [1, 4]).map(-> $e { say :$e.perl }) | 09:08 | |
camelia | rakudo-moar 906ca0: OUTPUT«:e([1, 2]):e([1, 4])True True» | ||
GLRelia | rakudo-moar bf1307: OUTPUT«:e($[1, 2]):e($[1, 4])TrueTrue» | ||
colomon | m: say ([1, 2], [1, 4]).perl | ||
camelia | rakudo-moar 906ca0: OUTPUT«([1, 2], [1, 4])» | ||
GLRelia | rakudo-moar bf1307: OUTPUT«([1, 2], [1, 4])» | ||
09:09
broquaint joined
09:10
|Tux| left
09:13
|Tux| joined
09:14
brrt left,
brrt joined,
brrt left
09:16
xinming left,
xinming joined
|
|||
colomon | m: say ($_ + 1) if $_ > 5 for 1..10 | 09:17 | |
camelia | rakudo-moar 906ca0: OUTPUT«7891011» | ||
GLRelia | rakudo-moar 94e6d1: OUTPUT«7891011» | ||
colomon | m: say (($_ xx 3).Slip if $_ > 5 for 3, 5, 7, 9) | 09:18 | |
camelia | rakudo-moar 906ca0: OUTPUT«Method 'Slip' not found for invocant of class 'List' in block <unit> at /tmp/UAUVKjZf_m:1» | ||
GLRelia | rakudo-moar 94e6d1: OUTPUT«(Any)(Any)(Any)(Any)(Any)(Any)» | ||
colomon | m: say ($_ xx 3 if $_ > 5 for 3, 5, 7, 9) | ||
GLRelia | rakudo-moar 94e6d1: OUTPUT«(7 7 7)(9 9 9)» | ||
camelia | rakudo-moar 906ca0: OUTPUT«7 7 7 9 9 9» | ||
colomon | m: say (($_ xx 3).list if $_ > 5 for 3, 5, 7, 9) | ||
GLRelia | rakudo-moar 94e6d1: OUTPUT«((Any) (Any) (Any))((Any) (Any) (Any))» | ||
camelia | rakudo-moar 906ca0: OUTPUT«(Any) (Any) (Any) (Any) (Any) (Any)» | ||
colomon | m: say (($_ xx 3) if $_ > 5 for 3, 5, 7, 9) | 09:19 | |
camelia | rakudo-moar 906ca0: OUTPUT«(Any) (Any) (Any) (Any) (Any) (Any)» | ||
GLRelia | rakudo-moar 94e6d1: OUTPUT«((Any) (Any) (Any))((Any) (Any) (Any))» | ||
colomon | m: say ($_ xx 3 if $_ > 5 for 3, 5, 7, 9) | ||
camelia | rakudo-moar 906ca0: OUTPUT«7 7 7 9 9 9» | ||
GLRelia | rakudo-moar 94e6d1: OUTPUT«(7 7 7)(9 9 9)» | ||
dalek | ast/glr: ccf062e | colomon++ | integration/advent2011-day23.t: Add "flat"s needed for GLR. |
09:21 | |
09:22
larion left
|
|||
colomon | m: my @a = (1,2,3).map(*.Int); say @a.perl | 09:27 | |
camelia | rakudo-moar 906ca0: OUTPUT«[1, 2, 3]<>» | ||
GLRelia | rakudo-moar 94e6d1: OUTPUT«[1, 2, 3]» | ||
colomon | m: my ($x, @a) = “dummy”, (1,2,3).map(*.Int); say @a.perl | ||
camelia | rakudo-moar 906ca0: OUTPUT«[1, 2, 3]<>» | ||
GLRelia | rakudo-moar 94e6d1: OUTPUT«[(1, 2, 3).Seq,]» | ||
colomon | GLRers: why is the second result different from the first? | ||
JimmyZ | bug! | ||
colomon | okay, switching over to zip.t for the moment. | 09:36 | |
09:36
aborazmeh joined,
aborazmeh left,
aborazmeh joined
|
|||
colomon | m: my @a = 1, 3, 5; my @b = 2, 4, 6; say (@a Z @b).perl | 09:36 | |
camelia | rakudo-moar 906ca0: OUTPUT«((1, 2), (3, 4), (5, 6))» | ||
GLRelia | rakudo-moar 94e6d1: OUTPUT«((1, 2), (3, 4), (5, 6)).Seq» | ||
colomon | m: my @a = 1, 3, 5; my @b = 2, 4, 6; say zip(@a, @b).perl | 09:37 | |
camelia | rakudo-moar 906ca0: OUTPUT«((1, 2), (3, 4), (5, 6))» | ||
GLRelia | rakudo-moar 94e6d1: OUTPUT«((1, 2), (3, 4), (5, 6)).Seq» | ||
09:37
laben joined
|
|||
laben | hello p6'ers | 09:37 | |
colomon | huh. That’s not what I’m getting in the test suite. | ||
laben: o/ | |||
dalek | ast/glr: d13a1bb | moritz++ | S32-list/map_function_return_values.t: Add a flat |
09:38 | |
hoelzro | o/ laben | ||
nine | m: my @r; say |@r; | 09:39 | |
camelia | rakudo-moar 906ca0: OUTPUT«» | ||
GLRelia | rakudo-moar 94e6d1: OUTPUT«This type does not support elems in block <unit> at /tmp/jSKdW6JNtT:1» | ||
adu | are there any Swagger libs yet? | 09:40 | |
nine | m: my @r; say |@r; | ||
camelia | rakudo-moar 906ca0: OUTPUT«» | ||
GLRelia | rakudo-moar 94e6d1: OUTPUT«This type does not support elems in block <unit> at /tmp/Kme20NQhCS:1» | ||
nine | jnthn: I might need a hint for this one ^^^ | ||
jnthn: looks to me like some .DEFINITE check is missing, but I don't know where. | 09:41 | ||
laben | what is Swagger? | ||
09:41
yeahnoob left
|
|||
tadzik | Flogging Molly album, for what I know :) | 09:41 | |
09:41
rmgk is now known as Guest39027,
rmgk_ joined,
Guest39027 left,
rmgk_ is now known as rmgk
|
|||
adu | laben: swagger.io/ | 09:43 | |
colomon | what I’m seeing in zip.t is (with slightly different args), @a Z @b goes into infix:<Z> with \([0, 2, 4], [1, 3, 5]), while zip(@a; @b) goes into it with \(([0, 2, 4]), ([1, 3, 5])) | ||
adu | laben: It's a JSON format for describing web apis | ||
09:44
larion joined
|
|||
dalek | ast/glr: 9928593 | moritz++ | S32-exceptions/misc.t: Make a test for empty list-like thingy more liberal |
09:44 | |
adu | laben: There's also a codegen thing for Java, but what I was thinking is something like it for Perl6 | ||
dalek | ast/glr: 7e08156 | moritz++ | S32-exceptions/misc.t: Fix test plan a554c9f3aa2429a0ab43325cbd2d70a18239916c removed four tests without adjusting the plan |
09:45 | |
adu | I don't think you would even need codegen with Perl6, you could probably do everything at runtime | 09:46 | |
laben | nine: your recent patch to DWIM hypers is only half, also, in the <<op>> case, it hangs instead of throwing. want me to do the rest? | ||
nine | laben: yeah, please, if you know what's missing, go ahead :0 | 09:47 | |
:) | |||
laben | adu: there is a YAML parser/generator module, the rest seems to be missing | 09:48 | |
colomon | m: say "a" «~« set(<pple bbot rmadillo>) | ||
camelia | rakudo-moar 906ca0: OUTPUT«set(rmadillo, bbot, pple)» | ||
GLRelia | rakudo-moar 94e6d1: OUTPUT«Cannot modify an immutable Set in block <unit> at /tmp/LQ9VZtmkp8:1» | ||
laben | nine: i was thinking i also need to add some tests that we're missing on dwims, like the case i fixed the other day | ||
nine | laben: FWIW I ran a full spectest and did not notice any regressions | 09:49 | |
laben: so yes, more tests are certainly needed | 09:50 | ||
laben | nine: yeah, it's because those cases were not tested. i'll try to add them so they dont regress anymore :) | ||
adu | laben: I guess they are kind of pushing for YAML, but my swagger files are usually JSON | 09:52 | |
moritz | ++laben | ||
jdv79 | is it nomal that t/spec/S32-io/IO-Socket-Async can hang? | ||
looks stuck in a futex:( | |||
moritz | jdv79: uhm, I haven't seen it hang, just fail randomly | ||
jdv79 | maybe i'll update and try again | 09:53 | |
laben | adu: there are loads of JSON parsing/generating modules, the recommended ones are JSON::Fast or JSON::Tiny | ||
09:53
esh joined
|
|||
laben | adu: both work already on glr | 09:53 | |
adu | laben: what's glr? | 09:54 | |
masak | TimToady++ # As to people's Qs | ||
adu | as in the parsing algo? | ||
moritz | adu: the Great List Refactoring, and a branch of the same name in rakudo | ||
09:54
colomon left
|
|||
adu | ah, as in a branch name | 09:55 | |
laben | adu: it means that it will work when the development glr branch will be merged in | ||
adu | I should probably test my parser | ||
Ven | adu: great list refactor | 09:56 | |
09:56
lizmat joined,
bin_005 left
|
|||
moritz | m: my @b = map { hash("v" => $_, "d" => $_ * 2)}, (1, 2, 3); say @b.elems | 09:57 | |
camelia | rakudo-moar 906ca0: OUTPUT«6» | ||
GLRelia | rakudo-moar 94e6d1: OUTPUT«3» | ||
09:57
bin_005 joined
|
|||
laben | btw thanks to nine++ spearheading the work, it seems the majority of the glr troubles were done with. the rest is fixing up the warts and the ecosystem | 09:57 | |
moritz | laben: uhm, there are still ~60 spectest files failing | ||
nine | 59 :) | 09:58 | |
FROGGS | :P | ||
laben | yeah but 60 vs 1000+, i would say quite good | ||
masak | what's 59 test failures between friends, eh? | ||
moritz | not test failures, test *file* failures | ||
lizmat | yeah, what moritz said | 09:59 | |
moritz | many files fail more than one test | ||
laben | work is not complete, but it's 94% of the way there | ||
nine | according to Coke++'s spec test reports, we're actually 99.68 % there | ||
09:59
colomon joined
|
|||
tadzik | [ptc]: ...so I'm thinking to maybe just make an aggresive decision and make panda refuse to install things that don't have version specified with a git tag to go along with it | 10:00 | |
colomon | m: <a b b c c c d d d d>.Set.maxpairs | ||
camelia | ( no output ) | ||
GLRelia | rakudo-moar 94e6d1: OUTPUT«Type check failed for return value; expected 'List' but got 'Seq' in block <unit> at /tmp/spiDCiKGF8:1» | ||
moritz | m: say (1..*).map({}).is-lazy | ||
GLRelia | rakudo-moar 94e6d1: OUTPUT«Cannot call map(Range: Hash); none of these signatures match: ($: &block, :$label, *%_) (HyperIterable:D $: &block, :$label, *%_) in block <unit> at /tmp/PjPjvvV98g:1» | ||
colomon | m: <a b b c c c d d d d>.Set.maxpairs.say | ||
GLRelia | rakudo-moar 94e6d1: OUTPUT«Type check failed for return value; expected 'List' but got 'Seq' in block <unit> at /tmp/b8EtbDYBlf:1» | ||
moritz | m: say (1..*).map({;}).is-lazy | ||
GLRelia | rakudo-moar 94e6d1: OUTPUT«True» | ||
camelia | rakudo-moar 906ca0: OUTPUT«(timeout)» | ||
rakudo-moar 906ca0: OUTPUT«a => True c => True b => True d => True» | |||
rakudo-moar 906ca0: OUTPUT«Method 'is-lazy' not found for invocant of class 'List' in block <unit> at /tmp/jqe4gt54S6:1» | |||
dalek | ast/glr: 1ea8920 | lizmat++ | S02-types/baghash.t: Fix one BagHash test |
10:01 | |
colomon | anyone object to me changing the signature for minpairs and maxpairs in GLR to return Seq instead of List? | 10:02 | |
hoelzro | I know there has been a lot of discussion about flattening in the GLR; is the flattening of slurpy arguments on the chopping block? | ||
lizmat | colomon: I would prefer losing the return sig | 10:03 | |
hoelzro | this fellow here: blogs.perl.org/users/aaron_baugher/...erl-6.html | ||
lizmat | for now | ||
hoelzro | used run(< ffmpeg -i >, $k, < -ab 96k >, "new/%v<newfile>", :out ) | ||
10:03
laouji left
|
|||
colomon | lizmat: works for me. | 10:03 | |
hoelzro | and I'm wondering if the <...> will still flatten | ||
(they currently do, and from my understanding of the GLR, they should still, but things seem to be in flux) | |||
10:03
dayangkun left
|
|||
colomon | lizmat: what are those methods meant to do, anyway? | 10:03 | |
moritz | m: sub f(*@s) { say @s.perl }; f < ffmpeg -i >, $k, < -ab 96k >, "new/%v<newfile>" | ||
camelia | rakudo-moar 906ca0: OUTPUT«5===SORRY!5=== Error while compiling /tmp/UvArV1cTw0Variable '$k' is not declaredat /tmp/UvArV1cTw0:1------> 3(*@s) { say @s.perl }; f < ffmpeg -i >, 7⏏5$k, < -ab 96k >, "new/%v<newfile>"» | ||
GLRelia | rakudo-moar 94e6d1: OUTPUT«5===SORRY!5=== Error while compiling /tmp/jhqp50TfjrVariable '$k' is not declaredat /tmp/jhqp50Tfjr:1------> 3(*@s) { say @s.perl }; f < ffmpeg -i >, 7⏏5$k, < -ab 96k >, "new/%v<newfile>"» | ||
moritz | m: sub f(*@s) { say @s.perl }; f < ffmpeg -i >, (my $k = 2), < -ab 96k >, "new/%v<newfile>" | 10:04 | |
camelia | rakudo-moar 906ca0: OUTPUT«5===SORRY!5=== Error while compiling /tmp/mRj1jbJB_oVariable '%v' is not declaredat /tmp/mRj1jbJB_o:1------> 3eg -i >, (my $k = 2), < -ab 96k >, "new/7⏏5%v<newfile>"» | ||
GLRelia | rakudo-moar 94e6d1: OUTPUT«5===SORRY!5=== Error while compiling /tmp/DHmEycVwT5Variable '%v' is not declaredat /tmp/DHmEycVwT5:1------> 3eg -i >, (my $k = 2), < -ab 96k >, "new/7⏏5%v<newfile>"» | ||
lizmat | colomon: not sure... watching jnthn now | ||
moritz | m: sub f(*@s) { say @s.perl }; f < ffmpeg -i >, (my $k = 2), < -ab 96k >, "new/bla" | ||
camelia | rakudo-moar 906ca0: OUTPUT«["ffmpeg", "-i", 2, "-ab", "96k", "new/bla"]<>» | ||
GLRelia | rakudo-moar 94e6d1: OUTPUT«["ffmpeg", "-i", 2, "-ab", "96k", "new/bla"]» | ||
nine | hoelzro: we only flatten implicitly if you pass a container as a single argument to a function. And only if it's not itemized. | ||
10:04
lizmat left
|
|||
colomon | lizmat: he’s not talking that fast. ;) | 10:04 | |
nine | hoelzro: in all other cases you have to flatten manually. | ||
moritz | nine: but here it's the slurpy that flattens | ||
hoelzro | indeed | 10:05 | |
nine | And from all the spec tests I've fixed where things relied on implicit flattening, this is a very good thing. Sometimes things didn't really work for the reasons the programmer thought they did. Often it was very confusing to find out what was really going on. | ||
dalek | ast/glr: c10975b | moritz++ | S32-list/map.t: GLRify S32-list/map.t |
10:06 | |
moritz | 58 :-) | ||
hoelzro | should slurpies still implicitly flatten, then? | ||
nine | hoelzro: really only if they slurp a single container. Think @a.push(@new-elems); | 10:07 | |
hoelzro: versus @a.push($@sublist) | |||
moritz | why not? There's always ** for when you don't it | ||
laben | can someome explain me the differences between make test, make spectest and make localtest etc? | ||
hoelzro | laben: make test is a quick compiler sanity check | 10:08 | |
10:09
|Tux| left
|
|||
hoelzro | make spectest tests rakudo against the langauge specification tests | 10:09 | |
and make localtest I've just heard of, from you =) | |||
colomon | m: say Set.new([1, 2], 3) | ||
camelia | rakudo-moar 906ca0: OUTPUT«set(1 2, 3)» | ||
GLRelia | rakudo-moar 94e6d1: OUTPUT«312» | ||
moritz | laben: 'spectest' uses t/spectest.data as a list of test files | 10:10 | |
laben: 'localtest' uses t/localtest.data, which is not under version control, so you can fill it with your own set of files | |||
hoelzro .oO( TIL about localtest! ) | 10:11 | ||
laben | thanks moritz! are there other kind of make *test? | ||
hoelzro | laben+ moritz++ | ||
laben: make fulltest | |||
tadzik | make stresstest | ||
hoelzro | laben++ | ||
colomon | laben: make t/spec/S02-types/set.t | ||
(for instance) | |||
laben | and what do they do "fulltest" and "stresstest"? | 10:12 | |
tadzik | iirc fulltest is spectest + stresstest? | ||
makefile probably knows :) | |||
laben | sorry my Makefile fu is not good | ||
oh | |||
moritz | laben: some files are marked as "stress" in t/spectests.data, because they take rather long | ||
tadzik | oh, no | ||
10:13
|Tux| joined
|
|||
tadzik | fulltest is make test + make stresstest, from what I see | 10:13 | |
moritz | and "stresstest" includes them, while normal "make spectest" excludes them | ||
10:13
lizmat joined
|
|||
moritz | "fullltest" runs "test" and "stresstest" | 10:14 | |
colomon | m: say Set.new($[1, 2], 3) | ||
camelia | rakudo-moar 906ca0: OUTPUT«set(3, (Any))» | ||
GLRelia | rakudo-moar 94e6d1: OUTPUT«[1 2]3» | ||
colomon | huh | ||
moritz | m: say Set.new($[1, 2], 3).^name | 10:15 | |
camelia | rakudo-moar 906ca0: OUTPUT«Set» | ||
GLRelia | rakudo-moar 94e6d1: OUTPUT«Set» | ||
moritz | m: say Set.new($[1, 2], 3).gist | ||
GLRelia | rakudo-moar 94e6d1: OUTPUT«set(3, [1 2])» | ||
camelia | rakudo-moar 906ca0: OUTPUT«set(3, (Any))» | ||
laben | thanks again moritz! now i'm ready to enter the world of test-making ^.^ | ||
moritz | colomon: it seems the slurpy in sub say(*@) flattens out the set | ||
m: say Set ~~ Iterable | |||
camelia | rakudo-moar 906ca0: OUTPUT«False» | ||
GLRelia | rakudo-moar 94e6d1: OUTPUT«False» | ||
moritz | m: say Set ~~ Positional | 10:16 | |
camelia | rakudo-moar 906ca0: OUTPUT«False» | ||
GLRelia | rakudo-moar 94e6d1: OUTPUT«False» | ||
colomon | moritz: preivously Set.new([1, 2], 3) does what Set.new($[1, 2], 3) does now. | ||
right, flattening | |||
moritz | m: sub f(*@s) { say @s.perl }; f Set.new([1, 2], 3) | ||
GLRelia | rakudo-moar 94e6d1: OUTPUT«[set(3,1,2)]» | ||
moritz | uhm, no | ||
colomon | hmm? | ||
moritz | the slurpy doesn't flatten it out | 10:17 | |
timotimo | will there be a recording of the q&a? | ||
lizmat | timotimo: yes, there was | ||
timotimo | phew. | ||
i'm not 100% screwed | |||
tadzik | we will never forget | ||
moritz | colomon: I don't understand why &say pretends the set() isn't there | ||
timotimo | the only question i could have thought of was "how did you reach the conclusion that you - out of all the people - would get the colon?" | ||
colomon | moritz: ah | 10:18 | |
lizmat | colomon moritz : I'm looking at set/bag/mix behaviour in glr | ||
we probably need a decision from TimToady | |||
colomon | lizmat: okay. | ||
lizmat | m: say Set.new(<a b c>,<d e>) # is this correct? | ||
GLRelia | rakudo-moar 94e6d1: OUTPUT«acbed» | ||
colomon | lizmat: any objections to my checking in the updated signatures (per your suggestion) for minpairs/maxpairs? | 10:19 | |
lizmat | no objection from me :-) | ||
moritz | m: say Set.new(<a b c>,<d e>).perl | ||
GLRelia | rakudo-moar 94e6d1: OUTPUT«set("a","c","b","e","d")» | ||
moritz | seems rather inconsistent with the rest of GLR | ||
lizmat | yes | ||
however, my first try at fixing this, resulted in some strange issues | 10:20 | ||
gist.github.com/lizmat/72a9b56ea23f4da02363 | 10:21 | ||
tadzik | hoelzro: tadzik uses Pull Request! It's super-effective! | 10:22 | |
hoelzro | Bug has fainted! | ||
moritz | is this some cool new technology from github? | ||
tadzik | we gamified it :) | ||
yay | 10:23 | ||
hoelzro | tadzik++ | ||
tadzik: are you just going through random ecosystem modules? | |||
10:23
|Tux| left
|
|||
tadzik | hoelzro: I started from HTTP::UserAgent | 10:24 | |
that got me to File::Temp | |||
and then I wanted a repl :) | |||
hoelzro | ah ha =) | ||
thanks for the fix | |||
moritz | sounds like Yaks all the way down | 10:25 | |
lizmat | moritz: yeah | 10:26 | |
10:26
|Tux| joined
10:27
pnu left,
espadrine left,
braintwist left,
dalek left,
[Tux] left,
skarn left,
SHODAN left,
synbot6 left,
hobbs left,
krakan left,
camelia left,
larion left,
AlexDaniel left,
zakharyas left,
Woodi left,
Peter_R left,
abaugher left,
nowan left,
Gardner left,
jferrero left,
JimmyZ left,
pink_mist left,
colomon left,
bin_005 left
10:28
lizmat left,
colomon joined
10:29
pnu joined,
larion joined,
AlexDaniel joined,
zakharyas joined,
Woodi joined,
Peter_R joined,
abaugher joined,
nowan joined,
Gardner joined,
jferrero joined,
pink_mist joined,
JimmyZ joined,
Khisanth joined,
kst joined,
erdic joined,
psch joined,
apejens joined,
mathw joined,
El_Che joined
10:30
espadrine joined,
braintwist joined,
dalek joined,
[Tux] joined,
skarn joined,
SHODAN joined,
synbot6 joined,
hobbs joined,
krakan joined,
camelia joined,
mls joined,
oha joined,
ruoso joined,
dg joined,
timbunce joined,
weber.freenode.net sets mode: +vv dalek camelia,
colomon left,
espadrine left,
braintwist left,
dalek left,
[Tux] left,
skarn left,
SHODAN left,
synbot6 left,
hobbs left,
krakan left,
camelia left,
mls left,
oha left,
ruoso left,
dg left,
timbunce left
10:33
espadrine joined,
braintwist joined,
[Tux] joined,
skarn joined,
SHODAN joined,
synbot6 joined,
hobbs joined,
krakan joined,
camelia joined,
mls joined,
oha joined,
ruoso joined,
dg joined,
timbunce joined,
weber.freenode.net sets mode: +v camelia,
dalek joined,
ChanServ sets mode: +v dalek
|
|||
nine | m: my @a = 1,2; my @b = 1,2,3,4; sub test($a, $b) {say $a.perl; say $b.perl;}; test(@a, @b); | 10:34 | |
GLRelia | rakudo-moar 64db54: OUTPUT«[1, 2][1, 2, 3, 4]» | ||
camelia | rakudo-moar 906ca0: OUTPUT«[1, 2][1, 2, 3, 4]» | ||
tadzik | ha, looks like HTTP::UA works on GLR | ||
nine | m: my @a = 1,2; my @b = 1,2,3,4; sub test($a is copy, $b) {say $a.perl; say $b.perl;}; test(@a, @b); | ||
camelia | rakudo-moar 906ca0: OUTPUT«[1, 2][1, 2, 3, 4]» | ||
GLRelia | rakudo-moar 64db54: OUTPUT«[1, 2][1, 2, 3, 4]» | ||
dalek | ast: 5e66cf2 | hoelzro++ | S32-io/copy.t: Test copy() when destination exists |
10:35 | |
ast: 5a81fde | hoelzro++ | S32-io/copy.t: Add tests for copy(:createonly) |
|||
nine | m: my @a = 1,2; my @b = 1,2,3,4,5; use nqp; say nqp::getattr(Range.new(@a, @b), Range, <$!max>).perl; | 10:36 | |
camelia | rakudo-moar 906ca0: OUTPUT«[1, 2, 3, 4, 5]» | ||
GLRelia | rakudo-moar 64db54: OUTPUT«[1, 2, 3, 4, 5]» | ||
10:38
Fleurety joined
|
|||
dalek | ast: c4385c4 | hoelzro++ | S32-io/copy.t: Change copy(:createonly) test to check for X::IO::Copy |
10:40 | |
10:44
Averna joined,
Averna left
|
|||
tadzik | huh, we have 'authors' defined in S22, but most of the ecosystem uses 'author' | 10:44 | |
dalek | kudo/nom: 17a7747 | hoelzro++ | src/core/io_operators.pm: Add :createonly to sub copy() |
||
tadzik | arglebargle | ||
10:45
telex left
|
|||
tadzik | also Please note that for identification purposes, only the owner (who uploaded the distribution to the content storage) should be used | 10:45 | |
so why even have a list there? | |||
10:45
TEttinger left
|
|||
tadzik | oh, the owner *field* | 10:45 | |
...which nobody uses :) | |||
oh, nvm | |||
okay, I got de-confused | 10:46 | ||
10:46
telex joined
10:47
Averna joined,
adu left
10:48
diana_olhovik_ left
|
|||
dalek | kudo/glr: 30cc6a3 | (Stefan Seifert)++ | src/core/Range.pm: Handle lists as right end point of Ranges @a..@b should mean @.elems .. @b.elems. We already had code to explicitly handle a list on the left hand side. That it worked on the right hand side was probably due to some side effect of the implementation that we lost when refactoring. Add code to explicitly handle it once and for all instead. |
10:49 | |
10:51
diana_olhovik_ joined,
Ven left
|
|||
nine | 54! | 10:54 | |
timotimo | after much delay, i'll finally actually head out | 10:55 | |
will i get a bit of noms at the venue to replace my missed breakfast? | |||
nine | timotimo: noms just started | 10:56 | |
timotimo | great! | 10:59 | |
dalek | ast/glr: 0edc6f8 | (Stefan Seifert)++ | S03-operators/repeat.t: Remove obsolete todo marker. Works on GLR now. |
||
nine | 52! | 11:00 | |
laben | nine: can you check on your machine if S03-metaops/hypers.t has regressed? | 11:03 | |
dalek | ast/glr: bb702e3 | (Stefan Seifert)++ | S03-operators/assign.t: Remove another obsolete todo marker. Passes on GLR! |
11:04 | |
laben | m: use Test; eval-dies-ok 'my @a >>[=]>> (1,2,3)', "hypering assignment dies correctly"; | ||
camelia | rakudo-moar 906ca0: OUTPUT«not ok 1 - hypering assignment dies correctly# Failed test 'hypering assignment dies correctly'# at /tmp/FNmySmOsSu line 1» | ||
GLRelia | rakudo-moar 30cc6a: OUTPUT«not ok 1 - hypering assignment dies correctly# Failed test 'hypering assignment dies correctly'# at /tmp/dww0KnenjM line 1» | ||
laben | m: use Test; is True «+« (), (), "left-dwim hyper against empty RHS doesn't hang"; | 11:05 | |
camelia | rakudo-moar 906ca0: OUTPUT«ok 1 - left-dwim hyper against empty RHS doesn't hang» | ||
GLRelia | rakudo-moar 30cc6a: OUTPUT«This type does not support elems in block <unit> at /tmp/L4WrYbKr5Y:1» | ||
11:05
FROGGS left
|
|||
laben | m: True <<+<< () | 11:06 | |
camelia | ( no output ) | ||
GLRelia | rakudo-moar 30cc6a: OUTPUT«This type does not support elems in block <unit> at /tmp/PcziSd9P7K:1» | ||
laben | m: ().elems | ||
camelia | ( no output ) | ||
GLRelia | ( no output ) | ||
laben | m: True.elems | ||
camelia | ( no output ) | ||
GLRelia | ( no output ) | ||
laben | m: my @a >>[=]>> (1,2,3) | ||
GLRelia | ( no output ) | ||
camelia | ( no output ) | ||
laben | m: my @a >>[=]>> (1,2,3); dd @a | 11:07 | |
camelia | rakudo-moar 906ca0: OUTPUT«@a = []<>» | ||
GLRelia | rakudo-moar 30cc6a: OUTPUT«@a = []» | ||
11:13
rurban left
|
|||
nine | laben: the elems error is due to my @r; say |@r; | 11:17 | |
m: my @r; say |@r; | |||
camelia | rakudo-moar 906ca0: OUTPUT«» | ||
GLRelia | rakudo-moar 30cc6a: OUTPUT«This type does not support elems in block <unit> at /tmp/5It1QKwFCs:1» | ||
laben | due to "say" or to flattening? it errors out even without "say", see "True <<+<< ()" | 11:18 | |
m: True <<+<< () | |||
GLRelia | rakudo-moar 30cc6a: OUTPUT«This type does not support elems in block <unit> at /tmp/AL3b2r0YCp:1» | ||
camelia | ( no output ) | ||
laben | the eval one evals without dieing anymore, someone (stub-)implemented hyper assign? | 11:19 | |
m: my @a >>[=]>> (1,2,3); dd @a | |||
camelia | rakudo-moar 906ca0: OUTPUT«@a = []<>» | ||
GLRelia | rakudo-moar 30cc6a: OUTPUT«@a = []» | ||
nine | laben: due to the |@a when @a is empty | 11:21 | |
11:21
lizmat joined
|
|||
laben | i guess i'll wait on that one. what to do on the eval one? change to eval-ok and test that it does not assign anything? | 11:24 | |
11:29
Ven joined
11:31
FROGGS joined
|
|||
FROGGS | yay, I think I got 'for Any {' and friends nailed down | 11:31 | |
11:33
gfldex joined
|
|||
tadzik | wow | 11:33 | |
dalek | kudo/glr: 348886d | FROGGS++ | src/core/ (2 files): make Any.elems==1 and Any.list==(Any) ... as discussed with jnhtn and others. This fixes the issue that you were not able to iterate over a single type object. |
11:34 | |
tadzik | panda's META.info now has 41 lines of "authors" | ||
11:34
lizmat left
|
|||
tadzik | github.com/tadzik/panda/blob/maste...TA.info#L7 | 11:36 | |
that's pure happiness | |||
11:36
domidumont left,
larion left
|
|||
timotimo | \o/ | 11:36 | |
JimmyZ | FROGGS: multi method list(Any:D:) and multi method list(Any:U:) can be just multi method list(Any:)? since the code is same | ||
FROGGS | JimmyZ: aye, forgot to change that... I left it in case I needed it, but it can be simplified | 11:37 | |
11:38
aborazmeh left
|
|||
dalek | ast/glr: fb33c96 | FROGGS++ | S (3 files): follow Any.list beeing 1 |
11:38 | |
nine | FROGGS: btw. I don't see any reason to use infix:<,> to create a List anymore | 11:39 | |
11:39
domidumont joined
|
|||
FROGGS | nine: ohh, I just was lazy I guess | 11:39 | |
didn't thought about it much | |||
timotimo | d'oh, the big room isn't filled very much, but the small one is packed to the brim | 11:43 | |
ab5tract++ is filling up the room quite well | |||
11:49
lizmat joined
|
|||
FROGGS | my patch potentially causes regressions in t/spec/S17-supply/classify.t | 11:50 | |
but I'm not sure | |||
dalek | ast: 5e7d42f | vendethiel++ | S03-metaops/cross.t: fix cross metaop with nested/itemized lists |
||
nine | FROGGS: classify.t has been failing before, too. | 11:51 | |
[Coke] | The Q&A with larry should eventually end up on youtube, I'll let you know when we have a URL. | ||
(they're double checking audio, etc.) | |||
[Coke] is reminded how empty github.com/coke/mojo6 is. :( | 11:52 | ||
tony-o | why doesn't panda precompile anymore? | 11:53 | |
11:54
larion joined
|
|||
moritz | m: my Int %h{Str} = a => 1, b => 2; say %h.pairs.sort.map({.perl(:arglist)}).join(', '); | 11:54 | |
camelia | rakudo-moar 17a774: OUTPUT«"a" => 1, "b" => 2» | ||
GLRelia | rakudo-moar 348886: OUTPUT«:a(1), :b(2)» | ||
moritz | m: my Int %h{Str} = a => 1, b => 2; say %h.perl | ||
camelia | rakudo-moar 17a774: OUTPUT«Hash[Int,Str].new("a" => 1, "b" => 2)» | ||
GLRelia | rakudo-moar 348886: OUTPUT«Hash[Int,Str].new(:a(1), :b(2))» | ||
moritz | m: my Int %h{Str} = a => 1, b => 2; say EVAL(%h.perl).perl | 11:55 | |
camelia | rakudo-moar 17a774: OUTPUT«Hash[Int,Str].new("a" => 1, "b" => 2)» | ||
GLRelia | rakudo-moar 348886: OUTPUT«Hash[Int,Str].new()» | ||
Ven | github.com/rakudo/rakudo/pull/518 | ||
moritz | m: my Int %h{Str} = a => 1, b => 2; say EVAL(%h.perl).elems | ||
camelia | rakudo-moar 17a774: OUTPUT«2» | ||
GLRelia | rakudo-moar 348886: OUTPUT«0» | ||
moritz | m: say Hash.new(:a(1)).perl | ||
camelia | rakudo-moar 17a774: OUTPUT«{}<>» | ||
GLRelia | rakudo-moar 348886: OUTPUT«{}» | ||
11:56
abraxxa left
|
|||
moritz | ah, that's the problem; Hash.perl produces named args, but Hash.new doesn't accept named args | 11:56 | |
dalek | kudo/glr: eda95ad | vendethiel++ | src/core/metaops.pm: make cross metaop respect itemization |
11:58 | |
kudo/glr: c68db93 | niner++ | src/core/metaops.pm: Merge pull request #518 from vendethiel/glr make cross metaop respect itemization |
|||
moritz | TimToady: ^^ the Hash.perl regression seems to be your doing | 11:59 | |
tony-o | yea precomp only sped up parsing by a second, damn. | ||
dalek | osystem: e570cb3 | (Tadeusz “tadzik” Sośnierz)++ | META.list: Retire IO::Select |
12:01 | |
tadzik | oh now dalek doesn't know who I am | ||
where do we fix this? | |||
timotimo | parsing what exactly? | 12:02 | |
tony-o | timotimo: wrong channel, seeing what performance i can get on a from-json method | 12:03 | |
timotimo | ah | 12:04 | |
this is about json::fast, too? | 12:05 | ||
or are you trying a different approach? | |||
tony-o | just trying some different approaches | ||
not sure i can beat json::fast without nativecall, though | |||
timotimo | there's still one thing that's bad about json::fast which is that the loop in nom_ws allocates a BOOTCode every time it starts | 12:07 | |
which means it doesn't get inlined | |||
12:08
Ven left
|
|||
JimmyZ | timotimo: Moarvm has a roadmap about it | 12:10 | |
FROGGS | what is the current test file count? | ||
12:11
Loren joined
12:14
rindolf left
|
|||
nine | I think 50 or 51 | 12:15 | |
12:15
Loren_ joined,
Averna left
|
|||
nine | Fixing List.ACCEPTS may raise that number though :( | 12:15 | |
12:17
lizmat left
12:18
Loren left
12:20
blackcat_ joined
|
|||
FROGGS | huh: | 12:21 | |
t/spec/integration/precompiled.rakudo.moar (Wstat: 0 Tests: 7 Failed: 0) | |||
TODO passed: 6 | |||
I even think that was my patch... as it turned up before I pulled other patches | 12:22 | ||
12:23
Loren joined,
Loren_ left
|
|||
nine | FROGGS: I see nothing wrong with fixing TODOs :) | 12:24 | |
FROGGS | aye :o) | ||
12:25
blackcat_ left
12:27
tinyblak joined
12:31
tinyblak left
12:32
coffee` left
|
|||
nine | If I give List a real ACCEPTS method, S05-modifier and S05-substitution tests start to fail. | 12:34 | |
12:34
lizmat joined
|
|||
moritz | FROGGS: fwiw the precompiled.t test is a flapper here | 12:34 | |
12:34
lizmat left
|
|||
moritz | (the passing TODO) | 12:34 | |
FROGGS | ohh, sad | 12:35 | |
also this? | |||
t/spec/S09-typed-arrays/arrays.rakudo.moar (Wstat: 0 Tests: 77 Failed: 0) | |||
TODO passed: 47, 63 | |||
ohh, and: | 12:36 | ||
t/spec/S04-phasers/begin.rakudo.moar (Wstat: 0 Tests: 13 Failed: 0) | |||
TODO passed: 13 | |||
12:36
brrt joined,
Ven joined
|
|||
timotimo | JimmyZ: that's not a moarvm problem, really; this is about having an intlexref preventing the block from being inlined | 12:37 | |
which i've been trying to improve, but i've been failing, too :| | |||
JimmyZ | you mean lex => local optimization? | 12:38 | |
timotimo | yes | ||
12:39
Ven left
|
|||
JimmyZ | that looks like will reduce the core setting size | 12:42 | |
timotimo | it is likely to, yeah, but it's also a big performance win for tight loops | 12:43 | |
JimmyZ agrees | |||
12:44
Ven joined
|
|||
dalek | ast/glr: f5c11d0 | (Stefan Seifert)++ | S09-typed-arrays/arrays.t: Remove obsolete TODO markers in S09-typed-arrays/arrays.t Thanks to FROGGS++ for pointing this out! |
12:47 | |
nine | m: use Test; my $bound; BEGIN { $bound := 'foo'; } is $bound, 'foo'; | 12:48 | |
camelia | rakudo-moar 17a774: OUTPUT«5===SORRY!5=== Error while compiling /tmp/Ud_rvyt5YwStrange text after block (missing semicolon or comma?)at /tmp/Ud_rvyt5Yw:1------> 3t; my $bound; BEGIN { $bound := 'foo'; }7⏏5 is $bound, 'foo'; expecting any of: infix…» | ||
GLRelia | rakudo-moar c68db9: OUTPUT«5===SORRY!5=== Error while compiling /tmp/PZTttnvq96Strange text after block (missing semicolon or comma?)at /tmp/PZTttnvq96:1------> 3t; my $bound; BEGIN { $bound := 'foo'; }7⏏5 is $bound, 'foo'; expecting any of: infix…» | ||
nine | m: use Test; my $bound; BEGIN { $bound := 'foo'; }; is $bound, 'foo'; | ||
camelia | rakudo-moar 17a774: OUTPUT«not ok 1 - # Failed test at /tmp/5YhQoM8lCY line 1# expected: 'foo'# got: (Any)» | ||
GLRelia | rakudo-moar c68db9: OUTPUT«not ok 1 - # Failed test at /tmp/KfG5bMQIdu line 1# expected: 'foo'# got: (Any)» | ||
12:48
Loren_ joined
|
|||
nine | I don't know why this passes in the spec test file, but it obviously is not fixed yet. | 12:49 | |
12:51
xfix joined,
xfix left,
xfix joined,
Loren left
12:56
larion left
|
|||
nine | m: my @a = any(3, 4); say @a.perl; | 12:56 | |
camelia | rakudo-moar 17a774: OUTPUT«[any(3, 4)]<>» | ||
GLRelia | rakudo-moar c68db9: OUTPUT«[4]» | ||
[Coke] | O_o | 12:57 | |
12:57
larion joined
|
|||
nine | m: my @a = (any(3, 4),); say @a.perl; | 12:57 | |
camelia | rakudo-moar 17a774: OUTPUT«[any(3, 4)]<>» | ||
GLRelia | rakudo-moar c68db9: OUTPUT«[any(3, 4)]» | ||
nine | m: say any(3, 4).item; | 12:58 | |
camelia | rakudo-moar 17a774: OUTPUT«any(3, 4)» | ||
GLRelia | rakudo-moar c68db9: OUTPUT«(timeout)» | ||
nine | That's even more worrying | ||
12:58
adu joined
|
|||
nine | m: say any(3, 4).item.perl; | 12:58 | |
camelia | rakudo-moar 17a774: OUTPUT«any(3, 4)» | ||
GLRelia | rakudo-moar c68db9: OUTPUT«any(3, 4)» | ||
12:59
adu left,
skids joined,
rurban joined
|
|||
ShimmerFairy | m: my @a = any(3, 4); say @a.perl; | 13:03 | |
camelia | rakudo-moar 17a774: OUTPUT«[any(3, 4)]<>» | ||
GLRelia | rakudo-moar c68db9: OUTPUT«[4]» | ||
dalek | pan style="color: #395be5">perl6-examples: 8a9c60d | paultcochrane++ | / (3 files): Add --no-highlight option to htmlify Which passes information about whether or not to run syntax highlighting on to the website object which builds the website. |
13:04 | |
pan style="color: #395be5">perl6-examples: 19b56c7 | paultcochrane++ | / (2 files): Turn off syntax highlighting if --no-highlighting is set |
|||
pan style="color: #395be5">perl6-examples: 7c832ab | paultcochrane++ | Makefile: Add html-nohighlight make target This generates the html without syntax highlighting to speed things up for development work. |
|||
pan style="color: #395be5">perl6-examples: 133f103 | paultcochrane++ | lib/Pod/Htmlify.pm6: Swap back to previous category sorting code |
|||
pan style="color: #395be5">perl6-examples: 6ffeb8a | paultcochrane++ | lib/Pod/Htmlify.pm6: Sort lists of subcategories by key when generating the index page |
|||
[Coke] | hack is MUCH faster today. Probably because everyone is in the talks. | 13:06 | |
[ptc] | _itz: sorting in example subcategories should work again now. The change probably happened after hashes lost their implicit ordering (that was a while ago now) | ||
timotimo | heh. | ||
13:08
muraiki joined
|
|||
[Coke] | m: my ($foo, $bar = "baz") = <a>; say "$foo $bar"; | 13:09 | |
camelia | rakudo-moar 17a774: OUTPUT«Use of uninitialized value $bar of type Any in string context in block <unit> at /tmp/zhNVztssuh:1a » | ||
GLRelia | rakudo-moar c68db9: OUTPUT«Use of uninitialized value $bar of type Any in string context in block <unit> at /tmp/Wrqq6JMeKx:1a » | ||
13:10
Loren_ left
|
|||
[Coke] | m: enum A (b => 42, <c d e>); say A.enums.perl | 13:12 | |
camelia | rakudo-moar 17a774: OUTPUT«{:b(42), "c d e" => 43}<>» | ||
GLRelia | rakudo-moar c68db9: OUTPUT«{:b(42), "c d e" => 43}» | ||
[Coke] | ^^ does that look acceptable? | ||
RT #115052 | |||
synbot6 | Link: rt.perl.org/rt3/Public/Bug/Display...?id=115052 | ||
13:13
smls joined
13:17
plicease left,
plicease joined,
Ven left
|
|||
moritz | [Coke]: I agree with RT #123191 that it should flatten the list, i.e. produces b => 42, c => 43, d => 43, e => 44 | 13:18 | |
synbot6 | Link: rt.perl.org/rt3/Public/Bug/Display...?id=123191 | ||
[Coke] | moritz: can I merge those tickets? | 13:19 | |
(I see they are referring to each other) | 13:20 | ||
moritz | [Coke]: no, I'd simply close RT #115052 | ||
synbot6 | Link: rt.perl.org/rt3/Public/Bug/Display...?id=115052 | ||
moritz | [Coke]: the error doesn't appear anymore | ||
brrt | javascript is becoming more.. .perly, apparantly | 13:21 | |
v8project.blogspot.nl/2015/08/v8-release-46.html | 13:22 | ||
skids | Reminder for hackathon folks, when you get to unflattenning the sub forms in Any-iterable, see gist.github.com/skids/4f6ff2e1c1e3b6855773 it fixes some stuff that can be tricky to find. | ||
I never sent a PR for the brach I had where I was doing that, because it was pre-GLRR. | |||
FROGGS | m: my $x = do if 0 { 1 } elsif 0 { 2 }; say $x | 13:23 | |
camelia | rakudo-moar 17a774: OUTPUT«Empty» | ||
GLRelia | rakudo-moar c68db9: OUTPUT«» | ||
FROGGS | m: my $x = do if 0 { 1 } elsif 0 { 2 }; say $x.defined | ||
camelia | rakudo-moar 17a774: OUTPUT«False» | ||
GLRelia | rakudo-moar c68db9: OUTPUT«True» | ||
FROGGS | m: my $x = do if 0 { 1 } elsif 0 { 2 }; say $x.WHAT | ||
camelia | rakudo-moar 17a774: OUTPUT«Empty» | ||
GLRelia | rakudo-moar c68db9: OUTPUT«(Slip)» | ||
FROGGS | should this be Nil by any chance? | ||
13:24
larion left
|
|||
moritz | how do I iterate a Perl 6 Iterable from NQP? | 13:26 | |
FROGGS | uff | 13:28 | |
moritz | this is for rt.perl.org/Public/Bug/Display.html?id=123191 where we should flatten a sublist | 13:32 | |
nine | skids! | 13:33 | |
skids | o/ | ||
13:34
bloonix joined
|
|||
FROGGS | m: for 1..2 { FIRST { say "hello $_" } } | 13:34 | |
camelia | rakudo-moar 17a774: OUTPUT«hello 1» | ||
GLRelia | ( no output ) | ||
13:34
virtualsue joined
|
|||
nine | skids: I found out that our List .ACCEPTS just about everything. If I fix that by giving it an implementation the S05-modifier tests start failing. Can you have a look? | 13:34 | |
13:35
Loren_ joined
|
|||
skids | nine: I'm at $DAYJOB, unfortunately. | 13:35 | |
13:37
lizmat joined
|
|||
nine | skids: any idea where I could look at? | 13:42 | |
13:44
Ven joined
|
|||
skids | nine: Well there are a couple smartmatches in there but they should only happen to Ranges. | 13:45 | |
dalek | c: 2e91532 | hoelzro++ | lib/Language/unicode_entry.pod: Mention Vim's unicode digraphs |
13:46 | |
skids | nine: which tests fail? | 13:47 | |
13:51
lizmat left
|
|||
timotimo | phew, it's really rather warm | 13:52 | |
skids | nine: I'd look at '$multi = Positional.ACCEPTS($nth);' which is supposed to determine which code to run at the bottom. (e.g. detect :nth(3) vs :nth(2,3) or :nth(2,4...*)) | 13:53 | |
13:56
virtualsue left
14:07
coffee` joined
|
|||
dalek | kudo/nom: 97ae81f | hoelzro++ | src/core/Exception.pm: Add X::IO::Move |
14:09 | |
kudo/nom: eb6de6d | hoelzro++ | src/core/ (2 files): Implement IO.move() and move() |
|||
ast: 66de147 | hoelzro++ | S32-io/move.t: Add test for move() and IO.move() |
|||
14:10
andreoss joined
|
|||
nine | skids: ok('abab' ~~ m:2x/ab/, ':2x (repetition) modifier (+)'); | 14:10 | |
andreoss | m: my @x = do for 1..10 { start { } }; map await, @x | ||
camelia | rakudo-moar 17a774: OUTPUT«Must specify a Promise or Channel to await on in block <unit> at /tmp/GXm1XcYyU6:1» | ||
GLRelia | rakudo-moar c68db9: OUTPUT«Must specify a Promise or Channel to await on (got an empty list) in block <unit> at /tmp/OV08Wr31k_:1» | ||
andreoss | where does this empty list come from? | 14:11 | |
masak | phew, talks are over. | ||
correction: I don't have to give more talk :) | 14:12 | ||
14:12
Sqirrel left
|
|||
nine | skids: Positional.ACCEPTS?? But Positional is just a Role and an almost empty at that. | 14:13 | |
skids | nine: ok then not that ACCEPTS line it does not get hit without :nth. The line (0..Inf).Array would be hit only when :x but no :nth. | 14:14 | |
nine | Ah, timotimo++ cleared it up. Positional.ACCEPTS($nth) is just a different way to write nqp::istype($nth, Positional) | 14:15 | |
andreoss | m: my @z = 1..10; my @x = do while my @z.shift { start { $_ } }; say await @x | 14:16 | |
camelia | rakudo-moar 17a774: OUTPUT«Potential difficulties: Redeclaration of symbol @z at /tmp/TWd0nXQ198:1 ------> 3my @z = 1..10; my @x = do while my @z7⏏5.shift { start { $_ } }; say await @x» | ||
GLRelia | rakudo-moar c68db9: OUTPUT«Potential difficulties: Redeclaration of symbol @z at /tmp/xncxmTdYzt:1 ------> 3my @z = 1..10; my @x = do while my @z7⏏5.shift { start { $_ } }; say await @x» | ||
nine | I think, I start to understand what's happening. match returns a list in those nth-cases. That's why implementing ACCEPTS on List changes the outcome. | ||
andreoss | m: my @z = 1..10; my @x = do while @z.shift { start { $_ } }; say await @x | ||
camelia | rakudo-moar 17a774: OUTPUT«» | ||
GLRelia | rakudo-moar c68db9: OUTPUT«» | ||
14:17
andreoss left
|
|||
skids | nine: Yes and it should hit the listgen code for anything with an :x as well. The above test does not have an :nth so if it is the only one failing I'd look at (0..Inf).Array. | 14:18 | |
14:18
andreoss joined
|
|||
andreoss | m: my @z = 1..10; my @x = do while my $u = @z.shift { start { $u } }; await @x | 14:19 | |
camelia | ( no output ) | ||
GLRelia | ( no output ) | ||
hoelzro | m: ''.substr(0, *-16) | ||
camelia | ( no output ) | ||
GLRelia | ( no output ) | ||
hoelzro | m: say(''.substr(0, *-16)) | ||
camelia | rakudo-moar 17a774: OUTPUT«Number of characters argument to substr out of range. Is: -16, should be in 0..Inf; use *-16 if you want to index relative to the end in block <unit> at /tmp/0VjtwxJfe7:1» | ||
GLRelia | rakudo-moar c68db9: OUTPUT«Number of characters argument to substr out of range. Is: -16, should be in 0..Inf; use *-16 if you want to index relative to the end in block <unit> at /tmp/NksYpL0ufB:1» | ||
nine | Soo...is it possible, that nth does not actually work all that well? | ||
hoelzro | ^ is that a bug? | ||
14:19
lizmat joined
|
|||
skids | nine: (not that I understand the bottom part of that method too well :-) | 14:19 | |
nine | m: say "foo" ~~ m:2x/foo/; | ||
camelia | rakudo-moar 17a774: OUTPUT«» | ||
GLRelia | rakudo-moar c68db9: OUTPUT«» | ||
masak | m: class C { has $.foo is rw where { $++ < 2 } }; given C.new { .foo = 1; say .foo; .foo = 2; say .foo; .foo = 3 } | ||
camelia | rakudo-moar 17a774: OUTPUT«12Type check failed in assignment to '$!foo'; expected '<anon>' but got 'Int' in block <unit> at /tmp/U0mQkWTVfZ:1» | 14:20 | |
GLRelia | rakudo-moar c68db9: OUTPUT«12Type check failed in assignment to '$!foo'; expected '<anon>' but got 'Int' in block <unit> at /tmp/_93IAw7zwk:1» | ||
masak | hee hee | ||
state variables in where blocks... :) | |||
nine | Aaaaaah...now it makes sense! | ||
List had the following ACCEPTS method: multi method ACCEPTS(List:D:, $topic) { self } | |||
timotimo | ... how does it make sense? | 14:21 | |
does having that method make sense? or does behavior caused by this make sense now? | |||
nine | Str.match will return a list of matches for the nth-stuff. If this list was empty, List.ACCEPTS would boolify to False. If it contained Matches (because the match was successfull) it boolifies to True. | ||
TimToady | List is one of the distinguished "result" types that prevent a redispatch to .ACCEPTS | ||
timotimo | oooooh | ||
masak | wow, I didn't know about that | 14:22 | |
TimToady | like True, False | ||
timotimo | i remember something about that | ||
JimmyZ | m: class C { has $.foo is rw where { $++ < 2 } }; given C.new { .foo = 3; say .foo; .foo = 5; say .foo; .foo = 3 } | ||
GLRelia | rakudo-moar c68db9: OUTPUT«35Type check failed in assignment to '$!foo'; expected '<anon>' but got 'Int' in block <unit> at /tmp/BciYcQ8pDD:1» | ||
camelia | rakudo-moar 17a774: OUTPUT«35Type check failed in assignment to '$!foo'; expected '<anon>' but got 'Int' in block <unit> at /tmp/QpoUT_f16t:1» | ||
nine | TimToady: this messes up (1, 2, 3) ~~ (1, 2, 3) now | ||
timotimo | the number of times we typecheck isn't guaranteed, though | ||
14:23
Sqirrel joined
|
|||
smls | Is there a list versio of join? | 14:23 | |
TimToady | m: say (1,2,3) ~~ [1,2,3] | ||
camelia | rakudo-moar 17a774: OUTPUT«True» | ||
GLRelia | rakudo-moar c68db9: OUTPUT«True» | ||
TimToady | list matching wants its own pattern language anyway | ||
tadzik | smls: list version of join? | ||
timotimo | what does "list version of join" mean? | ||
yeah | |||
nine | TimToady: or rather (1, 2, 3) ~~ (4, 5) | 14:24 | |
m: say (1, 2, 3) ~~ (4, 5) | |||
camelia | rakudo-moar 17a774: OUTPUT«False» | ||
GLRelia | rakudo-moar c68db9: OUTPUT«45» | ||
TimToady | m: say (1,2,3) ~~ [1,2] | ||
camelia | rakudo-moar 17a774: OUTPUT«False» | ||
GLRelia | rakudo-moar c68db9: OUTPUT«False» | ||
smls | i.e. joining (2, 4, 5) with 0 --> 2, 0, 4, 0, 5 | ||
timotimo | looks a bit like a zip + flatten | ||
well, and you'd hack off the last bit | |||
smls | except zip adds an extra one at the start or end | ||
TimToady | you can match using an array currently, but we want something like (1,2,3) ~~ pattern 1,2,3,* | ||
timotimo | m: my @in = 2, 4, 6; my @our = flat (@in X 0); say @our.perl | 14:25 | |
camelia | rakudo-moar 17a774: OUTPUT«[2, 0, 4, 0, 6, 0]<>» | ||
GLRelia | rakudo-moar c68db9: OUTPUT«[2, 0, 4, 0, 6, 0]» | ||
timotimo | i meant X rather than Z btw | ||
smls | trying to find the best way to generate an argument list of the form \( -name "*.txt" -o -name "*.htm" \) for pasing to the Linux `find` command | ||
(but kept as a list so it can be called without shell quoting) | 14:26 | ||
14:26
szabgab joined
|
|||
masak | m: say (1, 2, 3) ~~ (1, 2, 3) | 14:26 | |
camelia | rakudo-moar 17a774: OUTPUT«True» | ||
GLRelia | rakudo-moar c68db9: OUTPUT«123» | ||
14:26
khw joined
|
|||
nine | TimToady: then I will change the S03-smartmatch/array-array.t tests to match against Array instead of List | 14:26 | |
szabgab | good afternoon | ||
timotimo | heyo szabgab | 14:27 | |
masak | szabgab! \o/ | ||
timotimo | i remember having results from multi-match was rather hairy | ||
14:27
lizmat left
|
|||
tadzik | hey szabgab! | 14:27 | |
geekosaur | if you're avoiding the shell then it's just '(', '-name', '*.txt', '-o', '-name', '*.htm', ')' | ||
TimToady | well, we really do want to steal the wildcarding and give it to a special list pattern type | ||
szabgab | is there going to be a new rakudo * release soon? I'd like to build environment for my YAPC::EU talk | ||
and I wonder if I should use 2015.07 or wait for 08 ? | 14:28 | ||
masak | was there a compiler release yesterday? | ||
szabgab | masak: are you asking me? | 14:29 | |
I have no idea | |||
or was that a rhetorical question? | |||
geekosaur | general channel question | ||
masak | it was a question to the channel | ||
but it was connected to your question :) | |||
skids | m: (gather for 1,2,3 { once { take $_; next }; take 0; take $_; }).perl.say | 14:30 | |
camelia | rakudo-moar 17a774: OUTPUT«(1, 0, 2, 0, 3)» | ||
GLRelia | rakudo-moar c68db9: OUTPUT«(1, 0, 2, 0, 3).Seq» | ||
nine | TimToady: if I use Array.ACCEPTS' logic in List for Iterable $topics and the old ?self for everything else, we pass S03-smartmatch/array-array.t without any regressions. | 14:32 | |
timotimo | i know moritz worked towards a release | ||
masak | # Announce: Rakudo Perl 6 compiler, Development Release #91 ("TBD") | 14:33 | |
so not fully released. | |||
dalek | ast: 87d1e68 | alexghacker++ | S15-nfg/cgj.t: Create cgj.t |
||
ast: 79585f0 | alexghacker++ | S15-nfg/cgj.t: Update cgj.t Add comments with references for the behavior being tested for |
|||
ast: 8bb05dc | (Zoffix Znet)++ | S15-nfg/cgj.t: Merge pull request #66 from alexghacker/master Create tests for the COMBINING GRAPHEME JOINER special case |
|||
masak | szabgab: coming back to your question, I don't see why we wouldn't have a star release after the compiler release. but we haven't had the compiler release just yet. | 14:34 | |
szabgab | ok | ||
dalek | c: 7678c0f | hoelzro++ | lib/Type/IO/Path.pod: Remove not implemented warning for move() Because now it *is* implemented! |
14:35 | |
c: 12172fc | hoelzro++ | lib/Type/IO/Path.pod: Document copy() |
|||
masak | (I don't usually make the star release, so this is a guess, not a promise) :) | ||
skids | m: (flat (slip(),0,0...*) Z, (1,2,3)).perl.say # smls | 14:36 | |
GLRelia | rakudo-moar c68db9: OUTPUT«(0, 1, 0, 2, 0, 3)» | ||
camelia | rakudo-moar 17a774: OUTPUT«5===SORRY!5=== Error while compiling /tmp/XlZL0oeqHqUndeclared routine: slip used at line 1. Did you mean 'flip'?» | ||
timotimo | if you made a promise, szabgab could non-blockingly wait, rather than having to poll :) | ||
szabgab | and this will be a star release using panda with breaks | ||
:) | |||
masak | 'panda with breaks'? | ||
tadzik | panda's broken? | ||
timotimo | "brakes" | ||
i bet :P | |||
masak | 'brakes'? | ||
szabgab | brakes | ||
right | |||
tadzik | oh:) yeah | ||
masak | like, on a bike? | ||
timotimo | yes | 14:37 | |
szabgab | tadzik knows :) | ||
tadzik | a slowdown so shocking you'll hit the pavement with your face | ||
timotimo | poor pavement | ||
tadzik | yeah, take that! | ||
szabgab: thought I hope that it'll make updating panda on Star much more reliable | 14:38 | ||
which I see is a pain for a while | |||
smls | skids: How come replacing 0,0...* with (0 xx *) does not work in that example? | ||
(hangs indefinitely) | |||
skids | smls: the whole thing is one sequence and gets flattenned due to first arg rule. | 14:39 | |
(the slip is part of the ...) | |||
smls | but isn't flattening lazy? | ||
14:40
Ven left
|
|||
hoelzro | m: say(''.substr(0, *-16)) | 14:41 | |
GLRelia | rakudo-moar c68db9: OUTPUT«Number of characters argument to substr out of range. Is: -16, should be in 0..Inf; use *-16 if you want to index relative to the end in block <unit> at /tmp/k8j5ZO1v7c:1» | ||
camelia | rakudo-moar 17a774: OUTPUT«Number of characters argument to substr out of range. Is: -16, should be in 0..Inf; use *-16 if you want to index relative to the end in block <unit> at /tmp/0a7smABWrP:1» | ||
hoelzro | ^ is that a bug? | ||
szabgab | I think I move myself to the background again and check the web site for announcement | 14:42 | |
see some of you in Granada! | |||
14:43
szabgab left
14:44
lizmat joined
|
|||
lizmat | gist.github.com/lizmat/72a9b56ea23f4da02363 | 14:44 | |
TimToady | hoelzro: looks LTA to me | 14:45 | |
hoelzro | TimToady: I'm thinking it should result in an empty string, does that same ok? | ||
14:46
tinyblak joined
|
|||
TimToady | we've been treating off-the-beginning as an error, but it shouldn't recommend what you just said... | 14:47 | |
14:48
colomon joined
|
|||
skids | smls: 1,0..* Z, (1,2,3) would produce (1,1,0..*,2) which is then fed to flat. Which should be lazy but maybe it is eagerized after that somehow. | 14:48 | |
smls | skids: xx not .. | 14:49 | |
(though I guess the same applies?) | |||
skids | right, sorry. | 14:50 | |
colomon | lizmat: have you managed to talk with TimToady about set / bag construction? | ||
colomon is just now back on the Internet. | 14:51 | ||
14:53
itz joined,
yqt joined
|
|||
hoelzro | TimToady: what about arrays? should my @a; @a[0..*-16] doesn't result in an error | 14:53 | |
_itz | [ptc]: yay! that looks great again | 14:54 | |
nine | m: say (1,2,3) ~~ (4,5) | ||
GLRelia | rakudo-moar c68db9: OUTPUT«45» | ||
camelia | rakudo-moar eb6de6: OUTPUT«False» | ||
TimToady | hoelzro: that's just a null range | ||
nine | m: say (1,2,3) ~~ (1,2,3) | ||
camelia | rakudo-moar eb6de6: OUTPUT«True» | ||
GLRelia | rakudo-moar c68db9: OUTPUT«123» | ||
hoelzro | ahhhh | ||
14:54
tinyblak left
|
|||
hoelzro | that makes sense | 14:54 | |
TimToady | m: say(''.substr(0 .. *-16)) | 14:55 | |
GLRelia | rakudo-moar c68db9: OUTPUT«Type check failed in assignment to '$from'; expected 'Int' but got 'Range' in block <unit> at /tmp/Ybkh9OSlHY:1» | ||
camelia | rakudo-moar eb6de6: OUTPUT«Type check failed in assignment to '$from'; expected 'Int' but got 'Range' in block <unit> at /tmp/0Yh8hsXKLB:1» | ||
andreoss | is there something soft close on channels? like saying to it that this element is the last one? | ||
14:55
virtualsue joined
|
|||
TimToady | hmm, I thought we had a range form of substr | 14:55 | |
14:55
ab6tract joined
|
|||
FROGGS | m: say substr("foobar", 1..4) | 14:56 | |
camelia | rakudo-moar eb6de6: OUTPUT«ooba» | ||
GLRelia | rakudo-moar c68db9: OUTPUT«ooba» | ||
14:56
tinyblak joined
|
|||
FROGGS | m: say "foobar".substr(1..4) | 14:56 | |
camelia | rakudo-moar eb6de6: OUTPUT«ooba» | ||
GLRelia | rakudo-moar c68db9: OUTPUT«ooba» | ||
ab6tract | m: sub arr-ret { [<for many things>] }; my ($one,$two,$three) = arr-ret | ||
camelia | ( no output ) | ||
GLRelia | ( no output ) | ||
_itz | how late are the talks in the main room now running roughly? | ||
ab6tract | m: sub arr-ret { [<for many things>] }; say my ($one,$two,$three) = arr-ret | ||
camelia | rakudo-moar eb6de6: OUTPUT«for many things (Any) (Any)» | ||
GLRelia | rakudo-moar c68db9: OUTPUT«formanythings» | ||
ab6tract | so that question is answered :) | 14:57 | |
TimToady | m: say substr("foobar", 1..-9) | 14:58 | |
camelia | rakudo-moar eb6de6: OUTPUT«Number of characters argument to substr out of range. Is: -9, should be in 0..Inf; use *-9 if you want to index relative to the end in block <unit> at /tmp/XDEI7GXCJF:1» | ||
GLRelia | rakudo-moar c68db9: OUTPUT«Number of characters argument to substr out of range. Is: -9, should be in 0..Inf; use *-9 if you want to index relative to the end in block <unit> at /tmp/PllVFxG9cQ:1» | ||
dalek | kudo/glr: 51b313b | (Stefan Seifert)++ | src/core/List.pm: Make smartmatching Iterables against Lists use same semantics as Arrays S03-smartmatch/array-array.t tests smartmatching against Lists. TimToady++ suggests adding some pattern type for smart matching against lists. However, we're trying to get to the same functional level as nom now. We can always create new semantics later. Makes array-array.t pass. |
||
TimToady | m: say substr("foobar", 2..2) | 14:59 | |
camelia | rakudo-moar eb6de6: OUTPUT«o» | ||
GLRelia | rakudo-moar c68db9: OUTPUT«o» | ||
TimToady | m: say substr("foobar", 2..1) | ||
camelia | rakudo-moar eb6de6: OUTPUT«» | ||
GLRelia | rakudo-moar c68db9: OUTPUT«» | ||
colomon | TimToady: I think we talked about having a range form of substr, but there were objections? But I may have missed something, I’ve been not faithfully backlooging the last few months. | ||
TimToady | m: say substr("foobar", 2..-1) | ||
camelia | rakudo-moar eb6de6: OUTPUT«Number of characters argument to substr out of range. Is: -2, should be in 0..Inf; use *-2 if you want to index relative to the end in block <unit> at /tmp/mWgvVrORU9:1» | ||
GLRelia | rakudo-moar c68db9: OUTPUT«Number of characters argument to substr out of range. Is: -2, should be in 0..Inf; use *-2 if you want to index relative to the end in block <unit> at /tmp/avzl8U6xIq:1» | ||
TimToady | that should really treat any null range the same | ||
and it's just a wrong message anyway | 15:00 | ||
15:05
virtualsue_ joined,
virtualsue left
|
|||
tony-o | got json grammar down to 3.8s but that's still a 2 full seconds slower than built-in..gonna try streaming | 15:05 | |
15:05
virtualsue_ is now known as virtualsue
|
|||
tony-o | and coffee. | 15:05 | |
15:06
diana_olhovik_ left
|
|||
timotimo | mhhh, streaming coffee | 15:06 | |
tony-o | so gooood | 15:08 | |
_itz | my $coffee=Supply.new() | 15:09 | |
$coffee.tap | |||
dalek | ast/glr: 971583a | (Stefan Seifert)++ | S12-introspection/WHAT.t: Skip TODO tests that now fail fatally |
15:10 | |
hoelzro | I missed that while moving rooms - we have sub substr(Range), but not method substr(Str:D: Range)? | 15:11 | |
FROGGS | hoelzro: we have both | ||
hoelzro | oh, ok, I must've mistread | ||
*misread | |||
FROGGS | just negative and watevercode endpoints are handled wrongish | ||
hoelzro | ahhhhh yes | 15:12 | |
dalek | pan style="color: #395be5">perl6-examples: 45f1eb6 | paultcochrane++ | t/categories/euler.t: Skip long running examples when running tests |
15:13 | |
pan style="color: #395be5">perl6-examples: 13177d5 | paultcochrane++ | t/categories/euler.t: Improve skipping code |
|||
pan style="color: #395be5">perl6-examples: f418282 | paultcochrane++ | t/categories/euler.t: Correct number of planned Euler tests |
|||
pan style="color: #395be5">perl6-examples: 9f9f3d0 | paultcochrane++ | t/categories/euler.t: Skip prob034 as it takes too long in tests |
|||
pan style="color: #395be5">perl6-examples: 4122609 | paultcochrane++ | t/categories/euler.t: Fix spacing between Euler subtests |
|||
pan style="color: #395be5">perl6-examples: 55ec5cb | paultcochrane++ | t/categories/euler.t: Fix Euler test ordering |
|||
15:14
Ven joined
15:15
andreoss left
15:16
itz left,
larion joined
15:20
virtualsue left
|
|||
masak | by the way -- I just read that p6u thread -- my opinion is that we should have 'use strict' on in one-liners. | 15:23 | |
I've never felt helped by it being off, and I've sometimes been burned by it. | |||
15:23
tinyblak left
15:24
tinyblak joined
15:25
larion left
|
|||
Ven | masak: isn't it on these days? | 15:25 | |
no, I'm wrong. Anyway, I agree. `alias 6=perl6 -M-no-strict` or w/e is fine by me | |||
15:26
Ven left
|
|||
TimToady | so mot it be | 15:26 | |
tadzik | do we have no-strict? | ||
FROGGS | we have | ||
tadzik | oh, neat :) | ||
masak | TimToady: 'mot'? does that mean you agree we can change it to strict-on-by-default for one-liners? :) | 15:29 | |
TimToady | nodnod | ||
masak | \o/\o/ | ||
kudos to whoever makes it so | 15:30 | ||
15:30
tinyblak left
|
|||
masak | I'm gonna scurry back to the venue | 15:30 | |
if it's not fixed before I get there, I'll make it so :P | |||
& | |||
15:32
zakharyas left
15:35
spebern joined,
spebern left
|
|||
dalek | kudo/glr: 901d7c4 | (Stefan Seifert)++ | src/core/array_slice.pm: Implement multi-dim array assignment |
15:36 | |
FROGGS | I think I fixed the FIRST issue | ||
15:38
brrt left
15:39
ab6tract left,
tinyblak joined
15:43
cognominal left
15:44
tinyblak left
|
|||
nine | m: my @a = [0]; @a[0][0]++; say @a.perl; | 15:45 | |
camelia | rakudo-moar eb6de6: OUTPUT«[[1]]<>» | ||
GLRelia | rakudo-moar 901d7c: OUTPUT«Cannot assign to an immutable value in block <unit> at /tmp/XYlDK5Q7GT:1» | ||
nine | Why is this even allowed to work much less expected? | ||
dalek | kudo/nom: 5fb81ff | (Carl Masak)++ | src/Perl6/World.nqp: strict is now on by default, even for -e This should make (most of) p6u happy. |
||
laben | m: my @a = [0]; dd @a | 15:46 | |
camelia | rakudo-moar eb6de6: OUTPUT«@a = [[0]]<>» | ||
GLRelia | rakudo-moar 901d7c: OUTPUT«@a = [0]» | ||
laben | m: my @a = [0]; dd @a[0] | ||
camelia | rakudo-moar eb6de6: OUTPUT«@a = [0]» | ||
GLRelia | rakudo-moar 901d7c: OUTPUT«@a = 0» | ||
laben | m: my @a = [0]; dd @a[0][0] | 15:47 | |
camelia | rakudo-moar eb6de6: OUTPUT«<element> = 0» | ||
GLRelia | rakudo-moar 901d7c: OUTPUT«0» | ||
laben | m: my @a = [0]; dd @a[0][0]++ | ||
camelia | rakudo-moar eb6de6: OUTPUT«0» | ||
GLRelia | rakudo-moar 901d7c: OUTPUT«Cannot assign to an immutable value in block <unit> at /tmp/DQShfIsIeL:1» | ||
nine | Oh, so this test really means my @a = (0)? | ||
15:47
salva left
|
|||
nine | err... my @a = $[0]; really | 15:49 | |
laben | m: my @a = [0],; dd @a | ||
camelia | rakudo-moar eb6de6: OUTPUT«@a = [[0]]<>» | ||
GLRelia | rakudo-moar 901d7c: OUTPUT«@a = [[0],]» | ||
laben | m: my @a = [0],; dd @a[0][0]++ | ||
camelia | rakudo-moar eb6de6: OUTPUT«0» | ||
GLRelia | rakudo-moar 901d7c: OUTPUT«0» | ||
timotimo | - QAST::Stmt my int $foo | ||
- QAST::Var(lexicalref $foo :decl()) $foo | |||
why the F... do we declare this to be lexicalref? | |||
dalek | ast/glr: 4e91c07 | (Stefan Seifert)++ | S09-autovivification/autoincrement.t: Fix creation of nested arrays in S09-autovivification/autoincrement.t |
15:50 | |
kudo/glr: 0b76e79 | lizmat++ | src/core/ (2 files): Give Set/Bag/Mix single arg semantics, nine++ |
|||
colomon | m: say rindex( 'xxy','y', $pos ) | ||
camelia | rakudo-moar eb6de6: OUTPUT«5===SORRY!5=== Error while compiling /tmp/QdgMvkrHBCVariable '$pos' is not declaredat /tmp/QdgMvkrHBC:1------> 3say rindex( 'xxy','y', 7⏏5$pos )» | ||
GLRelia | rakudo-moar 901d7c: OUTPUT«5===SORRY!5=== Error while compiling /tmp/ZuxG_JNOxKVariable '$pos' is not declaredat /tmp/ZuxG_JNOxK:1------> 3say rindex( 'xxy','y', 7⏏5$pos )» | ||
tadzik | timotimo: ¯\_(ツ)_/¯ | 15:51 | |
dalek | kudo/glr: 15b06d0 | FROGGS++ | src/core/Any-iterable-methods.pm: fire FIRST phaser |
15:52 | |
FROGGS | another test file down! | ||
15:53
andreoss joined
|
|||
colomon | lizmat++ nine++ | 15:56 | |
m: say rindex( 'xxy','y', -1e34 ) | |||
camelia | rakudo-moar eb6de6: OUTPUT«Nil» | ||
GLRelia | rakudo-moar 901d7c: OUTPUT«Nil» | ||
nine | 48 current official count | 15:58 | |
jdv79 | is Pod::To::HTML broken for anyone else on nom? | ||
colomon | lizmat: are you working on getting the bag/set/etc test files working, or shall I? | ||
15:58
FROGGS left
|
|||
tadzik | I think panda just broke on glr | 15:58 | |
15:59
Ven joined,
Ven left
|
|||
dalek | kudo/glr: 186223e | (Stefan Seifert)++ | src/core/List.pm: Fix List.ACCEPTS regression List.ACCEPTS really has to return the list and not boolify too early. Otherwise my @matches = $foo ~~ m:g/bar/; breaks |
16:01 | |
colomon | m: say (set [ foo => 10, bar => 17, baz => 42 ]).perl | 16:02 | |
GLRelia | rakudo-moar 15b06d: OUTPUT«set(:baz(42),:foo(10),:bar(17))» | ||
camelia | rakudo-moar eb6de6: OUTPUT«set([:foo(10), :bar(17), :baz(42)])» | ||
16:03
domidumont left,
smls left
|
|||
nine | 47! | 16:04 | |
Oh, 46 actually! The 1 was lock.t | 16:05 | ||
JimmyZ | Is it ok to remove Array.ACCEPTS ? | ||
looks Array is List | |||
16:05
adu joined
|
|||
nine | JimmyZ: no, there are slight differences | 16:05 | |
16:09
kanl left,
kanl joined
16:11
lizmat_ joined
16:14
lizmat left
|
|||
dalek | ast/glr: b8a19c9 | (Stefan Seifert)++ | S04-phasers/begin.t: Remove obsolete TODO marker |
16:14 | |
nine | 45 | ||
colomon still has no clue what set / bag / etc constructors should be doing — once that’s figured out cleaning up the tests will be easy… | 16:16 | ||
16:16
virtualsue joined
16:17
kanl left,
Sufrostico joined
|
|||
nine | m: my @a = 1,2,3; my @b = 3,4,5; say zip(@a; @b).perl; | 16:18 | |
camelia | rakudo-moar eb6de6: OUTPUT«((1, 3), (2, 4), (3, 5))» | ||
GLRelia | rakudo-moar 186223: OUTPUT«(([1, 2, 3], [3, 4, 5])).Seq» | ||
16:18
dwarring left
|
|||
Sufrostico | sorry the silly question... where can i get the status of the implemetation of threads in perl6 .. rakudo | 16:19 | |
tadzik | what status do you mean? | ||
they are implemented and work on both supported backends | |||
16:19
kanl joined
|
|||
Sufrostico | nice | 16:20 | |
lightweight? | |||
btyler_ | Sufrostico: here's a very recent talk showing off features in that area: jnthn.net/papers/2015-yapcasia-concurrency.pdf | ||
16:20
rarara left
|
|||
Sufrostico | nice | 16:20 | |
my python co worker was complaining about perl threads just yesterday | 16:21 | ||
tadzik | he might have meant perl 5 threads | ||
colomon | nine: I stuck a say inside infix:<Z>, and it gets different arguments when you call it via zip | 16:22 | |
tadzik | "0b76e797c245892b9a5ddbc4fe7b8d3829d116f0 is the first bad commit" | ||
lizmat_: ^ | |||
colomon | nine: extra list wrapping it, I think. | ||
16:22
kaare__ left
|
|||
sjn | Sufrostico: that talk btyler_ linked to, it's already on youtube | 16:22 | |
sjn just watched it, and liked it a lot. Very instructive presentation | 16:23 | ||
hahainternet | wg 28 | ||
:( | |||
too many irc windows | |||
tadzik | lizmat_: I reverted it and it fixed panda, but I have no idea what can it possibly be impacting | 16:24 | |
16:25
itz joined
|
|||
dalek | pan style="color: #395be5">perl6-examples: 115ad18 | (Ben Tyler)++ | categories/rosalind/trie-grondilu.pl: trie-grondilu: fix error with postfix condition. Not yet sure how this broke, investigating what might be more or less tightly bound under GLR. |
16:26 | |
16:26
rurban left
16:28
AlexDaniel left
16:29
araujo joined
|
|||
_itz | pamda is broken on 'brew I think | 16:29 | |
err panda | |||
tadzik | yes | ||
you mean on glr, right? | 16:30 | ||
_itz | no on nom | ||
tadzik | oh | ||
that's straneg | |||
_itz | I'll try from scratch | ||
colomon | just worked fine for me a couple of minutes ago? | ||
(on nom) | |||
tadzik | seems to work for me | ||
is broken on glr though | 16:31 | ||
16:33
TimToady left
16:34
TimToady joined
|
|||
masak | m: constant k = 1, map { k[$_] }, 0..*; .say for k[^10] | 16:37 | |
camelia | rakudo-moar 5fb81f: OUTPUT«5===SORRY!5=== Error while compiling /tmp/h2ttbus2ECVariable '&k' is not declaredat /tmp/h2ttbus2EC:1------> 3constant k = 1, map { 7⏏5k[$_] }, 0..*; .say for k[^10]» | ||
GLRelia | rakudo-moar 186223: OUTPUT«5===SORRY!5=== Error while compiling /tmp/1TJghQX9ugVariable '&k' is not declaredat /tmp/1TJghQX9ug:1------> 3constant k = 1, map { 7⏏5k[$_] }, 0..*; .say for k[^10]» | ||
tony-o | is it the ',' instead of ';' ?.. | 16:38 | |
oh nvm | |||
masak | tony-o: it's rt.perl.org/Ticket/Display.html?id=111674 | ||
not having the constant just defined available in the rhs of the constant assignment currently prevents a bunch of cool self-referential constant lazy-list definitions :) | 16:39 | ||
I'm almost tempted to debug this one and see what causes it. | |||
16:43
Sufrostico left
16:47
FROGGS joined,
yqt left
|
|||
moritz idly wonders how many of those cool self-referential definitions are readably by mere mortals | 16:51 | ||
laben | nine: github.com/rakudo/rakudo/pull/519 | 16:54 | |
FROGGS | m: sub foo { say &?ROUTINE.name; for 1 { say &?ROUTINE.name; } }; foo | 16:55 | |
camelia | rakudo-moar 5fb81f: OUTPUT«foofoo» | ||
GLRelia | rakudo-moar 186223: OUTPUT«foofoo» | ||
FROGGS | m: sub foo { say &?ROUTINE.name; gather for 1 { say &?ROUTINE.name; } }; foo | 16:56 | |
camelia | rakudo-moar 5fb81f: OUTPUT«foo» | ||
GLRelia | rakudo-moar 186223: OUTPUT«foo» | ||
dalek | kudo/glr: 6e8b97b | laben++ | src/core/metaops.pm: Fix dwim hypers to manage lazy iterables correctly |
||
kudo/glr: fc8ab7e | moritz++ | src/core/metaops.pm: Merge pull request #519 from laben/glr Fix dwim hypers to manage lazy iterables correctly |
|||
FROGGS | m: sub foo { say &?ROUTINE.perl; gather for 1 { say &?ROUTINE.perl; }; gather for 1 { say &?ROUTINE.perl; } }; foo | ||
camelia | rakudo-moar 5fb81f: OUTPUT«sub foo () { #`(Sub|59748232) ... }Code.newCode.new» | ||
GLRelia | rakudo-moar 186223: OUTPUT«sub foo () { #`(Sub|53058688) ... }Code.newCode.new» | ||
FROGGS | m: sub foo { say &?ROUTINE.perl; for 1 { say &?ROUTINE.perl; }; gather for 1 { say &?ROUTINE.perl; } }; foo | ||
camelia | rakudo-moar 5fb81f: OUTPUT«sub foo () { #`(Sub|42434376) ... }sub foo () { #`(Sub|42434376) ... }Code.new» | ||
GLRelia | rakudo-moar 186223: OUTPUT«sub foo () { #`(Sub|54308288) ... }sub foo () { #`(Sub|54308288) ... }Code.new» | ||
FROGGS | m: sub foo($,$,$) { say &?ROUTINE.arity; for 1 { say &?ROUTINE.arity; }; gather for 1 { say &?ROUTINE.arity; } }; foo 1, 2, 3 | 16:57 | |
camelia | rakudo-moar 5fb81f: OUTPUT«330» | ||
GLRelia | rakudo-moar 186223: OUTPUT«330» | ||
laben | moritz: about the roast tests, do i push to my repo and create a PR or push directly (dont know if i can) | ||
FROGGS | m: sub foo($,$,$) { say &?ROUTINE.arity; for 1 { say &?ROUTINE.arity; }; gather for 1 { say &?ROUTINE(); } }; foo 1, 2, 3 | 16:58 | |
camelia | rakudo-moar 5fb81f: OUTPUT«(timeout)33» | ||
GLRelia | rakudo-moar 186223: OUTPUT«(timeout)33» | ||
moritz | laben: you push directly | ||
laben: and if you can't, you tell me | |||
FROGGS | m: sub foo($,$,$) { say &?ROUTINE.arity; for 1 { say &?ROUTINE.arity; }; gather for 1 { if 1 { &?ROUTINE.arity } } }; foo 1, 2, 3 | ||
camelia | rakudo-moar 5fb81f: OUTPUT«33» | ||
GLRelia | rakudo-moar 186223: OUTPUT«33» | ||
FROGGS | m: sub foo($,$,$) { say &?ROUTINE.arity; for 1 { say &?ROUTINE.arity; }; gather for 1 { if 1 { say &?ROUTINE.arity } } }; foo 1, 2, 3 | ||
camelia | rakudo-moar 5fb81f: OUTPUT«333» | ||
GLRelia | rakudo-moar 186223: OUTPUT«333» | ||
FROGGS | awesome bug | ||
laben | moritz: i'm part of the perl6 org but it seems i cant push directly, maybe some git stuff i dont know? | 16:59 | |
moritz | laben: what does 'git remove -v' say? | ||
laben | moritz: if you meant "git remote -v" it's "" | 17:00 | |
$ git remote -v | |||
origin git://github.com/perl6/roast.git (fetch) | |||
origin [email@hidden.address] (push) | |||
darn | |||
moritz | laben: hurm, looks correct; what error message do you get if you try to push? | 17:01 | |
laben | moritz: permission denied (publickey) | ||
_itz | ssh-add? | 17:02 | |
moritz | laben: does a 'git push' work to any other repo from the same shell? | ||
laben: might be that you have multiple SSH keys, and the one that's used isn't added on github | 17:03 | ||
laben | moritz: yea, i just pushed to my gh repo of rakudo for the last pr | ||
moritz | huh | ||
laben | maybe it's better i push to gh fork and create a pr | 17:04 | |
moritz | laben: if that works for you, sure | 17:05 | |
laben: you can even merge yourself | |||
(I hope :-) | |||
colomon | tadzik: emmentaler is eating my projects.json file?! | ||
moritz | nom nom nom | 17:06 | |
masak | m: role R[::N, $result = N] { say $result }; my $r = R[Int].new | ||
camelia | rakudo-moar 5fb81f: OUTPUT«Cannot find method 'collisions' in any apply at src/gen/m-Metamodel.nqp:2633 in any compose at src/gen/m-Metamodel.nqp:2810 in any make_pun at src/gen/m-Metamodel.nqp:1642 in any find_method at src/gen/m-Metamodel.nqp:1670 in block <uni…» | ||
GLRelia | rakudo-moar fc8ab7: OUTPUT«Cannot find method 'collisions' in any apply at src/gen/m-Metamodel.nqp:2635 in any compose at src/gen/m-Metamodel.nqp:2812 in any make_pun at src/gen/m-Metamodel.nqp:1644 in any find_method at src/gen/m-Metamodel.nqp:1672 in block <uni…» | ||
FROGGS reported an awesome bug right now as RT #125934 | |||
masak submits rakudobug | |||
17:06
virtualsue left
|
|||
moritz | m: role R[::N, $result = N] {} | 17:07 | |
GLRelia | ( no output ) | ||
camelia | ( no output ) | ||
laben | moritz: can you check it before merging? github.com/perl6/roast/pull/67 (btw it seems i can indeed merge it myself...) | ||
17:07
itz left
|
|||
moritz | laben: in line 204, it might be nicer to declare new lexicals @r and @e | 17:08 | |
laben: in fact, I don't think you use those values at all | 17:10 | ||
because in line 218, you re-assign to them | |||
laben: otherwise, looks fine | |||
17:10
Loren_ left
|
|||
laben | moritz: i do use them in line 207 | 17:11 | |
should i add more blank lines? | |||
moritz | laben: oh, count me blind :-) | ||
laben: no, it's fine, but declare them with 'my' please, so that global defintions in that file (which aren't relevant for the tests) aren't overridden | |||
(and the block of tests can easier be moved around, for exapmle) | 17:12 | ||
laben | moritz: i updated the commit, now it should be ok | 17:16 | |
17:17
FROGGS left
|
|||
tadzik | colomon: I don't know, is it? :) | 17:20 | |
17:20
lizmat joined
|
|||
tadzik | colomon: I haven't touched emmentaler in ages | 17:20 | |
17:20
lizmat_ left
|
|||
tadzik | I learned that panda now has a really strong competition :) | 17:20 | |
in form of github.com/ugexe/zef | |||
in many ways it feels like Mojolicious of module management, with its own bundled HTTP library and all | 17:21 | ||
muraiki | interesting | 17:23 | |
nine | laben: is it really ok to have one side being lazy without being DWIM? | ||
tadzik | I'll have to evaluate if I should see it as competition or a successor :) | ||
laben | nine: what do you mean? | ||
nine | laben: the DWIM makes it auto truncate to the non-DWIM side's length, so infinitiy is not a problem. But without DWIM we have to iterate infinitely. | 17:24 | |
tadzik | ugexe++ and tony-o++ in any case :) | ||
laben | nine: can you illustrate an example? i thought i covered all sides... | 17:25 | |
17:25
cognominal joined
|
|||
dalek | ast/glr: a88ba52 | laben++ | S03-metaops/hyper.t: Add tests for binary op (non-)dwim cases and fudge broken ones |
17:30 | |
ast/glr: 1846e7f | laben++ | S03-metaops/hyper.t: Merge pull request #67 from laben/glr Add tests for binary op (non-)dwim cases and fudge broken ones |
|||
17:31
FROGGS joined
|
|||
laben | nine: with this ^^^ one test file failing less | 17:32 | |
oh cmon now panda fails a test again on newest glr | 17:34 | ||
17:34
llfourn left
|
|||
tadzik | it doesn't work at all | 17:34 | |
FROGGS | :S | ||
tadzik | since 0b76e797c245892b9a5ddbc4fe7b8d3829d116f0 | ||
suddenly arrays are Seqs | |||
not sure who to blame :P | 17:35 | ||
nine | tadzik: Seq is usually the correct answer. .list it if you need to iterate it more than once | ||
tadzik | it was a bit more complicated than that :) | ||
there'd be .flat and .list and .grep(*.defined) and dragons and shit | 17:36 | ||
and suddenly, instead of ["File::Find", "Shell::Command", "JSON::Fast"] there'd be ((stuff).Seq, (Any).Seq, (Any.Seq)).Seq, in random order | |||
dalek | kudo/glr: 18261c9 | lizmat++ | src/core/set_operators.pm: Give set()/bag()/mix() single arg semantics |
17:45 | |
nine | laben: ah sorry for the noise. I misread your patch. Too tired to process boolean expressions it seems :) | 17:49 | |
laben | nine: dont worry, you were tired for perl6 goodness, i forgive you ^.^ | 17:50 | |
17:50
domidumont joined
|
|||
dalek | rl6-roast-data: a689b9e | coke++ | / (10 files): today (automated commit) |
17:52 | |
colomon wants to do module with .dragons and .shit now…. | |||
dalek | kudo/glr: 1a05c67 | lizmat++ | src/core/set_operators.pm: Be more smart about singel arging bag/set/mix() FROGGS++ for inspiration |
||
colomon | lizmat: I keep seeing your patches, celebrating, then discovering they don’t quite fix set.t… | 17:53 | |
tadzik | :D | ||
timotimo | ;( | ||
lizmat | colomon: that's because set.t / bag.t etc. need to be fixed | ||
working on that now | |||
colomon | okay, if you’ve got that, I’ll go back to being utterly confused by emmentaler | 17:54 | |
timotimo | zef has a "smoke" command, too | 17:55 | |
maybe emmentaler could be ported over to zef? :P | |||
dalek | pan style="color: #395be5">perl6-examples: 4e3e0eb | paultcochrane++ | categories/wsg/advanced-2008/event001-eric256.pl: Fix failure in event001-eric256 Using `split('')` to get the individual elements of a number or string is a Perl 5-like way of doing this. Unfortunately, `split` matches the empty string at the *ends* of the string as well, hence one gets 9 elements from a 7 digit string. The solution is to use `comb`, which is the correct way to do this in Perl 6. |
||
colomon | timotimo, tadzik: I’m deadly serous that I’ve started emmentaler with “./smoker projects.json”, get a weird error message, and then projects.json is just gone. | 17:56 | |
17:56
cognominal left
|
|||
tadzik | colomon: hmm | 17:56 | |
colomon: oh... | |||
colomon | oh? | ||
tadzik | colomon: so panda recently started updating $!projectsfile automatically | ||
I guess that's not always desirable | 17:57 | ||
especially if it fails | |||
colomon | it’s completely 100% undesirable, because that file isn’t necessarily projects.json | ||
tadzik | right | ||
colomon | I use subsets for testing pretty regularly | 17:58 | |
timotimo | argh! | ||
tadzik | colomon: yeah, I even had to override that for panda tests :/ | 17:59 | |
stupid thing | |||
colomon: should be fixed now | |||
18:00
andreoss left
|
|||
tadzik | thanks for letting me know | 18:00 | |
colomon | tadzik: hmmm | ||
==> Installing panda from a local directory '/home/colomon/.rakudobrew/moar-nom/panda' | |||
Could not download module metadata: No such method 'field' for invocant of type 'Array' | |||
tadzik | wat | 18:01 | |
glr? | |||
colomon | nope, nom | ||
laben | m: say defined my @c | ||
camelia | rakudo-moar 5fb81f: OUTPUT«True» | ||
GLRelia | rakudo-moar 1a05c6: OUTPUT«True» | ||
tadzik | . o O ( field? ) | ||
colomon | (I’m running on hack here) | ||
tadzik | there's no 'field' in panda | ||
laben | m: say defined (my @c=Any) | ||
camelia | rakudo-moar 5fb81f: OUTPUT«True» | ||
GLRelia | rakudo-moar 1a05c6: OUTPUT«True» | ||
colomon | tadzik: I know, that’s what’s been driving me nuts when I was trying to use emmentaler | ||
tadzik: let me try blowing away my rakudo and rebuilding from scratch | |||
tony-o | what is emmentaler? | ||
tadzik | colomon: oh! | 18:02 | |
colomon | tony-o: module smoke tester (via panda) | ||
tadzik | do you have HTTP::UserAgent installed? | ||
colomon | tadzik: maybe? | ||
tadzik | colomon: panda will use it if it's installed | ||
maybe it's broken | |||
colomon just kind of blew away everything | |||
tadzik | oh well :) | ||
laben | tadzik: is there a reason you want to use sets instead of list.unique? | 18:03 | |
tadzik | laben: I never wanted to use sets | 18:04 | |
they sort of appeared | |||
as long as you mean seqs | |||
laben | tadzik: no i mean sets that you create with (|) | 18:05 | |
tadzik | I now think I should've waited a bit longer with the glr merge | ||
laben: oh | |||
laben: I don't think I wrote that :P | |||
laben: no reason | 18:06 | ||
colomon | laben: what’s the context? | ||
tadzik | laben: and frankly, I don't think that's a right way of doing this anyway | ||
I mean, I'd rather have code that takes META.info and gives me something that actually conforms to specs that I can process | |||
dalek | ast/glr: 0da7828 | lizmat++ | S02-types/bag.t: Make S02-types/bag.t pass all tests |
||
ast/glr: a7dafef | lizmat++ | S03-metaops/hyper.t: Merge branch 'glr' of github.com/perl6/roast into glr |
|||
tadzik | rather than taking whatever mess META.info contains and trying to make the best of it in the latest possible moment | 18:07 | |
honestly I really feel like giving panda a good, solid shakeup from the ground up | 18:08 | ||
it's got 4 years of legacy all over its codebase, and some parts of it are either stupid or plain wron g:) | |||
[Coke] wonders if the p6u is like the mcu. | 18:13 | ||
[ptc] | _itz: the perl6-examples are testing green on travis again! Yay! | ||
colomon | \o/ | 18:14 | |
FROGGS | tadzik: go for it | ||
tadzik | FROGGS: part of my head says "nooo, rewrite is always stupider than fixing things carefully" | 18:15 | |
but I guess that's not always true | 18:16 | ||
FROGGS | tadzik: call it refactoring and you are fine :o) | ||
tadzik | haha | ||
18:19
dre_ joined
18:20
dre_ left
|
|||
dalek | ast/glr: 869e1a9 | lizmat++ | S02-types/mix.t: Make S02-types/mix.t pass all tests |
18:21 | |
[Coke] notes that he and colomon are on the 2nd floor. | 18:22 | ||
colomon notes that it is cool and fairly quiet up here. | |||
tadzik | oh! | ||
[Coke] | what did we miss? | 18:23 | |
*golf clap* *golf clap* | |||
ugexe | a Distribution object is meant to be the API to META.info | 18:24 | |
tadzik | hm? | ||
oh | |||
jdv79 | [Coke]: is it cool up there? | ||
b2gills | .oO( I just noticed that I have exactly 14,000 rep on StackOverflow, most of it from Perl 5/6 answers ) |
18:25 | |
lizmat | m: my %h = set < a a b b c c d d >; say %h.perl | ||
camelia | rakudo-moar 5fb81f: OUTPUT«Odd number of elements found where hash initializer expected in block <unit> at /tmp/I8hgYvvthd:1» | ||
GLRelia | rakudo-moar 1a05c6: OUTPUT«{:a("c"), :b("d")}» | ||
jdv79 | oh, colomon already said that. duh. | ||
[Coke] | jdv79: coolish. | 18:26 | |
b2gills | m: my %h := set < a a b b c c d d >; say %h.perl | ||
camelia | rakudo-moar 5fb81f: OUTPUT«set("a","c","b","d")» | ||
GLRelia | rakudo-moar 1a05c6: OUTPUT«set("a","c","b","d")» | ||
18:26
diana_olhovik joined
18:33
telex left
|
|||
jdv79 | what is the diff between META6.json and META.info? | 18:33 | |
tadzik | history | 18:34 | |
jdv79 | ugexe: what does that mean? | ||
tadzik | :P | ||
18:34
telex joined
|
|||
jdv79 | ok, so same; effectively. | 18:34 | |
tadzik | FROGGS: rebecca.blackfriday/ | ||
laben | b2gills: about our recent discussion about >>op<< not throwing and shortening the longer side, it seems there is no reason to go about doing this given Z already has this behaviour | 18:35 | |
tony-o | tadzik: FROGGS: www.youtube.com/watch?v=qe6ZbL6KbEE | 18:36 | |
moritz | TIL that blackfriday is now a TLD | ||
laben | colomon: the context is method init-projects in Ecosystem.pm where it creates the projects from the parsed json | ||
colomon: specifically where it sets dependencies | |||
FROGGS | tony-o: that's not his real hair :o) | 18:37 | |
dalek | rl6-roast-data: 8b52920 | coke++ | / (2 files): another glr run for 'today' |
||
tony-o | oh my | ||
18:37
khw left
18:40
diana_olhovik left
|
|||
tadzik | tony-o: I think I'll spare the rest of the hackathoners and watch it later at the hotel :o | 18:41 | |
moritz: endless.horse/ | |||
18:42
diana_olhovik__ joined
|
|||
[Coke] | !!! everyone working at the hackathon - please privmsg me or email me a small writeup of what you did, even if you were working remotely. I'm writing up a blog post so our hosts know what we got up to. | 18:42 | |
18:42
kaare__ joined
|
|||
ugexe | jdv79: i mean a distributions meta information should be consumed from a Distribution object, which can provide normalized values (ver vs version) as well as the .content method for accessing files in the `provides`. | 18:42 | |
tadzik | Distribution being part of Zef | 18:44 | |
or is it specced? | |||
ugexe | its specced in S22 | ||
18:44
Loren joined
|
|||
tony-o | it's specced | 18:44 | |
tadzik | oh! | ||
tony-o | we have questions about it though, it's kind of vague | ||
tadzik | well, it's a spec written before an implementation :) | 18:45 | |
same with hooks | |||
they just say "there should be hooks" | |||
[Coke] | down to 261 failing tests. | 18:46 | |
arnsholt | And TimToady said: "Let there be hooks!" =) | ||
[Coke] | we also have a few more skips than nom. | ||
ugexe | there is an implementation. called Distribution.pm in rakudo core. its not up to spec | 18:47 | |
tony-o | ugexe: wrote up my json::faster benchmark crap here: ugexe.com/speed-quest-1-0-or-0-1-or-something/ | 18:48 | |
tadzik: the question more revolves around the way these things were imagined, ugexe is imagining centralized CURs and i'm imagining decentralized CURs and both would work but the implementation is different. that's kind of a quick way of saying it for lack of time (i'm hungry) | 18:49 | ||
it's a theory question, i wrote a CUR that works over HTTP and not sure how to handle .install yet | 18:50 | ||
tadzik | hm | ||
ugexe | im writing content storage for Distribution objects now. Distribution::Local and then the Distribution::HTTP::Github. Distribution.content can then pull from the hard disk or from github.com via http requests by pulling from whatever content storage is attached to it | 18:53 | |
18:55
virtualsue joined,
domidumont left
|
|||
tadzik | sounds good | 18:55 | |
18:56
Ven joined
|
|||
colomon | tony-o++ | 18:56 | |
moritz | m: my Enum @a = :a; say @a.perl | 19:01 | |
camelia | rakudo-moar 5fb81f: OUTPUT«Array[Enum].new("a" => Bool::True)» | ||
GLRelia | rakudo-moar 1a05c6: OUTPUT«Array[Enum].new(:a)» | 19:02 | |
moritz | m: my Enum @a = :a; say EVAL(@a.perl).perl | ||
camelia | rakudo-moar 5fb81f: OUTPUT«Array[Enum].new("a" => Bool::True)» | ||
GLRelia | rakudo-moar 1a05c6: OUTPUT«Array[Enum].new()» | ||
moritz | m: say :a.perl, :a.perl(:arglist) | 19:05 | |
camelia | rakudo-moar 5fb81f: OUTPUT«:a"a" => Bool::True» | ||
GLRelia | rakudo-moar 1a05c6: OUTPUT«:a:a» | ||
laben | tadzik: i got it, what has changed that broke panda (other than glr): json::fast returns Any instead of () and that got containerized, so it didnt get flattened since the array got an element | ||
tadzik: i got a change that fix this | |||
tadzik: unless you want to rewrite it all | |||
dalek | ast/glr: 7e4a1c0 | (Stefan Seifert)++ | S32-array/push.t: GLRify S32-array/push.t |
||
tadzik | laben: ooh | 19:07 | |
laben: I definitely won't blindly rewrite it while throwing all the smart thing it's doing away, so if you have the fix please go ahead :) | 19:09 | ||
19:10
bin_005 joined
|
|||
laben | tadzik: well, you could simply want to rewrite those lines that calculate deps, anyway this is it gist.github.com/46655b37a8f21834b737 or do you prefer a PR? | 19:10 | |
colomon | m: say rindex( 'xxy','y', -1e34 ) | ||
camelia | rakudo-moar 5fb81f: OUTPUT«Nil» | ||
GLRelia | rakudo-moar 1a05c6: OUTPUT«Nil» | ||
dalek | kudo/glr: 2178f78 | moritz++ | src/core/Enum.pm: Restore Enum.perl(:arglist) behavior fixes S32-hash/perl.t |
19:11 | |
19:12
cognominal joined
|
|||
FROGGS | m: for 1..5 { LAST { .say } } | 19:12 | |
camelia | rakudo-moar 5fb81f: OUTPUT«5» | ||
GLRelia | ( no output ) | ||
colomon | lizmat: you still working on the set/bag test files? | 19:13 | |
lizmat | colomon: indeed I am | ||
colomon | okay, I’ll work on something else. lizmat++ | 19:14 | |
lizmat | okidoki | ||
tadzik | laben: just applied it :) | ||
thanks! | |||
19:14
brummett joined,
virtualsue left
19:15
Loren left
|
|||
colomon | m: say ([] ... [])[0] | 19:15 | |
camelia | rakudo-moar 5fb81f: OUTPUT«» | ||
GLRelia | rakudo-moar 1a05c6: OUTPUT«Cannot get sequence endpoint from an empty list (use * or :!elems instead?) in block <unit> at /tmp/IC4uUeKFzM:1» | ||
colomon | Am I correct in thinking that shouldn’t work under GLR? | 19:16 | |
laben | m: dd ([] ... []) | ||
camelia | rakudo-moar 5fb81f: OUTPUT«([],)» | ||
GLRelia | rakudo-moar 2178f7: OUTPUT«Cannot get sequence endpoint from an empty list (use * or :!elems instead?) in block <unit> at /tmp/4HLHlsTkas:1» | ||
laben | m: dd ([] .. []) | 19:17 | |
camelia | rakudo-moar 5fb81f: OUTPUT«0..[]» | ||
GLRelia | rakudo-moar 2178f7: OUTPUT«0..0» | ||
19:18
rangerprice joined
19:21
yqt joined
19:24
espadrine left
19:26
xinming left,
xinming joined
|
|||
tadzik | laben: hmm, it still seems to have list issues | 19:28 | |
now I get resolve stage failed for panda: Dependency File::Find JSON::Fast Shell::Command is not present in the module ecosystem | |||
19:28
virtualsue joined
|
|||
laben | tadzik: yeah i just noticed it too trying rebootstrap | 19:28 | |
i'll check it out in an hour or so, cant now | 19:29 | ||
tadzik | (╯°□°)╯︵ ɹןb | ||
19:30
llfourn joined
|
|||
moritz | tadzik: looks like a missing flat | 19:32 | |
tadzik | yeah | 19:33 | |
ugexe | say from-json("projects.json".IO.slurp) <-- output is correct. my @a = from-json("projects.json".IO.slurp); say @a; <-- output: [] | 19:34 | |
19:34
llfourn left
19:35
brummett left
|
|||
tadzik | strange | 19:36 | |
19:36
itz joined
|
|||
colomon | ugexe: did you have a module or list of modules that was borking panda when you tried to install it? | 19:37 | |
FROGGS | m: say from-json '{ "foo" : [ "bar", "baz" ] }' | ||
camelia | rakudo-moar 5fb81f: OUTPUT«foo => bar baz» | ||
GLRelia | rakudo-moar 2178f7: OUTPUT«foo => [bar baz]» | ||
FROGGS | m: say my @a = from-json '{ "foo" : [ "bar", "baz" ] }' | ||
camelia | rakudo-moar 5fb81f: OUTPUT«foo => bar baz» | ||
GLRelia | rakudo-moar 2178f7: OUTPUT«foo => [bar baz]» | ||
moritz | m: say $*IN.slurp-rest.^name | 19:38 | |
camelia | rakudo-moar 5fb81f: OUTPUT«Str» | ||
GLRelia | rakudo-moar 2178f7: OUTPUT«(timeout)» | ||
ugexe | colomon: no, i think it was generally nativecall modules or things with Build.pm | ||
colomon | ugexe: thanks | ||
moritz | m: say $*IN.slurp-rest.^name # checking if that timeout is reproducible | ||
camelia | rakudo-moar 5fb81f: OUTPUT«Str» | ||
GLRelia | rakudo-moar 2178f7: OUTPUT«(timeout)» | 19:39 | |
colomon | m: say $*IN.slurp-rest | ||
camelia | rakudo-moar 5fb81f: OUTPUT«Céad slán ag sléibhte maorga Chontae Dhún na nGallAgus dhá chéad slán ag an Eireagal ard ina stua os cionn caor is coll;Nuair a ghluais mise thart le Loch Dhún Lúich’ go ciúin sa ghleann ina luíI mo dhiaidh bhí gleanntáin ghlas’ G…» | ||
GLRelia | rakudo-moar 2178f7: OUTPUT«(timeout)» | 19:40 | |
moritz | cannot reproduce on my machine | ||
moritz@hack:~/p6/rakudo$ cat ../evalbot/stdin | ./perl6-m --setting=RESTRICTED -e 'say $*IN.slurp-rest.chars' | |||
1134 | |||
colomon | moritz: I keep on finding consistently reproducable differences between GLRelia and my local builds. | 19:43 | |
m: say rindex( 'xxy','y', -1e34 ) | |||
GLRelia | rakudo-moar 2178f7: OUTPUT«Nil» | ||
camelia | rakudo-moar 5fb81f: OUTPUT«Nil» | ||
colomon | > rindex( 'xxy','y', -1e34 ) | 19:44 | |
index start offset out of range | |||
hold on | |||
moritz gets Nil too | 19:45 | ||
19:46
Loren joined
|
|||
colomon | FROGGS++ just explained I needed to update MoarVM | 19:47 | |
and now it works properly | |||
19:48
Ven left
|
|||
dalek | rl6-roast-data: 301b56e | coke++ | / (2 files): another glr run for 'today' |
19:48 | |
FROGGS | jnthn / nine / moritz / lizmat: I've got a totally ugly patch for next.t and last.t: gist.github.com/FROGGS/6ad7ea03a39cc5453c7a | 19:49 | |
colomon | m: roundrobin((); 1; 2..4; (5..7); <a b>).join(' ‘).say | ||
camelia | rakudo-moar 5fb81f: OUTPUT«5===SORRY!5=== Error while compiling /tmp/M6TnNj13n1Unable to parse expression in single quotes; couldn't find final "'" at /tmp/M6TnNj13n1:1------> 3); 1; 2..4; (5..7); <a b>).join(' ‘).say7⏏5<EOL> expecting any of: ar…» | ||
GLRelia | rakudo-moar 2178f7: OUTPUT«5===SORRY!5=== Error while compiling /tmp/wm62xe6e3FUnable to parse expression in single quotes; couldn't find final "'" at /tmp/wm62xe6e3F:1------> 3); 1; 2..4; (5..7); <a b>).join(' ‘).say7⏏5<EOL> expecting any of: ar…» | ||
FROGGS | jnthn / nine / moritz / lizmat: it works but I think it is not commitable this way :o) | ||
colomon | m: roundrobin((); 1; 2..4; (5..7); <a b>).join(“ “).say | ||
camelia | rakudo-moar 5fb81f: OUTPUT«5===SORRY!5=== Error while compiling /tmp/U9otqS7iGOUnable to parse expression in smart double quotes; couldn't find final '”' at /tmp/U9otqS7iGO:1------> 3); 1; 2..4; (5..7); <a b>).join(“ “).say7⏏5<EOL> expecting any of:…» | ||
GLRelia | rakudo-moar 2178f7: OUTPUT«5===SORRY!5=== Error while compiling /tmp/EcbhlfBafVUnable to parse expression in smart double quotes; couldn't find final '”' at /tmp/EcbhlfBafV:1------> 3); 1; 2..4; (5..7); <a b>).join(“ “).say7⏏5<EOL> expecting any of:…» | ||
colomon | m: roundrobin((); 1; 2..4; (5..7); <a b>).perl.say | ||
camelia | rakudo-moar 5fb81f: OUTPUT«((1, 2, 5, "a"), (3, 6, "b"), (4, 7))» | ||
GLRelia | rakudo-moar 2178f7: OUTPUT«([1, 2, 3, 4, 5, 6, 7, "a", "b"]).Seq» | ||
colomon | seeing this is several other tests as well — seems like GLR is not honoring semi-colons | 19:50 | |
semi-colon is not LoL composer anymore (FROGGS++ says)? | |||
function signature is roundrobin(**@lol) | 19:51 | ||
FROGGS | m: roundrobin([], [1], [2..4], [5..7], <a b>).perl.say | ||
camelia | rakudo-moar 5fb81f: OUTPUT«((1, 2, 5, "a"), (3, 6, "b"), (4, 7))» | ||
GLRelia | rakudo-moar 2178f7: OUTPUT«([1, 2, 5, "a"], [3, 6, "b"], [4, 7]).Seq» | ||
19:54
ab6tract joined
|
|||
maettu | that was a fine day at the spw215 :-) | 19:58 | |
19:58
larion joined
|
|||
_itz | jnthn++ # particularly good talks | 20:00 | |
20:00
muraiki left
20:02
FROGGS left
20:06
virtualsue_ joined,
virtualsue left
|
|||
moritz | is yary (from p6u) on IRC? | 20:06 | |
20:07
virtualsue_ is now known as virtualsue
|
|||
moritz | and if yes, under which nick? | 20:07 | |
dalek | ast/glr: 14b065f | colomon++ | S32-container/roundrobin.t: Update to conform to GLR. FROGGS++ roundrobin((); 1; 2..4; (5..7); <a b>) becomes roundrobin([], [1], [2..4], [5..7], <a b>) and is(roundrobin([1..3]).elems, 1, 'roundrobin does not flatten array items'); just goes away, as that's not how these sorts of arguments work anymore. |
||
ugexe | something seems particularly messed up here | 20:09 | |
Use of uninitialized value $v of type Any in string context in block at /home/nickl/perl6/zef/lib/Zef/Utils/Any | |||
there is no /Any file/folder | |||
20:10
Loren left
|
|||
colomon | uninit’ed last part of the file path? | 20:10 | |
ab6tract | what's p6u? | 20:11 | |
tadzik | glr is fun :) | ||
20:11
kaare__ left
|
|||
tadzik | ab6tract: perl6-users mailing list | 20:11 | |
ab6tract | also: great SPW so far :D | ||
dalek | ast/glr: 2b5bf32 | colomon++ | S32-container/zip.t: Also switch to current "LoL" standard. |
||
ab6tract | tadzik: thanks :) | ||
tadzik | [email@hidden.address] | ||
SPW is awesome :) | 20:12 | ||
maettu++ # and the rest of the crew | |||
colomon | maettu++ indeed! | ||
20:15
adu left
20:16
FROGGS joined
20:18
colomon left
|
|||
dalek | ast/glr: 96b12b1 | (Stefan Seifert)++ | S04-statements/for.t: GLRify S04-statements/for.t |
20:18 | |
20:19
darutoko left
|
|||
dalek | kudo/glr: 441d54d | (Stefan Seifert)++ | src/core/List.pm: Fix "This type does not support elems" on my @a; say |@a; |
20:20 | |
FROGGS | m: use Test; my $a = ''; for $[1..3, 4..6] { $a ~= $_.WHAT.gist }; is($a, Array.gist, 'List context'); | 20:21 | |
camelia | rakudo-moar 5fb81f: OUTPUT«not ok 1 - List context# Failed test 'List context'# at /tmp/cfAEH_1jF0 line 1# expected: '(Array)'# got: '(Any)(Any)(Any)(Any)(Any)(Any)'» | ||
GLRelia | rakudo-moar 2178f7: OUTPUT«not ok 1 - List context# Failed test 'List context'# at /tmp/vMz8rI5vqa line 1# expected: '(Array)'# got: '(Range)(Range)'» | ||
FROGGS | m: use Test; my $a = ''; for ([1..3, 4..6],) { $a ~= $_.WHAT.gist }; is($a, Array.gist, 'List context'); | ||
camelia | rakudo-moar 5fb81f: OUTPUT«ok 1 - List context» | ||
GLRelia | rakudo-moar 2178f7: OUTPUT«ok 1 - List context» | ||
FROGGS | aha | 20:22 | |
but yeah, makes sense | |||
20:22
itz left
20:25
virtualsue left
|
|||
nine | Woah, we're at 37 latest official count | 20:25 | |
ab6tract | nine: amazing!! :D | 20:26 | |
20:26
colomon joined,
xfix left
|
|||
FROGGS | much awesome :o) | 20:27 | |
moritz | such GLR | ||
dalek | ast/glr: 382ffeb | lizmat++ | S02-types/set.t: Make S02-types/set.t pass all tests |
||
kudo/glr: 7591fc4 | lizmat++ | src/core/ (3 files): Simplify grep and friends on Set/Bag/Mix Since Set is now also returning pairs for .list |
20:28 | ||
20:30
llfourn joined
|
|||
dalek | ast/glr: 0e04a3a | laben++ | S03-metaops/hyper.t: Defudge hyper tests that incorrectly die no more Fixed by 441d54d42e1601d555e601c3068a935dbb4360d4 |
20:32 | |
ast/glr: edcf987 | laben++ | S03-metaops/hyper.t: Merge pull request #68 from laben/glr Defudge hyper tests that incorrectly die no more |
|||
nine | laben++ # good catch! | 20:33 | |
20:35
llfourn left
|
|||
laben | time to see what's up with panda, again :/ | 20:35 | |
ugexe | panda installs with zef, so it should just be the bootstraper that is not working | 20:37 | |
moritz | does zef precompile? | ||
colomon | does zef install with panda? | ||
laben | lizmat: did you try panda rebootstrap recently? it dies with "Use of uninitialized value %!elems of type Any in string context" that seem to reference a field from rakudo code | ||
ugexe | yes zef precompiles, and it will install with panda | ||
lizmat | laben: it has been ages since I did a panda rebootstrap | ||
could you give me a stack trace somehow? | 20:38 | ||
nine | m: my $pair = a => 1; for $pair.value -> $v is rw { $v += 1 }; say $pair.value; | 20:39 | |
camelia | rakudo-moar 5fb81f: OUTPUT«2» | ||
GLRelia | rakudo-moar 7591fc: OUTPUT«Cannot assign to an immutable value in block <unit> at /tmp/TZ11hQ2jzw:1» | ||
nine | m: class Foo { has $.value; }; my $foo = Foo.new(value => 1); for $foo.value -> $v is rw { $v += 1 }; say $foo.value; | 20:40 | |
camelia | rakudo-moar 5fb81f: OUTPUT«Cannot assign to an immutable value in block <unit> at /tmp/C0atOOJKsZ:1» | ||
GLRelia | rakudo-moar 7591fc: OUTPUT«Cannot assign to an immutable value in block <unit> at /tmp/Q3IFHhrAmb:1» | ||
nine | m: class Foo { has $.value is rw; }; my $foo = Foo.new(value => 1); for $foo.value -> $v is rw { $v += 1 }; say $foo.value; | ||
camelia | rakudo-moar 5fb81f: OUTPUT«2» | ||
GLRelia | rakudo-moar 7591fc: OUTPUT«Cannot assign to an immutable value in block <unit> at /tmp/ygrqpiCGUp:1» | ||
laben | lizmat: sorry, stacktrace seems unavailable, it complains about panda funcs but there's no %!elems there, i thought you would know better since it uses sets to calculate deps | 20:41 | |
nine | m: class Foo { has $.value is rw; }; my $foo = Foo.new(value => 1); $foo.value += 1; say $foo.value; | ||
camelia | rakudo-moar 5fb81f: OUTPUT«2» | ||
GLRelia | rakudo-moar 7591fc: OUTPUT«2» | ||
20:41
Loren joined
|
|||
nine | my $a = 1; for $a -> $v is rw { $v += 1; }; say $a; | 20:42 | |
m: my $a = 1; for $a -> $v is rw { $v += 1; }; say $a; | |||
camelia | rakudo-moar 5fb81f: OUTPUT«2» | ||
GLRelia | rakudo-moar 7591fc: OUTPUT«Cannot assign to an immutable value in block <unit> at /tmp/wm1cSXjnLp:1» | ||
20:47
diana_olhovik__ left
|
|||
nine | m: my $a = 1; $a.list += 1; | 20:47 | |
camelia | rakudo-moar 5fb81f: OUTPUT«Cannot assign to an immutable value in block <unit> at /tmp/ClaHKbb4QA:1» | ||
GLRelia | rakudo-moar 7591fc: OUTPUT«Cannot assign to an immutable value in block <unit> at /tmp/BJd52Bh6ii:1» | ||
nine | m: my $a = 1; $a.list.[0] += 1; | 20:48 | |
camelia | rakudo-moar 5fb81f: OUTPUT«Cannot modify an immutable Int in block <unit> at /tmp/PHFHYbWCfL:1» | ||
GLRelia | rakudo-moar 7591fc: OUTPUT«Cannot modify an immutable Int in block <unit> at /tmp/isVT4ES9jn:1» | ||
timotimo | o/ | 20:50 | |
lizmat | m: mix( (foo => 10.1, bar => 17.2)).perl.say | 20:51 | |
camelia | rakudo-moar 5fb81f: OUTPUT«(:foo(10.1)=>1,:bar(17.2)=>1).Mix» | ||
GLRelia | rakudo-moar 7591fc: OUTPUT«(:foo(10.1)=>1,:bar(17.2)=>1).Mix» | ||
timotimo | hoelzro: were we agreeing to sign on to irc before bed or were we agreeing to not do that? %) | ||
hoelzro | timotimo: umm... | ||
timotimo | ven's gone :( | 20:52 | |
nine | .oO( what bed? ) |
||
hoelzro | I don't know if we agreed or not, but here we are =) | ||
timotimo | oh snap | ||
moritz | you guys *sleep* when you should be hacking? :-) | ||
lizmat | ok, sethash.t and mixhash.t have some issues I'm too tired too grep now | ||
timotimo | moritz: psch! | ||
lizmat | so I'll take care of them tomorrow | ||
timotimo | moritz: btw, you started the release progress; what can i do to help? | 20:53 | |
fill out the moarvm changelog perhaps? | |||
moritz | timotimo: yes (and maybe even release MoarVM) | 20:54 | |
timotimo | right | ||
dalek | ast/glr: 0d1b8bf | lizmat++ | S02-types/mixhash.t: Fix at least one mixhash.t test More tomorrow |
||
20:54
espadrine joined
|
|||
dalek | rl6-roast-data: b82045e | coke++ | / (2 files): another glr run for 'today' |
20:57 | |
20:58
skids left
20:59
espadrine left
21:01
Loren left
21:04
lucasb_ joined
21:05
bin_005 left
21:06
FROGGS left
|
|||
lizmat | m: Bag.new( (a => 42, b=>666)).perl.say | 21:07 | |
camelia | rakudo-moar 5fb81f: OUTPUT«(:b(666)=>1,:a(42)=>1).Bag» | ||
GLRelia | rakudo-moar 7591fc: OUTPUT«(:b(666)=>1,:a(42)=>1).Bag» | ||
lizmat | m: Hash.new( (a => 42, b=>666)).perl.say | ||
GLRelia | rakudo-moar 7591fc: OUTPUT«{:a(42), :b(666)}» | ||
camelia | rakudo-moar 5fb81f: OUTPUT«{:a(42), :b(666)}<>» | ||
lizmat | m: Bag.new-from-pairs( (a => 42, b=>666)).perl.say | 21:08 | |
camelia | rakudo-moar 5fb81f: OUTPUT«("a"=>42,"b"=>666).Bag» | ||
GLRelia | rakudo-moar 7591fc: OUTPUT«("a"=>42,"b"=>666).Bag» | ||
lizmat fades away | |||
21:08
lizmat left
|
|||
lucasb_ | Is there some rationale for print() using .Str and say() using .gist? Shouldn't they just differ with regard to "\n"? | 21:10 | |
timotimo | say's supposed to be "for humans" and print "for computers" | 21:11 | |
[Coke] | lucasb_: there was an argument made years ago for that, it was lost, it's probably not getting changed at this point. (I wasn't a fan either) | 21:12 | |
21:12
Sqirrel left
21:13
Sqirrel joined
|
|||
jdv79 | [Coke]: what was the short reason? | 21:13 | |
lucasb_ | timotimo: I thought that was the difference between .perl and .gist. But if it applies to say/print, ok then | ||
jdv79 | seems nice there's a differentiation otherwise there's no need for 2 methods | ||
lucasb_ | timotimo, [Coke]: thanks for answering | 21:14 | |
[Coke] | what timotimo said. | ||
(for jdv79 ) | |||
PerlJam | greetings! How's SPW going? | 21:15 | |
jdv79 | i thought you meant for the other side | ||
21:16
ab6tract left
|
|||
hoelzro | PerlJam: greetings! it's going quite well, thanks! | 21:17 | |
21:17
larion left,
bin_005 joined,
bin_005 left
|
|||
PerlJam | Did someone cut a nom release? | 21:18 | |
21:18
kanl left
|
|||
PerlJam | Or ... is someone planning on doing it? | 21:18 | |
timotimo | we're working towards it, a little bit | 21:19 | |
but not really the people at the spw | |||
21:21
bin_005 joined
|
|||
PerlJam | Well, I'd volunteered for this month and I'll have some free time later tonight (in about 4 hours or so). Should I just make a nom release? | 21:21 | |
timotimo | moritz has started working on that today (or was it yesterday?); i'm going to bed real soon now, so i can't really be of help :( | 21:23 | |
japhb | Anybody have links to SPW slide decks? (If there have been any, I've missed them in the voluminous backlog. Which is sortof like luminiferous aether, and likewise problematic in that you can't detect anything in it.) | 21:24 | |
laben | good night|work #perl6 | 21:25 | |
laben heads off to bed | |||
PerlJam | g'night laben | ||
japhb | o/ laben | ||
21:25
laben left
|
|||
PerlJam patiently waits for someone to answer japhb too ... | 21:27 | ||
21:27
[Sno] left
|
|||
japhb | Yeah, here I am hoping to get a Friday afternoon Perl 6 talk fix .... | 21:27 | |
timotimo | ohai japhb | ||
how are you today? | 21:28 | ||
lucasb_ | has anybody mentioned that yapcasia videos are online? I watched timtoady's and rjbs's talk and liked it :) | ||
timotimo | oh! | ||
where can they be found? | |||
ah | |||
lucasb_ | youtube channel: www.youtube.com/user/yapcasia/videos | ||
timotimo | www.youtube.com/user/yapcasia/videos | ||
look, it's jnthn! | 21:29 | ||
japhb | ohai timotimo | 21:32 | |
Not doing too bad; recovering from latest iteration of oral surgery, wheee | |||
timotimo | japhb: i've been meaning to run benchmarks against a rakudo/glr, but somehow i never got around to it | 21:33 | |
japhb | Seems like enough bugs have been fixed that it might even work. :-) | 21:34 | |
timotimo | oh yes | ||
japhb | Although, since last year, it should at least record the failure modes it finds ... | ||
timotimo | some of the tests may want changes so that they do the same thing, basically | ||
huh | 21:35 | ||
japhb | True. Any obvious performance differences need to be investigated to make sure they still do the same amount of work. | ||
timotimo | someone put JSON::Fast into panda | ||
but not a sufficiently new version of it | |||
bootstrap now fails, because one of the tests requires a single trailing , to be added to the expected value | |||
japhb | Though TBH, that's why I added the ability to specify expected output -- so that we could go back and make the tests output an expected value that should only be reached if all the work was done. | 21:36 | |
timotimo: That seems like a wrong test ... | |||
timotimo | yes, glr made it required | ||
ugh, bench list-checkouts is very unhappy with GLR :) | 21:37 | ||
japhb | lucasb_: Thank you for the YAPC::Asia video pointer. :-) | ||
Oh, ouch, yeah, I bet. | |||
There's a fair amount of sugar in bench that's probably flattening/itemization-sensitive. | |||
21:38
itz joined
|
|||
timotimo | very much so | 21:38 | |
japhb | Double pluses if you figure out patches that will work correctly under both, FWIW. | ||
timotimo | i'm just now rebuilding rakudo on nom on my desktop at home | ||
so that i can bench on ahead :) | |||
japhb | Probably the best immediate course of action | 21:39 | |
timotimo | immediate means "right before bedtime" ;) | ||
japhb wonders what percentage of his collected Perl 6 code will have to be rewritten after the merge. :-/ | |||
heh | |||
.oO( "Why didn't you do your chores already?" "Because you told me to do them immediately, and it's not bedtime yet!" ) |
21:40 | ||
timotimo | okay, building a very recent nom and a very recent glr now | 21:42 | |
i'm at a crossroads, and a decision is needed | |||
do i buy new ram for my desktop because the 8gb just don't cut it any more | 21:43 | ||
or do i just wait for my next big update and get DDR4 along with that? | |||
21:46
virtualsue joined
|
|||
timotimo | now how am i supposed to go to bed when there's a benchmark going on and i could be watching for the exact moment it finishes so that i can see the performance difference immediately :| | 21:46 | |
japhb | timotimo: Do you need to swap out all of your current memory sticks in order to add more memory to the existing desktop? | ||
timotimo | yes | 21:47 | |
but i have someone who's very interested in getting at least one of the sticks | |||
japhb | timotimo: Have it alarm/SMS/page/otherwise wake you when it's done? | ||
timotimo | ugh, that's even worse! :) | ||
just started the "./bench time" call :) | 21:48 | ||
japhb | timotimo: Well, that makes it easier ... go to 16 GB then. :-) | ||
timotimo | Run command wrote to STDERR: install/bin/perl6 --optimize=3 -e 0 | ||
Compiler rakudo-moar is failing for test zero, continuing to next compiler/test. | |||
well, that's not so good | |||
hahahahaha | |||
Useless use of constant integer 0 in sink context (line 1) | |||
:D | |||
japhb | There aren't many times that I've regretted a memory upgrade. (The only time was when populating more slots in a single channel dropped the memory clock enough to steal much of the expected improvement in overall throughput) | 21:49 | |
timotimo | oh! yikes | ||
i have only two slots to begin with | |||
at the moment they have two 4gb sticks in them | |||
in theory, it'd already be a nice upgrade to replace one of them with an 8gb stick | |||
japhb | Yeah, I'm wondering if it ought to be possible to turn off the STDERR detection, because overzealous warnings/alerts are causing a problem. Or maybe I should just -Mno-strict the -e tester. | 21:50 | |
timotimo | we can just have the "zero" program do something that does something that doesn't warn :) | 21:51 | |
like perl6 -e '' | |||
or is that "empty" already? | |||
japhb | timotimo: ... as long as those two slots can be safely mismatched. Not all of them can. (Or at least, back the last time I had a desktop at home. Which was ... a while ago, actually.) | ||
timotimo | mhh | 21:52 | |
i expect it'll be fine | |||
for_empty also warns about the final "1" | |||
japhb | empty is '', and it's intentionally there to not even do any parsing. It should be the fastest the compiler can be started in non-help/REPL mode. | ||
timotimo | we should implement a special case of "empty program" so we don't even have to deserialize the grammar :P | ||
japhb | :-P | ||
timotimo | in the repl, we bring up the first input prompt before the compiler causes the grammar to be loaded | 21:53 | |
hoelzro | ok, bed time for realz | ||
good night #perl6 | |||
PerlJam | sleep well hoelzro! | ||
timotimo | gnite hoelzro! | ||
japhb | o/ hoelzro | ||
timotimo | still watching jnthn's concurrency talk | 21:54 | |
(which i missed via oversleeping tonight) | |||
japhb | Did he do the same one at SPW as at YAPC::Asia? | ||
timotimo | slightly changed, i believe | ||
japhb | Dang it, now I want that slide deck even more. :-) | ||
timotimo | you already have the previous one, yeah? | 21:55 | |
japhb | Yeah. But he does so much CDD, that often the first place I find out about his latest cool stuff is in those slide decks. :-) | ||
timotimo | ah | 21:56 | |
21:58
rurban joined
|
|||
timotimo | first component is at 56/73 already | 21:58 | |
21:59
lucasb_ left
|
|||
japhb thinks that 'my $z = 0;' might be a decent replacement for '0' that would be identical across all compilers (delta := for nqp) | 21:59 | ||
timotimo | ah | ||
sounds good | |||
that'll not warn any more | 22:00 | ||
japhb | Yeah, and still maintains its use as a near-minimal use of the parser (probably a much better one, too, come to think of it -- more likely to light up more of the grammar.) | ||
timotimo | yeah | 22:01 | |
japhb | Care to patch, or shall I? | ||
timotimo | please go ahead :) | ||
i'd be interested to see if rc-forest-fire is going to ever work properly in the future >_> | |||
oh! | 22:02 | ||
it works! | |||
cool | |||
dalek | rl6-bench: 8b8d049 | (Geoffrey Broadwell)++ | microbenchmarks.pl: Fix 'zero' microbenchmark not to sink-warn |
22:03 | |
japhb | Oh cool! | ||
wheee, the joy of freehand patching | 22:04 | ||
timotimo | are fires supposed to randomly go out? | ||
japhb | timotimo: If they can't find more to burn nearby, yes. It's been a long time since I looked, but some implementations of that CA can put a new tree on top of a burning one. I don't *think* we do that. | 22:06 | |
22:06
rurban left
|
|||
timotimo | nah, i see burning trees with lots of neighbours and these neighbours are spared from burning up | 22:06 | |
22:06
rangerprice left
|
|||
japhb | If it goes out when there's adjacent trees, that's probably a bug | 22:06 | |
22:07
RabidGravy left
|
|||
japhb | Do the fires ever spread in the first place? | 22:07 | |
timotimo | yes | ||
japhb | Oh, hmmm, that's more subtle territory | ||
timotimo | yeah | ||
second component is now running | |||
japhb | There was a long time ago a bug in which neighbor information started pointing to old versions of the forest; IIRC TimToady++ fixed that in the nom days. | 22:08 | |
I wonder if it has reared it's ugly head again. | 22:09 | ||
japhb imagines a t-shirt with the logo "UGLY BUG" | |||
So many possible images to go with that logo/tagline. Or maybe none at all, and implicitly that role falls to the wearer. :-) | 22:10 | ||
timotimo | BUGLY | 22:11 | |
22:11
byterock joined
|
|||
timotimo | ;; AUTHORITY SECTION: | 22:11 | |
ly. 600 IN SOA dns.lttnet.NET. khaleds.lttnet.NET. 2015082889 3600 900 2419200 600 | |||
^- for bug.ly :) | |||
japhb wishes there were a decent way to guarantee an equivalent random number stream between compilers, without limiting their freedom to write a fast PRNG | |||
heh | |||
timotimo | yeah, that's a hard problem™ | ||
on GLR, the forest doesn't change any more at all | 22:12 | ||
japhb | I thought about just reading from the same file of random bits, but then you end up testing binary I/O performance ... | 22:13 | |
timotimo | so we should take the benchmark results with more spoonsful of salt than we usually do | ||
yeah :| | |||
you could implement a dumb prng yourself | |||
japhb | true. | ||
My all time favorite is one from TAOCP. Lemme see if I can find it. | 22:14 | ||
timotimo | github.com/Microsoft/WinObjC/blob/...isc.mm#L28 | 22:16 | |
japhb | Oh. Oh dear. | ||
That's ... wow. | |||
timotimo | twitter.com/FioraAeterna/status/63...3636004865 - "This is a very creative RC4 implementation, huh" | 22:17 | |
who decided the monitor concurrency pattern should be called that? | 22:18 | ||
22:19
itz left,
virtualsue left
|
|||
timotimo | Type check failed in binding; expected 'Positional' but got 'Seq' | 22:20 | |
in sub MAIN at perl6/rc-forest-fire-stringify:8 | |||
quite GLR-ish | |||
that's "my @grid := [ ... ] xx $h" | |||
japhb | Yeah, sounds like it. | 22:22 | |
timotimo | yup. probably really wants to be = instead of := | ||
10 minutes of jnth's yapc::asia talk remaining, but only a single benchmark | |||
time to remember the ./bench compare incantation again | 22:24 | ||
japhb | Not finding the algorithm online, I went to my bookshelf. It's algorithm 3.2.2.A in my second edition copy: Basically fill 55 elements of a 56-element circular queue with arbitrary numbers (not all even), and then just keep doing Xn = X(n-24) + X(n-55) mod machine word size. Works whether the bit sequences are interpreted as integers or as floats, even. Deterministic but long-period and REALLY fast. | 22:25 | |
timotimo | neat | 22:28 | |
we'd really want a mersenne twister in our ecosystem at some time | |||
there's quite fast implementations of those using simd instructions even | |||
hm | 22:30 | ||
now which one was glr and which one was nom? | |||
t.h8.lv/p6bench/2015-08-29-nom_vs_glr.html - blue is nom, orange is glr | 22:31 | ||
22:31
llfourn joined
|
|||
timotimo | looks pretty bad | 22:31 | |
m: my @a; my $i = 0; @a[$i] = $i; while (++$i <= SCALE) { @a[ $i ] = $i }; say @a[*-1];' | 22:33 | ||
camelia | rakudo-moar 5fb81f: OUTPUT«5===SORRY!5=== Error while compiling /tmp/M447ppGz9OUnable to parse expression in single quotes; couldn't find final "'" at /tmp/M447ppGz9O:1------> 3 SCALE) { @a[ $i ] = $i }; say @a[*-1];'7⏏5<EOL> expecting any of: sing…» | ||
GLRelia | rakudo-moar 7591fc: OUTPUT«5===SORRY!5=== Error while compiling /tmp/hOGsBrnyXJUnable to parse expression in single quotes; couldn't find final "'" at /tmp/hOGsBrnyXJ:1------> 3 SCALE) { @a[ $i ] = $i }; say @a[*-1];'7⏏5<EOL> expecting any of: sing…» | ||
timotimo | m: constant SCALE = 1024; my @a; my $i = 0; @a[$i] = $i; while (++$i <= SCALE) { @a[ $i ] = $i }; say @a[*-1];' | ||
camelia | rakudo-moar 5fb81f: OUTPUT«5===SORRY!5=== Error while compiling /tmp/Wj6P7eW9QaUnable to parse expression in single quotes; couldn't find final "'" at /tmp/Wj6P7eW9Qa:1------> 3 SCALE) { @a[ $i ] = $i }; say @a[*-1];'7⏏5<EOL> expecting any of: sing…» | ||
GLRelia | rakudo-moar 7591fc: OUTPUT«5===SORRY!5=== Error while compiling /tmp/ojhqffgMU1Unable to parse expression in single quotes; couldn't find final "'" at /tmp/ojhqffgMU1:1------> 3 SCALE) { @a[ $i ] = $i }; say @a[*-1];'7⏏5<EOL> expecting any of: sing…» | ||
timotimo | m: constant SCALE = 1024; my @a; my $i = 0; @a[$i] = $i; while (++$i <= SCALE) { @a[ $i ] = $i }; say @a[*-1]; | ||
camelia | rakudo-moar 5fb81f: OUTPUT«1024» | ||
GLRelia | rakudo-moar 7591fc: OUTPUT«1024» | ||
timotimo | what is going on here ... | 22:34 | |
that benchmark i pasted above has a 4x slowdown :( | |||
well, we haven't really optimized things at all yet on the glr side | 22:35 | ||
japhb | Actually, it looks like mixed results to me. Some of the tests, like while_push*, show a good benefit from GLR, but while_array_set is much worse. | ||
timotimo | i still think it's bad ;) | ||
japhb | Ooh, for loops took a huge hit. | ||
22:35
llfourn left
|
|||
japhb | I'm still scrolling through it | 22:35 | |
reduce is mixed. any_equals is way worse | 22:36 | ||
timotimo | i wonder if the for-to-while optimization had been in effect in nom, but isn't any more in glr | ||
that optimization is super fiddly | |||
japhb | As are split_string* | ||
timotimo | breaks every few revision | ||
japhb | I bet you are correct. | ||
Hmmm, charrange (and a couple others) seem more unstable | |||
timotimo | how do you feel about building a nom and a glr locally and comparing their --target=optimize while i rest? :) | 22:37 | |
japhb | timotimo: You should definitely rest. Unfortunately, I should definitely get back to $day-job. | 22:38 | |
22:40
rangerprice joined
22:41
rarara joined
22:42
TEttinger joined
|
|||
timotimo | good luck at $day-job! | 22:45 | |
ttyl :) | |||
22:56
skids joined
22:58
yqt left
23:00
rarara left
23:03
Timbus_ joined,
Timbus left
23:04
byterock left
23:05
rangerprice left
23:07
larion joined
23:13
larion left
|
|||
jdv79 | wonder what a p6 "brush" for github.com/syntaxhighlighter would look like | 23:20 | |
where are the existing p6 syntax highlighers? |