pugscode.org/ | nopaste: sial.org/pbot/perl6 | pugs: [~] <m oo se> (or rakudo:, kp6:, elf: etc.) (or perl6: for all) | irclog: irc.pugscode.org/ Set by Tene on 29 July 2008. |
|||
wayland76 | perlbot karma wayland76 | 00:02 | |
perlbot | wayland76 doesn't have any karma | ||
meppl | good night | 00:11 | |
wayland76 | good night | ||
meppl | ;) | ||
00:12
meppl left
00:15
Alias_ joined
|
|||
japhb | jnthn: is it possible to set sub params as rw in Rakudo, and have it work? | 00:19 | |
jnthn | Yes. | ||
Though it's on my list of things that may not have good spectest coverage | |||
japhb | k | ||
just sub foo($param is rw)? | 00:20 | ||
jnthn | But I did review this just a few days back when pm and I were doing the container refactors. | ||
Yes. | |||
japhb | cool beans, thx | ||
jnthn | rakudo: sub foo($x is rw) { $x = 42 }; my $a = 2; foo($a); say $a; | ||
p6eval | rakudo 32502: OUTPUT[42] | ||
jnthn | Yes, works. | ||
wayland76 | Are there any windowing toolkits that cat be used from Parrot yet? | 00:26 | |
s/cat/can/ | |||
jnthn | wayland76: I know there's SDL but I don't know that this counts as windowing toolkit. | 00:28 | |
japhb | wayland76: and there's GLUT. Same problem. | ||
Although it does create windows and menus ... :-P | 00:29 | ||
wayland76 | Well, maybe SDL will do what I want :) | ||
jnthn doesn't know much about it | 00:30 | ||
wayland76 | At the moment, I'm mainly after something that makes canvases easy :) | ||
Anyway, now that I know what the options are, I can investigate them :) | |||
Thanks :) | 00:31 | ||
jnthn | Welcome, have fun. :) | ||
pugs_svn | r22970 | ruoso++ | [mildew] one test showing that if you define "knowhow ClassHOW", you can then use "class Foo". The relationship about each metaclass handles each keyword is hard-coded in the compiler. | 00:33 | |
00:36
jan_ left
|
|||
ruoso | @tell pmurias take a look at mildew/t/classhow_add_method.t | 00:36 | |
lambdabot | Consider it noted. | ||
00:37
penk joined
00:38
jan_ joined
|
|||
ruoso sleep & | 00:38 | ||
00:45
kanru joined
|
|||
pugs_svn | r22971 | lwall++ | [Cursor] isolate symbols in a NOTBEFORE to fix mncharity++'s last; problem | 00:51 | |
r22971 | lwall++ | [Cursor] stub in a trie-engine as down payment on a real dfa | |||
00:51
Lorn joined
|
|||
japhb | rakudo: my $a = 2; my $b = 4; say "foo: {$a / $b}" | 00:52 | |
p6eval | rakudo 32503: OUTPUT[foo: 0.5] | ||
japhb | *excellent* | ||
TimToady | what the heck was that? | 00:55 | |
why did it include foo:? | |||
it should have been parsed as a label | |||
jnthn | TimToady: What? | ||
Labels inside double quotes? | 00:56 | ||
TimToady | ah | ||
missed those | |||
jnthn breathes a sigh of relief | |||
TimToady | I misread a question on my SAT like that too--kept me from getting an 800 on the math section... | ||
jnthn | TimToady: Am I right in thinking that if you declare a class, then write a BEGIN block after it, you can use that class, instantiate it etc in the BEGIN block? | 00:59 | |
TimToady | yes, declarations happen at compile time | ||
jnthn | OK. | 01:00 | |
TimToady | otherwise there wouldn't be much point in 'em | ||
jnthn | OK, that was the answer that I was expecting. | ||
Follow up. | |||
my $x is foo; # where foo is some trait we've defined | |||
If we have that inside a sub, we would apply the trait each time the sub is invoked? | 01:01 | ||
As in, create a container and apply the trait? | |||
Or is that somehow a one-shot thing at compile time too? | |||
TimToady | there's an abstract $x that is shared by all invocations...at least in the abstract :) | 01:02 | |
ruoso | meaning that the runtime can clone in each passage? | ||
s/passage/invocation/ | 01:03 | ||
TimToady | it seems like you'd want to factor out common operations to one spot though, to the extent that your VM allows it | ||
jnthn | OK, so if the trait kept track of how many times it was applied (or, OK, the trait_auxilliary:is multi for that trait did), and we only ever wrote "my $x is foo" once in a subroutine, then called that sub 100 times, the counter would only get incremented once? | 01:04 | |
TimToady | but if a VM cannot support something declaratively then it has to be emulated, of course | ||
jnthn hopes his question made sense - I can put it in code too if not! | |||
Limbic_Region | TimToady - the SATs were restructured in 2005. I scored a 1200 my sophmore year and never took them again | ||
TimToady | the trait is applied at compile time, in the abstract, not at run time | 01:05 | |
ruoso | TimToady, on another issue, would you consider who's job to move bare statements in a package to INIT? viv? STD? or the actual compiler? | ||
jnthn | TimToady: OK, thanks. I'll probably now spend my flight on Thursday working out exactly what the fallout of this is. :-) | 01:06 | |
TimToady | ruoso: I don't really understand your question | 01:07 | |
ruoso | TimToady, viv currently sees the list of statements as plain | 01:08 | |
independently if it is a method_def or something else | |||
TimToady | well, it's certainly not peanut | ||
ruoso | it's my understanding that method_def, as well as other declarations happen at BEGIN | 01:09 | |
and other statements are only executed at INIT | |||
TimToady | after INIT, but go on | ||
ruoso | who do you think is the responsible for sorting out what should be in BEGIN and what shouldn't? | 01:10 | |
STD? | |||
viv? | |||
or the compiler itself? | |||
TimToady | I guess I don't know what you mean by "the compiler itself" | 01:11 | |
ruoso | well... in our current setup... | ||
mildew | |||
diakopter | out of band call to #perl6? | ||
TimToady | and I don't why you mention viv, when that's the vi-to-v translator :) | ||
jnthn suddenly gets what viv stands for | 01:12 | ||
TimToady | anyway, every construct needs to know whether it executes itself as part of its own reduction | ||
and declarations may or may not return extra stuff to run at run time | 01:13 | ||
my $x = 42; still hast to do the = at run time | |||
but it doesn't have to do the "my" part, except insofar as the variable storage needs setting up at entry | |||
01:14
hercynium joined
|
|||
ruoso | ok... | 01:14 | |
in mildew we have... | |||
STD -> viv -> mildew -> m0ld | |||
TimToady | it was intended that viv be copied, not used :) | 01:15 | |
ruoso | I'm not sure at which extent it is "used"... | ||
but wasn't viv the one that turned the match tree into something more AST-like? | 01:16 | ||
TimToady | I suspect it's just the callback engine, which is pretty small | ||
sure, but that's like one routine, and you don't want the rest of viv | |||
if we want to abstract out that routine, fine | |||
anyway, not what you're asking about | 01:17 | ||
ruoso | right... but it doesn't really matter to the question... | ||
jnthn | TimToady: You write "except insofar as the variable storage needs setting up at entry" - if you're doing a trait like is dim(2,3,4) or something, then this sized/shaped array needs creating at entry. | ||
TimToady: Does this mean that really the trait should be supply the AST to Do That at runtime? | |||
And it gets shoved into what we compile? | |||
Rather than the trait being invoked at runtime to do that... | 01:18 | ||
...which I guess doesn't fit with what you said earlier. :-) | |||
TimToady | well, declarations can have all kinds of consequences, and certainly some of the consequences are at run time | ||
jnthn | Sure. | ||
I'm just trying to work out how traits will look | |||
I mean, in Rakudo we identify a bunch of them hard coded in the actions. | 01:19 | ||
But, well, I don't think that's really what we want. | |||
01:19
Lorn left
|
|||
ruoso | trying to put in an example... | 01:19 | |
class Foo { say 1; method bar {...} say 2; }; | |||
mildew currently sees the three statements in a flat list | |||
TimToady | well, assuming a newline in there | 01:20 | |
ruoso | yes yes | ||
but "method bar {...}" declaration will get executed much sooner than "say 1" and "say 2" | 01:21 | ||
TimToady | yes, in the sense that the method bar declaration executes even before say 2 is parsed | ||
jnthn | Wow. | 01:22 | |
That's even earlier than I expected. | |||
ruoso | who is the one who decides which statements are executed when? | ||
TimToady | the reduction of a BEGIN block must trigger its execution | ||
just generalize from there | |||
ruoso | but who defines which one is a BEGIN and which isn't? | 01:23 | |
TimToady | there needs to be a method to run a block that is accessible to the reduction action | ||
alternately, some way for such reductions to signal their surrounding scope to execute them immediately | 01:24 | ||
ruoso | so, STD has a hook for everything, and the runtime then decides what should be BEGIN and what shouldn't... | 01:25 | |
ruoso really looking at concrete code right now | 01:26 | ||
not thinking abstract at all | |||
TimToady | another way of looking at it is that FOO {...} routines install themselves into various queues, and different queues are executed at different times | ||
ruoso doesn't really understand what that means relating to the question | 01:27 | ||
TimToady | declarations just happen to have an abstract container object that can be modified when such a beginnish routine is called by a trait | ||
ruoso | right... but who puts the container? | 01:28 | |
STD? | |||
TimToady | different declarators create different containers | ||
diakopter | TimToady: may a BEGIN block redefine the parsing of a BEGIN block [including itself]? | ||
TimToady | STD is just syntax, until you add actions | 01:29 | |
ruoso | mhmm... | ||
diakopter | I mean, it couldn't define away the BEGIN's }, could it | ||
TimToady | diakopter: no, it's already parsed | ||
the BEGIN reduction doesn't happen till after the } is parsed | |||
diakopter | oh | ||
ruoso feels too asleep to figure out entirely what all that means... | |||
ruoso sleep & | 01:30 | ||
01:30
japhb left
|
|||
TimToady | nite | 01:30 | |
jnthn | TimToady: While we're on the evil... :-) | ||
class Foo { method x { }; BEGIN { Foo.x }; } | |||
Would we expect that to actually invoke x, or is it too early to instantiate Foo before it's definition is over? | 01:31 | ||
diakopter | jnthn: those noops are detected and eliminated :P | ||
(kidding) | 01:32 | ||
TimToady | I think that's probably too early--it knows the name, but not the implementation | 01:33 | |
jnthn | OK, sounds good. | ||
TimToady | so it would compile the BEGIN fine, but fail in the dispatch to Foo | 01:34 | |
groceries & | 01:35 | ||
jnthn | ooh...2:30am...sleep & | ||
pmurias | ruoso: m0ld is dynamic linking now | 01:36 | |
lambdabot | pmurias: You have 4 new messages. '/msg lambdabot @messages' to read them. | ||
pmurias | shower& | ||
01:38
spx2 left,
spx2 joined
01:40
bcornett left
01:46
justatheory left
01:55
japhb joined
02:11
Limbic_Region left
02:16
nacho_ joined
02:18
pmurias left
02:19
hercynium left
02:23
bacek left
|
|||
wayland76 has not quit :) | 02:27 | ||
02:27
penk left
02:30
penk joined
02:39
penk left,
nacho_ left
02:42
wayland76 left
02:44
alester left
02:57
elmex left
03:00
wknight8111 left,
s1n joined
|
|||
s1n | pmichaud: finally back online | 03:01 | |
03:05
Tene joined
03:15
sri_kraih_ joined
03:18
justatheory joined
03:22
sri_kraih left
03:25
stephenos left
03:27
alester joined
|
|||
japhb | rakudo hackers about? | 03:35 | |
Alias_ | Probably mostly the wrong timezone | 03:37 | |
s1n | only 0930 here | ||
Alias_ | Very late in the US, very early in Europe. Just us mere Australasians online right now | 03:38 | |
japhb | rakudo: my $a = 2; sub foo { say "foo: $a"; bar(); }; sub bar { say "bar: $a"; }; foo(); | ||
p6eval | rakudo 32504: OUTPUT[foo: 2bar: ] | ||
japhb | That's breaking things for me right now, just wanted to know if it's a known issue | ||
s1n | not very late in the US, i meant to say 2130, not 0930 :) | 03:39 | |
03:47
ab5tract joined
04:03
kanru left,
Patterner1 joined
04:05
kanru joined
04:06
jfredett joined
04:15
Patterner left,
Patterner1 is now known as Patterner
04:19
s1n left
04:33
Jedai joined
04:41
jauaor left
04:42
hercynium joined
04:49
araujo left,
[particle] left
04:52
|Jedai| left
04:58
justatheory left
05:01
araujo joined
|
|||
pmichaud | japhb: lexicals are still having issues in Parrot/rakudo, yes. | 05:14 | |
05:16
ab5tract left
05:18
alc joined
05:22
agentzh left
05:26
jauaor joined
05:45
agentzh joined
|
|||
rakudo_svn | r32510 | coke++ | [rakudo] RT #58974 - use of .return as a synonym for .tailcall is [DEPRECATED] | 05:50 | |
05:56
TimToady left,
diakopter left,
cpfr left
05:57
TimToady joined,
diakopter joined
06:03
zamolxes left
06:15
araujo left,
tewk_ left,
jiing left,
idemal left,
nothingmuch left,
broquaint left,
fullermd left,
Guest70230 left,
literal left,
c1sung left,
c1sung joined
06:16
tewk joined,
nothingmuch joined,
broquaint joined
06:21
fullermd joined
|
|||
japhb | pmichaud: OK, thanks for letting me know, I'll try to work around it. | 06:22 | |
06:22
jiing joined
|
|||
lizsac | no prob | 06:24 | |
06:29
araujo joined,
literal joined,
idemal joined
06:30
broquaint left,
broquain1 joined,
broquaint joined,
broquaint left
06:31
[particle] joined
|
|||
japhb | How do I produce a Parrot ManagedStruct/UnManagedStruct from Rakudo? Or alternately, is the Perl 6 syntax for packed native data working? | 06:36 | |
06:39
alc left
06:42
spx2 left
06:48
cpfr joined
06:54
Bzek joined
06:59
bacek_ joined
07:00
bacek__ left
07:06
zamolxes joined
07:10
DemoFreak joined
|
|||
moritz_ | ruoso: it should be recompiled by know - could you please check? | 07:13 | |
07:21
adc_Penner joined
07:22
xunxi1 joined
07:23
xunxi1 left
07:24
pbuetow joined
07:27
smg left
07:29
jauaor left
07:37
pbuetow left
07:49
ZuLuuuuuu joined
|
|||
ZuLuuuuuu | hello I guess perl 6 doesn't have a cgi or database module yet right? | 07:50 | |
07:58
alc joined
|
|||
lizsac | use the force | 08:04 | |
08:07
stephenos joined
08:09
ZuLuuuuuu left
|
|||
moritz_ | it has a basic CGI module. | 08:10 | |
08:17
alester left
08:18
Guest70230 joined
08:21
jiing_ joined
08:22
jiing left
08:48
DemoFreak left
08:57
smg joined
09:10
ashizawa joined
09:13
iblechbot joined
|
|||
ruoso | mildew: knowhow Foo { method bar { $OUT.print("Hello World!\n") } }; Foo.bar; | 09:14 | |
p6eval | mildew: No output (you need to produce output to STDOUT) | ||
moritz_ | Can't chdir to 'umask 002; ../../v6/mildew': No such file or directory at lib/EvalbotExecuter.pm line 136 | 09:16 | |
oh dang, that looks broken. | |||
09:17
p6eval left,
p6eval joined
|
|||
moritz_ | mildew: knowhow Foo { method bar { $OUT.print("Hello World!\n") } }; Foo.bar; | 09:17 | |
p6eval | mildew: OUTPUT[Can't locate object method "term__S_387identifier" via package "STD" at ../../src/perl6/STD.pm line 1041.] | ||
moritz_ | that might be a permission problem | 09:18 | |
09:19
p6eval left
09:20
p6eval joined
|
|||
moritz_ | mildew: knowhow Foo { method bar { $OUT.print("Hello World!\n") } }; Foo.bar; | 09:20 | |
p6eval | mildew: OUTPUT[Can't locate object method "term__S_387identifier" via package "STD" at ../../src/perl6/STD.pm line 1041.] | ||
09:25
ashizawa_ joined
09:26
ashizawa left
09:28
ejs joined
09:29
adc_Penner left
09:30
Alias_ is now known as adamkennedy
09:31
pmurias joined
|
|||
pmurias | moritz_: that's an old lex/ problem | 09:31 | |
moritz_ | pmurias: feel free to clean it up | ||
pmurias | moritz_: i always forget the get into the chroot incantation | 09:36 | |
09:37
elmex joined
|
|||
moritz_ | chroot /chroot iirc | 09:37 | |
09:41
alc left
09:44
pnu left
09:46
pnu joined
09:49
meppl joined
|
|||
jnthn | japhb: The packed native data stuff isn't done in Rakudo yet - not sure about how you can use the ManagedStruct / UnManagedStruct stuff from their either...need to think that one over a bit. | 09:50 | |
09:50
apeiron_ joined
09:57
apeiron left
|
|||
pmurias | milew: $OUT.print("Hello world\n"); | 09:58 | |
mildew: $OUT.print("Hello world\n"); | |||
p6eval | mildew: OUTPUT[unknown method "new" at bool_message line 33 file /home/evalenv/pugs/v6/smop/src/native_bool.c] | ||
10:02
stephenos left
|
|||
ruoso | pmurias, hi | 10:13 | |
10:18
bacek__ joined
|
|||
pmurias | ruoso: hi | 10:19 | |
ruoso | pmurias, have you seen the new code in mildew? | ||
pmurias | i'm slowly getting up an fixing the mildew in the evalbot now | 10:20 | |
mildew: $OUT.print("Hello World\n") | 10:21 | ||
p6eval | mildew: OUTPUT[Hello World] | 10:22 | |
pmurias | looking now... | ||
ruoso | mildew: knowhow Foo { method bar { $OUT.print("Hello World!\n") } }; Foo.bar; | ||
p6eval | mildew: OUTPUT[unimplemented: at mildew line 22 Mildew::XXX() called at mildew line 100 VAST::noun::emit_m0ld('VAST::noun=HASH(0xa0ab3f0)') called at mildew line 129 VAST::Terminator::emit_m0ld('VAST::Terminator=HASH(0xa1b6d70)') called at mildew line 319 | ||
..VAST::statement::emit_m0ld('VAST::... | |||
10:23
cosimo joined
|
|||
ruoso | pmurias, I think mildew evalbot is still not up-to-date | 10:23 | |
pmurias | moritz_: mildew doesn't automatically update it self | 10:24 | |
pugs_svn | r22972 | jnthn++ | [spectest] Fudge isalso/is instead tests, so we only run is also for Rakudo and don't try to parse/compile the is instead. | ||
pmurias | mildew: knowhow Foo { method bar { $OUT.print("Hello World!\n") } }; Foo.bar; | ||
p6eval | mildew: OUTPUT[Hello World!] | ||
moritz_ | pmurias: feel free to install a cron job as user 'evalenv' (in the chroot) | ||
ruoso | hmm.. much better | ||
moritz_ | I thought I installed one, but it seems I missed it, or messed it up or something. | 10:25 | |
pmurias | ruoso: we need &say as $OUT.print($var.FETCH) is nonspec and ugly | ||
ruoso | pmurias, I think we could install something like... | 10:26 | |
er... | |||
we can't | |||
we need signatures | |||
pmurias | yes | 10:27 | |
:) | |||
ruoso | I'm not sure it's a good idea to create yet another lowlevel just to see it pretty ;) | ||
pmurias, but did you notice that method installs itself by calling $?CLASS.^add_method(...)? | 10:29 | ||
pugs_svn | r22973 | pmurias++ | [mildew] Makefile for make test - i forget to add it :( | ||
10:29
tomyan joined
10:31
bacek_ left
|
|||
pmurias | ruoso: cool | 10:31 | |
ruoso: we pass 19 of our own tests now ;) | 10:36 | ||
ruoso: why did you add AST::MetaCall? | 10:38 | ||
pugs_svn | r22974 | pmurias++ | [mildew] removed AST::List | 10:39 | |
10:40
ruoso_ joined,
ruoso left
10:41
ruoso_ left,
ruoso joined
|
|||
ruoso | pmurias, take a look on how the MetaCall is emitted | 10:42 | |
by doing that way I can re-use the invocant register | 10:43 | ||
otherwise something().^add_method would result in two calls to "something()" | |||
pugs_svn | r22975 | ruoso++ | [mildew] added test_ target for different prove version | 10:44 | |
ruoso | pmurias, is it really needed to rm -rf lex everytime you run make test? | 10:45 | |
it makes it incredibly slower... | |||
pmurias | ruoso: no | 10:48 | |
pugs_svn | r22976 | ruoso++ | [mildew] refactoring the Makefile... now you have make prove which does not make clean... | ||
10:48
cookys joined
|
|||
rakudo_svn | r32525 | jonathan++ | [rakudo] Add tests for is also to spectest_regression. | 10:50 | |
ruoso | pmurias, what does prove --version outputs for you? | ||
pmurias | TAP::Harness v3.14 and Perl v5.10.0 | 10:52 | |
rakudo_svn | r32526 | moritz++ | [rakudo] add autovivification tests to spectest.data | 11:00 | |
pmurias | ruoso: we could generalise MetaCall to a evaluate this use the result in that AST node | 11:03 | |
ruoso | pmurias, maybe... but MetaCall is something special anyway... | ||
pmurias | expand please... | 11:05 | |
ruoso | the way it expands $a.^b($c) to $a.^!how.b($a,$c) is very m0ld specific | 11:06 | |
11:06
meppl left
|
|||
pmurias | shouldn't it be HOW? | 11:06 | |
11:06
Lorn joined
|
|||
pmurias | $a.HOW.b($a,$c)? | 11:06 | |
Lorn | pmurias: obfuscated in perl6? japh6? :P | 11:07 | |
pmurias | Lorn: hm? | 11:08 | |
ruoso | pmurias, except that $a.HOW is a macro | ||
HOW is not really a method | |||
$a.HOW should be translated to $a.^!how | 11:09 | ||
11:09
apeiron_ is now known as apeiron
|
|||
pugs_svn | r22977 | ruoso++ | [mildew] find out which version of prove you have and wich command switch to use | 11:10 | |
ruoso | pmurias, please test the new Makefile | ||
pmurias | why is HOW a macro? | 11:11 | |
ruoso | because the spec says so | ||
pmurias | works? | ||
s/?// | |||
ruoso: meant more why does the spec say so | |||
ruoso | because it's implementation specific | 11:12 | |
in SMOP it turns out to be a REPR method | |||
which p6opque intercepts | |||
and p6opaque only intercepts REPR methods | |||
and all REPR methods have the '^!' prefix | |||
11:13
alc joined
|
|||
pmurias | makes a bit of sense if we view $foo.bar as $foo.HOW.dispatch(...) | 11:15 | |
ruoso | except that we don't need to see it that way, because p6opaque already does that delegation | 11:16 | |
11:18
rindolf joined
|
|||
pmurias | that | 11:18 | |
's true | |||
ruoso: re elf and mildew tests what i meant i intended to have all of the p6 in the smop tests suit migrated to the mildew test suit and the elf dependency dropped | 11:19 | ||
ruoso | oh... ok | ||
anyway... have to go now... | 11:20 | ||
pmurias, if you have some time, please consider working on compiling signatures to AdhocSignature | |||
pmurias | ok | ||
ruoso | that's the thing missing so we can run ClassHOW.add_method | ||
pugs_svn | r22978 | pmurias++ | [smop] removed test 26 as we don't target pugs anymore | ||
ruoso later & | 11:21 | ||
11:46
iblechbot left
|
|||
rakudo_svn | r32527 | jonathan++ | [rakudo] Fix a couple of bugs in candidate sorting for MMD. One was an off-by-one error. The other was more subtle; we mustn't remove edges from the graph per iteration of the topological sort, otherwise we end up not identifying one candidate as narrower than another, | 11:50 | |
..depending on the order they appear in the code. | |||
r32528 | jonathan++ | [rakudo] Make the Num type also accept Int values. | |||
12:00
rindolf left
12:07
SamB left
12:12
Ontolog joined
12:14
Ontolog is now known as ChrisDavaz
12:17
ludan joined
12:23
broquain1 is now known as broquaint
|
|||
rakudo_svn | r32530 | jonathan++ | [rakudo] Must create subset types earlier (in the end at compile time, but for now moving them to $?INIT, the same time as we do classes, makes things work much better). | 12:30 | |
pugs_svn | r22979 | jnthn++ | [spectest] Fix a bug in the spectest, and fudge one test that Rakudo can't pass yet, for subset types in multiple dispatch. | 12:42 | |
r22980 | jnthn++ | [spectest] Add an explicit test that Num accepts Ints on assignment - couldn't find one that did this. | |||
12:44
SamB joined
|
|||
rakudo_svn | r32532 | jonathan++ | [rakudo] Add multi dispatch based on subset types test. | 12:50 | |
12:56
perlbot left
|
|||
pmurias | jnthn: you are jonathan? | 12:59 | |
jnthn | pmurias: I'm jonathan on #parrot :-) | 13:02 | |
But that was taken here. | |||
Well, on this server. | |||
So I'm jnthn here. | |||
13:18
z80ASM joined
13:33
iblechbot joined
|
|||
pmurias | ruoso: i'm adding an call method_name => $invocant,[@positionals],[@named] AST creation helper to mildew, does it seem sane? | 13:34 | |
13:40
abra joined,
abra left,
abra_ joined,
abra_ left
13:41
schmalbe joined
13:42
abra joined
13:58
DemoFreak joined
14:13
pedrob joined
14:17
masak joined
14:18
z80ASM left
14:23
pedrob left
|
|||
masak | rakudo: say True ?? 1 !! False ?? 2 !! 3; | 14:24 | |
p6eval | rakudo 32537: OUTPUT[2] | ||
masak | I can see how it might (mistakenly) say 2, as it does. I _don't_ see how it should say 1. | ||
I could see how it'd say 0. | |||
um. nvm. of course it should say 1. | 14:25 | ||
masak needs more coffee | |||
pmichaud | rakudo is parsing that incorrectly as (True ?? 1 || False) ?? 2 !! 3; | 14:33 | |
pugs_svn | r22981 | pmurias++ | [mildew] &call helper | 14:34 | |
masak | yes, I gathered. | ||
seems I was parsing it incorrectly, too :) | 14:35 | ||
14:46
jauaor joined
14:54
schmalbe left
14:56
Exodist joined
14:58
jhorwitz joined,
hercynium_ joined
14:59
kanru left
15:00
abra left
15:04
ejs left,
ejs_ joined
|
|||
rakudo_svn | r32541 | pmichaud++ | [rakudo]: spectest-progress.csv update: 212 files, 4199 passing, 473 failing | 15:20 | |
pugs_svn | r22982 | moritz++ | [t/spec] some unfudges for rakudo | ||
rakudo_svn | r32542 | jonathan++ | [rakudo] A while back, some changes were done that set $?CLASS when a grammar was created. But since we checked $?PACKAGE =:= $?GRAMMAR second after checking $?PACKAGE =:= $?CLASS, we stopped creating grammars properly, meaning they started inheriting from Any instead of some | 15:40 | |
..grammar rules. This switches around the ordering. Also re-fixes the bug originally fixed before this change where $?NS wasn't cleared. | |||
15:51
DemoPhreak joined
15:54
ruoso left,
smg left
|
|||
rakudo_svn | r32543 | pmichaud++ | [rakudo]: Revise r32528 so that Num::ACCEPTS (re)uses existing .ACCEPTS | 16:00 | |
16:03
aindilis` joined
16:05
DemoFreak left
16:09
stephenos joined
|
|||
masak | 's there any way to write /aa+/ without repeating 'a'? | 16:13 | |
jnthn | a**{2...} maybe? | 16:14 | |
erm, a**2... | |||
...maybe... :-) | |||
masak | doesn't currently work, anyway. | ||
jnthn | Whether it's allowed and whether it's implemented may be two different things mind. | ||
masak | ya. | 16:15 | |
jnthn | I think it's what you'd want in the long run. | ||
Could always file a ticket asking for it. :-) | |||
PerlJam | three dots == infinity? I thought you had to put a whatever-* there | ||
a**2..* | |||
(or something) | |||
jnthn | Oh, maybe | ||
I forget exactly. | |||
PerlJam | me too :) | ||
jnthn | There is some infinite range style syntax that does that kinda thingy anyway. | 16:16 | |
:-) | |||
masak | PerlJam: 2..* looks much better. | ||
and it works! | |||
PerlJam++ | |||
PerlJam | Continued affirmation that my memory works better than I expect :) | 16:17 | |
masak will try to remember that :) | |||
16:19
ejs_ left
16:21
ejs_ joined
16:24
adamkennedy left
16:25
bacek_ joined
16:26
aindilis` left,
bacek__ left
16:27
rindolf joined,
aindilis left
16:28
justatheory joined
|
|||
rakudo_svn | r32545 | jonathan++ | [rakudo] Make C compiler shut up with its warnings. Spotted by masak++. | 16:30 | |
masak | rakudo: for "foo\nbar\nbaz".split( /\n ** 2..*/ ) { .say } | ||
p6eval | rakudo 32543: OUTPUT[foobarbaz] | ||
masak | um, bad example. :) | ||
moritz_ | but done right ;) | 16:31 | |
masak | rakudo: for "foo\nbar\nbaz".split( /\n ** 2..*/ ) { .say; say } | 16:32 | |
p6eval | rakudo 32543: OUTPUT[foobarbaz] | ||
masak | hah! | ||
izzat a bug I see? | |||
no, wait. | |||
moritz_ | where do you see a bug? | ||
masak | that's right too. | ||
pmichaud | hah! | ||
jnthn is struggling to see it. | |||
masak | I'm too trigger happy today... | 16:33 | |
moritz_ | cought the ticket before it left masak's head ;) | ||
masak | ...but now I've found something. seriously! | 16:35 | |
rakudo: say "foo\nbar\nbaz".trans([ /\s+/ => " " ]) | |||
p6eval | rakudo 32543: OUTPUT[foo bar baz] | 16:36 | |
masak | all good, yes? | ||
now look: | |||
rakudo: for "foo\nbar\nbaz".split( /\n ** 2..*/ ) { say .trans([ /\s+/ => " " ]) } | |||
p6eval | rakudo 32543: OUTPUT[too few arguments passed (2) - 3 params expectedcurrent instr.: '_block25' pc -342568903 ((unknown file):-1)] | ||
masak | HAH! | ||
masak files ticket | |||
jnthn tries to work out what on earth could have wanted 3 params.. | 16:37 | ||
masak | jnthn: the .trans | 16:38 | |
pmurias | jnthn: what arguments does postcircumfix:<( )> take in rakudo? | ||
pmichaud | rakudo: say "foo\nbar\nbaz".split( /\n ** 2..*/ ).WHAT; | 16:39 | |
p6eval | rakudo 32543: OUTPUT[List] | ||
pmichaud | rakudo: say "foo\nbar\nbaz".split( /\n ** 2..*/ ).elems; | 16:40 | |
p6eval | rakudo 32543: OUTPUT[1] | ||
masak | as should be. | ||
pmichaud | rakudo: for "foo".split( /\n ** 2..*/ ) { .say } | ||
p6eval | rakudo 32543: OUTPUT[foo] | ||
pmurias | jnthn: does it receive a capture or are the arguments passed as parts of the capture | ||
pmichaud | rakudo: for "foo".split( /\n ** 2..*/ ) { $_.trans( [ /o/ => ' ' ] ) } | 16:41 | |
p6eval | rakudo 32543: OUTPUT[too few arguments passed (2) - 3 params expectedcurrent instr.: '_block25' pc -342600339 ((unknown file):-1)] | ||
moritz_ | pmurias: rakudo doesn't have any postcircumfix methods or subs yet that are actually user visible | ||
pmichaud | rakudo: for "foo".split( /\n ** 2..*/ ) { $_.trans( [ 'o' => ' ' ] ) } | ||
p6eval | rakudo 32543: OUTPUT[too few arguments passed (2) - 3 params expectedcurrent instr.: '_block25' pc -342566453 ((unknown file):-1)] | ||
pmichaud | rakudo: for "foo".split( /\n ** 2..*/ ) { .say.WHAT } | ||
p6eval | rakudo 32543: OUTPUT[foo] | ||
pmichaud | rakudo: for "foo".split( /\n ** 2..*/ ) { say $_.WHAT } | ||
p6eval | rakudo 32543: OUTPUT[Str] | ||
jnthn | pmurias: What moritz said. But calls boil down to the invoke VTABLE method. | ||
moritz_ | rakudo: for "foo".split( /\n ** 2..*/ ) { say $_.trans( [ 'o' => ' ' ] ) } | 16:42 | |
p6eval | rakudo 32543: OUTPUT[too few arguments passed (2) - 3 params expectedcurrent instr.: '_block25' pc -342579023 ((unknown file):-1)] | ||
pmichaud | rakudo: "foo".split( /\n ** 2..*/ )[0].trans( [ 'o' => ' ' ]); | 16:43 | |
p6eval | rakudo 32543: OUTPUT[too few arguments passed (2) - 3 params expectedcurrent instr.: '_block11' pc -342477533 ((unknown file):-1)] | ||
pmichaud | rakudo: "foo".split( /\n ** 2..*/ ).[0].trans( [ 'o' => ' ' ]); | ||
p6eval | rakudo 32543: OUTPUT[too few arguments passed (2) - 3 params expectedcurrent instr.: '_block11' pc -342450071 ((unknown file):-1)] | ||
jnthn | I think that you'd be able to make postcircumfix:<( )> take things into a capture, though. | ||
pmichaud | oh, I see the issu | ||
issue | |||
jnthn | pmurias: We don't explicitly construct a capture right now. | ||
pmichaud | the strings that come back from PGE aren't Perl6Str | ||
jnthn | Ah. | 16:44 | |
pmichaud | so it's calling the .trans method in (Parrot) String instead of (Perl 6) Str | ||
jnthn | The Parrot string has a trans method? | ||
jnthn didn't know that | |||
Makes sense though. | |||
pmichaud | METHOD trans(STRING *src, PMC *table) { | ||
masak | pmichaud: is it easy to fix? | 16:45 | |
pmichaud | masak: not at the moment. | ||
jnthn | Needs HLL. :-( | 16:46 | |
pmichaud | we need to get HLL type mapping in place. | ||
masak | oh well. | ||
pmichaud | and then PGE will have to become smart enough to do that mapping. | ||
jnthn | pmichaud: I forgot what that blocked on? Or is it just tuits? | ||
masak will try to work around it somehow | |||
pmichaud | tuits, I think | ||
masak: try prefix:<~> | |||
masak | pmichaud: I will, thx | 16:47 | |
16:47
cosimo left
|
|||
pmurias | jnthn: postcircumfix:<( )> takes a capture in smop and spec currently | 16:47 | |
pmichaud | rakudo: for "foo".split( /\n ** 2..*/ ) { (~$_).trans( [ 'o' => ' ' ] ) } | ||
p6eval | rakudo 32545: OUTPUT[too few arguments passed (2) - 3 params expectedcurrent instr.: '_block25' pc -342619037 ((unknown file):-1)] | ||
pmichaud | we may need to fix prefix:<~> to always return Perl6Str | ||
(won't be necessary after HLL mapping, though.) | 16:48 | ||
jnthn | pmurias: Sure, that makes sense. | ||
japhb | jnthn: oh bother (re: packed data and (Un)ManagedStruct difficulties) ... that's going to make life ... interesting. Hmmm, is there a Perl 6 pack()/unpack() pair yet? I could go from that angle. | ||
jnthn | No, I think not. | 16:49 | |
pmichaud | we can certainly write a pack()/unpack() or other helper function for it. | 16:50 | |
rakudo_svn | r32546 | jonathan++ | [rakudo] Make grammars in namespaces work correctly. Patch courtesy of Chris Dolan. | ||
r32547 | jonathan++ | [rakudo] Add a namespace/grammar related spectest file. | |||
r32548 | pmichaud++ | [rakudo]: fix trailing space | |||
jnthn looks at what doing the managedstruct stuff the real way from Perl 6 would take. | 16:51 | ||
Ouch. | 16:52 | ||
japhb: Actually implemetning what's under the heading Compact Structs in S09 is a bit of work. | 16:53 | ||
There's a bunch of stufff I've not really thought about so much yet. | 16:54 | ||
japhb | jnthn: I believe it. | ||
pmichaud: how much work would it be to do the pack()/unpack()? | |||
pmichaud | japhb: I don't know how well pack/unpack are defined for Perl 6 yet (more) | ||
pmurias | jnthn: it was a thing we were unsure about for a bit, and i was having doubts again for a moment about it while implementing .() ;) | 16:55 | |
16:55
pmurias left
|
|||
pmichaud | japhb: however, in this particular case you might look at writing a custom pair of functions to do it and importing those | 16:55 | |
japhb: I'm not completely familiar with ManagedStruct under Parrot (nevr had a use or need for it) | |||
jnthn | pmichaud: It lets you construct a C-level struct, dynamically. | 16:56 | |
16:56
alester joined
|
|||
japhb | OR array, or combination of the two | 16:56 | |
pmichaud | jnthn: sure, I've just never used it. | ||
jnthn | It'll probably be somewhat involved when we do compact structs in Rakudo. | ||
Really we don't have any of the native types exposed at Rakudo level at all yet though. | 16:57 | ||
japhb | It basically shows a normal keyed interface as if it wasn't packed, but marshals magically through NCI to/from the packed equivalents. | ||
jnthn | Which is really a pre-req. | ||
japhb | Parrot will need to finally admit its native type system is lacking when you have to do the Perl version. Unless you just tell Parrot it's a buffer of bytes and back the heck off, thankyouverymuch. | 16:58 | |
16:58
zamolxes left
17:03
ejs_ left
17:04
ejs_ joined
17:05
ashizawa_ left
17:07
abra joined,
schmalbe joined
17:15
masak left
17:16
zamolxes joined
17:20
ludan left
17:24
smg joined
17:30
apeiron left
17:31
apeiron joined
17:40
ejs_ left
17:45
tomyan left
17:48
pbuetow joined
17:50
meppl joined
|
|||
meppl | good evening | 17:51 | |
japhb | jnthn, pmichaud: Is there a way to specify constants in a separate module in Rakudo, and after 'use FooConstants;' have them participate in any optimizations that literal constants would have? | 18:04 | |
18:05
abra left
|
|||
japhb | jnthn: what signature are you planning for the simplified MAIN? | 18:09 | |
jnthn | japhb: Not that I know of - we don't have "is constat" implemented yet, either, though... | 18:12 | |
japhb | Fair enough. | ||
TimToady | there is no "is constant" that I know of... | 18:13 | |
jnthn | Simplified MAIN will just pass the command line args along. If you've written a MAIN that takes that many positional arguments, you'll get that one (of course declare multi if you're doing that to write many) | ||
TimToady | there's a constant declarator though | ||
jnthn | That's all I'm doing for now - this is really Jerry's turf. :-) | ||
japhb | TimToady: Either you read everything that goes by here, or you've got a very fine sixth sense .... | ||
TimToady | the two are not mutually exclusive :) | 18:14 | |
japhb | True. | ||
But I meant that in the math 'or' sense, not the English bastardization. | |||
PerlJam | TimToady: Tell the truth. You didn't really get *ordinary* corneas, did you? You're really a cyborg now. | 18:15 | |
TimToady | will that MAIN break badly when named args get mapped to *% params? | ||
japhb | jnthn: So if I want to ignore all, can I declare 'sub MAIN { ... }', and to catch all just do 'sub MAIN (*@args) {...}' | ||
TimToady | I don't know who my (one) cornea came from, but both my lenses are plastic, though different from each other | 18:16 | |
jnthn | Yes, that should work, apart from slurpy may be broken at the moment. | ||
TimToady | with slightly different transmission of near UV | ||
japhb | jnthn: oh. | ||
TimToady | so my black lights look violeter in one eye than the other | ||
japhb | Will @*ARGS still be visible, at least, if slurpy args are broken? | ||
jnthn | japhb: Yes. | ||
japhb | TimToady: freaky. and cool. | ||
PerlJam | TimToady: ah ... only one cornea, eh? So the other eye has the device that links you directly to the internet? :) | 18:17 | |
japhb | jnthn: great, thanks. | ||
jnthn | TimToady: It's not meeting the spec for sure. :-) | ||
TimToady | maybe it should be called NOTMAIN or something :) | ||
jnthn | TimToady: particle's grant covers doing that, I'm just getting japhb something simple to work with for now. | ||
japhb | Somebody is getting paid well to make it correct .... | ||
jnthn | Right. | ||
18:21
justatheory left
|
|||
jnthn | I'm sure particle is going to be happy to find we already have introspectable signatures when he gets to doing it. :) | 18:24 | |
18:24
justatheory joined
18:26
adc_Penner joined
18:34
Bzek left
18:37
rindolf left
18:38
rindolf joined
18:40
bacek_ left,
bacek joined
18:42
ZuLuuuuuu joined
18:47
px_ joined
18:56
apeiron left
18:57
pbuetow left
|
|||
pugs_svn | r22983 | moritz++ | [t/spec] test for rakudo regression (Num += Int) | 19:00 | |
19:02
DemoPhreak is now known as DemoFreak
19:20
bacek left
19:29
alexn_org joined
|
|||
rakudo_svn | r32551 | chromatic++ | [Rakudo] Tidied some code in Perl6MultiSub PMC. No functional changes. | 19:30 | |
r32552 | chromatic++ | [Rakudo] Added sub name to multidispatch failure message in Perl6MultiSub PMC. | |||
19:34
jfredett left
19:39
schmalbe left
19:45
xinming_ joined,
xinming left
|
|||
rakudo_svn | r32554 | jonathan++ | [rakudo] Some very basic support for MAIN entry point sub. Just passes all command line arguments as positionals. | 19:50 | |
r32555 | pmichaud++ | [rakudo]: Don't do tailcalls for methods called from C. (jonathan++) | |||
19:56
apeiron joined
20:03
Lorn left
20:25
lisppaste3 left
20:26
lisppaste3 joined
20:29
masak joined
20:30
alc left
20:43
pedrob joined
20:49
solar_Ant joined
21:12
rindolf left
21:19
ruoso joined
21:21
ab5tract joined
|
|||
ruoso | Hello! | 21:22 | |
masak | ruoso: y0 | 21:24 | |
21:27
Limbic_Region joined
21:31
rdice joined
21:35
masak left
21:40
rdice left,
rdice joined
21:50
jhorwitz left
21:58
alexn_org left
22:01
ruoso left
22:15
rdice left
22:17
ruoso joined
22:19
smg left,
ab5tract left
22:32
nacho_ joined
22:34
adc_Penner left
|
|||
rakudo_svn | r32567 | jonathan++ | [rakudo] Set scope to $?FOO type variables to be lexical, and set up $?PACKAGE. Gives wrong stringification for root namespace for now (should be Main), but should be correct otherwise. | 22:40 | |
22:57
pedrob left
|
|||
ruoso | @tell pmurias we have some leaks in smop again | 23:05 | |
lambdabot | Consider it noted. | ||
23:11
solar_Ant left
23:16
iblechbot left
23:22
wknight8111 joined
|
|||
pugs_svn | r22984 | ruoso++ | [smop] now we have s1p_package... | 23:26 | |
r22984 | ruoso++ | [mildew] a package declarator defines $?PACKAGE as well.. | |||
23:27
bacek joined
23:32
ChrisDavaz left
23:37
DemoFreak left
|
|||
ruoso | perl6: class Foo { method bar { say $?PACKAGE{"&bar"} }; Foo.bar; | 23:37 | |
p6eval | rakudo 32567: OUTPUT[Missing '}' at line 1, near ""current instr.: 'parrot;PGE;Util;die' pc 129 (runtime/parrot/library/PGE/Util.pir:83)] | ||
..pugs: OUTPUT[***  Unexpected end of input expecting ";" or "}" at /tmp/0OFp7ei77f line 2, column 1] | |||
..elf 22847: OUTPUT[Parse error in: /tmp/z1VU4wxGBTpanic at line 1 column 58 (pos 58): Missing right braceWHERE: $?PACKAGE{"&bar"} }; Foo.bar;WHERE: /\<-- HERE STD_red/prelude.rb:99:in `panic' STD_red/std.rb:255:in `_block_rest' STD_red/std.rb:242:in `block in | |||
..... | |||
ruoso | pugs: class Foo { method bar { say $?PACKAGE.{"&bar"} }; Foo.bar; | ||
p6eval | pugs: OUTPUT[***  Unexpected end of input expecting ";" or "}" at /tmp/8ysX0Fyl6p line 2, column 1] | ||
pugs_svn | r22985 | lwall++ | [Cursor] revert last; fix because it breaks !~~ and friends | ||
ruoso | pugs: class Foo { method bar { say $?PACKAGE }; Foo.bar; | 23:38 | |
p6eval | pugs: OUTPUT[***  Unexpected end of input expecting ";" or "}" at /tmp/XmMlwHsOOi line 2, column 1] | ||
ruoso | pugs: class Foo { method bar { say $?PACKAGE.{"&bar"} }}; Foo.bar; | ||
p6eval | pugs: OUTPUT[*** Class prototype occured where its instance object expected: Foo at /tmp/1h650RWtpl line 1, column 30-49 /tmp/1h650RWtpl line 1, column 30-49] | ||
ruoso | pugs: class Foo { method bar { say $?PACKAGE.{"&bar"} }}; Foo.new.bar; | ||
p6eval | pugs: OUTPUT[*** Class prototype occured where its instance object expected: Foo at /tmp/Vxzh3iqQFt line 1, column 30-49 /tmp/Vxzh3iqQFt line 1, column 30-49] | ||
ruoso | pugs: class Foo { method bar { say $?PACKAGE<&bar> }}; Foo.new.bar; | ||
p6eval | pugs: OUTPUT[*** Class prototype occured where its instance object expected: Foo at /tmp/EA7OWfTrjn line 1, column 30-46 /tmp/EA7OWfTrjn line 1, column 30-46] | ||
ruoso | er | ||
are methods registered in the package as well as in the class? | 23:39 | ||
pugs: class Foo { method bar { say $?PACKAGE }}; Foo.new.bar; | |||
p6eval | pugs: OUTPUT[Foo] | ||
ruoso | pugs: class Foo { method bar { say $?PACKAGE.new }}; Foo.new.bar; | ||
p6eval | pugs: OUTPUT[<obj:Foo>] | ||
TimToady | depends on whether they're our or my methods | 23:40 | |
our is the default | |||
ruoso | right... but I was considering if they would only be in the class | ||
TimToady | it is possible that some declarations that currently default to our should default to my instead | 23:42 | |
ruoso | I wonder what is the use for methods being stored in package | 23:43 | |
*packages | |||
23:45
rhr left
|
|||
ruoso | TimToady, I understand the generalization of every routine being stored in the package, but does that really applies to methods? | 23:46 | |
23:47
alester left
23:48
aindilis joined
23:49
smg joined
23:53
ZuLuuuuuu left
|