»ö« 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:00
lizmat left
00:16
llfourn joined
00:20
llfourn left
00:21
tinyblak left
00:26
laouji joined
00:31
tinyblak joined
00:39
laouji left
00:40
laouji joined,
laouji left
00:48
araujo_ joined
00:50
laouji joined,
araujo left
00:55
khisanth_ is now known as Khisanth
|
|||
pmichaud | GLR-related challenge (a problem that once I know the solution will help with GLR design): | 01:03 | |
Write a function that given an array @a, lazily produces a list in the form (0, Write a Perl 6 function that given an array @a, lazily produces a list in the form (0, @a[0,0], 1, @a[1,1], 2, @a[2,2], 3, @a[3,3], ... ). | |||
(in standard Perl 6) | |||
01:03
lizmat joined
|
|||
pmichaud | you can assume that while/until/etc. loops are able to lazily return lists of elements | 01:04 | |
grondilu | you sure you wrote that right? | ||
pmichaud | which part are you unsure of? ;-) | ||
grondilu | it's not some recursive thing is it? | 01:05 | |
pmichaud | no, it should be iterative | ||
(at least I'm thinking it should be iterative) | |||
it's a question of syntax and composition more than anything else. | |||
grondilu | but I'm confused about the part "(0, Write" | ||
pmichaud | oh | 01:06 | |
yeah, copy/paste error | |||
fixing | |||
Write a Perl 6 function that given an array @a, lazily produces a list in the form (0, @a[0,0], 1, @a[1,1], 2, @a[2,2], 3, @a[3,3], ... ). | |||
*there* | |||
grondilu | does not look so hard | 01:07 | |
pmichaud | it has a couple of gotchas :) | ||
grondilu | oh it must flatten, right? | ||
pmichaud | no, no flattening | ||
the equivalent output would be (0, (@a[0], @a[0]), 1, (@a[1], @a[1]), 2, (@a[2], @a[2]), ... ) | 01:08 | ||
grondilu | sub (@a) { gather for ^Inf -> $n { take $n, @a[$n, $n].item } } # is that too naice? | 01:09 | |
*naive | |||
01:09
telex left
|
|||
pmichaud | grondilu: #1. It's itemizing the slices | 01:09 | |
(which my output doesn't have) | 01:10 | ||
01:10
telex joined
|
|||
pmichaud | the list that sub is producing is actually ((0, [@a[0], @a[0]]), (1, [@a[1], @a[1]]), ... ) | 01:11 | |
grondilu | fine | ||
well then just double the takes | |||
sub (@a) { gather for ^Inf -> $n { take $n; take @a[$n, $n].item } } | |||
or | 01:12 | ||
sub (@a) { gather for ^Inf -> $n { take $n; take @a[$n, $n] } } | |||
01:12
araujo_ left
|
|||
grondilu | no? | 01:12 | |
pmichaud | thinking | ||
that seems plausible, yes. | |||
grondilu | m: (sub (@a) { gather for ^Inf -> $n { take $n; take @a[$n, $n] } })( my @ = "a".."z" ) | ||
camelia | rakudo-moar 80f8ef: OUTPUT«(timeout)» | 01:13 | |
grondilu | m: say (sub (@a) { gather for 0..* -> $n { take $n; take @a[$n, $n] } })( my @ = "a".."z" ) | ||
camelia | rakudo-moar 80f8ef: OUTPUT«0 a a 1 b b 2 c c 3 d d 4 e e 5 f f 6 g g 7 h h 8 i i 9 j j 10 k k 11 l l 12 m m 13 n n 14 o o 15 p p 16 q q 17 r r 18 s s 19 t t 20 u u 21 v v 22 w w 23 x x 24 y y 25 z z 26 (Any) (Any) 27 (Any) (Any) 28 (Any) (Any) 29 (Any) (Any) 30 (Any) (Any) 31 (Any) …» | ||
grondilu | m: say (sub (@a) { gather for ^@a -> $n { take $n; take @a[$n, $n] } })( my @ = "a".."z" ) | 01:14 | |
camelia | rakudo-moar 80f8ef: OUTPUT«0 a a 1 b b 2 c c 3 d d 4 e e 5 f f 6 g g 7 h h 8 i i 9 j j 10 k k 11 l l 12 m m 13 n n 14 o o 15 p p 16 q q 17 r r 18 s s 19 t t 20 u u 21 v v 22 w w 23 x x 24 y y 25 z z» | ||
pmichaud | I'd need to see the .perl | ||
grondilu | m: say (sub (@a) { gather for ^@a -> $n { take $n; take @a[$n, $n] } })( my @ = "a".."z" ).perl | ||
camelia | rakudo-moar 80f8ef: OUTPUT«(0, ("a", "a"), 1, ("b", "b"), 2, ("c", "c"), 3, ("d", "d"), 4, ("e", "e"), 5, ("f", "f"), 6, ("g", "g"), 7, ("h", "h"), 8, ("i", "i"), 9, ("j", "j"), 10, ("k", "k"), 11, ("l", "l"), 12, ("m", "m"), 13, ("n", "n"), 14, ("o", "o"), 15, ("p", "p"), 16, ("q",…» | ||
01:14
AlexDaniel joined
|
|||
pmichaud | and it would *really* be better if this is done without gather/take. Either that or we'll have to really fix gather/take. | 01:14 | |
grondilu | ah that's the hard part then. Doing lazy lists without gather/take is tricky. | ||
pmichaud | I did say you can assume that while/until is able to lazily return lists of elements | 01:15 | |
(as designed in S04) | |||
grondilu | m: say (sub (@a) { for ^@a -> $n { $n, @a[$n, $n] } })( my @ = "a".."z" ).perl | 01:16 | |
camelia | rakudo-moar 80f8ef: OUTPUT«Nil» | ||
pmichaud | actually, let me relax the problem a bit, then. Take laziness out as a requirement. | ||
grondilu | m: say (sub (@a) { do for ^@a -> $n { $n, @a[$n, $n] } })( my @ = "a".."z" ).perl | ||
camelia | rakudo-moar 80f8ef: OUTPUT«((0, ("a", "a")), (1, ("b", "b")), (2, ("c", "c")), (3, ("d", "d")), (4, ("e", "e")), (5, ("f", "f")), (6, ("g", "g")), (7, ("h", "h")), (8, ("i", "i")), (9, ("j", "j")), (10, ("k", "k")), (11, ("l", "l")), (12, ("m", "m")), (13, ("n", "n")), (14, ("o", "o…» | ||
pmichaud | i.e., it's okay to do it eagerly. | ||
so, I'll reformulate the problem a bit. | |||
grondilu | m: say (sub (@a) { ( $++, @a[$++,$++] for ^@a ) })( my @ = "a".."z" ).perl | 01:17 | |
camelia | rakudo-moar 80f8ef: OUTPUT«((0, ("a", "a")), (1, ("b", "b")), (2, ("c", "c")), (3, ("d", "d")), (4, ("e", "e")), (5, ("f", "f")), (6, ("g", "g")), (7, ("h", "h")), (8, ("i", "i")), (9, ("j", "j")), (10, ("k", "k")), (11, ("l", "l")), (12, ("m", "m")), (13, ("n", "n")), (14, ("o", "o…» | ||
pmichaud | Q2: Write a Perl 6 function that takes an array as a parameter @a and produces a list in the form (0, @a[0,0], 1, @a[1,1], 2, @a[2,2], 3, @a[3,3], ... ). Avoid us | 01:18 | |
ing gather/take. | |||
grondilu | m: say (sub (@a) { ^Inf Z (@a Z @a) })( my @ = "a".."z" ).perl | 01:19 | |
01:19
silug left
|
|||
camelia | rakudo-moar 80f8ef: OUTPUT«((0, "a"), (1, "a"), (2, "b"), (3, "b"), (4, "c"), (5, "c"), (6, "d"), (7, "d"), (8, "e"), (9, "e"), (10, "f"), (11, "f"), (12, "g"), (13, "g"), (14, "h"), (15, "h"), (16, "i"), (17, "i"), (18, "j"), (19, "j"), (20, "k"), (21, "k"), (22, "l"), (23, "l"), (…» | 01:19 | |
pmichaud | You can assume that the list-producing qualities of while and until (as described in S04) are available. | ||
Util | m: sub pm (@a) { @a.keys.map({ $_, item(@a[$_, $_]) }) }; say [my @ = pm(["A".."D"])].perl; | 01:20 | |
camelia | rakudo-moar 80f8ef: OUTPUT«[0; "A", "A"; 1; "B", "B"; 2; "C", "C"; 3; "D", "D"]» | ||
Util | What is the significance of the semi-colons in the output? | ||
pmichaud | it's showing that you have lists-of-lists (i.e., a LoL object). | 01:21 | |
grondilu | m: say (sub (@a) { ( flat $++, @a[$++,$++] for ^@a ) })( my @ = "a".."z" ).perl | ||
camelia | rakudo-moar 80f8ef: OUTPUT«(0, "a", "a", 1, "b", "b", 2, "c", "c", 3, "d", "d", 4, "e", "e", 5, "f", "f", 6, "g", "g", 7, "h", "h", 8, "i", "i", 9, "j", "j", 10, "k", "k", 11, "l", "l", 12, "m", "m", 13, "n", "n", 14, "o", "o", 15, "p", "p", 16, "q", "q", 17, "r", "r", 18, "s", "s",…» | ||
grondilu | m: say (sub (@a) { ( flat $++, @a[$++,$++].item for ^@a ) })( my @ = "a".."z" ).perl | ||
camelia | rakudo-moar 80f8ef: OUTPUT«(0, $("a", "a"), 1, $("b", "b"), 2, $("c", "c"), 3, $("d", "d"), 4, $("e", "e"), 5, $("f", "f"), 6, $("g", "g"), 7, $("h", "h"), 8, $("i", "i"), 9, $("j", "j"), 10, $("k", "k"), 11, $("l", "l"), 12, $("m", "m"), 13, $("n", "n"), 14, $("o", "o"), 15, $("p",…» | ||
grondilu | what about that? | 01:22 | |
m: say (sub (@a) { ( flat $++, (@a[$++,$++]) for ^@a ) })( my @ = "a".."z" ).perl | |||
camelia | rakudo-moar 80f8ef: OUTPUT«(0, "a", "a", 1, "b", "b", 2, "c", "c", 3, "d", "d", 4, "e", "e", 5, "f", "f", 6, "g", "g", 7, "h", "h", 8, "i", "i", 9, "j", "j", 10, "k", "k", 11, "l", "l", 12, "m", "m", 13, "n", "n", 14, "o", "o", 15, "p", "p", 16, "q", "q", 17, "r", "r", 18, "s", "s",…» | ||
pmichaud | the inner parcels have been itemized, so no | ||
grondilu | m: say (sub (@a) { ( flat $++, (@a[$++,$++],) for ^@a ) })( my @ = "a".."z" ).perl | ||
camelia | rakudo-moar 80f8ef: OUTPUT«(0, "a", "a", 1, "b", "b", 2, "c", "c", 3, "d", "d", 4, "e", "e", 5, "f", "f", 6, "g", "g", 7, "h", "h", 8, "i", "i", 9, "j", "j", 10, "k", "k", 11, "l", "l", 12, "m", "m", 13, "n", "n", 14, "o", "o", 15, "p", "p", 16, "q", "q", 17, "r", "r", 18, "s", "s",…» | ||
grondilu | m: say (sub (@a) { ( flat $++, (@a[$++,$++],Nil) for ^@a ) })( my @ = "a".."z" ).perl | 01:23 | |
camelia | rakudo-moar 80f8ef: OUTPUT«(0, "a", "a", Nil, 1, "b", "b", Nil, 2, "c", "c", Nil, 3, "d", "d", Nil, 4, "e", "e", Nil, 5, "f", "f", Nil, 6, "g", "g", Nil, 7, "h", "h", Nil, 8, "i", "i", Nil, 9, "j", "j", Nil, 10, "k", "k", Nil, 11, "l", "l", Nil, 12, "m", "m", Nil, 13, "n", "n", Nil,…» | ||
grondilu | m: say (my @ = ^10)[4,5] | 01:24 | |
camelia | rakudo-moar 80f8ef: OUTPUT«4 5» | ||
grondilu | m: say (my @ = ^10)[4,5].perl | ||
camelia | rakudo-moar 80f8ef: OUTPUT«(4, 5)» | ||
grondilu | (just checking what a splice looks like with perl) | ||
m: say ("foo", (my @ = ^10)[4,5]).perl | |||
camelia | rakudo-moar 80f8ef: OUTPUT«("foo", (4, 5))» | ||
grondilu | i c | ||
lizmat | ( pmichaud has temporarily left the room ) | 01:25 | |
01:25
araujo_ joined
|
|||
pmichaud | I'm in a different room :) | 01:25 | |
grondilu | m: say (sub (@a) { ( flat $++, @a[$++,$++][] for ^@a ) })( my @ = "a".."z" ).perl | ||
camelia | rakudo-moar 80f8ef: OUTPUT«(0, "a", "a", 1, "b", "b", 2, "c", "c", 3, "d", "d", 4, "e", "e", 5, "f", "f", 6, "g", "g", 7, "h", "h", 8, "i", "i", 9, "j", "j", 10, "k", "k", 11, "l", "l", 12, "m", "m", 13, "n", "n", 14, "o", "o", 15, "p", "p", 16, "q", "q", 17, "r", "r", 18, "s", "s",…» | ||
grondilu | m: say (sub (@a) { ( @a[$++,$++] for ^@a ) })( my @ = "a".."z" ).perl | 01:26 | |
camelia | rakudo-moar 80f8ef: OUTPUT«(("a", "a"), ("b", "b"), ("c", "c"), ("d", "d"), ("e", "e"), ("f", "f"), ("g", "g"), ("h", "h"), ("i", "i"), ("j", "j"), ("k", "k"), ("l", "l"), ("m", "m"), ("n", "n"), ("o", "o"), ("p", "p"), ("q", "q"), ("r", "r"), ("s", "s"), ("t", "t"), ("u", "u"), ("v…» | ||
grondilu | m: say (sub (@a) { ^Inf Z ( @a[$++,$++] for ^@a ) })( my @ = "a".."z" ).perl | ||
camelia | rakudo-moar 80f8ef: OUTPUT«((0, "a"), (1, "a"), (2, "b"), (3, "b"), (4, "c"), (5, "c"), (6, "d"), (7, "d"), (8, "e"), (9, "e"), (10, "f"), (11, "f"), (12, "g"), (13, "g"), (14, "h"), (15, "h"), (16, "i"), (17, "i"), (18, "j"), (19, "j"), (20, "k"), (21, "k"), (22, "l"), (23, "l"), (…» | ||
grondilu | m: say (sub (@a) { ^Inf Z, ( @a[$++,$++] for ^@a ) })( my @ = "a".."e" ).perl | 01:27 | |
camelia | rakudo-moar 80f8ef: OUTPUT«((0, "a"), (1, "a"), (2, "b"), (3, "b"), (4, "c"), (5, "c"), (6, "d"), (7, "d"), (8, "e"), (9, "e"))» | ||
01:27
araujo_ left
|
|||
grondilu | Z flattens the RHS apparently | 01:27 | |
01:28
araujo_ joined,
cognominal joined
|
|||
grondilu | wait | 01:28 | |
m: say List.^methods | |||
camelia | rakudo-moar 80f8ef: OUTPUT«new to from fmt flat list lol flattens Capture Parcel Supply eager elems gimme iterator munch pick pop shift plan roll reverse rotate splice sort uniq unique squish rotor REIFY FLATTENABLE_LIST FLATTENABLE_HASH reduce sink STORE_AT_POS combinations permuta…» | ||
01:29
cognominal left
|
|||
grondilu | m: say (my @ = ^10).^methods | 01:29 | |
camelia | rakudo-moar 80f8ef: OUTPUT«new BIND-POS DELETE-POS flattens name of default dynamic REIFY STORE Method+{<anon>}.new Method+{<anon>}.new perl ACCEPTS elems iterator pick plan sort uniq unique Method+{<anon>}.new infinite fmt list flattens gimme sink STORE_AT_POS Method+{<anon>}.new M…» | ||
pmichaud | also, Z uses gather/take internally I suspect, so it's not legal. :) | ||
grondilu | m: say (my @ = ^10).kv | ||
camelia | rakudo-moar 80f8ef: OUTPUT«0 0 1 1 2 2 3 3 4 4 5 5 6 6 7 7 8 8 9 9» | ||
grondilu | m: say (sub (@a) { ( @a[$++,$++] for ^@a ).kv })( my @ = "a".."e" ).perl | ||
camelia | rakudo-moar 80f8ef: OUTPUT«(0, ("a", "a"), 1, ("b", "b"), 2, ("c", "c"), 3, ("d", "d"), 4, ("e", "e"))» | ||
grondilu | what about that? | 01:30 | |
01:30
araujo_ left
|
|||
grondilu | maybe using .kv is cheating? | 01:30 | |
pmichaud | kv is using gather/take also. | 01:31 | |
01:31
araujo_ joined
|
|||
grondilu | well if the list is not lazy, we can push in a variable, right? | 01:33 | |
01:33
silug joined
|
|||
grondilu | m: say (sub (@a) { my @b; push @b, $++, @a[$++, $++] for ^@a })( my @ = "a".."e" ).perl | 01:33 | |
camelia | rakudo-moar 80f8ef: OUTPUT«Nil» | ||
grondilu | m: say (sub (@a) { my @b; push @b, $++, @a[$++, $++] for ^@a; return @b })( my @ = "a".."e" ).perl | 01:34 | |
camelia | rakudo-moar 80f8ef: OUTPUT«[0, "a", "a", 1, "b", "b", 2, "c", "c", 3, "d", "d", 4, "e", "e"]<>» | ||
grondilu | m: say (sub (@a) { my @b; push @b, $++, (@a[$++, $++]) for ^@a; return @b })( my @ = "a".."e" ).perl | ||
camelia | rakudo-moar 80f8ef: OUTPUT«[0, "a", "a", 1, "b", "b", 2, "c", "c", 3, "d", "d", 4, "e", "e"]<>» | ||
grondilu | oh | ||
m: say (sub (@a) { my @b; for ^@a { push @b, $_; push @b, @a[$_, $_] }; return @b })( my @ = "a".."e" ).perl | 01:35 | ||
camelia | rakudo-moar 80f8ef: OUTPUT«[0, "a", "a", 1, "b", "b", 2, "c", "c", 3, "d", "d", 4, "e", "e"]<>» | ||
grondilu | push flattens ?! | ||
lizmat | push takes a slurpy, which flattens, no? | 01:36 | |
grondilu | m: say (sub (@a) { my @b; for ^@a { @b[2*$_] = $_; @b[2*$_+1] = (@a[$_, $_]) }; return @b })( my @ = "a".."e" ).perl | 01:37 | |
camelia | rakudo-moar 80f8ef: OUTPUT«[0; "a", "a"; 1; "b", "b"; 2; "c", "c"; 3; "d", "d"; 4; "e", "e"]<>» | ||
grondilu | semicolons again :/ | 01:38 | |
m: say (sub (@a) { my $b; for ^@a { $b[2*$_] = $_; $b[2*$_+1] = (@a[$_, $_]) }; return $b })( my @ = "a".."e" ).perl | |||
camelia | rakudo-moar 80f8ef: OUTPUT«[0; "a", "a"; 1; "b", "b"; 2; "c", "c"; 3; "d", "d"; 4; "e", "e"]» | ||
pmichaud | I have to get ready for my session -- bbl | 01:40 | |
will backlog later | |||
01:42
BenGoldberg joined
|
|||
grondilu | m: say (sub (@a) { ( $++, @a[$++, $++]) xx * }; return @b })( my @ = "a".."e" ).perl | 01:42 | |
camelia | rakudo-moar 80f8ef: OUTPUT«5===SORRY!5=== Error while compiling /tmp/ceoJACQ167Variable '@b' is not declaredat /tmp/ceoJACQ167:1------> 3) { ( $++, @a[$++, $++]) xx * }; return 7⏏5@b })( my @ = "a".."e" ).perl» | ||
grondilu | m: say (sub (@a) { ( $++, @a[$++, $++]) xx * })( my @ = "a".."e" ).perl | ||
camelia | rakudo-moar 80f8ef: OUTPUT«(ListIter.new,)» | ||
grondilu | m: say $++ xx 5 | ||
camelia | rakudo-moar 80f8ef: OUTPUT«0 1 2 3 4» | ||
grondilu | m: say (sub (@a) { ( $++, @a[$++, $++]) xx * })( my @ = "a".."e" )[^10].perl | ||
camelia | rakudo-moar 80f8ef: OUTPUT«((0, ("a", "a")), (1, ("b", "b")), (2, ("c", "c")), (3, ("d", "d")), (4, ("e", "e")), (5, (Any, Any)), (6, (Any, Any)), (7, (Any, Any)), (8, (Any, Any)), (9, (Any, Any)))» | ||
grondilu | m: say (sub (@a) { |( $++, @a[$++, $++]) xx * })( my @ = "a".."e" )[^10].perl | 01:43 | |
camelia | rakudo-moar 80f8ef: OUTPUT«5===SORRY!5=== Error while compiling /tmp/ilV2BgSHoTArg-flattening | is only valid in an argument listat /tmp/ilV2BgSHoT:1------> 3say (sub (@a) { |7⏏5( $++, @a[$++, $++]) xx * })( my @ = "a"» | ||
grondilu | well that's hard | ||
01:50
araujo__ joined
01:53
ssqq joined,
araujo_ left
01:55
SevenWolf joined
02:07
llfourn joined
02:08
dayangkun joined
02:09
laouji left,
laouji joined,
dayangkun left
02:10
dayangkun joined
|
|||
AlexDaniel | method antipair() returns Pair:D # - what does this smiley means? | 02:11 | |
02:13
ssqq left
02:15
yqt left
02:23
Petit_Dejeuner left
02:29
noganex joined
02:32
noganex_ left
|
|||
b2gills | It means it returns a defined Pair object | 02:34 | |
02:35
rmgk left,
rmgk_ joined,
rmgk_ is now known as rmgk
|
|||
AlexDaniel | b2gills: thanks | 02:41 | |
lizmat | m: my $a := $a; say $a # jackpot! | 02:53 | |
camelia | rakudo-moar 80f8ef: OUTPUT«(signal SEGV)» | ||
lizmat | can someone rakudobug this ? | ||
awwaiid | Hello! | 02:54 | |
lizmat | ok, I lost my pair programmer, I'll do it myself :-) | 02:55 | |
awwaiid o/ | |||
awwaiid | I'm having great fun using matplotlib.pyplot Inline::Python; I created a simple wrapper, gist.github.com/awwaiid/ef3f0abcfa96e34977b4 | 02:56 | |
... and now I don't want to keep adding methods. What witches brew can we stir up today?! | 02:57 | ||
a nice evil autoload type thing would do | |||
if this was a Class, I could inherit from it and be done; alas this is a collection of defs in a module | 02:58 | ||
lizmat | there's 'method FALLBACK' | 02:59 | |
awwaiid googles | |||
03:00
thezip joined
|
|||
lizmat | design.perl6.org/S12.html#FALLBACK_methods | 03:00 | |
awwaiid | lizmat: OMG that worked | 03:01 | |
lizmat++ # Rock! | |||
lizmat | :) | ||
03:03
kurahaupo1 joined
|
|||
awwaiid | I updated the gist with the new version | 03:03 | |
I'm slurping data out of git which has github PRs; using that to estimate PR lifetime (time delta from first commit to PR merge). I was previously dumping that as a CSV and plotting in libreoffice -- but no longer! | 03:08 | ||
so awesome | |||
lizmat | :-) | 03:10 | |
m: my $a := $a; say $a.Str | |||
camelia | rakudo-moar 80f8ef: OUTPUT«Cannot call method 'Str' on a null object in block <unit> at /tmp/bu5hgP8_WK:1» | ||
03:11
bin_005 joined
03:13
tinyblak left,
tinyblak joined
|
|||
awwaiid | update gist.github.com/awwaiid/ef3f0abcfa96e34977b4 to have the full example -- simple wrapper lib, script for slurping git, and an example result chart png | 03:14 | |
Great way to end the day. Bedtime! | 03:15 | ||
03:19
silug left
|
|||
lizmat | good night, awwaiid | 03:26 | |
03:26
kaare_ joined
|
|||
thezip | lizmat, thanks for your help in pmichaud's presentation tonight | 03:30 | |
lizmat | yw ! | 03:31 | |
03:32
silug joined
03:33
skids joined
03:39
jack_rabbit left
03:41
laouji left
03:46
thezip left
03:50
bin_005 left,
BenGoldberg left
|
|||
dalek | kudo/nom: 1372f77 | lizmat++ | src/core/Pair.pm: Make sure that Pair<doesnotexist> returns Any |
03:51 | |
lizmat | rather than Mu spotted at the YAPC::NA Perl 6 intro course | 03:52 | |
zostay | is there a better way to say: subtype IntOrPositional of Mu where any(Int, Positional) ? | 03:54 | |
03:57
vendethiel joined
03:58
AlexDaniel left
|
|||
lizmat | zostay: don't know offhand | 04:12 | |
zostay | or using valid syntax (:-p): subset IntOrPositional of Mu where Int|Positional; | 04:15 | |
was just thinking returns Int|Positional would be handy | |||
04:17
davido_ left
04:18
davido_ joined
|
|||
lizmat | yes, but that will probably not happen before this year's Christmas | 04:21 | |
m: sub a returns Bool { fail }; a | |||
camelia | rakudo-moar 1372f7: OUTPUT«Earlier failure:  in block <unit> at /tmp/H579fGZYP9:1Final error: Type check failed for return value; expected 'Bool' but got 'Failure' in any return_error at src/vm/moar/Perl6/Ops.nqp:639 in sub a at /tmp/H579fGZYP9:1 in block…» | ||
lizmat | m: sub a returns Bool|Failure { fail }; a | 04:22 | |
camelia | rakudo-moar 1372f7: OUTPUT«5===SORRY!5=== Error while compiling /tmp/6FKCwO2RKZMissing blockat /tmp/6FKCwO2RKZ:1------> 3sub a returns Bool7⏏5|Failure { fail }; a expecting any of: new name to be defined» | ||
zostay | np ^_^ | 04:23 | |
04:28
laouji joined
04:39
kurahaupo1 is now known as kurahaupo,
jack_rabbit joined
04:43
TimToady left
04:45
TimToady joined
04:46
quester joined
04:50
dagurval joined
04:56
diana_olhovik_ joined
05:34
diana_olhovik_ left
05:38
jack_rabbit left
05:42
vendethiel left
05:44
lizmat left
05:46
Psyche^ joined
05:48
xinming left
05:50
Patterner left
06:00
xinming joined
06:05
llfourn left
06:08
vendethiel joined
06:10
diana_olhovik joined
06:15
kurahaupo left
06:18
quester left
06:21
FROGGS joined
06:25
Sqirrel left,
Sqirrel joined
06:26
tinyblak left,
tinyblak joined
06:27
yeahnoob joined,
RabidGravy joined
06:31
tinyblak left
06:33
rindolf joined
06:34
lizmat joined
06:35
domidumont joined
06:37
vendethiel left,
domidumont left
06:38
domidumont joined,
bjz joined
06:39
bjz left
|
|||
lizmat | m: say say 2**4294967296 # seems we got a 64bit int power problem | 06:39 | |
camelia | rakudo-moar 1372f7: OUTPUT«0True» | ||
06:40
vendethiel joined
|
|||
lizmat | m: say 2**4294967295 # this will probably timeout | 06:40 | |
camelia | rakudo-moar 1372f7: OUTPUT«(timeout)» | ||
06:42
bbkr_ joined,
bbkr left
|
|||
lizmat | m: use nqp; say nqp::pow_I(2,4294967296,Num,Int) # basically wrong at NQP level | 06:44 | |
camelia | rakudo-moar 1372f7: OUTPUT«0» | ||
lizmat | m: use nqp; say nqp::pow_I(2,4294967295,Num,Int) # basically wrong at NQP level | ||
camelia | rakudo-moar 1372f7: OUTPUT«(timeout)» | ||
06:45
tinyblak joined
06:50
yeahnoob left
06:57
bjz joined,
gfldex joined
07:05
_mg_ joined
07:10
bjz left
07:17
cognominal joined
07:25
ely-se joined
|
|||
ely-se | hi | 07:25 | |
07:26
FROGGS left
|
|||
ely-se | I had this idea of adding "alias Larry=clang" to my zshrc so I could say "Larry -Wall" | 07:29 | |
probably a bad and old joke :( | |||
07:31
ely-se left,
llfourn joined
07:33
Ven joined
07:36
ely-se joined
07:41
g4 joined,
g4 left,
g4 joined
07:46
SevenWolf left
07:53
ely-se left,
[Sno] left,
[Sno] joined
07:55
Ven left,
Ven_ joined
|
|||
Mouq | m: say sub (@a){my $i = 0; do while $i <= @a { say ($++ %% 2) ?? $i++ !! @a[$i - 1, $i - 1] }}(my @ = "a".."e" )[^10].perl # not sure what's wrong here | 07:56 | |
camelia | rakudo-moar 1372f7: OUTPUT«0a a1b b2c c3d d4e e5(Bool::False,)» | ||
Mouq | (while always seems to return (Bool::False,) | ||
(also I know that's not a perfect solution, but it's close | 07:57 | ||
) | |||
Oh hey | 08:04 | ||
RabidGravy | is there anyway I can tell whether the perl is 32 or 64 bit? | ||
nothing stands out in $*VM | |||
Mouq | m: gist.github.com/Mouq/50660c17d7cd617f8537 | ||
camelia | rakudo-moar 1372f7: OUTPUT«((Bool::True, 0), (Bool::False, 0), (Bool::True, 1), (Bool::False, 1), (Bool::True, 2), (Bool::False, 2), (Bool::True, 3), (Bool::False, 3), (Bool::True, 4), (Bool::False, 4))(0, ("a", "a"), 1, ("b", "b"), 2, ("c", "c"), 3, ("d", "d"), 4, ("e", "e"))» | ||
Mouq | Err | ||
08:04
amurf left
|
|||
RabidGravy | cool | 08:05 | |
Mouq | m: gist.github.com/Mouq/50660c17d7cd617f8537 | ||
camelia | rakudo-moar 1372f7: OUTPUT«(0, ("a", "a"), 1, ("b", "b"), 2, ("c", "c"), 3, ("d", "d"), 4, ("e", "e"))» | ||
Mouq | Yayy | ||
08:05
abraxxa joined
|
|||
Mouq | RabidGravy: Wish I could answer your question, but I have no idea | 08:08 | |
[ptc] | tadzik: ping | 08:11 | |
08:11
spider-mario left
08:12
darutoko joined
|
|||
pmichaud | Mouq++ # that's helpful, thanks | 08:13 | |
Mouq | Cleaned up the gist a little as well, but no p | 08:14 | |
(It's lazy! :D) | |||
pmichaud | that helps me formulate my next Q. :) | 08:15 | |
Mouq | Bring it on ;) | ||
jnthn | morning, #perl6 | ||
pmichaud | jnthn: o/ | ||
Mouq | o/ | ||
pmichaud | jnthn: the Perl 6 tutorial was a huge hit tonight at yapc::na | ||
nwc10 | we're hoping for a neverending September, but in a good way? :-) | 08:16 | |
pmichaud | definitely over 30 attendees, most of whom stayed 3.5 hours or more | ||
Ven_ | wow :-) | 08:17 | |
pmichaud | without a break. | ||
jnthn | pmichaud: Wow o.O | 08:18 | |
pmichaud: Did you fix some of the bugs? ;) | |||
pmichaud | jnthn: some, but missed some | ||
08:18
bjz joined
|
|||
pmichaud | and we ran into some other oddities that we'll likely investigate at hackathon on thu | 08:18 | |
jnthn | OK; Swiss Perl Workshop are interested in having it, so please share your fixes ;) | ||
pmichaud | Will do. | ||
jnthn | (At a point that's convenient.) | ||
pmichaud | I'll send back the src file | ||
jnthn | Cool, thanks. | 08:19 | |
pmichaud | I also have a few suggestions for content reordering, etc. | ||
jnthn | OK. I was fairly careful to avoid forward dependencies in the material, but everything is vulnerable to forward dependencies in curiosity... :-) | ||
Would be good to make it less so, though. :) | 08:20 | ||
pmichaud | the use of the whatever-star in the given/when statement was a major one | ||
since it's not introduced prior to that | |||
jnthn | Hm | 08:21 | |
pmichaud | getting from given topicalizer to whatever star seemed to be way too big a leap | ||
most people leapt to "oh, * is an alias for $_" | 08:22 | ||
anyway, I'll come up with a list of places we got hung up | |||
jnthn | Hm, I don't remember that being problematic, though I suspect I did a "lies to children" :) | 08:23 | |
But yeah, if people actually want to dig into *why* it works, it's a big leap :) | |||
pmichaud | yeah, we had a lot of *why* | ||
and "how" | |||
I quickly did a whatever segue at that point, though, and people were very pleased to learn about whatever. | 08:24 | ||
jnthn | *nod* | ||
pmichaud | it might help to cover @a[*-1] earlier in subscripting | ||
jnthn | I guess you could re-write it as $_ in the given/when example | ||
pmichaud | that at least introduces whatever, without the obvious $_ reference | ||
then when we get to * < 10 they have the notion of "oh, whatever" | |||
er * < 0... whatever. | 08:25 | ||
jnthn | That could also work, yes. | ||
If you'll also be at Swiss Perl Workshop I'm also open to co-hosting it. :-) | 08:26 | ||
pmichaud | I'm still uncertain about swiss pw, but the odds are going up drastically with each passing day. :) | 08:27 | |
okay, time for my next GLR-related coding challenge.... | |||
08:27
abraxxa left
|
|||
pmichaud | Q3: Each of the standard looping constructs (for, while, until) has the ability to create a list. At present I only know how to get them to return a list with the same number or values as the number of iterations. Is there a way to get a loop that produces more than one value for some or all of its iterations? | 08:27 | |
diegok wants 3.5h of Perl 6 tutorial at YAPC::EU | |||
pmichaud | one of the things that worked really well here is that the tutorial was scheduled as an evening activity... | 08:28 | |
i.e., it was at the same time as YAPC::NA's traditional "game night" | |||
08:28
abraxxa joined
|
|||
pmichaud | so, it didn't clobber any other talks or events, it could be open-ended as to ending time | 08:28 | |
i.e., we ran it more like an extended BoF than a tutorial or scheduled talk | 08:29 | ||
08:29
tinyblak left
|
|||
jnthn | diegok: Should be do-able | 08:29 | |
[Tux] | RT#124191 is fixed \o/ | 08:30 | |
synbot6 | Link: rt.perl.org/rt3/Public/Bug/Display...?id=124191 | ||
jnthn | pmichaud: "redo"? | ||
diegok | jnthn: good!, should I start asking for space? | ||
jnthn | diegok: You're one of the organizers, iiuc? | ||
08:30
FROGGS joined
|
|||
diegok | jnthn: yup, I'm helping the Granada folks | 08:30 | |
pmichaud | jnthn: well, I'm really asking if there's a way to get more than one value out of each block invocation | 08:31 | |
and have them concatenate into a list | |||
jnthn | diegok: Cool. Anyway, I'm fine with doing it. | ||
pmichaud: Not as far as I'm aware; all kinds of "multiple return vlaue" in Perl 6 really mean "return a Parcel" | |||
pmichaud: And we decided we want to do away with flattening of those in most contexts | 08:32 | ||
pmichaud: So it'd take an explicit .flat somewhere on the resulting list | |||
pmichaud | right. and I'm thinking we need _something_ that allows us to iteratively build a list but where some iterations add more elements to the list than one | ||
jnthn | gather/take... :) | ||
pmichaud | using an explicit .flat on the resulting list over flattens | ||
diegok | jnthn: ok, I'll send it to the orgas list and I'll come back to you!, thank you!. | 08:33 | |
jnthn | pmichaud: True. and I guess you want a more efficient thing than gather/take | ||
pmichaud: Trouble is we want to avoid introducing checks all over the place | |||
pmichaud | We need either a more efficient thing than gather/take, or we need a far faster gather/take. | 08:34 | |
Mouq | m: my $s = 0; say do for ^10 -> $i { LEAVE { say "redo" and redo if $s++ < $i+2 }; $i } # alas | ||
camelia | rakudo-moar 1372f7: OUTPUT«redoredo0 1 2 3 4 5 6 7 8 9» | ||
skids | pmichaud: maybe something with catching/resuming an exception that occurs at just the right time? | ||
pmichaud | skids: catching/resuming exception is basically gather-take kind of slowness | ||
jnthn | skids: The catch/resume of the exception is, at least once we support batching, the main slow in gather/take. | ||
Today it shares that cost with "take a continuation" | |||
But if we get to batch we can avoid that. | |||
But there'll still be the catch/resume cost. We can cheapen that but it's never going to be free. | 08:35 | ||
pmichaud | essentially I feel like we're missing a list primitive | ||
skids | Yeah I wasn't suggesting it as a "way to" but the only way I could see something like that happenning. | ||
(with existing constructs) | |||
jnthn | pmichaud: I guess "how do we write kv" is an immediate motivator? | 08:36 | |
pmichaud | jnthn: you'd be right. | ||
[Tux] | if I re-enable the test I excluded for RT#124191, I now get a core dump after 11834 tests :( | ||
synbot6 | Link: rt.perl.org/rt3/Public/Bug/Display...?id=124191 | ||
[Tux] | /pro/3gl/CPAN/rakudobrew/bin/perl6: line 2: 6958 Segmentation fault PATH=/pro/3gl/CPAN/rakudobrew/moar-nom/install/bin:$PATH perl6 "$@" | 08:37 | |
08:37
Ven_ left
|
|||
pmichaud | basically, is .map(&block) constrained to producing lists that have the same number of elements as the number of invocations of &block ? | 08:38 | |
Mouq | pmichaud: No, it can have less :P | 08:40 | |
skids | Another way to look at it is is there a way to invoke block more than once per element (and then the block could alternate what it actually does) | ||
FROGGS | m: say (^10).map({$_ == 3 ?? Empty !! $_}) # not constraint | ||
camelia | rakudo-moar 1372f7: OUTPUT«0 1 2 4 5 6 7 8 9» | 08:41 | |
pmichaud | having the block alternate what it does is definitely not the approach I'm looking for | ||
FROGGS | but it cannot have more in the way it is implemented right now | ||
08:41
tinyblak joined
|
|||
pmichaud | I'm more interested in the case of more-than-one-element per iteration | 08:41 | |
I know about the zero case | |||
skids | (or invoke multiple blocks) | ||
FROGGS | what if 'return 1, 2' would return two things, and 'return (1, 2)' would return one? | 08:42 | |
I mean, would that bite us somewhere? | |||
m: say (^10).map({$_ == 3 ?? 1, 2 !! $_}) | 08:43 | ||
camelia | rakudo-moar 1372f7: OUTPUT«5===SORRY!5=== Error while compiling /tmp/xxFam3ekApPrecedence of , is too loose to use inside ?? !!; please parenthesizeat /tmp/xxFam3ekAp:1------> 3say (^10).map({$_ == 3 ?? 17⏏5, 2 !! $_}) expecting any of: infix …» | ||
Mouq | m: say sub mapcombin(@a, $f, $g) { (^(2*@a)).map({$_ %% 2 , ($_/2).floor}).map(->[$s,$i]{$s ?? @a[$i] ~~ $f !! @a[$i] ~~ $g})}(^10, *+1, */2) | ||
camelia | rakudo-moar 1372f7: OUTPUT«1 0 2 0.5 3 1 4 1.5 5 2 6 2.5 7 3 8 3.5 9 4 10 4.5» | ||
Mouq | m: say sub mapcombin(@a, $f, $g) { (^(2*@a)).map({$_ %% 2 , ($_/2).floor}).map(->[$s,$i]{$s ?? @a[$i] ~~ $f !! @a[$i] ~~ $g})}(^10, *+1, */2).perl | ||
camelia | rakudo-moar 1372f7: OUTPUT«(1, 0.0, 2, 0.5, 3, 1.0, 4, 1.5, 5, 2.0, 6, 2.5, 7, 3.0, 8, 3.5, 9, 4.0, 10, 4.5)» | ||
FROGGS | m: say (^10).map({$_ == 3 ?? leave 1, 2 !! $_}) # would that be the way to produce more output values? | 08:44 | |
camelia | rakudo-moar 1372f7: OUTPUT«5===SORRY!5=== Error while compiling /tmp/0Um8Fy_r3mUndeclared routine: leave used at line 1» | ||
jnthn | FROGGS: Trouble is that you'd then have to say "well, what is the type that is returned", and you'd get into "is a block-final (1, 2) different from 1, 2" and so on...which wil be...tricky | ||
pmichaud | FROGGS: we don't have any notion of "return two things" in Perl 6. | ||
FROGGS | jnthn: we already have List, Array and Parcel... just make one of them flatten :P | 08:45 | |
pmichaud | I would not be opposed to having a list-y type that always immediately flattens. | 08:46 | |
FROGGS | jnthn: though, in '@a = 1, 2' the LHS decides about the flattening, right? | ||
jnthn | FROGGS: yes | ||
FROGGS | :/ | ||
jnthn | pmichaud: We were trying to get rid of List/Parcel, but type would be the right slot to hang things off... | ||
pmichaud | At the moment I'm still expecting Parcel to go away. &infix:<,> becomes a List constructor | 08:47 | |
but if we had a type that immediately flattened when placed in a list, that would be... useful. | |||
FROGGS | (1, 2) == List which does not flatten on its own; 1, 2 == List that will | 08:48 | |
pmichaud | FROGGS: parens are grouping only | ||
FROGGS | would be ncie if we had a way oto see the results of these thoughts within minutes :o) | ||
pmichaud | if I have a type that immediately flattens, then I could have something like { ... ; Flat.new($a, @b) } | 08:49 | |
FROGGS | pmichaud: yes, but somehow two literal lists have to produce two different types | ||
:{ } creates object hashes... maybe |( ) creates flattened lists? | 08:50 | ||
pmichaud | then (1..10).map( { Flat.new($a, @b) } would be able to give me the ($a, @b, $a, @b, $a, @b, ...) sort of List I'm looking for | ||
FROGGS | though, the syntax bit might not be so important right now | ||
08:50
bin_005 joined
|
|||
pmichaud | FROGGS: the syntax is actually hugely important to me right now | 08:50 | |
FROGGS | ohh, okay | ||
pmichaud | part of my struggle is that p6 has never had a feature to do this sort of thing, and I think we need one. | ||
FROGGS | I tend to think about syntax just being sugar for the semantics | 08:51 | |
pmichaud | every time I start to work on fixing Lists I run into "we don't have a way to do this seemingly common thing" | ||
08:51
laouji left
|
|||
pmichaud | (this problem predates GLR) | 08:51 | |
[ptc] | .tell tadzik could you review github.com/tadzik/rakudobrew/pull/42 when you get time please? It allows matching Rakudo/panda versions to be installed on Travis | ||
yoleaux | [ptc]: I'll pass your message to tadzik. | ||
skids | Extend "proceed" to take a value, maybe? | 08:52 | |
jnthn | |(...) already has a meaning, so we can't really steal that | 08:53 | |
s/so/and/ | |||
jnthn agrees with Pm's analysis that we could do with this | 08:54 | ||
08:54
zengargoyle left
|
|||
FROGGS | jnthn: sad, it would be the obvious syntax :lo) | 08:55 | |
:o)* | |||
jnthn | I don't have a good syntax suggestion short of trying to pick a word like interpolate(1, 2) | ||
pmichaud | many of the problems we've had with Z and xx and Z, and ... come down to "we don't have a way to concatenate lists. | ||
08:56
zengargoyle joined
08:57
yeahnoob joined
|
|||
pmichaud | at this point I'd even consider something like a infix:<~,> or infix:<,~> operator :-) | 08:58 | |
08:59
espadrine joined
|
|||
[ptc] | hoelzro, ugexe: I've added docs about building Perl 6 on Travis: github.com/paultcochrane/docs-trav...9104b0dce0 | 08:59 | |
08:59
laouji joined
09:00
skids left
|
|||
moritz | pmichaud: fwiw I've also suggested to have a list concatenation operator | 09:00 | |
[ptc] | hoelzro, ugexe: could you please review before I submit the pull request? Thanks in advance! | ||
09:00
xinming left
|
|||
pmichaud | alternatively, I'd be happy with the notion that | 09:01 | |
09:01
xinming joined
|
|||
pmichaud | (1..5).map( { 1,2 } ) produces (1, 2, 1, 2, 1, 2, 1, 2, 1, 2) | 09:01 | |
and if you want the groups, you do | |||
jnthn | [Tux]: Where do I find the code to reproduce that? | ||
FROGGS | what about (,) ? | 09:02 | |
1, 2 (,) 3, 4 | |||
like the set ops | |||
pmichaud | (1..5).map( { ((1,2),) } producing ((1,2), (1,2), (1,2), (1,2), (1,2)) | ||
jnthn | pmichaud: What type will 1,2 produce? | ||
pmichaud | jnthn: List. | ||
(1,2) produces a List | 09:03 | ||
FROGGS | the flattenable List? | ||
pmichaud | ((1,2),) produces a List containing a single List element | ||
jnthn | pmichaud: (1..5).map({ my @ = 1, 2 }) # result? | ||
pmichaud | jnthn: (1, 2, 1, 2, 1, 2, 1, 2, 1, 2) | ||
FROGGS | aye, that's what the @-sigil should do | ||
that's why we have sigils after all, no? | 09:04 | ||
pmichaud | I'm just speculatin' here to try to move towards an answer. | ||
jnthn | But I thought a lot of this is what we were getting rid of in the GLR... | ||
FROGGS | ohh | ||
09:04
laouji left
|
|||
pmichaud | jnthn: getting rid of what, exactly ? | 09:04 | |
jnthn | pmichaud: A lot of the places that things magically flatten. | 09:05 | |
So there's a small number of them (slurpies, array assignment, [...]) to remember. | |||
pmichaud | this flattening isn't "magical", though. | ||
FROGGS | jnthn: this would return five Arrays, no? (1..5).map({ my @ = 1, 2 }) | ||
so the result would be ([1,2], [1,2], [1,2], [1,2], [1,2]) | |||
pmichaud | or, it's "flattening" only because we don't have a way of saying "a map iteration that adds multiple elements to the resulting List" | 09:06 | |
jnthn | FROGGS: No, mor elike ((1, 2), (1, 2), ...) | ||
FROGGS | err, [1, 2]<> | ||
yeah | |||
jnthn | Or what you said :) | ||
pmichaud | I publicly said tonight that I totally hate the [...]<> notation. :) | ||
jnthn | pmichaud: I don't think you're alone in that :P | 09:07 | |
pmichaud | To me it's a huge design smell. | ||
jnthn | *nod* | ||
moritz | "box with a beak" | ||
FROGGS | *nod* | ||
pmichaud | I'm wondering if [...] and {...} should produce flattenable array/hash | ||
the fact that they're itemized is a little bit of a holdover from p5 | 09:08 | ||
and I'm not sure that meaning has a lot of purpose in a post-GLR world. | |||
moritz | I'd like to be able to create nested arrays with my @a = [1, 2], [3, 4] | ||
FROGGS | or with my @a = (1, 2), (3, 4) | ||
pmichaud | moritz: would it be.... what FROGGS said | ||
moritz | what would ( , ) construct? | 09:09 | |
jnthn | That...surprises me. I'd thought Array assignment would flatten non-itemized things... | ||
moritz | a List? Array? Parcel? | ||
pmichaud | I asked TimToady yesterday what flattens, and he said "only slurpies and .flat" | 09:10 | |
(or 'flat()') | |||
he didn't mention list assignment as flattening. Perhaps that was an oversight. | |||
jnthn | Perhaps. | ||
pmichaud | moritz: there's no ( , ) | ||
jnthn | I'd had his list plus list assignment and [...] | ||
moritz | because if (1, 2) doesn't construct an Array, @a = (1, 2), (3, 4); @a[0][0] = 5 will fail | ||
jnthn | (the inside of [...]) | ||
pmichaud | moritz: I only see &infix:<,> syntactically | 09:11 | |
moritz: thinking, but you may be correct. | |||
moritz | pmichaud: ok, what would my @a = (1, 2), (3, 4); say @a[0].^name output? | ||
pmichaud | Still, my @a = [1,2], [3,4]; can work to construct arrays even if [...] doesn't itemize. | ||
moritz | if that works, +1 | 09:12 | |
pmichaud | basically @a gets two values, each of which are Arrays | ||
09:12
bbkr joined
|
|||
pmichaud | itemization isn't needed for that | 09:12 | |
because the act of putting the array into @a[0] and @a[1] produces itemization | |||
(since @a[0] and @a[1] are scalar containers) | 09:13 | ||
then @a.perl could just be "[ ... ]" without the ugly <> at the edn. | |||
09:13
laouji joined
|
|||
pmichaud | *end | 09:13 | |
jnthn | pmichaud: That could well work | 09:14 | |
09:14
bbkr_ left
|
|||
pmichaud | since flattening is no longer default-ish, I suspect we no longer need circumfix [ ] and { } to itemize. | 09:14 | |
jnthn | means flat [1,2,3], [4,5,6] would have to become flat $[1,2,3], $[4,5,6] ? | ||
pmichaud | jnthn: yes. | ||
jnthn | OK. | ||
pmichaud | although | 09:15 | |
flat [[1,2,3], [4,5,6]] wouldn't :-) | |||
indeed, one could expensively itemize anything by just putting it in square brackets. :) | 09:16 | ||
(and then I guess index to get it back out... but you get the point) | |||
I think I'd be _really_ happy if [1,2,3] was exactly the same as Array.new(1,2,3) and my @ = 1,2,3 | 09:17 | ||
and same for the hash constructor | |||
jnthn | It's certainly attractive. :-) | ||
09:17
laouji left
|
|||
pmichaud | I can't think of a post-GLR instance where we need to have [1,2,3] be the same as Array.new(1.2.3).item | 09:18 | |
nwc10 | and also "Quicker, easier, more seductive"? | ||
(ie, are there downsides of this?) | |||
pmichaud | nwc10: it makes things simpler and much faster on the implementation side. | ||
nwc10 | which is a down side, if the goal is to torture implementors | 09:19 | |
are there down sides for users? :-) | |||
pmichaud | nwc10: I'm trying to think of some... but I've not commonly used [...] or { ... } in my p6 programs so I can't be sure. | ||
surprisingly, having this behavior also means that | 09:20 | ||
my @a = [1,2,3] # works | |||
my @a = [1,2,3] # @a has three elements | 09:21 | ||
my @a = [1,2,3],[4,5,6] # @a has two Array elements | |||
my @a = [1,2,3], # @a has one Array element | |||
similarly, my %h = { foo => 'bar' }; # hash assignment | 09:22 | ||
moritz | my @a = [1,2,3] vs my @a = [1,2,3],[4,5,6] looks like a design smell to me | 09:23 | |
(one of them flattening, the other not) | |||
pmichaud | it has nothing to do with flattening | ||
moritz | whatever it has to do with, I'd to be the one to document that | ||
pmichaud | it has to do with the first being an Array, and the second being a List of Array | ||
it's the same principle we have now, where (1) is an Int but (1,) is a Parcel. | 09:24 | ||
moritz | "to write nested data structures, you can write things like my @a = [1,2,3],[4,5,6]; beware that it only works if you at least two pairs of braces" | ||
pmichaud | it's the comma that does it | ||
not the pairs of braces. | |||
my @a = [1,2,3],4 # @a has two elements | 09:25 | ||
moritz | still a design smell | ||
pmichaud | we have that design smell no matter what | ||
arnsholt | Python does more or less exactly the same thing, FWIW | ||
pmichaud | my @a = (1,2,3) # how many elements does @a get? | ||
arnsholt | "1," is a single-element tuple, "1" is just the number | ||
moritz | (not saying that the Parcel case right now is any better, but at least the parcel gets flattened away in many cases) | ||
pmichaud | does it? | 09:26 | |
not any more. We're getting rid of flattening. | |||
moritz | assignment to array variables still flattens it away | ||
m: my @a = (1, ); say @a[0].^name | |||
camelia | rakudo-moar 1372f7: OUTPUT«Int» | ||
pmichaud | okay, TimToady didn't mention that (as I noted, perhaps an oversight) | ||
m: my @a = ((1,),1); say @a[0].WHAT | 09:27 | ||
camelia | rakudo-moar 1372f7: OUTPUT«(Int)» | ||
pmichaud | m: say ((1,),1).[0].WHAT | ||
camelia | rakudo-moar 1372f7: OUTPUT«(Parcel)» | ||
pmichaud | m: say ((1,2,3),4).elems | 09:28 | |
camelia | rakudo-moar 1372f7: OUTPUT«2» | ||
09:29
laouji joined
|
|||
pmichaud | m: say (my @ = ((1,2,3),4)).elems | 09:29 | |
camelia | rakudo-moar 1372f7: OUTPUT«4» | ||
pmichaud | the whole bit of list assignment flattens but nowhere else does feels more smelly to me | ||
and more smelly still if array assignment flattens and list assignment doesn't | 09:30 | ||
09:30
laouji left
|
|||
pmichaud | m: say [(1,2),3].elems; say ((1,2),3).elems | 09:31 | |
camelia | rakudo-moar 1372f7: OUTPUT«32» | ||
jnthn | I'd hope [...] and my @ = ... would have the same flattening semantics. | 09:32 | |
(for the ...) | |||
pmichaud | exactly | ||
and I'm thinking I want "no flattening" | 09:33 | ||
but even here, what are the flattening semantics of @a = ... versus (@a, @b) = ... ? | |||
or ($a, $b) = ... ? | |||
09:34
laouji joined
|
|||
pmichaud | I mean, do we ahve the case that @a = ... flattens the rhs while ($a, $b) = ... doesn't? | 09:35 | |
if we say that both flatten, then list assignment flattens but constructing a list doesn't ? | |||
09:35
laouji left
|
|||
moritz is at the point where he wants to get rid of all implict flattening, and have a separate list concatenation operator for when you need flatten | 09:36 | ||
pmichaud | at the moment I really like the notion that [...] doesn't itemize. | 09:37 | |
I can't see where it poses a particular problem. | |||
moritz | and maybe a flattening meta operator, so that you can say @lista FZ @listb instead of flat(@lista Z @listb) | ||
09:38
laouji joined
|
|||
Mouq | What's the biggest difference between […] and (…) then? Mutability? | 09:38 | |
pmichaud | one constructs an Array | ||
OTOH!!! | |||
Mouq | Right, my question was more like, what's the difference between Array and List | 09:39 | |
or differences | |||
pmichaud | Array elements are all Scalars | ||
moritz | so you can always assign to Array elements | ||
pmichaud | i.e., everything put into an array is itemized | ||
moritz | m: my @a = List.new(1, 2, 3); @a[0] = 5; | ||
camelia | ( no output ) | ||
moritz | m: my @a := List.new(1, 2, 3); @a[0] = 5; | ||
camelia | rakudo-moar 1372f7: OUTPUT«Cannot modify an immutable Int in block <unit> at /tmp/vZFZm2V3tn:1» | ||
Mouq | heh | ||
pmichaud | OTOH!!! (again).... if we don't flatten list/array assignment, then my @a = 1..10; doesn't work. | ||
moritz | m: my @a := Array.new(1, 2, 3); @a[0] = 5; say @a | ||
camelia | rakudo-moar 1372f7: OUTPUT«5 2 3» | ||
Mouq | k, thanks :) | 09:40 | |
09:40
yeahnoob left
|
|||
pmichaud | still, I think that flattening is separate from [...] being itemized. | 09:41 | |
moritz | then what's the point of itemizing at all? | ||
FROGGS | can't we allow this? my @a = |1..10; | 09:42 | |
pmichaud | sorry, I should say "flattening of list assignment" is separate from "[...] being itemized" | ||
Mouq | FROGGS: Precedence | ||
09:42
laouji left
|
|||
pmichaud | FROGGS: we can allow that, but it's got the totally wrong default. | 09:42 | |
my @a = 1..10; ought to dwim | 09:43 | ||
09:43
brrt joined
|
|||
FROGGS | k | 09:43 | |
FROGGS agrees | |||
09:44
zakharyas joined
|
|||
pmichaud | moritz: note that when needed, we can still itemize with prefix-$ | 09:44 | |
i.e., if we needed a non-flattening array, then $[...] is always at hand. | |||
and that seems much better to me than having [...]<> which means "deitemize the itemized array" | |||
also I'd like to note that "flattening" is a little overloaded here... because traditionally we've used "flattening" to do nesting, when in most cases we just need/want one level of flattening. | 09:45 | ||
09:45
laouji joined
|
|||
moritz | FWIW I'd be fine with 'my @a = 1..10' not DWIMing, if that's the price we pay for a very simple model where it's trivial to explain how to flatten and how not, and that works 100% of all times | 09:46 | |
09:46
laouji left,
laouji joined
|
|||
pmichaud | i.e., sometimes we want to be able to "flatten" (1, (2, 3..7)) to become (1, 2, 3..7) and not (1, 2, 3, 4, 5, 6 7) | 09:48 | |
09:48
FROGGS left
|
|||
pmichaud | as an example of where we already have the "flattening" smell now: | 09:49 | |
m: for (1,2,3) { .say } | |||
camelia | rakudo-moar 1372f7: OUTPUT«123» | ||
pmichaud | m: for (1,2,3), { .say } | ||
camelia | rakudo-moar 1372f7: OUTPUT«5===SORRY!5===Expression needs parens to avoid gobbling blockat /tmp/yqAtdgcsfh:1------> 3for (1,2,3), { .say }7⏏5<EOL>Missing block (apparently taken by expression)at /tmp/yqAtdgcsfh:1------> 3for (1,2,3), { .say }7⏏5<EOL>…» | ||
pmichaud | m: for ((1,2,3),) { .say } | ||
camelia | rakudo-moar 1372f7: OUTPUT«1 2 3» | ||
pmichaud | m: for (1,2,3),(4,5,6) { .say } | ||
camelia | rakudo-moar 1372f7: OUTPUT«1 2 34 5 6» | ||
pmichaud | afaic, once the decision was made to not flatten parcels by default, that completely changes the implications for itemization. | 09:51 | |
El_Che | is there a test smoke like tooling/infra for perl 6 implementations (not modules). I only found perl6advent.wordpress.com/2013/12/...kudo-star/ and github.com/coke/perl6-roast-data. I am not sure how to set up a useful smoking setup similar like the ones I run for perl5 (or if it's needed/useful) | 09:52 | |
pmichaud | anyway, it's almost 04h00 here and I had better get some sleep | ||
jnthn | :) | 09:53 | |
Sleep well, pmichaud++ | |||
09:53
amurf joined
|
|||
pmichaud | before I go, I think I should summarize a bit of what I'm toying with / looking for | 09:57 | |
I'd like to separate our notion of "flattening" into "shallow flat" and "deep flat" | |||
09:57
amurf left
|
|||
pmichaud | so, with my @odd = 1, 3, 5; my @even = 2, 4, 6; | 09:58 | |
a shallow flat of (1, (2, (@odd, @even))) would result in (1, 2, ((1, 3, 5), (2, 4, 6))) | 09:59 | ||
while a deep flat of (1, (2, (@odd, @even))) would result in (1, 2, 1, 3, 5, 2, 4, 6) | |||
i.e., that most of the places we need automatic flattening really only need to be doing it at one level deep | 10:00 | ||
10:00
coffee` left
|
|||
pmichaud | (slurpy params perhaps being the exception to that.) | 10:00 | |
Mouq | my @a = 1...10 would still DWIM, yes? | 10:01 | |
pmichaud | yes | ||
because a shallow flat or deep flat of a range expands it | 10:02 | ||
10:03
coffee` joined
|
|||
pmichaud | anyway, that's what I'm toying with and the sort of answer that keeps popping up. | 10:03 | |
but the whole notion of itemizing, scalar containers, and even LoL came from a need to suppress the automatic flattening behavior of Parcels. | 10:04 | ||
Now that Parcels no longer flatten by default, many of the consequences that led to itemization and LoL no longer apply. | |||
more to the point, now that infix:<,> will be creating a List instead of a Parcel, many of the consequences.... | 10:05 | ||
anyway, sleep time for sure now | |||
bbl | |||
Mouq | sleep well pmichaud++ | 10:06 | |
10:07
laouji left,
brrt left,
coffee` left
|
|||
Mouq | m: say (1, 2, ((1, 3, 5), (2, 4, 6))).deepmap({$_}).perl | 10:08 | |
camelia | rakudo-moar 1372f7: OUTPUT«(1, 2, 1, 3, 5, 2, 4, 6)» | ||
10:09
laouji joined
|
|||
|Tux| | jnthn, github.com/Tux/Text-CSV_XS - edit t/55_combi.t and remove the '#' in line 46 | 10:10 | |
that '#' was put there when 124191 came into focus | |||
github.com/Tux/CSV of course. the other is perl5 | 10:11 | ||
Mouq | A thought, if flattening is split: flat could just be shallow flat and deep flat could be the default case of a bikeshedded version of deepmap | ||
10:11
coffee` joined,
Ven joined
|
|||
|Tux| | I'll try to create a shortened version | 10:12 | |
Mouq | m: say (1, 2, ((1, 3, 5), $(2, 4, 6))).deepmap({$_}).perl | ||
camelia | rakudo-moar 1372f7: OUTPUT«(1, 2, 1, 3, 5, $(2, 4, 6))» | ||
|Tux| | 124191 is definitely fixed | 10:17 | |
sergot | wut, what is deepmap? | 10:18 | |
moritz | it descends into arrays/hashes | ||
m: say (1, 2, ((1, 3, 5), $(2, 4, 6))).deepmap(* * 3).perl | 10:20 | ||
camelia | rakudo-moar 1372f7: OUTPUT«(3, 6, 3, 9, 15, 9)» | ||
jnthn | |Tux|: Good; it took some doing. :) | 10:21 | |
jnthn is currently working on RT #124318, which is also mysterious | |||
Mouq | I'm a little surprised it doesn't retain structure, honestly. I think there's a function that does | 10:22 | |
|Tux| tries to make reproducing the segfault a bit smaller | |||
Mouq | m: say ((1, 2, ((1, 3, 5), $(2, 4, 6))) »*» 3).perl | ||
camelia | rakudo-moar 1372f7: OUTPUT«(3, 6, ((3, 9, 15), $(6, 12, 18)))» | ||
10:23
araujo__ left,
araujo joined,
araujo left,
araujo joined
10:27
_mg_ left
10:35
bowtie joined,
telex left,
bowtie is now known as Guest85966
10:36
telex joined
|
|||
|Tux| | jnthn, gist.github.com/Tux/08b2083d9eaff31d8bc6 | 10:38 | |
that makes the segfault go away. It must be a hint :) | |||
FWIW it doesn't matter if the match is correct or not | 10:41 | ||
10:41
dayangkun left
10:43
bin_005 left
|
|||
dalek | p: bf329da | jnthn++ | tools/build/MOAR_REVISION: Bump MOAR_REVISION for new frame return API. |
10:46 | |
10:46
AlexDaniel joined
|
|||
dalek | kudo/nom: 24c39ea | jnthn++ | / (2 files): Don't run exit handlers on fake frames. When we are seeing if a multi can pass the bind check, we create a frame to hold lexicals used in the binding checking. This frame is never actually entered and not fully set up, however. If the block in question had exit handlers, we would end up looking at uninitialized memory in trying to run them, which led to all kinds of oddness when a frame with exit handlers (LEAVE, temp, etc.) had a signature with where constraints. Fixes RT #124318. |
10:50 | |
synbot6 | Link: rt.perl.org/rt3/Public/Bug/Display...?id=124318 | ||
jnthn | Turns out it wasn't an optimization bug at all like the ticket suggested, and Valgrind whined if you got rid of the loop | 10:51 | |
*even if | |||
arnsholt | jnthn: A QAST/HLL::Grammar question: Is there a mechanism for an infix:sym<foo> that wants to create a QAST::Op.new(:op<not>, QAST::Op.new(:op<foo>, $lhs, $rhs))? | 10:54 | |
If the infix makes a negated foo as its AST, the arguments end up as arguments to the not, not the foo =( | 10:55 | ||
jnthn | arnsholt: Not really; we tend to handle such things in Rakudo using a custom EXPR | ||
arnsholt: EXPR action method, I mean | |||
10:56
tinyblak left
|
|||
arnsholt | Yeah, that's what I thought. Cheers! | 10:56 | |
dalek | ast: aceeb7c | jnthn++ | integration/weird-errors.t: Untodo test for RT #123686 & RT #124318. |
10:57 | |
synbot6 | Link: rt.perl.org/rt3/Public/Bug/Display...?id=123686 | ||
10:59
llfourn left
11:01
llfourn joined
|
|||
|Tux| | jnthn, no more segfault, but the tests start failing halfway when using ~~ | 11:10 | |
11:11
Sqirrel left,
zakharyas left
|
|||
|Tux| | is (%state{1001}, "INI - separator is equal to quote- or escape sequence", "Illegal combo 1001"); | 11:15 | |
%state{1001} ~~ m{"separator is equal to"} or die %state{1001}; | |||
if I comment out the second line, all is well. If I have that ~~ in there, it dies | |||
INI - separator is equal to quote- or escape sequence | |||
in sub combi at t/55_combi.t:48 | |||
and the content is correct! so the ~~ fails | 11:16 | ||
The 258'th ~~ fails | 11:17 | ||
timotimo | o/ | 11:23 | |
11:25
smls joined
|
|||
smls | o/ | 11:25 | |
In case someone else finds it useful: | |||
addons.mozilla.org/en-US/firefox/a...-synopses/ | |||
addons.mozilla.org/en-US/firefox/a...erl-6-doc/ | |||
Only does a simple google site search | 11:26 | ||
but the advantage is that you can assign a shortcut to it in firefox | |||
So if you addign the "p6" search shortcut to the p6 doc addon, you can simply type "p6 substr" [ENTER] in the address bar to search it. | 11:27 | ||
*assign | |||
sergot | thanks moritz++ | 11:30 | |
11:30
llfourn left
11:31
mr-foobar left
11:32
mr-foobar joined
|
|||
|Tux| | jnthn, or whoever liker to dig into *weird* failures: | 11:32 | |
gist.github.com/Tux/e85a53243c7bab63858d | |||
adding that warn line makes the die line pass | 11:33 | ||
remove the warn line and it dies the 258'th time that match is done | |||
11:38
FROGGS joined
|
|||
masak | did someone say weird failures? :P | 11:38 | |
jnthn | masak: golf plz :P | 11:41 | |
11:42
amurf joined
11:43
llfourn joined,
_mg_ joined
11:47
amurf left
11:50
Ven left
11:56
tinyblak joined
12:01
Ven joined
12:02
Sqirrel joined,
Ven left,
domidumont left
12:18
Sqirrel left
12:23
domidumont joined
|
|||
jnthn | |Tux|: Got the SEGV reproduced locally | 12:30 | |
smls | Inside a grammar, can I get at the filename of the file passed to Grammar.parsefile ? | ||
12:30
silug left
|
|||
jnthn | No, we don't keep it around anywhere | 12:30 | |
smls | so I can include it in an error message | ||
jnthn | You could easily method parsefile($*FILENAME) { nextsame() } though | 12:31 | |
And then it's available in $*FILENAME | |||
(or whatever name you prefer) | 12:32 | ||
smls | interesting | ||
I guess I could also simply have { die "invalid line '$/'" } inside the grammar, and then have a CATCH {} in the scope where I call MyGrammar.parsefile to add the filename anddie for real | |||
right? | |||
timotimo | jnthn: and this is where we're actually happy that keyword arguments get silently accepted by methods! :) | 12:33 | |
jnthn | smls: Yes, that's also possible | ||
|Tux|: Seems it's something weird this time though...even if I disable dynamic opt it fails 392 tests. | 12:34 | ||
12:36
Ven joined
|
|||
smls | m: (grammar {token TOP { {fail "ooops"} }}).parse("aaa") // say "Failed" | 12:36 | |
camelia | rakudo-moar 24c39e: OUTPUT«Failed» | ||
smls | looks like it even workswith fail :) | ||
although then I can't get at the failure message anymore, right? | 12:37 | ||
timotimo | in that case you can use "orelse" | ||
m: (grammar {token TOP { {fail "ooops"} }}).parse("aaa") // say "Failed: $_" | 12:38 | ||
camelia | rakudo-moar 24c39e: OUTPUT«Use of uninitialized value $_ of type Any in string context in block <unit> at /tmp/7Xa09UnFCM:1Failed: » | ||
timotimo | m: (grammar {token TOP { {fail "ooops"} }}).parse("aaa") orelse say "Failed: $_" | ||
camelia | rakudo-moar 24c39e: OUTPUT«Use of uninitialized value $_ of type Any in string context in block <unit> at /tmp/Uh4G_hHE56:1Failed: » | ||
timotimo | m: (grammar {token TOP { {fail "ooops"} }}).parse("aaa") orelse say "Failed: $!" | ||
camelia | rakudo-moar 24c39e: OUTPUT«Use of Nil in string context in block <unit> at /tmp/x87a9Bbqdd:1Failed: » | ||
timotimo | except not | ||
jnthn | uh, I don't think fail will work out too well deep in the grammar though | ||
smls | ok | ||
jnthn | |Tux|: When I say the string in question, it comes out as "INI - separator is equal to quote- or escape sequence", which doesn't match the regex m{"sep_char is equal to"} | 12:42 | |
12:43
Ven left
|
|||
jnthn | |Tux|: Making the line 'ok (%state{1001} ~~ m{"separator is equal to"}, "Illegal combo 1001");' passes all the tests | 12:44 | |
12:45
silug joined
|
|||
dalek | kudo-star-daily: 989da10 | coke++ | log/ (2 files): today (automated commit) |
12:46 | |
jnthn | |Tux|: Ah, but then when I swtich dynopt back on again I see issues. | 12:47 | |
RabidGravy | does NativeCall have a way of checking whether a shared library exists without creating a binding and trying to use it? | ||
timotimo | i'd also like something to exist that sets up native subs "up front" | 12:48 | |
jnthn | RabidGravy: Not that I'm aware of | 12:49 | |
timotimo | but there's still more or less a rewrite of the "internals" of NativeCall on the horizon | ||
smls | sigspace is driving me crazy: i.imgur.com/SVb2A3q.png | 12:50 | |
jnthn | Well, I suspect a lot will stay the same, it's mostly that we need to do something to let us JIT native calls in a good way | 12:52 | |
arnsholt | smls: What does the comment rule look like? | ||
smls | token comment { '//' .*? $$ } | ||
token ws { \h* } | 12:53 | ||
RabidGravy | jnthn, would it possible then for it to throw different exceptions for "Cannot locate symbol" and "Cannot locate native library" ? | ||
jnthn | smls: I see no "rule" there? | 12:54 | |
arnsholt | smls: That shouldn't trigger ws at all, though. token doesn't give sigspace | ||
jnthn | RabidGravy: Hm, they don't already? | ||
smls | right, the comment was a rule | ||
TOP too | |||
change them to tokens currently to regain sanity :P | |||
arnsholt | But The rule you want is probably along the lines of "token comment { '//' \N* }" | ||
RabidGravy | well in the sense they have a different message, but both are X::AdHoc | ||
jnthn | I was gonna say, why does comment even want to be a rule there | 12:55 | |
RabidGravy: ah, you wnat different types... | |||
RabidGravy: Reasonable request; should be do-able | |||
FROGGS | El_Che: I'd like to see that we submit spectest reports to testers.perl6.org fwiw | 12:56 | |
RabidGravy | jnthn, yeah so I can do something like nicely | 13:00 | |
m: use NativeCall; sub foo() is native('libxndfile') { * }; try { foo(); CATCH { default { say $_.perl; } } } | |||
camelia | rakudo-moar 24c39e: OUTPUT«X::AdHoc.new(payload => "Cannot locate native library 'libxndfile.so': libxndfile.so: cannot open shared object file: No such file or directory")» | ||
13:02
domidumont left
13:03
domidumont joined
13:11
brrt joined
|
|||
hoelzro | [ptc]: so far looks good, but I'm concerned about the testing script. Shouldn't we use panda-test instead? | 13:12 | |
since some things have a Build.pm that does some custom things? | |||
13:15
yqt joined
13:16
g4 left
13:18
skids joined,
dayangkun joined
13:19
dayangkun left,
xinming left,
dayangkun joined
|
|||
hoelzro | is anyone here going to the Swiss Perl Workshop in August? | 13:19 | |
jnthn | hoelzro: yes | 13:20 | |
hoelzro | \o/ | ||
FROGGS | hoelzro: yes | ||
hoelzro | \o/ | ||
FROGGS | :D | ||
13:20
xinming joined
|
|||
hoelzro | with the hackathon happening, I figured as much | 13:20 | |
jnthn | |Tux|: So far I've managed to golf it to something not involving Text::CSV :) | 13:21 | |
13:21
ZoffixWork joined
|
|||
hoelzro | I'm buying my flight right now | 13:21 | |
13:22
laouji left
|
|||
ZoffixWork | FYI: modules.perl6.org/ doesn't have anything listed on it. Failing list generation? I don't see any commits made from the time when I know it was definitely behaving fine, so I'm assuming it's not the code that's the problem. | 13:22 | |
masak | hoelzro: yes | 13:23 | |
ZoffixWork | Is it possible for it to choke on invalid JSON in META.info? 'cause I spotted an extra comma in perl6-ANTLR4, which was recently added to the ecosystem. | ||
hoelzro | more \o/ | ||
itz | modules.perl6.org/ is fairly minimal JSON :) | 13:24 | |
oops | |||
masak | ZoffixWork: if it's possible for it to choke, then we should probably put a `try` statement somewhere... | ||
itz | modules.perl6.org/proto.json | ||
ZoffixWork checks the code | |||
OK, false alarm. It works now :) | 13:25 | ||
I guess I came to the site right in the process of it generating the updated list or something :P | |||
13:25
Ven joined
|
|||
itz | maybe it should generate a new json file and mv it atomically when complete | 13:26 | |
El_Che | FROGGS: I was preparing an sparc x86 vm for perl5 smoke testing and I was curious how perl6 implementation would run on "exotic" setups. However, I haven't find much to setup such environment | ||
FROGGS | El_Che: yeah, we have to do that soonish I think | 13:27 | |
El_Che | If I may step on some toes while giving kudos for the results, I found test smoke for perl5 a real pita to setup | 13:28 | |
(writing the config file felt like assembler) | |||
ZoffixWork | It's only 158KB. I doubt my initial guess about generating new files is correct. Oh well, works now. | 13:29 | |
ZoffixWork makes motions of sweeping stuff under the rug | 13:30 | ||
El_Che | (for the record: once setup the smoke works fine on autopilot) | 13:31 | |
llfourn | How do you do the use MyDynamicExporter 'some_method'; some_method(); -- patern that is used a lot in perl5? | 13:38 | |
where the arguments to import() end up being created via *$dyanimc_name = sub { } | 13:39 | ||
or *{"${caller}::dynamic_name}"} = sub {} rather | 13:40 | ||
I guess I have to get caller in same way come to think of it.. | |||
13:42
cdc is now known as cdc_le_co-corse
13:44
cdc_le_co-corse is now known as cdc
|
|||
jnthn | you write an EXPORT sub in the module that receives the arguments and returns a hash of symbols to install | 13:46 | |
llfourn | ahh is that what this is about: &EXPORT sub did not return an EnumMap | 13:47 | |
awesome thanks | |||
13:47
ab6tract joined
|
|||
ab6tract | o/ #perl6 | 13:48 | |
I've been backlogging and felt compelled to say that anything like having a trailing comma change the semantics of list creation would be a horrible thing to do to anyone | 13:49 | ||
brrt | y | ||
why | |||
a trailing comma may easily change the semantics of an english sentence, | 13:50 | ||
ab6tract | because it is the classic 'change a tiny detail in a Perl script and have everything change' | ||
scenario | |||
brrt | well, we operate in a field where tiny details change everything | ||
did not know the argument for changing the semantics, just arguing that it can be reasonable | 13:51 | ||
13:51
tinyblak left,
tinyblak joined
|
|||
ab6tract | brrt: trailing commas are a classic perl-ism | 13:54 | |
to have @a = [1,2,3] be different than @a = [1,2,3], | |||
... what can I say, it's the kind of choice that would drive many away from considering the language | |||
including me, depending on how the rest of the GLR settles | |||
13:57
_mg_ left
|
|||
smls | ooh, interesting backlog | 13:57 | |
"no longer need circumfix [ ] and { } to itemize" does indeed sound interesting | 13:58 | ||
but I don;t see how it would have those consequences that pmichaud lists (and ab6tract complains about) | |||
"my @a = [1,2,3],[4,5,6] # @a has two Array elements" | |||
13:59
JimmyZ_ joined
|
|||
smls | ^^since list assignment has flattening *@slurpy semantics for the RHS, that would actually be 6 elements, no? | 13:59 | |
also, "my @a = [1,2,3]" and "my @a = [1,2,3]," would still be the same, as both would get flattened by the slurpy | |||
ab6tract | smls: IIUC, pmichaud++ was basing that off of TimToady omitting/forgetting 'list assignment' in his list of flatteners | 14:00 | |
RabidGravy | m: my $f = Sub.new(); say $f | ||
camelia | rakudo-moar 24c39e: OUTPUT«(signal SEGV)» | ||
RabidGravy | m: my $f = Sub.new(); # is fine | ||
camelia | ( no output ) | ||
smls | I hope it's just forgetting :P | ||
ab6tract | me too | 14:01 | |
14:02
Ven left
|
|||
ab6tract | brrt: wrt tiny changes big impact, that is not a very good argument against making sure that those tiny changes are explicit, loud, unignorable | 14:04 | |
With great expressitivity comes greater responsibility | |||
itz | y $f | 14:05 | |
oops | |||
github.com/perl6/modules.perl6.org/pull/9 | |||
ab6tract | And ignoring our own languages' reputation for obscure corner cases will surely doom us | 14:06 | |
itz | ^^ that should fix the modules.perl6.org issue just seen | 14:07 | |
dalek | href="https://modules.perl6.org:">modules.perl6.org: ab616e1 | (Steve Mynott)++ | web/lib/P6Project.pm: make write_file atomic so partial or empty files are never in place |
14:08 | |
href="https://modules.perl6.org:">modules.perl6.org: 542e334 | ab5tract++ | web/lib/P6Project.pm: Merge pull request #9 from stmuk/stmuk make write_file atomic so partial or empty files are never in place as probably happened irclog.perlgeek.de/perl6/2015-06-10#i_10729972 |
|||
RabidGravy | just rt'd that segv as #125376 | 14:11 | |
synbot6 | Link: rt.perl.org/rt3/Public/Bug/Display...?id=125376 | ||
smls is also confused about pmichaud statement that "flat [[1,2,3], [4,5,6]] wouldn't" have to be rewritten if [] were non-itemizing. Will flat no longer be recursive? | 14:14 | ||
[ptc] | hoelzro: haven't heard of panda-test before, will have to look into it | 14:15 | |
hoelzro: I'm thinking that things are going to change a bit after people start using Travis for Perl 6 projects | 14:16 | ||
hoelzro: I had `make test` in the build script beforehand and was thinking while writing the docs: hmm, don't think everyone's likely to do that :-) | 14:17 | ||
hoelzro: was also wondering about using `ufo` to generate a Makefile like EUMM does, but haven't yet been able to get ufo to work on my system... | 14:18 | ||
RabidGravy | is there another way of creating a named sub with a name chosen at run-time that doing an EVAL? | 14:19 | |
hoelzro | [ptc]: yeah, I think that using the tools that panda ships is the way to go (for now) | 14:20 | |
14:21
dayangkun left
14:23
Ven joined
|
|||
llfourn | RabidGravy: You can make a sub like my $foo = sub {...}; $foo.set_name('foo'); | 14:25 | |
that won't declare the symbol in the current lexical scope though | 14:26 | ||
methods you can do with $obj.add_method | 14:27 | ||
I'm still in the process of figuring these things out | |||
m: my &Foo = sub { say "win" }; Foo(); | 14:29 | ||
camelia | rakudo-moar 24c39e: OUTPUT«win» | ||
llfourn | oh that works ^^ :D | ||
14:30
Ven left
14:32
andreoss joined
|
|||
moritz | m: my $name = 'thing'; my $sub = anon sub ::($name) () { say 'win' }; $sub(); say $sub.name | 14:35 | |
camelia | rakudo-moar 24c39e: OUTPUT«===SORRY!===Name ::($name) is not compile-time known, and can not serve as a sub declaration» | ||
psch | m: sub f($name, &code) { &OUTER::('&' ~ $name) = &code }; f("foo", sub { say "bar" }); foo # similarly forbidden | ||
camelia | rakudo-moar 24c39e: OUTPUT«5===SORRY!5=== Error while compiling /tmp/evaTssJ8WcUndeclared routine: foo used at line 1» | ||
moritz | too bad :/ | ||
psch | ISTR jnthn was against something like that because of opts..? | ||
moritz | psch: also if you use &OUTER::, it already has one &, so you don't need '&' ~ $name | ||
psch | oh, right | 14:36 | |
well, doesn't make it work :) | |||
moritz | yes, you can't add to lexpads at run time | ||
which is great, because it means we can use numbers instead of names for lexpad entries in compiled code | |||
RabidGravy | I'm going with the EVAL for the time being | 14:37 | |
moritz | also it allows us to catch undeclared names at compile time (which is a much bigger reason) | ||
14:39
Ven joined
|
|||
lizmat | m: say $*KERNEL.bits # irclog.perlgeek.de/perl6/2015-06-10#i_10728514 RabidGravy | 14:40 | |
camelia | rakudo-moar 24c39e: OUTPUT«64» | ||
RabidGravy | lizmat++ # perfect | 14:41 | |
I had actually seen that but instantly forgotten clearly | 14:42 | ||
psch | i remember the opt reason was actually about binding | 14:43 | |
e.g. «sub f { ... }; &( | |||
[Coke] | hoelzro: (SPW) possibly. | ||
psch | e.g. «sub f { ... }; &('f') := sub { #`[ do things ] } | ||
» | |||
it might be workable for stubs, but sets bad expectations | |||
and for actual subs it breaks at least inlining, i suppose | 14:44 | ||
hoelzro | [Coke]: cool | ||
psch | (plus the missing ::, too) | ||
14:45
Ven left
14:47
msouth joined,
cognominal left
14:48
Ven joined
|
|||
psch | "java.lang.RuntimeException: Unknown container config rakudo_scalar" | 14:48 | |
humm | |||
that points me at lack of understanding of CUs | 14:49 | ||
pmichaud | (trailing comma) we already have the case that a trailing comma changes the meaning of things | 14:50 | |
(1,) versus (1) has been a part of Perl 6 for a long time. | |||
14:52
MilkmanDan left
14:53
Ven left
|
|||
msouth | Is it a known thing that this: my $a=11; my $b:=$a; $b=12; say $b.WHAT gives (Mu) in the REPL in version 2015.03 ? | 14:53 | |
jnthn | I know I fixed something related to binding and the REPL and it was probably more recent than that. | 14:54 | |
msouth | ok | ||
psch | #122914 was close on april 20th, jnthn++ | 14:55 | |
synbot6 | Link: rt.perl.org/rt3/Public/Bug/Display...?id=122914 | ||
msouth | I have some pastebin'd reproductions: paste.scsys.co.uk/487896 paste.scsys.co.uk/487897 paste.scsys.co.uk/487898 | ||
if that's useful for a regression test or whatever | |||
pmichaud | unfortunately, 2015-03 is the latest .msi we have available and several people were using that at last night's tutorial | ||
jnthn | pmichaud: Ah | ||
msouth | yeah I got mine from homebrew on OS X | ||
14:56
MilkmanDan joined
|
|||
pmichaud | so that particular part of the tutorial failed for quite a few people | 14:56 | |
14:57
tinyblak left,
tinyblak joined
|
|||
ab6tract | pmichaud: still not very convincing. that's bothered me before, and I just assumed it would be cleaned up in GLR | 14:57 | |
I guess I've just been piling "don't like this about lists, must be going away" into a specific bucket | |||
pmichaud | ab6tract: sadly it often doesn't work that way. | 14:58 | |
that said, trailing commas are currently quite rare, and I don't think my trailing comma example from last night would end up being a common thing either. | |||
we've seen over and over that most people's natural expectation of | 14:59 | ||
my @a = [1,2,3]; | |||
is that @a ends up with three elements. I mean, it looks like an array assignment | |||
tadzik | computer, messages | ||
yoleaux | 08:51Z <[ptc]> tadzik: could you review github.com/tadzik/rakudobrew/pull/42 when you get time please? It allows matching Rakudo/panda versions to be installed on Travis | ||
ab6tract | true | ||
however, it seems like "[ ]" is always an item is a much easier rule to remember | 15:01 | ||
than "[ ]" is only an item in list context | |||
that sounds like the howling of zombie camels | 15:02 | ||
pmichaud | the whole notion of "[ ] is always an item" came out of the need for a way to suppress flattening in the majority of contexts | ||
because flattening was so much a default part of perl 6 behavior | |||
tadzik | [ptc]: done, thanks a lot! | ||
pmichaud | that's no longer true. flattening is now the exception, not the rule. | ||
15:02
lizmat left
15:03
brrt left
|
|||
pmichaud | Prior to 2010, we didn't have a notion of "item context" | 15:03 | |
|Tux| | jnthn++; # I was not paying attention due to $work activities | ||
sorry to keep throwing these more complicated bugs at you | |||
pmichaud | at least not one that manifested itself the way it does now | ||
jnthn | |Tux|: Well, I'd rather have them now than later... | ||
pmichaud | perhaps an example is good here: | ||
for [1,2,3], (4,5,6) { .say } # how many iterations? | 15:04 | ||
jnthn | |Tux|: I've got it down to a script that doesn't involve any modules now, and to a specific optimization; unfortunately it's a very widely applied one that's probably going on wrong info, so it's still going to take some hunting. | ||
|Tux| | good luck hunting | 15:05 | |
I found it *very* strange that adding the same match made all tests pass | 15:06 | ||
15:06
lizmat joined
|
|||
jnthn | |Tux|: Yeah; in the end I got it down to gist.github.com/jnthn/cff4c17fcc6d7bd2ece3 but even trying to remove one of the remaining conditionals makes the bug go away. | 15:07 | |
15:07
Ven joined
|
|||
|Tux| | O, wow, that is golfed down indeed! | 15:08 | |
15:08
Ven left
|
|||
grondilu | m: for False, True -> $b { .say } | 15:09 | |
camelia | rakudo-moar 24c39e: OUTPUT«(Any)(Any)» | ||
grondilu | m: for False, True -> $b { say $b } | ||
camelia | rakudo-moar 24c39e: OUTPUT«FalseTrue» | ||
grondilu was wondering if the parens were necessary in gist.github.com/jnthn/cff4c17fcc6d7bd2ece3 | |||
[ptc] | tadzik: sweet! Thank you! | 15:12 | |
15:19
msouth left
|
|||
ab6tract | pmichaud: well, if you keep [] stable as item-always | 15:19 | |
then the answer is quite clear | |||
pmichaud | is it? | ||
15:19
tinyblak left
|
|||
ab6tract | yes, it is a single item | 15:19 | |
pmichaud | for [1,2,3], (4,5,6) { .say } # how many iterations? | 15:20 | |
ab6tract | it's only when you start switching behaviors based on context that things get terrible | ||
15:20
tinyblak joined
|
|||
TimToady | well, for doesn't flatten, so that would stay 2 iterations in any case | 15:20 | |
pmichaud | right... so what's the difference between the [] and the () here ? | ||
15:20
amurf joined
|
|||
TimToady | as I understand the proposal without actually backlogging, [] just makes an Array, instead of a List | 15:20 | |
ab6tract | apparently nothing, except some future mugs hitting future walls | ||
TimToady | much like :{} makes Hash[Any,Any] rather than Hash[Any] | 15:21 | |
pmichaud | TimToady: the proposal is that [] produces an Array, not an itemized array | ||
TimToady | yes, I got that | ||
I'm saying that would be all the difference there is | |||
O(Array/List) | |||
s/O// | |||
it's still meaningful, but only in creating assignable elems | 15:22 | ||
pmichaud | somehow I'm not really following this answer. :-/ | 15:23 | |
TimToady | my $a1 := [1,2,3]; $a1[2] = 'works'; my $a2 := (1,2,3); $a2[2] = 'fails' | 15:24 | |
jnthn | Did TimToady just mean that [...] creates something with assignable elems (Array) and ...,... creates a List which doesn't? | ||
pmichaud | jnthn: okay, that helps clarify part of it :) | ||
15:25
amurf left
|
|||
TimToady | but your proposal as I understand it would be to strip the Scalar from around Array | 15:25 | |
when you make a [] one | |||
pmichaud | "not strip the scalar", but rather "don't add one" | ||
er | |||
not "strip the scalar", rather "don't add one" | |||
TimToady | well, sure, I meant "strip" metaphorically | 15:26 | |
pmichaud | just making sure :) | ||
15:26
diana_olhovik left
|
|||
pmichaud | yes, I'm proposing that [] simply be an Array constructor, not an itemized-Array constructor. | 15:26 | |
15:26
msouth joined
|
|||
pmichaud | s/proposing/exploring/ may be better | 15:26 | |
and same for {...} as a Hash constructor | 15:27 | ||
dalek | osystem: 7b56c97 | RabidGravy++ | META.list: Add LibraryCheck to ecosystem |
||
RabidGravy | filthy hack but someone had to do it | 15:28 | |
TimToady | but we'd probably have to make my @a = [],[]...oh, that's where you're proposing a shallow flatten? | ||
pmichaud | right | ||
TimToady | hafta think about that | ||
pmichaud | it's just now awkward to talk about "item context" when the only place that does flattening is array assignment and slurpies | ||
I noticed this very quickly in last night's tutorial | |||
TimToady | nodnod | 15:29 | |
pmichaud | since parcels no longer flatten | ||
hoelzro | is open('-', :r) re-opening standard input spec'd behavior, or a Rakudo-specific detail? the only mention I see of it behaving this way in the spec is in command line processing | ||
15:29
spintronic joined
15:30
dwarring left
|
|||
TimToady | I think I wouldn't call it "shallow flattening" | 15:30 | |
pmichaud | hoelzro: using '-' to represent standard input is pretty standard , so I'm guessing it's designed behavior | ||
I agree, I don't like the name "shallow flattening" | |||
hoelzro | pmichaud: for a command tool, that makes sense, but for the open() function? | ||
pmichaud | I just needed a placeholder to talk about interpolation that isn't a deep interpolation | ||
TimToady | in the proposed "for $array {}" I'd rather think of it as "for takes one argument which is coerced to give an iterator" | ||
hoelzro | granted, not a lot of people have files named '-', but those reasons | ||
TimToady | so "my @array = $array" could be the same story | 15:31 | |
pmichaud | TimToady: hmmm. | ||
TimToady | it's one argument, which might have commas in it, but if not, the single item is iterted | 15:32 | |
*rat | |||
so "for $a,$b" iterates twice, guaranteed | 15:33 | ||
pmichaud | even under that way of thinking about it, it doesn't seem that [] needs to be an itemized array | ||
TimToady | but "for $something {}" depends on the elems of $something | ||
pmichaud | a bare array works just the same | ||
TimToady | I wasn't proposing that [] be itemized | 15:34 | |
pmichaud | okay | ||
TimToady | I'm exploring :) | ||
pmichaud | here in Perl 6 land we've gotten so used to thinking about "item context" that now it's odd to go back to perhaps not needing it :) | ||
s/item context/itemized values/ | 15:35 | ||
TimToady | so "for 42 {}" still listifies to a single elem | ||
pmichaud | I still tend to think of that as being the same as (42).map({}) | 15:36 | |
but it amounts to the same thing... the automatic treating of scalars like lists in response to list-y methods | |||
skids | As long as we can say "look for a top-level comma, if it ain't there, behavior is different" the single-item case is at least explainable IMO. | ||
pmichaud | I don't like the "behavior is different" part of that phrasing. I'm not seeing a difference in behavior. | 15:37 | |
15:37
tinyblak left
|
|||
TimToady | it's consistently "ask the top-level thing for its list" | 15:37 | |
15:37
tinyblak joined
|
|||
TimToady | just when there's commas, the top-level thing is already a list | 15:37 | |
skids | Well, you don't see it because you aren't looking at [],[] as "two []s" and "[]" as "one []", naively. | 15:38 | |
pmichaud | [],[] is a list of two arrays | ||
[] is a single array | |||
skids | Yes you know that, newbies it is "two []s" | ||
TimToady | just like @foo,@br | ||
pmichaud | if I iterate a list of two arrays, I get two iterations | ||
if i iterate a single array, I get iterations for each element of the array | |||
or, phrased another way | 15:39 | ||
if I iterate a list of two arrays, I get two iterations. if I iterate an array of $n elements, I get $n iterations | |||
it's not "difference in behavior" at all. | |||
TimToady | I do suspect there's more gotchas from teh viewpoint of a P5 programmer though | 15:40 | |
pmichaud | maybe. I'm not yet convinced of that. | 15:41 | |
If we treat prefix-$ as being the "don't interpolate" thingy, p5'ers might be okay with that | |||
15:41
tinyblak_ joined
|
|||
pmichaud | because it looks a lot like an arrayref | 15:42 | |
TimToady | it does fit on a deep level with the referential simplification that the context determines the deref | ||
pmichaud | my @a = $[1,2,3]; # @a has one element | ||
TimToady | so 'for' is just another kind of .[] thingy | ||
pmichaud | my @a = [1,2,3]; # @a has three elements | ||
or put another way, perhaps at this point we're going to have gotchas from P5 viewpoint no matter what we do | 15:43 | ||
TimToady | well, but if you do that to [], you have to do it to $ either, so going back to using $ for pseudo-itemization is a problem | ||
s/either/too/ | |||
seems to me | |||
pmichaud | well, mainly because you're thinking of my @a = $s; iterates $s | 15:44 | |
TimToady | maybe $ could still imply Scalar, I dunno | ||
pmichaud | I hadn't looked at it that way. | ||
I was still thinking that my @a = $s; would give @a a single element, even if $s is iterable | |||
15:45
tinyblak left
|
|||
TimToady | but you were asking for 'for $s' to iterate the other day, which is the same thing | 15:45 | |
pmichaud | not really | ||
for me, 'for $s' is like $s.map | |||
and in that case, the item/scalarness doesn't apply. | 15:46 | ||
TimToady | well, if you dig deep enough, list assignment is also mapping input values into individual assignments | ||
though not perhaps with an explicit .map | 15:47 | ||
pmichaud | yeah, the idea of list assignment being map-like or for-like hadn't crossed my mind | 15:48 | |
there is historical basis for list assignment being iteration-y, though... I just hadn't ever made a connection. | |||
not sure a connection should be made :) | |||
now I'm curious about the meaning of something like (@a, @b) = @b, @a | 15:51 | ||
15:52
daxim joined,
tinybla__ joined
15:53
tinyblak_ left
|
|||
pmichaud | and we do need to deal with / consider the flattening behavior of .[ ] as well | 15:54 | |
15:54
lizmat left
|
|||
pmichaud | it's analogue-ish to the [ ] array constructor, I suspect | 15:54 | |
daxim | what's the equivalent of naked readline/implicit open on stdin? encrypted.google.com/search?q=site....org+stdin gives me no results | 15:55 | |
hoelzro | daxim: get or lines | ||
smls | Would it be so bad to have to use $ to construct an AoA? @a = $[1, 3], $[2, 4] | 15:56 | |
i.e. make [] non-itemizing, but keep list assignment as it is | |||
and keep flattening recursive | |||
pmichaud | smls: My first thought was "yes, that'd be so bad", but my subsequent thoughts are "well... maybe not so bad" :) | 15:57 | |
smls | s/construct/assign to a @ variable/ | ||
pmichaud | my brane is hurting a bit, I'll make my way down to the conference venue now | 15:58 | |
daxim | there's a difference | ||
both perl -E'print scalar readline' < foo and perl -E'print scalar readline' foo work | |||
smls | oh, I guess @a = [[1, 3], [2, 4]] would also still work because the outer [] constructs an array (thereby itemizing the inner ones) before assignment | 15:59 | |
daxim | but perl6 -e'say $*IN.get' foo hangs | ||
only the redirect version works | |||
pmichaud | smls: correct | 16:00 | |
smls: as opposed to ([1,3], [2,4]) which wouldn't itemize the inner arrays | |||
smls | yeah | ||
ab6tract | pmichaud: I can commiserate with the hurt in your brain :) | ||
ZoffixWork | I checked the code and it just logs the error and proceeds to the next module. There's no chocking :) RE: [09:24:33] <masak> ZoffixWork: if it's possible for it to choke, then we should probably put a `try` statement somewhere... | 16:01 | |
ab6tract | fwiw, I still haven't seem something that doesn't look like some form of sharp object to the eye | ||
pmichaud | $Pm.torment(<GLR>) | 16:02 | |
ab6tract | but then again, we are talking about contexts.... I guess it's an immutable property of the topic :( | ||
anyway, out for now | 16:03 | ||
jnthn | daxim: It's waiting for input; the foo there won't magically go to STDIN. If I typed something and hit enter it will say it. Maybe you're looking for $*ARGFILES | ||
ab6tract | have fun, #perl6! | ||
ZoffixWork | \o | ||
16:03
ab6tract left
|
|||
daxim | why is the magic gone? :( | 16:04 | |
16:05
FROGGS left
|
|||
TimToady | $*IN.get is <STDIN>, not <> | 16:06 | |
that's why the "IN" | 16:07 | ||
16:07
diana_olhovik joined,
yqt left
|
|||
TimToady | daxim: so if you want the magic, just do this: perl6 -e 'say get' foo | 16:11 | |
get will behave like <> | |||
or use lines for all of them | 16:12 | ||
moritz | (but hopefully without the security implications of <>) | ||
daxim | ah, so get is a function, too, not just a method | ||
16:12
domidumont left
|
|||
daxim | I'm glad the magic is not gone after all, that makes porting much easier | 16:12 | |
16:13
uncleyear left,
uncleyear joined
|
|||
TimToady | m: say get | 16:13 | |
camelia | rakudo-moar 24c39e: OUTPUT«Céad slán ag sléibhte maorga Chontae Dhún na nGall» | ||
moritz | m: say $*ARGS.get | 16:14 | |
camelia | rakudo-moar 24c39e: OUTPUT«Dynamic variable $*ARGS not found in block <unit> at /tmp/baPSkM5wxe:1» | ||
moritz | uhm, what's that thing called... | ||
daxim | jnthn said $*ARGFILES | ||
moritz | ah, right | ||
pmichaud | as to why "@a = $scalar" might not iterate $scalar whereas "for $scalar" does, part of the difference to me may come down to the former being list prefix precedence, whereas the latter doesn't seem to have that precedence. | 16:15 | |
dalek | osystem: f39c42c | (Jeffrey Goff)++ | META.list: Add ANTLR4, Marpa |
16:16 | |
daxim | how do I get a complete list of those built-in functions, then? docs.perl6.org/routine-sub.html does not list `get` | 16:17 | |
DrForr | The pull request didn't seem to do the trick yesterday. And Marpa is very much raw. | ||
16:18
uncleyear left
|
|||
ZoffixWork | DrForr, ANTLR got a JSON error in its meta so it's not indexing. I sent you a pull to fix it | 16:18 | |
16:19
uncleyear joined,
lizmat joined
16:23
spider-mario joined,
tinybla__ left
16:24
yqt joined
|
|||
DrForr | Yeah, I just saw that this morning. Merged, I also added Marpa in the update. | 16:24 | |
RabidGravy | daxim, right now it's look in the source then add the missing functions to the docs ;-) | ||
16:25
tinyblak joined
|
|||
PerlJam | DrForr: the README for Marpa is a little confusing ;) | 16:27 | |
DrForr | Sigh, fixing. | ||
JimmyZ_ | somebody wrote a parser for core setting to search subs and signature | 16:28 | |
it is in a gists, iirc | |||
16:28
silug left
|
|||
PerlJam | no worries. I just tuned in and saw Marpa in Perl6 context and wondered what, exactly, that meant. I can read the source in lieu of the README :) | 16:28 | |
DrForr | I haven't even managed to get the library compiled, but I'll get it work. | 16:29 | |
16:29
tinyblak_ joined
16:30
mj41 joined
16:31
ZoffixWork left
16:32
tinyblak left
|
|||
skids | WRT the "how do we implement .kv-ish things question" I think that whatever happens to flattening, it would also be good to have a procedural "take"-like (but strictly lexical and efficient) construct so you can to "loop { calc; takeish-thing; calc; takeish-thing; }" rather than "loop { calc; store-calc; calc; stored-calc, calc; }" | 16:33 | |
16:33
tinyblak joined
|
|||
skids | Being lexical it could do label stuff. | 16:33 | |
TimToady | what's the matter with just using gather/take? | 16:34 | |
dalek | kudo/nom: 14458a9 | lizmat++ | src/core/Str.pm: Add some camels and beer mugs |
16:35 | |
16:35
tinyblak left
16:36
tinyblak_ left,
tinyblak joined
|
|||
skids | TimToady: "It will never be efficient" is my understanding. | 16:36 | |
Plus, nesting and breaking the nesting. | |||
TimToady | that's horse pucky | ||
(the efficiency) | 16:37 | ||
16:37
mj41 left
|
|||
TimToady | part of the GLR is making gather/take fast | 16:37 | |
DrForr | README updated, though it's still very much a work in progress. | ||
I haven't even gotten the library to compile locally, and the API will probably change when I get back from YAPC. | 16:39 | ||
skids | TimToady: I'm mostly referring to irclog.perlgeek.de/perl6/2015-06-10#i_10728696 | ||
16:40
tinyblak left
|
|||
TimToady | a gather/take in eager context will be able to negotiate an implementation with no context switching | 16:41 | |
PerlJam | (Travis Chase)++ combining Perl + Testing + Legos | 16:44 | |
DrForr | I missed a talk with LEGO? :( | 16:46 | |
PerlJam | yeah, he should have put that in the title IMHO | 16:47 | |
(I just stumbled upon his talk looking through the live streams) | |||
DrForr | Yes, an improved draw. I'll have to check it out on stream. | ||
16:49
tinyblak joined
|
|||
RabidGravy | If anyone is interested, Test::is doesn't work properly with enums | 16:50 | |
timotimo | probably because enums stringify to EnumName::ValueName? | 16:51 | |
and "is" somewhat explicitly does string comparison | |||
RabidGravy | yeah that's basically it | 16:52 | |
timotimo | though if you want to compare to an enum, why doesn't the thing you're comparing return an enum instance, too? | ||
RabidGravy | m: enum Foo(:Bar(2)); say Bar eq 2; | ||
camelia | rakudo-moar 14458a: OUTPUT«False» | ||
RabidGravy | timotimo, because I don't know how to make the corresponding thing from an int | 16:54 | |
timotimo | m: enum Foo <Bar Baz Quux>; say Foo(2); | ||
camelia | rakudo-moar 14458a: OUTPUT«Quux» | ||
RabidGravy | ah-ha! | 16:55 | |
I tried just about every other thing | |||
timotimo | wow :) | ||
PerlJam | RabidGravy: next time, just ask timotimo ;) | ||
timotimo | Type($value) is "coercion syntax" in general | ||
colomon | hmmm, port to p6? www.retro11.de/ouxr/211bsd/usr/src/...arp.c.html | 16:57 | |
andreoss | i've just tried git clone this link | 16:59 | |
>You may copy the warp kit in whole or in part as long as you don't try to | 17:02 | ||
make money off it, or pretend that you wrote it. | |||
it's not free software | |||
timotimo | can this game be built easily on a modern linux system? | 17:05 | |
ab5tract | TimToady: it is great to hear some optimism about gather/take | 17:06 | |
colomon | andreoss: with enough work I think we can contact the author. ;) | ||
timotimo | it would be quite surprising if the game could compile without any digging for older library versions | 17:07 | |
ab5tract | It's an awesome construct | 17:08 | |
timotimo | it very much is | ||
i like it a whole lot more than python's "yield" | |||
colomon | woah, like half of the game is command line processing. | 17:09 | |
timotimo | i don't think warp.c is all there is to that game :D | ||
colomon | oh, right. | ||
timotimo | :D | ||
i made the same mistake as you | |||
colomon | indeed, www.retro11.de/ouxr/211bsd/usr/src/games/warp/ | ||
itz | www.retro11.de/ouxr/211bsd/usr/src/...arp.c.html | 17:10 | |
oops | |||
github.com/RetroBSD/retrobsd/tree/...games/warp | |||
colomon | itz++ | 17:11 | |
ab5tract | timotimo: does 'yield' have control flow implications? | ||
in Python, I mean | 17:12 | ||
pmichaud | stevan's talk: Q: "How many of you know what a mop is?" | 17:13 | |
timotimo | what do you mean? | ||
yield does the typical coroutine thing | |||
pmichaud | . o O ( If you understand what a mop is, you don't understand what a mop is ) # :-) | ||
timotimo | if we do modernize warp, we should get it included in the typical bsdgames packages | 17:14 | |
17:15
Possum left
|
|||
skids | lua's "yield" has a slight advantage over "take" in that it allows bidirectional coroutine communications (but you can hack that together in Perl6 with an extra lazy list). | 17:17 | |
andreoss | itz: it's not the original code i guess, some kind of mips port | 17:18 | |
ab5tract | timotimo: nevermind, I was misremembering the behavior of 'yield' in Ruby | 17:21 | |
timotimo | skids: we have take-rw which allows the "receiving" end to change values previously take'd before returning control to the gathering code | ||
arnsholt | I'm getting an error when building NQP head using MoarVM HEAD: "MoarVM op 'neverrepossess' is unknown as a core or extension op" | ||
Anyone seen this before? | |||
ab5tract | for some reason I had the impression that it behaved like a return statement, which would only allow one | ||
timotimo | arnsholt: could be you've got an older version of MoarVM in your path that Configure is picking up? | 17:22 | |
ab5tract | timotimo: that's eff-ing brilliant | ||
timotimo | i think it's hacky and sort of weird, but that's just me :) | ||
skids | timotimo: that does the trick, too. Good point. | 17:23 | |
17:23
FROGGS joined
|
|||
andreoss | it even compiles | 17:24 | |
ab5tract | timotimo: a :with(Code &a) adverb might be cool | ||
timotimo | i'd rather people just use threads that block on each other | ||
where would you put that adverb? | 17:25 | ||
17:25
JimmyZ_ left
|
|||
ab5tract | gather :with($transform) | 17:26 | |
timotimo | i think you'll have to give me a bit more than that :) | ||
ab5tract | Well, I might just be wildly interpreting 'bidirectional coroutine communications' | ||
and am still learning the adverbial syntax | 17:27 | ||
timotimo | i just don't understand when you expect that transform to be called and with what | ||
dalek | kudo/nom: c6925b2 | (Steve Mynott)++ | tools/build/create-moar-runner.pl: correct minor typo and grammar |
||
kudo/nom: 4f36870 | FROGGS++ | tools/build/create-moar-runner.pl: Merge pull request #437 from stmuk/stmuk correct minor typo and grammar |
|||
17:28
Possum joined
|
|||
FROGGS | rjbs++ and TimToady++ # chatter | 17:29 | |
rjbs | :) | 17:30 | |
smls | TimToady: The reason why space is forbidden before postfixes, is to avoid ambiguity with infixes, right? | ||
In that case, wouldn't it be feasible to make an exception for method calls, and solve the ambiguity by instead fobidding people from defining infix operators that look like ".foo" ? | |||
17:30
captain-adequate left
|
|||
smls | I thought I would get used to the .foo(...)\ unspace syntax for multi-line method chains, but it still bothers me a little every time I write it. | 17:31 | |
ab5tract | timotimo: I was imagining that $transform would be called with the taken values as args at the end of each iteration | ||
lizmat | FWIW, smls++ | ||
ab5tract | within the scope of wherever gathering is happening | ||
timotimo | ab5tract: that looks like you just want to use .map on the lazy list and give that to whoever is interested | ||
ab5tract | indeed | 17:32 | |
dalek | rl6-roast-data: 24af6fd | coke++ | / (8 files): today (automated commit) |
||
pmichaud | I really want the "unspace" question listed as a FAQ on faq.perl6.org | 17:33 | |
also, oddly there's no link to faq.perl6.org from the perl6.org home page | 17:34 | ||
ab5tract | Not very useful after all :) | ||
smls | Ideally, faq.perl6.org would be merged into doc.perl6.org IMO | ||
ab5tract is used to being lazy, less used to the code being as lazy as he is | |||
smls | separated into multiple pages grouped by topic, like perldoc's FAQs | ||
ab5tract | timotimo: thinking in adverbs has me asking the question though, why we use the *-rw idiom rather than a :rw one | 17:35 | |
timotimo | too many adverbs are a design smell | 17:36 | |
andreoss | smls: how about p6doc faq? | ||
17:37
tinyblak left
17:38
abraxxa left
|
|||
ab5tract | timotimo: I get the feeling you speak from deep, perhaps painful, experience | 17:38 | |
17:38
espadrine left
|
|||
ab5tract | It sounds reasonable, regardless | 17:38 | |
timotimo | haha | 17:39 | |
no, not really | |||
17:40
SevenWolf joined
|
|||
dalek | q: d6e9dbf | pmichaud++ | answers.md: Stub in a FAQ for unspace and method calls. |
17:43 | |
pmichaud | note that's just the Q without the A. | ||
colomon | my recollection is there was a general feeling that we were too gung ho about adverbs in the early days of p6, and have come to the conclusion they’re best used sparingly. | ||
ab5tract | pmichaud: Note that there is likely useful A's for some things in doc.perl6.org/language/traps | 17:45 | |
pmichaud | my recollection differs a bit. For a very long time, we didn't have a good way to parse adverbs, so we tended to avoid them. | 17:46 | |
ab5tract | which I think has fallen into an unfortunate naming scheme. 'gotchas' might be less forboding | ||
pmichaud | I'm totally fine with migrating faq.perl6.org into doc.perl6.org... it's just not my focus at the moment :) | ||
17:47
lizmat left
|
|||
pmichaud | basically, I'm thinking we might want to come up with the standard answers for the frequently bikeshedded topics :) | 17:47 | |
ab5tract | pmichaud: On the contrary, I was more considering the live scenario you are in right now, offering a resource which fields some known areas of confusion | ||
pmichaud | ab5tract: yeah, I'm reading it now | ||
(plus I'm half listening to stevan++'s talk ) | |||
actually, perhaps I should create a "bikeshedded answers" section of faq.perl6.org :) | 17:48 | ||
17:52
telex left
|
|||
PerlJam presumes that TimToady told Stevan an easier/better way to get at the bits of data tacked onto a package. | 17:54 | ||
17:54
telex joined
|
|||
smls | pmichaud: Will your quest to make @( ) / .list unnecessary in many places, also extend to making things like .tree less necessary? | 17:55 | |
e.g. this does not DWIM currently: @a X (@b Z @c) | 17:56 | ||
to make it do the "natural" thing, we have to write: @a X (@b Z @c).tree.list | |||
...which is quite ugly. | |||
17:56
lizmat joined
|
|||
smls | if the GLR would make that go away too, I'd be happy :) | 17:57 | |
FROGGS | btw, I'd also like to see an implicit unspace before the method call dot | ||
PerlJam | smls: @a X [@b Z @c] is quite close to what you want :) | 17:59 | |
lizmat | m: my $a = 42; say $a .Str # only when we would get a TTIAR | ||
camelia | rakudo-moar 4f3687: OUTPUT«5===SORRY!5=== Error while compiling /tmp/YnBCRQfLrkTwo terms in a rowat /tmp/YnBCRQfLrk:1------> 3my $a = 42; say $a7⏏5 .Str # only when we would get a TTIAR expecting any of: infix infix stopper po…» | ||
smls | it gets me a very different output | ||
lizmat | so basically turn a TTIAR in which the 2nd term starts with "." into something useful | 18:00 | |
arnsholt | timotimo: Looks like you were sort of right. I had --with-moar but no --prefix, which made it try to use nqp/install/bin/moar even though I told it to use some other moar | ||
18:01
rindolf left
|
|||
FROGGS | lizmat: Slang::Tuxic does it and it seems there are no false positives there | 18:01 | |
timotimo | arnsholt: ah, right | 18:02 | |
lizmat | FROGGS: but that's not the only thing that Slang::Tuxic does, is it ? | 18:03 | |
18:03
andreoss left
|
|||
timotimo | one problem with .foo with space in front is that ".foo" is already shorthand for "$_.foo" | 18:03 | |
FROGGS | lizmat: correct, but it is one of the sane things it does :o) | ||
timotimo: it is still nice to line-up long method.method.method calls | 18:04 | ||
timotimo | yes | ||
lizmat | timotimo: yes, and it can stay that way | ||
timotimo | i mean if we allowed .foo without a \ on the line before that | 18:05 | |
lizmat | because then it is the first term | ||
m: .say for ^5 # would continue to work | |||
camelia | rakudo-moar 4f3687: OUTPUT«01234» | ||
timotimo | i was thinking of the potential version of .foo where we're allowed to put whitespace and newline between $foo and .bar | 18:06 | |
RabidGravy | had gone name blind when Test.pm was kebabed github.com/rakudo/rakudo/pull/438 | ||
arnsholt | FROGGS: From my understanding, it's precisely that kind of helpful parsing rules that makes parsing Perl 5 the horror that it is | ||
FROGGS | timotimo: right, .say will continue to work | ||
timotimo | of course | 18:07 | |
raydiak | if I did "say sub {}.defined" would that be "say(sub {}); $_.defined" or "say(sub {}.defined)"? | ||
timotimo | i just mean it can confuse people | ||
FROGGS | arnsholt: yes, but you want to have nicely readable code, right? | ||
timotimo | the way we currently have it is good, IMO | ||
smls | raydiak: the former | 18:08 | |
} is a statement terminator | |||
allowing space befor .method would not change that | |||
raydiak | got it | 18:09 | |
18:09
rindolf joined
|
|||
RabidGravy | boo! is_approx isn't approximate enough | 18:11 | |
;-) | 18:12 | ||
lizmat | RabidGravy: please fix! soon! :-) | 18:13 | |
18:14
domidumont joined
|
|||
lizmat | that one was specifically *not* kebab-cased to allow for a better version | 18:14 | |
named "is-approx" | |||
RabidGravy | ah okay | ||
I only noticed because ffmpeg can't make a WAV file of exactly 1 second - for some reason it insists on some multiple of 1024 frames | 18:16 | ||
ab5tract suddenly imagines libav bindings | 18:17 | ||
RabidGravy | I finally got around to libsoundfile | ||
ab5tract | RabidGravy++ :D | 18:18 | |
RabidGravy | er, libsndfile - libsoundfile is different | ||
ab5tract | I think I parsed it properly anyway | 18:19 | |
awwaiid | Is there a "binding.pry" type thing in rakudo, so I can do like "start a REPL here"? | 18:21 | |
(I might have asked this before, but can't remember) | 18:22 | ||
18:25
yqt left
18:30
bin_005 joined
|
|||
daxim | p6: my $i = -1; #`{ computed last field } say <q w e r t>[$i..2] | 18:31 | |
camelia | rakudo-moar 4f3687: OUTPUT«Index out of range. Is: -1, should be in 0..Inf in block <unit> at /tmp/tmpfile:1» | ||
daxim | why does accessing indexes from the right end not work anymore? | 18:32 | |
FROGGS | daxim: you have to indicate that you really want to do it | 18:33 | |
masak | are you sure that ever worked? | ||
arnsholt | It's never been supposed to work | ||
AFAIK | |||
masak | right. | ||
FROGGS | p6: my $i = -1; #`{ computed last field } say <q w e r t>[*$i..2] | ||
camelia | rakudo-moar 4f3687: OUTPUT«5===SORRY!5=== Error while compiling /tmp/tmpfileTwo terms in a rowat /tmp/tmpfile:1------> 3 computed last field } say <q w e r t>[*7⏏5$i..2] expecting any of: infix infix stopper statement end …» | ||
FROGGS | err | 18:34 | |
p6: my $i = -1; #`{ computed last field } say <q w e r t>[(* + $i)..2] | |||
camelia | rakudo-moar 4f3687: OUTPUT«» | ||
FROGGS | p6: my $i = -1; #`{ computed last field } say <q w e r t>[0..*] | ||
camelia | rakudo-moar 4f3687: OUTPUT«q w e r t» | ||
FROGGS | p6: my $i = -1; #`{ computed last field } say <q w e r t>[0..(*-1)] | 18:35 | |
camelia | rakudo-moar 4f3687: OUTPUT«q w e r t» | ||
FROGGS | p6: my $i = -1; #`{ computed last field } say <q w e r t>[(*-1)] | ||
camelia | rakudo-moar 4f3687: OUTPUT«t» | ||
FROGGS | hmmm | ||
I thought it would mean .elems here | |||
[Coke] | gist.github.com/coke/f852b3728e459867f622 # of lines per author in rakudo blame. | ||
m: say 706/27668 # surprised i'm this high. | 18:36 | ||
camelia | rakudo-moar 4f3687: OUTPUT«0.025517» | ||
FROGGS | I am twice as much to blame than TimToady? O.o | ||
[Coke] | I alwso see some people are in there under 2 or more addresses. | ||
FROGGS | yeah | 18:37 | |
[Coke]: is that for rakudo? | |||
ahh yes | |||
you mentioned it :D | 18:38 | ||
daxim | FROGGS, masak: perl -e'my $i = -1; print for (qw"q w e r t")[$i..2]' # expected result, want to "wrap around" | 18:39 | |
[Coke] | maybe I can edge past perljam. :) | 18:43 | |
tony-o_ | jnthn: is there a mechanism in nativecall to call perl6 functions? | 18:46 | |
18:47
lizmat left
|
|||
FROGGS | tony-o_: as a callback? | 18:48 | |
tony-o_ | yea | ||
similar to a callback | |||
FROGGS | doc.perl6.org/language/nativecall#F..._arguments | ||
tony-o_ | FROGGS: tyvm | 18:49 | |
FROGGS | tony-o_: yw | ||
raydiak | m: print qw"q w e r t".rotate(-1)[^4] # for lack of a concise way to wrap the indices, you could wrap the list around instead... | ||
camelia | rakudo-moar 4f3687: OUTPUT«tqwe» | ||
tony-o_ | FROGGS: on the C side, do i end up calling 'callback(<whatever>)' to run the perl6 side sub/method ? | 18:51 | |
daxim | thanks, raydiak | 18:52 | |
FROGGS | tony-o_: I think so | ||
raydiak | daxim: you're welcome :) | 18:54 | |
daxim | when I dump something with $foo.perl.say, it shows up as $( ………something……… ) | 18:55 | |
what's that? | |||
gives me hard jquery flashbacks :/ | 18:56 | ||
vendethiel | daxim: itemization | ||
m: for $(1, 2, 3) { say .perl; } | |||
camelia | rakudo-moar 4f3687: OUTPUT«$(1, 2, 3)» | ||
vendethiel | m: for $(1, 2, 3), 2, 3 { say .perl; } | ||
camelia | rakudo-moar 4f3687: OUTPUT«$(1, 2, 3)23» | 18:57 | |
daxim | .WHAT says the type is List, what does itemization mean then? | 18:58 | |
18:58
amurf joined
|
|||
timotimo | [Coke]: it seems like i'll have to be doing some core setting contributions :3 | 18:58 | |
19:03
uncleyear left,
uncleyear joined,
amurf left
19:07
nys joined
19:10
yqt joined
|
|||
timotimo | [Coke]: can you give me a list of what file has the least timo-lines in it? :) | 19:14 | |
[Coke] | I leave that as an exercise to the reader. | 19:16 | |
vendethiel | Util++ #nice talk | 19:19 | |
hoelzro | what's the policy for accessing globaly things (eg. $*ARGFILES) from separate threads? "play with fire and you're going to get burned", or do we try to protect people from themselves? | 19:22 | |
19:22
domidumont left
19:25
smls left
|
|||
DrForr | OpenCV actually looks like a fun library to play with. | 19:25 | |
hoelzro | DrForr: OpenCV is one of the libraries I have on my "write a Perl 6 binding for this" list | 19:27 | |
19:27
pullphinger joined,
pullphinger left
19:28
pullphinger joined
|
|||
DrForr | The API is almost all C++, it looks like. | 19:28 | |
hoelzro | yes, but I think that they at least have extern "C" symbols you can link to for C support | 19:29 | |
19:29
Peter_R joined
|
|||
DrForr | waltman's talk got me thinking :) | 19:30 | |
Util | vendethiel: Thanks! | 19:31 | |
19:33
avalenn left
|
|||
DrForr | Building opencv takes quite a while. | 19:36 | |
19:36
avalenn joined
|
|||
vendethiel | "Michael Michaud - "How (not) to create a language specification for Perl 6" uh. | 19:37 | |
jnthn | ...who? :) | 19:38 | |
Util | www.yapcna.org/yn2015/talk/6274 | 19:40 | |
By Patrick Michaud (Pm) from DFW.pm | |||
How (not) to create a language specification for Perl 6 | |||
vendethiel | (my titme was from youtube) | ||
jnthn | .oO( How (not) to type "Patrick" ) |
19:41 | |
vendethiel | s/me/le/ | ||
Util | Ah | ||
colomon | Is pmichaud talking now? | 19:42 | |
Have him streaming on my iPad, yes! | 19:44 | ||
seems like they’re doing a really nice job of it, too. (knock on wood) | 19:46 | ||
masak | if we ever clone pmichaud, I move that we name the clone "Michael Michaud" :D | 19:47 | |
PerlJam watches pmichaud's talk too | |||
masak | with the nick "mmichaud", of course | ||
flussence | heh, xhtml2 would've been a better example there - the browsers went off and invented html5 outside the w3c instead :) | 19:48 | |
PerlJam | masak: Patrick A Michaud (who spoke at YAPC::NA 2013) should speak at more conferences concurrently with Patrick R. Michaud too | 19:49 | |
RabidGravy | I while back someone suggested of taking a CArray and putting its contents into a Buf but buggered if I can remember how | ||
19:50
molaf joined
|
|||
masak | PerlJam: I wonder if there's both a Michael A and a Michael R. too? | 19:50 | |
RabidGravy | a way of taking | ||
PerlJam | I think pmichaud's brother is named Michael ... I don't remember. | 19:51 | |
19:51
lizmat joined
19:53
diana_olhovik left
19:56
lizmat_ joined,
lizmat left
19:58
FROGGS left
|
|||
ab5tract | pmichaud: FWIW, It only took a few hours for me to (mostly) drop my issues with `$a` vs `$a,` | 19:58 | |
erm `[]` and `[],` | |||
though it essentially boils down to the same thing | |||
19:59
mohij joined
|
|||
ab5tract | `,` is an infix constructor (or is it a coercion?) to List | 19:59 | |
So it's not about "list context" in any way like my day-to-day work with Perl 5 would lead me to understand it | 20:00 | ||
Put another way, the 'rule' of `,` is sufficiently simple to offset that essential frustration that elicited my earlier reaction | 20:02 | ||
20:13
darutoko left
20:14
dwarring joined
20:16
colomon left
|
|||
dalek | kudo/nom: 88e1464 | lizmat++ | src/core/Perl.pm: Make this version Perl 6 A |
20:18 | |
[Coke] | Do we have any buyin on that version numbering scheme? last I heard it was undecided. | 20:19 | |
masak | the "Patrick A Michaud" suddenly makes a lot more sense... :P | ||
[Coke] | want to make sure we have buyin before it goes out in a monthly, is all. | 20:20 | |
masak | agreed. | ||
last I heard it was undecided, but there's also no alternative that will please everybody. | |||
PerlJam | masak: except that this one is Patrick R Michaud | ||
jnthn is guessing lizmat's commit came after some discussion at YAPC::NA :) | 20:21 | ||
lizmat_ | I guess the buyin is that pmichaud just mentioned the lettering scheme for the version of the *language* | ||
20:21
lizmat_ is now known as lizmat
|
|||
jnthn | ah :) | 20:21 | |
lizmat | and I hated the vunknown pretty badly :-) | 20:22 | |
20:22
msouth left
|
|||
nwc10 | .u | 20:22 | |
yoleaux | U+2006 SIX-PER-EM SPACE [Zs] ( ) | ||
lizmat | m: say $*PERL.version | ||
camelia | rakudo-moar 4f3687: OUTPUT«vunknown» | ||
nwc10 | there, that's got a "SIX" in it. That will do nicely. | ||
everyone can fill in their own preference. No nasty prescribed design :- | 20:23 | ||
) | |||
masak | no alternative will please everybody, but "vunknown" is likely to satisfy no-one :P | ||
PerlJam | lizmat: so ... how does one specify that version in code? use v6.A ? | 20:24 | |
lizmat | in code, one would specify a version of the *compiler* I would think ? | ||
PerlJam | lizmat: no, I want to say my code assumes this version of the language. | ||
jnthn | m: v6a | ||
camelia | rakudo-moar 4f3687: OUTPUT«5===SORRY!5=== Error while compiling /tmp/IHetXE0eAqUndeclared routine: v6a used at line 1» | ||
jnthn | m: v6.a | 20:25 | |
camelia | rakudo-moar 4f3687: OUTPUT«Method 'a' not found for invocant of class 'Version' in block <unit> at /tmp/6ioYvjpcsY:1» | ||
jnthn | aw :) | ||
itz | can't we have String::Koremutake strings based on git sha hashes for versions? :) | ||
20:27
ShimmerFairy left,
bin_005_j joined
20:28
bin_005 left
|
|||
dalek | kudo/nom: 2b2a1a1 | lizmat++ | src/core/Perl.pm: Got corrected by TimToady++, it's Advent, not A |
20:28 | |
PerlJam | nice! | ||
lizmat | and please forgive me if consensus turns out this is wrong :-) | 20:29 | |
$ 6 'say $*PERL.version' | |||
v6.Advent | |||
flussence | I'm trying to get a silly idea to work: making "is cached" use a typed %cache if possible, instead of calling .gist every time | ||
lizmat | flussence: that would call .WHICH everytime | ||
flussence | still in the "trying to get it to build at all" phase, though :) | ||
lizmat | which *could* be better, I agree | ||
[Coke] | cached can't use gist, can it, since that loses info? | 20:30 | |
lizmat | current is cached implementation is pretty naive in that respect | ||
more like a proof of concept and nice for demonstrations :-) | |||
flussence | my current line of thinking is: if there's only one param and it ~~ Cool, it's probably safe to use directly as a hash key | 20:31 | |
20:31
sjn joined
|
|||
masak | std: say v6.Advent | 20:32 | |
camelia | std 28329a7: OUTPUT«ok 00:00 135m» | ||
20:33
colomon joined
20:34
mohij left
|
|||
masak | std: say v6.Ekke.Ekke.Ekke.Ptangya.Zoooooooom.Boing.Ni | 20:34 | |
camelia | std 28329a7: OUTPUT«ok 00:00 135m» | ||
20:34
mohij joined
20:37
pecastro left
20:39
espadrine joined,
ShimmerFairy joined,
rindolf left
20:42
mohij left
20:43
rurban joined,
rurban left
|
|||
flussence | ooh, 5.22 has a grapheme thingy | 20:43 | |
lizmat | sorta, yes, for .combing :-) | 20:46 | |
wonder how that would work for the cases that jnthn had in his lightning talk | |||
flussence | I'm liking these other things going on :) | ||
20:48
rurban joined
|
|||
jnthn | Time for some rest...and will be offline in the morning traveling to London. o/ | 20:48 | |
lizmat | good night jnthn and safe travelling! | 20:49 | |
PerlJam | flussence: yeah ... too bad this perl (5) didn't exist years ago already | ||
spintronic | will PDL traits be implemented in Perl6? | 20:50 | |
it's from Synopsis 9 | |||
PerlJam | spintronic: eventually (probably) | ||
spintronic | ^_^ | 20:51 | |
lizmat hopes danaj will get with something soon :-) | |||
20:53
pullphinger left
21:05
sivoais left
21:06
sivoais joined
21:07
skids left
21:15
Ven joined
21:16
colomon left
|
|||
[Coke] | maybe not by christmas. | 21:16 | |
(pdl traits, that is) | 21:17 | ||
21:21
lizmat left
|
|||
timotimo | shaped arrays are on the roadmap | 21:25 | |
PerlJam | yeah, but pdls are more holy-grail-ish than just shaped arrays | 21:26 | |
21:28
rurban left
21:31
rurban joined
21:36
molaf left
21:37
hoelzro_trying_w joined
|
|||
timotimo | well, to be fair | 21:37 | |
when we say "we have routines", we also mean something more "holy-grail-ish" than just routines | |||
21:37
colomon joined
|
|||
RabidGravy | *** Error in `/home/jonathan/.rakudobrew/moar-nom/install/bin/moar': corrupted double-linked list: 0x00000000040ae1a0 *** | 21:39 | |
that's not good is it | |||
DrForr | I've gotten quite a few of those when playing with readline. | 21:40 | |
zostay | i've been doing some deep thinking about PSGI for Perl 6 and i've come up with a proposal for a Perl 6 version of the PSGI standard | 21:43 | |
if you're interested: github.com/zostay/P6SGI | |||
21:46
lizmat joined
|
|||
ab5tract | zostay++ | 21:47 | |
21:49
yqt left
21:51
rurban left
|
|||
timotimo | zostay: i think you meant "where { when ... {" instead of "where { where ... {" in the Application section | 21:53 | |
21:54
rurban joined
21:55
SevenWolf left
21:57
kaare_ left
|
|||
lizmat | m: gather { take fail } | 21:57 | |
camelia | rakudo-moar 2b2a1a: OUTPUT«Unhandled exception: Could not find symbol '&Return' at <unknown>:1 (/home/camelia/rakudo-inst-1/share/perl6/runtime/CORE.setting.moarvm:throw:4294967295) from src/gen/m-CORE.setting:16775 (/home/camelia/rakudo-inst-1/share/perl6/runtime/CORE.set…» | ||
21:59
Ven left
22:01
SevenWolf joined
22:02
yqt joined
|
|||
dalek | kudo/nom: 975bcc3 | lizmat++ | src/core/control.pm: Make gather { take fail } a proper failure |
22:03 | |
lizmat | $ 6 'gather { take fail }' | ||
Unhandled exception: Attempt to return outside of any Routine | |||
22:04
Foxcool left
22:07
Foxcool joined
|
|||
pmichaud | good afternoon, #perl6 | 22:07 | |
22:07
Foxcool left
22:08
Foxcool joined
|
|||
lizmat | pmichaud o/ | 22:08 | |
pmichaud | some current GLR thinking, from lunchtime: | ||
[ ... ] becomes an array composer without itemization | 22:09 | ||
[ ... ] imposes a flattening context on the values inside it | |||
22:10
frew joined
|
|||
pmichaud | gather/take will need to become very efficient | 22:10 | |
frew | I think --prefix is broken in Configure.pl when you use --gen-moar | 22:11 | |
is there a better place to say this? | |||
pmichaud | we still don't know of a way to have a loop (e.g. 'map') that returns a list with more elements than there were iterations in the loop | ||
frew: this is good, also [email@hidden.address] | |||
frew | ok; I'll leave it at that for now then | ||
pmichaud | (map returning more elements -- not being able to do that feels like an arbitrary limitation) | 22:12 | |
TimToady | quietfanatic++ suggested that Empty was a degenerate case of a more general list inserter | 22:13 | |
frew | details: gist.github.com/frioux/7922db83735d1a5984f8 | 22:15 | |
dalek | kudo/nom: 9b25d80 | lizmat++ | src/core/Compiler.pm: Remove deprecations that are 1 year old now |
||
frew | I don't think there's an obvious solution other than a better error | ||
or .deb's :) | |||
timotimo | frew: do you have write access to /opt as the user that executes that? | ||
frew | no | ||
that's the problem | |||
timotimo | that explains it | 22:16 | |
frew | but I don't like to compile as root? | ||
timotimo | right | ||
this is not about "--prefix is broken", this is "our --prefix behaves very differently from how you'd expect it to" | |||
frew | sure | ||
timotimo | which essentially boils down to "our --prefix is broken" | ||
frew | lol | ||
I mean, it's arguably the subtle --gen-moar (and I bet --gen-nqp) behaviour | 22:17 | ||
timotimo | right; those also contain the "make install" step | ||
frew | I figured that | ||
timotimo | we've been told before that it's very not cool to be installing during Configure.pl | 22:18 | |
frew | ok | ||
timotimo | even compiling during Configure.pl isn't very neat | ||
frew | right | ||
I mean | |||
I get it | |||
and really, the solution is to have nqp and moar installed by a package I think | |||
timotimo | yeah | ||
frew | but bootstrapping; I get it. | ||
frew googles ppa rakudo | |||
slavik | is it possible and is there any documentation on meta-object programming in perl6? I am wondering if it's possible to create a class at run time. | 22:19 | |
timotimo | it is very possible | ||
lizmat | ClassHOW.new ? | 22:20 | |
m: Int.^HOW.say | |||
camelia | rakudo-moar 975bcc: OUTPUT«5===SORRY!5=== Error while compiling /tmp/vgde32XoO2Cannot use .^ on a non-identifier method callat /tmp/vgde32XoO2:1------> 3Int.^HOW7⏏5.say expecting any of: method arguments» | ||
lizmat | m: Int.HOW.say | ||
camelia | rakudo-moar 975bcc: OUTPUT«Perl6::Metamodel::ClassHOW.new» | ||
22:20
bin_005_j left
|
|||
timotimo | github.com/timo/ADT/blob/master/lib/ADT.pm6#L55 here's one example library that does it | 22:20 | |
zostay | timotimo: thx... corrected | 22:21 | |
slavik | timotimo: ty | ||
pmichaud | quietfanatic++ # general list inserter | ||
timotimo | yw | ||
pmichaud | a general list inserter feels.... elegant. | 22:22 | |
timotimo | perhaps this is what we've always wanted parcel to be? | 22:23 | |
or maybe at one point | |||
lizmat | but isn't that what [ ... ] is ? | ||
timotimo | we'll call it Syringe :P | ||
pmichaud | [ ... ] is (to be) an array composer | ||
RabidGravy | is there any way of making a CArray of a certain length? other than looping and assigning each element? | ||
timotimo | i think if you just assign the 100th element it'll become 100 elements big | 22:24 | |
RabidGravy | ooh let's try that | ||
lizmat | .map: { |[ ... ] } ? # did not backlog yet | 22:25 | |
RabidGravy | timotimo, yep that appears to work | 22:26 | |
pmichaud | I kind of like the idea of |[...] and |(...) being used for this, yes. | 22:29 | |
dalek | ast: 43ad905 | lizmat++ | S02-types/deprecations.t: Remove tests for $*PERL deprecations |
||
timotimo | the Weekly is in quite some peril tonight; the cat is very adorable and cuddly at the moment | 22:31 | |
lizmat | timotimo: are you sure it's not a squirrel ? :-) | 22:32 | |
timotimo | hehe | ||
i'm the squirrel, if anything | |||
lizmat | ah. Confuse-A-Cat Ltd. :-) | ||
timotimo | hm? | ||
lizmat | www.youtube.com/watch?v=B2Je1CEPkUM | 22:34 | |
pmichaud | "Perl 6 is geyserware" | ||
labster++ | |||
22:35
amurf joined
|
|||
frew | how do I do this in perl6? s/[^[:ascii:]]//g; | 22:36 | |
frew is alrady porting stuff | |||
or where can I find out? | |||
lizmat | s:g to start with | ||
frew | s:g/foo/bar/ ? | 22:37 | |
RabidGravy | boo! this Audio::Sndfile is taking 15s to load a 1 second file | ||
pmichaud | m: my $_ = 'hello'; s:g/l/L/; .say | ||
camelia | rakudo-moar 975bcc: OUTPUT«Potential difficulties: Redeclaration of symbol $_ at /tmp/SwuYea3EDX:1 ------> 3my $_7⏏5 = 'hello'; s:g/l/L/; .sayheLLo» | ||
pmichaud | m: $_ = 'hello'; s:g/l/L/; .say | ||
camelia | rakudo-moar 975bcc: OUTPUT«heLLo» | ||
lizmat | RabidGravy: is it precomped ? | 22:38 | |
RabidGravy | no, not yet | ||
frew | hm | 22:39 | |
lizmat | I guess the source is 10K lines + ? | ||
RabidGravy | I've only just made it not crash | ||
lizmat | ah, actually loading a file, not just loading the module | 22:40 | |
frew | hmm | ||
lizmat | forget what I said | ||
22:40
amurf left
|
|||
frew | Method 'subst-mutate' not found for invocant of class 'Any' | 22:40 | |
TimToady | m: say "föo".subst(/ <-ascii> /, '', :g) | ||
camelia | rakudo-moar 975bcc: OUTPUT«Method 'ascii' not found for invocant of class 'Cursor' in block <unit> at /tmp/EB0ld3Rn6W:1» | ||
RabidGravy | no, load a 53200 byte WAV file into a buffer | 22:41 | |
TimToady | m: say "föo".subst(/ <-[\0..\x7f]> /, '', :g) | ||
camelia | rakudo-moar 975bcc: OUTPUT«fo» | ||
TimToady | m: say "föo".encode('ASCII') | ||
camelia | rakudo-moar 975bcc: OUTPUT«Blob[uint8]:0x<66 3f 6f>» | ||
22:42
rurban left
|
|||
TimToady | m: say "föo".encode('ASCII').decode | 22:42 | |
camelia | rakudo-moar 975bcc: OUTPUT«f?o» | ||
frew | trying to port this: github.com/frioux/dotfiles/blob/ma.../ascii-ify | ||
RabidGravy | say $*IN.slurp.subst(/ <-ascii> /, '', :g); | 22:47 | |
would do it | |||
22:48
jack_rabbit joined
22:49
rurban joined
|
|||
timotimo | lizmat: monty python is nice :) | 22:49 | |
lizmat: i only recently watched Fawlty Towers with friends | 22:50 | ||
frew | RabidGravy: well I'd rather continue to stream the IO | ||
huh, well when I do $_ = $_.subst(/ <-ascii> /, '', :g) I get Bogus postfix? | 22:51 | ||
RabidGravy | say $_.subst(/ <-ascii> /, '', :g) for $*IN.lines; | ||
frew | I'm doing more than the subst | 22:52 | |
22:52
rurban left
|
|||
frew | but yeah I'll do that | 22:52 | |
Method 'ascii' not found for invocant of class 'Cursor' | |||
TimToady | m: say "föo".subst(/ <-[\0..\x7f]> /, '', :g) | 22:53 | |
camelia | rakudo-moar 9b25d8: OUTPUT«fo» | ||
frew | TimToady: thanks | ||
so is that a missing feature? | |||
TimToady | I dunno, not sure I want to encourage people to asciify :) | 22:54 | |
frew | it's just a little toy script for the most part | 22:55 | |
seemed like it should be easy to convert | |||
timotimo | hm, doesn't trans also support this kind of thing | ||
m: my $r = r/foo/; say $r | 22:56 | ||
camelia | rakudo-moar 9b25d8: OUTPUT«5===SORRY!5=== Error while compiling /tmp/yHcp5G8L7eMissing required term after infixat /tmp/yHcp5G8L7e:1------> 3my $r = r/foo/7⏏5; say $r expecting any of: prefix term» | ||
timotimo | m: my $r = rx/foo/; say $r | ||
camelia | rakudo-moar 9b25d8: OUTPUT«rx/foo/» | ||
timotimo | m: my $r = regex { foo }; say $r | ||
camelia | rakudo-moar 9b25d8: OUTPUT«{ foo }» | ||
timotimo | hoelzro: should we also be saving the declarator into the regex source in this case | ||
22:57
skids joined
|
|||
hoelzro | timotimo: ah, good point | 22:58 | |
22:59
RabidGravy left
|
|||
timotimo | the weekly is useful for this kind of thing :) | 22:59 | |
23:00
BooK left,
rurban joined
23:01
BooK joined,
amurf joined,
quietfanatic joined
|
|||
quietfanatic | For the record, a general list inserter class was not what I was thinking of | 23:02 | |
but I guess I'm glad to have accidentally inspired a good idea. | |||
if it is good, we don't know yet. :) | 23:03 | ||
hoelzro | timotimo: could you ticket that up? | ||
dalek | kudo/nom: a6d2edc | lizmat++ | src/core/Code.pm: Make sure we don't create Code objects willy nilly |
23:04 | |
timotimo | rakudo ticket or rt? | 23:13 | |
lizmat | it's preventing #125376 | 23:14 | |
synbot6 | Link: rt.perl.org/rt3/Public/Bug/Display...?id=125376 | ||
23:24
cognominal joined
|
|||
hoelzro | timotimo: RT, please | 23:29 | |
23:34
bjz left
|
|||
timotimo | it's #125383 | 23:34 | |
synbot6 | Link: rt.perl.org/rt3/Public/Bug/Display...?id=125383 | ||
23:37
bjz joined
23:38
bjz left
23:41
gfldex left
|
|||
lizmat | yapc::na shutting down& | 23:48 | |
23:48
lizmat left
23:51
quietfanatic left
23:58
espadrine left
|