pugscode.org/ | nopaste: sial.org/pbot/perl6 | pugs: [~] <m oo se> (or rakudo:, kp6:, smop: etc.) || We do Haskell, too | > reverse . show $ foldl1 (*) [1..4] | irclog: irc.pugscode.org/ Set by TimToady on 25 January 2008. |
|||
01:03
ilogger2 joined
|
|||
Tene | pugs: @a = gather { for 1..10 { take $_ * 2 } }; say @a; | 01:09 | |
p6eval | OUTPUT[***  Unexpected " =" expecting "::" Variable "@a" requires predeclaration or explicit package name at /tmp/dkcGvfLLXY line 1, column 3] | ||
Tene | pugs: my @a = gather { for 1..10 { take $_ * 2 } }; say @a; | ||
p6eval | OUTPUT[2468101214161820] | ||
pugs_svnbot | r20981 | diakopter++ | [yap6] fixes from 'use diagnostics' | 01:15 | |
r20982 | diakopter++ | [yap6] | |||
r20982 | diakopter++ | * bin/test doesn't need 'use diagnostics' committed... | |||
diakopter read today about scattered context grammars (for context-sensitive languages) and how they enable semantic analysis (and type checking) specified directly in the grammar to be performed at parse time. interesting stuff. | 01:25 | ||
01:34
alester joined
|
|||
scrottie | hey, alester, why did you delete www.flickr.com/photos/petdance/2588945466/ ? | 01:36 | |
lambdabot | Title: Flickr: Image | ||
scrottie | Am I really that ugly? | ||
alester | what was it? | ||
scrottie | me! | ||
you deleted me, you bastard! | |||
alester | I did? | ||
I'm sorry, I had to prune down to 200 total | 01:37 | ||
where were you? | |||
scrottie vanishes in a puff of filesystem block reallocation. | |||
alester | pool table? | ||
scrottie | bowling, probably | ||
lichtkind | wknight8111: sorry i ment leave | ||
do have leave an impact to gather too? | |||
alester | Black shirt, glasses? | 01:38 | |
10 pound blue ball? | |||
scrottie | yeah. red hair, lots of forehead. | ||
alester | what's yr email | ||
scrottie | my god... you know, I picked out two blue balls just so I could make jokes about it. but I think I've used them all up. | ||
[email@hidden.address] | |||
if you're going to take lots of good pics (of my good side) at YAPC, I think we could chip in for a paid flickr account. assuming that's the reason you had to prune. | 01:39 | ||
alester | Flickr only lets me have 200 photos in all | ||
yes, that's why | |||
scrottie | even if you give them money? | ||
taking photos is a public service and should be encouraged. | |||
alester | No, I just didn't hve a pro account | ||
Next time I'll put 'em on Picasa. | |||
scrottie | I'll try to remember to mention this again come next year. | 01:40 | |
or that =) | |||
alester | OK, exporting 113 photos to Picasa. | 01:43 | |
pugs_svnbot | r20983 | Auzon++ | [gsoc_spectest] fixed eager_hyper.t to use gather/take as suggested by moritz++ (removed 2 tests; only 6 tests in this file now) | 01:49 | |
scrottie | thanks for the copy of the pic. and that's not just any black shirt... that's my SNOBOL 4 shirt! | ||
alester | scrottie: picasaweb.google.com/petdance/YAPCN...TheRawFeed | 02:05 | |
lambdabot | Title: Picasa Web Albums - Andy - YAPC::NA 2008... | ||
02:09
jjore joined
|
|||
diakopter fiddles with Devel::Pointer::PP | 02:14 | ||
... and is delighted to discover [the technique in] Sub::Become | 02:23 | ||
02:56
jjore left
|
|||
alester | perlbuzz.com/2008/06/yapcna-2008-ph...rapup.html | 02:59 | |
lambdabot | Title: YAPC::NA 2008 photo wrap-up - Perl Buzz | ||
alester | hey! | ||
diakopter! | |||
I don't remember what you look like! | |||
But I DO remember you sat to my right at lunch! | |||
Isn't it funny how my brane works? | 03:00 | ||
03:05
Alias_ joined
|
|||
SamB | alester: but do you remember what he ate? | 03:06 | |
alester | I think it was a sandwich on some sort of white hearty bread. | ||
ingy | scrottie: hola | 03:12 | |
Alias_ | o/ | 03:13 | |
ingy | hi Alias_ | ||
s1n | diakopter: where's the smoke tests in the pugs repo? | 03:16 | |
ingy | & | 03:17 | |
Auzon | s1n: pugs/t contains the Perl 6 test suite if that's what you mean | 03:19 | |
s1n | Auzon: that's what i thought, it just wasn't really documented as such | ||
diakopter | s1n: and there are quite a few ways to smoke the test suite... each implementation does it uniquely | ||
meaning Test.pm | 03:20 | ||
Auzon | Note that we're trying to move most of pugs/t to pugs/t/spec | ||
03:20
apeiron joined
|
|||
diakopter | alester: yeah | 03:20 | |
s1n | okay, well i just want to get a devenv setup tonight | ||
i checked out the pugs code, i have parrot building, what's the most advisable way of testing / modifying / adding a test to the suite? | 03:21 | ||
since i did a make spectest in the rakudo directory, it checked out the tests, i should be able to make changes / commits in the "t/spec" folder, right? | 03:23 | ||
diakopter | s1n: yes. Try to follow the existing pattern of tagging with a region of the relevant synopsis. if you make an error in your commit, I'm sure someone will notice and correct it :) | 03:24 | |
s1n | well, i may pastebot a patch or two until i get the hang of it | ||
every company and project has their way of developing, so i'd rather just get a feel for it first :) | 03:25 | ||
diakopter | s1n: but also make sure to get familiar with the t/everything-but-spec so that you don't duplicate what's waiting-to-be-migrated-to-spec | ||
s1n | diakopter: gotcha | 03:26 | |
03:26
BinGOs joined
|
|||
diakopter | Auzon: any comments/corrections to what I said? | 03:26 | |
Auzon | s1n: sure you can pastebot, but we're very forgiving in pugs/ | ||
Um... get and use 'ack' | 03:27 | ||
s1n | diakopter: again, since i'm new to this codebase, i'll take my time learning it's ins and outs, so i'll try not to commit anything without someone checking it over for a few commits | ||
i'm a perfectionist, i'd rather do it right or not do it at all | |||
Auzon | I guess you can use egrep if you know its patterns better than the Perl ones | ||
s1n | Auzon: i won't waste my time grepping through things, i'll see if i can get some useful ctags built | 03:28 | |
diakopter | s1n: that's a little difficult when the line between perfect and pluperfect is pretty fuzzy (around here) | ||
Auzon | ctags? | ||
s1n | Auzon: google it, it can save you time :) | ||
i don't write any typed language code without it, scripting is a little different (have to kinda nudge it along) | 03:29 | ||
diakopter: well, yeah i realize i won't be perfect, but i want what i do first to seem that way, until i improve and what i did yesterday suddenly looks like crap :) | 03:30 | ||
diakopter | s/pluperfect/something else/ | ||
DietCoke | parrot has tags targets. | 03:31 | |
s1n | DietCoke: yeah but does perl6 / rakudo? | 03:32 | |
parrot is more strongly typed | |||
diakopter | heh | ||
s1n | alright guys, since i'm ready to start playing with it, ima call it a night. i'll dink with some of the tests and see if i can get ctags built | 03:33 | |
diakopter | good luck | ||
diakopter declares #perl6,p6l,@Larry to be autopoietic | 03:34 | ||
alester: where's that mailing list you mentioned | 03:38 | ||
alester | rethinking-cpan | 03:39 | |
gogole it | |||
diakopter | good thing gogole goes to google | 03:40 | |
03:40
a-jing joined,
a-jing left
|
|||
diakopter | alester: is it intentional that perl101 is perl5 to binary | 03:42 | |
alester | ? | ||
diakopter | perl101.org | ||
never mind | |||
alester | I don't understand what you mean "perl5 to binary" | 03:43 | |
Auzon | 5 in binary is 101 | 03:44 | |
alester | ah | 03:48 | |
diakopter | someone should make Acme::Godel, a source filter that gives you the Godel number of the source code (or maybe even the bytecode) of the script that uses it. just gets the nth prime where n is the number represented by the program's something-endian source/bytecode representation. okay, so probably it would never terminate on most inputs.... | ||
Auzon | s1n: I don't see how ctags would help me figure out, for instance, if ^..^ was tested. Where running "ack '^\.\.^' t/" would locate them if they exist | ||
alester | because they're prefound, Auzon. | ||
And you can then do stuff like "vim -t tag" | |||
SamB | diakopter: what does a prime number have to do with it? | 03:49 | |
diakopter | SamB: isn't that how Godel represented the symbols in the formal languages he was analyzing? | ||
SamB | diakopter: there was no prime number | 03:50 | |
Auzon | alester: I ran ctags on one of my Perl 5 projects, and it just found the subroutine names and package names. Did I miss something? | ||
diakopter | I can't type the o with dots | ||
SamB: oh | |||
alester | Look at how ack or WWW-Mechanize do it. | ||
I have a "make tags" target in most of my projects. | |||
SamB | diakopter: just interpret the source file as a little-endian number ... | ||
diakopter | actually it probably would terminate if you split it at bytes... you'd only need up through the 256th prime (1619). (multiply all the primes together to get the Godel number) | 03:54 | |
of course | |||
that's wrong, b/c it doesn't preserve order of the bytes | |||
SamB | yeah -- just interpreting it as a radix-256 little-endian number is the thing to do | 03:55 | |
or ... well, something like that | |||
need to indicate termination somehow I guess | 03:56 | ||
well, that's easy if your programming language doesn't use NULs in source ;-) | |||
03:58
Alias_ left,
Alias_ joined
|
|||
diakopter | TimToady: SamB requests token nullator:sym<�> { <sym> <?before <sym>> } | 04:04 | |
SamB | what??? | 04:05 | |
diakopter | ;) | ||
SamB | that isn't a NUL! | ||
diakopter | oh :/ | 04:06 | |
SamB | that's a U+FFFD | ||
diakopter | silly irssi | ||
irc probably can't receive it anyway | |||
SamB | probably it would be misinterpreted as a CTCP request | ||
scrottie | Auzon, I seem to recall a "perl tags" package on CPAN. It outputs files in the ctags format but is a bit smarter about parsing Perl. Hrm. PPI... hmm. | 05:09 | |
05:13
Psyche^ joined
05:25
Psyche^ is now known as Patterner
05:44
eternaleye joined
05:52
jfredett_ joined
05:53
jfredett_ is now known as jfredett
|
|||
Alias_ | Alas, PPI is too slow for most purposes | 05:55 | |
Or at least, too slow for time-critical purposes | 05:57 | ||
scrottie | well, building the tags database is an off-line type activity | ||
I guess ctags in general was made for a generally static codebase, not this agile crap the kids are smoking. | |||
Alias_ | yup | 06:10 | |
06:18
luqui joined
06:21
Alias__ joined
06:23
Alias_ left
06:47
alester left
06:51
alester joined,
alester left
06:59
iblechbot joined
07:06
Maghnus joined
07:08
xinming joined
07:09
Maghnus left
07:12
Jedai joined,
Maghnus joined
07:16
masak joined
07:17
Helios` left,
Maghnus left,
Helios` joined
07:20
Maghnus joined
07:34
Alias__ left
07:48
xinming left
07:49
Jedai left
07:50
sri_work joined
08:02
Maghnus left
08:05
Maghnus joined
08:32
IRSeekBot joined,
xinming joined
08:36
elmex joined
08:46
lichtkind joined
08:53
meppl joined
08:58
penk joined
09:08
vixey` joined
09:09
apeiron left
09:10
vixey` is now known as vixey
09:23
bacek joined
|
|||
pugs_svnbot | r20984 | moritz++ | [spec] fixed eager_hyper.t - $counter++; needs to go before take $_; to get | 09:30 | |
r20984 | moritz++ | the expected results | |||
r20985 | moritz++ | [t] re-formulated rand() tasks in TASKS | 09:33 | ||
09:46
chris2 joined
|
|||
moritz_ | is Complex intended to be an immutable value? | 09:46 | |
ah, yes. Found the answer | 09:47 | ||
is anybody eager to discuss S29? | 09:51 | ||
our Seq multi method polar (Complex: $nim) is export | |||
shouldn't that be ... polar (Complex $nim:) ? | |||
10:00
penk left
|
|||
scrottie slams a mug of mead and then proceeds to look incredulous. | 10:01 | ||
10:02
meppl left
10:05
elmex left
|
|||
pugs_svnbot | r20986 | moritz++ | [util/perl6.vim] updated builtin types to closer match S02 | 10:05 | |
10:07
elmex joined
10:11
bacek left,
bacek joined
|
|||
moritz_ | rakudo: say pi / 2 | 10:32 | |
p6eval | rakudo r28673 OUTPUT[1.5708] | 10:33 | |
10:44
Jedai joined
10:51
a-jing joined,
a-jing left
|
|||
moritz_ | in @a[*-1], how is *-1 passed to postcircumfix:<[ ]> ? | 10:54 | |
10:55
luqui left
|
|||
spinclad | moritz_: re polar (Complex: $nim), i second you. | 11:05 | |
moritz_ | spinclad: thanks for backlogging and answering | 11:07 | |
pugs_svnbot | r20987 | moritz++ | [S29] fixed signatur for polar() | ||
spinclad | re *-1, as ... an Int? 'whatever less one': the day before Forever | ||
moritz_ | that doesn't make sense | 11:08 | |
so I somehow think it should be passed as a pair (Whatever, -1) or some such | |||
spinclad | (ie, as another special value of Int, like Int or (for Num) Inf or Nan) | 11:09 | |
moritz_ | -1 but Whatever? | ||
spinclad | but i'm not thrilled about multiplying entities in a basic class like Int | 11:10 | |
moritz_ | yes, that smells | ||
spinclad | if it were explicitly algebraic, so you could have 'x + 2', then saying it's simply '* - 1' would make sense to me | 11:11 | |
is (*-1) + 1 == * ? | 11:12 | ||
so i dunno | 11:13 | ||
moritz_ | I don't think you can do meaningful arithmetic with * | ||
just like you can't with Inf | |||
spinclad | oh, (Inf - 1) + 1 == Inf, it's just that Inf - 1 == Inf too :) | 11:14 | |
and Inf - Inf should be NaN | 11:15 | ||
moritz_ | standard mathematical notation doesn't even allow you to write Inf + 1 in an expression | ||
spinclad | perhaps because it simplifies? | 11:16 | |
omega + 1, otoh, is quite standard | |||
(omega: first ordinal infinity) | |||
moritz_ | yes | 11:17 | |
but people who know about omega usually know the common mistakes with Inf ;) | |||
btw it's so nice to chat with people who have a bit of mathematical background | 11:18 | ||
it doesn't make me feel I'm an isolated über-geek ;) | |||
spinclad | here too | ||
well, not isolated at least; and sometimes it's the right tool for the thinking | |||
moritz_ | (although I admit that (being a physicist) my approach to mathematics is sometimes overly pgramatic - "how cares if this integral is defined, as long as Mathematica can calculate its result" ;-) | 11:20 | |
s/how/who/ | |||
anyway, to return to the initial question, I think that pairs aren't a bad idea - I just haven't found it in the specs | 11:21 | ||
or is *-1 just frobbed into *, -1 ? | 11:22 | ||
spinclad | (i suspect mine may be overly abstract-nonsense - who cares about particular values, they're just maps from 1 to a target category) | 11:24 | |
looking at *-1 algebraicly, representing it as Poly(*, [1,-1]) suggests itself; Pair(*,-1) could work too. but i don't see a deciding thought here. | 11:27 | ||
11:28
mjk joined
|
|||
spinclad | i guess: an implementation chooses a canonical rep. could be C< { infix:<->(*, 1) } > (a closure node) if it likes... | 11:30 | |
anyway, back to bed... got up after half a night to meditate and backlog & | |||
moritz_ | closures are no good idea IMHO because they are harder to introspect than ordinary data structures | 11:32 | |
sleep well | |||
11:33
zamolxes joined
|
|||
SamB | moritz_: eh? | 11:33 | |
harder to introspect? | |||
moritz_ | SamB: in this context, if you have a closure $c, how do you determine if it's { infix:<->(*,1) } or { infix:<->(*,2) } ? | 11:34 | |
SamB | hmm. | 11:35 | |
well, I don't know what either of those are... so I dunno. | |||
spinclad | (represent them as lambda-expressions, as combinator apply-trees; canonicalize by left-most, innermost reduction (iirc)) | ||
SamB | spinclad: innermost? | 11:36 | |
I was under the impression that you repeatedly reduced the left-most redex | |||
which might have redexes as sub-expressions | 11:37 | ||
and would not be the subexpression of any other redex | |||
since I'd be measuring from the beginning | 11:38 | ||
going for the inner-most is STRICT evaluation... | |||
spinclad | sounds right... leftmost, lazymost reduction | ||
SamB | and normalizes less strongly | ||
spinclad | innermost may evaluate something unneeded, which may not halt... | 11:39 | |
SamB | you know what's really hard to introspect? | ||
spinclad | so half a thought gives a better answer | 11:40 | |
all right, what? # 'yo mama!' | 11:41 | ||
SamB | ... a value who's type you are polymorphic in | ||
spinclad | though if the type is constrained with a 'does Introspect' interface... | 11:43 | |
but if not, yeah | |||
12:01
chris2 left
12:17
wilx joined
|
|||
diakopter ponders call-by-need as applied to the top-level (statement list) and "rollup" activities necessary when the grammar is adapted/swapped. | 12:29 | ||
if each statement is viewed as an argument to a call of the program function... | 12:30 | ||
then 'program' evaluates its arguments successively, feeding the state changes left-to-right, so one of the arguments to each successive statment is the resulting state from the prior statement | 12:32 | ||
... unless statements are to be lazily evaluated as well...! | 12:33 | ||
any thoughts from anyone? | 12:34 | ||
12:34
alanhaggai joined
|
|||
diakopter | so if the 'program' is to be compiled, the parser/interpreter (as well as the original grammar's source!) itself would need to be embedded in the program if any argument's state-flow dependencies is non-deterministic input. | 12:39 | |
continuing along those lines, when parsing, the evaluation plan can be built by recursive calls to the parser with the input and the parser-set itself as the arguments to the parser. | 12:42 | ||
masak | rakudo: sub say { } say "is this printed?" | ||
p6eval | rakudo r28673 OUTPUT[Statement not terminated properly at line 1, near "say \"is th"current instr.: 'parrot;PGE::Util;die' pc 120 (runtime/parrot/library/PGE/Util.pir:82) | ||
masak | rakudo: sub say { }; say "is this printed?" | ||
p6eval | rakudo r28673 RESULT[Null PMC access in find_method()current instr.: '_block11' pc 38 (EVAL_13:18) | ||
diakopter | that would push parsing into call-by-need as well. | 12:43 | |
rakudo: sub say { sub say1 { 3.say; $_.say; }; say1(4); }; 5.say; | 12:47 | ||
p6eval | rakudo r28673 OUTPUT[maximum recursion depth exceededcurrent instr.: 'say' pc 100 (EVAL_11:48) | ||
diakopter | moritz_: I appear to have sent a non-terminating program to rakudo with an infinite recursion it couldn't detect: ... can you kill it? | 12:51 | |
Auzon: or you | |||
moritz_ | diakopter: sure | ||
evalbot control restart | |||
# just a different try | |||
diakopter | heh | 12:52 | |
apparently it's not listening | |||
moritz_ | sh: line 1: 6311 CPU time limit exceeded PUGS_SAFEMODE=true ./pugs /tmp/uOyoSWT3xI >>/tmp/7pc2xEY7Ax 2>&1 | ||
why doesn't that work for rakudo? | |||
diakopter | moritz_: :) not sure | ||
12:52
p6eval joined
|
|||
moritz_ | BSD::Resource only checks CPU time, not run time | 12:53 | |
maybe I should also limit runtime | |||
diakopter | apparently rakudo can detect *direct* infinite recursion, but not indirect. | ||
badrakudo: sub say2 { sub say1 { 3.say2; }; say1(4); }; 5.say2; | 12:54 | ||
pugs: sub say2 { sub say1 { 3.say2; }; say1(4); }; 5.say2; | 12:55 | ||
12:55
wknight8111 joined
|
|||
diakopter | hm. I guess pugs doesn't detect it either | 12:55 | |
p6eval | No output (you need to produce output to STDOUT) | ||
diakopter | well pugs eventually hits some kind of limit :) | 12:56 | |
kp6: sub say2 { sub say1 { 3.say2; }; say1(4); }; 5.say2; | |||
p6eval | kp6 r20987: OUTPUT[no method 'say2' in Class 'Int' at compiled/perl5-kp6-mp6/lib/KindaPerl6/Runtime/Perl5/MOP.pm line 345 | ||
diakopter | elf: sub say2 { sub say1 { 3.say2; }; say1(4); }; 5.say2; | 12:57 | |
p6eval | OUTPUT[Can't call method "say2" without a package or object reference at (eval 119) line 5. at ./elf_f line 3854] | ||
moritz_ | those two don't implement method fallback | ||
diakopter | oh | ||
kp6: sub say2 { sub say1 { say2; }; say1; }; say2; | 12:58 | ||
p6eval | kp6 r20987: No output (you need to produce output to STDOUT) | ||
diakopter | oh wait | 12:59 | |
the earlier non-terminating input - I sent it to perl6:, not just rakudo: oops. I guess I should try just rakudo | 13:00 | ||
rakudo: sub say2 { sub say1 { say2; }; say1; }; say2; | 13:01 | ||
p6eval | rakudo r28673 OUTPUT[maximum recursion depth exceededcurrent instr.: 'say2' pc 88 (EVAL_11:44) | ||
moritz_ | no stale perl 6 procoess whatsoever on $server | ||
diakopter | moritz_: yeah; it was only pugs that froze earlier | ||
er, boiled. | |||
moritz_ | $state_change ;) | 13:03 | |
diakopter | sublimated | ||
plasmified | |||
moritz_ | $change_of_state_of_aggregation | ||
diakopter | fissioned | 13:04 | |
moritz_ | cold fissioned? ;) | ||
diakopter | I guess there should be a way to tell rakudo what its recursion depth limit should be, when you want it to be quite deep. | 13:05 | |
and preferably not at rakudo-compile-time | |||
moritz_ | yes, but IMHO that's none of the iimportant features to implement atm | 13:06 | |
diakopter | but if the recursion limit is less than a hundred... | ||
moritz_ | is it? | ||
diakopter | I don't know | ||
moritz_ | then don't worry until you hit that barrier | 13:07 | |
diakopter | commute& | ||
pugs_svnbot | r20988 | diakopter++ | [yap6] disregard; work-in-progress. | 13:08 | |
pmichaud | (*-1 from backscroll): iirc, then *-1 becomes a special value of "whatever" that gets passed to postcircumfix:<[ ]> | 13:25 | |
it was described around a year ago on p6l | |||
but it's still just a single argument -- it just happens to be an "interesting" value of whatever (similar to how we can have "interesting" values of undef :-) | |||
13:36
ludan joined
13:40
rdice joined
13:41
Lorn joined
|
|||
diakopter | reconfigured yap6's parser builders to call-by-need | 13:50 | |
along the way found a non-working memoization, and fixed it, yielding who-knows-how-much efficiency improvement | 13:51 | ||
when inside several layers of nested closures, calls to memoize() aren't as reliable... | 13:52 | ||
inlining my own memoization works a lot better :) | |||
moritz_ can't find the thread, searching again | |||
13:56
iblechbot left
13:59
aindilis joined
14:01
wknight8111 left
14:03
pbuetow joined
14:05
GeJ joined
14:07
GeJ left
14:08
GeJ joined
14:10
stevan_ joined,
aindilis left
14:18
laurent_88 joined
14:26
stevan_ left
14:28
mjk left
|
|||
moritz_ | techfaux.com/2008/06/17/peta-target...-protests/ # OMFG | 14:28 | |
lambdabot | Title: TechFaux.com - Beta xBB Blog Archive xBB PETA Targets Computer Programmers With Stri ..., tinyurl.com/6klbg2 | 14:29 | |
14:31
stevan_ joined
|
|||
pugs_svnbot | r20989 | rhr++ | Add docs/p6types - a description of specced p6 roles, classes, and methods from the synopses | 14:31 | |
r20989 | rhr++ | it's meant to be sort of a roadmap for p6 library/Prelude development | |||
r20989 | rhr++ | currently covers S02 and S03 (I ran out of time and tuits), please add more! | |||
14:34
alanhaggai left
|
|||
pmichaud | I can't find the p6l thread about whatever * either (other than the one that introduced the concept), so maybe I'm misremembering. | 14:34 | |
moritz_ | ok, I'll compose a mail to the list later | ||
pmichaud | I do recall hearing from @Larry that *-2 was passed as "whatever with an offset" | 14:35 | |
and that it's then evaluated in context | |||
diakopter | pmichaud: tinyurl.com/4hcbsk | 14:36 | |
lambdabot | Title: Question on your last change to S02 - perl.perl6.language | Google Groups | ||
pmichaud | diakopter++ # thanks, found it | 14:37 | |
14:38
jhorwitz joined
|
|||
moritz_ | diakopter++ indeed | 14:38 | |
14:42
redicaps joined
14:52
laurent_88 left
|
|||
moritz_ | pugs: my @a = 1, 2, 3; if @a -> $b { say $b.perl } | 14:52 | |
p6eval | OUTPUT[*** Cannot bind to non-existing variable: "$b" at /tmp/99rBB5Nnqx line 1, column 1] | ||
moritz_ | rakudo: my @a = 1, 2, 3; if @a -> $b { say $b.perl } | ||
p6eval | rakudo r28675 OUTPUT[Statement not terminated properly at line 1, near "-> $b { sa"current instr.: 'parrot;PGE::Util;die' pc 120 (runtime/parrot/library/PGE/Util.pir:82) | ||
14:55
hercynium joined
|
|||
rakudo_svn | r28676 | pmichaud++ | [rakudo]: | 14:56 | |
r28676 | pmichaud++ | * Update spectest-progress.csv | |||
r28676 | pmichaud++ | * 66 files, 849 passing tests | |||
14:57
TJCRI joined
15:05
alanhaggai joined
15:07
redicaps left
15:10
Alias__ joined
15:19
ludan left
|
|||
pugs_svnbot | r20990 | rhr++ | [spec] S29-str/uc.t - ?\195?\159 -> SS is correct by Unicode 5.1.0 | 15:19 | |
15:27
clintongormley joined
|
|||
TimToady | well, it's possible that the semantic type of * is "Equation with scalar unknown", while the type of ** is "Equation with list unknown" | 15:28 | |
or maybe slice unknown | |||
masak | TimToady: what should happen if I did `sub say { ... }` in my code? | ||
TimToady | an only sub should hide the built-in | 15:29 | |
masak | ok | ||
TimToady | well, if it's "my sub" | ||
masak | and otherwise? | ||
TimToady | not clear for a package sub | ||
but I think that it should also probably hide | |||
masak | so why the 'my'? | ||
TimToady | hides in a tighter scope | 15:30 | |
15:30
Khisanth joined
|
|||
TimToady | well, might be tighter or looser | 15:30 | |
packages being independent of lexical scopes | |||
but subs defined in current package should probably be considered a scope between prelude scope and file scope | 15:31 | ||
if "prelude" scope is considered a lexical scope outside file scope | |||
that is, when searching for sub "foo", look outward in lexical scopes through file scope, then package scope, then prelude scope | 15:32 | ||
on *-1, my feeling is that it should probably be a separate type for multi dispatch purposes, neither Int nor Whatever | 15:35 | ||
so if there's a Relative or Unknown or Equation type, then a sig based on Whatever can reject it based on type | 15:36 | ||
pmichaud | that makes sense | ||
TimToady | so you get a mismatch if you say "foo" x *-1 | ||
pmichaud | I was also wondering about things like */2 | ||
which aren't simply linear offsets | 15:37 | ||
TimToady | that would be legal under an equational view | ||
pmichaud | agreed. | ||
TimToady | I believe Range objects are required to perform similar transformations | ||
so (1..10) + 5 is 6..15, etc | 15:38 | ||
15:38
zamolxes left
|
|||
TimToady | but Ranges don't usually have to do it lazily, as far as I can tell | 15:39 | |
it's also not clear how to handle range tests when the range goes non-linear | 15:40 | ||
vixey | pugs: (-2..2) ** 2 | ||
p6eval | RESULT[25/1] | ||
TimToady | pugs doesn't know ranges | ||
pugs: (-2,-1,0,1,2)**2 | |||
p6eval | RESULT[25/1] | ||
TimToady | pugs: 5**2 | ||
p6eval | RESULT[25/1] | ||
vixey | would maybe (-2..2) ** 2 = (0..2) & (0..2) ? | ||
TimToady | I don't do higher math :) | 15:41 | |
moritz_ | I hope you don't rely on the method dispatcher to solve algebraic equations ;) | 15:42 | |
TimToady | no, but the method dispatcher can hopefully detect the *need* for algebraic reasoning | 15:43 | |
15:43
jjore joined
|
|||
TimToady | and some of these constructs could be viewed as parametric types, I suppose | 15:44 | |
but I don't plan to solve the (-2..2)**2 problem for 6.0.0 | 15:45 | ||
moritz_ | I don't see an intuitie solution for it | ||
(perhaps other than constructing a two-dimensional range, against which you can match lists of two items) | 15:46 | ||
TimToady | though a Whatever that transforms Fahrenheit to Celsius is probably workable :) | ||
15:46
justatheory joined
|
|||
TimToady | there's doubtless some deep connection with coercions in here too | 15:47 | |
and maybe with dimensional analysis | 15:48 | ||
moritz_ | "dimensional analysis" sounds scary ;) | 15:51 | |
but actually it's quite nice they way it's used in physics | |||
TimToady | indeed | 15:52 | |
moritz_ | one of our teachers finished early with what he had to teach us, and then spent two hours teaching us d.a. | 15:53 | |
it's amazing what you can derive with it | |||
rhr | if you allow arithmetic with * and **, how do you parse ******** or * ** * * ** ** * ** ** * * ? | 15:58 | |
TimToady | at some point you should use real functions :) | 16:01 | |
rhr | no doubt :) | ||
TimToady | * is just the "what it is" function :) | ||
and ** is the "what they are" function | 16:02 | ||
or maybe I should say the "whatever it is" function | |||
16:02
clintongormley left
16:03
meppl joined
16:04
kanru joined
|
|||
TimToady | so maybe the type of * is really Code[:($)] or some such, and ** is Code[:(*@@)] | 16:06 | |
and the value of * is really sub ($x) { $x }, the identity function | 16:07 | ||
or -> $x { $x } in lambda-ese | |||
pmichaud | rhr: parsing * ** * * ** ** * ** ** * * is just { say "Whatever!" } :-P | 16:08 | |
or perhaps that should be { .panic("Whatever!") } | |||
TimToady | actually, that fails very early with "two terms in a row" | ||
16:10
kanru left
|
|||
TimToady | but if that is the type of *, then we ought to be able to write "foo" x -> $x { $x } to mean the same thing, and I'm not sure that's a good idea | 16:10 | |
16:10
kanru joined
|
|||
TimToady | so I think I still would like Whatever to be the identity function, and the other functions be a type that is easily dispatched elsewhere | 16:11 | |
since we know that there's not much point in calling the function when it's the identity function | |||
16:13
armagad joined
|
|||
TimToady | so maybe Whatever is a subtype of Transform that happens to be identity | 16:13 | |
rhr | Transform is Code[:($ --> $)] or some such? | 16:14 | |
16:15
meppl left
|
|||
TimToady | nodnod | 16:19 | |
16:20
iblechbot joined
16:38
Lorn left
16:40
a-jing joined,
a-jing left
16:43
Lorn joined
16:46
araujo joined
16:47
Alias__ left
16:52
[particle] joined
16:59
armagad left
17:16
cognominal_ joined
17:17
Jedai left
17:21
barney joined
17:23
meppl joined
|
|||
pugs_svnbot | r20991 | Auzon++ | [gsoc_spectest] Added more tests to eager_hyper.t to check that counting the elements in the iterator completes it. (added 2 tests). | 17:29 | |
Auzon | perl6: say "{}" | 17:48 | |
p6eval | kp6 r20991: OUTPUT[{}] | ||
..pugs: OUTPUT[] | |||
..rakudo r28677: OUTPUT[Null PMC access in get_string()current instr.: 'print' pc 9875 (src/gen_builtins.pir:6483) | |||
..elf r20991: OUTPUT[{}] | |||
DietCoke | elf? | 17:50 | |
17:54
Jedai joined
17:57
wknight8111 joined
|
|||
Auzon | elf! | 17:58 | |
It's primarily mncharity's project to write a P6 compiler written in P6 that runs on P5 and does AST things using STD_red. | 17:59 | ||
DietCoke | elf is primarily mncharity's project to write a P6 compiler written in P6 that runs on P5 and does AST things using STD_red. | ||
(danke, feeding the bot if there's one) | 18:00 | ||
TimToady | no purl here | ||
18:00
masak left
|
|||
DietCoke | elf? | 18:00 | |
Auzon | perlbot: help | ||
DietCoke | not even a stupidbot. ah well. | ||
perlbot | (fact) : tell (who) about (what) : (what) > (who) : learn (what) as (info) : relearn (fact) as (info) : phone (phone #) : shorten (url) : shorten it : search (keyword) : cpan (mod) : docs (mod) : perldoc -f (func) : jargon (term) : math (expr): fortune : flip : host (type) (record) : rot13 (text) : roll (die) : tempconv (temp) : scramble (foo) : 8ball (question) : slap (who) : diss (who) : top/bottom (num) karma : geoip (ip) | ||
TimToady | diss TimToady | 18:01 | |
perlbot: diss TimToady | |||
perlbot | TimToady is my little bitch. | ||
pmichaud | pugs: sub foo() { }; say foo().WHAT; | ||
p6eval | OUTPUT[Scalar] | ||
pmichaud | hrm. | 18:02 | |
Auzon | perlbot: slap perlbot | ||
perlbot slaps perlbot around a bit with a large trout | |||
Auzon | How useful | ||
diakopter | perlbot: 8ball Xmas? | ||
perlbot | Magic 8ball says: Yes | ||
TimToady | should probably be returning Object, or something equally undeffigeneric | ||
pmichaud | Object? Failure? Whatever? | 18:03 | |
TimToady | not Whatever, that's only for users to use | ||
pmichaud | I can have it return Object. | ||
TimToady | in Soviet Perl, Whatever asks *you* to dwim | ||
diakopter | perlbot: diss perlbot | 18:04 | |
perlbot | OMG perlbot sucks. | ||
TimToady | well, Object is generic undef | ||
pugs: say undef.WHAT | |||
p6eval | OUTPUT[Scalar] | ||
pmichaud | by Object do you mean the protoobject for Object ? | 18:05 | |
TimToady | Scalar is not quite right, since undef shouldn't be considered a container | ||
pmichaud | or an instance of Object (besides the protoobject)? | ||
TimToady | the protoobject | ||
pmichaud | okay | ||
works very well for me | |||
TimToady | an instance of it wouldn't be undefined, presumably | ||
though Object may well refuse to instantiate... | 18:06 | ||
on the other hand, Object.new could just be the empty defined object | |||
pugs: say Object.defined | 18:07 | ||
p6eval | OUTPUT[] | ||
pmichaud | should Object be the return value for any routine that doesn't explicitly provide one somehow? | ||
TimToady | pugs: say Object.new.defined | ||
p6eval | OUTPUT[1] | ||
TimToady | heh | ||
hmm, well, bare return returns () or some such, so maybe item () returns Object | 18:08 | ||
seems a bit harsh to call it a Failure | |||
pmichaud | S02:3175 sez: Note that if you could | 18:09 | |
instantiate an C<Object> it would be considered defined, and thus true. | |||
(It is not clear that this is allowed, however.) | |||
TimToady | clear specs++ :) | ||
pmichaud | currently in rakudo item() is returning an empty Array. | ||
(just worked out that way -- I can change it to whatever else.) | |||
having item() return Object makes sense, though. | |||
TimToady | well, something to be said for that view too, except you wouldn't expect item() to be defined, really | 18:10 | |
and I think expecting Void context and returning nothing should result in something undefined if you're not really in Void context | 18:11 | ||
pmichaud | agreed. | ||
TimToady | but I'd also like to have a variety of undef that interpolates () into list context, and Object doesn't quite seem to be it | 18:12 | |
pmichaud | could Object.list() return an empty list if the invocant is undefined? | 18:13 | |
TimToady | so possibly item() is just (), in a Capturely way rather than an Arrayly way | ||
we could make @(Object) return a null list | 18:14 | ||
not sure what the ramifications of that would be, though | |||
pmichaud | otoh, if I have sub foo() { return; } and then my $x = foo(); perhaps $x should be some sort of Failure object? | 18:15 | |
TimToady | return is already defined to return a Capture, so maybe item(Capture) returns Capture if the item slot is missing? <scratches head> | ||
pmichaud | which would be different from having return (); | 18:16 | |
TimToady | maybe, if a Capture naturally, er, captures that info. wouldn't want to force it too much though for efficiency reasons | 18:17 | |
I guess () has to be there in the Capture, or you couldn | |||
couldn't bind it to a scalar param correctly | |||
my ($a,$b) := ( (), () ); probably needs to do something rational | 18:19 | ||
pmichaud boggles | |||
TimToady | as does: my ($a,$b) := ( a(), b() ); | ||
Auzon | rakudo: say #{{ }} 'ok'; | 18:20 | |
p6eval | rakudo r28678 OUTPUT[] | ||
TimToady | pugs: my ($a, $b) := ( list(1,2,3), list(4,5,6) ); say $b | 18:21 | |
p6eval | OUTPUT[456] | ||
TimToady | that looks correct | ||
18:21
cjfields joined
|
|||
TimToady | though probably because pugs is generating a List object rather than a Capture object, but a list of Captures should behave similarly | 18:22 | |
(when bound to a sequence of scalar params) | |||
pmichaud | pugs: my $b = list(4,5,6); say $b | 18:23 | |
p6eval | OUTPUT[4 5 6] | ||
pmichaud | pugs: my $b := list(4,5,6); say $b | 18:24 | |
p6eval | OUTPUT[456] | ||
pmichaud | okay. | ||
TimToady | pugs: my $b = list(4,5,6); say $b.WHAT | ||
p6eval | OUTPUT[Array] | ||
TimToady | pugs: my $b := list(4,5,6); say $b.WHAT | ||
p6eval | OUTPUT[Array::Const] | ||
TimToady | heh | ||
cjfields | TimToady: wanted to ask yesterday, but with methods versions of trans(), substr(), match(), are we allowing modifiers? | 18:25 | |
TimToady | sure, they're just named args | ||
cjfields | ok | 18:26 | |
TimToady | they're even spelled the same way: :g | ||
you just pass 'em as args instead of keeping them out front | |||
and the replacement in subst can be a closure to do the s[foo] ~= 'bar' kind of stuff | 18:27 | ||
cjfields | Do we want to keep :c for trans()? I'm thinking of the many-to-one issue. | 18:28 | |
that would be 'complement' for those who got the emoticon | 18:29 | ||
TimToady | we could have it if it were defined carefully as "any character that does not match one of these", where "one of these" can be of variable length | 18:30 | |
it's really the same as <-[a..z]> processing in regular pattern matching | 18:31 | ||
that means skip '.' unless the class matches | |||
there's no requirement that '.' match the same length as all the elements in the class | |||
though with our default of graphemes, it generally will be the same in terms of grapheme count | 18:32 | ||
(since graphemes include any combining characters as part of the "character") | |||
cjfields | okay, thanks, that helps. | 18:33 | |
TimToady | I think being grapheme-centric rather than codepoint-centric will be one of the ways in which p6 will be a disruptive technology | ||
the user shouldn't have to worry about various Unicode representations, by default | 18:34 | ||
cjfields | The use of modifiers for methods, and what the modifiers mean in the context of p6 isn't indicated in S05 | 18:35 | |
Don't know if it should be clarified or not | |||
but if might help as we start implementing more and more in Rakudo | 18:36 | ||
TimToady | I we clarify everything everywhere, we get a combinatoric explosion :) | ||
*If | |||
cjfields | heh, true | ||
TimToady | but that could be a valid candidate | ||
cjfields | main reason I'm working on this is for a revised bioperl (which is a mess) | 18:37 | |
so I'll be putting the grammars to good use at some point | |||
cjfields doesn't think {*} works with rakudo grammars yet | 18:38 | ||
pmichaud | do you mean actual closures, or the {*} token? | ||
cjfields | closures | 18:39 | |
pmichaud | correct, we don't have that in rakudo yet. The hooks are there, though -- just need filling in. | ||
cjfields | though I haven't toyed around with them enough | 18:40 | |
ok | |||
18:43
ispy_ joined
18:47
Maghnus left
|
|||
TimToady | they kinda work in STD5 if you are careful to write in the subset of Perl 6 that gimme5 can fake into Perl 5 | 18:49 | |
Tene | hmm. closures in rakudo might be fun to work on. | 18:51 | |
18:51
aindilis joined
18:55
Alias_ joined
|
|||
cjfields | Tene: agreed | 19:03 | |
19:10
cognominal__ joined
19:11
cognominal_ left
19:20
Chillance joined
|
|||
Auzon | (diff -w)++ | 19:22 | |
pmichaud | rakudo already supports closures (sorta, see :outer/lexicals discussion elsewhere)... PGE just doesn't recognize them in regexes yet. | 19:25 | |
19:27
cognominal__ left
19:34
hercynium left
19:40
cognominal_ joined
19:50
armagad joined
19:59
gbarr joined,
gbarr left
20:13
LowBass joined
20:16
pmurias joined
20:20
barney left
|
|||
Auzon | pugs: say +^1 | 20:32 | |
p6eval | OUTPUT[-2] | ||
Auzon | pugs: say +^1.WHAT | ||
p6eval | OUTPUT[-1] | ||
Auzon | pugs: say (+^1).WHAT | ||
p6eval | OUTPUT[Int] | ||
moritz_ | prefix:<+> on a listy thingy should always return an Int I think | 20:33 | |
pugs_svnbot | r20992 | pmurias++ | [STD] | ||
r20992 | pmurias++ | added a {*} to arglist | |||
r20992 | pmurias++ | [pixie] | |||
r20992 | pmurias++ | initial commit on pixie - it's a STD frontend to elf | |||
r20992 | pmurias++ | mostly hello world works now | |||
r20992 | pmurias++ | the closures will be translated to p6 soon, pixie_actions contains the not yet used p6 | |||
pmurias | TimToady: elfish closures will be supported externaly in STD soon | ||
20:33
sri_work left
|
|||
moritz_ | pixie++ | 20:34 | |
pmurias | it's a hack now | ||
but it would be nice to have it in evalbot soon | |||
moritz_ | sure, how is it called? | 20:35 | |
pmurias | perl pixie --quiet < code_file | ||
moritz_ | ok, will do | 20:36 | |
no compilation required on evalbot side, right? | |||
btw evalbot needs refactoring - too much duplicated code | |||
pmurias | moritz_: you should run brew to compile pixie | ||
moritz_ | just `sh brew'? | 20:37 | |
20:37
Jedai left
20:38
p6eval left
20:39
p6eval joined
|
|||
pmurias | moritz_: yes | 20:39 | |
as described in the readme | |||
README | |||
what's the best way to get the result from a array of match objects? | 20:40 | ||
moritz_ sees no readme in misc/pixie/ | |||
20:41
b_jonas joined
|
|||
moritz_ | pmurias: what do you mean? | 20:41 | |
pmurias | sorry, forgot to svn add it | ||
moritz_: @array_of_match_object.map({$$_}) | |||
pugs_svnbot | r20993 | pmurias++ | [pixie] added README | 20:42 | |
diakopter | psixie with a silent p? | ||
pmurias | diakopter: if you like it that way | 20:43 | |
diakopter: hi | |||
diakopter | pmurias: hi | ||
almost done with the match object tree generation for yap6 | 20:44 | ||
moritz_ | evalbot control restart | ||
20:44
p6eval left
|
|||
pugs_svnbot | r20994 | moritz++ | [evalbot] added pixie (but not yet included in perl6: target) | 20:44 | |
20:44
aindilis left,
p6eval joined
|
|||
moritz_ | pixie: say "hi"; | 20:45 | |
p6eval | OUTPUT[sh: ./pixie: Permission denied] | ||
moritz_ is dump | |||
dumb even ;) | |||
evalbot control restart | 20:46 | ||
20:46
p6eval left
|
|||
pugs_svnbot | r20995 | moritz++ | [evalbot] use perl to execute pixie ;) | 20:46 | |
20:46
p6eval joined
|
|||
moritz_ | pixie: say "hi"; | 20:47 | |
p6eval | OUTPUT[sh: ./pixie: Permission denied] | ||
20:47
p6eval left
|
|||
moritz_ | it might help to svn up before restarting | 20:47 | |
20:47
p6eval joined
|
|||
moritz_ | pixie: say "hi"; | 20:47 | |
p6eval | OUTPUT[Can't locate STD5.pm in @INC (@INC contains: ../../src/perl6 /etc/perl /usr/local/lib/perl/5.8.8 /usr/local/share/perl/5.8.8 /usr/lib/perl5 /usr/share/perl5 /usr/lib/perl/5.8 /usr/share/perl/5.8 /usr/local/lib/site_perl .) at pixie line 4.BEGIN failed--compilation aborted at pix... | ||
diakopter | gotta run gimme5..? | 20:48 | |
pmurias | yes | ||
diakopter: what is the intended advantage of yap6 over STD5? | |||
diakopter | you better hope moritz_'s server runs linux :D | ||
Auzon | It runs Debian | ||
moritz_ | which in turn needs perl 5.10 to run | ||
sigh | |||
I can just as well upgrade evalbot's chroot to lenny | 20:49 | ||
Auzon | Does Debian stable ship 5.10 yet? | ||
moritz_ | Auzon: no, only testing | ||
diakopter | advantage? for me to learn to write a parser [engine] (and maybe a compiler [engine]). | ||
moritz_ | Auzon: stable doesn't do version updates at all | ||
Auzon | I could compile us 5.10 if you'd prefer not to upgrade everything... | ||
My 5.10 that I compiled on F8 was nice and fast | |||
diakopter recommends building specially.. | |||
moritz_ | Auzon: I do prefer upgrading everything ;) | 20:50 | |
Auzon | Faster than 5.10 that F9 shipped... | ||
diakopter | Auzon: w/ threads? | ||
moritz_ | Auzon: it has to be done anyway, and then we can get rid of the self-compiled ruby as well | ||
it'll just take some work | |||
doing a backup first | 20:51 | ||
Auzon | diakopter: Uhhh, yeah. My F8 5.10 was 32-bit defaults; my F9 is 64-bit from distro (which includes threading). So that's probably it. | ||
diakopter | pmurias: you saw my answer to whither yap6? | 20:52 | |
moritz_ | IO is a bit slow on the server :/ | 20:56 | |
Auzon | moritz_: Perhaps we could eliminate the need for files to be written for evalbot if they accept input via STDIN? | 20:57 | |
pmurias | diakopter: yes | ||
moritz_ | Auzon: it's not *that* slow. I just noticed it when copying the whole chroot | 20:58 | |
Auzon | oh. :P | ||
moritz_ | Auzon: I decided against that because I didn't know if all implementations would support it | ||
anyway, the plan is to 1) copy the whole chroot to /new_chroot/ (currently named old_chroot, I'm going to change that... ) | 20:59 | ||
2) in /new_chroot/, upgrade to testing aka lenny | |||
3) re-install all needed perl modules | |||
4) test the implementations there | |||
5) switch to it | |||
pmurias | diakopter: re compiler [engine] part, starting a yet another one perl6 *compiler* wouldn't be a good idea | 21:00 | |
how do i type the unicode << in vim? | 21:01 | ||
or the cent? | |||
TimToady | ^K<< | 21:02 | |
^KCt | |||
moritz_ | its AltGr+y for me ;) | ||
TimToady | or (for me) right-menu << or c/ | ||
pmurias | TimToady: thanks | 21:03 | |
TimToady | when in doubt, say :digraphs | ||
pmurias | i prefere not too use the mouse for coding unless i'm forced | ||
TimToady | :dig for short | 21:04 | |
somewhere I've got a program to grep through Linux's compose key database too, but I always forget where I put it | |||
b_jonas | I've put those few funny unicode characters that I need to caps-lock plus numbers in my keyboard | 21:05 | |
so « is capslock-shift-6 now | |||
TimToady | which is just as many keystrokes as AltGr < < | 21:06 | |
moritz_ | and one more than AltGr y ;-) | ||
b_jonas | well, I rarely need those | ||
TimToady | and the << is fast because it's a repeat | ||
b_jonas | I don't write perl6 code where I'd actually need « | ||
TimToady | my favorite is AltGr oo for ° | ||
but I wish I could install the vim bindings under AltGr | 21:07 | ||
never figgered out how to do that... | |||
pmurias | $<<array_of_match_objects is legal? | ||
b_jonas | and in the few cases when I actually need to write natural languages correctly, I write in LaTeX anyway so I just use commands which are ascii | ||
moritz_ | TimToady: probably not handled at viim level | ||
TimToady | moritz_: huh? | 21:08 | |
b_jonas | I only put them there because I already had caps-lock as a modifier key for hungarian letters | ||
moritz_ | TimToady: probably it's done on the X layer, and vim only sees what X forwards to it | ||
b_jonas | so it was easy to set up | ||
moritz_ | TimToady: or even in kernel space | ||
TimToady | er, I meant pmurias: huh? | ||
pmurias | TimToady: a hyper op version of applying $ to match objects | 21:09 | |
TimToady | moritz_: I meant, to take the vim format of digraphs and just translate it to whatever X uses | ||
wasn't intending to use a real vim to do it | 21:10 | ||
moritz_ | TimToady: ah, that's a different thing | ||
TimToady | since $ is a listop, it requires space, so $« would also require a following space, I suspect | ||
but I haven't thought much about hyperizing listops | |||
pmurias | $« @foo? | 21:11 | |
b_jonas | I think you could set up the X keyboard layout to compose whatever keystrokes you want to unused function keysyms, and then bind those keysyms to something in vim | 21:12 | |
TimToady | presumably that could be made to work, though currently the token is considered $\s | ||
b_jonas | depends on your configuration | ||
TimToady | b_jonas: don't wanna think that hard, just want vim bindings at the shell prompt :) | ||
the readline vi bindings aren't that smart, I suspect | 21:13 | ||
b_jonas | TimToady: do you actually want to bind compose and two keys? | ||
to a command/ | |||
TimToady | there's a database of all the sequences that you can compose, I just want to add the vim sequences | ||
b_jonas | ah, I see | ||
that's different | 21:14 | ||
I've no idea actually | |||
TimToady | so that, for instance AltGr Ct would do what AltGr c/ does | ||
b_jonas | I don't have composes in X so I don't know how it works | ||
TimToady | (not that I'd use that one...) | ||
I kinda like c/ | |||
Juerd | TimToady: It's in a file called Compose | ||
TimToady | yes, but that has to be compiled somewhere somehow | ||
b_jonas | last time I've seen composes was when I edited linux console keymaps | ||
and I didn't use them at that time either | |||
TimToady | and that's the part I've never figgered | ||
Juerd | TimToady: NAFAIK | ||
b_jonas | I juse seen them in the same original file as the rest of the keymap way | ||
was | |||
Juerd | I recall having changed Compose and being able to use it after restarting xdm | 21:15 | |
TimToady | well, I edit the file I think it uses, and it ignores me, but maybe it's different now | ||
haven't tried in a while | |||
Juerd | TimToady: There might be multiple Compose files. One per locale I believe. | ||
b_jonas | what? | ||
one per locale? | |||
Juerd | Or was it one per keyboard. I'm not sure. | ||
TimToady | I'm sure there's a way to do it, but I've been notably unsuccessful so far, is all | ||
b_jonas | how can it depend on the locale if it's handled by X itself? | 21:16 | |
oh, one per keyboard layout | |||
makes more sense that way | |||
TimToady | do locate Compose on linux and you'll see 'em all | ||
FSVO linux and locate | 21:17 | ||
pugs_svnbot | r20996 | Auzon++ | [gsoc_spectest] fixed test cases repeatedly assigning 'my $a' in the same scope. Also added one test for two's completement on Integers. (added 1 test) | ||
Auzon is thinking about moving t/data_types somehow. | |||
moritz_ | S02-types/builtin-types.t or something? | 21:19 | |
21:19
TJCRI left
|
|||
moritz_ | btw some tests seem to overlap with S02-liters/radix.t | 21:20 | |
but IIRC radix.t doesn't check WHAT | |||
21:20
pmurias left
|
|||
moritz_ | is($a, 36893488147419103232, "we have bignums, not weeny floats"); | 21:22 | |
I like that ;) | |||
Auzon | Heh. Yeah, I wish I could take credit for amusing things like that | 21:23 | |
So is there any opposition to me moving t/data_types/* to t/spec/S02-builtin_data_types ? | |||
moritz_ | what other files would you add to that directory? | ||
moritz_ likes the idea of a S02-types/ dir better, and can imagine other tests might fit there | 21:24 | ||
Auzon | There's a bunch of tests there, such as ones for arrays, bools, enums, hashs, lists, nums, pairs, blocks, and subtypes | ||
moritz_ | ok, then it's fine | ||
Auzon | S02-builtin_data_types is mostly empty | ||
moritz_ | I didn't see it alredy existed, sorry for the noise | 21:25 | |
Auzon | It's ok. :) | ||
diakopter | perhaps Prelude tests should be marked/organized as such? | 21:26 | |
moritz_ | I had nearly the same idea | ||
at some point it might be worth trying to separate prelude tests from language tests | 21:27 | ||
but sometimes it's hard for me to figure out what exactly is prelude, and what not | |||
Auzon | Presumably, prelude tests should belong in its implementation's test directory | ||
b_jonas | how would language tests even work without a prelude? | 21:28 | |
moritz_ | no, because they are specced, and thus part of the language | ||
b_jonas | they work with iniperl6 or something/ | ||
21:28
wknight8111 left
|
|||
diakopter | I wonder if multiple Prelude interpretations are permitted | 21:28 | |
implementations, I mean | |||
21:28
armagad left
|
|||
diakopter | I mean, other than the obvious yes | 21:29 | |
pmurias: what's wrong with wanting to learn how to write a compiler [engine]? | 21:30 | ||
21:32
cjfields left
|
|||
moritz_ hopes he's upgrading the debian in the right chroot (or even in the chroot at all) | 21:32 | ||
21:33
rdice left
|
|||
b_jonas | diakopter: how would they coexist? same parrot space, or just different ones? | 21:34 | |
pugs_svnbot | r20997 | Auzon++ | [gsoc_spectest] t/data_types/* -> t/spec/S02-builtin_data_types/ | ||
b_jonas | in the second case I'd say surely yes, in the first case you'd have to take a bit of care so they don't clash (even if they're two copies of the same code) | 21:35 | |
moritz_ runs one of his magic tools to see if some of the newly moved tests pass on rakudo | 21:36 | ||
diakopter | b_jonas: what do you mean | 21:38 | |
oh, Preludes | |||
I meant each implementation having its own | |||
b_jonas | diakopter: oh sure in that case | ||
they'd probably need to have separate preludes | |||
diakopter | but why'd you mention parrot | ||
b_jonas | because some parts of the prelude would depend on internals of that implementations | 21:39 | |
parrot's not important | |||
just whether it's in the same runtime space | |||
like, whether some parts of the program could e.g. see an Array defined by one prelude and expecting an Array defined by the other prelude | |||
or some other problem like that | |||
probably that exact thing won't be the problem because of roles and stuff | 21:40 | ||
(no-one actually wants an Array anyway) | |||
but something like that | |||
diakopter | BADArray | ||
b_jonas | like | ||
I don't know | |||
moritz_ | b_jonas: you could define a scheme that an implementation may provide parts of the prelude, and the rest is then loaded, which defines plain *everything*, and all definitions that are already there are ignored | ||
so if you can implement foo() in terms of bar() and the other way round, your prelude just includes both | 21:41 | ||
b_jonas | moritz_: yeah | ||
moritz_ | and the implementation has provide at least one of them | ||
b_jonas | actually it might be good if the prelude is coded so it's idempotent | ||
like plain.tex is | |||
diakopter looks up that word for the 3rd time this week | 21:42 | ||
moritz_ | my English <-> German translator says: English: idempotent. German: idempotent. | 21:44 | |
21:44
jfredett_ joined
|
|||
b_jonas | idempotent here means that you could load it a second time after it's already loaded and the second instance changes nothing | 21:45 | |
moritz_ | ah, f(f(x)) = f(x) for all x | ||
b_jonas: that would be automatically true in the scheme I described above | |||
TimToady | on the other hand, loading something only to override it is wasted computation on every invocation, unless you can freeze a checkpoint or something | 21:48 | |
(which you probably want anyway) | |||
diakopter | .pmc | ||
b_jonas | moritz_: I'm not completely familiar in what tasks are delegated to the perl6 prelude | 21:49 | |
but it can probably be solved that way | |||
21:49
jfredett left,
jfredett_ is now known as jfredett
|
|||
TimToady | from the user's point of view it should not matter at all whether something is defined by the parser or by the prelude. most of the operators in STD.pm could move to the prelude, which is why I put STD into the same directory in the first place | 21:51 | |
moritz_ | t/spec/S02-builtin_data_types/num.t looks dubious to me | 22:00 | |
ok(1i ~~ Num, 'Complex Numbers are Nums'); | |||
is that test correct? don't think so | 22:01 | ||
pugs_svnbot | r20998 | moritz++ | [spec] fudged num.t | ||
22:02
b_jonas left
|
|||
Auzon | moritz_: What's the problem with it? :-/ | 22:04 | |
moritz_ | Auzon: that it allows to pass a complex number to everything that declares a "Num" interface | 22:05 | |
rakudo: say 1i ~~ Num | |||
p6eval | rakudo r28688 OUTPUT[0] | ||
22:11
Limbic_Region joined
|
|||
rhr | Complex isnota Num (Nums are Ordered) | 22:15 | |
moritz_ | good point | 22:18 | |
22:21
wknight8111 joined
|
|||
pugs_svnbot | r20999 | rhr++ | [docs/p6types] All the synopses are done except S16+29 | 22:25 | |
Auzon is tempted to just change the '1i ~~ Num' test and snag r21000, but won't. | 22:28 | ||
moritz_ | Auzon: why not? just remove it | ||
Auzon | ok, I did. | 22:30 | |
pugs_svnbot | r21000 | Auzon++ | [gsoc_spectest] removing bad test for Complex matching Num found by moritz++. | ||
moritz_ | rakudo: say 54 + 1 + 12 | 22:31 | |
p6eval | rakudo r28688 OUTPUT[67] | ||
moritz_ can't find 3 or 4 tests :( | |||
Auzon | where? | 22:32 | |
moritz_ | in the array.t i'm fudging right now | ||
22:37
Lorn left
|
|||
rakudo_svn | r28689 | moritz++ | [rakudo] add passing test num.t to spectest_regression | 22:38 | |
pugs_svnbot | r21001 | moritz++ | [spec] start to fudge array.t, still needs much tweaking | ||
diakopter | .pmc | 22:41 | |
22:42
lichtkind_ joined
|
|||
pugs_svnbot | r21002 | moritz++ | [spec] S02-builtin_data_types/* | 22:45 | |
r21002 | moritz++ | removed/replaced old kwid POD. | |||
r21002 | moritz++ | Many of these tests still need smartlinks | |||
rhr | here's a completely silly attempt to diagram the p6 role/class heirarchy: airen.bcm.umontreal.ca/p6types.png | 22:48 | |
green==is red==does | 22:49 | ||
moritz_ | that does look scary ;) | ||
rhr | I left out all the 'is Any' connections | 22:50 | |
23:00
lichtkind left
23:01
edpratomo joined
|
|||
meppl | good night | 23:05 | |
23:06
meteorja1 joined
23:07
meppl left
23:09
Alias_ left
|
|||
rakudo_svn | r28691 | moritz++ | [rakudo] more tests for spectest_regression | 23:10 | |
pmichaud | moritz++ | 23:11 | |
moritz_ | and Auzon++ for moving these tests (although they weren't all sanity-checked) | 23:12 | |
somebody with tuits could convert Ovid++'s test on p6i into a test script | 23:13 | ||
moritz_ had to go to bed right now :( | 23:14 | ||
23:15
audreyt_ joined
23:39
japhb joined
23:41
lichtkind_ left
23:49
Jedai joined,
edpratomo left,
dolmen joined
|