Perl 6 | Rakudo | Specs | Parrot | source cross referenced
← Previous day | Index | Channel Index | Today | Next day → | Search | Google Search | Plain-Text | plain, newest first
All times shown according to UTC.
| Time | Nick | Message |
|---|---|---|
| 00:36 | Alias_ joined #perl6 | |
| 00:49 | silug joined #perl6 | |
| 01:07 | eternaleye joined #perl6 | |
| 01:08 | pugs_svn | r22549 | lwall++ | [assign.t] missing semicolons |
| 01:23 | r22550 | lwall++ | [STD] there is no infix:<is> (was hiding missing semicolons in assign.t) | |
| 01:23 | r22550 | lwall++ | [viv] much improved typology of EXPR asts (and doesn't lose nested ops) | |
| 01:29 | alanhaggai joined #Perl6 | |
| 01:37 | BinGOs joined #perl6 | |
| 01:48 | hercynium_ joined #perl6 | |
| 01:51 | PZt joined #perl6 | |
| 02:04 | alester joined #perl6 | |
| 02:22 | eternaleye joined #perl6 | |
| 02:48 | agentzh joined #perl6 | |
| 02:49 | pugs_svn | r22551 | lwall++ | [basic.t] default expression must come after traits |
| 02:52 | r22552 | lwall++ | [viv] autogenerate VAST packages as needed | |
| 03:09 | ab5tract joined #perl6 | |
| 03:31 | felipe joined #perl6 | |
| 03:44 | agentzh joined #perl6 | |
| 04:16 | pugs_svn | r22553 | lwall++ | [viv] can now reconstruct the p6 from the ast for simple expressions |
| 04:55 | masak joined #perl6 | |
| 05:07 | Psyche^ joined #perl6 | |
| 05:13 | |Jedai| joined #perl6 | |
| 05:20 | Bzek joined #perl6 | |
| 05:28 | |Jedai| joined #perl6 | |
| 06:08 | BinGOs_ joined #perl6 | |
| 06:10 | agentzh joined #perl6 | |
| 06:29 | ashizawa joined #perl6 | |
| 06:48 | alester joined #perl6 | |
| 06:58 | iblechbot joined #perl6 | |
| 06:59 | alester joined #perl6 | |
| 07:04 | penk joined #perl6 | |
| 07:08 | agentzh joined #perl6 | |
| 07:11 | sri_work joined #perl6 | |
| 07:13 | agentzh left #perl6 | |
| 07:17 | agentzh joined #perl6 | |
| 07:23 | viklund joined #perl6 | |
| 08:03 | cosimo joined #perl6 | |
| 08:06 | BinGOs_ joined #perl6 | |
| 08:15 | elmex joined #perl6 | |
| 08:27 | jferrero joined #perl6 | |
| 08:53 | BinGOs joined #perl6 | |
| 09:16 | renormalist joined #perl6 | |
| 09:36 | tomyan joined #perl6 | |
| 09:44 | moritz_ | std: class A { sub :foo { say bar }; }; |
| 09:44 | lambdabot | moritz_: You have 1 new message. '/msg lambdabot @messages' to read it. |
| 09:44 | p6eval | std 22553: OUTPUT[Unknown routines: bar called at 1 parsed] |
| 09:44 | moritz_ | @massages |
| 09:44 | lambdabot | azawawi said 11h 46m 54s ago: any-list.pir p5chop and p5chomp is running all tests now. Patches are on RT. Thanks. |
| 09:54 | meppl joined #perl6 | |
| 10:18 | Bzek joined #perl6 | |
| 10:29 | xinming_ joined #perl6 | |
| 10:37 | xinming joined #perl6 | |
| 10:37 | Ontolog joined #perl6 | |
| 10:46 | xinming_ joined #perl6 | |
| 10:47 | dmq joined #perl6 | |
| 10:48 | dmq left #perl6 | |
| 10:59 | [particle] joined #perl6 | |
| 10:59 | ruoso joined #perl6 | |
| 11:03 | xinming joined #perl6 | |
| 11:05 | moritz_ | @tell azawawi thanks for the patch. However (as the others that modify self) I'll wait wih applying until the lexical issues are sorted out |
| 11:05 | lambdabot | Consider it noted. |
| 11:06 | penk left #perl6 | |
| 11:13 | xinming joined #perl6 | |
| 11:29 | pugs_svn | r22554 | ruoso++ | [smop] small bugfix in native bool was causing unexpected behavior |
| 11:30 | ruoso | er... actually it wasn't the bugfix that was causing the unexpcted behavior... *sigh* |
| 11:35 | alanhaggai joined #Perl6 | |
| 11:47 | kanru joined #perl6 | |
| 12:05 | bjakb joined #perl6 | |
| 12:08 | bjakb | hello? |
| 12:08 | moritz_ | hi |
| 12:10 | xinming joined #perl6 | |
| 12:11 | bjakb | I have a problem with the Pugs installation, can somebody might help me? |
| 12:11 | moritz_ | I can try |
| 12:12 | but only if I know what your problem is | |
| 12:13 | bjakb2 joined #perl6 | |
| 12:13 | bjakb | sorry I have a problem with my irc client could you please repeat your answer? |
| 12:14 | moritz_ | the logs are at irc.pugscode.org |
| 12:14 | in short "I can try" | |
| 12:18 | bjakb2 | OK, I'm following the installation instructions of pugs |
| 12:18 | moritz_ | which instructions? |
| 12:18 | bjakb2 | that is the best to install it with cabal |
| 12:18 | 'cabal update' | |
| 12:19 | 'cabal install Pugs' | |
| 12:19 | kanru joined #perl6 | |
| 12:19 | moritz_ | ok |
| 12:19 | bjakb2 | to be able to do that you have to install a few haskell packages - which i did install |
| 12:20 | I was also able to run the two mentioned cabal commands | |
| 12:20 | the installation went through without any errors | |
| 12:20 | But, at the end, I cannot run pugs | |
| 12:21 | I can also not find any pugs binary | |
| 12:22 | moritz_ | the binary will be in ~/.cabal/ somewhere |
| 12:22 | probably ~/.cabal/Pugs/bin/pugs or something along these lines | |
| 12:22 | which OS are you on? | |
| 12:25 | Ontolog joined #perl6 | |
| 12:28 | bjakb2 | say 'hello' :-) |
| 12:29 | moritz: the binary was indeed in the ~/.cabal directory - thanks | |
| 12:29 | moritz_ | bjakb2: you're welcome |
| 12:31 | bjakbh joined #perl6 | |
| 12:33 | bjakb2 | the next thing I want to try is to compile perl6 code into perl5 - that sounds interesting |
| 12:34 | moritz_ | I don't think that's properly implemented in pugs |
| 12:34 | elf does it, though | |
| 12:35 | ruoso | pugs: module Foo { sub bar { baz() } }; &Foo::baz := sub { say 1 }; Foo::bar() |
| 12:35 | p6eval | pugs: OUTPUT[1] |
| 12:35 | bjakbh | elf? - never heard of that |
| 12:35 | moritz_ | elf: say "hi"; |
| 12:35 | p6eval | elf 22554: OUTPUT[hi] |
| 12:36 | moritz_ | see also http://perl.net.au/wiki/Elf |
| 12:36 | lambdabot | Title: Elf - PerlNet |
| 12:37 | ruoso | pugs: module Foo { sub bar { our $foo = 1; }; sub baz { say $foo } }; Foo::bar(); Foo::baz(); |
| 12:37 | p6eval | pugs: OUTPUT[***  Unexpected " }" expecting "::" Variable "$foo" requires predeclaration or explicit package name at /tmp/Bwbo2aprAs line 1, column 59] |
| 12:38 | ruoso | pugs: module Foo { sub bar { our &foo := sub { say 1 } }; sub baz { say foo() } }; Foo::bar(); Foo::baz(); |
| 12:38 | p6eval | pugs: OUTPUT[*** Cannot use Undef as a Code object at /tmp/vScVoZWa3S line 1, column 67-73] |
| 12:42 | ruoso | pugs: module Foo { sub bar { our sub foo { say 1 } }; sub baz { foo() } }; Foo::baz(); |
| 12:42 | p6eval | pugs: OUTPUT[1] |
| 12:44 | ruoso | that means one of two things: |
| 12:44 | 1) The package variables are visible as if they were declared as "our" even if there isn't such a declaration... | |
| 12:44 | 2) sub dispatch sees if the current package CANDO that after looking in the lexical scope | |
| 12:45 | moritz_ | ruoso: 'our sub' is the same as 'sub' |
| 12:45 | ruoso | but the local name is installed inside that scope only... |
| 12:47 | bjak joined #perl6 | |
| 12:47 | moritz_ | hurm |
| 12:48 | ruoso | which probably means that the option 2 is the correct one |
| 12:48 | alester joined #perl6 | |
| 12:49 | ruoso | sub dispatch is 'no strict' |
| 12:49 | it falls back to global lookup (by global meaning looking up in the package, and not only on the lexical scope) | |
| 12:50 | pugs: $Foo::bar = 1; module Foo { sub foo { say $bar } }; Foo::foo(); | |
| 12:50 | p6eval | pugs: OUTPUT[***  Unexpected " }" expecting "::" Variable "$bar" requires predeclaration or explicit package name at /tmp/uEICR3JQar line 1, column 47] |
| 12:50 | ruoso | pugs: &Foo::bar = sub { 1 }; module Foo { sub foo { say bar() } }; Foo::foo(); |
| 12:50 | p6eval | pugs: OUTPUT[*** Can't modify constant item: VStr "MkCode {isMulti = True, subName = \"&\", subType = SubPrim, subOuterPads = [], subInnerPad = MkPad (padToList []), subPackage = , subAssoc = AIrrelevantToParsing, subParams = [], subBindings = [], subSlurpLimit = [], subReturns = (mkType \"An... |
| 12:50 | ruoso | pugs: &Foo::bar := sub { 1 }; module Foo { sub foo { say bar() } }; Foo::foo(); |
| 12:50 | p6eval | pugs: OUTPUT[1] |
| 12:51 | moritz_ | ruoso: re sub lookup is 'no strict', that's my feeling as well |
| 12:53 | ruoso | pugs: &Foo::bar := sub { 1 }; module Foo { sub foo { say &bar.() } }; Foo::foo(); |
| 12:53 | p6eval | pugs: OUTPUT[***  Unexpected ".()" expecting "::" or signature value Variable "&bar" requires predeclaration or explicit package name at /tmp/pstwoiEGm4 line 1, column 56] |
| 12:53 | ruoso | indeed... it looks like so... |
| 12:55 | alright... so it looks that sub dispatch does: | |
| 12:55 | 1) looks for all variants from the lexical scope and from package CANDO | |
| 12:55 | bjakb joined #perl6 | |
| 12:56 | ruoso | (it traverses itself the lexical scope, so a inner declaration doesn't mask the outer declaration) |
| 12:56 | greps for the ACCEPTS | |
| 12:56 | moritz_ | (CANDO sounds like a reactor from a nuclear power plant; but I probably confuse that with CANDU) |
| 12:56 | ruoso | sorts using a "pluggable disambiguation code" |
| 12:57 | and invoke the first | |
| 12:57 | and we leave a cache of all variants in the innermost declaration as the room for optimizations | |
| 12:57 | moritz_ | sounds sane |
| 12:58 | Alias_ joined #perl6 | |
| 13:00 | Alias__ joined #perl6 | |
| 13:01 | z80ASM joined #perl6 | |
| 13:26 | pmurias joined #perl6 | |
| 13:30 | pmurias_ joined #perl6 | |
| 13:30 | pmurias | is it possible to add multi variants at runtime? |
| 13:31 | moritz_ | yes |
| 13:32 | pmurias | how? ;) |
| 13:33 | moritz_ | proto foo; eval 'sub foo($x) { $x*2 }'; say foo(2); |
| 13:35 | pmurias | perl6: multi foo(1) {say 3};foo(1); |
| 13:35 | p6eval | pugs: OUTPUT[***  Unexpected "1" expecting formal parameter or ")" at /tmp/yOHlPNDb3K line 1, column 11] |
| 13:35 | ..elf 22554: OUTPUT[No viable candidate for call to multimethod foo(#) at (eval 121) line 4 at ./elf_f line 3861] | |
| 13:35 | ..rakudo 31827: OUTPUT[Statement not terminated properly at line 1, near "{say 3};fo"current instr.: 'parrot;PGE::Util;die' pc 119 (runtime/parrot/library/PGE/Util.pir:82)] | |
| 13:35 | pmurias | perl6: multi foo(Int $a) {say 3};foo(1); |
| 13:35 | p6eval | elf 22554, pugs, rakudo 31827: OUTPUT[3] |
| 13:35 | BinGOs joined #perl6 | |
| 13:36 | moritz_ | perl6: multi foo(Int $x) { say "Int" }; eval 'multi foo(Str $x) { say "Str" }'; foo(1); foo("bar"); |
| 13:36 | p6eval | elf 22554, rakudo 31827: OUTPUT[IntStr] |
| 13:36 | ..pugs: OUTPUT[IntInt] | |
| 13:36 | moritz_ | elf++ |
| 13:36 | rakudo++ | |
| 13:36 | pmurias | is it possible to close multis? |
| 13:37 | like use multi :closed? | |
| 13:37 | moritz_ | dunno |
| 13:37 | don't think it makes much sense | |
| 13:37 | pmurias | why? |
| 13:38 | moritz_ | because multis are one of teh central mechanism to get extensibility into Perl 6 |
| 13:38 | ruoso | http://www.perlfoundation.org/[…]ulti_sub_dispatch |
| 13:38 | lambdabot | Title: SMOP Multi Sub Dispatch / Perl 6, http://tinyurl.com/43fhyt |
| 13:39 | Lorn joined #perl6 | |
| 13:39 | pmurias | ruoso: hi |
| 13:39 | ruoso | hi pmurias |
| 13:42 | pmurias | ruoso: withought variant disambiguation multis wouldn't be more powerfull then normal methods |
| 13:42 | ruoso | indeed |
| 13:42 | pmurias, refresh the wiki page ;) | |
| 13:43 | BinGOs joined #perl6 | |
| 13:44 | pmurias | we also need to check for ambiguity |
| 13:44 | that is there need to be 1 topmost item | |
| 13:45 | ruoso | pmurias, I think the disambiguation code would 'fail' in that case |
| 13:46 | pmurias | ok |
| 13:49 | xinming joined #perl6 | |
| 13:49 | pmurias | ruoso: can i remove the nasty adjective |
| 13:49 | ? | |
| 13:49 | abra joined #perl6 | |
| 13:49 | ruoso | yeah... :) |
| 13:49 | moritz_ | ;) |
| 13:53 | pmurias | got to run to eat something and catch a train |
| 13:53 | & | |
| 13:57 | alester joined #perl6 | |
| 14:08 | [particle]1 joined #perl6 | |
| 14:13 | iblechbot joined #perl6 | |
| 14:36 | sscaffidi joined #perl6 | |
| 14:36 | coke joined #perl6 | |
| 15:01 | z80ASM joined #perl6 | |
| 15:06 | rakudo_svn | r31829 | pmichaud++ | [rakudo]: spectest-progress.csv update: 205 files, 4366 passing, 11 failing |
| 15:15 | justatheory joined #perl6 | |
| 15:20 | ab5tract joined #perl6 | |
| 15:25 | mj41 joined #perl6 | |
| 15:28 | z80ASM joined #perl6 | |
| 15:38 | xinming_ joined #perl6 | |
| 15:41 | ruoso | TimToady, if you have some time, could you please take a look at http://www.perlfoundation.org/[…]ulti_sub_dispatch |
| 15:41 | lambdabot | Title: SMOP Multi Sub Dispatch / Perl 6, http://tinyurl.com/43fhyt |
| 15:42 | Exodist joined #perl6 | |
| 15:45 | lisppaste3 joined #perl6 | |
| 15:46 | TimToady | I never have some time :) |
| 15:46 | unless you count negative time... | |
| 15:47 | PerlJam | ruoso: I just looked at it and your examples look single-dispatchy |
| 15:48 | ruoso | PerlJam, what do you mean? |
| 15:49 | TimToady | thinking about lexical CANDO now :) |
| 15:50 | kanru joined #perl6 | |
| 15:51 | TimToady | as someone mentioned earlier, you need to deal with ambiguities too |
| 15:51 | jhorwitz joined #perl6 | |
| 15:54 | TimToady | and there are probably a few other things from S12:876 that will need to be considered eventually |
| 15:55 | though a lot of it can be swept under the carpet of "sorting" | |
| 15:55 | but it basically looks sane | |
| 15:56 | ruoso | lexical CANDO? |
| 15:56 | TimToady | lexical autoloading of some sort or other |
| 15:56 | probably only dynamic response, not install new symbols | |
| 15:57 | ruoso | ah... I see... |
| 15:57 | it seems heavyweight to call CANDO for every lexical scope in the tree | |
| 15:57 | TimToady | but it would be nice to intercept the query on the way outward |
| 15:57 | xinming_ joined #perl6 | |
| 15:58 | ruoso | TimToady, probably installing symbols at runtime is better |
| 15:58 | instead of doing the AUTOLOAD way | |
| 15:59 | TimToady | well, the presence of a CANDO in an outer lexical scope would basically pessimize the ability to know what a name means at compile time |
| 15:59 | but that can be known at compile time :) | |
| 15:59 | ruoso | oh... I see... you're actually thinking about CANDO not being in the package at all |
| 16:00 | TimToady | that's what I mean by "lexical" |
| 16:00 | coke | has anyone written a rule to english translator? |
| 16:00 | lambdabot | coke: You have 1 new message. '/msg lambdabot @messages' to read it. |
| 16:00 | ruoso | I initially read that as "additionally in the lexical scope" |
| 16:00 | TimToady | but also potentially in the package, as it is currently |
| 16:01 | ruoso | ok... |
| 16:01 | so it basically means adding another step... | |
| 16:01 | TimToady | anyway, just a thought, doesn't even need a bit in the lexical scope unless you actually find a my CANDO at compile time |
| 16:02 | ruoso | hmm... I see... the presence of a CANDO would generate a degenerated lexical scope object |
| 16:03 | TimToady | which would know to treat the CANDO as * |
| 16:03 | it's probably not worth worrying about right now | |
| 16:03 | ruoso | yeah... it looks like something that can be just plugged in |
| 16:03 | TimToady | can be retrofitted to the compiler if we decide to do it later |
| 16:03 | alanhaggai joined #Perl6 | |
| 16:07 | z80ASM joined #perl6 | |
| 16:07 | diakopte1 | moritz_: you pinged |
| 16:09 | diakopter | moritz_: you pang |
| 16:09 | moritz_ | diakopter: yes, about the SVN::Web stuff, but Infinioid helped me to sort it out in the mean time |
| 16:10 | diakopter | that guy is very resourceful |
| 16:10 | what was wrong with it | |
| 16:10 | moritz_ | it died on every request :/ |
| 16:11 | diakopter | what caused that symptom |
| 16:11 | moritz_ | assertion failure in some svn libs... changing a path from '/' to '' helped |
| 16:15 | exodist_ joined #perl6 | |
| 16:16 | pugs_svn | r22555 | moritz++ | [t/spec] unfudge passing tests in split-simple.t |
| 16:31 | [particle] joined #perl6 | |
| 16:33 | pugs_svn | r22556 | moritz++ | [t/spec] more tests for unchanged source string in transliteration tests. |
| 17:07 | xinming joined #perl6 | |
| 17:12 | mberends joined #perl6 | |
| 17:17 | jferrero joined #perl6 | |
| 17:18 | apeiron joined #perl6 | |
| 17:27 | raiph joined #perl6 | |
| 17:31 | jan_ joined #perl6 | |
| 17:32 | meppl joined #perl6 | |
| 18:05 | rakudo_svn | r31835 | moritz++ | [rakudo] workaround for RT #59730 by cjfields++ (Str.trans with closures) |
| 18:06 | pugs_svn | r22557 | moritz++ | [t/spec] unfduge passing test, cjfields++ |
| 18:10 | pyrimidine joined #perl6 | |
| 18:14 | Exodist joined #perl6 | |
| 18:19 | abra joined #perl6 | |
| 18:32 | pugs_svn | r22558 | moritz++ | [t/spec] added a test file for infix:<where> |
| 18:36 | moritz_ | I would appreciate it if somebody could take a look at r22558, not sure I fully understood that operator |
| 18:38 | Southen_ joined #perl6 | |
| 19:02 | zamolxes joined #perl6 | |
| 19:12 | smg joined #perl6 | |
| 19:14 | [particle1 joined #perl6 | |
| 19:18 | [particle1 left #perl6 | |
| 19:35 | TimToady | moritz_: well, I don't know if I'm somebody, but it looks okay to me. |
| 19:36 | moritz_ | TimToady: you're somebody enough to count in this one ;) |
| 19:36 | TimToady | it's a bit subtle that the closures doing appending are returning true |
| 19:36 | moritz_ | subtle, but intended ;) |
| 19:36 | TimToady | well, but you could say $x ~= 'b'; True to be explicit |
| 19:37 | moritz_ | right |
| 19:37 | TimToady | just thinking of the Gentle Reader |
| 19:38 | btw, thanks for all your spectacular work on the test suite | |
| 19:39 | moritz_ | my pleasure |
| 19:39 | TimToady | what's your opinion of changing all the is $a,$b to ok $a eqv $b? |
| 19:39 | or maybe even making the builtin ok an infix? | |
| 19:40 | so you could say $a eqv $b ok "message" | |
| 19:40 | moritz_ | wait a sec... |
| 19:40 | TimToady | well, would look better with ok lined up with tabs |
| 19:41 | moritz_ | I like "ok" up front |
| 19:41 | TimToady | or maybe the builtin tests could be $a eqv $b OK "message"; |
| 19:42 | well I like what you're testing up front :) | |
| 19:42 | and I don't like commas | |
| 19:42 | moritz_ | why do you want to make them all operators? |
| 19:42 | TimToady | esp when they can be confused with precedence |
| 19:42 | moritz_ | re all is $a, $b to ok $a eqv $b, I think many comparisons should stay string comparisons |
| 19:43 | TimToady | well, that's the trouble, people are using them both ways, so ok would make it explicit |
| 19:43 | moritz_ | right |
| 19:44 | TimToady | anyway, I'm just trying to think of a construct that reads more like "and", except it has to pay attention to the right side all the time |
| 19:44 | fullermd | "with"? |
| 19:45 | moritz_ | well, the infix:<where> is rather confusing when read as english |
| 19:45 | TimToady | in fact, ok doesn't work well because it's the wrong valence, and because it disappears too easily in the middle |
| 19:45 | moritz_ | that's why you suggested OK, right? |
| 19:45 | as all caps | |
| 19:45 | TimToady | yes, but also to hide the builtin a little better, since there are other functions too |
| 19:46 | not that anyone is going to want to define infix:<DIES_OK>, but you never know... :) | |
| 19:46 | moritz_ | anyway, I think that explicit comparison semantics are good, but I somehow fear all the work that it will make |
| 19:46 | TimToady | another reason I want to get rid of "is" is because it's overloaded in Perl 6 |
| 19:46 | moritz_ | right |
| 19:47 | TimToady | but I know how to work around that |
| 19:47 | (though it's ugly) | |
| 19:47 | [particle]1 joined #perl6 | |
| 19:47 | TimToady | still, I'd rather not have the cognitive dissonance |
| 19:47 | and the is test is horribly imprecise | |
| 19:49 | well, one argument (a weak one) for keeping a verb out front is that you could more easily make macros that way for evalish arguments | |
| 19:49 | but of course that's awfully fancy | |
| 19:49 | moritz_ | right now I'd rather rewrite all is() tests to ok() than rewriting everything to infix operators; but I don't see how early implementations can give good summaries of failing tests |
| 19:49 | TimToady | you mean with an infix? |
| 19:50 | don't see a problem with ok() | |
| 19:50 | moritz_ | ok $a eq $b would just say "not ok", whereas is() can tell you what's expected and what you got |
| 19:50 | TimToady | ah |
| 19:50 | moritz_ | so unless you have a very clever macro you loose the information too early |
| 19:52 | TimToady | I wonder how easy it would be to allow parameter properties that capture the text of the parameter, not because you want to reprocess the text like a macro, but simply for documentation |
| 19:52 | could write assert() using that too | |
| 19:53 | as long as the original program is available as a string, and we know where the argument started and stopped, it could be done. | |
| 19:53 | moritz_ | but how does that help with error reporting? |
| 19:54 | TimToady | right, still doesn't give you the two values...drat... |
| 19:54 | moritz_ | an assert($x eq $y) would know '$x eq $y' and true/false |
| 19:57 | unless it would peek into the AST of its arguments, which is really non-trivial | |
| 19:57 | TimToady | maybe there wants to be a metaoperator, as long as we're dreaming |
| 19:57 | because you can change is to iseq, iseqv, but is== is not good | |
| 19:58 | don't really need to deal with AST, I think | |
| 20:00 | moritz_ | so would you write '$x iseq $y OK "message";'? |
| 20:01 | that'd be confusing, to say the least | |
| 20:01 | TimToady | something like that, though that's kind of ugly |
| 20:01 | but something that would automatically capture $x, $y, '$x eq $y', and eval '$x eq $y' | |
| 20:01 | well, and maybe 'eq' | |
| 20:02 | moritz_ | still sounds like too much magic for basic implementations |
| 20:03 | TimToady | could always hardwire 'ok' into the grammar too |
| 20:04 | as long as we're building in test ops, that would not be terribly difficult | |
| 20:05 | after all, all the built-in constructs are essentially macros | |
| 20:05 | and the utility of this might well outweigh the futility :) | |
| 20:06 | * moritz_ | isn't entirely convinced |
| 20:07 | TimToady | people weren't entirely convinced by fudge either :) |
| 20:07 | moritz_ | aye ;) |
| 20:08 | TimToady | anyway, if we set up the syntax such that a stupid ok could work without macroizing, but you just get less info, that's probably cool |
| 20:08 | then if the grammar redirects to a smart ok, we just get more info | |
| 20:09 | moritz_ | maybe you could even convince viv to rewrite the tests automatically |
| 20:10 | TimToady | well, that'd be at the parse tree or ast level, but sure, that's about the right level to recognize the structure of the first argument |
| 20:11 | on the other hand, if it's just a grammar rule, we just pick the right precedence to pick off the two sides of the comparison | |
| 20:12 | several equivalent aproaches | |
| 20:14 | moritz_ | brb |
| 20:14 | FurnaceBoy joined #perl6 | |
| 20:16 | pmichaud | it almost cries out for making it clear that 'ok', 'is', etc. are truly test operators |
| 20:17 | so maybe infix:<?is> infix:<?ok> | |
| 20:17 | where ?is is a ternary. | |
| 20:18 | or, infix:<?is> keeps its arguments somewhere that ?ok can use in a diagnostic message | |
| 20:18 | $a ?is $b ?ok "variable equivalence" | |
| 20:18 | moritz_ | in a contet var, or something? |
| 20:18 | pmichaud | true ?ok "truth" |
| 20:19 | I'm just throwing out notions here -- I'm not convinced myself. | |
| 20:20 | maybe it's another meta prefix | |
| 20:20 | $a ?eqv $b :diag<equivalence of variables> | |
| 20:20 | TimToady | there are obvious infelicities in the current approach, so we might as well fix 'em all :) |
| 20:20 | pmichaud | although ? wouldn't work well as the meta prefix. |
| 20:20 | r0bby joined #perl6 | |
| 20:20 | TimToady | yeah, I was thinking about metaops earlier |
| 20:20 | pmichaud | oh, I guess it wouldn't be toooooo bad |
| 20:20 | moritz_ | pmichaud: in principle I like the notation, but it looks like more character noise |
| 20:21 | pmichaud | maybe it's just an adverb to the existing ops? |
| 20:21 | $a eqv $b :test<items are equivalent> | |
| 20:21 | $a eq $b :test<items are string equivalent> | |
| 20:21 | TimToady | I was thinking if we wrote 'ok' as a macro the extra info would come in as named args |
| 20:22 | so the first two args would still be the boolean and the string | |
| 20:22 | pmichaud | but the advantage of tying it to the comparison operator is that it has the operands immediately available for a diagnostic message |
| 20:22 | TimToady | hmm, interesting syntax |
| 20:22 | pmichaud | unless we have "interesting values of boolean" :-) |
| 20:22 | TimToady | Test Yourself! |
| 20:23 | pmichaud | it could even be |
| 20:23 | $a eq $b :ok<items are string equivalent> | |
| 20:23 | if there's no :ok adverb, then it's not part of the test output. | |
| 20:23 | TimToady | and the operator knows its own identity too |
| 20:23 | pmichaud | of course, this assumes that we have adverbs, which might be a little difficult in a newish implementation :-| |
| 20:24 | I'm guessing it's less difficult now that there's a standard grammar, though. | |
| 20:24 | TimToady | which is the advantage of a stupidish ok $a eqv $b, "string" |
| 20:24 | with extra named args containing the pertinent bits of the first arg | |
| 20:24 | which a stupid "ok" can ignore | |
| 20:24 | zamolxes joined #perl6 | |
| 20:25 | pmichaud | rakudo's lack of adverb support is mostly because it wasn't entirely clear how to get them into the grammar |
| 20:25 | (whereas it's much clearer now.) | |
| 20:25 | TimToady | but especially with tabs before :ok it could look very clean |
| 20:26 | pmichaud | yes |
| 20:26 | BinGOs joined #perl6 | |
| 20:26 | pmichaud | ....and.... |
| 20:26 | TimToady | it would also be pretty easy to preprocess into a stupider form |
| 20:26 | pmichaud | a newbie compiler could just treat :ok as a special syntax |
| 20:26 | TimToady | assuming one per line |
| 20:26 | pmichaud | until it has full adverb support |
| 20:26 | TimToady | that too |
| 20:26 | moritz_ | one per line isn't always realistic |
| 20:27 | TimToady | now we just have the problem of dispatching to the version of comparisons that supports the :ok parameter... :/ |
| 20:27 | pmichaud | it's also nice because the default :ok could give a reasonable message based on the operator type |
| 20:27 | i.e., $a eqv $b :ok | |
| 20:27 | could give a nicer error message than ok($a eqv $b) | |
| 20:27 | s/error/diagnostic/ | |
| 20:28 | TimToady | "FOO isn't eqv to BAR you #$&*@#$&!" |
| 20:28 | pmichaud | exactly. |
| 20:28 | that's much nicer. | |
| 20:28 | how many comparisons would need to support :ok? | |
| 20:28 | most other comparisons could be reduced (in tests) to versions that support :ok, same as we do now | |
| 20:29 | TimToady | I wonder how often we'd have people making the error of trying to interpoalte into :ok<bad $x pardner> |
| 20:29 | pmichaud | I also wonder what happens with negative comparisons |
| 20:30 | $a != $b :ok<not equal> | |
| 20:30 | I guess that actually works. | |
| 20:30 | TimToady | presumably meta-! needs to know about it |
| 20:30 | pmichaud | anyway, I think I've tossed my popcorn for now. |
| 20:30 | er, peanuts | |
| 20:30 | TimToady | peanuts hurt more |
| 20:31 | pmichaud | (I used to go to melodramas where the "peanut gallery" actually threw popcorn at the actors) |
| 20:31 | TimToady | anyway, I think this could be a new state of the art |
| 20:31 | moritz_ | agreed |
| 20:31 | TimToady | and it doesn't look terribly hard |
| 20:31 | pmichaud | the :ok adverb? really? I did something good? ;-) |
| 20:32 | TimToady | for once :P |
| 20:32 | moritz_ | if it's reasonable to implement (which I can't really judge) I'm all for it |
| 20:32 | TimToady | well, even if it's unreasonable, wouldn't be the first time I forced it anyway... :) |
| 20:32 | pmichaud | THAT'S for sure! :-P |
| 20:33 | TimToady | after all, Perl Philosphy is simply to torment the implementors on behalf of the user |
| 20:33 | pmichaud | aha! I have a quote for my keynote. |
| 20:33 | moritz_ | lol |
| 20:33 | pmichaud | and perhaps a theme. |
| 20:33 | TimToady | wow, I said something good (for once) |
| 20:35 | FurnaceBoy | eh, you're frequently quotable. |
| 20:35 | <TimToady>ASCII just doesn't have enough brackets... I've noticed this before... | |
| 20:36 | pmichaud | that's why we make new ones, like "<< >>" |
| 20:36 | and #{ ... } | |
| 20:36 | and =begin FOO ... =end FOO | |
| 20:36 | TimToady | there aren't enough quotidian quotes |
| 20:37 | pmichaud | and even things like '(' ~ ')' <EXPR> |
| 20:37 | which is a particularly bizarre form of bracketing construct :-) | |
| 20:37 | TimToady | in which the contents leak out of the brackets :) |
| 20:38 | moritz_ | so what happens to plan()? |
| 20:38 | TimToady | why should it change? |
| 20:38 | moritz_ | everything else is an operator now |
| 20:38 | pmichaud | we still want todo(), plan() |
| 20:39 | TimToady | we just want to throw out the "use Test;" part |
| 20:39 | unless you want a different tester | |
| 20:40 | moritz_ | so 'use Test::Most' would just overwrite... what? |
| 20:40 | the :ok part, somehow? | |
| 20:40 | TimToady | all those functions that aren't there anymore :) |
| 20:40 | pmichaud | :ok becomes the "builtin" form for testing, but other modules can still define their own "is", "ok", "dies_ok", "is_deeply", whatever equivalents |
| 20:40 | as normal functions | |
| 20:41 | TimToady | I wonder if people are going to be upset by our taking :ok as an adverb |
| 20:41 | pmichaud | on the operators? |
| 20:42 | moritz_ | so if somebody wants to change the behaviour of :ok, which hooks do they pull? |
| 20:42 | pmichaud | or in general? |
| 20:42 | TimToady | write a set of comparisons that have :ok as a named parameter and included in the current lexically scope more tightly than the builtins from the prelude |
| 20:42 | that's all | |
| 20:43 | and you only have to redefine the ones you want to change | |
| 20:44 | that's why lexically scoped multis interleave with other longnames from other scopes the way they do | |
| 20:44 | (used to be the other way till we got smarter) | |
| 20:45 | anyway, the :ok call won't dispatch at all to a version that doesn't support :$ok as a parameter | |
| 20:46 | pmichaud | that might result in "spooky at a distance" |
| 20:46 | TimToady | I presume the proto has :ok in it but the standard operator leaves that out of the sig |
| 20:46 | how so? | |
| 20:46 | pmichaud | $a foo $b might dispatch differently from $a foo $b :ok |
| 20:46 | TimToady | that's true of any multi |
| 20:46 | pmichaud | someone simply adding an :ok might not recognize the difference. |
| 20:46 | true. | |
| 20:47 | moritz_ | so there's no magical :ok that turns an infix op into a test, as a fallback? |
| 20:47 | TimToady | fudge --ok |
| 20:47 | hmm, that is a problem for fudge | |
| 20:48 | apeiron joined #perl6 | |
| 20:48 | TimToady | how will it recognize the beginning of a statement if there's no "is/ok" there? |
| 20:49 | another problem: $x eqv $a + $b :ok will apply the :ok to the + | |
| 20:50 | pmichaud | oh well. |
| 20:50 | it was a nice thought. :-) | |
| 20:50 | TimToady | they'd have to write $x eqv ($a+$b) :ok |
| 20:50 | but that's just how adverbs work on operators | |
| 20:50 | moritz_ | another test suite faq |
| 20:51 | pmichaud | presumably $a + $b :ok would not dispatch? |
| 20:51 | i.e., there wouldn't be a matching infix:<+> | |
| 20:51 | TimToady | probably not, so at least it's an error |
| 20:51 | albeit at runtime | |
| 20:51 | but hey, that's when you run the tests, at runtime :) | |
| 20:52 | so it can still fly, I think | |
| 20:52 | still have the fudge problem though | |
| 20:53 | unless we have an "is" placeholder at the beginning, or some such | |
| 20:53 | or change the rules for how fudge recognizes a test | |
| 20:53 | split into statements and assume anything containing :ok is a test, maybe | |
| 20:54 | where "split into statements" pays attention only to final ; or } | |
| 20:56 | moritz_ | and we significantly increase the number of builtin multis |
| 21:00 | TimToady | but the presence or absence of a named argument is known at compile time, so the candidate list can be optimized even before we know any of the types |
| 21:00 | pmichaud | ...and one could write the builtins with optional named params |
| 21:01 | TimToady | that seems like a recipe for slow builtins |
| 21:01 | moritz_ | aye |
| 21:01 | pmichaud | yes |
| 21:03 | TimToady | very likely the :ok versions delegate to the non-:ok versions for the actual work |
| 21:03 | and it seems like there's going to be a lot of boilerplate | |
| 21:04 | which argues more for a metaoperator | |
| 21:04 | maybe :ok is really a metaoperator in disguise | |
| 21:05 | it just happens to bind to the same operator as a real adverb | |
| 21:07 | pbuetow joined #perl6 | |
| 21:07 | TimToady | but always just generates the appropriate underlying operator you need |
| 21:08 | sort of a semantic pass macro | |
| 21:09 | PerlJam | Are you guys talking about adding testing operators to perl 6? |
| 21:09 | moritz_ | yes |
| 21:09 | PerlJam | awesome! |
| 21:09 | pmichaud | PerlJam: making test functions part of the builtins, yes. |
| 21:09 | moritz_ | PerlJam: the current approach looks like this: $x == 2, :ok<$x is really 2>; |
| 21:09 | TimToady | no comma |
| 21:10 | moritz_ | erm, withotu the comma |
| 21:10 | right | |
| 21:10 | PerlJam | er, how does :ok know not to bind to the 2 ? |
| 21:10 | pmichaud | adverbs bind to operators |
| 21:10 | TimToady | it's where an infix is expected |
| 21:11 | same way 1..10:by(2) knows | |
| 21:11 | PerlJam | aye, I just haven't looked at perl6 syntax in a while. |
| 21:12 | so, all of the comparators grok :ok ? | |
| 21:12 | (or will) | |
| 21:12 | TimToady | make :ok a crypto-meta-operator that rewrites any operator that returns boolean |
| 21:13 | PerlJam | so, what happens to $a == 2 && $b == 3 :ok<fooey> ? Do I need parens or something? |
| 21:13 | moritz_ | probably around the second == |
| 21:13 | TimToady | that one would silently fail currently |
| 21:13 | I mean, fail to work as expected | |
| 21:13 | you'd get a useless use of, maybe | |
| 21:14 | PerlJam | it would silently suceed where it may should have failed :) |
| 21:15 | TimToady | it's possible we should reformulate adverbs a bit |
| 21:15 | I wonder if they can be made to apply to the *top* operator visible | |
| 21:15 | instead of the last one | |
| 21:15 | then this would apply to the && instead of the == | |
| 21:16 | PerlJam | How far up the parsetree should they look? :-) |
| 21:16 | TimToady | but 1..10:by(2) would still work |
| 21:16 | pmichaud | then of course we have the issue of ... and 1..10:by(2) |
| 21:16 | TimToady | only inside the current scalar item, I think |
| 21:17 | so make it slighty tighter than comma | |
| 21:17 | pmichaud: that would be fine since :by is tighter than and | |
| 21:17 | && would be more of a problem | |
| 21:18 | PerlJam | This is starting to feel like the "regular" syntax version of that weird regex ~ thingie |
| 21:19 | Use the special <MAGIC HERE> operator for all your testing needs. | |
| 21:20 | pmichaud | I have to go help kids with their homework |
| 21:20 | bbl | |
| 21:22 | PerlJam | So ... what was wrong with ok($test,$str) ? Or, why do we need another form? |
| 21:22 | tewk_ joined #perl6 | |
| 21:24 | TimToady | we talked about that eariler, doesn't provide anything beyond a boolean unles ok is a macro |
| 21:24 | moritz_ | PerlJam: one of the problems is that is() isn't very verbose about its comparison semantics |
| 21:25 | PerlJam: and changing that to ok($a eqv $b) doesn't give any useful diagnostic output | |
| 21:25 | TimToady | backlog about the last 2 hours... |
| 21:26 | PerlJam | okay. |
| 21:27 | so, an adverb that attaches to the highest precedence operator in the previous expression ? And all adverbs or just special ones with nice syntactic markers? | |
| 21:28 | TimToady | highest within , precedence |
| 21:28 | so basically loose unary precedence like "not", but a postfix | |
| 21:29 | kulp joined #perl6 | |
| 21:29 | azawawi joined #perl6 | |
| 21:30 | TimToady | but unlike current formulation, can see within (), so $a and ($b and $c) :foo applies to the second and, because it's the top operator in the expression governed by the :foo |
| 21:30 | assuming you'd never want to apply an adverb to (), which we already assume | |
| 21:32 | PerlJam | Those seem like really special adverbs. Could we make them look lik ^:foo or something? |
| 21:32 | s/lik/like/ | |
| 21:32 | TimToady | but since tigher than comma, works in the middle of a list: 1,2,3..10:by(2), 4,5 |
| 21:33 | the only thing special is that it would write the code for you instead of dispatching to a multi with an :ok parameter | |
| 21:33 | PerlJam | or maybe I'm just really uncomfortable with all adverbs behaving this way. |
| 21:33 | TimToady | the syntax is independent of the behavior |
| 21:33 | if you mean the meta-op semantics | |
| 21:33 | PerlJam | sure, but I'd like the former to give me some clue about the latter |
| 21:34 | TimToady | do you care that !eq is writing code for you? |
| 21:34 | or += for that matter | |
| 21:35 | the only difference is whether you have to implement :ok explicitly or not, and the user doesn't really care | |
| 21:36 | PerlJam | !eq, += and :ok all occupy separate conceptual boxes in my head. Mayhap they shouldn't. |
| 21:36 | TimToady | maybe the current metaoperators all have :foo forms too, and maybe that's their native form |
| 21:36 | $a + $b :assignop | |
| 21:37 | doesn't really fly though | |
| 21:37 | since you can't write === @x :reduce | |
| 21:38 | not that [===] is exactly normal either :) | |
| 21:38 | PerlJam | [===] feels more natural to me though |
| 21:38 | TimToady | well, I guess it means "are all of these the same object" |
| 21:38 | well, you've been programmed to think of lists when you see [] | |
| 21:39 | PerlJam | true |
| 21:39 | TimToady | which is why I picked it, after all :) |
| 21:39 | jogla joined #perl6 | |
| 21:41 | PerlJam | What you need is an implementation :) They always seem to bring design flaws out (if there are any) |
| 21:41 | TimToady | anyway, I don't see much problem with treating some adverbs as semantic macros; this is not important for the user to track, only the implementor of :ok, who would otherwise have to duplicate all the builtins |
| 21:42 | the policy of which operator to apply an adverb to is a different matter | |
| 21:42 | Limbic_Region joined #perl6 | |
| 21:42 | moritz_ | in rx.t we have tests like this: |
| 21:42 | ok ('bazaar' ~~ /a*: a/) ~~ Match where matchcheck($_, q/:a/), 'basic'; | |
| 21:42 | TimToady | gee, who wrote that mess :) |
| 21:42 | moritz_ | would that become ('bazaar' ~~ /a*: a/) ~~ Match where matchcheck($_, q/:a/) :ok<basic>; |
| 21:42 | PerlJam | the principle of least surprise is a strong attractor. you just have to pick the right least surprise :) |
| 21:44 | TimToady | so that would apply :ok to the second ~~ if we went with the precedence solution, which is correct, I guess |
| 21:44 | moritz_ | aye |
| 21:44 | TimToady | since that's the top operator |
| 21:45 | moritz_ | but for longer expressions I'm a bit worried that the :ok is too far on the right |
| 21:45 | apeiron joined #perl6 | |
| 21:45 | PerlJam | yeah, there's a bit of distance between there |
| 21:45 | moritz_ | and it changes the expression from "useless expression in void context" to "run a test" |
| 21:45 | which somehow violates the principile of end weight | |
| 21:46 | TimToady | well, write a longer message :) |
| 21:46 | PerlJam | heh |
| 21:47 | TimToady | but it's kinda cool that brainos turn into "useless use" |
| 21:48 | it'll even tell you *which* operator leaked | |
| 21:49 | well, one of 'em, anyway | |
| 21:50 | and it better justifies the existence of "loose unary" precedence :) | |
| 21:50 | PerlJam | I guess part of my conceptual difficulty is that I don't think of tests in an adverbial way. I think of them as nouns that you feed stuff to. Maybe I'm just insane. |
| 21:50 | TimToady | well, they're predicates, really, or assertions |
| 21:51 | if there weren't a history of ! meaning factorial we'd say $a == $b! when we really mean it | |
| 21:52 | PerlJam | they're the teacher and we're the students handing in our assignments to find out if we pass or fail. :) |
| 21:52 | azawawi | hi |
| 21:52 | lambdabot | azawawi: You have 1 new message. '/msg lambdabot @messages' to read it. |
| 21:52 | moritz_ | the difference between a test and an assertion is that you (have to) actively run a test, whereas assertions are verified along the way of a normal executioing |
| 21:53 | TimToady | yes, and you don't really want to blow execution out of the water on the first failed test :) |
| 21:53 | moritz_ | (that's what the Eiffel people generally get wrong; they say "we don't need tests, we have our design by contract" - but as long as the code is not executed, these contracts aren't checked) |
| 21:54 | TimToady | you will soon have us all converted to Haskell :) |
| 21:54 | BinGOs joined #perl6 | |
| 21:54 | moritz_ | TimToady: so should :ok'ed operators catch exceptions? |
| 21:55 | not before I convert myself to Haskell ;) | |
| 21:55 | TimToady | well, why not? the one think it can't do it catch parsefails... |
| 21:56 | *thing | |
| 21:57 | moritz_ | nice |
| 21:58 | TimToady | although a parser could resync a statement if it sees an :ok coming up, I suppose, the way some parsers resync on semicolons |
| 21:58 | moritz_ | what will '1 :ok<1 is a true value>' work out to? |
| 21:59 | ie when there's no operator to bind to? | |
| 21:59 | PerlJam | "operator expected" :) |
| 21:59 | moritz_ | well, these things must be tested somehow |
| 21:59 | PerlJam | unless there's a null operator it can bind to for other possibilities |
| 22:00 | moritz_ | simple truthness, dies_ok, eval_dies_ok needs to be addressed |
| 22:00 | TimToady | currently it says 'No previous operator visible to adverbial pair |
| 22:00 | moritz_ | sub unfix:<> |
| 22:00 | the null operator | |
| 22:00 | PerlJam | "unfix"? :) |
| 22:01 | moritz_ | neither pre nor post nor infix |
| 22:01 | TimToady | given that :ok is testing for boolean, presumably it should supply a true() |
| 22:01 | moritz_ | unfix |
| 22:01 | PerlJam | What's your fixity? I have none. |
| 22:02 | Limbic_Region | salutations all |
| 22:03 | moritz_ | hello Limbic_Region ;) |
| 22:03 | where did you leave your ~ ? ;-) | |
| 22:04 | Limbic_Region | on use.perl it is a space |
| 22:04 | TimToady | the final frontier... |
| 22:05 | moritz_ | unendliche weiten... |
| 22:05 | ELANG | |
| 22:24 | YMas joined #perl6 | |
| 22:24 | azawawi | moritz_: any interesting RTs / tasks to work on? |
| 22:25 | moritz_ | depends on your notion of "interesting" ;) |
| 22:26 | azawawi | moritz_: something that gets committed in the end ;-) |
| 22:27 | moritz_ | azawawi: I'm sure most of your patches will get commited in the end... |
| 22:27 | on the side of the test suite there's still a lot in t/TASKS | |
| 22:27 | on the rakudo side - dunno, really | |
| 22:27 | azawawi | im actually looking at it |
| 22:27 | moritz_ | perhaps infix:<where> |
| 22:28 | azawawi | tests for complex: polar |
| 22:29 | moritz_ | have to go to bed now :( |
| 22:29 | happy hacking ;) | |
| 22:29 | azawawi | me 2 it is 1:29am here |
| 22:29 | good night... | |
| 22:30 | YMas left #perl6 | |
| 22:39 | hercynium joined #perl6 | |
| 22:45 | ab5tract joined #perl6 | |
| 22:48 | ingyfoo joined #perl6 | |
| 22:48 | ingy joined #perl6 | |
| 22:50 | pugs_svn | r22559 | azawawi++ | [t] removed unused empty directories |
| 23:02 | kulp joined #perl6 | |
| 23:04 | pugs_svn | r22560 | putter++ | [elfish/on_sbcl] Self-compiles. |
| 23:04 | r22560 | putter++ | Undef and bool boxing. Dispatch and misc fixes. Slower. | |
| 23:04 | r22560 | putter++ | Doesn't quite compile the p5 version. | |
| 23:04 | r22560 | putter++ | [STD_red] Improved --format=cl string and nil dumping. | |
| 23:04 | r22560 | putter++ | [elf_h] Yet more missing argument fixes. | |
| 23:11 | r0bby joined #perl6 | |
| 23:40 | speckbot | r14591 | larry++ | Make operator adverbs parse sanely based on precedence. They are now treated |
| 23:40 | r14591 | larry++ | as "loose unaries" (albeit still in a trailing position), and no longer require | |
| 23:40 | r14591 | larry++ | the parser to track "previous operator". The benefits are construed to | |
| 23:40 | r14591 | larry++ | outweigh the problems. | |
| 23:40 | r14591 | larry++ | | |
| 23:40 | r14591 | larry++ | Note also that existence and deletion are now simply adverbs on subscript | |
| 23:40 | r14591 | larry++ | operators. | |
| 23:55 | kulp joined #perl6 | |
| 23:58 | alester joined #perl6 |
← Previous day | Index | Channel Index | Today | Next day → | Search | Google Search | Plain-Text | plain, newest first
Perl 6 | Rakudo | Specs | Parrot | source cross referenced