»ö« Welcome to Perl 6! | perl6.org/ | evalbot usage: 'perl6: say 3;' or rakudo:, niecza:, std:, or /msg camelia perl6: ... | irclog: irc.perl6.org | UTF-8 is our friend! Set by sorear on 25 June 2013. |
|||
00:01
rurban1 joined
00:04
rjbs left
|
|||
dalek | kudo-star-daily: a63ba62 | coke++ | log/ (5 files): today (automated commit) |
00:06 | |
rl6-roast-data: 46d6f65 | coke++ | / (5 files): today (automated commit) |
|||
rl6-roast-data: b71d34a | coke++ | / (5 files): today (automated commit) |
|||
00:12
Psyche^ joined
00:14
btyler left
00:15
stevan__ left
00:16
Psyche^_ left
|
|||
lue | I'll leave it alone for today. I've got a magically called-too-often sub that's also eating my attempts at more granular debug says :( | 00:18 | |
00:22
rurban1 left
00:26
markov left
|
|||
[Coke] | woolfy1++ | 00:41 | |
00:41
stevan_ joined
00:42
markov joined
|
|||
timotimo has a prototype of the scan-with-boyer-moore-optimisation moritz made | 00:53 | ||
for jvm | 00:54 | ||
dalek | ast: 0f86f36 | coke++ | S02-literals/quoting-unicode.t: Fudge for niecza |
00:55 | |
00:56
dayangkun joined
|
|||
timotimo | ooooh, rakudo.jvm has overtaken rakudo.parrot \o/ | 00:56 | |
00:56
dayangkun left
|
|||
[Coke] | 2 days ago, looks like. | 01:04 | |
timotimo | mhm | 01:05 | |
modules/uri doesn't seem to actually do any installing at all | |||
causing some fallout in the following modules | |||
01:07
raiph left
01:08
colomon left
|
|||
timotimo | a beefed up version of the artificial benchmark takes 0.6s with boyer-moore (for 10_000 match attempts) | 01:08 | |
and now i'm recompiling the before-version | |||
01:09
colomon joined
01:10
berekuk left
|
|||
timotimo | oh, what, 10x faster? | 01:10 | |
apparently. wow. | |||
moritz: ^^ | |||
01:11
berekuk joined
|
|||
[Coke] | au: you made some pugs changes. Be happy if you could help fix the install on host06. | 01:13 | |
dalek | p: d4e274d | (Timo Paulssen)++ | src/vm/jvm/QAST/Compiler.nqp: teach jvm how to boyer-moore for scan+literal. |
||
[Coke] | er, *saw* you made. | ||
01:23
rurban1 joined
01:26
woosley joined,
raiph joined
01:29
rurban2 joined
01:31
thou left
01:32
rurban1 left
01:33
rurban2 left
01:35
thou joined
|
|||
diakopter | :-[ | 01:38 | |
01:55
mtk left
02:05
PZt left
02:20
jeffreykegler joined
02:25
jnap left
02:26
dmol left
02:30
rurban1 joined
02:36
rurban1 left
02:39
tgt left
02:58
jeffreykegler left
|
|||
[Coke] | both rakudo.parrot and rakudo.jvm have failing tests and could use some fudging. | 03:02 | |
(with tickets being opened.) | |||
03:08
ggoebel15 left
|
|||
lue | Hm. Somehow the line "my %meths := $par.method_table($par);" causes the sub it's in to get called when it shouldn't. This is odd... (.method_table simply returns the %!methods attribute) | 03:08 | |
03:35
daniel-s left
03:51
labster left
03:52
labster joined
03:56
davecc left,
davecc joined
04:06
PZt joined
04:10
SevenWolf joined
04:13
logie joined
04:20
preflex_ joined,
ChanServ sets mode: +v preflex_
04:21
preflex left,
preflex_ is now known as preflex
04:22
ssutch left
04:27
wbill left
04:29
wbill joined
04:35
kaleem joined
04:36
davecc left
04:42
logie left
04:43
thou left,
thou joined
04:49
nnunley left
04:51
kaleem left
04:55
thou left
05:01
logie joined,
rurban1 joined
05:14
SamuraiJack_ joined
05:19
logie left
05:23
nnunley joined
|
|||
dalek | p: 93b9d50 | dwarring++ | docs/ops.markdown: move nqp::takeclosure doco to misc section |
05:25 | |
05:30
[Sno] left
06:04
cognominal joined
06:14
hoelzro left
06:15
hoelzro joined
06:18
dylanwh joined
06:20
geekosaur joined
06:22
xinming_ left,
kaleem joined
06:23
xinming joined,
[Sno] joined
06:26
logie joined
06:30
logie left
06:31
rurban1 left
06:32
darutoko joined
06:34
darutoko left
06:35
darutoko joined
06:38
raiph left
|
|||
Woodi | morning everyone | 06:56 | |
"Don Knuth"++ , well deserved :) | 06:57 | ||
moritz | P: say 42 | 07:04 | |
camelia | pugs: OUTPUT«42» | ||
07:16
dmol joined
07:20
cognominal left
07:30
brrt joined,
brrt left
07:34
preflex left
07:36
preflex joined,
ChanServ sets mode: +v preflex
07:37
rurban1 joined
07:45
rurban1 left
07:55
atroxaper joined
|
|||
atroxaper | Hello #perl6 | 07:56 | |
moritz | hello atroxaper | ||
atroxaper | Hello moritz | ||
07:58
FROGGS joined
07:59
wbill left
|
|||
atroxaper | I have a question about usiong Rakudo grammar again... Is there a way to get a part of parsed data if parsing failed? I mean if i try to call Perl6::Grammar.parse('my $b=4; b=5;', :actions(Perl6::Actions.new())); than i get "Lexical '$*LINEPOSCACHE' not found in dynamic scope" | 08:01 | |
Hello FROGGS | |||
FROGGS | hi atroxaper | ||
well, you could do before calling .parse: my $*LINEPOSCACHE | |||
but if a match failed, you won't get a match object :/ | 08:02 | ||
maybe the highwater-mark is sufficient? | 08:03 | ||
atroxaper | What do you mean highwater-mark? | 08:04 | |
08:05
darutoko left
|
|||
moritz | it's some way to record how far the match got | 08:06 | |
FROGGS | atroxaper: the parser remembers how far it could get before failing a rule/token, so you get the right position where something is wrong, for error reporting | ||
moritz | (specific to Perl6::Grammar) | ||
08:06
SevenWolf left
|
|||
FROGGS | r: my $x = 42; b # see where the marker is | 08:06 | |
camelia | rakudo-parrot 2c40f6: OUTPUT«===SORRY!=== Error while compiling /tmp/MmBKTG4TRCUndeclared routine: b used at line 1» | ||
..rakudo-jvm 2c40f6: OUTPUT«===SORRY!=== Error while compiling /tmp/81zdeIVY3rUndeclared routine: b used at line 1» | |||
08:06
darutoko joined
|
|||
FROGGS | umm | 08:06 | |
atroxaper | I just want to parce Perl6 code and get some structure like which NQPMatch.dump prints... | 08:07 | |
FROGGS | r: sub a { } { } # see where the marker is | ||
camelia | rakudo-jvm 2c40f6: OUTPUT«===SORRY!=== Error while compiling /tmp/_nBCQSRmt7Unexpected block in infix position (two terms in a row, or previous statement missing semicolon?)at /tmp/_nBCQSRmt7:1------> sub a { } ⏏{ } # see where the marker …» | ||
..rakudo-parrot 2c40f6: OUTPUT«===SORRY!=== Error while compiling /tmp/Mq7hX4OxvTUnexpected block in infix position (two terms in a row, or previous statement missing semicolon?)at /tmp/Mq7hX4OxvT:1------> sub a { } ⏏{ } # see where the mark…» | |||
FROGGS | there you go | ||
08:07
denisboyun joined
|
|||
FROGGS | atroxaper: then I'd propose you a) write a module that turns an NQPMatch into a Match object, or b) make it an nqp module | 08:08 | |
atroxaper | FROGGS: and how can i get position where something is wrong? | 08:09 | |
08:10
zakharyas joined,
iSlug joined
|
|||
FROGGS | atroxaper: you need to check how and where the highwater-mark is stored... and try to get your hands on it | 08:11 | |
atroxaper | FROGGS: Hmmm. Ok. Thanks for hint) | 08:12 | |
FROGGS | atroxaper: since I know how wonderful jnthn++ writes code, a grep for 'highwater' in nqp/src should do | 08:13 | |
atroxaper | FROGGS: you are right! ) | 08:14 | |
08:14
nnunley left
08:15
rurban left,
rurban joined
08:20
denisboyun left
|
|||
FROGGS | timotimo++ # 10x | 08:32 | |
moritz | timotimo++ is a 10x programmer! :-) | 08:39 | |
08:39
denisboyun joined
08:42
kivutar joined
08:50
woolfy1 left
|
|||
lizmat | good *, #perl6! | 08:52 | |
moritz | \o lizmat, * | ||
lizmat | moritz o/ | ||
08:52
woolfy joined
08:53
Maddingu1 joined
|
|||
hoelzro | morning #perl6 | 09:00 | |
09:08
fhelmberger joined
09:12
Maddingu1 is now known as Maddingue
|
|||
lizmat | morning hoelzro! | 09:20 | |
09:21
denisboyun left
09:24
dakkar joined
09:25
denis_boyun joined
09:35
dram left
|
|||
hoelzro | morning lizmat ! | 09:41 | |
09:42
Guest2496 is now known as denysonique
09:44
dayangkun joined,
dayangkun left
09:46
rurban1 joined
09:58
rurban1 left
10:02
denis_boyun_ joined,
denis_boyun left,
go|dfish left
10:07
dram joined
10:09
atroxaper left
|
|||
dram | r: my $foo = "FOO"; say qq:ww/$foo "bar baz"/.perl; | 10:10 | |
camelia | rakudo-parrot 2c40f6, rakudo-jvm 2c40f6: OUTPUT«(("FOO",).list, "bar baz")» | ||
dram | r: say qq:ww/FOO "bar baz"/.perl; | 10:11 | |
camelia | rakudo-parrot 2c40f6, rakudo-jvm 2c40f6: OUTPUT«("FOO", "bar baz")» | ||
dram | Is this a bug? | ||
moritz | looks like it | 10:12 | |
dram | n: my $foo = "FOO"; say qq:ww/$foo "bar baz"/.perl; | 10:14 | |
camelia | niecza v24-98-g473bd20: OUTPUT«("FOO", "\"bar", "baz\"").list» | ||
FROGGS creates rakudobug | 10:15 | ||
moritz | FROGGS++ dram++ | 10:16 | |
the fix might be simply calling .list on the result (in the compiler, that is) | |||
dram | ok, i'll file a bug. | 10:17 | |
FROGGS | dram: see rt.perl.org/Ticket/Display.html?id...c0d93413a8 | ||
dram | thx. | 10:18 | |
FROGGS | you could try to fix it now that I've filed the bug report for you :P | ||
dram | I'm new to perl6. just several days. :) | 10:22 | |
10:25
brrt joined
10:26
rurban left
10:27
rurban joined,
woosley left
10:35
pernatiy left
10:50
rindolf joined
10:51
pernatiy joined
10:54
rurban1 joined
|
|||
timotimo | so I've been thinking, before i could get any sleep, that to make keeping the NFA's work is not terribly hard | 11:05 | |
first, the optimizer needs to know exactly how long the declarative prefix was, and it needs to know that the NFA has, in fact, matched this piece of the QRegex | 11:06 | ||
then, it needs to analyze the positions of capture groups. if they are constant, it can generate operations that just skip N characters, if not, it has to stop its work | |||
so it would turn [ foo (...) | bar (...) ] into a concat of skip 3, push cstack (or how it does the capturing), skip another 3, push cstack again (for the end of capture, right?) for both branches of the alt. | 11:07 | ||
the tricky part is: does the NFA hang off of one of these nodes? do i have to be careful not to replace it? | 11:10 | ||
i know the NFA gets created the moment the QRegex is generated in the Actions, which is long before the optimizer starts running | |||
11:15
jaffa4 joined
11:18
iSlug left
|
|||
timotimo | what does being a 10x programmer mean? :| | 11:21 | |
brrt | timotimo, i have no idea | 11:23 | |
i suspect that 'management is able to get what they want 10x easier' | |||
it certainly doesn't seem to correspond to one particular attribute | |||
timotimo | that sounds more like "being a pushover" :P | 11:24 | |
brrt | true | ||
brrt is thinking | |||
there is, i think, also some part to the 10x engineer meme that says: 'all these other guys are stupid' | 11:25 | ||
timotimo | i guess i'll spend the day trying to write code to analyse the absolute widths of matching thingies | ||
brrt | i.e. the implication of being a special human being | ||
or at least, that there are such special humans | |||
:-) | |||
timotimo | that doesn't sound much like a compliment to me. at least not one i'd like to get | ||
brrt | hmmm | 11:26 | |
maybe i'm thinking of it in a different context | |||
11:26
rurban1 left,
beee joined,
dram_ joined,
daxim_ joined
|
|||
brrt | perhaps the simplest way to explain it is: what used to be a 'rockstar developer | 11:26 | |
' | |||
timotimo | i don't like these people :| | 11:27 | |
.o( node.js is badass rockstar tech! ) | |||
brrt | neither do i | 11:28 | |
things can be awesome / exciting in their own right | |||
moritz | timotimo: there's a very old meme on the internet that there are some '10x' programmers that are 10 times as efficient as the average programmer, whoever that may be | ||
brrt | but to be excited about writing callback based servers is valid, but still a bit geeky :-) | 11:29 | |
… what moritz said | |||
moritz | and every month there's a blog post denying the fact that such a thing exists | ||
11:29
dram left
|
|||
brrt | the question is what 'efficient' even means | 11:29 | |
11:29
dram_ is now known as dram
|
|||
brrt | which is why i offered: get what management wants | 11:29 | |
moritz | and two others springing up in response citing examples or anecdotes | ||
timotimo | i see | 11:30 | |
locally, rakudo-jvm is failing isDeprecated and deprecations, is that known? | |||
it fails all of the tests | |||
brrt is bored by the internet | |||
moritz | timotimo: I think I've see that too | ||
brrt | bye folks :-) | ||
moritz | brrt: build a new one :-) | ||
timotimo | good | ||
brrt | would-like-too | ||
11:31
brrt left,
iSlug joined
|
|||
timotimo | moritz: do you see an obvious flaw with my musings above? | 11:32 | |
the only thing i can think of is that there are a few dangerous things i'll have to keep in mind, like \n sometimes being 2 characters instead of 1 | 11:33 | ||
moritz | well, you have to keep track of match lengths | ||
of all of them | |||
and there are funny things going on with case-insensitive matching | 11:34 | ||
/ß/i matching 'SS' and all that | |||
FROGGS | it matches the uppercase ß unicode thingy too | ||
timotimo | i don't have to keep track of all of them, it'll already be a performance benefit if i only do as much as possible | 11:35 | |
like, up until i find a match that's possibly mobile | |||
daxim_ | I call for abolishment of uc(ß) == SS | ||
FROGGS | daxim: me too | ||
timotimo | that can't be the only example, though | 11:36 | |
but good point. i'll just go with a whitelist-approach instead of a blacklist-approach then :P | |||
moritz | iirc it's the only example on the grapheme level | ||
but there are also funny things on the codepoint level | |||
timotimo | i'm working on the (wrong) assumption that we are already at grapheme-level :P | ||
moritz | like if you have a composed character, and the case-folded equivalent only exists as decomposed (does that case occur in real-life Unicode?) | 11:37 | |
timotimo | because most of our regex engine does, too, i think | ||
moritz | none of it does | ||
11:37
beee left
|
|||
moritz | it works all on the codepoint level :( | 11:37 | |
timotimo | er | ||
well ... :| | |||
FROGGS | but they all *should* work on grapheme level | ||
but only moarvm will get there I fear, right? | 11:38 | ||
11:39
daxim left,
daxim_ is now known as daxim
|
|||
timotimo | hopefully our jvm port will, too | 11:39 | |
FROGGS | yeah, I just don't know enough of the impl. to muse about NFG | 11:41 | |
nwc10 | I haven't read scrollback, but the fun one is /ss/i matches "ß". | 11:42 | |
OK, so what are the captures for "ß" =~ /(s)(s)/i; # expressed in p5 syntax | |||
daxim | burn it! with fire! | ||
nwc10 | you can do it with other folding. that's just the most common example. (of "Unicode consortium didn't think it through") | 11:43 | |
daxim | I'm going to release Lingua::DEU::Casing::Sharp_s in december | 11:44 | |
11:45
leont joined,
dram left
|
|||
daxim | r: print "\x{1F4A9}" | 11:46 | |
camelia | rakudo-parrot 2c40f6: OUTPUT«===SORRY!===Unrecognized backslash sequence: '\x'at /tmp/PhWcX7u3sY:1------> print "\⏏x{1F4A9}"Unable to parse expression in block; couldn't find final '}' at /tmp/PhWcX7u3sY:1------> print "\…» | ||
..rakudo-jvm 2c40f6: OUTPUT«===SORRY!===Unrecognized backslash sequence: '\x'at /tmp/vFKZ1XXmJV:1------> print "\⏏x{1F4A9}"Unable to parse expression in block; couldn't find final '}' at /tmp/vFKZ1XXmJV:1------> print "\x{1…» | |||
FROGGS | r: print "\x1F4A9" | 11:47 | |
camelia | rakudo-parrot 2c40f6, rakudo-jvm 2c40f6: OUTPUT«💩» | ||
daxim | r: print "\x666" | ||
camelia | rakudo-parrot 2c40f6, rakudo-jvm 2c40f6: OUTPUT«٦» | ||
FROGGS | r: print "\x1E9E" | 11:48 | |
camelia | rakudo-parrot 2c40f6, rakudo-jvm 2c40f6: OUTPUT«ẞ» | ||
11:48
dmol left
11:50
tgt joined
|
|||
timotimo made a questhub quest to organize his thoughts | 11:57 | ||
11:59
go|dfish joined
12:04
iSlug left
12:06
rindolf left
|
|||
moritz | quest: organize my thoughts | 12:07 | |
leont | Maybe interesting for perl6 people too: www.nntp.perl.org/group/perl.qa/201...13531.html | 12:08 | |
Not that I have much of a clue about the state of QA in perl6 | |||
moritz | sounds like an awesome hackathon | 12:09 | |
leont: we're much in need of QA :-) | |||
leont | I've heard the Test::Builder 2 is a rather good design (except for it using Mouse), possibly porting it over is useful. | 12:12 | |
A better harness may be desirable too (the current one rather reminds me of perl 5.000's, in having the minimum required features) | 12:13 | ||
But without a good Builder, additional testing modules just wouldn't scale well | 12:17 | ||
12:25
rurban1 joined
12:28
denis_boyun_ left
12:33
dmol joined
12:38
denis_boyun joined,
dmol left
|
|||
timotimo made the rakudo optimizer unfold junctions insied when, like { when Int | Str { ... } } | 12:41 | ||
spectests look good, but there's not terribly many spectests for this kind of thing anyway | 12:45 | ||
moritz | add some :-) | ||
timotimo | r: my $_ = []; when {$^a.push(100)}|{$^a.push(200)} { say "what am i doing" } | ||
camelia | rakudo-jvm 2c40f6: OUTPUT«Potential difficulties: Redeclaration of symbol $_ at /tmp/HHsNjTkslR:1 ------> my $_ ⏏= []; when {$^a.push(100)}|{$^a.push(200what am i doing» | ||
..rakudo-parrot 2c40f6: OUTPUT«Potential difficulties: Redeclaration of symbol $_ at /tmp/FkGZ_DN6AW:1 ------> my $_ ⏏= []; when {$^a.push(100)}|{$^a.push(200what am i doingsucceed without when clause in block at gen/parrot/CORE.settin…» | |||
timotimo | r: $_ = []; when {$^a.push(100)}|{$^a.push(200)} { say "what am i doing" } | 12:46 | |
camelia | rakudo-parrot 2c40f6: OUTPUT«what am i doingsucceed without when clause in block at gen/parrot/CORE.setting:547 in block at gen/parrot/CORE.setting:611 in block at /tmp/Q7gX7NTN27:1 in any at /tmp/Q7gX7NTN27:1 in any at gen/parrot/stage2/NQPHLL.nqp:1146…» | ||
..rakudo-jvm 2c40f6: OUTPUT«what am i doing» | |||
timotimo | r: $_ = []; when {$^a.push(100)}|{$^a.push(200)} { say "what am i doing" }; .say; | ||
camelia | rakudo-jvm 2c40f6: OUTPUT«what am i doing» | ||
..rakudo-parrot 2c40f6: OUTPUT«what am i doingsucceed without when clause in block at gen/parrot/CORE.setting:547 in block at gen/parrot/CORE.setting:611 in block at /tmp/3_LyQ_dxru:1 in any at /tmp/3_LyQ_dxru:1 in any at gen/parrot/stage2/NQPHLL.nqp:1146…» | |||
timotimo | r: $_ = []; when {$^a.push(100)}|{$^a.push(200)} { say "what am i doing" }; $_.say; | ||
camelia | rakudo-jvm 2c40f6: OUTPUT«what am i doing» | ||
..rakudo-parrot 2c40f6: OUTPUT«what am i doingsucceed without when clause in block at gen/parrot/CORE.setting:547 in block at gen/parrot/CORE.setting:611 in block at /tmp/HklmK3NmTz:1 in any at /tmp/HklmK3NmTz:1 in any at gen/parrot/stage2/NQPHLL.nqp:1146…» | |||
timotimo | well ... | ||
12:47
rurban1 left
|
|||
timotimo | r: $_ = []; given $_ { when {$^a.push(100)}|{$^a.push(200)} { say "what am i doing" }; } $_.say; | 12:47 | |
camelia | rakudo-jvm 2c40f6: OUTPUT«===SORRY!=== Error while compiling /tmp/KBuM9FVL_yConfusedat /tmp/KBuM9FVL_y:1------> push(200)} { say "what am i doing" }; } ⏏$_.say; expecting any of: postfix statement end …» | ||
..rakudo-parrot 2c40f6: OUTPUT«===SORRY!=== Error while compiling /tmp/j21uguGTV6Confusedat /tmp/j21uguGTV6:1------> push(200)} { say "what am i doing" }; } ⏏$_.say; expecting any of: postfix statement end …» | |||
timotimo | r: $_ = []; given $_ { when {$^a.push(100)}|{$^a.push(200)} { say "what am i doing" }; }; $_.say; | ||
camelia | rakudo-parrot 2c40f6, rakudo-jvm 2c40f6: OUTPUT«what am i doing100» | ||
timotimo | seems to still "work" | ||
well, this optimization has less chance to fail, because there's no side-effects that result from evaluating $_ | 12:50 | ||
... i guess unless you make it a proxy. in which case, what the hell are you doing! :D | 12:51 | ||
but even that will only evaluate $_ once | |||
so, now that i have a rakudo commitbit, is it "easier to ask for forgiveness than for permission"? | 12:53 | ||
FROGGS | hmm? | ||
moritz | +1 | ||
12:54
tgt left
|
|||
timotimo | FROGGS: i'm asking if i should push what i think is working code, or if i should ask for reviews before going ahead | 12:54 | |
FROGGS | timotimo: if you are "sure" that it is all right then go ahead | 12:55 | |
12:55
markov left
|
|||
FROGGS | if you feel uncomfortable with it, push to a branch or so :o) | 12:55 | |
timotimo | i feel comfortable with this, as soon as the spectest run has finished :) | 12:56 | |
FROGGS | that is a good way to do it :o) | ||
timotimo: what backend are you spectesting? | |||
I can do the other then | |||
timotimo | jvm at the moment | 12:57 | |
12:57
dmol joined
|
|||
moritz runs a p-spectest as baseline | 12:58 | ||
12:58
tgt joined
|
|||
timotimo notices he doesn't actually have the commitbit | 12:59 | ||
it's now in timo/rakudo on the "when_junctions_unfold" branch | |||
timotimo publicizes his membership of the rakudo organisation | 13:02 | ||
github.com/rakudo?tab=members - i'm the only one in it now :P | |||
there's lots of concealed members in the perl6 organisation, too. FROGGS, you for example | |||
FROGGS | done | 13:03 | |
timotimo: thanks :o) | |||
13:05
lizmat left
13:06
pernatiy left
13:07
tgt left
|
|||
timotimo | so i'm in the organisation, but can't actually commit to the rakudo repository, huh | 13:07 | |
FROGGS | you are in there due to PRs | 13:08 | |
timotimo | jvm spectest looks clean | ||
13:09
denis_boyun__ joined
13:10
denis_boyun left
|
|||
timotimo | i think i need zram on my desktop >_< | 13:11 | |
yeah, looks clean | 13:17 | ||
timotimo force-pushed over the branch to make a proper PR | 13:18 | ||
13:19
pdurbin left
|
|||
timotimo | github.com/rakudo/rakudo/pull/228 - feel free to pull it in | 13:19 | |
moritz loves the fact that he can now run a j-spectest and at the same time rebuild rakudo-p | |||
timotimo loves that he can run a j-install or j-spectest without having to rebuild rakudo-p first | 13:20 | ||
moritz++ # pretty fantastic build system | |||
dalek | kudo/nom: b0bf4d5 | (Timo Paulssen)++ | src/Perl6/Optimizer.nqp: allow junction unfolding for callmethod ACCEPTS |
13:21 | |
kudo/nom: b11094e | (Tobias Leich)++ | src/Perl6/Optimizer.nqp: Merge pull request #228 from timo/when_junctions_unfold allow junction unfolding for callmethod ACCEPTS |
|||
woolfy | timotimo: congrats with your commitbit! | ||
timotimo | woolfy: i was mistaken, i don't actually have it yet :( | 13:22 | |
woolfy | oowowwwww... too bad | ||
13:22
tgt joined
|
|||
timotimo | good things come to those who wait :P | 13:22 | |
FROGGS | *g* | 13:23 | |
woolfy | I'll retract the congrats and put them in the fridge for you, I hope they stay good | ||
dalek | p: aa14903 | (Timo Paulssen)++ | src/vm/jvm/QAST/Compiler.nqp: factor out a common instruction |
13:26 | |
p: 5a95294 | (Timo Paulssen)++ | src/vm/ (2 files): don't try to match \r\n for negated or zerowidth whitespace cclasses |
|||
13:27
denis_boyun__ left
13:33
leont left
13:34
ajr joined
13:35
ajr is now known as Guest65187,
Guest65187 is now known as ajr_
13:36
kivutar left
13:40
dakkar left
|
|||
timotimo is attempting to implement for @arr -> $foo, $bar? in NQP | 13:40 | ||
13:42
dakkar joined
|
|||
arnsholt | timotimo++ | 13:47 | |
timotimo | how do i clear a register? | 13:48 | |
moritz | clear? | ||
assign a defined value to it? | 13:49 | ||
timotimo | pretend i never did, so to speak | ||
my current bug is that for 1, 2, 3, 4, 5 -> $a, $b? will give 1 2, 3 4, 5 4 | |||
because i don't clear the $b register if the list is finished | |||
it's a _p register, if that makes a difference | 13:50 | ||
moritz | set it to NQPMu? | ||
timotimo | i'll try that | ||
13:51
fhelmberger left
|
|||
timotimo | nqp_get_sc_object $P5006, "7A67D46DDEA3C60BB73DFB1CA4F76715F3D1212C-1384263841.80708", 26 - this apparently gets NQPMu; how do i emit a pirop in Operations.nqp that does the right thing? | 13:52 | |
oh, maybe there's an op i can emit that just returns NQPMu? like nqp::null? | |||
nqp: say(nqp::null()) | |||
camelia | nqp-jvm: OUTPUT«java.lang.NullPointerException in (gen/jvm/stage2/NQPCORE.setting:672) in print (gen/jvm/stage2/NQPCORE.setting:671) in say (gen/jvm/stage2/NQPCORE.setting:678) in (/tmp/ex7apG0lGy:1) in (gen/jvm/stage2/NQPHLL.nqp:1100) in eval (gen/jvm/sta…» | ||
..nqp-parrot: OUTPUT«Null PMC access in get_string()current instr.: '' pc 768 (gen/parrot/stage2/NQPCORE.setting.pir:355) (gen/parrot/stage2/NQPCORE.setting:665)» | |||
..nqp-moarvm: OUTPUT«» | |||
timotimo | that's not quite it :| | ||
moritz | QAST::WVal.new( :value($*W.find_sym(['NQPMu'])) ); | 13:53 | |
arnsholt | timotimo: In the code gen, you probably want to set it to something like QAST::WVal.new( :value($*W.find_sym(['NQPMu'])) ) | ||
Bah, sniped =) | |||
moritz | (copy&paste)++ # faster than arnsholt++ :-) | ||
arnsholt | I copy-pasted as well | ||
I just had to open a terminal and get to the directory and then git grep =) | 13:54 | ||
timotimo | can i do something like self.as_post(QAST::WVal.new(...))? | ||
13:54
nnunley joined
|
|||
moritz | uhm, not sure if $*W is still around in the optimizer :( | 13:54 | |
timotimo | this is not in the optimizer | 13:55 | |
arnsholt | Doing this in the optimizer, though? That sounds weird... | ||
timotimo | this is in Operations.nqp | ||
arnsholt | Why does it have to be done in Operations.nqp? | ||
moritz | no idea if $*W is around then | ||
timotimo | arnsholt: because that's where 'for' is implemented. | 13:56 | |
arnsholt | Oh, right. Of course | 13:57 | |
13:57
fhelmberger joined
|
|||
timotimo | :) | 13:57 | |
i'll see what happens if i just null the register | |||
14:00
kaleem left
|
|||
timotimo | probably Terrible Things | 14:00 | |
14:01
logie joined
|
|||
timotimo | yup, NPMCA, as expected | 14:01 | |
er, i don't know how to make a QAST::Op for bind that binds into the register i have allocated for my operation | 14:03 | ||
as i don't have a var to write to | |||
maybe QAST::VM is needed here | 14:04 | ||
moritz | maybe a QAST::Op.new(:pirop<set>, '$P22', ....) | ||
and yes, QAST::VM then | |||
though I wonder if there shouldn't be a simpler way | |||
timotimo | i think there should be, but what do i know :) | 14:05 | |
in the worst case, the for opcode will get an argument that passes a NQPMu to it | 14:06 | ||
diakopter | so we were walking to breakfast and were suddenly in the middle of SUSEcon | ||
timotimo | i'll have to find out how to do the same for Moar and jvm, too :| | ||
diakopter | and tadzik is like, "is Novell still a thing?" | ||
timotimo | moritz: feel free to praise me in the blog post about the optimisation for scan + literal :D | 14:07 | |
Error while compiling op for (source text: "@a -> $a, $b? { say(\"$a $b\") }"): Method 'find_lexical' not found for invocant of class 'NQPMu' | |||
it seems like i don't have access to $*W at this point | 14:08 | ||
i may have to generate one call instruction for each number of actually existing arguments :| | |||
arnsholt | Yeah, I think $*W is set in the TOP rule, so by the time code-gen rolls around it's not there | ||
timotimo | yeah, that makes sense | ||
diakopter | so then tadzik is like "we would fit in just fine with our Perl shirts." | 14:11 | |
14:11
pernatiy joined
|
|||
diakopter | which isn't true, but mostly because they're all in business formal attire | 14:11 | |
14:12
ggoebel15 joined
14:13
woolfy left
|
|||
diakopter | woolfy: what does the oolfy stand for? | 14:14 | |
timotimo cleaned his whiteboard | 14:17 | ||
ready for some sketchion! | |||
14:18
lizmat joined,
tgt left
|
|||
diakopter | timotimo: is that a tasty breakfast treat? | 14:19 | |
14:20
kivutar joined
|
|||
timotimo | it could be :) | 14:21 | |
14:27
lue left
14:28
lowpro30 joined
|
|||
timotimo made a quest for it: questhub.io/realm/perl/quest/52823b...b3340000c9 | 14:28 | ||
14:31
rurban1 joined
|
|||
FROGGS | I'd guess the output is "1,\n2,\n3,\n" | 14:31 | |
like there is missing the comma after the 3 above | 14:32 | ||
timotimo | edited, thanks | 14:33 | |
PerlJam | greetings! | ||
moritz | \o PerlJam | 14:34 | |
PerlJam reminds everyone that advent season is nigh. | |||
Add yourselves to github.com/perl6/mu/blob/master/mi...3/schedule | |||
read github.com/perl6/mu/blob/master/mi...instorming for ideas if you don't have any | 14:35 | ||
(please add to topic-brainstorming too) | |||
moritz has trouble finding interesting topics that haven't been chewed out in the advent before | |||
PerlJam | moritz: yeah, I know the feeling | ||
moritz | and I must be competent to write about it | ||
PerlJam | ditto | ||
moritz | so, what have I done this year in the rakudo world? | 14:36 | |
build system? not a sexy topic | |||
timotimo | 1 2 | ||
3 4 | |||
5 | |||
\o/ | |||
FROGGS | \o/ | ||
moritz | a bit constant folding... not too exciting either | ||
timotimo++ | |||
14:37
lowpro30_ joined
|
|||
moritz | lots of small cleanups and corrections... not exciting either | 14:37 | |
14:37
fhelmberger left
|
|||
PerlJam | moritz: small, unsexy things, in aggregate, can be exciting :) (probably not ever sexy though :) | 14:37 | |
dalek | p/optional_for_arguments: 38333d3 | (Timo Paulssen)++ | src/ (3 files): teach nqp-p about optionals in loop blocks |
14:38 | |
timotimo | could a post about jnthns workshop be interesting to our audience? | ||
PerlJam | timotimo: yes | ||
timotimo | feel free to play with my optional_for_arguments branch and try to break it, please | ||
moritz | labster: would you blog about dir(), File::Path etc. on the p6 advent calendar? | 14:39 | |
14:39
lowpro30 left
|
|||
moritz | I could write about custom EXPORT subs :-) | 14:40 | |
14:40
lue joined
|
|||
moritz | oh, I know what I did this year: sink context | 14:41 | |
and I wish I hadn't | |||
timotimo | :( | ||
14:42
fhelmberger joined
|
|||
timotimo | what did I do all year? :\ | 14:42 | |
hm. i think i started my perl6 stuff a month or two before the advent calendar last year | 14:43 | ||
moritz | timotimo: you could blog about your experience contributing to Perl 6, as a relative newcomer | 14:44 | |
PerlJam | that sounds like an excellent topic | ||
timotimo | ... no pressure! :P | ||
14:45
lizmat left,
kaare_ joined,
raiph joined
14:46
lizmat joined
|
|||
PerlJam would like to see an advent post (or two) from lizmat about all the clean ups she's done :) | 14:46 | ||
timotimo | i wish i could finish my "is nodal" work before the advent calendar | ||
PerlJam | Heck, she could re-package her YAPC::NA lightning talk and that would be awesome | 14:47 | |
It would make an excellent Dec 1 post even | 14:48 | ||
14:50
bluescreen10 joined
|
|||
timotimo | oh! oh crap! | 14:50 | |
i don't handle redo at all at the moment :o | 14:51 | ||
if there's optional parameters, there has to be one redo for each! | |||
(for each amount of optionals that were present) | |||
where can i look to figure out how parrot does label calculation? | |||
moritz | label calculation? What's that? | 14:52 | |
you mean in the PIR -> PBC step? | 14:53 | ||
timotimo | er, no | ||
14:53
btyler joined
|
|||
timotimo | hopefully i could just replace the redo label just before each call | 14:53 | |
moritz doesn't quite understand, but has to leave anyway | 14:54 | ||
timotimo | so, more like "label arithmetics" | ||
a bit like "pointer arithmetics" | |||
or i'd have to build a "dispatcher" for the redo that looks at some integer register and jumps to the right label given its value | 14:55 | ||
that would suck :( | |||
14:56
rurban1 left
|
|||
colomon | Day 1 should be the state of Perl 6, shouldn't it? talk about JVM and Moar, how to get rakudo installed these days, etc. | 14:57 | |
timotimo | that's already in the schedule :) | ||
(but not with a name) | |||
PerlJam | Well, I make Day 1 be "State of Perl 6" out of habit because I think it's a good way to start off advent. There's nothing that says it *must* be that. | 14:58 | |
15:00
rurban1 joined
|
|||
PerlJam | But there should be some post that talks about the Perl 6 ecosystem in any case. | 15:01 | |
colomon | there's a schedule already? | ||
PerlJam | an empty one, but yeah | 15:02 | |
github.com/perl6/mu/blob/master/mi...3/schedule | |||
15:02
denis_boyun joined
|
|||
PerlJam | colomon: got any interesting topics you want to do for advent? | 15:02 | |
last year the schedule came together kind of at the last minute. That always makes me nervous. | 15:03 | ||
timotimo | how come there's no mention of concurrency/parallelism/asynchronicity? | ||
colomon | PerlJam: I've been pondering recoding what I've been working on in C++ in p6 and posting on it. It would be a quick small example of how cool given / when and grammars are. | 15:04 | |
PerlJam: I even have some hope I might have enough free time to write it. ;) | 15:05 | ||
PerlJam | colomon: sounds excellent! :) | ||
timotimo: feel free to add it to the topics | |||
(or, better, claim a day for that topic yourself :) | |||
timotimo | i don't feel like i'm the right person to write about it | 15:06 | |
i don't have much experience in parallelism and stuff | |||
15:07
lowpro30 joined
|
|||
PerlJam | A post on NativeCall for the JVM would be nice too. | 15:07 | |
15:08
kaleem joined
|
|||
timotimo | let's hope it's in a releasable state until then | 15:09 | |
PerlJam | Even if it's just "this is almost done, but here's a tiny bit that works" I think it would use useful/interesting. | 15:10 | |
s/use/be/ | |||
15:10
lowpro30_ left
|
|||
colomon | PerlJam: another thought: redo the old Mandelbrot code (used twice before for Advent, I think?) using parallel code in JVM. | 15:14 | |
might nicely emphasis the performance improvements we've had this year. | 15:15 | ||
15:16
dmol left,
jeffreykegler joined,
dmol joined
|
|||
dalek | : 1395dd5 | duff++ | misc/perl6advent-2013/topic-brainstorming: add some topics |
15:16 | |
15:17
iSlug joined
15:18
ingy2^ joined
15:21
jeffreykegler_ joined,
denis_boyun left
|
|||
PerlJam | Now, we just need people to claim days and topics | 15:21 | |
15:22
thou joined,
ingy2^ left,
jeffreykegler left
15:23
tgt joined
15:29
atroxaper joined
|
|||
timotimo | nqp: my $num := 10; while $num > 0 { $num := $num - i; }; | 15:30 | |
excellent typo ... | |||
camelia | nqp-moarvm, nqp-jvm, nqp-parrot: OUTPUT«(timeout)» | 15:31 | |
PerlJam | does nqp grok i? | ||
tadzik | hahaaha | ||
timotimo | i think it is NQPMu instead | ||
nqp: say(i) | |||
camelia | nqp-moarvm, nqp-jvm, nqp-parrot: OUTPUT«» | ||
timotimo | like everything :) | ||
nqp: say(NQPMu) | |||
camelia | nqp-moarvm, nqp-jvm, nqp-parrot: OUTPUT«» | 15:32 | |
tadzik | well, at least ita's not i vs $i | ||
15:32
rurban1 left
|
|||
timotimo | :) | 15:32 | |
tadzik | imagine my $i = 0; i < 5; $i++ | 15:33 | |
dat horror | 15:34 | ||
timotimo | :D | ||
15:34
woolfy joined
|
|||
colomon | rn: say i < 5 | 15:35 | |
camelia | rakudo-jvm b11094: OUTPUT«Cannot call 'Real'; none of these signatures match::(Mu:U \v: Mu *%_) in any at gen/jvm/BOOTSTRAP.nqp:1201 in sub infix:<<> at gen/jvm/CORE.setting:3971 in sub infix:<<> at gen/jvm/CORE.setting:3971 in block at /tmp/81k5wPDMMc:1 in …» | ||
..rakudo-parrot b11094: OUTPUT«Cannot call 'Real'; none of these signatures match::(Mu:U \v: Mu *%_) in any at gen/parrot/BOOTSTRAP.nqp:1218 in any at gen/parrot/BOOTSTRAP.nqp:1209 in method Real at gen/parrot/CORE.setting:990 in sub infix:<<> at gen/parrot/CORE.s…» | |||
..niecza v24-98-g473bd20: OUTPUT«Unhandled exception: Complex numbers are not arithmetically ordered; use cmp if you want an arbitrary order at /tmp/mME5Yg143X line 1 (mainline @ 3)  at /home/p6eval/niecza/lib/CORE.setting line 4583 (ANON @ 3)  at /home/p6eval/niecza/lib/C…» | |||
tadzik | niecza wins | 15:36 | |
jnthn | timotimo: I glanced your patch. It adds 8 bytes to every single QAST node for one feature we only sorta need in NQP, so in its current form it's worse than what it cures... | 15:38 | |
timotimo: I'd just assume if we do have arity > 1 set then the others were marked as optional. It may not be true, but if we didn't we're screwed anyway, and also we'll get an error like full Perl 6 gives (not enough args passed) | 15:39 | ||
timotimo | thanks. got a suggestion for how to make it better? | ||
add optarity using a role that only sometimes exists? | 15:40 | ||
jnthn | What I just wrote? :) | ||
No, just keep arity | |||
And assume. | |||
(that all but the first one are potentially optional) | |||
timotimo | wait, why? | ||
jnthn | I don't think anything else is worth the complexity. | ||
timotimo | oh | ||
that's why | |||
yeah, i can do that | |||
do you have a suggestion for the redo problem? | 15:41 | ||
jnthn | r: my @a = 1,2,3; for @a -> $x, $y { } | ||
camelia | rakudo-parrot b11094: OUTPUT«Not enough positional parameters passed; got 1 but expected 2 in block at /tmp/nHohizSqqN:1 in any at /tmp/nHohizSqqN:1 in any at gen/parrot/stage2/NQPHLL.nqp:1146 in any eval at gen/parrot/stage2/NQPHLL.nqp:1133 in any evalfiles a…» | ||
..rakudo-jvm b11094: OUTPUT«Not enough positional parameters passed; got 1 but expected 2 in block at gen/jvm/CORE.setting:7270 in block at gen/jvm/CORE.setting:7106 in method gimme at gen/jvm/CORE.setting:7524 in block at /tmp/bGWE2CZbHX:1 in any eval at gen/jv…» | |||
jnthn | Note that with what I'm suggesting you'd get a consistnet error with ^^ :) | ||
redo problem? | |||
timotimo | yeah. at the moment i have one call for each amount of arguments the block may have populated | ||
a redo would have to find that same call branch again | |||
jnthn | But isn't the redo handler around the call? | 15:42 | |
timotimo | er, i should look closely | ||
jnthn | So you could have an approriate one for each on MoarVM as that is really cheap. | ||
On Parrot it's different and would make things more expensive, so I guess "save an integer" or whatever... | |||
This is turning into a lot of complexity for an edge case... | 15:43 | ||
timotimo | i can abort if you'd prefer | ||
15:44
lizmat_ joined
|
|||
jnthn | Well, it will bite people is all. I just hadn't thought about the redo thing when saying "let's fix it"... | 15:44 | |
timotimo | bite ... in what way? | ||
jnthn | Well, the bug god filed because somebody at the internals workshop actually ran into it | 15:45 | |
colomon is worried about appeasing the bug god | |||
timotimo | :D | ||
jnthn | uh | ||
got :D | |||
lol | |||
timotimo | if i implement the redo thing, it won't bite people? what am i misunderstanding here? | 15:46 | |
geekosaur was wondering... | |||
colomon suspects that masak is beloved by the bug god | |||
jnthn | timotimo: I'm just sayin gthat when I thought it should be fixed, I didn't think about the interaction with redo. | ||
timotimo: And now that I do, I realize it's not as easy a fix as I'd first imagined. | |||
timotimo | but that doesn't mean i shouldn't attempt the fix, right? | 15:47 | |
jnthn | I think go for it and just try to make sure the common case of for @a -> $x { ... } does not get more expensive for it. | ||
timotimo | sure thing | ||
at the moment, the common case is still a branch that doesn't get any different code at all | |||
i can keep it that way | |||
15:48
lizmat left
|
|||
jnthn | Preferable, provided it doesn't lead to loads of dupe | 15:48 | |
OK, I need to go catch boats and trains and stuff | |||
bbl | |||
timotimo | have fun! | ||
moritz | dupe, the programmer's anti-dope | ||
atroxaper | How can i call method of parent class from childe class? I don't find it in Using Perl6... | 15:49 | |
moritz | self.TheParent::themethod(@args) | 15:50 | |
atroxaper | moritz: cool. Thanks! | ||
moritz | or callsame/callwith, depending on the exact use case | ||
PerlJam | moritz: It's odd that you didn't lead off with callsame/callwith :) | 15:51 | |
atroxaper | Hmm... Very flexible | ||
PerlJam | perhaps it's just odd that I think callsame/callwith would be more commoon | ||
er, common even | |||
moritz | PerlJam: I cannot remember if call{same,with} work outside the context of multis | 15:52 | |
PerlJam: which is why the other alternative seemed safer to mention first | |||
PerlJam | ah | ||
perhaps atroxaper really wanted nextsame/nextwith too? | 15:53 | ||
The question didn't have enough information for me to tell | |||
15:53
jnap joined
|
|||
atroxaper | And one more question: whay i can't type grammar P6Gr is Perl6::Grammar {} ? I mean why P6Gr.parce throwing an exception? | 15:54 | |
moritz | perhaps because you have misspelled 'parse'? | ||
it would help to know what exception you get | |||
atroxaper | No ;) | ||
No such method 'submethod_table' for invocant of type 'NQPClassHOW' | 15:55 | ||
moritz | atroxaper: that's likely related to Perl6::Grammar being an NQP class, not a rakudo class | ||
would be nice if it worked, though | |||
atroxaper | use Perl6::Grammar:from<NQP>; use Perl6::Actions:from<NQP>; grammar P6Gr is Perl6::Grammar {}; say P6Gr.parse('my $b=4;', :actions(Perl6::Actions.new())).dump; | 15:56 | |
rp: use Perl6::Grammar:from<NQP>; use Perl6::Actions:from<NQP>; grammar P6Gr is Perl6::Grammar {}; say P6Gr.parse('my $b=4;', :actions(Perl6::Actions.new())).dump; | |||
camelia | rakudo-parrot b11094: OUTPUT«No such method 'submethod_table' for invocant of type 'NQPClassHOW' in any at gen/parrot/Metamodel.nqp:449 in any methods at gen/parrot/Metamodel.nqp:444 in any !protoregex_table at gen/parrot/stage2/QRegex.nqp:766 in any at gen/parrot/…» | ||
15:57
rurban1 joined,
rurban1 left,
rurban1 joined
|
|||
moritz | in that case I'd recommend delegation, not inheritance | 15:57 | |
that is, keep the NQP Perl6::Grammar as an attribute, don't inherit from it | 15:58 | ||
atroxaper | moritz: I am finding a way to find out a place where grammar failed (when we put some wrong stuff in parse method). And i'm thinking about overriding some method of Perl6::Grammar. | 15:59 | |
moritz | atroxaper: then it's likely easier to do that in NQP code | 16:00 | |
atroxaper | moritz: override panic method and get CURSOR object... | 16:01 | |
moritz | though it might be an easy fix in rakudo, lemmy try something... | 16:02 | |
atroxaper | How NQP code differ from Perl6? I mean what should i code? Just .nqp file? | ||
16:02
denis_boyun joined
|
|||
atroxaper | moritz: And use MyModule:from<NQP>; Right? | 16:03 | |
16:04
telex left
|
|||
atroxaper | What dows 'lemmy' mean? ) | 16:07 | |
16:08
telex joined
|
|||
FROGGS | let me | 16:08 | |
16:09
denis_boyun left
|
|||
moritz | atroxaper: NQP is more low level than NQP; I recommend looking at the existing example code in src/Perl6/Actions.nqp for example to get an idea how it looks | 16:10 | |
atroxaper | FROGGS: oh... Ok. I am not an English guy... | ||
FROGGS | (we neither) | ||
err, nqp is more low level than perl6 | |||
moritz | also 6guts.wordpress.com/2013/09/17/mat...ls-course/ has some pointers to documentation for NQP | ||
gfldex | does Perl6::Grammar throw exceptions? | ||
FROGGS | gfldex: yes | ||
rp: 07; # that is why we have this bug | 16:11 | ||
camelia | rakudo-parrot b11094: OUTPUT«Potential difficulties: Leading 0 does not indicate octal in Perl 6; please use 0o7 if you mean that at /tmp/k3Imm_22mr:1 ------> 07⏏; # that is why we have this bug Leading 0 does not indicate octal in Perl 6…» | ||
FROGGS | the bug is that it warns twice | ||
16:11
tgt left
|
|||
atroxaper | moritz: ok. thank you. I will try to inherit grammar by NQP. | 16:12 | |
16:13
tgt joined
16:14
ingy2^ joined
|
|||
atroxaper | moritz: I know what NQP is. I just dont know how i can write nqp module and import it in Perl6 code ) | 16:14 | |
16:14
tgt left
16:15
raiph left
|
|||
moritz | atroxaper: you seem to be doing fine :-) | 16:16 | |
atroxaper | moritz: glad to hear :-) | 16:17 | |
colomon | PerlJam: just realized I've already written like a third of the code I was thinking I was going to have to write for the advent post I was thinking of. ;) | 16:18 | |
16:18
tgt joined
16:19
dmol left
|
|||
PerlJam | colomon: nice | 16:19 | |
16:20
iSlug left
|
|||
colomon | also, I think I found a major shortcoming in my C++ implementation. :\ | 16:20 | |
r: say "1f".base(16) | 16:21 | ||
camelia | rakudo-parrot b11094: OUTPUT«No such method 'base' for invocant of type 'Str' in block at /tmp/57ANSoL8Sv:1 in any at /tmp/57ANSoL8Sv:1 in any at gen/parrot/stage2/NQPHLL.nqp:1146 in any eval at gen/parrot/stage2/NQPHLL.nqp:1133 in any evalfiles at gen/parrot/…» | ||
..rakudo-jvm b11094: OUTPUT«No such method 'base' for invocant of type 'Str' in block at /tmp/8zyzVgMb7B:1 in any eval at gen/jvm/stage2/NQPHLL.nqp:1086 in any evalfiles at gen/jvm/stage2/NQPHLL.nqp:1292 in any command_eval at gen/jvm/stage2/NQPHLL.nqp:1196 in any…» | |||
colomon | r: say "1f".hex | ||
camelia | rakudo-parrot b11094: OUTPUT«No such method 'hex' for invocant of type 'Str' in block at /tmp/_K2yVe0vjG:1 in any at /tmp/_K2yVe0vjG:1 in any at gen/parrot/stage2/NQPHLL.nqp:1146 in any eval at gen/parrot/stage2/NQPHLL.nqp:1133 in any evalfiles at gen/parrot/s…» | ||
moritz | atroxaper: I have a local patch that gets rid of the error message (inheriting from an NQP class), but a new problem appears then | ||
camelia | ..rakudo-jvm b11094: OUTPUT«No such method 'hex' for invocant of type 'Str' in block at /tmp/tG0N9j1Hzk:1 in any eval at gen/jvm/stage2/NQPHLL.nqp:1086 in any evalfiles at gen/jvm/stage2/NQPHLL.nqp:1292 in any command_eval at gen/jvm/stage2/NQPHLL.nqp:1196 in any …» | ||
moritz | P6opaque only supports type changes where the MRO of the original type is a suffix of the MRO of the new type | ||
colomon | r: say :16("1f") | 16:22 | |
camelia | rakudo-parrot b11094, rakudo-jvm b11094: OUTPUT«31» | ||
16:22
[Sno] left
|
|||
colomon does not know why he always forgets that. | 16:22 | ||
moritz | I don't know why the subcllass'es MRO shouldn't be a suffix of the superclasses' MRO | ||
atroxaper | MRO ? | 16:23 | |
moritz | maybe related to automatically adding Mu? | ||
atroxaper: method resolution order | |||
16:23
zakharyas left
|
|||
moritz | a linearization of the tree of parent classes | 16:23 | |
16:23
raiph joined
|
|||
atroxaper | moritz: General i don't want to rid error message. I want to get a CURSON in that moment for getting position of cursor. | 16:25 | |
CURSOR i mean | 16:26 | ||
gfldex | atroxaper: did you try to catch the excpetion? | 16:30 | |
atroxaper | moritz: can i just override Perl6::Grammar.panic method to get my $cursor_class field of HLL::Grammar ? ) | ||
FROGGS | moritz: I hit the same problem when trying to make v5 a proper module | 16:31 | |
colomon | r: my $hex = "AFFD" ~~ / [<[0..9]> | <[A..F]>]+/; say $hex | ||
camelia | rakudo-parrot b11094, rakudo-jvm b11094: OUTPUT«「AFFD」» | ||
colomon | r: my $hex = "AFFD" ~~ / [<[0..9]> | <[A..F]>]+/; say :16($hex) | ||
camelia | rakudo-parrot b11094: OUTPUT«Nominal type check failed for parameter '$str'; expected Str but got Match instead in sub unbase at gen/parrot/CORE.setting:6513 in block at /tmp/YZPYMJN5ss:1 in any at /tmp/YZPYMJN5ss:1 in any at gen/parrot/stage2/NQPHLL.nqp:1146 …» | ||
..rakudo-jvm b11094: OUTPUT«Nominal type check failed for parameter '$str' in block at /tmp/zzAFioQMzP:1 in any eval at gen/jvm/stage2/NQPHLL.nqp:1086 in any evalfiles at gen/jvm/stage2/NQPHLL.nqp:1292 in any command_eval at gen/jvm/stage2/NQPHLL.nqp:1196 in any c…» | |||
colomon | bug or just LTA? | ||
FROGGS | moritz: so it would be nice if we could brainstorm a bit about that, maybe with jnthn | 16:32 | |
moritz | atroxaper: I have no idea | ||
colomon | r: my $hex = "AFFD" ~~ / [<[0..9]> | <[A..F]>]+/; say :16(~$hex) | ||
moritz | colomon: LTA bug :-) | ||
camelia | rakudo-parrot b11094, rakudo-jvm b11094: OUTPUT«45053» | ||
atroxaper | gfldex: no. but i think that catching dont help me in that case... | ||
moritz | colomon: well, kinda, (more) | ||
colomon: I think that :16(...) intentionally doesn't use Cool for its arguments | |||
16:32
tgt_ joined,
dbr left
|
|||
moritz | colomon: so that we can catch the case where people pass integers to :16(), because they are confused | 16:32 | |
colomon | ah | 16:33 | |
it's obviously easy to work around... | |||
atroxaper | moritz: ok. i will try. | ||
16:34
tgt left,
tgt_ is now known as tgt,
FROGGS left
|
|||
dalek | kudo/inherit-from-nqp-class: b7de167 | moritz++ | src/Perl6/Metamodel/MethodContainer.nqp: inch towards making Perl 6 classes able to subclass NQP classes |
16:34 | |
16:35
tgt_ joined,
tgt left
|
|||
tadzik | hah, flight from waw to london is like 50€ | 16:45 | |
lpw seems more and more tempting | |||
moritz | woah | 16:46 | |
16:54
ingy3^ joined,
ingy3^ left
|
|||
atroxaper | night #perl6 | 16:58 | |
16:58
atroxaper left
16:59
rindolf joined
17:01
kaleem left
17:09
dmol joined
17:20
stevan_ left
|
|||
diakopter | only $1100 to fly from sfo. more and more attractive. | 17:26 | |
quietfanatic agrees with me that Lesser and Greater would be better than Less and More | 17:29 | ||
since those imply direction slightly more | 17:30 | ||
jnthn | o/ from le train | ||
diakopter | jnthn: ahoy buggod | ||
jnthn | *groan* | 17:31 | |
diakopter | jnthn: how about Lesser/Greater | 17:32 | |
jnthn | context? | ||
tadzik | Gesser/Later | ||
jnthn | oh, the Increase/Decrease... | ||
timotimo | jnthn: if i handle arity > 1 like optional arity, it'll result in more verbose/cautious code in any case :( | ||
but yeah, you're right, we would be getting a nicer error message out of the whole ordeal | 17:33 | ||
17:33
ajr_ left
|
|||
tadzik | well, I opened the bug because jnthn said that that should work | 17:33 | |
jnthn | timotimo: Only for arity 2 things, though? | ||
timotimo | er, what? | ||
tadzik | I'll be fine with agreeing that it shouldn't :) | ||
timotimo | tadzik: i'd like it to work, though :) | 17:34 | |
jnthn | timotimo: 2 or greater | ||
diakopter | oh noes | ||
jnthn | arity 1 we can assume :) | ||
17:34
ajr joined
|
|||
tadzik | okayo :) | 17:34 | |
timotimo | yes, 2 or greater. | ||
tadzik | jnthn: 2 or more :P | ||
17:34
ajr is now known as Guest71892
|
|||
jnthn | 2 or increase :P | 17:34 | |
timotimo | btw, i changed the code that increases the arity of the cur_lexpad thingie from "only if it has no default" to "always" | ||
is that dangerous? | |||
17:35
Guest71892 is now known as ajr_
|
|||
jnthn | Well, so long as it doesn'tcount names | 17:35 | |
It probably is OK, especially if tests/spectest pass | 17:36 | ||
timotimo | it does not count nameds, no | ||
there is no calculated jump in parrot, is there? | 17:37 | ||
jnthn | yeah, I think there is a local_jump thingy | ||
17:37
[Sno] joined
|
|||
timotimo | do i have to calculate bytecode widths for that? | 17:37 | |
jnthn | the regex engine uses it | 17:38 | |
it's dangerous s hell | |||
no, it's not that bad :) | |||
timotimo | heh | ||
jnthn | but I *think* you might be able to segfault things with sufficiently good use of it | ||
Unless things got fixed... | |||
timotimo | local_jump doesn't seem to exist anywhere in src/ | 17:39 | |
jnthn | I don't know what it's actually called... | ||
Look somewhere in the regex code postlude | |||
timotimo | oh, it's just jump $I123 | ||
jnthn | oh :) | 17:40 | |
timotimo | and i can set $I123, label_name[$offset] | ||
17:40
trexy joined
|
|||
jnthn | k | 17:41 | |
timotimo | huh, is that it? its usage is weird. | ||
jnthn | that looks weird to me too but I'm mostly managing to forget PIR :P | ||
timotimo goes with a linear search instead | 17:42 | ||
jnthn tries to remember if anybody besides timotimo++ now has worked on code-gen on every backend... | 17:43 | ||
moritz | jnthn: I'm pretty sure you did :-) | ||
timotimo | "worked on" is a bit much, no? :) | 17:44 | |
jnthn | I...I did? :P | 17:45 | |
17:48
nebuchadnezzar joined
17:50
FROGGS joined
17:51
fhelmberger left,
fhelmberger joined
17:52
jnap1 joined
|
|||
moritz | there are really two things you can do: work on the actual code generation framework, or do code generation for specific operations (using the previously mentioned framework) | 17:52 | |
I've only ever been involved with the latter | |||
17:52
jnap left
|
|||
jnthn | I guess givne I designed JAST and most of MAST I've done a bit of the former :) | 17:53 | |
17:56
fhelmberger left
17:58
lowpro30_ joined
|
|||
tadzik | jost most :) | 18:01 | |
18:01
lowpro30 left
|
|||
timotimo | yeah, i also only did the latter | 18:06 | |
QAST transformations don't count, IMO | |||
hey jnthn, can you tell me what kinds of nodes are safe to be replaced inside a tree of QRegex during optimisation time, in order not to harm the generated NFA data? | |||
18:07
zakharyas joined
18:08
cognominal joined
|
|||
jnthn | timotimo: "replaced"? | 18:08 | |
jnthn kinda needs more detial to answer :) | |||
detail | |||
timotimo | well, can I remove, for example, a QAST::Regex( :rxtype<literal> ) out of the tree? | 18:09 | |
what about an :rxtype<alt>? | |||
will NFA data be lost when i pull such a Regex node out of the tree? | |||
i would like to replace nodes like literal or cclass with a new type of node that just skips ahead when i'm certain the NFA has already done the scanning of that particular node before | 18:11 | ||
questhub.io/realm/perl/quest/528217...1c340000a8 - here's a writeup of my thoughts on this topic | |||
18:12
ajr_ left
|
|||
jnthn | Trouble is that you don't know if you were invoked by the NFA or not... | 18:13 | |
18:13
dakkar left
|
|||
jnthn | statically I mean | 18:13 | |
timotimo | oh? what other cases are there? | ||
jnthn | What I mean is given | ||
token foo { bar } | |||
uh, bad exmaple | 18:14 | ||
timotimo | that's right. i can't do this in many cases | ||
but in the cases where i can, i totally could :) | |||
jnthn | token foo:sym<bar> { <sym> } | ||
timotimo | like the example in the questhub quest: [ "integer: " (\d+) | "identifier: " (\w+) | "based-number: 0" (<[xob]>) (\d+) ] | ||
jnthn | Here, you *may* be in it thanks to the NFA | ||
But it's possible somebody explicilty called it too | |||
timotimo | yes, i touched on that exact argument in my questhub quest (without a good solution) | 18:15 | |
one idea is to introduce QAST::Want into the regex system and have the nfa set a flag that triggers a different branch of the Want to be executed | |||
jnthn | I don't think that's it | 18:16 | |
Looking more generally, if we have | |||
token foo:sym<bar> { \w+ } | |||
18:17
ggoebel16 joined
|
|||
jnthn | We actually can handle that from the NFA too | 18:17 | |
But it means we need to know where the end is | |||
18:17
kivutar left,
jeffreykegler_ left
|
|||
jnthn | I'd actually been pondering something in the other direction than you're thinking... | 18:17 | |
That is, when we make the NFA, we differentiate automatic "skip to here" point from fate | 18:18 | ||
timotimo | opposite or orthogonal? | ||
jnthn | And store the "skip to here" points | ||
timotimo | ah, that seems to be opposite | ||
jnthn | Well, it's mroe that we make the NFA tell us | ||
It's generally a better design when we let things that know stuff do the telling, than let things that don't know guess ;) | |||
timotimo | yes, that's a good point. | 18:19 | |
jnthn | And if we want to get REALLY cute | ||
timotimo | but that's hard, too. the NFA doesn't carry with it from where it has matched, does it? | ||
jnthn | We already generate an NFA for everything. | ||
timotimo | or where capture groups begin and end etc etc | ||
18:19
ggoebel15 left
|
|||
jnthn | No, capture groups would scupper it | 18:19 | |
But that still leaves quite a lot. | |||
timotimo | scupper == break? | 18:20 | |
jnthn | yeah | ||
well, force us not to do that opt | |||
The other part of this though... | |||
If we have a token foo { \d+ } | |||
Nothing to do with a proto-regex | |||
It has an NFA that can do all the matching | 18:21 | ||
That is, in certain cases we can delegate to that even in non-protoregex/alternation cases. | |||
timotimo | so you want to find tokens that are completely declarative | ||
jnthn | It's not just about declarative. | ||
timotimo | and have no capture groups in them? | ||
jnthn | Well, I tink we need to separate out the two notions | ||
Where is the end of the declarative prefix? | |||
And where is the end of the stuff we can just let the NFA do? | 18:22 | ||
e.g. before we gotta start capturing. | |||
timotimo | ah, of course | 18:23 | |
18:23
ggoebel16 left
|
|||
timotimo | at the moment it just bails out if something is !.declarative | 18:23 | |
it should continue, but no longer count up the length of the declarative prefix | |||
jnthn | oh, I wsa more thinking the other way around | ||
the amount we can consider skippable is a subset of what's declarative | 18:24 | ||
\d+ <exponent> | |||
That whole thing is probably all declarative | |||
But we can only skip the \d+ 'cus the next thing captures | |||
timotimo | by skippable you mean "the QRegex implementation can rely on the NFA to have done it"? | ||
yes, that's true | |||
jnthn | Right | ||
There's a static and dynamic aspect here | |||
timotimo | i was thinking we could tell {} apart from {...} and let the NFA run past empty {} until it finds another stumbling block | 18:25 | |
jnthn | Statically we know that it's "after the \d+" which is useful for knowing where the jump to in the generated code. | ||
timotimo | so it could, in theory, eliminate more branches? | ||
jnthn | *to | ||
TimToady | and we could, in theory, do a single capture if it starts at an abs position and ends with a known offset to the end of declarative | 18:26 | |
timotimo | that's true, too | ||
jnthn | timotimo: true, but trying to keep this manageable :) | ||
timotimo | i was about to say :) | ||
jnthn | timotimo: It's not "eliminate more branches" | ||
It's about not re-doing work. | |||
Anyway, the harder part for us to factor is the dynamic aspect | 18:27 | ||
timotimo | if it's going to be me who's to implement this, it should not be a huge monolithic blob of work; instead i'd hope for a bunch of achievable milestones that all have a bit of a reward to them | ||
TimToady | well, some of them could be yaks :) | ||
FROGGS | timotimo: that was what I was thinking atm, define separate "smaller" tasks | ||
jnthn | That is, knowing wheat to set pos to | ||
PerlJam randomly mentions advent posts again :) | |||
18:28
ggoebel16 joined
|
|||
timotimo | PerlJam: we're too busy building castles in the sky | 18:28 | |
jnthn | I'd love to tell you a lovely robust design for this but I don't have one to hand :) | ||
diakopter | TimToady: Mr Toad's Wild Ride is no more... | ||
PerlJam | timotimo: but we don't yet have flying cars to get to the sky-castles | ||
timotimo | i was thinking the approach i was suggesting is much simpler in the dynamic case | ||
TimToady | diakopter: you mean in DW, or in DL? | ||
timotimo | PerlJam: i wasn't saying what we were doing was a good idea :) | 18:29 | |
jnthn | Maybe I'll have some decent thinking time tomorrow...it's mostly travel and stuff. :) | ||
diakopter | W | ||
timotimo | it would be fantastic if you could come up with a "typical jnthn design" :) | ||
jnthn | timotimo: Will ponder it a bit, given you're interested to work on it :) | 18:30 | |
TimToady | well, it seems obvious to me that whatever calculates the declarative prefix has to also pass along whatever it knows about lengths and offsets that could be useful later | 18:31 | |
PerlJam | "I'll solve this problem in the style of ... jnthn!" | ||
18:31
ssutch joined,
ggoebel16 left
|
|||
jnthn | TimToady: Yes, it's how to factor that passing along :) | 18:31 | |
timotimo | jnthn: if it's way too hard for me, though, i may not be up to the task just yet; but having a design almost ready to implement it is bound to help :) | 18:32 | |
TimToady | alternatively, maybe the declarative bits are in their own little structure that can be scanned as a separate pass | ||
(but I'm guessing that would be harder) | 18:33 | ||
diakopter | TimToady: hm, apparently? | ||
it was 1998 | 18:34 | ||
meh | |||
jnthn | timotimo: Well, it may be hard in places, but I suspect I can guide you through them if so :) | 18:35 | |
18:35
ggoebel16 joined
|
|||
jnthn | I actually will have time to do Perl 6 things besides ranting about stuff on the channel again next week, it seems... :) | 18:36 | |
timotimo | \o/ | ||
FROGGS | nice :o) | 18:38 | |
dalek | d: b469b42 | larry++ | STD.pm6: \x{} now recommends \x[] |
18:40 | |
diakopter | so, the onion logo means the more you dig into it, the more you cry? | ||
TimToady | and the less there is left to cry about :) | ||
timotimo | the code may be super ugly, but i think my redo handling now works | 18:43 | |
first make it work, then make it beautiful | |||
diakopter | Melanie just suggested making a camel logo with a camelia drawn on a saddle on the camel | ||
18:43
SamuraiJack_ left
|
|||
diakopter | .. to which I replied, uhm, you're really setting up that critical pun well | 18:44 | |
timotimo | i kind of wish there was a construct to go through multiple parallel lists in nqp | 18:45 | |
that could potentially also give us an optimized for @foo X @bar -> $a, $b { } for rakudo | |||
diakopter | nqp::zipzipzip | ||
TimToady | you mean Z I presume? | 18:47 | |
timotimo | indeed, thinko | ||
18:51
darutoko left
|
|||
timotimo | twitter.com/loltimo/status/400336432939544576 - i made a funny | 18:57 | |
18:59
rurban1 left
19:02
pernatiy left
19:07
dwarring joined
|
|||
lue | Can anybody tell me offhand why this line my %meths := $par.method_table($par); might call a sub when it shouldn't, or what NQP debugging features might help me figure that out? .method_table consists entirely of "return %!methods;" | 19:07 | |
timotimo | --target=pir :P | 19:08 | |
19:08
tgt_ left
|
|||
dwarring | .u §«¶· | 19:09 | |
moritz | |||
dwarring | .u § | 19:10 | |
moritz | ENOYOLEAUX | ||
timotimo | nqp has a function that i really think should be exposed to perl6 to get the name of a character | 19:11 | |
19:11
tgt joined
|
|||
moritz | +1 | 19:11 | |
dwarring | seems that § and ¶ have been reclassified as punct between unicode 5.2 and 6.0 | 19:12 | |
so punct tests in github.com/perl6/roast/blob/master...charsets.t are giving variable results depending on version of icu etc | 19:13 | ||
methinks I should make those punct tests todo | 19:14 | ||
moritz | +1 | ||
timotimo | +1 | 19:15 | |
diakopter | +1 | 19:16 | |
dwarring another good reason to bring unicode handling into nqp core | 19:18 | ||
jnthn | Bring them in line with the latest | ||
And then we can todo them by backend, when the backend is behind or inconsistent due to ICU version | |||
I think that on Moar we have >= 6 | |||
TimToady has been arguing against icu from the start, having found the other approach worked pretty well for P5 | 19:19 | ||
FROGGS | no icu in moarvm \o/ | 19:20 | |
timotimo | +1 | 19:21 | |
diakopter | I can very easily port/generalize moar's unicu to the other backend | ||
timotimo | oooooh! | ||
TimToady | it's the very complexity of tracking Unicode that argues against entrusting it to a 3rd party | ||
19:22
ingy2^ left
|
|||
TimToady | and it's one of the spots where P5 is still miles ahead of most other programming languages | 19:22 | |
19:23
rindolf left
19:25
tgt left,
spider-mario joined
|
|||
lue | .oO( /usr/local/lib/lib»ö«.so ) |
19:25 | |
FROGGS | lue: btw, I only see $foo.HOW.method_table($foo) in nqp's src | 19:26 | |
lue: did you forgot the .HOW? | |||
lue | FROGGS: maaybe, but I don't think that's the issue. /me checks anyway | ||
o.o | 19:27 | ||
FROGGS | O.o | ||
lue | FROGGS++ | ||
FROGGS | \o/ | ||
diakopter | no one reacted to my "other backend" dig | ||
19:28
ingy2^ joined
|
|||
lue | diakopter: which other backend are we talking about? :P | 19:28 | |
moritz | diakopter: +2 (to porting it to two other backends) | ||
FROGGS | diakopter: would make sense I guess... but I totally wanna see NFG too *g* | ||
Util | #ps in 3m | ||
lue | FROGGS: but how missing that .HOW caused the sub within which that statement was to get called immediately again is a mystery to me :/ | ||
diakopter | FROGGS: well that's harder bc it's the whole string impl | 19:29 | |
FROGGS | diakopter: and in moarvm only? | ||
(I really do like MoarVM) | |||
lue: I guess it wants to call .method_table on the return value of $par or so | 19:30 | ||
lue | FROGGS: thing is, the sub being called again is a sub within a method find_method. Without going through the method again, if the 'die'-induced backtrace is to be believed. | 19:31 | |
FROGGS | diakopter: I just think that at some point it does not make soo much sense to port stuff over from MoarVM to Parrot, since, it would be a MoarVM-clone with another heartbeat then | ||
lue | FROGGS: I don't really care though, because it works now :) | 19:32 | |
FROGGS | *g* | ||
lue: that's fine :o) | |||
tadzik | about 'which other backend': i2.kym-cdn.com/photos/images/origin...94/463.jpg | ||
FROGGS | tadzik++ | ||
hehe | |||
19:33
ingy2^ left
|
|||
TimToady | timotimo: will your optimization make it harder to optimize when 1|2 {} to a jump table at some point? | 19:33 | |
or can the recognizer for that just run in front of this optimization? | 19:34 | ||
jaffa4 | WHat is the state of MoarVM? | 19:35 | |
TimToady | (Perl 4 would actually make a jump table for the first character of string cases as well as for integer cases!) | ||
diakopter | jaffa4: existeth | ||
TimToady | nqp bootstrapped on it | ||
just needs rakudo now :) | 19:36 | ||
jaffa4 | what does it mean that nqp bootstrapped on it? | ||
19:36
zakharyas left
|
|||
TimToady | means that nqp can compile nqp running on top of MoarVM, and use that to compile itself on top of MoarVM, and use that... | 19:37 | |
jaffa4 | ok | 19:38 | |
It is a kind of measure of progress I see | |||
diakopter | masak: name for p5interop: Voldemoar | ||
jaffa4 | What is the advantage of MoarVm? | ||
TimToady | it's moar better! | ||
it's designed specifically to support Perl 6 | 19:39 | ||
diakopter | jaffa4: it has higher ground | ||
TimToady | it natively speaks p6's metamodel | ||
jaffa4 | So is it going to be faster than javavm or parrot? | ||
diakopter | someday | 19:40 | |
tadzik | it's what Parrrot wanted to be when it grows u, | ||
* up | |||
lue | .oO(MoarVM is basically Parrot timeshifted about a decade.) |
||
diakopter | both directions | ||
FROGGS | jaffa4: we are currently working on making rakudo work on it btw | ||
lue: and with the knowledge how a perl6 implementation looks like, to be fair | |||
jaffa4 | Is there going to be PIR for MOarvm? | 19:41 | |
FROGGS | NO | ||
TimToady | making rakudo work primarily entails 1) getting the CORE setting to parse, and 2) implementing the run-time support for the semantics of those things that are beyond what npq needs | ||
jnap1 | for long lived processes, the javaVM can can really optimized, but startup isn't great. I guess MoarVM will be faster for CLI, from my understanding. At least as a lurker here is what I've heard | ||
FROGGS | *NO PIR* *NO PROJECT EULER* | ||
tadzik | NO LOL | ||
FROGGS | (the latter is a joke) | ||
TimToady | jnap1: yes, that seems accurate | 19:42 | |
lue | FROGGS: yep. The "timeshift" comment was referring to "what if Parrot design started a decade later" than anything else. | ||
*more than | |||
FROGGS | jaffa4: it does not spit out yet another readable code, just to parse it again | ||
TimToady | lue: no "what if" about it :P | ||
tadzik | will moar have pir: i2.kym-cdn.com/photos/images/origin...94/463.jpg | ||
lue | :) | ||
FROGGS | hihi | ||
diakopter | .oO( sometimes I find myself writing here, imagining chromatic reading the logs, like a convalescent reads the funny papers |
||
) | |||
FROGGS | diakopter: I've read more of his stuff yesterday :o) | 19:43 | |
tadzik | I should make an image-only faq | ||
jaffa4 | It means it will convert it into some kind of internal representation I guesrs | ||
diakopter | incl questons | ||
FROGGS | especially his Parrot-good-bye letter that I didn't know before | ||
dalek | ast: 3c83e50 | (David Warring [email@hidden.address] | S05-mass/charsets.t: mark charset punct tests as todo - results varying depending on unicode version |
19:44 | |
19:44
tgt joined
|
|||
FROGGS | jaffa4: into instructions, as bytecode | 19:44 | |
jaffa4 | SO it is interpreted | ||
TimToady | straight from MAST to bytecode | ||
jaffa4 | Like Basic? | ||
tadzik | FROGGS: is that very new? | ||
FROGGS | bytecode just means a pretty packed unreadable mess of binary data here :o) | 19:45 | |
tadzik: no, only to me | |||
2011 or so | |||
TimToady | jaffa4: it's still just a virtual machine interpreting "bytecode" | ||
FROGGS | jaffa4: Basic needs to be parsed, that does not happen with bytecode | ||
jnthn | Compiling stuff on MoarVM goes directly from a low-level tree-ish thing to bytecode | ||
The bytecode is the spec'd interface to the VM | |||
TimToady | for some definition of "byte" that doesn't include 8-bit opcodes, I suspect | ||
diakopter | bytecode is parsed | 19:46 | |
tadzik | well, what CPU is doing is basically interpreting bytecode, fsvo bytecode | ||
FROGGS | like it reads a byte, knows it is the number of an instruction, and it will straight ahead execute it or so | ||
lue | .oO(the new PIR will be MoarVM Objective Abstraction of Runtime Virtual Microcode, clearly) |
||
TimToady | is it a bytecode, or is it a wordcode? | ||
diakopter | bytecode is a lanfuage too! | ||
jnthn | TimToady: Well, yes, but it's stored as a bunch of bytes. :) | ||
lue | octetcode! | ||
TimToady | jnthn: so is the original Perl 6 | ||
jnthn | :P | ||
jaffa4 | then bycode can be converted into some kind of assembly language | ||
timotimo | TimToady: i don't think so. the code that comes out is "if 1.ACCEPTS($_) || 2.ACCEPTS($_)". that should still be optimisable, probably even easier than before. | 19:47 | |
jnthn | jaffa4: We do have a way to dump the bytecode into something that loosk like assembly. | ||
jaffa4: But that's just a dumping format. Not spec'd in any way, and there's nothing to parse it. | |||
diakopter | it's cslled trollcode | ||
lue | jnthn: yet | ||
TimToady | timotimo: okay, just something to bear in mind that can make a switch statement run much faster if it's jumpable | ||
FROGGS | quick! register the MoarVM:: namespace on cpan! | 19:48 | |
we will parse its dumpling format! | |||
19:48
raiph left
|
|||
diakopter | if they were still registerable | 19:48 | |
lue | .oO(Incoming culinary jokes...) |
||
diakopter | jnthn doesn't know it's already parsed | ||
FROGGS | so he's the innocent one? | 19:49 | |
jnthn | lue: Well, we can have something to parse it, but I ain't gonna bless it as "official" in any way :) | ||
TimToady | diakopter: shh, that's an NSA secret | ||
diakopter | it's in master; he hasn't found it yet | ||
TimToady | it's for inserting the NSA's backdoor, so please don't talk aobut it | ||
jnthn | Plus it's hardly what you'd want to write by ahnd :) | ||
FROGGS | jnthn: in contrast to pir, hahaha | 19:50 | |
jnthn | I'd rather insert some backdoors for NASA so MoarVM can go into space :P | ||
FROGGS | hehe | ||
diakopter | it's pretty verbose and repetitititiively redundant | ||
TimToady meant NASA, yeah, that's what I meant... | |||
FROGGS | can you tell that again? | ||
jaffa4 | person of interest? | 19:52 | |
diakopter | cbs comedy | 19:53 | |
TimToady | .oO(pirson of interest) |
||
diakopter | procedural | ||
not very oo | |||
lue | .oO( r: say Q:NSA{███████████████████████████████████} ) |
||
TimToady | r: say Q:NSA{███████████████████████████████████} | 19:54 | |
camelia | rakudo-parrot b11094: OUTPUT«===SORRY!=== Error while compiling /tmp/HeDpixyBe4Unrecognized adverb: :NSAat /tmp/HeDpixyBe4:1------> say Q:NSA⏏{████████████████████████████████…» | ||
..rakudo-jvm b11094: OUTPUT«===SORRY!=== Error while compiling /tmp/AWWZL9Drq9Unrecognized adverb: :NSAat /tmp/AWWZL9Drq9:1------> say Q:NSA⏏{█████████████████████████████████…» | |||
TimToady | I think that is only recognized when you're compiling yourself | ||
timotimo | TimToady: well, when someone comes up with a jump table implementation of given/when, they can ask me to revert that commit if it hinders them. for now, this is faster. | 19:55 | |
TimToady | funny that whitespace coming out red... | ||
diakopter | r: say "y Q:NSA{██████████████████████████████████" | ||
camelia | rakudo-jvm b11094: OUTPUT«===SORRY!=== Error while compiling /tmp/XCcotNfc0YBogus statementat /tmp/XCcotNfc0Y:1------> say "y Q:NSA{⏏██████████████████████████████████"[0…» | ||
..rakudo-parrot b11094: OUTPUT«===SORRY!=== Error while compiling /tmp/IjVp7h674RBogus statementat /tmp/IjVp7h674R:1------> say "y Q:NSA{⏏██████████████████████████████████"…» | |||
diakopter | r: say "██████████████████████████████████" | ||
camelia | rakudo-parrot b11094, rakudo-jvm b11094: OUTPUT«██████████████████████████████████» | ||
lue | The only other compiler that ████████████ does that ██████ is ████M, if I re██ll. | ||
diakopter | r: say "██████████████████████████████████"; nhvh h | ||
camelia | rakudo-parrot b11094: OUTPUT«===SORRY!=== Error while compiling /tmp/ICma4THD71Undeclared routines: h used at line 1 nhvh used at line 1» | ||
..rakudo-jvm b11094: OUTPUT«===SORRY!=== Error while compiling /tmp/4be5EwdLjsUndeclared routines: h used at line 1 nhvh used at line 1» | |||
diakopter | r: say "██████████████████████████████████"; . . . | ||
camelia | rakudo-parrot b11094: OUTPUT«===SORRY!=== Error while compiling /tmp/Ht5lGp2QusUnsupported use of . to concatenate strings; in Perl 6 please use ~at /tmp/Ht5lGp2Qus:1------> "█████████████████████████…» | 19:56 | |
..rakudo-jvm b11094: OUTPUT«===SORRY!=== Error while compiling /tmp/M32O1OkmYuUnsupported use of . to concatenate strings; in Perl 6 please use ~at /tmp/M32O1OkmYu:1------> "██████████████████████████…» | |||
TimToady | ooh, green! | ||
jnthn | why did my IRC client just turn into a weird tetris? :P | ||
timotimo | %) | ||
lue | jnthn: to train our ████ matter in preparation for The ████u██™, ██ course. | 19:57 | |
.oO(too bad irclog.perlgeek screws up the camelia output, this doesn't look nearly as cool there :/) |
19:58 | ||
FROGGS spectests his fix for #120517 | |||
synopsebot Link: rt.perl.org/rt3//Public/Bug/Displa...?id=120517 | |||
19:58
raiph joined
|
|||
FROGGS | lue: it is always better when it is live | 19:58 | |
TimToady | yes, but as soon as we give instant replay to the refs, it had better be more accurate than their own eyes | 19:59 | |
dalek | p/optional_for_arguments: ae3226b | (Timo Paulssen)++ | src/ (3 files): store no optarity, assume arity > 1 means optional |
20:00 | |
timotimo | i'm going to clean up that ugly pile of code now :) | ||
TimToady wonders if CRLF should have a pre-assigned NFG codepoint^Wgraphpoint | 20:03 | ||
20:03
colomon left
|
|||
jaffa4 | if I see black stripes, is that good? | 20:05 | |
lue | r: say "\r͏\n".ords # :TimToady | ||
camelia | rakudo-parrot b11094, rakudo-jvm b11094: OUTPUT«13 847 10» | ||
TimToady | if you get your eyes checked, you should see alternating black and white | 20:06 | |
lue | jaffa4: yes, that was intentional on our parts :) | ||
TimToady | um, where does that 847 come from? | 20:07 | |
lue | TimToady: COMBINING GRAPHEME JOINER of course :) | 20:08 | |
TimToady | o.° | 20:09 | |
FROGGS | jaffa4: that is how #perl6 works :o) | ||
20:09
Celelibi left
|
|||
FROGGS | jaffa4: welcome in our midst | 20:09 | |
lue | r: say "█".unicharname; # oh wait, I no can haz | ||
camelia | rakudo-parrot b11094: OUTPUT«No such method 'unicharname' for invocant of type 'Str' in block at /tmp/5Ig6Dzklg4:1 in any at /tmp/5Ig6Dzklg4:1 in any at gen/parrot/stage2/NQPHLL.nqp:1146 in any eval at gen/parrot/stage2/NQPHLL.nqp:1133 in any evalfiles at gen/…» | 20:10 | |
..rakudo-jvm b11094: OUTPUT«No such method 'unicharname' for invocant of type 'Str' in block at /tmp/zwHl8qo1x7:1 in any eval at gen/jvm/stage2/NQPHLL.nqp:1086 in any evalfiles at gen/jvm/stage2/NQPHLL.nqp:1292 in any command_eval at gen/jvm/stage2/NQPHLL.nqp:1196 …» | |||
lue | If I vote against ICU (and stand with TimToady), does that mean I could get a .unicharname ? | ||
FROGGS | lue: unless there are other charnames the "uni" is redundant | ||
TimToady | it might be a function rather than a method, and it might work on integers, not strings | 20:11 | |
jnthn | detrain, bbiab | 20:15 | |
dalek | kudo/nom: 9dfecb8 | (Tobias Leich)++ | src/core/Str.pm: fix #120517, Str:D:.words returns the one elem if it is just one This way .perl on it looks a bit nicer. |
||
synopsebot | Link: rt.perl.org/rt3//Public/Bug/Displa...?id=120517 | ||
20:16
colomon joined
|
|||
lue | TimToady: yeah, I imagine there's a whole class of functions waiting. &charname, &cclass, <rdir, etc... | 20:17 | |
dalek | kudo-star-daily: 41f0a61 | coke++ | log/ (5 files): today (automated commit) |
20:18 | |
20:19
Celelibi joined
|
|||
lue would like those functions to work on (integers&(arrays of integers|utf-y bufs/blobs)) | 20:21 | ||
20:21
stevan_ joined
|
|||
FROGGS | lue: like .chrs? | 20:23 | |
lue | FROGGS: yeah, like that :) | ||
FROGGS | well, it would fit | 20:24 | |
timotimo | Unable to checkout '240f8d025a72dfd9695290dde45981f238287d79' in submodule path 'modules/uri' | ||
huh. | |||
20:24
pecastro_ joined
|
|||
dalek | ar: e31918b | (Timo Paulssen)++ | modules/uri: check out an actually existing commit in uri/ |
20:25 | |
timotimo | [Coke]: that should help with the daily star runs | ||
20:26
pecastro left
|
|||
dalek | ast: 9010356 | (Tobias Leich)++ | S32-str/words.t: test for RT #120517, Str.words.gist |
20:26 | |
synopsebot | Link: rt.perl.org/rt3//Public/Bug/Displa...?id=120517 | ||
FROGGS | preflex: tell dram your bug is fixed: rt.perl.org/Ticket/Display.html?id=120517 | 20:28 | |
preflex | Consider it noted. | ||
20:31
rurban1 joined
20:50
kaare_ left
|
|||
dalek | kudo/moar-support: f5a38f2 | nickg++ | tools/build/Makefile- (2 files): This fixes a build problem when you run Configure with '-backends=moar,jvm'. We make RUN_PERL6 unique to each build variant. |
20:53 | |
jnthn back | 20:56 | ||
21:01
stevan_ left
|
|||
TimToady | rather than handling the redo outside the block, it would be a lot simpler conceptually to just turn it into a goto to the first statement | 21:02 | |
then it doesn't interact with binding at all | 21:03 | ||
or am I misunderstanding the difficulty? | |||
timotimo | are you talking about my code? | 21:04 | |
TimToady | I'm talking about the discussion surrounding irclog.perlgeek.de/perl6/2013-11-12#i_7848718 | ||
TimToady assumes you're talking about the "redo" op | 21:05 | ||
slavik | will there be a state of the perl6 spec that is like '1.0' type of stable? | ||
or is it already there? | |||
timotimo | yes, jnthn said it's not cheap to make a new redo handler for each of the calls | ||
TimToady | I'm saying it should not be done that way in the first place | 21:06 | |
timotimo | oh | ||
well, after the first statement, it will shift items from the iterator | |||
TimToady | LABEL: loop { redo LABEL } should turn into loop { LABEL1: goto LABEL1 } | ||
jnthn | Beware LEAVE handlers :) | 21:07 | |
timotimo | well, in that case i'd have to introspect the inside of the loop, which i don't know if i can manipulate freely | ||
TimToady | redo should be defined as equivalent to that goto | ||
lue | slavik: eventually Perl 6(.0.0) will be 'stable', for some definition :) | ||
slavik | yeah, I am waiting for that, moarvm and the concurrency stuffs. :) | 21:09 | |
TimToady | redo should completely ignore iterators on the outside of the block, as well as phasers that leave/enter the block | ||
it's just supposed to be a shorthand for 'goto' | |||
trying to restart a redo from outside the block is going to be just as painful as trying to goto into a block that has an initializer | 21:10 | ||
timotimo | well, that's how it's been done so far in nqp | 21:11 | |
TimToady | n: for 1..2 { .say; redo if rand < 0.7; LEAVE { say "oops" } } | 21:12 | |
camelia | niecza v24-98-g473bd20: OUTPUT«1oops2oops2oops2oops» | 21:13 | |
jnthn | Rakudo also, it keeps it in line with the rest of the control exception handlers. | ||
Rather than making it a special case. | |||
TimToady | r: for 1..2 { .say; redo if rand < 0.7; LEAVE { say "oops" } } | ||
camelia | rakudo-jvm b11094: OUTPUT«1oops1oops2oops2oops2oops2oops2oops2oops2oops2oops2oops2oops2oops2oops2oops2oops2oops» | ||
..rakudo-parrot b11094: OUTPUT«1oops2oops2oops» | |||
timotimo | well, that seems accurate | ||
TimToady | r: for 1..2 { HERE: .say; goto HERE if rand < 0.7; LEAVE { say "oops" } } | 21:14 | |
camelia | rakudo-parrot b11094: OUTPUT«===SORRY!=== Error while compiling /tmp/0s0xihFsLYUndeclared name: HERE used at line 1Undeclared routine: goto used at line 1» | ||
..rakudo-jvm b11094: OUTPUT«===SORRY!=== Error while compiling /tmp/mCxAFpifFuUndeclared name: HERE used at line 1Undeclared routine: goto used at line 1» | |||
TimToady | n: for 1..2 { HERE: .say; goto HERE if rand < 0.7; LEAVE { say "oops" } } | ||
camelia | niecza v24-98-g473bd20: OUTPUT«1111oops2oops» | ||
timotimo | ah, so it shouldn't give a leave for redo. gotcha. | ||
TimToady | that's how redo is supposed to work | ||
21:14
lowpro30 joined
|
|||
timotimo | that's just a small bit outside of my comfort zone to fix right now | 21:15 | |
21:16
lowpro30__ joined
|
|||
TimToady | jnthn: seems to me the whole point of defining loop control constructs in the language is because each of them is a special case | 21:17 | |
21:18
lowpro30_ left
21:20
lowpro30 left
|
|||
timotimo | i think Proc::Status should be mentioned in this month's changelog | 21:20 | |
FROGGS++ | |||
TimToady | but in this case, it should just be handled like a goto to an implicit label, not by escaping the block in question | ||
to the extent that goto is also a control exception at need | 21:21 | ||
I think we can restrict 'redo' to work only lexotically, so we don't have to install a conjectural label on every loop, which could impact optimization | 21:23 | ||
otherwise we can't unroll any loops | 21:24 | ||
21:25
Celelibi left
|
|||
timotimo | that sounds wise indeed. | 21:29 | |
dalek | ecs: 20876cc | larry++ | S04-control.pod: notes on redo semantics, restrict to lexotic |
21:30 | |
21:34
bluescreen10 left
21:35
bluescreen10 joined,
bluescreen10 left
21:36
bluescreen10 joined
|
|||
TimToady | inlining is just one of many possible optimizations that we want to be careful not to make impossible... | 21:36 | |
21:37
raiph left
|
|||
dalek | p: dba785d | (Timo Paulssen)++ | src/vm/parrot/QAST/Operations.nqp: presize list{,_*} only for 2 or more elements |
21:37 | |
timotimo | inlining and unrolling, yeah | ||
TimToady | though I suppose one could view loop unrolling as a form of inlining some of a tail recursion on the loop block | ||
timotimo | mhm | ||
TimToady | dividing a list into work pieces also plays into possibly hypering | 21:38 | |
though in that case you're trading for cores rather than memory | |||
timotimo | i think we can safely assume that many cores will be available in the future | 21:39 | |
at least 4 on normal machines. even phones have quad-cores now. | |||
but rakudo should learn to treat memory more sparingly, i think | 21:40 | ||
that doesn't mean we shouldn't do inlining. we just have to be more intelligent in other places that we have yet to find >_< | |||
TimToady | well, loop unrolling using instruction memory, not data memory | ||
it's the data multipliers that kill you | 21:41 | ||
timotimo | you mean something like "8 extra bytes per QAST node" like i almost introduced into nqp? ;) | ||
TimToady | one generally doesn't store 1000000 versions of the same code, but data can easily do that | ||
yes, well, that's data :P | |||
timotimo | that sounds entirely logical | 21:42 | |
i see you're no longer jetlagged in your brane :D | |||
TimToady | well, now it's just the innate branedamamge... | ||
jnthn | I dunno how many QAST nodes CORE.setting is, but it'll be easily in the tens of thousands, maybe rather more. | 21:43 | |
TimToady | hence "multiplier" | ||
jnthn | So I tend to be kinda watchful on that stuff :) | ||
FROGGS | maybe we should run-length encode our memory :o) | ||
timotimo | say, why is arity in QAST::Node rather than QAST::Block? | 21:44 | |
FROGGS | or even LZW or so | ||
TimToady | code like an unrolled loop doesn't tend to multiply unless you inline it, or unroll everything :) | ||
is there any effort to store natives in decreasing size order? P5 takes pains to put 32 bits before 16 bits before 8 bits... | 21:45 | ||
otherwise you take alignment hits | |||
jnthn | timotimo: Good question... | ||
timotimo | jnthn: i'll try to move it into Block and see if it breaks | ||
jnthn | TimToady: Certainly various structs in Moar have had that thought out carefully | 21:46 | |
TimToady | good | ||
jnthn | timotimo: Please do; it'd be good to know what breaks. | ||
[Coke] | timotimo (deprecations) known, but probably not ticketed yet. | ||
it's been failing on jvm since it was added. | |||
timotimo | [Coke]: very well | ||
[Coke]: i'm looking forward to the next star daily run, since i fixed the checkout of uri | |||
or at least i think i fixed it. i may have made it a tiny bit less good :P | 21:47 | ||
21:47
raiph joined
|
|||
timotimo | jnthn: Error while compiling op unless: Method 'arity' not found for invocant of class 'QAST::Op' - so, should i duplicate arity in QAST::Op and have it in QAST::Block, too? | 21:47 | |
21:48
denis_boyun joined
|
|||
jnthn | timotimo: Um...first, let's understand what arity's an op... | 21:48 | |
timotimo | i'm already looking :) | 21:49 | |
i think it's being done to calculate $*HAVE_IMM_ARG | 21:50 | ||
21:50
Rotwang joined
21:51
spider-mario left
|
|||
timotimo | and here it tries to find the arity of a QAST::Var, that's *certainly* not right :) | 21:51 | |
maybe it should only look at it if it nqp::istype QAST::Block | |||
jnthn | Where, ooc? | ||
I thought the immediate stuff looked at the arity of the block | 21:52 | ||
timotimo | src/vm/parrot/QAST/Operations.nqp 441 | ||
jnthn | Oh....is it simply that it just blindly checks arity of the children of if/unless/while/blah that can take a block with a param? | ||
timotimo | while does the same thing | 21:53 | |
jnthn | And so far we always give back 0? | ||
timotimo | yes, i think so. | ||
jnthn | Yeah | ||
Well, nqp::istype check like you check will cut it. | |||
timotimo | \o/ | ||
jnthn | I'm pretty sure it will anyway | ||
That'd be a rather nice saving. | |||
21:53
denis_boyun left
|
|||
timotimo | that's 8 byte saved for a lot of QAST nodes :D | 21:53 | |
jnthn | :D | ||
21:54
logie left
|
|||
timotimo | how do you feel about knowing the allocation numbers for the different QAST nodes for... the setting for example? | 21:54 | |
jnthn | Can't hurt. | 21:55 | |
21:55
denis_boyun joined
|
|||
jnthn | We may learn something from it :) | 21:55 | |
timotimo | i'll whip up something | ||
[Coke] | looks like modules-test worked. | 21:57 | |
github.com/coke/rakudo-star-daily/...odules.log | |||
Testing modules/Math-Model... | |||
Saw 1 call to deprecated code during execution. | |||
jaffa4 | what do you use guys to make slides? | ||
dalek | ast: 3531185 | (Tobias Leich)++ | S32-str/encode.t: unfudge now-passing test |
||
timotimo | Perl6/Actions also seems to blindly look at a Stmts's arity and crashes, i can fix that, too, though | 21:59 | |
21:59
jaffa4 left
|
|||
timotimo | hah | 22:00 | |
if nqp::defined($past.arity) | |||
FROGGS | ummm | 22:01 | |
a nice no-op | |||
timotimo | no, a nice crash :) | ||
FROGGS | at least, in the $past | ||
lue | jaffa4: depends (I'm guessing LaTeX beamer most often). The one constant is that we tend to publish them as pdfs. | ||
FROGGS | yeah :o) | ||
japhb___ | jnthn: From the point of view of the task doing the publishing, is a publish action blocking? In other words, can the publisher expect all current subscribers to have had a chance to look at the published item before the publish action completes? (Apologies for likely out of date terminology, I haven't had a chance to soak up the name-mangled version of the concurrency spec.) | 22:02 | |
timotimo | i don't think it should be blocking | ||
jnthn | japhb___: That makes two of us :P | ||
japhb___ | heh | 22:03 | |
jnthn | japhb___: A publisher doesn't introduce any asynchrony of its own | ||
timotimo | oh | ||
jnthn | japhb___: When there was a Publisher class, which I can't remember what is called now, there was gonna be an AsyncPublisher too. | ||
timotimo | so it's blocking in the normal case | ||
Supply, no? | |||
jnthn | timotimo: Right | ||
japhb___ | Yeah, I definitely want both use cases. | 22:04 | |
jnthn | japhb___: Yeah, we should have it. It's just part of my general "don't introduce async where it ain't asked for" design sense. | ||
timotimo | .o(the duplication of QAST nodes through the autosink thingie is probably a big factor in memory usage actually) | ||
japhb___ | Sure, I'm fine with that default. | 22:05 | |
jnthn | timotimo: Note that it's not duplicating the two trees in the want... :) | ||
timotimo: As in, just referencing the same nodes, even if they dump twice. | |||
timotimo | ah, that's good | ||
japhb___ | And in fact, for the use case that spawned the question, I do want blocking behavior. I just also have a need for async in other cases. | ||
jnthn | japhb___: Yup, both are needed in different places. | ||
japhb___: Rx also provides both. | 22:06 | ||
japhb___: The other thing we need is replay semantics. | |||
timotimo | nqp: say(105 % 10) | ||
camelia | nqp-moarvm, nqp-jvm, nqp-parrot: OUTPUT«5» | ||
jnthn | japhb___: uh, control over... | ||
japhb___ | jnthn: By which you mean being able to subscribe "late" and get the history, right? | ||
jnthn | japhb___: Right. | ||
japhb___ | Yep, very needed. | ||
TimToady | .oO(cockpit recorders) |
||
timotimo | like zero-mq :P | ||
jnthn | japhb___: Probably you get replay of everything as a * where you can also put a buffer size. | 22:07 | |
timotimo: Yes, this is very much in messaging pattern space. | |||
TimToady | the application probably needs a way to limit replay to avoid sending all its memory down that primrose path | 22:08 | |
japhb___ | In fact, we need that semantic general enough that I'd almost say we need replay to be a method that people override to e.g. do "Remove events that logically replace old events, so as to shrink the replay to the minimum necessary to create a given state" | ||
jnthn | TimToady: Yes, "replay everything from this supply" is often overkill. | ||
TimToady | key frames, basically | ||
japhb___ | client/server game engines use state sync whenever a new client connects, and then minimal diffs when a client loses sync. | 22:09 | |
jnthn | That's a nice analaygy | ||
uh, spelt right... | |||
:) | |||
japhb___ | .oO( method sync(:$from) { ... } ) |
22:11 | |
sync there, because it's different from replay in that the latter feels like it imposes the concept of replaying events in the same order they were initially issues, rather than getting fastest-possible resync to a published stream in progress | 22:12 | ||
*issued | |||
jnthn | Yeah, that's more window-y | 22:15 | |
timotimo | jnthn: i'll have your numbers in about 4 minutes | ||
TimToady | the question is, do you want to see the whole movie again, or just get to the particular point in the movie? | ||
FROGGS | well, both | 22:17 | |
timotimo | hey everybody. want to bet on how many of each QAST node type are allocated in the rakudo setting? (plus optimizer work, which adds a few nodes here and there as well) | ||
FROGGS | 4_231_456_200 | ||
timotimo | what type of node would that be? | 22:18 | |
jnthn | FROGGS: ffs, for a moment I thought that was timotimo posting the total :P | ||
FROGGS | ahh, that was a guess for all in total | ||
22:18
rurban1 left
|
|||
timotimo | i'll calculate that number, too | 22:18 | |
FROGGS | I'd say 35% blocks | ||
the rest is hard to guess | 22:19 | ||
timotimo | java.lang.StackOverflowError | ||
FROGGS | I parse that as NaN | ||
timotimo | :) | 22:20 | |
jnthn | I don't think 35% will be blocks | ||
I think QAST::Op will be the most numerous | |||
timotimo | sounds likely | ||
jnthn | Perhaps followed by QAST::Want | ||
timotimo | followed by Var? | ||
FROGGS | well, 55% QAST::Op then :o) | ||
timotimo | ah, Want, yeah | ||
FROGGS | < 5% QAST::Regex | ||
jnthn | And lots of QAST::Var too | 22:21 | |
QAST::Stmts and QAST::Stmt will be above QAST::Var | |||
FROGGS | jnthn: you have to provide exact numbers :P | 22:22 | |
timotimo | finally made the counter work %) | 22:23 | |
~589350 nodes in total | 22:24 | ||
FROGGS | O.o | 22:25 | |
timotimo | Var is in the lead with 123350, followed by Op with 121550 | ||
WVal, SVal and IVal: 98900, 92850, 74950 | |||
Stmts, Stmt, Want: 29350 18100 16650 | |||
Block, BVal, InlinePlaceholder: 5950 5050 1350 | 22:26 | ||
finally: 1050 QRegex, 150 CompUnit, 50 Node, 50 NVal | |||
22:26
denis_boyun left
|
|||
jnthn | 150 CompUnit is a useful number. That tells us we run 149 BEGIN time things :) | 22:26 | |
timotimo | r: say "{ (589350 - 5950) * 8 } bytes saved by timotimo++" | 22:27 | |
camelia | rakudo-jvm 9dfecb: OUTPUT«(timeout)» | ||
..rakudo-parrot 9dfecb: OUTPUT«4667200 bytes saved by timotimo++» | |||
TimToady | if you guys were better functional programmers there'd be fewer Vars :P | ||
jnthn | 4 MB. I'll take that. | ||
FROGGS | 4.6MB, nice timotimo++ :o) | ||
timotimo | r: say "that's {4667200 / 1024} kbytes" | ||
camelia | rakudo-parrot 9dfecb, rakudo-jvm 9dfecb: OUTPUT«that's 4557.8125 kbytes» | ||
timotimo | jnthn: and compile_in_context from the optimizer, i bet | ||
FROGGS | aww, way too much for a floppy :( | 22:28 | |
jnthn | timotimo: Yeah, that counts as BEGIN time | ||
timotimo | 4.6 MB is far from a big amount of ram usage compared to the 2gb or what it takes most of the time :( | ||
TimToady | well, let's go for a live CD | ||
jnthn | Well, kinda... :) | ||
FROGGS | hehe, a live CD of rakudo's saved bytes :o) | 22:29 | |
timotimo | r: say "timotimos computer generates about {589350 / 110} QAST Nodes per second during parse time." | ||
camelia | rakudo-parrot 9dfecb, rakudo-jvm 9dfecb: OUTPUT«timotimos computer generates about 5357.727273 QAST Nodes per second during parse time.» | ||
timotimo | i like { } interpolation a lot | 22:30 | |
TimToady | it used to be controversial :) | 22:31 | |
FROGGS | especially when you think of it as an embedded foreign language | ||
(about liking it) | |||
timotimo | it's powerful and if you don't like it, just use qq:!c | ||
(is that the right spelling?) | |||
r: say qq:!c(heyo {1 + 1}!) | 22:32 | ||
camelia | rakudo-jvm 9dfecb: OUTPUT«===SORRY!=== Error while compiling /tmp/kzu0ognnWEArgument not allowed on negated pairat /tmp/kzu0ognnWE:1------> say qq:!c⏏(heyo {1 + 1}!)» | ||
..rakudo-parrot 9dfecb: OUTPUT«===SORRY!=== Error while compiling /tmp/PqCPuzeMeMArgument not allowed on negated pairat /tmp/PqCPuzeMeM:1------> say qq:!c⏏(heyo {1 + 1}!)» | |||
timotimo | r: say qq:!c/heyo {1 + 1}!/ | ||
camelia | rakudo-parrot 9dfecb, rakudo-jvm 9dfecb: OUTPUT«heyo {1 + 1}!» | ||
FROGGS | r: say :!c | ||
camelia | rakudo-parrot 9dfecb, rakudo-jvm 9dfecb: OUTPUT«» | ||
FROGGS | r: say (:!c).perl | ||
camelia | rakudo-parrot 9dfecb, rakudo-jvm 9dfecb: OUTPUT«"c" => Bool::False» | ||
FROGGS | I didn't know that | 22:33 | |
timotimo | you didn't?! | ||
FROGGS | no | 22:34 | |
timotimo | but it's so nice! :) | ||
FROGGS | looks a bit sad though | ||
timotimo | i'm pining for a commitbit :P | ||
FROGGS | don't ask me :o) | ||
timotimo | i wonder if TimToady would be able to verify that my CLA has arrived? | 22:35 | |
and give a commitbit | |||
TimToady has nothing to do with that end of the business | |||
timotimo | OK | ||
FROGGS | he is just our brane :o) | ||
TimToady isn't even sure he has a commitbit himownself | |||
though he did turn in a CLA for Parrot lo these many years ago | |||
FROGGS | dunno if somebody else than pmichaud++ is able to | 22:36 | |
TimToady: really? | |||
that is kinda weird | |||
jnthn | timotimo: I *think* I can do the commit bit part, but not the CLA check part :( | ||
timotimo: Where'd you send it to? | 22:37 | ||
FROGGS | walnut I suppose | ||
TimToady | FROGGS: the early parrotfolk chided me for all the macros I put into Perl 5, and then proceeded to put a nearly identical set of macros into parrot :) | 22:38 | |
jnthn doesn't know whos' on the receiving end of that... | |||
timotimo | FROGGS: t.h8.lv/0001-.arity-will-only-be-on...soon.patch would you be so kind real quick? | ||
22:38
djanatyn left
|
|||
timotimo | Karen Pauley got it | 22:38 | |
22:38
hummeleB1 joined
|
|||
jnthn | timotimo: Oh...she has it? | 22:38 | |
timotimo | yes, she passed it on for me, she said | ||
22:39
djanatyn joined
|
|||
dalek | kudo/nom: 1371ccc | (Timo Paulssen)++ | src/Perl6/Actions.nqp: .arity will only be on QAST::Block soon. |
22:39 | |
22:39
colomon left
|
|||
FROGGS | let me be your commitbot :o) | 22:40 | |
timotimo | :3 | ||
many thankulations | |||
.o( gewürz thankulatius ) | |||
FROGGS | no problemotics | ||
hehe | |||
22:40
colomon joined
|
|||
FROGGS | I don't like them :o( | 22:40 | |
dalek | p: eada3ad | (Timo Paulssen)++ | src/ (4 files): move $!arity from Node to Block Saves about 4.6 MB of RAM when compiling the rakudo core setting |
22:41 | |
FROGGS | TimToady: I felt a bit home in Parrot land, it is so XS-ish :o) | 22:42 | |
jnthn | Somebody at TPF acknowledging timotimo++'s CLA is enough for me, so I've granted the commit bit. :) | ||
FROGGS | \o/ | ||
TimToady | welcome to the exclusive club...oh wait... | 22:45 | |
FROGGS | hehe | ||
*g* | |||
22:46
iSlug joined
|
|||
Ulti | was there a R* .msi that needed testing? | 22:46 | |
22:46
woolfy left
|
|||
FROGGS | Ulti: sort of | 22:47 | |
Ulti | I guess I should try building my own at some point | ||
jnthn | TimToady: Moar has its share of macros too. Not all of which I'm glad of... :) | ||
FROGGS | Ulti: irclog.perlgeek.de/perl6/2013-11-02#i_7804199 | ||
Ulti | thanks FROGGS I'll give it a go | 22:48 | |
FROGGS | Ulti: panda has some problem installing some modules | ||
Ulti | I'm on 64bit Windows 8 so might have a go sorting out building stuff | 22:49 | |
FROGGS | but that is mostly due to outdated included modules | ||
Ulti | all my machines that run Rakudo are either OSX or Ubuntu... havent touched setting up a dev environment on Windows for more than a decade | ||
FROGGS: ahh ok | |||
22:49
woolfy joined
22:50
lowpro30__ left
|
|||
Ulti | one nasty thing on windows 8 you get a great big warning banner when installing | 22:50 | |
FROGGS | yeah, we need to sign it somehow :/ | ||
Ulti | well it said finished... | ||
FROGGS | I think `panda install Math::RungeKutta` failed to delete a tempdir and aborted installation due to that | 22:51 | |
TimToady | you can't really write portable C without a lot of macros | ||
timotimo | hm, there's no spectests for List.combinations | 22:52 | |
22:53
berekuk left
|
|||
jnthn | TimToady: Oh, I agree. Turning smallish static functions into macros rather than leaving the inliner to get them is what I'm less fond of. | 22:53 | |
22:53
berekuk joined
|
|||
FROGGS | and we're fudging the rakudo source code, that is the same | 22:53 | |
jnthn: *nod* | 22:54 | ||
TimToady | and to be fair, there was no such inliner when Perl was first written | ||
FROGGS | AND THEN YOU EVEN HAVE TO SHOUT THEM | ||
timotimo | If the range option is taken, returns all subset combinations in order of increasing size, up to the specified max, or the size of the list, whichever is smaller. - i don't understand. what is the range for, now? | ||
jnthn | TimToady: Yes, but I'm talking about Moar, being written in 2013 :) | ||
TimToady: I've read to little of the Perl 5 source to have anything agaisnt it ;) | 22:55 | ||
timotimo | and what if i start the range not at 0 but at, say, 5? | ||
jnthn | *too | ||
TimToady | then it throws away any combinations that are 0..4 at a time | ||
Ulti | FROGGS: I get a problem just running panda | ||
FROGGS | Ulti: what exactly? | 22:56 | |
TimToady | r: say <a b c>.combinations.perl | ||
camelia | rakudo-jvm 9dfecb: OUTPUT«No such method 'combinations' for invocant of type 'Parcel' in block at /tmp/aUrIbjwi3d:1 in any eval at gen/jvm/stage2/NQPHLL.nqp:1086 in any evalfiles at gen/jvm/stage2/NQPHLL.nqp:1292 in any command_eval at gen/jvm/stage2/NQPHLL.nqp:1196…» | ||
..rakudo-parrot 9dfecb: OUTPUT«No such method 'combinations' for invocant of type 'Parcel' in block at /tmp/BF2MRLDgs5:1 in any at /tmp/BF2MRLDgs5:1 in any at gen/parrot/stage2/NQPHLL.nqp:1146 in any eval at gen/parrot/stage2/NQPHLL.nqp:1133 in any evalfiles at …» | |||
timotimo | either my non-native englishness is kicking into gear here or that sentence could be reworded a bit | ||
TimToady | r: say [<a b c>].combinations.perl | ||
camelia | rakudo-jvm 9dfecb: OUTPUT«Not enough positional parameters passed; got 1 but expected 2 in block at /tmp/wgFc3WP3vS:1 in any eval at gen/jvm/stage2/NQPHLL.nqp:1086 in any evalfiles at gen/jvm/stage2/NQPHLL.nqp:1292 in any command_eval at gen/jvm/stage2/NQPHLL.nqp:11…» | ||
..rakudo-parrot 9dfecb: OUTPUT«Not enough positional parameters passed; got 1 but expected 2 in method combinations at gen/parrot/CORE.setting:7979 in block at /tmp/_ATFXc2dnM:1 in any at /tmp/_ATFXc2dnM:1 in any at gen/parrot/stage2/NQPHLL.nqp:1146 in any eval …» | |||
Ulti | FROGGS: Could not open C:\rakudo\bin\C:\rakudo\bin\panda.bat. Unable to open filehandle from path 'C:\rakudo\bin\C:\rakudo\bin\panda.bat' | 22:57 | |
TimToady | r: say [<a b c>].combinations($_) for 0..3 | ||
camelia | rakudo-parrot 9dfecb, rakudo-jvm 9dfecb: OUTPUT«a b ca b a c b ca b c» | ||
Ulti | perl6 runs fine though | ||
FROGGS | hmmm | ||
is "C:\rakudo\bin\" set in environment somewhere? | 22:58 | ||
(except path) | |||
or.. how did you invoke it? just by "panda"? | 22:59 | ||
Ulti | FROGGS: yeah | ||
I invoked it from the directory as 'panda' | |||
FROGGS | hmmm, that worked on my box | 23:00 | |
23:00
BenGoldberg joined
|
|||
FROGGS | why should it even want to open the bat file? | 23:00 | |
Ulti | im doing it from a powershell terminal though.. one sec I'll try cmd | ||
FROGGS | it should execute it to run `perl6-p panda` | ||
yeah, maybe... I have no powershell installed | 23:01 | ||
23:01
PacoAir left
|
|||
Ulti | yeah PowerShell doesn't like it but under cmd.exe everything works fine including installing Math::RungeKutta ^___^ | 23:01 | |
FROGGS | nice | 23:02 | |
23:02
bluescreen10 left
|
|||
Ulti | I'll try and work out whats up with pash | 23:02 | |
FROGGS | I'll install powershell these days then :o) | ||
cool! | |||
Ulti++ | |||
Ulti | Windows 8.1 has it from the 'start menu' as a link | ||
FROGGS | only have XP and 7 | ||
Ulti | nice to know you are forwards compatible :) | ||
FROGGS | yes :o) | 23:03 | |
Ulti | compile now run an OS version later | ||
FROGGS | Windows++ here | ||
that is something where Windows Just Works, and linuxes are pain | |||
dalek | ecs: 570c49c | larry++ | S32-setting-library/Containers.pod: clarify wording of .combinations(Range) |
23:06 | |
FROGGS | s/Dec/Nov/ | 23:07 | |
TimToady | oops | ||
dalek | ecs: 7e0441c | larry++ | S32-setting-library/Containers.pod: s/Dec/Nov/ FROGGS++ timotimo++ |
23:08 | |
TimToady | larry-- | 23:09 | |
FROGGS | :o) | ||
LEAVE; /* gnight all */ | |||
TimToady | o/ | 23:10 | |
23:10
FROGGS left,
rurban1 joined
|
|||
timotimo | r: [1, 2, 3].combinations(-1) # what should this do? | 23:21 | |
camelia | rakudo-parrot 9dfecb: OUTPUT«(signal KILL)» | ||
..rakudo-jvm 9dfecb: OUTPUT«Unhandled exception: java.lang.StackOverflowError in count (gen/jvm/CORE.setting:7107) in count (gen/jvm/CORE.setting) in (gen/jvm/CORE.setting:7525) in reify (gen/jvm/CORE.setting) in (gen/jvm/CORE.setting:7949) in reify (gen/jvm/…» | |||
timotimo | r: [1, 2, 3].combinations(0) | 23:22 | |
camelia | ( no output ) | ||
jnthn | std: LEAVE; | 23:23 | |
camelia | std b469b42: OUTPUT«===SORRY!===Whitespace required after keyword at /tmp/4M843Awg8G line 1:------> LEAVE⏏;Parse failedFAILED 00:01 120m» | ||
jnthn | r: LEAVE; | ||
camelia | rakudo-parrot 9dfecb: OUTPUT«===SORRY!=== Error while compiling /tmp/6pcNl5uiAQUndeclared name: LEAVE used at line 1» | ||
..rakudo-jvm 9dfecb: OUTPUT«===SORRY!=== Error while compiling /tmp/1yabGdR6QhUndeclared name: LEAVE used at line 1» | |||
jnthn | Discrepancy! | ||
23:28
logie joined
|
|||
timotimo | S32-list/combinations.t sounds like a good place to put combination tests? | 23:30 | |
n: say [1, 2, 3].combinations(2) | |||
camelia | niecza v24-98-g473bd20: OUTPUT«Unhandled exception: Unable to resolve method combinations in type Array at /tmp/4TSkLQkbfF line 1 (mainline @ 3)  at /home/p6eval/niecza/lib/CORE.setting line 4583 (ANON @ 3)  at /home/p6eval/niecza/lib/CORE.setting line 4584 (module-CORE …» | ||
jnthn | timotimo: wfm | ||
23:30
Rotwang left
|
|||
timotimo | for tests, am i allowed to rely on the ordering of combinations? | 23:30 | |
it's not specced, right? | 23:31 | ||
jnthn | If it's not spec'd the no... | ||
r: say [1, 2, 3].combinations(2) | 23:32 | ||
camelia | rakudo-jvm 1371cc: OUTPUT«(timeout)» | ||
..rakudo-parrot 1371cc: OUTPUT«1 2 1 3 2 3» | |||
timotimo | aaw, jvm, come on ;_; | ||
jnthn | eval server gone wild I guess | ||
timotimo | r: say all([1, 2, 3]) == one([2, 1, 3]); | 23:33 | |
camelia | rakudo-parrot 1371cc, rakudo-jvm 1371cc: OUTPUT«all(one(True))» | ||
23:33
logie left
|
|||
timotimo | r: say [1, 2, 3].combinations(3); | 23:34 | |
camelia | rakudo-parrot 1371cc, rakudo-jvm 1371cc: OUTPUT«1 2 3» | ||
timotimo | er, wha? | ||
r: say [1, 2, 3].combinations(2); | |||
camelia | rakudo-parrot 1371cc, rakudo-jvm 1371cc: OUTPUT«1 2 1 3 2 3» | ||
timotimo | ah, they are supposed to be sets | 23:35 | |
i was thinking permutations | |||
r: say [1, 2, 3].permutations(3); | |||
camelia | rakudo-jvm 1371cc: OUTPUT«Too many positional parameters passed; got 2 but expected 1 in method permutations at gen/jvm/CORE.setting:7970 in block at /tmp/9f3KlR8RB7:1 in any eval at gen/jvm/stage2/NQPHLL.nqp:1086 in any evalfiles at gen/jvm/stage2/NQPHLL.nqp:1292…» | ||
..rakudo-parrot 1371cc: OUTPUT«Too many positional parameters passed; got 2 but expected 1 in method permutations at gen/parrot/CORE.setting:7994 in block at /tmp/RuDIFxQ4sW:1 in any at /tmp/RuDIFxQ4sW:1 in any at gen/parrot/stage2/NQPHLL.nqp:1146 in any eval at…» | |||
timotimo | r: say [1, 2, 3].permutations(); | ||
camelia | rakudo-parrot 1371cc, rakudo-jvm 1371cc: OUTPUT«1 2 3 1 3 2 2 1 3 2 3 1 3 1 2 3 2 1» | ||
23:35
rurban1 left
23:42
iSlug left,
REPLeffect left
23:43
amkrankruleuen left
|
|||
dalek | ast: 25ccede | (Timo Paulssen)++ | S32-list/combinations.t: test List.combinations a bit. |
23:57 | |
kudo/nom: 5e56c98 | (L. Grondin)++ | src/core/List.pm: implement List.combinations(Range $) |
|||
kudo/nom: 7942362 | (L. Grondin)++ | src/core/List.pm: fixing indent |
|||
kudo/nom: 4e29ebf | (Timo Paulssen)++ | src/core/List.pm: don't stack-overflow on negative arguments |
|||
kudo/nom: e71f994 | (Timo Paulssen)++ | t/spectest.data: run S32-list/combinations.t |
23:58 | ||
timotimo | when i've already merged in commits from a pull request and push "merge pull request" on github, what happens? | ||
i'll just try it, worst case i'll force-push immediately | 23:59 | ||
jnthn | timotimo: I guess it'll tell you they're already there... |