pugscode.org/ | nopaste: sial.org/pbot/perl6 | pugs: [~] <m oo se> (or rakudo:, kp6:, smop: etc.) || We do Haskell, too | > reverse . show $ foldl1 (*) [1..4] | irclog: irc.pugscode.org/ Set by TimToady on 25 January 2008. |
|||
00:00
chris2 left
|
|||
Auzon | rakudo: class Foo does Bar {} | 00:04 | |
p6eval | rakudo r28205 No output (you need to produce output to STDOUT) | ||
00:14
bacek joined
00:15
bsb joined
00:19
[particle]1 joined
00:26
silug left
00:28
[particle] left
00:29
cmarcelo left
00:30
silug joined
00:42
Eevee joined
00:48
[particle]1 left
00:55
japhb joined
01:03
mncharity joined
|
|||
Auzon | perl6: say 0 but Bool::True | 01:10 | |
01:10
p6eval left
|
|||
Auzon | boom. heh. | 01:10 | |
01:10
p6eval joined
|
|||
mncharity | more tests needed :) | 01:15 | |
Auzon wonders which one failed | 01:17 | ||
Parrot, it seems | 01:18 | ||
pmichaud | rakudo: say 0 but Bool::True # probably parse error. | ||
p6eval | rakudo r28205 No output (you need to produce output to STDOUT) | ||
Auzon | pugs: say 0 but Bool::True | ||
p6eval | OUTPUT[*** Cannot cast from VBool True to Pugs.AST.Internals.VCode (VCode) at Prelude.pm line 541, column 5-16] | ||
Auzon | elf: say 0 but Bool::True | ||
01:18
p6eval left
|
|||
pmichaud | :-) | 01:18 | |
Auzon | The question is why elf is blowing it up | ||
01:18
p6eval joined
|
|||
mncharity | * (defun ☺ () "SBCL rocks!") * (☺) #=> "SBCL rocks!" | 01:19 | |
01:19
Limbic_Region left
|
|||
mncharity | I just love SBCL. It's great when unicode support is real. | 01:19 | |
re elf, let's see... | 01:20 | ||
Auzon | I'm curious why any eval can crash the bot | 01:21 | |
Because it runs it in a system call | |||
mncharity | elf: ) | ||
p6eval | OUTPUT[Parse error in: /tmp/LThPhNwuxDpanic at line 1 column 0 (pos 0): Can't understand next input--giving upWHERE: )WHERE:/\<-- HERE STD_red/prelude.rb:98:in `panic' STD_red/std.rb:76:in `scan_unitstopper' STD_red/std.rb:224:in `comp_unit' STD_red/std.rb:210:in `_UNIT' | ||
.../../STD_red/STD_red_run:108:in `main' ./../STD_red/STD_red_... | |||
Auzon | maybe it's something with BSD::Resource or some such | 01:22 | |
evalbot control restart | |||
01:22
p6eval left
|
|||
Auzon | elf: say 0 but Bool::True | 01:22 | |
01:22
p6eval joined
|
|||
mncharity | elf: $x | 01:22 | |
p6eval | OUTPUT[Global symbol "$x" requires explicit package name at (eval 14) line 3. at ./elf_f_faster line 4492] | ||
Auzon | elf: say 0 but Bool::True | ||
01:22
p6eval left
|
|||
Auzon | hm, nope | 01:22 | |
mncharity | So it's not the exit() code. | ||
01:22
p6eval joined
|
|||
Auzon | evalbot control restart # to be sure | 01:23 | |
01:23
p6eval left,
p6eval joined
|
|||
Auzon | oh | 01:23 | |
I didn't edit that on the server, I edited it locally | |||
Auzon is apparently braindead | |||
mncharity | seems unlikely ;) | 01:24 | |
Auzon | I'll be back later when I have a better idea | ||
mncharity | Any folks around who do CL? | 01:27 | |
am sooo tempted to start a SBCL backend... | 01:28 | ||
01:29
Ched- joined
|
|||
mncharity | which would raise the question of "kludge straight to bootstrap", or something more principled. | 01:30 | |
or both :) | |||
01:32
cjfields joined
|
|||
diakopter | mncharity: I'm interested to learn it. | 01:33 | |
though I'm not sure that helps you much :) | 01:35 | ||
01:36
cjfields left
01:37
cjfields joined,
xinming_ left
|
|||
mncharity | tamarin would be nifty, but doesn't seem quite ready for primetime... and might have to tweak JavaScripdt::SpiderMonkey to work iwth it... but js 1.7 or 1.8 could be fun, though not a speedup... :/ | 01:38 | |
diakopter: does :) indicates presence of interest... | 01:39 | ||
doesn't seem plausible to attempt anything statically typed at this point... | 01:40 | ||
at least for bootstrap. might perhaps compile down "lots of function calling", eg, parser, to Inline::C... | 01:41 | ||
Yay! Someone has done a tcc module. search.cpan.org/~hamano/C-TCC-0.03/lib/C/TCC.pm :) ! Wait enough years, and thigns decay off your todo list. | 01:44 | ||
lambdabot | Title: C::TCC - An interface to the TCC(Tiny C Compiler) - search.cpan.org | ||
mncharity | Aside from fast compile, is it lets you compile and link C code _without touching disk_. | 01:45 | |
research.sun.com/projects/lively/ squeak's morphic in js :) | 01:47 | ||
lambdabot | Title: Sun Labs Lively Kernel | ||
mncharity | hotruby.accelart.jp/ anyone want to implement some p5 vm instructions in js? :) | 01:49 | |
lambdabot | Title: HotRuby - Ruby on JavaScript & Flash | ||
mncharity | Auzon: re "So it's not the exit() code.", err, no. I tested the wrong thing. Forgot that evalbot wraps the code. So I've no data. | 01:58 | |
01:58
xinming joined,
SCalimlim left
|
|||
diakopter | anyone here going to YAPC::NA this year? | 02:00 | |
02:06
[particle] joined
|
|||
pmichaud | <- going to yapc::na. | 02:06 | |
02:13
drbean joined
02:21
[particle]1 joined
02:26
cjfields left
02:30
[particle] left
02:34
[particle]1 left
02:35
cjfields joined,
cjfields left,
cjfields joined
02:48
[particle] joined
|
|||
pugs_svnbot | r20735 | putter++ | [elf] Permit non-perl5 backends. | 02:50 | |
02:51
cjfields left
02:53
cjfields joined
|
|||
pugs_svnbot | r20736 | putter++ | [elfish/on_sbcl] Start of an SBCL elf backend. | 02:57 | |
03:02
kanru joined
|
|||
mncharity | perl6: :a<b c d> | 03:11 | |
p6eval | kp6 r20736: OUTPUT[syntax error at position 0, line 1 column 0::a<b c d^ HERE] | ||
..pugs: RESULT[("a" => ("b", "c", "d"))] | |||
..rakudo r28205: No output (you need to produce output to STDOUT) | |||
..elf r20736: OUTPUT[Unquoted string "d" may clash with future reserved word at (eval 14) line 3.Can't locate object method "b" via package "c" (perhaps you forgot to load "c"?) at (eval 14) line 3. at ./elf_f_faster line 4496] | |||
mncharity | pugs: :a<<a b c>> | 03:12 | |
p6eval | RESULT[("a" => ("a", "b", "c"))] | ||
mncharity | pugs: :a'a b c' | ||
p6eval | OUTPUT[***  Unexpected "'" expecting word character, dot, block construct, "(", "[", "<<", "<", "\171", term postfix or operator at /tmp/OAJAhUpBv9 line 1, column 3] | ||
mncharity | pugs: :a<'a b c'> | ||
p6eval | RESULT[("a" => ("\'a", "b", "c\'"))] | ||
spinclad | mncharity: have done maclisp, T, and scheme, and paid some attention to CL beginnings; it's at least not a foreign tongue. (way behind on reading LtUltimate.) | 03:18 | |
svn up... | 03:19 | ||
rakudo_svn | r28221 | pmichaud++ | [rakudo]: | 03:23 | |
r28221 | pmichaud++ | * Add 'return'. Only works for single-element values at the moment -- | |||
r28221 | pmichaud++ | returning lists and named elements will be available shortly. | |||
r28221 | pmichaud++ | | |||
03:28
cognominal_ left
03:34
eternaleye joined
|
|||
diakopter | erm | 03:36 | |
TimToady | svn bot seems down though... | 03:44 | |
pugs_svnbot | r20737 | lwall++ | [STD5] EXPR finally unbroken again after refactorot | 03:45 | |
TimToady | er, nevermind... | ||
diakopter | TimToady: so apparently I need to memoize coderefs in order to convert this rd parser from geometric time to linear time... | 03:51 | |
pugs_svnbot | r20738 | putter++ | [elfish/on_poly] Created. A "bulk creation of backends" thought experiment. A placeholder - little here yet. | ||
diakopter foresees symbol table hackage | |||
mncharity | spinclad: :) | 03:52 | |
pugs_svnbot | r20739 | cjfields++ | Set up trans.t for rakudo testing | 03:54 | |
mncharity | re 'svn up'... doesn't do much yet. just hacked it to take 'sub f($x){say $x+3} f(4)' and print 7. Mostly just getting the setup in place. | 03:55 | |
03:58
alc joined
|
|||
mncharity | spinclad: re scheme, on my todo list after 'full bootstrap with STD_red translated into p6 and absorbed into elf, and elf running on at least two backends', is to start pushing on frontends. First a js, but then a scheme. Thinking of bigloo, just because it has a regexp-like reader design. | 04:03 | |
but if someone was interested in pursuing it, we could start sooner, even now. | 04:04 | ||
re T, shudder. Worked on overhauling the T manual years ago. Became a "if the client asks for something insane, push back or leave" life lesson. | 04:06 | ||
re 'er, nevermind...', :) | 04:12 | ||
04:12
cjfields left
|
|||
mncharity | end of day. good night all & | 04:13 | |
04:13
mncharity left
04:14
alanhaggai joined
|
|||
pugs_svnbot | r20740 | lwall++ | [STD] radix numbers should allow embedded underscores | 04:15 | |
04:17
kst joined
04:19
alanhaggai left
|
|||
spinclad | re T, an interesting dialect in its day. enjoyed looking around its innards; strange and different and interesting. | 04:24 | |
its compiler reminded me a lot of GLS's Rabbit. | 04:25 | ||
04:34
rafl left,
rafl joined
|
|||
spinclad | @message cjfields re r20739, did you check in a fudged version? please just add #?rakudo comments... | 04:45 | |
lambdabot | Maybe you meant: messages messages? | ||
spinclad | @tell cjfields re r20739, did you check in a fudged version? please just add #?rakudo comments... | ||
lambdabot | Consider it noted. | ||
05:04
nipotan is now known as nipotaway
05:21
wknight8111 left
05:29
eternaleye left
05:30
cognominal_ joined
05:38
meppl joined
05:51
bacek_ joined
05:52
nipotaway is now known as nipotan
05:59
bnjmn-- joined
06:08
bacek left
06:21
alc left
06:23
iblechbot joined
06:24
Psyche^ joined
06:35
Patterner left,
Psyche^ is now known as Patterner
06:55
rindolf joined
|
|||
diakopter | anyone around? | 06:59 | |
rindolf | Hi diakopter | ||
moritz_ | diakopter: no ;) | ||
pugs_svnbot | r20741 | diakopter++ | [yap6] | ||
r20741 | diakopter++ | - Added new non-terminal parser constructors: | |||
07:00
pugs_svnbot joined
|
|||
diakopter | drat. I just wanted to show off my last commit - dev.pugscode.org/changeset/20741 | 07:00 | |
lambdabot | Title: Changeset 20741 - Pugs - Trac | 07:01 | |
diakopter | again, commit msg too long :[[[ | ||
moritz_ | uhm, maybe pugs_svnbot stops at empty lines | ||
diakopter | there wasn't an empty line | ||
moritz_ | or whitespace-only lines | 07:02 | |
diakopter | see perlcabal.org/svn/pugs/revision/?rev=20741 | ||
lambdabot | Title: revision: /pugs (Rev: 20741, via SVN::Web) | ||
07:02
iblechbot left
|
|||
diakopter | there wasn't a whitespace-only line | 07:02 | |
moritz_ | well, dev.pugscode.org/changeset/20741 shows empty lines | ||
lambdabot | Title: Changeset 20741 - Pugs - Trac | ||
diakopter | no it doesn't; it's blockquoting the indented areas | 07:03 | |
moritz_ | ok | 07:04 | |
diakopter | anyway, the nthru operator overloads symbol "..." | ||
oh, and match() will take qr// patterns and match them against input | 07:05 | ||
which will offer very easy shortcut creation for helping one() rule out branches quickly | 07:06 | ||
where one() is the old alternate() | |||
07:06
justatheory left
|
|||
diakopter | btw, I realized that backtracking recursive descent parsers like this one already do LTM, as long as you write your grammar correctly. the branch that matches the entire input wins. you just have to make all your recursive nonterminals right-recursive instead of left. Though tonight I will think about how to write a parser constructor to help you with that. | 07:09 | |
pugs_svnbot | r20742 | lwall++ | [STD5] can now parse radix.t | ||
moritz_ | can parse radix.t - is that a good or a bad sign? ;-) | ||
diakopter | also you have to specify as greedy things that should be greedy. | ||
moritz_ | (given the current shape of our test suite, that is ;) | ||
diakopter | oh, and, the memoizing is essentially constructing a DFA as it goes... | 07:10 | |
TimToady | it's more than STD5 was ever able to parse before, so I think it's good | ||
moritz_ | diakopter: why are you non-greedy by default? | ||
ok TimToady++ | |||
diakopter | moritz_: b/c you can't be greedy by default...? I mean, what if a repeated pattern signifies the start of a new pattern | 07:11 | |
moritz_ | diakopter: example? | ||
diakopter | well, in writing the grammar you're specifying legal input as well as writing parsing instructions. | 07:12 | |
so you don't want to allow repeated patterns where the language doesn't allow them.. like } at the end of a block - you don't want to have it accept an unbalanced extra } | 07:13 | ||
oh, sorry; I meant a different greedy | 07:14 | ||
moritz_ | in which case you wouldn't use a quantifier at all, which makes the distinction between "greedy" and "non-greedy" useless | ||
ah ok | |||
diakopter | to restate, I meant to say that where a pattern can be recursive, the other things inside it should be as greedy as possible, to prevent non-LTM | 07:16 | |
in other words, make sure the grammar covers all possible legal syntax :D | |||
in other words, write a correct grammar | 07:17 | ||
heh | |||
moritz_ | ;) | ||
diakopter | bed->() | 07:18 | |
er, couch->() | 07:19 | ||
07:41
cookys left
07:42
Ched- left
07:45
elmex joined
07:50
jiing_ joined,
Jedai joined
07:53
masak joined
07:59
rindolf left
08:04
IllvilJa left
08:30
iblechbot joined
08:32
IllvilJa joined
08:39
cookys joined
|
|||
moritz_ | Auzon, pmichaud, [particle]: I won't be able to attend our meeting tomorrow, so I pre-typed my report: irclog.perlgeek.de/perl6-soc/2008-06-10#i_339985 | 08:43 | |
lambdabot | Title: IRC log for #perl6-soc, 2008-06-10 | ||
08:45
alanhaggai joined,
pmurias joined
08:52
meppl left
08:57
Jedai left,
Jedai joined
09:04
bacek_ left
09:18
jiing_ left
09:25
chris2 joined
09:40
Chillance joined
09:44
alanhaggai left
09:52
drbean left,
drbean joined,
Lorn_ left
09:56
alanhaggai joined
09:58
nipotan is now known as nipotaway
09:59
IllvilJa left
10:04
Jedai left
10:08
[particle] left
|
|||
masak | is it `say $a;` or `say $a:;`? | 10:17 | |
ah, the former, probably, because 'say' is a sub | 10:18 | ||
10:18
alanhaggai_ joined
|
|||
masak | could I call a private method with `self.mthd()`? | 10:20 | |
masak is re-reading S12 | |||
audreyt | no, you need to use self! | ||
S12:348 | |||
er, I mean, `self!`. | 10:21 | ||
10:31
alanhaggai left
10:38
bacek joined
10:43
alanhaggai_ is now known as alanhaggai,
jan_ left
10:44
jan_ joined
10:45
jan__ joined
10:52
jan_ left
|
|||
bacek | rakudo: say 'hello' | 11:13 | |
p6eval | rakudo r28205 No output (you need to produce output to STDOUT) | ||
bacek requesting make realclean for evalbot :) | 11:14 | ||
moritz_ charges bacek 10 EUR for his request | |||
realclean is fast, it's the parrot rebuild that takes its time | 11:17 | ||
pmichaud | good morning, all | ||
moritz_ | if most of it was used by gcc I'd consider iinstalling ccache on that machine, but it seems much of the time is used by perl scripts | ||
good localtime pmichaud ;) | 11:18 | ||
bacek | good evening, pmichaud | 11:25 | |
11:26
Jedai joined
|
|||
moritz_ is offline for a few days. TTFN, I expect christmas on my return ;) | 11:26 | ||
bacek | moritz_, how is your yesterday exam? 6 month in jail for cheating? | 11:27 | |
pmichaud | I just gave a return a few hours ago :-) | ||
bacek | pmichaud, yes, it's all your fault :) | 11:28 | |
moritz_ | bacek: I got an A (when translated to english/american grades) | ||
bacek | moritz_, do you use 1-5 and you've got 5? | 11:29 | |
pmurias | the use 5-1 | ||
moritz_ | bacek: 1 to 6, and got 1 | ||
pmurias | * they use 6-1 | ||
moritz_ | but 5 and 6 are both failed so it doesn't really matter | ||
bacek | moritz_, :) Congratulations anyway | 11:30 | |
moritz_ | bacek: thanks | ||
bacek got last exam about 10 year ago... | |||
11:32
alc joined
11:39
IllvilJa joined
|
|||
bacek | rakudo: my $pi = 3.141592653589793238; say cis(3*$pi / 2); | 11:40 | |
p6eval | rakudo r28225 OUTPUT[-1.83691e-16-1i] | ||
bacek | rakudo: say 1i; | ||
p6eval | rakudo r28225 OUTPUT[0+1i] | ||
bacek | rakudo: my $pi = 3.141592653589793238; say abs(cis(3*$pi / 2) - 1i); | 11:42 | |
p6eval | rakudo r28225 OUTPUT[2] | ||
bacek | rakudo: say 4.unpolar(0) | 11:48 | |
p6eval | rakudo r28225 OUTPUT[Method 'unpolar' not found for invocant of class 'Int'current instr.: '_block11' pc 38 (EVAL_12:19) | ||
11:55
chris2 left
12:04
wknight8111 joined
|
|||
bacek | rakudo: say 4.0.unpolar | 12:08 | |
p6eval | rakudo r28226 OUTPUT[too few arguments passed (1) - 2 params expectedcurrent instr.: 'parrot;Num;unpolar' pc 1313 (src/gen_builtins.pir:991) | ||
bacek | rakudo: say 4.0.unpolar(0) | ||
p6eval | rakudo r28226 OUTPUT[4+0i] | ||
bacek | perl6: say unpolar(4.0, 0) | 12:13 | |
p6eval | kp6 r20742: OUTPUT[syntax error at position 11, line 1 column 11:say unpolar(4.0, 0 ^ HERE] | ||
..pugs: OUTPUT[*** No such subroutine: "&unpolar" at /tmp/CjfuV9yE3a line 1, column 5 - line 2, column 1] | |||
..rakudo r28226: OUTPUT[4+0i] | |||
..elf r20742: OUTPUT[Undefined subroutine &GLOBAL::unpolar called at (eval 14) line 3. at ./elf_f_faster line 4496] | |||
bacek | perl6: say unpolar(4, 0) | ||
p6eval | kp6 r20742: OUTPUT[no method 'APPLY' in Class 'Undef' at compiled/perl5-kp6-mp6/lib/KindaPerl6/Runtime/Perl5/MOP.pm line 345 | 12:14 | |
..pugs: OUTPUT[*** No such subroutine: "&unpolar" at /tmp/ZFgUNOEYE4 line 1, column 5 - line 2, column 1] | |||
..rakudo r28226: OUTPUT[4+0i] | |||
..elf r20742: OUTPUT[Undefined subroutine &GLOBAL::unpolar called at (eval 14) line 3. at ./elf_f_faster line 4496] | |||
12:17
Lorn_ joined
|
|||
bacek | perl6: my $a = '2 is my favorite number'; say +$a.isa(Num) | 12:25 | |
p6eval | kp6 r20742: OUTPUT[no method 'APPLY' in Class 'Undef' at compiled/perl5-kp6-mp6/lib/KindaPerl6/Runtime/Perl5/MOP.pm line 345 | ||
..pugs: OUTPUT[0] | |||
..rakudo r28226: OUTPUT[0] | |||
..elf r20742: OUTPUT[1] | |||
bacek | perl6: my $a = '2 is my favorite number'; say (+$a).isa(Num) | 12:26 | |
p6eval | kp6 r20742: OUTPUT[no method 'APPLY' in Class 'Undef' at compiled/perl5-kp6-mp6/lib/KindaPerl6/Runtime/Perl5/MOP.pm line 345 | ||
..pugs: OUTPUT[1] | |||
..rakudo r28226: OUTPUT[1] | |||
..elf r20742: OUTPUT[1] | |||
bacek | perl6: my $a = 2; say (+$a).isa(Num) | 12:27 | |
p6eval | kp6 r20742: OUTPUT[no method 'APPLY' in Class 'Undef' at compiled/perl5-kp6-mp6/lib/KindaPerl6/Runtime/Perl5/MOP.pm line 345 | ||
..pugs: OUTPUT[1] | |||
..rakudo r28226: OUTPUT[0] | |||
..elf r20742: OUTPUT[1] | |||
12:29
cjfields joined
|
|||
diakopter | pmichaud: have you read about the "packrat parser"? sorry if this is a dumb question | 12:34 | |
pugs_svnbot | r20743 | diakopter++ | [yap6] found a way to memoize all the generated parsers | ||
r20743 | diakopter++ | yap6 is now packrat-ified. so that means its degenerate | |||
r20743 | diakopter++ | grammar now enters infinite recursions in linear time :D | |||
r20743 | diakopter++ | seriously though, I still need to convert the left | |||
r20743 | diakopter++ | recursions in STD_hand to right recursions. | |||
12:35
Lorn_ left,
sri_work joined
12:36
cjfields_ joined,
cjfields left
|
|||
diakopter | commutativity & | 12:36 | |
bacek | perl6: say Byte.WHAT | 12:37 | |
p6eval | kp6 r20743: OUTPUT[DISPATCH: calling WHAT on invalid object:$VAR1 = undef; at compiled/perl5-kp6-mp6/lib/KindaPerl6/Runtime/Perl5/MOP.pm line 128 main::DISPATCH('undef', 'WHAT') called at - line 11] | 12:38 | |
..pugs: OUTPUT[*** No such subroutine: "&Byte" at /tmp/Xi7RmNlha5 line 1, column 5 - line 2, column 1] | |||
..rakudo r28226: OUTPUT[Failure] | |||
..elf r20743: OUTPUT[STRING] | |||
bacek | perl6: say Byte.isa(Num) | ||
p6eval | kp6 r20743: OUTPUT[no method 'APPLY' in Class 'Undef' at compiled/perl5-kp6-mp6/lib/KindaPerl6/Runtime/Perl5/MOP.pm line 345 | ||
..pugs: OUTPUT[*** No such subroutine: "&Byte" at /tmp/dHXW19n9da line 1, column 5 - line 2, column 1] | |||
..rakudo r28226: OUTPUT[0] | |||
..elf r20743: OUTPUT[] | |||
bacek | rakudo: my Byte $a; say $a.isa(Num) | 12:39 | |
p6eval | rakudo r28226 OUTPUT[0] | ||
12:53
xinming left
12:54
xinming joined
12:56
[particle] joined
|
|||
pmichaud | diakopter: I read something about it a bit, but not in great detail. | 12:57 | |
bacek | perl6: say (1+1.0).WHAT | 12:58 | |
p6eval | kp6 r20743: OUTPUT[syntax error at position 4, line 1 column 4:say (1+1.0).WHA ^ HERE] | ||
..pugs: OUTPUT[Rat] | |||
..rakudo r28226: OUTPUT[Num] | |||
..elf r20743: OUTPUT[Int] | |||
bacek | ouch... | 12:59 | |
pugs: say Int <: Num | 13:04 | ||
p6eval | OUTPUT[***  Unexpected ": Num" expecting "::" at /tmp/2Tkl3la8vC line 1, column 10] | ||
13:10
iblechbot left
13:20
donaldh joined
13:23
cjfields_ left
13:26
TJCRI joined
13:35
cmarcelo joined
|
|||
pugs_svnbot | r20744 | diakopter++ | [yap6] removed completed items from TODO | 13:41 | |
r20744 | diakopter++ | added a comment to the Trace.pm source filter | |||
r20744 | diakopter++ | added another parameter to perl6.bat | |||
13:41
eternaleye joined
13:44
osfameron left,
osfamero1 joined
13:51
jhorwitz joined
|
|||
diakopter | a few more things to be fully packrat-ified: get rid of the 3 remaining character classes; finish the match() parser generator to accept p5 REs so character classes are a lot easier; add an explicit normalizer function parameter to memoize() to ensure $input is keyed correctly in the memo tables. | 13:52 | |
oh and, rip out the lexer component entirely so that it's a lot simpler. also requires changes to the two terminals hit() and eoi() | 13:53 | ||
there's no need to use nested arrayref tuples when a single arrayref will do... | 13:54 | ||
14:01
Khisanth joined
14:04
eternaleye left
14:06
iblechbot joined
14:09
cjfields joined
14:10
[particle]1 joined
14:18
Ashizawa joined
|
|||
pugs_svnbot | r20745 | diakopter++ | [yap6] initial cut at the match() constructor | 14:20 | |
14:27
[particle] left
14:33
Ashizawa left
14:43
cognominal_ left
14:53
sscaffidi joined
15:04
jhorwitz left,
Jedai left
15:06
osfamero1 is now known as osfameron
15:07
jhorwitz joined,
Jedai joined,
nothingmuch joined,
agentzh joined
15:12
jan joined
15:15
masak left
15:17
stevan_ left
15:24
elmex left
15:27
rdice joined
15:33
pbuetow joined
15:45
Unix joined
15:50
stevan_ joined
|
|||
Auzon | rakudo: class Foo {my method !bar {say 42}; method tryit {self!bar}} Foo.new.tryit; | 15:53 | |
p6eval | rakudo r28227 OUTPUT[Statement not terminated properly at line 1, near "Foo.new.tr"current instr.: 'parrot;PGE::Util;die' pc 120 (runtime/parrot/library/PGE/Util.pir:82) | ||
Auzon | rakudo: class Foo {my method !bar {say 42}; method tryit {self!bar}}; Foo.new.tryit; | ||
p6eval | rakudo r28227 OUTPUT[Could not find non-existent sub barcurrent instr.: 'parrot;Foo;_block22' pc 85 (EVAL_11:43) | ||
Auzon | rakudo: class Foo {my method bar {say 42}; method tryit {self!bar}}; Foo.new.tryit; | ||
p6eval | rakudo r28227 OUTPUT[42] | ||
15:55
alanhaggai left
16:04
alanhaggai joined
16:07
justatheory joined
16:09
agentzh left,
ting left
16:22
wknight8111 left
16:25
ting joined
16:28
[particle] joined
16:33
agentzh joined
|
|||
Auzon | rakudo: class Foo {my method bar {say 42}; method tryit {self!bar}}; Foo.new."tryit"; | 16:35 | |
p6eval | rakudo r28227 OUTPUT[42] | ||
Auzon | rakudo: class Foo {my method bar {say 42}; method tryit {self!bar}}; my $name = "tryit"; Foo.new.$name; | 16:36 | |
p6eval | rakudo r28227 OUTPUT[invoke() not implemented in class 'Perl6Str'current instr.: '_block11' pc 70 (EVAL_12:29) | ||
Auzon | rakudo: class Foo {my method bar {say 42}; method tryit {self!bar}}; my $name = "tryit"; Foo.new.'$name'; | ||
p6eval | rakudo r28227 OUTPUT[Method '$name' not found for invocant of class 'Foo'current instr.: '_block11' pc 64 (EVAL_13:28) | ||
Auzon | rakudo: class Foo {my method bar {say 42}; method tryit {self!bar}}; my $name = "tryit"; Foo.new."$name" | ||
p6eval | rakudo r28227 OUTPUT[42] | ||
Auzon | rakudo: class Foo {my method bar {say 42}; method tryit {self!bar}}; Foo.new.'tryit'; | 16:39 | |
p6eval | rakudo r28227 OUTPUT[42] | ||
[particle] | 's nice seeing tests passing | 16:41 | |
Auzon | Yep. I don't see any tests like this, so those are my next additions. | 16:42 | |
They'll be in S12-methods. | |||
16:43
[particle]1 left
|
|||
Auzon | Is there a term for calling a method using a variable or quoted string like this? | 16:43 | |
[particle] | interpolated? | 16:44 | |
there is a term... i'm trying to remember it | |||
gotta look at the ::(...) op i think | |||
Auzon | The spec mentions something like indirect | ||
[particle] | ah, right | ||
indirect method call | |||
16:45
nipotaway is now known as nipotan
|
|||
Auzon | but that's confusing with the indirect syntax, e.g. bar $foo: 1,2,3 | 16:45 | |
TimToady | that's the "indirect object" syntax | ||
Auzon | Ah, ok. | ||
[particle] | ut oh | ||
$bar $foo: 1,2,3 | 16:46 | ||
TimToady | not allowed | ||
[particle] | stated in spec? | ||
TimToady | that's two terms in a row | ||
[particle] | ok, that should be tested | ||
Auzon | I'll add it. | ||
[particle] | auzon++ | ||
pmurias | TimToady: ~/localperl/bin/perl STD5_run statementlist ~/p6/t/spec/S02-literals/radix.t is the right way to run radix.t? | 16:49 | |
pugs_svnbot | r20746 | pmurias++ | STD5_run dosn't fail silently if the wrong rule is specified | ||
16:49
eternaleye joined
16:50
IllvilJa left
|
|||
pasteling | "TimToady" at 71.139.14.242 pasted "what I was running radix.t with (actually an old copy in try.t)" (13 lines, 270B) at sial.org/pbot/31266 | 16:51 | |
TimToady | takes about 15 seconds to spit out 37 megabytes of log :) | 16:55 | |
diakopter | hey, that's similar to yap6 on trace level 6 | 16:57 | |
pmurias | took 16sec here with debugging switched off | 16:58 | |
on radix.t | 16:59 | ||
TimToady | 4 seconds here | ||
but some of that is dumping the result | |||
pmurias | but works and that's important ;) | ||
TimToady | important points: it's doing true LTM and true language switching | 17:00 | |
true LTM modulo bugs like aa|a | |||
but that's really only an issue under non-ratchet | 17:02 | ||
so I'm not worrying about it until we get better laziness | |||
not sure what to do next | |||
get regexes parsing maybe | |||
or work on lazy list semantics in p5 so I don't have to care about things like .* generating a list for the whole rest of the string | 17:03 | ||
(and presumably fix the aa|a bug at the same time) | |||
but I think regex parsing is more applicable to getting STD to parse STD at this point | 17:04 | ||
since, for some reason, STD seems to use a lot of regexen... | 17:05 | ||
17:05
rdice left
|
|||
TimToady | also don't want to break it all for my talk next week, so now is not the time for a major refactor... | 17:06 | |
Auzon | bah. 'perldoc Test.pm' can silently reference the system-wide Test module if the one in the current directory has no documentation | ||
rakudo: class Foo {my method bar {say 42}; method tryit {self!bar}}; Foo.new.'tryit'(); | 17:09 | ||
p6eval | rakudo r28227 OUTPUT[42] | ||
Auzon | rakudo: class Foo {my method bar {say 42}; method tryit {self!bar}}; say(Foo.new.'tryit'()); | ||
p6eval | rakudo r28227 OUTPUT[421] | ||
Auzon | rakudo: class Foo {my method bar {say 42}; method tryit {self!bar}}; say(Foo.new.'tryit'(), 1, 2); | ||
p6eval | rakudo r28227 OUTPUT[42112] | ||
17:10
nipotan is now known as nipotaway
|
|||
Auzon | hm. Turns out that it's me being wrong, not Rakudo :) | 17:10 | |
rakudo: class Foo {method tryit {'it works'}}; say Foo.new.tryit | 17:11 | ||
p6eval | rakudo r28227 OUTPUT[it works] | ||
Auzon | rakudo: class Foo {method tryit {'it works'}}; my $o = Foo.new; tryit $o: | ||
p6eval | rakudo r28227 OUTPUT[Statement not terminated properly at line 1, near ":"current instr.: 'parrot;PGE::Util;die' pc 120 (runtime/parrot/library/PGE/Util.pir:82) | ||
17:13
eternaleye_ joined
17:14
nipotaway is now known as nipotan
|
|||
pugs_svnbot | r20747 | Auzon++ | [gsoc_spectest] indirect method call tests. (added 7 tests) | 17:14 | |
pmurias | TimToady: i could try to fake lazy lists in perl5 | 17:15 | |
17:15
eternaleye left
|
|||
TimToady | how 'bout hacking real lazy lists into P5 :) | 17:19 | |
smtms | w/in 3 | 17:20 | |
pmurias | i would have to learn perl5 guts, but if you can wait ;) | ||
17:27
Unix left
17:36
tobeya joined
17:40
barney joined
17:41
wknight8111 joined
|
|||
pugs_svnbot | r20748 | diakopter++ | [yap6] stable grammar checkpoint.. I think. hopefully p6eval will work now :) | 17:47 | |
Auzon | rakudo: class Foo {} my $code = sub {@_.perl.say}; Foo.new.$code; | ||
p6eval | rakudo r28227 OUTPUT[Statement not terminated properly at line 1, near "my $code ="current instr.: 'parrot;PGE::Util;die' pc 120 (runtime/parrot/library/PGE/Util.pir:82) | ||
17:50
lambdabot left
|
|||
pugs_svnbot | r20749 | diakopter++ | [yap6] slight fix to match() | 17:50 | |
17:50
lambdabot joined
|
|||
Auzon | yap6: class Foo {}; say "ok" | 17:51 | |
p6eval | yap6 r20748 OUTPUT[syntax error near "Foo {}; say \"ok\""] | ||
Auzon | yap6: sub Foo {}; say "ok" | ||
p6eval | yap6 r20748 OUTPUT[syntax error near "Foo {}; say \"ok\""] | ||
diakopter | it still doesn't know quotes | 17:52 | |
17:57
wknight8111 left,
wknight8111 joined
|
|||
pugs_svnbot | r20750 | diakopter++ | [yap6] when p6eval updates yap6 from svn, this will work: | 17:59 | |
r20750 | diakopter++ | sub Foo { $a; } say $ok; | |||
18:01
donaldh left
18:02
donaldh joined
|
|||
kolibrie | TimToady: if I had a grammar to parse a conference schedule, I could compile that into perl 5 with gimme5. Is there a way to run it against an input file? | 18:08 | |
kolibrie is thinking about starting to prepare to update his talk for next week: feather.perl6.nl/~kolibrie/extraction.xul | 18:10 | ||
kolibrie wants to be able to field questions regarding how to use: pugs, PCR, kp6, STD, elf, rakudo, (and what about smop and yap6) | 18:13 | ||
pmurias | smop and elf don't support much perl6 rules yet | 18:23 | |
TimToady | kolibrie: see my recent nopaste | 18:24 | |
kolibrie | TimToady: I was trying to figure out how to use that for this scenario, but my brain did not wrap far enough | 18:25 | |
TimToady | you're basically talking about using something else where that program uses STD5 | 18:26 | |
but if you want to feed something directly to gimme5, you'll need to make sure it is in a form that it can handle | 18:27 | ||
because it's not actually doing a real parse on its input | |||
so the } at the end of a grammar must be marked with # end grammar, for instance | 18:28 | ||
kolibrie | I got what appears to be perl 5 code at the top with a data structure at the bottom | ||
TimToady | it does do a real parse on the rules | ||
the data structure is the parse of those rules | 18:29 | ||
mostly used by the LTM to determine the longest token | |||
kolibrie | so if I only have rules, it should parse fine | ||
TimToady | what happens when you run it | ||
? | |||
well, you'll probably need to write something that uses it like the nopast | 18:30 | ||
kolibrie | right, so that is the next step | ||
I think that 'comp_unit' becomes whatever my toplevel rule is | |||
and 'try.t' becomes my input file | |||
TimToady | yes, and change Perl-> to whatever your grammar name is | ||
kolibrie | aha - I was trying to figure out where that came from | 18:31 | |
TimToady | eventually we'll probably have one more step there where you have to say Perl->new->parse() so that we have a mutable grammar object, but for now, that's the incantation | 18:32 | |
kolibrie | thank you so much. I'll play with this for a bit and get back to you (I have to play with real $work a bit too) | 18:33 | |
TimToady | it's quite likely to blow up | ||
kolibrie | I'll stand a few feet away | ||
pmurias | @tell mncharity elf breaks with the newest autobox | 18:34 | |
lambdabot | Consider it noted. | ||
pmurias | TimToady: gimme5 hardcodes grammar Perl | 18:36 | |
kolibrie | pmurias: oh, that is perhaps why I could not get elf running. will try an older version of autobox unless elf gets fixed first | ||
pmurias: not in my grammar - no mention of 'Perl' at all - it says: package main::bogus | 18:37 | ||
18:39
pbuetow_ joined
|
|||
TimToady | I can probably patch that, as long as you start your file grammar Foo | 18:39 | |
hang on | |||
Auzon | rakudo: class Foo {my method bar {say 42}; method tryit {$!bar}}; Foo.new.'tryit'(); | 18:44 | |
p6eval | rakudo r28227 OUTPUT[Scope not found for PAST::Var '$!bar'current instr.: 'parrot;PCT::HLLCompiler;panic' pc 156 (src/PCT/HLLCompiler.pir:103) | ||
pugs_svnbot | r20751 | lwall++ | [gimme5] unhardwire Perl as top grammar | 18:47 | |
TimToady | 'k, now you should be able to start your file with "grammar Bogus;" | 18:49 | |
Auzon | perl6: class Foo {my method bar {say 42}; method tryit {$!bar}}; Foo.new.tryit(); | ||
p6eval | kp6 r20751: OUTPUT[no method 'APPLY' in Class 'Undef' at compiled/perl5-kp6-mp6/lib/KindaPerl6/Runtime/Perl5/MOP.pm line 345 | ||
..pugs: RESULT[\undef] | |||
..rakudo r28227: OUTPUT[Scope not found for PAST::Var '$!bar'current instr.: 'parrot;PCT::HLLCompiler;panic' pc 156 (src/PCT/HLLCompiler.pir:103) | |||
..elf r20751: OUTPUT[Parse error in: /tmp/ZiVqFOIEXtpanic at line 1 column 49 (pos 49): Missing right braceWHERE: d bar {say 42}; method tryit {$!bar}}; Foo.new.tryit();WHERE: /\<-- HERE STD_red/prelude.rb:98:in `panic' STD_red/std.rb:255:in `_block_rest' | |||
..STD_red/std.rb:242:in `block in block' STD_red/prelude.rb:51:in `... | |||
Auzon | and it all goes boom | ||
TimToady | mad bomber Auzon++ | 18:51 | |
18:54
pbuetow left
|
|||
Auzon | TimToady: In S12, should the $!doit be mentioned around the "Dot notation can omit the invocant if it's in $_" part? | 18:57 | |
TimToady | you mean, as in !doit doesn't do what you think if you think it means $_!doit ? | 18:58 | |
Auzon | Oh. Never mind, I forgot that .doit was for $_ and not self | 18:59 | |
I saw the self!doit(1,2,3) line below and thought .doit was self.doit | 19:00 | ||
TimToady | the fact that it's not self.doit is a Very Long Discussion back in the dark ages | 19:02 | |
Auzon | Yeah, I read that two weeks ago | ||
19:05
sscaffidi left
|
|||
Auzon | perl6: class Foo {method bar {say 42}; method tryit {$.bar}}; Foo.new.tryit(); | 19:05 | |
p6eval | kp6 r20751: OUTPUT[42] | ||
..pugs: OUTPUT[42] | |||
..rakudo r28227: OUTPUT[42] | |||
..elf r20751: OUTPUT[42] | |||
diakopter | yap6: sub foo { $a; }; say $ok; | ||
p6eval | yap6 r20751 OUTPUT[parse successful] | ||
19:06
sscaffidi joined
|
|||
Auzon | That's a scary global, diakopter ;) | 19:06 | |
19:06
cognominal_ joined
|
|||
diakopter | yap6: class Foo {method bar {say 42}; method tryit {$bar};}; | 19:07 | |
p6eval | yap6 r20751 OUTPUT[parse successful] | ||
Auzon | do you mean "method tryit {$.bar}"? | 19:08 | |
diakopter | Auzon: where it says parse successful, read that as "hierarchical tokenization successful" | ||
Auzon: no, b/c yap6 doesn't know about "." yet | 19:09 | ||
let alone method calls | |||
Auzon | Ok, so it parsed, even though the execution wouldn't be valid since $bar isn't declared there. | ||
diakopter | right, it tokenized so that it can be *really* syntax checked on the next pass | 19:10 | |
or squished into this pass. | |||
at lunch I thought of a hint() parser combinator/constructor | 19:11 | ||
hint(match(qr|some pattern|),anotherRule) | 19:12 | ||
where hint results in both(iff(match(qr|some pattern|)),anotherRule(),'.') | 19:14 | ||
pugs_svnbot | r20752 | Auzon++ | [gsoc_spectest] adding smartlink for tests of $!method syntax | ||
diakopter | iff means lookahead and continue if successful | ||
but don't eat input | |||
get it? if and *only* if; haha | |||
TimToady | how is it different from <?before ...> | ||
diakopter | I don't know; what does <?before ...> do... point me to a SXX:nnnn? | 19:15 | |
I'm afraid I'm only cursorily familiar with the SXX | 19:17 | ||
Auzon | rakudo: class Foo {method doit {say "works"}} my $class = "Foo"; "$class".new.doit | ||
p6eval | rakudo r28227 OUTPUT[Statement not terminated properly at line 1, near "my $class "current instr.: 'parrot;PGE::Util;die' pc 120 (runtime/parrot/library/PGE/Util.pir:82) | ||
Auzon | rakudo: class Foo {method doit {say "works"}}; my $class = "Foo"; "$class".new.doit | ||
p6eval | rakudo r28227 OUTPUT[works] | ||
Auzon | rakudo: class Foo {method doit {say "works"}}; my $class = "Foo"; $class.new.doit | ||
p6eval | rakudo r28227 OUTPUT[works] | ||
TimToady | oh S05:1362 and thereabouts | ||
Auzon | rakudo: class Foo {method doit {say "works"}}; my $class = "Foo"; $class.doit | 19:18 | |
p6eval | rakudo r28227 OUTPUT[Method 'doit' not found for invocant of class 'Perl6Str'current instr.: '_block11' pc 52 (EVAL_12:24) | ||
Auzon | rakudo: class Foo {method doit {say "works"}}; my $class = "Foo"; "$class".doit | ||
p6eval | rakudo r28227 OUTPUT[Method 'doit' not found for invocant of class 'Perl6Str'current instr.: '_block11' pc 52 (EVAL_12:24) | ||
19:20
alc left
|
|||
diakopter | TimToady: it's identical to <?before ...> I think | 19:21 | |
which means <!before <something>> and <!something> can be translated to it | |||
but not the capturing one... | |||
actually, the capturing one can be done too | 19:22 | ||
the combinated parser would just create/publish its own new parser coderef under some keyed name | 19:23 | ||
and then send it on through to the continuation using eval | 19:24 | ||
hmm; lookbehind... currently it's constructing the AST only on the way back from the EOI, but I guess it can construct it on its way there too/instead, so that lookbehind could work. | 19:26 | ||
but the RE hints, esp in the nbexpr (non-block expression) rule, would really help efficiency I think. | 19:27 | ||
TimToady | EOI? | 19:28 | |
the way the LTM works, it uses the contents of <?before> as the token and ignores what follows | 19:29 | ||
diakopter | end of input | ||
TimToady | while <!before> is just the opposite | ||
diakopter | oh ok | 19:30 | |
TimToady | I don't understand what constructing the AST has to do with lookbehind | ||
it's just matching backwards | |||
see all the *rev methods in Cursor5 for its implementation of <after> | 19:32 | ||
diakopter | well currently the input is stored as nested arrayrefs/characters which are chewed up destructively as a heretofore successful path is taken, so that would need redone to support lookbehind (since right now there's nothing to look for backwards) | ||
TimToady | ah, Cursor5 just uses pos on an immutable input string | 19:33 | |
19:33
barney left
|
|||
TimToady | actually, the real pos is passed around via the continuations | 19:33 | |
diakopter | ok. that's what I'll choose as well then | ||
it's not like someone is going to give us a 512MB input string | 19:34 | ||
well, STD5.pm is close | |||
TimToady | I suspect I'll eventually need to move to scalar contexts and iterators instead of list contexts | ||
19:35
TJCRI left
|
|||
TimToady | unless I can figure out an easy way for p5 to support lazy lists outside of tied arrays | 19:35 | |
most of the time you can get away with p5's eager lists under ratchet mode | 19:36 | ||
since you're always just throwing away all but the first value of the list | |||
diakopter | is an <?after > literally applied in reverse? as if the whole content string is inverted? or are ^ and $ effectively swapped | ||
TimToady | but as I mentioned earlier, .* would be a problem, since it would eagerly generate all the continuations from here to the end of the input | 19:37 | |
nothing changes meaning, but the pattern is matched from the back end | |||
some patterns are not reversible | |||
diakopter | there are algorithms to convert left recursion to right recursion... I though? | ||
thought | |||
TimToady | well, anything is better than p5's limitation of literal strings only | 19:38 | |
and it's completely impractical to try to rescan in the forward direction | |||
so I guess at some point the implementations will have to come to some rough agreement on what is reversible and what isn't | 19:39 | ||
STD5's implementation is a good first approximation though | |||
if you say <?after ^^ .* $$> it will match the $$, then the .* backwards till it finds a ^^ | 19:40 | ||
well, modulo the .* problem I mentioned. You'd probably want to write \N* there for now | 19:41 | ||
or .*? | |||
though that will try to generate all the possibilities under eager lists | 19:42 | ||
diakopter | well currently I put a self-recursion depth limitation (depth charge) on every parser for every input position | ||
TimToady | originally gimme5/metholate targeted pugs with gather/take, which is (in theory) lazy | 19:43 | |
diakopter | and it's set to 2 | ||
so if the exact same parser (rule) is called on the exact same input more than twice, it fails that branch | 19:44 | ||
... at least I think we're talking about the same thing. | |||
19:46
rindolf joined
|
|||
TimToady | if your LTM is really working right it should detect recursion without progress most of the time | 19:46 | |
as long as your longest token is non-zero length, you make progress, pretty much guaranteed | 19:47 | ||
19:47
Gothmog_ left
|
|||
diakopter | well that's the method $cdepth->{$magical_eta_conversion_parser_self_reference}->{$input arrayref, though it should be changed to flattened string} ++ for each new depth | 19:48 | |
where cdepth used to mean concatenation depth before I renamed concatenation to all(), which recurses down to both() | |||
yeah; as long as it escapes infinite recursion (and the grammar is encoded correctly), it will eventually match the entire input correctly or fail at some point b/c the input doesn't fit the grammar's language | 19:50 | ||
and I think I've implemented the memoization correctly so that it can act in linear time instead of exponential like most top-down/rd parsers | 19:51 | ||
19:51
Gothmog_ joined
|
|||
diakopter | at least according to the paper on packrat parsing | 19:53 | |
TimToady: your parser would fall into the predictive category, right? | |||
TimToady | by and large | 19:54 | |
diakopter | pugs: say 3 if { "trailing conditional block" } | 19:57 | |
p6eval | OUTPUT[3] | ||
diakopter | pugs: say 3 if ({ "trailing conditional block" }) | ||
p6eval | OUTPUT[3] | ||
diakopter | pugs: say 3 if ({ "trailing conditional block"; return 0 }) | ||
p6eval | OUTPUT[3] | ||
Auzon | pugs: say 3 if 0 | 19:58 | |
p6eval | RESULT[undef] | ||
diakopter | pugs: say 3 if { "trailing conditional block"; return 0; } | ||
p6eval | OUTPUT[3] | ||
TimToady | it's not counting that as a bare statement | ||
bare statements inside () are really post-pugs | 19:59 | ||
diakopter | pugs: say 3 if &{ "trailing conditional block"; return 0; } | ||
p6eval | OUTPUT[***  Unexpected "{" expecting "::" at /tmp/Arbi2xBWqM line 1, column 11] | ||
TimToady | pugs say 3 if { "trailing conditional block"; return 0; }() | ||
pugs: say 3 if { "trailing conditional block"; return 0; }() | |||
p6eval | No output (you need to produce output to STDOUT) | ||
TimToady | pugs: say 3 if do { "trailing conditional block"; return 0; } | 20:00 | |
p6eval | OUTPUT[*** Cannot use this control structure outside a 'routine' structure at /tmp/vYMbW2ephW line 1, column 45-53] | ||
TimToady | actually, return is illegal there | ||
diakopter | pugs: say 3 if do { "trailing conditional block"; return 1 } | ||
p6eval | OUTPUT[*** Cannot use this control structure outside a 'routine' structure at /tmp/2m7xyQYRo3 line 1, column 45-54] | ||
TimToady | should be illegal in the bare block too | ||
diakopter | pugs: say 3 if do { "trailing conditional block"; 1; } | ||
p6eval | OUTPUT[3] | ||
TimToady | pugs: say 3 if do { "trailing conditional block"; leave(1) } | ||
p6eval | OUTPUT[3] | ||
diakopter | say 3 if do { "trailing conditional block"; | 20:01 | |
pugs: say 3 if do { "trailing conditional block"; leave 1; 0; } | |||
p6eval | RESULT[undef] | ||
diakopter | pugs: say 3 if do { "trailing conditional block"; leave(1); 0; } | ||
p6eval | RESULT[undef] | ||
TimToady | looks busted | 20:02 | |
diakopter | pugs: say 3 if do { "trailing conditional block"; leave(1); $_; } | ||
p6eval | RESULT[undef] | ||
TimToady | pugs: say 3 if do { "trailing conditional block"; leave(0) } | ||
p6eval | OUTPUT[3] | ||
TimToady | looks like leave is return a true value :/ | 20:03 | |
*returning | |||
20:03
rindolf left
|
|||
diakopter | pugs: say leave(undef) | 20:03 | |
p6eval | OUTPUT[] | ||
diakopter | pugs: say leave(0) | ||
p6eval | OUTPUT[0] | ||
TimToady | that *should* be bypassing the say | 20:04 | |
diakopter | pugs: say do { do { leave('hi') } } | 20:05 | |
p6eval | OUTPUT[hi] | ||
TimToady | bbl & | 20:09 | |
20:10
chris2 joined
|
|||
diakopter | yap6: say do { do { say 78 }; }; | 20:11 | |
p6eval | yap6 r20752 OUTPUT[parse successful] | ||
diakopter | yap6: say do { do; { say 78 };;}; | 20:12 | |
p6eval | yap6 r20752 OUTPUT[syntax error near "; { say 78 };;};"] | ||
diakopter | yap6: say do { do { say 78 };;}; | ||
p6eval | yap6 r20752 OUTPUT[parse successful] | ||
Auzon | yap6: ;; | ||
p6eval | yap6 r20752 OUTPUT[parse successful] | ||
diakopter | yap6: { { }; }; | 20:13 | |
p6eval | yap6 r20752 OUTPUT[parse successful] | ||
20:13
pugpuppy joined
|
|||
Auzon | yap6: class Foo {} | 20:13 | |
p6eval | yap6 r20752 OUTPUT[syntax error near "}"] | 20:14 | |
Auzon | yap6: class Foo {}; | ||
p6eval | yap6 r20752 OUTPUT[parse successful] | ||
diakopter | yap6: classs Foo {}; | ||
p6eval | yap6 r20752 OUTPUT[syntax error near "Foo {};"] | ||
pugpuppy | any ideas on how to start contributing on PERL6, found the directions quite confusing | ||
diakopter | that's b/c it parsed "classs" as a type/classname | ||
pugpuppy: what do you like to do? | 20:15 | ||
diakopter looks around for PERL6 | |||
pugpuppy | well I have been working on PERL, pretty much all my bread and butter depends on it. So therefore thought well let me start some farming | ||
I am from a development background, so anything on development will be just great | 20:16 | ||
just dont know where to get started and how | |||
Auzon | moritz++ did a writeup of the current status of Perl 6 implementations at perlmonks.org/?node_id=690945 | ||
lambdabot | Title: Getting Involved with Perl 6 - an Update | ||
diakopter | if I were you, I'd check out that page and the perlfoundation.org/perl6 wiki | ||
20:17
Gothmog_ left
|
|||
pugpuppy | thanks for that but PERL6 wiki is voluminious and I get to sleep just enough to know that I had a break from my comp | 20:18 | |
great thanks for the article | 20:19 | ||
Auzon | pugpuppy: You can also play around with the various Perl 6 implementations here in a limited form. | ||
rakudo: say "hi" | |||
p6eval | rakudo r28227 OUTPUT[hi] | ||
pugpuppy | how do I do that | ||
Auzon | Prefix some code with rakudo:, pugs:, kp6:, elf:, yap6:, or nqp:, depending on which one to try | 20:20 | |
you can also call the 4 most complete with perl6: | |||
perl6: say [*] 1 .. 5 | 20:21 | ||
p6eval | kp6 r20752: OUTPUT[syntax error at position 4, line 1 column 4:say [*] 1 ..  ^ HERE] | ||
..pugs: OUTPUT[120] | |||
..rakudo r28227: OUTPUT[Statement not terminated properly at line 1, near "1 .. 5"current instr.: 'parrot;PGE::Util;die' pc 120 (runtime/parrot/library/PGE/Util.pir:82) | |||
..elf r20752: OUTPUT[Parse error in: /tmp/r4Yedl3yQvpanic at line 1 column 0 (pos 0): Can't understand next input--giving upWHERE: say [*] 1 .. 5WHERE:/\<-- HERE STD_red/prelude.rb:98:in `panic' STD_red/std.rb:76:in `scan_unitstopper' STD_red/std.rb:224:in `comp_unit' | |||
..STD_red/std.rb:210:in `_UNIT' ./../STD_red/STD_red_run:108:in `main' ./../STD... | |||
pugpuppy | mind blowing | ||
Auzon | That one can be a bit noisy when things fail, though | ||
Do you know any of the new syntax? | 20:22 | ||
pugpuppy | but will it not be disturbing for other uesrs | ||
nopes I have actually not started on learning the new syntaxes | 20:23 | ||
was going through this article though sometime back and also installed PERL6 in my system | |||
20:23
cjfields left
|
|||
diakopter thought of another combinator: of(3..5,rulename) hits only if there are between 3 and 5 repititions of rulename, inclusively | 20:24 | ||
pugpuppy | www.wellho.net/solutions/perl-parro...chine.html | ||
lambdabot | Title: Parrot - Perl's new Virtual Machine, tinyurl.com/57gmhh | ||
diakopter | not sure how helpful that will be though | ||
pugpuppy | so any ideas on which materials to refer to | ||
Auzon | What are you hoping to do? | 20:25 | |
pugpuppy | well contributing to PERL6 development | ||
Auzon | What languages do you know? | 20:26 | |
pugpuppy | this will be first time that I will actually be contributing to any community so you can really imagine me as a real puppy (though a very enthusiastic one and wagging tail and all that ) | ||
PERL, C, VBA, PHP | |||
learning bits and pieces of JAVA as well | 20:27 | ||
pugs_svnbot | r20753 | diakopter++ | [yap6] fixed semicolon-less trailing statements in statement lists (including inside blocks) | ||
Auzon | I'm personally working on the Perl 6 test suite. The only skills needed for that are Perl 6, the ability to read the specs, and some general testing knowledge. | 20:29 | |
diakopter | pugpuppy: probably you should read the Synopses... the specification for the Perl 6 language: perlcabal.org/syn/ | ||
lambdabot | Title: Official Perl 6 Documentation | ||
[particle] | pugpuppy: yikes, that's an old link | 20:30 | |
parrot's assemble.pl went away long ago | |||
pugpuppy | can you get me the new/ fresh link | 20:31 | |
diakopter | yap6: class Foo {{{{}}}} | 20:32 | |
p6eval | yap6 r20753 OUTPUT[parse successful] | ||
20:33
icwiener joined
|
|||
[particle] | pugpuppy: see for example www.parrotblog.org/ or parrotcode.org/ | 20:36 | |
lambdabot | Title: Parrot | ||
Auzon | There was a NQP (or was it PIR?) tutorial a while back that could help with hacking on Rakudo. The barrier to entry there is a bit higher than things in the Pugs repository, however | ||
pugpuppy | okay, I had a look at the second one. Its two am out here and I will catch up with you tomorrow | 20:37 | |
thanks a lot for your help | |||
Auzon | See you. | ||
[particle] | welcome! | ||
Auzon | perl6: class Foo {}; say Foo.new.?test; | 20:41 | |
p6eval | kp6 r20753: OUTPUT[syntax error at position 26, line 1 column 26:class Foo {}; say Foo.new.?test ^ HERE] | ||
..pugs: OUTPUT[] | |||
..rakudo r28227: OUTPUT[Failure] | |||
..elf r20753: OUTPUT[Unknown rule: dotty:.?It needs to be added to ast_handlers. at ./elf_f_faster line 2676] | |||
Auzon | perl6: class Foo {}; say Foo.new.test; | ||
p6eval | kp6 r20753: OUTPUT[no method 'test' in Class 'Foo' at compiled/perl5-kp6-mp6/lib/KindaPerl6/Runtime/Perl5/MOP.pm line 345 | ||
..pugs: OUTPUT[*** No such method in class Foo: "&test" at /tmp/o4m8A6O6JM line 1, column 19-31] | |||
..rakudo r28227: OUTPUT[Method 'test' not found for invocant of class 'Foo'current instr.: '_block11' pc 43 (EVAL_10:20) | |||
..elf r20753: OUTPUT[Can't locate object method "test" via package "Foo" at (eval 14) line 8. at ./elf_f_faster line 4496] | |||
20:42
pugpuppy left
|
|||
pugs_svnbot | r20754 | diakopter++ | [yap6] set toodeep to 0; in theory this should be ok | 20:42 | |
20:44
icwiener left,
Gothmog_ joined
|
|||
diakopter | yap6: class Foo {{{{{{{{{{{{{{}}}}}}}}}}}}}} | 20:45 | |
20:45
barney joined
|
|||
p6eval | yap6 r20754 OUTPUT[parse successful] | 20:45 | |
pmurias | yap6: say 4 | 20:46 | |
p6eval | yap6 r20754 OUTPUT[syntax error near 4] | ||
pmurias | yap6: 4 | ||
p6eval | yap6 r20754 OUTPUT[parse successful] | ||
pmurias | yap6: say(4) | ||
p6eval | yap6 r20754 OUTPUT[syntax error near "(4)"] | ||
pmurias | yap6: 1+2+3 | 20:47 | |
p6eval | yap6 r20754 OUTPUT[parse successful] | ||
pmurias | yap6: say(123); | ||
p6eval | yap6 r20754 OUTPUT[syntax error near "(123);"] | ||
Auzon | I think that's a bug. ^_^' | ||
20:47
barney left
|
|||
pmurias | Auzon: maybe it's an missing feature ;) | 20:48 | |
Auzon | It used to work, so it's a regression :) | ||
20:48
pjcj_ left
|
|||
pmurias | yap6: class Foo {{{{{{{{{{{{{{}}}}}}}}}}}}}} | 20:55 | |
p6eval | yap6 r20754 OUTPUT[parse successful] | ||
pmurias | yap6: class Foo {} | 20:56 | |
p6eval | yap6 r20754 OUTPUT[parse successful] | ||
pmurias | yap6: class Foo {{}} | ||
p6eval | yap6 r20754 OUTPUT[parse successful] | ||
diakopter | pmurias: are you doing some execution time tests? :P | 20:57 | |
Auzon | pugs: say "rakudo: say 'hi'" | ||
p6eval | OUTPUT[rakudo: say 'hi'] | ||
Auzon | oh | ||
not beginning of line, so I can't make it cascade | |||
diakopter | 7 seconds for 14 nested expressions; 1 second for 2 nested expressions | ||
Auzon | dang. :P | ||
diakopter | heh | 20:58 | |
pmurias | diakopter: just checking if yap6 works at all | ||
diakopter: how should i run src/sbin/perl6? | |||
Auzon | I think it runs with Perl 5 | 20:59 | |
21:00
alanhaggai left
|
|||
pmurias | it gives me syntax errors on everything | 21:00 | |
i use perl -I src/lib/ src/sbin/perl6 file | 21:01 | ||
yap6: class Foo {} | 21:04 | ||
p6eval | yap6 r20754 OUTPUT[parse successful] | ||
pmurias | i'll try later;sleep& | ||
21:04
pmurias left
|
|||
diakopter | pmurias: the syntax errors are pre-source filter I think :D | 21:09 | |
the source filter actually doesn't do that much | |||
Auzon | What Perl are you using, diakopter? | 21:10 | |
diakopter | just takes the rule name and makes the rule rulename {}; block a my $rulename = parser {}; declaration | ||
strawberry 5.10.0.latest on win32 daytime and 5.10.0 on x86 darwin at nighttime | 21:11 | ||
but I think p6eval uses 5.8...? | |||
Auzon | Right. | ||
diakopter | b/c it didn't like it when I used //= | ||
Auzon | elf: say $?VERSION | ||
p6eval | OUTPUT[Global symbol "$VERSION" requires explicit package name at (eval 14) line 3. at ./elf_f_faster line 4496] | ||
Auzon | elf: say $*VERSION | ||
p6eval | OUTPUT[Can't call method "Str" on an undefined value at ./elf_f_faster line 619. at ./elf_f_faster line 4496] | ||
Auzon | What's that variable...? | 21:12 | |
diakopter | elf: eval "system('perl -v')" | ||
p6eval | OUTPUT[This is perl, v5.8.8 built for i486-linux-gnu-thread-multiCopyright 1987-2006, Larry WallPerl may be copied only under the terms of either the Artistic License or theGNU General Public License, which may be found in the Perl 5 source kit.Complete documentation for Perl, including FAQ | ||
..lists, should be found onthis system using "ma... | |||
Auzon | You shouldn't need to eval it | ||
diakopter | oh yeah | 21:13 | |
Auzon | elf: say $?PERLVER; say $*PERLVER | ||
p6eval | OUTPUT[Can't call method "Str" on an undefined value at ./elf_f_faster line 619. at ./elf_f_faster line 4496elf / perl 5.8.8 / EmitFasterP5] | ||
Auzon | there. It's $*PERLVER. | ||
elf: say $*OSVER | 21:14 | ||
p6eval | OUTPUT[Can't call method "Str" on an undefined value at ./elf_f_faster line 619. at ./elf_f_faster line 4496] | ||
Auzon | elf: say $*PERLVER | ||
p6eval | OUTPUT[Can't call method "Str" on an undefined value at ./elf_f_faster line 619. at ./elf_f_faster line 4496] | ||
Auzon | or, it's $?PERLVER | ||
OK, just wondering if Perl 5.10 had issues with yap6 that 5.8.8 didn't | |||
diakopter | *wow* I haven't implemented the memoization correctly... it could be even faster. | 21:17 | |
21:18
jhorwitz left
|
|||
diakopter | hm; yap6 is hitting p6eval's memory limit on 21 nested expressions | 21:19 | |
surely there aren't that many in STD.pm ;) | |||
Auzon | So 21 brackets deep? | 21:20 | |
diakopter | yeah | 21:21 | |
or () | |||
Auzon | perl6: my $foo = "hello"; $foo ~= ' world'; say $foo | 21:23 | |
p6eval | kp6 r20754: OUTPUT[syntax error at position 24, line 1 column 24:my $foo = "hello"; $foo ~= ' world'; say $fo ^ HERE] | ||
..pugs: OUTPUT[hello world] | |||
..rakudo r28227: OUTPUT[hello world] | |||
..elf r20754: OUTPUT[Unknown rule: infix_postfix_meta_operator:=It needs to be added to ast_handlers. at ./elf_f_faster line 2676] | |||
Auzon | ok, good enough. | ||
perl6: my @foo = <a b c d>; say @foo.perl | 21:24 | ||
p6eval | kp6 r20754: OUTPUT[[ 'a', 'b', 'c', 'd' ]] | ||
..pugs: OUTPUT[["a", "b", "c", "d"]] | |||
..rakudo r28227: OUTPUT[["a", "b", "c", "d"]] | |||
..elf r20754: OUTPUT[["a","b","c","d"]] | |||
Auzon | rakudo: class Foo {method doit(Int $num) {say $num + 1}} Foo.new.doit | 21:29 | |
p6eval | rakudo r28227 OUTPUT[Statement not terminated properly at line 1, near "Foo.new.do"current instr.: 'parrot;PGE::Util;die' pc 120 (runtime/parrot/library/PGE/Util.pir:82) | ||
Auzon | rakudo: class Foo {method doit(Int $num) {say $num + 1}}; Foo.new.doit(5) | ||
p6eval | rakudo r28227 OUTPUT[6] | ||
Auzon | rakudo: class Foo {method doit(Int $num) {say $num + 1}}; Foo.new.doit() | ||
p6eval | rakudo r28227 OUTPUT[too few arguments passed (1) - 2 params expectedcurrent instr.: 'parrot;Foo;doit' pc 86 (EVAL_13:48) | ||
Auzon | rakudo: class Foo {method doit(Int $num) {say $num + 1}; method doit {say 'nothing'}}; Foo.new.doit() | ||
p6eval | rakudo r28227 OUTPUT[too few arguments passed (1) - 2 params expectedcurrent instr.: 'parrot;Foo;doit' pc 156 (EVAL_13:78) | ||
Auzon | rakudo: class Foo {multi method doit(Int $num) {say $num + 1}; multi method doit {say 'nothing'}}; Foo.new.doit() | ||
p6eval | rakudo r28227 OUTPUT[No applicable methods.current instr.: '_block11' pc 43 (EVAL_13:20) | ||
Auzon | rakudo: class Foo {multi method doit(Int $num) {say $num + 1}; multi method doit {say 'nothing'}}; Foo.new.doit | ||
p6eval | rakudo r28227 OUTPUT[No applicable methods.current instr.: '_block11' pc 43 (EVAL_13:20) | 21:30 | |
21:41
rindolf joined
21:59
sscaffidi_ joined
22:01
IllvilJa joined
22:02
Limbic_Region joined,
sscaffidi left
22:12
rindolf left
22:13
khisanth_ joined
|
|||
Auzon | rakudo: class Foo {method doit(Int $num) {say $num + 1}} Foo.new.doit(5) | 22:19 | |
p6eval | rakudo r28227 OUTPUT[Statement not terminated properly at line 1, near "Foo.new.do"current instr.: 'parrot;PGE::Util;die' pc 120 (runtime/parrot/library/PGE/Util.pir:82) | ||
Auzon | rakudo: class Foo {method doit(Int $num) {say $num + 1}}; Foo.new.doit(5) | 22:20 | |
p6eval | rakudo r28227 OUTPUT[6] | ||
22:20
Khisanth left
22:21
khisanth_ is now known as Khisanth
22:24
sscaffidi_ is now known as sscaffidi
22:25
sscaffidi left
|
|||
bacek | rakudo: say 1 ~~ Perl6Scalar | 22:30 | |
p6eval | rakudo r28227 No output (you need to produce output to STDOUT) | ||
bacek | oops | ||
22:31
wknight8111 is now known as wknight-away
22:33
iblechbot left
22:41
cjfields joined
|
|||
pugs_svnbot | r20755 | diakopter++ | [yap6] committing changes so I can work another place | 22:41 | |
22:42
cjfields left,
jan__ left
|
|||
Auzon | Heh. I know that feeling | 22:42 | |
22:43
eternaleye_ left
|
|||
pugs_svnbot | r20756 | Auzon++ | [gsoc_spectest] Fixed typo in S13 test. Added new defer_call and defer_next tests to test the callsame, callwith, nextsame, and nextwith functions (S12). Added 18 tests. | 22:44 | |
22:48
eternaleye_ joined
23:03
apeiron left
23:11
Eevee_ joined
23:16
apeiron joined
23:19
chris2 left
23:24
Eevee left
23:29
vixey joined
23:36
Eevee__ joined,
Eevee_ left
23:38
wknight-away left
|
|||
pugs_svnbot | r20757 | Auzon++ | [gsoc_spectest] more entries for t/TASKS | 23:40 | |
23:49
cmarcelo left
23:58
Eevee_ joined
|