»ö« Welcome to Perl 6! | perl6.org/ | evalbot usage: 'perl6: say 3;' or rakudo:, niecza:, std:, or /msg camelia perl6: ... | irclog: irc.perl6.org | UTF-8 is our friend! Set by sorear on 25 June 2013. |
|||
timotimo | in my opinion, there must be recognition of repetition and redundancy across sub/method call boundaries | 00:00 | |
anything that'll fall out of data flow analysis, really | |||
anyway, since i really don't know nearly enough about this, i'll just go to bed and see what the next day will bring :) | |||
00:10
FROGGS left
00:15
Psyche^ left
00:17
Psyche^ joined
00:44
dwarring left
|
|||
japhb__ | r: use Test; class A {}; multi infix:<eqv>(A $a, A $b) { True }; my A $one .= new; my A $two .= new; say $one eqv $two; is_deeply($one, $two); | 01:07 | |
camelia | rakudo c6d5c9: OUTPUT«Truenot ok 1 - # got: A.new()# expected: A.new()» | ||
japhb__ | GAH. | ||
japhb__ shakes his fist at Rakudo | |||
colomon | why is deeply? | 01:08 | |
japhb__ | colomon: That's the test to use when you want eqv comparison. | ||
colomon | but they're not eqv | ||
it's just the got / expected that are wrong. | 01:09 | ||
japhb__ | colomon: look at the code again. ;-) | ||
colomon | oh | ||
:\ | |||
japhb__ | Yeah. | ||
My best guess right now is that the infix:<eqv> cannot participate in the eqv multi used by the already-compiled Test class. | 01:10 | ||
colomon | oh! | ||
that's totally it | |||
that's the way p6 is supposed to work | 01:11 | ||
if you want to shake your fist, you need to shake it at TimToady++ | |||
r: sub check($a, $b) { say $a eqv $b; }; class A {}; multi infix:<eqv>(A $a, A $b) { True }; my A $one .= new; my A $two .= new; say $one eqv $two; check($one, $two) | 01:12 | ||
camelia | rakudo c6d5c9: OUTPUT«TrueTrue» | ||
colomon | unless that's not it at alll... | ||
japhb__ | How in the world do you make use of multi candidates that aren't in the same compilation unit then? | ||
colomon | that's what lift is supposed to be for | 01:13 | |
and I totally agree it kind of sucks | |||
r: sub check($a, $b) { say $a eqv $b; }; class A {}; my A $one .= new; my A $two .= new; say $one eqv $two; check($one, $two) | 01:14 | ||
camelia | rakudo c6d5c9: OUTPUT«FalseFalse» | ||
japhb__ | 'git grep lift' in a rakudo checkout gives nothing of value. | ||
colomon | japhb__: right, because lift is just hypothetical so far | ||
TimToady | and likely to go away anyway | ||
colomon | and may well not end up being named lift | ||
TimToady! \o/ | 01:15 | ||
japhb__ | Ah, language designer in da house. | ||
TimToady | well, it's likelier to be macros that can implicitly carry down operators | ||
but is_deeply should probably be parameterized for comparison | |||
japhb__ | So: how do I fix my code at 18:07 such that Perl 6 will Do What I Want? | ||
colomon | probably don't use is_deeply, I think. | 01:16 | |
TimToady | japhb__: well, one of the two things I just said | ||
diakopter | how many timezones is that from me | ||
japhb__ | is_deeply is just an example of the broader problem. | ||
TimToady | either is_deeply gets a :by parameter | ||
or we have macros that can do &infix:<cmp> = &CALLER:<cmp> | 01:17 | ||
well, maybe can get away without full macros there | 01:18 | ||
rather, &infix:<cmp> = &CALLER::infix:<cmp> | |||
japhb__ | eqv recurses through the proto at each level. Do you mean that you would do :by(&infix<eqv>) and thus get the caller's view of the proto? | ||
colomon | diakopter: I believe he means 9:07 Eastern | ||
japhb__ | diakopter: Are you not in your usual timezone? | 01:19 | |
TimToady | he's at ppw | ||
japhb__ | Ah! | ||
Are you also? | |||
colomon | ppw++ | ||
colomon is in Chicago for Legoland | 01:20 | ||
japhb__ | Very cool. | ||
diakopter | polish perl workshop is great | 01:22 | |
colomon | pghpw.org/ppw2013/talk/5091 | 01:24 | |
are you going to have slides online? | |||
diakopter | heh | ||
considering I changed the topic today... | |||
colomon | oh? | 01:25 | |
diakopter | yeah, to "WTFP6" | 01:26 | |
or "P6WTF"; I haven't decided | 01:27 | ||
colomon | moar bugs that bad today? ;) | 01:28 | |
diakopter | no it's meant to identify with the audience | ||
and the first Sunday talk | 01:30 | ||
colomon | diakopter++ # representing | 01:31 | |
TimToady | we all show our passion in different ways :) | 01:32 | |
diakopter | I'm not sure I'll actually be representing anyrhing | 01:33 | |
japhb__ | r: class A {}; sub foo { say &CALLER::infix:<eqv>(A.new, A.new) }; multi infix:<eqv>(A $a, A $b) { True }; foo() | ||
camelia | rakudo c6d5c9: OUTPUT«No such method 'dynamic' for invocant of type 'Sub+{Precedence}' in method at_key at src/gen/CORE.setting:9171 in sub postcircumfix:<{ }> at src/gen/CORE.setting:2414 in sub postcircumfix:<{ }> at src/gen/CORE.setting:2410 in sub foo at /tmp/wc8…» | ||
japhb__ | Now WTH does that mean? | ||
TimToady | it means "Now WTH does that mean?" | 01:36 | |
japhb__ | TimToady: OK ... so what did I not understand about your suggestion? (Leaving aside the question of temporary assignment of &infix:<eqv>, I can't even *use* it right now) | 01:37 | |
diakopter | colomon: but no, jnthn and FROGGS seemed to make huge progress today on the moarqp bootstrap | 01:38 | |
colomon | \o/ | ||
TimToady | right, it will take either a compiler to allow infix:<eqv> to be accessed as a dynamic lexical, or it will take some kind of semimacro to tell the caller to pass it implicitly somehow, or enable it to show up in the current lexical scope in a dynamically visible fasion | ||
colomon | very exiting. | ||
diakopter | yes, exciting too | 01:39 | |
japhb__ | hmmm | ||
colomon | I'm sorry I've been so out of things lately. And I'm going to keep being too busy to p6, I should be $working right now. | ||
diakopter | colomon: thumbs up 7up | 01:40 | |
:D | |||
japhb__ | colomon: Seems to be the season for $day-job tuit constraint .... | ||
diakopter | ,i | 01:41 | |
colomon | japhb__: for me it's as much life as $day-job, but yes, almost all my normally spare tuits are being funneled into contract $work right now. | 01:42 | |
japhb__ | TimToady: in not treating infix:<eqv> as a dynamic lexical, is this a rakudobug or WAI? | ||
TimToady | r: class A {}; sub foo { say CALLER::['&infix:<eqv>'](A.new, A.new) }; multi infix:<eqv>(A $a, A $b) { True }; | 01:43 | |
camelia | ( no output ) | ||
TimToady | r: class A {}; sub foo { say CALLER::['&infix:<eqv>'](A.new, A.new) }; multi infix:<eqv>(A $a, A $b) { True }; foo() | ||
camelia | rakudo c6d5c9: OUTPUT«Cannot call 'Real'; none of these signatures match::(Mu:U \v: Mu *%_) in method Real at src/gen/CORE.setting:944 in method Real at src/gen/CORE.setting:3422 in method Real at src/gen/CORE.setting:944 in sub infix:<<> at src/gen/CORE.setting:3…» | ||
japhb__ | o.O | 01:44 | |
01:44
cognominal left
|
|||
TimToady | r: class A {}; sub foo { say CALLER::('&infix:<eqv>')(A.new, A.new) }; multi infix:<eqv>(A $a, A $b) { True }; foo() | 01:44 | |
camelia | rakudo c6d5c9: OUTPUT«No such method 'dynamic' for invocant of type 'Sub+{Precedence}' in method at_key at src/gen/CORE.setting:9171 in sub postcircumfix:<{ }> at src/gen/CORE.setting:2414 in sub postcircumfix:<{ }> at src/gen/CORE.setting:2410 in sub INDIRECT_NAME_L…» | ||
TimToady | anyway, we need to be able to do something like that, one way or t'other | 01:45 | |
japhb__ wonders if jnthn++ got partway through implementing it, just based on the odd error message. | 01:46 | ||
TimToady | r: class A {}; sub foo { say CALLER::myeqv(A.new, A.new) }; multi infix:<eqv>(A $a, A $b) { True }; my &myeqv = &infix:<eqv>; foo() | 01:47 | |
camelia | rakudo c6d5c9: OUTPUT«No such method 'Any' for invocant of type 'Parcel' in sub foo at /tmp/bykqP9x6HL:1 in block at /tmp/bykqP9x6HL:1» | ||
japhb__ | TimToady: It feels to me that multis need to by default stay "open", because something like infix:<eqv> can work its way through multis in quite a few compilation units before bottoming out doing comparison of complex data structures. | ||
TimToady | they do stay open, in a lexically scoped sense | 01:48 | |
we're just trying to use CALLER to get at the lexically scoped definition at the point of the caller | 01:49 | ||
once it finds the right proto, it should happen right automatically | 01:50 | ||
japhb__ | I meant they'd need to stay open in a dynamic sense ... but maybe if every single eqv multi that wants to delegate always does CALLER::infix:eqv when it does so, the chain could be kept correct ... | ||
Yeah, I'm seeing a little more clearly what you're going for. | |||
TimToady | whether we can get away with doing the completely dynamically, or need a bit of macroish help, I dunno | 01:51 | |
it would be nice to have the compiler aware enough of it that, should it inline the call, it can just throw away all the linkage | |||
japhb__ | Well, every eqv multi would have to do: local infix:<eqv> = &CALLER::infix:<eqv> before delegating | ||
hmmm | |||
TimToady | that's why I'd like some syntactic relief in the signature, perhaps | 01:52 | |
but we're moving away from the lift idea, insofar as that was going to auto-hoist every operator, but we really want a little better control | 01:53 | ||
japhb__ | signature of ... the eqv multi candidates? | ||
TimToady | either in the proto sig, or in each multi | ||
not all multis want to lift | 01:54 | ||
eventually you find the multi that is the base case, and that wants the raw version of eqv | |||
japhb__ | 'proto infix:<eqv>(|) is lifted {*}' ? | ||
TimToady | not that proto | ||
or not like that | 01:55 | ||
01:55
colomon left
|
|||
TimToady | I think it's more likely that each multi has a way to talk about each operator as lifted or not | 01:55 | |
which is why we were discussing a hook directly into the parser such as ¤ might provide for ASTs | 01:56 | ||
but it's not an AST, it's just an implicit caller's operator | |||
japhb__ | That seems to put a lot of burden on the casual extender (by which I mean, person who just wants to add a multi candidate for their new class) | ||
TimToady | so $a © eqv $b or some such | 01:57 | |
01:57
prevost joined
|
|||
japhb__ | And perhaps I'm thinking too narrowly about eqv, but I don't think that one bottoms out to "raw version of eqv", but rather bottoms out when the comparison begins to use other operators (eqv for Str, Str translating to eq) | 01:57 | |
01:58
colomon joined
|
|||
japhb__ | In other words, you start looking at a different proto. | 01:58 | |
TimToady | eqv is perhaps a bad example | ||
japhb__ | yeah, perhaps | 01:59 | |
I can see the value of a (c) meta-operator, though | |||
01:59
cognominal joined
|
|||
TimToady | $a ©+ $b is perhaps a more likely lifted operator | 01:59 | |
© for CALLER of course | |||
japhb__ | I understood. :-) | 02:00 | |
TimToady | the point of © and ¤ is to provide direct hooks into the parser to let them slip things into the parse in place of a syntactic category | ||
so there's be some kind of generic "caller infix" that this would pull in as a kind of metaoperator | 02:01 | ||
japhb__ | Under that scheme, would much of Any.pm, Cool.pm, Real.pm start needing their operations to use (c) metaops everywhere? | ||
TimToady | much as we might have macros that can replace other things than just nouns, but we need to be explicit about exactly how much of the AST we're replacing | ||
02:02
logie joined
|
|||
TimToady | so the type of the ¤ needs to be either on the parameter or at the point of the "gnostic interpolation" | 02:02 | |
well, at some point we'll need to control genericity, or we're just re-inventing BAL 360 :) | 02:03 | ||
but fershure you can't inline everything--that don't scale to good | |||
*too | 02:04 | ||
you'd like the modules that develop new ops to pay the price, not everyone else | |||
so yeah, we might need people to register their interest in genericity to avoid such problems | 02:05 | ||
02:08
mattp_ left
|
|||
dalek | p/moarboot: fa5dcf2 | coke++ | t/docs/opcodes.t: test for MOAR opcodes, also |
02:09 | |
02:09
mattp_ joined
02:13
FROGGS joined
|
|||
benabik | TEST MOAR THINGS! | 02:15 | |
"¤"? | 02:17 | ||
[Coke] | ? | ||
.u ¤ | 02:18 | ||
yoleaux | U+00A4 CURRENCY SIGN [Sc] (¤) | ||
02:18
FROGGS left
|
|||
benabik | [Coke]: TimToady was talking about ¤ and ASTs, and I've never seen this symbol before. Ack doesn't seem to find it in the specs, either | 02:19 | |
TimToady | 'tis an IRC speculation of long standing | 02:20 | |
benabik | Interesting that there is a generic currency symbol. I had always just used µ for "monetary unit" | ||
Sadly the irclogs seem to use it as part of mojibake for the N/L symbol. | 02:21 | ||
So it's fairly unsearchable. | |||
TimToady | you'd wanna scan for me discussing macro parameters and syntax categories with masak++ | 02:22 | |
or scan for "CURRENCY" :) | 02:24 | ||
benabik | As people go "what is that character"? Good idea. | ||
*blinks* And now the irc logs are 403ing, which makes it even less searchable. I'll assume moritz++ is doing something to them. | 02:25 | ||
TimToady | not likely at this time of night... | ||
japhb__ is thinking about 'class A { has Mu @.mus }; class B { has A @.as }; my @c := [1, "foo", B.new(as => [A.new(mus => ...)])];' where A, B, and @c are defined in separate compunits, and wondering how anything non-pessimizing could possible handle multi operations on @c correctly | 02:26 | ||
TimToady | the logs themselves eem fine to me | ||
benabik | Oh, it's not the newline character. Maybe color codes? It's in all the SORRY lines. | 02:27 | |
And they're back. Probably cosmic rays | |||
TimToady | someone needs to teach that program to understand color codes someday | ||
02:28
prevost left
|
|||
japhb__ | .oO( Rule 3: "Well volunteered!" doesn't work on Larry. ) |
02:28 | |
TimToady | Not when I was told at the beginning of this that they didn't like my programming style... :) | ||
lue | TimToady: what is the generic currency symbol proposed to mean? Or must we search the logs for an answer? | 02:29 | |
TimToady | of course, all the VMs start looking just the same, because portable C forces you to do macros that way | ||
benabik | Searching for "currency sign" in the clogs seems to find it nicely. TimToady++ | 02:30 | |
TimToady | it's intended to signal the parser that it should immediately replace an alternative in the grammar with something of known category | ||
02:30
apejens joined
|
|||
TimToady | so where it looks for a bunch of <infix> it would know that ¤myoperator is an AST parameter declared somewhere as an infix | 02:30 | |
or ¤infix:myparameter or some such | 02:31 | ||
lue imagines the texas version to be >()< based on his current font :) | |||
02:31
wsri joined
|
|||
TimToady | the category could be marked on either the interpolation location or on the parameter decl | 02:31 | |
this is intended to replace and generalize the {{{$myparam}}} monstrosity | |||
benabik wonders if the texas version is "if you're mucking around with macros, you can figure out Unicode" | 02:32 | ||
lue | Ah, so you keep the parser from trying to sift through alternatives by just giving it the answer right away, IIUC. | ||
.oO( "if you're mucking around with macros, you can figure out Unicode"infix:myparameter ) |
|||
benabik | lue++ | ||
TimToady | yes, but masak++ was dubious | ||
when I floated that it should be difficult :) | 02:33 | ||
benabik | masak++ is good at dubious. | ||
TimToady | it needs to be something that highjacks the parser, so it needs to be rather unusual | ||
since there's be an implicit alternative to almost any rule in the grammar | 02:34 | ||
lue | .oO(for unusual, perhaps a quaternary operator, just to show you mean it. <something> ? <something> : <something> | myoperator :P) |
02:35 | |
TimToady | that's not what I call "obvious" | ||
¤ is obvious :) | |||
lue | .oO(And then maybe hide ¤ behind a use MONKEY_SMARTS; if safeguards are desired) |
02:36 | |
TimToady | in the sense of giving the parser an immedate WTF moment | ||
lue | ‽ would nicely sum up the parser's feelings :) ‽infix:right_alternative | 02:37 | |
TimToady | well, we're still struggling feebly to stay in Latin-1, so that there's likely to be a compose key | 02:38 | |
though I guess that one has a compose | |||
⸘Doesn't it‽ | 02:39 | ||
lue | Don't be silly. I only needed to type <Menu Key> ? ! for that! There was no key labelled "compose key" involved :) | ||
TimToady | :P | ||
benabik | .u ⸘ | ||
yoleaux | U+2E18 INVERTED INTERROBANG [Po] (⸘) | ||
benabik | Okay, while I'm not too surprised interrobang is popular enough to make Unicode... Inverted Interrobang? | 02:40 | |
.u ‽ | |||
yoleaux | U+203D INTERROBANG [Po] (‽) | ||
lue | TimToady: I think we're basically fine if we stay inside BMP for Core P6. ☺ | ||
TimToady | 😺 | 02:41 | |
lue | (if only because there's a font out that can act as an ultimate fallback for that range: unifont) | ||
TimToady imagines that it gives you half the glyph for surrogates :) | 02:44 | ||
02:51
logie left
|
|||
lue | Huh. For some utterly strange and weird reason my "print the BMP" one-liner fails on character D800 :) | 02:53 | |
03:00
FROGGS joined
03:06
FROGGS left
03:08
FROGGS joined,
lizmat left
03:13
lizmat joined
03:14
woolfy joined
03:15
prevost joined
03:18
FROGGS left
03:31
lizmat left
03:32
woolfy left
|
|||
japhb__ | My current conundrum -- Sum.pm: 'module Sum; sub zip-sum(Mu @a, Mu @b) is export { @a Z+ @b }' A.pm: 'class A {}; multi infix:<+>(A $a, A $b) is export { 42 }' main: 'use Sum; use A; say zip-sum([A.new], [B.new]);' How do you compile each of these files so they are default-efficient, but main still produces the correct answer? | 03:32 | |
(Aside from B.new should be A.new, of course) | 03:33 | ||
03:34
lizmat joined
03:36
logie joined
03:37
woolfy joined
|
|||
japhb__ | .tell jnthn Thoughts on irclog.perlgeek.de/perl6/2013-10-06#i_7677518 through irclog.perlgeek.de/perl6/2013-10-06#i_7677853 very much appreciated. | 03:44 | |
yoleaux | japhb__: I'll pass your message to jnthn. | ||
japhb__ | .tell jnthn In particular, I *think* much of the problem in this space can be summarized by irclog.perlgeek.de/perl6/2013-10-06#i_7677850 . | 03:46 | |
yoleaux | japhb__: I'll pass your message to jnthn. | ||
japhb__ | TimToady: Do you consider the addition of new multi candidates to be a mutation of the language, or just the addition of new protos? In other words, there a linguistic reason (as opposed to performance) reason why my example from 20 minutes ago shouldn't Just Work? | 03:53 | |
*is there | 03:54 | ||
03:58
preflex_ joined,
ChanServ sets mode: +v preflex_,
preflex left,
preflex_ is now known as preflex
04:03
finanalyst joined
04:18
colomon left
04:25
logie left
|
|||
japhb__ | Furthermore, given -- A.pm: 'use B; class A { has B @.b }' B.pm: 'use C; class B { has C @.c }' C.pm: 'class A {...}; class C { has A @.a }' -- How in the heck would you sanely define working infix:<eqv> multis for each of these? | 04:26 | |
04:28
sisar joined
04:33
logie joined
04:48
fridim_ left
05:16
xenoterracide left,
xenoterracide_ joined,
prevost left
|
|||
moritz | \o | 05:23 | |
05:28
rindolf joined
05:29
xenoterracide_ left
05:37
rindolf left
05:45
logie left
05:46
darutoko joined
05:59
Celelibi joined
06:02
BenGoldberg left
06:10
logie joined
06:20
btyler left,
FROGGS joined
06:58
logie left
07:23
FROGGS left
07:51
dmol joined
08:01
FROGGS joined
|
|||
FROGGS | o/ | 08:07 | |
arnsholt | Does anyone have access to a 32-bit Linux machine? | 08:16 | |
I'm pretty sure NQP #28 is fixed, but can't confirm since it's supposedly a 32-bit thing | |||
FROGGS | arnsholt: I'm booting one atm | 08:17 | |
arnsholt | Oh, awesome. If the NQP test suite runs cleanly on it, you can close #28 | 08:18 | |
FROGGS | k | ||
08:22
kaare__ joined,
kaare__ is now known as kaare_
|
|||
FROGGS | t/nqp/46-charspec.t (Wstat: 256 Tests: 0 Failed: 0) | 08:25 | |
Non-zero exit status: 1 | |||
Parse errors: No plan found in TAP output | |||
ahh, these are due to missing icu | 08:26 | ||
arnsholt | FROGGS++ # Cheers! | 08:29 | |
FROGGS | :o) | 08:30 | |
dalek | rlito: 875d2eb | (Flavio S. Glock)++ | / (3 files): Perlito5 - perl5 - pretty-printer - statement modifier |
||
FROGGS | arnsholt: btw, I'd like to keep #133 open until we actually have a parrot release that fixes it | ||
arnsholt | Yeah, that's probably a good idea | 08:56 | |
bbkr__ | indeed :) lizmat++ colomon++, thanks for instant help | 08:58 | |
arnsholt | And then we can both try to remember to close it when the next Parrot release is out | ||
bbkr__ | sorry | ||
wrong widow :) | |||
window* | |||
09:03
xinming left
09:05
xinming joined
09:09
KroKite joined
09:14
spider-mario joined
|
|||
arnsholt | bbkr__: Could you give the stuff in NQP #32-35 a whirl? Are those warnings still there, or can we close the bugs? | 09:14 | |
09:17
yogan left,
yogan joined
|
|||
bbkr__ | arnsholt: sure, testing it right now... | 09:18 | |
09:18
yogan left
|
|||
arnsholt | Cheers! | 09:19 | |
09:25
sisar left
|
|||
bbkr__ | so far 33, 32, 35 have popped in build messages :( | 09:31 | |
new one spotted: github.com/perl6/nqp/issues/136 | 09:33 | ||
arnsholt | Oh, that one looks legitimate | 09:35 | |
bbkr__ | this compiler is way too oversensitive | 09:36 | |
jnthn | aye | ||
It is, but for once the prec warning has pointed out a problem :) | |||
arnsholt | jnthn: What's your thoughts on NQP #46? Bug or WONTFIX? | 09:37 | |
bbkr__++ | 09:40 | ||
dalek | p: 8f719a5 | (Arne Skjærholt)++ | src/vm/parrot/ops/nqp_dyncall.ops: Fix precedence oops in dyncall ops. Fixes #136. |
||
09:41
KroKite left
|
|||
bbkr__ | I've dumped all warnings to a single file: gist.github.com/bbkr/6851782 | 09:42 | |
If someone wants OS X shell account to fix them please PM me | |||
jnthn | arnsholt: Bug | 09:44 | |
arnsholt | Okies | 09:45 | |
bbkr__ | I've closed #34 | 09:46 | |
arnsholt | I tried to fix the contextual one, but the easy fix I tried didn't work | ||
bbkr__: Many of those are artefacts of the C code being generated code, but the non-void ones sound legitimate as well | 09:47 | ||
dalek | p/moarboot: c847d0e | (Tobias Leich)++ | tools/build/Makefile-Moar.in: whitespace cleanup |
09:48 | |
09:55
yogan joined
09:56
grondilu joined
|
|||
dalek | rlito: 6f61350 | (Flavio S. Glock)++ | / (3 files): Perlito5 - perl5 - pretty-printer - operators |
09:58 | |
arnsholt | bbkr__: Most of the non-void ones are due to clang not handling GCC's "doesn't return" annotations, but I've found a bug as well | 10:01 | |
10:05
[Sno] left
|
|||
dalek | p: b1acc0b | (Arne Skjærholt)++ | src/vm/parrot/pmc/sixmodelobject.pmc: Add a missing return. bbkr__++ for finding this. Fixes #35. |
10:09 | |
FROGGS | ohh, nice one | ||
10:18
hexcoder joined
|
|||
hexcoder | Hi, i have a stupid beginners question. When using latest rakudo in REPL mode (without args), how am i supposed to enter multi line snippets? | 10:25 | |
I tried pasting these 5 lines, but the block spanning 3 lines was not accepted. | 10:27 | ||
my @array = 1, 2, 3, 'foo'; my $sum = @array[0] + @array[1]; if $sum > @array[2] { say "not executed"; } | |||
Hm, here they are join into one line | |||
Hm, here they are joined into one line | 10:28 | ||
FROGGS | that might be due to your irc client | ||
hexcoder | yes | ||
FROGGS | i'm not a REPL user so I dunno if you can have multi-line statements at all | ||
why not paste it as one line in the repl? | |||
r: my @array = 1, 2, 3, 'foo'; my $sum = @array[0] + @array[1]; if $sum > @array[2] { say "not executed"; } | 10:29 | ||
camelia | ( no output ) | ||
jnthn | It doesn't do multi-line statements | ||
hexcoder | I thought for testing many small snippets , this was the way to go... | ||
ok, thanks. | |||
jnthn | Each line has to be valid syntax on its own | ||
FROGGS | r: my @array = 1, 2, 3, 'foo'; my $sum = @array[0] + @array[1]; unless $sum > @array[2] { say "not executed"; } | ||
camelia | rakudo c6d5c9: OUTPUT«not executed» | ||
jnthn | However, variables or functions declared on previous lines are visible to subsequent lines. | ||
FROGGS | hexcoder: you can privmsg camelia and test there too if you want | 10:30 | |
hexcoder | So I would have to write scripts. This is the easiest way? | ||
ok, will try camelia... | |||
FROGGS | scripts have the benefit that you can change previous lines... that is sort of impossible with a REPL | 10:32 | |
arnsholt | jnthn: I think we can close NQP #66, but I'm not quite sure. Care to have a look? | ||
Or maybe not close, but I think I found the issue at hand at least | |||
jnthn | yeah. I bet that's gonna vary by platform too | 10:34 | |
hexcoder | r: my @array = 1, 2, 3, 'foo'; my $sum = @array[0] + @array[1]; if $sum > @array[2] { say "not executed"; } | ||
camelia | ( no output ) | ||
arnsholt | bbkr__: I'd love an OS X shell, BTW! | ||
jnthn | On JVM, WVal lookups resolve once. Moar does them pretty efficiently too | ||
On Parrot I think it's actually a hash lookup... | |||
arnsholt | My old Mac laptop has been retired, which makes it harder to test OS X specific things | 10:35 | |
dalek | rlito: 66f5d76 | (Flavio S. Glock)++ | / (3 files): Perlito5 - perl5 - pretty-printer - operators |
10:43 | |
bbkr__ | arnsholt: did you get login info on private channel? | 10:49 | |
10:57
[Sno] joined
11:07
hummeleB1 joined
11:13
ssutch left
|
|||
lizmat | good *, #perl6! | 11:16 | |
11:19
SamuraiJack__ joined
|
|||
moritz | \o lizmat | 11:25 | |
11:28
finanalyst left
11:30
finanalyst joined
11:34
finanalyst left
11:38
colomon joined
|
|||
hexcoder | a question regarding read-only parameters for subs: sub try-to-reset($bar) { $bar = 2; }. Can this ever have a chance to succeed? If not, why let it compile? | 11:38 | |
jnthn | No, it won't, we just aren't doing the static analysis needed to rule it out at compile time yet. | 11:39 | |
It'll probably be done in the optimization phase, when it's trying to prove other things about assignments. | 11:40 | ||
hexcoder | great, thanks. | ||
jnthn | Which is the same point it rejects sub calls with incorrect argument counts/types when it can. | ||
lizmat | r: sub a ($a) {}; a() | 11:50 | |
camelia | rakudo c6d5c9: OUTPUT«===SORRY!===CHECK FAILED:Calling 'a' will never work with no arguments (lines 1, 1) Expected: :($a)» | ||
12:02
PacoAir joined
12:22
lizmat left,
lizmat joined
|
|||
dalek | rlito: 413dc0d | (Flavio S. Glock)++ | / (3 files): Perlito5 - perl5 - pretty-printer - number, apply |
12:24 | |
12:24
lizmat left
12:28
lizmat joined
|
|||
timotimo | GlitchMr: i find it weird that you singled out heredocs allocating less cursors, when there were a whole bunch of commits removing all in all almost a million cursors (though some of those commits were in nqp) | 12:35 | |
or was that half a million? | 12:37 | ||
dalek | rlito: f861f2b | (Flavio S. Glock)++ | / (2 files): Perlito5 - perl5 - pretty-printer - number, apply (fix) |
12:40 | |
12:46
telex left
12:52
aindilis left
12:56
sisar joined
|
|||
dalek | kudo/nom: 889892a | (Elizabeth Mattijsen)++ | src/core/Baggy.pm: Simplify Bag.grab|pick|roll, they're really just the same |
12:58 | |
nwc10 | good *, #perl6 | ||
timotimo | (* *, *)("good", Whatever.new, "#perl6") | 12:59 | |
13:05
telex joined
13:20
baest_ left
|
|||
masak | good afty, #perl6 | 13:28 | |
FROGGS | o/ | ||
13:29
kathy joined,
kathy is now known as kathyz
|
|||
dalek | kudo/nom: c6b15dc | (Elizabeth Mattijsen)++ | src/core/ (2 files): Implement Bag|Mix.grabpairs, oddly enough exactly the same as Setty.grab |
13:34 | |
grondilu | maybe we need a PairContainer role or something? | 13:36 | |
moritz | Associative? | 13:37 | |
masak | r: say 40 + 2 | ||
camelia | rakudo 889892: OUTPUT«42» | ||
masak | r: class Bird { method tweet { say "chirp!" } }; Bird.new.tweet | 13:38 | |
camelia | rakudo 889892: OUTPUT«chirp!» | ||
jnthn | nqp-m: say('Moar frivolous evals!') | 13:39 | |
camelia | nqp-moarvm: OUTPUT«Moar frivolous evals!» | ||
masak | nqp-moarvm! \o/ | ||
m: say('does this work, then?') | 13:40 | ||
hm, I guess that should be reserved for Rakudo-on-Moar, anyway ;) | |||
jnthn | Maybe we should save that one for Rakudo on Moar :) | ||
masak | I think we should save that one for Rakudo on Moar. | ||
13:41
kathyz left
|
|||
diakopter | let's save that one for Rakudo on Moar | 13:41 | |
TimToady: you think we should save that one for Rakudo on Moar? | |||
tadzik | we should save it for Rakudo/Moar | 13:42 | |
sisar | I've been out of the perl6 loop for some time. Any progress on S09 implementation on any VM? | ||
masak | sisar: some, but not enough :) | ||
sisar: when it does progress, it will on all VMs, I wager. | |||
at least for Rakudo. | 13:43 | ||
moritz | sisar: rakudo-jvm and rakudo-parrot now both support packed native lists, and Buf/Blob are implemented as those | ||
jnthn | Well, Buf/Blob got improved which caused a bunch of the underlying work for native arrays to happen. And the postcircumfix changes happened which was also partly to help with native arrays :) | ||
13:44
baest joined
|
|||
diakopter guesses who kathyz is | 13:44 | ||
grondilu | r: my $b = Buf.new: (^10).roll(5); $b[4] = 0; | ||
camelia | rakudo 889892: OUTPUT«Cannot modify an immutable value in block at /tmp/FwvL8Xd1s0:1» | ||
grondilu | n: my $b = Buf.new: (^10).roll(5); $b[4] = 0; | ||
sisar | masak, jnthn : i see. | ||
camelia | niecza v24-98-g473bd20: OUTPUT«Unhandled exception: Cannot call new; none of these signatures match: Mu, *%_ at /tmp/pQmkQy7rp5 line 1 (mainline @ 4)  at /home/p6eval/niecza/lib/CORE.setting line 4583 (ANON @ 3)  at /home/p6eval/niecza/lib/CORE.setting line 4584 (m…» | ||
jnthn | diakopter: Given it ends in a z, I'd wager it's a Czech name :P | ||
uh, Polish | |||
argh ;) | |||
grondilu | Buf is still not mutable, though | ||
jnthn | grondilu: Yes, that's 'cus it needs the other piece we need for native arrays :) | 13:45 | |
diakopter guesses Chinese | |||
sisar | Is there a major raodblock to S09 implementation or is it just simply lack of tuits ? | ||
(of course, any major hurdle can be broken with enough tuits :p ) | 13:47 | ||
jnthn | I guess partly lack of tuits; various bits of it need work at quite a few different levels of the stack. | 13:48 | |
sisar | jnthn: ok | ||
jnthn | From my perspective, some of S09 falls into "nice to have" rather than "priority" also. | ||
I suspect the native array stuff will happen in the not too distant future given most of the pieces are in place. | 13:50 | ||
The PDL stuff I'd say is rather further out unless somebody jumps up to work on it. | |||
sisar | the R metaop, where is it _really_ useful ? Where does it really simplify an expression ? Can someone give a good example. | 13:52 | |
13:54
stevan_ joined
|
|||
moritz | sisar: usually for non-comunitative operators | 13:54 | |
r: say [R-] 1, 2, 10 | |||
camelia | rakudo 889892: OUTPUT«9» | ||
moritz | uhm | 13:55 | |
r: say [-] 10, 2, 1 | |||
camelia | rakudo 889892: OUTPUT«7» | ||
moritz | masak: wanna submit rakudobug? (at least I think that's one) | ||
masak | moritz: I'm just looking at it. | ||
moritz: are you sure? | |||
does R reverse the associativity? | 13:56 | ||
jnthn | not afaik | ||
masak | r: say (1 R- 2) R- 10 | ||
camelia | rakudo 889892: OUTPUT«9» | ||
sisar | no, S03 says associativity is not reversed | ||
masak | r: say 1 R- (2 R- 10) | ||
camelia | rakudo 889892: OUTPUT«7» | ||
masak | moritz: so, non-bug. | ||
jnthn | STD doesn't reverse it either | 13:57 | |
sisar: Maybe it's useful in whatever-star cases | |||
* / * is fine, but what if the things come in the wrong order? | 13:58 | ||
* R/ * then does it | |||
sisar | jnthn: sorry, i still don't see it :( | 14:00 | |
where would such a thing come up ? | |||
grondilu | r: say 1 R- 2 R- 10 | ||
camelia | rakudo 889892: OUTPUT«9» | ||
grondilu | r: say 10 - 2 - 1 | 14:01 | |
camelia | rakudo 889892: OUTPUT«7» | ||
grondilu | r: say 2 ** 3 ** 4 | 14:02 | |
camelia | rakudo 889892: OUTPUT«2417851639229258349412352» | ||
sisar | I'm looking at rosettacode.org/wiki/Runge-Kutta#Perl_6 , is using R at line 3 really helping/simplifying things ? | ||
14:03
spider-mario left
|
|||
moritz | sisar: it means one doesn't need parens | 14:03 | |
sisar | (I know it is a subjetive thing, but still ) | ||
grondilu | sisar: I wrote this. I often write $n R/ [+] ... because this allows me to avoid using parens | ||
lizmat | cycling& | 14:04 | |
sisar | moritz, grondilu : ok. I'll think about it. Thanks. | ||
sisar wishes state scoped term definitions were implemented, then the Runge-Kutta code can have sigilless δy too | 14:05 | ||
(at line 5 ) | |||
grondilu | can't do that. Sigilless terms can not be rw variable | 14:06 | |
sisar | grondilu: oh | ||
grondilu | you can write 'my \n = 42;' but then n is a constant. | 14:07 | |
though I guess there has to be ways to cheat | 14:08 | ||
r: sub foo is rw { state $ }; foo = 4; | |||
camelia | rakudo 889892: OUTPUT«===SORRY!=== Error while compiling /tmp/SBZE274VQqPreceding context expects a term, but found infix = insteadat /tmp/SBZE274VQq:1------> sub foo is rw { state $ }; foo =⏏ 4;» | ||
grondilu | r: sub foo is rw { state $ }; foo() = 4; | ||
camelia | ( no output ) | ||
grondilu | r: sub foo is rw { state $ }; say foo() = 4; | 14:09 | |
camelia | rakudo 889892: OUTPUT«4» | ||
sisar | grondilu: btw, output is slightly different from what is given. The printf "y(%2.0f) now gives output like y(0.) and y(1.) etc. | ||
grondilu | hum, let me check | ||
ahh, I need to recompile rakudo first | 14:10 | ||
r: printf("%d", pi) | 14:12 | ||
camelia | rakudo 889892: OUTPUT«3» | ||
sisar | r: printf "%2.0f", 2.000 | 14:13 | |
camelia | rakudo 889892: OUTPUT«2.» | ||
grondilu | maybe just replace %2.0f with %d | ||
of %02d | |||
I mean %2d | |||
sisar | grondilu: yup, i'll do that | 14:14 | |
sisar changes rosettacode | |||
14:15
fridim_ joined
|
|||
sisar | done | 14:15 | |
grondilu | sisar++ | 14:17 | |
14:18
stevan_ left
|
|||
grondilu | r: sub foo() is rw { state $ }; say foo() = 4; | 14:20 | |
camelia | rakudo c6b15d: OUTPUT«4» | ||
grondilu | r: sub foo() is rw { state $ }; say foo = 4; | 14:21 | |
camelia | rakudo c6b15d: OUTPUT«===SORRY!=== Error while compiling /tmp/JtiSdrO5M_Preceding context expects a term, but found infix = insteadat /tmp/JtiSdrO5M_:1------> sub foo() is rw { state $ }; say foo =⏏ 4;» | ||
grondilu | r: sub term:foo() is rw { state $ }; say foo = 4; | 14:22 | |
camelia | rakudo c6b15d: OUTPUT«===SORRY!===No such method 'ast' for invocant of type 'NQPMu'» | ||
sisar | grondilu: what does it mean when a sub is rw ? | ||
grondilu | it means that it returns a lvalue | 14:23 | |
diakopter | "Rakudo on JVM is passing 99.28% of the spectests that Rakudo on Parrot does" | ||
grondilu | r: sub term:<foo>() is rw { state $ }; say foo = 4; | ||
camelia | rakudo c6b15d: OUTPUT«4» | ||
diakopter | what's the new number for this | ||
sisar | grondilu: ok, thanks. | ||
tadzik | we should change the remaning test descriptions to "I am the 1%" | ||
diakopter | "down with the 99%" | 14:24 | |
grondilu | r: sub term:<foo>() is rw { state $ }; foo = 4; say ++foo | 14:25 | |
camelia | rakudo c6b15d: OUTPUT«5» | ||
jnthn | diakopter: Don't know because something is wrong with the automated run | ||
diakopter | boo | ||
grondilu | sisar: so sigilless variables are possible, but it's a cheat | ||
diakopter | well is it below or above 100% | ||
14:27
ajr joined
14:28
ajr is now known as Guest42553
|
|||
jnthn | diakopter: Probably a little below; once we start getting tests for the concurrency stuff I suspect it'll get ahead, though... | 14:28 | |
benabik | r: my \foo; foo = 4; say ++foo | 14:29 | |
camelia | rakudo c6b15d: OUTPUT«===SORRY!===No such method 'ast' for invocant of type 'NQPMu'» | ||
benabik | LTA error | ||
14:30
Guest42553 is now known as ajr_,
stevan_ joined
|
|||
felher | r: enum E < a b c>; my E $e = E.enums.keys[0] | 14:32 | |
camelia | rakudo c6b15d: OUTPUT«Type check failed in assignment to '$e'; expected 'E' but got 'Str' in block at /tmp/pbHmOWiv0g:1» | ||
felher | How do I get all E constants from the enum? E.enums.keys returns strings, not Es | ||
jnthn | r: enum E < a b c>; my E $e = E.enums.values[0] | 14:33 | |
camelia | rakudo c6b15d: OUTPUT«Type check failed in assignment to '$e'; expected 'E' but got 'Int' in block at /tmp/w5ZLw4llOT:1» | ||
jnthn | ah, yeah | ||
r: enum E < a b c>; my E $e = E.^enum_value_list[0] | 14:34 | ||
camelia | ( no output ) | ||
jnthn | But surely there's a better way... :) | ||
Oh, E::.values works too I guess | |||
r: enum E < a b c>; my E $e = E::.values[0] | |||
camelia | ( no output ) | ||
felher | jnthn: okay, I'll use E::.values, thanks :) | 14:35 | |
jnthn | yeah, that's a better way that relying on the enum MOP... | ||
I wonder if there shouldn't be a better way though. | |||
felher | jnthn: how does E::.values work anyway? because E ist a package? | 14:37 | |
jnthn | Yes | ||
E:: gets the stash | |||
felher | jnthn: yeah, then I guess there ought to be a more explicit way. :) | 14:38 | |
14:44
BenGoldberg joined
|
|||
dalek | osystem: b2dc645 | (Pawel Pabian)++ | META.list: Added Text::Markov |
14:47 | |
osystem: e1158c6 | tadzik++ | META.list: Merge pull request #27 from bbkr/master Added Text::Markov |
|||
tadzik | bbkr__++ | ||
moritz | huh. 109s for rakudo-jvm to parse the setting | 14:50 | |
that's... SLOW | |||
jnthn | huh, yes | ||
moritz | considering that rakudo-parrot took only about 140s | ||
jnthn | It normally comes out well ahead here | ||
moritz | and that's a java-7-oracle JVM + javac | 14:51 | |
FROGGS | I have 65s ommpared to 140s | ||
jnthn | 45s vs 100s here | 14:52 | |
FROGGS | compared* | ||
14:58
xenoterracide_ joined
|
|||
dalek | rlito: 46c565c | (Flavio S. Glock)++ | / (3 files): Perlito5 - perl5 - pretty-printer - lookup, index |
15:00 | |
[Coke] yawns. | 15:10 | ||
hexcoder | r: @@( <a b>, <c d> ) == @( <a b>, <c d> ) | ||
camelia | ( no output ) | ||
hexcoder | r: say @@( <a b>, <c d> ) == @( <a b>, <c d> ) | ||
camelia | rakudo c6b15d: OUTPUT«True» | ||
jnthn tries to work out what hexcoder is expecting that to mean and fails :) | 15:11 | ||
hexcoder | i am exploring slice context, but fail too. | ||
:r my @a = @@( <a b>, <c d> ); say @a | 15:12 | ||
FROGGS | r: my @a = 'a' .. 'z'; say @a[0; 2] | 15:13 | |
camelia | rakudo c6b15d: OUTPUT«WARNINGS:Useless use of constant integer 0 in sink context (line 1)c» | ||
FROGGS | r: my @a = ^10; say @a[0, 2] | ||
camelia | rakudo c6b15d: OUTPUT«0 2» | ||
dalek | rlito: 71da9bc | (Flavio S. Glock)++ | / (2 files): Perlito5 - perl5 - pretty-printer - slices |
||
FROGGS | r: my @a = 'a'..'z'; say @a[0, 2] # that is what I meant | 15:14 | |
camelia | rakudo c6b15d: OUTPUT«a c» | ||
hexcoder | no, i meant the slice contextualizer that moritz describes in his document Perl 5 to Perl 6 in chapter 'Context' | ||
@() should flatten, and @@() should not. | 15:15 | ||
FROGGS | r: say @( <a b>, <c d> ) | ||
camelia | rakudo c6b15d: OUTPUT«a b c d» | ||
FROGGS | hexcoder: I think @@() is not yet implemented | ||
r: say @( <a b>, <c d> ).perl | |||
camelia | rakudo c6b15d: OUTPUT«(("a", "b"), ("c", "d")).list» | 15:16 | |
hexcoder | ah, and suddenly everything makes sense :-))) thanks!! | ||
FROGGS | so, @() does the job of @@() atm | ||
hexcoder: you're welcome :o) | |||
hexcoder | I agree, I could not even find it in the Synopsis. Or is it in already? | 15:17 | |
dalek | rl6-roast-data: c35c60b | coke++ | / (5 files): today (automated commit) |
||
jnthn | I think @@ went away, fwiw | ||
FROGGS | ahh, that explains it then :o) | 15:19 | |
masak greps the logs | 15:20 | ||
yeah. it was removed in Feb 2010. | |||
**@ is still alive and well, though. | |||
hexcoder | Thanks folks. I will tell Moritz... | 15:21 | |
jnthn | yeah, but that ain't a conextualizer... | ||
moritz | hexcoder: did you read it on one of my websites? | ||
hexcoder | Yes | ||
perlgeek.de/en/article/5-to-6 | |||
BenGoldberg | r: say ^'z' | 15:22 | |
camelia | rakudo c6b15d: OUTPUT«Cannot call 'Real'; none of these signatures match::(Mu:U \v: Mu *%_) in method Real at src/gen/CORE.setting:944 in method new at src/gen/CORE.setting:6814 in method new at src/gen/CORE.setting:6794 in sub prefix:<^> at src/gen/CORE.setting:6…» | ||
hexcoder | moritz: I will sent all of my findings combined to you. Stay tuned... | 15:23 | |
moritz stays tuned, ++hexcoder | 15:24 | ||
[Coke] tries to think of a good way to debug this stupid rakudo.jvm failure on the test box. | 15:25 | ||
[Coke] supposes he could attach visualvm and sit around for 2 hours. | |||
jnthn | [Coke]: Does it only happen under the eval server? | 15:26 | |
15:31
rindolf joined
15:37
kaare__ joined
|
|||
[Coke] | jnthn: that's an excellent thing to to test. | 15:40 | |
15:41
kaare_ left
|
|||
[Coke] | aha! | 15:41 | |
looks like this time my "log the eval serve" thing worked. | |||
gist.github.com/coke/6855515 - OOME | 15:42 | ||
of course, it has no useful details. :) | |||
BenGoldberg | r: my @a; say (@a xx *)[0]; | 15:43 | |
camelia | rakudo c6b15d: OUTPUT«(timeout)» | ||
BenGoldberg | Should xx check if it's first argument is an empty list? | ||
15:49
araujo left,
araujo joined
15:50
sisar left
|
|||
moritz | [Coke]: you could check if t/spec/S02-types/array.t OOMs | 15:57 | |
[Coke]: that's the test file that causes problems on my boxes with parakudo | 15:58 | ||
16:18
stevan_ left
16:22
xinming left
16:25
xinming joined,
ssutch joined
|
|||
masak | BenGoldberg: seems to me `(() xx *)[0]` falls within "doctor, it hurts when I do this" territory. just like `loop {}` | 16:34 | |
TimToady | r: say (() xx *).lol[^10].perl | 16:36 | |
camelia | rakudo c6b15d: OUTPUT«(ListIter.new(), Any, Any, Any, Any, Any, Any, Any, Any, Any)» | ||
TimToady | lol should not flatten () | ||
moritz | r: say (() xx *).lol[^10].elems | ||
camelia | rakudo c6b15d: OUTPUT«Inf» | ||
moritz | r: say (() xx *).lol[^10].tree.elems | ||
camelia | rakudo c6b15d: OUTPUT«Inf» | ||
moritz | r: say (() xx 5).lol.perl | 16:37 | |
camelia | rakudo c6b15d: OUTPUT«LoL.new(ListIter.new())» | ||
moritz | r: say (() xx 5).lol.elems | ||
camelia | rakudo c6b15d: OUTPUT«1» | ||
dalek | rlito: 5a62cef | (Flavio S. Glock)++ | / (3 files): Perlito5 - perl5 - pretty-printer - map |
||
TimToady | I'd think () xx 5 should return (),(),(),(),() | ||
and lol should turn that into [],[],[],[],[] | 16:38 | ||
grondilu thinks about 'loop {}' Something bugs him about it | |||
TimToady | or something equivalently itemy | ||
loop is both a noun and a verb, so you can think of it either way | 16:39 | ||
r: (loop {})[^10].perl.say | 16:40 | ||
camelia | rakudo c6b15d: OUTPUT«(timeout)» | ||
grondilu | currently, 'loop {}' hangs, right? I wonder if, for a language that is supposed to allow parallelism, it is not a bad idea. Maybe loop {} should do just nothing. | ||
TimToady | the imperative mindset is difficult to subvert :) | ||
grondilu | I guess it is | ||
TimToady | it should do the same thing as () xx * :) | ||
by current spec, which people keep carping about :) | 16:41 | ||
grondilu remembers that he once thought there should be an entire synopys dedicated to degenerate cases. | |||
TimToady | we do probably need to exempt loops at statementlist level from being lazy though | 16:42 | |
masak | if you ask me, `loop {}` is behaving exactly as it should. | ||
you ordered an infinite loop? well, you have it. | |||
TimToady | there's that imperative mindset again :) | ||
grondilu | :) | ||
TimToady | the question is not whether it's infinite, but whether it's lazy | ||
jnthn | loops kinda are imperative... :) | ||
grondilu | they are imperative 'inside' the loop. But from an external point of view, they are a member of a program that does not have to be imperative. | 16:44 | |
jnthn | Maybe, but I think at least culturally loops are seen as an imperative construct, and the functional constructs are spelt more like "map" :) | 16:45 | |
masak | the fact that I have an imperative mindset (and that I consider it "correct" here) was my entire point. | 16:46 | |
jnthn | Heck, when I'm teaching Linq I even find myself saying "it's nice because we don't have a load of loops, just nice declarative code saying how to process the stream of things coming through the enumerable"... | 16:47 | |
16:48
diakopter left
|
|||
BenGoldberg | r: gather { loop {} }; | 16:49 | |
camelia | rakudo c6b15d: OUTPUT«(timeout)» | ||
BenGoldberg | r: gather { loop {} }; 1; | ||
grondilu wonders if loop {} is not the same kind of undefined notion as 0 * Inf | |||
ingy | want to be a Perl 6 programmer? so how many mindsets do you have? 3? hmmmm... stick with Perl 5 | ||
camelia | rakudo c6b15d: OUTPUT«(timeout)» | ||
BenGoldberg | n: gather { loop {} }; 1; | ||
camelia | ( no output ) | ||
benabik | Doesn't 0 * Inf = 0? | ||
grondilu | benabik: no | 16:50 | |
benabik | r: print 0*Inf | ||
camelia | rakudo c6b15d: OUTPUT«NaN» | ||
grondilu | 0 * Inf is undefined. | ||
BenGoldberg | Why did gather { loop {} }; 1; hang in Rakudo? | ||
rn: gather { die 'foo' }; 1; | 16:51 | ||
camelia | ( no output ) | ||
..rakudo c6b15d: OUTPUT«foo in block at /tmp/lkkO7Msc9b:1» | |||
BenGoldberg | rn: gather { take 0; die 'foo' }; 1; | 16:52 | |
camelia | ( no output ) | ||
..rakudo c6b15d: OUTPUT«foo in block at /tmp/DlYXOBv0OP:1» | |||
BenGoldberg | rn: my @a := gather { take 0; die 'foo' }; @a; | ||
camelia | ( no output ) | ||
..rakudo c6b15d: OUTPUT«foocurrent instr.: 'throw' pc 402312 (src/gen/CORE.setting.pir:169118) (src/gen/CORE.setting:10504)called from Sub 'die' pc 42214 (src/gen/CORE.setting.pir:16280) (src/gen/CORE.setting:662)called from Sub 'die' pc 42113 (src/gen/CORE.setting.pir:16224)…» | |||
BenGoldberg | rn: my @a := gather { take 0; throw 'foo' }; @a; | ||
camelia | rakudo c6b15d: OUTPUT«===SORRY!=== Error while compiling /tmp/7HZWHGsU6dUndeclared routine: throw used at line 1» | ||
..niecza v24-98-g473bd20: OUTPUT«===SORRY!===Undeclared routine: 'throw' used at line 1Unhandled exception: Check failed at /home/p6eval/niecza/boot/lib/CORE.setting line 1502 (die @ 5)  at /home/p6eval/niecza/src/STD.pm6 line 1147 (P6.comp_…» | |||
BenGoldberg | EINSUFFICIENTCAFFIENE | 16:53 | |
grondilu is fine with gather { take 0; die } dying. | |||
BenGoldberg | grondilu: in sink context? | 16:54 | |
grondilu | yeah | ||
though I should check what sink contect means | |||
BenGoldberg | Surely gather <anything> in sink context should be a no op. | ||
It's like undef context in perl5 | 16:55 | ||
moritz | there might still be side effects | ||
BenGoldberg | Err, !defined(wantarray) in perl5 :) | ||
moritz | yes, void context | ||
lue | hello world o/ | ||
BenGoldberg | rn: my @a := map { die if $_ > 0 } ^Inf; say @a[0]; | 16:56 | |
camelia | rakudo c6b15d: OUTPUT«Cannot call 'map'; none of these signatures match::(&code, *@values) in sub map at src/gen/CORE.setting:1719 in sub thread_junction at src/gen/CORE.setting:3123 in method AUTOTHREAD at src/gen/CORE.setting:3151 in sub map at src/gen/CORE.sett…» | ||
..niecza v24-98-g473bd20: OUTPUT«(Any)» | |||
BenGoldberg | rn: my @a := map { die if $_ > 0 }, ^Inf; say @a[0]; | ||
16:56
zakharyas joined
|
|||
camelia | rakudo c6b15d: OUTPUT« in block at /tmp/VYAgyhd1Sq:1» | 16:56 | |
..niecza v24-98-g473bd20: OUTPUT«» | |||
grondilu | rn: my @a := gather { take 1; say "bye" }; @a | 16:57 | |
BenGoldberg | rn: map { die if $_ > 0 }, ^Inf; | ||
camelia | ( no output ) | ||
..rakudo c6b15d: OUTPUT«bye» | |||
( no output ) | |||
..rakudo c6b15d: OUTPUT«No exception handler and no messagecurrent instr.: 'throw' pc 402312 (src/gen/CORE.setting.pir:169118) (src/gen/CORE.setting:10504)called from Sub 'die' pc 42298 (src/gen/CORE.setting.pir:16317) (src/gen/CORE.setting:665)called from Sub '' pc 156 ((…» | |||
grondilu | rn: my @a := 1..*; @a | 16:58 | |
camelia | ( no output ) | ||
grondilu | rn: my @a := gather for 1..* { .take; say "." }; @a | 16:59 | |
camelia | ( no output ) | ||
..rakudo c6b15d: OUTPUT«(timeout)...............................................................…» | |||
grondilu | BenGoldberg: you might be right. There should not be evaluations in sink context. | 17:00 | |
moritz | grondilu: that's contrary to our current philosphy | ||
which is: if you evaluate something in sink context, it's for its side effects, so it must be eagerly evaluated | 17:01 | ||
grondilu | ok | ||
dalek | rlito: 2bdccfe | (Flavio S. Glock)++ | / (4 files): Perlito5 - perl5 - pretty-printer is the default perl5 backend |
17:04 | |
hexcoder | moritz: which of your email addresses should I use for feedback on 'Perl 5 to Perl6'? | 17:21 | |
17:24
diakopter joined
|
|||
moritz | hexcoder: [email@hidden.address] | 17:29 | |
dalek | rlito: ac48c65 | (Flavio S. Glock)++ | / (2 files): Perlito5 - perl5 - pretty-printer - more operators |
17:30 | |
rlito: 8398d27 | (Flavio S. Glock)++ | / (2 files): Perlito5 - perl5 - pretty-printer - tweak operators |
|||
hexcoder | :moritz done | 17:31 | |
17:32
stevan__ joined
17:33
btyler joined,
ajr_ left
17:34
ajr joined
17:35
ajr is now known as Guest44737,
Guest44737 is now known as ajr_
17:58
araujo left
17:59
araujo joined,
Rotwang joined
18:02
ajr_ left
18:04
Rotwang left
18:20
SamuraiJack__ left
|
|||
ingy | sorear: ping | 18:27 | |
dalek | ast: af7277f | (Elizabeth Mattijsen)++ | S02-types/ (3 files): Add tests for .grabpairs where they are not supposed to work |
18:29 | |
18:29
ajr_ joined
18:30
darutoko left
18:32
rindolf left
|
|||
BenGoldberg | rn: my @a := gather { take 1; say 'bye' }; @a.eager; | 18:38 | |
camelia | rakudo c6b15d, niecza v24-98-g473bd20: OUTPUT«bye» | ||
moritz | r: 'abcd'.substr(my @a = 1, 4).say | 18:42 | |
camelia | rakudo c6b15d: OUTPUT«cd» | ||
FROGGS | ? | 18:43 | |
jnthn | that's like .substr(2) I guess | ||
lizmat | final value of the parcel ? feels like a p5ism | ||
p5eval: my @a=(1,2,3,4); say $a[my @b=1,3] | 18:45 | ||
p5eval | lizmat: 41 | ||
lizmat | p5eval: my @a=(1,2,3,4); $a[my @b=1,3] | ||
p5eval | lizmat: 4 | ||
FROGGS | ahh, now I see it | 18:46 | |
xinming | I saw the methdo ucfirst is renamed to tc for Str, What does tc mean here please? | 18:55 | |
jnthn | xinming: title case | 18:56 | |
xinming | got it, thanks | ||
dalek | rlito: 18ea7c3 | (Flavio S. Glock)++ | / (2 files): Perlito5 - perl5 - pretty-printer - elsif |
19:05 | |
masak | lizmat: it's not final value of a parcel. it's its length. | 19:09 | |
lizmat | p5eval: my @a=(1,2,3,4); say $a[my @b=1,2] | 19:10 | |
p5eval | lizmat: 31 | ||
lizmat | ok, so it's not a p5ism | ||
masak | I'm really glad we didn't inherit that one :) | 19:13 | |
r: say 'abcd'.substr(my @a = 1, 4); say 'abcd'.substr(2) | 19:14 | ||
camelia | rakudo c6b15d: OUTPUT«cdcd» | ||
masak | r: say [1, 4].elems | ||
camelia | rakudo c6b15d: OUTPUT«2» | ||
masak | r: say +[1, 4] | ||
camelia | rakudo c6b15d: OUTPUT«2» | ||
masak | r: say +my @a = 1, 4 | ||
camelia | rakudo c6b15d: OUTPUT«2» | ||
19:18
zakharyas left,
sisar joined
19:32
Rotwang joined
|
|||
lizmat | r: my $b=<a b b>.BagHash; $b.grab(*).say; $b.say | 19:33 | |
camelia | rakudo c6b15d: OUTPUT«b b aBagHash.new(a(0), b(0))» | ||
lizmat | oops, grab doesn't clean up | 19:34 | |
dalek | kudo/nom: 08d0f14 | (Elizabeth Mattijsen)++ | src/core/Baggy.pm: Make sure Baggy.grab cleans up after itself |
19:35 | |
lizmat | TimToady: on the subject of typed Bag/Mix: the problem is that rakudo currently cannot serialize any typed hashes/arrays | 19:38 | |
jnthn is aware of the pb, but for now is low on the list | 19:39 | ||
jnthn | lizmat: We determiend it wasn't just about the setting also, iirc? | 19:45 | |
lizmat | jnthn is aware of the pb, but for now is low on the list | 19:47 | |
Stage optimize : 17.719 | |||
Code ref 'Str' does not exist in serialization context | |||
so it happens in stage post | |||
you want me to try this with e.g. lib/Test.pm and see what happens ? | 19:48 | ||
19:49
japhb_ left
|
|||
dalek | kudo/nom: 2e2f5f0 | (Elizabeth Mattijsen)++ | src/core/Setty.pm: Implement Setty.grabpairs for consistency |
19:50 | |
kudo/nom: 7b98f86 | (Elizabeth Mattijsen)++ | src/core/ (3 files): Implement .grabpairs where they're *not* supposed to work |
|||
moritz | hexcoder++ # very good feedback on 5-to-6 | 19:52 | |
japhb__ | jnthn, did you have any thoughts on the multi problem I rambled about last night? | ||
FROGGS | gnight | ||
lizmat | jnthn: it *only* appears to be happening when compiling the setting | 19:53 | |
japhb__ | gnight FROGGS | ||
19:53
FROGGS left
|
|||
lizmat | adding a typed hash spec to lib/Test.pm and doing a "./perl6 --stagestats --target=pir --output=lib/Test.pir lib/Test.pm" just works fine | 19:53 | |
jnthn | japhb__: Well, it's a language design issue rather than Rakudo not implementing current spec wrt multis, afaik. And yeah, it's a tricky issue...but multi-dispatch candidate lists being known lexically is *really* important for optimization, so we can't break that. | 19:55 | |
japhb__: Which somewhat constrains the solution space... | |||
19:56
araujo left
|
|||
ivanshmakov | S17 mentions continuations, but doesn’t seem to either describe them itself, or point to another document describing them. Where do I find more information on that? perlcabal.org/syn/S17.html | 19:58 | |
20:01
japhb_ joined
|
|||
lue | ivanshmakov: unfortunately (if I remember correctly), S17 is severely undeveloped, so the stuff described inside is due for a lot more work. | 20:02 | |
They do seem to be mentioned once in S09, and a few times in S04 however. | |||
lizmat | indeed, S17 is mostly ~2005 ramblings, by yours truly among others :-( | 20:03 | |
20:03
araujo joined
|
|||
lizmat is looking forward to get back to that once moarvm lands | 20:03 | ||
jnthn | Well, S17 probably wants to become a description of the stuff that's actually implemented so far :) | 20:04 | |
20:04
dmol left
|
|||
jnthn | The answer on continuations, though, is that Perl 6 doesn't expose them at user level. | 20:04 | |
The closest is gather/take, which is coroutine-powerful. | 20:05 | ||
lizmat | jnthn: that's what I mean :-) | ||
jnthn | lizmat: Yeah, but no need to wait for MoarVM to evolve that. ;) | 20:06 | |
perigrin | ivanshmakov: the relatively ancient www.sidhe.org/~dan/blog/archives/000156.html helped me grasp the concept of continuations. | ||
20:07
dmol joined,
PacoAir left
|
|||
arnsholt | jnthn: NQP inherits all of its CFLAGS from Parrot, right? | 20:07 | |
jnthn | yeah | 20:08 | |
Believe so | |||
arnsholt | 'Cause then I can punt #33 back to Parrot | 20:09 | |
lue | That reminds me, can anyone tell me why my long-ago change to syn_index.html to have a link to S99 still doesn't show up on either feather's or perlcabal's synopses indexes? | 20:10 | |
arnsholt | Not that compiler warnings are that big of a deal anyways | ||
lue | (it should appear directly underneath the row for S33 fwiw) | 20:12 | |
japhb__ | jnthn: How much does it weaken the multi optimizations if we drop from "absolute knowledge of all applicable candidates" to "the list of applicable candidates changes rarely"? | 20:15 | |
20:18
araujo left,
araujo joined,
sisar left
|
|||
lue | .oO(is it possible the index updater is not running? Both sites' indexes say they were last modified Wed 03 Apr 2013 02:01:04 AM PDT) |
20:19 | |
jnthn | japhb__: Means we can't inline at compile time. | ||
japhb__: So a $native_int + $native_int would have to compile down to a multi-dispatch and we are at the mercy of JIT compilers doing inlines to make adding two native integers together work out, rather than code-generating a simple add instruction, which is what happens today with compile-time inlining. | 20:21 | ||
japhb__ | jnthn: What about a fast generation check that fails out of the straight line path, and succeeds with fallthrough to code generated on the assumption that it hasn't changed? Hmmm, come to think of it, for native ops, that's still a heckuva lot of overhead ... | 20:22 | |
Kinda does assume the existance of a JIT that can hoist that check higher, though. | 20:24 | ||
dalek | ast: 8379851 | (Elizabeth Mattijsen)++ | S02-types/ (3 files): Add tests for where .grabpairs *should* work |
20:31 | |
lizmat | another ~70 tests or so | ||
japhb__ | TimToady: What are your thoughts on language decisions that penalize interpreters? "Heck no!" ? "It depends"? | 20:32 | |
jnthn | japhb__: Yeah, and while we *may* be able to use invokedynamic to each the JVM's JIT enough to actually do it with Perl 6 multi-dispatch...and of course we can do as we please in Moar...anything else is a bit more tricky | 20:35 | |
20:36
PacoAir joined
20:38
PacoAir left
20:42
dmol left,
dmol joined
20:45
stevan__ left
|
|||
japhb__ | Am I correct in assuming that no later-added multi candidate can contribute to an op that is *called* in the setting? | 20:46 | |
lizmat | depends, afaik: if you add a multi-method to Any, it will only work on objects that *are* Any, not on any of its subclasses | 20:48 | |
jnthn | The setting is the outermost lexical scope of the program, so what's visible there is what they see. Note that "later-added" doesn't actually add to the multi candidate lists of the operators as the setting sees them; rather, the dispatcher is derived... | ||
lizmat: We're doing multi subs here... | |||
lizmat | ah, ok… :-) | 20:49 | |
lizmat goes back to lurk mode | |||
japhb__ | jnthn: Yeah, that's what I thought. I just wanted to make sure I wasn't being pessimistic on account of an incorrect mental picture. | 20:51 | |
20:54
ajr_ left
|
|||
hexcoder | privmsg camelia | 20:59 | |
privmsg camelia :macro circumfix:«< >» ($text) is parsed / <-[>]+> / {return $text.comb(rx/\S+/);} | 21:02 | ||
grondilu | is parsed is NYI, isn't it? | ||
r: macro postfix:<????> is parsed { } | 21:03 | ||
camelia | rakudo 7b98f8: OUTPUT«===SORRY!=== Error while compiling /tmp/C6Cr6Q03pmCan't use unknown trait 'is parsed' in a macro+{precedence} declaration.at /tmp/C6Cr6Q03pm:1------>  expecting any of: rw parcel hidden_from_backtrace pure de…» | ||
hexcoder | might be, but rakudo expects a block after that, so I thought it understands it. | ||
21:04
skids left
|
|||
grondilu | it doesn't, but it recognizes it as a trait | 21:04 | |
hexcoder | aha, I see. | ||
21:10
dmol left
21:12
Rotwang left
21:16
skids joined
21:21
hummeleB1 left
21:22
kaare__ left
|
|||
dalek | kudo/nom: d45e4da | (Elizabeth Mattijsen)++ | src/core/Backtrace.pm: Add :named so that we can filter on named subs/methods |
22:06 | |
22:12
stevan_ joined
22:31
hexcoder left
22:36
stevan_ left
|
|||
dalek | p/moarboot: 431c3b1 | jnthn++ | src/vm/moar/ (3 files): Properly handle --bootstrap on MoarVM backend. |
22:52 | |
p/moarboot: 3f8a23c | jnthn++ | tools/build/Makefile-Moar.in: Correct backend name in Moar makefile. |
|||
p/moarboot: ff77d36 | jnthn++ | src/vm/moar/stage0/ (9 files): Update stage0 for MoarVM to get various fixes. |
|||
p/moarboot: 78f4d64 | jnthn++ | src/NQP/Compiler.nqp: Tweak so that stage1 actually starts up. Fails upon calling the first action method, however; some code-object related issue. |
|||
kudo/nom: 9947610 | (Elizabeth Mattijsen)++ | src/core/Backtrace.pm: Add a .package method for convenience and abstraction |
23:02 | ||
lizmat | sleep& | 23:16 | |
timotimo | gnite lizmat | ||
23:20
grondilu left
23:33
JJesus joined
23:41
cognominal left
23:47
dwarring joined,
JJesus left
|