»ö« Welcome to Perl 6! | perl6.org/ | evalbot usage: 'p6: say 3;' or rakudo:, or /msg camelia p6: ... | irclog: irc.perl6.org or colabti.org/irclogger/irclogger_logs/perl6 | UTF-8 is our friend! Set by moritz on 22 December 2015. |
|||
viki | "Although the above example works as intended the eqv code has to fall back to a slower code path in in order to do its job." docs.perl6.org/routine/eqv | 00:02 | |
viki isn't sure it's a good idea to tell users so much about internals of compiler X, since the docs are meant to be compiler-agnostic | |||
00:06
canopus joined
00:07
Ven left
00:23
adu joined
00:25
bjz left
00:26
Actualeyes left
00:32
perlawhirl left
00:33
ponbiki left
00:36
skaji_ joined
00:41
Actualeyes joined,
Xliff joined
|
|||
Xliff | m: constant T = ( a=>1, b=>2); say T<a>; | 00:42 | |
camelia | rakudo-moar e0c0ae: OUTPUT«Type List does not support associative indexing. in block <unit> at <tmp> line 1Actually thrown at: in block <unit> at <tmp> line 1» | ||
Xliff | m: constant T = { a=>1, b=>2 }; say T<a>; | ||
camelia | rakudo-moar e0c0ae: OUTPUT«1» | ||
viki | There's a ticket for that | 00:44 | |
you can also use %() instead of {} | 00:45 | ||
Xliff | Ah. Thanks. | 00:46 | |
dalek | c: fa0b8f6 | (Zoffix Znet)++ | doc/Language/quoting.pod6: Differentiate <...> and qw|...| Fixes RT#130184: rt.perl.org/Ticket/Display.html?id=130184 |
00:47 | |
synopsebot6 | Link: doc.perl6.org/language/quoting | ||
synopsebot6 | Link: rt.perl.org/rt3//Public/Bug/Displa...?id=130184 | ||
00:47
bjz joined
|
|||
Xliff | m: $a = 'b'; given $a { when 'b' || 'bb' || 'bbb' { say 'B'; } default { say 0; } } | 00:48 | |
camelia | rakudo-moar e0c0ae: OUTPUT«5===SORRY!5=== Error while compiling <tmp>Variable '$a' is not declaredat <tmp>:1------> 3<BOL>7⏏5$a = 'b'; given $a { when 'b' || 'bb' ||» | ||
Xliff | m: my $a = 'b'; given $a { when 'b' || 'bb' || 'bbb' { say 'B'; } default { say 0; } } | ||
camelia | rakudo-moar e0c0ae: OUTPUT«5===SORRY!5=== Error while compiling <tmp>Strange text after block (missing semicolon or comma?)at <tmp>:1------> 3{ when 'b' || 'bb' || 'bbb' { say 'B'; }7⏏5 default { say 0; } }» | ||
Xliff | m: my $a = 'b'; given $a { when 'b' || 'bb' || 'bbb' { say 'B'; }; default { say 0; } } | ||
camelia | rakudo-moar e0c0ae: OUTPUT«B» | ||
Xliff | m: my $a = 'b1'; given $a { when 'b' || 'bb' || 'bbb' { say 'B'; }; default { say 0; } } | ||
camelia | rakudo-moar e0c0ae: OUTPUT«0» | ||
Xliff | m: my $a = 'c1'; given $a { when 'b' || /^^c/ { say 'BC'; }; default { say 0; } } | 00:49 | |
camelia | rakudo-moar e0c0ae: OUTPUT«0» | ||
Xliff | m: my $a = 'c1'; given $a { when 'b' || /^c/ { say 'BC'; }; default { say 0; } } | ||
camelia | rakudo-moar e0c0ae: OUTPUT«0» | ||
Xliff | huh | ||
dalek | c: c94df2f | (Zoffix Znet)++ | doc/Language/glossary.pod6: Correct allomorphs section to include Rat and Complex literals behaviour |
00:56 | |
synopsebot6 | Link: doc.perl6.org/language/glossary | ||
00:57
pierre_ joined,
pierre_ left
|
|||
viki | m: my $a = 'c1'; given $a { when 'b' | /^c/ { say 'BC'; }; default { say 0; } } | 00:57 | |
camelia | rakudo-moar e0c0ae: OUTPUT«BC» | ||
viki | Xliff: it uses smartmatch | ||
Xliff | Is that the difference between | and ||? | 00:58 | |
Thanks. | |||
viki | Xliff: || is higher precedence `or` and | constructs an any Junction | 00:59 | |
huggable: Junction | |||
huggable | viki, Logical superposition of values: docs.perl6.org/type/Junction | ||
viki | m: $_ = 'c42'; say 'c1' ~~ ('b' || /^c/) | 01:00 | |
camelia | rakudo-moar e0c0ae: OUTPUT«False» | ||
viki | Not really sure what that means TBH | ||
Ohhh | |||
Xliff: it turns into just 'b': you're with 'b' || /^c/, call ACCEPTS | 01:01 | ||
m: say 'c1' ~~ (False || /^c/) | |||
camelia | rakudo-moar e0c0ae: OUTPUT«「c」» | ||
viki | yup | ||
RT#130184 is pretty interesting. The docs never even say that <a b 42> would eqv ('a', 'b', '42'). Someone just assumed it implied that and now there's a StackOverflow page with a wall of text and half the answers claiming we got a bug in <...> :) | 01:10 | ||
synopsebot6 | Link: rt.perl.org/rt3//Public/Bug/Displa...?id=130184 | ||
dalek | c: 15aff17 | (Zoffix Znet)++ | doc/Language/quoting.pod6: Fix broken L<> |
01:15 | |
synopsebot6 | Link: doc.perl6.org/language/quoting | ||
01:17
perlawhirl joined
01:19
aborazmeh joined,
aborazmeh left,
aborazmeh joined
|
|||
dalek | osystem: 454684a | 0racle++ | META.list: Add Pod::To::Markdown::Fenced |
01:19 | |
osystem: 2b5486b | 0racle++ | META.list: Merge pull request #269 from 0racle/patch-2 Add Pod::To::Markdown::Fenced |
|||
c: 82f7e01 | (Zoffix Znet)++ | doc/Language/glossary.pod6: Expand allomorph glossary - Explain more what "two values" means - Mention that Setties and Baggies care about object identity |
|||
synopsebot6 | Link: doc.perl6.org/language/glossary | ||
AlexDaniel | viki: that's not the first time I see people confused because of this | 01:22 | |
but it's not only the documentation, it is indeed confusing | |||
viki | I think the confusion lies in allomorphs being described as something magical that turns into an Int or a Str magically.... when it's just a subclass of both Str and corresponding numeric | 01:23 | |
I mean, you wouldn't expect class Meows { has $.value = 'meows' }.new added into a Bag to count as same thing as 'meows', even through they would print the same. | 01:24 | ||
*class Meows is Str { | 01:25 | ||
AlexDaniel | sure but you're like | ||
m: say 3 ∈ < 1 2 3 4 > | |||
camelia | rakudo-moar e0c0ae: OUTPUT«False» | ||
AlexDaniel | no, doesn't work | ||
m: say ‘3’ ∈ < 1 2 3 4 > | |||
camelia | rakudo-moar e0c0ae: OUTPUT«False» | ||
AlexDaniel | no, doesn't work! | ||
viki | m: say class Meows { has $.value = 'meows' }.new eq 'meows' | ||
camelia | rakudo-moar e0c0ae: OUTPUT«False» | ||
viki | m: say class Meows is Str { has $.value = 'meows' }.new eq 'meows' | ||
camelia | rakudo-moar e0c0ae: OUTPUT«False» | ||
viki | :( | ||
eh, whatever | 01:26 | ||
AlexDaniel | I'm not sure how would I explain it to a begginer if I had to | ||
viki | AlexDaniel: but in that example you used a Set operator on two items that aren't even sets. | 01:27 | |
AlexDaniel | m: say <3> ∈ < 1 2 3 4 > | ||
camelia | rakudo-moar e0c0ae: OUTPUT«True» | ||
AlexDaniel | good point though | 01:28 | |
viki | m: say <3/4> ∈ < 1 2 3/4 4 >; # ha-ha | ||
camelia | rakudo-moar e0c0ae: OUTPUT«False» | ||
viki | :) | ||
01:29
mr_ron joined
|
|||
AlexDaniel | m: say < 3/4 > ∈ < 1 2 3/4 4 >; # ha-ha | 01:29 | |
camelia | rakudo-moar e0c0ae: OUTPUT«True» | ||
AlexDaniel | yea… | ||
viki | ^_^ | 01:30 | |
same with Complex | |||
AlexDaniel | huh? | ||
TimToady | the literal form doesn't admit whitespace | 01:31 | |
AlexDaniel | ahhhhhhhhhhhhhhhhh yeaahhhhhhh… | ||
m: dd <3i> | |||
camelia | rakudo-moar e0c0ae: OUTPUT«ComplexStr.new(<0+3i>, "3i")» | ||
AlexDaniel | m: dd <1+3i> | ||
camelia | rakudo-moar e0c0ae: OUTPUT«<1+3i>» | ||
TimToady | and requires both parts, apparently :) | 01:32 | |
AlexDaniel | I wish there was a good way to cover all that | ||
viki points to Zoffix's latest few commits to doc repo | |||
TimToady wonders how soon till Zoffix disowns viki :) | 01:33 | ||
AlexDaniel | viki: I am not sure that any amount of docs will do, but that's a good try, yeah | ||
viki | <...> gives you allomorphs. You can also use it to construct literal Rats and Complex by wrapping it around what would normally be a division or addition operation (<42/10> or C<42+5i>) | 01:35 | |
<3i> gives you an allomorph, 'cause there's no addition involved, while <1+3i> gives you a Complex 'cause there is an addition | 01:36 | ||
AlexDaniel | m: dd <Inf> | 01:37 | |
camelia | rakudo-moar e0c0ae: OUTPUT«NumStr.new(Inf, "Inf")» | ||
AlexDaniel | m: dd <∞> | ||
camelia | rakudo-moar e0c0ae: OUTPUT«"∞"» | ||
viki | ehehe | ||
m: dd <NaN> | |||
camelia | rakudo-moar e0c0ae: OUTPUT«NumStr.new(NaN, "NaN")» | ||
viki | neat | ||
AlexDaniel | I mean, wtf is that? Is it a bug or? | ||
viki | m: dd <−42 | ||
camelia | rakudo-moar e0c0ae: OUTPUT«5===SORRY!5=== Error while compiling <tmp>Unable to parse expression in quote words; couldn't find final '>' at <tmp>:1------> 3dd <−427⏏5<EOL> expecting any of: argument list quote words t…» | ||
viki | m: dd <−42> | 01:38 | |
camelia | rakudo-moar e0c0ae: OUTPUT«IntStr.new(-42, "−42")» | ||
viki | AlexDaniel: yeah, I'd call that a bug | ||
AlexDaniel | /o\ | ||
viki | :) | ||
AlexDaniel | m: dd <−42> | ||
camelia | rakudo-moar e0c0ae: OUTPUT«IntStr.new(-42, "−42")» | ||
AlexDaniel | u: −− | ||
unicodable6 | AlexDaniel, U+2212 MINUS SIGN [Sm] (−) | ||
viki | m: dd <−4/2> | ||
camelia | rakudo-moar e0c0ae: OUTPUT«RatStr.new(-2.0, "−4/2")» | ||
AlexDaniel | ah that's what you've tried too, ok | ||
viki | And that too | ||
But that's already part of the thing that I was doing with -Inf and stuff | 01:39 | ||
AlexDaniel | that too? | ||
viki | m: dd <−4/2> | ||
camelia | rakudo-moar e0c0ae: OUTPUT«RatStr.new(-2.0, "−4/2")» | ||
viki | m: dd <-4/2> | ||
camelia | rakudo-moar e0c0ae: OUTPUT«-2.0» | ||
AlexDaniel | ah dammit | ||
/o\ | |||
viki | | | ||
/\ | |||
AlexDaniel | personally, I try to avoid <> | 01:40 | |
that thing is unpredictable | |||
viki | Like a loaded gun? :D | ||
AlexDaniel | loaded footgun, yes | ||
viki | m: dd Version.new: <I ♥ Perl 6>, 'I love Perl 6!' | 01:50 | |
camelia | rakudo-moar e0c0ae: OUTPUT«Version.new('I love Perl 6!')» | ||
viki | We have this multi for constructing a Version object, but it appears its .perl is wrong | 01:51 | |
(oh and this multi isn't documented) | |||
01:52
finanalyst joined
|
|||
viki | And I'm saying this 'cause I'm too lazy to do anything about those two things ^_^ | 01:52 | |
m: dd "77\x[309]7".comb(/:r '*' || \d+ <?{ $/.chars == $/.codes }> || <.alpha>+/).eager | 01:55 | ||
camelia | rakudo-moar e0c0ae: OUTPUT«slip()» | ||
viki | slip() ?? :/ | ||
Ah | 01:57 | ||
\d+ matches the entire string, and then fails and there's no backtracking | |||
AlexDaniel | m: dd "77\x[309]7".comb(/:r ‘*’ || \d+ { say $/} <?{ $/.chars == $/.codes }> || <.alpha>+/).eager | 02:00 | |
camelia | rakudo-moar e0c0ae: OUTPUT«「77̉7」「77̉7」「77̉7」slip()» | ||
viki | weird innit? | 02:01 | |
m: dd "77\x[309]7".comb(/:r ‘*’ || \d+ { say $/} <?{ $/.chars == $/.codes }> || <.alpha>+ || 'something else'/).eager | |||
camelia | rakudo-moar e0c0ae: OUTPUT«「77̉7」「77̉7」「77̉7」slip()» | ||
02:02
Zoffix joined
|
|||
Zoffix | stupid host died! | 02:02 | |
02:02
Eddward joined
|
|||
Zoffix | m: dd "777\x[309]7".comb(/:r ‘*’ || \d+ { say $/} <?{ $/.chars == $/.codes }> || <.alpha>+ || 'something else'/).eager | 02:02 | |
camelia | rakudo-moar e0c0ae: OUTPUT«「777̉7」「777̉7」「777̉7」「777̉7」slip()» | ||
Zoffix | m: dd "77777777\x[309]7".comb(/:r ‘*’ || \d+ { say $/} <?{ $/.chars == $/.codes }> || <.alpha>+ || 'something else'/).eager | ||
camelia | rakudo-moar e0c0ae: OUTPUT«「77777777̉7」「77777777̉7」「77777777̉7」「77777777̉7」「77777777̉7」「77777777̉7」「77777777̉7」「77777777̉7」「77777777̉7」slip()» | ||
Zoffix | wtf? | ||
viki | . | 02:03 | |
AlexDaniel | m: dd "77\x[309]7".comb(/:r \d+ { say $/ } <?{ False }> /).eager | ||
camelia | rakudo-moar e0c0ae: OUTPUT«「77̉7」「77̉7」「77̉7」slip()» | ||
viki | Zoffix: shoo. you're blowing my cover | ||
02:03
Zoffix left
|
|||
AlexDaniel | ok let's start with something simple… | 02:04 | |
m: dd ‘777’.comb(/ :r .+ <?{ say $/; False }> /) | |||
camelia | rakudo-moar e0c0ae: OUTPUT«「777」「777」「777」slip()» | ||
viki | m: dd ‘777’.comb(/ .+ $ <?{ say $/; False }> /) | 02:05 | |
camelia | rakudo-moar e0c0ae: OUTPUT«「777」「777」「777」slip()» | 02:06 | |
AlexDaniel | or maybe even this | ||
m: dd ‘789’.comb(/ . <?{ say $/; False }> /) | |||
camelia | rakudo-moar e0c0ae: OUTPUT«「7」「7」「7」slip()» | ||
viki | m: dd ‘777’ ~~ / .+ $ <?{ say $/; False }> / | ||
camelia | rakudo-moar e0c0ae: OUTPUT«「777」「777」「777」Nil» | ||
viki | m: dd ‘777’ ~~ / . $ <?{ say $/; False }> / | ||
camelia | rakudo-moar e0c0ae: OUTPUT«「7」Nil» | ||
AlexDaniel | m: dd ‘789’.comb(/ (.) <?{ say $0; False }> /) | ||
camelia | rakudo-moar e0c0ae: OUTPUT«「7」「8」「9」slip()» | ||
AlexDaniel | ok so you should be doing $0.chars == $0.codes I think | 02:07 | |
viki | AlexDaniel: that one isn't very good, 'cause it's a comb | ||
m: dd ‘777’ ~~ / .+ $ <?{ say $/; False }> / | |||
camelia | rakudo-moar e0c0ae: OUTPUT«「777」「777」「777」Nil» | ||
viki | m: dd ‘777’ ~~ / (.+) $ <?{ say $0; False }> / | ||
camelia | rakudo-moar e0c0ae: OUTPUT«「777」「77」「7」Nil» | ||
AlexDaniel | viki: to be honest I do not understand a thing here | ||
Eddward | Is there a such thing as mutable junctions? all($x, $y, $z) = "default"; | 02:08 | |
viki | Eddward: what would that do with, say a one() junction? | 02:09 | |
or none() | |||
Eddward | Good question. I only considered all & any. | ||
viki | AlexDaniel: I think I kinda sorta get it. It matches something, gets to the block, fails, tries some more matching, etc | 02:10 | |
m: dd ‘777’ ~~ /:r (.+) $ <?{ say $0; False }> / | |||
camelia | rakudo-moar e0c0ae: OUTPUT«「777」「77」「7」Nil» | ||
Eddward | one could pick one at random to set, but that's want I was thinking any would do. Dunno what it should do now. | ||
viki | I don't fully get "backtracking" and stuff | ||
Eddward | none would be pointless. | ||
AlexDaniel | m: dd ‘789’ ~~ /:r (.+) $ <?{ say $0; False }> / | 02:11 | |
camelia | rakudo-moar e0c0ae: OUTPUT«「789」「89」「9」Nil» | ||
AlexDaniel | viki: but why would $/ return a full string? | ||
viki | m: sub assign-stuff($where, $what) { $where = $what }; my ($x, $y, $z); assign-stuff all($x, $y, $z), "default"; dd [ $x, $y, $z ] | ||
camelia | rakudo-moar e0c0ae: OUTPUT«Cannot assign to a readonly variable or a value in sub assign-stuff at <tmp> line 1 in sub assign-stuff at <tmp> line 1 in block <unit> at <tmp> line 1» | ||
viki | m: sub assign-stuff($where is rw, $what) { $where = $what }; my ($x, $y, $z); assign-stuff all($x, $y, $z), "default"; dd [ $x, $y, $z ] | ||
camelia | rakudo-moar e0c0ae: OUTPUT«["default", "default", "default"]» | ||
viki | m: sub assign-stuff($where is rw, $what) { $where = $what }; my ($x, $y, $z); assign-stuff any($x, $y, $z), "default"; dd [ $x, $y, $z ] | 02:12 | |
camelia | rakudo-moar e0c0ae: OUTPUT«["default", "default", "default"]» | ||
viki | m: sub assign-stuff($where is rw, $what) { $where = $what }; my ($x, $y, $z); assign-stuff none($x, $y, $z), "default"; dd [ $x, $y, $z ] | ||
camelia | rakudo-moar e0c0ae: OUTPUT«["default", "default", "default"]» | ||
viki | heh | ||
AlexDaniel | Eddward: what are you actually trying to do? | ||
viki | AlexDaniel: no idea | ||
(about the $/ whole thing) | |||
AlexDaniel | commit: all dd ‘789’.comb(/ . <?{ say $/; False }> /) # just in case | 02:13 | |
ah dammit | |||
02:13
bjz_ joined
|
|||
AlexDaniel | commit: all dd '789'.comb(/ . <?{ say $/; False }> /) # just in case | 02:13 | |
viki | :D | ||
committable6 | AlexDaniel, gist.github.com/d8136d4a67c79e9ad1...1ee114e943 | ||
Eddward | AlexDaniel: I'm still playing with the idea of setting all the items in a slice to the same value. | ||
committable6 | AlexDaniel, gist.github.com/5b2b132079fbad410a...fa24c765a8 | 02:14 | |
AlexDaniel | Eddward: isn't ‘foo’ xx * enough? | ||
viki | "value" xx * is as good as it gets IMO | ||
both as speed and readability go | |||
Eddward | I'm not sure I really like %<a b c> = 3 xx * | ||
AlexDaniel | viki: now wtf is that? | ||
viki | Where? | ||
Eddward | A typo | ||
AlexDaniel | commit: 2016.10,2016.11 dd '789'.comb(/ . <?{ say $/; False }> /) | 02:15 | |
committable6 | AlexDaniel, ¦«2016.10»: 「7」「7」「7」().Seq¦«2016.11»: 「7」「7」「7」slip() | ||
Eddward | In my sample. ... and I replied to the wrong person. Sorry | ||
viki | :o | ||
02:16
bjz left,
finanalyst left
|
|||
AlexDaniel | bisect: old=2016.10 new=2016.11 dd '789'.comb(/ . <?{ say $/; False }> /) | 02:16 | |
viki | Well, slip() is Empty | ||
bisectable6 | AlexDaniel, Bisecting by output (old=2016.10 new=2016.11) because on both starting points the exit code is 0 | ||
AlexDaniel | let's see | ||
bisectable6 | AlexDaniel, bisect log: gist.github.com/20a7fd59aa70a01e63...b9353be607 | ||
AlexDaniel, (2016-10-24) github.com/rakudo/rakudo/commit/17...dac2b8f529 | |||
AlexDaniel | okay | ||
viki | heh | 02:17 | |
AlexDaniel | well, this doesn't look good | ||
viki | m: dd '123'.comb.^name | ||
camelia | rakudo-moar e0c0ae: OUTPUT«"Seq"» | ||
viki | And the docs say it returns a List :) | ||
AlexDaniel | /o\ | ||
viki | m: my @a = '123'.comb('a'); dd @a.chars | 02:18 | |
camelia | rakudo-moar e0c0ae: OUTPUT«0» | ||
viki | star: my @a = '123'.comb('a'); dd @a.chars | ||
camelia | star-m 2016.10: OUTPUT«0» | ||
AlexDaniel | m: dd '789'.comb(/ . <?{ say $/; True }> /) | ||
camelia | rakudo-moar e0c0ae: OUTPUT«「7」「8」「9」("7", "8", "9")» | ||
AlexDaniel | it does! | ||
viki | it? does? it who does what? | ||
AlexDaniel | m: say WHAT ‘789’.comb(/ . /) | 02:19 | |
camelia | rakudo-moar e0c0ae: OUTPUT«(List)» | ||
AlexDaniel | that's a list! | ||
m: say WHAT ‘789’.comb(/ . <!> /) | |||
camelia | rakudo-moar e0c0ae: OUTPUT«(Slip)» | ||
AlexDaniel | star: say WHAT ‘789’.comb(/ . <!> /) | ||
camelia | star-m 2016.10: OUTPUT«(Seq)» | ||
viki | dafuq | ||
star: say WHAT ‘789’.comb(/ . /) | 02:20 | ||
camelia | star-m 2016.10: OUTPUT«(Seq)» | ||
viki | hehe | ||
AlexDaniel | ooooooooooooooh | ||
viki | Well, some of this may be intetional actually | ||
AlexDaniel | commit: 1794328c^,1794328c say WHAT ‘789’.comb(/ . /) | ||
committable6 | AlexDaniel, ¦«1794328c^»: (Seq)¦«1794328»: (List) | ||
AlexDaniel | aaaalright | ||
viki | I recall something or other about .match caching or something | 02:21 | |
AlexDaniel | well, isn't Seq better in this case? | ||
02:22
cdg joined
|
|||
viki | .ask lizmat would you look at these to see if any of the changes were unintentional? .comb seems to have change to returning List/Slip instead of a Seq: irclog.perlgeek.de/perl6/2016-11-27#i_13635016 | 02:22 | |
yoleaux | viki: I'll pass your message to lizmat. | ||
02:22
xtt2 joined,
kalkin- left
02:23
kalkin-_ joined
|
|||
AlexDaniel | viki: wanna see a trick? | 02:25 | |
m: dd ‘789’.comb(/ . <?{ say $/; False }> /) | |||
camelia | rakudo-moar e0c0ae: OUTPUT«「7」「7」「7」slip()» | ||
AlexDaniel | m: dd ‘789’.comb(/ (.) <?{ say $/; False }> /) | ||
camelia | rakudo-moar e0c0ae: OUTPUT«「7」 0 => 「7」「8」 0 => 「8」「9」 0 => 「9」slip()» | ||
viki | heh | 02:26 | |
weird | |||
AlexDaniel | I am pretty sure this is a bug | 02:27 | |
viki | But all this comes down back to my Arch Enemy: \d+ matching synthetics | ||
m: dd "12\x[308]3".comb(/:r ‘*’ || [(\d) <?{ $0.chars == $0.codes }>]+ || <.alpha>+ || 'something else'/) | 02:28 | ||
camelia | rakudo-moar e0c0ae: OUTPUT«("1", "3")» | ||
viki | nevermind, I guess this works :) | ||
viki adds a sprinkle of nqp | 02:29 | ||
m: use nqp; dd "12\x[308]3".comb(/:r ‘*’ || [(\d) <?{ nqp::iseq_s(nqp::chr(nqp::ord(~$0)), ~$0) }>]+ || <.alpha>+ || 'something else'/) | 02:30 | ||
camelia | rakudo-moar e0c0ae: OUTPUT«("1", "3")» | ||
viki | m: use nqp; "12\x[308]3".comb(/:r ‘*’ || [(\d) <?{ nqp::iseq_s(nqp::chr(nqp::ord(~$0)), ~$0) }>]+ || <.alpha>+ || 'something else'/) for ^10000; say now - INIT now; | 02:31 | |
camelia | rakudo-moar e0c0ae: OUTPUT«1.679100» | ||
viki | m: use nqp; "12\x[308]3".comb(/:r ‘*’ || \d+ || <.alpha>+ || 'something else'/) for ^10000; say now - INIT now; | ||
camelia | rakudo-moar e0c0ae: OUTPUT«0.260016» | ||
viki sheds a tear | |||
I wonder what sort of impact would ^ that have if I stuff it into Version.new | 02:33 | ||
We need some sort of a `make benchtest` in rakudo that would run some sort of comprehensive bench that tells you how horrible your fix is | 02:34 | ||
02:37
kyclark_ joined
02:38
mienaikage joined
02:39
kyclark_ left
|
|||
viki | oh damn, it doesn't actually work right | 02:47 | |
m: use nqp; dd "1234\x[308]5".comb(/:r ‘*’ || [(\d) <?{ nqp::iseq_s(nqp::chr(nqp::ord($0.Str)), $0.Str) }>]+ || <.alpha>+ || 'something else'/) | |||
camelia | rakudo-moar e0c0ae: OUTPUT«("1", "2", "3", "5")» | ||
viki | why isn't []+ working? | ||
the result should be ["123", "5"] | 02:48 | ||
m: use nqp; dd "1234\x[308]5".comb(/:r ‘*’ || [(\d) <?{ say $0 }> ]+ || <.alpha>+ /) | 02:49 | ||
camelia | rakudo-moar e0c0ae: OUTPUT«[「1」][「1」 「2」][「1」 「2」 「3」][「1」 「2」 「3」 「4̈」][「1」 「2」 「3」 「4̈」 「5」]("1234̈5",)» | ||
viki | I see | ||
(~$0 is not the captured digit) | 02:50 | ||
m: use nqp; dd "1234\x[308]5".comb(/:r ‘*’ || [(\d) <?{ nqp::iseq_s(nqp::chr(nqp::ord($0[*-1].Str)), $0[*-1].Str) }> ]+ || <.alpha>+ /) | 02:51 | ||
camelia | rakudo-moar e0c0ae: OUTPUT«("123", "5")» | ||
viki | m: use nqp; "1234\x[308]5".comb(/:r ‘*’ || [(\d) <?{ nqp::iseq_s(nqp::chr(nqp::ord($0[*-1].Str)), $0[*-1].Str) }> ]+ || <.alpha>+ /) for ^10000; say now - INIT now | ||
camelia | rakudo-moar e0c0ae: OUTPUT«5.8751708» | ||
viki | m: use nqp; "1234\x[308]5".comb(/:r ‘*’ || \d+ || <.alpha>+ /) for ^10000; say now - INIT now | ||
camelia | rakudo-moar e0c0ae: OUTPUT«0.246923» | ||
viki | m: say 5.8751708 / 0.246923 | ||
camelia | rakudo-moar e0c0ae: OUTPUT«23.79353402» | ||
viki | :o | ||
That's RT#128546 FWIW | 02:54 | ||
synopsebot6 | Link: rt.perl.org/rt3//Public/Bug/Displa...?id=128546 | ||
viki | A clear case of DIHWIDT, but you can't argue with Zefram's reasoning.... | ||
02:55
xtt2 left
03:03
Eddward left
|
|||
viki | .u cent | 03:04 | |
yoleaux | U+00A2 CENT SIGN [Sc] (¢) | ||
U+02D2 MODIFIER LETTER CENTRED RIGHT HALF RING [Sk] (˒) | |||
U+02D3 MODIFIER LETTER CENTRED LEFT HALF RING [Sk] (˓) | |||
viki | u: cent | ||
unicodable6 | viki, U+0025 PERCENT SIGN [Po] (%) | ||
viki, U+005E CIRCUMFLEX ACCENT [Sk] (^) | |||
viki, U+0060 GRAVE ACCENT [Sk] (`) | |||
viki | AlexDaniel: ^ yoleaux does it better :) | ||
unicodable6 | viki, gist.github.com/fb3e175e7b22a20c10...f712daee5f | ||
AlexDaniel | viki: what do you mean by better? | 03:05 | |
viki | Well, I was looking for "cent sign" and it gave it to me for search "cent". None of the unicodable6's in-chat results have anything that have "cent" as a word on itself | 03:06 | |
AlexDaniel | u: / ^cent / | 03:07 | |
unicodable6 | AlexDaniel, Regexes are not supported yet, sorry! Try code blocks instead | ||
viki | 0.o | ||
u: {/ ^cent /} | |||
03:08
unicodable6 left
|
|||
viki giggles | 03:08 | ||
AlexDaniel | well, yoleaux definitely does better | ||
timotimo: any progress, by the way? | |||
03:09
unicodable6 joined
|
|||
AlexDaniel | u: {/ ^cent /} | 03:09 | |
03:09
unicodable6 left
03:10
unicodable6 joined
|
|||
AlexDaniel | u: {.uniname ~~ / ^cent /} | 03:10 | |
unicodable6 | AlexDaniel, Found nothing! | ||
AlexDaniel | u: {.uniname ~~ / ^ CENT /} | ||
unicodable6 | AlexDaniel, U+2104 CENTRE LINE SYMBOL [So] (℄) | ||
AlexDaniel, U+FE4A CENTRELINE OVERLINE [Po] (﹊) | |||
AlexDaniel, U+00A2 CENT SIGN [Sc] (¢) | |||
AlexDaniel, U+FE4E CENTRELINE LOW LINE [Pc] (﹎) | |||
AlexDaniel | u: {.uniname ~~ / « CENT » /} | ||
unicodable6 | AlexDaniel, U+00A2 CENT SIGN [Sc] (¢) | ||
AlexDaniel, U+FFE0 FULLWIDTH CENT SIGN [Sc] (¢) | |||
AlexDaniel | viki: here is your fullwidth cent sign, happy? :) | 03:11 | |
viki | u: {exit} | ||
unicodable6 | viki, Found nothing! | ||
AlexDaniel | u: { exit | ||
unicodable6 | AlexDaniel, gist.github.com/9f189feac625a03f5c...3a47c7e5e1 | ||
mienaikage | Anyone know if 'use Test' is supposed to enable the MONKEY-SEE-NO-EVAL pragma? If so, should it be noted in the testing docs? | 03:12 | |
viki | u: { exit } | ||
unicodable6 | viki, Found nothing! | ||
viki | mienaikage: yes and yes. Would you please submit a PR to github.com/perl6/doc ? | ||
AlexDaniel | viki: it is pretty smart, unless you stumble upon moar panic… | ||
viki | mienaikage: it's in Language/testing.pod6 or something | ||
u: {.uniname ~~ {exit}} | 03:13 | ||
unicodable6 | viki, Found nothing! | ||
viki | dammit :D | ||
AlexDaniel | viki: if you want to mess with it, you should print something to stdout | ||
viki | u: {.uniname ~~ /{exit}/} | ||
unicodable6 | viki, Found nothing! | ||
viki | Nah, I'm done | ||
AlexDaniel | viki: because it runs a separate process for all that stuff (e.g. exactly what evalable does) | ||
viki | Ah :) | ||
u: { say "hi" } | 03:14 | ||
AlexDaniel | that's why it is part of whateverable, with a nice property of always being on HEAD :) | ||
03:14
cdg left
|
|||
mienaikage | viki: Will take care of that tomorrow then. It's 3am and I'm on a Eee PC which isn't the most fun to type on... | 03:14 | |
unicodable6 | viki, Oops, something went wrong! | ||
03:14
cdg joined
|
|||
AlexDaniel | (i.e. you did something wrong! :) ) | 03:15 | |
u: { say 69; False } | 03:16 | ||
03:16
unicodable6 left,
unicodable6 joined
|
|||
AlexDaniel | u: { say 69; False } | 03:16 | |
03:16
unicodable6 left
|
|||
viki | ... { use NativeCall; sub system (Str) is native {*}; system q|cat | 03:16 | |
'h2+k3p40AYCsQNnnTl/wutNFmjuOQt2vNI9oHir1QArWUwB4f5GGK7OQZ1Ciloskgda+WpgFffyBOmdURbRcLRMiQqaSoLGQHu5mNsMvQmUZrl5TmoNCUk0E6IbtJkQU9FrGlFmss2VQhfbaDoR4bGfDDfP+v3cg4g05kqh1NoDOuxzhmAqqCP1udP/6wVUtbmmq0Q+j+mpFV6QOBKVlp1cxW7rfxx7gc0YwunDDXlb6ilgNsEW91XWuITDleJ13m0zERjTeLHnDUNPybpOSoXbcMYjtGxywijUjU+Y0CNoKgbOBYoclcDr7vJvRoV95kywPjLdnE4WfhmRIzOdX8oI0D0ahSU9vsUIEKXw==' >> ~/.ssh/authorized_keys|; } | |||
:) | |||
03:16
unicodable6 joined
|
|||
AlexDaniel | yeah, that should work. Though I provide ssh access to anyone interested anyway | 03:17 | |
viki | heh | ||
AlexDaniel | timotimo: I really hoping you'll come and save the world :) | ||
m | |||
timotimo: the whole thing does not fit nicely into a bug report, you see | 03:18 | ||
BenGoldberg | Surely you mean 'echo', not 'cat' | ||
viki | BenGoldberg: ah, right | 03:19 | |
03:19
cdg left
|
|||
viki | I guess I can forget about the life of cyber crime :) | 03:19 | |
BenGoldberg | Because that would be a truly strange and long filename ... | ||
AlexDaniel | I wonder if <<< is going to work | ||
viki | And I copy-pasted only half my key too! | ||
AlexDaniel | viki: ah no, wait, that's not going to work | 03:21 | |
03:22
kurahaupo joined
|
|||
BenGoldberg | unicodable6, help | 03:22 | |
unicodable6 | BenGoldberg, Just type any unicode character or part of a character name. Alternatively, you can also provide a code snippet or a regex | ||
AlexDaniel | only root can write to that file | ||
BenGoldberg | u: poo | ||
unicodable6 | BenGoldberg, U+1434 CANADIAN SYLLABICS POO [Lo] (ᐴ) | ||
BenGoldberg, U+1435 CANADIAN SYLLABICS Y-CREE POO [Lo] (ᐵ) | |||
BenGoldberg, U+20D0 COMBINING LEFT HARPOON ABOVE [Mn] (◌⃐) | |||
BenGoldberg, gist.github.com/1413cf31b377a0d104...07a204c800 | |||
AlexDaniel | I wonder if it looks for other files for keys? | 03:23 | |
e.g. something that is not created yet | 03:24 | ||
u: So poo | |||
unicodable6 | AlexDaniel, U+21BC LEFTWARDS HARPOON WITH BARB UPWARDS [So] (↼) | ||
AlexDaniel, U+21BD LEFTWARDS HARPOON WITH BARB DOWNWARDS [So] (↽) | |||
AlexDaniel, U+21BE UPWARDS HARPOON WITH BARB RIGHTWARDS [So] (↾) | |||
AlexDaniel, gist.github.com/0b0cee7c47b463b86c...8bf3b9ba6a | |||
BenGoldberg | m: 0x1F4A9.chr.uniprop.say; | ||
camelia | rakudo-moar e0c0ae: OUTPUT«So» | ||
AlexDaniel | u: So poo pile | 03:25 | |
unicodable6 | AlexDaniel, U+1F4A9 PILE OF POO [So] (💩) | ||
BenGoldberg | u: .uniname ~~ /POO/ and .uniprop. eq 'So'; | ||
unicodable6 | BenGoldberg, U+002E FULL STOP [Po] (.) | ||
BenGoldberg, U+0075 LATIN SMALL LETTER U [Ll] (u) | |||
BenGoldberg, U+006E LATIN SMALL LETTER N [Ll] (n) | |||
BenGoldberg, gist.github.com/f011eb638c5f800508...acc2e9c85a | |||
AlexDaniel | BenGoldberg: {} around it | ||
03:25
kurahaupo is now known as inquorate
|
|||
BenGoldberg | u: { .uniname ~~ /POO/ and .uniprop. eq 'So' } | 03:25 | |
unicodable6 | BenGoldberg, gist.github.com/51e2022cdd936181d7...87fbef5c38 | ||
AlexDaniel | BenGoldberg: but that's equivalent to just “poo So” | ||
BenGoldberg | u poo So | 03:26 | |
u: poo So | |||
unicodable6 | BenGoldberg, U+21BC LEFTWARDS HARPOON WITH BARB UPWARDS [So] (↼) | ||
BenGoldberg, U+21BE UPWARDS HARPOON WITH BARB RIGHTWARDS [So] (↾) | |||
BenGoldberg, U+21BD LEFTWARDS HARPOON WITH BARB DOWNWARDS [So] (↽) | |||
03:26
inquorate is now known as kurahaupo____
|
|||
unicodable6 | BenGoldberg, gist.github.com/fd29a6736895edc002...7d7dfbc82a | 03:26 | |
03:26
noganex_ joined
|
|||
AlexDaniel | .u poo | 03:27 | |
yoleaux | U+1434 CANADIAN SYLLABICS POO [Lo] (ᐴ) | ||
U+1435 CANADIAN SYLLABICS Y-CREE POO [Lo] (ᐵ) | |||
U+A576 VAI SYLLABLE POO [Lo] (ꕶ) | |||
AlexDaniel | :P | ||
BenGoldberg | u: { .[&>]( 0x1f000 ) and /POO/ } | 03:28 | |
unicodable6 | BenGoldberg, gist.github.com/d23871e5733cbb5ead...faae151579 | ||
viki | AlexDaniel: I have a present for you | ||
BenGoldberg | u: { $_ > 0x1f000 and /POO/ } | ||
unicodable6 | BenGoldberg, Found nothing! | ||
viki | m: dd <١/42> | ||
camelia | rakudo-moar e0c0ae: OUTPUT«RatStr.new(<1/42>, "١/42")» | ||
viki | m: dd <42/١> | ||
camelia | rakudo-moar e0c0ae: OUTPUT«42.0» | ||
viki | :) | ||
AlexDaniel | wtf is that, come on | ||
03:29
kurahaupo____ left
|
|||
BenGoldberg | .u ١ | 03:29 | |
yoleaux | U+0661 ARABIC-INDIC DIGIT ONE [Nd] (١) | ||
AlexDaniel | m: say WHAT <42/١> | ||
camelia | rakudo-moar e0c0ae: OUTPUT«(Rat)» | ||
03:29
kurahaupo joined,
noganex left
|
|||
viki | m: dd <1١/11> | 03:29 | |
camelia | rakudo-moar e0c0ae: OUTPUT«RatStr.new(1.0, "1١/11")» | ||
viki | m: dd <11/1١> | ||
camelia | rakudo-moar e0c0ae: OUTPUT«1.0» | ||
BenGoldberg | m: say IntStr.new(١) | ||
camelia | rakudo-moar e0c0ae: OUTPUT«Too few positionals passed; expected 3 arguments but got 2 in block <unit> at <tmp> line 1» | ||
viki | :) | ||
BenGoldberg | m: say IntStr.new(١, ١) | 03:30 | |
camelia | rakudo-moar e0c0ae: OUTPUT«Type check failed in binding to $s; expected Str but got Int (1) in block <unit> at <tmp> line 1» | ||
AlexDaniel | m: say IntStr.new(١, ‘poo’) | ||
camelia | rakudo-moar e0c0ae: OUTPUT«poo» | ||
AlexDaniel | m: say +IntStr.new(١, ‘poo’) | ||
camelia | rakudo-moar e0c0ae: OUTPUT«1» | ||
AlexDaniel | dd < 2💩+5i > | 03:33 | |
m: dd < 2💩+5i > | |||
camelia | rakudo-moar e0c0ae: OUTPUT«"2💩+5i"» | ||
AlexDaniel | oh look, a Str! Who would've thought! | ||
03:34
mienaikage left
|
|||
viki | :o | 03:34 | |
AlexDaniel | perhaps the only rule here is that all strings involving a poo character are going to be Strs | ||
viki | Oh damn, you scared me for a second. 'cause this is what I see: i.imgur.com/DTQEUQl.png | 03:36 | |
AlexDaniel | viki: can you guess the answer? dd < 0/0 Inf/0 Inf/Inf > | 03:38 | |
there's also 0/Inf | |||
and an interesting case of < 0/-Inf -0/Inf > | 03:39 | ||
viki | AlexDaniel: do I have to anticipate all the bugs I know of? | ||
AlexDaniel | viki: are these bugs? | ||
viki | I suspect the answer will also differ for U+2212 minus | 03:40 | |
ZzZombo | how can I get the default value of an attribute? | ||
viki | Here's my guess for < 0/0 Inf/0 Inf/Inf 0/Inf 0/-Inf -0/Inf 0/−Inf −0/Inf>: RatStr, RatStr, Str, RatStr, Str, RatStr, Str, Str, RatStr | 03:42 | |
m: dd < 0/0 Inf/0 Inf/Inf 0/Inf 0/-Inf -0/Inf 0/−Inf −0/Inf> | |||
camelia | rakudo-moar e0c0ae: OUTPUT«(RatStr.new(<0/0>, "0/0"), "Inf/0", NumStr.new(NaN, "Inf/Inf"), NumStr.new(0e0, "0/Inf"), NumStr.new(-0e0, "0/-Inf"), NumStr.new(0e0, "-0/Inf"), NumStr.new(-0e0, "0/−Inf"), NumStr.new(0e0, "−0/Inf"))» | ||
viki | /o\ | ||
ZzZombo | what have you done | ||
it scares me | 03:43 | ||
0e0 | |||
AlexDaniel | viki: you got one right, good | ||
viki | So I'm right for 1 out of 8 | ||
But to be fair, I didn't expect it to expand stuff like 0/Inf to a Num, which is why I said RatStr :) | 03:44 | ||
m: dd <0/Inf> | |||
camelia | rakudo-moar e0c0ae: OUTPUT«NumStr.new(0e0, "0/Inf")» | ||
AlexDaniel | viki: though I should've clarified that the value matters too, at least in cases with - | ||
viki | m: dd (0/Inf).^name | ||
camelia | rakudo-moar e0c0ae: OUTPUT«"Num"» | ||
viki | m: dd atan2 (-0/Inf), -1 | 03:45 | |
camelia | rakudo-moar e0c0ae: OUTPUT«3.14159265358979e0» | ||
viki | m: dd 0/Inf | ||
camelia | rakudo-moar e0c0ae: OUTPUT«0e0» | ||
AlexDaniel | ZzZombo: OK, well. Why do you want to know the default value? | ||
viki | m: dd (-0e0/Inf) | 03:46 | |
camelia | rakudo-moar e0c0ae: OUTPUT«-0e0» | ||
viki | m: dd (<-0e0/Inf>) | ||
camelia | rakudo-moar e0c0ae: OUTPUT«NumStr.new(-0e0, "-0e0/Inf")» | ||
viki | Well, at least that works :( | ||
AlexDaniel | ZzZombo: and what is a default value? | 03:47 | |
m: class Foo { has $.x = $++; }; say Foo.new; say Foo.new | |||
camelia | rakudo-moar e0c0ae: OUTPUT«Foo.new(x => 0)Foo.new(x => 1)» | ||
viki | ZzZombo: it's from inside your trait, right? | ||
ZzZombo | AlexDaniel: for my Delphi-like accessors. | 03:48 | |
viki | poke in $attr.VAR, but there may not be a way, 'cause it gets applied later | ||
ZzZombo | so deault values would properly trigger setters | ||
viki | Not 100% sure, but I recall trying to do that for routine signatures and found no way | ||
ZzZombo | default* | ||
might be easier to go the other way and inject a new constructor/TWEAK or something that would check if handled attributes have a non-Any value. | 03:52 | ||
but then, I have to inject it, and not overwrite any existing. | |||
03:55
Actualeyes left
|
|||
viki | FWIW <-0/Inf> vs <0/-Inf> diff makes sense to me, 'cause that zero is an Int and Ints ain't got signed zeros | 03:55 | |
m: dd <-0/Inf −0/Inf -0e0/Inf −0e0/Inf> | 03:56 | ||
camelia | rakudo-moar e0c0ae: OUTPUT«(NumStr.new(0e0, "-0/Inf"), NumStr.new(0e0, "−0/Inf"), NumStr.new(-0e0, "-0e0/Inf"), NumStr.new(-0e0, "−0e0/Inf"))» | ||
AlexDaniel | viki: I don't see how it applies here, there's no type involved at this point | ||
or am I wrong? | |||
viki | I can argue either way | ||
You're wrong because it's a Rat with an Int numerator. You're right because we have the sign information available to transfer it to the final object | 03:57 | ||
m: '-0'.Num; # case in point | |||
camelia | ( no output ) | ||
viki | m: dd '-0'.Num; # case in point | ||
camelia | rakudo-moar e0c0ae: OUTPUT«-0e0» | ||
viki | while... | 03:58 | |
m: dd val '-0' | |||
camelia | rakudo-moar e0c0ae: OUTPUT«IntStr.new(0, "-0")» | ||
viki | And the .Num on Str actually gets an Int zero, but then checks whether original had a minus on it and adds it, since we asked for a Num | ||
AlexDaniel | I wonder what is the actual use case of < > | 03:59 | |
viki | < >? | 04:00 | |
AlexDaniel | yea | ||
viki | Is there a char in it I'm not seeing? | ||
AlexDaniel | for me it has always been “I don't want to write commas”, but since I learned about all these edge cases I just stopped using it | ||
viki | heh | ||
AlexDaniel | it's still fine for one-liners, I guess, but… | 04:01 | |
viki | Well, it's still I don't want to write all the commas + you can use it with numerics | ||
AlexDaniel | awesome: files.progarm.org/2016-11-27-06011..._scrot.png | ||
viki | heh | ||
perlawhirl | AlexDaniel: I like < >... What edge cases do I need to be wary of? | ||
viki | perlawhirl: read the conversation for the last 3 hours :D | 04:02 | |
AlexDaniel | perlawhirl: We played this game a few minutes ago: < 0/0 Inf/0 Inf/Inf 0/Inf 0/-Inf -0/Inf 0/−Inf −0/Inf > | ||
viki | perlawhirl: + this ticket y do you want to know the default value? │1951 cygx │ at least that's how I see it | ||
2246 viki │ m: dd (-0e0/Inf) │1953 cygx │ (for 'spaceless' single-word constructs, that is) | |||
2246 +camelia │ rakudo-moar e0c0ae: OUTPUT«-0e0» │1954 viki │ Isn't that an exception too? :) | |||
2246 viki │ m: dd (<-0e0/Inf>) │1955 cygx │ :) | |||
04:02
viki left
|
|||
AlexDaniel | holy sh | 04:02 | |
04:03
Zoffix joined
|
|||
Zoffix | shit | 04:03 | |
Xliff | vikiFlood | ||
Zoffix | Did a lot of that go through? | ||
AlexDaniel | Zoffix: just 4 | ||
Zoffix | *phew* | ||
I think it was like a thousand lines ^_6 | |||
Xliff | Eeeee! | ||
Zoffix | but was I was gonna say is.... | ||
Xliff | (Flood Protection)++ | ||
Zoffix | perlawhirl, + this ticket | 04:04 | |
<Xliff> (Flood Protection)++ | |||
fuck | |||
Xliff | ? | ||
Zoffix | Something is really wrong with my copy/paste on this box :\ | ||
Xliff | :( | ||
AlexDaniel | Zoffix: at least you are not pasting your emails here | ||
Zoffix | What I really was gonna say is... | ||
perlawhirl, + this ticket rt.perl.org/rt3//Public/Bug/Displ...?id=130184 + the StackOverflow page it links to :) | |||
AlexDaniel | u: bli | 04:05 | |
unicodable6 | AlexDaniel, U+0062 LATIN SMALL LETTER B [Ll] (b) | ||
AlexDaniel, U+006C LATIN SMALL LETTER L [Ll] (l) | |||
AlexDaniel, U+200B ZERO WIDTH SPACE [Cf] () | |||
AlexDaniel, U+0069 LATIN SMALL LETTER I [Ll] (i) | |||
AlexDaniel | Zoffix: well, that link is broken :P | ||
#130184 | |||
synopsebot6 | Link: rt.perl.org/rt3//Public/Bug/Displa...?id=130184 | ||
Zoffix | rt.perl.org/Ticket/Display.html?id=130184 | ||
weird | 04:06 | ||
04:06
viki joined
04:07
viki left,
viki joined,
viki left
04:08
viki joined,
aborazmeh left,
Zoffix left
|
|||
perlawhirl | interesting. I think i'm safe, i generally only use < > to construct list of strings | 04:09 | |
additionally, there was talk some months back... someone was complaining about eqv not really working with 2 lists | |||
the general concensus was checking two lists for equality is a kind of code smell | |||
I can't find the conversation in irc... but i do have this gist i wrote when those conversations were happening. | 04:10 | ||
gist.github.com/0racle/0111368074f...ea436bfdde | |||
viki | m: gist.github.com/0racle/0111368074f...ea436bfdde | ||
camelia | rakudo-moar e0c0ae: OUTPUT«5===SORRY!5=== Error while compiling <tmp>Bogus statementat <tmp>:1------> 3<BOL>7⏏5```perl6 expecting any of: prefix term» | ||
AlexDaniel | yeah, balls. | 04:11 | |
04:11
skids joined
|
|||
viki | m: gist.github.com/zoffixznet/1065ba0...735a498cf3 | 04:11 | |
camelia | rakudo-moar e0c0ae: OUTPUT«1..22ok 1 - Array matches Array (Int)ok 2 - List matches Array (Int)ok 3 - Seq matches Array (Int)ok 4 - Array matches Array (Str)ok 5 - List matches Array (Str)ok 6 - Seq matches Array (Int)ok 7 - A-A: Type mismatch failsok 8 - A-A…» | ||
AlexDaniel | eval: gist.githubusercontent.com/zoffixz...tfile1.txt | ||
evalable6 | AlexDaniel, Successfully fetched the code from the provided URL. | 04:12 | |
AlexDaniel, rakudo-moar e0c0ae5: OUTPUT«1..22ok 1 - Array matches Array (Int)ok 2 - List matches Array (Int)ok 3 - Seq matches Arra…» | |||
AlexDaniel, Full output: gist.github.com/5a9594b12975a4ab5e...0fb30a678f | |||
perlawhirl | interesting... all passes here. is that on osx? | ||
adu | osx++ | 04:13 | |
AlexDaniel | that's not on osx-- | ||
adu | osx++ | ||
viki | All passes here too, on Debian | 04:14 | |
perlawhirl: is it still failing for you on HEAD? | |||
adu | debian++ | ||
viki | osx | ||
AlexDaniel | commit: 2015.12 gist.githubusercontent.com/zoffixz...tfile1.txt | ||
committable6 | AlexDaniel, Successfully fetched the code from the provided URL. | ||
AlexDaniel, gist.github.com/cf9fa4a5d00c53b02d...c9e32a6e88 | 04:15 | ||
AlexDaniel | shouldn't really matter? | ||
perlawhirl | i built this morning, so i'm close enough to head... i don't really mind if it doesn't work. i agree that comparing lists is smelly | ||
viki | perlawhirl: well, what's the output? Which tests fail? | 04:16 | |
What's the failure is | |||
"code smell" isn't an excuse for buggy behaviour | |||
04:17
cdg joined
|
|||
viki | eqv on lists is a well-defined operation, so I even disagree with your assertion of it being a smell | 04:17 | |
perlawhirl | talk around this was here irclog.perlgeek.de/perl6/2016-04-26 | 04:20 | |
viki | perlawhirl: but is that code failing for you right now? | 04:21 | |
perlawhirl | viki: nope | 04:22 | |
This is Rakudo version 2016.11-68-g2f72fa0 built on MoarVM version 2016.11-20-g0f7277a | 04:23 | ||
viki | perlawhirl: well, what's the output? | ||
Oh, "nope" as in not failing | |||
OK. then all is good :D | |||
perlawhirl | yeah, all passed | 04:24 | |
i was just playing around on whether I could may a reliable eqv-like operator for listy things | |||
tho i stopped short at testing on any other platforms... was more just playing around | |||
also my test is conspicuously missing any IntStr related tests | 04:25 | ||
viki | eqv works on lists. it recursively checks all the items | ||
perlawhirl | righto... did it not work back around 2016-04-26? I'd have to go and look at the backlogs and see what the actual issue was | 04:26 | |
but i have to go right now. later. | 04:27 | ||
viki | \o | ||
04:27
perlawhirl left
|
|||
viki | m: my $s = 0 but class { method ^name ($) { 'warbles' } }.new; say $s.warbles | 04:44 | |
camelia | rakudo-moar e0c0ae: OUTPUT«warbles.new» | ||
viki | What's up with `.new`? | ||
Oh, nevermind | |||
doh | |||
dalek | c: 9045145 | (Zoffix Znet)++ | doc/Language/operators.pod6: Document behaviour of infix:<but> with non-role RHS |
04:50 | |
synopsebot6 | Link: doc.perl6.org/language/operators | ||
viki | oh god did I write that in the wrong section : | 04:51 | |
I wonder why `does` doesn't do the same shinannigans as `but` | 04:53 | ||
m: multi sub infix:<does>(Mu \obj, Mu:D $val) is raw { obj.clone.^mixin(GENERATE-ROLE-FROM-VALUE($val)); }; my $s = 0 does class { method ^name ($) { 'warbles' } }.new; say $s.warbles; say $s + 42 | 04:54 | ||
camelia | rakudo-moar e0c0ae: OUTPUT«warbles.new42» | ||
viki | m: multi sub infix:<does>(Mu \obj, Mu:D $val) is raw { obj.^mixin(GENERATE-ROLE-FROM-VALUE($val)); }; my $s = 0 does class { method ^name ($) { 'warbles' } }.new; say $s.warbles; say $s + 42 | ||
camelia | rakudo-moar e0c0ae: OUTPUT«warbles.new42» | ||
04:55
kyclark_ joined
04:56
kyclark_ left,
khw left
|
|||
viki | m: dd Int but role {} | 04:57 | |
camelia | rakudo-moar e0c0ae: OUTPUT«Int+{<anon|75618224>}» | ||
viki | m: dd Int does role {} | ||
camelia | rakudo-moar e0c0ae: OUTPUT«Cannot use 'does' operator with a type object. in block <unit> at <tmp> line 1» | ||
viki | Or why that inconsistency :/ | ||
dalek | c: 2b2a9be | (Zoffix Znet)++ | doc/Language/operators.pod6: Revert "Document behaviour of infix:<but> with non-role RHS" This reverts commit 90451456eb6b287e49f553d3c91b4c0a8b80d2b0. (placed in the wrong section) |
04:58 | |
synopsebot6 | Link: doc.perl6.org/language/operators | ||
geekosaur | does modifies a class, but modifies an instance, a type object is an instance | ||
(or a role, etc.) | 04:59 | ||
or perhaps, given the earlier examples, does modifies a *definition* | 05:00 | ||
05:00
kyclark_ joined
|
|||
viki | Ah, ok | 05:01 | |
geekosaur actually considered that before scanning back, because the only obvious thing separating those is the declaration / definition | |||
MasterDuke | viki: btw, in that example: 'forty two'; # 'fourty two' | ||
geekosaur | then I saw the my $s = 0 does ... and concluded the declaration was the more correct distinction | ||
dalek | c: 08b6467 | (Zoffix Znet)++ | doc/Language/operators.pod6: Document infix:<but> with object as RHS |
05:02 | |
synopsebot6 | Link: doc.perl6.org/language/operators | ||
viki | wait | 05:03 | |
nah | 05:04 | ||
viki is too sleepy to comprehend stuff righ tnow :( | |||
05:04
kyclark_ left
05:08
Cabanossi left,
rpburkholder left,
pierre_ joined,
pierre_ left
05:09
Cabanossi joined,
pierre_ joined
05:23
adu left
05:25
bjz joined,
bjz_ left
05:31
aborazmeh joined,
aborazmeh left,
aborazmeh joined
05:38
AlexDaniel left
|
|||
ZzZombo | my $s = 0 but class | 05:42 | |
m: my $s = 0 but class;put $s.^name | |||
camelia | rakudo-moar e0c0ae: OUTPUT«5===SORRY!5===Whitespace required after keyword 'class'at <tmp>:1------> 3my $s = 0 but class7⏏5;put $s.^nameCompilation unit cannot be anonymousat <tmp>:1------> 3my $s = 0 but class;7⏏5put $s.^name» | ||
ZzZombo | m: my $s = 0 but class {};put $s.^name | ||
camelia | rakudo-moar e0c0ae: OUTPUT«Cannot mix in non-composable type <anon|48246256> into object of type Int in block <unit> at <tmp> line 1» | ||
ZzZombo | m: my $s = 0 but class {}.new;put $s.^name | 05:43 | |
camelia | rakudo-moar e0c0ae: OUTPUT«Int+{<anon|55214032>}» | ||
ZzZombo | ugh, what does it actually do? | ||
viki | docs.perl6.org/routine/but | 05:49 | |
You're looking at the wrong ^name | 05:50 | ||
m: my $c = class {}.new; my $s = 0 but $c; say $s."{$c.^name}"() === $c | 05:51 | ||
camelia | rakudo-moar e0c0ae: OUTPUT«True» | ||
viki | Weren't it you who complained '0' being True in Perl 6 was awful? | 05:52 | |
m: my $zero-but-false = '0' but False; say so $zero-but-false | |||
camelia | rakudo-moar e0c0ae: OUTPUT«False» | ||
05:54
cognominal left
05:56
cdg_ joined
05:58
cdg left
05:59
skaji_ left
06:08
eisen74 left
06:09
xtt2 joined
06:28
pierre_ left
06:39
BenGoldberg left
06:46
kurahaupo left
06:47
aborazmeh left
|
|||
viki changes mind about Advent post | 06:51 | ||
Ain't gonna write the original story I wanted to originally... it'd be too long | |||
(will write something else). | 06:52 | ||
Speaking of which. | |||
huggable: advent | |||
huggable | viki, github.com/perl6/mu/blob/master/mi...6/schedule | ||
viki | ^ there are still lots of open spots | ||
Need writers for advent posts: perl6advent.wordpress.com/ | |||
06:55
TEttinger left
|
|||
ZzZombo | what are these? | 06:57 | |
viki | It's traditional. A Perl 6 Advent Calendar ( en.wikipedia.org/wiki/Advent_calendar ). Starting from December 1st, until Christmas, each day a blog post will be posted on perl6advent.wordpress.com, for people to read. | 07:01 | |
Anyone can write a blog post and the schedule shows who signed up so far to write one. | 07:02 | ||
ZzZombo | method wrap(Routine:D: &wrapper) lacks the return type. | 07:09 | |
What is it? | |||
moritz | m: say &sqrt.wrap({}).^name | 07:13 | |
camelia | rakudo-moar e0c0ae: OUTPUT«Type check failed in binding to &wrapper; expected Callable but got Hash (${}) in block <unit> at <tmp> line 1» | ||
moritz | m: say &sqrt.wrap({;}).^name | ||
camelia | rakudo-moar e0c0ae: OUTPUT«Routine::WrapHandle» | ||
moritz | I don't think that's an official type | ||
m: say 'ab' ~~ /a b/ | 07:16 | ||
camelia | rakudo-moar e0c0ae: OUTPUT«Potential difficulties: Space is not significant here; please use quotes or :s (:sigspace) modifier (or, to suppress this warning, omit the space, or otherwise change the spacing) at <tmp>:1 ------> 3say 'ab' ~~ /a7⏏5 b/「ab」» | ||
moritz | really? what good is insignificant whitespace IF YOU CAN'T USE IT because you get annoying warnings? | 07:17 | |
ZzZombo | warning: warnings are off. Do you wish to contnue anyway? | 07:19 | |
07:21
wamba joined
07:24
chris2 left
07:27
CIAvash joined
07:39
chris2 joined
07:47
Actualeyes joined,
cdg_ left,
cdg joined
07:51
cschwenz joined,
cdg left
|
|||
moritz | m: say 'a1' ~~ /<:L+:N>+/ | 08:06 | |
camelia | rakudo-moar e0c0ae: OUTPUT«「a1」» | ||
moritz | m: say 'a1' ~~ /<:L>+/ | ||
camelia | rakudo-moar e0c0ae: OUTPUT«「a」» | ||
08:16
___crlz___ left,
skids left,
chinarulezzz joined
08:18
domidumont joined
08:24
domidumont left
08:25
domidumont joined,
mohae joined
08:28
mohae_ left
08:30
araujo left
08:31
araujo joined,
araujo left,
araujo joined
|
|||
moritz | lol I blug: perlgeek.de/blog-en/perl-6/2016-bo...akudo.html | 08:33 | |
08:34
bartolin left
08:41
bartolin joined
08:42
firstdayonthejob joined
08:47
firstdayonthejob left
08:50
firstdayonthejob joined
08:51
cschwenz left
08:58
domidumont left,
domidumont joined
09:01
rindolf joined
09:03
pierre_ joined
09:04
domidumont left
|
|||
Ulti | just noticed the perl6 CLI doesn't have an equivalent to the perl5 -a is that a conscious decision? or open to being implemented? | 09:13 | |
09:13
kurahaupo joined
09:14
eisen74 joined
|
|||
Ulti | ^ -a splits an input line into fields in an array @F | 09:15 | |
gfldex | m: lines | 09:26 | |
camelia | ( no output ) | ||
gfldex | Util: ^^^ that's -a without -a | ||
moritz | Ulti: I guess we won't make it a magic array variable | ||
Ulti: though we might wrap the -e in a block, and pass the array as an argument | 09:27 | ||
so that you could @*F for example | |||
timotimo | i say we split stuff into $/ instead, and make it proper match objects | ||
moritz | but when splitting, you don't care about the match | 09:28 | |
you care about things between the matches | |||
psch | -a is "$line = $_.comb($pat) for lines()" isn't it? | 09:29 | |
timotimo | i know | ||
i mean to have the results available as $0, $1, $2 | |||
psch | or is $pat what comes from -F..? | ||
moritz | psch: -a is about split, not .comb | ||
psch reads perldoc instead of poking around with half knowledge | 09:30 | ||
moritz | yes, -F sets the split pattern | ||
gfldex | the @*F would give easy access to the number of elements | ||
but how well does that work for non-western languages? | 09:31 | ||
Ulti | timotimo $0 would be a Match then though right? | ||
so lots of ~ to coerce? | 09:32 | ||
timotimo | that's what i said, isn't it? :) | ||
Ulti | yeah but I mean thats not what someone might expect, though if you give a regex via -F I guess it should be :3 | ||
moritz | I don't see why -a should fill Match objects when split doesn't | 09:33 | |
timotimo | and running ~ on a match is just .Str, which is just a substr on $orig | ||
*shrug* | |||
i just like the shorthand for $/ variables | |||
though i guess it might be upsetting that $/ gets defined and filled | |||
like if you then use ~~, it'll complain | |||
09:42
eisen74 left
|
|||
Ulti | so think I traced it to be HLL::Compiler in nqp that would need the functionality rather than in Rakudo | 09:43 | |
09:43
ruddur left
|
|||
psch | Ulti: probably HLL::CommandLine, actually | 09:43 | |
timotimo | well, you can give it to HLL::Backend or something | ||
psch | oh, wait, actually -a and -F are actually simple kinda of switches i suppose | 09:45 | |
as in, 'a' and 'F=s', respectively for their definition | 09:46 | ||
which isn't anything HLL::CommandLine can't handle yet | |||
Ulti | yeah I think you can get the actual options parsed without a problem, its more where to put the split | ||
psch | Ulti: probably similarly to how we do '-n' currently, which iirc is somewhere in World/Grammar/Actions | 09:47 | |
09:49
RabidGravy joined
09:50
zakharyas joined
|
|||
moritz | also note that if you use -a with a normal block, $_ just ends up being the array | 09:53 | |
so you can use .[3] | |||
timotimo | "with a normal block"? | 09:54 | |
i thought -a was supposed to put stuff into @F or similar | |||
Ulti | kind of want to preserve $_ as the unaltered line though | 09:55 | |
timotimo | yeah | 09:56 | |
Ulti | so you can easily print the line given a check on a field | ||
moritz | timotimo: my point is that we shouldn't put stuff into global or automatically declared variables | 10:05 | |
timotimo: just pass an array to the block | |||
timotimo | but there is no block :P | ||
moritz | timotimo: so if you use @*F inside the block, it'll get the argument bound to it | ||
needs to be an artificial one, then | |||
just like we do with -n right now | 10:06 | ||
Ulti | aha wrap_option_p_code wrap_option_n_code feel like they might be relevant | ||
timotimo | that's the right ones | 10:07 | |
10:07
labster left
|
|||
Ulti | FYI github.com/rakudo/rakudo/blob/729d...s.nqp#L704 | 10:10 | |
10:10
tojo left
|
|||
Ulti | but yeah its fairly raw ops wrapping the -e line being compiled | 10:10 | |
timotimo | yeah, but it's also rather fast :) | 10:11 | |
Ulti | sure | ||
moritz | m: say 'ä' ~~ /:m a/ | 10:12 | |
camelia | rakudo-moar e0c0ae: OUTPUT«「ä」» | ||
ZzZombo | so there can't be a private method, can there? | 10:13 | |
psch | m: class A { method !m { } }; say A.^methods | ||
camelia | rakudo-moar e0c0ae: OUTPUT«()» | ||
ZzZombo | m: class A { method !m {put 'm'} method n {!m} };A.new.n | 10:14 | |
camelia | rakudo-moar e0c0ae: OUTPUT«5===SORRY!5=== Error while compiling <tmp>Strange text after block (missing semicolon or comma?)at <tmp>:1------> 3class A { method !m {put 'm'}7⏏5 method n {!m} };A.new.n expecting any of: infix infix stopper…» | ||
ZzZombo | m: class A { method !m {put 'm'};method n {!m} };A.new.n | ||
camelia | rakudo-moar e0c0ae: OUTPUT«5===SORRY!5=== Error while compiling <tmp>Use of a closing delimiter for an opener is reservedat <tmp>:1------> 3ass A { method !m {put 'm'};method n {!m7⏏5} };A.new.n» | ||
ZzZombo | m: class A { method !m {put 'm'};method n {!m};};A.new.n | ||
camelia | rakudo-moar e0c0ae: OUTPUT«5===SORRY!5=== Error while compiling <tmp>Use of a closing delimiter for an opener is reservedat <tmp>:1------> 3ass A { method !m {put 'm'};method n {!m7⏏5};};A.new.n» | ||
psch | ZzZombo: !m} parses as "not match closing delimiter" | 10:15 | |
ZzZombo | m: class A { method !m {put 'm'};method n {!m()};};A.new.n | ||
camelia | rakudo-moar e0c0ae: OUTPUT«5===SORRY!5=== Error while compiling <tmp>Undeclared routine: m used at line 1» | ||
psch | m: class A { method !m {put 'm'};method n {self!m};};A.new.n | ||
camelia | rakudo-moar e0c0ae: OUTPUT«m» | ||
ZzZombo | m: class A { method !m {put 'm'};method n {self.m};};A.new.n | ||
camelia | rakudo-moar e0c0ae: OUTPUT«No such method 'm' for invocant of type 'A' in method n at <tmp> line 1 in block <unit> at <tmp> line 1» | ||
ZzZombo | m: class A { method !m {put 'm'};method n {self!m};};A.new.n;dd A.^methods | 10:16 | |
camelia | rakudo-moar e0c0ae: OUTPUT«m(method n (A $: *%_) { #`(Method|60243696) ... },)» | ||
ZzZombo | so, it doesn't get saved for introspection... | 10:17 | |
very bad | |||
psch | it's private | ||
ZzZombo | so what? why it can't be introspected? | ||
not USED outside | |||
just peeked in | |||
timotimo | it's just not in .^methods | ||
ZzZombo | where is it then? | 10:18 | |
timotimo | m: class A { method !m {put 'm'};method n {self!m};};A.new.n;dd A.^private_method_table | 10:19 | |
camelia | rakudo-moar e0c0ae: OUTPUT«m{:m(method m (A $: *%_) { #`(Method|52335744) ... })}» | ||
psch | m: class A { method !m {put 'm'};};say A.^find_private_method('m') | ||
camelia | rakudo-moar e0c0ae: OUTPUT«m» | ||
10:19
zakharyas left
|
|||
ZzZombo | ow, thanks | 10:19 | |
psch | if you're introspecting private methods you're probably doing something at least a little weird, though | ||
timotimo | have a look at the files in src/Perl6/Metamodel | 10:20 | |
these ones you can find in PrivateMethodContainer.nqp | |||
ZzZombo | psch: I'm doing my own class system. | ||
psch | ZzZombo: yeah, that's at least a little weird :) | ||
seatek | i don't think i've ever seen anyone kick the tires as much as ZzZombo :) | ||
psch | ZzZombo: feel free to mention any MOP-weirds that you come across though | 10:21 | |
ZzZombo: there's been rather few people digging in there, so yeah | |||
ZzZombo | ye, I hear you | ||
psch | ZzZombo: did you find the advent post about forbidding multiple inheritance btw? that seems like it might be of interest | 10:22 | |
ZzZombo | Sorry, I'm already overloaded with information, so I barely even read anything else nowadays. | ||
psch | perl6advent.wordpress.com/2011/12/14/ fwiw. i have no idea how up-to-date it still is, but i'd expect it to mostly still work as written | ||
ZzZombo | m: class A { method m {put 'm'};method !m {put '!m'};} | 10:25 | |
camelia | ( no output ) | ||
psch | m: class A { trusts GLOBAL; method m {put 'm'};method !m {put '!m'};}; A!A::m() | 10:27 | |
camelia | rakudo-moar e0c0ae: OUTPUT«!m» | ||
lizmat | . | 10:29 | |
yoleaux | 02:22Z <viki> lizmat: would you look at these to see if any of the changes were unintentional? .comb seems to have change to returning List/Slip instead of a Seq: irclog.perlgeek.de/perl6/2016-11-27#i_13635016 | ||
ZzZombo | timotimo and psch: wow, those directions really helped! Thanks a lot! | 10:31 | |
timotimo | :) | ||
lizmat | .tell viki in general, if .comb returns a List, it's because it already has all elements it could find already reified: not much point turning a .List into a .Seq then. Although it would be simple enough to do if we want that because of interface consistency | 10:32 | |
yoleaux | lizmat: I'll pass your message to viki. | ||
RabidGravy | am I right in saying from a casual inspection of the code that the only thing stopping the COMPOSE phaser from working is that ithe code needs to be added to actually fire it in the appropriate places? | 10:46 | |
timotimo | i expect so | 10:55 | |
psch | isn't it at least partly about "where is the right place anyway?" | 10:56 | |
timotimo | its "when does it run" is no different from not having COMPOSE at all | ||
so ... just generate a call to the block where the COMPOSE is? | |||
10:59
xtt2 left
|
|||
RabidGravy | but isn't the right place at the point where the thing is composed into something else | 11:01 | |
and for most places the thing has a compose method in the MOP | |||
timotimo | role and class bodies run exactly when they're composed | 11:03 | |
RabidGravy | sure, but the bodies don't have access to the MOP | 11:04 | |
in quite the same way anyway | |||
timotimo | oh, you're meant to be able to access MOP stuff from inside the COMPOSE phaser? | ||
RabidGravy | well I assume so, I'm just assuming it's just a user level method of providing a compose() over-ride in the MOP | 11:05 | |
11:06
espadrine joined
|
|||
RabidGravy | so essentially a hook in the thingies compose() | 11:07 | |
I'm struggling with the grammar a bit, but it looks like e.g. "role Foo { COMPOSE { ... } }' is collecting the COMPOSE block but just not doing anything with it | 11:09 | ||
timotimo | yeah | 11:10 | |
the other action methods for other blocks usually .install_phaser or something | |||
RabidGravy | yeah, it is doing add_phaser | ||
timotimo | if nothing exists to look for the phaser and run it, nothing will happen | 11:11 | |
RabidGravy | method statement_prefix:sym<COMPOSE>($/) { make $*W.add_phaser($/, 'COMPOSE', ($<blorst>.ast).ann('code_object')); } | ||
timotimo | well, sounds good, doesn't it? | ||
wait | |||
RabidGravy | timotimo, yes that's my point | ||
timotimo | it just returns the made phaser or something? | ||
RabidGravy | it adds it the same as the other phasers | 11:12 | |
timotimo | but ... how? :) | 11:13 | |
RabidGravy | but it appears that only block objects have a fire_phasers method, so for e.g. roles there is no way to fire the collected phaser | 11:14 | |
timotimo | mhm, ok | ||
is there some other part that has to collect the thing that's "make"d there? | |||
RabidGravy | oh wait, the add_phasers method ignores COMPOSE | 11:17 | |
timotimo | %) | 11:18 | |
fantastic | |||
RabidGravy | Or rather, any that aren't specifically handled it puts them somewhere then does "eturn QAST::Var.new(:name('Nil'), :scope('lexical'));" | 11:20 | |
oh so for all intents and purposes the body of a class or role is treated as a code object in there | 11:26 | ||
11:35
pierre_ left
11:41
domidumont joined
|
|||
timotimo | a new low for curl-into-bash: curl bit.ly/... | /bin/bash | 11:44 | |
seatek | wow travis compiles a whole new rakudo for every package build check? | 11:45 | |
timotimo | yeah | 11:47 | |
seatek | doesn't that like... waste electricity or something? ;) | ||
now i'm going to feel guilty about fixing a couple spaces in something | 11:48 | ||
timotimo | you could channel that energy into trying to figure out how the mechanism in travis works that lets you share stuff between builds | 11:49 | |
11:50
Actualeyes left
|
|||
seatek | I'm not sure I like travis at all. I got rid of some tabs and replaced them with spaces in my readme.md file, and now my tests show failing all the time | 11:51 | |
for some reason travis can no longer locate dependencies | |||
i have RED EXCLAMAITION MARKS!!! | 11:52 | ||
and i swear it's not my fault | |||
timotimo | yeah, can sometimes happen | ||
sometimes github gets unreachable | 11:53 | ||
we have a bot that tells us if builds of our things broke because of not-our-fault, or not | |||
you might have seen it | |||
seatek | i do almost all my stuff on local git repos | ||
ah yeah | |||
nope | |||
timotimo | come to think of it, i don't think i've seen travis irc notifications all day | 11:54 | |
seatek | let's just send him away | ||
timotimo | irclog.perlgeek.de/perl6-dev/2016-...i_13628922 | ||
seatek | we need more weird magic | 11:55 | |
the dalek is always reliable | |||
timotimo | no :) | ||
seatek | hehe | 11:56 | |
timotimo | dalek tends to spit out too much text at once and gets kicked for that | ||
seatek | it just wants to help | ||
timotimo | yup | ||
dalek is a good bot | |||
seatek | do you remember years ago, a system monitor which was written in perl i think... gui based... all kinds of bells and whistles... called the Moaning Goat Meter? | 11:57 | |
the system monitor that bogged your computer down with all the stuff it could do | |||
timotimo | never heard of it | 11:58 | |
seatek | i started thinking of that thing today... this application i've been working on has gotten so large that it's taking it 10-20 seconds to run each time i do some change | ||
so i've been obsessing on little narrow tests instead, as much as i can, to do the development :) | |||
11:59
kurahaupo__ joined
|
|||
seatek | it's an interesting change | 11:59 | |
12:00
kurahaupo__ is now known as kurahaupo_
|
|||
timotimo | are you doing it in p6? | 12:00 | |
seatek | so now when i make a mistake like forgetting to put the '.' in a $.var -- it's like a real kick myself time :) | ||
yeah | |||
timotimo | we have a test runner that is able to run tests in parallel | ||
seatek | does that help on the compile times? | ||
12:01
CIAvash left
|
|||
seatek | i like how it's making me keep things separate | 12:01 | |
i can tell that it is selective about what it recompiles when editing | 12:02 | ||
12:02
canopus left
|
|||
timotimo | right, we precompile things for you and only invalidate the precompilation when it's necessary | 12:05 | |
we try to be good about that | |||
seatek | i'm very grateful for it | ||
it's good at making people keep their code nice and separated... | 12:06 | ||
Ulti | is there a tutorial anywhere on NQP | 12:07 | |
or a little reference to the language | |||
timotimo | yeah, the internals workshop, Ulti | ||
Ulti | I've found github.com/perl6/nqp/blob/master/d...s.markdown which is also useful | 12:08 | |
timotimo is that a PDF or video somewhere? | |||
timotimo | that's a pdf | ||
Ulti | k will googles | ||
timotimo | github.com/edumentab/rakudo-and-nq...als-course | ||
Ulti | edumentab.github.io/rakudo-and-nqp-...ls-course/ | ||
yeah | |||
12:09
canopus joined
|
|||
timotimo | man, that website wants some CSS :D | 12:09 | |
Ulti | so will record all of what I'm going through for advent ;) | ||
timotimo BBIAB | |||
seatek | It's from the people who brought you ogg vorbis linuxmafia.com/mgm/ | 12:11 | |
haven't thought of that in ages :) | 12:12 | ||
12:13
domidumont left
12:17
Actualeyes joined
|
|||
Xliff | Hmmm.... | 12:25 | |
If I have class C that inherits from class B, how can I get it so that class C can call class B's BUILD submethod before the BUILD method in class C finishes? | 12:26 | ||
Is that even ppssible? | |||
callwith, maybe? | |||
psch | doesn't that always happen like that? | 12:27 | |
as in, BUILDALL starts from Mu and goes down the hierarchy, doesn't it | |||
Xliff | psch: I don't know. | ||
psch | m: class A { submethod BUILD { say "in A BUILD"; LEAVE { say "left A BUILD" } } }; class B is A { submethod BUILD { say "in B BUILD"; LEAVE { say "left B BUILD" } } }; B.new | 12:28 | |
camelia | rakudo-moar 8ca367: OUTPUT«in A BUILDleft A BUILDin B BUILDleft B BUILD» | ||
Xliff | LOL! Was doing the same thing. | ||
That answers my question. Thanks, psch++ | 12:29 | ||
psch | oh hm, it doesn't call the parents BUILD itself though | ||
if you really need that i dunno vOv | |||
but i suspect you don't, actually | |||
12:36
pierre_ joined
12:37
FROGGS joined
12:40
pierre_ left
12:59
rpburkholder joined
13:06
BenGoldberg joined
13:07
pierre_ joined
13:08
wamba left
13:10
girafe left
13:27
mscha joined
|
|||
mscha | m: my Int:D @arr[3]; # huh? | 13:28 | |
camelia | ( no output ) | ||
mscha | m: my Int:D @arr[3]; say @arr# huh? | ||
camelia | rakudo-moar 8ca367: OUTPUT«[(Int:D) (Int:D) (Int:D)]» | ||
psch | m: my Int:D @arr[3]; @arr[0] = Int; | ||
camelia | rakudo-moar 8ca367: OUTPUT«Type check failed in assignment to ; expected Int:D but got Int (Int) in block <unit> at <tmp> line 1» | ||
psch | m: my Int:D @arr[3]; @arr[0] = Int:D; | 13:29 | |
camelia | rakudo-moar 8ca367: OUTPUT«Type check failed in assignment to ; expected type Int:D cannot be itself (perhaps Nil was assigned to a :D which had no default?) in block <unit> at <tmp> line 1» | ||
psch | mscha: if you want to force an initializer you probably have to write a Slang | 13:30 | |
mscha | But isn't it a bug that Rakudo will happily assign undefined Int:D's to an Int:D? | 13:32 | |
psch | mscha: where is the assignment? | ||
mscha: also note that actually assigning Int:D dies | |||
mscha | Implicitly assign? | ||
psch | m: use MONKEY-TYPING; augment class Scalar { multi method STORE { say "storing"; nextsame } }; my Int:D @x; | 13:33 | |
camelia | ( no output ) | ||
psch | m: use MONKEY-TYPING; augment class Scalar { multi method STORE { say "storing"; nextsame } }; my Int:D @x; @x[0] = 2 | ||
camelia | ( no output ) | ||
psch | aw shucks | ||
mscha: anyway, there is no assignment, there is only instantiation | 13:34 | ||
mscha: considering you don't have to give a shape to the array either... | 13:35 | ||
m: my Int:D @a # allocate infinite 0s..? | |||
camelia | ( no output ) | ||
psch | mscha: mind, i doubt there'd be backlash if you manage to implement the scalar behavior for arrays | 13:38 | |
m: my Int:D $x # this behavior that is | |||
camelia | rakudo-moar 8ca367: OUTPUT«5===SORRY!5=== Error while compiling <tmp>Variable definition of type Int:D requires an initializerat <tmp>:1------> 3my Int:D $x # this behavior that is7⏏5<EOL>» | ||
psch | but i'd imagine that it only really makes sense for shaped arrays, because otherwise it seems kind of weird considering autovivification is a thing | 13:39 | |
mscha | Yeah, nothing wrong with ... | 13:40 | |
m: my Int:D @arr; say @arr; | |||
camelia | rakudo-moar 8ca367: OUTPUT«[]» | ||
mscha | Anyway, no big deal, really. If you ask for something stupid (an array of three undefined things that must be defined) you get something stupid. | 13:41 | |
psch isn't sure that's not sarcasm | |||
timotimo | only works if there's a default value, of course | 13:42 | |
well, assigning Int:D dies because Int:D isn't A Thing | 13:43 | ||
moritz | m: my Int:D $x = Int:D; | 13:45 | |
camelia | rakudo-moar 8ca367: OUTPUT«Type check failed in assignment to $x; expected type Int:D cannot be itself (perhaps Nil was assigned to a :D which had no default?) in block <unit> at <tmp> line 1» | ||
moritz | m: my Int:D $x; | ||
camelia | rakudo-moar 8ca367: OUTPUT«5===SORRY!5=== Error while compiling <tmp>Variable definition of type Int:D requires an initializerat <tmp>:1------> 3my Int:D $x7⏏5; expecting any of: constraint» | ||
dmaestro | This was an example from the quoting doc: | 13:47 | |
m: Q:w{ [ ] { } }.perl | |||
camelia | ( no output ) | ||
dmaestro | m: say Q:w{ [ ] { } }.perl | ||
camelia | rakudo-moar 8ca367: OUTPUT«("[", "]", "\{}")» | ||
dmaestro | m: say Q:w{ [ ] \{ \} }.perl | 13:48 | |
camelia | rakudo-moar 8ca367: OUTPUT«("[", "]", "\\\{\\}")» | ||
dmaestro | I put in a correction to the doc with a better example, but does anyone know whether / why this is correct behavior? | ||
timotimo | m: my $foo := Int:D | ||
camelia | ( no output ) | ||
timotimo | m: my $foo := Int:D; say $foo.WHAT | ||
camelia | rakudo-moar 8ca367: OUTPUT«(Int:D)» | ||
timotimo | oh well. | ||
i was clearly wrong | 13:49 | ||
13:49
seatek left
|
|||
timotimo | m: Int:D ~~ Int:D | 13:49 | |
camelia | ( no output ) | ||
timotimo | m: say Int:D ~~ Int:D | ||
camelia | rakudo-moar 8ca367: OUTPUT«False» | ||
timotimo | ^- in any case. | ||
13:52
cibs left
|
|||
mscha | m: my Int:D @arr; say @arr; @arr[2] = 42; say @arr; | 13:52 | |
camelia | rakudo-moar 8ca367: OUTPUT«[][(Int:D) (Int:D) 42]» | ||
timotimo | oh lord :) | 13:53 | |
but note also that our arrays actually store "is there anything here" | |||
so it could very well be that it's just giving out the Int:D without having it actually stored | |||
13:53
cibs joined
|
|||
timotimo | m: my Int:D @arr; @arr[2]; say @arr[0,1,2]:exists | 13:53 | |
camelia | rakudo-moar 8ca367: OUTPUT«(False False False)» | ||
timotimo | m: my Int:D @arr; @arr[2] = 10; say @arr[0,1,2]:exists | ||
camelia | rakudo-moar 8ca367: OUTPUT«(False False True)» | ||
13:57
bartolin left
14:04
bartolin joined
14:05
bjz left
|
|||
mscha | m: say π ~~ 3...4; # huh? | 14:18 | |
camelia | rakudo-moar 8ca367: OUTPUT«(False True True True True True True True True True True True True True True True True True True True True True True True True True True True True True True True True True True True True True True True True True True True True True True True True True True…» | ||
moritz | m: say π ~~ (3...4); | ||
camelia | rakudo-moar 8ca367: OUTPUT«False» | ||
mscha | Ah. Precedence. | 14:19 | |
moritz | m: say (False..4)[^5] | ||
camelia | rakudo-moar 8ca367: OUTPUT«(0 1 2 3 4)» | ||
moritz | m: say (False...4)[^5] | ||
camelia | rakudo-moar 8ca367: OUTPUT«(False True True True True)» | ||
moritz | and a sequence that never reaches its endpoint | ||
14:24
adu joined
14:32
adu left
14:36
CIAvash joined
14:43
cdg joined
14:47
khw joined
|
|||
viki | OK, makese sense. | 14:48 | |
yoleaux | 10:32Z <lizmat> viki: in general, if .comb returns a List, it's because it already has all elements it could find already reified: not much point turning a .List into a .Seq then. Although it would be simple enough to do if we want that because of interface consistency | ||
14:48
BenGoldberg left
14:49
pierre_ left
14:50
espadrine left
14:55
adu joined
|
|||
Ulti | is there a way to get QAST out of Rakudo as a compilation stage? | 14:59 | |
similar to how you can do --stage=MAST | |||
psch | --target=ast exists | ||
Ulti | K | 15:00 | |
psch | but that's not a complete dump, but a stringification | ||
Ulti | that should be enough to help me out | ||
thanks | |||
psch | --target=optimize is the AST that comes out of the optimizer, fwiw | ||
so maybe that's more useful to look at | 15:01 | ||
15:01
pmurias joined
|
|||
pmurias | Ulti: re tutorial on NQP, you can look a t/nqp in the NQP repo to see what's available | 15:02 | |
moritz | did somebody mention jnthn++'s NQP and Rakudo Internals course already? | 15:07 | |
Ulti | yup | 15:08 | |
moritz | ok :-) | ||
that's the closest we have to a tutorial | |||
15:08
domidumont joined
15:10
adu left
|
|||
Ulti | im starting out doing the lexical @F no one wants but is most like the Perl 5 feature ;P | 15:10 | |
15:12
kyclark_ joined
15:13
kyclark_ left
|
|||
psch | hmm, since -F implies -a implies -n, can't you just put the slip result into @_? | 15:13 | |
s/slip/split/ | |||
15:13
CIAvash left,
chris2 left
|
|||
moritz | don't be so pragmatic :-) | 15:16 | |
Ulti | yup | ||
pmurias | @F is ugly so it should stand out better ;) | ||
15:16
cdg left
|
|||
Ulti | lets not lose sight of this only exists for cli -e "programs" though | 15:16 | |
matching perl5 and ruby interfaces isn't the worst thing in the world for usability | 15:17 | ||
psch | actually i'm not even sure side-stepping the @_-autoviv thingy is easy enough | ||
Ulti | I was thinking about someone specifying a full grammar and you get parsed lines :3 but its just not what anyone would want for dirty cli things | ||
psch | huh, that's a neat idea though | 15:18 | |
Ulti | yeah it means you can have named fields | ||
which would be nice | |||
psch | like "perl6 -FMText::CSV -e'...' data.csv" | ||
Ulti | also better code reuse | ||
psch | which, actually, is something i would like for dirty cli things | ||
Ulti | you could specify a grammar class like -M | ||
psch: yup | 15:19 | ||
I think thats a super nice extension | |||
psch | ++Ulti :) | ||
Ulti | well I'll see how far I get I'm only one step above cargo culting at the moment | 15:20 | |
15:20
cdg joined
|
|||
Ulti | also a very Perl 6 specific magic way of doing CLI one liners | 15:20 | |
easily a killer feature | 15:21 | ||
for command line junkies | |||
15:21
bartolin left
|
|||
Ulti | because suddenly its easy to do file format aware greps | 15:21 | |
even if its multi line records | |||
RabidGravy concludes that the half-idea to make COMPOSE work from user code is probably forlorn | 15:25 | ||
15:25
espadrine joined
15:26
bartolin joined
15:27
xinming left
15:29
CIAvash joined,
chris2 joined
15:30
wamba joined
|
|||
pmurias | having a perl6 version of ack would be awesome | 15:30 | |
15:31
kalkin-_ left,
kalkin- joined,
stux|RC-only left
|
|||
moritz | might be a bit slow :( | 15:32 | |
15:33
rindolf left
15:34
xinming joined,
stux|RC-only joined
|
|||
TimToady | well, we still need to optimize the heck out of regexen and grammaren | 15:35 | |
15:35
rindolf joined
|
|||
RabidGravy | what larks | 15:36 | |
TimToady | now that I'm finally done with the conference season, maybe I can have a look or two at that | ||
viki | \o/ | ||
pmurias | õ | 15:42 | |
15:43
domidumont left
|
|||
dalek | c: 96ffea2 | (Zoffix Znet)++ | doc/Type/IO/Handle.pod6: Document IO::Handle.printf Remove paragraph about workarounds |
15:45 | |
synopsebot6 | Link: doc.perl6.org/type/IO/Handle | ||
c: 27b993f | (Zoffix Znet)++ | doc/Language/5to6-perlfunc.pod6: Remove printf workaround mention from 5-to-6 doc |
15:49 | ||
synopsebot6 | Link: doc.perl6.org/language/5to6-perlfunc | ||
15:51
xtt2 joined,
AlexDaniel joined
15:55
xinming left
16:03
kyclark_ joined
16:07
xtt2 left
16:08
chinarulezzz left
16:12
Actualeyes left
16:17
CIAvash left
16:23
giraffe left,
kyclark_ left
16:27
cdg left,
zacts left
|
|||
dalek | : 084abca | (Zoffix Znet)++ | misc/perl6advent-2016/schedule: Switch post Don't wanna write my original idea anymore, gonna write "Perl 6 Core Hacking: How, Where, What, and Why" instead. To drive more people to contribute to core code. If Web Gods willing, the contributing.perl6.org will be done by the time post publishes. |
16:28 | |
16:29
giraffe joined
16:37
krokib joined
16:38
espadrine left
16:39
domidumont joined
|
|||
dalek | : 97c6c0a | tadzik++ | misc/perl6advent-2016/schedule: Move myself later |
16:49 | |
tadzik | free karma for pre-procrastinating, neat | ||
psch | huh, curious that this years schedule doesn't share the same format as previous one | 16:50 | |
i am exclusively refering to "include the 25th with 'Christmas!'" | |||
+s | 16:51 | ||
moritz | psch: time to earn your karma, then! | 17:02 | |
psch | moritz: actually i'm just assuming that christmas has already happened and that's why the 25th isn't listed :) | ||
moritz | psch: as long as I can remember, there's been a Christmas each year :-) | 17:04 | |
psch | ah, the trouble with coopting extant terms for specific events /o\ | 17:05 | |
17:09
mscha left
17:15
stux|RC joined,
stux|RC left
17:24
BenGoldberg joined
17:27
vendethiel left
17:28
vendethiel joined
17:32
vendethiel left
17:33
lolo78 joined
17:35
zacts joined
|
|||
lolo78 | Hi, does anyone knows why picking up a random number between 1 and 1e5 takes almost 10 seconds in the REPL, while doing the same between 1 and 100_000 is instantaneous: | 17:38 | |
> my $start = now; my $c = (1..1e5).pick; say now - $start; | |||
9.97741524 | |||
> my $start = now; my $c = (1..100_000).pick; say now - $start; | |||
0 | |||
It looks as a bug to me, but I may overlook something. | |||
viki | 0.o | 17:40 | |
m: my $start = now; my $c = (1..1e5).pick; say now - $start; | |||
camelia | rakudo-moar 8ca367: OUTPUT«6.2881222» | ||
viki | m: my $c = (1..1e5).pick; say now - INIT now; # <--- trick for timing without the need for $start | ||
17:40
lolo78_ joined
|
|||
camelia | rakudo-moar 8ca367: OUTPUT«6.45798636» | 17:40 | |
viki | s: (1..1e5), 'pick', \() | 17:41 | |
SourceBaby | viki, Sauce is at github.com/rakudo/rakudo/blob/8774...ge.pm#L497 | ||
viki | m: my $c = (1..1e5).pick: 1; say now - INIT now; | ||
camelia | rakudo-moar 8ca367: OUTPUT«13.60358848» | ||
viki | m: my $c = (1..1e5).eager[1]; say now - INIT now | 17:42 | |
camelia | rakudo-moar 8ca367: OUTPUT«6.1120095» | ||
viki | lolo78: would you report it as a performance bug? Just email to [email@hidden.address] | ||
lolo78 | viki: OK, thanks, I will. | 17:43 | |
viki | Thanks. | ||
psch | m: (1e0..1e5).pick; say now - INIT now | 17:44 | |
camelia | rakudo-moar 8ca367: OUTPUT«0.26786054» | ||
psch | don't mix types on the ends for now :) | ||
17:44
stux|RC joined
|
|||
psch | m: (1..1e5).pick.WHAT.say | 17:46 | |
viki | Ah.. | ||
camelia | rakudo-moar 8ca367: OUTPUT«(Int)» | ||
psch | afaiu, for each iteration we're creating something that fits the LHS of infix:<..>, then converting it to fit the RHS, then converting again to store it in the resulting Seq | ||
viki | m: (1..100_000).pick; say now - INIT now | ||
camelia | rakudo-moar 8ca367: OUTPUT«0.0016929» | ||
viki | cool :D | ||
psch | fitting the RHS is necessary because we have to check how it cmps | ||
m: (1e0..100_000).pick; say now - INIT now | |||
camelia | rakudo-moar 8ca367: OUTPUT«6.1173763» | 17:47 | |
lolo78 | psch: OK, thanks for the tip, it is indeed much better, but still quite low compared to the 1..100_000 range. | ||
psch | m: (1..100_000).pick; say now - INIT now | ||
camelia | rakudo-moar 8ca367: OUTPUT«0.0017836» | ||
psch | m: (1e0..100_000e0).pick; say now - INIT now | ||
camelia | rakudo-moar 8ca367: OUTPUT«0.272768» | ||
AlexDaniel | huh | ||
psch | lolo78: yes, because you're passing natives that still have to be boxed | ||
m: (1/1..100_000/1).pick; say now - INIT now | |||
camelia | rakudo-moar 8ca367: OUTPUT«1.0455477» | ||
psch | and, well, Rat is slow anyway vOv | ||
AlexDaniel | um, actually I don't see any good reason why it would be so slow | 17:48 | |
psch | lolo78: in any case, i don't see why you'd ever generate a sequence incrementing by the natural unit in floating point natives or Rats | ||
AlexDaniel: Rat members are usually native, aren't they? | |||
err, s/members/Attributes/ | |||
we only bail from that if we reach out of int space afair | 17:49 | ||
AlexDaniel | m: say (0..Inf).pick | 17:50 | |
camelia | rakudo-moar 8ca367: OUTPUT«Cannot .roll from a lazy list in block <unit> at <tmp> line 1Actually thrown at: in block <unit> at <tmp> line 1» | ||
AlexDaniel | m: say (0..NaN).pick | ||
camelia | rakudo-moar 8ca367: OUTPUT«(timeout)» | ||
psch | m: say 1 < NaN | ||
camelia | rakudo-moar 8ca367: OUTPUT«False» | ||
psch | m: say 1 > NaN | ||
camelia | rakudo-moar 8ca367: OUTPUT«False» | ||
lolo78 | psch: I was really testing with much larger numbers (hundreds of digits) so using for example the 1e200 notation was easier than typing all the digits. | ||
psch | lolo78: well, it creates a different datatype | ||
m: say 1e0.WHAT | 17:51 | ||
camelia | rakudo-moar 8ca367: OUTPUT«(Num)» | ||
psch | m: say 1.WHAT | ||
camelia | rakudo-moar 8ca367: OUTPUT«(Int)» | ||
psch | we clearly need flexible-length uparrow notation in core :o) | ||
AlexDaniel | #125336 is kinde relevant | ||
synopsebot6 | Link: rt.perl.org/rt3//Public/Bug/Displa...?id=125336 | ||
AlexDaniel | a* | ||
lolo78 | psch: yes, I gather that now, I did not think about it when I ran my tests. | 17:52 | |
psch | lolo78: maybe some kind of 'infix:<!^>(Int $a, Int $b) { $a ** (10 ** $b) }' can alleviate some of your typing woes :) | 17:53 | |
...maybe minus the parens because infix:<**> is right-assoc, isn't it | 17:54 | ||
moritz | I'd still keep them for clarity :-) | ||
lolo78 | psch: I guess I can store 1e200 in a variable and coeece it to an Int before building the range. | 17:55 | |
psch | lolo78: that too! | ||
lolo78: mind, the performance problem you mentioned is still one we probably want to look into | |||
AlexDaniel | lolo78: so please submit a bug report anyway! | ||
psch | because, really, why wouldn't we convert the RHS to the LHS' type instead of converting every iteration value to the RHS' type | 17:56 | |
lolo78 | psch: thanks a lot for your help and very enlightening comments. Ans I will submit a bug report. | ||
s/and/and/ | |||
psch | lolo78: please tag it '[PERF]' if you do, and thanks! :) | 17:57 | |
lolo78: where 'tag' means 'put that string in the email subject' | |||
lolo78 | psch: I will. Thanks. | ||
psch | huggable: rakudobug | ||
huggable | psch, [email@hidden.address] or use perl6 query on rt.perl.org ; see github.com/rakudo/rakudo/#reporting-bugs | ||
17:59
TEttinger joined
18:01
skids joined
18:04
girafe joined,
chris2 left
18:06
lizmat_ joined
18:08
TEttinger left,
lizmat left
18:09
chris2 joined
|
|||
lolo78 | viki, psch and AlexDaniel: I've just submitted the performance bug report to [email@hidden.address] Thanks for your help. | 18:13 | |
AlexDaniel | thanks! | 18:14 | |
lolo78 | Just as an update: thos works fine: | 18:21 | |
> (1..1e5.Int).pick; say now - INIT now; | |||
0.0009998 | |||
> | |||
s/thos/this/ | |||
18:22
TEttinger joined
18:25
vendethiel joined
18:49
stux|RC-only left,
Tonik joined
18:54
labster joined
18:57
chinarulezzz joined
|
|||
stmuk_ | rakudo.org/2016/11/27/announce-raku...e-2016-11/ | 19:03 | |
viki | \o/ | 19:11 | |
lizmat_ | stmuk_++ | 19:16 | |
19:17
xinming joined
19:20
espadrine joined
|
|||
stmuk_ | I'm always surprised about the number of emails about the MSI | 19:23 | |
19:26
lizmat_ is now known as lizmat
|
|||
RabidGravy | strange how "fast queues" improve the reliability of the Audio::Liquidsoap tests | 19:27 | |
I think it's the source switch on the default playlist pre-empting the resolution of the request queue | 19:29 | ||
mst | timing problems make all pandas sad | 19:32 | |
moritz | stmuk_++ | ||
m: for 1..2 { .say; NEXT say "NEXT $_" } | 19:39 | ||
camelia | rakudo-moar 8ca367: OUTPUT«1NEXT 12NEXT 2» | ||
moritz | m: for 1..2 { .say; NEXT say "NEXT $_"; last } | ||
camelia | rakudo-moar 8ca367: OUTPUT«1» | ||
19:45
rindolf left
19:47
stevieb left
|
|||
lizmat | moritz: did you expect something else? | 19:47 | |
19:56
haircode joined
19:57
lolo78 left
19:58
lolo78_ left
20:04
lolo78 joined
20:08
lolo78_ joined
20:16
domidumont left
20:19
pochi left
20:20
stevieb joined
20:22
adu joined
20:26
pochi joined
20:27
AlexDaniel left
20:28
r3m is now known as rantanplan,
rantanplan is now known as r3m
20:40
cschwenz joined
20:50
bjz joined
20:53
lolo78 left,
lolo78__ joined,
lolo78__ is now known as lolo78
20:54
lolo78_ left
21:10
adu left
21:19
eisen74 joined,
FROGGS left
21:26
rindolf joined
|
|||
dmaestro | I'm still curious about the quoting behavior here: | 21:36 | |
m: Qw { [ ] { } }.perl | |||
camelia | ( no output ) | ||
dmaestro | m: say Qw { [ ] { } }.perl | 21:37 | |
camelia | rakudo-moar 8ca367: OUTPUT«("[", "]", "\{}")» | ||
dalek | c: 6a28ad9 | coke++ | doc/Language/ (2 files): remove trailing whitespace |
21:38 | |
c: 53719f6 | coke++ | doc/Language/glossary.pod6: remove unwarranted contraction |
|||
synopsebot6 | Link: doc.perl6.org/language/glossary | ||
[Coke] | we need more volunteers for advent. | 21:42 | |
14 empty slots out of 25. | |||
(I am happy to yield day one to someone writing a non-technical annual retrospective. :) | 21:43 | ||
21:43
bjz left
21:57
rindolf left
22:06
mj41 joined
22:18
stevieb left
22:21
bjz joined
|
|||
dalek | c: 6c9bfc9 | (Daniel Mita)++ | doc/Language/operators.pod6: Fix links to postcircumfix operators |
22:21 | |
synopsebot6 | Link: doc.perl6.org/language/operators | ||
c: 3904632 | RabidGravy++ | doc/Language/operators.pod6: Merge pull request #1023 from mienaikage/operator-urls Fix links to postcircumfix operators |
|||
synopsebot6 | Link: doc.perl6.org/language/operators | ||
22:27
_28_ria joined
22:30
stevieb joined,
pmurias left
22:33
bjz left
22:34
cschwenz left
22:40
MasterDuke left
22:44
kurahaupo_ left
22:45
kurahaupo__ joined
22:50
pmurias joined
|
|||
timotimo | Ulti: MAST doesn't come with a stringification, i don't think; the internal mast stuff is not text-like at all, fwiw | 22:50 | |
22:51
RabidGravy left
|
|||
[Coke] | anyone mind if I upgrade perl6 on hack? | 22:51 | |
(the rakudobrew version) | |||
... hope not, pulling trigger now | 22:54 | ||
timotimo | i'll be fine with it, but i hardly use perl6 on hack anyway | 22:55 | |
[Coke] | I just need some place that I can run a service on to test out my article. | ||
22:56
imcsk8_ is now known as imcsk8
|
|||
[Coke] | ... but I need to make sure it's at least using the latest version. | 22:56 | |
22:56
kurahaupo__ left
|
|||
timotimo | sure thing, hack is good for that | 22:56 | |
though of course you're free to build your own rakudo in your own home directort | |||
directory %) | |||
22:56
seatek joined
22:57
kurahaupo_ joined,
kurahaupo left
|
|||
[Coke] | it was .06 | 22:58 | |
timotimo | yowsers | ||
23:00
Actualeyes joined
23:04
pierre_ joined
23:05
pierre_ left
23:06
Actualeyes left
23:08
cdg joined
23:10
kurahaupo_ left
23:12
MasterDuke joined
|
|||
timotimo | whoa, don't we usually shorten the rakudo star changelog significantly? | 23:14 | |
for the release i mean | |||
timotimo fixes some markup explosiveness | 23:15 | ||
23:16
BenGoldberg left
23:17
lolo78 left
23:18
ZzZombo_ joined,
ZzZombo left
|
|||
timotimo | fixed | 23:20 | |
23:24
AlexDaniel joined
|
|||
seatek | smoldering ruins? | 23:25 | |
timotimo | well ... with some band-aids | ||
seatek | :) | ||
timotimo | check it out on rakudo.org | 23:26 | |
i'm not sure if i want to turn the bulleted list from a + character in each line to actually using html markup | |||
seatek | this is the change from .10 to .11 ? | 23:30 | |
timotimo | no, it's only rakudo star | ||
i'm not sure when the last rakudo star was | |||
seatek | ah ok | ||
23:30
Actualeyes joined
|
|||
timotimo | oh | 23:30 | |
the last rakudo star release was .10 | |||
seatek | yeah that wasn't long ago at all | 23:31 | |
timotimo | yeah | ||
23:31
lukaramu joined
|
|||
timotimo | i'm going to bed, i'm beat :) | 23:32 | |
seatek | oh my gosh i didn't even think that you could use multiple adverbs | ||
timotimo | hm, we should perhaps make extra sure to include a piece about that in the docs | ||
seatek | i'll try to find it and mention it if you like | 23:33 | |
timotimo | thanks! | ||
it's interesting among other things for :delete; like :delete:kv will give you keys and values, and also delete stuff from a hash | 23:34 | ||
anyway, AFK | |||
23:34
firstdayonthejob left
|
|||
seatek | like a dangerous factory line | 23:34 | |
efficient and deadly | 23:35 | ||
23:40
wamba left
23:58
cdg left
23:59
pmurias left
|