»ö« | perl6.org/ | nopaste: paste.lisp.org/new/perl6 | evalbot usage: 'perl6: say 3;' or rakudo:, alpha:, pugs:, std:, or /msg p6eval perl6: ... | irclog: irc.pugscode.org/ | UTF-8 is our friend! Set by lichtkind on 5 March 2010. |
|||
TimToady | the ordering of rules can only be partial | 00:00 | |
and some rules are unorderable wrt each other | |||
oh, another thing about the trie extension notion is that we can quit as soon as we're down to one possible fate | 00:01 | ||
we don't actualy have to follow the \w+ out to the end if it won't change anything | 00:02 | ||
since the actual token rule will still decide whether it matches or not | |||
the lexers job is really just to order the real rules, not actually find the ends of the tokens | 00:04 | ||
*'s | |||
the major thrust of S05 is to find some kind of grand compromise between deterministic and non-deterministic matching, and manage the transition between them on behalf of the user | 00:05 | ||
00:06
f00li5h joined
|
|||
TimToady | that's going to feel awkward at times, for sure | 00:06 | |
hmm, no pun intended | |||
00:06
whiteknight joined
|
|||
TimToady | but awk matching is deterministic, and not very powerful, while p5 matching is non-deterministic, and not very fast | 00:07 | |
my research is in getting these two relatively immiscible ideas to mix nicely, so I need a certain amount of "detergent" | |||
and as with most of the design of Perl over the years, I try to let the design flow primarily from practical considerations of what I really need at the moment, and less from those clean academic sources that are nevertheless fundamental | 00:10 | ||
sorear | Why is remember_alts separate from walk in the gimme5 regex compiler? | 00:11 | |
TimToady | p6 turns that around a bit and tries to sneak in as much of the fundamental goodness while hiding it from mere mortals, but it's still a grand compromise underneath, and cheating happens to get it all to mesh | ||
there was a reason, lemme think | |||
jnthn | The nice thing is that the cheats seem to be increasingly cleanly expressed in terms of the fundemantal goodness. :-) | 00:12 | |
lue | Hello! | ||
jnthn | Hellue! | 00:13 | |
lue | Fedora 13 is out, and PPC is now a "secondary architecture" | ||
One reason I picked Fedora was because they treated PPC so well :( | |||
jnthn | Ooh, I didn't know you were running on PPC. Nice that somebody is running Rakudo there. :-) | 00:14 | |
clkao | win 28 | 00:16 | |
lue | I'm not developing on it. It crashes every time I try to compile [I ssh] | ||
But fedora does provide Rakudo :) | |||
jnthn | Oh :-( | ||
TimToady | sorear: I don't remember offhand from glancing at it; it may have been a result of some fossil external requirement, perhaps forcing certain cross-linkages that are no longer evident, or that I've forgotten | ||
sorear | ok, I won't copy it | 00:17 | |
the propagation of @_ also appears to be a fossil | |||
TimToady | if you try to do it in the same pass, and run into a problem, you may have found the reason :) | 00:18 | |
sorear | the only real way to understand something is to reinvent it | ||
TimToady | it was probably always just there as a just-in-case | ||
I don't think I ever used @_ for anything | |||
sorear | viv culture uses locals in %main:: for that stuff | 00:19 | |
TimToady | the separate pass might have been required under a different model of LTM generation that did more at compile time | ||
maybe it will come to me later | |||
yes, but contextuals hadn't even been invented yet when that all started | 00:20 | ||
sorear | ...invented? | ||
00:20
synth joined
|
|||
TimToady | invented into p6 | 00:21 | |
when they were, it was a conscious decision to emulate them with locals and give up multi-threading the parser | |||
or more precisely, give up on the notion of modelling a cleanly re-entrant parser as long as gimme5 semantics were involved | 00:22 | ||
sorear | gimme5 is older than I had realized | 00:23 | |
TimToady | in the early design of p6, we just carried locals over as "temp", but eventually I figgered out that temporizing globals was just going to make the same threading headaches that p5 has, so that's when I started de-emphasizing 'temp' | 00:25 | |
and started emphasizing $*FOO semantics, even though we can't actually have them in gimme5-world | |||
well, we could, but it would be expensive | |||
Pad::Walker, and such | |||
one of the reasons the old 'v6' engine was slow was because it did try to emulate a lot of that stuff in p5 | 00:26 | ||
and as it is, STD.pm5 is only tolerably slow | |||
fsdo tolerable... | 00:27 | ||
tedv | Question about committing updates to the pugs unit tests. I gave someone my email and they said they gave me authorization, but when I commit, it asks for a user name and password. Where do I set those up? | 00:30 | |
phenny | tedv: 24 May 03:07Z <jnthn> tell tedv I just use the command line svn client, e.g. from subversion.apache.org/packages.html#windows | ||
diakopter | tedv: you should've gotten an email from the svn auth system | 00:31 | |
if you didn't, someone can rerequest one | |||
tedv | I should check my spam filters | ||
who should the sender be? | |||
diakopter | hrm | ||
[email@hidden.address] maybe? | |||
TimToady | commitbit? | ||
tedv | definitely nothing in my inbox | 00:32 | |
00:32
yinyin joined
|
|||
diakopter | msg your email address to TimToady :) | 00:32 | |
tedv | I kind of figured he was busy with important stuff! | ||
TimToady | there's no tedv in there, was it under a different name? | 00:33 | |
tedv | but alright, I guess it's like calling shotgun, but in reverse | ||
tedvessenes at gmail dot com | |||
TimToady | okay | ||
diakopter | my childseat isn't allowed in the front row | ||
tedv | because gmail doesn't let me have 4 letter email addresses. :( | ||
TimToady | what do you want for the svn id? | ||
tedv? | |||
tedv | tedv sounds good | ||
namespace there isn't in quite as much demand as gmail addresses | 00:34 | ||
TimToady | okay, sent | ||
tedv | Oh hey, I just got email from audreyt. Not sure if I quite believe that, but it looks legit | ||
TimToady | it's customary to add yourself to AUTHORS as a test commit | ||
yes, she set it up | |||
so that's probably it | |||
tedv | Did she just fall off the face of the earth or something? | 00:35 | |
TimToady | it might have some pugs-vm specific things in there that are no longer operative, but the svn bits should be right | ||
tedv | I had found an extremely simple thing to fix for a test commit, but AUTHORS sounds even simpler. | ||
diakopter | twitter.com/audreyt | ||
a nit: the pugscode tests aren't unit tests; they're functional tests | 00:38 | ||
tedv | Is there any difference between the pugs repository that rakudo checks out in rakudo/t/spec and the official pugs repository? | ||
TimToady | t/spec is a sub-branch of the official repo | 00:39 | |
if you check out the whole repo you can also fix other things like the specs | |||
[Coke] | if you're *only* dealing with spec tests, I find it easier to work out of rakudo's t/spec | ||
tedv | I suspect it will be a little while before I'm changing the specs | ||
TimToady | and AUTHORS is outside of t/spec too :) | 00:40 | |
tedv | start small and all that | ||
TimToady | go for broke! | ||
there's always a contradictory saying :) | |||
look before you leap! he who hesitates is lost! | |||
lue | Do not make fun of a penguin. | 00:41 | |
TimToady | Make fun of a penguin. | ||
there's another | |||
lue | Ignorance Is Bliss <-> Knowledge is power | 00:42 | |
tedv | those don't contradict | ||
since bliss isn't the same thing as power | |||
TimToady | .oO(Oranges, poranges--there's another one) |
||
tedv | "Be innocent as doves and shrewd as serpents" | ||
Jesus knew how to do it in the SAME SENTENCE | 00:43 | ||
that's pretty hardcore | |||
diakopter | Prov 26:4, Prov 26:5 | ||
TimToady | welcome aboard! and remember that we work on forgiveness rather than permission, at least for the first 70*7 mistakes. :) | ||
lue | [I thought it was 70**7] | ||
TimToady | the other reading is 77 | ||
tedv | aramaic is not a good language for mathematical precision | ||
diakopter | or accuracy! | ||
tedv | the options are 490 or 77 though. I don't think powers were in their understanding of math | 00:44 | |
TimToady | anyway, I'll go for the more forgiving view, at least until you start abusing it. :) | ||
lue | "I deleted the t/spec folder and commited it. Is that bad?" <== don't do thta | 00:45 | |
*that | |||
TimToady | there's also: "If anyone has a sword, he should bring it." "We have two." "Er, that's enough." | ||
that was two too many, as far as Malchus was concerned :) | |||
let's see, if I have to forgive you for each file in t/spec, that adds up pretty rapidly... | 00:46 | ||
I think you've just exceeded your 490 in one fell swoop. | |||
sorear | TimToady: Is the setting of $PURE used for anything? | 00:47 | |
sorear thinks not | |||
lue | Oh, but it was replaced with a huge t.p6 file. Does that make up for it? :) | ||
TimToady | I don't believe it is anymore. might have been related to the separate pass and a different LTM regime | 00:48 | |
00:48
snarkyboojum left
|
|||
lue needs to learn to type 'yum upgrade' more often O.o | 00:49 | ||
TimToady just types "yup" | |||
and svn update is just "sup" | |||
lue | gup | 00:52 | |
Git PUll | 00:53 | ||
TimToady | whoops, gotta go to a meeting to find a new "shepherd" | ||
since our old one retired | |||
back in three hours ± | |||
& | 00:54 | ||
lue | That explains why I saw you three hours ago, you time-traveller | 00:55 | |
[oh wait, maybe that's not what the ± means....] | |||
01:02
snarkyboojum joined
|
|||
lue | afk whilst upgrading | 01:09 | |
pugssvn | r30795 | tedv++ | Added self to authors file; also the standard commit test. | 01:18 | |
snarkyboojum looks forward to a working REPL :) | 01:23 | ||
lue: how's your dna hacking going? :) | 01:28 | ||
01:37
am0c left
01:45
whiteknight left
01:56
meppl left
|
|||
pugssvn | r30796 | sorear++ | [viv] New two-pass regex compiler based much more closely on gimme5 logic | 02:04 | |
02:05
tylerni7 joined
02:16
colomon_phone joined
|
|||
sorear | TimToady: Is there a tracker for STD.pm6? I just found another bizarre misparse | 02:25 | |
regex foo { <bar(1)> } # The string 'bar' does not appear anywhere in the AST. <bar> works fine and is parsed using *the same rule* | |||
02:26
cls_bsd joined
02:27
cls_bsd left
|
|||
pugssvn | r30797 | sorear++ | [viv] Fix normal name assertion undef error | 02:27 | |
02:31
cls_bsd joined
02:32
colomon_phone left
02:33
masonkramer joined
02:42
snarkyboojum left,
cls_bsd left,
cls_bsd joined
02:43
cls_bsd left
02:45
plobsing joined
02:47
cls_bsd joined
02:48
cls_bsd left
02:52
cls_bsd joined,
cls_bsd_ joined
|
|||
pugssvn | r30798 | sorear++ | [viv] Reintroduce | and || | 02:53 | |
02:55
snarkyboojum joined,
cls_bsd left,
cls_bsd_ left,
cls_bsd joined
02:56
cls_bsd left
03:00
cls_bsd joined
|
|||
pugssvn | r30799 | sorear++ | [viv] Implement literal atoms and simple quotes | 03:21 | |
03:26
masonkramer left
03:33
mberends joined
03:35
agentzh joined
03:44
gfx joined
|
|||
sorear | TimToady: What does <regex_block>:!s mean? | 03:45 | |
03:45
jaldhar joined
03:47
stephenlb joined
03:55
mimcpher joined,
snarkyboojum left
03:56
revdiablo joined
04:02
snarkyboojum joined
04:09
TiMBuS joined
04:13
stephenlb left,
dju joined
04:14
[mark] joined
04:23
dju left
04:24
dju joined
04:30
dju left
04:31
dju joined,
dju left
04:34
JimmyZ joined
|
|||
pugssvn | r30800 | sorear++ | [STD] Correctly parse sigspace in rules | 04:40 | |
r30800 | [viv] Generate .ws calls | |||
04:40
snarkyboojum left
|
|||
TimToady | sorear: :s turns on :sigspace, so :!s turns it off | 04:52 | |
sorear | oh, that simple | 04:55 | |
I figured it was an adverb to the assertion | |||
TimToady | no, just left the space out because it would have been significant :) | 04:56 | |
and all those internal :s, :i, etc are lexically scoped, for some definition of 'lexical' | |||
sorear | does %*RX predate slangs? | 04:57 | |
it seems weird that the regex engine tweaks entirely differently from quotes | |||
TimToady | well, those aren't exactly slangs, since they don't exactly change the parsing | 04:58 | |
they're more like pragmas | |||
sorear | %*RX<s> changes what <.ws> matches | ||
there were 2 bugs | |||
1. rule did nothing to actually set %*RX<s> | |||
2. someone tested 's' using $*RX<s> in a fit of p5think | 04:59 | ||
both fixed | |||
TimToady | well, kinda, but really it's only supposed to change the meaning of non-null whitespace | ||
2. gee, who could've that been | |||
TimToady looks around for someone to blame | |||
04:59
snarkyboojum joined
|
|||
TimToady | as for STD trackers, I keep a private todo file | 05:01 | |
so your message is already in it :) | |||
sorear | and yes, now that I've gotten viv to the state where I can just copy code from gimme5, things are going much faster :D | 05:03 | |
TimToady | \o/ | 05:04 | |
looks like we're throwing out the longname with a language change that is not subsumed, maybe | |||
05:13
kaare joined,
kaare is now known as Guest65941
05:20
kel__ joined
05:27
slavik joined
05:46
XaeroOne joined
05:56
uniejo joined
05:59
TSa joined
|
|||
moritz_ | good morning | 06:00 | |
spinclad | gutn morgn, moritz_ | 06:01 | |
TSa | HaloO | ||
dalek | p-rx: 814727d | pmichaud++ | (7 files): Enable outer_ctx handling in NQP programs (e.g., via NQP::Compiler.eval). to do the same. |
||
p-rx: d905d5b | pmichaud++ | src/cheats/parrot-callcontext.pir: Skip any null lex_pad entries in the outer_ctx chain. |
|||
p-rx: 9125c3c | pmichaud++ | src/HLL/Actions.pm: Add HLL::Actions.CTXSAVE to make it easy for compilers to save contexts. |
|||
p-rx: c5659bb | pmichaud++ | src/HLL/Compiler.pm: Clean up exception printing when catching exceptions in interactive mode. |
|||
sorear | good morning pmichaud | 06:05 | |
was my efforts helpful? | |||
06:20
jhuni joined
06:21
Su-Shee joined
06:22
jakk joined
06:23
jakk left
06:26
Eevee joined
|
|||
JimmyZ | std: my @foo = <a c d>; for @foo (sub bar() { say $^a; })(); | 06:27 | |
p6eval | std 30800: OUTPUT«===SORRY!===Missing block at /tmp/SnAnZP2bFv line 1:------> my @foo = <a c d>; for @foo ⏏(sub bar() { say $^a; })(); expecting any of: bracketed infix infix or meta-infixParse failedFAILED 00:01 114m» | ||
JimmyZ | rakudo: my @foo = <a c d>; for @foo (sub bar() { say $^a; })(); | ||
p6eval | rakudo 240400: OUTPUT«Missing block at line 11, near "(sub bar()"current instr.: 'perl6;HLL;Grammar;panic' pc 501 (ext/nqp-rx/src/stage0/HLL-s0.pir:327)» | ||
TimToady | you have to use map if you want that kind of indirection | 06:32 | |
JimmyZ | I just got a known bug :) | 06:41 | |
aesop | whats $^a | 06:45 | |
sorear | a self-declared positional parameter | ||
like a named $_ | |||
aesop | ahh | ||
sorear | if you have $^a in a block, it's automatically added as a parameter | ||
06:46
BrowserUk joined
|
|||
sorear | { $^a leg $^b } # this is a 2-ary block usable as a sort callback | 06:46 | |
moritz_ | rakudo: say {$^a leg $^b} | 06:55 | |
p6eval | rakudo 240400: OUTPUT«_block46» | ||
moritz_ | rakudo: say {$^a leg $^b}.signature.perl | 06:56 | |
p6eval | rakudo 240400: OUTPUT«:(;; Mu $a, Mu $b)» | ||
sorear | std: /a ** 2 - 3/ | 07:00 | |
p6eval | std 30800: OUTPUT«===SORRY!===Unrecognized regex metacharacter (must be quoted to match literally) at /tmp/jIjYCOpZW3 line 1:------> /a ** 2 - ⏏3/Unable to parse regex; couldn't find final '/' at /tmp/jIjYCOpZW3 line 1:------> /a ** 2 - | ||
..⏏3/… | |||
sorear | TimToady: potential for awesomeness | 07:01 | |
TimToady: What does <foo>:? mean? | 07:02 | ||
STD doesn't parse it, but it's implied to be legal in S05 | 07:03 | ||
TimToady | S05:2089 | ||
sorear | yes... | 07:04 | |
that's where it's implied to be legal | |||
but I can't figure out what the semantics are | |||
07:06
viklund joined
|
|||
TimToady | well, eager vs greedy is only meaningful when applied to a quantifier, so <foo>:? merely means it can be backtracked into, and :! would likely have the same effect | 07:10 | |
whereas <foo>: may not backtrack into <foo> | |||
sorear | I see. | ||
What is :+ ? | |||
TimToady | same as :! | 07:11 | |
or is it the same as : | |||
sorear | it doesn't seem to be specced | 07:12 | |
except in gimme5 | |||
TimToady | I think *+ and ++ are ratcheting forms in some regex languages | 07:13 | |
sorear | p5 ;) | ||
07:14
masak joined
|
|||
masak | oh hai, #perl6! | 07:14 | |
m6locks | o hai guise | ||
TimToady | it was added after p6 had specced :!, so there's some thought of adding it or switching to it | 07:15 | |
sorear | STD parses <foo>:? as two atoms, the latter of which is quantified | ||
is this correct? | |||
TimToady | no | ||
07:20
snarkyboojum left
|
|||
moritz_ | rakudo: say samecase('FoO', 'bar') | 07:25 | |
p6eval | rakudo 240400: OUTPUT«foo» | ||
moritz_ | rakudo: say samecase('FoO', 'bAr') | 07:26 | |
p6eval | rakudo 240400: OUTPUT«fOo» | ||
moritz_ | rakudo: say samecase('FoObar', 'bAr') | ||
p6eval | rakudo 240400: OUTPUT«fOobar» | ||
moritz_ | rakudo: say samecase('FoObar', 'bAR') | ||
p6eval | rakudo 240400: OUTPUT«fOOBAR» | ||
07:34
rgrau[1] joined
07:38
XaeroOne left
|
|||
TimToady | zzz & | 07:39 | |
07:40
snarkyboojum joined
|
|||
mathw | Morning | 07:41 | |
masak | go' mo' | 07:43 | |
07:45
snarkyboojum left
|
|||
pugssvn | r30801 | sorear++ | [viv] Implement quantifiers | 07:47 | |
jnthn | oh morning | ||
masak | :) | 07:50 | |
mmm. auto-print in the REPL. | |||
jnthn | masak: You likes it? :-) | ||
masak | it almost made me forget for a while that variables don't survive to the next line. almost. :) | 07:51 | |
moritz_ | ... until you used a variable from the previous line, and it segfaulted? | ||
masak | actually, yes. | ||
and I see from the backlog that others did the same. | |||
moritz_ | my plan for this week's contribution: implement :samecase in .subst | 07:53 | |
masak | sounds good. | ||
moritz_ | should be about 5 lines of patch, if done right | ||
+ tests | |||
jnthn | +1 | 07:54 | |
mathw | tests++ | ||
masak | so... next week, the rakudosketch meeting will take place in... #phasers? :P | 07:57 | |
moritz_ | yes | ||
jnthn | Yes | ||
masak | I leave you guys alone for five minutes... :P | ||
07:57
yinyin left
|
|||
jnthn | We're all pretty fired up about the idea. | 07:57 | |
I'd bank on this name lasting a while. | 07:58 | ||
masak | oh no, now all the puns get triggered. | ||
jnthn | It's OK. | ||
Jag har svenska klass nu. :-) | |||
masak | \o/ | ||
07:58
rgrau[1] left
|
|||
JimmyZ | who owns #rakudosketch? | 07:59 | |
moritz_ actually understood that :-) | |||
JimmyZ: nobody. That's the problem :-) | |||
masak | JimmyZ: it's not registered. | ||
JimmyZ | nobody can unset it? | 08:00 | |
08:00
yinyin joined
|
|||
JimmyZ | bad | 08:00 | |
moritz_ | we've beeen more careful with #phasers | ||
masak .oO( especially the 'business end' of the phasers ) | 08:02 | ||
JimmyZ | two guys is there. sorear and PerlJam | ||
*are | |||
masak | nice fellows. I like them. | 08:03 | |
they're six days early, though :P | 08:04 | ||
moritz_ | no, one day late | ||
mathw | They're camping out | ||
like you do for tickets for Wimbledon | |||
moritz_ | there'll no more meetings in #rs | ||
JimmyZ | hey,there is another irc://irc.perl.org/#rakudosketch :) | 08:05 | |
moritz_ | if in $str.subst($pattern, $replacement, :samecase) the $replacement is a closure, should the samecase() function be applied to its return value? | 08:08 | |
moritz_ assumes "yes" and moves along | 08:13 | ||
masak | seems to me it would, yes. | 08:14 | |
is there an alternative? | 08:15 | ||
moritz_ | ignore it in the case of a closure | ||
08:16
ejs joined
|
|||
moritz_ | or apply it to the match object, and pass the result string to the closure | 08:16 | |
lolihazblogged: perlgeek.de/blog-en/perl-6/contribu....writeback | 08:18 | ||
mathw | isn't it week three? | 08:19 | |
moritz_ | no, week 4 :-) | 08:20 | |
08:20
ejs left
|
|||
mathw | It says week 2 :) | 08:20 | |
moritz_ | it says week 4... now :-) | 08:21 | |
mathw | yay | ||
masak | 'ignore it in the case of a closure' breaks Least Surprise. | 08:26 | |
08:26
ejs joined
|
|||
masak | moritz_++ # blog post | 08:27 | |
moritz_ hopes that somebody else comes up (and writes up) with next week's challenge | 08:32 | ||
mathw | yeah I'd say apply it to the closure's return value | 08:34 | |
masak | moritz_: detaching from a recurring task is nontrivial. not saying it can't be done, though. | 08:35 | |
people get to expect person X doing task Y, so they don't jump in and take over. | 08:36 | ||
mathw | quite | ||
I'm not going to volunteer, because I don't have the knowledge to come up with these things | |||
08:36
iblechbot joined
|
|||
moritz_ | masak: that's why I tried to hook people at the very beginning... diakopter++ and colomon++ have put their names into the README, and have come up with some ideas already | 08:36 | |
masak | ah, good plan. | 08:37 | |
moritz_ | if it matters I can also host challenges by other people on my blog | ||
or just post a short notices to look at a different location | |||
masak was just going to suggest that | |||
if not the first solution, then the other. | |||
08:40
dakkar joined
|
|||
moritz_ | masak: any chance Emmentaler is in need of a website next week? | 08:42 | |
masak | moritz_: I don't feel in a position to promise anything. but I can share my dateless time table. | ||
it looks like this. | |||
(1) fix up GGE with Rakudo master. almost done with that. | 08:43 | ||
08:43
BrowserUk left
|
|||
masak | (2) set up automatic builds of at least GGE, probably other projects as well. will be proto-based somehow. there's already a proof-of-concept for November, but it's b0rken. | 08:43 | |
(3) have the builds generate sensible data and save it somewhere on feather. | 08:44 | ||
that's it. with (3), someone can do a weekly challenge. | |||
but I'd drift towards "no" for next week, actually. there's only one of me, and we have a Yapsi release on Tuesday. | |||
moritz_ | ok | ||
I hope you know if TAP::Formatter::HTML, btw :-) | 08:45 | ||
masak | I've used it for the November reporter thing. | 08:47 | |
it's functional, but I'm not a fan of the layout. | |||
and it's a bit too detailed for what I have in mind. | |||
08:47
BrowserUk joined
|
|||
masak | perhaps links from the main report page can link to such output, though. | 08:47 | |
hm. doing spectests, I got a non-zero exit status from t/spec/S12-methods/submethods.rakudo. unable to reproduce it outside of the harness. | 08:49 | ||
08:49
gfx left
|
|||
masak | ditto t/spec/integration/99problems-41-to-50.rakudo. | 08:49 | |
three files contain TODO passed tests: t/spec/S14-roles/composition.rakudo t/spec/S32-hash/delete.rakudo t/spec/S32-str/uc.rakudo | 08:50 | ||
moritz_ | first and third are not reliable | ||
pugssvn | r30802 | moritz++ | [t/spec] remove a few #todo markers, masak++ | 08:52 | |
09:02
plobsing left
09:09
BrowserUk left
09:14
XaeroOne joined,
iblechbot left
09:26
ejs left
09:32
ejs joined
|
|||
jnthn back | 09:39 | ||
09:41
clintongormley joined
09:47
finanalyst joined
10:14
yinyin left
|
|||
mberends | hello jnthn, here's a slightly harder zavolaj question: could you extend NativeCall.pm6 to create wrappers for native functions that return void? The crucial mysql_free_result() does that, and our wrapper presumably still pops something off the native stack, causing Parrot to segfault. | 10:17 | |
10:17
am0c joined,
am0c left,
am0c joined
|
|||
jnthn | mberends: If you don't write a "returns" it should already handle that. | 10:21 | |
mberends: Add a debugging say to see what it's making for the Parrot NCI signature string; it should start with a "v" | 10:22 | ||
mberends | jnthn: now why didn't I think of trying that... ;-/ | ||
jnthn | :-) | ||
moritz_ | HOW IS CODE DEBUGGED? :-) | ||
mberends | google for the answres | 10:23 | |
10:23
ejs left
|
|||
moritz_ | goggle only tellz me how is babi formed | 10:23 | |
oh wait, that was yahoo answers | |||
jnthn | They should do way instain bugs! | ||
10:28
am0c left
10:30
ejs joined
|
|||
masak | they need to do way instain developer, who kill their buggies. | 10:30 | |
jnthn closes his open RT tabs quickly, lest he be done away for looking like he might be about to kill buggies. | 10:33 | ||
10:38
IllvilJa joined
10:39
JimmyZ left
10:42
fridim joined
|
|||
pragma_ | My name is pragma_ and I approve of this channel. | 10:48 | |
10:50
ejs left,
IllvilJa left
|
|||
masak | \o/ we approve of you too. | 10:51 | |
10:52
colomon joined
|
|||
masak | jnthn: it's ok to kill buggies. it's just a bit sad because these buggy can't frigth back. | 10:53 | |
jnthn | Aye, but they're lady to rest gently. | 10:54 | |
masak | oh, good. | 10:55 | |
10:55
ejs joined
11:12
rgrau[1] joined
|
|||
mberends | jnthn: unfortunately the NativeCall still segfaults on void functions. It seems that sub make-mapper always gives a return-mapper data type. | 11:16 | |
jnthn | mberends: What siggy does it make? | 11:17 | |
(the Parrot one) | 11:18 | ||
mberends looks | |||
jnthn | mberends: It should start with v | 11:20 | |
(for void) | |||
If not, we certainly have a zavolajbug | |||
(if yes, we probably still have one) | 11:21 | ||
11:21
[Coke] joined
11:28
[Coke] left,
envi^home joined
|
|||
moritz_ back from nom | 11:35 | ||
colomon | rakudo: my $a = "hello world"; say $a ~~ s/o/0/; | 11:37 | |
p6eval | rakudo 240400: OUTPUT«hell0 world» | ||
colomon | rakudo: my $a = "hello world"; say $a ~~ sa/o/0/; | ||
p6eval | rakudo 240400: OUTPUT«Confused at line 11, near "say $a ~~ "current instr.: 'perl6;HLL;Grammar;panic' pc 501 (ext/nqp-rx/src/stage0/HLL-s0.pir:327)» | ||
colomon | rakudo: my $a = "hello world"; say $a ~~ ss/o/0/; | ||
p6eval | rakudo 240400: OUTPUT«Confused at line 11, near "say $a ~~ "current instr.: 'perl6;HLL;Grammar;panic' pc 501 (ext/nqp-rx/src/stage0/HLL-s0.pir:327)» | ||
colomon | rakudo: my $a = "hello world"; $a ~~ s[o] = '0'; | 11:38 | |
p6eval | rakudo 240400: ( no output ) | ||
colomon | rakudo: my $a = "hello world"; $a ~~ s[o] = '0'; say $a | ||
p6eval | rakudo 240400: OUTPUT«hell0 world» | ||
jnthn | .oO( $stomach ~~ essess/empty/full/ ) |
11:39 | |
moritz_ | std: s:g:g/a/b/ | 11:40 | |
p6eval | std 30802: OUTPUT«ok 00:01 114m» | ||
moritz_ | std: s:g:foo/a/b/ | ||
p6eval | std 30802: OUTPUT«===SORRY!===Unrecognized adverb :foo(1) at /tmp/xiwaLnki7A line 1:------> s⏏:g:foo/a/b/Check failedFAILED 00:01 111m» | ||
11:40
ejs left
|
|||
colomon | moritz_: I'm just looking at subst.t, and noticing there seem to be a decent number of skipped tests that should work in Rakudo now. | 11:40 | |
and also, some of the tests are wonky. | 11:41 | ||
moritz_ | no surprise here :/ | ||
colomon | and many of the skip messages are a bit off. :( | ||
11:42
masonkramer joined
|
|||
colomon | "hello".subst(rx:g:i/L/,'p'), 'heppo' | 11:42 | |
should that really work the same way as "hello".subst(rx:i/L/,'p', :g), 'heppo' ? | |||
moritz_ | might work, might not | ||
colomon | it seems weirdly non-intuitive to me. | 11:43 | |
in fact, it really seems like rx:g shouldn't work at all. | |||
moritz_ | aye, :g, :x, :nth could be seen as "external" to the regex | 11:44 | |
colomon | moritz_: exactly. | ||
rakudp | 11:45 | ||
std: rx:g/hello/ | |||
p6eval | std 30802: OUTPUT«ok 00:01 112m» | ||
11:45
ejs joined
|
|||
colomon | rakudo: my $a = "hello world"; say $a ~~ rx:g/o/ | 11:45 | |
p6eval | rakudo 240400: OUTPUT«Confused at line 11, near "say $a ~~ "current instr.: 'perl6;HLL;Grammar;panic' pc 501 (ext/nqp-rx/src/stage0/HLL-s0.pir:327)» | ||
colomon | rakudo: my $a = "hello world"; rx:g/o/ | ||
p6eval | rakudo 240400: OUTPUT«Confused at line 11, near "rx:g/o/"current instr.: 'perl6;HLL;Grammar;panic' pc 501 (ext/nqp-rx/src/stage0/HLL-s0.pir:327)» | ||
moritz_ | rakudo: s/a/b/g | 11:46 | |
p6eval | rakudo 240400: OUTPUT«Unsupported use of /g; in Perl 6 please use :g at line 11, near ""current instr.: 'perl6;HLL;Grammar;panic' pc 501 (ext/nqp-rx/src/stage0/HLL-s0.pir:327)» | ||
colomon | rakudo: 'a'.subst(/(.)/,"$1$0").say | ||
p6eval | rakudo 240400: OUTPUT«Method 'postcircumfix:<[ ]>' not found for invocant of class ''current instr.: '!postcircumfix:<[ ]>' pc 11646 (src/builtins/Cool.pir:15)» | ||
moritz_ | rakudo: $1 | 11:47 | |
p6eval | rakudo 240400: OUTPUT«Method 'postcircumfix:<[ ]>' not found for invocant of class ''current instr.: '!postcircumfix:<[ ]>' pc 11646 (src/builtins/Cool.pir:15)» | ||
colomon | that "$1$0" should never work correctly. | ||
or at least, as a sane programmer probably intended it to work. | |||
mberends | jnthn: the signature is correct (vp) and the native function sometimes returns correctly, so the bug is elsewhere. I'll commit the signature printer, commented out. | 11:48 | |
colomon | rakudo: 'a b c d'.subst(/\w/, 'x', :x(*)) | 11:49 | |
p6eval | rakudo 240400: OUTPUT«Method 'Num' not found for invocant of class 'Block'current instr.: 'perl6;Mu;' pc -1 ((unknown file):-1)» | ||
11:49
JimmyZ joined
|
|||
colomon wonders why we want to support :x(*)... | 11:50 | ||
rakudo: say 'a b c d'.subst(/\w/, 'x', :nth(2), :g) | |||
p6eval | rakudo 240400: OUTPUT«a x c d» | ||
jnthn | mberends: k, hm | ||
moritz_ | colomon: :x(*) is the same as :g | 11:51 | |
colomon: and while trying to implement it I found RT #75302 | |||
colomon | moritz_: ah. | ||
11:52
ejs left
|
|||
colomon | woah, that's a crazy bug. | 11:52 | |
moritz_ | aye :-) | ||
it took me a while to find out it wasn't my fault | 11:53 | ||
colomon | rakudo: sub f($x is copy) { $x = 'abc'; say $x.WHAT; say $x.perl }; f 'a' | 11:54 | |
p6eval | rakudo 240400: OUTPUT«Str()"abc"» | ||
colomon | just checking. ;) | ||
rakudo: say 'a b c d'.subst(/\w/, 'x', :nth(2), :g) | |||
p6eval | rakudo 240400: OUTPUT«a x c d» | ||
11:54
pmurias joined
|
|||
colomon | moritz_: the test for that is | 11:54 | |
'a b c d'.subst(/\w/, 'x', :nth(2), :g), 'a x c x' | 11:55 | ||
moritz_ | that's wrong | ||
colomon | has the same problem that :nth and :x mixed has. | ||
lisppaste3 | pmichaud pasted "REPL in nqp" at paste.lisp.org/display/100504 | 11:57 | |
colomon | rakudo: say 'a b c d'.subst(/\w/, 'x', :nth({$_ % 2})) | ||
p6eval | rakudo 240400: OUTPUT«x b x d» | ||
colomon | rakudo: say 'a b c d'.subst(/\w/, 'x', :nth({$_ !% 2})) | ||
p6eval | rakudo 240400: OUTPUT«a x c x» | ||
pmichaud | good morning, #perl6 | ||
11:57
jhuni left
|
|||
colomon | o/ | 11:57 | |
mberends | \o | ||
pmichaud | NQP now ha a REPL that remembers lexicals. :-) | 11:58 | |
moritz_ | \o/ | ||
masak | yay | ||
moritz_ | now port it to rakudo... and ship it! | ||
jnthn | morning, pmichaud++ | ||
masak | good morning, pmichaud! | ||
pmichaud | port to rakudo should be straightforward (and should remove some existing code from rakudo) | ||
colomon | moritz_: has TimToady weighed in on the :nth and :x thing, or is that just your (extremely sensible) opinion? | 11:59 | |
moritz_ | colomon: just my opinion | ||
masak | colomon: he has weighed in once. | ||
it's somewhere in the IRC logs. | |||
11:59
pmurias left
|
|||
moritz_ | guided by the principle that one construct should not magically mean different things under certain conditions | 11:59 | |
colomon | It's easy enough to get the desired behavior using :nth and a closure, too. | 12:00 | |
moritz_: maybe we should change the Spec and see if anyone complains? ;) | |||
takadonet | morning all | 12:01 | |
moritz_ | IMHO the spec is pretty clear | ||
masak | colomon: hah! found the discussion! :) irclog.perlgeek.de/perl6/2010-03-26#i_2158320 | ||
moritz_ | :nth(2) means just one match, in 2nd position | ||
masak | (grepping the IRC logs for RT numbers)++ | ||
12:02
agentzh left
|
|||
colomon | moritz_: that's not how I read TimToady there at all. looks to me like he's suggesting the test is correct. :( | 12:02 | |
moritz_ | colomon: he says he can argue for it, not that it must be that way | 12:03 | |
masak | indeed. | ||
12:04
masonkramer left
|
|||
moritz_ | TimToady++ is sometimes very careful to indicate that he's not convinced "his" option might not be the best. We should take these clues as we see fit :-) | 12:05 | |
s:2nd/not// | |||
12:05
mimcpher left
|
|||
moritz_ | s:nth(2):x(1)/not// # to make my case :-) | 12:06 | |
colomon | moritz_: did you do those :nth with :x tests? | ||
moritz_ | colomon: I did... before I understood that :nth(2) never means "ever second match" | ||
colomon: I've since then corrected some tests, but not all :( | |||
and I did fix the spec :-) | |||
masak | moritz_: that's a useless use of :x ... :) | 12:07 | |
moritz_ | masak: so you'd think... :-) | ||
masak doesn't know what to think now | 12:10 | ||
moritz_ | then think some GSOC | ||
like, adding a Stringy role | |||
masak | I did. | ||
that test passes now. | |||
it didn't last time I ran it. | 12:11 | ||
moritz_ | oic | ||
masak | something must have miraculously fixed itself in the meantime. | ||
moritz_ | but Str ~~ Stringy is NYI, right? | 12:12 | |
masak | it's I in my buf branch. | ||
oh wait. | |||
no, just Buf ~~ Stringy. | |||
colomon | rakudo: my $a = "hello world"; $a ~~ s[o] = '000'; say $a | ||
p6eval | rakudo 240400: OUTPUT«hell000 world» | ||
colomon | oh, bother. | ||
12:13
ejs joined
|
|||
colomon | rakudo: for <hello world> { s[o] = '000'; say $_; } | 12:13 | |
p6eval | rakudo 240400: OUTPUT«helloworld» | ||
moritz_ | masak: colomon had some fun changing prefix:<+> to call .Numeric, not .Num; I think in the long run you'll need to change prefix:<~> to .Stringy too | ||
colomon | "fun" in the "not really -Ofun" sense. :) | 12:14 | |
masak | -O-fun | ||
moritz_: I'll keep that in mind. | |||
colomon | what's the protocol for false positive tests? skip them? | 12:15 | |
masak | rakudo: my $a; say "I do not have ", $a, " shoes on" | ||
p6eval | rakudo 240400: OUTPUT«I do not have Any() shoes on» | ||
masak | that's spec'd behaviour nowadays, right? | ||
colomon | rakudo: for <hello world> { say s[o] = '000'; say $_; } | ||
p6eval | rakudo 240400: OUTPUT«Substitution()<0x3f33340>helloSubstitution()<0x3cc5af0>world» | 12:16 | |
colomon | wtf? | ||
oh. | |||
rakudo: for <hello world> { say (s[o] = '000').Bool; say $_; } | |||
p6eval | rakudo 240400: OUTPUT«1hello1world» | ||
colomon | rakudo: for <hello world> { say (s[w] = '000').Bool; say $_; } | ||
p6eval | rakudo 240400: OUTPUT«1hello1world» | ||
masak | I thought the 's[] = $rhs' form was purely syntactical and didn't need a type of its own. | 12:17 | |
moritz_ | it should default to $_, and doesn't | ||
known bug | 12:18 | ||
colomon | masak: I have no clue, I'm just looking at the "s[...] = ... returns true on success" test in subst.t | ||
jnthn | masak: To do that you'd have to also make the smartmatch recognize it as some kind of special form too | ||
masak | moritz_: I tried augmenting Str to do the Stringy role. it seems to have worked! spectesting. | ||
jnthn: hm, true. | 12:19 | ||
jnthn | masak: Which felt messy. | ||
At the time, nobody could give me an answer for how it should be done, so I just Did Something. | |||
colomon | rakudo: for <hello world> -> $a { say ($a ~~ s[w] = '000').Bool; say $a; } | ||
masak | Something++ | ||
p6eval | rakudo 240400: OUTPUT«Cannot assign to readonly valuecurrent instr.: '&die' pc 18205 (src/builtins/Junction.pir:381)» | ||
jnthn | It's almost certainly not right though. | ||
colomon | rakudo: for <hello world> -> $b { my $a = $b; say ($a ~~ s[w] = '000').Bool; say $a; } | ||
p6eval | rakudo 240400: OUTPUT«1hello1000orld» | ||
colomon | aarrrrrgh! | 12:20 | |
masak | jnthn: fwiw, I would have guessed the smartmatch to be part of the special form. | ||
jnthn | Perhaps so. | ||
Just...ugly to do. | |||
masak | aye. might involve backtracking. | ||
jnthn | I think pmichaud++'s context PAST node might help us fix it though. | ||
Becuase then we can at least say "oh, we're in sink context, clearly we should do it to $_" | 12:21 | ||
colomon must remember not to be sad about writing tests that fail... | |||
moritz_ | I think s[...] should always default to $_ | ||
and smartmatching sets $_ for the RHS | |||
pmichaud | moritz_: +1 | ||
masak | the problem with irclog.perlgeek.de/perl6/2010-03-26#i_2158369 is, how do you find out the upper limit? and if that's not a hard enough problem, how do you do it with a closure? | ||
moritz_ | and then .sink triggers execution of the substitution | ||
jnthn | moritz_: Feel free to try it. | ||
.sink is, iirc, probably actually spelt .eager. | 12:22 | ||
pmichaud | no, I think it's .sink | ||
moritz_ | jnthn: types are free to re-interpret .sink as something else | ||
pmichaud thinks he'd better read some backscroll | 12:23 | ||
masak | uhn. are for loops eager because they're in sink context? | 12:25 | |
moritz_ | masak: yes | ||
colomon | for loops are eager IF they're in sink context | 12:26 | |
masak | what about a for loop at the end of a sub-or-method? will it behave differently? :( | ||
moritz_ | yes | ||
pmichaud | depends on how the sub-or-method is called | ||
masak | true. | ||
maybe it's not so bad, then. | |||
pmichaud | a for loop at the end of a sub isn't in sink context, no. | ||
but if the sub invocation is in sink context, the for loop gets executed eagerly then | 12:27 | ||
jnthn | pmichaud: Hmm. I can't find the bit of irclog for the discussion I was thining of. | ||
*thinking | |||
pmichaud | it always felt to me as though :x and :n argument handling should be done with smart matching. | 12:28 | |
moritz_ | :nths is | ||
masak | heh -- laziness context is like the value context for Perl 6. :) | ||
moritz_ | in rakudo | ||
colomon | code is $i !~~ any |$nth | 12:32 | |
moritz_ | anyway, I'm rather firmly convinced that what we have now for :x + :nth is the sanest semantics, until somebody comes up with a different, consistent interpretation and shows working code for it | 12:33 | |
takadonet | moritz_: sounds like a challenge to me.. | ||
masak | colomon: I'd classify that as one of the confusing uses of negation and junctions... | ||
moritz_++ # pragmatism | 12:34 | ||
colomon | masak: hmmm, I think it could be rewritten in the positive sense without breaking anything... | ||
mathw isn't sure what the prefix | does there | 12:35 | ||
masak | colomon: if I read it correctly, it means '$i ~~ all $nth'. | ||
moritz_ | takadonet: not quite a challenge; rather a try to end non-productive bikeshedding | ||
colomon | masak: oh, no no no no | ||
takadonet | moritz_: sounds good | ||
moritz_ | mathw: interpolation into argument lists | ||
masak | colomon: see? confusing! :) | ||
colomon: now explain to me why it doesn't mean that. | |||
moritz_ | masak: prefix:<|> is interpolation into argument lists | 12:36 | |
masak | mathw: what moritz_ said but mistabbed. | ||
colomon: sorry, left out the | in |$nth. | |||
12:37
elmex joined
|
|||
moritz_ | takadonet: also if somebody actually cares enough to write code for it, I'm willing to reconsider my position. Until then I just assume that I put the most thought into (hubris :-) | 12:37 | |
mathw | oh yes of course | ||
I should have remembered that | |||
masak | colomon: $i !~~ any(|$nth) is the same as any(map { $i !~~ $_ }, |$nth), isn't it? | 12:38 | |
colomon | masak: darned if I know. these things are hard to explain. | ||
pmichaud | actually, $i !~~ any(|$nth) should be the same as !($i ~~ any(|$nth)) iiuc | ||
moritz_ | masak: yes | ||
masak | ok, pmichaud and moritz_ just contradicted each other. | 12:39 | |
this should be interesting. | |||
colomon | pmichaud: that's how I read it. | ||
moritz_ | wait | ||
moritz_ not so sure anymore | |||
pmichaud++ is right | |||
mathw | I read it as "$i is not any of the things in $nth" | ||
masak | dang. :) | ||
moritz_ | the negation comes at the end | ||
pmichaud | negations and junctions are problematic | ||
(in general) | |||
masak | apparently so. | ||
I accept what you're saying, but I can't see how it works out that way. | |||
jnthn | To the point that the spec in one place suggests a warning. | ||
masak | how does the ! end up outermost? | ||
pmichaud | it's a metaop | 12:40 | |
it always ends up "outermost" | |||
jnthn | masak: All ! meta-ops are like that. | ||
12:40
[mark] left
|
|||
masak | the ! metaop ends up outside of junctions? cool! | 12:40 | |
jnthn | $a !== $b is !($a == $b) really | ||
masak | jnthn: oh, indeed. | ||
so this doesn't go for the infix:<ne> operator? | |||
moritz_ | nope | ||
that's not meta-y | 12:41 | ||
masak | that's probably what bit me once, then. | ||
mathw | infix:<ne> would presumably be subtly different to !eq | ||
since it does all its !-ness inside | |||
masak | after that, I've made large circles around negated comparison ops combined with junctions. | ||
moritz_ | so !eq is not quite the same as ne, when junctions are involved | ||
masak | someone should write a blog post about that. | ||
and a u4x entry. | |||
moritz_ | masak: that's a good item for our best practise list | ||
jnthn | btw, Rakudo's ne is implemented in terms of !eq | 12:42 | |
masak | indeed. | ||
jnthn | If you want to avoid the inconsistency, then change infix:<ne> to take two Mus. | ||
masak | jnthn: so maybe that's a potential bug in Rakudo? :) | ||
jnthn | masak: Only if we can decide what the spec is. ;-) | ||
masak | didn't we just do that? | ||
pugssvn | r30803 | colomon++ | [t/spec] Clean up fudging and tests a bit. | 12:43 | |
moritz_ | masak: where's the bug you're talking about? | ||
jnthn | moritz_: Did you mean !eq is not the same as ne is current Rakudo reality, or an awkward but fixable issue, or? | ||
Or intentional? | |||
jnthn would kinda feel more comfortable if they were the same. | |||
moritz_ | rakudo: say 1 ne 1|2 | 12:44 | |
p6eval | rakudo 240400: OUTPUT«any(Bool::False, Bool::True)» | ||
moritz_ | rakudo: say 1 !eq 1|2 | ||
p6eval | rakudo 240400: OUTPUT«0» | ||
masak | what happens in that first one? | ||
moritz_ | that's correct as I understand the current spec | ||
masak: autothreading over ne | |||
jnthn | masak: We auto-thread over ne | ||
masak | right, and the junction shouldn't collapse, of course. | ||
jnthn | In the second we auto-thread voer eq, and then the ! collapses it. | ||
masak: Yeah, I was asking if we really want that | 12:45 | ||
masak | so it's actually correct? hooray! | ||
jnthn | masak: Or if we should mark ne and != as having Mu parameters. | ||
So they work out the same as !eq and !== | |||
masak | jnthn: I don't see why we should. | ||
mathw | I'm wondering how often it's going to bite people | ||
And if we want to allow the distinction | |||
Is it potentially useful? | |||
pmichaud | as I read the spec, infix:<ne> is supposed to be the same as !eq | ||
i.e., it's just a shortcut. | 12:46 | ||
masak | so it is a bug? | ||
moritz_ | masak: only by pmichaud++'s interpretation | ||
masak submits rakudobug | |||
that's enough for me. :) | |||
mathw | I'm not convinced | ||
pmichaud | S03:1189 | ||
As in Perl 5, converts to C<Str> before comparison. C<ne> is short for C<!eq>. | |||
moritz_ | ok | 12:47 | |
that's enough for me :-) | |||
12:47
plainhao joined
|
|||
pmichaud | also later at S03:3915 | 12:47 | |
mberends | just re-asking before committing: is it OK to put the directories specified in PERL6LIB before the defaults in @*INC instead of after, to be able to override system modules with local ones? (it works fine locally) | 12:48 | |
pmichaud | that tells me that &infix:<ne> is more macro-ish than a normal function, in the long run. | ||
moritz_ | mberends: +1 from me | ||
masak | mberends: that sounds like the Right Thing to me, at least. | ||
mathw | I think any way this goes is going to confuse somebody at some point | ||
if ne is just syntactic sugar for !eq, it's going to surprise someone | 12:49 | ||
and the current behaviour is going to surprise someone else | |||
colomon | masak: code is now if !$nth.defined || ($i ~~ any |$nth) | ||
mathw | So my inner paper shredder says why do we need infix:<ne> :) | ||
colomon | hope you find that nicer. :) | ||
(spectesting) | |||
moritz_ | mathw: because TIMTOWTDI :-) | 12:50 | |
12:50
M_o_C joined
|
|||
colomon | moritz_: what, to surprise people? ;) | 12:51 | |
jnthn | Because we might get lynched if we don't have == :-) | ||
moritz_ | colomon: it would certainly p5 programmers if we had eq but not ne | ||
jnthn | Heh. Back when we had prefix:<=> defined, if we'd dropped ==, then $a == $b woulda parsed as $a = (=$b) :-D | ||
12:51
fridim left
|
|||
moritz_ | colomon: and then we'd have to install infix:<ne> just to generate an error message | 12:51 | |
12:52
SmokeMachine joined
|
|||
jnthn | oh wait | 12:52 | |
it would be != we dropped | |||
But same | |||
Two prefixes :-) | |||
moritz_ | colomon: and then people will ask "why don't you just make infix:<ne> the same as infix:<!eq>" | ||
dalek | kudo: 39c38ca | (Martin Berends)++ | src/Perl6/Compiler.pir: [Perl6/Compiler.pir] change the order of directories in @*INC so that the |
||
jnthn | But then two terms in a row. :-) | ||
masak | colomon: I do find it nicer. colomon++ | ||
colomon | moritz_: I'm not actually against ne, just amused at invoking TIMTOWTDI in that context :) | ||
12:52
alanhaggai joined
|
|||
jnthn | Anyway, we do ne and != often enough that's probably a huffman argument for 'em anyways. :) | 12:53 | |
pmichaud | mberends: it just occurred to me... what does perl5 do in the case of @INC? | ||
mathw | Maybe | ||
moritz_ | colomon: you're right, it was not the best argument :-) | ||
moritz_ knows that 'use lib $path;' prepends to @INC | |||
mathw | It just feels like an inconsistency to me if <ne> behaves with junctions like a meta-opped <eq> | ||
Because one of them would return a bool, and one of them would return a junction of bools | 12:54 | ||
12:54
perlygatekeeper joined
|
|||
moritz_ | mathw: if you take the radial approach, junctions are the problem, not the ne/!eq multi existence | 12:54 | |
mathw: so just abolish junctions, and everything is suddenly much easier :-) | 12:55 | ||
mberends | pmichaud: good point. PERLLIB also goes before, just checked empirically | ||
mathw | moritz_: just make all comparison operators produce a single bool when used on junctions :) | ||
pmichaud | mberends: if perl 5 does it that way, that's a strong argument for rakudo to do the same :) | ||
mberends | yes, they agree now :) | ||
masak | also, there's an argument by sanity. :) | 12:56 | |
jnthn | mberends: Nice. :-) | ||
mathw | moritz_: well except the ones that don't return boolean values of course | ||
12:56
SmokeMachine left
|
|||
masak | if the user actually *specifies* a path in the invocation, that's pretty prioritized. | 12:56 | |
pmichaud | (junctions and negation) S03:3121 discusses this in some detail. ("Use of negative operators...") | ||
I'm not sure if that needs to be updated to take into account !'s meta-ness. | 12:57 | ||
moritz_ | pmichaud: you're so boring, citing specs when we could bikeshed for ages... :-) | ||
mathw | pmichaud: yes can't you tell I'm trying to procrastinate here? | 12:58 | |
mathw reads S03 | |||
pmichaud | because the way S03:3121 reads, it makes it sound as though infix:<!=> is its own operator, and not the same as !($a == $b) | ||
12:59
snarkyboojum joined
|
|||
pmichaud | mathw: (procrastination) -- trying to resolve ambiguities/contradictions in the synopses is a great way to procrastinate. Unless you're trying to procrastinate resolving the ambiguities and contradictions in the synopses. :-) | 12:59 | |
mathw | pmichaud: the best form of procrastination gets something else useful done | ||
and yes, S03:3121 does seem to indicate that | |||
pmichaud | mathw: that sounds good... I'll need to think on it more a bit later. | ||
mberends | uh-oh, perl5 puts '.' at the end of @INC, perl6 has it immediately after PERL6LIB, which is also better for overriding system with local. Hmm, don't want to follow perl5 there. | 13:01 | |
pmichaud | mberends: iiuc, having . anywhere but the end is a potential security risk | 13:02 | |
moritz_ | '.' in INC is potentially harmful | ||
we should disable that once wie have 'use lib' and Cwd and such nice modules | |||
mberends | ok, '.' can move to the end | 13:03 | |
pmichaud | "overriding system with local" is also another way of saying "silently replace the standard system module with a hacker-compromised version" | 13:04 | |
mberends | it sounded like a good idea for testing, but indeed it's bad for production | 13:05 | |
pmichaud | while it makes things easier for developers, it .... right | ||
developers should probably have the burden of extra work here. :-) | |||
mberends | heh, yes | ||
13:05
moritz_ sets mode: +o mberends
13:08
Guest65941 left
|
|||
mathw | yes doing that should be possible, but very explicit | 13:11 | |
13:14
wasmahen joined
|
|||
wasmahen | hey | 13:14 | |
is this perl6 | |||
mberends | wasmahen: oh yeah! | ||
masak | it is. | ||
welcome! | |||
wasmahen | i have been looking at this wikipedia article on perl6 en.wikipedia.org/wiki/Perl6 | ||
are we regressing? | |||
masak | a little, sometimes. | ||
wasmahen | perl 5: my $i = "25" + 10; # $i is 35 | ||
masak | aye. | 13:15 | |
wasmahen | perl6: my Str $s = "Hello, world"; | ||
why | |||
p6eval | elf 30803, pugs, rakudo 240400: ( no output ) | ||
moritz_ | rakudo: my $i = "25" + 10; say $i | ||
p6eval | rakudo 240400: OUTPUT«35» | ||
masak | wasmahen: you don't have to type your variables if you don't want to. | ||
moritz_ | still works. | ||
wasmahen | do i have to declare my variable type | ||
masak | no. | ||
pmichaud | wasmahen: no. | ||
masak | that's what I meant by 'you don't have to'. | ||
pmichaud | wasmahen: if you do, it's a type constrait. | 13:16 | |
wasmahen | so $str = "hello world" works | ||
masak | yup. | ||
wasmahen | great | ||
pmichaud | well, you still have to declare $str | ||
moritz_ | perl6: my $str = "hello world"; say $str | ||
p6eval | elf 30803, pugs, rakudo 240400: OUTPUT«hello world» | ||
pmichaud | you just don't have to type it | ||
wasmahen | great, i was afraid for a moment there | 13:17 | |
am expecting a lot from perl6 | |||
masak | wasmahen: does the Wikipedia article give the impression that you have to provide types for all variable declarations? | ||
wasmahen | masak: ya | ||
masak: it says: In Perl 6, the dynamic type system of Perl 5 has been augmented by the addition of static types | |||
snarkyboojum | and then "However, as with Perl 5, programmers can do most things without any explicit typing at all:" | 13:18 | |
13:18
nodie joined
|
|||
masak | snarkyboojum! \o/ | 13:18 | |
wasmahen | ya, as if telling me perl5 could do this but in perl6, they made is more complicated | ||
it* | |||
PerlJam | greets | ||
snarkyboojum | masak: o/ | ||
pmichaud | PerlJam: /part #rakudosketch | 13:19 | |
masak | wasmahen: 'Perl 6 offers a hybrid typing system whereby the programmer may choose to use Static Typing, Dynamic Typing or mix the two.' | ||
wasmahen: seems to me to be pretty explicitly telling you that it's optional. | |||
pmichaud | I'd move the option description a bit higher | ||
snarkyboojum | I guess it points out static types first because that's new in Perl 6 | 13:20 | |
wasmahen | masak: all this is too complicated words for me | ||
PerlJam | pmichaud: Is someone going to register the channel, etc.? | ||
wasmahen | english is not my maternal language | ||
masak | wasmahen: ok. thanks for letting me know. | ||
pmichaud | "However, static typing remains optional, so that ..." | ||
instead of "However, as with Perl 5, ..." | |||
moritz_ | PerlJam: we moved to #phasers because nobody had registered #rs | ||
PerlJam: so we couldn't even set the topic | |||
pmichaud | only sorear++ is left in the channel when PerlJam++ parts | 13:21 | |
masak | pmichaud: how do you know? :) | ||
wasmahen: the Wikipedia page was clear, but maybe not perfectly organized. thanks for pointing it out. | |||
jnthn | .oO( nobody a/part from ... ) |
13:22 | |
wasmahen | ok goodnite | ||
13:22
wasmahen left
|
|||
pmichaud | masak: by surreptitiously peeking my head inside the channel from time to time :-) | 13:22 | |
PerlJam | 13:22 -!- PerlJam [duff@feather.perl6.nl] has left #rakudosketch [] | 13:23 | |
masak | pmichaud: you can't measure an IRC system without also affecting it :P | ||
pmichaud | masak: I'm willing to claim that my statement was/is correct, however. :) | 13:24 | |
masak: and I'm not sure anyone can disprove it. :) | |||
masak | pmichaud: lol | ||
moritz_ | :-) | ||
pmichaud | when PerlJam++ parted, only sorear++ was left. That seems the most likely situation. | ||
13:24
nodie left
13:27
takadonet left
|
|||
dalek | kudo: 1728e99 | (Solomon Foster)++ | src/core/Cool-str.pm: Clarify logic at masak++'s suggestion. |
13:28 | |
kudo: 51b61c5 | (Martin Berends)++ | src/Perl6/Compiler.pir: [Perl6/Compiler.pir] re-order @*INC again, '.' goes to the end, pmichaud++ |
|||
13:28
jhuni joined
|
|||
dalek | kudo: 6f0e67d | (Martin Berends)++ | src/core/Cool-str.pm: Merge branch 'master' of github.com:rakudo/rakudo |
13:28 | |
kudo: fd769c8 | pmichaud++ | (2 files): Update Perl6::Actions to grab dynamic outer compilation via HLL::Actions |
|||
kudo: 20068fa | pmichaud++ | src/ (2 files): Merge branch 'master' of github.com:rakudo/rakudo |
|||
pugssvn | r30804 | colomon++ | [t/spec] Add tests for .subst with :p and :c options. | ||
colomon | woah | ||
13:30
pmurias joined
13:31
zostay left
13:34
isBEKaml joined
13:39
ejs left
13:40
pmurias left,
SmokeMachine joined
|
|||
isBEKaml | hi all! :) | 13:40 | |
13:41
JimmyZ left
|
|||
moritz_ | colomon: do those tests pass? | 13:41 | |
13:42
kaare joined
|
|||
isBEKaml | oh, I was wondering if my network went into latency or this channel was _really_ silent.. ;) | 13:43 | |
13:43
kaare is now known as Guest74734
|
|||
pmichaud | Perhaps the people in the channel went into latency. | 13:43 | |
moritz_ | isBEKaml: you can always check the website with the IRC logs :-) | ||
isBEKaml | :) | 13:44 | |
PerlJam | isBEKaml: We're all here to varying degrees :) | ||
13:44
ejs joined
|
|||
isBEKaml | #perl6++ # I wish I could +1 everyone. :) | 13:45 | |
pmichaud | I bet it could be done with a Perl script. :) | ||
moritz_ | irssi directly supports Perl plugins | 13:46 | |
isBEKaml | yes, and I'm yet to learn how to do those. But I use XChat since I don't have an unicode ready console, yet.. | ||
masak | hi, isBEKaml! :) | 13:47 | |
isBEKaml | yo, masak! :) | ||
moritz_ | the documentation of the plugin API is in a rather sad state | ||
it basically consists of a short intro (Juerd++), the source code and many example scripts | 13:48 | ||
isBEKaml | moritz_: XChat or irssi? | ||
moritz_ | isBEKaml: irssi | ||
masak | Perl 6 doesn't have a way to combine hexadecimal literals and scientific notation, does it? | ||
isBEKaml | I have used both, but I knida like irssi better since i don't have to go into X for that. :) | ||
moritz_ | masak: sure it does :/ | 13:49 | |
search S02 for :16< or so | |||
13:49
patspam joined
|
|||
moritz_ | rakudo: say :16<a0*10**2> | 13:50 | |
p6eval | rakudo 240400: OUTPUT«16000» | ||
masak | moritz_: I know about that, but it doesn't elimiate the fact that you can't use E to mean 'scientific notation' in a hexadecimal literal. | ||
colomon | moritz_: yes, the :p and :c tests all pass, no prob. | ||
masak | but I suppose ** works just as well. | 13:51 | |
moritz_ | urk, t/spec/integration/advent2009-day02.t test 8 failed | ||
fixing... | 13:53 | ||
pugssvn | r30805 | moritz++ | [t/spec] fix typo | ||
dalek | kudo: 4569863 | masak++ | src/Perl6/Module/Loader.pm: [Module::Loader] removed redundant period without a full stop after them. |
13:59 | |
13:59
gbacon joined
|
|||
moritz_ | masak++ # cleaning up my mess :-) | 13:59 | |
masak | it was a very minor mess. :) | ||
but it's a great feeling to have the power, when bothered by a minor detail, to just commit the change, and it's fixed! \o/ | 14:00 | ||
moritz_ | .oO( masak admits his power hunger :-) |
14:01 | |
masak | om nom nom. | ||
isBEKaml | rakudo: say 'The foo and the bar'.subst(/:i the/, 'that', :g, :samecase); | 14:02 | |
p6eval | rakudo 240400: OUTPUT«that foo and that bar» | ||
isBEKaml | moritz_: I'm confused by your blog challenge. What was it about? hooking :samecase to Cool-str ? | 14:03 | |
moritz_ | yes | ||
and still is | |||
if it worked, the first 't' in the output would have been upper case | |||
isBEKaml | ah | 14:04 | |
rakudo: say 'The foo and the bar'.subst(/:i the/, 'that', :g); | |||
p6eval | rakudo 240400: OUTPUT«that foo and that bar» | ||
moritz_ | it just ignores options it doesn't understand | 14:05 | |
isBEKaml | so, :samecase is redundant as of now. But challenge is to add weights to it. :) | ||
moritz_ | right | ||
masak | isBEKaml++ # I can see you're thinking about it... :) | 14:06 | |
isBEKaml | masak: lol, I don't know if I can come up with something. I'm only git pulling.... :) | 14:07 | |
PerlJam | 'THE'.subst(/:i the/, 'that', :samecase); # what should this do? :) | ||
moritz_ | rakudo: say samecase('that', "THE") | ||
p6eval | rakudo 240400: OUTPUT«THAT» | ||
moritz_ | exactly THAT :-) | ||
14:07
M_o_C left
|
|||
PerlJam | excellent. | 14:08 | |
snarkyboojum | yay, I just did an HTTP request using Rakudo :P | ||
lol | |||
masak | PerlJam: S05:225. | ||
PerlJam | masak: yeah, just got there :) | ||
isBEKaml | snarkyboojum++ ## that could turn into something of a tryrakudo.org ? :) | ||
moritz_ | we really need a specbot that answers FAQs with links to synopsis :-) | 14:09 | |
snarkyboojum | isBEKaml: :) | ||
masak | snarkyboojum: you're about two years behind. :P november-wiki.org/ | ||
PerlJam | moritz_: that would make a good not-necessarily-perl6 challenge :) | ||
snarkyboojum | masak: I have no clever comeback for that :) | ||
moritz_ | masak: doing a HTTP request != answering a HTTP request | 14:10 | |
14:10
BrowserUk joined
14:11
am0c joined
|
|||
masak | moritz_: oops. | 14:12 | |
actually, I don't think I've ever *done* an HTTP request from Rakudo. snarkyboojum++ | |||
snarkyboojum | :) | ||
jnthn wonders if IRC::Client works on current Rakudo | 14:13 | ||
14:18
M_o_C joined
|
|||
pmichaud | jnthn: ping | 14:19 | |
14:19
viklund left
|
|||
moritz_ received a submission for this week's challenge o/ | 14:19 | ||
and from a first look it's pretty good | 14:20 | ||
isBEKaml | moritz_: so soon? \o/ | ||
14:20
ruoso_ joined
|
|||
jnthn | pmichaud: pong | 14:20 | |
pmichaud: Gimme some relief from Java! :-) | |||
pmichaud | I need some guidance with the YOU_ARE_HERE stuff that's been added to Rakudo. | ||
jnthn | Out of the fat and into the fryer... :-) :-) | 14:21 | |
pmichaud | iiuc, YOU_ARE_HERE is intended to make it appear that code is executed lexically inside of the setting | ||
jnthn | pmichaud: It mostly works just by twiddling the outer of the outermost lexical scope of the program to actually be the setting. | 14:22 | |
pmichaud | I don't like the $*IN_EVAL contextual -- it's fragile. | ||
jnthn | As in, user-space twiddlable? | 14:23 | |
In that sense yes. | |||
pmichaud | no, in the sense that there may be code that gets evaled (e.g. interactive mode) but doesn't set $*IN_EVAL | ||
jnthn | Ah, and then we don't want the outer scope of the thing to be the setting... | ||
Yes. | |||
Maybe it's the wrong flag. | 14:24 | ||
And we need to look at it the other way | |||
$*IN_MAINLINE # this is the mainline code | |||
pmichaud | dynamic vars as flags tend to be code smells to me | ||
jnthn | Many things relating to the current bit of parsing/compilation we're doing are done with dynamic vars. | 14:25 | |
Guess this could be an over-use of them. | |||
What would you suggest instead? | |||
pmichaud | yes.... it feels like the use of $past<something> as flags as well -- they should be used minimally | ||
jnthn | Aye, I agree on those. | 14:26 | |
pmichaud | I don't know -- I just needed to make sure I understood what YOU_ARE_HERE is doing | ||
jnthn | The action for YOU_ARE_HERE just shoves a tiny bit of code in the setting that twiddles the outer lexical scope of the bit of the Parrot sub it is passed. | ||
Since that code is in the lexical scope of the setting, the chain ends up having the setting in it. | 14:27 | ||
pmichaud | looks to me like it actually generates a sub in the setting | ||
jnthn | Right. | ||
pmichaud | any particular reason it needs to be !YOU_ARE_HERE? | ||
i.e., couldn't it also be &YOU_ARE_HERE just as easily? | |||
jnthn | No, I just needed something to call it. :-) | ||
Well | |||
I didn't really think it should be user-space exposed. | |||
Folks can't call a thing from Perl 6 land with a ! at the start. :-) | 14:28 | ||
moritz_ | S06 (iirc) mentions YOU_ARE_HERE, and doesn't say it's hidden | ||
jnthn | That was pretty much the entire reason though. | ||
pmichaud | YOU_ARE_HERE shows up in the spec, so I'm guessing it's userspace exposed | ||
jnthn | As something you can pass a chunk of code to and have it run in the current setting? | ||
If so, then yes, by all means let's rename it. | |||
pmichaud | Haven't read yet -- I just know that it's in the spec | ||
okay, I'll work on any refactors there. Currently that $*IN_EVAL appears to be destroying my outer context in interactive REPL | 14:29 | ||
jnthn | tbh, the majority of the effort in making this work was fixing other areas we got lexical-ish bits not quite right. | ||
14:29
uniejo left
|
|||
jnthn | Not the actual YOU_ARE_HERE thing that did set_outer | 14:29 | |
14:29
isBEKaml left
|
|||
jnthn | Yes, I can imagine it would cause problems there. | 14:30 | |
Feel free to change it as you see fit. | |||
pmichaud | will do | ||
In some sense I'm thinking of changing YOU_ARE_HERE.pm to have a full sub declaration | |||
our sub YOU_ARE_HERE(...) {...} | 14:31 | ||
jnthn | That would also be workable | ||
pmichaud | okay, I'll read up on the spec and see what comes out | ||
jnthn | I was more attempting to match STD and svn.pugscode.org/pugs/src/perl6/CORE.setting | ||
pmichaud | yes, I noticed that also :-) | ||
jnthn | (see YOU_ARE_HERE token at end) | ||
pmichaud | I can see that it's following STD. I'm wondering if this is a place wehre Rakudo should simply so that STD.pm6 can follow what it does instead :) | 14:32 | |
*simplify | |||
jnthn | :-) | ||
mathw | jnthn: I'm right with you on Java generics | 14:34 | |
jnthn: the only thing that's worse is using the collection classes without them | |||
pmichaud | yeah, term:YOU_ARE_HERE appears to be more of a "invoke the mainline code" term rather than a "define the YOU_ARE_HERE sub at this point" | ||
(according to S02) | |||
14:35
XaeroOne left
|
|||
TimToady | for | 14:36 | |
for VMs that can't do 'set outer' it's more of a freeze/thaw point | |||
pmichaud | TimToady: makes sense to me | ||
jnthn | mathw: I know just fine what type erasure is, but I'm quite sure Joe Programmer is in for a shock when the compiler starts whining that he can't define these two methods with different signatures because the type-erase to the same thing. :-/ | 14:37 | |
*they | |||
oh hey, I think I fixed $nasty-work-bug | |||
pmichaud | jnthn: I wonder if we can dynamically detect "mainline" code as being code that doesn't have an outer context set. | 14:38 | |
(at which point we force its outer to be the setting) | |||
eval'd code would already have an outer context set | |||
jnthn | pmichaud: Maybe. | 14:39 | |
TimToady | in a sense, so does the mainline code | ||
jnthn | pmichaud: May get an off-by-one if there is some outer scope which is the thingy that actually gives the mainline to YOU_ARE_HERE (or whatever we call the code that does the twiddling) | 14:40 | |
TimToady | YOU_ARE_HERE should be more or less indistinguishable from a 'my package UNIT { ... }' at that point | ||
pmichaud | TimToady: yes, I was thinking of something like that too :-) | 14:41 | |
jnthn | pmichaud: Then, I guess that's solvable by .lexical(0) on the mainline PAST::Block. | ||
TimToady | but anything you can do to fake that is fine | ||
pmichaud | jnthn: right. | ||
jnthn | So yeah, sounds feasible. | ||
TimToady | as long as it happens soon enough that the compilation of UNIT knows it | ||
jnthn | "if get_outer returns NULL..." | ||
pmichaud | or the outer scope is the thing that does the checking for "do I have an outer scope?" before calling UNIT_START | ||
as opposed to checking outer of the "inner mainline" | 14:42 | ||
14:42
M_o_C left
|
|||
pmichaud | (sorry, that was totally confusing) | 14:42 | |
(rephrasing) | |||
the off-by-one wrapper scope can check itself for "do I have an outer?" to decide if it's really the mainline execution or no | 14:43 | ||
it can then decide what to do with the "mainline" that it's wrapping. | |||
jnthn | pmichaud: Ah, get it. | 14:44 | |
pmichaud: That also works. | |||
pmichaud | if the wrapper already has an outer scope set, then it can just invoke the mainline and be done. | ||
jnthn | *nod* | ||
pmichaud | and we then reserve UNIT_START for actual mainline execution. | 14:45 | |
jnthn | That feels righter than making the code that does the set_outer have to do that check. | ||
snarkyboojum | masak, moritz_: ok, I just posted a dent from rakudo :P | ||
masak | cool! | ||
jnthn | oh noes...you dented it?! | ||
.oO( It'll buff out ) |
|||
pmichaud | and in fact! | ||
snarkyboojum | command-line identica'ing from rakudo :) | 14:46 | |
pmichaud | we can make sure our mainline block is always .lexical(0) | ||
if the off-by-one wrapper has an outer scope set, it passes that scope to mainline before executing it | |||
otherwise it calls UNIT_START or YOU_ARE_HERE or whatever, which sets the mainline's outer to the setting before executing it | 14:47 | ||
14:47
am0c left
|
|||
masak | found it! identi.ca/notice/33651989 | 14:47 | |
pmichaud | either way, the off-by-one wrapper is out of the outer context chain by the time it passes control to mainline | ||
jnthn | *nod* | ||
pmichaud | then mainline's OUTER would indeed be the setting directly | ||
jnthn | Even better. | 14:48 | |
snarkyboojum | hehe that's it ;) now I just have to make it say "from rakudo" instead of "from api" | ||
pmichaud | okay, I'll work on those refactors. | ||
jnthn | pmichaud++ | ||
pmichaud | I'm much more comfortable with this now. | ||
jnthn | Me too. ;-) | ||
pmichaud | it feels much less workaround-y and more "do exactly what is supposed to happen here" | 14:49 | |
it also stays consistent with other aspects of PCT/NQP compilation | |||
(i.e., the evalpmc[0] is the one that determines outer context) | |||
pugssvn | r30806 | moritz++ | [t/spec] tests .subst() with :samecase | ||
r30806 | | |||
r30806 | Patch courtesy of Hongwen Qiu | |||
masak | snarkyboojum: make it say 'from perl6awesomedent' :) | 14:50 | |
snarkyboojum | masak: hehe | ||
pmichaud | okay, need a short break here -- will be back later | ||
masak | on the list of Things We Have Plan 9 to Thank For: UTF-8. | 14:51 | |
moritz_ | I'm curious: what else is on that list? | 14:54 | |
[particle] | the plan 9 mascot. | ||
masak | I bet one could put something having to do with C compilers on that list. | ||
the Plan 9 people actually share much of the hubris of the Perl 6 crowd. they know they got a lot of things right, and deplore that it's not more widely known. | 14:55 | ||
pmichaud | s/Thank/Blame/ # perhaps? | 14:56 | |
moritz_ kinda likes UTF-8 | |||
14:56
finanalyst left
|
|||
moritz_ | it's not ideal for implementing regex engines, but I don't do that very often :-) | 14:56 | |
TimToady | UTF-8 is pretty okay as long as you don't have to random access it | 14:57 | |
arnsholt | I'd argue that it's also a matter of foisting complexity off to the implementors | ||
PerlJam | moritz_: Plan 9 is also relatively unknown as far as OSes go. Hopefully Perl 6 doesn't share the analogous trait wrt languages. | 14:58 | |
masak | this presentation especially kinda reeks of "here's what we know we did wrong and want to do better": www.cs.unm.edu/~fastos/05meeting/PL...EADYET.pdf | ||
PerlJam: Perl 6 is already famous. unfortunately not yet for all the right reasons :/ | |||
& | 14:59 | ||
TimToady | if you squint, Perl 6 looks like a dyslexic Plan 9 | ||
moritz_ | that's a line for my fortune file :-) | ||
arnsholt | masak: Perhaps infamous is even better than famous. Especially when Perl 6 suddenly turns out to be awesome =) | 15:00 | |
jnthn -> beer shopping, bbiab | |||
15:02
am0c joined
15:03
justatheory joined
|
|||
moritz_ | masak: I like it. "Don't believe me? Type 'stty' at an xterm | 15:03 | |
and tell me why a window has a baud rate" | |||
PerlJam | heh, I just read that slide too :) | ||
moritz_ | they do have a point | 15:08 | |
15:09
justatheory left
|
|||
snarkyboojum | masak: there ya go - identi.ca/notice/33654228 :P | 15:09 | |
moritz_ | :-) | ||
snarkyboojum | 'from perl6awesomedent' | 15:10 | |
ok.. enough spam from me :) | |||
15:13
orafu joined
|
|||
TimToady | .oO(Perl 5 : Perl 6 :: Ma Bell : Bell Labs) |
15:13 | |
15:19
isBEKaml joined
|
|||
pugssvn | r30807 | pmurias++ | [mildew] renamed Mildew::Parser::* to Mildew::Frontend::* | 15:20 | |
ajs | rakudo: use Test; "abc" ~~ /a[ $<x> = (b) ]?c/; ok($/<x> eq "b", "aliased match within optional non-capturing group") | 15:22 | |
p6eval | rakudo 456986: OUTPUT«No applicable candidates found to dispatch to for 'infix:<eq>'. Available candidates are::():(Any $a, Any $b)current instr.: '_block14' pc 29 (EVAL_1:0)» | 15:23 | |
pmichaud | jnthn: ping | ||
ajs | rakudo: use Test; "abc" ~~ /a[ $<x> = (b) ]c/; ok($/<x> eq "b", "aliased match within non-capturing group") | ||
p6eval | rakudo 456986: OUTPUT«ok 1 - aliased match within non-capturing group» | ||
ajs | One of these things is not like the other.... | ||
moritz_ | ajs: the problem with the first test is that $/ isn't a a Perl 6 object at the moment | ||
so it's not compatiable with Any :( | 15:24 | ||
ajs | So how do you do aliasing in that case? | ||
moritz_ | rakudo: use Test; "abc" ~~ /a[ $<x> = (b) ]?c/; is("$/<x>", "b""aliased match within optional non-capturing group") | 15:25 | |
p6eval | rakudo 456986: OUTPUT«Unable to parse postcircumfix:sym<( )>, couldn't find final ')' at line 11current instr.: 'perl6;Regex;Cursor;FAILGOAL' pc 1971 (ext/nqp-rx/src/stage0/Regex-s0.pir:1050)» | ||
moritz_ | rakudo: use Test; "abc" ~~ /a[ $<x> = (b) ]?c/; is("$/<x>", "b", "aliased match within optional non-capturing group") | ||
p6eval | rakudo 456986: OUTPUT«not ok 1 - aliased match within optional non-capturing group# got: "1"# expected: "b"» | ||
pmichaud | stringify it first | ||
try ~$<x> eq 'b' | |||
moritz_ | rakudo: use Test; "abc" ~~ /a[ $<x> = (b) ]?c/; is("$/<x>[0]", "b", "aliased match within optional non-capturing group") | ||
p6eval | rakudo 456986: OUTPUT«ok 1 - aliased match within optional non-capturing group» | ||
moritz_ | ah, that's the problem | 15:26 | |
the array in $<x> stringifies incorrectly | |||
(again it's a parrot thing, not a proper Perl 6 array) | |||
pmichaud | ....because it's a parrot array. Good catch. | ||
I should be able to look at those today. | |||
moritz_ | we have an old ticket for that in RT | ||
ajs | freaky.... so why is it an array when I say [$<x> = (b)]? and a string when I say [$<x> = (b)] | 15:27 | |
pmichaud | ajs: because of the quantifier | ||
moritz_ | [...]? | ||
pmichaud | consier: [$<x> = (b)]* | ||
*consider | |||
ajs | Ah, I see | ||
OK, thanks | |||
pmichaud | $<x> would be an array of captures | ||
s/captures/matches/ | |||
ajs | That's going to really trip some people up, becuase they have to look outside of the alias to determine what kind of match they're going to get. | 15:28 | |
But I can work with that now | |||
pmichaud | I've been wondering if quantified captures should act the same as the :global flag, though | ||
i.e., they return a match object with the individual captures in .[] | 15:29 | ||
instead of returning an array of match objects | |||
moritz_ | that could also be pretty confusing | ||
because match objects usually represent continuous matches | |||
and those wouldn't | |||
pmichaud | ...except in the case of :global :-) | ||
it just seems like a potential semantic mismatch there | 15:30 | ||
ajs | Unrelated: in perl 5, I would return undef to indicate "no result". In P6, is that Mu or should I be returning a more specific type or fail()? | 15:31 | |
pmichaud | ajs: fail(), usually. | ||
ajs | ok,thanks | ||
moritz_ | or maybe Nil | ||
pmichaud | yes, Nil if you really mean "no result" | ||
moritz_ | that' like the perl 5 return(); # empty list in list context | 15:32 | |
pmichaud | moritz_: yes, I agree that using match instead of array could end up being confusing. someone could then do $<x>.to and be totally surprised at the result | ||
whereas if it's an array, $<x>.to at least gives an error about no method 'to' | 15:33 | ||
so, I guess we leave it as an array | |||
still feels a little weird that :global is different :-) | |||
moritz_ | +1 to leaving as-is | ||
or even better... | 15:34 | ||
pmichaud | okay, I'm grabbing lunch, then will come back to work on YOU_ARE_HERE refactors | ||
moritz_ | don't we have some listy objects that behave just like the stored object if there's only one inside? | ||
pmichaud | sure -- they're called Parcels :-) | ||
moritz_ | then why don't we use a Parcel instead of an Array? | ||
that way matches quantified with ? will DWIM as much as possible | 15:35 | ||
pmichaud | well, at the parrot level that would be problematic. | ||
moritz_ | Perl 6 will construct its own Match objects | ||
pmichaud | i.e., nqp-rx would never be able to match that. | ||
(not that nqp-rx needs to be driving perl 6 design) | |||
isBEKaml | rakudo: my %hash =<a 1 b 2>; say %hash.keys; say %hash{$_} for %hash.keys; | 15:36 | |
p6eval | rakudo 456986: OUTPUT«ba21» | ||
15:36
pmurias joined
|
|||
pmichaud | there might also be the problem that single-element captures might cease to act like an array when we need them to | 15:38 | |
moritz_ | that might indeed be a problem | ||
pmichaud | (i.e., the array-ness would get lost somewhere) | ||
15:38
Ross joined
|
|||
moritz_ | anyway, I don't want to stop you from grabbing lunch :-) | 15:38 | |
pmichaud | I'm more comfortable with things as they re now. | ||
*are | |||
yes, lunch | |||
pmichaud _ISNT_HERE | |||
pugssvn | r30808 | pmurias++ | [mildew] add missing file | 15:39 | |
r30809 | pmurias++ | [mildew] add -Fm0ld frontend | |||
pmurias | moritz_: will there be a gsoc irc meeting? | ||
moritz_ | pmurias: we've had masak report as part of the #rakudosketch meeting yesterday | 15:40 | |
pmurias: you'd certainly be welcome there next week (Tue 1900 UTC), or you could arrange something yourself | |||
masak | snarkyboojum++ # perl6awesomedent! \o/ | 15:41 | |
snarkyboojum | masak o/ :) | ||
jnthn | lol...systemet unicode FAIL. | ||
masak | pmurias: but be aware that 'there' is in another place from next week on. #phasers | ||
jnthn: what now? | 15:42 | ||
pmurias | #phasers is the new #rakudosketch? | ||
moritz_ | yes :-) | ||
for Perl 6 and Rakudo phase transitions, or so | |||
jnthn | masak: Was just glancing my receipt...and turns out whatever font they print in it doesn't have ý in it. :-) | 15:43 | |
Well | |||
masak | jnthn: oh. receipts. | ||
ajs | Gotta go, but I leave you with this one: | ||
jnthn | I'm not sure what the glyph that appears there is. :-) | ||
ajs | rakudo: "abc" ~~ /[$<x> = (b)]?/; say @($/<x>) | ||
p6eval | rakudo 456986: OUTPUT«Method 'list' not found for invocant of class 'ResizablePMCArray'current instr.: '_block14' pc 29 (EVAL_1:0)» | ||
masak | jnthn: I don't know anyone who gets receipts right. | ||
jnthn | :-) | ||
masak: As long as the beer's right, it's fine. :-) | |||
pmurias | moritz_: i think i'll just write a blog post when my milestone is finished and show it to ruoso | ||
15:44
am0c left
|
|||
masak | the ESR quote at en.wikipedia.org/wiki/Plan_9_from_B...abs#Impact is interesting from a Perl 6 perspective as well. Perl 5 may ultimately be a 'dead end', but it's a quite successful one. :) | 15:46 | |
pmurias | if i convert m0ld -> AST -> m0ld it's called round-tripping? | ||
masak | pmurias: aye. | 15:48 | |
pugssvn | r30810 | pmurias++ | [mildew] added a -Cm0ld backend to test roundtriping | 15:51 | |
diakopter | pmurias: ih | ||
15:54
constant joined,
constant left,
constant joined
|
|||
diakopter | lol at "ydlsxeci Plan 9" | 15:54 | |
pmurias | diakopter: hi | 15:56 | |
15:57
masak left
|
|||
diakopter | pmurias: wuzzup | 15:57 | |
pmurias | hacking on rewriting m0ld from haskell to perl5 (part of my GSoC project) | 15:58 | |
15:59
synth left
|
|||
diakopter | pmurias: cool | 15:59 | |
16:00
IllvilJa joined,
synth joined
|
|||
pmurias | it's more a thing that needs to be done, rather then a particularly cool/fun piece of hacking | 16:00 | |
16:01
jaldhar left
|
|||
diakopter | oh | 16:01 | |
what, you're not creating a haskell-esque runtime in Perl? :) | 16:02 | ||
that was a joke | 16:05 | ||
pmurias | diakopter: see failing test i committed for perlesque | 16:07 | |
dalek | meta: r297 | pawelmurias++ | trunk/Sprixel/t/parse_bug3.t: failing test - dunno why |
16:08 | |
pmurias | please rename it when you find out the true orgin of the bug | 16:09 | |
when are classes better then roles? | 16:11 | ||
TimToady | when you might want to do monkey patching, since roles are immutable | 16:12 | |
when you want your class to have state | 16:13 | ||
16:13
ejs left
|
|||
TimToady | when you want uneven mixin semantics rather than flat composition | 16:14 | |
mberends | jnthn: I probably haz $work in Helsingborg June 20-23 (a M$ bootcamp). Will you be in Lund before/after those days? | ||
pmurias | TimToady: mixin semantics? | 16:15 | |
diakopter: the other thing i'm hacking on is a game in erlang | |||
jnthn | mberends: ooh, maybe, let me check travel/conf schedule. | ||
mberends: Helsingborg is extremely near here. | |||
mberends: I'm away from the 23rd. | 16:16 | ||
mberends: I'm around the couple of days before. | |||
mberends | ok, maybe a visit from Friday 18th evening or Saturday morning is possible | 16:17 | |
isBEKaml | moritz_: sorry I was away for some time, "power" problems. :( | ||
moritz_: that challenge was unbelievably simple. :O | |||
jnthn | mberends: wfm. | ||
You're welcome. :-) | |||
mberends | :-) self.invite(); | 16:18 | |
jnthn | ;-) | ||
mberends: Did you get any further on the void thingy? | |||
mberends: If not, have you got a small test case I can try? | |||
mberends | nope. the examples file runs, but not the DBI stuff under construction. It's much bigger :-( | 16:19 | |
mberends gets back into FakeDBI mode | 16:20 | ||
jnthn | Ah | ||
mberends: I wonder if the null return value is somehow causing an explosion. | |||
mberends | null != void of course | ||
jnthn | That is, I'd expect that doing $P0 = foo() where foo is an NCI with a signature starting "v" would just shove a null PMC in the register (or complain) | 16:21 | |
Yeah | |||
16:21
pnate joined
|
|||
jnthn wonders what a good fix may be | 16:21 | ||
mberends: There isn't any chance you can get a backtrace? | |||
16:22
colomon left
|
|||
jnthn | e.g. run it under gdb? | 16:22 | |
jnthn is really curious where it segfaults | |||
mberends | ok, will try gdb | ||
PerlJam | from #p5p ... | 16:24 | |
<@xdg> anyone want to opine on how hard it would be to let "when" work inside a map block? | |||
slowly morphing perl 5 into perl 6 :) | |||
mberends | heehee | ||
jnthn | rakudo: (1..10).map({ when 3 { say "tre" }; when 5 { say "fem" }; }).eager | 16:26 | |
p6eval | rakudo 456986: OUTPUT«trefem» | ||
jnthn | Easy. ;-) | ||
jnthn mostly wanted to make sure Rakudo handled it right :-) | |||
16:27
justatheory joined,
hercynium left
|
|||
snarkyboojum | isBEKaml: my "I did an HTTP request!" *did* turn into something useful - a little cli identi.ca client :) | 16:27 | |
moritz_ | isBEKaml: never said it was hard | ||
isBEKaml | snarkyboojum: nice. link? | 16:28 | |
moritz_: :) | |||
snarkyboojum | isBEKaml: well, it's "as rough as guts" but this is the gist gist.github.com/414632 | 16:29 | |
isBEKaml | snarkyboojum++ ## Dented IO::Socket::INET!! :) | 16:30 | |
16:31
M_o_C joined
|
|||
snarkyboojum | isBEKaml: :P | 16:31 | |
pmichaud | back again | 16:33 | |
jnthn: ping | 16:34 | ||
jnthn | pmichaud: pong | ||
pmichaud | jnthn: want to see a Truly Evil Cheat? ;-) | ||
(found this last night while working on repl) | |||
jnthn | Uh-oh... | ||
:-) | |||
lisppaste3 | pmichaud pasted "lexpad evil cheat (for jnthn++)" at paste.lisp.org/display/100517 | 16:35 | |
16:35
synth left
|
|||
jnthn | copy pad, $P1 | 16:35 | |
?! | |||
16:35
XaeroOne joined
|
|||
pmichaud | I CAN HAZ DYNAMIC LEXPADZ | 16:35 | |
moritz_ | epic | ||
jnthn | omg. | ||
There is a proper way to do that. :P | 16:36 | ||
pmichaud++ | |||
pmichaud | there is? | ||
jnthn | pmichaud: LexPad and LexInfo are, iirc, HLLMappable. | ||
pmichaud: But that's effort. ;-) | |||
pmichaud | I only need to do it in one instance, though. | ||
jnthn | Ah | ||
Then hack away...and hope. :-) | |||
pmichaud | I don't want all of them to be dynamic... just the one that holds the outer context information for each interactive repl line | ||
jnthn | Where are you doing it, ooi? | ||
ah, ok | 16:37 | ||
Makes sense. | |||
16:37
meppl joined
|
|||
pmichaud | essentially, invoke a line of code, capture its context while executing, when it's done executing collect all of the lexicals into the dynamic lexpad | 16:38 | |
jnthn | Ah | ||
pmichaud | on the next line of code, use the context containing the dynamic lexpad as the outer context for the new line of code | ||
jnthn | Saves building up a long long chain of 'em. | 16:39 | |
pmichaud | rinse, repeat. | ||
actually, the long-long chains weren't working out. | |||
Parrot doesn't provide sufficient introspective context getting/setting ability to really get the chains to work out | |||
jnthn | Oh. | ||
:-| | |||
pmichaud | also, if a sub doesn't believe it's an :outer, it tends to want to throw away its context when it's done | ||
16:39
synth joined
|
|||
pmichaud | i.e., the return continuation says "okay, we're done, we're not an outer, so we can just throw everything away now!" | 16:39 | |
and it clears out the registers | 16:40 | ||
jnthn | :| | ||
Happy there's a solution. | |||
pmichaud | me too. | ||
jnthn | Even if it does win you disgusting hack on the month award. :-) | ||
*of | |||
pmichaud | I thought it was pretty clever | ||
nicer would've been if I could simply setattribute ctx, 'lexpad', pad instead of using the copy | 16:41 | ||
but allas, that's not allowed either | |||
jnthn | Aye. :-) | ||
pmichaud | *alas | ||
16:42
cdarroch joined,
cdarroch left,
cdarroch joined
|
|||
jnthn wonders...what else we can use this cheat for. :-) :-) | 16:42 | ||
pmichaud | I knew you'd start thinking of that... :-) | ||
I also added a method that allows us to get an entire lexical environment of a context into a single hash | 16:43 | ||
jnthn | Ah, flattened? | ||
pmichaud | where "entire lexical environment" means context+all outer contexts | ||
yes, flattened | |||
jnthn | Handy. | ||
[particle] | easy to look up OUTER then, i suppose | 16:44 | |
OUTER::$* anyway | |||
pmichaud | somewhat... I think OUTER may be just one level | ||
jnthn | Yeah, same | ||
[particle] | oh, right. OUTER::OUTER::$*. forgot about that | 16:45 | |
jnthn | CALLER:: OTOH may want a to-the-sub-boundary flat view. | ||
pmichaud | anyway, it's in PIR, so it's a good template for other stuff we might want/need. | ||
jnthn would have to check the spec | |||
That is | |||
16:45
__2synth joined
16:46
__2synth left
|
|||
jnthn | sub foo() { my $a = 42; if 1 { bar() } }; sub bar() { say CALLER::<$a> } # does this work? | 16:46 | |
sub foo() { my $a = 42; if 1 { bar() } }; sub bar() { say CALLER::OUTER::<$a> } # or do you have to write this? | |||
diakopter | my class LexicalScope : PrototypeChain<string, LexicalScope> { } has a similar (well, PrototypeChain<TKey,TValue> does) all-keys-flattened method | ||
moritz_ | jnthn: nope, CALLER only works if the variable in the caller is declared as 'is context' | 16:47 | |
pmichaud | jnthn: I think CALLER variables are hidden unless 'is dynamic' | ||
16:47
__2synth joined
|
|||
moritz_ | wasn't CONTEXT:: used for caller + caller's lexical environment? | 16:47 | |
pmichaud | it's now DYNAMIC:: | 16:48 | |
moritz_ | ok | ||
pmichaud | and it only looks in callers, not their surrounding outers | ||
16:48
synth left
|
|||
jnthn | Ah, OK. | 16:48 | |
16:50
dakkar left
16:52
__2synth left
|
|||
pmurias | diakopter: any idea what causes that bug? | 16:54 | |
that = one in the failing test | 16:55 | ||
sorear | good morning pmurias | 16:56 | |
pmichaud | |||
pugssvn | r30811 | lwall++ | [S05] attempt to clarify :nth and :x | ||
pmurias | sorear: hi | 16:57 | |
16:59
patrickas joined
|
|||
patrickas | ola! | 16:59 | |
isBEKaml | hello, patrickas! :) | ||
mberends | perusing docs/test_summary.times, somewhere between May 16th and 20th, the execution time of the first test in every script increased dramatically (factor 2x to 10x). Subsequent tests unchanged. Any idea what caused that (not suggesting a bisect witchhunt)? | 17:00 | |
patrickas | hey isBEKaml! what's up ? what have you been working on lately ? | ||
moritz_ | mberends: so.. startup cost? | 17:01 | |
mberends | no | ||
cost of calling the first Test.pm function | |||
jnthn | mberends: Doesn't include calling plan? | ||
(that is, could plan have got more costly?) | 17:02 | ||
isBEKaml | patrickas: nothing much. Just hanging around, mostly. :) | ||
mberends | it might be plan(), yes. looking... | ||
17:03
pmurias left
|
|||
mberends | the increase is between the end of plan() and the first execution of proclaim(), usually via ok(). | 17:05 | |
jnthn | Curious. | ||
diakopter | phenny: tell pmurias no I don't know what's wrong with that bug; I recently slowed down my rate of deluding myself into thinking I have more round tuits than I actually have... | 17:06 | |
phenny | diakopter: I'll pass that on when pmurias is around. | ||
17:13
alester left
|
|||
pugssvn | r30812 | lwall++ | [S03] explain how not-raising works on != and ne | 17:21 | |
TimToady | pmichaud, mathw: S03 no longer implies that != and ne are distinct operators | 17:23 | |
jnthn | \o/ | ||
diakopter | !! | ||
pmichaud | TimToady: excellent, thanks. | ||
TimToady | so the semantics of != should match !== | 17:24 | |
jnthn | TimToady: Is negate the right thing to call the HOF that the ! meta-ooperator desugars to? | ||
TimToady | that's why I double-hedged it :) | ||
jnthn | TimToady: If so, will update Rakudo there too (or somebody can beat me to it; currently we call it something else). | ||
TimToady | what do you call it? | ||
jnthn | notresults iirc | ||
I prefer negate. | |||
rakudo: notresult | 17:25 | ||
p6eval | rakudo 456986: OUTPUT«Could not find sub ¬resultcurrent instr.: '_block14' pc 29 (EVAL_1:0)» | ||
jnthn | rakudo: notresults | ||
p6eval | rakudo 456986: OUTPUT«No applicable candidates found to dispatch to for 'notresults'. Available candidates are::(&op, Mu $a, Mu $b):(&op)current instr.: '_block14' pc 29 (EVAL_1:0)» | ||
TimToady | I like verbs like cross, reduce, etc | ||
jnthn | That | ||
Same | |||
'cus others are like | |||
rakudo: crosswith | |||
p6eval | rakudo 456986: OUTPUT«No applicable candidates found to dispatch to for 'crosswith'. Available candidates are::(&op, Iterable $a-iterable, Iterable $b-iterable):(&op, Any $a, Any $b)current instr.: '_block14' pc 29 (EVAL_1:0)» | ||
jnthn | etc | ||
snarkyboojum just realised you can exit the REPL with 'last' :) | 17:33 | ||
17:33
colomon joined
|
|||
moritz_ | now that's the last command... :-) | 17:33 | |
sorear | this is somewhat a bug and may be fixed, depending on how much of my code pmichaud used | ||
snarkyboojum | good that the REPL doesn't segfault any longer | 17:34 | |
moritz_ | std: 1/0e0 | ||
p6eval | std 30812: OUTPUT«ok 00:01 114m» | ||
moritz_ | rakudo: 1/0e0 | ||
p6eval | rakudo 456986: OUTPUT«Confused at line 11, near "1/0e0"current instr.: 'perl6;HLL;Grammar;panic' pc 528 (ext/nqp-rx/src/stage0/HLL-s0.pir:348)» | 17:35 | |
snarkyboojum | sorear: cool - I certainly didn't expect it to exit when I typed 'last' | ||
moritz_ | what's confusing about 1/0e0? | ||
colomon | maybe leftovers from the days when 1/0 was a single number instead of 1 / 0? | 17:36 | |
moritz_ | maybe | ||
rakudo: say 2/2**3 | |||
p6eval | rakudo 456986: OUTPUT«1» | ||
moritz_ | yes | ||
pugs: say 2/2**3 | |||
p6eval | pugs: OUTPUT«0.25» | ||
colomon | I thought we'd gotten rid of that complete.... :\ | ||
*completely | |||
moritz_ | token number:sym<rational> { <nu=.integer>'/'<de=.integer> } | 17:37 | |
moritz_ tries to remove | |||
colomon | any idea why TimToady just nixed smartmatching in :nth() ? | ||
moritz_ | ETOOMUCHMAGIC? | 17:38 | |
colomon | it seems the natural way to implement the rest of the specified features... | ||
17:38
perlygatekeeper left
|
|||
patrickas | how can I add a multi method to Hashes ? | 17:38 | |
naively I would have expected "augment class Hash" or "%h.^add_method" to work but they didn't :-( | |||
TimToady | because smartmatching does the *wrong* thing with :nth(1,3,5) | ||
moritz_ | patrickas: currently rakudo implements Hash as a role... so not at all | 17:39 | |
sorear | TimToady: Is there any difference between COMPILING::<$?FOO> and $*FOO ? | ||
moritz_ | rakudo: Hash.^add_method('foo', sub ($a, $b) { say $b } }); say {a => 2}.foo(3) | ||
p6eval | rakudo 456986: OUTPUT«Unable to parse postcircumfix:sym<( )>, couldn't find final ')' at line 11current instr.: 'perl6;Regex;Cursor;FAILGOAL' pc 1971 (ext/nqp-rx/src/stage0/Regex-s0.pir:1050)» | ||
colomon | TimToady: you mean if you do it $i ~~ 1, 3, 5 rather than $i ~~ any 1, 3, 5 ? | ||
moritz_ | rakudo: Hash.^add_method('foo', sub ($a, $b) { say $b }); say {a => 2}.foo(3) | 17:40 | |
p6eval | rakudo 456986: OUTPUT«Method 'foo' not found for invocant of class ''current instr.: '_block14' pc 29 (EVAL_1:0)» | ||
TimToady | colomon: yes | ||
colomon | ah, okay. | ||
are closures still allowed? | |||
moritz_ | nope | ||
TimToady | and you can still get the smartmatching via grep | ||
patrickas | moritz_ I can add a method foo, but not a multi method | ||
moritz_ | patrickas: no idea then :/ | 17:41 | |
TimToady | sorear: yes, COMPILING could conceivably be many dynamic levels outward, and any number of dynamic scopes could have overridden $*FOO inside that | ||
so they are not the same | |||
and in any case, $?FOO only defaults to $*FOO if there isn't a predefined meaning | 17:42 | ||
patrickas | rakudo: my %h;%h.^add_method('foo', sub ($a, $b) { say $b }); say {a => 2}.foo(3) | ||
p6eval | rakudo 456986: OUTPUT«31» | ||
TimToady | also, it's pretty easy to tell when a list is exhausted, and the matching can quit early | 17:43 | |
colomon | TimToady: If I'm understanding correctly, I'm not sure I like that at all. Seems like we just went from two different easy ways to specify "match every other time" (either :nth(2) :x(*) or :nth({ %_ !% 2 })) to no easy way. | ||
moritz_ | :nth(1, *+2 ... *) | ||
TimToady | :nth(2,4,6...*) | ||
:nth(1,3,5...*) | 17:44 | ||
moritz_ | colomon: :nth(2) :x(*) never did that | ||
that would always only match the 2nd item, never the 4th | |||
TimToady | well, it did in the original formulation lo these many years ago | ||
17:44
ajd joined
|
|||
TimToady | but a series is much more powerful and expressive | 17:44 | |
ajd | is there anything out on the state of perl 6? | 17:45 | |
TimToady | yes | ||
moritz_ | ajd: planetsix.perl.org has blogs about many Perl 6 things | 17:46 | |
ajd | like a paper I could read talking about where is is now, what needs to be done, what has been done, etc | ||
TimToady | however, it's a rather large state vector, so it would help to ask more specific questions | ||
moritz_ | there's also rakudo.org/status | 17:47 | |
TimToady | the state of the language as opposed to the various implementations is defined in the synopses | ||
(and in the standard parser, STD) | 17:48 | ||
17:48
patrickas left,
perlygatekeeper joined
17:49
envi^home left
|
|||
colomon | TimToady++ # series | 17:51 | |
though that completely blows our current code. | 17:52 | ||
17:53
sundar joined
|
|||
colomon | does that imply that if you have :nth and :g, hitting the end of the :nth list resets the counter to 1? | 17:53 | |
17:54
snarkyboojum left
|
|||
moritz_ doesn't think so | 17:55 | ||
sorear | TimToady: How does using a series as a smartmatch work? | ||
rakudo: say 2 ~~ 1, 3 ... * | 17:56 | ||
p6eval | rakudo 456986: ( no output ) | ||
moritz_ | it's not a smartmatch | ||
read the diff again :-) | |||
pugssvn | r30813 | moritz++ | [S03] typo | 17:57 | |
lisppaste3 | sundar pasted "Why isn't a non-increasing list an error in :nth? (S05-regex.pod)" at paste.lisp.org/display/100524 | 17:58 | |
sundar | To clarify, such a non-increasing list will most probably be a mistake, so isn't it better to flag it as such and help the programmer? | 17:59 | |
colomon | sundar: are you arguing it should be "such a list must be monotonically increasing" rather than "such a list should be monotically increasing"? | 18:01 | |
18:04
XaeroOne left
|
|||
sundar | colomon: I had to refer to the difference, but yes. :) | 18:06 | |
colomon | sundar: if so, probably because detecting it is very unreasonable (maybe impossible) if the list extends beyond the number of matches. | ||
TimToady | sorear: you can't smartmatch against an infinite series, except maybe with some kind of prover that shows two expressions will produce the same series | 18:08 | |
list smartmatches do not imply any() | |||
unlike in p5 and ancient p6 | 18:09 | ||
we might possibly define any() on monotonic infinite serieses; there may already be a conjecture in the spec about that | 18:10 | ||
moritz_ | a conjectural conjecture :-) | 18:11 | |
TimToady | but there has to be some way to know when to stop looking | ||
in the case of :nth, we have the benefit of knowing we're checking against 1...$n for finite $n | 18:12 | ||
well, until we get infinite strings :) | |||
colomon | hmm? | 18:14 | |
moritz_ | like .cat? | ||
colomon | I just figured every time we got a match, we looked at the next thing in the :nth list, and walked up the list as needed, which is why it has to be in monotonically increasing. | 18:16 | |
(which is an approach well-suited to being lazy in the case of infinite strings (ie Cat)) | 18:17 | ||
moritz_ | now we need to JFDI | ||
colomon is still confused by :x | 18:18 | ||
18:18
ajd left
|
|||
diakopter | Return of the Jfdi | 18:19 | |
colomon | moritz_: you want to work on .match or on the tests? ;) | ||
moritz_ | colomon: will look at the tests first | 18:21 | |
18:21
iblechbot joined
|
|||
colomon | moritz_: okay, I'll see if I can quickly puzzle out the new algorithm | 18:21 | |
moritz_ | so I guess ranges are still allowed? | 18:22 | |
(assuming they somhow interpolate into lists | 18:23 | ||
rakudo: say (1, 2..3).perl | |||
p6eval | rakudo 456986: OUTPUT«(1, 2..3)» | ||
colomon | I'm assuming it's actually Iterable which is allowed, which includes Ranges | ||
dalek | kudo: 4e3d29d | (Hongwen Qiu)++ | src/core/Cool-str.pm: add :samecase to Cool.subst |
18:25 | |
kudo: bafb6d9 | moritz++ | src/Perl6/ (2 files): remove rational number literal fossile |
|||
18:25
bluescreen joined
18:26
bluescreen is now known as Guest72640
18:27
charsbar left,
charsbar joined
|
|||
colomon | say 4.Iterator | 18:28 | |
rakudo: say 4.Iterator | |||
p6eval | rakudo 456986: OUTPUT«Method 'Iterator' not found for invocant of class 'Integer'current instr.: '_block14' pc 29 (EVAL_1:0)» | ||
colomon | rakudo: say 4.list | ||
p6eval | rakudo 456986: OUTPUT«4» | ||
colomon | rakudo: say 4.list.iterator | ||
p6eval | rakudo 456986: OUTPUT«4» | ||
pugssvn | r30814 | moritz++ | [t/spec] bring :nth tests up to current spec | ||
colomon | rakudo: my $a = 4.list.iterator; say $a.get; say $a.get | ||
p6eval | rakudo 456986: OUTPUT«4» | ||
18:29
BrowserUk left
|
|||
colomon | rakudo: my $a = 4.list.iterator; say $a.get; say $a.get ~~ EMPTY | 18:29 | |
p6eval | rakudo 456986: OUTPUT«41» | ||
18:30
TiMBuS left
|
|||
pugssvn | r30815 | moritz++ | [t/spec] remove more outdated usages of :nth | 18:30 | |
18:30
iblechbot left
18:31
uvtc joined
|
|||
sorear | interesting | 18:32 | |
TimToady: I think I broke something | |||
TimToady | so did I :) | ||
sorear | ./viv STD.pm6 --> Check failed; undeclared routines: invert, note | ||
uvtc | Hi p6. Does code written in Perl 6 use 2 different filename extensions for scripts and modules (like Perl 5: .pl and .pm)? | ||
moritz_ | uvtc: yes (though .pm6 is also OK) | 18:33 | |
TimToady | sorear: maybe you need a clean remake | ||
those should come in from CORE.setting via syml/CORE.syml or some such | |||
sorear | unless viv is using the wrong setting | 18:34 | |
colomon | moritz_: have a trial implementation. now compiling. | ||
pugssvn | r30816 | moritz++ | [t/spec] remove old :nth usages from .subst tests | ||
colomon | nice thing about this version is it radically more efficient when looking for a few early matches out of many. | 18:35 | |
if it sees :nth(2) it stops processing the string for matches after the 2nd is found. | |||
moritz_ | colomon: I tend to prototype the implemention of such methods in "normal" (non-setting) code, because it's faster to compile | ||
colomon | moritz_: that's probably sensible. but too late... :) | ||
my brain is still set to the days when compiling and testing ng was really fast. | 18:36 | ||
moritz_ | for example for .subst I just monkey-typed class Str, that way it was always tighter than the built-in | ||
which is in Cool | |||
colomon | moritz_++ # I had no idea you could do that. | 18:37 | |
and say probably works then too, eh? | |||
moritz_ | it does | ||
decadent luxury, I know | 18:38 | ||
sorear | Just how old is STD and gimme5? | ||
colomon | say "hello world".match(/./, :nth(1,2,*+*...*)) | 18:39 | |
duh | |||
> say "hello world".match(/./, :nth(1,2,*+*...*)) | |||
heloo | |||
18:40
slavik left
|
|||
colomon | > say "hello world".match(/./, :nth(1,3...*)) | 18:40 | |
hlowrd | |||
18:40
slavik joined
|
|||
colomon | moritz_: are the tests ready to go? | 18:40 | |
moritz_ | colomon: yes | ||
not terribly many use :nth | |||
colomon | @match = $data.match(/fo+/, :nth({ $_ !% 2 })); still in counted-match.t | 18:41 | |
moritz_ | oh | ||
colomon | should be 2, 4 ... * | ||
? | |||
moritz_ | yes | ||
colomon | I've got it;. | 18:42 | |
you added a non-monotonic test, moritz_++ | |||
pugssvn | r30817 | moritz++ | [t/spec] remove another :nth fossile, colomon++ | 18:43 | |
uvtc | When building rakudo, `make install` just installs things within my rakudo-2010.05 directory -- and not in my /usr/local -- is that correct? | ||
sorear | yes | 18:44 | |
uvtc | sorear: thanks | ||
sorear | make install installs things within your Parrot installation | ||
if you're using a system-wide Parrot install, you can install Rakudo system-wide | 18:45 | ||
pugssvn | r30818 | colomon++ | [t/spec] Simple :nth test with infinite series. | ||
uvtc | I'm doing a `perl Configure.pl --gen-parrot` build. | ||
moritz_ | that will install into rakudo-2010.05/parrot_install/ | 18:46 | |
so that after 'make install' in Rakudo you'll have a parrot_install/bin/perl6 binary | |||
jnthn | The fibonaci hello world! | 18:48 | |
jnthn likes :nth | |||
colomon | moritz_: had to patch my fix to make your non-monotonic test work. compiling version 2 now... | 18:49 | |
ooo, infinite loop | |||
uvtc | If I then want to make that perl6 available to all users on the system, can I just copy the whole rakudo-2010.05 directory to /opt, create an /opt/rakudo symlink there, and then tell them to use this shebang in their Perl 6 scripts: `#!/opt/rakudo/parrot_install/bin/perl6`? | ||
sorear | no | 18:50 | |
if you want to make perl6 available to all users on the system, you'll need to do a global install of Parrot | |||
uvtc | (Sorry, I meant mv, not cp.) | ||
sorear | parrot_install is not relocatable | 18:51 | |
1. get Parrot | |||
2. perl Configure.pl --optimize && make && sudo make install # this will put Parrot in /usr/local | |||
uvtc | sorear: but i mean moving the whole rakudo-2010.05 directory to /opt, not just the parrot_install dir. | ||
sorear | uvtc: parrot bakes paths into its files | ||
moritz_ | uvtc: perl Configure --gen-parrot --gen-parrot-prefix=/usr/local/ | ||
sorear | 3. switch back to Rakudo | ||
oh, that works too. | 18:52 | ||
moritz_ | uvtc: then run 'make install' in rakudo => profit | ||
colomon just realized he shouldn't have committed that fix, as it will cause failing tests for everyone else | 18:53 | ||
moritz_: counted-match.t works completely here now. | |||
uvtc | Oh, interesting. Sounds like somewhere it's using absolute paths instead of relative ones. | ||
pugssvn | r30819 | sorear++ | [viv] Allow saving of parsed code | 18:54 | |
sorear | uvtc: s/somewhere/everywhere/ | ||
moritz_ | colomon: \o/ | ||
uvtc | moritz: would that be `--gen-parrot-prefix=/opt` or `--gen-parrot-prefix=/opt/rakudo-2010.05`? | ||
sorear | uvtc: why not /usr/local? | ||
colomon | where were the other :nth tests? | 18:55 | |
moritz_ | colomon: subst.t | ||
sorear | whatever you use, Rakudo will be installed as PREFIX/bin/perl6 | ||
colomon | where there some in a match.t or no? | ||
moritz_ | there too | ||
uvtc | Either would be fine. I guess I just got into the habit of using /opt for "larger" self-contained software (like java). | ||
moritz_ | colomon: but those are not runnable by rakudo, iirc | ||
no wait, in counted.t | 18:56 | ||
$ ack -l :nth S05-* | |||
S05-modifier/counted-match.t | |||
S05-modifier/counted.t | |||
S05-substitution/subst.t | |||
colomon | moritz_: apparently I took stupid pills this morning, latest version handles weird lists but breaks non-nth matches. :( | ||
moritz_ | colomon: nopaste patch? | 18:57 | |
colomon | already fixed it, I think. | ||
uvtc | sorear: in that case, shouldn't PREFIX be `/usr/local/rakudo-2010.05/parrot_install` ? | ||
colomon | (compiling / testing now) | ||
sorear | uvtc: that's the default PREFIX, but you just said you wanted to move it to /opt | 18:58 | |
moritz_ | uvtc: where do you want the binary to be? | ||
uvtc | sorear: Sorry, I don't think I understand ... do I need the whole rakudo-2010.05 directory and all its contents to be in /usr/local? | ||
18:59
arthur-_ joined,
arthur-_ left
|
|||
sorear | uvtc: NO | 18:59 | |
er | |||
no. | |||
colomon | moritz_: that's better. | ||
sorear | do not move rakudo-2010.05 | ||
it will not work | |||
clean everything, change the prefix, and rebuild | |||
also, where do you want the binary to be? | |||
uvtc | sorear: Ok. Just finished a make that I'd started before we began chatting. | 19:00 | |
sorear | whee. ./viv -5 --thaw STD.store in 4.5sec | ||
19:00
M_o_C left
|
|||
uvtc | sorear: Where is the customary place for the binary? I suppose `/usr/local/parrot/bin`? | 19:01 | |
afk | |||
sorear | uvtc: just /usr/local/bin | ||
colomon | moritz_: prepping for spectest | ||
TimToady | sorear: I think I finally have a fix for your <foo()> dropping the longname | 19:03 | |
uvtc | sorear: {back} thanks. | ||
sorear: Sorry, but I'm still confused. Doesn't the perl6 binary need some accompanying parrot directory to run? | 19:04 | ||
moritz_ | uvtc: it needs an installed parrot + tools | 19:05 | |
uvtc | sorear: if I download rakudo and build in my ~/temp directory, I'd like to be able to delete that temporary build stuff after installing what's necessary somewhere into /usr/local. | ||
moritz_ | so you configure it iwth --gen-parrot-prefix=/usr/local | 19:06 | |
but we had that already, no? | |||
uvtc | moritz: right. So, it seems easiest to have the perl6 binary and the parrot + tools all living together, in per-fect har-mon-ey. :) | ||
moritz_ | correct. | ||
sorear | uvtc: you should install the parrot stuff in /usr/local/bin/parrot, /usr/local/lib/parrot/2.4.0/runtime, etc | ||
this can be accomplished by a default install of standalone parrot or a --gen-parrot --gen-parrot-prefix=/usr/local build of rakduo | 19:07 | ||
TimToady: Excelllent. | |||
uvtc | sorear: I'd rather not let parrot install itself throughout my /usr/local. Seems tidier to have it in its own /usr/local/parrot directory. | 19:08 | |
19:08
awwaiid joined
|
|||
moritz_ | then use /usr/local/parrot as prefix | 19:08 | |
and rakudo will be in /usr/local/parrot/bin/perl6 | 19:09 | ||
uvtc | moritz: beautiful. Will try that, but gotta run at the moment. Thanks very much! | ||
19:12
dju_ joined,
uvtc left
19:18
Guest72640 left,
Guest72640 joined
|
|||
pugssvn | r30820 | sorear++ | [viv] Store generated class information in compiled files | 19:21 | |
19:21
ShaneC joined
|
|||
TimToady | sorear: did you fix the :sigspace problem in viv? if not, I think my <foo()> fix might've done so...at least it shows up now | 19:21 | |
19:21
synth joined
|
|||
sorear | yes, I fixed :sigspace | 19:22 | |
$*RX<s>, remember? | |||
TimToady | 'kay | ||
right | |||
19:22
ShaneC left
|
|||
TimToady | (just testing my patch) | 19:22 | |
19:23
rhr left
|
|||
sorear is running viv on live STD.pm6 now :) | 19:29 | ||
pugssvn | r30821 | colomon++ | [spec] Add Real.Int, Real.Rat, Real.Num, and Real.Complex to the spec. | 19:30 | |
r30822 | sorear++ | [viv] Implement token foo:bar syntax | 19:31 | ||
TimToady | sorear++ | 19:32 | |
sorear | now I've gotten far enough down STD.pm6 to hit what appears to be the <foo()> crash | ||
dalek | kudo: 475d1c7 | (Solomon Foster)++ | src/core/Cool-str.pm: Change .match to support the new list approach for :nth. |
19:33 | |
sorear | hmm, I don't have anything for protoregex traits | ||
TimToady | about to check in fix, but it breaks $<foo> = <bar> for some reason | 19:37 | |
19:40
rhr joined
19:41
nadim joined
|
|||
TimToady | well $<foo> = (@x), more specifically | 19:42 | |
19:44
plainhao left
|
|||
pugssvn | r30823 | colomon++ | [t/spec] Unfudge tests that now work. | 19:46 | |
moritz_ | colomon++ | 19:48 | |
19:49
Ross^ joined,
Ross left
|
|||
sjohnson | rakudo: my $x = | 19:53 | |
p6eval | rakudo bafb6d: OUTPUT«Confused at line 11, near "my $x ="current instr.: 'perl6;HLL;Grammar;panic' pc 528 (ext/nqp-rx/src/stage0/HLL-s0.pir:348)» | ||
sjohnson | oops... enter key fail | ||
... anyone else ever hit the enter key often, when trying to hit the single quote? | |||
moritz_ | I hit enter when I want to hit backspace | ||
jnthn | My keyboard has a #~ key in the way. :-) | 19:54 | |
19:54
justatheory left
|
|||
jnthn | (between ' and enter) | 19:54 | |
moritz_ | not a good habit when you're typing rm $somthing on the command line, and want to change the wrong last character | ||
pugssvn | r30824 | lwall++ | [STD] don't lose existing bindings when we go to a sublanguage | 19:58 | |
r30824 | [STD] refactor $*GOAL to only be informative, never used as <stopper> | |||
r30824 | instead, we create a <stopper> rule for $*GOAL if necessary | |||
r30824 | [gimme5,Cursor] various tweaks in support of the above | |||
19:59
Ross^ left
|
|||
sorear | TimToady++ | 19:59 | |
TimToady | phone | ||
20:00
Ross^ joined
|
|||
colomon | rakudo: say 1 | 20:02 | |
p6eval | rakudo bafb6d: OUTPUT«1» | ||
moritz_ | recompilation in 13min | ||
20:17
justatheory joined
|
|||
colomon | rakudo: say 1 | 20:17 | |
p6eval | rakudo bafb6d: OUTPUT«1» | ||
colomon | recompile starts in 13min, I'm guessing that should have said? | ||
colomon has no idea why he wants to play with p6eval when he has an up-to-date REPL at home. | 20:18 | ||
rakudo: say 1 | 20:26 | ||
p6eval | rakudo bafb6d: OUTPUT«1» | ||
pmichaud | hugme: add chromatic to nqpbook | 20:29 | |
hugme hugs chromatic. Welcome to nqpbook! | |||
20:31
TSa left
20:32
rhr left
20:39
clintongormley left
20:47
pmurias joined
20:52
kel__ left
21:01
patspam1 joined,
patspam left
21:02
patspam1 is now known as patspam
|
|||
cognominal searched a long time why parse actions where not triggered. I did parse(...., :actions<ActionClass>) instead of ... :actions(ActionClass) | 21:05 | ||
21:06
Guest74734 left
|
|||
cognominal | I hate sllent fails... | 21:06 | |
m6locks | fale | 21:07 | |
21:08
rhr joined
21:09
SmokeMachine left
|
|||
pmichaud | cognominal: I think we can remove the silent fail. | 21:16 | |
oh, actually, in this case it might be tricky. Hrm. | |||
I'll think about it. | |||
cognominal | I don't whine much because I suppose someday, once bootstrapped, you (or someone) will rewrite that in Perl 6 and make that more solid. | 21:17 | |
You have so much on your plate... | |||
jnthn | The thing is that methods in general take a *%_ | 21:20 | |
Which swallows up the typo'd names. | |||
21:20
whiteknight joined
|
|||
cognominal | my error was more a braino than a typo, passing a string instead as a class as a pair value | 21:21 | |
s/as/of/ | 21:22 | ||
jnthn | Ah | 21:23 | |
That's harder to catch, yes | |||
Well, maybe a :U on actions so you gotta pass some type object. | |||
Oh, no, 'cus you may pass an instance... | 21:24 | ||
Hm | |||
Yeah, hard to catch. :) | |||
cognominal | what a :U? | ||
why not testing if a string and if so searching the corresponding class and passing that instead, Is that so difficult? | 21:25 | ||
anyway I am happy I caught my mistake | 21:26 | ||
21:26
ruoso_ left
21:27
Su-Shee left
21:28
Guest72640 left
21:31
pmurias left
21:43
tedv joined
|
|||
jnthn | pmichaud: ping | 21:44 | |
pmichaud | jnthn: pong | ||
pugssvn | r30825 | tedv++ | Fixed incorrect test descriptions. | ||
jnthn | pmichaud: I'm working on auto-currying. | ||
pmichaud: What you rather we construct the PAST for a closure, or instead just call some PIR thingy that manufatures them? | |||
pmichaud | you mean at runtime? | 21:45 | |
jnthn | For the PIR case, yes. | ||
Well | |||
We could write it in Perl 6 actually :-) | |||
pmichaud | heh | ||
jnthn | I can go either wa | ||
*way | |||
colomon | in p6 would be pretty straightforward, wouldn't it? | 21:46 | |
pmichaud | you don't have a preference or bias? | ||
jnthn | It occurs to me that we can also for * op * just return the op itself, but maybe that'd be cheating. | ||
pmichaud: Well, given it can be done in Perl 6, that eliminates my preference not to write more stuff in PIR. :-) | |||
pmichaud | do you need an answer soon, like, tonight? | ||
jnthn | pmichaud: I can go either way. The Perl 6 way is a little more runtime cost, but a little less PAST. | ||
colomon | still have to handle the * op (* op2 1) case, right? | ||
(etc) | |||
jnthn | colomon: oh, yes | ||
colomon: That...shouldn't be a problem with either approach. | 21:47 | ||
pmichaud: Am just hacking on it now and was about to JFDI one way or the other, and wondered if you had a big preference, that's all. | |||
pmichaud | jnthn: my gut reaction is that the PIR case might be _really_ nice. | ||
as in, cleaner overall for dealing with closures in general. | 21:48 | ||
jnthn | pmichaud: It'd be short but...well...then we end up with annoying problems that make it less nice. | ||
colomon | jnthn: I can sort of see how to do it, but was wondering about * op * just being op and how it would interact with that. | ||
pmichaud | jnthn: thus my question about how soon do you need it -- I think I need an evening (but just one) to let it stew in my head a bit | ||
jnthn | Like, we want to return a Perl 6 Block, not a Parrot Sub. And we want it to have a proper signature... | ||
pmichaud: It's, like, what I've dug into doing tonight. :-) | |||
colomon | pmichaud: will that depend on fixing closures? | ||
pmichaud | colomon: I think it might simplify fixing closures | 21:49 | |
colomon | oooooo | ||
pmichaud | jnthn: I'm thinking it might simplify the Perl 6 Block issue a bunch | ||
jnthn ...hadn't seen those as related. | |||
pmichaud | oh, I think I might've misunderstood what you said earlier, then. | 21:50 | |
jnthn | pmichaud: I'm just working on the | ||
* + * => { $^a + $^b } | |||
thingy | |||
pmichaud | jnthn: right | ||
I'm wondering if it could be generalized slightly to clean up Perl 6 block construction in general throughout the actions | 21:51 | ||
right now it's a bit... messy | |||
jnthn | Ah, OK | ||
Now I see what you're getting at a bit more. | |||
sorear | pmichaud: How is the REPL stuff faring? | 21:53 | |
pmichaud: Is any of my research helping? | |||
pmichaud | sorear: yes, it helped quite a bit. | ||
I _really_ appreciated your conversion of HLLCompiler stuff into nqp. Much nicer to work with. | |||
I have REPL in NQP implemented now. Adding it to other HLLs will be really easy. | |||
Adding it to Rakudo is a bit tricky because the YOU_ARE_HERE stuff needs a bit of a refactor (and because of the way Perl 6 in general deals with lexical setting) | 21:54 | ||
sorear | Yes. You're running into a problem which I did. | 21:56 | |
My solution was to change YOU_ARE_HERE so that it only called set_outer if the old outer was null | |||
pmichaud | that's the solution we cam up with today | ||
*came | |||
so looks like you were ahead of us a bit | |||
but YOU_ARE_HERE still needs some other cleanups | 21:57 | ||
sorear | your handling of the REPL as outers is a bit different from mine though | ||
pmichaud | actually, outer singular now | ||
sorear | this custom lexpad stuff is pretty crazy ;) | ||
pmichaud | there's one outer | ||
and its lexpad continues to be replaced with an updated lexpad | |||
currently I have it as a package-scoped object, I'm likely to let it be created local to any given interactive loop | 21:58 | ||
sorear | where I went with this was, since eval always sets the outer, it's no longer needed to keep two separate code paths in src/builtins/eval.pm | ||
then $*IN_EVAL can die, !UNIT_START can be simplified a tiny bit | |||
pmichaud | correct | 21:59 | |
again, you're doing the same as what I plan | |||
sorear | also, you're about to break spectests | ||
pmichaud | oh? | ||
sorear | the spectests assume that eval "return" will drop a non-null value into $! | 22:00 | |
in current Rakudo, this works entirely by accident | |||
return throws a control exception, which gets caught by the compile-exception-catcher in eval | |||
once eval is made symmetric, that won't work | |||
pmichaud | oh, that's probably not too big an issue | 22:01 | |
I think I can work around it, at any rate. | |||
sorear | so you'll need to port a patch from topic/lexical-persistence-2 which adds a CONTROL { die "unexpected control exception" } | ||
jnthn | Hmm. | ||
* + foo(42) | |||
Means { $_ + foo(42) } | |||
Or | |||
$temp = foo(42); { $_ + $temp } | 22:02 | ||
pmichaud | I'd be okay if &eval isn't exactly the same as HLL::Compiler.eval | ||
jnthn: my expectation would be the latter. | 22:03 | ||
jnthn | Ah, S02 suggests the first. | ||
pmichaud | doh! | ||
jnthn | Well | ||
It's making a subtler and trickier point though | 22:04 | ||
Eevee | latter seems potentially surprising: foo(*) + foo(42) | ||
jnthn | oh hmm | ||
Eevee: That won't get curried, fwiw | |||
Eevee | where, e.g., foo == print | ||
oh well then nevermind | |||
jnthn | Needs to be a literal * directly on one side of the operator. | ||
pmichaud: The bit of the synopsis is: | |||
This rewrite happens after variables are looked up in their lexical scope, | |||
and after declarator install any variables into the lexical scope, | |||
with the result that | |||
* + (state $s = 0) | |||
is effectively curried into: | |||
-> $x { $x + (state $OUTER::s = 0) } | |||
Eevee | how much does * gobble? only infix operators? | 22:05 | |
jnthn | Eww. :-/ | ||
lue | Ohai! | ||
jnthn | Oh, wait, it's maybe not nasty | ||
Because we have already shoved the decl in the right place. | |||
It seems to imply that the assignment happens inside the closure though. | |||
Eevee: Postfixes and prefixes too, it appears. | 22:06 | ||
For any unary or binary operator (specifically, any prefix, postfix, | |||
and infix operator), if the operator has not specifically requested | |||
to handle C<*> itself, the compiler is required to translate directly | |||
to an appropriately curried closure at compile time. | |||
Compiler translates...directly. | |||
jnthn sees the evidence starting to stack up one way :-) | |||
Eevee | hm. not list? | 22:07 | |
pmichaud | jnthn: yeah, but I just see weird issues with something like | ||
my $x = * + foo($y); | |||
$y = 7 | |||
say $x(3) | |||
jnthn | 10? :-) | ||
pmichaud | because at the time we evaluate the closure, $y is changed | ||
jnthn | pmichaud: Aye - I'm not sure if I see that as weird or not. :-) | 22:08 | |
pmichaud | I suppose if we think of * as always meaning "construct a closure", then it makes okay sense | ||
jnthn | pmichaud: Yeah, that's how I'd been seeing it. | 22:09 | |
22:09
IllvilJa left
|
|||
pmichaud | and I'm guessing that *-currying is now always syntactic? | 22:09 | |
since it's a compile-time feature? | |||
jnthn | pmichaud: That's very much how the synopsis reads to me. | ||
arnsholt | It sounds like a potential feature, but one that'll take a bit of getting used to | ||
pmichaud | yeah, me too. | ||
jnthn | OK, I'll go that way. | ||
sorear | It's actually a quite critical feature. | ||
pmichaud | how does something like * + foo(*) work? | 22:10 | |
jnthn | Nastily, I suspect. | ||
pmichaud | or even * + (3 - *) ? | ||
sorear | It's what makes @foo[*-1] work | ||
jnthn | That second one works OK | ||
sorear | pmichaud: like { $^a + foo($^b) } | ||
pmichaud: I asked earlier | |||
arnsholt | The first example would be the same as *+foo(3), no? | ||
colomon | I would assume foo(*) is called, or at least that call is compiled in. | ||
jnthn | Ah, or is it.. | ||
colomon: Yeah | |||
sorear | er, actually it wouild be { $_ + foo(*) } | ||
Eevee | wouldn't the first be { $^a + { foo($^a) } } | ||
colomon | sorear: right | ||
Eevee | and thus sort of useless | ||
jnthn | Eevee: No | 22:11 | |
It'd end up as { $^a + foo(*) } | |||
sorear | Eevee: no. WhateverCode closures curry like Whatever itself | ||
22:11
sundar left
|
|||
jnthn | sorear: WhateverCode is what we can rid of by doing it syntactic, btw. :-) | 22:11 | |
pmichaud | but foo(*) isn't a WhateverCode | ||
jnthn | pmichaud: Correct. | ||
It's just a call that passes *. | |||
pmichaud | so what happens with | 22:12 | |
* + foo(*.xyz) | |||
Eevee | it might be time to read S02 | ||
this is getting increasingly contrived | |||
sorear | It's never not time to read S.. | ||
jnthn | { $^a + foo({ $^a.xyz }) } | ||
pmichaud: The two auto-curryings are independent there. | |||
afaiu. | 22:13 | ||
pmichaud | jnthn: right | ||
and foo() probably won't know how to handle a WhateverCode argument? | |||
or.... | |||
jnthn | pmichaud: There is no WhateverCode | ||
pmichaud | sorry, closure | ||
jnthn | pmichaud: It's just a Block now? | ||
jnthn had been thinking the switch to syntactic was so we could do away with all the various types and multi candidates. | |||
cognominal | the game is to read a S* in one sitting without missing anything. I have lost eacht time so far | 22:14 | |
jnthn | And then map will Just Work 'cus it knows what to do with a Callable | ||
pmichaud | jnthn: well, I think that is the thinking, but in my experience it's a waterbed model | ||
i.e., we think we're doing away with it but we've really just pushed the problems somewhere else :-) | |||
kind of like lists and arrays, or the original interpretations of Whatever :) | |||
jnthn | pmichaud: It feels to me like we're trying to take a little bit of sugar that's handy for simple things and trying to make it handle every case we could ever come up with. | ||
pmichaud | jnthn: well, that was the original problem with Whatever, also. :) | 22:15 | |
Eevee | well, the language is perl 6... :P | ||
jnthn | I'd kinda rather it didn't, and people can write out exactly what they want if the simple thing isn't it. | ||
pmichaud | okay, so we only curry on unary and binary operators | 22:16 | |
jnthn | Otherwise we get * + 3 * * - 42 | ||
And it's like...huh wtf. | |||
pmichaud | I can live with that. | ||
jnthn | I can live with people being disuaded to write things like that. :-) | 22:17 | |
pmichaud | I meant I can live with the currying happening at compile time for the binary operators | ||
jnthn | pmichaud: Ah, OK. :-) | ||
pmichaud | (and unaries) | ||
jnthn | OK. | ||
pmichaud | I'm guessing that would have to patch into the expression actions somewhere? | ||
i.e., we need nodes that can say "I'm a currying argument?" | 22:18 | ||
jnthn | pmichaud: I was thinking just a check if $key is INFIX, POSTFIX or PREFIX and if so call whatever_curry or something that goes checking for the whatevers, and also that it's not one of the operators we shouldn't auto-curry. | ||
pmichaud: I just added :returns('Whatever') to the PAST node that * generates. | 22:19 | ||
pmichaud | jnthn: sounds like a very reasonable starting point | ||
jnthn | Then it's a very easy check | ||
pmichaud | go with that :) | ||
jnthn | No $pastnode<whatever> flags. ;-) | ||
pmichaud: OK, I'll fetch a beer and dig in. :-) | |||
Eevee | (*, *, $x) = (1, 2, 3); <= appears in S02. wouldn't this require * to eat listops too | ||
jnthn | Eevee: No, that works for Other Reasons. :-) | 22:20 | |
Eevee | oh dear. Other Reasons are frightening | ||
jnthn | Eevee: It's just a list assignment. | ||
pmichaud | but it does have infix:<,> in it :-) | ||
jnthn | And it so happens that if you assign to * it throws away the value. | ||
Eevee | in that case I guess that's a good argument for not eating listops | ||
jnthn | pmichaud: oh ouch... | ||
Eevee | oh I thought , was list | ||
jnthn | pmichaud: I think I need a check for binary. ;-) | ||
*binaryness | 22:21 | ||
binarity? | |||
Meh, I should learn English some day. | |||
pmichaud | just check that it's not :assoc<list>, probably. | ||
jnthn | pmichaud: That works too. | ||
rakudo: * = 'lol thrown away'; | |||
p6eval | rakudo 475d1c: OUTPUT«Cannot assign to readonly valuecurrent instr.: '&die' pc 18373 (src/builtins/Junction.pir:373)» | ||
jnthn | ...oh. | ||
pmichaud | either that or make sure that infix:<,> doesn't curry. | 22:22 | |
which, it probably doesn't since it takes Object as arguments. | |||
jnthn | rakudo: my $x; (*, *, $x) = (1, 2, 3); | ||
p6eval | rakudo 475d1c: ( no output ) | ||
jnthn | pmichaud: Aye. | ||
pmichaud | sorry, Mu | ||
jnthn | :-) | ||
pmichaud | so, does an operator have to explicitly declare a Whatever formin order to be not curried? or is declaring a Mu parameter sufficient? | 22:23 | |
i.e., if I have sub infix:<abc>(Mu $a, Mu $b) { ... } | |||
does "* abc 3" auto-curry? | |||
Eevee | rakudo: (*) = (1); | 22:24 | |
p6eval | rakudo 475d1c: OUTPUT«Cannot assign to readonly valuecurrent instr.: '&die' pc 18373 (src/builtins/Junction.pir:373)» | ||
jnthn | pmichaud: Well, TimToady mentioned as a first cut we just black-list some we know. | 22:25 | |
pmichaud | or would it have to be sub infix<abc>(Mu $a, Mu $b) is like-Whatever-and-stuff { ... } ? | ||
jnthn | pmichaud: afaik you'd need a signature that somewhere mentioned Whatever | ||
pmichaud | (note that "like-Whatever-and-stuff" is what is written in S02) | ||
jnthn | omg | ||
22:25
Khisanth joined
|
|||
pmichaud | oh, we'd have to proto it. | 22:25 | |
jnthn | n operator can declare that it wants to | 22:26 | |
handle C<*> either by declaring one or more of its arguments for at | |||
least one of its candidates with an argument of type C<Whatever>, or | |||
by marking the proto sub with the trait, C<is like-Whatever-and-stuff>. | |||
pmichaud | Right. | ||
that's the section. :) | |||
jnthn | :-) | ||
Yeah | |||
Things get easy on that on the (*sigh*) post-R* multi refactor. :-) | |||
Or at least, I'll do the multi compile time introspection enhancements at the same time I work on getting the new meaning of proto in place. | 22:27 | ||
pmichaud | anyway, I'll let you work on it | ||
jnthn | :-) | ||
I has selected a beer and am ready to hack. :-) | |||
Eevee | wow, parrot's in ubuntu's universe repo | 22:28 | |
lue | So nice of them to invite us :) | 22:30 | |
22:30
gbacon left
|
|||
Eevee | maybe star will get rakudo in there :( | 22:34 | |
diakopter | Ubuntu Silver Star ? | 22:35 | |
pmichaud | probably. rakudo isn't quite yet stable enough | ||
22:35
elmex_ joined
|
|||
diakopter | Ubuntu Spry Star ? | 22:35 | |
lue | Which one is that? | ||
diakopter | the S one? | ||
22:35
elmex left
|
|||
Eevee | haha, no, rakudo star | 22:35 | |
22:35
elmex_ is now known as elmex
|
|||
Eevee | rakudo★ | 22:36 | |
lue | ahh, no I see what you're saying. | ||
s/no/know | |||
s/know/now/ | |||
gah! | |||
diakopter | .u hexa | 22:37 | |
phenny | U+4DCA HEXAGRAM FOR PEACE (䷊) | ||
diakopter | .u spl | ||
phenny | U+4DD6 HEXAGRAM FOR SPLITTING APART (䷖) | ||
diakopter | my font doesn't have those | ||
Eevee | mine does but they overflow slightly | 22:38 | |
lue | Mine fit just fine within the parens | ||
arnsholt | On my OS X they overflow a bit on the right | ||
lue | .u | 22:39 | |
phenny | U+F8FF (No name found) | ||
lue | Why does my keyboard let me type that? What is it? | ||
Eevee | an apple | ||
it's actually the last glyph in the private use block | |||
which apple deemed should be a tiny apple logo | |||
lue | Well that figures, it's the Apple fourth level I got that from :) | ||
.u E000 | 22:40 | ||
phenny | U+E000 (No name found) | ||
lue | rakudo: say "\xE000" | ||
p6eval | rakudo 475d1c: OUTPUT«» | ||
Eevee | and that's the beginning | ||
yeah I don't have a glyph | |||
lue | Anyone that has Linux Libertine can see uE000 :) | ||
Eevee | hm, I seem to have a bunch of misc junk all throughout private use | ||
U+E033 BUTTERFLY | 22:41 | ||
lue | That's what it's for :) [0xE000 in Linux Libertine is Tux, the penguin] | ||
Eevee | ha | ||
lue | .u butter | ||
phenny | lue: Sorry, no results for 'butter'. | ||
lue | rakudo: say "\xE033" | 22:42 | |
p6eval | rakudo 475d1c: OUTPUT«» | ||
Eevee | at this size it looks like an airplane with the nose missing | ||
lue | I get an ffj glyph, just like fi (fi) and fl (fl) | ||
[for E033] | |||
rakudo: say "\x[$_]" for 0xE000..0xE010 | 22:43 | ||
p6eval | rakudo 475d1c: OUTPUT«Unrecognized backslash sequence: '\x' at line 11, near "[$_]\" for "current instr.: 'perl6;HLL;Grammar;panic' pc 528 (ext/nqp-rx/src/stage0/HLL-s0.pir:348)» | ||
lue | darn :) | 22:44 | |
Eevee | ha I don't think escapes work like that | ||
rakudo: say chr($_) for 0xe000..0xe010 | 22:45 | ||
p6eval | rakudo 475d1c: OUTPUT«» | ||
jnthn | rakudo: say "$_: &chr($_)" for 0xe000..0xe010; | 22:46 | |
p6eval | rakudo 475d1c: OUTPUT«57344: 57345: 57346: 57347: 57348: 57349: 57350: 57351: 57352: 57353: 57354: 57355: 57356: 57357: 57358: 57359: 57360: » | ||
lue | Apparently, Linux Libertine and Orbitron have provided some nice characters in the Private Use Area | ||
rakudo: say "{$_.fmt('%x')}: &chr($_)" for 0xe000..0xe010; | |||
p6eval | rakudo 475d1c: OUTPUT«e000: e001: e002: e003: e004: e005: e006: e007: e008: e009: e00a: e00b: e00c: e00d: e00e: e00f: e010: » | ||
Eevee | I just have a bunch of diamonds, an arrow, a checkmark, and circled digits at the end | ||
lue | E009 and E00A are cool W's from Orbitron | 22:47 | |
sorry, E008 and E009 | |||
rakudo: say "«{$_.fmt('%x')}: &chr($_)»" for 0xe000..0xe010; | 22:48 | ||
p6eval | rakudo 475d1c: OUTPUT««e000: »«e001: »«e002: »«e003: »«e004: »«e005: »«e006: »«e007: »«e008: »«e009: »«e00a: »«e00b: »«e00c: »«e00d: »«e00e: »«e00f: »«e010: »» | ||
lue | Is Pretty Print [colors, font weight, etc.] possible thru perl6? At least to the STDOUT in a console. | 22:50 | |
Eevee | rakudo: say [~] map 0xe000..0xe010: { "« {$_.fmt('%x')}: &chr($_) »" }; | 22:51 | |
p6eval | rakudo 475d1c: OUTPUT«Confused at line 11, near "say [~] ma"current instr.: 'perl6;HLL;Grammar;panic' pc 528 (ext/nqp-rx/src/stage0/HLL-s0.pir:348)» | ||
Eevee | rakudo hurt itself in its confusion! | ||
rakudo: say [~] 0xe000..0xe010.map: { "« {$_.fmt('%x')}: &chr($_) »" }; | 22:52 | ||
p6eval | rakudo 475d1c: OUTPUT«» | ||
23:00
Psyche^ joined
|
|||
cognominal | rakudo: say (class A {} ).defined | 23:00 | |
p6eval | rakudo 475d1c: OUTPUT«1» | ||
cognominal | rakudo: class A {} say ::A.defined | 23:01 | |
p6eval | rakudo 475d1c: OUTPUT«Confused at line 11, near "class A {}"current instr.: 'perl6;HLL;Grammar;panic' pc 528 (ext/nqp-rx/src/stage0/HLL-s0.pir:348)» | ||
cognominal | rakudo: class A {}; say ::A.defined | ||
p6eval | rakudo 475d1c: OUTPUT«0» | ||
cognominal | beats me. | ||
jnthn | rakudo: class A {} say A.defined | 23:02 | |
lue | rakudo: class ::A{}; say ::A.defined | ||
p6eval | rakudo 475d1c: OUTPUT«Confused at line 11, near "class A {}"current instr.: 'perl6;HLL;Grammar;panic' pc 528 (ext/nqp-rx/src/stage0/HLL-s0.pir:348)» | ||
rakudo 475d1c: OUTPUT«0» | |||
jnthn | std: class A {} say ::A.defined | ||
p6eval | std 30825: OUTPUT«===SORRY!===Strange text after block (missing comma, semicolon, comment marker?) at /tmp/2opAbO3d0N line 1:------> class A {}⏏ say ::A.defined expecting any of: bracketed infix infix or meta-infix statement modifier loopParse | ||
..failed… | |||
jnthn | Oddness. | 23:03 | |
23:03
Patterner left,
Psyche^ is now known as Patterner
|
|||
jnthn | std: class A {} say A.defined | 23:03 | |
p6eval | std 30825: OUTPUT«===SORRY!===Strange text after block (missing comma, semicolon, comment marker?) at /tmp/NpoVdMhlmE line 1:------> class A {}⏏ say A.defined expecting any of: bracketed infix infix or meta-infix statement modifier loopParse | ||
..failedFA… | |||
jnthn | std: class A {}; say A.defined | ||
p6eval | std 30825: OUTPUT«ok 00:01 111m» | ||
jnthn | std: class A {}; say ::A.defined | ||
p6eval | std 30825: OUTPUT«ok 00:01 111m» | ||
jnthn | rakudo: class A {}; say ::A.defined | ||
p6eval | rakudo 475d1c: OUTPUT«0» | ||
jnthn | ETOOLIBERAL | ||
yay | 23:04 | ||
> say (1 + *).WHAT | |||
Block() | |||
> say (1 + *).(2) | |||
3 | |||
> say (* + *).(2, 4) | |||
6 | |||
> say (1..*).WHAT | |||
Range() | |||
pmichaud | wow | 23:06 | |
afk, dinner | 23:07 | ||
lue | rakudo: my $a = 3; say 1+$a; say (1+*).($a) | ||
p6eval | rakudo 475d1c: OUTPUT«44» | ||
cognominal | rakduo: say (* * *).(*,*) | 23:08 | |
rakudo: say (* * *).(*,*) | |||
p6eval | rakudo 475d1c: OUTPUT«Method 'Num' not found for invocant of class 'Block'current instr.: 'perl6;Mu;' pc -1 ((unknown file):-1)» | ||
lue | rakudo: say (* *).(3,++) | 23:10 | |
p6eval | rakudo 475d1c: OUTPUT«Unable to parse postcircumfix:sym<( )>, couldn't find final ')' at line 11current instr.: 'perl6;Regex;Cursor;FAILGOAL' pc 1971 (ext/nqp-rx/src/stage0/Regex-s0.pir:1050)» | ||
jnthn | rakudo: say (* * *).(2,4) | 23:11 | |
p6eval | rakudo 475d1c: OUTPUT«Method 'Num' not found for invocant of class 'Block'current instr.: 'perl6;Mu;' pc -1 ((unknown file):-1)» | ||
jnthn | That one works now. | ||
> say (* * *).(2,4) | |||
8 | |||
Eevee | rakudo: say (*.*).(3, postfix:sym<!>) | 23:12 | |
p6eval | rakudo 475d1c: OUTPUT«Unable to parse postcircumfix:sym<( )>, couldn't find final ')' at line 11current instr.: 'perl6;Regex;Cursor;FAILGOAL' pc 1971 (ext/nqp-rx/src/stage0/Regex-s0.pir:1050)» | ||
23:12
jhuni left
|
|||
jnthn | The parser won't accept *all* line noise. ;-) | 23:12 | |
cognominal | :) | ||
23:14
jhuni joined
|
|||
lue | rakudo: say (*,*).(3, postfix:sym<!>) | 23:17 | |
p6eval | rakudo 475d1c: OUTPUT«Could not find sub &postfix:sym<!>current instr.: '_block14' pc 29 (EVAL_1:0)» | ||
lue | rakudo: say (*,*).(3, !) | ||
p6eval | rakudo 475d1c: OUTPUT«Unable to parse postcircumfix:sym<( )>, couldn't find final ')' at line 11current instr.: 'perl6;Regex;Cursor;FAILGOAL' pc 1971 (ext/nqp-rx/src/stage0/Regex-s0.pir:1050)» | ||
lue | rakudo: say (*,*).(3, "&!") | ||
p6eval | rakudo 475d1c: OUTPUT«invoke() not implemented in class 'ResizablePMCArray'current instr.: '_block14' pc 29 (EVAL_1:0)» | ||
lue | std: say (*,*).(3, "&!") | 23:18 | |
p6eval | std 30825: OUTPUT«ok 00:01 114m» | ||
jnthn | Works on user defined opps too :-) | ||
> our multi postfix:<!>(0) { 1 }; our multi postfix:<!>($n) { $n * ($n - 1)! } | |||
> my $fact = *!; say $fact.WHAT; say $fact(10); | |||
Block() | |||
3628800 | |||
lue | rakudo: our multi infix:<+>($a is rw,$b){$a++ for ^$b;}; our multi postfix:<++>($a is rw){$a + 1;}; my $a = 3; say $a++; say $a+3 | 23:22 | |
p6eval | rakudo 475d1c: OUTPUT«Method 'set_candidates' not found for invocant of class 'MultiSub'current instr.: '' pc -1 ((unknown file):-1)» | ||
lue | ō.o Last time it was infinite recursion | ||
23:22
Ross^ left
|
|||
jnthn | rakudo: our multi infix:<+>($a is rw,$b){$a++ for ^$b;}; | 23:23 | |
p6eval | rakudo 475d1c: ( no output ) | ||
jnthn | rakudo: our multi postfix:<++>($a is rw){$a + 1;}; | ||
p6eval | rakudo 475d1c: OUTPUT«Method 'set_candidates' not found for invocant of class 'MultiSub'current instr.: '' pc -1 ((unknown file):-1)» | ||
jnthn | Evidentaly postfix:<++> didn't make it into the setting yet. | 23:24 | |
lue | rakudo: our multi infix:<+>($a is rw,$b){$a++ for ^$b;}; our multi sub postfix:<++>($a is rw){$a + 1;}; my $a = 3; say $a++; say $a+3 | ||
p6eval | rakudo 475d1c: OUTPUT«Method 'set_candidates' not found for invocant of class 'MultiSub'current instr.: '' pc -1 ((unknown file):-1)» | 23:25 | |
23:25
sorear joined
|
|||
lue | It worked last time... | 23:25 | |
pugssvn | r30826 | sorear++ | [viv] Refactor emit_p5 using an augment/inner paradigm. -2500 characters. | ||
r30826 | ret and $lvl are no more. | |||
lue | rakudo: say "\xE020" | 23:26 | |
p6eval | rakudo 475d1c: OUTPUT«» | ||
lue | Why do we use ICU? What does it give us that we use? [just curious] | 23:28 | |
jnthn | lue: A bunch of unicode stuff. | ||
lue: Like character properties, etc. | |||
lue | I thought we really only used it for character tables. | 23:29 | |
I was thinking of whether it would be feasible to "remove" that dependancy [I've heard about doing that before, IIRC] | 23:30 | ||
pugssvn | r30827 | sorear++ | [viv] Finish translation of <foo(bar)> | ||
sorear | lue: Why? | ||
Repeat after me. | |||
Dependencies are Good. | |||
lue | Not like I was going to do it, I was just wondering. | 23:31 | |
23:31
demond joined
|
|||
diakopter | sorear: r30826 !!?!??! :D | 23:34 | |
just from reading the commit message, I suspect this will make me willing/able to work on it now! | |||
23:47
snarkyboojum joined
|
|||
diakopter | phenny: tell pmurias I looked at paste.lisp.org/display/100307 and it doesn't work just b/c of the non-working expression parser - my $poss = self.positionals; $poss.Add($pos); # works | 23:53 | |
phenny | diakopter: I'll pass that on when pmurias is around. | ||
23:55
patspam left
23:56
justatheory left
|
|||
sorear | std: method foo ($x) ($y) is rw ($z) { } | 23:56 | |
p6eval | std 30826: OUTPUT«ok 00:01 115m» | ||
sorear | TimToady: what does that mean? | 23:57 | |
jnthn | .oO( 2 sigs, 1 sub ) |
23:58 | |
Eevee | whoa | ||
sorear | 3 sigs, mixed in with a trait | ||
jnthn | Stop spoiling my meme references with accuracy. :P | ||
sorear: Somewhere in S12 there's some conjectural syntax relating to being able to give a single multi candidate multiple signatures. | 23:59 | ||
sorear: I suspect it's that. |