Upgrade to YAML::Syck 0.85 before smoking | pugscode.org | sial.org/pbot/perl6 | ?eval [~] <m oo se> | We do Haskell, too | > reverse (show (scanl (*) 1 [1..] !! 4)) Set by agentzh on 22 April 2007. |
|||
nothingmuch | veritos: i speak hebrew too | 00:00 | |
as does gaal | |||
roiem | |||
lightstep | |||
a few others, too | |||
TimToady | still, there are probably a few more speakers of Chinese of one sort or another... | 00:01 | |
veritos | fine, hebrew (4+) beats hanyu (2 known) | ||
TimToady | though maybe not here | ||
nothingmuch | prolly true | ||
oh, globally def. true =) | |||
TimToady | let's see, there's audreyt and clkao and xinming and... | 00:02 | |
nothingmuch | but us jews with our jew gold and our, uh... yamacas run the world, donchaknow ;-) | ||
*yawn* | 00:03 | ||
sleepy time | |||
TimToady | but in AUTHORS there are an amazing number asian names from both ends of asia... | 00:06 | |
veritos | can miniperl6 be lexed by straight yacc? | 00:09 | |
TimToady | you mean parsed? yacc generally needs an external lexer. but I think miniperl6 is sufficiently regular to allow it. | 00:11 | |
veritos | sorry, what was that? i hit /clear too soon | ||
TimToady | you mean parsed? yacc generally needs an external lexer. but I think miniperl6 is sufficiently regular to allow it. | 00:12 | |
veritos | i meant lex, sorry | ||
i'm trying to write in straight regexes | |||
TimToady | I'm not actually a lex expert--always rolled my own lexers. but I suspect lex can do it | ||
veritos | hmm. | ||
TimToady | especially given that lex has the ability to have multiple modes. | 00:13 | |
veritos | go, little lexer. go! | ||
TimToady | you might need to distinguish terms from operators though. | ||
you could just bypass all this, translate src/perl6/Perl-6.0.0-STD.pm to Python, and you'd be done. :) | 00:14 | ||
veritos | i go lower level, shouldn't be a problem. i'm even lexing $foo as [T_DOLLAR_SIGN, T_WORD_STUFF] | ||
urgh, python is evil sometimes. | 00:15 | ||
TimToady | well, sure, that's why you want to write Python in Perl 6, right? :) | ||
veritos | other way around | ||
i don't go for that whole laziness thing ;) | 00:16 | ||
geoffb | veritos: that may have been a hint. ;-) | ||
veritos | fglock asked me to do MiniPerl6 first anyway, so that's what i'm doing now | ||
00:16
BooK joined
|
|||
TimToady | don't have any problem with that, which is why my "hint" has a smiley on it. | 00:17 | |
veritos | i like ruby; it just tries to be _too_ clean. my biggest problem with it though is that functions aren't first class...you need to use blocks, which have a different call syntax | 00:18 | |
jjore-w | Blocks aren't just another kind of function? | 00:19 | |
TimToady | In Perl 6 they're called the same but the return syntax has to differ | ||
jjore-w | er, object? | ||
TimToady | specifically "return" has to return from the "official" function, not the blocks embedded within it. | ||
so to return from a block requires "leave" instead. | 00:20 | ||
veritos | oh, and ruby -current stole our new block syntax (->(){}) too! except they call it 'stabby'. | ||
TimToady | I think they require parens too | 00:21 | |
geoffb | murderous lot ... | ||
veritos | TimToady: no, you can get away without. | ||
bsb | hi can someone do: svn propset svn:mime-type image/png pugs/project_planning/a_dependency_graph.png | ||
geoffb half expecting the atheme and katana syntax to follow soon ... | |||
veritos | www.dabeaz.com/ply/ - i'm saved! | 00:22 | |
lambdabot | Title: PLY | ||
veritos | can i stick something that's LGPL straight in the pugs tree (in source form, but intended as a separate library) or would that 'pollute' everything else? | 00:23 | |
TimToady | as long as it's only ever dynamically linked, I don't see a problem with it | 00:25 | |
00:26
veritos joined
|
|||
TimToady | veritos: as long as it's only ever dynamically linked, I don't see a problem with it | 00:28 | |
veritos | TimToady: it's basically a .pm lib, but for python | 00:29 | |
TimToady | bsb: svn: 'pugs/project_planning' is not a working copy | 00:31 | |
It's also okay to have it as an external dependency... | |||
veritos | what would you do in this case? | 00:32 | |
TimToady | would depend on how stable I thought the original was, and how stable its source webpage. | 00:33 | |
00:33
semifor joined
|
|||
veritos | it was intended as a teaching tool originally it says. www.dabeaz.com/ply/ if you want more | 00:34 | |
that's the author's site | |||
lambdabot | Title: PLY | 00:35 | |
TimToady | bsb: okay, figured out I should delete the pugs/ :) | ||
I will let you decide--that's why you have a commit bit. :) | 00:36 | ||
but I don't think the license is a problem offhand. | |||
veritos | sounds good...i'll put my email in the readme so he can whine to me if he has a problem with it. he's a teacher though, i think he'll be fairly reasonable. (one of the SWIG guys too!) | 00:37 | |
bsb | svn.pugscode.org/pugs/project_plann..._graph.png works now | 00:38 | |
lambdabot | tinyurl.com/2z58bw | 00:39 | |
TimToady | so it would seem here too, thanks | 00:40 | |
00:48
xdg joined
00:51
amnesiac joined
01:01
dolmans joined
|
|||
TimToady | A cow. A trampoline. Together they fight. A crime. | 01:09 | |
01:18
Lunchy joined
01:36
lisppaste3 joined
01:43
bonesss joined
02:10
SubStack joined
02:13
rissy joined
02:22
geoffb joined
02:40
veritos joined
|
|||
veritos | hello again | 02:40 | |
02:42
Limbic_Region joined
02:48
toshinori joined
02:54
mako132_ joined
|
|||
veritos | what happened to the svn bot? | 02:56 | |
and is anyone else working today? my tree's been up to date all 5 times i've updated it. | 02:57 | ||
03:02
elmex_ joined
|
|||
dduncan | I'm working today | 03:19 | |
offby1 is loafing today ... as most days | 03:21 | ||
03:30
agentzh joined
03:32
Alias_ joined
|
|||
TimToady | most of my work happens when I'm loafing | 03:32 | |
agentzh | iblech, malon: the synopses on the smoke server have run out of order (see the ones under "repository snapshot / linux"). thanks. | ||
dduncan | I like bread | 03:33 | |
which comes in loaves | |||
03:36
veritos joined
|
|||
veritos | hey guys and gals...just got another v6-Python commit. it now (sort of) parses (a bit of) MiniPerl6 and outputs an ugly mass that somewhat resembles Ruby. have a looksee: pugsroot/v6/v6-Python | 03:37 | |
and if you looked, try svn up - ing your tree again. | 03:39 | ||
and again. | 03:40 | ||
anyone actually on? | 03:42 | ||
offby1 wishes he could write off loafing as work | |||
veritos | offby1: psst....svn up. | 03:44 | |
cd ~ | |||
pasteling | "evalbot_r16100" at 194.145.200.126 pasted "Pugs build failure" (3808 lines, 445K) at sial.org/pbot/24451 | ||
veritos | cd pugs | ||
pasteling | "evalbot_r16100" at 194.145.200.126 pasted "Pugs build failure" (3803 lines, 445K) at sial.org/pbot/24452 | ||
veritos | cd v6 | ||
cd v6-Python | |||
03:46
ruoso joined
|
|||
offby1 | hmm | 03:46 | |
she | |||
offby1 svk pulls | 03:47 | ||
veritos | i think i'm the only one who's committed in the last ~6 hours | 03:48 | |
TimToady | no, dduncan has too | ||
veritos | oh, people are here. | 03:49 | |
dduncan | yes, several times | ||
in fact, I hope to make a release today | |||
veritos | what's your little pet, pun intended, project? or did you mean for pugs in general? | ||
Patterner | yay for releases | ||
dduncan | QDRDBMS is a module in synchronized Perl 5 and 6 versions ... the Perl 5 version will probably be released on CPAN today, but the announcement will mention both versions, so people who want the Perl 6 one can go to the Pugs repository, and the Perl 5 one is on CPAn as usual | 03:50 | |
veritos | oh | ||
fun... | 03:51 | ||
oh, alright...tree needed updating a couple sec ago | |||
dduncan | I also see it as appropriate to post the announcement on Perl 5 and Perl 6 lists ... in the former case, it would be database related lists, in the latter case, I figured perl6-announce plus perl6-users would be the most appropriate ... I assume that perl6-language won't be an appropriate place to announce ... not for this release anyway | 03:52 | |
a few releases later, p6l would be appropriate, because at that time QDRDBMS would include implementations of data types that I've been suggesting for mainline language support | 03:53 | ||
that is, the relation data type | |||
but the initial release won't have that, it is more of a skeleton | |||
veritos | how do you type QDRDBMS so fast? kind of a mouthful. | 03:54 | |
dduncan | I'm used to it | ||
in any event, that name is temporary, to be replaced with somethng easier to type later | 03:55 | ||
wolverian | what's it "short" for? :) | 03:57 | |
dduncan | oh, and I'm not the packager of Pugs ... basically just audreyt releases that | ||
veritos | i see. | ||
dduncan | I'll give you a hint ... the first 2 letters mean the same as in QDOS, the latter 5 are readily understood if you know the module is about databases | 03:58 | |
and that may tell you why the name is temporary | |||
wolverian | yeah, it's the first two I'm unfamiliar with | ||
dduncan | Quick and Dirty Operating System ... which was later renamed to MS DOS | 03:59 | |
wolverian | ah :) | ||
dduncan | the name denotes that this work is currently pre-alpha state | ||
or particularly that I've cut certain corners on purpose in order to get something working out sooner | |||
when those omissions are corrected and the project is more mature, it will be renamed | 04:00 | ||
and so people aren't surprised, I state this intention in the project's README file | |||
the other thing is that I haven't 100% decided what the longer term name will be, so I picked a bad short term name on purpose so people won't want to stick with it longer term | 04:02 | ||
that is all | |||
gaal | veritos: actually (+) is not Num -> Num -> Num because Num is a typeclass, not a type. | 05:07 | |
@type (+) | |||
lambdabot | forall a. (Num a) => a -> a -> a | ||
gaal | you can ignore the forall a here; what this signature means is that for any type a that you pick, the signature is a -> a -> a so long as a happens to belong to Num. | 05:08 | |
where "belong to Num" means that you have "instance Num ThatDatatype where .. " and definitions of at least the minimum nexessary functions | 05:09 | ||
05:18
laye joined
05:21
SubStack joined
05:51
buubot joined
05:54
Aankhen`` joined
06:11
rfordinal_ joined
06:13
BooK_ joined
06:30
franck__ joined
06:35
franck___ joined
06:40
BooK__ joined
06:44
benny joined
06:46
devogon joined
06:51
drupek12 joined
07:05
drupek12 joined
07:06
rfordinal_ is now known as rfordinal,
sapir joined
07:09
rissy joined
07:10
marmic joined
07:19
buetow joined
07:20
justatheory joined
07:21
jisom joined
07:35
iblechbot joined
08:10
Daveman joined
08:19
buetow joined
08:23
awwaiid_ joined
08:36
rfordinal_ joined
08:53
zamolxes joined
09:02
Salzh joined
09:23
toshinori joined
09:25
dduncan left
09:56
demq joined
10:13
ludan joined
|
|||
ludan | hola | 10:14 | |
moritz | moin ;-) | ||
10:15
midellaq joined
10:17
devogon joined
10:23
mj41 joined
10:27
polettix joined
10:33
jisom_ joined
10:48
ruoso joined
10:50
BooK joined
10:55
BooK_ joined
11:05
ayrnieu joined
11:15
chris2 joined
11:27
iblechbot joined
11:28
rfordinal_ is now known as rfordinal
|
|||
pasteling | "evalbot_r16106" at 194.145.200.126 pasted "Pugs build failure" (278 lines, 15.8K) at sial.org/pbot/24459 | 11:32 | |
11:32
ruoso joined
|
|||
moritz | I think we need a file in the pugs repository where different tasks are listed, and who usually takes care of them | 11:32 | |
for example evalbo, irclogs, smartlinks, autosmokes etc. | 11:33 | ||
avar | /SLAVES | 11:34 | |
moritz | good name ;-) | ||
bbiab& | |||
OwlEye | autosmokes sounds interesting :) | 11:36 | |
11:36
fglock joined
11:43
mako132_ joined
11:46
the_dormant joined
|
|||
fglock | veritos: ping | 11:48 | |
veritos: in case you backlog: | 11:49 | ||
mp6 can be bootstrapped by writing an emitter for the target language (Python) | |||
and then recompile the mp6 source code to python | 11:50 | ||
that is, you don't need to rewrite the whole compiler | |||
12:08
buetow joined
12:11
fglock__ joined,
fglock__ left,
fglock__ joined
12:13
fglock___ joined
12:17
fglock__ left,
fglock joined
12:27
vel joined
|
|||
avar | (multiple emitters)++ fglock++ | 12:28 | |
12:59
semifor joined
13:04
BooK joined
13:16
jerrylee joined
13:19
HiTech69 joined
|
|||
fglock | the current version of kp6 can convert perl6 OO into pure procedural code - makes it easier to support 'simple' backends | 13:36 | |
avar | how does kp6 relate to mp6? Isn't the aim of kp6 to not require mp6? | 13:37 | |
moritz | I think kp6 is written in miniperl6, right? | ||
fglock | kp6 is currently the language in which kp6 is written | 13:38 | |
mp6 | |||
moritz: yes :) | |||
avar | don't trip over each other:) | ||
fglock | kp6 has better semantics, but requires less backend support; OTOH, it does more emulation and can be slower | 13:41 | |
but the level of emulation is configurable | 13:42 | ||
avar | how were you doing with the parrot backend? Past hello world?:) | ||
fglock | avar: with the latest kp6 changes, it could now support full OO | 13:43 | |
moritz | PIR hello world? ;-) | ||
fglock | the latest tested code is: | ||
svn.pugscode.org/pugs/v6/v6-MiniPer...6parrot.pl | 13:44 | ||
the current plan is: kp6 -> non-OO mp6 -> p6parrot | 13:50 | ||
avar | fglock: does it emit pir that you can then run without [mp]p6? | 13:55 | |
fglock | I could not make p6parrot emit pir yet; not sure if it's my fault... | 13:56 | |
but mp6 emits simple-p6 that p6parrot can run | 13:57 | ||
without mp6 | |||
14:03
rlb3_work joined
14:20
rlb3_work joined
14:21
[particle] joined
14:24
perlmonkey2 joined
14:28
fglock_ joined
14:29
DarkWolf84 joined
14:30
rindolf joined
|
|||
rindolf | Hi all. | 14:30 | |
14:30
hcarty joined
|
|||
moritz | hi rindolf | 14:30 | |
rindolf | Hi moritz | ||
moritz: sup? | |||
moritz | rindolf: nothingmuch ;-) | 14:31 | |
rindolf | moritz: OK. | ||
14:32
fglock__ joined
|
|||
rindolf | I've started working on perl.net.au/wiki/Tactfulness_for_Geeks | 14:32 | |
lambdabot | Title: Tactfulness for Geeks - PerlNet | ||
moritz | rindolf: that's like trying to preach to the devel ;-) | 14:34 | |
geoffb | moritz: oh, man, that one *hurt* | ||
moritz | geoffb: no harm intended ;-) | 14:35 | |
nothingmuch | rindolf: tactfulness doesnt involve protocols and latency, it involves applying a filter to what you say | 14:38 | |
90% of the time you can avoid needless confrontation by just stfuing for another 10 seconds and thinking if that's really what you want to or should say, and if that's how you want to say it | 14:39 | ||
and that applies to real life also | |||
i don't think the concept of tact varies from one medium to another | |||
and also, i believe it's media, not mediums (i think mediums is plural for the synonym of the fortune teller) | 14:40 | ||
at least that's the only way i've seen it used that way withoutu being corrected by others quickly | |||
rindolf | nothingmuch: often if you don't say anything it will be worse than saying something. | 14:41 | |
nothingmuch: tact is not only about shutting up. | |||
nothingmuch: which you should know if you've read PG. | 14:42 | ||
nothingmuch | PG? | ||
moritz | rindolf: but in 90% of the cases shutting up helps ;-) | ||
nothingmuch | for what it's worth I don't agree, it's very uncommon that saying something is better than saying nothing if there's a dillema between the two | 14:43 | |
moritz | ?eval my @a = 1..3; @aĀ»++ | ||
evalbot_r16111 | (*** Can't modify constant item: VInt 1ā¤ at <eval> line 1, column 15 - line 2, column 1, *** Can't modify constant item: VInt 2ā¤ at <eval> line 1, column 15 - line 2, column 1, *** Can't modify constant item: VInt 3ā¤ at <eval> line 1, column 15 - line 2, column 1) | ||
nothingmuch | and I didn't say it was only, i said it was mostly | ||
moritz | should that work? | ||
nothingmuch | moritz: yes, it should | ||
moritz | ?eval my @a = 1..3; @a=@aĀ»+1 | ||
nothingmuch | oh wait | ||
evalbot_r16111 | Error: ā¤Unexpected "\187+"ā¤expecting "::", term postfix, operator or "," | ||
nothingmuch | ?eval my @a = (1..3); @aĀ»++ | 14:44 | |
evalbot_r16111 | (*** Can't modify constant item: VInt 1ā¤ at <eval> line 1, column 17 - line 2, column 1, *** Can't modify constant item: VInt 2ā¤ at <eval> line 1, column 17 - line 2, column 1, *** Can't modify constant item: VInt 3ā¤ at <eval> line 1, column 17 - line 2, column 1) | ||
nothingmuch | hmm, no | ||
i remember something vague about binding semantics in array assignment | |||
rindolf | perlbot: ph | ||
perlbot: pg | |||
nothingmuch | but i'm out of touch | ||
rindolf | nothingmuch: PG == Paul Graham | ||
14:44
hcarty left
|
|||
moritz | but the version with @aĀ»+1 should work, right? | 14:44 | |
nothingmuch | rindolf: i doubt paul graham could teach me much about tact or life in general, my parents have first dibs | 14:45 | |
rindolf | nothingmuch: "A wise man can learn from a fool, much more than a fool can ever learn from a wise man". | ||
nothingmuch: and Paul Graham is very wise. | |||
nothingmuch | also, most of what I read by him (and it wasn't much) may have been interresting, but I definitely didn't consider it to be The Word | ||
so, if i read his stuff he will learn from me? ;-) | 14:46 | ||
rindolf | nothingmuch: www.paulgraham.com/nerds.html | ||
lambdabot | Title: Why Nerds are Unpopular | ||
rindolf | nothingmuch: I didn't say he was the absolute truth. | ||
nothingmuch: but I got many important insights from him. | |||
nothingmuch: no. Not unless you blog about it or whatever. | 14:47 | ||
nothingmuch: and he reads it. | |||
nothingmuch: I don't consider you a fool. | |||
What my quote means is that a wise man always learns more than a fool. | |||
A fool is stubborn, he's not open. | |||
nothingmuch | i know what it means, i was kidding | 14:48 | |
rindolf | He may be very intelligent. | ||
nothingmuch: oh. Sorry. | |||
:-) | |||
/me can sometimes not detect when people are saying stuff tongue-in-cheek | |||
nothingmuch | that's why i put the smiley in there | ||
internet lacks tone | 14:49 | ||
PG's problem is that he writes a lot of text to convey a simple idea | |||
ah, there we go | 14:52 | ||
i agree with that paragraph in spirit | |||
"In fact, it's derived from the same root as "tactile," and what it means is to have a deft touch. Tactful is the opposite of clumsy. I don't think I learned this until college." | |||
to me that means knowing when to shut up and when to speak up | |||
not to shut up most of the time | |||
14:52
toshinori joined
|
|||
pasteling | "evalbot_r16111" at 194.145.200.126 pasted "Pugs build failure" (6 lines, 228B) at sial.org/pbot/24466 | 14:53 | |
fglock_ | nothingmuch: I wrote a very simple OO model for kp6, it would be nice if you could review it | 14:57 | |
nothingmuch | sure | ||
fglock_ | run tests in v6/v6-KindaPerl6, with 'sh run_tests.sh' | 14:58 | |
the lib is: svn.pugscode.org/pugs/v6/v6-KindaPe...rl5/MOP.pm | 14:59 | ||
lambdabot | tinyurl.com/2apyw6 | ||
rindolf | nothingmuch: it also means knowing what is the right thing to say. | 15:00 | |
nothingmuch: and how to say it. | |||
nothingmuch: what's up, BTW? | |||
nothingmuch | knowing what the right thing to say and when to say it is omiscience | 15:01 | |
tacfulness, for me, is minimising damage when you're not 100% sure | |||
rindolf | nothingmuch: pardon? | ||
nothingmuch | when you know the right thing to say there's no need for tact | ||
rindolf | nothingmuch: you can often say the same thing in two different ways, and one of them will be much better. | ||
nothingmuch: no, but you can often have a good judgement of what is better to say. | 15:02 | ||
How will people interpret it, etc. | |||
nothingmuch | in practice I find that is often not such a big problem as the other half | ||
15:02
toshinori left
|
|||
nothingmuch | fglock_: why go back to "traditional" OO | 15:03 | |
rindolf | nothingmuch: I agree with you that not saying anything is something you have to do. | ||
nothingmuch | ? | ||
rindolf | nothingmuch: as opposed to prototype-based OO? | ||
Or what? | |||
nothingmuch | as opposed to the generalized metamodel thing that was the result of roughly 2 years of continual redesign by stevan and then by me | 15:04 | |
which is capable of both classy OO and prototype OO | |||
and handling things like AUTOLOAD easily | 15:05 | ||
fglock_ | nothingmuch: I was after something that I could implement fast; I mean to upgrade the model later | 15:06 | |
nothingmuch | why not reuse MO? it's already implemented | 15:07 | |
fglock_ | nothingmuch: I need to translate this to MiniPerl6; it's easier to translate my own code (not a good excuse) | 15:08 | |
nothingmuch | fairynuff | ||
it | 15:09 | ||
[particle] | fglock: i think that's one reason other folks aren't helping you much (you keep translating your own stuff) | ||
nothingmuch | s just a bit of a shame to see a regression in terms of the limitations we tried to take out | ||
fglock_ | [particle]: mp6 is the stable implementation | 15:10 | |
[particle] | nm: is MO the latest and greatest metamodel? | 15:11 | |
or class::mop? | |||
fglock_ | nothingmuch: do you think I can keep the API and change the implementation later? | ||
clkao | Win 47 | ||
rindolf | www.m-w.com/cgi-bin/dictionary?book...;va=medium - Inflected Form(s): plural mediums or meĀ·dia /-dE-&/ | ||
lambdabot | Title: Definition of medium - Merriam-Webster Online Dictionary | ||
nothingmuch | [particle]: MO is later | 15:12 | |
Class::MOP is perl 5 specific | |||
MO is inspired by it (and as such by CLOS and smalltalk's metamodel) | |||
but attempts to make compile time and runtime separatable | |||
[particle] | great. maybe i'll port MO to parrot | 15:13 | |
nothingmuch | the part that should be ported first is very very simple -- reusable responder interfaces | ||
[particle] | now that we have a fancy new object model | ||
nothingmuch | (not necessarily the ones I sketched in p5) | ||
responder interfaces are dumbed down versions of classes meant to be easy to dispatch on | |||
fglock_: MO's API requires a new layer | |||
what you sketched seems to be like the responder interface layer | 15:14 | ||
[particle] | where is MO? | 15:15 | |
nothingmuch | nothingmuch.woobling.org/MO/ | ||
lambdabot | Title: Index of /MO | ||
[particle] | cpan search is less than helpful | ||
great! | |||
nothingmuch | it's not CPAN worthy yet | ||
[particle] | ah, i see | ||
nothingmuch | $work ;-) | ||
the problem is that the "stock" objects for Class, etc are more experiments | |||
to stretch the boundries isntead of provide a good base | |||
it's noncomittal | |||
[particle] reads the ten thousand inch view | 15:16 | ||
nothingmuch | nothingmuch.woobling.org/MO/lib/MO/Overview.pod | ||
? | |||
[particle] | yep | ||
nothingmuch | lk | ||
oi, i see | |||
[particle] | s/"/'/ | ||
nothingmuch | ;-) | ||
patches welcome | |||
;-) | |||
fglock_ | nothingmuch: I'm mostly interested in working 'Code' objects right now; the model can be improved later | ||
nothingmuch | fglock_: fairynuff, i agree that the perfect is the enemy of the good | 15:17 | |
but I would make sure you are not using the meta model in a way that is too restricting for an MO style one to come by later | |||
theoretically in MO you can swap out your entire object system (new concept of method calls, new concept of objects, new concept of "concepts" (defining meta objects such as prototype objects or classes)) | 15:18 | ||
without stepping over the language's native ones | |||
(part of the inspiration was parrot's intended multiple language thing, and the problems that might arise from that) | |||
fglock_ | is there something I should change right now? | ||
nothingmuch | it's tricky to say | ||
i don't know kp6 or your mop very well | 15:19 | ||
[particle] | nm: in parrot, Class and Object are coupled... if you override one, you need to override the other. is this common? | ||
nothingmuch | [particle]: Class is the class of the meta class and Object is the class that is the base class of all instances? | ||
fglock_: the problem with MO is that it works in cycles | 15:20 | ||
the compiler or the runtime creates meta objects whose job is to retain the declarative data closely | 15:21 | ||
kinda like a high level AST | |||
[particle] | nm: yes, iirc | ||
nothingmuch | [particle]: in the current example metaclass (Class::MI and Class::SI) there is no concept of a base class of everything | ||
instead "core" methods are generated | |||
but this can be changed | |||
as for whether or not it's common - oi | 15:22 | ||
i've never seen that restriction before | |||
i don't think it matters much | |||
if you subclass Class into e.g. My::ORM::Metaclass | |||
then maybe $db_bound_object has a separate default meta class | |||
but maybe it doesn't and it's just the meta protocol (e.g. accessor generation) that's being changed | |||
i think they are orthogonal but that it's not a horrible restriction to enforce | 15:23 | ||
... fglock_: | |||
these objects may refer to eachother (by value or by name, it doesn't matter) | |||
for things like subclassing, etc | |||
then you compute standalone structures from these | |||
either at compile time in advance or as necessary during boxing | 15:24 | ||
and you reference this structure from the object's type box | |||
instead of the original metaclass | |||
if you keep this runtime/compile time separation possible (even if it's all runtime for now) then you should be able to plug MO later by just generalizing the method call opcioode | |||
but there needs to be room for the multiple pass arch | 15:25 | ||
you should probably ask audreyt for advice, if she knows your stuff better | |||
because she also knows MO well | |||
btw, how is ingy? does anybody have an update? | |||
fglock_ | nothingmuch: thanks | 15:26 | |
nothingmuch | btw, don't take this the wrong way but WRT the perfect being the enemy of the good | ||
this is the Nth mini language, right? | |||
at some point i think you need to try to get at least the most difficult part closer to perfect | 15:27 | ||
even if it slows you down | |||
because in the long run it's going to have to happen sometime | |||
fglock_ | nothingmuch: most difficult part == MO ? | 15:28 | |
nothingmuch | the most difficult part is interlocking parts that need to get bootstrapped somehow | ||
the compiler is written in it's own language, right? | |||
fglock_ | yes | ||
nothingmuch | to write a compiler you want good uspport for $nifty features | ||
but to support these features you need a good compiler | |||
(parser, meta model, interpreter, emitter, yadda yadda yadda) | |||
all these parts depend heavily on one another and if you kludge one of them you will at some point suffer in another part due to that | 15:29 | ||
15:29
toshinor_ joined
|
|||
nothingmuch | i don't think you can really write everything up front | 15:29 | |
15:29
|OUF|HiTech69 joined
|
|||
[particle] | can't you build a better metamodel from a simpler one? | 15:29 | |
nothingmuch | the point is that there have already been many simpler ones | 15:30 | |
we've learned our lessons =) | |||
i'm not preaching for big design up front | |||
but it looks a bit like we're avoiding the next big step by looking for slightly more immediate results | |||
s/we're/you're | |||
[particle] | i'm wondering if MO can sit on top of what fglock has | ||
nothingmuch | i don't deserve to claim i'm doing anything ;-) | ||
[particle]: yes and no | |||
MO sits on Moose in perl 5 land | 15:31 | ||
i've experimented with MO in perl 5 bootstrapping itself | |||
and it works OK too | |||
but the thing is that the current stuff is in perl 5, with some integration it could be reused quite easily | |||
eventually MO will need to get ported to perl 6 | |||
and then get compiled by it's perl 5 counterpart | |||
and then it can compile itself | 15:32 | ||
[particle] | and if it's ported to kp6, then that can happen *soon* | ||
nothingmuch | whereas in the current scenario it looks like the simpler model will get converted to perl 6, and then MO will be written in that, and then it will be integrated | ||
fglock_ | nothingmuch: I think the simpler model can be converted to MO by hand, with some help of the compiler | 15:33 | |
nothingmuch | i don't see how the compiler helps | 15:34 | |
but suure, it can be converted later | |||
the question is at what cost | |||
and if it's really cheaper (time wise) to do that later instead of now | |||
fglock_ | the compiler just takes care of the syntax sugar | 15:35 | |
nothingmuch | superficially | ||
fglock_ | I'm ok to do it now, | ||
nothingmuch | in practice it's also about the compilation structures' lifecycles | ||
fglock_ | kp6 milestones are all met, | ||
nothingmuch | which are crucial for MO to be used correctly | ||
fglock_ | so there is no reason not to do it now | ||
nothingmuch | i can't help right now ($work schedule is hard) | ||
but maybe come may 15th i'll have more time to hack again | 15:36 | ||
things to keep in mind -- a port of MO does not necessitate direct porting of the classes therein | |||
it's mostly about the most basic design decisions | |||
and about responder interfaces (which are the easiest part to port) | |||
so you can simplify MO to very few LOCs, i think | |||
and it remains extensible when the language requires richer meteaclasses | 15:37 | ||
[particle] | nm: based on this conversation, and your work on MO, i'd appreciate your comments on PDD15. think you can give it a look when you have time? | ||
nothingmuch | [particle]: i'll give it a shot | ||
link? | |||
fglock_ | what if I ported some MO tests to kp6, and worked on it | ||
[particle] | www.parrotcode.org/docs/pdd/pdd15_objects.html | 15:38 | |
lambdabot | Title: Object and Class semantics for Parrot - parrotcode: | ||
nothingmuch | fglock_: i think the smartest thing to do is to take your model | ||
and refactor it to use MO style cycles | |||
that way you don't need to make big changes later | |||
and you don't need to adopt a foreign code base alltogether | |||
fglock_ | are there docs on MO style cycles? | 15:39 | |
nothingmuch | and you can even fake it | ||
because the responder interface can just be the metaclass | |||
it's for when it's inconvenient for the metaclass to be a responder interface that MO brings benefits | |||
that overview that [particle] was reading | |||
fglock_ | ok | ||
nothingmuch | i've gone further and implemented all the objects involved in MO in a purely functional style | 15:40 | |
so that they're portable to haskell, too | |||
but that's not mandatory | |||
(though ideally it'll be refactored back into that once it's self hosting in perl 6) | |||
[particle] | we're currently redesigning the PMC object | 15:41 | |
nothingmuch | [particle]: skimming it it looks like Class tries to be the one true responder interface in MO speak | ||
[particle] | i've just started reading about responders now in MO | ||
nothingmuch | (not necessarily good or bad) | ||
i'll read into it more | 15:42 | ||
fglock_ | brb | ||
[particle] | for PMCs, the responder interface is a vtable | ||
hrmm, actually that's incomplete | |||
it's the vtable plus non-vtable methods | |||
nothingmuch | from what I remember the pmc is practically it's own responder interface | 15:43 | |
[particle] | we've been talking about role-based pmc composition | ||
nothingmuch | becaus eit's data coupled with a type | ||
ingy | nothingmuch: kiss | ||
nothingmuch | ingy: yay, you're concious! | ||
[particle] | hey there ingy! | 15:44 | |
ingy | hi | ||
cls_bsd | ingy: hi !! | 15:45 | |
and night!!! | |||
nothingmuch | [particle]: the original vision is that by extending the VM or implementing responder interfaces with the VMs language (both should be possible) the metaclass author can support an idealized runtime version of the object's behaviro | ||
== performance | 15:46 | ||
for example compiling a flattenned vtable | |||
indexing method names | |||
etc | |||
[particle] | okay | ||
nothingmuch | all lead to the construction of a simpler data type | ||
90% of the itme this will be a dispatch table | |||
[particle] | we definitely want vtable flattening, rather than storing pointers to the vtables of the composers | 15:47 | |
ingy | hi cls_bsd | ||
[particle] hopes ingy has found a friend in tab-completion | 15:48 | ||
nothingmuch | when the process is separated then the metaclass's advanced features (e.g. roles, attribute grammars, complex attributes, various construction behaviors etc) can be implemented in the host source language | ||
ingy | heh | ||
alwayz | |||
nothingmuch | as long as the output is a simplified structure that can then be transliterated into a natively supported responder interface | 15:49 | |
example: for every possible target class, precompute the final table of all applicable methods and save them into a tabular structure | |||
if optimising for size, fragment the tables into shared ones with pointers | |||
if optimising for speed make only one vtable for every class | |||
the two optimisations can coexist as long as there is either a polymorphic dispatch | |||
(the responder interface has a type) | 15:50 | ||
or a different opcode is generated for the method call | |||
ingy | i'm not much slower typing one handed then two | ||
nothingmuch | inlining the lookup logic at the callsite | ||
rindolf | Hi ingy | ||
ingy: are you feeling any better? | |||
ingy | hi rindolf | ||
still hate me? | |||
rindolf | ingy: I never hated you. | ||
ingy: oh, you mean about speeding? | |||
ingy | ;) | 15:51 | |
nothingmuch | speeding is fun | ||
[particle] | everyone hates ingy! | ||
rindolf | nothingmuch: not on the road. | ||
nothingmuch | rindolf: speeding is fun on the road | ||
ingy | Ricky Bobby is my hero | ||
nothingmuch | skydiving is also fun | ||
rindolf | "Everyone hates Ingy dƶt Net" | ||
[particle] | skydiving *is* fun | ||
nothingmuch | risk and consequences don't necessarily deduct from the fun of the activity before they are realized | 15:52 | |
hence speeding is fun even if it's reckless | |||
ingy | nothingmuch: well said | ||
nothingmuch | ingy: i've been studying for this | 15:53 | |
played wiuth snowboards and ice axes | |||
i can rationalize stupid hobbies very well now =) | |||
[particle]: are you seeing what I'm getting at? rich semantics in the language's compiler, and low level reusable components in the runtime | 15:54 | ||
ingy | www.cafepress.com/buy/movie/-/pv_de...pt_/c_360/ | ||
lambdabot | Title: CafePress.com : Error, tinyurl.com/29lbs5 | ||
nothingmuch | if required the runtime can use rich semantics too, but it doesn't have to all the time | ||
for example in perl 5 it's rich semantics all the way (the interperter walks the stash) | |||
rindolf | I've uploaded to Flickr a photo of a Hyrax I took in the Carmel : www.flickr.com/photos/shlomif/471195681/ | 15:55 | |
lambdabot | Title: Hyrax in Little Switzerland on Flickr - Photo Sharing! | ||
[particle] | yes, i can see it, but i'm not exactly sure how to get there | ||
nothingmuch | hosting perl 5 on a MO VM will mean that the metaclass (prolly an object wrapping the stash) is probably going to be it's own responder | ||
whereas in C++ for example, you have the one true metaclass | |||
rindolf | Licence is PD. | ||
nothingmuch | that compiles to the one true responder interface | ||
because everything is static it's easy: | |||
either it's virtual and you run it through a vtable or it's just a function call with OO syntax ;-) | |||
but C++ is not rich | 15:56 | ||
MO tries to make both worlds possible depending on the investment the VM and the language compiler are willing to make | |||
[particle] | ultimately, we'd like PMC and PIR oo to look the same, so you can use interchangeably | ||
nothingmuch | i'm not sure exactly what you mean | 15:57 | |
from whose POV? | |||
[particle] | it's a bit tangential | ||
from the user's perspective | 15:58 | ||
nothingmuch | from the user's perspective it should be possible | ||
(you mean the metaprogramming, compiler writing user, right? not that user's user?) | |||
[particle] | yes | ||
nothingmuch | .. provide implementations of RIs and metaclasses for PMCs | ||
[particle] | correct. | ||
15:59
ruoso joined
|
|||
nothingmuch | it should be simple | 15:59 | |
then the code gen emits abstract opcodes like "box" | |||
and the static analyzer can decorate these opcodes with more info | 16:00 | ||
like a set of types that this box might be | |||
and then this can be optimized into lowlevel opcodes | |||
which are different | |||
e.g. if you say $class.new(...); then it's always the abstract opcode in the runtime | |||
but if it's Str.new | |||
then the metaclass is known, hence the RI getting boxed in the .new is also known | 16:01 | ||
and since this is really a proxy for the PMC stuff in the low level it's not "native" OO but FFI OO | |||
(in the sense that Str is a class implemented by the VM or a library the VM uses or whatever) | |||
this applies to multiple languages at once too, btw | |||
Str might be implemented in python | 16:02 | ||
and $str.foo will be dispatched according to pytjon rules | |||
using python metaclasses | |||
it's not "brought over" to the perl side | |||
is this any clearer? | |||
[particle] | yes, thanks | 16:04 | |
nothingmuch | i should probably read the PDD before advising more | ||
i only have a vague picture so i need to keep things too generalized ;-) | 16:05 | ||
[particle] | sure. | ||
and i've only just begun writing tests for the implementation | |||
mostly i'm testing api's and other unit tests | |||
16:05
bernhard joined
|
|||
[particle] | we need some solid functional and performance tests, though | 16:06 | |
fglock_ | backlogging... | 16:22 | |
16:23
veritos joined
|
|||
veritos | morning | 16:23 | |
i already told fglock this, but apparently Python lets you compile to c code too. | 16:24 | ||
it's only dependent on your system's libc | |||
basically like B::C, but that works. | |||
16:31
amnesiac joined
16:34
kanru joined,
midellaq left
|
|||
fglock_ | re nothingmuch.woobling.org/MO/lib/MO/Overview.pod - the compile-time metamodel look just right; now looking at the runtime... | 16:38 | |
16:45
fglock_ left
|
|||
nothingmuch | /w 35 | 16:47 | |
16:48
franck__ joined
16:53
buetow joined
|
|||
gaal | looks like a great resource: www.diku.dk/hjemmesider/ansatte/torbenm/Basics/ | 16:54 | |
lambdabot | Title: Basics of Compiler Design | ||
gaal | # free book | ||
moritz looks | 16:55 | ||
16:57
fglock joined
|
|||
TimToady | nothingmuch: I'm wondering if P6's "undefined prototype" objects can be thought of as essentially just the pure, abstract responders without any particular attached object. | 17:05 | |
17:06
penk joined
|
|||
TimToady | the responder representative, if you will... | 17:06 | |
I was always thinking of the RI as "something beyond .HOW", but those undefs are pretty close to the same notion, insofar as they respond to the same methods (to the extend possible without an object) | 17:08 | ||
nothingmuch | TimToady: IMHo there's no need to burdon the language with RI details | 17:09 | |
that's for language implementors | |||
granted prototype object based OO is very easy to translate to RIs | |||
moritz | gaal++ # that books looks fine ;-) | ||
nothingmuch | so the affinity is high between the metaclass and the RI of prototype OO stuff | ||
but I'm not sure p6 should care | 17:10 | ||
i mean, technically, yes, that's what they'll be (a box with just a type, i suppose) | |||
TimToady | sure, just trying to figure out if it saves me mental energy to identify them more closely in my mind. | ||
nothingmuch | but i don't think it's a fundamental change in the thought modeling | 17:11 | |
TimToady | if RI is fundamental to the MO view, and MO is fundamental to P6, then at some point RI shows up as fundamental in P6... | ||
nothingmuch | RI is fundamental in the same sense that target opcodes are | ||
compile time metamodeling is fundamental in the same sense that prelude functions are | 17:12 | ||
TimToady | except there's a profound difference between a singular interface and a bunch of opcodes. | ||
nothingmuch | but it's not singular | 17:13 | |
RIs are menat to duck type in the interpreter | |||
17:13
ozo joined
|
|||
TimToady | well, sure, the whole OO mindset is that things that are singular on the outside are plural on the inside somehow... | 17:13 | |
nothingmuch | si | 17:14 | |
17:14
justatheory joined
|
|||
TimToady | and I'm not saying that RI's have to be real objects, only that to the extent they are, an undefined prototype is very like it. | 17:14 | |
nothingmuch | which is why i think it's invisible to the language | ||
oh | |||
sorry, i misunderstood | |||
hmm | |||
that's aesthetic | 17:15 | ||
but I don't know if it actually has any technical meaning ;-) | |||
TimToady | probably not, unless they also happen to respond to ".WHATTHEHECKKINDOFRESPONDERINTERFACEAREYOU" | 17:16 | |
nothingmuch | hmm | ||
rindolf | Hi TimToady | ||
TimToady | or .WTF maybe. :) | ||
nothingmuch | i always ssaw RI as the return value from blessed() in perl 5 terms | ||
TimToady | but yeah, mostly just mental construct | 17:17 | |
nothingmuch | and likewise what you give to bless() to box some data with a type | ||
rindolf | Heh. Today is Tuesday, when God said "And it is good" twice. | ||
TimToady | gotta take my kid to the bus stop for ~20 min. | ||
afk & | |||
rindolf | Or when God saw it was good twice. | ||
TimToady: bye. | |||
TimToady: have fun. | |||
nothingmuch | rindolf: what a coincidence! | ||
rindolf | nothingmuch: it's mystical I tell you! | 17:18 | |
nothingmuch | yep... this tueday just keeps popping up | ||
rindolf | It only happens once every 7 days. | ||
nothingmuch | TimToady: bless( $instance_data, Dog ); # consistent | 17:19 | |
also querying the type of is consistent | |||
but i think it's more of a parallelism | |||
rindolf | nothingmuch: you're using vim, right? | ||
nothingmuch | because the proto is the type of the object to some extend (loose definition of type here) | ||
and the RI is the support object that the VM uses to figure out how the type behaves | 17:20 | ||
rindolf: yes | |||
rindolf | nothingmuch: ah OK. | ||
nothingmuch | what value will that object give, though? | ||
i mean, besides proto stuff | |||
rindolf | nothingmuch: how long is your .vimrc file? | 17:21 | |
160 641 5679 .vimrc | |||
But I have some stuff in other files. | |||
nothingmuch | Dog.handle_method( method => Method::Named.new( :name<foo> ), responder => $dog ); # possibly useful? | ||
especially if $dog is really something else | 17:22 | ||
rindolf | Hmmm... www.flickr.com/services/api/upload.api.html | ||
nothingmuch | rindolf: about the same | ||
lambdabot | Title: Flickr Services | ||
rindolf | nothingmuch: how do you upload photos to Flickr? | 17:23 | |
nothingmuch | i don't | ||
rindolf | nothingmuch: ah. | ||
nothingmuch: then who does? | |||
nothingmuch | flickr users | 17:25 | |
rindolf | Hmmm... search.cpan.org/~cpb/Flickr-Upload-1.25/ | ||
lambdabot | Title: Christophe Beauregard / Flickr-Upload-1.25 - search.cpan.org | ||
rindolf | nothingmuch: I meant in regards to Perl 6. | ||
nothingmuch | who uploads photos to flickr in regards to perl6? | 17:26 | |
rindolf | And Mandriva has it. | 17:29 | |
nothingmuch: from conferences, etc? | |||
nothingmuch | the intersection of the set of flickr users and the set of people who attend conferences and take pictures | 17:30 | |
i really don't understand what type of information you're trying to get with these questions | |||
17:31
ozo_ joined
|
|||
nothingmuch | food & | 17:35 | |
17:38
Psyche^ joined
17:39
[particle] joined
17:54
Psyche^ is now known as Patterner
18:06
jisom joined
18:10
fglock left,
fglock joined
18:14
the_dormant joined
|
|||
fglock | nothingmuch: I think I got it now - my 'CALL' is the 'responder' implementation; I need to box it into a 'responder object', and make a 'responder interface' | 18:15 | |
hmm - simple like that? | |||
nothingmuch | CALL($obj, "foo") should have a body of something like UNBOX_RI($obj)->dispatch( method => Invocation::Method::Named->new("foo"), responder => $obj ); | 18:18 | |
rindolf is doing urpmi.update -a now. | 18:19 | ||
fglock | you mean, the objects knows it's dispatcher | 18:20 | |
s/objects/object/ | |||
the reason for this is so that you can have several MOs in the same program? | 18:23 | ||
18:30
stevan__ joined
|
|||
fglock | nothingmuch: MO/t/si.t has commands like MO::Run::Aux::method_call( $base_obj_box, "elk" ) | 18:31 | |
nothingmuch | those are helper routines | 18:32 | |
or opcodes, if you will | |||
method_call( $mo_obj, $string ) is equiv to $perl_obj->$string | |||
oops, missed the prev part | 18:33 | ||
yes, the reason is that you can have several responder interfaces | |||
from even more varied metaclasses | |||
multiple languages' systems | |||
multiple "concepts" in the same language | 18:34 | ||
hand coded optimisations | |||
whatever is fit | |||
fglock | how about the bridge between the implementations? does it just fits together | ||
I mean, what if the method arguments belong to a different MO - it's probably handled by a 'coerce' routine somewhere else | 18:37 | ||
ah - no, it's just the API that matters | |||
18:38
calamare joined
|
|||
nothingmuch | nope | 18:38 | |
if the languages share a similar enough Invocation object | 18:39 | ||
then there's no need for coercion | |||
if they don't then that glue has to be done using a wrapper RI | |||
the boxed type presented to e.g. perl 6 from $lang_foo will have a wrapper RI that translates invocations before delegating to the original ones | |||
so basically what you said afterwords =) | |||
fglock | wrapper = MO::Run::Aux::method_call for example | 18:40 | |
nothingmuch | nope | ||
more like class ShimRI { method dispatch ( :$obj, :$method ) { Invocation::DifferentKind.new( .... ); # based on $method; $.wrapped_ri.dispatch( $obj, $new_invocation ) } } | 18:41 | ||
and, of course, it wraps all return values as necessary, too | |||
fglock | ok - I guess I'll do some implementation and come back with more questions :) | 18:42 | |
nothingmuch | cool | ||
fglock | brb | 18:46 | |
18:46
fglock left
19:17
fglock joined
|
|||
fglock | unbox($obj)->dispatch( $obj, $meth ) == now works in kp6 | 19:34 | |
any MO people still around? | 19:58 | ||
one remaining problem in kp6 OO: | 19:59 | ||
containers currently have 2 dispatchers, one for plain methods, and one for VAR() methods | 20:00 | ||
20:01
penk joined
|
|||
fglock | having 2 dispatchers in the same object doesn't seem to be against MO, so I'll just keep it | 20:02 | |
20:03
geoffb joined,
marmic joined
|
|||
Juerd | Feather is going to change IP address soonish. | 20:04 | |
kolibrie | new network? | 20:07 | |
20:11
Aankhen`` joined
20:15
veritos joined
|
|||
veritos | heya | 20:17 | |
pasteling | "fglock" at 201.54.129.80 pasted "kp6 - working "new-MO" output of t/kp6/20-bit.t" (51 lines, 1.5K) at sial.org/pbot/24472 | 20:18 | |
fglock | veritos: hi | 20:19 | |
20:20
_bernhard joined
|
|||
avar | yay I sort of understand how mp6 works now:) | 20:23 | |
fglock | avar: cool | ||
"sort of"? :) | 20:24 | ||
avar: now you can start with kp6 | |||
avar | well how the p5 emitting backend differs from parrot | ||
veritos | phew. | 20:25 | |
i'm working on the python code generator. | |||
fglock: so what did you think of that Freeze thing i showed you? certainly one thing python did right... | 20:26 | ||
avar | v6-Python? | ||
veritos | avar...not now | ||
fglock | the kp6 emitter is much simpler than mp6's | ||
veritos | i'm working on a backend for miniperl6 | ||
avar | neat | ||
[particle] | compiling perl 6 to python 3000? | ||
veritos | [particle]: not 3000 | 20:27 | |
avar | hah | ||
20:27
dduncan joined
|
|||
fglock | veritos: it would be nice to see v6->python->C working | 20:27 | |
[particle] | vaporlang on vaporlang | ||
veritos | fglock: once i get this python emmiter working | ||
fglock: we could have almost skipped parrot. | |||
fglock | [particle]: mp6 new-MO is out | ||
[particle] | great | ||
that was fast! | 20:28 | ||
fglock | veritos: heh | ||
[particle]: see the last paste | |||
avar | fglock: the kp6 emitting backends end up in mp6 though right? | 20:29 | |
demq | hey particle did you notice my message the other day? | ||
fglock | [particle]: kp6->parrot is probably more doable now; it requires simpler semantics | ||
20:29
demq is now known as dmq
|
|||
veritos | generating python is hard, you have to keep track of indent and everything.w | 20:29 | |
[particle] | dmq: no | 20:30 | |
fglock | avar: mp6 is just one backend; it does kp6->perl5 directly | ||
avar | veritos: ya, that sucks:) | ||
dmq | oh, just wanted to thank you for the pointer to the \v/\h esclists, and to say that ive added such support to p5. | ||
so, thanks. :-) | 20:31 | ||
was kinda curious actually what the rules were for generating the lists, just in case unicode X.0 adds new ones... | 20:32 | ||
veritos | maybe i could implement it as a two-pass compiler. first would leave comments like # DEDENT or # INDENT, and the second pass would change those to actual indents. | ||
avar | fglock: and it can do kp6->python|php|lisp|whatever easier than mp6->whatever? | ||
fglock | veritos: I wonder if there is a "pythontidy" that would do it for you | ||
dmq | just use { } | ||
[particle] | dmq: fantastic news | ||
avar | if 1+1: # { | 20:33 | |
print "ook": | |||
# } | |||
kolibrie | fglock: should I start looking at kp6 as a replacement for v6.pm and PCR? | ||
fglock | avar: yes, the ast transforms make it easier to desugar | ||
veritos | fglock: no, because there's no way to tell. indentation works like {}, you can't work otherwise. | ||
dmq | i also added support for \R as per uniocde tr18: unicode.org/unicode/reports/tr18/ | ||
lambdabot | Title: UTS #18: Unicode Regular Expressions | ||
fglock | kolibrie: sorry, not enough runtime yet | ||
avar | kolibrie: yeah it looks much nicer for what PCR does | 20:34 | |
kolibrie: not that I know...:) | |||
kolibrie | fglock: no problem (I'm not doing much to help) | ||
I am getting ready to update my 'Practical Extraction with Perl6' talk | 20:35 | ||
it's experienced some major bitrot I'm sure | |||
avar | veritos: it would be awesome if you could document some of this stuff as you go along:) | 20:36 | |
fglock | kolibrie: but I guess it's time to start 6-on-6-on-kp6; the runtime will be written as-needed | ||
avar | veritos: writing custom backends that is | ||
*nudge* *nudge* | |||
veritos | avar: i'm mostly taking the perl5 one and changing the emitted code. | ||
kolibrie | fglock: sounds great | ||
[particle] | dmq: thanks for the \R reminder, >>@todo | ||
avar | veritos: mm, and writing a match.pm in pythoon? | ||
veritos | avar: www.dabeaz.com/ply/ | 20:37 | |
lambdabot | Title: PLY | ||
dmq | i dont think p6 is supposed to or needs \R in the sense of that article. | ||
\R is supposed to be [^\r] in p6. | |||
avar | p6 pretty much doesn't need any escapes since you can just add them:) | ||
<-[\r]> you mean:) | 20:38 | ||
[particle] | hrmm... i guess pge is *mostly* perl 6-based | ||
dmq | avar: er, right. :-) | ||
[particle] | it will support negated \r, so maybe that'll do | ||
avar | I don't think you can define custom \ escapen in p6 though | 20:39 | |
then again I don't know p6:) | |||
veritos | you could in p5...there was an example in ze camel. | ||
fglock | [particle]: re translating my own stuff - hmm - do you think people get lost? | ||
[particle] | fglock: yes, i do | 20:40 | |
dmq | so no idea how those lists were determined? | 20:41 | |
[particle] | it's a combination of things--not many understand compilers, nevermind bootstrapped compilers written in a subset of perl 6 :) | ||
dmq: the \v \h lists? | |||
i copied them from the spec | |||
moritz | avar: you _can_ define \-sequences in p6 ;-) | 20:42 | |
avar | moritz: howz? | ||
moritz | token rule_backslash:<w> { ... } # define your own \w and \W | ||
avar | neat | 20:43 | |
moritz | perlcabal.org/syn/S05.html#Syntactic_categories | ||
lambdabot | Title: S05 | ||
veritos | python has some quirks though. there's no bare 'do this once block' like do{}, you have to say something like if True: yada | 20:44 | |
fglock: what's class Bind supposed to be? | 20:45 | ||
a list of statements? | |||
fglock | veritos: $a := $b | 20:46 | |
veritos | hmm...it seems to look like ->(){} from the syntax here | 20:47 | |
fglock | or: [any-structure] := [other-structure] - but you don't have to support this syntax | ||
20:47
vel joined
|
|||
fglock | Bind is used in many places, like parameter-passing | 20:47 | |
veritos | go to like line 160 in the perl5 backend | ||
fglock | one sec | ||
veritos: that part of the program transforms [$a,$b] := [1,2] into $a:=1; $b:=2 | 20:49 | ||
veritos | fglock: oh, ok. | ||
that works | |||
right now i'm basically translating the bits of perl5 into python. | |||
i haven't typed a := since i learned pascal. | 20:51 | ||
fglock | later & | 20:53 | |
avar | perl6: the new pascal | 20:55 | |
geoffb | As a young kid, my parents sent me to a computer day camp. It was tiered into basic and advanced students. I was considered a "basic" student because I didn't know Pascal, despite knowing at least one assembly language at the time. My, how times have changed. | ||
[particle] | you go to advanced day camp now? | ||
Tene | geoffb: that's odd. | ||
geoffb | [particle]: heh. | ||
On the plus side, the basic students got to play with a programmable robot as their final project. So I spent most of my time coding it to drive various patterns around the classroom. | 20:56 | ||
Early 80's robotics not so precise, btw. | 20:58 | ||
Some day when I'm rich and bored I ought to get back to playing with robotics again ... | 20:59 | ||
geoffb hopes embedded Parrot will be a reality by then | |||
[particle] | i sure haven't programmed in VAL-II in a while | 21:00 | |
operating a robot that could position 44lbs at any angle was fun, but without force feedback, quite dangerous | 21:01 | ||
21:07
Caelum joined
21:09
desiderato joined
21:19
desiderato left
21:39
sapir joined
23:17
SubStack joined
23:25
kunwon1 joined
|
|||
TimToady wonders how well Perl 6 will run on a TRIPS processor... | 23:31 | ||
mugwump | do they come from the frig? | 23:40 | |
23:42
kunwon1 joined
|
|||
jrockway | TRIPS = TimToady work project? | 23:44 | |
TimToady | hardware.slashdot.org/article.pl?si...24/2021243 | ||
lambdabot | Title: Slashdot | Next-Gen Processor Unveiled | ||
jrockway | ah, cool | 23:45 | |
TimToady | we already have the requisite references to Erlang and Haskell in the commentary... | ||
specbot6 | r14378 | larry++ | cut-n-paste typo noticed by TheDamian++ | 23:51 | |
23:58
forsaken joined
|