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. |
|||
pugs_svnbot | r20793 | diakopter++ | [yap6] lots of visual cleanup; some rule fixing; | 00:04 | |
r20793 | diakopter++ | a tester.pm;sbin/test facility introduced to make | |||
r20793 | diakopter++ | experimentation with Parser.pm easier. Stable | |||
r20793 | diakopter++ | checkpoint for the tester.pm grammar... | |||
00:16
armagad left
00:19
rian joined
00:22
araujo left
|
|||
pugs_svnbot | r20794 | diakopter++ | [yap6] a few more fixes | 00:31 | |
00:33
Limbic_Region left
00:37
apeiron_ joined
00:38
apeiron left,
apeiron_ is now known as apeiron
00:48
sri_work left
|
|||
diakopter | like, not cool. | 01:19 | |
turns out continuation passing style is wrong for this algorithm. so it's another refactoring. 8| | |||
01:31
Ched- joined
01:36
pbuetow joined
|
|||
pugs_svnbot | r20795 | diakopter++ | [yap6] converted back to normal rule production | 02:02 | |
r20795 | diakopter++ | now for making the ast generation actually work... | |||
02:14
thestarslookdown joined
02:55
pbuetow left
03:04
elmex_ joined
03:20
elmex_ is now known as elmex
04:03
r0bby joined
04:09
dominiko joined
04:14
Psyche^ joined
04:31
Psyche^ is now known as Patterner
04:55
bacek_ joined
05:02
bacek_ left
|
|||
pugs_svnbot | r20796 | diakopter++ | [yap6] well now it's just a very strict tokenizer... | 05:09 | |
Auzon | but does it work? ;) | 05:10 | |
diakopter | it does indeed tokenize. | ||
Auzon | How much can it tokenize? | ||
diakopter | :) | ||
I'm trying to invent a decent syntax for telling the grammar engine in what order the parsed "tokens" should be passed to the handler(s) | 05:11 | ||
05:16
bacek_ joined
05:17
bacek_ left
|
|||
Auzon | rakudo: class Foo {method Bar {1}}; say Foo.new.HOW.methods.perl | 05:18 | |
p6eval | rakudo r28335 OUTPUT[Method 'methods' not found for invocant of class 'P6metaclass'ā¤current instr.: '_block11' pc 52 (EVAL_12:21)ā¤ | ||
Auzon | rakudo: class Foo {method Bar {1}}; say Foo.new.^methods.perl | ||
p6eval | rakudo r28335 OUTPUT[MMD function __concatenate not found for types (152, -98)ā¤current instr.: 'parrot;Perl6;Grammar;Actions;dotty' pc 107997 (src/gen_actions.pir:8237)ā¤ | ||
pugs_svnbot | r20797 | diakopter++ | [yap6] | 05:22 | |
r20797 | diakopter++ | particle | |||
r20797 | diakopter++ | thinks | |||
r20797 | diakopter++ | *he's* | |||
r20797 | diakopter++ | embarassed | |||
r20797 | diakopter++ | .... | |||
r20798 | Auzon++ | [gsoc_spectest] moved what.t into the spec portion, and added new tests to check the difference between ."WHAT" and .WHAT when a WHAT method exists. | |||
r20799 | lwall++ | [STD5] implemented lazymap to defer some of the closure calls | 05:28 | ||
05:28
vsoni joined
05:29
thestarslookdown left,
vsoni left
|
|||
diakopter | yap6: say $a; my $foo = sub { has $ears; does $flying; };;; | 05:31 | |
p6eval | yap6 r20799 OUTPUT[parsed: [["use"],["v6"],[";"],["say"],["\$"],["a"],[";"],["my"],["\$"],["foo"],["="],["sub"],["{"],["has"],["\$"],["ears"],[";"],["does"],["\$"],["flying"],[";"],["}"],[";"],[";"],[";"],["EOI"]]ā¤] | ||
Auzon | .WHAT? We have no multiple inheritance tests? | ||
diakopter | see, told you it's just a tokenizer | ||
Auzon | yap6: class Foo is Bar {} | ||
p6eval | yap6 r20799 OUTPUT[syntax error near the end of inputā¤[["use"],["v6"],[";"],["class"],["Foo"]]] | ||
diakopter | well now | 05:32 | |
Auzon | :P | ||
pugs_svnbot | r20800 | diakopter++ | [yap6] class Foo is Bar {} | 05:34 | |
diakopter | or not | 05:35 | |
Auzon | dang. forgot to tag my last commit that I added 2 tests :-/ | 05:37 | |
diakopter | argh | 05:39 | |
Auzon | no worries. | ||
I just add it onto this one | |||
I think this is a sign for me to sleep. | |||
pugs_svnbot | r20801 | Auzon++ | [gsoc_spectest] more TASKS and tests for class methods with inheritance. (added 4 tests here) | ||
r20801 | Auzon++ | also, last time: (added 2 tests) | 05:40 | ||
05:44
araujo joined
05:52
alester joined
|
|||
diakopter | hrm; sumpthinz rawng whiff duh sawrce fi'ter | 05:53 | |
pugs_svnbot | r20802 | diakopter++ | [yap6] the afore-mentioned works now, but the related syntax checking is not | 05:55 | |
r20802 | diakopter++ | quite as technically strict as it ought to be.. | |||
diakopter | yap6: class ^Foo is Bar {} | 05:58 | |
p6eval | yap6 r20802 OUTPUT[parsed: [["use"],["v6"],[";"],["class"],["^"],["Foo"],["is"],["Bar"],["{"],["}"],["EOI"]]ā¤] | ||
diakopter | like I said, a super-strict tokenizer | ||
yap6: class ^Trunk (Elephant $Dumbo:, $crow) does Flying { has Ears; } | 06:06 | ||
p6eval | yap6 r20802 OUTPUT[parsed: [["use"],["v6"],[";"],["class"],["^"],["Trunk"],["("],["Elephant"],["\$"],["Dumbo"],[":"],[","],["\$"],["crow"],[")"],["does"],["Flying"],["{"],["has"],["Ears"],[";"],["}"],["EOI"]]ā¤] | ||
diakopter | yap6: use Another; package SomethingOrOther; | 06:08 | |
p6eval | yap6 r20802 OUTPUT[Can't declare a non-block package at lib/Perl6in5/Compiler/Parser.pm line 857.ā¤] | ||
diakopter | yap6: use Another; package SomethingOrOther { sub Begone {} ; } | 06:10 | |
p6eval | yap6 r20802 OUTPUT[parsed: [["use"],["v6"],[";"],["use"],["Another"],[";"],["package"],["SomethingOrOther"],["{"],["sub"],["Begone"],["{"],["}"],[";"],["}"],["EOI"]]ā¤] | ||
diakopter | well, panic() works | ||
ok well, finally the engine is decently stable and fast (enough)... tomorrow a zillion more rules. and probably lots of slowdown. | 06:15 | ||
06:20
iblechbot joined
06:43
Psyche^ joined
06:54
Psyche^_ joined,
Patterner left,
Psyche^_ is now known as Patterner
07:05
alester left
07:10
Psyche^ left
07:29
dominiko left
07:43
Jedai joined
07:53
gourav joined
|
|||
gourav | hi | 07:54 | |
is any one live here at this time | 07:56 | ||
07:57
gourav left
07:58
bacek joined
08:03
gourav joined
|
|||
gourav new to IRC and pugs | 08:05 | ||
had a wonderful chat last time | |||
can anyone suggest to start contributing where do I get started from exactly | |||
that is I am looking for some mentoring | |||
Tene | Hi, gourav! | 08:06 | |
What is it you're interested in? | |||
gourav | hi Tene | ||
just interested in starting to write some code for PERL6 development and thereby start contributing | 08:07 | ||
I know languages like PERL, PHP, VBA and C and presently learning JAVA as well | |||
Tene | gourav: your best bet is to look at parrot. That's the Perl 6 implementation that has been making the most progress lately. | ||
Pugs has been inactive for a long time. | |||
gourav | that's great | 08:08 | |
Tene | rakudo (the name for perl 6 on parrot) has been making a lot of progress lately. | ||
08:08
Ched- left
|
|||
Tene | The best channel for that is #parrot on irc.perl.org | 08:08 | |
What sort of tasks are you interested in? | |||
gourav | I went through quite a lot of documentation lately but was not able to find any area where i can look exactly what to code/ test for | ||
any ideas | 08:09 | ||
Tene | Okay, the main test suite is in the pugs repository, in the t/ directory. | ||
gourav | that sounds great but how do I go there | 08:10 | |
Tene | There are copies of the specifications online at spec.pugscode.org/ I believe. | ||
lambdabot | Title: Official Perl 6 Documentation | ||
Tene | Have you ever used svn before? | ||
moritz_ | perlcabal.org/syn/ <-- specification | ||
lambdabot | Title: Official Perl 6 Documentation | ||
Tene | Why do they both claim to be official? | ||
gourav | yeah use that regularly in office for saving code backup | ||
moritz_ | svn.pugscode.org/pugs <-- svn | 08:11 | |
lambdabot | Title: Revision 20802: / | ||
moritz_ | in t/TASKS there's a list of things that need testing | ||
gourav | join #parrot | ||
Tene | I think you said you're looking to write tests? | ||
gourav | yes quite true | ||
i think that should be starting point for me | |||
this will the first time that i will really be contrubuting | 08:12 | ||
(sorry for the sad english this keyboard is a little pesky) | |||
Tene | that is a great place to start | ||
gourav | Tene which is the great place to start | 08:15 | |
still have not found any place from where I can download any code from the SVN | |||
Tene | gourav: svn co svn.pugscode.org/pugs/ | 08:16 | |
lambdabot | Title: Revision 20802: / | ||
gourav | yeah found that | 08:17 | |
but as Tene said that the major development is happening on the PERL6 development on PARROT | |||
Tene | Yes, but they both share the same tests | 08:18 | |
gourav | good so how do I start the testing and contributing my test results | ||
Tene | What platform are you running on? | 08:19 | |
gourav | ubuntu | ||
their desktop edition | |||
Tene | Okay. | ||
svn co svn.perl.org/parrot/ | |||
lambdabot | Title: Revision 28335: / | ||
08:23
pmurias joined
|
|||
pmurias | gourav: you should also take a look at elf pugs/misc/elf | 08:25 | |
which is also actively developed | 08:27 | ||
08:41
kanru joined
08:44
gourav left
08:46
gourav joined
09:02
Ched- joined,
Ched- left
09:11
rian left
|
|||
moritz_ | uhm, checking out trunk/ of the parrot repo should be enough | 09:16 | |
09:17
meppl joined
09:19
barney joined
09:27
redicaps joined
09:28
cognominal_ joined
|
|||
Tene | oh, good suggestion. | 09:32 | |
09:35
gourav left
10:41
icwiener joined
11:09
cognominal_ left
11:11
meteorjay joined
11:12
pbuetow joined
|
|||
moritz_ | rakudo: say <a b>.WHAT | 11:16 | |
p6eval | rakudo r28336 OUTPUT[Listā¤] | ||
moritz_ | rakudo: say <a>.WHAT | ||
p6eval | rakudo r28336 OUTPUT[Strā¤] | ||
11:28
FurnaceBoy joined
11:33
Jedai left
|
|||
rakudo_svn | r28337 | particle++ | [rakudo] more list function tests for spectest_regression (moritz++) | 11:34 | |
11:34
chris2 joined
11:35
FurnaceBoy left
11:49
meppel-san joined
11:50
meppl left
12:08
kanru left
12:14
Jedai joined
12:18
kanru joined
12:47
ron joined
13:04
sri_work joined,
sri_work left,
sri_work joined
13:28
FurnaceBoy joined
13:49
bacek left,
ron left
13:50
Jedai left
13:52
cognominal_ joined
14:25
borondil joined,
a-jing joined,
a-jing left
14:28
ron joined
14:35
borondil left
14:37
borondil joined
14:42
wknight8111 joined,
Jedai joined
14:45
a-jing joined
14:52
FurnaceBoy left,
alester joined,
icwiener_ joined
15:05
xinming_ joined,
icwiener left
15:12
FurnaceBoy joined
15:19
Caelum_ joined
15:21
wknight8111 left
15:23
borondil left
|
|||
pmurias | is svnbot alive? | 15:39 | |
pugs_svnbot | r20803 | pmurias++ | [yap6] executables other than "perl" don't need to do perl5 recognition so "use v6" shouldn't be mandator in yap6 | ||
15:53
meppel-san left
|
|||
pmurias | diakopter: do you have an idea how to generate the sub foo(); list? | 15:59 | |
(other the stuffing it into the source filter) | |||
16:00
borondil joined
16:01
borondil left
|
|||
pugs_svnbot | r20804 | pmurias++ | [yap6] did the refactoring correctly | 16:08 | |
16:08
SubStack joined
16:16
a-jing left
|
|||
diakopter | pmurias: drat; I already had made a lot of changes there; that's ok; I'll merge them | 16:20 | |
thanks again... ! it was a tough problem for me | |||
pmurias | np | 16:21 | |
moritz_ | diakopter: that's why they say "commit early, commit often" ;) | ||
diakopter | I was trying to put your generation routines in Grammar.pm ... the only thing stopping me is getting the STD_hand.pm package name to the sub so it can put the symbols in the right place... any ideas? | 16:23 | |
I wonder if FILTER {} receives any arguments... | 16:24 | ||
(like the importing package's name) :) | |||
pmurias | diakopter: you can pass them through import | 16:25 | |
&import | |||
16:28
Jedai left
16:29
pmurias left,
pmurias joined
16:32
ron left,
alester left
16:33
chris2 left
|
|||
pmurias | (my new laptop)++ #having a hardware button to swith off the touchpad | 16:34 | |
why do you need the source filter to receive arguments? | 16:37 | ||
ruoso | perl6: my $cond = 0; my @a = $cond ?? 1 !! 2, 3, 4; | 16:39 | |
p6eval | kp6 r20804: OUTPUT[syntax error at position 37, line 1 column 37:ā¤my $cond = 0; my @a = $cond ?? 1 !! 2, 3, 4ā¤ ^ HEREā¤] | ||
..pugs: RESULT[[2, 3, 4]] | |||
..rakudo r28349: OUTPUT[Statement not terminated properly at line 1, near "?? 1 !! 2,"ā¤current instr.: 'parrot;PGE::Util;die' pc 120 (runtime/parrot/library/PGE/Util.pir:82)ā¤ | |||
..elf r20804: OUTPUT[Unknown rule: infix:conditionalā¤It needs to be added to ast_handlers.ā¤ at ./elf_f_faster line 2693ā¤] | |||
ruoso | perl6: my $cond = 0; my @a = $cond ?? 1 !! (2, 3, 4); | ||
pmurias | cycling& | ||
p6eval | kp6 r20804: RESULT[[ 2, 3, 4 ]] | ||
..pugs: RESULT[[2, 3, 4]] | |||
..rakudo r28349: OUTPUT[Statement not terminated properly at line 1, near "?? 1 !! (2"ā¤current instr.: 'parrot;PGE::Util;die' pc 120 (runtime/parrot/library/PGE/Util.pir:82)ā¤ | |||
..elf r20804: OUTPUT[Unknown rule: infix:conditionalā¤It needs to be added to ast_handlers.ā¤ at ./elf_f_faster line 2693ā¤] | |||
16:40
r0bby left
|
|||
diakopter | pmurias: oh; you're right; the source filter doesn't need it, but &rule does... | 16:43 | |
so I guess the source filter could insert __PACKAGE__ in there... without it being magical at the time... | 16:44 | ||
ruoso | moritz_, I've just replied to larry's reply on your post... I'm now a strong opposer of the our multi join(Any, Str) thing... | 16:46 | |
I've just realised that it could lead to a lot of false-hits | |||
moritz_ | ruoso: probably join(Any, *@rest) | ||
pmurias | diakopter: rule can use caller | 16:47 | |
16:47
Jedai joined
|
|||
ruoso | moritz_, Any being the separator? | 16:47 | |
I also realised that | |||
moritz_ | ruoso: forget what I just said, that was mindless | ||
ruoso | join 1, 2, 3, 4, ', ' | 16:48 | |
is kinda lame | |||
join ', ', 1, 2, 3, 4; makes much more sense | |||
moritz_ | join(Any $separator: *@rest) perhaps | ||
ruoso | yes... that's the p5 order... | ||
which seems to be inverted now... | |||
join(@things, $separator) is the proposed order... | |||
at least that is what I got from TimToady's reply... | 16:49 | ||
TimToady | no | ||
the multi syntax is exactly as in Perl 5 | |||
ruoso | so how 'str'.join('other') returns 'str'? | ||
TimToady | the single-dispatch syntax is purely $what_to_join($separator) | 16:50 | |
$what_to_join.join($sep) rahter | |||
and there is no failover (at least, not there) | |||
moritz_ | anyway, TimToady++ for a clear answer to my question | ||
ruoso | but if join is not a method of $what_to_join, it falls back by putting $what_to_join as first parameter... | 16:51 | |
so... $what_to_join.join($sep) becomes join($what_to_join, $sep) | |||
TimToady | there is no fall back if it hits the .join method in Any | ||
ruoso | ohhhhhhhhhhhhhhhh | ||
TimToady | and may never be any fallback anyway if we also open Door 3 | ||
but that's an independent decision, more or less | 16:52 | ||
ruoso | yes... now it is... | 16:53 | |
so... forget about the reply I just sent five minutes ago ;) | 16:54 | ||
16:55
pmurias left
16:56
[particle] joined
|
|||
Auzon | TimToady++ # thanks for seeing the issues that I thought about with $unknown.join('foo') | 16:58 | |
TimToady | ruoso: hasn't come through yet, so I'll have to remember to forget it... :) | 16:59 | |
ruoso | TimToady, btw... had you thought more about the meta calls? | 17:06 | |
TimToady | no, but I can probably think about it after my talk on Monday | 17:07 | |
ruoso | alright... | ||
TimToady | brane is currently in STDspace | ||
ruoso | btw... if the fallback to sub-dispatch is dropped, the other issue pending on p6-language would also be solved... | 17:08 | |
TimToady | most of the need for fallback was already dealt with via "is export", which handles the case where you *do* want to shadow the method with foo($invocant,@args) | 17:10 | |
it's just that join isn't one of those | |||
ruoso | each second I like more the idea of dropping it | ||
it would make the dispatch much simpler | 17:11 | ||
TimToady | which is why I asked for a use case some time ago, and haven't really heard one | ||
ruoso | oh.. you meant a use case where the fallback is actually needed.. | ||
not a confusing one... | |||
TimToady | yes, a reason to include the feature | 17:12 | |
ruoso | I really think it brings a lot of unexpected trouble... | ||
because the Package and the Class have unrelated lives | 17:13 | ||
and Package modification could cause unexpected changes in Classes | |||
and the dispatcher will be much more complicated... | |||
TimToady | well, it would just be one dispatch calling the other dispatcher when it runs out of candidates | 17:14 | |
moritz_ | TimToady: wouldn't it make sense to move most of the List builtins to Positional? | ||
ruoso | that would require the object dispatcher to introspect to get the CALLER semantics | ||
moritz_, actually we still need a more clear "iterator" api... | 17:15 | ||
TimToady | Positional implies indexibility, and you can join something that you can iterate, even if it doesn't provide a subscript interface | ||
so maybe Iterable | |||
or some such | |||
moritz_ | TimToady: ok, makes sense | ||
ruoso | Iterable and RWIterable? | 17:16 | |
moritz_ | so prefix:= is defined by default or Iteratable ? | ||
TimToady | I wish people wouldn't use the parrot shortcut to name operators... | ||
moritz_ | no need for separate roles if we have parametrized mixins, I think | ||
prefix:<=> # better? | 17:17 | ||
TimToady | much easier to read, I think | ||
17:18
kanru left
|
|||
TimToady | and unamibuous when you want to talk about circumfix:<( )> vs circumfix:Ā«< >Ā» | 17:18 | |
*unambiguous | |||
17:18
Effington joined
|
|||
ruoso | about the API... I know the "Iterable" API seems a lot to be implementation specific... but higher-level "Iterable" implementations that want to behave like normal lists need to have that API as a standard | 17:19 | |
like... for (@foo) --> $x {...} | 17:20 | ||
where @foo is implemented by some high-level class | |||
17:21
cognominal_ left
17:22
cognominal_ joined
|
|||
ruoso | or simply foo() ==> bar() ==> baz() | 17:22 | |
17:23
kanru joined
17:24
Jedai left
17:28
cognominal_ left
17:35
cognominal_ joined
17:42
Effington left
17:44
Chillance joined
17:46
pbuetow left,
pbuetow joined
17:52
icwiener-_- joined,
icwiener-_- is now known as icwiener
17:57
kanru left
18:05
chris2 joined
18:07
chris2 left
18:09
icwiener_ left
18:14
holst joined
|
|||
holst | I read about the C# bytecode and how they have "true multidimensional arrays" | 18:15 | |
however, they enforce C ordering | |||
does the bytecode in the new perl6 system support both Fortran and C ordering? | |||
diakopter | pmurias - I figured out how to move your routines to Perl6in5::Grammar... I used a tricky mixin. :p | 18:16 | |
TimToady | holst: it would depend on which new perl6 system you're talking about. Perl 6 the language doesn't care, though if it did care it would tend toward C. But Perl 6 objects are opaque in layout, and that includes arrays. | 18:19 | |
holst | so there are no shape associated with the arrays in the byte code? | 18:20 | |
wolverian | which byte code? | 18:21 | |
holst | I was reading some BLISS code and they have the ability to define general access methods for multidimensional arrays: diagonal, n-diagonal, symmetric, ... :) | 18:22 | |
[particle] | holst: there are multiple implementations of perl 6, so there's no one bytecode | 18:23 | |
holst | the shape isnt passed-with of course but must be explicit stated | ||
[particle]: aha | |||
but there will be a single one right? isnt "parrot" this? | |||
[particle] | no | ||
there will be multiple implementations of perl, just like c | 18:24 | ||
as long as the implementations pass the official test suite, they're officially perl 6 | |||
holst | ok, I should ask in any of the implementation channels/ | 18:25 | |
[particle] | many implementors are here | ||
kp6, smop, rakudo (on parrot), pugs... | 18:26 | ||
oh, also elf | |||
i'm a parrot core committer, and we have array-of-array, not true multidim arrays | 18:29 | ||
ruoso | even in each implementation... there can be different array implementations coexisting... | ||
[particle] | but, we're open to the possibility, just haven't had anyone spec/develop something along those lines | ||
ruoso | I suspect that if someone declares my $foo = Array of Array of int; $foo .= new(); might be optimized to a bidimensional int array | 18:31 | |
TimToady | and then what do you do when they say $foo.push(1,2,3,5)? | 18:32 | |
holst | [particle]: thats because the high performance computing people hasnt been interested yet :) | 18:33 | |
but I think that JITs will be more and more common in this field | |||
TimToady | $foo.push([1,2,3,4],[5,6,7,8]) rather | ||
[particle] | holst: precisely. are you one? :) | ||
holst | [particle]: well, I work with numbers :) | ||
TimToady | we've certainly been trying to keep the hpc folks in mind while designing :) | 18:34 | |
18:34
yahooooo joined
|
|||
ruoso | holst, the thing is... nothing stops some module that bind to a high-performance array implementation in C, for instance... | 18:37 | |
it is supposed to be much easier to do that in P6 than it is in P5 | |||
thanks to the representation polymorphism | 18:38 | ||
holst | yes, but now there is a possibility to raise the bar on what is an "basic type" | ||
18:39
eternaleye_ left
|
|||
holst | having multidimensional arrays as a basic type, with both C and Fortran ordering, would be a great feature as far as I could tell | 18:39 | |
TimToady | just as Perl 5 allowed you to talk to two databases at once, so too Perl 6 will allow you to specify your ordering both ways if the underlying implementation supports it | 18:40 | |
holst | the modern versions of BLAS and LAPACK uses a feature called "dummy arrays" and they carry with them their shape information | ||
TimToady | it is hoped that the Perl 6 type system is flexible enough to slurp in any existing metadata and run with it | 18:42 | |
ingy | hi TimToady | ||
TimToady | the only real question is whether it'll be too flexible for the optimizers to get a good handle on | 18:43 | |
hi ingy | |||
ingy | going to Chicago? | ||
TimToady | there already | ||
you in .tw? | |||
ingy | me too | ||
no, Chicago | |||
TimToady | I'm at the hackathon | 18:44 | |
holst | TimToady: the dummy arrays are a fact since 1990 in the fortran community; so there is quite a bit of research in how to work with them :) | ||
ingy | see you tomorrow unless you go to the naked bike ride tonight... | ||
TimToady | hadn't planned on it, but you never know... | ||
ingy | :D | ||
holst | anyways, I must read up on the parrot system | ||
moritz_ | holst: #parrot on irc.perl.org will answer parrot specific questions ;) | 18:45 | |
TimToady | S09 and S12 talk about shaped arrays and the object system | ||
from the language view | 18:46 | ||
holst | the reason I started to investigate this, is that I found a forum post which described a real problem: | 18:47 | |
the C# bytecode causes some problem with interoperability betewen fortran subroutines and routines writtein in VB.net or other languages | |||
so you can only pass 1-dimensional arrays (with assumed shape) | 18:48 | ||
[particle] | parrotcode.org/docs/pdds/ | ||
sorry, www.parrotcode.org/docs/pdd/ | |||
lambdabot | Title: Parrot Documentation :: Parrot Design Documents - parrotcode | ||
TimToady | well, obviously, if you're dealing with different layouts, someone has to take responsibility to interconvert, and hopefully Perl 6 can be that someone if it has the right metadata | 18:49 | |
but the language itself takes pains to keep the shape an abstract concept | 18:50 | ||
ruoso | SMOP solves that by using the "Responder Interface" concept... every object points to the object that knows that object's shape... | 18:51 | |
TimToady | course, that still doesn't mean that you can just write Fortran in Perl 6. :) | 18:53 | |
moritz_ | which is considered a feature ;) | 18:54 | |
holst | moritz_: well, I suspect that a bug will appear soon. the system seems to be broken by design, with such features as: | 19:02 | |
en.wikipedia.org/wiki/Parser_Grammar_Engine | |||
moritz_ | holst: what do you mean? | ||
holst | I mean, implementing Fortran (or a subsect like F) seems almost doable with that toolchain:) | 19:04 | |
moritz_ | holst: TimToady said you couldn't simply write Fortran in Perl 6 (ie without major changes), he didn't talk about parrot + PCT | ||
yath | .oO(hmm, i wonder if i could implement RPG in perl6 rules *hides*) |
19:05 | |
(RPG as in Report Program Generator) | |||
moritz_ | sure you can implement Fortran with parrot, although it will probably not as fast as native compilers (which are darn fast) | ||
holst | some day they might be | 19:06 | |
moritz_ | some day parallel computing will be *much* more important than micro-optimized code | ||
holst | yes, but having the JIT determine loop unrolling instead of the compiler makes more sense | 19:07 | |
yath | moritz_: the erlang guys keep telling this for ten years :P | ||
moritz_ | yath: I know, but *my* laptop now has two cores - it didn't back then ;) | 19:08 | |
yath: and 8 cores aren't out of the normal right now | |||
pugs_svnbot | r20805 | diakopter++ | [yap6] updated STATUS; now the grammar module is extremely | 19:09 | |
r20805 | diakopter++ | terse; thanks to pmurias++ for Perl101-fu | |||
yath | moritz_: well, erlang processes are pretty lightweight, but i suspect the overhead of parallelising everything is rather huge. | ||
moritz_ | perl 6 tries to be very future proof ;) | ||
yath | moritz_: OTOH, if the interpreter or compiler does the job for you, there's no problem for you :P | ||
diakopter | shoulda named it yap110 | ||
holst | the problem is the interconnect between nice programming languges and the hardware | 19:10 | |
moritz_ | yath: that's where we're trying to go ;) | ||
holst | today you have about 2-3 different languages to choose from if you want to do stream computing on a GPU, say | ||
yath | why should i care about my hardware when programming? | ||
that's an implementation detail | |||
holst | lol | ||
yes | |||
moritz_ | more than half of my friends think that they should care about memory management manually | 19:11 | |
"because GCs suck" | |||
yath | even your goddamn cpu is "interpreting" the opcodes. | ||
holst | GCs are probably better than them on memory management | ||
yath | (in software, that is) | ||
Tene | some gcs | ||
;) | |||
moritz_ | IMHO memory management is yet another implmentation detail | ||
yath | holst: so is a compiler. | ||
Tene: not counting perl5's? :P | 19:12 | ||
moritz_ | yath: yes. But Java's GC has a bad reputation (because it used to be very bad), and many others are just plain b0rked | ||
holst | yath: you reasoning does not make sense about "just an implementation detail" | ||
yath | moritz_: well, java actually is very nice in this case, because you are able to *tune* (only per vm, unfortunately) either which gc is used and its parameters | ||
holst | if you want programmer productivity you must first give the programmer a GOOD language that is suitable for the job | 19:13 | |
yath | isn't that what perl6 aims to do? :) | ||
ruoso | the problem in Java GC is that it is not deterministic | ||
moritz_ | yath: yes, but many java VMs only handle a fixed amount of memory, to be configured at startup | ||
yath: or at least that's how it used to be | 19:14 | ||
yath: and that's a decision nobody wants to make - rightfully. It's another implementation detail in your way | |||
diakopter | yap6: use F; package E { sub a {} ; } | ||
p6eval | yap6 r20805 OUTPUT[parsed: [["use"],["v6"],[";"],["use"],["F"],[";"],["package"],["E"],["{"],["sub"],["a"],["{"],["}"],[";"],["}"],["EOI"]]ā¤] | ||
yath | moritz_: yes. well, java (the VM) is not perfect, but it's better than the people claim. | ||
TimToady | requiring determinism to achieve a correct solution is one part of the problem :) | ||
yath | moritz_: (speaking of the hotspot vm, of course. kaffe may do things different) | 19:15 | |
holst | determinism is just a philosophy | ||
ruoso | sometimes, when you're doing something CPU-intensive... the footprint will enlarge considerably, because the GC thread has a lower priority | ||
moritz_ | TimToady: well, it's very nice to know that your file is being closed immediately when your file handles goes out of scope ;) | ||
yath | ruoso: well, one could give the gc some hints. | ||
ruoso | sure... but in the end, I kinda like refcounting... | 19:16 | |
yath | uh? | ||
moritz_ | yath: that's where people start to say "if I have to give hints anyway, I can do it all on my own" | ||
ruoso | because it's plain simple and deterministic behaviour | ||
yath | doing at least two operations for each reference of a pointer? | ||
TimToady | yes, but relying on accidental implementation-based determinism is bad, when you should make explicit what the dependencies are in your code | ||
ruoso | hmm... | ||
TimToady | if the code doesn't express the required dependencies, it's bogus in some sense | 19:17 | |
yath | moritz_: uh, well, with this attitude i could also program in assembler. | ||
ruoso | the code being inside a for loop seems deterministic code to me | ||
TimToady | which "for" are you referring to? | ||
ruoso | java for | ||
moritz_ | yath: I know. But that's what people say nonetheless :( | ||
yath | moritz_: i admit that it's relevant to know how things are implement SOMETIMES (e.g. when dealing with performance or golfing :P), but that should be <1% of production code. | 19:18 | |
Tene | diakopter: what's that parser thing you keep playing with in here? | ||
ruoso | I've already experienced the java GC getting late on a for loop... | ||
yath | s/implement/&ed/ | ||
ruoso | and sometimes you have to manually hint the gc to give it priority | ||
(they even have an API to that) | |||
diakopter | Tene: :P sorry; it's my little Perl-6-ish lexer/tokenizer. I'm augmenting it to a parser now. | ||
yath | ruoso: hu? how is it called? | 19:19 | |
ruoso | GarbageCollector or something... | ||
yath | hm | ||
ruoso | netbeans have a button so you can call it manually | ||
before it extends the footprint | |||
it's rediculous | |||
yath | i know of System.gc(), but that just.. well.. it doesn't trigger the gc, it does.. hm | ||
it _maybe_ triggers the gc ;) | |||
ruoso | that's the point where I start to kinda like refcounting... | 19:21 | |
diakopter | Perl101 === Perl5 | 19:22 | |
moritz_ | "you know what is in Perl 101. Everybody knows what is in Perl 101" | 19:23 | |
diakopter | /join #perl110 | ||
my last commit broke SVN::Web: www.parrotvm.org/svn/pugs/revision/?rev=20805 | 19:25 | ||
lambdabot | Title: revision: /pugs (via SVN::Web) | ||
moritz_ | diakopter: bad boy | 19:26 | |
diakopter | it's too bad; it would be a fun diff to read | ||
holst | thanks for all the info TimToady and moritz_! | 19:27 | |
just a final question | |||
will Perl6 beat Duke Nukem Forevers release date? :) | |||
(dont answer that) | 19:28 | ||
19:28
holst left
|
|||
diakopter | when DNF is written in Perl 6, no. | 19:28 | |
moritz_ | will Duke Nukem Forever be out before christmas? ;-) | ||
19:31
pmurias joined
|
|||
pmurias | j | 19:32 | |
pugs_svnbot | r20806 | diakopter++ | [yap6] backing out my backout of pmurias' un-backout | 19:33 | |
diakopter | pmurias: tinyurl.com/4pouej | 19:34 | |
lambdabot | Title: view: /pugs/misc/yap6/src/lib/Perl6in5/Grammar/STD_hand.pm (Rev: HEAD, via SVN:: ... | ||
19:37
ruoso_ joined
19:38
ruoso_ is now known as ruoso
19:39
barney left
|
|||
pmurias | diakopter: there is a syntax error | 19:43 | |
diakopter | ? works for me... | ||
pugs_svnbot | r20807 | diakopter++ | [yap6] committing in case I fixed a syntax error since the last commit | 19:45 | |
r20808 | pmurias++ | [yap6] fixed tiny syntax error | |||
diakopter | oh, that... thanks | 19:46 | |
I was using tester.pm after all. | |||
19:47
sri_work left
|
|||
pugs_svnbot | r20809 | moritz++ | [spec] moved basechar.t to ignoreaccent.t, changed modifier name to reflect | 19:47 | |
r20809 | moritz++ | current synopsis, updated smartlink | |||
19:47
sri_work joined
|
|||
pmurias | is hit an acronim? | 19:48 | |
diakopter | hit()? it can mean to "reach/arrive at" | ||
"the train hit the station" | 19:49 | ||
19:50
coppercore joined
|
|||
diakopter | I guess it's a colloquialism | 19:50 | |
pugs_svnbot | r20810 | pmurias++ | [yap6] removed useless declarations | ||
coppercore | moritz_: do you care for me using your logbot on a channel? | ||
moritz_ | coppercore: it's free software, go right ahead ;) | ||
coppercore | ok | 19:51 | |
:) | |||
moritz_ | coppercore: it would be nice if you kept the attribution line in the footer, but add your own contact details | ||
coppercore | of course | ||
19:56
wknight8111 joined
|
|||
pmurias | diakopter: what sould live in Perl6in5 Object/*? | 19:56 | |
19:56
wknight8111 left
|
|||
diakopter | pmurias: I was merely dreaming when I added those; they can be deleted if you feel like pughouse cleaning | 19:57 | |
pmurias: have you tried the TRACE output yet? :) | |||
export TRACE=2 (don't go much higher than 2 unless you want to fill up your disk/memory) | 19:58 | ||
pmurias | not yet | 20:01 | |
do you use a seperate tokeniser? | 20:02 | ||
pugs_svnbot | r20811 | moritz++ | [spec] first simple tests for :sameaccent regex modifier | ||
diakopter | pmurias: nope; the whole thing is a tokeniser. it would be impossible to do it in >1 passes... | 20:03 | |
moritz_ | yap6: say 1; | ||
p6eval | yap6 r20811 OUTPUT[parsed: [["use"],["v6"],[";"],["say"],[1],[";"],["EOI"]]ā¤] | ||
moritz_ | that's actually not a parse tree, just the tokenizer's output | ||
yap6: 2*(1+3) | |||
p6eval | yap6 r20811 OUTPUT[parsed: [["use"],["v6"],[";"],[2],["*"],["("],[1],["+"],[3],[")"],["EOI"]]ā¤] | ||
diakopter | pmurias: although, much of it could probably be vastly accelerated by converting many of the rules to have RE hints. | 20:04 | |
moritz_: yep I'm adding in the hierarchers/orderers now | |||
pmurias | RE hints - that's inelegant | ||
diakopter | true | ||
pmurias | such things should be generated automaticly | 20:05 | |
;) | |||
diakopter | oh yeah; I was speculating about that the other day... | ||
since all of these parser generators are reversible (so far) | |||
pmurias | food& | ||
diakopter | they could conceivably be compiled to something | ||
pmurias | is yap6 O(N) | 20:10 | |
? | |||
diakopter | no; but if mapply() were enabled (and working correctly) theoretically it would be. | ||
pmurias | with the packrat thingy? | 20:11 | |
diakopter | b/c it has direct right recursions it's geometric. | ||
pmurias: yeah the packrat memoizer/pruner | |||
pugs_svnbot | r20812 | moritz++ | [spec] some more :sameaccent and :ignoreaccent tests | ||
20:12
icwiener left
|
|||
diakopter | enabling mapply() (in parser()) slows down the parsing of small inputs greatly... I haven't experimented with how it affects the speed of tokenizing larger inputs. | 20:12 | |
if there are lots of right-associated nested expressions, it might speed it up, if I understand the theory correctly. | 20:13 | ||
pmurias | geometric is O(n**2) ? | ||
diakopter | there isn't any left recursion in the grammar (yet) | ||
so it doesn't help there | |||
yeah, polynomial; sorry | 20:14 | ||
pmurias | O(n*what)? | 20:15 | |
pugs_svnbot | r20813 | pmurias++ | [yap6] removed Perl6in5::Object | ||
diakopter | again, based on my (highly possibly suspect) understanding... I dunno. whatever a vanila/naive recursive descent parser is where there are right recursions | ||
pmurias | diakopter: should i removed unused MJD stuff such as Iterator.pm | 20:18 | |
? | |||
diakopter | sure | ||
leave Stream and Regex | 20:19 | ||
pmurias | too late | 20:25 | |
pugs_svnbot | r20814 | pmurias++ | removed unused MJD stuff and empty files | ||
pmurias | what was in Regex? | 20:27 | |
diakopter | some more parser combinators | ||
pmurias | ones not implemented yet? | ||
diakopter | the rudiments of yetyetyet another Perl 5 RE engine | ||
pmurias | Stream is lazy lists? | 20:28 | |
diakopter | it was from hop.perl.plover.com/Examples/ALL/Regex.pm | ||
yeah | |||
pmurias | Stream dosn't look very appealing | 20:31 | |
diakopter | no; I yanked it from being used for the input feeder | 20:32 | |
(by Lexer.pm) | |||
converted it to something closer to STD5.pm | |||
and Cursor5.pm | |||
pmurias | diakopter: should the source filter generates sub predeclarations? | 20:36 | |
diakopter | pmurias: that would be really cool; I don't know how to do it | ||
pmurias | it will be a hack :( | 20:40 | |
svnbot is lazy :( | 20:47 | ||
pugs_svnbot | r20815 | pmurias++ | [yap6] sub predeclaration are generated by the source filter | ||
pmurias | diakopter: any other wishes? | ||
diakopter | ohhh.... I didn't realize FILTER was called only once... | 20:48 | |
figures | |||
pmurias | i would suggest porting yap6 to elf but not having a compile part of the edit-test cycle is a refreshing difference | 20:50 | |
diakopter | you could write rules for the version of pod that's in STD | ||
20:52
borondil joined
|
|||
pmurias | ok | 20:52 | |
diakopter | but no, I don't have any more wishes; that's a super-clean pure-Perl-5 grammar | ||
well, with a bit of source filtering | |||
pmurias | shouldn't we use &lit instead of &hit | 20:53 | |
20:53
meppel-san joined,
justatheory joined
|
|||
diakopter | pmurias: sounds good to me; if it makes better sense to you | 20:53 | |
I assume you mean literal | 20:54 | ||
pmurias | yes | ||
20:55
eternaleye joined
|
|||
pmurias | diakopter: ++ and -- could be replaced with some other operators | 20:57 | |
diakopter | pmurias: any ones that have the right precedence and fixation | ||
pmurias: oh wait, it's using a source filter anyway so it doesn't matter! :D | 20:58 | ||
pmurias | although +ws is only one char longer then ++ dosn't require any filtering and is self explanatory | 20:59 | |
diakopter | ok. and -ws for optional ws? | 21:00 | |
pmurias | yes | ||
the }{ rule dosn't seem to be used and it's just looking for truble | 21:01 | ||
* trouble | 21:02 | ||
diakopter | pmurias: I'm using it in tester.pm | ||
rule some { otherrule }{ handler code }; | 21:03 | ||
unless you have another idea | |||
I wanted something other than },sub { | |||
I didn't like mjd's syntax ( { } >> sub { } | 21:05 | ||
21:06
justatheory left
|
|||
pmurias | my limited experience with source filtering js is that they only don't cause trouble if you do something extremly blunt | 21:06 | |
diakopter: what is the second block meant to do? | |||
got it | 21:08 | ||
diakopter | handle the list of results from the rule match (to put them in the proper order, insert a function name | ||
or a callback | |||
pmurias | why can't we embed the handling code inside | ||
diakopter | that's an idea | 21:09 | |
rule some { hit - handle( handler() ) } | |||
they could be generated similarly to the parsers | |||
actually it would be . handle | 21:10 | ||
so it doesn't slurp whitespace | |||
is that what you had in mind? | 21:11 | ||
pugs_svnbot | r20816 | Auzon++ | [gsoc_spectest] fixed some .WHAT tests. (Added 1 test) | ||
pmurias | diakopter: yes | ||
diakopter | ok; I like that idea better... it uses the existing infrastructures | ||
diakopter svn revert | 21:12 | ||
21:13
icwiener joined
|
|||
pugs_svnbot | r20817 | pmurias++ | [yap6] removed "features" from the source filter | 21:13 | |
pmurias | shower& | ||
21:13
[particle] left
21:17
borondil left
21:19
dmq left
21:23
justatheory joined
|
|||
pmurias | the '.' hack could be replace with overload::constant | 21:32 | |
OTOH it could just be removed | 21:34 | ||
diakopter | removed how? | 21:35 | |
pmurias | '.' being converted to lit('.') | ||
diakopter | oh that | ||
but 'a' is pretty close to Perl 6 style | 21:36 | ||
pmurias | overload::constant could also be used | 21:37 | |
but it would also affect "." and q{.} etc. | |||
diakopter: are the rules in STD_hand.pm in any order? | 21:48 | ||
diakopter | no | ||
pmurias | what is tester.pm? | 21:52 | |
diakopter | the much shorter grammar I'm using for experimenting | ||
it's just the basic calculator | |||
I used it to test the longest-match mechanism | 21:53 | ||
and it does handle nested right associatives ok | 21:54 | ||
pugs_svnbot | r20818 | pmurias++ | [yap6] changed &hit to &lit | ||
diakopter | +p6ws will never match anything | 21:56 | |
b/c you're asking for whitespace after you've already slurped up all intervening whitespace | |||
(should be ".p6ws") | 21:57 | ||
pmurias | right | ||
re handlers are you working on them? | 22:00 | ||
pugs_svnbot | r20819 | pmurias++ | [yap6] small fix | ||
diakopter | pmurias: yep | ||
22:00
camgirl29 joined
|
|||
pmurias | what do you return from them? | 22:00 | |
diakopter | a modified version of the hashref that was inputted (same as the other parsers) | 22:01 | |
pmurias | you mean the Match object? | ||
diakopter | $in , in all the combinators | 22:02 | |
committing | |||
22:02
camgirl29 left
|
|||
pmurias | what editor are you using? | 22:02 | |
diakopter | at the office, Notepad++, at home/road, TextMate | ||
pugs_svnbot | r20820 | diakopter++ | [yap6] rudimentary (proof-of-concept) for post parse handlers | 22:03 | |
diakopter | why; are the line endings or encoding broken or something? | ||
um; I thought I reverted those earlier changes.... fixing | 22:04 | ||
pmurias | diakopter: no just curious | ||
diakopter | they're both pretty powerful - plenty for me at least | 22:05 | |
pmurias | thought we could try using gobby sometime if you are not using a vi based editor | ||
diakopter | nobody commented on my Perl5=Perl101;Perl6=Perl110 joke... ;) | 22:08 | |
pmurias | as only i would be inconvinienced at using non-vi key bindings | ||
pugs_svnbot | r20821 | diakopter++ | [yap6] cleanup of mis-reversions | ||
22:10
bacek joined,
coppercore left
|
|||
pmurias | it should be possible to create match objects automaticly | 22:10 | |
diakopter | how does one force list context.. | 22:11 | |
I know about scalar() | |||
Eevee | list? | 22:12 | |
as in, list() | |||
or do you mean p5 | |||
diakopter | sorry yes Perl 5 | ||
pmurias | (something,) | ||
diakopter | :D | ||
thx | |||
Eevee | yeah that | 22:13 | |
pugs_svnbot | r20822 | diakopter++ | [yap6] a proof of concept that actually works | 22:14 | |
diakopter | I'm thinking: both() should put its results on the same tier; one() should put it in a new tier | 22:15 | |
one's the horizontal dimension; the other is the vertical | |||
22:16
cognominal_ left
|
|||
pmurias | diakopter: tier? | 22:18 | |
diakopter | in the ast | ||
or really, in the interpretation plan | |||
22:19
[particle] joined
|
|||
pmurias | diakopter: it's speced how much objects should look like | 22:20 | |
diakopter | ? | ||
whereat | |||
S00 | 22:21 | ||
pmurias | S05 | ||
Return Values from matches | 22:22 | ||
diakopter | oh... I hadn't realized that was similar to what I was doing | 22:23 | |
hm | |||
pmurias | good night | 22:25 | |
22:26
pmurias left
22:28
justatheory left
|
|||
diakopter | TimToady: in S05 ... s/pattern/{ eval doit() }/ shouldn't that be { try...? I misunderstand. | 22:30 | |
22:30
Limbic_Region joined
|
|||
diakopter | or does that eval the string resulting from doit() ? | 22:37 | |
TimToady | the latter | 22:41 | |
Limbic_Region hopes to see many of you at YAPC in the next few days | |||
22:45
Eevee_ joined
|
|||
diakopter | TimToady: S05:350 - sentence lacks a word I think | 22:51 | |
specifically, a verb | 22:53 | ||
23:11
[particle] left
23:30
FurnaceBoy left
|
|||
diakopter | for yap6, as{} will signify "interpret/understand/model as/by"... and to{} will signify "evaluate/destination/outcome". | 23:38 | |
that way, all the declarations/procedures relating to a single atom/variable are together. | 23:40 | ||
23:52
mjk joined
|