Pugs t-shirts www.cafepress.com/pugscode | Pugs 6.2.9 released | pugscode.org | pugs.kwiki.org | paste: sial.org/pbot/perl6 | www.geeksunite.net Set by stevan on 15 August 2005. |
|||
jasho | pugs fedora binaries where? | 03:23 | |
xinming | jasho: hmm, I think you have to checkout the source and compile yourself | 03:27 | |
jasho | xinming: it seems like perl6 is only for Windows. | 03:28 | |
xinming | jasho: BTW, the machine with less than 256M, for compiling GHC and Pugs is not recommended. :-) | ||
jasho: No, I am in Linux. | |||
jasho | xinming: I mean in terms of community. it seems to be all Windows now. | 03:29 | |
there are binaries for Windows, but you are on your own for Linux, etc. | |||
xinming | jasho: hmm, I hadn't used Fedora for over months, So I might not be able to help much, | ||
jasho: hmm, I think most linux distro can compile ghc and pugs. | 03:30 | ||
jasho: hold on. | |||
jasho | I can't find anything for Linux which is ready to go. the pugs docs say that by 6.2.0 there will be builds for various common platforms. but so far it seems only Windows. | 03:31 | |
xinming | jasho: In fact, that's true, I don't know if Fedora has compiled binary, But Mandrake does. :-) | 03:33 | |
jasho | I looked for Fedora and Suse. couldn't find anything. I didn't check Mandrake. I don't have it. | 03:34 | |
xinming | jasho: hmm, I think, You don't need to change so much, The easiest way to compile pugs, might be, do a full install for with Fedora, And then, download ghc6.4 and pugs source, compile yourself. | 03:36 | |
s/for with/with/ | |||
jasho | I think perl6 will become a Windows community if there are no builds readily available for Linux. 8( | 03:37 | |
xinming: thanks for your help. | |||
xinming is still sleepy, But can't fall asleep, so go on reading the Synopsis. | |||
jasho: well, I am a newbie also, that might be what I can help :-) | |||
revdiablo | jasho: I think the prevalence of windows builds are simply an indication of the fact that people using that platform don't tend to build stuff themselves | 03:38 | |
jasho: compared to the average unix user, who tends to be comfortable doing their own compiling | |||
jasho | revdiablo: but Linux is also trying to become an OS for people who just want to get stuff done. for now, that seems to mean Windows for perl6, or maybe stick with perl5. | 03:39 | |
coral | whoah | 03:40 | |
linux in two windows | |||
revdiablo | jasho: pugs is hardly to the Get Stuff Done phase | ||
jasho: it's still a developer's toy. | |||
a mighty nice and fun toy, but a toy nonetheless | |||
jasho | revdiablo: I want to test grammars. I understand this was working already with pugs? | 03:41 | |
xinming | jasho: Most basic grammar is supported. :-) There are lots things to do. | ||
revdiablo | the basic framework is there; I don't know how complete it is | ||
jasho | does this mean there is nothing even to test? maybe I should forget perl6 for my project and stay with perl5. | 03:42 | |
xinming | revdiablo: IMHO, If the full OO support for pugs is finished, some( or maybe many ) modules can be started writting in "perl 6", | 03:43 | |
spinclad | plenty to test. just compile and play. | ||
revdiablo | jasho: you can test it by building it | ||
jasho: it builds easily on linux | |||
xinming: *nod* a lot of stuff can be written in perl6 with pugs. | |||
jasho | now I think pugs is not worth it to test yet. | 03:44 | |
revdiablo | don't get me wrong -- playing with pugs helps everyone, I encourage it | ||
xinming | revdiablo: But the problem is, There are "many" test exists... :-) | ||
jasho | I would play with pugs if there were binaries available for Linux. | 03:45 | |
xinming | jasho: well, In fact, for Now, You try Pugs, You might get more than learning "only" the grammar. :-) | ||
revdiablo | jasho: "to test" and "get things done" are two different things. which one do you really want to do? | ||
jasho | revdiablo: I want to install binary pugs and test, to decide if perl6 is ready for my project. but I hear now pugs is not ready and not available for Linux without compile. | 03:46 | |
I think I should stay with perl5. | |||
thanks for the help. | |||
revdiablo | jasho: I would say that is correct. I would still like you to try pugs and help us make it better | 03:47 | |
jasho | make it easy for me to try. on Linux. | ||
revdiablo | I don't use any of the distros you listed. | 03:48 | |
so I can't really make a binary build for you | |||
xinming | If the money falls from sky, I would go out. But the fact is, If there is no money fall from sky, We still have to go out, the only thing important is, "when" | ||
:-) | |||
Now is the time to try pugs, It won't make you disappoint. :-) | 03:49 | ||
jasho | xinming: I wanted to try. maybe when pugs is available for my OS. | 03:50 | |
revdiablo | it is, jasho | ||
xinming | jasho: In fact, Even if the pugs finished working on all "perl 6" specification. There might not be enough module for you to use... | ||
jasho | revdiablo: you said it is only a toy. | ||
revdiablo | jasho: it is available for your distro, just not in the form you want. | ||
spinclad | at this point, any binary package will be out of date quickly. parrot has debian packaging, pugs not yet (or vice versa, i forget offhand), but you would want recent packages in any case. | ||
jasho | xinming: do I need modules to use grammars? | ||
xinming | jasho: well, Linux is a toy also, Why do you use it? :-) | ||
jasho | in need modules for perl5. | ||
xinming | jasho: No, But for your project, I think There are ( "should" be ) many modules depends on other modules. | 03:51 | |
revdiablo | I think I'm talking in circles now | ||
jasho | xinming: Linux with perl5 works well for me now, but I wanted to test grammars with perl6. but it seems perl6 is for Windows community now. | ||
xinming | ... | ||
?eval "painful to go out this circle.".say | 03:52 | ||
evalbotzy | painful to go out this circle. bool::true | ||
xinming | jasho: There are still perl 5 modules can't co-work with pugs. | ||
spinclad | btw, grammars are not well integrated as yet. there's PGE and there's pugs, but they don't talk in both directions with each other. | ||
xinming | jasho: some are working, But some are not. | ||
jasho | xinming: yes, I should stay with perl5 for my project. | 03:53 | |
revdiablo | I think jasho had a set of points he wanted to make when he came in here, and is ignoring any evidence to the contrary. | ||
jasho | spinclad: do I need modules for grammars for PGE? | ||
revdiablo | I'm done with this | ||
spinclad | not sure | ||
jasho | revdiablo: I think you helped me to decide to stay with perl5. so I don't have to test pugs now. that helps me. | 03:54 | |
I like to try myself. but no binaries, and not sure it is worth my time. you tell me that it is not ready yet, and is still for developers only. so no binaries. I will use perl5. | 03:55 | ||
spinclad | i think they're good points, we could welcome patches to build drop in packages, for debian at least, with each release... | ||
xinming | jasho: hmm, If you need the pugs to finish the full "perl 6" specification, you might still have to wait for 4 months, And also, for the other modules, maybe half a year, hmm, But can't assure this exactly. | ||
spinclad | (i think that's optimistic...) | 03:56 | |
xinming | spinclad: pugs can use perl 5 modules. :-) | ||
though It's a kind of pain on "speed". | 03:57 | ||
spinclad | sure. the full specs need a lot of work still though. | ||
xinming | spinclad: I just mean the "grammar" specification. | 03:58 | |
jasho | maybe after this project we can try for pugs again. | ||
spinclad | ok, you may be closer there then. | ||
xinming | jasho: ?? what do you mean? After pugs, the perl 6 is out. | ||
jasho | I mean my project, not the pugs project. my project can't wait for pugs to finish I think. | 03:59 | |
spinclad | xinming: not quite: plans are to release perl6 written in perl6, which calls for a rewrite after pugs... | 04:00 | |
xinming | spinclad: hmm, well, the "perl 6"s father. :-) maybe pugs can be grand-pa... :-P | 04:01 | |
jql | as soon as pugs can be used to write perl6, pugs is perl6 enough for me | ||
xinming | jql: So am I, I don't care speed much as I just use it as a toy. :-) | ||
jql | it'll be good -- our programs can only get faster | 04:02 | |
jasho | my project doesn't care about speed, but I want to use perl6 syntax for advanced constructions. but I need correct results, so maybe pugs needs some debugging first before I choose perl6 for projects. | 04:04 | |
xinming | jasho: you are right. :-) | 04:06 | |
pugs still can't be used for production. | |||
spinclad | that sounds like a different gate than whether there are binary packages for it. it definitely needs development on many fronts still. | ||
jasho | spinclad: I only wanted binaries for quick test. but you give me the answers already. pugs is not ready for me to test. I will use perl5. | 04:07 | |
spinclad | sure. check again later, things will have gotten further. | 04:08 | |
jasho | ok. thanks for the help. | ||
luqui | jasho, what is your project | 04:10 | |
it's always nice to have people using stuff in production | 04:11 | ||
we get lots of bug reports that way | |||
(and from what I've seen, no bug goes untended for more than 24 hours :-) | |||
xinming | luqui: I don't suggest to use pugs on project for now really. :-) | 04:13 | |
svnbot6 | r6414 | putter++ | PIL-Run - MetaModel is now used for Sub. fglock++ | 05:07 | |
r6414 | putter++ | Macro is now the only remaining non-mm Run/Type/. | |||
r6414 | putter++ | PrimX.pm: primitives' argument lists are now written in perl6 form. | |||
r6414 | putter++ | crude_repl.pl: :v verbose is now even more so, including a nicely readable yaml dump of the PIL. iblech++ | |||
putter | jasho: | ||
jasho: there are binary builds of ghc available for FC from haskell.org. (as long as you dont have x86_64 - that requires 6.4.1, which hadn't been released the last time I checked). | 05:08 | ||
good night all & | 05:10 | ||
luqui understands type inferrence... a little bit | 05:43 | ||
luqui will write a perl module that does type checking on trees to see if he really groks it | 05:44 | ||
QtPlatypus | Type checking? | 05:46 | |
What do you plan to do. | 05:47 | ||
? | |||
stevan | luqui: what about Devel::TypeCheck? | 05:49 | |
or is it not the same thing you are talking about | |||
luqui | That's the new inferrence module for perl 5? | ||
stevan | yes sir | ||
luqui | that's not what I'm talking about | ||
Perl 6's type inferrence must be much more general than that | |||
stevan | then you sir, are talking crazy :P | 05:50 | |
can you elaborate? | |||
luqui | I'm just going to let the user specify a tree structure and then try to fill it in | ||
stevan | type checking on trees? | ||
luqui | such as, oh, say, PIL | ||
With typed nodes | |||
stevan | ah | ||
luqui | and it will check that everything makes sense as you fill it in | ||
stevan | so you are not talking about making a "type tree" and checking types with that | ||
luqui | I'm not sure what you mean by "type tree" | 05:51 | |
stevan | testing derived types and such | ||
luqui | oh I will be testing derived types and such | ||
It's pretty easy to do -- you don't ever need to look outside the types that were actually mentioned | |||
It's just a little expensive (n^2 in the number of type variables) | |||
stevan | no I mean making a tree of types like (Any Node(Scalar), Node(Int)) stuff like that | ||
luqui | you mean union types | 05:52 | |
? | |||
stevan is going to stop asking and wait for luqui to write some code :) | |||
luqui | okay | ||
I have a five hour gap at school tomorrow | |||
that's probably when it will get done | |||
bedtime now | 05:53 | ||
stevan | I think we are probably talking about 2 diff things, but not in the same dialect | ||
luqui | probably | ||
good night | |||
luqui sleep & | |||
stevan | bah,.. for a college student you are a wussy | ||
it is early still | |||
luqui wake | |||
luqui smacks stevan | |||
stevan | no no,.. you need your beauty sleep | ||
luqui | tomorrow is the second day of classes | ||
I'd really rather not sleep through that one | 05:54 | ||
luqui puts in earplugs and sleeps & | |||
stevan | :) | ||
nite | |||
stevan cracks open MetaModel 2.0 and gets to work | |||
coral | oo, unaffiliated | 06:03 | |
geoffb | stevan, what is MM 2.0? (Sorry, been away for a while because of RL) | 06:22 | |
stevan | geoffb: 2.0 is a better tasting metamodel with only half the calories of 1.0 | 06:31 | |
geoffb: it is based on MiniMetaModel | 06:32 | ||
geoffb | Will it replace MM 1 everywhere? | ||
stevan | I am trying to clean things up, and be as minimalist as possible | ||
geoffb: eventually, yes | |||
I am trying to keep the changes to the user-facing API to a minimum | 06:33 | ||
geoffb | nodnod | ||
stevan | just re-write the core | ||
geoffb | How up to date is STATUS wrt your stuff? | ||
stevan | no idea | ||
geoffb | ah | ||
stevan | I have been totally swamped with $work | ||
geoffb | Understood, I've been totally swamped with $life | ||
stevan | $life++ | 06:34 | |
but $work-- | |||
QtPlatypus | none($work)-- | ||
stevan | basically this is my "relaxation" after about 14+ hours of work | ||
geoffb | Hmmm, maybe tomorrow or so I need to do another round of asking people for status and updating docs to match | ||
good choice, stevan :-) | |||
stevan | :) | ||
geoffb is relaxing by writing notes on optimization strategies | 06:35 | ||
stevan | :D | ||
last night I read papers on implementing subtypes/generics with metamodels | |||
geoffb | :-) | ||
stevan | and got inspired,.. so I wanted to finish 2.0 enough to try ideas | 06:36 | |
I probably actually should be doing $work | |||
geoffb recognizes that behavior | |||
(having been there many times) | |||
bah, must run, thanks for the info, stevan | 06:37 | ||
stevan | geoffb: enjoy :) | ||
06:57
_jql is now known as jql
|
|||
svnbot6 | r6415 | Stevan++ | Perl6::MetaModel 2.0 - | 07:45 | |
r6415 | Stevan++ | * $::Object is now defined, but does not yet work | |||
r6415 | Stevan++ | correctly. I need to figure out the best way to | |||
r6415 | Stevan++ | deal with class methods and meta methods still. | |||
r6415 | Stevan++ | * a few more test files, however not many tests | |||
r6415 | Stevan++ | can be written until the class/meta method issue | |||
r6415 | Stevan++ | is resolved. | |||
nothingmuch | morning | 07:58 | |
QtPlatypus | Mornig. | 08:05 | |
nothingmuch concludes from the 1.e5 thread that his solution is the best | 08:13 | ||
anyone want to implement an AUTOMETHOD that does that? | |||
it should be something like 'method AUTOMETHOD (Int $int:) { parse_as_float("$int$AUTOLOAD") }' where parse_as_float is one of haskell's 'read's | 08:16 | ||
ah, oops | 08:17 | ||
s/AUTOLOAD/_/; | 08:18 | ||
as per s10 | |||
nothingmuch is off to clean up the house | 08:21 | ||
xinming | sub head(*$head, *@tail) { return $head } | 10:01 | |
hmm, I can understand this one, What about this example please? | |||
sub head( *$head, $special, *@tail ) { return $special; ) | 10:02 | ||
sub head( *$head, $special, *@tail ) { return $special; }; | |||
ouch... I think I mislead myself... | 10:03 | ||
svnbot6 | r6416 | rgs++ | * a note on split STRING | 10:53 | |
r6416 | rgs++ | * shortly mention =$fh | |||
r6417 | yiyihu++ | Add the test for S06 List parameters, which will test slurpy scalar, slurpy array, and slurpy hash. | 11:32 | ||
QtPlatypus | What is the meaning of a slurpy scalar? | 11:33 | |
xinming | Slurpy scalar parameters capture what would otherwise be the first elements of the variadic array: | 11:34 | |
hmm, QtPlatypus Sorry for my confusion, I think I should say ("slurpy scalar"| "slurpy array"|"slurpy hash") parameters | 11:35 | ||
s/my/the/ | |||
xinming is considering to go to Junior School for learning English. | 11:36 | ||
QtPlatypus nods. | 11:38 | ||
xinming | seen autrijus | 12:50 | |
jabbot | xinming: autrijus was seen 1 days 9 hours 16 minutes 18 seconds ago | ||
nothingmuch | hola | 12:57 | |
Limbic_Region | como esta ustede? | 13:02 | |
svnbot6 | r6418 | fglock++ | * perl5/ Code - TODO update | 13:28 | |
itz | print @foo.len(); # this returns No compatible subroutine found: "&len" with the SVN version? | 13:36 | |
nothingmuch | ?eval my @foo = (1, 2, 3); @foo.length | ||
evalbotzy | Error: No compatible subroutine found: "&length" | ||
nothingmuch | ?eval my @foo = (1, 2, 3); @foo.elems | ||
evalbotzy | 3 | ||
nothingmuch | this is an explicit distinction | 13:37 | |
length is ambiguous | |||
otoh the number of elements is unambiguous | |||
for strings too - let me try to remember: | |||
?eval my $foo = "abc"; $foo.chars | |||
evalbotzy | 3 | ||
nothingmuch | ?eval my $foo = "abc"; $foo.graphemes | ||
evalbotzy | Error: No compatible subroutine found: "&graphemes" | ||
nothingmuch | ?eval my $foo = "abc"; $foo.bytes | ||
evalbotzy | 3 | ||
nothingmuch | ?eval my $foo = "×× ×× ××"; $foo.bytes | ||
evalbotzy | 3 | ||
nothingmuch | ?eval my $foo = "×× ×× ××"; $foo.chars | 13:38 | |
evalbotzy | 3 | ||
nothingmuch | that's bollocks | ||
?eval "fooooo".chars | |||
evalbotzy | 6 | ||
nothingmuch | ?eval "ש×××".chars | ||
evalbotzy | 1 | ||
nothingmuch | anyway, nevermind, appearantly evalbot is not grokking the unicode | ||
in my terminal it works correctly | 13:39 | ||
as for graphemes, Ʊ is one char, but two graphemes, and i don't know how many bytes (encoding dependant) | 13:41 | ||
?eval 'Ʊ'.chars | |||
evalbotzy | 1 | ||
nothingmuch | ?eval 'Ʊ'.craphs | 13:42 | |
evalbotzy | Error: No compatible subroutine found: "&craphs" | ||
nothingmuch | ?eval 'Ʊ'.graphs | ||
evalbotzy | 1 | ||
nothingmuch | itz: fair enough? | 13:44 | |
iblech | autrijus: Could you please explain what isNamed indicates? sub foo ($a) -- isNamed is 1, sub foo (+$a) -- isNamed is 0 | 13:46 | |
nothingmuch | iblech: named vs positional params | 13:47 | |
iblech | nothingmuch: Right, but why is isNamed 1 for a positional? | ||
nothingmuch | because it can be named | ||
wait | |||
ughhh, confusion! | 13:48 | ||
itz | nothingmuch: you lost me there :) is @foo.len not valid syntax? I thought it worked in the past? | ||
nothingmuch | itz: there is no 'len' method for arrays | ||
iblech | nothingmuch: Thought so too. But then I wondered why isNamed is 0 for a name-only param... | ||
nothingmuch | and not even 'length' like there should have been | ||
iblech | itz: It is valid syntax, though | ||
nothingmuch | itz: the error is not a syntax one, it's a "can't find such a method" one | 13:49 | |
iblech | ?eval "a string can't be .summed".sum | ||
evalbotzy | 0.0 | ||
itz | was it ever in pugs or did I dream it? | ||
iblech | d'oh | ||
itz: You must have dreamed it :) | |||
nothingmuch | itz: there are no more abbrv func names in p'l 6 | 13:50 | |
itz | hmm I must be confusing p6 with ruby or something | ||
nothingmuch | so it was never 'len' but rather 'length', but even that doesn't make sense, because arrays don't have a length | ||
they have a size in a certain dimension, like the number of elements | |||
uh | 13:51 | ||
itz | I want "elems" then? | ||
nothingmuch | damnit, shouldn't it be @array.elements ? | ||
i thought they were dropping all the gethostbynm type crap | |||
iblech | nothingmuch: Huffmann, etc. chars, graphs, bytes, elems | ||
nothingmuch | are there full sized aliases? | ||
iblech | itz: If you want the number of elements in an array, yes -- you can use @array.elems or +@array | 13:52 | |
nothingmuch: our &elements ::= &elems? | |||
nothingmuch | iblech: i mean by default | ||
but yes | |||
?eval my @foo = <1 2 3>; @foo.elements | 13:53 | ||
evalbotzy | Error: No compatible subroutine found: "&elements" | ||
nothingmuch | ?eval my @foo = <1 2 3>; @foo.elems | ||
evalbotzy | 3 | ||
nothingmuch | also 'graphs' is not as clear as 'graphemes | ||
and shouldn't the tilde on Ʊ be a different grapheme? | 13:54 | ||
iblech | .graphs is currently the same as .chars | 13:55 | |
nothingmuch | ah | ||
btw, should we also have phonemes? | |||
iblech doesn't have a strong opinion, as long as he has .bytes and .chars | 13:57 | ||
nothingmuch | en.wikipedia.org/wiki/Terminology_i...aphonomics | ||
well, .chars is sometimes diff | |||
it's the most common usage | |||
and .bytes is totally orthogonal | |||
in hebrew, for example, we have nikud | 13:58 | ||
we have very few vowels | |||
and most motions are implicit, when there is no nikud present | |||
svnbot6 | r6419 | fglock++ | * perl5/ List | 14:13 | |
r6419 | fglock++ | - implemented ('a' x 100) style lists | |||
r6419 | fglock++ | this can be used to create sparse arrays like: [ 1, undef x 1_000_000, 2 ] | |||
r6420 | iblech++ | * Usual svn props and EOLs at EOFs. | |||
r6420 | iblech++ | * t/builtins/lists/: map.t, sort.t, grep.t, sum.t, reduce.t: | |||
r6420 | iblech++ | Test that 42.sum, 42.map, etc. do not work (but (42,).sum, etc.) should work. | |||
r6420 | iblech++ | * t/subroutines/slurpy_param.t: Fixed some minor details, changed the expected | |||
r6420 | iblech++ | results of some tests to make more sense, started a p6l thread concerning | |||
r6420 | iblech++ | the test and skipped all tests ("semantics not confirmed by p6l") until p6l | |||
r6420 | iblech++ | replies. | |||
iblech | fglock: undef x 1_000_000 should not create a list containing 1_000_000 items, but a string of length 1_000_000: | 14:14 | |
?eval "42" x 5 | |||
evalbotzy | '4242424242' | ||
iblech | ?eval "42" xx 5 | ||
evalbotzy | ('42', '42', '42', '42', '42') | ||
lhooq | ?eval my $i = 0; sub i { $i++ }; i() for (1..5); | 14:15 | |
evalbotzy | undef | ||
lhooq | ?eval my $i = 0; sub i { $i++ }; (i, i, i, i, i); | 14:16 | |
evalbotzy | (0, 1, 2, 3, 4) | ||
lhooq | ?eval my $i = 0; sub i { $i++ }; i xx 5; | ||
evalbotzy | Error: No compatible subroutine found: "&xx" | ||
lhooq | ?eval my $i = 0; sub i { $i++ }; i() xx 5; | ||
evalbotzy | (0, 0, 0, 0, 0) | ||
lhooq | eager! | ||
iblech | lhooq: Right. You need something like (1..5).map:{ i() } | 14:17 | |
But IIRC luqui (or was it somebody else?) wants to change that to { i() } XX 5 | |||
s/change that to/make the following possible/ | |||
lhooq | with uppercase XX? | 14:18 | |
iblech | Yep. | ||
But the proposal hasn't been accepted by @Larry | |||
PerlJam | map is easier to type | 14:19 | |
nothingmuch | iblech: i think it was Juerd | ||
iblech | nothingmuch: Ah, thanks | ||
PerlJam | I'd take i() xxx 5 before I'd like XX | 14:20 | |
nothingmuch | &:infix:{'x' x 3} | 14:21 | |
nothingmuch thinks it should have been 'x' instead of 'xx' and '~x' instead of 'x' | |||
PerlJam | nothingmuch: maybe. We already have that consistency elsewhere, so it makes sense with x I guess. | 14:22 | |
nothingmuch | PerlJam: did you hear my rant about == ? | ||
PerlJam | nope | ||
nothingmuch | i think ~== and +== should replace 'eq' and '==' respectively | ||
where '==' is generic equality | |||
PerlJam | Hmm. | 14:23 | |
nothingmuch | so "foo" == "bar"; | ||
and "foo" == 1 | |||
they work | |||
PerlJam | What does "work" mean? | ||
nothingmuch | it's stringwise in these cases, because coercion works that way better than numification works | ||
otoh 10 == 10 and 10 == 10.0 is also good | |||
although "10.0" == 10 | 14:24 | ||
that is bad, because it's ~== | |||
for that you need to say "10.0" +== 10, and instead of the right side being stringified, the left side is numified | |||
autrijus hates it | |||
but my argument is that i need generic equality much more often than I need "eq" or "==" | |||
PerlJam | nothingmuch: I'll tell you that I don't believe in "generic equality" | 14:25 | |
You have to know the types of the things you're comparing at some level. | |||
nothingmuch | it's not generic equality in the sense that it's super smart | ||
it's a part of the Eq role | |||
and object must implement it if it wants to | |||
like "use overload '=='" in perl 5 | 14:26 | ||
PerlJam | my $a = new Foo; my $b = new Bar; $a == $b # What's this? An error if both don't do the Eq role? | 14:27 | |
nothingmuch | yes | ||
unless MMD defines it otherwise | |||
perhaps ~== is the default == | 14:28 | ||
but it lets you have truely meaningful things: | |||
xinming | iblech: :-) In fact, I considered the slurpy *%hash carefully, And I think I "might" be right, So I wrote the test. :-P | ||
nothingmuch | multi sub &infix:<==> (@l, @r) { @l.elems +== @r.elems && (@l Ā»==Ā« @r) | 14:29 | |
xinming | iblech: thanks for your modification. | ||
PerlJam | trigraphs are little loved though. If you could make them digraphs even they'd be more palatable. | ||
iblech | xinming: Lets wait for p6l to respond :) | ||
xinming: But I don't think it makes much sense that you can't pass any parameters by name if there's a *%slurpy_hash | 14:30 | ||
nothingmuch | PerlJam: what bothers me about eq vs == is that in perl 5 the choice was mostly aesthetic | 14:31 | |
people overload == more often because it looks more like = | |||
lhooq | ?eval my @a = (); @a.push('x') for(1..3); @a; | 14:32 | |
evalbotzy | ['x', 'x', 'x'] | ||
lhooq | ?eval my $i = 0; sub i { $i++ }; my @a = (); @a.push(i) for(1..5); @a; | ||
evalbotzy | [0, 1, 2, 3, 4] | ||
nothingmuch | and for many things, especially structures it makes sense to overload equality (sets, arrays, junctions, etc) for reasons of efficiency as well as accuracy | ||
further uses: | 14:33 | ||
path handling: the path object's == consolidates 'dir/..' so that Path.new("foo/../bar") == Path.new("bar") | 14:34 | ||
you can overload == locally for float tolerance: | |||
my &infix:<==> (Float $l, Float $r) { abs($l - $r) < $threshold } | 14:35 | ||
this doesn't interfere with +== on numbers | |||
PerlJam | nothingmuch: careful ... Larry may like your idea but use +eq and ~eq instead ;-) | 14:37 | |
nothingmuch | does this seem somewhat sane? | ||
lhooq | nothingmuch: sorry, but I don't like +== for comparison, it looks too much like += | 14:38 | |
iblech | nothingmuch: I agree, it's very useful. *But* I want eq to stay string eq and == to stay numeric eq. | 14:39 | |
nothingmuch: But now there's eqv :) | |||
nothingmuch: my multi &infix:<eqv> (Float $l, Float $r) {...} | |||
nothingmuch | right, i know eqv | ||
and I hate it | |||
lhooq: what do you think about the other ~/+/? distinctions? | 14:40 | ||
PerlJam | There's too much cultural history for == or eq to go away. | ||
nothingmuch | what about the consistency? &&, || and ^^ are generalized | ||
?&, ?|, +&, ~^, etc are specialized | 14:41 | ||
broquaint | ?eval class MyArray is Array { sub push { say "pushing things: {@_.perl}" } }my @a = MyArray.new; @a.push("a string"); # What am I missing? | 14:42 | |
evalbotzy | 2 | ||
broquaint | No, I don't think there's a 2 missing, evalbotzy. | 14:43 | |
But nice guess. | |||
nothingmuch | ?eval class MyArray is Array { sub push { method "pushing things: {@_.perl}" } }my @a = MyArray.new; @a.push("a string"); | ||
evalbotzy | 2 | ||
nothingmuch | ?eval class MyArray is Array { method push { say "pushing things: {@_.perl}" } }my @a = MyArray.new; @a.push("a string"); | ||
evalbotzy | 2 | ||
iblech | broquaint: That wouldn't work, you have to use my @a is MyArray | ||
nothingmuch | oops, wrong subs ;-) | ||
iblech | broquaint: Otherwise it's simply my @a = (MyArray.new) | ||
nothingmuch | ?eval class MyArray is Array { method push { say "pushing things: {@_.perl}" } } my @a is MyArray; @a.push("a string"); | 14:44 | |
iblech | broquaint: But it's not implemented yet | ||
evalbotzy | 1 | ||
broquaint | Indeed, iblech. Using := instead of = does the trick too. | ||
?eval class MyArray is Array { sub push { "pushing things: {@_.perl}" } }my @a := MyArray.new; @a.push("a string"); # What am I missing? | |||
evalbotzy | 'pushing things: [MyArray.new();, \'a string\']' | ||
broquaint | Neat. | 14:45 | |
And sub Array::push works too, which is very cool. | |||
xinming | iblech: where can I find the contents for the `built-in sum`? | ||
iblech | xinming: IIRC src/Pugs/Prim/List.hs | ||
xinming | iblech: thanks | 14:46 | |
iblech | xinming: Or perl5/PIL2JS/lib6/Prelude/JS/Array.pm if you want to see a pure-Perl 6 version of it :) | ||
xinming | Oops... Isn't there a perl version? | ||
thanks | |||
lhooq | nothingmuch: well, I don't like the distinctions too much, especially the ? one | ||
iblech | xinming: The sum in the .hs file is in Haskell | 14:47 | |
lhooq | nothingmuch: but &&, || and ^^ are different, they are always boolean in context | ||
nothingmuch | so is == | ||
wait | |||
no, only == is | |||
&& and || and ^^ are not boolean at all | 14:48 | ||
or do you mean the context they force on their args? | |||
fglock | stevan: ping | ||
lhooq | yes, I mean the context | ||
xinming | iblech: yes, In fact, I want to know If I can do as the "same" as the built-in ones. :-) | ||
nothingmuch | sub &infix:<||> ($l, $r) { return $l if ?$l; return $r } | ||
i always saw them as passthrough | 14:49 | ||
lhooq | there is an explicit ? there | ||
nothingmuch | yes | ||
lhooq | so they "force" boolean context somehow | ||
nothingmuch | if $l in boolean context is true, then return $l, otherwise return $r | ||
$r is never boolean | |||
unless they stack | |||
lhooq | well, ok, I think you understood what I'm talking about | 14:50 | |
iblech | xinming: Not sure I've understood you correctly, but yes, you can override the builtin implementantions. I.e. even sub say (*@args) {...} is fine | ||
lhooq | you don't really need something like +||, +&& etc. | ||
QtPlatypus | lhooq: You need it to distingiush between +|| and ~|| | 14:51 | |
lhooq | QtPlatypus: you _don't_ _need_ | 14:52 | |
14:52
autark is now known as jp-autark
|
|||
lhooq | the distinction is +(A || B) vs. ~(A || B), maybe | 14:52 | |
QtPlatypus | lhooq: So using context to deside which one? | 14:53 | |
broquaint | Let's just drop boolean operators and be done with it. | ||
lhooq | QtPlatypus: no, because the || is always the same | ||
nothingmuch | how is operator precedence specified for 'sub &infix:<blah>' ? | ||
lhooq | the _external_ context may be different, but || doesn't care | ||
nothingmuch | or which synopsis is that in? | ||
QtPlatypus | Hold on || is bitwise or isn't it? | 14:54 | |
lhooq | (doesn't care in the sense that it is "passthrough", as nothingmuch noted) | ||
nothingmuch | or (~A || ~B) | ||
xinming | iblech: what I mean, is, I want to know, If I catch the "right" idea of writing perl 6 program. :-) the built-in certainly would be the best example for me to follow. | ||
iblech: by the way, did you read the Synopsis? | |||
nothingmuch | the passthrough-ness of &&, and && should apply to ==, IMHO | ||
xinming | the S06 | ||
nothingmuch | ^^ returns Bool anyway | ||
so == is not in a different ballpark | 14:55 | ||
xinming | iblech: It was updated this "morning" (here now is evening, maybe midnight) | ||
lhooq | nothingmuch: I disagree | ||
nothingmuch | lhooq: i know you don | ||
t | |||
it's just my opinion =) | 14:56 | ||
lhooq | I don't see _how_ == is supposed to passthrough | ||
xinming away to go out to take something to eat. | |||
bbl | |||
iblech | xinming: Of course, I have read all AES several times :) | ||
xinming: Right, but the update didn't effect the section about slurpies, right? | |||
lhooq | variables in Perl are not strong-typed, so unless you use == or eq, you can't possibly know what to numify and what to stringify | 14:57 | |
iblech | xinming: I've thought of slurpy hashes similar as of slurpy arrays -- they slurp all *remaining* arguments (positionals or pairs) | ||
nothingmuch | lhooq: it's not passthrough, but it's generic | 14:58 | |
lhooq | define "generic" | ||
nothingmuch | does anybody remember how you say what an &infix's precedence is? i can't find it | ||
lhooq: multi sub &infix:<==> (@l, @r --> Bool) { @l.elems +== @r.elems and @l.elems } | |||
uh, crap, that's 50% | |||
lhooq: multi sub &infix:<==> (@l, @r --> Bool) { @l.elems +== @r.elems and @l Ā»==Ā« @r } | 14:59 | ||
lhooq | nothingmuch: is tighter(...) or something like that | ||
nothingmuch | lhooq: thanks | ||
lhooq | nothingmuch: this can't be what you want | 15:01 | |
nothingmuch | it is | ||
lhooq | nothingmuch: if I want a == to compare each element in two arrays, I prefer to explicitly use >>...<< | ||
nothingmuch | what if it's a generic collection? like a tree? | 15:02 | |
lhooq | eg. when I do something that could bog down my CPU like a slug, I don't want it to be _so_ easy to do | ||
nothingmuch | do you need to define multi &circumfix:{'>>', '<<'} (Code $op, Tree $tree) { .... } ? | 15:03 | |
lhooq: why bog down? | |||
stringification of an array takes just as long | |||
and @array == @other is very confusing | |||
that is really (@array.elems == @array.elems) | |||
newbies will weep | 15:04 | ||
lhooq | but their CPUs will rejoice :-) | ||
nothingmuch | (@array +== @other) is much more "clear cut" | ||
but it'll be wrong code | |||
and infix == is more "optimized" than >>==<< because it checks @l.elems +== @r.elems first, too =) | |||
and in fact, i think that >>==<< can be misleading if the shape of two arrays isn't the same | |||
are undefs substituted in the shorter list? | 15:05 | ||
lhooq | then it is (@array == @other && @array >>==<< @other) | ||
nothingmuch | i know, but i think that's aweful | ||
what it is now is much better: | 15:06 | ||
if (@array eqv @other) | |||
but that still kinda sucks | |||
IMHO at least | |||
iblech | nothingmuch: That won't do what you think it does, I think. | ||
nothingmuch: eqv expects two scalars, so that really is \@array eqv \@other | |||
nothingmuch | ugh | ||
lhooq | shouldn't that be @array ~~ @other? | ||
nothingmuch | is it multi? | 15:07 | |
lhooq: ~~'s conveyed meaning is completely different, IMHO | |||
iblech | nothingmuch: Then these refs (in the absense of some rebinding) don't point to the same container, so it'll always be false | ||
lhooq: Right, @array ~~ @other should work, I think | |||
nothingmuch | my @array = <a b c>, my @other = (rx/a/, rx/[abc]/, rx/\w+/); @array ~~ @other; | ||
*BOOM* | |||
it's way too smart | 15:08 | ||
which is good for most things | |||
but not for some things | |||
lhooq | nothingmuch: anyway, your example still doesn't answer this question: is each element in @l and @r compared numerically or stringish? | ||
nothingmuch | lhooq: that depends on each pair of elements, and the MMD that matches | ||
=) | |||
iblech | nothingmuch: Hm, to the problem is that it recurses too much... @array ~~ @other :recurse(0) | ||
nothingmuch | iblech: i beg to differ | 15:09 | |
~~ is just as recursive, even if it's implicit | |||
Array Array arrays are identical match if $_ Ā»~~Ā« $x | |||
from s04 | |||
iblech | nothingmuch: Right, I meant that by using an adverbial modifier you could change that behaviour | 15:10 | |
nothingmuch | in a sense I think that &infix:<==> should have the same "recursive" semantics as &infix:<~~> in the prelude | ||
oh | |||
it's just that == is applied instead of ~~ to the elements | |||
so why not have @array == @other :recurse(0); | |||
iblech | Because == means number, and I doubt that this changed | 15:11 | |
(I don't want it to change, too :)) | 15:12 | ||
But that's what ~~, paired with modifiers, is there for, I think | |||
nothingmuch | ick | 15:13 | |
i'm mailing to p6l | |||
please make sure to voice your protest | |||
iblech | I will :) | ||
nothingmuch | &infix:<~~>.add_variant(sub (Code &op, Array @l, Array @r) { @l >>&op<< @r }.assuming(&infix:<~~>)) | 15:15 | |
iblech | ooh | ||
but | |||
how do you specify your own comparator, given that ~~ is not ternary? | |||
nothingmuch | rephrase please | ||
iblech | I mean, ~~ takes only two arguments, LHS and RHS | 15:16 | |
nothingmuch | right | ||
iblech | But your snippet adds a third param | ||
nothingmuch | so does == | ||
iblech | Right. | ||
nothingmuch | assuming =) | ||
iblech | Right. | ||
But: | |||
If I don't want to use .assuming | 15:17 | ||
But if I want to override it only for one single call | |||
nothingmuch | then it's just a weird variant | ||
that takes an entirely different set of params | |||
iblech | I.e. something along the lines of @foo ~~:{ $^a eq $^b } @bar | ||
(But this look very ugly) | |||
nothingmuch | huh? | 15:18 | |
iblech | Hm, @foo ~~ @bar :comparator{ $^a eq $^b } | ||
nothingmuch | ah | ||
you just take the generic comparator generator from the prelude, and apply it to your own op | |||
in my email it will be cleared | 15:19 | ||
iblech | ok, /me waits :) | ||
nothingmuch | sent | ||
iblech | (I like that general idea, as far as I've understood it, BTW) | ||
nothingmuch | yes, i like it too =) | 15:20 | |
btw, i've changed my mind slightly | |||
=='s affinity is towards multi sub &infix:<==> (Num $l, Num $l) { ... } | |||
lhooq | nothingmuch: anyway, I think that "generic equality" a) causes more problems than it tries to solve and b) is too CPU-intensive to implement | ||
nothingmuch | so "10.0" == 10 is backwards compatible | ||
lhooq: most of perl 6 is too CPU intensive already | 15:21 | ||
lhooq | so you fight fire with fire? :-) | ||
nothingmuch | as for a) we're trying to clean this up... MMD is helping, but I definately don't want 'use overload' all over again | ||
lhooq: no.. See also Psyco, type inferencing, and what not to make it "just work" | 15:22 | ||
as well as the fact that despite this we still have >><< and [] which are *very* dangerous in that respect, but so useful we can't give uup | |||
the caveat in my proposal is that (@a == @b) cannot be translated as is | |||
and makes things slower for that case | |||
but when I want to compare the number of elements we have all sorts of disambiguations anyway.. .for example, it's not @a.length like in other programming languages, it's @a.elems | 15:23 | ||
so in that sense I think Perl 6 is progressing to another plane of usefulness | |||
and correctnes | |||
s | |||
and in that sense we should strive to give bazookas to shoot your foot with | |||
lhooq | but you're giving a bazooka that looks like a lollipop | 15:24 | |
nothingmuch | because in the long run, as people become adept in perl this will pay off, as a programmer time optimization, and that's what really matters at the end of the day | ||
i agree | |||
but i think perl 6 is far enough from history to allow us to make it look like a lollipop | |||
lhooq | well | ||
nothingmuch | because it's a very sweet bazooka | 15:25 | |
lhooq | I remember the first time I saw a regexp | ||
nothingmuch | as in totally cool | ||
lhooq | I thought "bazooka!" | ||
nothingmuch | (ref: www.realultimatepower.net/) | ||
lhooq | now I master it, and can shoot with it | ||
nothingmuch | iblech: extend_comparators on the bottom | 15:26 | |
These guys are cool; and by cool, I mean totally sweet | 15:27 | ||
i got it backwards =( | |||
anyway, perl 6 is all about real ultimate power... think about it: | |||
1990s: regexes... perl 6: full blown parser engine | |||
1990s: for loops... perl 6: vectorizations | |||
1990s: overloading... perl 6: higher order infix subs, and MMD dispatch make it all just functions | 15:28 | ||
1990s: boolean logic... perl 6: junctive types encapsulate logic in data | |||
(slow! autohtreading! dangerous! but still in there!) | 15:29 | ||
anyway, i have to get back to house work | 15:30 | ||
i have to finish putting the books back on the shelf | |||
and vaccum the cement dust from my room | |||
nothingmuch thinks about restarting fryTunes in perl 6 | 15:35 | ||
the metamodel for music data is much easier to do with such a tough object system | |||
nothingmuch will think about it while cleaning... Ciao! | |||
iblech | nothingmuch: Could you elaborate a bit on extend_comparators later? | ||
nothingmuch | iblech: still here, was reading mail | 15:36 | |
iblech: are you asking? | 15:37 | ||
iblech | nothingmuch: Yep :) | ||
nothingmuch | okay =) | ||
btw, is control over whether --> is used for inferencing or not in the lexical scope? | 15:38 | ||
(strong inferrencing) | |||
iblech | Huh? Can it be used for something different that inferencing? | ||
nothingmuch | (we should always have [partial] static inferencing) | ||
well, if &infix:<==> (.... --> Bool) (regardless of whether it's generic or numerical) | 15:39 | ||
then can I use it and ignore the fact that it wants to return a Bool ? | |||
or do I have to use it in a type safe way? (BAD BAD BAD) | |||
iblech | Ah, I understand | ||
nothingmuch | i'd like to say "use types 'inferred'" | ||
and that way all functions can have (-->) | 15:40 | ||
or maybe that's just moot | |||
anyway, i'd like to be able to make use of any library that says what it returns in a type inferred way, and in an unsafe way | |||
and i'd like types to be inferred in both cases, and only when there is a conflict for the distinction to shine: safe - compile time error, unsafe - coercion compiled in | 15:41 | ||
iblech | I think that will definitely work, given that we're talking about Perl (and not Haskell) :) | ||
You always have coercion, I think | |||
I.e. "1" + 1 will always work | |||
nothingmuch | should it always work? | 15:42 | |
iblech | Hm, I think so | ||
Because | |||
nothingmuch | even if i "use types 'nazi'"? | ||
iblech | There exists a coerce:<as>(Str $str, Num ::to) | ||
I think you need to talk with autrijus about that :) | |||
nothingmuch | "use types 'inferred' :forbid<coercion>" | ||
there, problem solved =) | 15:43 | ||
iblech | Right, something along this line | ||
nothingmuch | i think everyone agrees that it's time for a language that is as type safe as the programmer wants it to be =) | ||
so what is your question about extend_comparators? | |||
btw, is the sigil & just a macro for 'Code $' ? | 15:44 | ||
i think that is pretty cool, except for 'my $var; my &code'; | 15:45 | ||
uh, i meant 'my $foo; my &foo; | |||
QtPlatypus | nothingmuch: Not in all cases. | ||
nothingmuch | QtPlatypus: morally =) | ||
QtPlatypus | sub foo {...}; &foo; | 15:46 | |
nothingmuch | iblech: faster! | ||
think of sub $name as just a macro for BEGIN { &symbol = $parsed } | |||
if it's not preceeded by 'my' or 'our' it gives our | |||
iblech | nothingmuch: Sorry, was afk for a moment | ||
nothingmuch: Right, autrijus and I want to change it that way | |||
nothingmuch: But the sigil is till & | 15:47 | ||
s/till/still/ | |||
QtPlatypus | nothingmuch: I like that. | ||
nothingmuch | sorry | ||
iblech | So there's no conflict between $var and &var | ||
nothingmuch | there is the macro 'sub' | ||
and the function 'sub' | |||
which is just like 'id' | |||
but also takes parameters | |||
(a prototype) | |||
beh, it's a bit more difficult than that, obviously | |||
but in a sense the declaration 'sub' is a macro just like 'use' is a macro | 15:48 | ||
iblech | nothingmuch: WRT extend_comparators, could you give me some code lines to illustrate your idea? :) | ||
nothingmuch | iblech: think of that as the part of the prelude that defined ~~ | ||
iblech | ok | ||
nothingmuch | there are already &infix:<~~> ($_, $code) | ||
and so on and so forth | |||
and then more generic comparisons regarding collections are generated | 15:49 | ||
like $item ~~ %hash; | |||
or @array ~~ @array | |||
the rules for how ~~ matches WRT to collections can be applied to == too | |||
iblech | ok | ||
nothingmuch | btw, can I define aggregate functions like this? | 15:50 | |
&foo := for.assuming(:block -> $x, $y { ... }); | |||
iblech | &foo := &statement_control:<for>.assuming(block => -> $x, $y {...}) should work | 15:51 | |
nothingmuch | woot! | ||
iblech: is the extend_comparators issue cleared up? | |||
because I really need to become useful now | |||
holy shit! leaf.dragonflybsd.org/mailarchive/s...00028.html | 15:52 | ||
iblech | nothingmuch: No, but I have to think a bit longer about that and I don't want to keep you from becoming useful :) | ||
nothingmuch | iblech: then reply to the p6l post please =) | ||
iblech | nothingmuch: Yep, will write it in a minute :) | 15:53 | |
nothingmuch | ciao! | ||
iblech | bye nothingmuch :) | ||
xinming | iblech xinming: I've thought of slurpy hashes similar as of slurpy arrays -- they slurp all *remaining* arguments (positionals or pairs) | 16:00 | |
iblech: then, This would cause Error. | |||
the positional argument is normally required, right? | |||
slurpy *%hash slurped it, Then, You didn't specify the $positional, It would be a compile time error. | 16:01 | ||
iblech: hmm, But what I do not agree with is if there is a ( pair ) need to pass to the hash, but not the keyword is the same as positional's name, then, It's an error. just like | 16:05 | ||
sub fun( $a, *%h ) { ... }; In my opinion, If there is a slurpy hash, pass the arguments with "pair-form" should be disabled. | 16:06 | ||
iblech: Sorry, I went out for the "supper" :-) | |||
iblech: In fact, I even thought that if @Larry hesitates to choose in these two choices. | 16:08 | ||
mambotech | hi, can anyone here tell me what is missing please Can't locate Config/IniFiles.pm in @INC (@INC contains: /usr/local/lib/perl5/site_perl/5.8.7/mach /usr/local/lib/perl5/site_perl/5.8.7 /usr/local/lib/perl5/site_perl /usr/local/lib/perl5/5.8.7/BSDPAN /usr/local/lib/perl5/5.8.7/mach /usr/local/lib/perl5/5.8.7 .) at /usr/local/sbin/vuser line 9. | 16:09 | |
BEGIN failed--compilation aborted at /usr/local/sbin/vuser line 9. | |||
xinming | mambotech: How do you run pugs? | 16:10 | |
do you use make install as root? | |||
mambotech | ? | ||
xinming | mambotech: command make just compile the sources. It seems that your installation isn't complete | 16:11 | |
iblech | xinming: luqui replied to my question on p6l | 16:16 | |
mambotech: I think you want #perl, not #perl6, #perl6 is only about Perl 6 | |||
xinming: The point is, that slurpy hashes only slurp remaining pairs, i.e. only pairs which were *not* already consumed by naming other positionals | 16:18 | ||
I.e. sub foo (*%hash, *@rest) -- %hash always gets all pairs | |||
sub foo ($x, *%hash, *@rest) -- foo(bar => "baz") -- %hash gets (bar => "baz") | 16:19 | ||
sub foo ($x, *%hash, *@rest) -- foo(x => "baz") -- %hash gets (), $x gets "baz" | |||
xinming | iblech: hmm, Ok, I think your right. So, will there be a "shadow-copy" of x => "baz" in %hash? | 16:24 | |
iblech | xinming: luqui wasn't sure | 16:25 | |
xinming: But currently, not | |||
xinming | iblech: :-) I think If we need to explicit specify the pair to hash, we could use a keyword to explicitly specify it. | 16:26 | |
iblech: I would change the test later. :-) | |||
jql goes even farther off the deep end... foo("baz") should imply %hash<x> eq 'baz' | |||
positionals should just default the key-name, IMO | 16:27 | ||
iblech | xinming: Or we could simply use sub foo (*%hash), which will unconditionally slurp all pairs | ||
xinming | iblech: hmm, But that lack the flexibily of foo "bar", "this", ( x => 'y' ) | 16:28 | |
why @Larry made spcify the *%hash might because of, Some of the arguments might not be needed, And the optional 'named-param' can't handle all the situation. | 16:30 | ||
hmm, That's just my opinion. :-) | |||
iblech | Right, then you'd have to use sub foo (*%hash, *@rest) | ||
xinming | iblech: The problem also exist, *@rest can't do "type-checking" :-) | 16:31 | |
s/exist/exists/ | |||
eg: sub foo ( Str $str, *%h ) { ... }, If you use @rest, Then, The first param can be every thing. | 16:32 | ||
iblech | Right. In this case, simply don't use *@rest :) | ||
I.e., sub foo ( Str $str, *%h ) { ... } is perfectly fine | 16:33 | ||
xinming | hmm, I think, sub foo( [Type $var, ... *@rest ], *%hash ); might help. | ||
iblech | oh, right! :) | ||
xinming | iblech: well, these example doesn't cover all the cases. And @Larry wish to cover them all, to obey m0tto, "TMTOWTDIT" :-) | 16:34 | |
seen autrijus | |||
jabbot | xinming: autrijus was seen 1 days 13 hours 20 seconds ago | ||
xinming | hmm, Where did autrijus go? | ||
xinming is missing him... | 16:35 | ||
iblech | xinming: Right, TIMTOWTDI++ :) | 16:36 | |
He's deep into $work, I think | |||
deadline, etc. | |||
xinming hopes he can be more helpful in the future. | |||
fglock | iblech: I'm reading PIL2JS - trying to see if we can unify some code | 16:40 | |
iblech | fglock: ooh (unifying code)++ | 16:43 | |
fglock: Especially lib6/Prelude/JS/ControlFlow.pm could probably share some code with PIL-Run | |||
E.g. map, for, while, until, etc. all use loop | 16:44 | ||
fglock | why is it written in p5 (not p6)? | ||
iblech | It is written in P6 :) | ||
With some JS code, of course | 16:45 | ||
fglock | I mean, the main program, not the library | 16:46 | |
iblech | ah. | 16:47 | |
Speed, I think | |||
fglock goes away for a while | 16:50 | ||
xinming | ?eval ( a => 'abc', b => 'xyz' ).key | 16:55 | |
evalbotzy | ('a', 'abc') | ||
xinming | ?eval ( a => 'abc', b => 'xyz' ).keys | 16:56 | |
evalbotzy | (0, 1) | ||
xinming | hmm... :-) | ||
iblech | m19s28.vlinux.de/iblech/stuff/not_p...smoke.html # New PIL2JS smoke, 65.59% ok, ~~40min | ||
Hm, seems to be a bug | 16:57 | ||
xinming | ?eval ( a => 'abc', b => 'xyz', c => 'ddd' ).keys | ||
evalbotzy | (0, 1, 2) | ||
iblech | (the first one) | ||
?eval (a => "abc").key # should give "a" | |||
evalbotzy | 'a' | ||
iblech | ?eval (a => "abc", bar => "baz").key # should be an error | ||
evalbotzy | ('a', 'abc') | ||
iblech | as (a => "abc", bar => "baz") is not a Pair | ||
food & | |||
xinming | ?eval { a => 'abc', b => 'xyz', c => 'ddd' }.values | 16:58 | |
evalbotzy | ('abc', 'xyz', 'ddd') | ||
xinming | ?eval { a => 'abc', b => 'xyz', c => 'ddd' }.keys | ||
evalbotzy | ('a', 'b', 'c') | ||
ods15 | hi nothingmuch | 17:06 | |
nothingmuch: do you use your laptop as your main box? | |||
nothingmuch | i have two "main boxes" in this sense | 17:07 | |
the laptop does everything PCish: text editing, movie viewing, browsing | |||
ods15 | ircing? | ||
nothingmuch | and I also have pasta, which is headless... it does apache, postfix, dhcp, dns, routing, etc | ||
irc is on the laptop | |||
i tried irc in screen on pasta for a while | 17:08 | ||
but then I realized that I don't really need to be available 24/7 through backlogs | |||
I do read my email on pasta, via mutt inside screen | |||
muttng actually | |||
but that is the only regular use for pasta that isn't implicit | |||
ods15 | muttng? | 17:09 | |
nothingmuch | mutt + many patches (maildir header caching, side bar, nntp, pgp password forgetter, and more and more and more) | ||
iblechbot: :comparator is trivial, read mail | 17:10 | ||
wolverian | I use muttng just for the caching :) | ||
nothingmuch | it's wonderful | ||
wolverian | yes. | ||
nothingmuch | i switched to reiserfs when i made the move towards LVM + software raid | ||
so that I could have online resizing of partitions | |||
wolverian | online? | 17:11 | |
nothingmuch | so old mutt became unbearably slow (maildirs + reiser + nocaching) | ||
wolverian: no unmount | |||
you can only grow though | |||
wolverian | hm. I thought rfs is supposed to be fast in a scenario like that? | ||
nothingmuch | i thought so too, but it's not fast, it's just size efficient, i guess | ||
i have notail now | |||
maybe I should copy my maildir and swap | 17:12 | ||
anyway, muttng and screen were very good optimizations | |||
ods15 | caching? | ||
as in, when you open a really big maildir? | |||
nothingmuch | ods15: instead of reading each maildir file it keeps an index of the headers | ||
17:12
Maddingue__ is now known as Maddingue
|
|||
nothingmuch | each message file in a maildir, that is | 17:12 | |
ods15 | doesn't mutt already support this? | 17:13 | |
nothingmuch | yes, but with a patch that isn't in mainline | ||
ods15 | header_cache Type: path Default: "" | ||
The header_cache variable points to the header cache database. If header_cache points to a directory it will contain a header cache database per folder. If header_cache points to a file that file will be a single global header cache. By default it is unset and so no header caching will be used. | |||
thats from man muttrc, and afaik i'm using regular mutt | |||
nothingmuch | ods15: it may be your distro being nice to you | ||
ods15 | 20:13) ods15@linux15:~ $ mutt -v | 17:14 | |
Mutt 1.5.9i (2005-03-13) | |||
no sidebar that i know of btw | |||
wolverian | hmm. I have that too. odd. | 17:15 | |
nothingmuch | the sidebar is actually quite nice, b ut I dont really use it | ||
wolverian: that's in muttng | |||
wolverian | it might have come with 1.5.9i, I guess. | ||
nothingmuch, I have that in man muttrc | |||
nothingmuch | oh | ||
wolverian | (debian sid) | ||
nothingmuch | the headercache, not the sidebar | ||
wolverian | right. | ||
nothingmuch | i used mutt + headercache for a long time though, and i think muttng felt faster | 17:16 | |
ods15 | whats the sidebar | ||
wolverian | I'll try it. | ||
nothingmuch | so I think it caches on another level | ||
ods15 | folder list? | ||
nothingmuch | ods15: a mailbox list on the side | ||
that shows you counts | |||
ods15 | ah, one of the things i'm MOST missing in mutt | ||
but tbh doesn't sound "quite" right in console | |||
nothingmuch | tbh? | ||
ods15 | even with high res framebuffer, console isn't THAT big that you can stuff a sidebar too :/ | ||
to be honest | |||
nothingmuch | ods15: you toggle it | 17:17 | |
default binding to toggle is 'b' | |||
ods15 | hmm | ||
wolverian | ah. mutt doesn't have header_cache_compress | ||
ods15 | btw, is there any SIMPLE mime command line tool? | ||
wolverian | not that that should affect speed, at least negatively... | ||
ods15 | and btw, how d you deal with hebrew in mutt? | ||
nothingmuch | ods15: i don't deal with hebrew too well | 17:18 | |
the terminal is utf-8, which is Good Enoughā¢ | |||
but i don't write mail | |||
in theory it's possible, with vim supporting it | |||
ods15 | i don't deal with it at all.. if it's something i REALLY want to read, i open it with kmail | ||
justathe1ry removes it | |||
I'm an Emacs guy, after all. | |||
17:18
justathe1ry is now known as justatheory
|
|||
ods15 | i find the emacs/vim war extremely funny, because i personally think both suck :P | 17:19 | |
i REALLY like nano | |||
xinming | justatheory: So am I, :-) I love Emacs really... | ||
ods15 | seriously | ||
anyway, nothingmuch , you can READ hebrew mails in mutt though? | |||
justatheory | I don't love Emacs, but I do love cperl-mode. :-) | ||
nothingmuch | ods15: nano is decent because it's simple, and all the commands are displayed on the screen, so you don't even need to find out what command brings up help | ||
but for anything more it's... eh... | 17:20 | ||
ods15 | nothingmuch: i use for C coding, perl coding, bash scripting, mail editor, etc. etc. | ||
nothingmuch | no quantification, no pattern matching, no complex regular expressions, no pipes... | ||
xinming | ods15: hmm, But I don't think Vi is a poor Editor, Why I don't like Vim is because, For long time programming, If I am in Vim, The left hand (arm) won't feel so good. | ||
nothingmuch | I can read most hebrew mails | ||
ods15 | i have syntax highlighting, copy paste of entire lines or selected region, etc. etc. | ||
nothingmuch | xinming: tried ctrl + bracket? | ||
ods15 | nothingmuch: you lost me with all you said regarding pipes etc. | 17:21 | |
if i need to do some kind of 'generic' editing to a file, i do in bash, no an editor.. that's insane | |||
nothingmuch | ods15: how easy is it to pipe your buffer through 'expand' for example, if you're editing ingy's code? | ||
ods15 | expand? ingy? | ||
oh, ingy is a person | |||
nothingmuch | ingy doesn't use tabs, I do | ||
ods15 | expand is "indent"? | ||
nothingmuch | expand is s/\t/ /; | 17:22 | |
buut smarter | |||
xinming | nothingmuch: How do you konw my problem? -) | ||
ods15 | i've never seen a need for that... | ||
nothingmuch | ofcourse, this is permanently fixable by saying '# vim:set expandtab:' or whatever the syntax is | ||
ods15: do you edit other people's code? | |||
ods15 | if i do need such a thing, i do: c bla.pl P 's/\t/ /' > bla2.pl nano bla2.pl | ||
nothingmuch | WTF?! | 17:23 | |
use expand -4 | |||
ods15 | i've never even friggin heard of expand | ||
i've never expanded tabs | |||
nothingmuch | x\ty is not x y it's x y | ||
xinming | nothingmuch: In fact, I would prefer Emacs to reindent the code. C-M-h C-M-/ :-) | ||
nothingmuch | ods15: that's not my fault | ||
ods15 | that was just an example | ||
i've never done such a thing or wanted to do such a thing | |||
i wasn't complaining about not knowing expand :) because i've never had a use for it | 17:24 | ||
nothingmuch | and btw, ods15 if yhou're doing bla.pl and bla2.pl | ||
ods15 | in MPlayer, tab expansion is illegal anyway | ||
nothingmuch | you might as well do `perl -pi -e's/\t/ /' bla.pl' | ||
ods15 | (you can't send patches which change indentation) | ||
nothingmuch: yes i know, but i already have the aliases.. | |||
nothingmuch | ods15: in ingy code tabs are illegal | ||
(you can't send patches which change indentation) | |||
ods15 | i really should make a 'perl -pi.bak -e' alias... | ||
need a name for it.. 'P' is taken.. 'p' maybe? | 17:25 | ||
nothingmuch | pi | ||
ods15 | hmm, yes, 'p' good enough | ||
nothingmuch added a short alias today | |||
i have a sogudi alias 'pd' that is 'search.cpan.org/perldoc?@@@' | 17:26 | ||
ods15 | heh | ||
nothingmuch | so when I started typing 'pd' in the command line for already installed modules I realized I need an alias | ||
obra | sogudi? | ||
nothingmuch | obra: a safari hack | ||
you type into the URL bar 'pd Some::Module' | 17:27 | ||
and it takes the string on the right and substitutes for the '@@@' | |||
ods15 | heh i've never used url aliases | ||
obra | ah. *nod* | ||
nothingmuch | very convenient, except you can no longer type spaces in URLs and have safari replace them with %20 | ||
obra: I have wikipedia, regular cpan search, cpan perldoc, c2.com | |||
obra | *nod* I tend to work from the cli, not a browser | 17:28 | |
ods15 | btw what's your browser nothingmuch | ||
nothingmuch | oh, and recently 's 06' etc for synopses | ||
obra | I need to get a quicksilverish microterminal. | ||
nothingmuch | ods15: safari which isa konqueror | ||
ods15 | mine is 50:50 between elinks and firefox | ||
nothingmuch | obra: me too, but for things that aren't installed I use the browser | ||
as for quicksilver, I think it complements the terminal | 17:29 | ||
www.atamadison.com/w/kitzkikz.php?page=Sogudi | |||
ods15 | nothingmuch: anyway, nano is surprisngly more powerful than most people think | ||
nothingmuch | ods15: i know nano is not like pico | ||
obra | nothingmuch: I'm not on a mac ;) | ||
nothingmuch | but it's not a full blown editor either | ||
obra: for some reason I thought you were... hmm | |||
ods15 | wtf is a "full blown editor" | ||
nothingmuch tries to remember | |||
ods15: one with at least one embedded language | 17:30 | ||
ods15: which can autoindent smartly | |||
ods15 | heh? | ||
nothingmuch | and nest syntax highlighting modes | ||
ods15 | autindent is crap, all you need is keeping previous line's indent | ||
nothingmuch | ods15: not when you're writing bullets in email instead of code | ||
ods15 | nano has syntax highlights, and i wrote pretty nice regexes for it for C and Perl | ||
nothingmuch | regexes for perl? EEK | 17:31 | |
xinming | hmm, for a newbie, I really don't know why don't you choose Emacs, :-P for it is slowly? | ||
nothingmuch | you can't really write a *GRAMMAR* for perl | ||
ods15 | yes.. they are no failsafe (mostly with # inside strings), but they work pretty damn well | ||
obra | nothingmuch: I used to use a mac. I got better :) | ||
or rather, I got a laptop that suits me better. my desktop is still a mac | |||
nothingmuch | obra: congrats.. I'm still too lazy and happy with macs =) | ||
did you see the mac I bought at YAPC? | |||
obra | The thing that sold me was the Toshiba R100. | 17:32 | |
nothingmuch: no. what is? | |||
nothingmuch | PB 17" | ||
ods15 | my only 2 pet peeves with nano is bad pasting (if i forget auto-indent is goes wild), and it has some weird mem leak or something that causes it to slow to a crawl if you use it for a long while with syntax highlighting | ||
obra | The R100 weighs 2 pounds. but is a real laptop. | ||
ods15 | other than that i love it | ||
nothingmuch | ods15: ah, the opposite of what I was searching for =) | ||
i needed a desktop computer I could take to work | |||
ods15 | nothingmuch: btw, know the hebrew song 'kawaka'? | 17:33 | |
nothingmuch: ? | |||
desktop what huh | |||
nothingmuch | uh, haven't heard of it | ||
ods15 | hold on | ||
obra | nothingmuch: I travel too much ;) | ||
ods15 | www.supersite.co.il/manzur/kawakafliz.mp3 | ||
friggin hilarious song, dl it :) | |||
nothingmuch | ods15: i don't understand it | 17:34 | |
only a few words | 17:35 | ||
oh wait, the verse isn't as bad | |||
xinming | ?eval sub fun { ... }; fun(); | ||
evalbotzy | *** ... - not yet implemented at <eval> line 1, column 11-15 | ||
xinming | ?eval sub fun { ; }; fun(); | ||
evalbotzy | undef | ||
xinming | hmm, So what are the differences please? | ||
nothingmuch | xinming: ... is an error under 'use fatal' | 17:36 | |
and it also says "not yet implemented" | |||
xinming | nothingmuch: Ok, thanks, just for "visual" effect. :-) | ||
nothingmuch | xinming: not only that, it | ||
bah | |||
it really means 'undef but error "not yet implemented" | 17:37 | ||
so if it propagates upwards, i think it should be collected in the error stack for any errors happenning because of it | |||
ods15 | nothingmuch: listen to the words, the "punchlines" are always completely clear... :) | ||
nothingmuch | ods15: it was... OK, i guess | ||
xinming | :-) | ||
ods15 | nothingmuch: mp3music.gpg.nrg.co.il/lyrics/9881.html | ||
nothingmuch | not really hilarious | ||
ods15 | bleh :) | 17:38 | |
nothingmuch | oh wait, if I remove the 'default' sogudi thing then I can type spaces again... Woohoo! | 17:40 | |
ods15 | nothingmuch: so could you explain to me the tab thing? | 17:43 | |
nothingmuch | ods15: tab thing? | ||
ods15 | why on earth would you want such a thing | ||
nothingmuch | i use tabs | ||
ingy uses spaces | |||
ods15 | oh, i just remembered what else i syntax highlight, .patch :) and mail ofcourse (starts with '> ') | 17:44 | |
nothingmuch | if I edited code and forgot to :set expandtab | ||
then I pipe to 'expand -4' | |||
ods15 | :set expandtab does what | 17:45 | |
nothingmuch | it means that every time I type a tab, or it autoindents, it'll be with spaces | 17:46 | |
but other tabs in the file are not replace | |||
d | |||
ods15 | wait, if you forgot to set it, other tabs are replaced? | ||
nothingmuch | ods15: no, if I set it after a while, then other tabs are still tabs | 17:47 | |
and it's only new tabs | |||
also, another feature I bet nano doesn't have is hints to the editor placed in comments | |||
ods15 | explain? | 17:48 | |
nothingmuch | for haskell I do use spaces instead of tabs | ||
it just works out bettetr | |||
so I have {- vim:set expandtab: -} | |||
in the top of the file | |||
{- -} is haskell for "block comments" | 17:49 | ||
ods15 | i don't think i've really ever piped code through a program.. i have pipes data through scripts to make em generate code though, but rarely anything else | ||
ok | |||
ah, i got what you meant | |||
no, it doesn't have that | |||
there aren't that many options so you really don't need such a thing | 17:50 | ||
nothingmuch | ods15: also, sometimes when I'm editing xSV files I want to stay in my editor to see the tabulated data properly, but use "real men" commands to edit them, like awk or perl | ||
ods15 | nano's "auto-indent" is straightforward - whatever whitespace was in the begginning of the line, is repeated when you press enter... | ||
nothingmuch | anyway, I've got to get back to house work | 17:51 | |
ods15 | i've never really used awk :) | ||
ok bye | |||
nothingmuch | ciao! | ||
ods15 | heh | ||
geoffb | Limbic_Region, you tried to reach me a couple days ago, and I've been just missing you ever since (like sitting down at keyboard a minute after you quit, sheesh). What did you need me for? | 18:00 | |
xinming | ?eval sub foo is rw { state $var }; foo = 1; | 18:02 | |
evalbotzy | Error: Can't use readline() or getc() in safemode. | ||
xinming | ?eval sub foo is rw { state $var }; foo() = 1; | ||
evalbotzy | \1 | ||
xinming | ?eval sub foo is rw { state $var }; foo() = 1; foo.say; | ||
evalbotzy | \1 | ||
xinming | ?eval sub foo is rw { state $var }; foo() = 1; foo().say; | 18:05 | |
evalbotzy | 1 bool::true | ||
nothingmuch | heh, larry appearantly forgot that I'm "nothingmuch", and that I lobbied for lazy { } in the first place ;-) | 18:09 | |
geoffb | Hey iblech, how is the JS backend coming? | 18:10 | |
iblech | nothingmuch: Seems your lazy proposal is accepted :) | 18:11 | |
nothingmuch | yep =D | ||
hurrah, dancing, whatnot | |||
iblech | geoffb: Great, 65%, latest smoke is at m19s28.vlinux.de/iblech/stuff/not_p...smoke.html | ||
geoffb | iblech: do you have a blog I can just follow? | ||
iblech, schweet | |||
iblech | No, no blog | ||
geoffb | What's the best way to follow PIL2JS work, other than bugging you? Do diffs on the README? | 18:12 | |
iblech | Bugging me is fine :) | 18:13 | |
geoffb | OK then: how is MM integration coming? | 18:14 | |
iblech | And yes, I try to keep README in sync with the code | ||
geoffb | iblech++ # Keeping docs updated | ||
iblech | Everything I could integrate is integrated -- but that's only methods. | ||
geoffb | Why not other stuff? | ||
iblech | Waiting for -PIL2 so PIL2JS gets class declarations etc. | ||
geoffb | AH! | ||
OK, that answers the next question about the status of PIL2 -- I take it autrijus's $work has delayed that? | 18:15 | ||
iblech | (Currently, even small things like class Foo { has $.x } do not compile to PIL, so PIL2JS can't do anything.) | ||
Yep, he has deadlines etc. as far as I know | |||
geoffb | bleah, suckage | 18:16 | |
.oO( What that boy needs is a MacArthur (sp?) award) |
|||
xinming | iblech: could you please reveal some information about the deadline? | 18:18 | |
iblech | xinming: I dunno, all I know is from autrijus' journal (use.perl.org/~autrijus/journal): "It is tomorrow now and I'm still neck deep in this $work deadline thing" | 18:19 | |
geoffb | Who's working on the P5 backend these days? | 18:20 | |
nothingmuch | geoffb: fglock stevan and putter IIRC | 18:21 | |
i pretend to do it ;-) | |||
fglock | what kind of information 'want' returns - is it a type or class? | ||
geoffb | iblech, is the failing 35% mostly because of lack of PIL2 and therefore full P6 OO? | ||
nothingmuch | fglock: i think 'want' returns an object which yuou can ask questions | ||
and the object is a Context, i presume | |||
and maybe you can say Context::Scalar.new.enforce(&code); | 18:22 | ||
that could be fun | |||
ods15 | bleh | ||
nothingmuch | but either way, it stringifies | ||
and has the notation of arity | |||
ods15 | firefox is taking 200mb of ram :( | ||
nothingmuch | (how many items you want from a list) | ||
iblech | fglock: nothingmuch's correct, and there're test for it in t/builtins/want.t | ||
nothingmuch | and laziness, too, i think | ||
ods15 | total used free shared buffers cached | ||
Mem: 515500 511812 3688 0 5552 125320 | |||
-/+ buffers/cache: 380940 134560 | |||
Swap: 787148 393572 393576 | |||
i have a total of 750mb of "ram" used... | |||
heh more actually | 18:23 | ||
nothingmuch | ods15: want to do some porting? there was a patch to linux 2.2 that scanned processes after they forked | ||
it remerges identical but spoiled pages | |||
ods15 | scanned how | ||
nothingmuch | so that they are read only again | ||
geoffb | any(< nothingmuch fglock stevan putter ): what is the current status of the P5 backend? Pointer to appropriate place is OK, I'm updating STATUS right now. | ||
nothingmuch | and shared | ||
iblech | geoffb: The main missing parts are OO and packages, P5 and P6 regexes, temp/state/let vars, and some missing builtins | ||
nothingmuch | geoffb: I only pretend to know ;-) | ||
ods15 | what are you talking about | ||
and i know nothing of kernel programming | |||
nothingmuch | ods15: say you launched two firefox processes | 18:24 | |
it would scan them (eventually, i think it's an idle time loop) | |||
and compare identical memory pages | |||
ods15 | firefox is stupid and doesn't allow multiple instances, but ok, go on | ||
nothingmuch | when it finds pages that are the same, it will merge them | ||
so that they are read only, and shared | |||
ods15 | that's somewhat dangerous and mostly not worth it | ||
nothingmuch | dangerous? | ||
iblech | geoffb: OO and packages needs PIL2 support, P5 would be relatively simple (because JavaScript has a Regex class), ask putter for P6 regexes :), temp/state/let vars needs a little bit of work on -CPIL/-CPerl5 and then some work on the PIL2JS side | 18:25 | |
ods15 | unless it does it safely.. copy on write... | ||
it's not worth it though | |||
nothingmuch | ods15: ofcourse it does copy on write | ||
fglock | geoffb - stevan is working on the metamodel-2; putter is improving PIL-RUN; I'm working on the implementation of base classes | ||
nothingmuch | and it's very worth it if similar processes are starting up the same way | ||
geoffb | (nothingmuch: interestingly, at least one virtualization product (VMware ESX) does this across VMs, which I find quite cool. I wonder if the Xen guys do it) | ||
ods15 | brk hardly ever has common data, stack is tiny, and code is shared anyway by linux kernel | ||
nothingmuch | geoffb: i like virtualizations... they have many cool features | ||
like a cache of translated code pages, and whatnot | 18:26 | ||
geoffb | virtualization++ | ||
nothingmuch | ods15: if brk has common data due to malloccing of the same stuff | ||
like common initialization | |||
especially if these are aligned to arenas | |||
(a new window has a new javascript interpreter, for example) | 18:27 | ||
ods15 | firefox is mem leaking anyway, it should not be taking 200mb of ram | ||
(and 320mb of swap...) | |||
nothingmuch | ods15: another option is to poke in the "heavy" config params | ||
geoffb | fglock, happen to how is PIL-RUN coming, since putter appears offline? Passing any of test suite? | ||
nothingmuch | it might cache history pages in memory | ||
safari does that so that the back button is almost instantenous | |||
the prev page is completely parsed, all it has to do is draw | 18:28 | ||
ods15 | yes, i did find some option.. "browser.cache.memory.enable" | ||
nothingmuch | well, back to chores | ||
ods15 | but i disblaed it now.. only way to check if it helped it restart firefox and wait again.. | ||
iblech | geoffb: IIRC, 01-sanity.t passes | ||
ods15 | still, 200 mb is extreme for it | ||
iblech | geoffb: But there's no "make p5smoke" or so yet | 18:29 | |
geoffb | iblech, the whole dir? Cool. | ||
ods15 | heh, that's funny, X is using 400mb of virtual :P | ||
iblech | geoffb: No, only the first test. | ||
geoffb | oh, 01-sanity/01-tap.t | ||
iblech | geoffb: Right, meant that | 18:30 | |
geoffb: But let me look so we know for sure | |||
geoffb: oooh even 03-equal.t passes! :) | |||
ods15 | anyway, i can probably free quite a bit of ram by just closing kdevelop and qt designer, not using em right now anyway | 18:31 | |
putter | hey guys. hi geoffb. | ||
fglock | hi putter | ||
ods15 | but come to think of it, why should i :) the whole point of having a lot of ram and swap is to use it.. (althought not ABUSE it, like firefox is doing...) | ||
geoffb | iblech, heh: | 18:32 | |
er, heh. | |||
putter, hey there | |||
putter | hi fglock. putter was rather hoping fglock was working on PIL-Run, and putter was just dabbling. ;) | ||
ingy | BURN ALL TABS! | 18:33 | |
geoffb | iblech, when you say -CPIL/-CPerl5 are needed for temp/state/let -- are these PIL2 or PIL1? | ||
iblech | geoffb: PIL1 is sufficient | 18:34 | |
geoffb: (Currently, let $foo = 3 is emitted as my $foo = 3) | |||
geoffb: So that's a relatively simple change | |||
putter | as I consider creating pirsmoke and perl5test and perl5smoke and ... how about make test-pir test-js test-per5 smoke-pir smoke-js etc test-all smoke-all. thoughts? I expect we will have additional backends, and things are already getting crufty... no? | ||
xinming | Just read the comment of autrijus' Journal, I sometimes wonder why will people like wish perl to "become" php. :-) | ||
s/just/just now/ | 18:35 | ||
putter | pugs -BJS -e 'use php; ....php code...' | ||
iblech | putter: I like that :) (But I don't mind them staying jssmoke, pirsmoke, etc.) | 18:36 | |
putter | iblech: any thoughts on jssmoke and jstest becoming somewhat depreciated? | ||
ok. awsome. will do. | |||
iblech | putter++ | ||
putter wonders if there is a word for irc messages that cross in the writing... | |||
mjl69 | cross? | 18:38 | |
putter | two msgs written at the same, sent with seconds of each other. each of which obsoletes the other. if you could see the other person's keystrokes, it wouldnt happen... | 18:39 | |
or a weaker form, one of which obsoletes the other. | 18:40 | ||
mjl69 | I remember years ago, we used to chat online and you would see keystrokes in real time. backspacing was a talent. | 18:41 | |
geoffb | mmm, ytalk . . . . | ||
fglock | would it take much coding to replace pugs 'List' implementation with a perl6 version? | 18:43 | |
putter | pugs ability to use p6 code is currently a bit limited. Prelude.pm has issues, as does the type checker, and ... . rules development is currently stopped waiting for something to improve just enough for regexs (Prelude rx_common_) to return a Rul. | 18:47 | |
s/(currently stopped)/$1 (modulo pm's continuing work on pge etal)/ | 18:48 | ||
iblech: jssmoke uses PUGS_RUNTIME rather than -BJS, any particular reason, or just historical artifact? | 18:49 | ||
geoffb | putter, you were working on P6 rules implemented in P6, yes? | ||
iblech | putter: PUGS_RUNTIME is a hack, -BJS is the way to go | ||
putter | iblech: ok. thanks. | 18:50 | |
iblech | putter: PUGS_RUNTIME is only used to tell run-smoke to skip the ext/ tests and use a perl5/PIL2JS/pugs-smokejs.pl instead of ./pugs | ||
putter | geoffb: I was working on all sorts of rules stuff. on p5, on p6/pcre, on p6/native, etc. except with p5, spent most of the time dealing with pugsbugs. was too ambitious a project for the then/now state of pugs. finally, switched to frontend-backward development approach. get something in, improve it, allowing others to see and contribute. after a lot of trying, failed to get something in. well, have warnings about modifiers now. | 18:54 | |
but cant return a Rul, means everthing else is stuck. :( | |||
geoffb | putter, bleah | 18:56 | |
putter, do you mean Rule, or is Rul a magic type? | 18:58 | ||
putter | Rule is currently (against/un-spec) a role, with Rul intended to be the usual class doesing it. | 18:59 | |
geoffb | ah | 19:00 | |
OK, pugs' memory requirements to build have gotten completely insane | 19:01 | ||
putter | Rul is just a couple of lines. infix:<~~> calls a sub. oh, and will carry around a copy of the pattern and modifiers. | ||
optimized? | 19:02 | ||
putter still feels guilty about the rx rules hook in Prelude. its a non-trivial fraction of Prelude, and Prelude is a bit painful to compile, and the hook isnt buying much at the moment. I have a "rip out hook" patch just incase we need it for a release... | 19:03 | ||
Juerd | iblech: No, there was no discussion about *changing* map to repetition | 19:04 | |
iblech: Map on a range, and then using none of the numbers in the range, is misuse of a range and of map. | |||
iblech | Juerd: Right, I s// my wording (unless I forgot it) | 19:05 | |
putter | iblech: does PIL2JS/pugs-smokejs.pl suggest we need a pugs wrapper script, say p5, which deals with these kinds of things, to insulate pugs? or is that not worth it... | ||
iblech | Juerd: I agree with you completely | ||
Juerd | iblech: This also means that, contrary to what some people have been requesting with the XX, there should be no easily accessible standard counter variable | ||
For when you do need the number, you should use map. | 19:06 | ||
geoffb | putter: *un* optimized (sorry for delay, this box is thrashing its brains out) | ||
iblech | putter: Hm. runjs.pl (which is a thin wrapper around pugs -CPerl5 and pil2js.pl) is theoretically sufficient. The only problem is that runjs.pl doesn't stop pugs from compiling Test.pm. | ||
putter: Therefore pugs-smokejs.pl applies this evil hack (s/use Test//) | 19:07 | ||
putter: If we had a cleaner way to say pugs "trust me, I've precompiled that module to JS, don't load it", we wouldn't need pugs-smokejs.pl | |||
Juerd: Right. | |||
putter | -m (the case inverse of -M;)? | 19:08 | |
iblech | putter: I pondered a TrustMeTestPMIsAlreadyLoaded.pm, which'd only contain "%*INC<Test.pm>++", and then using pugs -MTrustMeTest... -CPerl5 ..., but unfortunately, pugs' option parser doesn't like that | 19:09 | |
geoffb | Why not just a flag that specifies which modules (generically) have been preloaded? | 19:10 | |
Given the thrashing on this system, I can't look for a free flag letter ATM :-) | 19:11 | ||
iblech | This would work too, and is cleaner, I think, so I like it :) | 19:12 | |
fglock | Juerd: isn't lazyness going to fix this? (sorry maybe I don't know what the problem is exactly) | ||
Juerd | fglock: Oh, Perl 6 will have this operator one way or another, I'm sure. | ||
If not in the standard language, then in the standard dialect. | |||
PerlJam | Juerd: and if not there, then in your own personal dialect :) | 19:13 | |
Juerd | PerlJam: That is the standard dialect. | ||
I plan perlego, that has stuff that didn't make it to the base language, but adds value without breaking existing code. | 19:14 | ||
This can be read as the esperanto word perlego (perl-eg-o, the noun meaning: a greater pearl), or as per-lego (adding building blocks) or as perl-ego (MINE!) | |||
geoffb | nice, Juerd | 19:15 | |
bah, have to boot yet more systems | 19:16 | ||
Juerd | So far, my perlego document that I have been maintaining has had all its original items removed because they got implemented somehow in the base design. | ||
This strengthens my belief that my ideas aren't that stupid :) | |||
geoffb feels the temperature in his office climb a couple more degrees (again) | |||
Juerd | If only I used a versioning system for it, then I'd know exactly which they are | ||
PerlJam | Juerd: Those weren't your ideas. You just imagine that you had some really great ideas that were then implemented only it's that they were implemented and then you thought of them. (hint: get a versioning system :) | 19:19 | |
Juerd | Oh, that's perfectly possible :) | 19:21 | |
PerlJam | I'm still quite ... shocked? surprised? in disbelief? over all the ./ hoopla | 19:22 | |
geoffb | sheesh, is that *still* going on? | 19:23 | |
svnbot6 | r6421 | iblech++ | * t/subroutines/slurpy_param.t: unSKIP as luqui confirmed my thoughts. | ||
r6421 | iblech++ | * t/unspecced/lazy.t: Added three more tests to it and added a pointer to | |||
r6421 | iblech++ | Larry's p6l post which implicitly accepted nothingmuch++'s lazy {...} | |||
r6421 | iblech++ | proposal. | |||
r6422 | iblech++ | Moved t/unspecced/lazy.t to t/var/lazy.t, as nothingmuch's proposal has been accepted. | |||
Juerd | I kind of stopped following all Perl 6 developments because of that. | ||
I usually abandon ships with drunken captains | |||
PerlJam | geoffb: no, no one has mentioned it on-list in a while, but I bet if you did, it would start all over again. | 19:24 | |
xinming | luqui: are you there please? | ||
Juerd | It'll get better | ||
xinming | oops, hmm, | ||
Juerd | But I think all Larry's done is disappoint people and make them less ethusiastic | ||
geoffb | oh holy crap, this newly-booted box hasn't been updated in a while -- 233 packages to update, according to apt | ||
putter notes Juerd is always gloomy about @Larry and p6 design decisions... | 19:25 | ||
Juerd | Oh, not always | ||
Let it be and stay clear that the majority of the design decisions together make a really great language that I'm looking forward to use | 19:26 | ||
putter | ah | 19:27 | |
is there a pattern to the kinds of things you disagree with? | 19:28 | ||
Juerd | Yes, they are all syntax. | ||
My primary concern is with syntax, in any case. | |||
Some very nice features can be implemented with operators that are new, but don't require any learning | 19:29 | ||
The best example I can give for that is <->. When used in the position where we now use ->, there can be no doubt in any intelligent lifeform's mind that it is closely related to -> itself. | 19:30 | ||
It doesn't live in one's brain as "another way to create a sub". -> and <-> are the same operator, except that <-> implies "is rw" for all parameters | |||
And there are really many occasions where "is rw" on multpile parameters is the best solution | 19:31 | ||
xinming | Juerd: I think <-> will confuse newbie with <=> ... | 19:32 | |
Juerd | It'd suck to ever have to write "for @foo -> $foo is rw, $bar is rw, $baz is rw, $quux is rw { ... }" if we could have "for @foo <-> $foo, $bar, $baz, $quux { ... }" at absolutely no cost. | ||
xinming | Juerd: They are too smimilar. | ||
Juerd | xinming: I think newbie should commit suicide if that's a problem. | ||
We already have -> and => which are radically different and in no way related. | |||
putter | (that was putter's first thought, what is <->? a variant on <=>?) | ||
(no doubt clearer in context) | 19:33 | ||
PerlJam | Juerd: for @foo -> ($foo,$bar,$baz,$quux) is rw { ... } # :-) | ||
Juerd | <-> by itself is unclear. But when used in context, I have yet to encounter one species that has no clue what it means while knowing Perl 6's -> operator. | ||
xinming | Juerd: well, In fact, => is looks like a key point the "value" | ||
Juerd: and -> should make people think for a little while, | |||
putter | what portion of the syntax concerns are foward compatible? (eg, define op foo) not, but parse? (eg, redefine ==) and require fiddling with the parser rules? (??) | 19:35 | |
xinming | Juerd: maybe suggest @Larry consider my ($a, $b, $c, $d) is rw... | ||
Juerd | xinming: I think you're missing the point | ||
PerlJam | xinming: I think he'd rather have $Larry consider <-> instead | ||
Juerd | xinming: The point is not that there should be a way to do it. The point is that there should be the *obvious* way to do it. | 19:36 | |
This particular example has an appendix | |||
xinming | for @foo -> ($foo, $bar, $baz, $quux) is rw { ... } | ||
Juerd: I don't, I think This might be clear to me... :-) | |||
Juerd | The default is now "-> $_ is rw", which is a pattern seen nowhere else: a trait added by default, but no longer when you specify a variable. | ||
PerlJam | Juerd: yeah, that is a bit odd. | 19:37 | |
Juerd | This asymmetry can easily be broken by simply saying that the default operator is <->, instead of ->. The effect and hopefully bytecode of which are equal, but this being a much easier way to live with the situation consistency wise. | ||
PerlJam | But I figure that Larry is trying to unhobble the hobgoblin of foolish consistency where ever he can. Sure he makes mistakes, but in the long run, he gets most things right. | 19:38 | |
Juerd | Most things, yes. | ||
wolverian | is there a unicode version of ->? | ||
Juerd | Foolish consistency would be adding <- as well. | ||
wolverian | (just curious...) | ||
PerlJam | Besides, I recall when perl5 was first released there were tons of things that got changed right away as Larry's intuition diverged from the perl populace | 19:39 | |
Juerd | Because write-only is hardly ever used, as opposed to read-write and read-only, and <- introduces a parsing nightmare (qw<-...) that -> and <-> do not. | ||
fglock | { say } <- for 1..10 | ||
Juerd | fglock: Have you any idea what the -> operator does? | 19:40 | |
fglock | something with binding a variable to the block scope, I think | ||
Juerd | fglock: That's only half, if not less, of what it does. | 19:41 | |
xinming | fglock: In my understanding, It stands for "sub" | ||
Juerd | fglock: "-> $foo { bar }" is a way of writing "sub ($foo) { bar }" (except the class of the block is different) | ||
$foo = -> { ... }; is valid syntax. | 19:42 | ||
<-, if it existed, would be in the same position: | |||
for @foo <- $elem { ... } | |||
xinming | Juerd: then, what does for @foo <- $elem { } mean? | ||
Juerd | xinming: @foo <- $elem { $elem = 5 } would assign 5 to each of @foo | 19:43 | |
s/: /: for/ | |||
While for @foo <- $elem { say $elem } would raise an exception because $elem is write-only. | |||
BUT AGAIN: "<-" would be incredibly silly | 19:44 | ||
svnbot6 | r6423 | putter++ | Makefile.PL: added targets {test,smoke}-{pir,js,perl5,all}. their old names still work. some of the targets, eg *-perl5, dont work yet. | ||
Juerd | The correct way to write this would be: @foo = { ... } XX +@foo | ||
For now assuming an XX op | |||
Otherwise: @foo = map { ... } 1..@foo | 19:45 | ||
Or any variant on that (consider pipes) | |||
1..@foo ==> map { ... } ==> @foo | |||
wolverian | @foo>>= 5 | 19:46 | |
Juerd | Well, yes, in the specific case of assigning a single value, that would be a better way to go. | ||
I don't think that'll ever happen in code written by any of us, though. | |||
putter realizes what has been bugging him about Juerd's descriptions - "_Larry_ this and that", personalities, rather than just discussing positions and their merits. feels un-academic. ;-) (err, at least in engineering! ;) some fields it seems like sop) | 19:47 | ||
PerlJam | putter: It's personal. Larry has the ultimate say for better or worse. Juerd just focuses on the "worse" aspects sometimes (for those issues where it's bothersome) | 19:48 | |
iblech | putter: Does it affect PIL-Run if PSub gets a boolean pSubLValue indicating "sub foo is rw {...}" vs. "sub foo {...}"? | 19:49 | |
putter: (I.e. just like pSubName) | 19:50 | ||
putter | iblech: dont let any aspect of PIL-Run slow you down. just go for it. PIL2JS is critical path on improving PIL. any PIL-Run fallout can be cleaned up in its wake. that said, no affect, no problem. ;) | 19:53 | |
iblech | putter: ok then :) | ||
putter | :) | ||
Juerd | PerlJam: I hope the reason for the focus is obvious, though | 19:57 | |
PerlJam | Juerd: it is to me. | ||
Juerd | putter: I've referred to Larry once only. Did this really bother you, or did you mistake the many references by others for mine? | 19:58 | |
Oh, and please do note that the things I mention were (and some still are) widely supported ideas that didn't make it for one man's veto. | 20:00 | ||
There may be more opposers, but they are silent and thus ignored. | 20:01 | ||
xinming | Juerd: well, In fact, @Larry design Perl 6, with mutable features, You can write rule your own. ;-) | 20:02 | |
Juerd | xinming: I know that | ||
But I'm a very strong believer in sane defaults. | |||
putter | Juerd: no bother. perhaps my mistake. | ||
xinming | Juerd: well, So am I, I use Emacs, And I never erased any default key-bindings. | 20:03 | |
Juerd | putter: I found your remark surprising, as I constantly try to keep it technical. | ||
xinming | Juerd: But the problem is, Perl 6 now is "a bit" like Emacs, Some one would use Gnus to read email, some may not, And some others like w3m better than w3, | 20:05 | |
s/better/more/ | |||
Juerd | I don't see how that relates to recent discussion, xinming | ||
xinming | Juerd: So, default might not be the best, But might be most suitable to many people to others. | 20:06 | |
putter | re "constantly try to keep it technical", err, "I usually abandon ships with drunken captains" and "I think all Larry's done is disappoint people and make them less ethusiastic"... | ||
;) | 20:07 | ||
Juerd | We were discussing default existing of syntax | ||
xinming | Juerd: hmm, In my opinion, You can define any "op" right? But Your perfect might not be perfect to other. | ||
Juerd | Not a default of options. | ||
xinming: I'm not even referring to perfection | |||
It's leaving things out of the language that fit in so well that bothers me most. | |||
xinming | Juerd: hmm, Well, the "perfect" there mean "suitable", sorry for the confusion, | ||
putter | bbiab | 20:08 | |
xinming | what does bbiab mean? T_T | ||
Juerd | putter: I can't help but be sad about some recent decisions. This is, by the way, about the ./ decision, which upset almost everyone. | ||
putter: And thus goes much further than syntax. | 20:09 | ||
xinming | It's a pain to chat with "hacker". Too many Jargon... | ||
PerlJam | putter: When Larry makes a poor choice, I expect to see "Larry screwed up" | ||
anything else is just putting "political correctness" before truth | 20:10 | ||
xerox | xinming: Be Back In A Bit | ||
iblech | Hm, does t/01-sanity/06-use.t fails for others, too? (Working with Pugs.Parser...) | ||
xinming | xerox: Thanks. | 20:11 | |
xerox | xinming: yw. | ||
fglock | xinming: see www.computerhope.com/jargon.htm | 20:13 | |
putter | xinming: google bbiab. you can even just use the first hit;) | 20:14 | |
xinming | fglock: bookmarked. | ||
putter: hmm, Sometimes, I am lazy to open the google to search.. :-) | 20:15 | ||
xerox | Yeah, that's why you have `wtf` :-) | ||
xinming | The three virtues of a perl programmer: laziness, impatience, hubris | 20:16 | |
I wish to be a programmer, So I have to learn how to become "Lazy". :-P | |||
and you seee, "Laziness" comes to the first... | 20:17 | ||
putter | "open" google? putter looks buffudled. ooohhh, you dont roll out of bed in the morning thinking, "hmm, lets google what to have for breakfast"! ;-) | ||
svnbot6 | r6424 | iblech++ | * Pugs.PIL1: Added pSubLValue/pLValue to PSub and PCode, indicating the | 20:18 | |
r6424 | iblech++ | difference between "sub foo {...}" and "sub foo is rw {...}". | |||
r6424 | iblech++ | * Pugs.Compile: Extract the (subLValue vcode) and put in in the appropriate | |||
r6424 | iblech++ | field of PSub/PCode. | |||
r6424 | iblech++ | * Pugs.CodeGen.PIR: Accomodate for the above changes. | |||
r6424 | iblech++ | * Pugs.Parser: Parse traits for anonymous subs, too (i.e. "sub () is rw | |||
r6424 | iblech++ | {...}" parses and works now). | |||
putter | I've been a great believer in the "laziness" standard. autrijus has forced me to... reconsider how broadly to apply it. | 20:20 | |
xinming | m:w/ \( <expr> [ , <expr> ]* : \) / | 20:22 | |
is this the same as `m:w/ \( <expr> \)+ /` ? | |||
svnbot6 | r6425 | iblech++ | PIL2JS: | 20:23 | |
r6425 | iblech++ | * PIL, PIL::Subs: Previously, all subs were implicitly "is rw", because | |||
r6425 | iblech++ | Pugs.Compile didn't include pSubLValue. As this is fixed now, PIL2JS | |||
r6425 | iblech++ | distinguishes "sub foo is rw {...}" from "sub foo {...}" now. | |||
r6425 | iblech++ | * PIL2JS.js: Minor cosmetic fix regarding the error message you get if you try | |||
r6425 | iblech++ | to assign to a readonly box. | |||
xinming | I can't understand what the : mean here really, | ||
anyone would tell me? | 20:27 | ||
fglock | they mean different things - (a,b,c:) and (a)(b)(c) | 20:30 | |
putter | Juerd/PerlJam: Despite solutions always being social+technical, its of course best to separate policy from mechanism in design. and to, at least initially, to discuss issues independently of the people involved. so when I see "my-position-technical-argument vs another-position-people-argument", my alarm bells go off. but no doubt there has been more strictly technical arguments elsewhere. and, err, I vaguely recally someone named pu | 20:31 | |
tter flaming at length a day or two ago about the repeated decision not to allow p5 ->methodcalls on unblessed- and non- reference values. ;) anyway, back to hacking. | |||
fglock | putter: may I help you? (maybe I need a break with my modules) | 20:32 | |
Juerd | xinming: read S5 | 20:34 | |
putter | oh, with PIL-Run? have at it. or with integrating js and p5 backends with pugs? or... ;) | ||
PerlJam | xinming: colon is the "cut" operator inside of a p6 rule. | ||
xinming: :, ::, :::, <cut> and <commit> are the various flavors of cut operators. | |||
xinming | PerlJam: Yes, I know, But What is it does for one : | 20:35 | |
PerlJam | a single : means don't backtrack into the previous atom | ||
xinming | PerlJam: I can feel that :: and ::: and even <commit> ( maybe like :::: ) will do a break( return ) in a level | ||
putter | re PIL-Run, one next step might be to get the next sanity test working. needs if(). which means if() bodies, Thunks and their Code Applications, need to be handled better by EvalX (which currently ignores both Thunks and Code). | 20:36 | |
PerlJam | xinming: for the rule you posted, once we've matched to the :, if the RE doesn't match a ) then the whole rule will fail (because it can't backtrack) | 20:37 | |
iblech | putter, fglock: FYI, implementing thunks were easy in PIL2JS -- they're simply subs which never take params and which only have a single expression as their body | 20:38 | |
xinming | PerlJam: Thanks, Might catch the main idea... | 20:39 | |
svnbot6 | r6426 | fglock++ | * perl5/ List - fixed "ambiguous call to int" | ||
putter | statement_control:<if> is in PrimX. takes three p5 strings, and returns a combined string of code. perhaps "if (p6_to_b($xx1)) { $xx2 } else { $xx3 }". or without the {}, depending on what thunks get converted to. | 20:40 | |
iblech: thanks! :) | |||
fglock | putter: crude_repl.pl is refusing to run, with errors in PrimP5.pm | ||
putter | bleep! checking... | 20:41 | |
iblech | putter: Oooh, so PIL-Run inlines &statement_control:<if>? | ||
putter: (Instead of really calling &statement_control:<if>) | |||
fglock | iblech: the P5 runtime is actually a mix of P6/P5 structures | 20:42 | |
putter | fribble. there is no such thing as an ok hand-written change after a pre-commit test. missing semicolon on the end of the <if> line. | 20:43 | |
fixed. r6427 | 20:44 | ||
svnbot6 | r6427 | putter++ | PrimP5.pm: typo fix. fglock++ | ||
putter | iblech: yes. so far at least, things are being agressively converted to p5 code. but no interesting control flow is done yet, so we'll see if that lasts. macros got put in to do && . | 20:46 | |
iblech | putter: Ah! This is probably a very good optimization | ||
iblech ponders this for PIL2JS... | 20:47 | ||
fglock | putter: are you using Value::List? I'd like to test lazy lists | ||
putter | could be. I'm not sure how it will interact with (potential?) cps... | ||
fglock | and implement functions in Prelude | ||
cps? | |||
putter | fglock: I dont think lists are in yet. "say 3" "say 'hi'" and I havent checked "say 3 + 4" in a while...;) | 20:48 | |
iblech | Could somebody check with latest Pugs whether our still works? I might have broken it... | ||
fglock: Continuation Passing Style | 20:49 | ||
fglock: Instead of foo(); bar(), you compile foo({ bar() }, basically | |||
putter | fglock, what was the question again? (sorry, I've become confused:/) | 20:50 | |
fglock | putter: can I use lazy lists? | ||
putter | iblech: I was thinking one might pass the continuation using local(), to permit calls from plain p5 code. | 20:51 | |
fglock: in PIL-Run? | |||
or in pugs and Prelude.pm? | |||
iblech | putter: Ah! That should work, too | ||
fglock | yes - the object is implemented in Value::List, and the functions would be in Prelude | 20:52 | |
it needs callbacks - but it can use P5 callbacks | |||
putter | call, bbiab | ||
back | 20:53 | ||
fglock | p5ugs> (1,2,3) -- Method not found: .do in Scalar.pm 224 | 20:54 | |
this actually means that the scalar is undef | 20:55 | ||
xinming | hmm, where to find the `built-in` method for default Class? | 20:57 | |
putter | fglock: assuming we are talking PIL-Run, Value::List can be required in MainX.pm. There is a lib6/P5Runtime/PrimP6.pm for extra stuff, but I dont think the file is used at all yet. (thats probably a matter of changing the pugs line (-I etc) in EvalX - I could do that). EvalX would need a PIL entry for however PIL represents the lists. which uses either a new p6_{to,from}_list in ApiX, or uses Value::List directly and we'll worry abo | ||
ut ApiX later. I think that's it... | |||
:v will show the PIL and generated p5 code. | 20:58 | ||
p5ugs> :v | |||
xinming | Just like, Array will get a sum method by default, I still didn't know there is a built-in sum method until iblech told me. | ||
putter | p5ugs> ...whatever... | 20:59 | |
iblech | xinming: Look at src/Pugs/Prim.hs, there's a table at the end of the file | ||
xinming | thanks.. | 21:00 | |
svnbot6 | r6428 | putter++ | PrimP5.pm: remove debugging output from previous too-rapidly-applied patch. | 21:02 | |
r6429 | fglock++ | * perl5/ Container - more descriptive error message in Scalar | |||
putter | fglock: ok, it looks like that error message is the current way of saying "the function you tried to apply isnt defined". | 21:03 | |
there is a prefix:<,>, but no infix:<,> | |||
is infix:<,> what defines Lists? | |||
fglock | don't know - but it looks like it is | 21:05 | |
iblech | putter: Right, &infix:<,>(1,2,3) is (1,2,3) | ||
putter | (With :v , I evaluated (3,4), which gave the p5 code p6_apply(p6_var('&infix:,'),p6_new('Int','3'),p6_new('Int','4')); but checking Prim, infix:<,> didnt exist...) | ||
fglock | and infix:<..> implements ranges | 21:06 | |
iblech | &infix:<,> can be implemented extremely easy: sub infix:<,> (*@elems) { @elems } | ||
(Presuming, * works, of course) | |||
putter | ok, so MULTI SUB infix:<,> (*@a) { p6_to_list(@a) } and ApiX defines p6_to_list using Value::List... | ||
fglock | so I can hack ApiX p6_to_list? | 21:07 | |
putter | err, thats p6_from_list | ||
err, ok, that naming scheme is fraying around the edges. | |||
yes, ApiX, whateveryouwanttocallit(@a) { Value::List->new(@a) } | 21:08 | ||
in ApiX | |||
fglock | I think the function is not there | 21:09 | |
putter | and the reverse too, getting an array from a List, for the primitives which need to deal with it... | ||
(I assume some primitives need to deal with it...) | |||
fglock | putter: you can't always map lazy lists to P5 array | 21:10 | |
putter | p6_from_list? no, not there yet. no lists yet at all. | ||
fglock | but lazy list to P6 Array is fine | ||
putter | ah well, do p5 array -> List now, worry about using List later, as the need arises. | 21:11 | |
iblech notes that PIL2JS doesn't differentiate between Array and List, without causing any (apparent) problems | 21:12 | ||
fglock | so it would be p6_to_l / p6_from_l ? | ||
iblech: I'm not sure what the difference is, actually - maybe just because Array are containers (mutable) | |||
the p5 implementation of Array is much more complex than List | 21:13 | ||
putter | p6_from_l for now. we can revisit how they are named at some point. | ||
iblech | fglock: I don't know either. Probably something along that line | ||
putter | or p6_list() | 21:14 | |
whatever. there are only three files. change is easy. | |||
iblech: prefix:<,> is just (*@a){@a} as you describe. say() should take a List rather than a p5 list, that might need to change. | 21:16 | ||
s/say/but if say/ | |||
iblech | Hm, does a plain @a evaluate to a P5 list, instead of a P6 List/Array? | 21:17 | |
(If not, I don't understand your sentence.) | 21:18 | ||
putter | fglock: bottom line - there are only three smallish files of code (well, Prim is big, but only the first few lines are hand-written). so follow your wimsy. do anything. its easy to frob it back and forth. And I kind of suspect noone be me has ever run it. And I sure dont mind it breaking. ;) | 21:19 | |
xerox | Hey. | 21:20 | |
Why do I have a pypy supporter saying "perl6 people copied the object spaces idea" ? | |||
I mean, is it like this or the other way around? | |||
wolverian | object spaces idea? | ||
xerox | So he says O_o | 21:21 | |
wolverian | what does he mean with it? | ||
putter | yes, right now, say(3,4) compiles as p6_apply(p6_var('&say'),p6_new('Int','3'),p6_new('Int','4')); and... (hmm... the 4 doesnt get printed at all!?!?) ... anyway, so a regular p5 list of arguments is being used. once we have List, perhaps something needs to change there. | ||
iblech | putter: Ah, ok. | ||
xerox | wolverian: I'm asking... | 21:22 | |
wolverian | xerox, in any case, it doesn't much matter. everything was done with lisp in the 60s or 70s, anyway. we're just reinventing the wheel - with nicer syntax. :) | ||
putter | xerox: perhaps the same reason some people think "you used my software patent!"? ;) | 21:23 | |
integral | I got the impression that "object spaces" was just that you have objects which have an interface to the code, but they're implemented by something in your runtime engine, but you can implement them in different ways :-/ | ||
xerox | wolverian: indeed. | ||
putter: haha, good point. | |||
iblech | geoffb: I just implemented temp in PIL2JS :) | ||
geoffb: (As you were asking earlier today) | 21:24 | ||
xerox | k thanks :) | ||
putter | pugs is a bit unusual, in that autrijus is a paper monster. a lot of projects putter along with only a fuzzy feel for the state of the art, and consider the solutions the work out to be novel. | ||
s/the/they/ | |||
wolverian | xerox, so, did he mean what integral said? | 21:25 | |
putter | oooo, temp! putter considers doing rules development on PIL2JS... | ||
xerox | wolverian: he meant nothing, he seem to do not know what he was talking about - it should be something like "having different backends for code generation" | ||
wolverian | xerox, right. | ||
xerox | Sorry for bugging you on this. | 21:26 | |
iblech | putter: let will follow in a minute :) | ||
fglock | putter: done ApiX | ||
putter: List contains a Perl6::Value::List object, so that there is no problem if you 'unbox' it | 21:28 | ||
svnbot6 | r6430 | fglock++ | * implemented to/from p6 List functions in ApiX.pm | ||
putter | iblech: :) | 21:30 | |
fglock: neat! so... should say(3) be, instead of p6_apply(p6_var('&say'),p6_new('Int','3')), something like p6_apply(p6_var('&say'),p6_from_l(p6_new('Int','3'))) ? | 21:31 | ||
fglock | I think so | ||
did you find what is the node type for List? | 21:32 | ||
putter | sorry, I havent looked... | ||
fglock | I'm trying to find out | ||
putter | if you do :v and then (3,4) you get a nice yaml dump of the pil tree. | 21:33 | |
fglock | yep. I'm trying to understand it | ||
putter | looks like nothing more than a call to infix:<,> | ||
svnbot6 | r6431 | putter++ | PrimP5.pm: say() now prints all its arguments, not just the first one. | ||
iblech | nothingmuch: As I'm going to commit a change to Pugs.AST.Scope (which could possibly break everything), I'd appreciate if you restart your smoke script, thanks very much :) | ||
fglock | I tried (1,2).shift | 21:34 | |
putter | which compiles to an excessively brief p6_apply(p6_var('&shift')); , because infix:<,> doesnt exist yet... | 21:35 | |
the key things to look for in the pil dump is the PApp's, pVarName's, and simple literals. | 21:36 | ||
fglock: did you define an infix:<,> in Prim? | 21:38 | ||
fglock | no - I'll open it | ||
putter | something like MULTI SUB infix:<,> (*@a) { p6_from_l(@a) }; should do it. | 21:40 | |
fglock | there is one already - I'll try to modify it | ||
what is prefix:<,> used for? | 21:42 | ||
iblech | fglock: To construct a list/array | 21:43 | |
putter | I was wondering that a moment ago. must be something, or I wouldnt have defined it. maybe leave it, write the infix:<,> we need now, and worry later. | ||
svnbot6 | r6432 | iblech++ | * Pugs.AST.Scope: Reorder the declarations of the various scope types -- SLet | ||
r6432 | iblech++ | and STemp do something to *existing* variables. Accidentally, this causes | |||
r6432 | iblech++ | temp.t to pass on normal Pugs! | |||
r6432 | iblech++ | * Pugs.Lexer, Pugs.Compile: Acommodate for that change. | |||
r6432 | iblech++ | * PIL2JS: temp! let! | |||
r6432 | iblech++ | * PIL: All JS functions have a block_leave_hooks array now, containing native | |||
r6432 | iblech++ | JS functions to be called at block exit. | |||
r6432 | iblech++ | * PIL::PPad uses this variable to implement the (possible) variable | |||
r6432 | iblech++ | restoration needed for temp and let. | |||
r6432 | iblech++ | * t/var/let.t, t/var/temp.t: Should "temp @array[$index]" work? I think so, but | |||
r6432 | iblech++ | Pugs doesn't even parse that. Added appropriate tests in a =pod block. | |||
putter | iblech: so when infix:<,> and when prefix:<,>? | ||
svnbot6 | r6432 | iblech++ | BTW, let.t passes 7/7, temp.t passes 22/22 (with TODO tests). | ||
iblech | putter: Never prefix:<,> | 21:44 | |
putter | hmm.... | 21:45 | |
iblech | (At least, I've never seen that one.) | ||
svnbot6 | r6433 | putter++ | ApiX.pm: moved Value::List->from_single() call to p6_new | 21:46 | |
r6434 | putter++ | ApiX.pm: oops, added missing return. | |||
putter | guess I imagined it... | 21:47 | |
iblech, does temp() unwind when exceptions are thrown? | 21:51 | ||
and does temp.t passing on pugs mean it really works (!?!), or that temp.t needs more tests...? | 21:52 | ||
svnbot6 | r6435 | putter++ | PrimP5.pm: deleted mythical prefix:<,> primitive. | ||
iblech | putter: Oh, no, haven't thought of that. Writing test and thinking about implementation | ||
putter | ok | ||
iblech | ?eval $?PUGS_VERSION | ||
evalbotzy | \'Perl6 User\'s Golfing System, version 6.2.9, August 3, 2005 (r6378)' | ||
putter | my fuzzy recollection is doing unwind-protect (aka temp) in the face of full continuations is a "long studied but regretably inherently hard problem". | 21:53 | |
fglock | I'll commit what I have so far and go after a problem with 'List' | 21:54 | |
iblech | putter: oh. hm. | 21:56 | |
putter | k | ||
hmm... temp $obj.attribute = 5; ;) | 21:57 | ||
svnbot6 | r6436 | fglock++ | * small fix in ApiX | ||
iblech | That's actually extremely easy to implement in PIL2JS, presuming that this parses :) | ||
putter | !:) | 21:58 | |
nothingmuch | parrot is headed in the right direction... ;-) | 21:59 | |
www.sidhe.org/~dan/blog/archives/000425.html | |||
dan's parrot, at least | |||
putter | iblech: oops. I'm wrong (vis continuations vs unwind-protect) bc.tech.coop/blog/050731.html (bottom) and perhaps www.nhplace.com/kent/PFAQ/unwind-pr...tions.html | 22:02 | |
dan's parrot would have been an interesting thing to play with... | 22:03 | ||
fglock | putter: p6_from_l works, but there seems to be a problem with the object somewhere else | 22:04 | |
putter | hmm... just in case it was too hidden, note that in crude you can :5 <perl5 expression>, which helps with debugging... | 22:05 | |
fglock | It might be a problem with the object - I'll check this first | ||
putter | k | ||
nothingmuch: one thing I take away from having seen both parrot and pugs, is that if the domain is amenable to prototyping (it was in both cases), at least in an open source setting, it really helps if your system architect can spew code, instead of just spec. | 22:09 | ||
svnbot6 | r6437 | fglock++ | * updated ApiX.pm | ||
nothingmuch | putter: fairy nuff, but MMD as an implementation detail (even when it's exposed to the high level language) is a smart move, since it vastly simplifies optimization when static analysis and type inferrence becomes involved | 22:10 | |
and optimization is incremental, and modular | |||
for example the assignment operation on integers as given in dan's blog post makes a lot of sense | 22:11 | ||
especially when static analysis lets you just emit machine code that has absolutely no respect to an encapsulated object's guts, since the data type is shared | 22:12 | ||
putter goes back to read article more closely... | |||
nothingmuch | this can be bolted on later, after you've got "safe" assignment implemented | ||
which is very good, because it can be profile driven | |||
if your integer operations are too slow, you meter them, and figure out that assignment is taking too long, so you special case assignment on integers, and you save a little here | 22:13 | ||
then you find that too much time is wasted on MMD dispatch, so you improve static assignment, and inline the MMD candidates as machine code where they can be known in advance | |||
this approach to making things fast is known to work, and is easy to design well, and is good for many-hacker few full timer projects | 22:14 | ||
where someone who cares can whip up a specialization of the system for the small part they cares about | |||
s/cares/care/; | 22:15 | ||
uh, damnit | |||
the second cares | |||
fglock | weid error - calling a closure as a method doesn't pass $_[0] (in Perl5) | 22:16 | |
/weid/weird/ | |||
nothingmuch | fglock: really? i've relied on it a million times | ||
if (my $sub = $obj->can("method")){ $obj->$sub(@args) }; | 22:17 | ||
for example | |||
iblech | putter: Thanks much for the links :) I'll (have to) read them carefully, tomorrow | ||
svnbot6 | r6438 | iblech++ | t/var/: let.t, temp.t: Test that let and temp restore variables even when the | ||
r6438 | iblech++ | block they're in has been left via an exception (and not via an (possibly | |||
r6438 | iblech++ | implicit) call to &return). | |||
fglock | I just had to fix this in List.pm | ||
putter | np :) | ||
they were just a quick google, so there may well be better stuff out there. | |||
iblech | Maybe I dream of the solution, similar to autrijus :) | ||
fglock | sub str { $_[0]->{cstringify}( $_[0] ) } -- doesn't work without ($_[0]) | 22:18 | |
iblech | Which reminds me, I should sleep now. Night all! :) | ||
putter | Good night iblech! :) | ||
wolverian | fglock, {cstringify} is not a method | 22:20 | |
putter | fglock: but the () is sub-call (not method call) to the sub ref in the hash (index cstringify) pointed to by $_[0]. | ||
nothingmuch | wtf is this hoodwink.d thing? | ||
putter | ? | ||
fglock | mm right - I thought it was a method | ||
putter: it works now - the list prints weird, but that's because stringification is very simple | 22:21 | ||
putter | neat! | ||
fglock | 1,2 prints Int=HASH(0x88f6894)....Int=HASH(0x88f6270) | ||
putter | and actually, the answer to the earler "does say get called with a list" is.... only if PIL says so! ;) which it doesnt at the moment. | 22:22 | |
putter svn up's to look... | |||
svnbot6 | r6439 | fglock++ | * perl5/ List - fixed stringification | ||
fglock | now trying to find out how to do 1..2 | 22:23 | |
actually 'shift' is easier | 22:24 | ||
putter | err, did you define infix:<,>...? I'm getting an error on (3,4) | 22:25 | |
fglock | ah ok, I didn't commit PrimP5 | ||
putter | k | ||
fglock | done | 22:26 | |
putter | iblech: prefix:<,> is in Pugs/Prim.hs (after DESTROYALL) | 22:27 | |
wolverian | prefix ,? that's weird | ||
putter | fglock: I'm still seeing 6439 | 22:28 | |
fglock | I'm getting a svn conflict - resolving... | 22:29 | |
putter takes a moment to marvel at working with someone in another part of the planet, and thinking a 3minute latency in tossing a file back and forth, via taiwan, is like *taking forever*. ;) | 22:30 | ||
fglock: oops, sorry. probably my dropping prefix:<,>. | |||
fglock | done - 6440 | 22:31 | |
(1,2) works, but (1,2).shift doesn't | 22:32 | ||
putter | prefix:<,> came back, and that's fine. I'll add a note to it saying we're puzzled. | ||
wolverian | (1,2).shift is invalid perl6, if that's the problem :) | ||
(I don't know what you're doing, so just ignore me if you know that.) | |||
svnbot6 | r6440 | fglock++ | * defined (1,2).shift | ||
wolverian | well, I thought it would be. oh well. (lists are mutable now?) | 22:33 | |
fglock | strange - how do you take a value from a list? | ||
putter | hmm, (3,4) gives me Can't use string ("") as a subroutine ref while "strict refs" in use at /home/net1/perl6/pugsxpl2/perl5/PIL-Run/../Perl6-Value/lib/Perl6/Value/List.pm | ||
wolverian | my question exactly, fglock. :) | ||
fglock | putter - you have to update Value::List | ||
putter hits his head, "doh!". svn up in wrong (two low) dir. | 22:34 | ||
too low, even | |||
fglock | lists aren't exactly mutable, but you have to traverse them (?) | ||
wolverian | [] traverses, doesn't it? I don't understand what (1,2).shift would do. | ||
fglock | it returns 1, and keeps a list (1). the original list doesn't exist anymore | 22:35 | |
oops, returns 1 and keeps 2 | |||
wolverian | but the list isn't "kept". that's the definition of a list. only arrays are kept. | 22:36 | |
putter leaves fglock to do interesting things with List's and goes to get a snack... | |||
wolverian | (well, the definition of a list is that it's immutable, I guess. :) | ||
fglock | anyway, shift it is not an error at this level of implementation - I'm getting a message saying that I'm trying to shift from an 'undef' | 22:38 | |
wolverian | right. (the error should be that you're trying to shift from a List) | 22:40 | |
putter | feeping creatures, snack -> dinner. later & | 22:42 | |
fglock | bye - I'm getting home too | ||
putter | err, fglock, hmm... if you do :v, (3,4).shift for me is compiling as p6_apply(p6_var('&shift')); so somethings not quite right... | 22:43 | |
fglock | I'll try again later - maybe storing the list in a Scalar first | 22:44 | |
putter | say(say 3) works... | ||
ok, later! :) & | |||
fglock | my $a=(1,2); $a.shift doesn't compile too | ||
putter | $a = (3,4) | 22:46 | |
:5 p6_var('$a') | |||
Scalar=HASH(0x1164710) | |||
which perhaps isnt what you intended? | |||
oh, duh. yes, that's right. | 22:47 | ||
5 p6_var('$a')->fetch | |||
List=HASH(0x116c0c0) | |||
i'm late. this was fun, thanks! :) & | 22:48 | ||
luqui | ?eval 42 | 22:53 | |
evalbotzy | 42 | ||
luqui | good | ||
coral | ?eval 42.pick | ||
evalbotzy | Error: pick not defined: VInt 42 | ||
luqui | ?eval (42|5).pick | ||
evalbotzy | 42 | ||
luqui | ?eval (42|5).pick | ||
evalbotzy | 5 | ||
coral | whoah! neat! | ||
someone++ | |||
luqui | I think that's been there awhile | 22:54 | |
buu | Holy wtf. | ||
?eval (42|5) | |||
evalbotzy | 5 | ||
buu | ?eval (42|5) | ||
evalbotzy | 5 | ||
luqui | I think that's a parsing error | ||
buu | Really? | ||
luqui | there is no automatic collapse of junction | ||
wolverian | I think evalbot doesn't output junctions right | ||
buu | shux. | ||
wolverian | ?eval 1 & 2 | ||
evalbotzy | 1 | 22:55 | |
wolverian | ?eval "a" | 42 | "c" | ||
luqui | ?eval (42|5).states | ||
evalbotzy | 42 | ||
Error: No compatible subroutine found: "&states" | |||
luqui | ?eval (42|5).values | ||
evalbotzy | (5, 42) | ||
luqui | there we go | ||
wolverian | ?eval "a" | 42 | "c" | "d" | ||
evalbotzy | 42 | ||
wolverian | that's still not right. :) | ||
luqui | it seems to give you the first one when sorted | ||
wolverian | right. | ||
or it's trying to tell us something important.. | |||
?eval "a".."b".pick | 22:57 | ||
evalbotzy | Error: pick not defined: VStr "b" | ||
wolverian | ?eval ("a".."z").pick | 22:58 | |
evalbotzy | 'x' | ||
wolverian | just curious about precedence. now, good night. :) | ||
nothingmuch | *yawn*... time for shower & bed | ||
so much dust.. yuck! | |||
luqui | eew dust | ||
nothingmuch | the worst kind too - cement dust | 22:59 | |
luqui | sticky | ||
nothingmuch | it's corrosive, and it dries up the skin | ||
luqui | hmmm.. that's worse than sticky | 23:00 | |
I've never been around it too long | |||
nothingmuch | we're rennovating, so there's lots of it |