pugscode.org/ | nopaste: sial.org/pbot/perl6 | pugs: [~] <m oo se> (or rakudo:, kp6:, elf: etc.) (or perl6: for all) | irclog: irc.pugscode.org/ Set by Tene on 29 July 2008. |
|||
ruoso | but consider prioritizing the buffer model... | 00:00 | |
it will make your extension api much richer | |||
Lichtkind | i do not because that bind to much work and slows only don the app | ||
vip tried that and got nowhere | |||
the project was always about get something usable | 00:01 | ||
ruoso | I see... | ||
Lichtkind | all you said i also considered | ||
but you have to time when fold out the big feature | 00:02 | ||
i hope you understand | |||
ruoso | sure I do.. | ||
and I'm only exercising some frustations I had when planning an editor ;) you don't have to take me seriously ;) | 00:03 | ||
00:03
bacek joined
|
|||
ruoso | (except for the tab-always-indent and emacs-style-keybindings thing ;) | 00:03 | |
Lichtkind | perl deserves its own IDE and of cource :) | ||
but that will come after version 0.4 | 00:04 | ||
00:04
felipe left
|
|||
Lichtkind | top topics are now output panel, bugs under linux, UTF and config dialog | 00:04 | |
so i can ship 0.4 | |||
ruoso | that's cools | ||
Lichtkind | recently started gabor his own perl editor | 00:05 | |
will see sometimes it fucks me off but on other hand he found some solutions i now will also use | 00:06 | ||
ruoso | @tell pmurias, I've spotted one point that should help a lot s1p... we need an implementation of the (|$capture) signature.... and then we implement the actual signature in the s1p classes in the begging of the method code... | ||
ENOBOT | 00:07 | ||
meppl | good night | ||
ruoso | pmurias... I'm implementing that signature as (|$_), so the s1p code would have the capture in $_ for the routines... we then implement the actual signature in the beginning of the actual code... | 00:11 | |
00:13
clkao left
|
|||
ruoso | Lichtkind, it's like Perl 6 development... we have a lot of people trying different things... in the end it's nice because we learn more... | 00:13 | |
00:13
sunnavy left
|
|||
Lichtkind | ruoso: yeah but all want the holy grail of programming now :) | 00:13 | |
00:13
obra left
00:16
meppl left
00:23
funktio left,
gbacon left,
Southen left,
speckbot left
00:27
funktio joined
00:30
donaldh left
00:32
donaldh joined
|
|||
pugs_svn | r22050 | ruoso++ | [smop] :(|$_) signature implementation as SMOP__S1P__BindCaptureSignature. This should help implementing the sample s1p output | 00:35 | |
00:35
iblechbot left
00:37
funktio left
00:39
sunnavy joined,
obra joined
00:40
clkao joined
00:43
funktio joined,
clkao left
00:44
clkao joined,
sunnavy left,
sunnavy joined,
obra left,
obra joined
00:46
hercynium left,
kanru left
00:47
funktio left
|
|||
ruoso | pmurias, I've updated the ROADMAP... and I'm now focused on the runtime features we need to compile src-s1p/P6Meta.pm | 00:50 | |
pugs_svn | r22051 | ruoso++ | [smop] updating the S1PSample to the starting sketches for a mold-only output in the s1p compiler... | ||
ruoso sleep & | 00:54 | ||
00:54
ruoso left
00:55
funktio joined
01:00
gbacon joined,
Southen joined,
speckbot joined
01:02
larsen_ joined
01:03
REPLeffect left,
REPLeffect joined
01:05
funktio left
01:12
funktio joined
01:14
elmex left
01:18
meppl joined
01:21
[particle]1 joined
01:40
[particle] left
01:44
larsen_ left
01:45
Ehtyar left
02:07
cls_bsd_ is now known as cls_bsd
02:18
xuser joined
02:21
xuser left
02:24
wknight8111 left
02:35
Lichtkind left
02:42
meppl left,
meppl joined
02:46
alc joined
02:52
alanhaggai left
02:55
alanhaggai joined
|
|||
s1n | moritz_: see your pm | 03:12 | |
03:26
alanhaggai left
03:27
alanhaggai joined
|
|||
meppl | good night | 03:44 | |
03:45
meppl left
03:54
alester_ joined
04:09
a-jing joined
04:10
a-jing left
04:40
BinGOs_ joined
04:45
eternaleye_ left
04:53
BinGOs left
05:02
a-jing joined,
a-jing left
05:25
Psyche^ joined
05:26
Patterner left,
Psyche^ is now known as Patterner
05:27
IRSeekBot joined,
IRSeekBot left
05:29
IRSeekBot joined
05:30
alc left
05:47
ashizawa joined
05:48
cataska joined
06:00
donaldh left,
donaldh joined
06:06
alc joined
06:23
BinGOs_ is now known as BinGOs
06:29
meppl joined
06:32
charsbar left,
charsbar joined
06:33
eternaleye joined
06:46
alester_ left
06:54
felipe joined
07:08
pmurias joined
07:16
eternaleye left
07:17
iblechbot joined
07:19
eternaleye joined
|
|||
pugs_svn | r22052 | pmurias++ | [smop] | 07:46 | |
r22052 | pmurias++ | for uses ->, not --> | |||
r22052 | pmurias++ | fixed a bug in DESTROYALL in mold | |||
07:51
Alias_ left
07:54
cataska left
08:02
donaldh left
08:08
zamolxes joined
08:12
aindilis left,
aindilis joined
08:15
a-jing joined,
a-jing left
|
|||
pmurias | does anyone here now how should i add gcov hooks to smop (it uses cmake)? | 08:17 | |
08:17
sri_work joined
08:19
zamolxes left
08:30
elmex joined
08:33
zamolxes joined
08:38
pmurias left
08:41
iblechbot left
09:11
a-jing joined
09:31
a-jing left
09:39
a-jing joined,
a-jing left
09:53
ruoso joined
10:08
alc left
10:11
bacek left
10:34
hercynium joined
10:39
masak joined,
ruoso left
10:40
hercynium left
10:57
a-jing joined,
a-jing left
11:01
iblechbot joined
11:05
zamolxes left
11:21
ruoso joined
11:22
alc joined
11:24
endless- joined
11:30
endless- left
11:45
BinGOs left,
BinGOs joined
|
|||
ruoso | @tell pmurias, do you think we should create a capture-proxy for slurpy arrays in signatures? or maybe we should just copy the values to a new empty array... | 12:00 | |
ruoso ENOBOT | |||
copying the values in an empty array is less efficient, but maybe is simpler... | 12:01 | ||
We were discussing an Iterator type some time... I'm about to implement "for", and I think "for" should enforce "Iterator context"... but the specs doesn't refer to an explicit Iterator type... | 12:16 | ||
12:18
pmurias joined
|
|||
ruoso | hi pmurias | 12:19 | |
pmurias | ruoso: the proxy array must be indistinguishable from a real Array | ||
ruoso: hi | |||
ruoso | pmurias, yes it would be... | ||
(that's the most important feature of SMOP, anyway) ;) | 12:20 | ||
pmurias | looking at code& | ||
ruoso: is the slurpy params array resizable? | 12:22 | ||
ruoso | pmurias, in theory it's just a regular array after the bind... | 12:23 | |
in P6Meta we even unshift an element to it... | |||
pmurias | so it's legal to @(\()).push(1)? | 12:24 | |
moritz_ | you know that slurpy params are lazy lists? | ||
rakudo_svn | r30618 | julianalbo++ | clean ATTR workarounds in perl6multisub | ||
moritz_ | normally all parameters are read-only references | ||
12:24
dr_df0 joined
|
|||
ruoso | the parameters are... but do slurpy arrays fall in that case? | 12:26 | |
moritz_ | I don't see why they should not | 12:27 | |
pugs_svn | r22053 | dr_df0++ | [spec] fudged spec/S03-operators/eager_hyper.t for rakudo | 12:29 | |
pmurias | the @*slurp_array is always rw, it's elements are ro unless declared with a is rw i.e. '@*_ is rw' | ||
ruoso: so i think a copy would be suitable here (it can be optimised to COW latter) | 12:30 | ||
ruoso | yes... it looks simpler... | 12:31 | |
moritz_ | pmurias: *@stuff, not @*stuff | ||
@*stuff is "global namespace" | |||
ruoso | moritz_, my $foo = shift; is still a valid idiom in Perl 6, isn't it? | ||
moritz_ | ruoso: probably. I retract my opinion ;) | 12:32 | |
ruoso | pmurias, that makes our ROADMAP simpler... | 12:33 | |
moritz_ | More precisely, the slurpy star | 12:34 | |
means the declared formal parameter is I<not> considered readonly; only | |||
its elements are. | |||
from S06:150 | |||
ruoso++ | |||
12:34
Lorn left
|
|||
ruoso | but we still need an iterator api | 12:35 | |
.has_next() and .next() | |||
pmurias | ruoso: do you have any experience with gcov? | 12:41 | |
ls | |||
sorry ;) | |||
12:42
abra joined
|
|||
moritz_ | no such file or directory ;) | 12:42 | |
pmurias | moritz_: | ||
(caps lock)-- | |||
moritz_ | (keycode 66 = Escape in .xmodmaprc)++ | 12:43 | |
ruoso | I think I'll consider that API for SMOP, and provide TimToady this use as an exercise of a possible api | 12:44 | |
pmurias | S03:680 | 12:46 | |
ruoso | pmurias, but that is to eagerly load the entire iterator in a new list... | 12:47 | |
wait... | 12:48 | ||
somewhere else in the specs it was saying that... | |||
but that piece seems to imply otherwise... | |||
pmurias | ruoso: it's context dependend | 12:49 | |
that reminds we once again that we need context support in m[0o]ld | |||
12:49
abra left
|
|||
ruoso | pmurias, I was planning to implement "context sensitiveness" by additional method calls | 12:50 | |
and use "context saved in the frame" as a future optimization | 12:51 | ||
to help avoiding unnecessary 'context enforcing' | |||
btw... prefix:<=> implies an internal iterator state in the list itself... is that expected? | 12:52 | ||
pmurias | why not make the context part of the method call my $foo = ($context) $bar."baz"(...); | ||
ruoso: it dosn't seem desirable IMHO | 12:53 | ||
(internal iterator state that is) | 12:54 | ||
ruoso | pmurias, because that would make the method call more complex... having to calll .bool() to force boolean context seems ok... | ||
as well as .List() to force List context, and so on... | |||
pmurias | but you would have to return proxy objects for lots of things | 12:55 | |
ruoso | only when this things react differently in each context | ||
most of the time the coercion provided by the type you returned is enough | |||
(just like p5, btw) | 12:56 | ||
12:57
abra joined
|
|||
ruoso | pmurias, about internal iterator... that's why I would consider having an Iterator type that would define .prefix:<=> | 12:58 | |
pmurias | ruoso: you can't tell in advance if something is context dependent | ||
dr_df0 | rakudo: # feeding to whatever using ==> and ==>> | ||
p6eval | rakudo 30618: RESULT[{}] | ||
ruoso | pmurias, you can't always tell the context either... | 12:59 | |
pmurias | ruoso: example please | ||
ruoso | foo(bar()) | ||
multi foo (bool $a); multi foo (int $a) | |||
pmurias | spec searching& | 13:00 | |
moritz_ | but these multis don't force context | ||
pmurias | checking the wind& | ||
moritz_ | actually a parameter list is a list, so it would call bar() in list context, I think | 13:01 | |
13:03
ebassi joined
|
|||
ruoso | feather.perl6.nl/syn/S02.html#line_3308 | 13:03 | |
13:04
a-jing1 joined,
cmarcelo joined,
a-jing1 left
13:06
cmarcelo left
|
|||
dr_df0 | when to use '#?rakudo skip' and '#?rakudo todo' ? | 13:08 | |
moritz_ | skip when rakudo dies on the test | ||
and todo when it just gives a wrong result | |||
13:08
ashizawa left
|
|||
moritz_ | btw don't fudge test files for features that are not yet implemented in rakudo | 13:09 | |
13:12
ebassi left
13:13
zamolxes joined
13:15
alc left,
jan_ joined,
alc joined
13:37
rindolf joined
13:38
Lorn joined
|
|||
moritz_ | @tell TimToady STD.pm still complains about ok !(undef & 1), even with the disambiguating whitespaces ("Obsolete use of undef as a verb") | 13:42 | |
ENOLAMBDABOT | |||
masak | rakudo: token test { test }; say "this is but a test" ~~ test | 13:43 | |
p6eval | rakudo 30618: OUTPUT[too few arguments passed (0) - 2 params expectedcurrent instr.: 'test' pc 59 (EVAL_14:23)] | ||
13:43
yath_ left
|
|||
masak | are tokens specced to have an existence indepentent of grammars? | 13:43 | |
dito rules, regexes? | 13:44 | ||
moritz_ thinks so, but not sure | |||
masak | anymoose, strange error | 13:45 | |
(unless one understands the underlying reason) | |||
dr_df0 | perl6: { my $a; -> $i { $a += $i } for 1..3; } | ||
p6eval | rakudo 30618: OUTPUT[Missing '}' at line 1, near "-> $i { $a"current instr.: 'parrot;PGE::Util;die' pc 119 (runtime/parrot/library/PGE/Util.pir:82)] | ||
..elf 22053: OUTPUT[AST handler circumfix:pblock partially unimplemented at ./elf_f line 2401] | |||
..pugs: RESULT[undef] | |||
moritz_ | pugs: { my $a; -> $i { $a += $i } for 1..3; }; say $i | 13:46 | |
p6eval | pugs: OUTPUT[***  Unexpected end of input expecting "::" Variable "$i" requires predeclaration or explicit package name at /tmp/DiDzYQLxI4 line 1, column 48] | ||
masak | dr_df0: I don't think blocks and statement-modding for go together | ||
either it's a statement (and can take a modifying for) or it's a block (and doesn't) | 13:47 | ||
moritz_ | masak: but a pointy block is a statement | ||
masak | oh. | ||
that's news to me. | |||
moritz_ | STD.pm parses to me | ||
dr_df0 | moritz_: it's was fragment from for.t test | 13:48 | |
masak | dr_df0: ah. | ||
moritz_ | my $x = -> $stuff { foo }; is valid Perl 6 | ||
masak | that I have less trouble accepting, for some reason | ||
moritz_ | it's just a block with a signature | ||
masak | aye | ||
moritz_ | but rakudo doesn't do pointy-block-as-a-statement yet | 13:49 | |
masak | conundurum: rakudo is cool, but using it makes me want more of it! | 13:50 | |
moritz_ | aye ;) | ||
masak | how do I make everyone else hack on rakudo? :) | ||
[particle]1 | moritz_: if token et al can be used outside a named grammar, do you suppose every namespace has an anonymous grammar into which these methods are added? | 13:51 | |
or every namespace has a grammar of the same name? | 13:52 | ||
masak | moritz_: this morning I got fairly far in writing a syntax parser for the wiki that did external links, italic text, headings and list items. but somewhere in the middle of it all, juggling the grammar overwhelmed me. I'm going to try again tonight more systematically, with tests. | ||
moritz_ | [particle]1: I guess that tokens live in the "normal" namespace, just like subs | ||
13:52
zamolxes left
|
|||
masak | [particle]1: I agree with moritz_. no grammar needed. | 13:53 | |
[particle]1 | package Foo; token xyz { 'xyz' }; package main; say 'zyzzxyzzyz' ~~ Foo::xyz; | ||
masak | aye | ||
[particle]1 | masak: tests++ | ||
masak | grammars++ | 13:54 | |
I suspect the end-of-the-week writeup on november will be about grammars, and how wonderful they are | |||
this week, I've come to firmly believe that they are THE killer feature of Perl 6 | |||
[particle]1 | perl 6 is nothing without them | 13:55 | |
13:55
pmurias left
|
|||
masak | that said, I still suck at writing them, so the wonders I glimpse are the total amount of woundrousness projected down on my ineptitude :) | 13:57 | |
moritz_ tries to parse that sentence | |||
13:57
Caelum joined
|
|||
masak | moritz_: sorry. I'm inept at communicating too, it seems | 13:58 | |
moritz_ | or my English just isn't good enough ;) | ||
masak | hard to tell. | ||
s/projected down on/filtered through/, maybe. does that help? | 13:59 | ||
moritz_ | I think I know what you mean | ||
since you don't understand it right, you can't grasp all of it's power, right? | |||
masak | right. | 14:00 | |
and even then, I'm impressed. | |||
rakudo: "hello" ~~ /ll/; .from.say given $/ | |||
p6eval | rakudo 30618: OUTPUT[2] | ||
masak | I'm also impressed at how stuff like that works already :) | 14:01 | |
2008 is shaping up to be a good year for Perl 6! | |||
[particle]1 | perl 6 lets smart people make programming look easy and lets inept people make programming look possible | ||
14:01
[particle]1 is now known as [particle]
|
|||
moritz_ | yes, it's a weird mixture of really cool, advanced features work, and some very simple stuff plain refuses to work | 14:01 | |
masak | moritz_: ...and that strange recursion bug, and the fact that programs segfault for no good reason :/ | 14:02 | |
14:03
jhorwitz joined
|
|||
masak | rakudo: the good, the cool, the advanced, the bad, the ugly and the wierd | 14:11 | |
p6eval | rakudo 30618: OUTPUT[Could not find non-existent sub goodcurrent instr.: '_block11' pc 11 (EVAL_13:11)] | ||
masak | p6eval: sorry :) | ||
[particle] | sounds like quark names | ||
ruoso | perl6: class Foo { method bar ($s: $a, $b) { say $s, $a, $b } }; my $f1 = Foo.new(); my $f2 = Foo.new(); my $c1 = \($f1: 'a'); my $c2 = \($f2: 'b'); $f2.bar(|$c1, |$c2); | ||
p6eval | elf 22053: OUTPUT[Useless use of a constant in void context at (eval 123) line 11.Useless use of a constant in void context at (eval 123) line 12.Undefined subroutine &GLOBAL::prefix__124 called at (eval 123) line 13. at ./elf_f line 3861] | ||
..rakudo 30618: OUTPUT[Statement not terminated properly at line 1, near ": 'a'); my"current instr.: 'parrot;PGE::Util;die' pc 119 (runtime/parrot/library/PGE/Util.pir:82)] | |||
..pugs: OUTPUT[<obj:Foo>CaptMeth {c_invocant = VObject (MkObject {objType = (mkType "Foo"), objAttrs = <Hash:0xb7aa1f8d>, objOpaque = Nothing, objId = MkObjectId {unObjectId = 4}}), c_feeds = [:MkFeed {f_positionals = [:"a":], f_nameds = []}:]}CaptMeth {c_invocant = VObject (MkObject {objType =... | |||
ruoso | pugs: class Foo { has $.n; method bar ($s: $a, $b) { $n ~ $a ~ $b } }; my $f1 = Foo.new(n => 1); my $f2 = Foo.new(n => 2); my $c1 = \($f1: 'a'); my $c2 = \($f2: 'b'); say $f2.bar(|$c1, |$c2); | 14:13 | |
p6eval | pugs: OUTPUT[***  Unexpected " ~" expecting "::" Variable "$n" requires predeclaration or explicit package name at /tmp/mfG74jDYKE line 1, column 51] | ||
ruoso | pugs: class Foo { has $.n; method bar ($s: $a, $b) { $s.n ~ $a ~ $b } }; my $f1 = Foo.new(n => 1); my $f2 = Foo.new(n => 2); my $c1 = \($f1: 'a'); my $c2 = \($f2: 'b'); say $f2.bar(|$c1, |$c2); | ||
p6eval | pugs: OUTPUT[2CaptMeth {c_invocant = VObject (MkObject {objType = (mkType "Foo"), objAttrs = <Hash:0xb5eda419>, objOpaque = Nothing, objId = MkObjectId {unObjectId = 4}}), c_feeds = [:MkFeed {f_positionals = [:"a":], f_nameds = []}:]}CaptMeth {c_invocant = VObject (MkObject {objType = (mkType... | ||
ruoso | pugs: class Foo { has $.n; method bar ($s: $a, $b) { $s.n ~ $a ~ $b } }; my $f1 = Foo.new(n => 1); my $f2 = Foo.new(n => 2); my $c1 = \($f1: 'a'); my $c2 = \($f2: 'b'); say $f2.bar(|$c2, |$c1); | 14:14 | |
p6eval | pugs: OUTPUT[2CaptMeth {c_invocant = VObject (MkObject {objType = (mkType "Foo"), objAttrs = <Hash:0xb5dda429>, objOpaque = Nothing, objId = MkObjectId {unObjectId = 5}}), c_feeds = [:MkFeed {f_positionals = [:"b":], f_nameds = []}:]}CaptMeth {c_invocant = VObject (MkObject {objType = (mkType... | ||
ruoso | hmm... | 14:15 | |
it seems that pugs is not expanding the captures... | |||
bennymack-work | so, is &?ROUTINE implemented in rakudo? I'm trying moritz's YC but getting: invoke() not implemented in class 'Undef' | ||
ruoso | pugs: my $c = \(1); sub b ($a) { say 'Hello ' ~ $a }; b(|$c); | 14:16 | |
p6eval | pugs: OUTPUT[Hello 1] | ||
14:16
TJCRI joined
|
|||
ruoso | pugs: my $c1 = \(1); my $c2 = \(2) sub b ($a, $b) { say 'Hello ' ~ $a ~ $b }; b(|$c1 , |$c2); | 14:16 | |
p6eval | pugs: OUTPUT[***  Unexpected "sub" expecting operator at /tmp/clcMaEwsYl line 1, column 30] | ||
ruoso | pugs: my $c1 = \(1); my $c2 = \(2); sub b ($a, $b) { say 'Hello ' ~ $a ~ $b }; b(|$c1 , |$c2); | ||
p6eval | pugs: OUTPUT[Hello 12] | ||
ruoso | pugs: my $c1 = \(1,2); my $c2 = \(:hello<world>); sub b ($a, $b) { say 'Hello ' ~ $a ~ $b }; b(|$c1 , |$c2); | 14:17 | |
p6eval | pugs: OUTPUT[*** No compatible multi variant found: "&b" at /tmp/BSNMscFawe line 1, column 88-102] | ||
moritz_ | bennymack-work: it's not :( | ||
bennymack-work | awww. | ||
14:18
a-jing joined
|
|||
ruoso | pugs: my $c1 = \(1,2); my $c2 = \(:hello<world>); sub b ($a, $b, :$hello) { say 'Hello ' ~ $a ~ $b ~ $hello }; b(|$c1 , |$c2); | 14:18 | |
moritz_ | pugs: { say &?BLOCK } | ||
p6eval | pugs: OUTPUT[pugs: indexPArr: out of bounds parallel array index; idx = 1, arr len = 1] | ||
pugs: OUTPUT[<SubPrim(<anon>)>] | |||
14:18
a-jing left
|
|||
ruoso | hmm... it seems that capture expansion will be first implemented in SMOP... | 14:18 | |
moritz_ | pugs: my $b = { $x < 2 ?? 1 !! $x * $?BLOCK($x - 1) }; $b(2) | ||
p6eval | pugs: OUTPUT[***  Unexpected "$b" expecting "=", "::", context, ":" or "(" Variable "$x" requires predeclaration or explicit package name at /tmp/MVFeCWNygv line 1, column 4] | 14:19 | |
moritz_ | pugs: my $b = { $_ < 2 ?? 1 !! $_ * &?BLOCK($_ - 1) }; $b(2) | ||
p6eval | pugs: RESULT[2] | ||
moritz_ | pugs: my $b = { $_ < 2 ?? 1 !! $_ * &?BLOCK($_ - 1) }; $b(5) | ||
p6eval | pugs: RESULT[120] | ||
moritz_ | bennymack-work: pugs seem to get the &?BLOCK one right | ||
bennymack-work | pointy sub syntax doesn't seem to work either. | ||
moritz_ | in rakudo they work only on for-loops | 14:20 | |
ruoso | is there any prior thinking on how do capture expansion work? | 14:21 | |
14:22
rindolf left
|
|||
ruoso | I think I'll consider implementing it by defining the inline capture (or captures) as individual capture objects and then have a capture merger that would hold several ordered captures and provide sane access... | 14:24 | |
($a, |$b, $c, |@d, $e, |%f) would have be translated to a "merger" capture that would hold 6 different ordered captures... | 14:25 | ||
14:27
zamolxes joined
|
|||
ruoso | |@d and |%f still need special "array capturizer" and "hash capturizer" objects... | 14:28 | |
pugs_svn | r22054 | dr_df0++ | [spec] added from t/statements/modifiers/ and fudged t/spec/S05-modifier/for.t for rakudo | 14:34 | |
masak | perl6: my $a = 5; if 3 < $a <= 10 { say "It chains!" } | 14:35 | |
p6eval | pugs, rakudo 30618: OUTPUT[It chains!] | ||
..elf 22053: RESULT[] | |||
masak | that already works in rakudo, and I haven't used it once! | ||
masak wonders if it's because there has been no genuine need, or because of unawareness of the need | |||
ruoso | what should happen when both %a and %b have conflicting keys in foo(|%a, |%b)? | 14:36 | |
masak | ruoso: last hash wins? warning? | ||
ruoso | maybe both ;) | 14:37 | |
I was wondering if that should be fatal or not... | |||
[particle] | what happens now? | ||
ruoso | [particle], in p5, you mean? | ||
[particle] | in pugs or rakudo, with multiple same-named params | 14:38 | |
ruoso | [particle], noone implements capture expansion yet... | ||
[particle] | forget the capture expansion part | ||
just deal with the flattened case | |||
foo(bar=>'baz', bar=>'quux'); | 14:39 | ||
ruoso | perl6: sub foo { say %_<bar> }; foo(bar=>'baz', bar=>'quux'); | ||
p6eval | pugs: OUTPUT[***  Unexpected "<bar" expecting "::" Variable "%_" requires predeclaration or explicit package name at /tmp/P9Ja5VW26Z line 1, column 17] | ||
..rakudo 30618: OUTPUT[quux] | |||
..elf 22054: OUTPUT[Global symbol "$h__" requires explicit package name at (eval 121) line 3. at ./elf_f line 3861] | |||
[particle] | that's only somewhat helpful | 14:41 | |
:/ | |||
ruoso | I'll assume a warning should be raised... | 14:42 | |
pugs_svn | r22055 | dr_df0++ | [t/statements] for.t moved to spec | ||
[particle] | warning++ | 14:43 | |
pugs_svn | r22056 | moritz++ | [irclog] first shot at having pdd01 link to the right parrot design document | ||
14:44
Jedai left
|
|||
moritz_ | dr_df0: you didn't add the new file, just deleted the old | 14:46 | |
dev.pugscode.org/changeset/22055 | |||
ruoso | www.perlfoundation.org/perl6/index...._expansion | ||
moritz_ | dr_df0: svn add path/to/new/file | ||
dr_df0: and then again svn ci | |||
uhm, why the hell do these pdd\d\d links not work? | 14:51 | ||
because I'm stupid, that's why | |||
pugs_svn | r22057 | moritz++ | [irclog] fixed regex for PDDs | 14:52 | |
ruoso | I think we're about to reach the smop type-system bootstrap with the capture merger object, because a lot of objects that require the native capture will have to support non-native captures... | ||
[particle] | moritz++ | ||
pdd19_pmc | 14:53 | ||
moritz_ | [particle]: the link is wrong | ||
ppd instead of pdd | |||
pugs_svn | r22058 | moritz++ | [irclog] fix link for pdds | ||
ruoso lunch & | 14:54 | ||
[particle] | yep, you need pdd | ||
14:54
Myoma joined
|
|||
ruoso | any comment on the capture expansion wiki page is very much appreciated.... | 14:54 | |
[particle] | seems the bot isn't logging atm | ||
moritz_ | which bot? | ||
[particle] | there's nothing irclog.perlgeek.de/parrot/today after 14:49 | 14:55 | |
moritz_ | uhm | ||
restarting the logger | 14:56 | ||
pugs_svn | r22059 | dr_df0++ | [spec] moved for.t form 'S05-modifier' into 'S04-statement-modifiers' | 14:57 | |
moritz_ | dr_df0++ | ||
pugs_svn | r22060 | moritz++ | [t/spec] simplified some tests in for.t by initializing variables | 15:03 | |
moritz_ | dr_df0: I now simplified the tests a little so that more of them pass. Rakudo can't do 'my $x; $x++' at the moment, but it *can* do 'my $x = 0; $x++' | 15:04 | |
and since that is not what we're testing for, we can simplify the tests a tiny bit, thus making more of them pass | |||
15:05
iblechbot left
|
|||
dr_df0 | yep | 15:05 | |
pugs_svn | r22061 | moritz++ | [t/spec] fixed previous commit | ||
masak | rakudo: my $r = regex { ET }; "ET, phone home!" ~~ $r # this works | 15:06 | |
p6eval | rakudo 30618: RESULT[{}] | 15:07 | |
masak | rakudo: my $r = regex { ET }; "ET, phone home!" ~~ $r; say $/ | ||
p6eval | rakudo 30618: OUTPUT[ET] | ||
masak | should I report it as a rakudobug that the bare, non-assigned form doesn't work outside of grammars? | ||
I've already reported that methods are allowed (and behave strangely) outside of classes :) | 15:08 | ||
moritz_ | what shouldn#t work? | ||
masak | moritz_: no, I think they should work, but don't at present | 15:09 | |
hold on, I'll make another example | |||
rakudo: regex alien { ET | Superman }; say "ET" ~~ alien | |||
p6eval | rakudo 30618: OUTPUT[too few arguments passed (0) - 2 params expectedcurrent instr.: 'alien' pc 59 (EVAL_14:23)] | ||
[particle] | rakudo: token alien { 'ET' }; say "ET" ~~ alien; | 15:13 | |
p6eval | rakudo 30618: OUTPUT[too few arguments passed (0) - 2 params expectedcurrent instr.: 'alien' pc 59 (EVAL_12:23)] | ||
moritz_ | ah, I get what you mean | ||
[particle] | rakudo: my $r = token alien { 'ET' }; say "ET" ~~ $r; | ||
p6eval | rakudo 30618: OUTPUT[ET] | ||
moritz_ | the name doesn't work, just the variable | ||
masak | right. | 15:14 | |
moritz_ | masak: write a test first, then the bug report ;) | ||
masak | awww :) | ||
ok. | |||
15:14
lumi joined
15:15
dr_df0 left
|
|||
rakudo_svn | r30619 | moritz++ | [rakudo] added test for statement modifying for to spectest_regression | 15:15 | |
[particle] | (raising the bar)++ | ||
moritz_ | masak: implementing that should be as simple as adding the right ACCEPTS multi | 15:19 | |
15:20
bpphillips joined
|
|||
masak | moritz_: nice | 15:23 | |
vim++ # C-a | |||
15:24
viklund left
|
|||
moritz_ | further investigations turn out that I don't even manage to find out which multi does it now, in the case of $str ~~ $rule | 15:25 | |
does $a ~~ $b call $b.ACCEPTS($a) ? | 15:26 | ||
rakudo: my $x = token foo { 'abc' }; say $x.WHAT | |||
p6eval | rakudo 30619: OUTPUT[Block] | ||
pugs_svn | r22062 | masak++ | [t/spec/S05-metasyntax/regex.t] | ||
r22062 | masak++ | added tests for regex, token, and rule outside of grammars | |||
moritz_ | rakudo: say Block ~~ Code | ||
p6eval | rakudo 30619: OUTPUT[1] | ||
moritz_ | that's the problem, there's no different type for a regex | 15:27 | |
which means that it can't work by MMD | |||
masak | rakudo-- | ||
moritz_ | masak++ submitting tests | 15:29 | |
15:32
Exodist joined
15:36
abra left,
abra joined
|
|||
masak | moritz_: save for some strange effects having to do with <TMPL_IF> and <TMPL_ELSE> (ultimately stemming from more ineptitude and too few tests, I think), the new HTML::Template is ready to be merged back into the master branch | 15:39 | |
moritz_ | nice | ||
do you need <TMPL_ELSE> for the merge? | |||
masak | yes, it's in almost every live .tmpl file | 15:42 | |
moritz_ | ;) | ||
masak | checks loggeed-in-ness and puts the appropriate "Log in"/"Log out" button on the page | ||
moritz_ | asking naiively, why should it be hard to do? | 15:43 | |
masak | it's not a naive question :) | ||
thing is, I have an implementation | |||
...which fails in strange ways | |||
and that's where I suspect the ineptitude and lack of tests come in | 15:44 | ||
15:44
[particle]1 joined
|
|||
masak | the failures are benign, stuff like only part of the page being output from HTML::Template | 15:45 | |
moritz_ | speaking of tests... I just git-pull'ed, and found 'not ok 2 - TMPL_VAR with ESCAPE' | ||
masak | moritz_: oh. | ||
I haven't given that test any thought | |||
it's entirely natural that it will fail, since there still are no ties to your new module from HTML::Template | |||
moritz_ | it seems the HTML/Template part of my patch hasn't made it into git | 15:46 | |
masak | will fix immediately | ||
moritz_ | no, correction - it seems that I have forgotten to send it :/ | ||
masak | aye | 15:47 | |
15:50
larsen_ joined
15:51
abra left
15:52
abra joined
15:53
abra left,
abra joined,
Lorn left
15:56
abra left
|
|||
moritz_ | patch sent | 15:57 | |
15:59
kanru joined
16:01
[particle] left
|
|||
masak | moritz_: applied/pushed | 16:03 | |
masak runs tests | |||
#2 passes! | 16:04 | ||
moritz++ | |||
16:05
alanhaggai left
|
|||
moritz_ | masak: wrong order - first apply, then test, then push ;) | 16:08 | |
masak | people keep telling me that :) | 16:09 | |
especially people I work with | |||
moritz_ | viklund? ;) | ||
masak | actually, no. we haven't had tests long enough for him to suffer from this weakness of mine | 16:10 | |
or rather, the tests are only in my branch so far | |||
16:13
abra joined
16:17
iblechbot joined
|
|||
masak | should Perl 6 implementations warn when a variable is declared with 'my' more than once in the same scope? | 16:19 | |
(rakudo doesn't) | |||
[particle]1 | rakudo doesn't have any warnings yet | 16:20 | |
masak | ok. | ||
16:22
cggoebel joined
|
|||
masak | the recursion-is-broken bug in rakudo is hard to work around :/ | 16:26 | |
16:27
alanhaggai joined
|
|||
Myoma | broken in what way? | 16:27 | |
masak | Myoma: rt.perl.org/rt3/Ticket/Display.html?id=58392 | 16:28 | |
Myoma | wow weird | 16:29 | |
16:29
ggoebel left
|
|||
masak | aye | 16:30 | |
masak thinks he'll actually write a use.perl post called "rakudo: the good, the cool, the advanced, the bad, the ugly and the wierd" | 16:31 | ||
moritz_ | masak: if you do, please submit for the front page | 16:32 | |
masak | ooh | ||
I can haz frontz peij!? | 16:33 | ||
16:33
pmurias joined
|
|||
moritz_ | when you write a new entry, activate the Publicize radio button | 16:35 | |
16:35
zamolxes left
|
|||
masak | moritz_: yes, I know the mechanism, but was unclear of the merit :) | 16:36 | |
s/of/on/ | |||
moritz_ | more readers | ||
it's as simple as that | |||
masak | also, I need to learn how to spell "weird" before publicizing it :/ | ||
pmurias | rehi | ||
masak | pmurias: y0 | ||
moritz_ | there are about 20 people that read your journal (or so I guess) and about 1500 that read the front page. Or even more | 16:37 | |
masak | good point. | 16:38 | |
masak decommutes | |||
see you! | |||
16:38
masak left
|
|||
moritz_ | ciao | 16:38 | |
cognominal | commutation is a quantic state? :) | 16:47 | |
or a move between them? | |||
moritz_ | [a,b] = ab - ba # the commutator | 16:48 | |
and if [a, b] != 0 then a and b can't both be measured exactly | 16:49 | ||
cognominal | www.youtube.com/watch?v=QOcyGZvKkgU # regular expression for solving temporal problems! | 16:53 | |
I wish I knew anything about quanta. | 16:54 | ||
moritz_ | most of it is not very exciting | 16:57 | |
16:57
pmurias left
|
|||
moritz_ | solving differential equations and linear algebra problems | 16:57 | |
and it rarely gives you the warm fuzzy "now I understand physics" feeling that you get in other areas | 16:58 | ||
17:00
rindolf joined
|
|||
cognominal | the problem is that the subatomic world has no relation to the world at our scale so I guess it must take time to get a feeling of it. | 17:06 | |
even the brightest mind would not want to tread with that :"God does not play dices" | |||
moritz_ | problem is, he does ;) | 17:07 | |
[particle]1 | a whole lot of dice | ||
moritz_ | even R. Feynman said he didn't understand quantum mechanics, and he was one of our brightest minds (and invented the quantum electro dynamics theory) | 17:08 | |
17:08
hercynium joined
|
|||
cognominal | quanta are dicey | 17:09 | |
moritz_ | update on that rakudo problem with applying rules - I think that the RHS is evaluated first, and then .ACCEPT is called on the result | ||
which works fine for variables, but not for syntactical sub and rule calls | 17:10 | ||
so it probably can't be solved without changing actions.pm | |||
[particle]1 | rakudo: "foo" ~~ sub { @_.say } | 17:13 | |
p6eval | rakudo 30620: OUTPUT[foo] | ||
moritz_ | rakudo: sub a { say @_.perl }; 'foo' ~~ a; say 1 | 17:14 | |
p6eval | rakudo 30620: OUTPUT[[]1] | ||
[particle]1 | hrmm, i thought subs required parens | 17:15 | |
cognominal | in NQP? | ||
moritz_ | they don't | ||
[particle]1 | rakudo: sub a { say @_.perl }; 'foo' ~~ a(); say 1 | ||
p6eval | rakudo 30620: OUTPUT[[]1] | ||
[particle]1 | ah, in nqp they do, cognominal++ | ||
moritz_ | rakudo: sub a { say @_.perl }; 'foo' ~~ &a; say 1 | ||
p6eval | rakudo 30620: OUTPUT[["foo"]1] | 17:16 | |
[particle]1 | hrmm indeed | 17:17 | |
17:17
[particle]1 is now known as particle1,
particle1 is now known as [particle]
17:21
eternaleye left
17:35
eternaleye joined
|
|||
ruoso | if $a = (1,2,3); can I simply use foo(|$a)? or should it do foo(|@$a) | 18:03 | |
moritz_ | I think |$a should be enough | ||
what else could |$a mean? | 18:04 | ||
ruoso | that $a ~~ Capture | ||
pugs: say |(1,2,3); | 18:05 | ||
p6eval | pugs: OUTPUT[123] | ||
ruoso | but pugs is not implementing the capture expansion correctly... | 18:06 | |
so It might be accidentally right | |||
pugs: say |(1,2),|(3,4) | |||
p6eval | pugs: OUTPUT[1234] | ||
18:06
Chillance joined
|
|||
ruoso | if that is correct, it means that in capture expansion, it needs to do a Capture coercion on all values... | 18:08 | |
Object will fail... Capture will return itself... Array will return a new Capture that has its elements and so will Hash... | 18:09 | ||
18:11
TJCRI left
|
|||
ruoso | pugs: my $a = [ 1, 2 ,3 ]; sub foo ($a, $b, $c) { say $a,$b,$c }; foo(|$a); | 18:21 | |
p6eval | pugs: OUTPUT[123] | ||
ruoso | pugs: my $a = [ 1, 2 ,3 ]; sub foo (|$capture) { say $capture.WHAT }; foo(|$a); | ||
p6eval | pugs: OUTPUT[*** No compatible multi variant found: "&foo" at /tmp/5uKZiOqYp0 line 1, column 65-73] | ||
ruoso | pugs: my $a = [ 1, 2 ,3 ]; sub foo (|$capture) { say $capture.WHAT }; foo(); | 18:22 | |
p6eval | pugs: OUTPUT[*** No compatible multi variant found: "&foo" at /tmp/nTHU9hIAXd line 1, column 65-70] | ||
ruoso | pugs: my $a = [ 1, 2 ,3 ]; sub foo (|$capture) { say $capture.WHAT }; foo(); | ||
p6eval | pugs: OUTPUT[*** No compatible multi variant found: "&foo" at /tmp/Nptjc7nYxl line 1, column 65-70] | ||
ruoso | pugs: my $a = (:b<foo>); sub foo ($a,:$b) { say $a,$b }; foo(1,|$a); | 18:23 | |
p6eval | pugs: OUTPUT[1foo] | ||
ruoso | pugs: my $a = \(:b<foo>); sub foo ($a,:$b) { say $a,$b }; foo(1,|$a); | 18:24 | |
p6eval | pugs: OUTPUT[pugs: indexPArr: out of bounds parallel array index; idx = 1, arr len = 1] | ||
ruoso | pugs: my $a = (:b<foo>); sub foo ($a,:$b) { say $a,$b }; foo(|$a,1); | ||
p6eval | pugs: OUTPUT[1foo] | ||
18:28
IRSeekBot left
18:36
bpphillips left
18:38
buu joined
|
|||
ruoso assuming prefix:<|> implies "Capture context", which in SMOP means .Capture() call. see www.perlfoundation.org/perl6/index...._expansion for details | 18:41 | ||
bennymack-work | moritz_ et al, I commented on reddit WRT the &?ROUTINE construct being somehow extended to support tail recursion or is pasing around an accumulator good enough? | 19:00 | |
19:25
abra left
|
|||
bennymack-work | I kind of think that the YC article should be submitted to the programming reddit as well. | 19:27 | |
moritz_ | go ahead if you want | 19:29 | |
19:30
larsen_ left
19:36
zamolxes joined
20:01
araujo left
|
|||
ruoso home & | 20:01 | ||
20:01
ruoso left
20:03
eternaleye_ joined
20:04
eternaleye left
20:20
hercynium left
20:22
hercynium joined
|
|||
bennymack-work | apparently it was submitted to the programming sub-reddit by gst already but it has zero points. Everyone go here and upvote it: www.reddit.com/r/programming/search...r+AND+perl | 20:28 | |
moritz_ | reddit is overrated ;) | 20:29 | |
20:37
eternaleye joined
20:44
wknight8111 joined
20:47
larsen_ joined,
|alanhaggai| joined
20:48
alanhaggai left
20:49
eternaleye_ left
21:23
jfredett_ joined
21:24
jfredett_ left
|
|||
meppl | good night | 21:29 | |
21:33
jfredett left,
meppl left,
jfredett joined
21:34
BinGOs left
21:50
hercynium left
21:53
hercynium joined
21:54
iblechbot left
22:00
BinGOs joined
22:10
idemal joined
22:18
alc left,
elmex left
22:22
hercynium left
22:24
bacek joined
22:37
bacek_ joined
22:43
bennymack joined
22:46
lambdabot joined
22:54
eternaleye left
22:56
ruoso joined,
eternaleye joined
23:03
bacek left
23:04
dduncan joined
23:06
bacek_ left
23:08
dduncan left
23:15
Exodist left
23:19
bacek joined
|
|||
pugs_svn | r22063 | lwall++ | [STD] only warn if undef is followed by a variable | 23:22 | |
23:36
meppl joined
23:51
bacek left
23:56
bacek joined
|
|||
TimToady | ruoso: multiple arguments with the same name is specced at S06:567 | 23:59 |