-Ofun: xrl.us/hxhk | pugscode.org | pugs.kwiki.org | paste: paste.lisp.org/new/perl6 or sial.org/pbot/perl6 Set by apple-gunkies on 11 November 2005. |
|||
svnbot6 | r8053 | Darren_Duncan++ | r1069@Darren-Duncans-Computer: darrenduncan | 2005-12-02 16:52:55 -0800 | 00:57 | |
r8053 | Darren_Duncan++ | /ext/Rosetta-Incubator : updated Overview.pod and TODO.pod following Bricolage developers' feedback | |||
clkao | awzzz | 00:58 | |
justatheory Mua-ha-ha-ha-ha! | |||
stevan_ | luqui: ping/pong/whatever | 02:33 | |
luqui | stevan_, gnop | 03:32 | |
stevan_ | hey luqui | ||
luqui | so, in case you didn't see, I did a 180 on the type system | 03:33 | |
stevan_ | yup, I saw :) | ||
luqui | and now it's going to depend a lot more on the metamodel... | ||
stevan_ | yup | ||
luqui | so, how's that going | ||
stevan_ | LOL | ||
03:33
stevan_ is now known as stevan
|
|||
luqui fails to see what's funny | 03:34 | ||
stevan | luqui: the metamodel is stalled looking for a parser to connect with | ||
luqui | hmm? | ||
stevan has written at least 3 versions of the metamodel by now | |||
and I am exploring the idea of one in PIR right now | |||
luqui: the most recent metamodel work is in the Perl6-ObjectSpace,.. but I dont think that is what you want | 03:35 | ||
luqui | I'm really just looking for theoretical ideas | ||
stevan | ah | ||
get a copy of "The Art of the MetaObject Protocol" | |||
that along with the Smalltalk "Brown Book" | 03:36 | ||
luqui reads the descriptions of said books | |||
stevan | those were my guides | ||
what specific theoretical ideas are you looking for though | |||
luqui | well, I dunno, seeing as how they're ideas and if I had them then I wouldn't need to look for them | 03:37 | |
er... something | |||
stevan | ok | ||
luqui | basically I'm looking for some ground to stand on somewhere | 03:38 | |
stevan | ok | ||
well the core building blocks of the metamodel are an "instance" type, a "method" type and an "attribute" type | |||
luqui | what is this "brown book"? | 03:39 | |
stevan goes and looks for a link | |||
it is called "Smalltalk 80 : The Language " | |||
www.amazon.com/gp/product/020113688...p;v=glance | |||
its a classic ;) | 03:40 | ||
so, once you have this "instance" type,.. you make an instance named Class | |||
this is the class Class | |||
then some bootstrapping handwaving | |||
luqui | okay | 03:41 | |
stevan | then you create the class Object | ||
then set the superclass of Class to Object | |||
(this is your object model cycle) | |||
because Object is an instance of Class, and Class is a subclass of Object | 03:42 | ||
this is the core of the metamodel IMO | |||
luqui | hm, okay | ||
stevan | with this foundation, you can easily build a highly reflective object model along the lines of CLOS | 03:43 | |
you can ditch some of the early steps, and just make classes "exist" | |||
but then you end up with Java/C#-ish classes | |||
and you have to build your reflection layer on top of it | 03:44 | ||
luqui | okay, that should be pretty easy to reason about in a type system. | ||
(except the object/class cycle might give set theorist some heartburn, but whatever) | |||
stevan | there is probably a good amount of work already done re: thing kind of model | ||
oh wait,... one other book for you | 03:45 | ||
luqui | bascially, I'm thinking that we expose AST to the language level | ||
and let you annotate it with whatever kind of data you like | |||
during this annotation you're allowed to die, of course. this is where typechecking can occur. | |||
stevan | www.amazon.com/gp/product/020143305...p;v=glance | ||
luqui | the hard part about this is how to actually make use of the types other than yelling at the user | ||
stevan | "Putting MetaClasses to Work" ,... this is the one which inspired Guido to use C3 | 03:46 | |
luqui | so I want a way to communicate certain guarantees back to the runtime | ||
stevan | so it is runtime type checking? | ||
luqui | uh, not really | ||
stevan | or are we exploiting that "run at compile time" bit here | ||
luqui | I mean, you could insert runtime checks, but the idea is that this happens at compile time | ||
yeah, definitely exploting that... a lot | 03:47 | ||
stevan | like BEGIN phase runtime? | ||
luqui | right | ||
stevan | ok | ||
luqui | (and typechecking of the BEGIN block would happen at the BEGIN's BEGIN time) | ||
stevan | so one trick about the metamodel | ||
it has to be built on something | |||
(this is what Perl6-ObjectSpace investigates) | |||
that something needs to exist prior to the metamodel existing | 03:48 | ||
luqui | $150!!?? | ||
stevan | native types basically | ||
what is $150? | |||
luqui | that book | ||
stevan | eak | ||
I got it for like $1 off ebay | 03:49 | ||
luqui | ahh, that's a good iea | ||
stevan | yeah ,.. ebay is great for odd computer books | ||
luqui | okay, built on something... | 03:50 | |
stevan | oh "Putting MetaClasses to Work" has lots of theory "stuff" in it (aka - skawiggly things I dont understand) | 03:51 | |
yes,.. the P6-ObjectSpace attempts to define the smallest set of "thing" a "backend" would need to provide in order to support the metamodel | 03:52 | ||
luqui | hmm | ||
stevan | so you have really basic int, string, bit, list, hash, closure, etc | ||
luqui | I see it as the type system's job to let the backend know when it can use a larger set of "things" | ||
stevan | I dont understand that comment | 03:53 | |
luqui | (oh, also when it can unbox and whatnot) | ||
well we have a minimal set of necessary support | |||
stevan | these 'things' are not exposed at user level | ||
they are all deep inside the runtime | |||
luqui | sure | ||
stevan | however, I was pondering ways to expose them to the runtime, but nothing final yet | ||
luqui | that necessary support might be slow, if the runtime has better support for some native perl 6 concepts, it should be able to use those | 03:54 | |
stevan | anyway,.. in P6-ObjectSpace there is a metamodel which is composed of nothing more than those types, and message sends | ||
luqui | but then again, I guess that's more of the PIL->Native compiler's job than the type system's | ||
cool | 03:55 | ||
stevan | well, that was partially what I wanted to do with the "runtime thing" to "userland thing" bridge | ||
the basic idea was to have some kind of core primative "thing" which looks suspicously like a Role | 03:56 | ||
then provide a bridge from that "thing" to a Role in the post-metamodel bootstrap world | |||
the large idea was that if we could define all "userland" access this way, then implementation of those underlying things is irrelevant | 03:57 | ||
and we could then allow each backend to optimize according to the specific features it had | |||
luqui | hmmm.. just trying to grok this. on what level is this "thing" "core primitive" | 03:58 | |
stevan | but this is all still in my head,.. and I am not sure it will work anyway,.. so probably best to ignore all that | ||
stevan ponders drawing a picture | |||
core primatives | metamodel primatives | metamodel | userland | |||
those are the 4 steps | |||
luqui | okay | 03:59 | |
stevan | although we should probably insert a "container & boxed types" item in between "metamodel" and "userland" | ||
since the container and boxed types should be implemented with the metamdoel | |||
so this primative thing which looks like a role,.. lets call it a "sig" | 04:00 | ||
luqui | mmkay | ||
stevan | this "sig" lives in the "core primatives" level | ||
a sig is much like a Java interface | |||
(this is all ripped off from Standard ML's module system) | 04:01 | ||
luqui | hmmm | ||
stevan | you can also have some kind of implementation attached to the sig | ||
stevan still hasn't worked all this out for real,.. so I am gonna handwave some | 04:02 | ||
every "thing" defined prior to the end of the "metamodel" step will have a sig | |||
then post metamodel bootstrap,.. we make a Role which corresponds to each sig in the system | 04:03 | ||
and whalla we have Roles for all our primative "things" | |||
stevan waves his hands madly | 04:04 | ||
luqui wonders what a sig looks like at a low level | |||
stevan | sig Bit { method to_num (Bit $self:) returns Num; method to_str (Bit $self:) returns Str; } | 04:05 | |
something like that | |||
luqui | er, I mean, from the other end of the low level | ||
how would the runtime we're implementing on see it | 04:06 | ||
stevan | although the real thing woul be more like: $Bit = sig->new(name => Bit); $Big->add_method(....) | ||
stevan waves his hands madly again | |||
the runtime would probably not use it that much | |||
although the ideal is that we do something like ML's Functors | 04:07 | ||
luqui | but those are strongly typed IIRC | ||
stevan | and we just program to the interfaces | ||
luqui | and that's about the only interesting thing about them | ||
stevan | well, they are polymorphic modules basically | ||
so we can program to the Bit interface | |||
and the underly impl is irrelevant | 04:08 | ||
luqui | but polymorphic over what? | ||
stevan wonders what should be under the polymorphism? | |||
oh,.. | |||
over the other sigs | |||
cyclical systems rock :) | |||
luqui | so you give it a sig, and it gives you back a module | ||
stevan | a sig and a impl | 04:09 | |
and it gives you back a "type" | |||
you use the type | |||
luqui | er | ||
stevan | yeah I know | ||
luqui | yeah... see, I'm trying not to have types down there | ||
stevan waves his hands madly once more | |||
luqui | they must be getting tired | ||
stevan | they arent really types | ||
there is little value in having sigs for very primative things like "bit" | 04:10 | ||
luqui | how come? | ||
stevan | except that with my sig->to->Role idea,.. you get role Bit {} for free | ||
luqui | (what case supposed to be significant there?) | ||
s/what/was/ | |||
stevan | well they are only used inside the runtime,... | ||
luqui | where by "free" you mean "implemented elsewhere" | 04:11 | |
instead of defining role Bit you just define sig Bit | |||
and it's about the same either way ;-) | |||
stevan | no, I mean the role Bit is just a box around the core primative "bit" | ||
well you can't use roles below the "metamodel" layer | 04:12 | ||
and you need to use bits in those lower levels | |||
luqui | I'm still not seeing what, er, role sigs play | ||
stevan | lets ignore it for now,.. I am smoking too much crack | 04:13 | |
luqui | is the idea that the metamodel defines sigs, and the runtime implements them? | ||
stevan | no | ||
sigs are a core runtime thing (below the metamodel layer) | |||
the metamodel uses them | |||
because the metamodel methods will return core runtime "things" | 04:14 | ||
luqui isn't sure how you can really define a "core runtime thing", seeing as we are trying to target existing runtimes | |||
i.e. that part isn't up to you | |||
stevan | true, but if they want my metamodel.. I need to have some basic building blocks | ||
luqui | we're probably in vocabulary hell here | ||
stevan | yeah thats surely a problem too | ||
oh wait,.. i think i see one issue | 04:15 | ||
backend != runtime | |||
parrot != runtime | |||
luqui | backend is deeper than runtime? | ||
stevan | parrot == backend | ||
yes, think of parrot as the "platform" | |||
luqui | but runtime would be implemented in PIR, not perl, right? | 04:16 | |
stevan | or in the case of Perl6-ObjectSpace,.. the "platform" is p5 | ||
I think some of the runtime will be in PIR, and other parts in perl | |||
preludes and such | 04:17 | ||
the metamodel can be part of the prelude actually | |||
if the right 'things' are there | |||
04:20
gugod_ is now known as gugod
|
|||
luqui | alright. let me sleep on this. I'll have a peek at Perl6-ObjectSpace | 04:20 | |
stevan | good idea :) | ||
I think autrijus should be in on this converstation too | 04:21 | ||
he and I discussed a lot of this | |||
luqui | Well, I'll be back in about a week. | ||
stevan | and I am sure he has some of the insight you are looking for that I dont have | ||
luqui | I really have some big projects to do for school and I'm procrastinating by thinking about htis | ||
this | |||
stevan | ok,.. $work is busy for me too, so my tuits are very limited | 04:22 | |
P6-ObjectSpace is probably a good place to start | |||
so enjoy :) | |||
and get those books if you can | |||
they are great | |||
luqui | alrighty | ||
stevan | (+ (+ CLOS)) | 04:23 | |
luqui | heh | ||
stevan goes off to watch some TV & | |||
later | |||
luqui | sayonara | ||
meppl | gute nacht | 04:47 | |
04:59
evalbot_8052 is now known as evalbot_8053
|
|||
luqui | ?eval Inf+1 | 05:09 | |
evalbot_8053 | Inf | ||
luqui | ?eval Inf/Inf | ||
evalbot_8053 | NaN | ||
luqui | ?eval Inf-Inf | ||
evalbot_8053 | NaN | ||
luqui | ?eval 1/0 | 05:10 | |
evalbot_8053 | Error: Illegal division by zero | ||
devin | ?eval Inf*0 | ||
evalbot_8053 | NaN | ||
luqui | seems to be correct | ||
under the assumption that it treats infinity as a number in the first place | |||
devin | see t/operators/arith.t around line 300 | 05:13 | |
i suppose there is an ieee or posix standard pugs should follow here | 05:14 | ||
luqui | ?eval 1**Inf | 05:15 | |
evalbot_8053 | 1.0 | ||
luqui | I disagree | ||
(I agree with the POSIX thing; I disagree with the result of that eval) | |||
?eval (-1)**Inf | 05:18 | ||
evalbot_8053 | 1.0 | ||
luqui | ?eval (-2)**Inf | ||
evalbot_8053 | Inf | ||
luqui | and I definitely don't agree with those | ||
devin | i agree that if you are going to say Inf*0 is NaN then you should say the same thing about 1**Inf | ||
luqui | ?eval (-.5)**Inf | ||
evalbot_8053 | 0.0 | ||
luqui | Oh, and: | 05:19 | |
?eval Inf**0 | |||
evalbot_8053 | 1.0 | ||
devin | well i guess the first thing you should do is write failing tests for those cases and submit a patch to the test suite | ||
luqui | yep | 05:20 | |
doing so | |||
Khisanth | luqui: why do you disagree with 1**Inf? | 05:21 | |
devin | cool ... big parts of the pugs testsuite will be usable for other implementations | 05:22 | |
luqui | because (1.00000000000000001)**Inf == Inf | ||
Khisanth | heh assuming there is another :) | ||
luqui | I can come up with a more rigorous example if you like | ||
Khisanth | hmm but 1 is not a float | 05:23 | |
luqui | ahh... that's an interesting perspective | ||
devin | ?eval 1.0**Inf | ||
evalbot_8053 | 1.0 | ||
Khisanth | see that is disagreeable :) | 05:24 | |
luqui | but Inf is a float... and we surely don't have infix:<**>(Int, Num) defined... do we? | ||
devin | Inf is not a float either, so who knows | ||
Inf is a float? | |||
luqui | sure. you can put it in floats in C at least | 05:25 | |
(we're on the edge of mathematics and engineering here, you see) | |||
(a lot of bullshit happens in these lands) | |||
devin | wow you are right, i have used floats in C for years and never realised Infinity was a possibility | ||
luqui | the mathematician in me has strong objections to the allowance of Inf in any variable | ||
but the programmer in me likes them, because I can use them in min() and max() | 05:26 | ||
s:g/them/it/ | |||
devin | Inf and NaN are like undef and SQL's NULL etc .. sentinel values | 05:27 | |
luqui | and I definitely have objections to "if $x == Inf {...}" | 05:28 | |
anyway. | |||
I don't consider this to be a part of the language design where rigor is essential | |||
because people have been using floats with these possibilities for years | |||
and every once in a while they have a good use | |||
devin | Inf is not infinity. it's a special purpose value that just represents infinity ... so it's not math, it's binary comparison. don't think of it as algebra | 05:29 | |
*shrug* time for me to go pick up my cleaning | 05:30 | ||
luqui | the thing is, when I don't think of it as algebra, then I can't use algebra to reason about it | ||
devin | actually i think it should be rigorously defined... that is what the test suite does | 05:39 | |
as long as it is rigorously defined, then for sure you will be able to use logic to reason about it, which is fine even if the logic isn't the same as algebra | 05:40 | ||
luqui | oh, by "rigor", I suppose I meant "conventional mathematical rigor". | 05:44 | |
I agree that it should be precisely defined | |||
devin | sounds like we're in violent agreement | 05:51 | |
luqui | ?eval 0**(-6) | 05:53 | |
evalbot_8053 | pugs: Ratio.%: zero denominator | ||
luqui | ?eval 0.0**(-6.0) | ||
evalbot_8053 | pugs: Ratio.%: zero denominator | ||
luqui | ?eval 0.0**(-6.1) | 05:54 | |
evalbot_8053 | Inf | ||
luqui | gr | ||
?eval 1/0 | 05:56 | ||
evalbot_8053 | Error: Illegal division by zero | ||
luqui | hmm... shouldn't that just be NaN, since we seem to be applying that everywhere | 05:57 | |
svnbot6 | r8054 | luqui++ | Added tests about infinity, and "fixed" op2Exp to make them pass. They should | 06:08 | |
r8054 | luqui++ | be checked for correctness. | |||
dwold | hello all | ||
can anyone see this? | 06:09 | ||
luqui | yep | 06:10 | |
dwold | good :) | ||
got a one line paste do I still need to put it in the past urls? | |||
luqui | you can just put it here | 06:12 | |
lisppaste3 | dwold pasted "regex" at paste.lisp.org/display/14245 | ||
luqui | or.. not | ||
that's one line? | |||
lisppaste3 | dwold annotated #14245 with "regex" at paste.lisp.org/display/14245#1 | ||
dwold | say well now lol | 06:13 | |
Well I just posted the whole thing | |||
What I cant get to work properly is the regex, Im not too familiar with either perl or regex | |||
luqui | first, this is not the correct place to ask this question | ||
this channel is about Perl 6, which hasn't been released | |||
go to #perl or #perlhelp | |||
dwold | ahh Woops :) | ||
sorry | 06:14 | ||
luqui | no prob | ||
?eval 0**0 | 06:15 | ||
06:15
evalbot_8053 is now known as evalbot_8054
|
|||
evalbot_8054 | 1/1 | 06:15 | |
luqui | ?eval (-1)**Inf | 06:16 | |
evalbot_8054 | NaN | ||
luqui | It's possible that that commit was antispec | 06:18 | |
I seem to recall Larry specifying that Perl will follow some common floating point spec | |||
rather than trying to reinvent the wheel | |||
however wrong that spec might be | |||
devin | yes, pugs should be "bug-compatible" with everyone else | 06:25 | |
luqui | I just read the IEEE spec wrt infinity. | ||
I'll roll back my changes :-( | 06:26 | ||
?eval 0/90 | 06:27 | ||
evalbot_8054 | 0/1 | ||
luqui | ?eval 0/0 | ||
evalbot_8054 | Error: Illegal division by zero | ||
luqui | ?eval 0.00/0.00 | ||
evalbot_8054 | Error: Illegal division by zero | ||
luqui | ?eval 1.43/0 | ||
evalbot_8054 | Error: Illegal division by zero | ||
luqui | hmm | ||
that should be NaN... maybe | |||
it really depends on whether we're interpreting it as a float or as a rat | |||
svnbot6 | r8055 | luqui++ | Darn. Rolled back my "fixes", because of Larry's decree that | 06:32 | |
r8055 | luqui++ | we should follow IEEE floating point, even if it is broken. | |||
autrijus | luqui: ping | 07:17 | |
luqui | pong | 07:18 | |
er, autrijus, pong | 07:19 | ||
autrijus | we need to talk :) | ||
> Perl 6 has no type system. | |||
Perl 5 has a strong, dynamic (late-bound), type system | 07:20 | ||
luqui | alright, fine, I was not being precise | ||
autrijus | nowhere did I see in type_meta that says we do without it | ||
also: | |||
luqui | (keep in mind that type_meta is largely a work-in-progress: I am still researching) | 07:21 | |
autrijus | my Socket $fh = open('/etc/passwd'); | ||
I gather from the text of type_meta that this should _still_ fail at runtime? | |||
luqui | yes | ||
autrijus | if so, that is a type system... unless we discard "Socket" by default | ||
which would be kind of wacky. | |||
luqui | right | ||
I meant no "static" type system. I intend to make a very simple pattern-based "type system", basically allowing roles to be functions from objects to bools | 07:22 | ||
autrijus | also, MMD being late-bound... I see no problems with it. | ||
luqui | ? | 07:23 | |
autrijus | the text seem to argue that MMD needs to be statically determined | ||
otherwise it's lost at sea | |||
luqui | there is only one problem | ||
autrijus | I fail to see that, really | ||
luqui | and that is with "is lazy" and MMD | ||
you know, the reason you added the tiny type inferencer currently in pugs | |||
autrijus | yes, but that is not really MMD | 07:24 | |
you can get it with SMD too | |||
luqui | 'splain | ||
autrijus | sub foo (Socket $s is lazy) { ... }; foo(open('/etc/passwd')); | 07:25 | |
luqui | that's not *deciding* what to execute based on the type of $s | ||
you can delay a check | |||
autrijus | how do I delay it? | ||
luqui | but you can't roll back and say "oh, now that we've evaluated, I think we actually should have chosen this other sub instead" | 07:26 | |
autrijus | sub foo (Socket $s is lazy) { system("rm -rf /") } | ||
sub foo (Socket $s is lazy) { system("rm -rf /"); ... evaluate $s ... } | |||
luqui | uh | ||
autrijus | it's the same problem really... with lazy evaluation we still don't want rm-rf to happen | ||
luqui | I suppose | ||
autrijus | it's, in a sense, deciding which path to execute (rm-rf or type fail) | ||
it's asif all sub{} is actually multi{} with a default case that throws type error. | 07:27 | ||
luqui | okay, I'll buy that | ||
but that was a problem before | |||
(and it's a hard one... hmm, hadn't thought about it before) | |||
Incidentally, if you consider lazy passing as passing a coderef, i.e. my proposal a little while back, the problem gets swept under the rug | 07:28 | ||
sub foo ($s is lazy:(--> Socket)) {...} | 07:29 | ||
we can't check that that is the type of $s if it is untyped | |||
we can only check that it is a code at all | |||
hmm. You can't really do MMD on function types. | 07:30 | ||
dynamically, that is | |||
autrijus | sure we can, if the function is explicitly typed. | ||
luqui | yeah, but if it's not | ||
there's nothing we can evaluate to figure out its type | 07:31 | ||
autrijus | if it's not it's populated with Any by default, which is like CLR's "Object" catchall type | ||
luqui | but now, supposing for a second that we did have a static type system, there is a subtle interplay between compile-time and runtime multiple dispatch | 07:32 | |
autrijus | anyway. my point is that if people discover that adding type annontation does not bring any errors forward to compile time | ||
luqui | (and makes their programs slower to boot) | ||
autrijus | then there is significantly less incentive of adding any sort of annotations. | ||
yup. | |||
luqui | yeah. But "use Types::Static" isn't so hard to type... | ||
they just have to know about it | |||
autrijus | ah but what would Types::Static bring to table, is the questoin. | 07:33 | |
luqui | The whole idea is that you put the static type system in the hands of CPAN, not eliminate it altogether | ||
autrijus | yup, I understand that | ||
luqui | okay... | ||
autrijus | however, even under separate compilation, type constraints expected by a module still has to be understood by another | ||
luqui | yeah, that's the part that I haven't figured out yet | 07:34 | |
autrijus | so there still have to be a static calculus somewhere | ||
luqui | research, thinking, sketching, all of that | ||
dduncan | autrijus, I'm not sure if it was addressed in the last couple weeks, but when I last tried to define a perl 6 class whose constructor had named arguments, it didn't work | ||
autrijus | dduncan: minimal example? | ||
dduncan | see Locale::KeyedText::Message | ||
luqui thinks dduncan should write a test case instead ;-) | 07:35 | ||
dduncan | I was under the impression that normally you just define a BUILD submethod, and not a new() ... | ||
autrijus | luqui: nodnod... I think it's a healthy direction (not tied to any static calculus for the moment) but I think the static calculus is still needed -- it has to be very rich and not at all decidable | ||
dduncan | and that named arguments are what the default new() has ... you only explicitly make a new() if you want positional args | ||
luqui | autrijus, does that help us? | 07:36 | |
autrijus | luqui: if we don't have that, we can't capture constraints in module interfaces, and no static analysis can exist in multimodule programs | ||
luqui: and by limiting to a sensible subset in it (via some Types::* framework), the frameworks can provide users with interesting services | |||
like inferrence and whatnot. | |||
luqui | hm... | 07:37 | |
dduncan | but when I declare just a BUILD having named arguments, the argument's value is a Pair | ||
the reason I'm asking you is ... | |||
autrijus | submethod BUILD (Str :$msg_key!, Any :%msg_vars? = hash()) { | ||
} | |||
this one? | |||
luqui | the thing I'm thinking is that the calculus in CLTI is not a subset of F<: | ||
dduncan | when I last brought this matter up, there were opinions raised that the behaviour I expected wasn't what should be done ... someone had a problem with that design idea | 07:38 | |
autrijus, yes | |||
part of the reason I'm bringing it to you is to see what you think the correct behaviour is supposed to be, so I can code to that | |||
autrijus | luqui: p6 already has Ada's "range" constraint types... we can't be a proper subset of F<: anyway | ||
(unless you demote them all to runtime, but I think it's a pity) | 07:39 | ||
my Int where {1..5} $x = 3; | |||
dduncan | I didn't make a test suite because I didn't know if an official decision had been reached about what the correct behaviour is supposed to be | 07:40 | |
luqui | dduncan, it's hard to understand what you're asking | ||
can you write a little code please? | |||
just paste or whatever | |||
autrijus, ah, no, I'm just saying that there are interesting calculi which may not be a subset of ours | |||
autrijus | dduncan: does BUILD work if you call it explicitly? | ||
luqui | which may be okay | ||
it'd be nicer to increase the demand for writing a Types:: module instead... if that is possible | |||
autrijus, i.e. the type system would provide more an interface than a calculus | 07:41 | ||
autrijus | luqui: nodnod... but you can have a calculus that is just collecting annotations and has _no_ static progression rules | ||
luqui | still not quite sure what that would look like though | ||
autrijus | (every thing is deferred to runtime) | ||
luqui | oh | ||
I see | |||
autrijus | so you can typecheck this: | ||
6.{7} = 1.(3) | 07:42 | ||
as there's no static progression) | |||
luqui | autrijus, for example, so that two modues that use parametric types can agree with each other about what they mean | ||
autrijus | yup | ||
luqui | okay, I can see that that might be a necessity | ||
autrijus | once that is in place, I'm going to argue there is still a default static type system that makes 1.(3) not typecheck | 07:43 | |
dduncan | autrijus, I didn't know I could call it explicitly, for some reason, but I could try that ... | ||
autrijus | but we can save that arguement later :) | ||
dduncan | when you say "call it explicitly", do you mean declare a new() that declares bless(), or call BUILD from the outside? | ||
autrijus | call BUILD from outside | 07:44 | |
dduncan | will try ... | ||
luqui | autrijus, well... what I argued in type_meta is that if you have a default, it has to be good | ||
but I guess we're saving that argument until later ;-) | |||
dduncan brb | |||
autrijus | dduncan: nvm, I fixed the bug. | 07:45 | |
luqui: yup... 1.[6.(3)] exceeds my definition of "good by default" :) | 07:46 | ||
meanwhile, can I commit this? | |||
--- notes/type_meta.pod (revision 8551) | |||
+++ notes/type_meta.pod (local) | |||
-Perl 6 has no type system. | |||
+Perl 6 has no single, canonical, static type system. | |||
luqui | sure | ||
it was kind of a shock effect thing, but I suppose I shocked you too much :-) | 07:47 | ||
dduncan | oh, luqui ... | ||
luqui | dduncan, asiiiiiiiii? | ||
dduncan | I just remembered that I *did* write a test case | ||
luqui | cool | ||
dduncan | its the then-new file t/oo/named_parameters_in_BUILD.t, committed on Nov 13th | ||
after I committed this, it was on the list that someone said my expected behaviour was disagreeable | 07:48 | ||
so autrijus, if /oo/named_parameters_in_BUILD.t passes its tests, then my problem is probably fixed | 07:49 | ||
luqui | dduncan, that's, um... I don't remember that | ||
autrijus | dduncan: it should as of r8057 | ||
luqui | but I think the expected behavior is entirely agreeable | ||
I don't see how one could argue otherwise | |||
dduncan | I can check the log to see who disagreed ... | 07:50 | |
autrijus | anyway, it's caused by Prim.hs still using the &infix:=> form instead of the new exploded Syn "named" form | ||
dduncan: | 07:51 | ||
1..2 | |||
ok 1 - BUILD arg declared as named and invoked with literal pair should contain only the pair value | |||
ok 2 - same arg should be of declared type | |||
enjoy :) | |||
dduncan | thank you | ||
luqui | hooray, bugfixes! | ||
autrijus | np... sorry for being away this long :) | ||
dduncan | checking the latest smoke from a couple days ago, that was still broken ... great for the fix | ||
svnbot6 | r8056 | autrijus++ | * Perl 6 does have a strong dynamic type system | ||
r8057 | autrijus++ | * In calling BUILD from BUILDALL, use named arguments instead | |||
r8057 | autrijus++ | of unexploded pair objects. Reported by dduncan. | |||
autrijus | I assure you it was by neccessity and on short notice. :) | ||
dduncan | something else I'll bring up, which may have already been fixed, concerned CATCH blocks not being called | 07:52 | |
luqui | you going to blog about it autrijus? | ||
dduncan | between what autrijus just fixed and that, which I think already had a failing test written by someone else ... | ||
autrijus | luqui: I think I did already | ||
dduncan | those are the main things in the way of the rewritten Locale::KeyedText working properly in perl 6 | ||
luqui | that really abstract blog that I didn't understand? | 07:53 | |
autrijus | luqui: yeah, and the current one talking about financial hell | ||
dduncan: I don't think we even parse CATCH blocks. | |||
luqui | ah right, now I remember | ||
dduncan | CATCH blocks did parse, but they didn't execute | ||
the only way I could check if an exception was thrown was to read $!, like how its done in perl 5 | 07:54 | ||
I can do that as a workaround, but its ugly | |||
autrijus | ?eval CATCH { 1 } | ||
07:54
evalbot_8054 is now known as evalbot_8057
|
|||
evalbot_8057 | Error: No such method: "&CATCH" | 07:54 | |
autrijus | it did not parse :) | ||
?eval BEGIN { 1 } # compare this | |||
evalbot_8057 | 1 | ||
dduncan | if it didn't parse, why was the error not citing bad syntax? | ||
anyway ... | 07:55 | ||
autrijus | maybe it was used in a function application position | ||
luqui | It's trying to execute CATCH(sub { 1 }) | ||
in that case at least | |||
autrijus | I see t/builtins/control_flow/try.t already has tests | ||
dduncan: for now you may have to test $! by hand until someone adds CATCH to ruleClosureTrait in Parser.hs | 07:56 | ||
I can try to help but my pressing priority now is still Roles and .meta | 07:57 | ||
once that's done though, hooking closure traits like CATCH should be much simpler | |||
dduncan | no problem ... at least there IS a workaround | ||
autrijus | nod... whilst with BUILD there was none | ||
dduncan | yes | ||
autrijus | thanks for your persistence as usual :) | ||
I may need to run for a bit... be back in ~15 mins | 07:58 | ||
dduncan | fyi, I think it was Juerd that disagreed with my assumption | ||
luqui | oh, Juerd, that makes sense ;-) | ||
dduncan | see colabti.de/irclogger/irclogger_log/...2005-11-13 , time index 01:34 | 07:59 | |
luqui | oh, that | ||
it was on a larger scale than specific semantics | |||
dduncan | and since he thought that, well it seemed maybe others did | 08:00 | |
luqui | like, oh, say, me | ||
but that was unrelated to the issue | |||
if it does change, it needs to be a major change | |||
dduncan | I'm not sure | ||
luqui | and endorsed by Larry especially | ||
dduncan | actually, you were involved too | 08:01 | |
luqui | yeah, I remember | ||
and I agree with Juerd that the new/BUILD thing is both wrong and overly complicated. but that requires a proposal to fix, not a "this buggy behavior might actually be correct" kind of issue | 08:02 | ||
well, I'm tired. I wanted to go to bed at midnight and it's already 1:00 | 08:03 | ||
dduncan | meanwhile, now that it is fixed, my code written that way in Perl 6, and my mirroring Perl 5 code using Class::Std, can work the same | ||
luqui | g'night. thanks for poking holes in pugs where they need to be poked. | ||
dduncan | good night | 08:04 | |
luqui & | |||
autrijus | re | 08:33 | |
svnbot6 | r8058 | root++ | * My original Chinese name is officially obsolete as of last week. | ||
autrijus | oh wow, "root" | ||
(that's my misuse of svn+ssh -- apologies. fixing) | 08:34 | ||
fixed. | 08:35 | ||
xinming | autrijus: ping | 09:31 | |
:-) | |||
autrijus | xinming: pong | 09:32 | |
xinming | autrijus: what's your Chinese name for now? :-/ | ||
autrijus | xinming: that's a secret :) | ||
xinming | or, are you going to become in hidden mode. :-/ | 09:33 | |
autrijus | no... not really, just disassociating with my past as a notorious poster child for whatever | 09:34 | |
so I can focus on work I like, eg. pugs | |||
xinming | autrijus: well, But your English name still exists. :-P | 09:36 | |
autrijus | you mean the net-id "autrijus"? yeah, that's going to stay around | ||
xinming want to be the first person who knows antrijus' changed name... :-D | 09:37 | ||
autrijus | nah... it's already known by some people :) | 09:38 | |
xinming | could you send me private message to tell me this. :'( | 09:39 | |
autrijus | one day I will, but the day is not today... :) | ||
xinming | .. | ||
Well, Ok. | |||
autrijus | kane_: hey! | 10:03 | |
oops. | 10:04 | ||
kane_ | autrijus! long time no see :) | 10:05 | |
wherabouts are you now? | |||
autrijus | just arrived to .au | 10:06 | |
sorry I missed your msgs... I also just discovered I forgot to identify to nickserv again | |||
kane_ | ah, right... nice weather i hope? | ||
yeah, nickserv is annoying | |||
autrijus | yup, excellent excellent weather | ||
kane_ | did you happen to have a chance to see what happened to S22? | 10:07 | |
autrijus | I've seen the misc/sixpan | ||
does it have something to do with you? | |||
and no, I havn't really read thru it. plan to do so now as part of journaling | |||
kane_ | eh, yeah :) | ||
read the S22, check out hte prototype dir -- that's my code | |||
in short: it'll work | 10:08 | ||
but not on dpkg ;) | |||
autrijus | that... is very reassuring | ||
very rare someone utter that in association with a synopsis/perl6 :) | |||
kane_ | well, i can make shit up as i go along -- no silly syntax problems, no legacy.. it's so much easier :) | 10:09 | |
oh, and this could technically be bolted on to existing p5 infrastructure, if we felt like giving it a good run | |||
dpkg++ # good place to steal ideas from | 10:10 | ||
r0nny | morning | 10:14 | |
autrijus | kane_: excellent... I'll read, sleep on it, and get back :) | 10:15 | |
(going to meet alias tomorrow morning and fly to melbourne) | |||
kane_ | autrijus: okidoki -- have some sleep & fun, we'll talk later | 10:16 | |
autrijus | cool! kane++ | ||
r0nny | autrijus: can u take a look at rafb.net/paste/results/J1QI3k92.html and tell me if im wrong, or the method dispatcher ? | 10:19 | |
autrijus | do you mean that doit should not be able to be called as a subrountine? | 10:21 | |
as $.baz is undef | |||
that is a bug alright, but it's kinda subtle | |||
r0nny | well - it aslo happens, if $baz has a method with the name doit | ||
i had a design, where i had a class with a method, and if u called the method it calles a method with the same name on a attribute, with itself as 2nd param | 10:22 | ||
autrijus | ok, I think I know why | ||
r0nny | it allways ended up in endless loops | ||
why ? | |||
i really want to know | 10:23 | ||
(else im forced to switch to python) | |||
autrijus | ?eval class Foo { has Bar $.bar; method doit { $.bar.doit } } class Bar { method doit { 'bar' } }; Foo.new(bar => Bar.new).doit | 10:24 | |
10:24
evalbot_8057 is now known as evalbot_8058
|
|||
evalbot_8058 | "bar" | 10:24 | |
autrijus | that works | ||
r0nny | btw - does evalbot run on pugs ? | ||
autrijus | yes | ||
?eval class Foo { has Bar $.bar; method doit { $.bar.doit } } class Bar { method doit { 'bar' } }; say Foo.new(bar => undef).doit | 10:25 | ||
so you see, the dispatch is really keyed on the actual runtime type of $.bar | |||
evalbot_8058 | (no output) | ||
r0nny | hat appens, if i dont define the type of bar ? | 10:26 | |
autrijus | it depends on what actually is in it | ||
the bug here is that if it is undef | |||
then it degrades into a call to doit() in the current scope | |||
which is obviously wrong. | |||
but in your design it should not be undef, should it. | |||
(as the first case of my ?eval above) | |||
(and also... give ruby a try before switching to python. :-)) | 10:27 | ||
r0nny | it is never undef | ||
autrijus | can I see some actual code? | 10:28 | |
where it is not undef, that is | |||
r0nny | actually im on rewriting everything | ||
i just deleted my code using it | |||
autrijus | ok | ||
r0nny | but i think a new one will be ready in about 6-7 hours | ||
autrijus | k... I'll check back after I wake up tomorrow morning | 10:29 | |
r0nny | ok | ||
gn | |||
gaal looks at 8058 and wonders if the domain name should perhaps have been eruditorum.org | 10:40 | ||
autrijus | it's obra's domain :) | 10:41 | |
gaal | yeah, I found that out a while ago :-) | 10:42 | |
what is your favorite color? | |||
autrijus | dark purple | ||
gaal | "Autrijus the dark purple" doesn't have quite the same ring to it as "Enoch the Red", but I guess we'll have to make do with that. | 10:43 | |
autrijus | ... | 10:44 | |
I still havn't read anything in that cycle other than cryptonomicon | |||
gaal | I wonder if it's SPJ the (referentially) Transparent | 10:45 | |
autrijus | I'm sure chromatic is chromatic. | ||
gaal | autrijus: I've got them all if you're into speed-reading ;-) | ||
Crypronomicon, of course, is number i in that series. | 10:46 | ||
autrijus | cc2e, with barely 1000 pages, already took me more than a week | ||
I think speed reading is not my forte :) | |||
integral | but CC is rather serious compared to TBC :) | ||
autrijus | I don't know... I flipped thru some of the later TBC tomes | ||
they look serious | |||
or at least seriously long | 10:47 | ||
integral | you don't read on planes/trains much? | 10:48 | |
integral reads another pterry every time he travels | |||
gaal | a friend is really excited about the Aubrey/Maturin series by Patrick O'Brian. They apparently are quite "serious" in the sense that they are impeccably reserached. | ||
autrijus | integral: I do... now that I don't bring laptops into (say) bath, I've got even more slices of time to read | 10:49 | |
gaal: I heard someone saying that wrt Rule of Four. then I read it. a bit underwhelmed. :/ | 10:50 | ||
the pizza is kicking in... I'll be back after a short nap :) | 10:51 | ||
gaal | actually although I really dig Stephenson's writing, this isn't exaclty my favorite genre | ||
gaal makes a wish for pizza | 10:52 | ||
autrijus | I note you read Nobokov... which really really helped, btw. | ||
gaal++ | |||
Nabokov, even | |||
bbiab... & | 10:53 | ||
gaal | bye :) | 10:54 | |
dduncan | good night | 11:17 | |
r0nny | is there a global var, tells if im in debug mode, ot not ? | 11:44 | |
gaal | what's debug mode, r0nny? | 12:40 | |
r0nny | gaal: my app | 13:02 | |
gaal | r0nny: but what is debug mode? afaik we don't have a debugger in pugs yet. in p5 I suppose you could do this: | 14:44 | |
# perl -le 'print "IN DEBUG MODE" if keys %DB::' | |||
Juerd_ | There being something in %DB:: could also mean someone used the include-trick (tnx.nl/include) | 14:47 | |
gaal | wow, that's a dirty hack :) | 14:48 | |
Juerd_ | Dirty but incredibly useful :) | 14:49 | |
It's a shame that this feature can only be accessed this way. | |||
gaal | but so ok, the test above can trivially be fixed to look for one of the expected debugger routines. | ||
r0nny | does anyone know, how the yadayada operaots are done ? | 15:39 | |
eg ..., ??? and !!! | |||
gaal | what do you mean, how they are done? | 15:41 | |
look in Parser.hs, IIRC at the bottom of the file. | |||
r0nny | i want to write a own yadayada operator | 15:42 | |
gaal | ?eval sub castle_of_aaaaaah { !!! } castle_of_aaaaaah() | ||
evalbot_8058 | Error: !!! - not yet implemented | ||
gaal | what do you want it to do? | ||
r0nny | print wich class, wich method , wich instacne class, then exit | 15:43 | |
eh return failure | |||
gaal | ?eval sub XYX { Carp::confess } sub A { B() } sub B { C() } sub C { XYZ() } | 15:44 | |
evalbot_8058 | undef | ||
gaal | grrrr. | ||
?eval sub XYX { say Carp::longmess } sub A { B() } sub B { C() } sub C { XYZ() } | |||
evalbot_8058 | undef | 15:45 | |
gaal | grrrr! | ||
?eval sub XYX { say Carp::longmess() } sub A { B() } sub B { C() } sub C { XYX() } | |||
evalbot_8058 | undef | ||
r0nny | u miss to call one of the subs | ||
gaal | GRRRRR! | ||
?eval sub XYX { say Carp::longmess() } sub A { B() } sub B { C() } sub C { XYX() } A() | |||
evalbot_8058 | Error: No such method: "&Control::Caller::caller" | ||
gaal | wtf!? | ||
r0nny | i think hell foze in an instant | 15:46 | |
hmm | 15:51 | ||
gaal | ?eval sub XYX { say caller() } sub A { B() } sub B { C() } sub C { XYX() } A() | ||
evalbot_8058 | OUTPUT[<obj:Control::Caller> ] bool::true | ||
gaal | ?eval sub XYX { say caller().subname } sub A { B() } sub B { C() } sub C { XYX() } A() | ||
evalbot_8058 | OUTPUT[&main::C ] bool::true | ||
r0nny | ?eval sub XYX { say caller.caller.subname } sub A { B() } sub B { C() } sub C { XYX() } A() | 15:52 | |
evalbot_8058 | Error: No such sub: "&subname" | ||
gaal | you need the () | ||
r0nny | ?eval sub XYX { say caller().caller().subname } sub A { B() } sub B { C() } sub C { XYX() } A() | 15:53 | |
evalbot_8058 | Error: Can't modify constant item: VUndef | ||
r0nny | ?eval sub XYX { say caller().meta } sub A { B() } sub B { C() } sub C { XYX() } A() | ||
evalbot_8058 | Error: No such method: "&meta" | ||
r0nny | darn | ||
gaal | oh and you can't call caller() on the object returned by caller(). | ||
r0nny | is there a way, to get more of the stack ? | ||
gaal | read the source for caller in Prelude.pm. | 15:54 | |
Juerd_ | Yeah, but don't stray to the dark side of the source. | 15:55 | |
gaal | ?eval sub XYX { say caller(skip => 2).subname } sub A { B() } sub B { C() } sub C { XYX() } A() | ||
evalbot_8058 | OUTPUT[&main::A ] bool::true | ||
gaal | when did longmess break, is what I want to know. | 15:56 | |
my fault for not writing a test for it :/ | |||
Juerd_ | Does mess stand for message? | 15:59 | |
We need standard abbreviations. msg, mess, mesg... Too confusing | |||
gaal | yeah. this is unspecced, lifted straight from p5 Carp. | ||
rafl | I guess it stands for messiness | 16:00 | |
gaal | that too | ||
as it loops on caller rather than using some more efficient API. | |||
then again people who need upstacking to be efficient may have other problems. | |||
r0nny | hmm | 16:01 | |
svnbot6 | r8059 | kane++ | * whitespace fixes | 16:05 | |
rafl | kane_: Hello | 16:13 | |
kane_: Do you know a nice p5 module that does the stuff File::Copy::Recursive stuff but with support for patterns? I don't want to clutter up the code for copying the module src to _jib/build to exclude _jib from that.. | 16:15 | ||
Juerd_ | rafl: package Acme::Nice::Module::Copy; sub cpr { system "cp -r @_" } | 16:16 | |
rafl: ;) | |||
gaal | cpr reminds me of Inline::CPR (which is totally cool) | 16:17 | |
rafl | If it comes with a portable cp script.. why not? | ||
gaal | what, Inline::CPR? No, it doesn't :-) | ||
kane_ | rafl: i think you could use File::Find::Rule and add the output to File::Copy | 16:20 | |
rafl: btw, i'm working on JIB::Source now -- to build our source package sfrom a dir (analog to prototype's create.pl) | |||
gaal | kane_: you have to create dirs too. | 16:21 | |
kane_ | doesn't file::copy just Get That? | ||
gaal | I think it doesn't, at least not portably. | ||
rafl | kane_: Oh, I'm as well. Well, maybe commit your's so I can code there as well. | ||
gaal | bbiab& | 16:22 | |
kane_ | rafl: heh.. typical... ok, i'll do an intermediate commit | ||
rafl: btw, i lowercased the methods in config.pm -- seemed more consistent with the rest of the code, i'll submit that too | |||
rafl: btw, the JIB::Meta needs some consistency checks in it too, to make sure the META.info is 'sane' -- if you feel like that, by all means :) | 16:23 | ||
rafl | kane_: First I need to do some work that I get paid for. | ||
kane_ | rafl: np.. i'll hack on source.pm in the meantime | 16:24 | |
commit coming up | |||
svnbot6 | r8060 | kane++ | * lowercase config.pm methods | 16:30 | |
r8060 | kane++ | * add first rendition of source.pm + tests | |||
rafl | kane_: Thanks. | 16:51 | |
kane_: I'll do the Repository stuff next, if you're fine with that. | 16:52 | ||
kane_ | rafl: i am -- i'm adding some utils & constants modules too.. good place to cram stuff (stealing most of it back from CPANPLUS) -- i'll check those in next | 16:53 | |
rafl: oh.. the meta sanity checks also good -- if you find the time/energy of course | |||
rafl | kane_: OK. I'll look into it when I've done my work for monarch. | 16:54 | |
kane_ | ok | ||
svnbot6 | r8061 | kane++ | * add jib::constants & basic tests | 17:00 | |
r8061 | kane++ | * add jib::utils & basic tests | |||
r8061 | kane++ | * add 'build_dir' to config.pm | |||
r8061 | kane++ | * work in progress | |||
r8062 | kane++ | * basic tests for config.pm | |||
r8063 | kane++ | * replace the loc() strings | 17:06 | ||
rafl | kane_: Why do the Utils method start with an underscore? | 17:28 | |
Khisanth | hmm weird | 17:34 | |
make unoptimized takes 46 minutes to fail but "make" succeeds in 29 minutes :/ | |||
kane_ | rafl: internal use only | 17:48 | |
not part of the published API | |||
and i'm hating perl... frigging no decend path manipulation tools | |||
rafl | kane_: I actually like Path::Class. | 17:49 | |
kane_: At least its api. Some things are still missing to make it good enough. | |||
kane_ | it's missing the manipulation though.. or maybe i should say fs manipulation tools | 17:50 | |
like 'mv' and 'cp -R' and 'rm -r' that Just Frigging WOrk on *nix | |||
it takes me 20 lines to do a clever recursive copy | |||
that's just stupid | |||
wheras cp -R does what i need | |||
kane_ ponders jsut leaving the system()'s in for now, and clean it up later | 17:51 | ||
will go Much Faster | |||
SamB | Khisanth: that is peculiar | 17:52 | |
maybe there are tools in the tree that need to be optimized to fit in memory and/or work right? | |||
Khisanth | SamB: seems to be fairly consistent as well | 17:54 | |
SamB | well, this sort of thing does tend towards being that way | 17:55 | |
usually there is one thing that doesn't work quite right if a certain optimization doesn't happen | 17:56 | ||
bsb | kane_: IO::All has $io->all to recurse dir trees | 18:01 | |
Don't know about copying though | |||
kane_ | i got the recursion.. it's the copying | ||
kane_ prays for a good file::copy::recursive | |||
hrmpf | 18:02 | ||
kane_ hates software some more | 18:03 | ||
rafl | kane_: It does some manipulation.. | ||
kane_ | screw it, i'll fix this later | ||
rafl | kane_: $dir->rcopy($dest), etc. | ||
(WRT Path::Class) | |||
clkao | kane! | ||
kane_ | cl, dude! | ||
rafl: /rcopy/ is not mentioned in the path::class docs | 18:04 | ||
rafl | kane_: You're right. The only thing I can find for path manipulation are mkpath and rmtree. | 18:05 | |
kane_ | yeah, this blows... i'll use the old root-* way of building and we'll fix this later | ||
i hate getting stuck on this nonsense for 45 mins becasue perls tools blow :( | |||
gaal | kane_: I assure you, cp is more than 20 lines of code :-) | 18:10 | |
r0nny | re | 18:11 | |
rafl | kane_: I can give a try to fix that. My create.pl equiv was able to copy everything into the right place. | 18:13 | |
kane_ | rafl: good.. i'll check it in with prototype code, and we can just tear out the system()'s one by one | ||
svnbot6 | r8064 | kane++ | * add more deps to makefile.pl | 18:28 | |
r8064 | kane++ | * fail miserably in getting cp -R to work Proper | |||
r8064 | kane++ | * stay with system() calls, remove them later | |||
r8064 | kane++ | * also, i hate perl sometimes | |||
r0nny | i got a problem with the yadayada operator ??? - it exits the program - acording to the docs it just prints a warning | 18:31 | |
anyone can tell me whats up with this ? | 18:33 | ||
kane_ | ?eval print 1 if ??? | 18:37 | |
18:37
evalbot_8058 is now known as evalbot_8064
|
|||
evalbot_8064 | Error: cannot cast from VUndef to Handle (VHandle) | 18:37 | |
kane_ | ?eval if( 1 ) { ??? } | ||
evalbot_8064 | Error: cannot cast from VUndef to Handle (VHandle) | ||
kane_ eyes the bot | |||
r0nny | sub test{???}; test; | 18:39 | |
?eval sub test{???}; test; | |||
evalbot_8064 | Error: cannot cast from VUndef to Handle (VHandle) | ||
wolverian | ?eval ??? | 18:41 | |
evalbot_8064 | Error: cannot cast from VUndef to Handle (VHandle) | ||
wolverian | ?eval !!! | ||
evalbot_8064 | Error: !!! - not yet implemented | ||
r0nny | ?eval ... | ||
evalbot_8064 | *** ... - not yet implemented at <eval> line 1, column 1-4 | ||
r0nny | ?eval sub foo{...};foo | ||
evalbot_8064 | *** ... - not yet implemented at <eval> line 1, column 9-12 | ||
r0nny | darn it | 18:42 | |
eval $?VERSION | |||
?eval $?VERSION | |||
evalbot_8064 | Error: Undeclared variable: "$?VERSION" | ||
r0nny | eval $?V | ||
gaal | ?eval $?PUGS_VERSION | ||
evalbot_8064 | \"Perl6 User\'s Golfing System, version 6.2.10, October 10, 2005 (r8064)" | ||
gaal | please see Run.hs for globals | ||
r0nny | i will do | ||
gaal | kane_: File::Path has a mkpath function. | 18:44 | |
kane_ | it's recursive copying with exclusion i want | ||
but thanks for trying :) | |||
gaal | yes, i was referring to _mkdir | ||
kane_ | it calls, under the hood: eval { File::Path::mkpath($args->{dir}) }; | 18:45 | |
it's just a wrapper to DTRT and handle errors | |||
gaal | oh. | ||
r0nny | btw - is there a global is set, when compiling ? | ||
gaal | r0nny: explain? | 18:46 | |
kane_: what do you want a recursive copy to do? you mentioned "exclusion"...? | |||
r0nny | if i coampile, i want to include the stuff usually is loaded based on runtime-determined variables | ||
kane_ | in shell speak, along the lines of cp -R source_dir destination_dir, where source_dir has been grep -v'd for a pattern | 18:47 | |
like no txt files or so | |||
gaal | kane_: rcopy($from, $to, Rule $except?) { ... } ? | 18:48 | |
is the filter applied deeply as well? | 18:49 | ||
kane_ | yes | ||
in our case, it's 'dont copy one particular subdir somewhere in the tree' | |||
gaal | oh. but what if a file with the same name exists somewhere else? | 18:50 | |
a regex would not be enough. looks like you need your own visitor. | |||
kane_ | i can do the filtering with file::find::rule | ||
just the -R doesn't do the right thin any more on cp or anything else | |||
gaal | then what's missing? | ||
kane_ | but rafl said he had some code that worked, so hopefully that does the trick | ||
gaal | ok. | ||
kane_ | the implicit mkdir -p for one | ||
gaal | r0nny: sorry, I don't understand | 18:51 | |
kane_ | and the mkdir'ing of hte basename, rather than the whole path you feed it | ||
and stuff like that | |||
gaal | kane_: I must have written this a few times in the past. :-) | ||
r0nny | gaal: when i conpile, i want to include all modules could be needed, while if i run it, i just want to use these are actually needed | 18:52 | |
gaal | r0nny: so you want something like AUTOLOAD that possibly loads additional modules? | ||
...but which are forced-loaded when precompiling | 18:53 | ||
r0nny | yeah | ||
gaal | ah, now I understand the "global" you were asking about. | ||
r0nny | how to do this ? | ||
gaal | I don't think this is specced anywhere, since the perlrun stuff hasn't been specced. | 18:54 | |
r0nny | :/ | ||
then my build system will be very slow | 18:55 | ||
gaal | as a workaround, not very neat, you can check %*ENV in a BEGIN block. | ||
and conditionally load things if sometihng like IS_PRECOMPILING is set. | |||
that'd be your applicative env flag, though. | 18:56 | ||
r0nny | hmm | ||
gaal | this can be made into a module fairly easily, the question is what interface to give it. Ask p6-l maybe? | 18:59 | |
r0nny | hmm | ||
maybe i should wait, till binary modules are suppported | 19:00 | ||
btw - kane_ what will be used for binary module building | |||
kane_ | r0nny: in what regard? | 19:01 | |
r0nny | sixpan | ||
kane_ | no binary modules on sixpan | 19:02 | |
r0nny | hmm | 19:03 | |
then what willbe used on the client to compile them ? | |||
rafl | The Perl Compiler? *duck* | ||
kane_ | r0nny: Some Build Tool (tm) | ||
package manager ne build tool | |||
r0nny | kane_: mind if i contribute the default build tool ? | 19:04 | |
kane_ | knock yourself out -- that would be the replacement of EU::MM/Module::Build | ||
you might wanna take it up with those guys for the guts | |||
r0nny | hmm | ||
kane_ doesn't know much about the ev0l of building modules | 19:05 | ||
r0nny | EU::MM ? | ||
long name ? | |||
kane_ | ExtUtils::MakeMaker -- current 'default' installer for perl5 | 19:06 | |
the JIB code (sixpan pm) will invoke 'a' build tool with certain arguments at certain times.. what happens next is up to the buildtool, etc | |||
r0nny | hmm | 19:07 | |
kane_ | the end result of what hte buildtool should do is install thigns in a target directory which it should treat as /..f rom there, JIB takes over again | 19:08 | |
r0nny | hmm | ||
my build tools default is to create a directory wich contains everything needed to copy to / to install the thing | |||
kane_ | that's pretty much what i said | 19:09 | |
only difference would be is that we say 'here is that dir' rather than you making one up :) | |||
r0nny | my tol will be happy to eat your preferences | 19:10 | |
but atm its not mature enough | |||
rafl | kane_: Everything commited by now? I'd like to leave now and hack on my way. | ||
kane_ | no, much hacking in progress | ||
i got $src->biuld working, so we have .jibs now | |||
doing JIB::Installation next, so we can do $src_pkg install as well | 19:11 | ||
r0nny | jibs ? | ||
kane_ points r0nny at the S22 draft | |||
rafl | When do you expect to be done so I can pull it and leave? | ||
kane_ | hopefully within the hour | ||
provided no stupid perl things annoy me :) | |||
you can pull now though, and just remember i'm hacking on those 2 sections :) | 19:12 | ||
i'll just commit something that's save then | |||
rafl | OK. I hope the WLAN at $rafls_destination hasn't changed its WEP key again. :-) | ||
kane_ | just committed | 19:13 | |
Committed revision 8065. | 19:14 | ||
that should be fairly safe | |||
kane_ finds hacking stuff in and leaving lots of XXX markers speeds things up :) | |||
19:15
_SamB_ is now known as SamB
|
|||
svnbot6 | r8065 | kane++ | * rework config.pm to be mutable | 19:15 | |
r8065 | kane++ | * add a few config settings from prototypes _inc.pl | |||
r8065 | kane++ | * add more tests for config.pm | |||
r8065 | kane++ | * add a conf.pl to be loaded at the beginning of a test to set up the environment | |||
rafl | kane_: Thanks. | ||
r0nny | Module::Build is fun - unfortunately is supports only perl | ||
rafl | kane_: Hm... acceleration X's :-) | ||
kane_ | rafl: exactly.. im just taking our prototype and throwing it in a good API | ||
the guts will need fixing up then obviously | |||
rafl | Indeed. | 19:17 | |
Bye! | |||
r0nny | kane_: are u going to support multiple build systems ? | 19:18 | |
kane_ | r0nny: yes | ||
r0nny | sweet | ||
plz tell me, if its ready | 19:19 | ||
kane_ | ok | 19:20 | |
r0nny | i want my system to fit from the beginning | 19:21 | |
btw - how are u doing the depency solving ? | 19:22 | ||
kane_ | there's a dependency engine -- i suggest you read the S22 draft, it explains a lot | 19:24 | |
r0nny | hmm | 19:27 | |
i'd say add llvm support, and then allow bytecode modules | 19:28 | ||
kane_ | what are you talking about? | 19:29 | |
r0nny | right - forgot to mention the context | 19:30 | |
i'd like to see a distribution, where the users can load bytecode modules, are faster loaded - and since llvm supports this for c-bits and reachs native speed it would be very usefull | 19:32 | ||
kane_ | sounds great... do it :) | 19:34 | |
r0nny | omg - im allmost on my limits with studying, the build system and the os | 19:35 | |
how could i possibly get llvm support into perl6 | 19:36 | ||
kane_ | dunno... persuade someone else to do it then.. just dont look at me :) | ||
r0nny looks at kane_ with the "who else coud do" eyes | 19:37 | ||
kane_ | package manager > bytecode imho | ||
kane_ points at his just 2 hands | |||
r0nny | i could give u some others - i know much people only need one ;P | 19:38 | |
svnbot6 | r8066 | kane++ | * remove loc() strings | ||
kane_ | ok, now you're just freaking me out | 19:39 | |
r0nny puts another "freaked-out-person" stamp on his wall | 19:40 | ||
svnbot6 | r8067 | kane++ | * add a .jib file for testing | 19:56 | |
r8067 | kane++ | * add work in progress install code to package.pm | |||
r8067 | kane++ | * remove loc() string from constants | |||
r8067 | kane++ | * add installation.pm & tests to use for query local installation information | |||
Alias_ | .jib? | 20:01 | |
DesreveR | hmm | ||
jesus is back | |||
20:02
DesreveR is now known as r0nny
|
|||
kane_ waves in the general direction of S22 once more :) | 20:02 | ||
r0nny | ;P | ||
r0nny hands kane a wave-mashine | |||
svnbot6 | r8068 | kane++ | * get basic install working jib::package | 20:14 | |
Khisanth | hmm yaht.kwid | 21:18 | |
kane_: where is the perldoc program that can actually parse S22draft.pod? | 21:19 | ||
r0nny | Khisanth: usually its part of the perl5 dist | 21:24 | |
Khisanth | hmm this version handles it but someone what having problems with some of the directives | 21:25 | |
r0nny | hmm | 21:26 | |
21:52
Lopo_ is now known as Lopo
|
|||
venk | attach irc.perl.org | 22:38 | |
autrijus | the "nap" turns out to be 13 hours :/ | 22:57 | |
wolverian | it's good for you :) | 22:59 | |
goo looks really neat, I just can't figure out how to use it | 23:00 | ||
if anyone has tips, please do share :) | |||
autrijus runs to airport to meet Alias | 23:08 | ||
Khisanth | goo? | 23:09 | |
use Goo; splatter "wolverian"; ? | 23:10 | ||
wolverian | see thegoo.org/about.html, particularly the tour | 23:18 | |
(and the LPW slides, too.. they're on the LPW site I believe.) | 23:19 | ||
Khisanth damns the , | |||
wolverian | sorry :) |