6.2.10 released! xrl.us/hxnb | geoffb's column (/. ed): xrl.us/hxhk | pugscode.org | pugs.kwiki.org | paste: sial.org/pbot/perl6 | www.geeksunite.net Set by autrijus on 10 October 2005. |
|||
eric256 | ?eval 3e5.perl | 00:03 | |
evalbot_7621 | "300000/1" | ||
eric256 | ?eval (3e5.5).perl | ||
evalbot_7621 | Error: unexpected "." expecting digit, "_", term postfix, operator or ")" | ||
eric256 | ?eval (3/5).perl | ||
evalbot_7621 | "3/5" | ||
mrborisguy | does pugs use the Perl6 Prelude right now? (src/perl6/Prelude/PIR.pm) | 00:09 | |
dolmen | ?eval (3eR).perl | 00:11 | |
evalbot_7621 | Error: unexpected "e" expecting digit, "_", "-", "+", exponent, term postfix, operator or ")" | ||
dolmen | ?eval (3e5).perl | ||
evalbot_7621 | "300000/1" | ||
dolmen | ?eval (3e5/5).perl | ||
evalbot_7621 | "60000/1" | ||
dolmen | ?eval (3e5/1).perl | ||
evalbot_7621 | "300000/1" | ||
mrborisguy | ?eval eval_parrot( "I0 = 8\nprint IO" ); | ||
evalbot_7621 | Error: No compatible subroutine found: "&eval_parrot" | ||
dolmen | ?eval (3e5/Inf).perl | 00:12 | |
evalbot_7621 | "0.0" | ||
dolmen | ?eval (1/Inf).perl | ||
evalbot_7621 | "0.0" | ||
mrborisguy | or does the Prelude just not really do anything right now? | ||
dolmen | sorry, don't know | 00:13 | |
?eval (Inf ^ 2).perl | |||
evalbot_7621 | "(2 ^ Inf)" | ||
dolmen | ?eval (Inf ^^ 2).perl | ||
evalbot_7621 | "bool::false" | ||
dolmen | ?eval true | ||
evalbot_7621 | Error: unexpected end of input expecting term | ||
dolmen | ?eval bool::true | 00:14 | |
evalbot_7621 | bool::true | ||
dolmen | ?eval bool::true.perl | ||
evalbot_7621 | Error: unexpected "p" expecting block construct, ":", term, term postfix, operator, postfix conditional, postfix loop, postfix iteration, ";" or end of input | ||
dolmen | ?eval (bool::true).perl | ||
evalbot_7621 | "bool::true" | ||
eric256 | yes it uses the prelude | ||
its compiled during make | |||
dolmen | ?eval (4 ^ 2).perl | ||
evalbot_7621 | "(2 ^ 4)" | ||
dolmen | ?eval (4 ^^ 2).perl | ||
evalbot_7621 | "bool::false" | ||
eric256 | ?eval (4**2).perl | ||
evalbot_7621 | "16/1" | ||
dolmen | ?eval (4 ^^ 4).perl | ||
evalbot_7621 | "bool::false" | ||
dolmen | what is ^ ? | 00:15 | |
?eval (4 ^^ 4/bool::true).perl | |||
evalbot_7621 | "bool::false" | ||
dolmen | ?eval (4 ^^ 4/7).perl | ||
evalbot_7621 | "bool::false" | ||
dolmen | ?eval bool::true + 2 | 00:16 | |
evalbot_7621 | Error: No compatible subroutine found: "&bool::true" | ||
dolmen | ?eval (bool::true) + 2 | ||
evalbot_7621 | 3.0 | ||
mrborisguy | dolmen: don't have a perl6 of your own to test on? :D | ||
dolmen | no | ||
sorry | |||
scook0 | dolmen: ^ is a one() junction | ||
?eval ?( (1 ^ 2 ^ 3) == 1 ) | 00:17 | ||
evalbot_7621 | bool::true | ||
scook0 | ?eval ?( (1 ^ 1 ^ 3) == 1 ) | ||
evalbot_7621 | bool::false | ||
mrborisguy | dolmen: I don't care if you do... but you can ask Juerd for an account on feather.perl6.nl too | 00:24 | |
he gives 'em out so you can play with p6 | |||
that's what I do | |||
Juerd | mrborisguy: dolmen left 2 minutes before you said that. | 00:33 | |
eric256 | quite today...except for me and dolmen blabbing to ourselves | 01:24 | |
lol | |||
luqui | blabbing to evalbot you mean | 01:25 | |
eric256 | yea, not sure thats much better though | ||
luqui | well, we get to see the weird behavior you recover, like: | 01:26 | |
?eval bool::false / 2 | |||
evalbot_7621 | 0.0 | ||
luqui | er, oh! | ||
/ binds tighter than ^^, of course, so that stuff that dolmen did makes sense | 01:27 | ||
putter | hey folks | 01:28 | |
luqui | hi putter | ||
scook0 | hey putter | ||
eric256 | hola | ||
putter | as dolmen just observed, bool::true/false have parsing issues currently. | 01:29 | |
?eval (0 ?? bool::false !! 0) | |||
evalbot_7621 | Error: unexpected ")" expecting "x", "d", octal digit, "o", "b", digit, fraction, exponent, term postfix, operator, ":", "," or "!!" | ||
putter | ?eval (0 ?? (bool::false) !! 0) | ||
evalbot_7621 | 0 | ||
luqui | ?eval 0 ?? bool::false() !! 0 | 01:30 | |
evalbot_7621 | 0 | ||
luqui | the arity of bool::true/::false is not known at compile time | ||
eric256 loves how putter shows up knowing stuff that happened before he came in. lol | |||
luqui | that's my guess at least | ||
putter | I was so happy I got error line numbers working well when I hit that... :) (new p5 backend) | 01:31 | |
scook0 | yeah, I don't think 0-ary subs are treated specially by the parser atm | ||
luqui | ?eval sub foo() { "hello" } say foo 1 | ||
evalbot_7621 | Error: unexpected "1" expecting "(", term postfix, operator, ":", ",", postfix conditional, postfix loop, postfix iteration, ";" or end of input | ||
putter | re happening, colabti.de/irclogger/irclogger_logs/perl6 is your friend... | ||
luqui | no, I think they are | ||
eric256 | i know putter, its still funny | 01:32 | |
putter | :) | ||
?eval sub foo(){say "hi"} (1 ?? foo !! 0) | 01:33 | ||
evalbot_7621 | hi bool::true | ||
scook0 | I guess they are then | 01:34 | |
putter | iblech: from a few? days ago: eval() should be working in PIL-Run. :lang<perl6> and :lang<perl5> at least. Not yaml or haskell. | 01:37 | |
scook0 | (oh, now I see where they're handled) | 01:39 | |
putter | autrijus: is there a calendar time estimate on when pil2 might be available? | 01:44 | |
scook0 | stevan__: ping # quick note re: 'metaclass' | 01:47 | |
eric256 | ?eval ((1 =>2)).perl | 01:48 | |
evalbot_7621 | "(1 => 2)" | ||
eric256 | ?eval eval(((1 =>2)).perl).perl | ||
evalbot_7621 | "(1 => 2)" | ||
putter | after burning more hours than I'd like to think about doing a p5 backend overhaul, mostly writing things which will be trashed the minute pil2 exists, I'm reminded of my conviction that pil2 is a prerequisite for doing a real p5 backend. | ||
not that one cant do without. witness pil2js. but since the target is oo, you either approach things the NotRightWay(tm), like PIL-Run, or spend hours like water trying to fake around pil1. | 01:49 | ||
eric256 | "spend hours like water" ... ? | ||
putter | lots of it goes by and the scene looks quite unchanged | 01:50 | |
;) | |||
eric256 | lol. okay | ||
putter | ach. /me is just a wee bit frustrated at the moment. | 01:51 | |
eric256 | any specific? | 01:53 | |
eric256 watches as a feathers build process passes my local one started 15min earlier. lol | |||
putter | one of those exercises where things are clearly converging, so you keep on making the "ok, continue just a little bit more, rather than switching to other things" (eg, rules engine). but time estimates keep getting blown, so variance grows to the point of uselessness. "done sometime between this evening and next year". and you look back and realize the hours spent could have bought much more useful things. :/ | 01:56 | |
stevan__ | scook0: pong # what about metaclasses? | 01:57 | |
eric256 | as long as you learn something from the hours spent then it was worth it. ;) i try to view everything as a learning experience...even things that i know i could have done better in hind site | ||
stevan__ can only ask, then backlog ,.. sorry :) | 01:58 | ||
scook0 | stevan__: please don't equivocate 'metaclass' and 'class metaobject' | ||
it's just that it's really confusing | |||
ideally, I'd like 'class metaobject' to be an object, and a 'metaclass' to be the class of that object | 01:59 | ||
just a suggestion | |||
eric256 's mind is going to turn to jello if he hears meta, class and object used ever agian. ;) | |||
putter | eric256: true. knew someone who treated major life disasters with a "I will put whatever effort needed looking, because there damn well better be something good in here proportional to the pain!". ;) even worked sometimes. :) | 02:00 | |
hey stevan__ | 02:01 | ||
eric256 | arg...stepped on tack strip in the carpet and it totaly chewed up my foot...stupid tack strips | ||
putter | ouch | 02:02 | |
eric256 | big wholes and blood.. is this pugs EVER going to finish compiling!! | ||
putter | stevan__: any thoughts on why Chaos's sub ::opaque_instance_attr : lvalue (line 40) might sometimes blow out with a Not an ARRAY reference? no doubt I'm abusing it, but I wondered if you'd seen the symptom before. tnx | 02:04 | |
eric256 | ?eval :b(1).perl | 02:08 | |
evalbot_7621 | "(\"b\" => 1)" | ||
eric256 | ?eval ("b" => 1).perl | 02:09 | |
evalbot_7621 | "(\"b\" => 1)" | ||
eric256 | ?eval :b(1).ref | ||
evalbot_7621 | ::Pair | ||
putter | ?eval sub f(*%h){} f:a() | ||
evalbot_7621 | undef | ||
putter | ?eval sub f(*%h){say %h} f:a() | 02:10 | |
evalbot_7621 | a1 bool::true | ||
putter | ?eval sub f($x,*%h){say "$x--",%h} f:a(6) | ||
evalbot_7621 | Error: Undeclared variable: "$x" | ||
putter | ?eval sub f($x,*%h){say "$x--",%h} f:a (6) | ||
evalbot_7621 | 6--a1 bool::true | ||
putter | ?eval sub f($x,*%h){say "$x--",%h} f:a(3)(6) | 02:11 | |
evalbot_7621 | 6--a3 bool::true | ||
putter | ?eval sub f($x,*%h){say "$x--",%h} f(6):a | 02:12 | |
evalbot_7621 | 6--a1 bool::true | ||
putter | ?eval sub f($x,*%h){say "$x--",%h} f(6) :a | ||
evalbot_7621 | Error: unexpected ":" expecting operator, postfix conditional, postfix loop, postfix iteration, ";" or end of input | ||
eric256 | ?eval sub x (@a) { for @a { print } }; x(1=>2); | ||
evalbot_7621 | Error: Insufficient number of required parameters: 0 actual, 1 expected | ||
eric256 | any idea how to fix that putter? | ||
putter | hmm... | ||
luqui | ?eval sub x (*@a) { for @a { print } } x(1 => 2) | ||
evalbot_7621 | undef | ||
luqui | ?eval sub x (*@a) { say +@a } x(1 => 2) | 02:13 | |
evalbot_7621 | 0 bool::true | ||
eric256 | ?eval sub x (@a) { @a.perl.say; for @a { print } }; x(1=>2); | ||
evalbot_7621 | Error: Insufficient number of required parameters: 0 actual, 1 expected | ||
eric256 | ?eval sub x (Pair @a) { @a.perl.say; for @a { print } }; x(1=>2); | ||
evalbot_7621 | [(1 => 2)] undef | ||
putter | "fix" as in workaround? my fuzzy impression is Pair handling is currently a bit kludgy. | ||
eric256 | nah i have a work around. just though maybe you would have a real fix | ||
putter | my fuzzy understanding is real fix is thought to consist of language spec change and non-trivial changes to pugs | 02:15 | |
eric256 | gotcha...just seemed like since adding Pair fixed it, there might be an easier fix | ||
?eval { a => [1,2,3] }.perl | 02:16 | ||
evalbot_7621 | "\{(\"a\" => [1, 2, 3])}" | ||
eric256 | ?eval ~{ a => [1,2,3] } | 02:17 | |
evalbot_7621 | "a\t1 2 3\n" | ||
putter | my fuzzy recollection is there were a bunch of autrijus commit messages "drat, that didnt work, backing out" re Pairs. so easy seems unlikely. ;) | 02:18 | |
eric256 | lol. alright | ||
?eval ~{ a => [1,2,3] }.perl.eval | |||
evalbot_7621 | "a\t1 2 3\n" | ||
putter | it's also worth trying pugs -Bjs with stuff like this. pil2js has quite a few 'unexepected successes' on tests. | 02:20 | |
eric256 | ?eval ~{ :a(1), :b(2), :c(3) } | 02:21 | |
evalbot_7621 | "a\t1\nb\t2\nc\t3\n" | ||
eric256 | ?eval { :a(1), :b(2), :c(3) }.perl.eval.perl | ||
evalbot_7621 | "((\"a\" => 1), (\"b\" => 2), (\"c\" => 3))" | ||
putter | wont help with parsing or compilation problems, but sometimes the js runtime works better | ||
eric256 | ?eval ~{ :a(1), :b(2), :c(3) }.perl.eval | ||
evalbot_7621 | "a\t1 b\t2 c\t3" | ||
eric256 | ?eval { :a(1), :b(2), :c(3) }.perl | ||
evalbot_7621 | "\{(\"a\" => 1), (\"b\" => 2), (\"c\" => 3)}" | ||
eric256 | how come evaling that returns a list? | 02:22 | |
putter | not a list, a hash, no? | ||
eric256 | ?eval eval("\{(\"a\" => 1), (\"b\" => 2), (\"c\" => 3)}" ).perl | 02:23 | |
evalbot_7621 | "((\"a\" => 1), (\"b\" => 2), (\"c\" => 3))" | ||
eric256 | ?eval { a => 1 }.perl | ||
evalbot_7621 | "\{(\"a\" => 1)}" | ||
eric256 | ?eval { a => 1 }.perl.eval.perl | ||
evalbot_7621 | "\{(\"a\" => 1)}" | ||
eric256 scratches head | 02:24 | ||
?eval { :a(1) }.perl.eval.perl | |||
evalbot_7621 | "\{(\"a\" => 1)}" | ||
eric256 | ?eval { :a(1) }.perl | ||
evalbot_7621 | "\{(\"a\" => 1)}" | ||
eric256 | ?eval { :a(1), :b(2) }.perl | ||
evalbot_7621 | "\{(\"a\" => 1), (\"b\" => 2)}" | ||
eric256 | ?eval { :a(1), :b(2) }.perl.eval.perl | ||
evalbot_7621 | "((\"a\" => 1), (\"b\" => 2))" | ||
eric256 | see? or am i crazy? | 02:25 | |
?eval { :a(1), :b(2) }.ref | |||
evalbot_7621 | ::Hash | ||
eric256 | ?eval { :a(1), :b(2) }.perl.eval.ref | ||
evalbot_7621 | ::Array | ||
eric256 | ?eval "{(\"a\" => 1), (\"b\" => 2)}".eval.ref | ||
evalbot_7621 | ::Array | ||
putter | ?eval { :a(1), :b(2) }.perl.eval | ||
evalbot_7621 | (("a" => 1), ("b" => 2)) | ||
eric256 | ?eval "hash {(\"a\" => 1), (\"b\" => 2)}".eval.ref | ||
evalbot_7621 | ::Scalar | ||
eric256 | ?eval "hash ((\"a\" => 1), (\"b\" => 2))".eval.ref | 02:26 | |
evalbot_7621 | ::Scalar | ||
putter | ?eval my $x = { :a(1), :b(2) }.perl.eval; $x | ||
evalbot_7621 | [("a" => 1), ("b" => 2)] | ||
eric256 | parse error? or pretty print error? | 02:27 | |
putter | that does seem excessively listy | ||
eric256 | ?eval "{(a => 1), (b => 2)}".eval.ref | ||
evalbot_7621 | ::Scalar | 02:28 | |
eric256 | ?eval "\{(a => 1), (b => 2)}".eval.ref | ||
evalbot_7621 | ::Array | ||
luqui | ?eval { :a(1) :b(2) }.perl | ||
evalbot_7621 | Error: unexpected ":" expecting term postfix, operator, postfix conditional, postfix loop, postfix iteration, ";" or "}" | ||
putter | remember { is now magic in strings | ||
eric256 | ?eval {(a => 1), (b => 2)}.ref | ||
luqui | ?eval { :a(1), :b(2) }.perl | ||
evalbot_7621 | ::Block | ||
"\{(\"a\" => 1), (\"b\" => 2)}" | |||
putter | ?eval '{(a => 1), (b => 2)}'.eval.ref | ||
evalbot_7621 | ::Array | ||
luqui | ?eval { :a(1), :b(2) }.perl.say | ||
eric256 | i think luqui has it | ||
evalbot_7621 | {("a" => 1), ("b" => 2)} bool::true | ||
putter | ?eval '\{(a => 1), (b => 2)}'.eval.ref | ||
evalbot_7621 | ::Block | ||
eric256 | ?eval "{\{(a => 1), (b => 2)}}".eval.ref | 02:29 | |
evalbot_7621 | ::Str | ||
eric256 | hmmm | ||
putter | ?eval "{say 'hi'}" | ||
evalbot_7621 | hi "1" | ||
luqui | ?eval { :a(1), :b(2) }.perl.eval | ||
eric256 | ?eval '\{(a => 1), (b => 2)}'.eval.ref | ||
evalbot_7621 | (("a" => 1), ("b" => 2)) | ||
::Block | |||
luqui | ?eval { :a(1), :b(2) }.perl.say | 02:30 | |
evalbot_7621 | {("a" => 1), ("b" => 2)} bool::true | ||
eric256 | or not.... i dunno. something wierd is happening | ||
luqui | ?eval eval '{("a" => 1), ("b" => 2)}' | ||
evalbot_7621 | (("a" => 1), ("b" => 2)) | ||
luqui | ?eval \eval '{("a" => 1), ("b" => 2)}' | ||
evalbot_7621 | [("a" => 1), ("b" => 2)] | ||
luqui | weird | ||
the braces are just disappearing | |||
eric256 | can't seem to eval *anything* into a hash.... | 02:31 | |
luqui | ?eval {("a" => 1), ("b"=>2)} | ||
evalbot_7621 | (("a" => 1), ("b" => 2)) | ||
luqui | there we go | ||
?eval my $x = {("a" => 1), ("b"=>2)}; $x | |||
evalbot_7621 | \sub {...} | ||
luqui | OH! | ||
Got it | |||
eric256 | ?eval { :a(1) }.perl | ||
evalbot_7621 | "\{(\"a\" => 1)}" | ||
luqui | its the parentheses | ||
eric256 | ?eval { :a(1) }.perl.eval.perl | ||
evalbot_7621 | "\{(\"a\" => 1)}" | ||
luqui | ?eval { a => 1 }.ref | ||
evalbot_7621 | ::Hash | ||
luqui | ?eval { (a => 1) }.ref | 02:32 | |
evalbot_7621 | ::Hash | ||
luqui | what? | ||
I thought I got it | |||
eric256 | lol | ||
luqui | ?eval { (a => 1), (b =>1) }.ref | ||
evalbot_7621 | ::Block | ||
luqui | there we go | ||
eric256 | ?eval '\{a => 1, b => 2}'.eval.ref | ||
evalbot_7621 | ::Hash | ||
eric256 | you were right | ||
;;) | |||
luqui | only if the top level of a {} has a pair is it considered a hash | ||
putter | ?eval { a => 1, (b =>1) }.ref | ||
evalbot_7621 | ::Hash | ||
putter | ?eval { (a => 1), b =>1 }.ref | 02:33 | |
eric256 goes off to fix it...hopefully | |||
evalbot_7621 | ::Block | ||
eric256 | thanks luqui | ||
luqui | hang on eric256 | ||
it may not be broken | |||
eric256 | arg....my stupid putty screen to feather | ||
it is. its failing the tests for pretty printing and then evaling | |||
luqui | oh right | ||
eric256 | when printing a hash it can't make them pairs | ||
luqui | but how do you intend to fix it? | ||
oh, you could kill the parens on output | 02:34 | ||
eric256 | dunno yet, haven't looked at the printing for hashes yet | ||
luqui | ?eval { a => 1, b => 2 }.perl.say | ||
evalbot_7621 | {("a" => 1), ("b" => 2)} bool::true | ||
luqui | make that say { "a" => 1, "b" => 2 } | ||
eric256 | yep | ||
putter | :) | ||
eric256 | do you know how to turn off line wraps in vi? | 02:35 | |
luqui | yeah, let me look at my .vimrc (I've done it) | ||
set nowrap | |||
eric256 | hmmm could hashes be being printed by the list routine? | 02:38 | |
luqui | where are the braces coming from? | 02:39 | |
eric256 | damn...found them...hmmm | ||
is a hash truly a list of pairs? | 02:41 | ||
scook0 | by the way, I'm currently looking into demagicalizing pairs | ||
eric256 | and is there anyother way to force { into a hash? | ||
?eval '\{, (a => 1), (b => 2)}'.eval.ref | 02:42 | ||
evalbot_7621 | ::Scalar | ||
eric256 | ?eval '\{ (a => 1), (b => 2)}'.eval.ref | ||
scook0 | I have a mostly-complete patch, but I'm running into trouble with primitives | ||
evalbot_7621 | ::Block | ||
eric256 | ?eval '\{+ (a => 1), (b => 2)}'.eval.ref | ||
evalbot_7621 | ::Block | ||
eric256 | ?eval '\{, (a => 1), (b => 2)}'.eval.ref | ||
evalbot_7621 | ::Scalar | ||
eric256 | oh yea..just tried that. lol | 02:43 | |
stevan__ | scook0: I would prefer not metaclass at all | ||
scook0: I think classes should be instances of Class (note the uppercase) | |||
eric256 | hash is treated as a list of pairs, so there is no easy way to drop the paran's....but if there is another way to force it into a hash i could handle that. | ||
?eval 'hash { (a => 1), (b => 2)}'.eval.ref | |||
evalbot_7621 | ::Scalar | ||
eric256 | ?eval '\hash { (a => 1), (b => 2)}'.eval.ref | ||
evalbot_7621 | ::Scalar | ||
stevan__ | the meta stuff just makes things more confusing | ||
scook0 | stevan__: as in, no distinction between a 'class', and the metamodel-object that represents it? | ||
stevan__ | yes | ||
why should there be | 02:44 | ||
xinming | Hi, all, Now I am in ZheJiang... back... :-P | ||
stevan__ | we need to throw out the C++/Java notion that a class is anything special | ||
eric256 | ?eval 'hash ( (a => 1), (b => 2))'.eval.ref | ||
evalbot_7621 | ::Scalar | ||
scook0 | yes, but if $Larry *insists* on separating classes and objects, then 'class meta-object' is a better term | ||
eric256 | ?eval 'hash ( (a => 1), (b => 2))'.eval.perl | ||
evalbot_7621 | "undef" | ||
eric256 | ?eval 'hash { (a => 1), (b => 2)}'.eval.perl | ||
evalbot_7621 | "undef" | ||
scook0 | that was my main point--overall, I probably prefer dropping the distinction | ||
eric256 | ?eval { (a => 1), (b => 2)}.perl | ||
evalbot_7621 | "sub \{...}" | ||
eric256 | ?eval hash ( (a => 1), (b => 2)).perl | 02:45 | |
evalbot_7621 | Error: cannot cast from VUndef to Handle (VHandle) | ||
eric256 | ?eval hash( (a => 1), (b => 2)).perl | ||
evalbot_7621 | "\{(\"a\" => 1), (\"b\" => 2)}" | ||
eric256 | ahhh... ;) | ||
stevan__ | I think $Larry needs to see how powerfull non-seperated class/object is | ||
eric256 | ?eval 'hash( (a => 1), (b => 2))'.eval.perl | ||
evalbot_7621 | "\{(\"a\" => 1), (\"b\" => 2)}" | ||
eric256 | sweet | ||
stevan__ | but for now, I need to go watch a movie with my wife :) | ||
stevan__ & | |||
eric256 | luqui .. that look about right to you? | ||
luqui | eric256, are you going to output as a hash()? | ||
eric256 | i was thinking about it | 02:46 | |
down side? | |||
luqui | not as pretty | ||
eric256 | i'm open to suggestions | ||
luqui | can you keep the parens off the pairs? | ||
eric256 | working++ > pretty-- ;) | ||
luqui | eric256, of course | ||
eric256 | no | ||
luqui | ?eval (a => 3).perl | ||
evalbot_7621 | "(\"a\" => 3)" | ||
eric256 | i can't, someone else might be able to | ||
luqui | have any leads? | 02:47 | |
eric256 | or provide some other signal to the parser that its a hash and not a block | ||
luqui | hash() is probably good for now | 02:48 | |
eric256 | well for now i'll do that. ;) | ||
objections? | |||
hearing non, eric heads out to break...i mean fix output. ;) | |||
(return $ ("hash(":(init (tail str))) ++ ")") | 02:51 | ||
putter | :) | ||
good night & | |||
eric256 | i'm reading something wrong on that line | ||
later | |||
putter | good luck | ||
eric256 | i don't know what the : is doing...anyone know haskell? | 02:56 | |
scook0 | eric256: : is cons | 02:57 | |
PerlJam | eric256: The } is cons | ||
er, : | |||
eric256 | ahhh. dunno how i forgot that ;) | ||
do you see an error there then? | 02:58 | ||
perlbot nopaste | |||
perlbot | Paste your code here and #<channel> will be able to view it: sial.org/pbot/<channel> | ||
scook0 | I think you might need to try getting rid of some parens, so it's easier to read | ||
pasteling | "eric256" at 24.8.74.230 pasted "parse error." (6 lines, 238B) at sial.org/pbot/13708 | 02:59 | |
PerlJam | I agree with that. Too many parens remind me of lisp | ||
lisp is fine for a computer to read, but the excessing regularity is annoying to this human. | |||
scook0 | eric256: is it supposed to be returning a string, or a list of strings? | ||
eric256 | i thought a string, but now i think its a list of strings | 03:00 | |
scook0 | return $ "hash(" ++ (init $ tail str) ++ ")" | ||
eric256 | thats the way it was already, i didn't do any of that except the hash( opart | ||
scook0 | eric256: what file/line? | 03:01 | |
eric256 | Prim.hs 1363 | ||
trying yours there... looks like its going to make it...dunno what it will look like ;) | 03:02 | ||
scook0 | eric256: you replaced a single-char '{' with a string "hash(" | ||
eric256 | i don't understand why they are abusing str like that | ||
yea | |||
scook0 | which means (:) is no longer what you need | ||
try (return $ "hash(" ++ (init $ tail str) ++ ")") | |||
eric256 | : was just a cheap way of joining strings? | ||
lol | |||
PerlJam | eric256: it's a "cheap" way of constructing lists of atomic things. | 03:03 | |
scook0 | (:) only works for adding a single character (element) to the start of a string (list) | ||
PerlJam | eric256: in haskell, a string is already a list | ||
scook0 | once you start joining two strings (lists), you need (++) | ||
eric256 | yea i just forgot what i knew..lol | 03:04 | |
?eval "hash((\"1\" => 2))".eval.perl | |||
evalbot_7621 | "undef" | ||
PerlJam | eric256: "hello" == 'h':'e':'l':'l':'o':[] ( I think, it's been a while since I've hacked haskell) | ||
eric256 | ?eval "hash((1 => 2), 2)".eval.perl | ||
evalbot_7621 | "\{(\"1\" => 2), (\"2\" => undef)}" | ||
eric256 | ?eval "hash((1 => 2))".eval.perl | ||
evalbot_7621 | "undef" | ||
eric256 curses agian. lol | |||
scook0 | PerlJam: that's correct | ||
eric256 | fixed the output...but it doesn't work anyway. lol. i thought i tested that | 03:05 | |
?eval "hash((1 => 2), (3=>4))".eval.perl | |||
evalbot_7621 | "\{(\"1\" => 2), (\"3\" => 4)}" | ||
eric256 | ?eval "hash( (1 => 2) )".eval.perl | 03:06 | |
evalbot_7621 | "undef" | ||
scook0 | does anyone know how named-args get passed to primitives (specifically Object::new)? | ||
eric256 | ?eval hash( (1 => 2) ) | ||
evalbot_7621 | Error: cannot cast from VUndef to Handle (VHandle) | ||
eric256 | ?eval hash( 1 => 2 ) | ||
evalbot_7621 | Error: cannot cast from VUndef to Handle (VHandle) | ||
eric256 | ?eval hash( 1 => 2, 3 => 4 ) | ||
evalbot_7621 | {("1" => 2), ("3" => 4)} | ||
eric256 | hash is broken too?? | ||
magical pairs are cursing me agian arn't they? | 03:07 | ||
scook0 | &hash is a bit of a hack at the moment | ||
PerlJam | Hmm. Last time I looked hash(1=>2) complained about an odd number of elements. I'm guessing someone has been working on hash()? | 03:08 | |
scook0 | PerlJam: `hash {}` still complains | 03:09 | |
PerlJam | yeah, I was just looking at Eval.hs | 03:10 | |
All those "bloody hacks" need an application of haskell-fu | 03:11 | ||
eric256 was trying. ;) well actualy mine are probably more on the hackish side. but i'm trying to work on my haskell-fu | |||
PerlJam | eric256++ keep it up. | 03:12 | |
eric256 | ahhh...single item...hmmm | 03:14 | |
looking at Eval.hs | |||
Khisanth | well hopefully it won't have a hairier core than p5 :) | ||
eric256 | no way for it to know that one item is a pair is there? if there is that would/should be a simple fix to add | 03:15 | |
of course 3 pairs should still work. | |||
could we just let hash assume the best? | |||
Khisanth | that doesn't sound good | 03:16 | |
eric256 | well you should still get an error if it doesn't realy produce a hash. just not as early | ||
hmmm...silently assumes last odd key has an undef value. not sure thats a feature | 03:18 | ||
lol | |||
?eval { 1,2,3}.perl | |||
evalbot_7621 | "sub \{...}" | ||
eric256 | ?eval { 1 => 2,3}.perl | ||
evalbot_7621 | "\{(\"1\" => 2), (\"3\" => undef)}" | ||
eric256 | same behavior as that if you drop the warning | ||
no comments? | 03:20 | ||
seems like drop the error and add the error in the actual hash compisition | |||
?eval "\\{ 1, 2}" | 03:22 | ||
evalbot_7621 | "\\1 2" | ||
eric256 | ?eval "\\{ 1, 2}".perl | ||
evalbot_7621 | "\"\\\\1 2\"" | ||
eric256 | ?eval '\\{ 1, 2}'.perl | ||
evalbot_7621 | "\"\\\\\\\{ 1, 2}\"" | ||
eric256 | ?eval \\{ 1, 2}.perl | ||
evalbot_7621 | Error: unexpected "\\" expecting program | ||
eric256 | ?eval '\\{ 1, 2}'.eval.perl | 03:23 | |
evalbot_7621 | "\\sub \{...}" | ||
scook0 | autrijus: ping # in a call to &Object::new, when/where do the named/positional args get segregated? | 03:29 | |
stevan | scook0: are you asking about pugs, or perl6 in general | 03:30 | |
scook0 | stevan: pugs internals | ||
stevan couldn't find a good movie to watch | |||
scook0: ahh, can't help you there | 03:31 | ||
03:31
Supaplex is now known as linuxmammal,
linuxmammal is now known as Supaplex
|
|||
stevan | scook0: re: meta junk | 03:33 | |
scook0 | stevan: yeah? | 03:34 | |
stevan | if the entire meta-model can sit "on top" of the core interpreter | ||
then it can be much more flexible | |||
this requires that Class (uppercase, proper noun) is accessible and usable in the same way Object is | |||
just having .meta is probably not enough | |||
but then again, if you just put Class at the other end of .meta it is probably okay too | 03:35 | ||
I think Larry has some really interesting ideas, my issue is that I want to understand them within the context of some meta-model | |||
s/meta/object/ | 03:36 | ||
eric256 | hmmm its doing something special droping the first and last character in Prim.hs .... for some reason that must get called twice on the same bit? seems like a bit of a hack to drop the first and last letter and add your own though../me searches more | ||
stevan | I based the current model heavily on CLOS because CLOS was built from the start to be able to encompass the behaviors of some of the other LISP Object systems out there at the time | 03:37 | |
since p6 should interact with (at least) p5, and (at most) Python & Ruby, I thought going down this road would be a the right direction | 03:38 | ||
in the end if you call it meta, that is fine, but it is my hope that the terminology will just be "names" and nothing more | |||
scook0 | stevan: the only point I was really trying to make | 03:39 | |
was that *iff* classes and objects are distinct kinds of entities | |||
stevan | hey nothingmuch :) | 03:40 | |
nothingmuch | morning | ||
scook0 | then if you want a term for "the representation of a class in object-space" | ||
stevan | morning | ||
scook0 | nothingmuch: hi | ||
eric256 | hey nothingmuch | ||
scook0 | then that term should be "class metaobject" rather than "metaclass" | ||
eric256 | nothingmuch: do you know much about the Pretty printing ? | ||
nothingmuch | the pretty printing of what? | ||
stevan | scook0: In my mind, Class and Object are no different from Foo and Bar | 03:41 | |
eric256 | .perl | ||
nothingmuch | oh | ||
no clue at all | |||
stevan | Class is an instance of Class, and Class is a subclass of Object | ||
eric256 | figured it was worth a shot. lol | ||
scook0 | stevan: I personally subscribe to that view | ||
nothingmuch has some stupid macho friends | |||
they got slightly drunk | 03:42 | ||
and we drove this girl home on the way | |||
stevan | scook0: my goal for the near future is to get Larry to subscribe to that as well :) | ||
nothingmuch | all the time she was in the car they were shouting crap at the top of their lungs trying to impress her | ||
the moment she got out, they became quiet | |||
then one of them got a call from girlfriend, and they talked with her friend | 03:43 | ||
shouting again | |||
scook0 | stevan: I think in Larry's mind, none of Class, Object or Foo are 'proper' objects | 03:44 | |
stevan | scook0: well I think he is seeing them as Roles of some kind | ||
scook0 | so what you think of as Class, Object and Foo, he thinks of as Class.meta, Object.meta and Foo.meta | 03:45 | |
i.e. he's making the distinction between class and class-metaobject explicit | |||
whereas you don't believe there's value in that distinction | |||
stevan | scook0: my guess is that he is thinking of Class, Object, etc as being creatures of the interperter | ||
and that they need some kind of Perl6 space facade, which is where the Roles come in | 03:46 | ||
but I might be reading too much into it | |||
nothingmuch | anyway, off to bed, lambdacamels | ||
scook0 | nothingmuch: bye | ||
stevan shouts at nothingmuch | |||
stevan takes the dog out, be right back | 03:48 | ||
eric256 | i'm missing something obvious...must be...or it could be the fact that there are 15 different coding styles in a language i'm just starting to learn. ;) | 03:53 | |
luqui | eric256, you mean about haskell? | 03:56 | |
eric256 | pugs source code in haskell | ||
luqui | it's not that you're missing something obvious | ||
it's that you're missing fifty subtle things all at once | |||
that's learning haskell... | |||
eric256 | hehe yea i've noticed that already | ||
going...duh thats a sub right there it just looks like an assignment lol | |||
whole new way of thinking | 03:57 | ||
luqui | yep | ||
have you just played with ghci? | |||
eric256 | yep | ||
and walked through a tutorial | |||
;) nothing like hands on though | |||
prettyVal d v@(VRef r) = do | |||
what does the @ mean there? | |||
luqui | oh, that's just (v = (VRef r)) | 03:58 | |
so you're extracting the r inside VRef, but still referring to the whole VRef as v | |||
eric256 | so why would the sub then refer to both the v and the r? | ||
oh wait i think i get it | 03:59 | ||
scook0 | eric256: for .perl-ifying hashes, have you tried `hash list (1=>2)`? | ||
eric256 | scook..hard part is i can't get it to ouput right yet | ||
cuts off parts of hash( ) | |||
scook0 | it just avoids having to write `let v = (VRef r)` | ||
eric256 | or doubles it up...ended up with hash(ash(1 => 2)) a couple times | ||
scook0 | eep | 04:00 | |
eric256 | lol | ||
yea | |||
scook0 | eric256: I wonder if that's related to the (init $ tail str)? | 04:01 | |
eric256 | definitly is...but removing the init $ tail just makes it stop working at all and returns undef....dunno why | 04:02 | |
so there is something subtle going on. i just have to figure out what ;) | |||
prettVal d v@(VRef r) is being called on the value twice as it is being printed..i think. :) | 04:03 | ||
but i don't know where or why | |||
luqui | (init $ tail str) takes off the first and last character of str | ||
eric256 | yea | ||
scook0 | my guess is that it's trying to remove redundant parens or braces | 04:04 | |
eric256 | yea...but its doing it while adding them....why remove them and then add? | 04:05 | |
remove parens while adding brackets...could be | |||
scook0 | seems most likely | ||
eric256 | but its also removing redundant brackets.... | ||
scook0 | maybe the pretty-prenting of a hash (not hashref) has parens | ||
so the pretty-print of a hashref takes that, removes parens, and adds braces instead? | 04:06 | ||
eric256 | and hashref uses it, but removes the parens to add brackets | ||
yea that seems to follow the code there | |||
scook0 | exactly | ||
eric256 | okay...now to use this new knowledge ;) | ||
thanks. you have to think completely different in haskell...thats hard | |||
not like learning VB or C++ or javascript...totaly differnt | 04:07 | ||
scook0 | eric256: it's not as though the program itself is easy, though | ||
if you were doing something equivalently complex in C++, you probably would have given up by now :) | |||
eric256 | probably. i hate c++. lol | 04:09 | |
hmm broke something agian. ... wonder what. | 04:12 | ||
how do i have svk undo all local changes? | 04:13 | ||
nm found it | |||
eric256__ | any idea why if i changed something and it broke something else, then i changed it back and remade...the break didn't go away? do i need to always perl Makefile.PL ? | 04:29 | |
luqui | eric256__, weird | 04:40 | |
i think it depends on what you changed... | |||
no, nevermind | 04:41 | ||
you should never have to Makefile.PL unless you rearrange files | |||
eric256__ | i commented out the # of elements check in Eval.hs and then pugs started returning undef for all hashrefs...so i uncommented it and recompiled but it still did it. | 04:42 | |
luqui | that was the only change you did between recompiles? | 04:43 | |
eric256__ | yep | 04:44 | |
commented, make, tested, uncommented, make, tested | |||
before the comment it worked, after both tests failed | 04:45 | ||
luqui | very strange | ||
don't know what to tell you | |||
eric256__ | hehe. i thought i'd done something wrong, thats why i revereted all files. didn't help | ||
well it di, it started working right. but then when i tried agian same thing happened | |||
like it wasn't noticing my change toe Eval.hs | 04:46 | ||
lol or i'm stupid | |||
lol. interactive pugs doesn't print the value | |||
you ahve to {1=>5}.perl.say; | |||
blah | |||
thats an hour of life wasted | 04:47 | ||
luqui | :-/ | ||
luqui had a similar experience | |||
I was debugging one of my modules for two hours only to find that the error was due to an error in the .t | |||
PerlJam | luqui: always check both sides of the equation :) | 04:48 | |
eric256__ | hmmm.. works fine. except for loop seems to do something realy strange | 04:59 | |
?eval my @t = (1, {1=>2} ); for @t {$_.perl.say;} | |||
evalbot_7621 | \1 {("1" => 2)} undef | ||
eric256__ | ?eval my @t = (1, 1=>2 ); for @t {$_.perl.say;} | ||
evalbot_7621 | \1 Error: Insufficient number of required parameters: 0 actual, 1 expected | ||
eric256__ | ?eval my @t = (1, hash(1=>2) ); for @t {$_.perl.say;} | ||
evalbot_7621 | Error: cannot cast from VUndef to Handle (VHandle) | ||
eric256__ | ?eval my @t = (1, hash(1=>2) ); for Any @t {$_.perl.say;} | ||
evalbot_7621 | Error: cannot cast from VUndef to Handle (VHandle) | ||
eric256__ | ?eval my @t = (1, hash(1,2) ); for Any @t {$_.perl.say;} | 05:00 | |
evalbot_7621 | Error: Pattern match failure in do expression at src/Pugs/Eval.hs:419:4-12 | ||
eric256__ | ?eval my @t = (1, hash(1,2) ); for @t {$_.perl.say;} | ||
evalbot_7621 | \1 {("1" => 2)} undef | ||
eric256__ | why is that \1?? its a ref to it? | ||
luqui | a ref to 1 | ||
luqui dunnos why | |||
eric256__ | hmmm. so if you have a hashref in an array, then $_ ends up being a ref to a ref?... explains the odd behaviour at least. | 05:01 | |
?eval hash( hash( 1, 2) ).perl | |||
evalbot_7621 | Error: cannot cast from VUndef to Handle (VHandle) | ||
eric256__ | hehe. things start to make a sick kind of sense...why they coded it the way they did | 05:02 | |
luqui | ?eval hash( a => hash( b => c ) ) | 05:08 | |
evalbot_7621 | Error: cannot cast from VUndef to Handle (VHandle) | ||
luqui | ?eval hash( a => hash( b => 'c' ) ) | ||
evalbot_7621 | Error: cannot cast from VUndef to Handle (VHandle) | ||
eric256__ | whole thing is screwy . lol | ||
luqui | yeah | ||
I've been wanting to port some of my modules to perl 6 | 05:09 | ||
but then I start and I run into these bugs. it's very frustrating | |||
pugs is not very good with nested data strucutures... at all | |||
?eval hash( a => 'b' ) | 05:10 | ||
evalbot_7621 | Error: cannot cast from VUndef to Handle (VHandle) | ||
luqui | umm, I swear that used to work | ||
eric256__ | ?eval hash( a , 'b' ) | ||
luqui | ?eval hash( a => 'b' ).perl | ||
evalbot_7621 | Error: cannot cast from VUndef to Handle (VHandle) | ||
eric256__ | arg. wish escape wouldn't close the window | ||
?eval hash(1,2) | 05:11 | ||
evalbot_7621 | {("1" => 2)} | ||
luqui | ?eval hash('a', 'b') | ||
evalbot_7621 | {("a" => "b")} | ||
luqui | ?eval hash('a' =>'b') | ||
evalbot_7621 | Error: cannot cast from VUndef to Handle (VHandle) | ||
eric256__ | it sees it as a pair and a single element. dunno why evalbot isn't catching the warning though | ||
luqui | ?eval hash('a' =>'b', 'c') | 05:12 | |
evalbot_7621 | {("a" => "b"), ("c" => undef)} | ||
luqui | ?eval hash('a' =>'b', 'c', 'd', 'e' => 'f') | ||
evalbot_7621 | {("a" => "b"), ("c" => "d"), ("e" => "f")} | ||
eric256__ | i'm confused...how can a hashref be pointing to a hashref? shouldn't a hashref have to point to the hash itself? | 05:14 | |
or all refs that point to a hash in the end considered a hash?.....arg. | 05:15 | ||
luqui | what do you mean a hashref pointing to a hashref | ||
is there somewhere you are looking | |||
eric256__ | when i do that for loop thing...right now i wrap hashrefs in hash( ) instead of { } | 05:16 | |
inside a for loop it becomes | |||
hash ( hash ( ) ) | |||
only way i can get there in the code is if there is a ref (of type hash) pointing to a ref (of type hash)... | 05:17 | ||
luqui | ... for Any @t ? | ||
maybe the reftype code dereferences until it finds something that is not a ref | 05:18 | ||
(just guessing here) | |||
?eval (\\\1).ref | |||
evalbot_7621 | Error: unexpected "\\" expecting expression | ||
luqui | ?eval (\ \ \1).ref | 05:19 | |
pasteling | "eric256" at 24.8.74.230 pasted "pugs> my @t =(1, {2=>2}); for" (5 lines, 91B) at sial.org/pbot/13709 | ||
evalbot_7621 | ::Int | ||
luqui | yeah, like that | ||
?eval \ \ \ 1 | |||
evalbot_7621 | \1 | ||
eric256__ | hmmm | 05:20 | |
well that presents a problem. lol | |||
but it explains what they did...gonna sleep on this. i think there might be an easy way around it. | |||
luqui | perhaps | ||
maybe autrijus will be around when you get back | 05:21 | ||
so he can guide you | |||
eric256__ | i'm assumeing that if there is a way to jump to the final type that you could also jump to a final value. at least i know alot more than 4 hours ago | ||
luqui is meaning to get back into pugs hacking at some point | 05:22 | ||
thanks for inspiring me | |||
eric256__ | hehe thanks for the help. feel free to fix this if you can figure it out! i just picked tests that were failing and started. ;) | ||
later | |||
luqui | later | 05:23 | |
mrborisguy | anybody know the story on 'src/perl6/Prelude/PIR.pm' ? | 05:28 | |
does it somehow get included, or is it just there for the future? | 05:29 | ||
luqui | you could grep the source | 05:34 | |
mrborisguy | to be honest, I don't even know where to start looking. src/Pugs ? | ||
runinshine | Is the source of Pugs Hashell? | 05:36 | |
mrborisguy | runinshine: yeah, Haskell | ||
runinshine | I don't understand it , can you give me some advise? | 05:38 | |
mrborisguy | you don't understand what? Haskell? | 05:39 | |
you don't understand Perl6? | |||
scook0 | runinshine: did you have a question before? | 05:57 | |
runinshine | yeah | 05:58 | |
who can give me some advice of learning the Hashell ? | 06:00 | ||
luqui | go to #haskell and ask where to start | 06:01 | |
give them your background as a programmer | |||
runinshine | thanks | 06:02 | |
Khisanth | haskell looks very nice and appealing, just need to find something to do with it! :) | ||
scook0 | Khisanth: like writing a Perl 6 implementation! :P | 06:03 | |
Khisanth | well I mean personally | 06:04 | |
runinshine | why is it suitable for writing the implementation of Perl6? | ||
mrborisguy | scook0: the problem with starting to write a Perl 6 implementation is that it's not really a good place for the beginner | 06:05 | |
scook0 | mrborisguy: *grin* | ||
mrborisguy | I tried to learn a little Haskell this summer, and I can do some stuff in it, but I poked around in the internals, and I'm clueless! | 06:06 | |
(although, it might help if I knew what each file was trying to accomplish :D) | |||
scook0 | mrborisguy: well, don't hesitate to ask | ||
luqui | runinshine, because that's what autrijus wrote it in | ||
scook0 | not everybody has to figure it out the hard way | ||
luqui | :-) | ||
mrborisguy | true, true. | 06:07 | |
sometimes I think... just give me something to hack away on for a while until I figure it out, maybe I could help | 06:08 | ||
but I never know what... any ideas? | |||
luqui | the high numbers of :todo<bug>s in .t | 06:09 | |
er, t/ | |||
scook0 | attention: anyone who uses alternative backends | 07:03 | |
I have a patch that demagicalizes pairs/named-args in the Parser and the normal Haskell runcore | 07:04 | ||
but it will almost certainly break named-args in the various backends | |||
luqui | scook0, cool | 07:08 | |
svnbot6 | r7622 | scook0++ | * Abracadabra, shalakazam, demagicalize pairs! | ||
r7622 | scook0++ | (This will probably break all the other backends.) | |||
r7622 | scook0++ | * A few minor style/readability tweaks | |||
luqui | scook0++ | 07:09 | |
(3 isn't enough) | |||
scook0 | luqui: it *almost* passes the entire test suite | ||
(except for a few cases that are really caused by other parser bugs) | |||
but, as I said, it will break the other backends :( | |||
luqui | how come | ||
did you change PIL? | |||
scook0 | luqui: no--that's why they'll break | 07:10 | |
luqui | oh... | ||
scook0 | I added (Sym "named"), which the compiler won't recognise | ||
luqui | I see | ||
well, it had to be done sometime | |||
scook0 | but, it's possible to temporarily undo the parser changes with a one-line fix | 07:11 | |
(basically, I have a 'named' combinator that wraps around the parsers for pairs) | |||
if you replace that combinator's definition with "id", named-pairs get parsed as normal pairs again | |||
by the way, did somebody check in some tests for demagicalized behaviour? | 07:12 | ||
I seem to remember someone adding some, but I might have imagined it | 07:13 | ||
luqui | ?? | ||
luqui will grep and then add if not | |||
did you use the semantics from the recent p6l thread? | |||
that is foo(a => b) # named foo((a => b)); # normal pair | 07:14 | ||
scook0 | luqui: yeah | ||
but not everything works: e.g. `foo.(:a)` is broken | |||
because of a bug in `foo.()` parsing | 07:15 | ||
luqui | Retrieving log information from 7119 to 7622 # it's been a while | ||
a day or two ;-) | 07:16 | ||
gaal | kolibrie: pong | ||
luqui | we'll catch up to parrot pretty soon here | ||
scook0_ | urk, net troubles :( | 07:17 | |
luqui | ?eval sub foo($x) { say $x } foo(x => 4) | 07:18 | |
evalbot_7622 | 4 bool::true | ||
luqui | ?eval sub foo($x) { say $x } foo((x => 4)) | ||
evalbot_7622 | x4 bool::true | ||
luqui | woot | ||
?eval sub foo($x) { say $x.ref } foo((x => 4)) | |||
evalbot_7622 | Pair bool::true | ||
luqui | ?eval sub foo($x) { say $x.ref } my $p = (x => 4); foo($p) | 07:19 | |
evalbot_7622 | Pair bool::true | ||
luqui | ?eval sub foo($x) { say $x.ref } my $p = (x => 4); foo(*$p) | ||
evalbot_7622 | Array bool::true | ||
luqui | ?eval sub foo($x) { say $x.ref } my %p = (x => 4); foo(%p) | ||
evalbot_7622 | Hash bool::true | ||
luqui | ?eval sub foo($x) { say $x.ref } my %p = (x => 4); foo(*%p) | ||
evalbot_7622 | Array bool::true | ||
luqui | scook0_, didn't do the splat? | ||
i.e. the remagicalizing operator | |||
scook0_ | luqui: I don't think hash-splat ever worked before | 07:20 | |
luqui | fair enough | ||
scook0_ | luqui: are you writing tests, or shall I start some? | 07:25 | |
luqui | I was updating pugs | 07:30 | |
but I shall start writing tests now | |||
scook0_, looks like there are already tests in t/syntax/pairs.t | 07:32 | ||
scook0_ | iblech++ # demagicalized pair tests | 07:34 | |
luqui | how do I praise and not always see my own name with svk? | 07:35 | |
07:36
scook0_ is now known as scook0
|
|||
scook0 | luqui: you don't happen to know the exact syntax of sub calls wrt where you can put adverbs, do you? | 07:38 | |
(I'm writing parse-tests for various sub-call forms) | 07:39 | ||
Aankhen`` | foo($bar, :baz :quux) | ||
coral | . | 07:40 | |
ww | |||
scook0 | I'm just wondering about these sorts of things: | 07:41 | |
foo:adv()($arg) # probably not | |||
Aankhen`` | I agree with the comment. :-) | ||
scook0 | foo():adv | ||
foo() :adv # with space | |||
Aankhen`` | Those last two are probably possible. They'd need to be for operators which take adverbial modifiers, e.g.: 1..10 :by(2) | 07:42 | |
scook0 | foo(:alfa :bravo $arg :charlie :delta):echo :foxtrot | ||
Aankhen`` | Of course, I'm out of the loop, so I could be dead wrong. | ||
I believe you can't put a positional parameter in the middle of a bunch of named parameters... | 07:43 | ||
scook0 | maybe I'll write up a big list of all the corner cases, and send it to p6l | ||
foo(:adv $arg) | |||
Aankhen`` | Positional parameters before named parameters! | 07:44 | |
foo($arg, :adv); | |||
foo $arg, :adv; # dunno about this | |||
scook0 | Aankhen``: I think that should work too | 07:45 | |
luqui | Aankhen``, I'm trying to kill that | ||
not sure what Larry thinks | |||
Aankhen`` | OK. | ||
scook0 | it's not really necessary any more | ||
luqui | he's wanted "zones" for a while, but that may have been his implementation-head, which the demagicalized pairs proposal destroyed | ||
Aankhen`` | But if you kill it, what happens to operators that can take adverbial modifiers? | ||
scook0 | now that named-arguments can be determined statically | 07:46 | |
luqui | Aankhen``, what do you mean? | ||
they still exist | |||
Aankhen`` | They're not affected? | ||
luqui | no | ||
scook0 | Aankhen``: he was talking about "Positional parameters before named parameters!" | ||
Aankhen`` | Ah, I see. | ||
scook0 | not your example | ||
luqui | ohh | ||
scook0 | foo $arg, :adv; # should work | 07:47 | |
Aankhen`` spanks his lag. | |||
scook0 | just like: foo $arg, adv=>1; | ||
and as a matter of style, mixing named and positional args is still bad news | 07:48 | ||
luqui | maybe | ||
scook0 | but it no longer needs to be illegal, from an implementation POV | 07:49 | |
luqui: i.e. foo($pos, :named, $pos, :named) | |||
luqui | foo 1, 2, 3, :parallel, { big block of code } | ||
it's an endweight thing | |||
gaal | Hey Aankhen``, long time no moose. | ||
Aankhen`` | Hiya gaal. :-D | ||
scook0 | luqui: yes, your particular example was good | 07:50 | |
putter | a quick log check before sleep yields... | ||
scook0 | which is why it's nice that they don't need to be illegal | ||
but things like *my* example should be frowned upon by P6 style guides | |||
luqui | yeah probably | ||
putter | on adverbs, re "# probably not", remember rx:perl5// rx:x(4)// etc. | ||
scook0 | putter: but in the case of rules, you can choose your own delimiters | 07:51 | |
with sub calls, you're stuck with parens | |||
luqui | putter, those are for quoters though | ||
putter | hmm.... | ||
scook0 | foo:adv<>($arg) # illegal ? | ||
Aankhen`` ponders the perverseness of whoever termed these things delimiters. | |||
luqui | I think so | ||
scook0 | foo :adv .($arg) # insane? | 07:52 | |
putter | ;) | ||
luqui | s/\./,/ and it should work | 07:53 | |
but for a very different reason :-) | |||
putter | ok. quoters, good point. good night & | ||
Aankhen`` | Quoters? | 07:55 | |
Nah. | |||
Delimiters is the right word. It's just a strange word. :-) | |||
luqui | "quoter" speaking about the rx part, not the //, which are delimiters | 07:56 | |
Aankhen`` | Ah, I see. I overcompensated for my lag, then. | ||
wolverian | Juerd, ah, thanks. | 08:33 | |
iblech | scook0++ # demagicalizing pairs | 11:40 | |
scook0: I'm fixing Pugs.Compile and then PIL2JS currently | |||
svnbot6 | r7623 | iblech++ | Pugs.Compile: Compile the new Syn "named". scook0++ for demagicalizing pairs! | 11:43 | |
r7624 | iblech++ | * t/syntax/pairs.t: Per | 12:46 | ||
r7624 | iblech++ | www.nntp.perl.org/group/perl.perl6....age/23532, the keys of | |||
r7624 | iblech++ | syntactical pairs should get stringified. | |||
r7624 | iblech++ | * PIL2JS: Demagicalized pairs! | |||
r7624 | iblech++ | * libjs/PIL2JS.js: For now, special PIL2JS.NamedPair class -- named pairs | |||
r7624 | iblech++ | are no longer PIL2JS.Pairs, but PIL2JS.NamedPairs. | |||
r7624 | iblech++ | * libjs/PIL2JS.js, PIL::*: s/pairs/namedpairs/ where appropriate. | |||
r7624 | iblech++ | * PIL::PApp, PIL::PVal: Efficient &Pugs::Internals::named_pair. | |||
r7624 | iblech++ | * P6 Prelude::JS: | |||
r7624 | iblech++ | * *$normal_pair evaluates to a magical pair. | |||
r7624 | iblech++ | * Enabled code for *%hash (was always there, but because of a small | |||
r7624 | iblech++ | oversight not used). | |||
r7624 | iblech++ | * This means PIL2JS passes 16/17 of pairs.t! (And the single failing test | |||
r7624 | iblech++ | is because of Pugs.Parser, not PIL2JS). Hurray for demagicalized pairs :)) | |||
scook0 | iblech: which pairs.t test-fail is caused by Parser? | 13:05 | |
iblech | scook0: foo @array => 42 -- this doesn't get a Syn "named" | 13:06 | |
scook0: (It's the last test of pairs.t) | 13:07 | ||
scook0 | now that I check...I don't think *any* pairs that don't have a bareword on the lhs get parsed properly | ||
iblech | yep, the all seem to get converted into &infix:Ā«=>Ā»($lhs,$rhs) | 13:08 | |
scook0 | seems the rule I'm using only matches the bareword variant | ||
other ones are probably matched using normal operator parsing | 13:09 | ||
iblech | ah, yes, makes sense | ||
svnbot6 | r7625 | scook0++ | * More sub-call parse tests | 13:16 | |
r7626 | iblech++ | t/syntax/pairs.t: More tests: | 13:28 | ||
r7626 | iblech++ | * :a is a named, but (:a) is pair. | |||
r7626 | iblech++ | * $arrayref => ... should stringify $arrayref (but ($arrayref => ...) should not). | |||
eric256__ | what do demagicalized pairs by us? | 13:59 | |
?eval sub x (@y) { @y.perl.say }; @y( x=> 2); | 14:01 | ||
evalbot_7626 | Error: Undeclared variable: "@y" | ||
eric256__ | ?eval sub x (@y) { @y.perl.say }; @x( x=> 2); | ||
evalbot_7626 | Error: Undeclared variable: "@x" | ||
eric256__ | ?eval sub x (@y) { @y.perl.say }; x( x=> 2); | ||
evalbot_7626 | Error: Insufficient number of required parameters: 0 actual, 1 expected | ||
eric256__ | ?eval sub x (@y) { @y.perl.say }; x( (x=> 2) ); | ||
evalbot_7626 | [("x" => 2)] bool::true | ||
eric256__ | ?eval sub x (*@y) { @y.perl.say }; x( x=> 2 ); | 14:02 | |
evalbot_7626 | [] bool::true | ||
eric256__ | ?eval sub x (*@y) { @y.perl.say }; x("test", x=> 2 ); | ||
evalbot_7626 | ["test"] bool::true | ||
eric256__ | ?eval sub x (Pair *@y) { @y.perl.say }; x("test", x=> 2 ); | ||
evalbot_7626 | ["test"] bool::true | ||
eric256__ | ?eval "hello".trans("h" => "t"); | 14:03 | |
evalbot_7626 | "hello" | ||
eric256__ | you broke trans!!! | ||
;) | |||
?eval "hello".trans(( "h" => "t" )); | |||
evalbot_7626 | "hello" | ||
eric256__ | ?eval "hello".trans( ("h" => "t") ); | ||
evalbot_7626 | "hello" | ||
eric256__ | hmmm | ||
?eval "hello".trans( (h => "t") ); | 14:04 | ||
evalbot_7626 | "hello" | ||
iblech | eric256__: Demagicalized pairs are extremele important. In short: foo(bar => $baz) does now always pass $baz by the name "bar" to &foo. foo((bar => $baz)) does now always pass the pair (bar => $baz) positionally to &foo. foo($pair) does now always pass $pair positionally to &foo, even if $pair happens to contain a Pair object. | ||
eric256__ | gotcha...so how would we get trans( Str $self; Pair *@intable) to always take a list of pairs and not named parameters? | 14:05 | |
iblech | eric256__: Consider you wrote a generic subroutine, sub foo ($thing) { ...; bar($thing); ... }. Your &foo would probably break if somebody passed a pair to &foo, as this pair would get intepreted as a named arg by &bar. | 14:06 | |
eric256__ | right. i understand, i think. ;) | 14:07 | |
iblech | Larry meant we should use <== (so "hello".trans(<== "h" => "t", ...), IIUC) | ||
eric256__ | but how do i say, my sub doesn't accept named args so take named args as a list of pairs? | ||
iblech | Or we have to add parens around each pair ("hello".trans((a => "b"), (c => "d"))) | ||
eric256__ | okay thats what i was wondering | ||
i wonder why the parns aren't working right now though. | 14:08 | ||
?eval "hello".trans( (h => "t") ); | |||
evalbot_7626 | "hello" | ||
eric256__ | ?eval sub x (Str $t, Pair *@intable) { @intable.perl.say }; x("t", (h => t)); | 14:09 | |
evalbot_7626 | Error: No compatible subroutine found: "&t" | ||
iblech | Yep, seems that the vanilla core has some kind of bug | ||
eric256__ | ?eval sub x (Str $t, Pair *@intable) { @intable.perl.say }; x("t", (h => 't')); | ||
evalbot_7626 | [("h" => "t")] bool::true | ||
eric256__ | there are two cores? thats the exact same signature and it works outside perlude.pm | 14:10 | |
?eval sub x (Str $t, Pair *@intable) { @intable.perl.say }; x("t", (h => 't', q => 'r')); | |||
evalbot_7626 | [("h" => "t"), ("q" => "r")] bool::true | ||
iblech | Yep, there is the vanilla Haskell core, the JavaScript compiler, and the compiler to Perl 5 | 14:11 | |
ah! Try rebuilding the Prelude | |||
eric256__ still feels like there should be a way to say i'm expecting pairs so don't pars as args, but i'm guessing thats at the heart of magical vs. unmagical | |||
iblech++ | |||
hadn't thought of that../me starts full rebuild | |||
do i have to make clean to force it to rebuild prelude? | 14:17 | ||
iblech | eric256__: make clean works for sure, but modifying src/perl6/Prelude.pm (e.g. insert a space somewhere) will suffice | 14:18 | |
eric256__ slaps forhead....yea that would have worked, and triggered feather to rebuild too. lol | |||
where you around last night when i was working on .perl ? | 14:19 | ||
iblech | no, but I did saw your checkins | ||
eric256__ | do you know why when printing refs...it prints each layer and breaks the brackets off the previous layer until it reach the value? fi you have $ref1 -> $ref2 -> Hash; it doe sthe first one, then does the second one breakcing the { } off the first and adding its own | 14:20 | |
wouldn't it make sense just to skip printing anything till you get to the actual value? | 14:21 | ||
iblech | ?eval my %hash = (a => 1); my $ref2 = \%hash1; my $ref1 = \$ref2; $ref1.perl.say | ||
evalbot_7626 | Error: Undeclared variable: "%hash1" | ||
iblech | ?eval my %hash = (a => 1); my $ref2 = \%hash; my $ref1 = \$ref2; $ref1.perl.say | ||
evalbot_7626 | {("a" => 1)} bool::true | ||
eric256__ | you can't see it there because its removing the { } and then adding them agian. ever level | 14:22 | |
but i changed the front { to hash... and i get hash(ash(1=>2)) | |||
iblech | Hm. The vanilla core always derefs references -- this might be important here | 14:23 | |
eric256__ | which then took me an hour to trace around enough to realize that the multiple levels for ref created by for @z ( where driving me nuts | ||
nothingmuch | morning | ||
eric256__ | morning | ||
iblech | Hi nothingmuch :) | 14:24 | |
eric256__ | if you look Prim.hs 1349 you'll see the function i'm talking about. it gets called twice if you do sub x (@y) { for @y ( $_.perl.print ) }; x({hello=>1}); | 14:25 | |
?eval sub x (@y) { for @y ( $_.perl.print ) }; x({hello=>1}); | |||
evalbot_7626 | \"perl6"Error: Pattern match failure in do expression at src/Pugs/Eval.hs:419:4-12 | ||
eric256__ | ?eval sub x (@y) { for @y ( $_.perl.print ) }; x(1); | ||
evalbot_7626 | \"perl6"Error: Pattern match failure in do expression at src/Pugs/Eval.hs:419:4-12 | ||
iblech | ?eval sub x (@y) { for @y { $_.perl.say } }; x(1) | 14:26 | |
evalbot_7626 | \1 undef | ||
eric256__ | thats what i was going for. lol spaces ? | ||
?eval 1 | |||
evalbot_7626 | 1 | ||
iblech | Actually, this call should die -- 1 is not an array. [1] or (1,) should work. Or, alternatively, the signature should read (*@y) | ||
eric256__ | see how the 'for' makes a ref to 1 though | 14:27 | |
iblech | eric256__: It's for @array {...}, not for @array (...) | ||
Ah | |||
eric256__ | that ref adds on top of exisiting refs, so if you pass it an array ref, you get a ref to an array ref | ||
duh | |||
lol | |||
iblech | This is not a "real" ref, I think. It's because $_ is a full container, not only a value. See: | ||
?eval 1 | |||
evalbot_7626 | 1 | ||
iblech | ?eval my $foo = 1 | ||
evalbot_7626 | \1 | ||
eric256__ | hmmm.. well if my moded version { x => 1 }.perl = "hash( (x => 1) )" while if use that sub above it prints "hash(ash( (x => 1))" | 14:29 | |
iblech | Ah, I get your problem now, I think. But anyway, { x => 1 } should .perl to either '{ x => 1 }' or '\hash((x => 1))'. And hash((x=>1)) should .perl to 'hash((x=>1))' | 14:31 | |
eric256__ | yea and since i couldn't get the inner pairs to drop parents, i was going with hash or \hash...didn't matter till i could get it to print right though | 14:32 | |
iblech | ah, ok | 14:34 | |
eric256__ | so i was trying to figure out a way in haskell to get to the bottum value instead of printing each one and stripping the { } off at different levels. | ||
eric256__ scratches his head....actualy it looks like it might be fixed already...oddnees | 14:36 | ||
iblech | scook0: I just ran a new JS smoke with the demagicalized pairs patch in -- it seems that the only problem is that foo("x" => 1) is not recognized as a named (same bug as with foo(@array => 1)). | 14:39 | |
svnbot6 | r7627 | iblech++ | PIL2JS: PIL::PApp: Properly handle complex structs (especially coderefs) as the | ||
r7627 | iblech++ | RHS of a named (e.g. FETCH => {...}) (one-word patch). | |||
iblech | scook0: But no other regressions :) | ||
svnbot6 | r7628 | iblech++ | src/perl6/Prelude.pm: Extremely minor cosmetical fix, so the Prelude gets | 14:44 | |
r7628 | iblech++ | rebuilt (needed by scook0++'s demagicalized pairs patch). | |||
eric256__ | ?eval '\hash(1,2)'.eval.ref | 14:48 | |
evalbot_7627 | *** No compatible subroutine found: "&eval" at -e line 11, column 5-47 | ||
eric256__ | ?eval \hash(1,2).ref | ||
evalbot_7627 | *** No compatible subroutine found: "&eval" at -e line 11, column 5-37 | ||
eric256__ | ?eval hash(1,2).ref | ||
evalbot_7627 | *** No compatible subroutine found: "&eval" at -e line 11, column 5-35 | ||
eric256__ | ?eval 1; | 14:49 | |
evalbot_7627 | *** No compatible subroutine found: "&eval" at -e line 11, column 5-21 | ||
eric256__ | ohh....okay. ? | ||
?restart | 14:50 | ||
?eval 1 | 14:51 | ||
evalbot_7628 | 1 | ||
eric256__ | ?eval hash(1,2).ref | ||
evalbot_7628 | ::Hash | ||
eric256__ | ?eval \hash(1,2).ref | ||
evalbot_7628 | \::Hash | ||
eric256__ | ?eval {1,2}.ref | ||
evalbot_7628 | ::Block | ||
eric256__ | ?eval {1 => 2}.ref | ||
evalbot_7628 | ::Hash | ||
eric256__ | ?eval \{1 => 2}.ref | ||
evalbot_7628 | \::Hash | ||
nothingmuch | eric256__: this is discussed in s04 i think | 14:52 | |
geoffb: ping | |||
iblech | eric256__: \ binds stronger than method application, i.e. you've to use \(hash(...).ref) | ||
nothingmuch | iblech: that seems odd | 14:56 | |
it just doesn't look right syntactically | |||
iblech | It's the same with ~long.expression(here) | 14:57 | |
(And, FWIW, it does look right to me, but I don't have a strong opinion on this) | |||
eric256__ | in pugs source...readRef gets the next layer of ref...unless i'm still way off base, is there a function that gets the actual value of the thing eventualy referenced? | 14:58 | |
iblech | eric256__: The problem is: you may only dereference exactly one real level, where "real levels" get created by prefix \, see t/var/autoderef.t. So a function which will dereference as often as needed to get the actual value would probably be against the spec | 15:01 | |
eric256__ | hmmm. okay. so your saying if i'm in a for that is forcing an additionaly layer of ref, then when i perl print that it should be the extra ref? | 15:02 | |
iblech | eric256__: (But I do see your problem -- the vanilla core does a) not make a difference between real refs as created with \$foo and containers, and b) the vanilla core dereferences unlimitedly | ||
eric256__ | hehe..great | 15:03 | |
iblech | eric256__: Quite. The "additional layer of ref" you're seeing is not a real reference (which should get .perled), but only an indicator that you're .perling a container, not value. And this is a bug in pugs's internals, which is probably hard to fix | ||
eric256__ | but if i ignore the extra layer of ref then i might be ignore a true reference somewhere else? but would a reference to a reference to a value, always be a reference to a value? (as far as .perl is concerned) | 15:04 | |
iblech | Exactly this is the problem, you can't know which refs are true refs and which aren't... | 15:05 | |
Yep. (\\5) should .perlify to \\5. | 15:06 | ||
eric256__ | ?eval \\5.ref | ||
evalbot_7628 | Error: unexpected "\\" expecting program | ||
eric256__ | ?eval (\\5).perl | ||
evalbot_7628 | Error: unexpected "\\" expecting expression | ||
eric256__ | ?eval (\ \5).perl | ||
evalbot_7628 | "\\5" | 15:07 | |
eric256__ | ?eval (\ \5).ref | ||
evalbot_7628 | ::Int | ||
eric256__ | the docs say .perl just needs to output something that will eval back to the same ref type. | ||
eric256__ decides it must be time for cerial. | |||
iblech | Here you see the bug -- (\\5) should be a Ref of Ref of Int, not a Int | 15:08 | |
eric256__ | ohhh | ||
that seems like a pretty serious bug | |||
?eval (\5).ref | |||
evalbot_7628 | ::Int | ||
eric256__ | ?eval \(\5).ref | ||
evalbot_7628 | \::Int | ||
eric256__ | ?eval \5.ref | ||
evalbot_7628 | \::Int | ||
iblech | Yep. The new Haskell runcore will fix this (and it is already fixed in the JavaScript runcore) | ||
eric256__ | when does the new one come out? becuase i'm not going to bother on .perl for now if its going to be fixed better soon ;) | 15:09 | |
iblech | autrijus has already started (see src/PIL*). IIRC porting stevan's metamodel to Haskell has got the highest priority ATM | 15:10 | |
eric256__ | gotcha...guess i'll look for other tests to fix then. thanks | 15:11 | |
drove me nuts all last night. ;) | |||
iblech | nod... | 15:12 | |
rafl | Juerd: ping | 15:31 | |
gaal | hello everybody! has anyone here built their own ghc? | 15:34 | |
i want Hoogle to do GHC libraries, and the easiest way to get that is to run feather:~gaal/src/hihoo/hihoo.pl on a compiled GHC tree :-) | 15:35 | ||
but ghc doesn't build correctly on feather or on my machine at home. | |||
rafl | Juerd: ping | 15:36 | |
gaal | rafl: you're actually a likely candidate and you were logged out exactly as i was asking. do you happen to have ghc build from source yourself? | 15:37 | |
apt-get source ghc6 doesn't build out of the box. | 15:38 | ||
Juerd | rafl: pong | ||
nothingmuch | is irc.perl.org dead? | 15:42 | |
gaal | colabti.de/irclogger/irclogger_logs/perl6 is alive... | ||
eric256__ | irc.pugscode.org maybe? | ||
gaal | oh, .perl.org, you're looking for #parrot? | 15:43 | |
ESCdd then. | |||
nothingmuch | esc dd? | ||
oh | |||
eric256__ | how do you maodify the env for commands you are going to run with system? | 15:44 | |
gaal | env CAT=foo command | ||
oh, from within Perl? | |||
eric256__ | yea | ||
gaal | { local $ENV{CAT} = 'foo'; system ... } # p5 | 15:45 | |
nothingmuch | eric256__: you can '{ local $ENV{xxx} = "foo"; system(@cmd_and_args) }' | ||
gaal | { temp %*ENV<CAT> = 'foo'; ... } # p6, but won't work yet | ||
nothingmuch | for a channel with 188 users #irssi is pretty dead | ||
wolverian | nothingmuch, probably because it's just a help channel nowadays | 15:48 | |
nothingmuch | i guesso | ||
wolverian | nothingmuch, if you want development, #irssi2 (although I don't know how active it is either) | ||
nothingmuch | i don't really =) | ||
i wanted help | |||
eric256__ | oh i was hoping to do it in p6...could i system('env CAT=foo command') | 15:49 | |
nothingmuch | eric256__: not portably | ||
eric256__ | okay. i think i have a way around it. if a set the evn in a shell script, then run a perl script from the shell script, the env should carry over right? | 15:50 | |
iblech | eric256__: %*ENV<CAT> = "foo" does work, only temp on a hash element does not | ||
rafl | gaal: That should be an RC bug. | 15:51 | |
gaal: I'll try to reproduce it. | |||
eric256__ | ohh. i don't care if i can temp it...do i? | ||
gaal | this RC bug? | ||
iblech | I.e. you have to my $old_cat = %*ENV<CAT>; %*ENV<CAT> = "foo"; system "..."; %*ENV<CAT> = $old_cat | ||
gaal | s/this/what is an/ | 15:52 | |
rafl | gaal: Release critical. I'll report it for you if you want. | ||
Juerd: I wanted to ask if I can install tetex-extra and mzscheme on feather, but I just did it and removed it afterwards. | 15:53 | ||
gaal: What's the error you get when building ghc? | 15:54 | ||
gaal | rafl: okay. I just tried ./configure ; make | ||
and there were a few C errors | |||
Juerd | rafl: You can install anything via apt-get | ||
rafl: And anything else in your home directory | |||
rafl | gaal: Do dpkg-buildpackage -us -uc -rfakeroot | ||
gaal | the first one looked pretty silly, an undeeded static declaration, which i removed | ||
but there were other problems later on. | 15:55 | ||
Juerd | rafl: No debian packages without repositories in /etc/apt/sources.list, please though | ||
That sucks when libraries are upgraded :) | |||
rafl | Juerd: Aye. | ||
gaal | rafl: what do you need me to do? | 15:57 | |
rafl | gaal: Do apt-get source ghc6; cd ghc6.4-4.1; dpkg-buildpackage -rfakeroot -us -uc and tell me if it produces some errors. | 15:58 | |
gaal | it does, but i believe they don't have anything to do with my compilation errors. | ||
because the compilation errors are very cish. | 15:59 | ||
rafl | gaal: Paste them. | 16:01 | |
gaal | does debian have an automatic build system? | ||
paste in a sec | |||
rafl | Yes. It's started by doing dpkg-buildpackage -rfakeroot -us -uc in the src directory. | ||
pasteling | "gaal" at 192.115.25.249 pasted "ghc6 source build error" (13 lines, 1.2K) at sial.org/pbot/13713 | ||
gaal | i mean, does every source upload get built for the maintainer? | 16:02 | |
rafl: so, this just looks like a bug in the GHC code, apparently simple to fix: remove the 'static' keyword from the declaration from static_objects' | 16:03 | ||
rafl | There are no source-only uploads. Maintainers upload a source package + one binary build for their architecture. Other architectures gets build by build daemons. | ||
gaal | but then there are different errors down the road | ||
rafl | buildd.debian.org | ||
gaal | rafl: so presumably the maintainer ought to know pretty fast about such a breakage? | 16:04 | |
rafl | I'm also compiling it ATM. Let's see if I can reproduce it. | ||
Maybe you also want to try to build it in a clean chroot (pbuilder). | |||
gaal: No. You don't get mails if the build fails. | |||
gaal | rafl: the newest one at buildd.debian.org/build.php?arch=i3...p;pkg=ghc6 is from a while ago! | 16:06 | |
rafl | gaal: Yes. The 6.4-4.1 version was uploaded using binary-only NMUs for each architecture because it needed by-hand-bootstrapping. | 16:07 | |
(ghc6 build-depends on ghc6 and ghc6 wasn't installable) | |||
OK, I need to go. See you in some hours. | 16:08 | ||
gaal | bye rafl. | 16:09 | |
xerox | Searching for GHC .debs? | 16:10 | |
I'd say, use haskell-unsafe: deb haskell-unsafe.alioth.debian.org/archive/i386 . unstable testing stable | 16:11 | ||
gaal | xerox: no, i want a built source tree | ||
xerox | Maybe it has deb-src ? | ||
gaal | to slurp function signatures from the .hi files | ||
to create a .HOO file | |||
xerox | Hoogle does that, iirc | ||
gaal | so that Hoogle can finally show libraries | 16:12 | |
xerox | Ah! | ||
You should talk with ndm. He's doing that for Hoogle3. | |||
gaal | # no.perlcabal.org/~gaal/hihoo.pl | ||
(very rough first take) | 16:13 | ||
xerox: he doesn't seem to be online on #haskell now. | |||
xerox | Check #haskell-blah, he talked some mins ago. Though he said something like "I'm drunk" :-P | ||
svnbot6 | r7629 | iblech++ | * t/syntax/pairs.t: foo("a" => 42) is named, foo(("a" => 42)) is not. | 16:15 | |
r7629 | iblech++ | * Pugs.Parser: Pairs with complex LHS may now be parsed as a Syn "named": | |||
r7629 | iblech++ | foo @array => 42; # named | |||
r7629 | iblech++ | foo (@array => 42); # positional pair | |||
r7629 | iblech++ | * PIL2JS: | |||
r7629 | iblech++ | * PIL::PApp, PIL::PVal: Stringify the LHS of a named pair. | |||
r7629 | iblech++ | * This means PIL2JS passes t/syntax/pairs.t 27/27! :) scook0++ | |||
iblech | ?eval sub foo { say caller().perl }; foo | 16:22 | |
evalbot_7629 | Error: Must only use named arguments to new() constructor | ||
iblech | Ah, the Prelude needs to be recompiled again | ||
svnbot6 | r7630 | iblech++ | src/perl6/Prelude.pm: Again a trivial cosmetical change so the Prelude gets | 16:23 | |
r7630 | iblech++ | rebuilt (necessary because of r7622 and r7629). | |||
brother | ?eval "ABC".trans("a" => "A", "b" => "B", "c" => "C") | 16:28 | |
evalbot_7629 | *** No compatible subroutine found: "&eval" at -e line 11, column 5-98 | ||
iblech | brother: Try again in a minute, feather is probably rebuilding pugs currently | 16:29 | |
wolverian | wow. that looks a wonderful interface. pairs are so natural for that sort of a thing. | 16:31 | |
(really.) | |||
does it work if the value of a pair is more than one character? can I give it closures which it runs on every replacement? | |||
"ABC".trans(a => { ("A".."C").pick }) | |||
brother | Probaly not with a closure | 16:32 | |
wolverian | why not? | 16:33 | |
brother | but "<foo>".trans( '<' => "<", '>' => ">" ) is supposed to work | 16:34 | |
?eval "ABC".trans("a" => "A", "b" => "B", "c" => "C") | |||
evalbot_7629 | *** No compatible subroutine found: "&eval" at -e line 11, column 5-98 | ||
wolverian | right, that is similar use to that | ||
brother | still not there | ||
wolverian | and has nothing to do with my question :) | ||
i.e. why wouldn't closure work there (given that it could be implemented)? | 16:35 | ||
gaal | Juerd: mind if I install + register hs-plugins on feather? | ||
brother | ok, wrong answer. It doesn't work (now), not that it wouldn't work (eventually). | 16:36 | |
?eval "ABC".trans("a" => "A", "b" => "B", "c" => "C") | 16:40 | ||
evalbot_7630 | "ABC" | ||
brother | dohhh | ||
wolverian | brother, ah. thanks! | ||
hahaha. | |||
brother | you could have told me that first time I tried | ||
wolverian | ?eval "ABC".trans(A => "a") | ||
evalbot_7630 | "ABC" | ||
brother | ?eval "abc".trans("a" => "A", "b" => "B", "c" => "C") | ||
evalbot_7630 | "abc" | ||
wolverian | oh, wow, => autoquoting doesn't work yet, I guess | ||
s,/wow, // | |||
brother | ?eval "abc".trans("a" => "A", "b" => "B", "c" => "C") | ||
evalbot_7630 | "abc" | ||
wolverian | erm. | 16:41 | |
oh, it's broken. | |||
sorry to confuse. | |||
brother | ?eval "abc".trans("a" .. "c" => "A" .. "C") | ||
evalbot_7630 | "abc" | ||
brother | ?eval "abc".trans(["a" .. "c"] => ["A" .. "C"]) | ||
evalbot_7630 | "abc" | ||
brother | ?eval "abc".trans(list ["a" .. "c"] => ["A" .. "C"]) | 16:42 | |
evalbot_7630 | Error: Unknown syntactic construct: Syn "named" [Syn "\\[]" [Pos (MkPos "<eval>" 1 19 1 29) (App (Var "&infix:..") Nothing [Cxt (CxtItem (mkType "Str")) (Val (VStr "a")),Cxt (CxtItem (mkType "Str")) (Val (VStr "c"))])],Syn "\\[]" [Pos (MkPos "<eval>" 1 35 1 45) (App (Var "&infix:..") Nothing [Cxt (CxtItem (mkType "Str")) (Val (VStr "A")),Cxt (CxtItem (mkType "Str")) (Val (VStr "C"))])]] | ||
wolverian | weird that it doesn't error either | ||
brother | wow | ||
did I do that? | |||
wolverian | well, now it did ;) | ||
?eval list [1] | |||
evalbot_7630 | ([1]) | ||
wolverian | ?eval list [1] => [2] | ||
evalbot_7630 | Error: Unknown syntactic construct: Syn "named" [Syn "\\[]" [Pos (MkPos "<eval>" 1 7 1 8) (Val (VInt 1))],Syn "\\[]" [Pos (MkPos "<eval>" 1 14 1 15) (Val (VInt 2))]] | ||
wolverian | there you go. | ||
probably not your fault. | |||
iblech | ?eval "abc".trans((a => "A")) | 16:43 | |
evalbot_7630 | "abc" | ||
brother | Hmmm, "abc".trans(["a" .. "c"] => ["A" .. "C"]) | 16:44 | |
work on my pugs | |||
xerox | Here does work too. | ||
iblech | ?eval $?PUGS_VERSION | 16:45 | |
evalbot_7630 | \"Perl6 User\'s Golfing System, version 6.2.10, October 10, 2005 (r7630)" | ||
brother | r7628 here | ||
iblech | ?eval "abc".trans((["a" .. "c"] => ["A" .. "C"])) | 16:46 | |
evalbot_7630 | "ABC" | ||
xerox | r7573 here | ||
iblech | Since r7622, pairs are demagicalized (scook0++). Since r7629 complex named arguments are possible too. So .trans(["a".."c"] => ...) does not pass a Pair object to .trans, but the named argument "a b c" | 16:47 | |
Should pugs emit a warning in this case? | 16:48 | ||
brother | So, for a short time r7617 till r7622 trans actually worked | 16:49 | |
iblech | It should still work if you add parens around the pairs | ||
(It's a bug of the vanilla core that .trans(a => "A") doesn't die with "Unexpected named argument 'a'") | 16:51 | ||
wolverian | oh, but that usage is so nice! | ||
?eval "abc".trans( (["a"] => ["A"]) ) | 16:52 | ||
evalbot_7630 | "Abc" | ||
wolverian | I guess I can live with that if I can remove the arrayreferences :) | ||
(I think that was the spec?) | 16:53 | ||
(wrt named arguments) | |||
brother | ?eval "ABC".trans( 'A'=>'a', 'B'=>'b', 'C'=>'c' ) | 16:59 | |
evalbot_7630 | "ABC" | ||
brother | ?eval "XYZ".trans( 'XYZ' => 'xyz' ) | ||
evalbot_7630 | "XYZ" | ||
iblech | wolverian: Yep, removing the [] ought to work | ||
brother: You either need (the not yet implemented) <== or you have to add parens around the pairs. .trans("A" => "a") is parsed as passing the *named argument* "A" (with value "a") to .trans, not as passing the pair ("A" => "a") positionally to .trans | 17:00 | ||
brother | ?eval "ABC".trans( ('A'=>'a'), ('B'=>'b'), ('C'=>'c') ) | ||
evalbot_7630 | "ABC" | ||
iblech | yep, that should work. | ||
wolverian | do I need to put the <== inside the parens? | 17:01 | |
would this work: "ABC".trans <== a => "A"; | |||
iblech | dunno | 17:02 | |
wolverian | I think that works for normal functions | ||
foo ==> map { } ==> bar | |||
probably should work here too. I'll check for :todo tests | |||
brother | ok, I give up. | ||
iblech | www.nntp.perl.org/group/perl.perl6....uage/23541 (message from Larry, "self" is now an alias for $?SELF) | 17:07 | |
www.nntp.perl.org/group/perl.perl6....uage/23541 (message from Larry, "self" is now an alias for $?SELF) | 17:10 | ||
err, wrong key | |||
r0nny_ | hoi there :) | 17:15 | |
gaal | ahoy r0nny_! | ||
iblech | food & | 17:17 | |
Limbic_Region | anyone having problems building pugs from scratch on winders? | 17:19 | |
Limbic_Region just got a GHC out of heap error | |||
I am restarting the build now - but I have my doubts | 17:20 | ||
mrborisguy | anyone here on feather? | 17:35 | |
what's the best way to build pugs to test a change? | 17:36 | ||
I'd suppose it needs to be built locally in my /home somehow | |||
Limbic_Region has an acct on feather but doesn't use it for anything other than IRC when I am at work | 17:38 | ||
ok - succesfully built | 17:44 | ||
any particular reason decimals are now showing up as fractions? | |||
gaal | mrborisguy: read perlcabal.org/~autrijus/ | ||
Limbic_Region | ?eval my $foo = 11 / 10; say $foo | ||
evalbot_7630 | 1.1 bool::true | ||
gaal | mrborisguy: then cd into your pugs dir, and do perl Makefile.PL ; nice make | ||
iblech | Limbic_Region: you mean: | 17:45 | |
?eval say (11/10).perl | |||
evalbot_7630 | 11/10 bool::true | ||
gaal | whoa. is that intended? | 17:46 | |
Limbic_Region | ?eval my $foo = .1 * (int (rand 2) ?? 1 !! -1); say $foo | ||
evalbot_7630 | 0.1 bool::true | ||
Limbic_Region | ?eval my $foo = .1 * (int (rand 2) ?? 1 !! -1); $foo | ||
evalbot_7630 | \1/10 | ||
Limbic_Region | that's what I mean | ||
gaal | ?eval my $foo = .1 * (int (rand 2) ?? 1 !! -1); "$foo" | ||
Limbic_Region | ?eval my $foo = .1 * (int (rand 2) ?? 1 !! -1); $foo | ||
evalbot_7630 | "0.1" | ||
\1/10 | |||
Limbic_Region | ?eval my $foo = .1 * (int (rand 2) ?? 1 !! -1); $foo | ||
evalbot_7630 | \1/10 | ||
iblech | Yep, eric256 implemented this yesterday. The only requirement for .perl is, that $thing.perl.eval eqv $thing. Thus showing fractions as x/y is ok and doesn't loose precision | ||
gaal | indeed. cool hack! | 17:47 | |
iblech | The stringification of fractions is unchanged, i.e.: | ||
gaal | ?eval my $foo = .1 * (int (rand 2) ?? 1 !! -1); "$foo" | ||
iblech | ?eval ~11/10 | ||
evalbot_7630 | "0.1" | ||
1.1 | |||
gaal | :-p | ||
Limbic_Region | this is definatley not what I mean though | ||
iblech | eric256++ # indeed | ||
Limbic_Region | if I multiply a decimal by an integer | ||
I don't expect a fraction | |||
?eval my $foo = .1 * (int (rand 2) ?? 1 !! -1); $foo | |||
evalbot_7630 | \1/10 | ||
Limbic_Region | oh wait | 17:48 | |
nevermind | |||
mrborisguy | gaal: thanks. | ||
Limbic_Region | I am using .perl | ||
Limbic_Region kicks himself | |||
iblech | Limbic_Region: But if you say() or ~ $foo, you'll see normal 123.456-style output | ||
Limbic_Region | this code is a bit old | ||
17:48
r0nny_ is now known as r0nny
|
|||
Limbic_Region | I forgot how it worked | 17:48 | |
ok - so nmake required 2 runs for it to actually get all the way through | |||
I ran out of ghc heap | |||
but other than that - groovy | 17:49 | ||
TTFN all | |||
svnbot6 | r7631 | iblech++ | examples/network/evalbot/{evalbot.p6,evalhelper.p5}: Support the other | 17:50 | |
r7631 | iblech++ | backends, e.g. | |||
r7631 | iblech++ | ?eval 5 + 3 # normal backend | |||
r7631 | iblech++ | ?eval:js 5 + 3 # PIL2JS | |||
r7631 | iblech++ | ?eval:p5 5 + 3 # PIL-Run | |||
r0nny | is there somewhere a description of the pugs thread interface ? | 17:53 | |
iblech | r0nny: No... you may grep for Thread in src/Pugs/Prim.hs | ||
r0nny | darn | 17:54 | |
iblech | ?eval "does evalbot still work?" | 17:55 | |
evalbot_7631 | "does evalbot still work?" | ||
iblech | ?eval:js "and does -BJS work?" | ||
evalbot_7631 | *** Precompiled Prelude doesn't exist yet; precompiling... (You can safely ignore the 'useless use of constant' warnings.) pugs: *** No compatible subroutine found: "&use" at -e line 1, column 1 Use of uninitialized value in print at /home/fibonaci/devel/pugs-base/perl5/PIL2JS/lib/PIL2JS.pm line 142. *** Reading input from "/tmp/gJJDX52T0F"... *** Compiling PIL to JavaScript... Can't bless non-reference value at /home/fibonaci/devel/pugs-ba | ||
r0nny | ?eval:c++ cout << "meh - wont work" << endl; | 17:56 | |
evalbot_7631 | Error: unexpected "c" expecting operator, postfix conditional, postfix loop, postfix iteration, ";" or end of input | ||
iblech | ?eval:p5 "hello from pil-run" | ||
evalbot_7631 | Can't locate Scriptalicious.pm in @INC (@INC contains: /home/fibonaci/devel/pugs-base/perl5/PIL-Run/lib /home/fibonaci/devel/pugs-base/perl5/PIL-Run/.. /home/fibonaci/devel/pugs-base/perl5/PIL-Run/../Perl6-Value/lib /home/fibonaci/devel/pugs-base/perl5/PIL-Run/../Perl6-Container/lib /home/fibonaci/devel/pugs-base/perl5/PIL-Run/../Perl6-MetaModel /home/fibonaci/devel/pugs-base/perl5/PIL-Run/../Perl6-MetaModel/lib /etc/perl /usr/local/lib/perl/5.8.7 | ||
gaal | w00t! | 17:58 | |
?eval say "iblech++ " xx 3 | 17:59 | ||
evalbot_7631 | iblech++ iblech++ iblech++ bool::true | ||
iblech | ?eval say "thanks" xx 3 # :) | 18:00 | |
evalbot_7631 | thanksthanksthanks bool::true | ||
r0nny | OMG | 18:03 | |
pugs-threads are messy to understand | 18:04 | ||
can anyone tell me, if there is another way, then async, to create a thread ? | 18:07 | ||
gaal | r0nny: nope. these are kind of uncharted water, too. | 18:09 | |
r0nny | hmm | ||
is there a way, to pass params in a nice way to a asynv block | |||
gaal | dunno | 18:11 | |
funny pic of autrijus: www.syntaxpolice.org/pics/estoniaBe...ia/14.html | |||
xerox | We want names :D | 18:14 | |
gaal | names? | ||
xerox | Of all those people! :-) | 18:15 | |
gaal | ah, ask syntaxninja on #haskell :) | ||
integral | r0nny: pass params? you just use closure surely? sub foobar ($arg) { async { say $arg } } # ie, the sub generates asyncs that are closed over $arg | 18:16 | |
r0nny | integral: cool - thx | 18:17 | |
so i can do a cmdline shell, and "fork" irc bots for different servers to the bg :) | 18:18 | ||
gaal | r0nny: why would you not want to use separate processes for that? | 18:19 | |
r0nny | gaal: "fork" not fork ;P | 18:21 | |
just let them be in the bg as threads | |||
gaal | yes, i understand. why *not* use separate processes though? what do threads buy you? | 18:25 | |
iblech | brother: I think I have fixed $str.trans in r7632 | ||
svnbot6 | r7632 | iblech++ | * src/perl6/Prelude.pm: Fixed $str.trans (trivial one-char patch). | ||
r7632 | iblech++ | * t/var/constant.t: The initial value of a constant should get evaluated at compile-time. | |||
iblech | gaal: inter-bot-communication :) | ||
r0nny | no | 18:26 | |
its one big bot handles different servers in different threads | |||
gaal | iblech: that is a scary thought :) | ||
iblech | :D | ||
r0nny | btw - ho does variable-sharing betwen threads work in pugs ? | 18:27 | |
iblech | ?eval my $var; my sub forker () { async { $var++ } }; forker() for 1..20; $var | 18:28 | |
evalbot_7631 | \19 | ||
iblech | The framework for threading Pugs uses, STM, guarantees that the internal state etc. doesn't get corrupted | 18:29 | |
?eval my $var; my sub forker () { async { $var++ } }; forker() for 1..20; 1 for 1..1000; $var | |||
evalbot_7631 | \20 | ||
r0nny | so basically everything is not local is shared | ||
gaal | '1 for 1..1000'? is sleep unsafe? | 18:30 | |
?eval sleep 1; say "perhaps to dream" | |||
evalbot_7631 | Can't exec "./pugs": Permission denied at examples/network/evalbot//evalhelper.p5 line 46. | ||
gaal | ?eval sleep 1; say "perhaps to dream" | 18:31 | |
evalbot_7631 | *** No compatible subroutine found: "&eval" at -e line 11, column 7-59 | ||
gaal | heh. | ||
iblech | gaal: Yep, it is. Else you could ?sleep 1_000_000 (and this isn't trapped by BSD::Resource/ulimit, as sleep() doesn't burn any cpu time (IIRC)) | ||
gaal | it had better not ;) | ||
r0nny | ?eval my $var; ny sub bsleep() { 1 for 1..1000;} ; my sub forker () { async {bsleep for 1..rand(20); $var++ } }; forker() for 1..20; 1 for 1..10000; $var | ||
?eval my $var; ny sub bsleep() { 1 for 1..1000;} ; my sub forker () { async {bsleep for 1..rand(20); $var++ } }; forker() for 1..20; 1 for 1..10000; $var | 18:32 | ||
evalbot_7631 | *** No compatible subroutine found: "&eval" at -e line 11, column 7-229 | ||
gaal | "ny sub"? | ||
r0nny | ops | ||
?eval my $var; my sub bsleep() { 1 for 1..1000;} ; my sub forker () { async {bsleep for 1..rand(20); $var++ } }; forker() for 1..20; 1 for 1..10000; $var | |||
evalbot_7631 | *** No compatible subroutine found: "&eval" at -e line 11, column 7-229 | ||
iblech | r0nny: Try again in a minute, the Prelude is currently recompiling, thus &eval isn't there yet | ||
r0nny | ok | 18:33 | |
?eval my $var; my sub bsleep() { 1 for 1..1000;} ; my sub forker () { async {bsleep for 1..rand(20); $var++ } }; forker() for 1..20; 1 for 1..10000; $var | |||
evalbot_7631 | *** No compatible subroutine found: "&eval" at -e line 11, column 7-229 | ||
r0nny | hmm | ||
iblech | s/try again in a minute/try again in two minutes/ ;) | 18:34 | |
r0nny | ?eval my $var; my sub bsleep() { 1 for 1..1000;} ; my sub forker () { async {bsleep for 1..rand(20); $var++ } }; forker() for 1..20; 1 for 1..10000; $var | ||
evalbot_7631 | *** No compatible subroutine found: "&eval" at -e line 11, column 7-229 | ||
r0nny | argh | ||
i got no patience | |||
brother | iblech: nice, didnt see that | 18:35 | |
r0nny jumps around way to nervous, and breaks the src tree | |||
can i try now *dogy eyes* | |||
?eval my $var; my sub bsleep() { 1 for 1..1000;} ; my sub forker () { async {bsleep for 1..rand(20); $var++ } }; forker() for 1..20; 1 for 1..10000; $var | 18:36 | ||
evalbot_7631 | *** No compatible subroutine found: "&eval" at -e line 11, column 7-229 | ||
r0nny | o0 | ||
theorbtwo | Hm, it was doing the 'No compatible subroutine found: "&eval"' thing the other day, too. | ||
r0nny | damn - compile it faster | 18:37 | |
r0nny changed his mind-state to pre-insane | |||
?eval my $var; my sub bsleep() { 1 for 1..1000;} ; my sub forker () { async {bsleep for 1..rand(20); $var++ } }; forker() for 1..20; 1 for 1..10000; $var | 18:38 | ||
evalbot_7631 | *** No compatible subroutine found: "&eval" at -e line 11, column 7-229 | ||
theorbtwo | r0nny: you could get your own copy... | ||
You can tell when evalbot fixes itself; it'll log out then log back in with a new username. | |||
gaal | why, btw, are you declaring your subs 'my' at all? | ||
theorbtwo | Yeah, like that, but it's supposed to log back in agin... | 18:39 | |
r0nny | ?eval my $var; my sub bsleep() { 1 for 1..1000;} ; my sub forker () { async {bsleep for 1..rand(20); $var++ } }; forker() for 1..20; 1 for 1..10000; $var | ||
theorbtwo | Thank you, evalbot. | ||
r0nny | hope it eats it | ||
evalbot_7632 | (no output) | 18:40 | |
iblech | ?eval "abc".trans((a => "A")) | ||
evalbot_7632 | "Abc" | ||
theorbtwo | r0nny: Why are you trying to "eat" evalbot? | ||
iblech | r0nny: s/10000/1000/ (evalbot has a cpu time limit) | ||
r0nny | ehm - mean hope evalbot eats my code, and wont spill it out | ||
?eval my $var; my sub bsleep() { 1 for 1..1000;} ; my sub forker () { async {bsleep for 1..rand(20); $var++ } }; forker() for 1..20; 1 for 1..1000; $var | |||
evalbot_7632 | \undef | 18:41 | |
r0nny | ?eval my $var; my sub bsleep() { 1 for 1..10;} ; my sub forker () { async {bsleep for 1..rand(20); $var++ } }; forker() for 1..20; 1 for 1..1000; $var | ||
evalbot_7632 | \20 | ||
r0nny | ?eval use xxo; | ||
evalbot_7632 | pugs: *** No compatible subroutine found: "&use" at Prelude.pm line 61, column 30-59 | ||
r0nny | ?eval my sub test(){use xxo;xxo->new;}; | 18:42 | |
evalbot_7632 | pugs: *** No compatible subroutine found: "&use" at Prelude.pm line 61, column 30-59 | ||
r0nny | it is secure | ||
svnbot6 | r7633 | iblech++ | t/operators/adverbial_modifiers.t: Fixed some tests WRT pairs now being | 18:52 | |
r7633 | iblech++ | demagicalized. | |||
r7634 | iblech++ | New docs/journal/2005-10-15.kwid: scook0 demagicalized pairs; I updated PIL2JS | 18:58 | ||
r7634 | iblech++ | accordingly; PIL2JS passes 27/27 of t/syntax/pairs.t. | |||
geoffb | nothingmuch, I have not backlogged yet . . . but I saw you pinged? | 19:00 | |
nothingmuch | no longer relevant | 19:01 | |
because I have to go | |||
geoffb | ah | ||
nothingmuch | but I wanted to start writing ;-) | ||
geoffb | nothingmuch, I am gone most of today. Back online tomorrow | ||
nothingmuch | okies | ||
Juerd | gaal: If it won't break automatic upgrades, go ahead | 19:22 | |
gaal: If it's available through debian packages, use those. | |||
wolverian | hm, now I have my own "feature" in perl6 as well. | 19:24 | |
Juerd | WHich? | ||
wolverian | self is called 'self' by default. | ||
Juerd | And .foo is $_.foo unconditionally? | ||
wolverian | I assume so. the decision only pertained to naming, but that makes sense. I'll follow up if you want. | 19:25 | |
actually, I guess I'll follow up anyway | |||
as it's important to me as well | |||
Juerd, or did you already? | 19:26 | ||
Juerd | Nafaik | ||
wolverian | how can you not know? :) | ||
Juerd | I have faulty memory | 19:27 | |
wolverian | oh, okay. well, sending. | ||
Juerd | It's not okay | ||
Not remembering things sucks | |||
wolverian | I'm sorry. | 19:28 | |
sent. | 19:29 | ||
rafl | gaal: ghc6 (sid version) built fine in my chroot. | 20:31 | |
gaal: I don't know where your problem is. Please also try to build it in a clean environment. | |||
svnbot6 | r7635 | iblech++ | Moved primitive_named_params.t and passing_the_pair_class_to_a_sub.t out of | 21:05 | |
r7635 | iblech++ | pugsbugs/, as they pass now (because of the demagicalizing pairs patch). | |||
wolverian | does S02 really mean to imply that you can use regexes as q:to (heredoc) terminators? | 22:38 | |
rafl | Pugs is in Debian testing, yay! (6.2.8, though. 6.2.10 needs to go though the NEW queue first) | 22:45 |