»ö« | perl6-projects.org/ | nopaste: sial.org/pbot/perl6 | evalbot: 'perl6: say 3;' | irclog: irc.pugscode.org/ | UTF-8 is your friend! Set by Tene on 14 May 2009. |
|||
00:04
DanielC left
00:07
snarkyboojum joined
00:09
_Chillance_ joined
00:10
_Chillance_ left
00:12
kst left
00:13
kst joined
00:15
Chillance left
00:24
bacek joined
00:53
FurnaceBoy_ is now known as FurnaceBoy
01:02
snarkyboojum left
01:05
jferrero left,
snarkyboojum joined
|
|||
sjohnson | will Perl 6 (or even perl 5), have, or does have, an easy way to read a single key in without the ENTER key, and do something? | 01:06 | |
i found Term::ReadKey as it sounds like something that would do it, but upon reading its CPAN page, it doesn't sound like it | 01:07 | ||
or it's heavily obfuscated | |||
TimToady | is CTRL a key? | 01:08 | |
sjohnson | not one that i really care to trap, but maybe in the future | 01:09 | |
just looking to trap keys like 1 to 0 | |||
and a few letters | |||
i've written a flashcard program in perl for kanji review | |||
and it would definitely speed it up if i didnt have to hit ENTER all the time | 01:10 | ||
01:10
Whiteknight left
|
|||
TimToady | yes, well, it's a complicated problem, even on one OS, let alone cross-OS | 01:10 | |
what OS are you one? | |||
*on? | |||
sjohnson | ubuntu linux | 01:11 | |
01:11
exodist left
|
|||
TimToady | I'd suggest (for p5) running stty to set your terminal to cbreak mode or raw, and then use sysread | 01:11 | |
sjohnson | unfortunately it looks like what i am asking is like pulling a tooth out of a sleeping tiger's mouth without waking it up | ||
TimToady | if you use raw, make sure your exit code works first :) | 01:12 | |
sjohnson | TimToady: sysread() being a function i should use in p5? | ||
TimToady | yes, bypasses STDIO, another wrinkle | ||
sjohnson | perhaps i could run an alias that does all the comamnds for me | 01:13 | |
alias flashprogram='stty cbreak && flashprogram.pl && stty normal' | |||
or something | |||
TimToady | mebbe | ||
pmichaud | "stty sane", often. | 01:14 | |
TimToady | in my program I just use system "stty raw -echo opost"; | ||
pmichaud | that sounds familiar :-) | ||
TimToady | then while (sysread(STDIN, $buf, 1)) { | 01:15 | |
sjohnson | Term::TermKey; from CPAN might do the trick as well | ||
without me busting out the dusty unix manuals | |||
though i should try the "l33t" timtoady way, as i wuold probably learn something in the process too | 01:16 | ||
TimToady | then when it exits, system "stty echo cooked -istrip"; | ||
sjohnson | FYI: search.cpan.org/~pevans/Term-TermKe...TermKey.pm | 01:17 | |
01:19
ispy_ joined
|
|||
sjohnson | ahhh i knew it was too good to be true. cpan won't install it for me, some error | 01:19 | |
i will do it the Official Larry Wall way | |||
thanks Tim's toady | 01:20 | ||
oops, | 01:30 | ||
i should have taken your CTRL-C advice seriously | |||
heh | |||
well i did, but at least i should have remembered it | |||
thankfully i wrote a "kill" wrapper in perl too | 01:31 | ||
to handle these "unforseeable" incidents | |||
but the technology worked! | 01:33 | ||
many thanks. that would have probably taken me a month to figure out on my own | 01:34 | ||
pmichaud: your sane thing saved the day too | 01:54 | ||
01:59
unitxt left
02:02
xinming_ joined
02:03
agentzh left
02:04
eternaleye_ is now known as eternaleye,
agentzh joined
02:05
agentzh left,
luqui joined
02:06
xinming left,
agentzh joined
|
|||
sjohnson | Q: is there a universal $dummy variable in Perl 6 or 5? | 02:25 | |
maybe ()? | 02:26 | ||
the Camel book said to set () = &something; | |||
but i have found cases where that fails | |||
also, undef = &something; fails too sometimes | |||
(or maybe all the time) | |||
i'd like to always be able to set $dummy stuff, without having to do "my $dummy;" all the time | 02:27 | ||
literal | *, I think | ||
sjohnson | am i dummy for asking this question? | ||
literal | ($foo, *, $bar) = something(); | ||
sjohnson | will try it out | ||
sjohnson hopes the universe doesn't implode | |||
literal | $ if it's in a declaration: my $foo, $, $bar = something(); | 02:28 | |
sjohnson | i have found that doing undef in that case works | ||
literal | in Perl 6? | ||
sjohnson | my ($foo, undef, $goose) = getFarmAnimals(); | ||
haven't tried p6 | |||
i should tho | |||
literal | oh, I was talking about Perl 6 | ||
in Perl 5 you'd use undef | |||
sjohnson | rakudo: my ($foo, undef, $bar) = <1 2 3>; say $foo, $bar; | 02:29 | |
p6eval | rakudo 10a9b2: OUTPUT«Unable to parse declarator; couldn't find final ')' at line 2, near ", undef, $"in Main (src/gen_setting.pm:0)» | ||
sjohnson | rakudo: my ($foo, undef, $bar) = <1 2 3>; say $foo.$bar; | ||
p6eval | rakudo 10a9b2: OUTPUT«Unable to parse declarator; couldn't find final ')' at line 2, near ", undef, $"in Main (src/gen_setting.pm:0)» | ||
sjohnson | hmm, now i've done it | ||
rakudo: my $foo, undef, $bar = <1 2 3>; say $foo.$bar; | |||
p6eval | rakudo 10a9b2: OUTPUT«Symbol '$bar' not predeclared in <anonymous> (/tmp/N8Ew8cisvi:2)in Main (src/gen_setting.pm:3207)» | ||
sjohnson throws his hands in the air | |||
literal | my $foo, $, $bar = <1 2 3>; say $foo, $bar; | ||
rakudo: my $foo, $, $bar = <1 2 3>; say $foo, $bar; | 02:30 | ||
p6eval | rakudo 10a9b2: OUTPUT«Statement not terminated properly at line 2, near "$, $bar = "in Main (src/gen_setting.pm:0)» | ||
luqui | rakudo: my $foo, $, $bar = <1 2 3>; say $foo~$bar; | ||
p6eval | rakudo 10a9b2: OUTPUT«Statement not terminated properly at line 2, near "$, $bar = "in Main (src/gen_setting.pm:0)» | ||
literal | hm | ||
sjohnson | we broketed the compiler | ||
literal | rakudo: my $foo, $bar; $foo, *, $bar = <1 2 3>; say $foo, $bar; | ||
p6eval | rakudo 10a9b2: OUTPUT«Symbol '$bar' not predeclared in <anonymous> (/tmp/ETNvJ8wmyF:2)in Main (src/gen_setting.pm:3207)» | ||
literal | rakudo: my ($foo, $bar); ($foo, *, $bar) = <1 2 3>; say $foo, $bar; | 02:31 | |
p6eval | rakudo 10a9b2: OUTPUT«13» | ||
02:31
luqui left
|
|||
literal | rakudo: my ($foo, $, $bar) = <1 2 3>; say $foo, $bar; | 02:31 | |
p6eval | rakudo 10a9b2: OUTPUT«13» | ||
literal | needs the parens, I guess | ||
sjohnson | oh right | 02:32 | |
i was doing the undef thing that wouldnt work in p6 | 02:33 | ||
literal: do you know how to do it in p5? | |||
literal | yeah, by using undef: my ($foo, undef, $bar) = qw<1 2 3>; | ||
$ perl -E'my ($foo, undef, $bar) = qw<1 2 3>; say $foo, $bar' | 02:34 | ||
13 | |||
sjohnson | oh | 02:37 | |
what about the... other scenario | |||
like undef = 5+5; | |||
() = 5+5; works, but i tried it in other cases and it fails i think | 02:42 | ||
02:42
alanhaggai joined
02:43
Limbic_Region left
02:44
beggars joined
|
|||
s1n | what's the difference between method and submethod? | 02:59 | |
pmichaud | submethods aren't inherited | ||
s1n | pmichaud: thanks | ||
03:02
amoc left
03:12
ispy_ left
03:15
aindilis joined
|
|||
TimToady | they're not inherited, but they must be accessible directly as $obj.ExactMatch::meth() | 03:15 | |
even if $obj isn't an exact match; the submethod is really only concerned with the infrastructure of the object relating to ExactMatch, but others can invoke that | |||
sjohnson | TimToady: do you know an answer to the $dummy variable question? | 03:16 | |
i will ask again | 03:17 | ||
TimToady | so, for instance, BUILDALL can invoke the BUILD submethod on the object multiple times, once for each thing that the object is | ||
sjohnson | is there a better way to write, sysread(STDIN, my $dummy, 1); | ||
for a "press any key" action | |||
TimToady | in p5? | 03:18 | |
not really | 03:19 | ||
sjohnson | yeah, and p6 if you know the future | ||
in the camel book , it says to use () for non-important returned values, but this fails from time to time | |||
TimToady | I only know the future to the extent people let me create the future | ||
sjohnson | () = 5+5; works | ||
but not in that sysread thing | |||
TimToady | that's only for assigment, not for in/out parameters | ||
sjohnson | i thought you were the king of the future, though | ||
TimToady | I am the servant of the future | 03:20 | |
sjohnson | and other people follow suit | ||
TimToady | If anyone is to be great among you, he must become least of all. --Jesus | ||
sjohnson | hence being one of Tim's toadies :) | 03:21 | |
TimToady | but I can be strong on behalf of people who do not (yet) have a voice | 03:22 | |
cj is happy to note this he finally got UTF-8 working with irssi. in case anyone was still worried about that. | |||
TimToady | 楽 | 03:23 | |
sjohnson | music | ||
testing my kanji knowledge? | |||
:) | |||
TimToady | no, testing cj's utf-8 | ||
sjohnson | oh | ||
i wrote my kanji thing thanks to your tip, in TimToady(TM)-approved coding techniques | 03:24 | ||
TimToady | well, just because I suggested it doesn't mean I approve :) | ||
sjohnson | i suppose I should have said... inspired | 03:25 | |
TimToady | inspiration is another tricky concept... | ||
03:26
snarkyboojum left
|
|||
sjohnson | may i ask, what inspired you to learn some japanese? | 03:27 | |
is it because of your background in linguistics? | 03:28 | ||
and/or do you think it's a cool language to tackle (as I do) | |||
TimToady | both those, plus we love anime | 03:30 | |
sjohnson | me too | ||
03:30
frew|work joined
|
|||
sjohnson | that is why I am learning it | 03:30 | |
TimToady | also, started on my 2nd trip to Japan | ||
sjohnson | have you met Matsumoto? | 03:31 | |
TimToady | a friend took me around Kyoto | ||
and started teachin me :) | |||
sure, we get along fine | |||
imitation is the sincerest form of flattery, after all :) | |||
sjohnson | it is kind of neat when the "big names" of the computer world meet other big names | 03:32 | |
well, at least i think it is | |||
and i mostly mean the heros of the computer stuff... not so much millionaire CEOs | |||
TimToady | I enjoy the Hacker's Conference because we can all get together and be "normal" with each other | 03:33 | |
sjohnson | what do you guys usually talk about? | ||
TimToady | cool gadgets, works in progress, social hacks, and anything else we like, which is pretty much everything | 03:34 | |
sjohnson | have you heard of the anime Rurouni Kenshin (TV, not OVA)? | 03:36 | |
TimToady | sure, we've watched all of Kenshin | 03:37 | |
sjohnson | wow that is suprising. it's an older one so many haven't seen it. it is my favourite | 03:38 | |
do you have any favourites? | |||
TimToady | oh, lots | ||
Last Exile is cool | |||
Utena | 03:39 | ||
fushigi yuugi | |||
sjohnson | ya i like that Otome Ranman song they played in fushigi yuugi | 03:40 | |
TimToady | his and her circumstances | ||
sjohnson | www.youtube.com/watch?v=cUpDECjbbSE | ||
what about Hunter x Hunter | |||
TimToady | samarai champloo was pretty good, gad gaurd, escaflowne, (anything with music by Yoko Kano) | 03:41 | |
cowboy beebop, trigun, irrisponsible captain tylor | 03:42 | ||
most of the old classics | |||
03:42
FurnaceBoy left
|
|||
TimToady | stellvia is good | 03:42 | |
sjohnson | Legend of Basara | ||
? | |||
that's around that time too | |||
TimToady | yes, pretty okay | ||
sjohnson | i liked that one | 03:43 | |
bought the dvds so a fansubbing group could re-release, which is ongonig right now | |||
TimToady | oh, my favorite favorite is still probably Azumanga Daioh | ||
sjohnson | im noting these, as i am in the mood for another "good show" | 03:44 | |
and its hard to find something that REALLY touches you | |||
TimToady | crest of the stars, banner of the stars was pretty good | ||
sjohnson | other than champloo, escaflowne, and fushigi yuugi, i havent heard of any of these | 03:45 | |
sjohnson is frothing at the mouth | |||
you must have seen... Love Hina, right? | |||
TimToady | sorry, have to go | 03:47 | |
sjohnson | i copide all you suggested | ||
thanks for the tips!!! | |||
03:54
amoc joined,
Util joined
|
|||
Util | rakudo: my $i = 4; my @a = ($i); $i += 2; print @a[0]; | 04:00 | |
p6eval | rakudo 10a9b2: OUTPUT«4» | ||
Util | rakudo: my $i = 4; my @a; push @a, $i; $i += 2; print @a[0]; | ||
p6eval | rakudo 10a9b2: OUTPUT«6» | ||
Util | Why does the second version print "6" instead of "4"? Is it a known bug? | ||
04:07
unitxt joined
04:12
davidad joined
|
|||
s1n | Util: looks like it's pushing the reference/pointer, src/classes/Array.pir:196 might be a good place to start | 04:13 | |
Util | s1n: thanks, that looks promising. | 04:17 | |
s1n | Util: np, i can't say whether it's the correct behavior, but that's probably what's happening (args might be a ref pmc, if such a thing exists) | 04:18 | |
Util | I cannot believe that "6" is the correct behavior, but I see no explicit example in the S32 tests. | 04:21 | |
04:30
eternaleye left
04:48
Util left
04:55
unitxt left
04:57
unitxt joined
05:08
snarkyboojum joined
05:17
frew|work left
05:19
alanhaggai left
|
|||
japhb | Tene: ping | 05:56 | |
05:58
sparc joined
06:03
snarkyboojum left
06:06
eternaleye joined
06:16
viklund_ joined
06:17
viklund_ left
|
|||
Tene | japhb: pong | 06:17 | |
japhb: what's up? | |||
06:41
[particle] joined
06:49
justatheory left
06:52
alanhaggai joined
06:59
[particle]1 left
07:00
beggars left
07:01
finanalyst joined
07:02
drbean_ joined
07:04
DemoFreak joined
07:07
drbean__ joined
07:11
barney joined
07:19
dakkar joined
07:20
drbean left
07:22
drbean_ left
07:25
unitxt left
07:46
masak joined
|
|||
Matt-W | Good morning | 07:47 | |
masak | good morning! | 07:48 | |
today is Rakudo day! \o/ | 07:53 | ||
and Form hackathon day! \o/ | |||
07:54
cognominal left,
agentzh left
07:55
agentzh joined
07:57
lichtkind_ joined
|
|||
masak | lichtkind: run.pugscode.org hasn't been working in a long time. | 07:57 | |
lichtkind_: it would be really cool to re-create something like that, but for Rakudo. | |||
Matt-W | yes indeed it's form hackathon day | 08:04 | |
I fixed the failing test last night | |||
So we're on a clean slate and ready to go | |||
masak | Matt-W++ | 08:05 | |
Matt-W | So hopefully it will be an exciting day | ||
I shall have to blog about it when it's done | 08:06 | ||
And get my perl 6 category feed on planet perl six, maybe | 08:07 | ||
08:08
kst left
08:09
kst joined
08:10
davidad left
08:11
lichtkind left
08:23
ssm joined,
donaldh joined
08:24
ejs joined
08:28
DanielC joined
08:29
ejs left,
ejs joined
|
|||
DanielC | rakudo: for (0..9):by(2) -> $i {say $i} | 08:30 | |
p6eval | rakudo 10a9b2: OUTPUT«Statement not terminated properly at line 2, near ":by(2) -> "in Main (src/gen_setting.pm:0)» | ||
DanielC | buubot: :by | ||
08:30
riffraff joined
|
|||
buubot | DanielC: hi | 08:30 | |
DanielC | Damn it, my firefox just froze. | 08:31 | |
masak | DanielC: :by not implemented yet in Rakudo. you want 'buubot: spack' | ||
DanielC | thanks | 08:32 | |
buubot: spack :by | |||
buubot | DanielC: S01-overview.pod:3 S02-bits.pod:119 S03-operators.pod:109 S04-control.pod:58 S05-regex.pod:95 S06-routines.pod:85 S07-iterators.pod:3 S09-data.pod:46 S10-packages.pod:5 S11-modules.pod:15 S12-objects.pod:62 S13-overloading.pod:9 S16-io.pod:17 S17-concurrency.pod:10 S19-commandline.pod:5 S22-package-format.pod:8 S26-documentation.pod:67 S29-function | ||
DanielC | buubot says that :by is in S02 but he's lying. | ||
buubot | DanielC: Stored says that :by | ||
DanielC | Either that, or Firefox text search is lying. | 08:33 | |
masak | DanielC: I find one instance using ack locally. | ||
DanielC tries searching for just "by" | 08:34 | ||
masak | S02:2647. | ||
DanielC | I'm looking a the web page, so I don't know where line 2647 is. | 08:35 | |
masak | it's in the HTML source, if you insist on using the web page. :) | 08:36 | |
DanielC | 1 .. 100 :by(3) | ||
I assume that the spaces are optional, right? In Perl 6 spaces are almost always optional. | 08:37 | ||
1..100:by(3) <-- ok | |||
masak | std: 1..100:by(3); 1 .. 100 :by(3) | ||
p6eval | std 27000: OUTPUT«ok 00:02 36m» | 08:38 | |
masak | DanielC: STD.pm says yes. | ||
DanielC | What does "00:02 36m" mean? | ||
masak | two seconds, 36 megabytes. | 08:39 | |
DanielC | STD took 36MB just to do 1..100:by(3) ? | ||
masak | DanielC: yes, well... feel free to write your own more memory-efficient Perl 6 parser... :P | 08:40 | |
masak adds STD.pm and its underlysing technology to queue of things to review, after PGE and the Perl 6 test suite | 08:42 | ||
std: | |||
std: * | |||
p6eval | std 27000: OUTPUT«ok 00:02 35m» | 08:43 | |
08:44
krunen joined
08:45
bacek left
|
|||
Matt-W | NO NO NO NO NO! | 08:45 | |
Excuse me | |||
Colleague committing code that DOESN'T COMPILE | 08:46 | ||
Matt-W fumes quietly in the corner | |||
DanielC | Matt-W: One of your co-workers? | ||
Matt-W | yes | ||
Matt-W twitches | |||
DanielC | You'd think he'd at least make the code compile before he commits to the main branch. | 08:47 | |
Matt-W | must... not... shatter... skull... | ||
yes, you'd think | |||
08:47
snarkyboojum joined
|
|||
DanielC | Matt-W: What programming language do you work in? | 08:48 | |
Matt-W | C++ | ||
DanielC | I thought it would be. That or C. | ||
Matt-W | occasionally I do some Java or Perl | ||
but it's mostly C++ for me | |||
DanielC | I know C but I've never tried to learn C++. It looks complicated. | 08:49 | |
Matt-W | IT is | ||
extremely | |||
masak | C-- C-- C-- C-- C-- | ||
Matt-W | but no more so than Perl 6 | ||
What's different is that the complexity hits you in different places | 08:50 | ||
DanielC | But I don't find Perl 5 (and so far Perl 6) complicated. | ||
Matt-W | Perl 6 is better at hiding it | ||
and provides a lot of simple things which are easy | |||
C++ doesn't have any of those | |||
DanielC | I tend to like simple languages. That includes C, Ruby, Perl, and others. | ||
re Perl: You don't need to learn much to start writing useful Perl programs. Most of the language is just alternative ways of saying things. | 08:51 | ||
08:51
kst left
|
|||
DanielC | e.g. If you only know one way to do a for loop, you'll get your work done just fine, even if there is a other way that would look nicer. | 08:52 | |
08:52
kst joined
|
|||
Matt-W | yeah | 08:54 | |
C++ is not too bad | |||
until you start playing with templates | |||
DanielC | I've heard bad things about templates. Honestly, I don't know what they are. | ||
Matt-W | unfortunately, creative abuse of templates is where all the fun bits are :) | ||
they're C++'s means of doing generic programming | 08:55 | ||
classes with type parameters | |||
etc. | |||
DanielC | Like a + function that works for both matrices, vectors and complex numbers? | ||
08:55
riffraff left,
jferrero joined
|
|||
DanielC | Wikipedia: "Generic programming [allows] some code to effectively circumvent the static typing" | 08:58 | |
08:59
payload left
|
|||
DanielC wonders, why don't they use a dynamicly typed language if they are just going to circumvent the static types. | 08:59 | ||
09:00
payload joined
|
|||
DanielC | Ok, I've read a bit about C++ templates and generic programming, so I have an idea of what you are talking about. | 09:04 | |
09:04
cognominal joined
09:08
xomas left,
synth left
09:09
davidad joined
09:10
synth joined,
alanhaggai left
09:11
xomas joined,
xomas left
09:12
xomas joined
09:17
kst left
09:18
viklund_ joined,
snarkyboojum left,
viklund left,
viklund_ is now known as viklund
09:19
viklund_ joined
09:20
kst joined
09:24
pjcj joined
|
|||
Matt-W | DanielC: C++ templates do not allow you to circumvent static typing in any way | 09:25 | |
they're like another preprocessor language | 09:26 | ||
a templated class is regenerated for each type your code uses it with | |||
it remains very definitely statically typed | |||
DanielC | Ok... a pre-processor... | ||
I saw the Swap() example. | 09:27 | ||
template<typename T> | |||
void Swap(T & a, T & b) { ... } | |||
Matt-W | yeah | ||
you'd get a new definition of Swap for each type T you use it with in the code | |||
DanielC | Ok. | ||
Matt-W | templates cause a few problems with the c++ compilation model | ||
because you have to be able to see function bodies when the templates are instantiated | |||
so you tend to end up with all the code in the header files | 09:28 | ||
DanielC | ah | ||
Matt-W | not particularly pleasant | ||
One day I'd quite like a job where I don't have to worry about that anymore | |||
i.e. a Perl 6 job :) | |||
DanielC | A Perl 6 job would be nice. | 09:29 | |
Matt-W | not very likely for a while though | ||
DanielC | I currently work with PHP, and while I don't hate PHP, it certainly doesn't excite me. | ||
Matt-W | urgh | ||
poor you | |||
DanielC | Strange that the most popular languages seem to be the crappy ones. | ||
Matt-W | I think what most interests me about C++ is finding clever ways to circumvent its restrictions and do very cool things | ||
and also how you can write code that's actually quite nice, but still manages to run really fast | 09:30 | ||
DanielC | I find nothing interesting about PHP. I think that embedding code in HTML is a great idea for making templates (Mason does that too), but that's it really. | ||
Matt-W | as a language, it's entirely unremarkable | ||
DanielC nods | |||
That's a good summary: unremarkable. | 09:31 | ||
ugh! My boss just asked me if we could make the website give an audio warning before it logs you out automatically. | 09:32 | ||
You know, because the website is not annoying enough as it is. | |||
Matt-W | you can, if the user's using firefox 3.5 :) | 09:34 | |
DanielC | ?? | ||
Matt-W | <audio> element :) | ||
DanielC | ah | ||
I'd rather tell him it's impossible :) | |||
I can just imagine a classroom fool of beeping computers. | 09:35 | ||
(our software is used in classrooms) | |||
Matt-W | ouch | ||
Just say it's impractical | |||
And also highly unwise | 09:36 | ||
Ill-considered | |||
And it would increase the global production of Evil by nearly 0.02% year on year | |||
DanielC | He rarely listens to me when it comes to design. He figures I'm a technie so I can't know anything about design. | ||
09:37
ejs1 joined
|
|||
DanielC | I told him I have studied design as long as I have studied programming (which is true), but you know that design is one of those soft topics where everyone thinks they are an expert. | 09:37 | |
jnthn | ahojte...to je Rakudo den :-) | 09:38 | |
Matt-W | Yes, it's a bikeshedding topic | ||
DanielC | yeah | ||
Matt-W | but I've always felt, from my limited experience, that there are certain things which are objectively true | 09:39 | |
And one of those is that making noises is a bad idea in almost every circumstance | |||
DanielC | and you would be right. | ||
There is actually a lot of research on usability design. | |||
Matt-W | yes | ||
I've read some of it | |||
I thought it was very interesting | |||
DanielC | I just follow Jakob Nielsen's blog, and read a few books. | 09:40 | |
s/blog/web page/ | |||
Much of design is subjective, but much of it isn't. But my employer thinks it's all subjective. | 09:41 | ||
09:42
ejs left
09:44
ilogger2 joined,
hudnix joined
09:45
p6eval joined
|
|||
DanielC | Hmm... maybe we'll start selling auto-logout ring tones... Just to make the classroom experience /really/ annoying. | 09:45 | |
Matt-W | no don't do it! | ||
think of the children! | |||
DanielC | heh | ||
jnthn | (finishes backlogging) | 09:48 | |
DanielC | jnthn: Is this your Rakudo day? | ||
masak | DanielC: yes, he just said that. :) | 09:49 | |
DanielC: "ahojte...to je Rakudo den :-)" | |||
DanielC | masak: What language is that? | ||
masak | DanielC: slovak. | ||
DanielC | Do you know Slovak too? | ||
masak | it's our second language here at #perl6. | ||
DanielC: no, I just pretend to know it. | |||
DanielC | Ich wünsche, dass ich konnte Slowakisch sprechen. | 09:50 | |
09:50
ejs2 joined
|
|||
masak | well, at least you know German. :) | 09:51 | |
DanielC | :-) | ||
I'm gradually learning German. | |||
It'll be important, since my wife-to-be is German and much of her family doesn't speak English. | 09:52 | ||
jnthn | Yes, it's Slovak. :-) | ||
masak: Second language? I thought that was lolspeak? ;-) | |||
Matt-W | I always thought that a good way to improve my German would be to marry a German lady | 09:53 | |
DanielC | :-) | ||
jnthn wouldn't be entirely opposed to taking such an approach to improve his Slovak... | |||
Matt-W | But I don't meet many, and it seems a strange way to go searching for somebody | ||
I don't really care what language she speaks, to be honest | |||
Perl 6 would be good :) | 09:54 | ||
DanielC | heh | ||
Matt-W | jnthn: what's on the plan for rakudo day? | ||
jnthn | Matt-W: first, git pull && make coffee | ||
DanielC | I actually met my wife-to-be in the OpenOffice.org project. We were both volunteers there. | ||
jnthn | After that, I'm open to suggestions, but am sure I'll find plenty in RT. :-) | ||
We currently have 344 tickets. Wow. | 09:55 | ||
masak | jnthn: it's probably a pmichaud thing, but I'd really like to get the Perl6::Grammar.parse thing working... | ||
09:56
Muixirt joined
|
|||
viklund | is there anyway of specifying encoding for a string in rakudo (or change)? | 09:57 | |
Matt-W | I'm sure there was something I really wanted to ask you to do jnthn | 09:58 | |
But now I can't remember what it was | |||
09:58
xinming joined
|
|||
Matt-W | So I suppose it can't be all that important :) | 09:58 | |
jnthn | masak: Do we know why it's broken? | ||
rakudo: Perl6::Grammar.parse('42') | |||
p6eval | rakudo 10a9b2: OUTPUT«Method 'parse' not found for invocant of class ''» | 09:59 | |
jnthn | Ah. | ||
Matt-W | rakudo: class A { has @!l; method B { @!l[*-1] = 4; } }; say A.new.B; | ||
p6eval | rakudo 10a9b2: OUTPUT«4» | ||
Matt-W | cool that got fixed | ||
DanielC | Question: Is there a difference between || and ?| aren't they both just boolean OR ? | 10:00 | |
jnthn | rakudo: my ($meth) = Grammar.WALK(:name<parse>); $meth(Perl6::Grammar.new, '42') | ||
p6eval | rakudo 10a9b2: OUTPUT«Null PMC access in find_method()in method Perl6Object::WALK (src/gen_setting.pm:3207)called from Main (/tmp/l9smLp1BMW:2)» | ||
jnthn | Eww. | 10:01 | |
OK, oddness. | |||
DanielC: || short-circuits. | |||
DanielC | do this || die ... | ||
Muixirt | the exit status of rakudo doesn't reflect if sth. went wrong while compiling, it's always? zero, will that change? | 10:02 | |
DanielC | jnthn: thanks | ||
Matt-W | jnthn: sub/method return types | ||
masak submits rakudobug | 10:03 | ||
Matt-W | aah the first masakbug of the day | ||
jnthn | Muixirt: That should be fixed... | ||
Matt-W: Yes? | |||
10:05
tulcod joined
|
|||
jnthn | Matt-W: We have sub/method return types afaik. I seem to remember there being a ticket of some kind about 'em though... | 10:05 | |
masak | s1n: maybe it might be a better idea to do the Dallas.p6m announcements on perl6-users? | 10:06 | |
Matt-W | jnthn: I'm sure there was a problem using them in Form.pm, you get type mismatch errors all over the place | ||
jnthn | Matt-W: I'm happy to help work out what's going on. | 10:08 | |
Let me see if I can spot any RTs... | |||
I'm sure there was one on return value type checking. | |||
Matt-W | I'm looking... | ||
masak | s1n: p6l is more for language discussion, p6u more for community discussion... | 10:09 | |
Matt-W | rt.perl.org/rt3/Public/Bug/Display.html?id=58022 is just an 'implement' task | ||
jnthn | ah, that is out of date since we already have "of" | ||
"as" we don't have, mostly due to lack of co-ercion at the moment. | |||
10:10
eiro joined,
eiro left
|
|||
Matt-W | rt.perl.org/rt3/Public/Bug/Display.html?id=65128 might be related to what I remember from Form | 10:11 | |
jnthn | std: my Num List sub f () { return () }; | 10:12 | |
p6eval | std 27000: OUTPUT«##### PARSE FAILED #####Multiple prefix constraints not yet supported at /tmp/ZpyIfLZt4o line 1:------> my Num List sub f () { return () }; expecting typenameFAILED 00:02 35m» | ||
Matt-W | I can't find it exactly | 10:13 | |
Sorry :) | |||
jnthn | OK. Well, that above bug needs a fix anyways... | ||
10:13
eiro joined
|
|||
DanielC | while $fh.get -> $line { say $line } only returns one line. ??? | 10:13 | |
jnthn | rakudo: my Num List sub f () { return () } | ||
p6eval | rakudo 10a9b2: ( no output ) | ||
DanielC | Strange, because the while loop works fine with $*IN. | 10:14 | |
Matt-W | DanielC: you want for $fh.lines, I think | 10:16 | |
although maybe while $fh.get should work... | 10:17 | ||
and it should if it works with $*IN.get... | |||
Matt-W smells herring | |||
DanielC | Yes, it should work. | ||
masak | Matt-W: maybe take a shower? | ||
:) | |||
DanielC | I know that $fh.lines works, but if $*IN.get works then so too should $fh.get | 10:18 | |
masak | jnthn: what about rt.perl.org/rt3/Ticket/Display.html?id=65960 ? | ||
jnthn: #65390 is kinda strange too... | 10:20 | ||
jnthn | std: Role | ||
p6eval | std 27000: OUTPUT«ok 00:02 35m» | ||
jnthn | rakudo: role A {}; say A ~~ Role; say A.WHAT | ||
p6eval | rakudo 10a9b2: OUTPUT«1A()» | ||
jnthn | masak: Seems like it's fixed now. :-) | 10:21 | |
masak | jnthn: indeed. closing. :) | ||
jnthn | masak: wait wait wait...need a regression test! | ||
masak | jnthn: #64948 would be nice. | ||
jnthn: ok, I'll add that first. | |||
Matt-W | tests++ | 10:22 | |
masak | phenny: tell s1n maybe it might be a better idea to do the Dallas.p6m announcements on perl6-users? p6l is more for language discussion, p6u more for community discussion... | ||
phenny | masak: I'll pass that on when s1n is around. | ||
jnthn | masak: OK, or I can add it? But go ahead. :-) | ||
masak | I'll add it. :) | 10:23 | |
I'm already in ur test suite, adding a test. | |||
10:25
rjh left,
rjh joined
|
|||
DanielC | rakudo: run "ls" | 10:25 | |
p6eval | rakudo 10a9b2: OUTPUT«operation not permitted in safe modein Main (lib/Safe.pm:25)» | ||
pugs_svn | r27001 | masak++ | [t/spec/S12-role] added role-does-role.t, with one test | 10:26 | |
jnthn | masak: S12-role? | 10:27 | |
Roles are in S14... | |||
masak | oh. | ||
jnthn | I thought the tests had all been renamed. | ||
masak moves the test | |||
jnthn | Also, maybe you could put it in with an existing file? | 10:28 | |
10:28
snarkyboojum joined
|
|||
masak | jnthn: so that's why the S12-role dir was empty! :) | 10:28 | |
jnthn | S14-roles/basic.t is probably good. | ||
masak: ah, lol :-) | |||
DanielC | if $fh.get { say "yes" } else { say "no" } --> prints "no" | 10:29 | |
that can't be right. | |||
(ie. the file does have lines) | |||
jnthn | DanielC: If the line is "0" or "" that's false... | ||
Otherwise, maybe bug. | 10:30 | ||
DanielC | wait... now it's saying "yes", something is fishy here. | ||
The line is not zero. But this is really weird. Some times it says "yes" and some times "no". I'm trying to narrow it down... one minute. | 10:31 | ||
jnthn: Actually... it behaves the *opposite* than what you'd expect. | 10:32 | ||
pugs_svn | r27002 | masak++ | [t/spec] moved test from S12-role/ to S14-roles/ | ||
DanielC | my $fh = open('foo.txt', :r); if $fh.get { say "yes" } else { say "no" } | ||
says "yes" | 10:33 | ||
my $fh = open('foo.txt', :r); say $fh.get; if $fh.get { say "yes" } else { say "no" } | |||
says "no" | |||
masak | lunch & | ||
jnthn | Is $fh.get slurping up all of the file, by any chance? | ||
DanielC | No, just one line. | ||
Or at least... say $fh.get only prints one line. | 10:34 | ||
Wait... I need to test a bit more... | 10:36 | ||
#!/usr/bin/perl6 | 10:37 | ||
It looks as iff I remove that line from the file it behaves correctly. But that can't be right... | |||
DanielC is bewildered | |||
Matt-W | weird | 10:38 | |
DanielC | Ok, I can make a report. | 10:39 | |
My open() line looks like this: my $fh = open('test.pl', :r); | 10:40 | ||
Where 'test.pl' is the file of the program. Yes, the file is reading itself (I was lazy, didn't want to make another file). | |||
Matt-W | out of interest, does it behave if you read a different file? | ||
DanielC | When test.pl starts with #!/usr/bin/perl6 the program behaves weird. | ||
Matt-W: It behaves correctly when you read a different file (!!!). | 10:41 | ||
When test.pl does not start with #!/usr/bin/perl6 the program behaves right. | |||
But when I read a different fie, the program always behaves right. | |||
jnthn | DanielC: Erm. It isn't by any chance being stupid enough to run the program when it has the #! line at the top, is it? | 10:42 | |
(If it is, then epic ouch...) | |||
DanielC | Can you think of a way to test that? | ||
I'll put a sample program in pastebin... | |||
rjh | strace it? | 10:43 | |
you could also add a sleep in the code, then run pstree | |||
pasteling | "DanielC" at 92.227.64.74 pasted "Weird behaviour with open() and $fh.get" (15 lines, 232B) at sial.org/pbot/37044 | 10:44 | |
10:44
pmurias joined
|
|||
jnthn fixes one half of RT#65128 | 10:44 | ||
rakudo: sub Int f() { return "a" }; f() | 10:45 | ||
p6eval | rakudo 10a9b2: OUTPUT«Malformed routine definition at line 2, near "Int f() { "in Main (src/gen_setting.pm:0)» | ||
jnthn | rakudo: sub Int f() { "a" }; f() | ||
p6eval | rakudo 10a9b2: OUTPUT«Malformed routine definition at line 2, near "Int f() { "in Main (src/gen_setting.pm:0)» | ||
jnthn | oh gah | ||
rakudo: our Int sub f() { "a" }; say f() | |||
p6eval | rakudo 10a9b2: OUTPUT«a» | ||
DanielC | There's the sample code. If you either change the file that is being opened, or remove the #! line, the program works correctly. | ||
jnthn | Gah, sucky. | ||
DanielC: Looking | 10:46 | ||
DanielC: Reproduced. | 10:47 | ||
DanielC: It doesn't by any chance come back if you have a blank line at the start of the file? | |||
DanielC | Good to know I'm not crazy :) | ||
jnthn | DanielC: Erm, two blank lines in a row... | 10:48 | |
DanielC | you are right... | ||
two blan lines => outputs "NO" | |||
jnthn | DanielC: Right. Because $fh.get for a blank line returns "" | ||
Which is false. | |||
DanielC | s/blan/blank/ | ||
rjh | DanielC: am I an idiot or does your first 'say $fh.get' not snaffle the #! line | ||
leaving a blank line | |||
jnthn | rjh: That's what I'm thinking too. | 10:49 | |
rakudo: my $x = ""; if $x { say "yes" } else { say "no" } | |||
p6eval | rakudo 10a9b2: OUTPUT«no» | ||
jnthn | It's exactly like that. | ||
Remember that Perl 6 auto-chomps | |||
So the \n is gone and you just have an empty string | |||
DanielC | rjh: You are correct, it seems. | ||
jnthn | You probably want more like | ||
rakudo: my $x = ""; if defined($x) { say "yes" } else { say "no" } | |||
p6eval | rakudo 10a9b2: OUTPUT«yes» | ||
rjh | or maybe | 10:50 | |
DanielC | So maybe this is the problem with the while loop that the guy reported on the list. | ||
Maybe his input file has a blank line. | |||
rjh | my $line = $fh.get; say $line; if $line { ... } | ||
so you don't read twice | |||
DanielC | So the while() gets "false" | ||
jnthn | DanielC: I very much suspsect so... | ||
q1faq! | |||
That's probably going to catch a few people out. | |||
But so far as I can see, Rakudo is behaving as spec'd in your program. | 10:51 | ||
DanielC | So it seems now. | ||
jnthn | Which list by the way? p6u? | ||
jnthn should maybe subscribe to that | |||
DanielC | yeah, users | 10:52 | |
jnthn | yeah, not subscribed there | ||
But anyway, seems you have an answer. | |||
DanielC | yeah | ||
jnthn | OK, let me try and fix up type checking of implicit return values... | ||
DanielC | Oh, and I just noticed that he used for loop instead of while. Is that wrong too? | ||
for $fh.get -> $line | 10:53 | ||
10:53
xinming left
|
|||
jnthn | DanielC: Yes | 10:53 | |
DanielC | thanks | ||
jnthn | for $fh.lines -> $line { } # will work | ||
DanielC | ok, thanks for the clarification | ||
jnthn | And will not be tripped up on the blank ines issue. | ||
DanielC | I suspect that ' while $*IN.get -> $line ' will be a very common construct. | 10:54 | |
jnthn | I hope not. | 10:55 | |
DanielC | Is there a way to make it behave as expected? | ||
jnthn | No | ||
DanielC | :-( | ||
Matt-W | for $*IN.lines -> $line is equivalent | ||
to what people want to do with while | |||
jnthn | People should learn to use for $*IN.lines -> $line { } instead | ||
DanielC | Matt-W: I know... | ||
jnthn | while for IO is a p5ism. | ||
Matt-W | and really | ||
it makes more sense | |||
sounds like a good article for someone's Perl 6-related blogging | 10:56 | ||
DanielC | But the $*IN.get is something I learned right here in this channel. | ||
jnthn | DanielC: Yes - for reading one line. | 10:57 | |
That's fine. | |||
DanielC | No, in a while loop I mean. | ||
jnthn | Ah. | ||
DanielC | So people in this channel are making the same error. | ||
Matt-W | well it works fine as long as none of the lines you're reading are false | ||
so maybe the person who told you never had that | |||
jnthn | :-) | ||
Matt-W | and hadn't realised | ||
jnthn | Most likely. | ||
DanielC: At some level, everyone is still learning Perl 6. | 10:58 | ||
Matt-W | now I suppose it's possible that .get could return $line but True, but... well | ||
messy | |||
DanielC | yeah | ||
Matt-W | and .lines is great when we have lazy evaluation | ||
jnthn | Matt-W: I pondered that for a moment but soon stopped pondering and realized it would probably cause more harm than good. | ||
Matt-W | when are we getting lazy? | ||
jnthn | Matt-W: We're putting it off until we have to do it. | ||
Matt-W | jnthn: I think it would ripple unexpectedly outwards, people wouldn't realise it was stuck on True | ||
jnthn | ;-) | 10:59 | |
DanielC | Matt-W: Is $fh.lines lazy? | ||
Matt-W | DanielC: it will be | ||
DanielC | good! | ||
Matt-W | nothing's lazy in rakudo at the moment | ||
but there will be lazy one day | |||
DanielC | Matt-W: I was just thinking that the main problem with $fh.lines is that it might suck up the entire memory if you are going through a large file. | ||
jnthn | Matt-W: Seriously though - it depends on a list refactor that I think pmichaud++ already has underway, or at least knows how to do. | ||
DanielC | That's my concern with $fh.lines ... memory. | 11:00 | |
Matt-W | DanielC: yeah, which is why the idiom in so many languages is 'while I can read one more line' | ||
DanielC | yeah | ||
jnthn | Matt-W: After that, the major roadblock is probably cleared. | ||
Matt-W | but with lazy evaluation, that goes away | ||
jnthn: I'm glad to hear it. I had assumed it was a distant thing | |||
woohoo! | 11:01 | ||
jnthn | Matt-W: At NPW there was a discussion about laziness, and a lot of things became clearer on that area to pm and myself. | ||
Matt-W | lunch & | ||
jnthn: hurrah for NPW :) | |||
I'm aware that laziness is not particularly easy to implement | 11:02 | ||
jnthn | Matt-W: So there's at least a plan for moving forward now | ||
Matt-W | So I'm trying not to be impatient for it | ||
jnthn | It's not, but the fact that much of it hangs off gather/take helps. | ||
Matt-W | yeah | ||
once that works, a lot of stuff will be lazy automatically | |||
jnthn | Right. | ||
Matt-W | lunch really & | ||
jnthn | That's why I'm really happy many things in the setting are using it. | ||
:-) | |||
DanielC | jnthn: How about a "warnings" mode for Rakudo that detects probable bugs like 'while $*INC.get'? | 11:04 | |
It could say "Excuse me, but this line might not do what you think it does" | |||
rjh | I don't know, I'm going to feel weird about for $*IN.lines -> $line | 11:05 | |
jnthn | DanielC: Maybe more something for a kind of "lint" program. | ||
rjh | you can stream into STDIN | ||
'while' seems more sensible to me | |||
jnthn | DanielC: But thanks to having the Perl 6 grammar available that shouldn't be so hard. | ||
DanielC | I'd bet my house that other people will make exactly the same mistake. Using 'for $fh.lines' actually looks wrong (it looks like it reads the entire file into memory). | 11:06 | |
11:06
snarkyboojum left
|
|||
DanielC | jnthn: What rjh said :) | 11:06 | |
11:06
nsh_ joined
|
|||
DanielC | jnthn: Perl Lint sounds like a great idea. | 11:06 | |
jnthn | DanielC: Heh, don't tell me, I just implement the spec. :-P | ||
DanielC | :-) | 11:07 | |
jnthn | oh, hmm...checking implicit return types...less easy than first expected. | ||
DanielC | Should someone mention this to TimToady? | ||
rjh | perl 5 people are going to have to get used to lazy evaluation :) | ||
jnthn | DanielC: He backlogs, I believe. | 11:08 | |
DanielC | rjh: Problem is that you don't notice lazy evaluation most of the time... until it bites you. I'ts like Haskell where you *have* to learn about laziness before you can get anything done. | 11:09 | |
rjh | perl 6 is still an eager language by default, though? | ||
DanielC | jnthn: Maybe he'll notice I mentioned his nick. | ||
rjh: Rather, some things are lazy but most is eager. | 11:10 | ||
rjh: Only lists are lazy. | |||
jnthn | rjh: Different operations have different levels of laziness/eagerness. | ||
For example, array assignment is mostly eager. | |||
DanielC | I thought it was binary: lazy or eager. Lists are lazy, everything else is eager. | ||
jnthn | No. | 11:11 | |
It's more broken down into 4 groups | |||
rjh | :/ | ||
this is going to _more_ confusing than Haskell :) | 11:12 | ||
jnthn | Array assignment is mostly eager in so far as my @a = 1,2,3,4; will be eager but my @a = 1..Inf; will not be. | ||
rjh | jnthn: is @a = 1..Inf lazy list assignment, or is it a Range object? | ||
jnthn | rjh: As far as I remember the discussion though, strict eagerness and strict laziness are things that are generally explicitly asked for. | 11:13 | |
1..Inf is a range object. | |||
@a = 1..Inf puts the 1..Inf into the "unevaluated" section of @a. | 11:14 | ||
lambdabot | Maybe you meant: activity activity-full admin all-dicts arr ask . ? @ v | ||
rjh | @shutup | ||
lambdabot | Unknown command, try @list | ||
jnthn | I think we mostly at the moment are tending to see arrays as having an evaluated and unevaluated part. | ||
Either of which may not exist. | |||
At least, that's the thinking at an implementation level. | 11:15 | ||
rjh | So you have iterators masquerading as arrays too? | ||
jnthn | It's more that the array contains the iterator. | 11:16 | |
And just knows that if you ask for something beyond the "already evaluated" portion of the array, it should go and ask the iterator to give it some values. | |||
rjh | ...so if you do an operation (map? grep?) on an array, you might get an iterator back? | 11:18 | |
11:18
hanekomu joined
|
|||
rjh | iterator-inside-an-array I mean | 11:18 | |
jnthn | Right. | 11:19 | |
But if you then assign it to another array, it's going to be mostly eager and evaluate what it can (e.g. non-infinite bits) at that point. | 11:20 | ||
Non-infinite is really the wrong term though. | |||
More like "not readily available" or something. | |||
11:21
donaldh joined
|
|||
rjh | I don't see much coverage in the spec | 11:22 | |
jnthn | S07 is about the best there is at the moment. | ||
rjh | There's going to be real fun if you take an array/iterator and start pushing values into it | 11:23 | |
jnthn | But I agree it needs some filling out. | ||
rjh | I guess you need to immediately coerce to a eager array at that point | ||
jnthn | That or you push onto the ungenerated part if it contains infinite bits. | 11:24 | |
erm | |||
lazy bits | |||
I'm not sure what push should do. | |||
my @a = 1..Inf; push @a, 42; # might be a little too surprising. | |||
(if it works) | |||
(in finite time ;-)) | 11:25 | ||
rjh | for me it appears to go into an infinite loop | ||
as expected | |||
Might be worth adding protection against this in the obvious cases | |||
jnthn | Aye. | 11:26 | |
rjh | rakudo: my @a = 1..Inf; say @a[0]; | ||
p6eval | rakudo 10a9b2: ( no output ) | ||
jnthn | Note Rakudo doesn't handle laziness at all yet. | ||
rjh | ah | 11:27 | |
11:29
pmurias left,
eiro left
11:30
pmurias joined,
eiro joined,
cls_bsd joined,
frew joined,
pnu joined,
pugs_svn joined,
antiphase joined,
patmat joined,
Caelum joined,
jiing joined,
zev joined,
pmichaud left,
presh joined
11:31
pmichaud joined
|
|||
masak | young wippersnappers... first time I did 'while =$*IN' (as it was called at the time), I got a segmentation fault from Parrot. that's how I learned not to use that idiom! :) | 11:31 | |
jnthn | lol | 11:32 | |
masak | I remember it clearly (thanks to 'git log'). it was on the 23rd of July last year. | ||
we've sure come a long way since then. | 11:33 | ||
11:33
nsh- joined
|
|||
jnthn | Less segfaults generally, methinks. | 11:33 | |
masak | oh yes. | ||
especially of the 'your program is very large and complex so I think I'll just segfault here' kind. | |||
very happy about that. | |||
11:34
pmurias left
|
|||
jnthn | Yes, Parrot has certainly improved over the course of Rakudo's development. | 11:34 | |
masak | aye. | ||
jnthn factors out some duplicated code | 11:35 | ||
DanielC | I wish I could contribute so Rakudo. It would be so cool to work on a Perl 6 compiler. | ||
jnthn | DanielC: You've already made a start. :-) | 11:36 | |
DanielC | :) | ||
jnthn | (Bug reports are a useful contribution. :-)) | ||
DanielC | I've always thought of compilers as the sort of thing that only über-hackers do. Kind of like kernel development. | ||
jnthn | Well, at the end of the day, compilers just take one thing and translate it into another. | 11:37 | |
The complexity is that the thing we're translating from is Perl 6. ;-) | 11:38 | ||
11:38
kst joined
|
|||
jnthn | Really though Rakudo mostly boils down to, a parser, a bunch of tree transformations, some built-ins and a few bits of C that do occasionally mind-bending things. | 11:39 | |
(Thus why they're written in C. ;-)) | |||
DanielC | I'll make a point to finish S05. That should help me understand Rakudo. | 11:40 | |
jnthn | If you want to learn more and get a higher level overview, Pm and I both have slides on Rakudo too. | ||
DanielC | I didn't know that Rakudo had anything in C. I thought it was all Parrot+Perl. | ||
jnthn | That give a kind of overview. | ||
Rakudo has some little bits in C. | |||
DanielC | I would love to see the slides. | 11:41 | |
jnthn | Mine are on www.jnthn.net/articles.shtml | ||
DanielC | *click* | ||
jnthn | Probably easiest is "Rakudo: Implementing Perl 6, in Perl 6, on Parrot" | ||
A little out of date in some spots no doubt, but probably not so far. | |||
DanielC | found it... | 11:42 | |
jnthn | Also "All Your Dynamic Language Are Belong To Us" is an overview - not specific to Perl 6 - of the Parrot Compiler Toolkit, and goes through buliding a toy language. | ||
Rakudo is based on that same toolkit, and looking at a smaller example is probably a less overwhelming introduction to it. | |||
11:43
xinming joined
|
|||
DanielC | Thanks. I've downloaded them. | 11:43 | |
11:43
nsh_ left
|
|||
DanielC | jnthn: Where are you located? Sweden? | 11:43 | |
Nordic Perl Workshop, Stockholm University, etc | 11:44 | ||
masak | :) | ||
11:45
zev left,
antiphase left,
pugs_svn left,
frew left,
patmat left,
jiing left,
Caelum left,
pnu left,
cls_bsd left,
eiro left,
presh is now known as bigpresh,
bigpresh left,
eiro joined,
cls_bsd joined,
frew joined,
pnu joined,
pugs_svn joined,
antiphase joined,
patmat joined,
Caelum joined,
jiing joined,
zev joined
|
|||
DanielC | Actually, the lectures seem very spread out. | 11:45 | |
11:45
presh joined
|
|||
jnthn | DanielC: I'm located in Slovakia at the moment. | 11:46 | |
But yes, I've talked in a lot of places. | |||
11:46
presh is now known as Guest92010
|
|||
DanielC | k | 11:46 | |
jnthn | I travel quite a bit. :-) | ||
DanielC | :-) | ||
11:50
snarkyboojum joined
11:53
zev left,
antiphase left,
pugs_svn left,
frew left,
patmat left,
jiing left,
Caelum left,
pnu left,
cls_bsd left,
eiro left
11:55
eiro joined,
cls_bsd joined,
frew joined,
pnu joined,
pugs_svn joined,
antiphase joined,
patmat joined,
Caelum joined,
jiing joined,
zev joined,
Guest92010 is now known as presjh,
presjh is now known as presh
|
|||
pmichaud | www.pmichaud.com/2009/pres | 12:02 | |
(for my slides) | |||
DanielC | *click* | ||
thanks | |||
Matt-W will have to read those at some point | |||
jnthn | pmichaud: Ah, that's the URL. :-) | ||
pmichaud | npw-pct and npw-rakudo are the latest | ||
Matt-W | but in the mean time, I venture that for $fh.lines reads very well to me | ||
jnthn | pmichaud: I didn't find it linked anywhere on pmichaud.com | ||
morning, btw. | |||
pmichaud | yeah, pmichaud.com is _way_ out of date :-( | ||
Matt-W | I don't think it's a serious problem that people might have to learn about laziness. Oh, the horror! | ||
pmichaud | good morning! | 12:03 | |
Matt-W | hi pmichaud | ||
jnthn | > my Int sub foo() { "x" }; foo() | 12:04 | |
Type check failed on return value | |||
lambdabot | <no location info>: parse error on input `"' | ||
jnthn | woo | ||
masak makes a mental note to sprinkle pointers to $fh.lines in appropriate places in u4x... | |||
jnthn | Apart from it only works for that case... | ||
12:04
pmurias joined
|
|||
Matt-W | jnthn: does it work if you give it an int? | 12:04 | |
jnthn | Matt-W: Yes. :-) | ||
masak | pmichaud: you mentioned you could probably get #66270 to work... | 12:05 | |
pugs_svn | r27003 | pmurias++ | [re-smop] punned roles call BUILDALL during new if it's present | ||
r27004 | pmurias++ | removed debugging say | |||
Matt-W | jnthn: excellent! | ||
jnthn++ | |||
pugs_svn | r27005 | pmurias++ | [re-smop] default values from params | ||
jnthn | (by that case I meant that sub foo($x --> Int) { } does work like that yet...) | ||
pmichaud | jnthn: obtw... it's doubtful that Parrot calling conventions refactor will land before 1.4 release | 12:06 | |
jnthn | That one should be a sub call addition away though. | ||
pmichaud: omgz I'm like totally shocked... :-/ | |||
pmichaud | (based on latest perl 6 design meeting) | ||
jnthn | (not) | ||
1.4 is like, the release this month though? | 12:07 | ||
pmichaud | no, July | ||
June release is 1.3 | |||
jnthn | Oh. That's more ouch. | ||
12:07
xomas joined
|
|||
jnthn | Did you get much indication of the time scale we're looking at? | 12:07 | |
DanielC | jnthn: I'm looking at "Implementing Perl 6 in Perl 6". Why do you need the outer $( ) in the statement $then := $( $<block> ). | 12:08 | |
pmichaud | Allison said 1.5 (Aug) but I very much doubt that either unless someone else takes it up | ||
jnthn | DanielC: That bit of the slides is kinda out of date, we write $<block>.ast now | 12:09 | |
DanielC | ok | ||
jnthn | Which is a bit more self-explanator. | ||
DanielC | yes, it is | ||
jnthn | But menas "give me the PAST tree for this parse tree node" | ||
jnthn much prefers the new syntax | 12:10 | ||
DanielC | I forget what AST means, but I figure it is "A... Syntax Tree" | ||
Abstract | |||
pmichaud | yes, I prefer the new syntax also. | 12:11 | |
DanielC | What is the difference between a PAST and an AST? | 12:12 | |
P = Parrot? | |||
jnthn | ye | ||
s | |||
oh noes, here's where we find out that the setting has type constraint issues. | |||
our Bool multi method true() { | |||
self!to_test($.from_exclusive ?? ++($.from.clone) !! $.from) | |||
} | |||
I'm guessing to_test doesn't return a bool... | 12:13 | ||
Matt-W | clearly it should | ||
beat it up? | |||
jnthn | Yeah, I'm curious how many things I'm going to have to beat up now... ;-) | 12:14 | |
Example | |||
our Str multi method Str() { | |||
$.list | |||
} | |||
masak | :) | ||
jnthn | .list is *not* going to return a Str! | ||
masak | jnthn: it's all for the greater good... | 12:15 | |
pmichaud | Yeah, needs to be ~$.list | ||
jnthn | Right. | ||
pmichaud | can I see the diff? | ||
jnthn | sure | 12:16 | |
pmichaud | I'm curious how the exception-return versus non-exception is being handled (more) | ||
jnthn | You might be able tot hink of something better... | ||
pmichaud | I've been thinking of refactoring PCT a bit there | ||
I probably don't do anything immediately; just curious. | |||
s/don't/won't | |||
jnthn | gist.github.com/124262 | 12:17 | |
12:17
nsh- left
|
|||
jnthn | pmichaud: Basically I force a return *if* we have a return type constraint (and only if we have one). | 12:17 | |
pmichaud: I'm sure there's a more efficient way, but couldn't think of one without dipping into :inline's with a goto or PCT changes, which I'd rather you did. | |||
pmichaud | agreed. This looks good, actually. | 12:18 | |
obtw.... | |||
jnthn | ya? | ||
pmichaud | (checking something) | ||
there's no more trait_auxiliary or trait_verb :-) | |||
DanielC | proto infix:<+> is precedence('t=') <--- What does "t=" mean? | ||
pmichaud | DanielC: each predefined operator has a precedence level given by a string | 12:19 | |
jnthn | pmichaud: Oh, Larry is has a decision? | ||
pmichaud | string comparisons are used to decide if one operator is tighter than another | ||
so, for example, an operator with precedence 'v=' would be tighter than infix:<+> | 12:20 | ||
DanielC | pmichad: So it's like alphabetical order? a= is a higher precedence than b= ? | ||
pmichaud | a= is lower than b= (less tight) | ||
DanielC | ok, got it backwards | ||
pmichaud | the '='s are there to make it easier for us to dynamically create new precedence levels based on existing ones | ||
for example, if someone does | |||
DanielC | Why do you bother with the = sign? Why not just call it "a" or "u" ? | ||
pmichaud | proto infix:<blah> is tighter(&infix:<+>) { ... } | 12:21 | |
then infix:<blah> ends up with a precedence level of t>= | |||
if someone then does | |||
proto infix:<bar> is looser(&infix:<blah>) that one ends up with a precedence level of t><= | |||
and if we sort/compare those, it turns out that we get the right ordering :-) | 12:22 | ||
DanielC | Interesting. | ||
Thanks. | |||
pmichaud | so, we insert a '<' to mean looser and a '>' to mean tighter | ||
jnthn | oh wow, I didn't know it did that. That's cool! :-) | 12:23 | |
pmichaud | (and it works because '<' lt '=' and '>' gt '=' | ||
DanielC | This is indeed cool. Almost magical that it actually works. | ||
I's an interesting coincidence that in ASCII < comes before = which comes before > | 12:24 | ||
pmichaud | well, that's why I chose those chars :-) | ||
if it hadn't worked out that way, I would've picked some different sequence | |||
afk, kids to school | |||
DanielC | for looser(&infix:<blah>) I don't think you need t><= I think t<= should be enough. | 12:25 | |
in fact... that's probably what pmichaud meant to type because ><= does the wrong thing :) | 12:26 | ||
jnthn | our Range multi method reverse() { | 12:28 | |
@.list.reverse; | |||
} | |||
Is that really right? | |||
masak | no. | 12:29 | |
jnthn | I mean, should a range being reverse return a range with the endpoints flipped? | ||
Or a reversed list of the range's elements? | |||
masak | oh wait. | ||
Matt-W is glancing through pmichaud's PCT slides with his jaw on the floor | 12:30 | ||
masak | rakudo: say (1..4).reverse.perl | ||
jnthn | I'm not sure if the return type is wrong or the body is wrong. :-) | ||
p6eval | rakudo 10a9b2: OUTPUT«[4, 3, 2, 1]» | ||
Matt-W | pmichaud: I didn't realise PCT did quite that much of the work | ||
jnthn | Matt-W: PCT is The Awesome. :-) | ||
masak | jnthn: this is what I'd expect, at least. | ||
jnthn | masak: OK, in that case the return type wants to change. | ||
Matt-W | jnthn: it is really really awesome | ||
masak | jnthn: maybe some Range wizardry with :by(-1) could be used to acheive the same effect. | ||
Matt-W | now I want to write a compiler | 12:31 | |
jnthn | Matt-W: Health warning: highly addictive | ||
;-) | |||
Matt-W: Not sure. | 12:32 | ||
erm, masak | |||
:-/ | |||
masak: Changing return type for now. | |||
masak | aye. | ||
I can't think of a case where it matters. | |||
it's not like people would be trying to reverse 0..Inf anyway. | |||
Matt-W | jnthn: if I got addicted to working on rakudo, I don't think that would be a problem | 12:33 | |
jnthn | rakudo: say (?1) ~~ Bool | ||
masak | Matt-W: famous last words. | ||
p6eval | rakudo 10a9b2: OUTPUT«1» | ||
jnthn | rakudo: say (1..7).true.WHAT | ||
p6eval | rakudo 10a9b2: OUTPUT«Int()» | ||
jnthn | oh. | ||
rakudo: say (?((1..7).true)).WHAT | 12:34 | ||
p6eval | rakudo 10a9b2: OUTPUT«Bool()» | ||
jnthn | rakudo: say (?((1..7).true)) ~~ Bool | ||
p6eval | rakudo 10a9b2: OUTPUT«1» | ||
Matt-W | masak: indeed. Let's get our Form hackathon done first shall we? | 12:35 | |
masak | Matt-W: deal. | ||
jnthn | Hmm. Well, checking implicitly returned values is going to make the setting a little more honest, at least... | ||
12:36
clintongormley joined
|
|||
Matt-W | jnthn: no bad thing | 12:36 | |
masak | it's a kind of in-code tests, actually. | 12:37 | |
pmichaud | no, t><= is correct. | 12:40 | |
t<= would make the other operator looser than infix:<+>, which it shouldn't be. | 12:41 | ||
Range.reverse returns a Range. However, we can't really do that until we implement :by | 12:42 | ||
jnthn sticks some bacon in the frying pan | |||
pmichaud | so we've been returning a list of the reversed elements | ||
(so that it at least works somewhat) | |||
for now, eliminate the return type constraint | |||
or leave it as an embedded comment | 12:43 | ||
masak | (...and maybe add a comment...) | ||
pmichaud | our #(Range) multi method reverse() { ... } | ||
masak | ooh, nice! | ||
jnthn | pmichaud: Done that, and added a comment to the body too. | ||
pmichaud | (feel free to pick a different bracketing char :-) | ||
jnthn | pmichaud: Saying what it should do eventually. | ||
pmichaud | jnthn: excellent. | ||
jnthn goes looking for the weirdest unicode bracketing char he can find | |||
;-) | |||
12:44
meppl joined
|
|||
Matt-W | bacon++ | 12:44 | |
jnthn | eww we fails a bunch of test scripts from type checks being enforced | 12:46 | |
jnthn fixes up | |||
pmichaud | Matt-W: (from backscroll) yeah, I really like PCT. Much of it was inspired by audreyt's work on Pugs and PIL. | ||
Matt-W | pmichaud: good to know there are influences from that marvellous project | 12:47 | |
I remember when I heard about Pugs, I was overjoyed | |||
To think that such an interesting language as Perl 6 was going to be implemented in a language I like as much as Haskell | |||
pmichaud | (more backscroll) difference between ?| and || is (1) short-circuit and (2) ?| always returns a boolean | 12:50 | |
actually, ?| can short circuit if it wants | 12:51 | ||
oh, perhaps it can't. hmm. | |||
anyway ?| returns a boolean. || doesn't. | |||
(er, || doesn't have to) | |||
12:52
skids_ joined
|
|||
jnthn | Bacon. Inside fried bread. | 12:53 | |
...musteatandforgetimmediatelyhowgooditis... | 12:54 | ||
Matt-W | || will if the side that comes out is a Bool :) | ||
jnthn: mmmmm! | |||
Matt-W goes to jnthn's for dinner | |||
12:57
agentzh joined,
FurnaceBoy joined
13:14
hv2 joined
13:17
snarkyboojum left
|
|||
DanielC | Shoot. I burnt my pizza. | 13:17 | |
I got distracted with Rakudo stuff. | |||
jnthn | :-( | 13:18 | |
DanielC puts another pizza in the oven | |||
pmichaud | It's important to keep priorities straight. Pizza > Rakudo | ||
DanielC | :) | ||
I find Rakudo interesting, so I get distracted. | |||
pmichaud | Beer > Rakudo | 13:19 | |
DanielC | I get distracted eas... oh look at the bird! | ||
pmichaud | I did get distracted by Rakudo while trying to cook some rice, however, so Rakudo > Rice | ||
jnthn | Beer > * | 13:20 | |
PerlJam | Dr Pepper > * | ||
:-) | |||
(hello btw) | |||
DanielC | o/ | ||
13:22
beggars joined,
rjh_ joined,
rjh left
|
|||
DanielC | Regex: Can someone explain the difference between a rule and a token? When do you use each? | 13:25 | |
jnthn | pmichaud: www.pmichaud.com/perl6/rakudo-tests...-06-02.png is has a shrunk. | ||
DanielC | I'm looking at the RPN calculator from jnthn's talk. | ||
PerlJam | DanielC: rules have significant whitespace, tokens do not. | ||
DanielC | thanks | ||
pmichaud | jnthn: yes, I know. That's what GD::Graph does, apparently. | ||
DanielC | In the RPM calculator operators are tokens but values are rules. | 13:26 | |
pmichaud | I'm not sure what to do about it. | ||
13:26
beggars left
|
|||
DanielC | rule Value { \d+[\.\d+]? }; | 13:26 | |
pmichaud | DanielC: it has to do with where we allow whitespace | ||
Oh, I don't know why that would be a rule. Should be a token. | |||
DanielC | Ok, so I'm not crazy :-) | ||
pmichaud | I don't have enough evidence to judge that. | 13:27 | |
:-P | |||
PerlJam | rakudo: say "hello".trans( l => 'L' ); say "hello".trans( 'l' => 'L' ); | ||
DanielC | :-) | ||
p6eval | rakudo 10a9b2: OUTPUT«helloheLLo» | ||
13:27
tulcod left,
mizioumt joined
|
|||
PerlJam | What's happening on that first one? Is rakudo interpreting a lowercase ell as something different? | 13:27 | |
pmichaud | named parameter vs Pair | ||
jnthn | PerlJam: that looks...odd | ||
oh! | |||
pmichaud | the first is a named param. The second is a Pair. | ||
PerlJam | ah. | 13:28 | |
jnthn | And methods ignore named params. | ||
oh huh? | |||
PerlJam | (It's still surprising) | ||
jnthn | # Looks like you planned 52 tests, but ran 52 | ||
...gee! | |||
dalek | kudo: 056847f | pmichaud++ | src/classes/Grammar.pir: Add .parse to base Perl6::Grammar and other non-Rakudo grammars. Fixes #66270. we can inherit that one and omit this one. |
13:39 | |
jnthn | Yay :-) | 13:41 | |
jnthn spectests, hoping he's cleared up the setting's return type constraint issues now. | 13:43 | ||
DanielC | jnthn: I'm having trouble getting your RPN calculator (from your slides) to work. | ||
pasteling | "DanielC" at 92.227.64.74 pasted "RPN Calculator" (36 lines, 870B) at sial.org/pbot/37046 | ||
DanielC | Error: Statement not terminated properly at line 34, near "else {\n\tsa" | 13:44 | |
Line 34 is the "else" right at the end of the file. | |||
hv2 | Hi guys, just trying to get up to speed on Rakudo, got 3 failures in the spectests. The first is one I think is known about: a coredump after the end of t/spec/S09-subscript_slice/slice; the second I don't see mentioned, a (different) coredump after the end of t/spec/S10-packages/basic; something similar to the third was reported and fixed before, in t/spec/S02-lexical-conventions/unicode: | 13:47 | |
error:imcc:syntax error, unexpected USTRINGC ('unicode:"\x{e4}\x{f6}\x{fc}"') | |||
in file 'EVAL_27' line 2553 | |||
Null PMC access in type() | |||
in Main (t/spec/S02-lexical-conventions/unicode.rakudo:100) | |||
FAILED tests 30-31 | |||
Failed 2/31 tests, 93.55% okay (less 4 skipped tests: 25 okay, 80.65%) | |||
Which ones should I open tickets for? | 13:48 | ||
jnthn | hv2: I see the t/spec/S10-packages/basic one too | 13:50 | |
hv2: What platform are you on? | |||
hv2 | linux, FC6 | ||
jnthn | Ah, different form me then...so it ain't platform specific. | ||
The unicode one - that's known too, actually a Parrot issue. We filed a Parrot ticket on it. | |||
t/spec/S10-packages/basic I'm not sure if fails for everyone? | 13:51 | ||
PerlJam | DanielC: rather than $expr ~~ RPNExpression, try RPNExpression.parse($expr) or $expr ~~ /<RPNExpression>/; | ||
jnthn | Feel free to file a ticket on that one. | ||
DanielC: What PerlJam said... | |||
pugs_svn | r27006 | pmurias++ | [re-smop] fix bug in ReadonlyParam | ||
hv2 | Oh ok, most recent ref I could find for the unicode one was a bug closed by chromatic last month, for an earlier parrot revision than I fetched. | ||
jnthn | DanielC: That older syntax is outdated. | ||
hv2 | ack | ||
DanielC | jnthn/PerlJam: thanks | ||
jnthn | hv2: I *think* pmichaud filed a new one recently for the unicode method names bug. | 13:52 | |
hv2 | ok, Google might not have indexed it yet, I didn't search directly on the database | ||
jnthn | Ah, OK. | 13:53 | |
It was recent. | |||
trac.parrot.org/parrot/ticket/730 | 13:54 | ||
DanielC | Method 'postcircumfix:{ }' not found for invocant of class 'Failure' | ||
:-( | |||
hv2 | Is there a standard set of information to include, maybe even a rakudobug script? rt.perl.org just says "send a detailed email". | 13:55 | |
jnthn | Include your platform, the name of the spectest that fails and if you know how to (since it's segfaulting) then a gdb backtrace can be useful. | 13:56 | |
hv2 | ok | ||
Oh, how do I get the rakudo version that I git-cloned to? | 13:57 | ||
PerlJam | git rev-parse HEAD | 13:58 | |
hv2 | ty | ||
13:58
nsh_ joined,
ruoso joined
|
|||
ruoso | HellO! | 14:00 | |
PerlJam | greetings ruoso | ||
14:04
Chillance joined
|
|||
DanielC | Having trouble with the RPN calculator. | 14:06 | |
sial.org/pbot/37047 | 14:07 | ||
14:07
Scorp1us joined
|
|||
DanielC | for $!parsetree<Expr> -> $cur { say $cur.perl } <-- why is this wrong? | 14:07 | |
I'm just trying to figure out how the jnthn's RPN calculator is supposed to work. | 14:08 | ||
PerlJam | What makes you think there's somethign wrong with that line? | ||
DanielC | The output is: undef and the -1 | ||
But the expression is "2 3 +" | |||
s/and the/and then/ | 14:09 | ||
14:09
snarkyboojum joined
|
|||
PerlJam | DanielC: maybe put a $!parsetree.perl.say in there some where to get a look at the whole parse tree ? | 14:10 | |
DanielC | I did that, and the whole tree looks fine (keeping in mind that I don't know exactly what it should look like). | ||
But to my untrained eyes it looked perfect. | 14:11 | ||
pasteling | "DanielC" at 92.227.64.74 pasted "Parse tree" (52 lines, 1K) at sial.org/pbot/37048 | 14:13 | |
DanielC | There's the output of $!parsetree.perl.say | ||
14:13
nsh_ left
|
|||
DanielC | The undef and -1 at the end are just from the 'say $cur.perl' | 14:13 | |
14:15
alester joined
|
|||
jnthn | DanielC: moment, will look | 14:15 | |
jnthn is momentarily distracted | |||
pmichaud | might need for $!parsetree<Expr>.list -> ... | 14:17 | |
it would help to see the full code | |||
there are also some known bugs for .perl on Match objects | 14:18 | ||
DanielC | pmichaud: Right now the full code for the RPN calculator is at sial.org/pbot/37047 | ||
I'll try .list | |||
no change | 14:19 | ||
Ultimately I'm just copy-pasting from Jonathan's talk. | |||
pmichaud | note that the tree is actually in $/<RPNExpression>, not just $/ | ||
so there's no $/<Expr> -- it would actually be $/<RPNExpression><Expr> | 14:20 | ||
DanielC | Replacing $/ by $/<RPNExpression> made a big difference. | ||
pasteling | "DanielC" at 92.227.64.74 pasted "Replacing $/ by $/<RPNExpression>" (33 lines, 522B) at sial.org/pbot/37049 | 14:21 | |
DanielC | The 'undef' is now a parse tree. | ||
PerlJam | DanielC: what is it you expect to be output btw? | ||
DanielC | PerlJam: Honestly, I don't know. I got this code from jnthn's slides and I'm trying to figure out how it works. | 14:22 | |
PerlJam: The first link I posted is a copy of Jonathon's code. | |||
Except I changed =$*IN to $*IN.get | 14:23 | ||
jnthn is undistracted | |||
DanielC | It seems to come from an older version of Perl 6. | ||
jnthn | And spectests pass \o/ | ||
DanielC | jnthn++ | ||
pugs_svn | r27007 | pmichaud++ | Add a test for STD.parse() from RT #66270. | 14:24 | |
Matt-W | DanielC: the loss of prefix:<=> was quite recent, so there'll be a lot of example code floating around which will require that change | 14:26 | |
pugs_svn | r27008 | pmurias++ | [re-smop] :($foo) creates a new Signature | ||
[particle]- | anyone offhand know the sive of an SV in p5? | ||
*size | |||
pmurias | ruoso: hi | 14:27 | |
ruoso | hi pmurias | 14:28 | |
PerlJam | [particle]-: didn't it change from 5.8 to 5.10? | ||
[particle]- | ooh, yeah. i need 5.8. | 14:29 | |
14:29
decasm joined
|
|||
pmurias | ruoso: re your lazyness post on p6l sometimes you can easily calculate a large chunk of a lazy list e.g. 1..100000 but you don't want to waste time & memory on unused values | 14:29 | |
14:30
hv2 left,
nihiliad joined
|
|||
ruoso | pmurias, that's why lazy lists should probably have buffer sizes | 14:30 | |
so you only calculate some of it | |||
like Unix Pipes | |||
PerlJam | ruoso: so ... laziness is a whole other form of IO ? :) | ||
dalek | kudo: 636a2b6 | jnthn++ | src/parser/actions.pm: Fix one half of what is reported in RT#65128 - our T1 T2 sub f() { ... } now gives a compile time error like STD. |
14:31 | |
kudo: 7a40779 | jnthn++ | src/setting/ (2 files): Fix up various return type constraints in teh built-ins. |
|||
ruoso | yeah... the way I see it is really in the same logic as unix pipes | ||
[particle]- | pj: what header is SV defined in? i'll try to look it up on github | ||
dalek | kudo: 8c09b53 | jnthn++ | src/parser/actions.pm: Refactor setting of return types to eliminate duplicate code, and implement checking of implicitly returned values for the my T sub foo() { ... } and sub foo(--> T) { ... } cases. |
||
DanielC | Ok, if I use $/<RPNExpression> but remove the .list the code seems to behave reasonably. | ||
kudo: a89161f | jnthn++ | : Merge branch 'master' of [email@hidden.address] |
|||
ruoso | except you exchange objects instead of strings | ||
PerlJam | [particle]-: I haven't really looked at p5 in a while, but I would guess sv.h :) | 14:32 | |
[particle]- | pj: yes, that was a silly question.... | ||
14:32
snarkyboojum left
|
|||
Matt-W | Is there any semantic difference between saying my Int sub foo() { ... } and my sub foo (--> Int) { ... } | 14:33 | |
PerlJam | Matt-W: I hope not. | ||
jnthn | Matt-W: No. | ||
Matt-W | jnthn: great | ||
DanielC | What does the ~ do in ~$var ? | ||
Matt-W | what about foo() returns Int | ||
PerlJam | DanielC: stringifies | ||
jnthn | Matt-W: In fact I just refactored Rakudo to call exactly the same some path for the two... | ||
returns Int - doesn't enforce on implicits yet. | 14:34 | ||
That's what I have left to fix now. | |||
DanielC | PerlJam: thanks | ||
jnthn | But it should be the same | ||
Also .of | |||
erm, | |||
sub foo() of Int I mean | |||
Matt-W | hmm | ||
so why do we have four ways to say the same thing | |||
jnthn | It's like...there's only 4 ways to do it. :-) | ||
Heh | |||
Matt-W | I know TMTOWTDI but this seems a bit silly | ||
jnthn | Yes, I haven't found it too amusing trying to keep all four ways in sync. | 14:35 | |
Matt-W | 'as' is a different semantic, isn't it? | ||
jnthn | as is coercion rather than check, yes | 14:36 | |
Matt-W | that's okay then | ||
it's not five :) | |||
PerlJam | Matt-W: perl always optimizes for expressivity. | ||
Matt-W | so if you say sub foo() as Str, you basically get prefix:<~> called on anything you return? | ||
jnthn | No | 14:37 | |
IIRC, you get .Str called on everything you return | |||
Matt-W | jnthn: that would make more sense | ||
it's just that prefix:<~> usually ends up calling .Str :) | |||
but I suppose you could change that | |||
jnthn | It's either that or a multi-dispatch sub call Str($ret_val) | 14:38 | |
14:38
frew left
|
|||
jnthn | Oh, or is it not quite like that... | 14:38 | |
Hmm | |||
Whatever co-ercion syntax would be anyway. I should check up on that. | |||
14:39
frew joined
|
|||
pugs_svn | r27009 | jnthn++ | [t/spec] Tests for one issue reported in 65128. | 14:40 | |
DanielC | The RPN calculator works!!! sial.org/pbot/37050 | ||
pmichaud | multi-dispatch sub call, I think. | 14:41 | |
(rakudo doesn't do it this way yet; it's one of those areas that I sense some spec volatility) | |||
DanielC | jnthn: Do you mind if I post your RPN calculator in my blog? | ||
jnthn | DanielC: Sure, fixed version I hope ;-) | 14:42 | |
pmichaud: Yeah. | |||
DanielC | jnthn: Thanks. | ||
jnthn | pmichaud: Rakudo doesn't do coercion at all yet though AFAICT. | 14:43 | |
pmichaud | not through 'as', no. | ||
but obviously prefix:<~> coerces to a Str :-) | |||
PerlJam | Does augment work in rakudo yet? | 14:45 | |
jnthn | pmichaud: Yes, I meant the general case. | ||
pmichaud | no, it's still 'isa also' | ||
*'is also' | |||
PerlJam | thanks | ||
jnthn | pmichaud: We can't in Rakudo currently write Str($x) afaik. | ||
pmichaud | jnthn: correct. I'm not sure what to do with that one. | ||
I'm _very_ tempted to put some out-of-band handling for 'VTABLE_invoke' to get the original object. | 14:46 | ||
jnthn | pmichaud: Well, if it just be multi sub I'd guess that it's only the result of 'is export' on multi-methods, no? | 14:47 | |
class MyType { multi method Str() is export { return "badger" } } | |||
pmichaud | no, I suspect people can write them as plain multisubs also | ||
14:47
kst left
|
|||
jnthn | Oh, for sure. | 14:47 | |
pmichaud | but that's not the difficulty | ||
jnthn | But I don't see how it's any more difficult than a plain 'ole multi. | ||
pmichaud | it's not | 14:48 | |
the difficulty is vtable_invoke on protoobjects | |||
er, type objects | |||
jnthn | Oh! | ||
14:48
kst joined
|
|||
jnthn | Ah, and this means we need to start storing subs as &foo before we can fix this too... | 14:48 | |
pmichaud | not necessarily | 14:49 | |
although that might be where we end up. That's a conversion I'm not particularly looking forward to. | |||
jnthn | Otherwise how will the proto Str and the multi Str($foo) co-exist in the namespace? | ||
pmichaud | the proto can forward. | ||
jnthn | Huh? | 14:50 | |
pmichaud | (yes, that's not clean or nice) | ||
jnthn | For sure it can when the sub is &Str | ||
But I can only at the moment see the imported multi sub conflicting with the Str proto. | |||
e.g. trying to both go into the namespace slot Str. | |||
pmichaud | I'm sure there are ways around it. That said, I'm not sure I want to do any of those ways. | 14:51 | |
jnthn | rakudo: multi Str($x) { say "badger" }; Str(42) | ||
p6eval | rakudo a89161: ( no output ) | ||
pmichaud | std: multi Str ($x) { say 'badger' }; | ||
p6eval | std 27009: OUTPUT«ok 00:02 37m» | ||
pmichaud | hmmm. | ||
std: multi Str foo($x) { say 'badger' }; | |||
p6eval | std 27009: OUTPUT«##### PARSE FAILED #####Malformed block at /tmp/kFD2rGlZWR line 1:------> multi Str foo($x) { say 'badger' }; expecting any of: blockoid routine_def terminator traitFAILED 00:02 35m» | 14:52 | |
jnthn | (btw, I just did that in my local Rakudo. It segv'd.) | ||
Yes, that's a syntax error | |||
pmichaud | std: multi sub Str ($x) { say 'badger' }; | ||
p6eval | std 27009: OUTPUT«ok 00:02 37m» | ||
pmichaud | std: multi sub Str foo($x) { say 'badger' }; | ||
p6eval | std 27009: OUTPUT«##### PARSE FAILED #####Malformed block at /tmp/QWHcfuOrFq line 1:------> multi sub Str foo($x) { say 'badger' }; expecting any of: blockoid routine_def terminator traitFAILED 00:02 35m» | ||
pmichaud | okay. | ||
jnthn | std: our Str multi sub foo($x) { say 'badger mushroom' } | ||
p6eval | std 27009: OUTPUT«ok 00:02 37m» | ||
jnthn | Needs mushroom | ||
pmichaud | std: our Str foo($x) { ... } | 14:53 | |
jnthn | erm, I mean, needs a scope decl. | ||
p6eval | std 27009: OUTPUT«##### PARSE FAILED #####Whitespace is required between alphanumeric tokens at /tmp/t5ynAqTx3j line 1:------> our Str foo($x) { ... } expecting any of: declarator multi_declarator typenameFAILED 00:02 35m» | ||
jnthn | And a routine decl. :-) | ||
pmichaud | indeed. | ||
jnthn | Which is afaik what Rakudo needs too. | ||
pmichaud | anyway, converting to use '&' on subnames is going to pose some serious library conflicts. | ||
(with PGE and PCT) | 14:54 | ||
jnthn | rakudo: multi Str($x) { say "badger" }; say "alive" | ||
p6eval | rakudo a89161: ( no output ) | ||
jnthn | That segv's too | ||
Ah? Can PGE and PCT switch too? | |||
pmichaud | likely no. | ||
jnthn | Youch. | ||
pmichaud | I'm also not sure if method names should get &'s as well | 14:55 | |
i.e., does it become $P0.'&foo'(...) ? | |||
I suspect not. | |||
jnthn | I suspect not too. | ||
pmichaud | (an exported method should definitely have the & on its symbol table entry, but I'm not sure about the methodn name itself) | ||
jnthn | But OTOH they should get entries in the lexpad or namespace with an &. | ||
OK, looks like we're agreeing. :-) | 14:56 | ||
pmichaud | switching to & also means we have to be a lot more rigorous about when we stick things directly into a namespace (via namespace_keyed) and when we use 'add_sub' | 14:57 | |
er, set_pmc_keyed | |||
jnthn | Ah yes, the typed interface fun. | 14:58 | |
pmichaud | and set_*_global | ||
jnthn | Yay, of and returns now check implicit return values too. | ||
jnthn does a spectest run in case there are any waiting surprises | 15:00 | ||
15:02
Jedai left
|
|||
pmichaud | jnthn: likely to need my suggestions/ideas for anything else this morning? I'm going to be having to do some errands shortly | 15:07 | |
(which will require ~3 hrs total) | |||
15:07
iblechbot joined
|
|||
jnthn | pmichaud: I've not got much planned other than looking through tickets today. | 15:07 | |
pmichaud: Unless there's anything you'd like me to work on. | 15:08 | ||
pmichaud | nothing specific | ||
jnthn | Oh, I might hack on the Perl6MultiSub hll_map branch too... | ||
pmichaud | looking through tickets sounds really good -- I did some of that earlier in the week. | ||
I found many that could be closed, or easily closed. | |||
jnthn | Aye, we've plenty of 'em. | ||
pmichaud | okay, I'm afk for a while | 15:14 | |
bbl | |||
pugs_svn | r27010 | jnthn++ | [t/spec] Correct a type constraint. | 15:20 | |
15:20
donaldh left
|
|||
pugs_svn | r27011 | jnthn++ | [t/spec] Tests for type checking of implicitly returned values. | 15:20 | |
15:21
donaldh joined
15:22
Jedai joined
15:23
unitxt joined
|
|||
dalek | kudo: fb2fd43 | jnthn++ | src/parser/actions.pm: Make sure we type check implicit return values for of and returns also. Completely resolves RT#65128. |
15:24 | |
DanielC | What does "$sel:" mean in somemethod($self:) mean? | ||
What does "$sel:" mean in somemethod($self:)? | |||
s/sel:/self:/ | |||
DanielC can't type today | |||
15:25
ejs1 joined
|
|||
[particle]- | it's the invocant | 15:27 | |
DanielC | If I don't plan to use it, do I still need it? | ||
[particle]- | $self.somemethod($a) == somemethod($self: $a) | ||
DanielC is having some trouble here | 15:28 | ||
[particle]- | it's not much of a method if you don't need the invocant | ||
15:28
ejs1 left
|
|||
jnthn | DanielC: You can access it via self normally | 15:28 | |
DanielC: It's useful if you want to take the invocant into a variable of a different name, or apply extra constraints to it. | 15:29 | ||
[particle]- | oh, right, you can name it by whatever ... | ||
jnthn++ | |||
DanielC | What do you mean "access it via self"? | ||
jnthn | The self keyword | ||
DanielC | ah | ||
jnthn | self.foo within a method calls foo on self | ||
As in, the current instance | 15:30 | ||
DanielC | So I can write self.somemethod() inside a class. | ||
jnthn | Right. | ||
[particle]- | method foo { say self.bar() } | ||
jnthn | But $.somemethod() is shorter and usually just fine. :-) | ||
[particle]- | method foo { say $.bar() } | ||
DanielC | Ok, that looks better than the exclamation mark way: $self!bar() | ||
[particle]- | method foo($this) { say $this.bar() } | ||
er | |||
jnthn | That's for calling your privates. | ||
DanielC | self.bar() <-- better | ||
[particle]- | method foo($this:) { say $this.bar() } | ||
DanielC | jnthn: I'm trying to see if I can simplify your RPN calculator a bit so it is easier to explain how it works. | 15:31 | |
[particle]- | . is used to call public methods | ||
! is used to call private methods | |||
DanielC | ok | ||
and "my method" makes it private. | 15:32 | ||
jnthn | DanielC: I think by now that's outdated. | ||
DanielC | Ok. | ||
jnthn | I think you write method !secret_thingy() { } | ||
DanielC | It seems to work though. | ||
jnthn | Aye, I think Rakudo trails the spec there. | 15:33 | |
DanielC | ok | ||
!secret_method() is more consistent with the syntax for public and private variables. | |||
jnthn | *nod* | ||
DanielC | Do you write 'method !secret()' or '!method secret()' ? I assume the former. | 15:34 | |
15:34
ejs2 left
|
|||
jnthn | rakudo: class Foo { method !affair() { say "shhh" }; method what_you_doing() { self!affair(); return "washing up" } }; say Foo.new.what_you_doing | 15:35 | |
p6eval | rakudo a89161: OUTPUT«shhhwashing up» | ||
jnthn | Like that. | ||
DanielC | thanks | ||
pugs_svn | r27012 | pmurias++ | [re-smop] :($foo is ref) | 15:42 | |
pmurias | ruoso: is copy should work by calling .clone? | 15:45 | |
15:47
hudnix left
|
|||
pmurias | ruoso: it seems it must deal with readonly container specially so it won't be enough | 15:47 | |
15:51
nihiliad left,
sri_kraih joined
|
|||
TimToady | I don't think Str should be a multi | 15:55 | |
Str produces a type object, which responds to .() | |||
that's all | |||
well, that's the top view, I guess you still need a way to specify different coercions by type | 15:56 | ||
jnthn | TimToady: OK fine but then what does it do in response the .()? | 15:57 | |
Call $the-thingy-passed.MyTypeName? | |||
15:57
justatheory joined
|
|||
TimToady | not sure, lemme drink some coffee before spouting off further | 15:57 | |
jnthn | :-) | 15:58 | |
DanielC | jnthn: Is your RPN calculator supposed to be able to handle a more complex expression like "3 4 - 5 +" ? | 15:59 | |
TimToady | I think Str's .($x) calls $x.Str as a normal method | ||
jnthn | TimToady: OK. | ||
TimToady: How does this play out with multi-joined names? | 16:00 | ||
TimToady | because Str is a known type, it ignores any following () syntactically | ||
jnthn | DanielC: I can't remember now... | ||
DanielC | ok | ||
TimToady | multi-joined names? | ||
jnthn | class Foo::Bar { } | ||
Foo::Bar($x) # I want to coerce $x to a Foo::Bar | 16:01 | ||
$x."Foo::Bar" # but how to define that method? | |||
TimToady | good question, more coffee | ||
jnthn | :-) | ||
CDD # Caffeine Driven Development | 16:04 | ||
16:04
hercynium joined
16:05
tulcod joined
|
|||
pmichaud | yes, I remember TimToady saying once before that Str responded to .(), which is why I was thinking that & wasn't an issue for us here. | 16:06 | |
(back from errands part 1) | |||
however, that does mean that Str() acts somewhat differently from the now-normal notions of if(), loop(), e(), rand(), etc. | 16:08 | ||
(i.e., that immediate parens always indicate a sub call) | |||
jnthn | pmichaud: In src/parser/expression.pir we have a comment: | 16:12 | |
TimToady | if we think of everything in terms of an abstract multi coerce(From,To), then .() is coerce(Any,Str) | ||
jnthn | (FIXME Parrot bug RT#53296 prevents us from using :optional | ||
on the C<tighter> argument along with :slurpy :named parameters, | |||
so we use :multi as a temporary workaround.) | |||
pmichaud | I think that bug has since been fixed. Is it still using :multi? | ||
jnthn | pmichaud: Do you know if that workaround can go away? | ||
pmichaud: It is still using multi, and it just exploded onto the scene in my hll_map Perl6Multi branch. :-) | 16:13 | ||
pmichaud | if you can get it to work with .param pmc tighter :optional, then yes, it can go away. | ||
jnthn | pmichaud: OK, I'll try that. | ||
DanielC | jnthn: Is this valid? rule Expr { <Value> | <Expr> <Expr> <Op> }; | ||
pmichaud | DanielC: it'll infinitely recurse | 16:14 | |
jnthn | pmichaud: Not if it parses a <Value> first, no? | ||
DanielC | pmichaud: Until it hits values. | ||
TimToady | | is parallel | ||
DanielC | :-( | ||
jnthn | Or do we need || for that? | ||
pmichaud | If it doesn't find a <Value>, it'll infinitely recurse (in PGE) | ||
jnthn | Right, I suspect that's what it relies on. | ||
DanielC | yes | 16:15 | |
jnthn | If that was taken from the RPN example. | ||
DanielC | Yes. It's a variation on jnthn's RPN example. | ||
You'd need to write a different class to manage the parse tree, but I figure that the above (recursive) regex is the "correct" parse tree. | |||
jnthn | pmichaud: Does this mean we're saving ourselves a Parrot multi-dispatch per time we enter the expression parser? :-) | ||
DanielC | rule Expr { <Value> || <Expr> <Expr> <Op> }; | 16:16 | |
pmichaud | jnthn: yes, but I don't think that's significant from a time perspective. (I'd be happy to be wrong about that, though.) | ||
jnthn | pmichaud: I doubt it'll be a big difference. | 16:17 | |
pmichaud | jnthn: same here | ||
jnthn | pmichaud: Just a little nice to have. | ||
pmichaud | I'm looking for the original rt ticket that it was supposedly referring to | ||
I guess I typoed it | |||
jnthn | pmichaud: What might be a nicer win is that currently every infix:= to a scalar has to check it isn't really a Perl6Array or a Perl6Hash and then re-dispatch. | 16:18 | |
Because Parrot's MMD didn't always get us the correct answer. | |||
pmichaud | yes, that will indeed be nicer | ||
the original bug was 53926 | 16:19 | ||
(transposed 2 and 9) | |||
jnthn | We lose two isa-s and gain multi-dispatch caching. | ||
Ah, OK. | |||
pmichaud | did you see that I split deref_objectref into two different opcodes? | 16:20 | |
jnthn | Yes | ||
Makes sense. | |||
Guess they are two different operations. | 16:21 | ||
pmichaud | well, sometimes I need to completely dereference something (e.g., for dispatch) | ||
other times we need to dereference only ObjectRefs | |||
jnthn | *nod* | ||
pmichaud | (so that we stop at a scalar) | ||
ruoso | pmurias, re: is copy.... I think that's a question for TimToady... I'm not sure the spec is very clear on that... | 16:25 | |
16:28
pmurias left
16:29
Util joined
|
|||
jnthn suspects a lot of the things in the PIR built-ins that are currently marked as multis may not be in the spec... | 16:31 | ||
16:31
hanekomu_ joined
|
|||
jnthn | oh no, a lot of them are... | 16:32 | |
TimToady | I think maybe any surface coercion syntax ends up calling COERCE($x,Str), where class Str redirects &.() into an autogenerated COERCE(Any,Str), but class Rat redirects method Str into an autogenerated COERCE(Rat,Str) | 16:33 | |
and the optimizer is always free to call COERCE directly if it can deduce that | |||
16:33
Psyche^ joined
|
|||
pmichaud notes his "spec volatility" comment was spot-on again :-) | 16:34 | ||
TimToady | but my $s = Str; $s.($x) still works, as does $x.$s | 16:35 | |
or maybe COERCE is spelled infix:<as> | |||
[particle]- | hrmm... we should have a spec volatility metric generated regularly | 16:36 | |
pmichaud | it still needs to be a trait or something, yes? | ||
my sub foo($x as Str) { ... } | |||
16:36
rocket_guatemala joined
|
|||
TimToady | that just turns any return $x into return $x as Str | 16:36 | |
16:36
kst left
|
|||
pmichaud | I mean from a parsing perspective. | 16:36 | |
TimToady | yes, the trait is just factoring out the operator | ||
16:36
rocket_guatemala left
|
|||
pmichaud | okay. | 16:36 | |
TimToady | as a convenience | 16:37 | |
pmichaud | and actually, it's modifying $x, not the return value, right? | ||
16:37
kst joined
|
|||
pmichaud sends TimToady some more caffeine. | 16:37 | ||
TimToady | why would $x need to be modified? | ||
pmichaud | isn't my sub foo($x as Str) different from my sub foo($x --> Str ) { ... } | 16:38 | |
or am I way off again? | |||
I thought that $x as Str coerced $x into a Str | |||
TimToady | oh, on the input side | ||
16:38
rocket_guatemala joined
|
|||
TimToady | sorry, didn't have a good night | 16:38 | |
I was thinking sub foo($x) as Str | |||
pmichaud | yes, in that case it parses "traitish" as well. | 16:39 | |
I'm fine with infix:<as> -- just wanted to make sure the trait existed still. | |||
TimToady | I view the parameter trait as binding to an anonymous temporary, then $x := $temp as Str | 16:40 | |
pmichaud | agreed | ||
that's the way I've tended to think of it. | |||
TimToady | but $x never can be rw | ||
well, can't refer to the arg | 16:41 | ||
as rw | |||
pmichaud | agreed again. | ||
TimToady | as implies copy | ||
pmichaud | 16:35 <TimToady> but my $s = Str; $s.($x) still works, as does $x.$s | ||
$x.$s confuses me. | |||
16:41
kst left
|
|||
rocket_guatemala | hi, I am doing some work on the tests and i have a question: should the t/run be moved to the t/spec/S19 folder? | 16:41 | |
pmichaud | rocket_guatemala: if you're reasonably sure it's up-to-date with respect to the specs, then yes, please do so. | 16:42 | |
16:42
donaldh left,
kst joined
|
|||
rocket_guatemala | great, ill check each one before moving them | 16:42 | |
TimToady | pmichaud: it confuses me too | ||
pmichaud | rocket_guatemala: that's the correct process, many thanks! | ||
rocket_guatemala: if you end up with questions, [particle] is the current lead on that synopsis :-) | 16:43 | ||
TimToady | just trying to indicate that $x."Str" would still work even if the optimizer doesn't turn it into infix:<as> | ||
pmichaud | (but you can ask any of us and we'll venture an opinion) | ||
I'm fine with $x."Str", so we're good there. | |||
rocket_guatemala | thanks, ill chime in if i have any other question | 16:44 | |
TimToady | my basic point is that defining either .() or .Str still allows that syntax, but also guarantees the corresponding deep infix:<as> exists with appropriately typed args | 16:45 | |
pmichaud | it seems to me that there's also a difference between .() on a type object and .() on an instance | 16:46 | |
TimToady | sure, it's the abstraction thing again | ||
pmichaud | i.e., if I define method postcircumfix:<( )> { ... } then I want to distinguish whether my invocant is the type object or an instance.... right | ||
16:47
hanekomu left
16:49
Psyche^ is now known as Patterner
|
|||
pmichaud | would something like $x as 3 result in coercing $x to Int (the same type as 3) or a "no matching sub"? | 16:49 | |
i.e., is infix:<as> typically infix:<as>($x, Abstraction $y) ? | |||
TimToady | no matching, I'd think | 16:50 | |
pmichaud | actually, I have a more general question | ||
sometimes it seems as though methods delegate to operators | 16:51 | ||
other times it seems as though operators delegate to methods | |||
16:51
ashizawa joined
|
|||
pmichaud | in this particular instance, if I have | 16:51 | |
class A { method Str() { ... } } | |||
then how does my $a = A.new; $a as Str | |||
play out? | |||
TimToady | if you have a more general question then I'll have a less specific answer :) | 16:52 | |
thinking... | |||
pmichaud | my more general question would be "is there a guide for methods calling operators or vice versa"? | ||
This also relates to the relationship of prefix:<?>, .bool, .Bool, .true, etc (more) | 16:53 | ||
TimToady | yes, that's a question that's been niggling my subconscious for some time too | ||
pmichaud | but we also have prefix:<~>, .Str, and now infix:<as> | ||
and similar issues with prefix:<+>, .Num, .Int, .... | |||
16:53
mizioumt1 joined
|
|||
pmichaud | fwiw, the model with .ACCEPTS and how it relates to type matching and infix:<~~> seems to work very well in practice. | 16:54 | |
I don't know if there are parallels to be drawn here. | |||
TimToady | overall my impression is that single dispatch tends to be more primitive than multi, but either there exceptions, or we're missing a level somewhere | 16:55 | |
*there are | |||
pmichaud | I'm fine with single dispatch being more primitive than multi -- I'd just be curious which are the single dispatchy things | ||
the operators? the methods? | |||
TimToady | all surface operators are conceptually multi dispatch, even if unary | 16:57 | |
pmichaud | then if I'm understanding correctly, that would seem to argue in favor of operators-defined-in-terms-of-methods | 16:58 | |
TimToady | multi vs single is where we distinguish language-forcing from OO-forcing semantics | ||
in general | |||
and as does look a lot like the reverse dipatch of ACCEPTS | |||
pmichaud | (side note: we might want to think about how someone defining .ACCEPTS for a class keeps from overriding the typecheck form of .ACCEPTS for the type object. Does the class definer have to remember to constrain the .ACCEPTS invocant to avoid grabbing the type object?) | 16:59 | |
TimToady | with secondary dispatch on the first arg | ||
which is why I wanted some easier syntax than Abstraction | 17:00 | ||
that can be negated | |||
pmichaud | makes sense. Although we could have Concrete that is just the opposite of Abstraction :-) | ||
TimToady | where { $_ !~~ Abstraction } is much too heavy | ||
pmichaud | method ACCEPTS(Concrete $x: ...) { ... } | 17:01 | |
TimToady | well, something also to be said for that being the default | ||
jnthn | multi method... | ||
TimToady | and something else that means Abstraction|Concrete | ||
jnthn | Object :-) | ||
pmichaud | Maybe Abstraction isn't a subclass of Any | ||
or Any is somehow constrained to !Abstract | 17:02 | ||
jnthn | I think the thing to also keep in mind is that this is kinda "special" in that it almost breaks the rules of "no multiple prefix constraints" | ||
TimToady starts picking up the pieces of his brain | |||
jnthn | And also it's something that we want to be able to recognize and optimize (heavily) in the dispatcher. | ||
TimToady | I was thinking of syntax more on the line of ! and ? | 17:03 | |
pmichaud | I thought about that also. | 17:04 | |
Seems like there might be cases where we'd want to say "anything _except_ this type :-)" | |||
TimToady | wheren't Abstraction | ||
[particle]- | prefix:<*> | ||
pmichaud | exclude | 17:05 | |
sub foo($x excluding Abstraction ...) | |||
TimToady | these are all pretty toxic | ||
pmichaud | still probably too long :-) | ||
well, errands part 2 is upon me, so I'll come back and read the solution in backscroll (hope hope) | |||
17:06
tulcod left
|
|||
[particle]- | toxic, for sure. | 17:07 | |
TimToady | $x sans Abstraction is betterer | ||
[particle]- | oh, great. french. | 17:08 | |
TimToady | $x sans { $_ % 2 } | ||
[particle]- | what's the texas form of that? | ||
TimToady | $x without_none_o'_that_thar Abstraction | 17:09 | |
though that's more hillbilly, I guess | |||
shower & | 17:11 | ||
17:13
rocket_guatemala left
17:15
M_o_C joined,
mizioumt left,
nihiliad joined
17:23
broquaint left
|
|||
pmichaud | 16:35 <TimToady> but my $s = Str; $s.($x) still works, as does $x.$s | 17:27 | |
oops | |||
ignore that past-o | |||
$x whole-nuther-thing Abstraction # probably | 17:30 | ||
or maybe | 17:31 | ||
oh, never mind. :-) | |||
rjh_ | $x not { $_ % 2 }, $x not Abstraction :) | ||
pmichaud | $x butnot Abstraction | 17:32 | |
rjh_ | yeah, the negation should be longer than 'where' | ||
larry loves his huffman encoding | |||
pmichaud | oh? Then why is "no" shorter than "use"? ;-) | 17:33 | |
it's 33% shorter, in fact. | |||
and "not" is shorter than "true" (25%) | |||
rjh_ | that's a point | ||
can we finally have don't { } blocks | |||
pmichaud | and ! has a lot fewer 1-bits than ? | ||
rjh_ | you need to be less optimistic and start using "no" and "not" more often :) | 17:34 | |
pmichaud | even the frowny :-( comes before the smiley :-) | ||
rjh_ | std: my $don't = 0; | 17:35 | |
pmichaud | rakudo: say ":-(" lt ":-)" | ||
p6eval | std 27012: OUTPUT«ok 00:02 36m» | ||
rakudo fb2fd4: OUTPUT«1» | |||
jnthn | gaaahhh | 17:36 | |
rjh_ | rakudo: sub don't (*@) { }; don't { say "Hello!" } | ||
p6eval | rakudo fb2fd4: ( no output ) | 17:37 | |
jnthn changes Signature!add_param to not require a junction to be passed if if there's just one type... | |||
pmichaud: I implemented the "auto-generated a Signature by arity" thing, btw. | |||
pmichaud: Got that bit working now. :-) | |||
pmichaud | oh, nice! | 17:38 | |
jnthn | Not caching 'em for sharing purposes yet - will do that later once I get things working. | 17:39 | |
(Working in a branch) | |||
Ouch. | 17:45 | ||
(sitting in an infinite loop at startup)-- | |||
Tene | rakudo: sub circumfix:<:-( :-)> { say "☹ $^msg ☺" }; :-( "hi guys" :-) | 17:47 | |
p6eval | rakudo fb2fd4: OUTPUT«☹ hi guys ☺» | ||
jnthn | omg | ||
Tene | I read "the frowny :-( comes before the smiley :-)" at the top of my buffer before scrolling up to read context, and thought of that. | 17:48 | |
jnthn | It's sick and wonderful that Rakudo can do that. :-) | 17:49 | |
Tene | TimToady: I see you using "use Foo:from<ruby>;" or some such in scrollback a while ago. Is that actually specced? Rakudo currently uses :lang<...>; | 17:50 | |
17:54
nsh- joined
17:55
PacoLinux joined
18:01
PacoLinux left
|
|||
DanielC | rule Expr { <Value> || <Expr> <Expr> <Op> }; <--- doesn't do what I want because Rakudo seems to match the smallest possible token. | 18:01 | |
So if your string is "2 2 +" Rakudo only matches the first "2" instead of the whole string. | 18:02 | ||
Tene | DanielC: put it inside of a rule that's like: | ||
rule Foo { ^^ <Expr> $$ } | |||
DanielC | ok | ||
Well, that did something... Now it doesn't recognize "2 3 +" as an expression... | 18:03 | ||
if $expr ~~ / ^^ <Expr> $$ / | |||
jnthn | DanielC: I think I originally had it as rule TOP { ^ <Expr>+ $ } | 18:04 | |
TimToady | Tene: see S11:421 | ||
Tene | Ah. | 18:05 | |
Thanks. | |||
DanielC | jnthn: I'd have to remove the + because with the new Expr rule I wrote, the whole thing is an expression. | 18:06 | |
TimToady | DanielC: you really mustn't do it with left recursion; that doesn't work in recursive descent | ||
DanielC | ok | ||
TimToady | then you've written an ambiguous grammar, probably | ||
DanielC | So I'm barking up the wrong tree here. What is the correct way to do it? | ||
You'd think a grammar for a RPN calculator would be simple... | 18:07 | ||
TimToady | to stick with recursive descent, you need to split the Expr concept into can-be-first, can't be first | ||
18:07
PacoLinux joined
|
|||
TimToady | or you use a bottom up parser as a rule like STD does | 18:07 | |
"as simple as possible, but no simpler" | |||
DanielC | :-) | 18:08 | |
I think I have a lot to learn about grammars. | |||
This is my first attempt to write a grammar for anything. | |||
TimToady | figure out what distinguishes the first Expr from the second Expr, then you can do recursive descent | 18:09 | |
DanielC | ok | ||
DanielC starts thinking | |||
TimToady | but as it is, it's like writing a factorial function without an end condition | ||
18:09
nsh- left
|
|||
DanielC was hoping that <Value> would be the end condition... | 18:09 | ||
TimToady | what's the end condition between the two Exprs though, is the point | 18:10 | |
but more generally, it's kinda strange to use a top-down parser to parse something that is designed to be processed bottom-up | 18:11 | ||
(reverse polish) | |||
DanielC | I don't even know the difference between a top-down parser and a bottom-up parser. | 18:12 | |
18:12
nsh- joined
|
|||
PerlJam | DanielC++ trying to do something beyond your understanding. | 18:12 | |
:-) | |||
DanielC | :) | ||
TimToady: The objective of this exercise is for me to learn something about grammars, so it's not surprising that I'm making elementary mistakes. | 18:13 | ||
Can anyone give me a link that explains the difference between a top-down and a bottom-up parser? | 18:14 | ||
PerlJam | google can help with that. | ||
or wikipedia | |||
DanielC | I find that wikipedia often gives very broad explanations for a concept, so I may have trouble relating it to Perl. | 18:15 | |
But I'll try wikipedia. | |||
TimToady | www.google.com/search?q=top-down+bo...-up+parser | ||
DanielC starts reading | |||
TimToady | don't get distracted :) | 18:16 | |
18:16
nsh- left
18:26
DemoFreak joined
18:29
bkeeler joined
18:32
justatheory left
|
|||
bkeeler | rakudo: grammar Foo { rule TOP { <ww> } }; Foo.parse("foo") | 18:32 | |
p6eval | rakudo fb2fd4: OUTPUT«Unable to find regex 'ww'Null PMC access in invoke()in regex Foo::TOP (/tmp/Iw6E4bKMzm:2)called from Main (/tmp/Iw6E4bKMzm:2)» | ||
bkeeler | rakudo: grammar Foo is PCT::Grammar { rule TOP { <ww> } }; Foo.parse("foo") | ||
p6eval | rakudo fb2fd4: ( no output ) | 18:33 | |
18:33
gegloe joined
|
|||
bkeeler | I shouldn't have to sub-grammar PCT::Grammar to get <ww> should I? | 18:33 | |
PerlJam | is <ww> spec? | 18:34 | |
pmichaud | you might -- I don't think <ww> has been added to PGE yet. | ||
Yes, <ww> is now spec. | |||
at least, it was spec last time I checked. | |||
bkeeler | It's in S05 for sure | ||
pmichaud | I can add <ww> to PGE pretty simply. | 18:35 | |
and then it'll show up by default. | |||
bkeeler | That would be nice | ||
18:35
synth joined
18:37
justatheory joined
|
|||
PerlJam | Is there a way to see what rules a grammar has? | 18:37 | |
pmichaud | .methods? | ||
rakudo: Grammar.methods>>.say | 18:38 | ||
p6eval | rakudo fb2fd4: OUTPUT«Method 'methods' not found for invocant of class ''» | ||
jnthn | meta | ||
pmichaud | hmmm. | ||
jnthn | .^ | ||
pmichaud | rakudo: Grammar.^methods>>.say | ||
rjh_ | rakudo: Grammar.^methods>>.say | ||
p6eval | rakudo fb2fd4: OUTPUT«parseparsefile» | ||
18:38
ispy_ joined
|
|||
rjh_ | snap! | 18:38 | |
pmichaud | there are likely more than this -- right now I'm not sure how Rakudo's Grammar type is interacting with PGE::Grammar | ||
I'm a little surprised it only came back with parse and parsefile, though. | 18:39 | ||
TimToady | thinking more about abstraction and failure, I'm wondering if "while foo() -> $var {...}" should be defined as running until the binding fails, where presumably an undefined return from foo() fails to bind | 18:40 | |
pmichaud | that somewhat goes against the notion of if $x { } else -> $y { } those | ||
*though | |||
not a big loss, but different. | 18:41 | ||
TimToady | else -> $y where Abstraction | ||
or whatever sugar it turns out to be | |||
pmichaud | it does seem like a good idea to not propagate failures except where explicitly allowed | 18:42 | |
TimToady | it's almost a variant of else -> $y? | ||
pmichaud | i.e., passing a Failure to a function that isn't prepared to handle it could be a form of "using the failure should throw the exception" | ||
TimToady | could we overload ? to mean undef allowed? hmm | ||
pmichaud | that seems odd. | ||
TimToady | or -> $y// somehow | 18:43 | |
pmichaud | I did (75% jokingly) suggest prefix:<//> in the meeting the other day. :-) | ||
TimToady | I'm thinking more suffix, since stands in for a where | ||
pmichaud | sure. | ||
18:43
ispy_ left
|
|||
pmichaud | that could work, but it doesn't have that "ring of truth" about it to me yet. | 18:44 | |
DanielC | PerlJam: Well... I think I have a bottom-up implementation. It works, but it's not very elegant. sial.org/pbot/37055 | ||
[particle]- | $m// | ||
DanielC | PerlJam: Oops, that's missing the do_op() function, but you can guess what it does. | 18:45 | |
[particle]- | $y? | ||
that doesn't really work in sigs | 18:46 | ||
pmichaud | I wonder if/how this relates to the fact that we allow any scalar to hold undefs regardless of type constraint | 18:47 | |
the fact that it wouldn't bind by default but would assign by default seems... weird. | |||
[particle]- | wait, what? | ||
my int $x = 3; $x = undef; # no earth-shattering kaboom? | |||
pmichaud | rakudo: my Int $x = 3; $x = undef; | 18:48 | |
p6eval | rakudo fb2fd4: ( no output ) | ||
pmichaud | rakudo: my Int $x = 3; $x = undef; say "no kaboom" | ||
p6eval | rakudo fb2fd4: OUTPUT«no kaboom» | ||
[particle]- | that's Int, and that i get. | ||
i'm talking int. | |||
TimToady | that's defined to kaboom anyway | ||
pmichaud | sure, that kabooms | ||
[particle]- | ok | ||
that matches my expectations. | 18:49 | ||
is 'int' not 'Scalar'? | |||
TimToady | it's essentially the Just vs Maybe distinction of Haskell, we need a notation on the type itself as to whether it should be considered a subset that disallows undef | 18:50 | |
and a decision on whether that should be default | |||
StephenPollei | I thought section 02 said int couldn't hold a undef, I don't recall for certain | 18:51 | |
TimToady | because native types are naturally subset types | ||
and int in particular has no representation for undf | 18:52 | ||
*undef | |||
whereas num could translate at least some undefs to NaN | |||
StephenPollei | thats what I recall S02 saying | ||
pmichaud | S02 says that non-native typed variables can hold undef | 18:53 | |
native typed variables cannot (with the num exception that TimToady++ just cited) | |||
StephenPollei | my int $y = undef; # dies | ||
TimToady | the can, but that's independent of whether the type check acts as a subset constraint or not | ||
StephenPollei | my Int $x = undef; # works | ||
pmichaud | My original statement should've probably said "any non-native type constrained scalar" | ||
18:53
ruoso_ joined
|
|||
pmichaud | In general I'm not referring to native types in any way, shape, or form unles I explicitly say so :-) | 18:54 | |
*unless | |||
my original point was that we allow | |||
my Int $x = undef; | |||
but would seemingly disallow | |||
[particle]- | (Just vs Maybe)++ | ||
pmichaud | sub foo(Int $x) { ... }; foo(undef) | 18:55 | |
[particle]- | so, in general, core non-native types follow 'maybe' semantics | 18:56 | |
native types follow 'just' semantics | |||
but there are exclusions, in that some non-native types want 'just' semantics | |||
TimToady | so even if we leave that default, we could tell people to write something like: while foo() -> just $x | 18:57 | |
[particle]- | and there needs to be a way to distinguish the semantics | ||
18:57
masak joined
|
|||
masak | oh hai | 18:57 | |
TimToady | but really just Str $x | ||
if it modifies the type constraint | |||
well, I suppose just $x means just Any $x | |||
pmichaud | I'm afraid I don't completely understand the meaning behind 'just' and 'maybe' | ||
StephenPollei | multi sub foo(Int $x) { ... }; multi sub foo(Str $x) { ... }; foo(undef) | 18:58 | |
TimToady | as opposed to "not just any $x" :) | ||
[particle]- | Just = only this type and not undefined things | ||
TimToady | haskell doesn't have the anti-just sense, afaik | ||
pmichaud | that doesn't match my sense of "just"'s english meaning, though. | ||
TimToady | the the don't care sense of maybe | ||
pmichaud | To me, "just Int" would mean "Int and only Int," | ||
TimToady | s/the/just | ||
not suggesting that syntax | 18:59 | ||
just trying to nail down the fact that it's a modifier on the type, not the $x | |||
19:00
ruoso left
|
|||
pmichaud | agreed. | 19:01 | |
TimToady | it would be possible to interpret Int differently by default for assignment than for binding | ||
pmichaud | yes, I thought of that -- that seems strange to me also. | ||
TimToady | if we had a way to mark it either way | ||
jnthn -> dinner, bbiab | 19:02 | ||
masak eagerly waits for the Matt-W/masak hackathon to commence | |||
Matt-W is just putting on some hacking music | 19:04 | ||
masak is putting on his robe and wizard hat | |||
TimToady | just don't put on some putting off hacking music | ||
Matt-W | Right | 19:07 | |
There we go | |||
masak | Matt-W: I'm looking at search.cpan.org/dist/Perl6-Form/For...cal_fields right now. you got an attack plan, or do we just wing it? | ||
Matt-W | I think we throw together a plan, and then we grab hold of it and leap off into the unknown, attempting to use it as a parachute | 19:08 | |
There are clearly two areas required here | |||
masak | sounds reasonable to me. and perfectly safe. | ||
Matt-W | One is the extension of the grammar and actions and data structures to parse these fields and create the objects to describe them | ||
The other end is the routines which actually do the work - a new Form::NumberFormatting module, I suspect | 19:09 | ||
masak | aye. | ||
Matt-W | And then we just stick them together with a little glue | ||
masak runs './proto update form' | |||
Matt-W | So do you feel more like grammar hacking, or writing formatting routines? | 19:10 | |
masak | I feel like writing tests! | 19:11 | |
Matt-W | You don't get out of writing tests either way :) | ||
masak | oh. :) | ||
can I at least write the tests first? :) | |||
Matt-W | Tests go hand in hand! | ||
If you like | |||
masak visualises the tests going hand in hang | |||
er, s/hang/hand/ | |||
Matt-W | yes, tests are very friendly and slightly archaic | 19:12 | |
19:12
bkeeler left
|
|||
Matt-W | culturally, that is, not at all archaic in software usefulness | 19:12 | |
Matt-W makes sure form works with latest rakudo | |||
19:13
bkeeler joined
|
|||
Matt-W | masak: you should be able to push to mattw/form btw | 19:13 | |
all 100 form tests passing | |||
better fix that | |||
masak | :) | ||
19:13
payload joined
|
|||
Matt-W | I'll do Form::NumberFormatting | 19:14 | |
masak | ooh, pmichaud++ # Perl6::Grammar.parse | ||
19:14
justatheory left
|
|||
masak | I'm not sure I'll get any sleep tonight. :) | 19:14 | |
eiro | hello guys | ||
pmichaud | note that it will change to STD.parse at some point. | ||
masak | eiro: o/ | 19:15 | |
pmichaud: yes, of course. | |||
I've lived through change before, I can do it again. | |||
pmichaud | I suppose that as a temporary fix I can do: grammar STD is Perl6::Grammar { }; | 19:16 | |
:-P | |||
Matt-W | :) | ||
masak | oh, you don't have to. I can do it in my script instead. | ||
sjohnson | hey ma | 19:19 | |
Matt-W: | |||
i mean | |||
Matt-W considers how to do number formatting | 19:20 | ||
sjohnson: hello | |||
masak | Matt-W: number format parsing, does it go in its own .t file, or in an existing one, such as 01-fieldparsing.t? | 19:21 | |
japhb | Tene: ping again # sorry I missed you before | ||
Tene | japhb: hi | ||
japhb | Yay! You're here. | ||
.oO( Nice, reception, huh? ) |
19:22 | ||
Matt-W | masak: I'd put it in with the parsing tests for text | ||
Tene | AFK, internet sabbatical for the next week. | ||
japhb | OUCH | ||
Tene lies. | |||
Anyway, what's up? | |||
japhb | I guessed. :-) | ||
I'm trying to get OpenGL working with Rakudo again. Last time I had it working was before the HLL namespace change and your use Foo:from<bar> work. | 19:23 | ||
So now I need to figure out how to get a Parrot module to load into current Rakudo. | |||
Do you know offhand the right incantation, and if not, where in the code do I start looking for answers? | |||
Tene | japhb: I know exactly what you need to do! | 19:24 | |
japhb | Yay again! | ||
Tene | Check out... uh... 'sec | ||
pmichaud is very interested to learn this also. :-) | |||
Tene pastes | 19:25 | ||
Matt-W | do we have an integer division operator? | ||
Tene | gist.github.com/124453 | ||
masak | hm, my Rakudo doesn't work. :/ | ||
Tene | japhb: like that. Make sure that the namespace matches the file path, in the usual way, including case | 19:26 | |
TimToady | we have a type-specific div that could do that | ||
Matt-W | masak: noooooooooo | ||
TimToady | but it's not div in the Pascal sense | ||
masak | pmichaud: has anyone reported the error message C<"load_bytecode" couldn't find file 'perl6.pbc'> lately? | ||
Matt-W | TimToady: okay | ||
pmichaud | masak: no. | ||
masak | pmichaud: I had it earlier today on feather too. | ||
19:26
[particle]1 joined
|
|||
masak | pmichaud: I'm thinking it might be because I insist on running bleeding-Parrot/bleeding-Rakudo. | 19:26 | |
pmichaud | masak: if running bleeding parrot, that could be an issue, yes. | 19:27 | |
I'll try bleeding parrot. | |||
TimToady | div could integer division, but it wouldn't coerce to Int unless you supplied the extra multis | ||
masak rebuilds | |||
TimToady | *could do | ||
japhb | Tene: When you say the namespace matches the file path ... where exactly does it need to be now? For OpenGL, is the current location in parrot/runtime/parrot/library/OpenGL.pbc correct? | ||
Tene | masak: I always run latest rakudo and parrot. Where are you seeing that problem? | ||
TimToady | div is really generic division, not integer | 19:28 | |
masak | Tene: when running the fakecutable. | ||
Tene | japhb: if you have that path, you need to use the namespace ['OpenGL'] | ||
masak | Tene: nice to know I'm not alone in this habit. :) | ||
pmichaud | the fakecutable of perl6, or some other fakecutable? | ||
masak | pmichaud: the perl6 one. | ||
pmichaud | okay. | ||
TimToady | Matt-W: but otherwise you currently want Int($x/$y) | 19:29 | |
or floor maybe | |||
Matt-W | TimToady: thanks | ||
I thought about it and I think floor is more appropriate | |||
japhb | Tene: Line 81 of OpenGL.pir says .namespace ['OpenGL'] , so I'm good there. | ||
pmichaud | (in rakudo, Int($x/$y) wont work. use floor, or .int) | ||
TimToady | .int should coerce to the native type, of course... | 19:30 | |
pmichaud | in our case, it probably does exactly that :-) | ||
we can likely add a .Int, though. | 19:31 | ||
japhb | Tene: does c.'export'('subname') have a lot of set up overhead? In other words, do you expect a big difference between doing c.'export'('subname') several thousand times, versus doing names = join(list-of-thousands-of-names); c.'export'(names) ? | 19:34 | |
19:34
EvanCarroll joined
|
|||
EvanCarroll | I just had a brilliant idea. | 19:34 | |
Rather than unshift/shift, we should have pull/shove. | |||
;)) | |||
pmichaud | masak: the perl6 fakecutable appears to be working fine for me, bleeding rakudo/parrot | ||
rjh_ | EvanCarroll: beautiful | 19:35 | |
EvanCarroll | because it takes more force to shove something under an array, then it takes to push it on the top of an array... | ||
Tene | japhb: I'm not sure whether the former will work at all | ||
rjh_ | can we use those for gather/take semantics as well? | ||
Tene | lemme check | ||
japhb | take($this_job) && .shove($_) | ||
masak | pmichaud: I get the C<"load_bytecode" couldn't find file 'perl6.pbc'> error when running outside of the parrot/languages/rakudo dir. when I run from within it, it works for -e scripts. | ||
19:35
hercynium left
|
|||
pmichaud | sounds to me like parrot may have changed its load_bytecode semantics. | 19:35 | |
masak | pmichaud: for Matt-W's first test file, I get a really weird error: C<A method named 'clone' already exists in class 'Perl6Object'. It may have been supplied by a role.> | ||
EvanCarroll | rjh_: I'm being serious here... there is an easy mental connection between force and the begining of an array. | ||
Tene | japhb: looks like the former would work (thousands of calls), but I wouldn't be too surprised if it was kinda slow. | 19:36 | |
japhb | Tene: OK, thanks | ||
EvanCarroll | I'm just saying it would certainly be better than a confusing inconstant un- syntax. | ||
rjh_ | EvanCarroll: I actually think there's a clear mental distinction between push/pop and shift/unshift | ||
japhb | Syntax tends to be very inconstant. | ||
pmichaud | Tene: doesn't 'export' take an array also? | ||
Tene | pmichaud: it should. It currently doesn't. | 19:37 | |
rjh_ | whereas push/shove are strongly associated words | ||
EvanCarroll | but a shove is always a stronger form of a push. | ||
rjh_ | i don't really see the relation | ||
end-users don't need to be concerned that adding to the other end of a stack is more 'difficult' | |||
pmichaud | masak: how long since a realclean? | 19:38 | |
EvanCarroll | no they don't. but humans naturally think about this... | ||
masak | pmichaud: a couple of minutes ago. I just rebuild everything. | ||
pmichaud | hmmm. | ||
rjh_ | Perl6 arrays are presumably designed to work as queues or stacks | ||
EvanCarroll | 100% of people view arrays as laying horizontally or vertically, no one thinks of them us internally ordered, non-sorted abstract lists. | ||
masak | s/d/t/ | ||
pmichaud | I wonder how I fall outside of the 100%, then :-) | 19:39 | |
rjh_ | imho, push/pull/shove are too similar to each other | ||
Matt-W | pmichaud: it worked for me when I updated about 20 minutes ago | ||
EvanCarroll | I'm just saying the connection is definitly there, I remember being confused about ``shifting onto an array'' or ``shifting off of an array'' niether of those made any sense to me when i start, and they still don't know | ||
now* | |||
pmichaud | masak/Matt-W: I'm a bit stumped then. It all appears to be working fine for me. | 19:40 | |
rjh_ | I'll admit I only know what 'shift' does because of Perl 5 :) | ||
pmichaud | fwiw, I knew of 'shift' from shell programming. | ||
EvanCarroll | see. | ||
masak | I admit it seems to be something on my system that fails. | ||
pmichaud | "shift" is the way to process command line arguments in shell scripts. | ||
masak | I'll try a clean download and see if that helps. | ||
pmichaud | masak: that would be good. | ||
rjh_ | seems python doesn't have shift/unshift. it uses pop(0) to pop from the left side | 19:41 | |
perhaps they agree with you | |||
pmichaud | "shift" is also what we do with bit shifting , although it's normally called left-shift and right-shift. | ||
japhb | Speaking of shell scripts, I've clearly spent too much time around you guys, because yesterday I yak shaved for a couple hours figuring out how to do functional programming in bash. Quoting was an issue. | ||
19:41
kate21de joined
|
|||
jnthn back | 19:42 | ||
pmichaud | japhb: hey, don't blame me! Most of my code is highly dis-functional. :-) | ||
jnthn | I eated a cheezburger! | ||
Greatest achievement all day... | |||
japhb | mmm, did that last night | ||
TimToady | Int:D is constrainted to defined, Int:U is constrained to undefined, and Int:P is constrained to stick out its tongue | ||
pmichaud | I had a cheezburger for lunch | ||
sjohnson | heheh | ||
"eated" | |||
jnthn | TimToady: Oh, pretty. | ||
masak | I baked some delicious bread tonight. | ||
pmichaud | Once again, TimToady gets the colon. | 19:43 | |
TimToady | I especially like :D | ||
masak | and then I eated it. | ||
TimToady | for a value that makes you happy | ||
rjh_ | :U looks aghast | ||
japhb | Once again, my IM client is going to mangle my code ... | ||
TimToady | it does at that | ||
well alloweing either is probably :B or some such | 19:44 | ||
EvanCarroll | TimToady: shift/unshift, vs pull/shove ? | ||
pmichaud | :U looks like it's not quite complete. Like it's somehow poorly defined... :-) | ||
rjh_ | "An undefined parameter? In MY subroutine?" | ||
pmichaud | "Excuse me, you seem to be missing part of your mouth." | ||
japhb | "Oh, Programmer, how *could* you?!?" | ||
TimToady | then we just make -> $x default to Any:D and while -> work on binding success rather than boolean | 19:45 | |
japhb | "Any:D" ... isn't that a famous rapper? | ||
pmichaud | ....binding success? | ||
oh, just for while. | |||
hmmm. | |||
TimToady | and if | ||
pmichaud | is that a special syntactic case, then? | 19:46 | |
TimToady | but it's specially generally, not just special specially :D | ||
pmichaud | okay, I'm confused. | ||
rjh_ | DWIM++ | ||
TimToady | while -> is already a special syntactic form | ||
pmichaud | while $a != 'hello' { ... } # is that binding failure? | ||
TimToady | or at least if -> is | 19:47 | |
masak | how so? | ||
TimToady | since the if changes the default arity of the block | ||
masak | ah. | ||
TimToady | so does while | ||
EvanCarroll | How would i change perl6 to use pull/shove rather than shift/unshift? This is very important to me. | 19:48 | |
masak | nice to know there are still things Perl 6 sweeps under the carpet for me! :) | ||
pmichaud | currently rakudo does if/while without changing the arity of the block. | ||
and this sounds to me more like the arity of the block changing the meaning of the if/while | |||
(unless it's truly syntactically special) | |||
skids_ | EvanCarroll: with macros, once they work (that is, not currently) | ||
StephenPollei | EvanCarroll, probably just make alias ::= or something | 19:49 | |
sjohnson | what does the p6 community think of a $DUMMY compiler variable | ||
TimToady | I have no idea what the p6 community thinks of anything :) | ||
most of them don't know they'll be a part of it someday | |||
sjohnson | much like the other $VARIABLES_TO_USE in Perl | ||
pmichaud | EvanCarroll: class Array is also { method pull(*@_) is export { self.unshift(@_); } ... } | ||
EvanCarroll: (only works in Rakudo at the moment, will eventually change to 'augment') | 19:50 | ||
sorry, s/unshift/shift/ | |||
rjh_ | lol his point has been proven | 19:51 | |
pmichaud | not really. | ||
I understand shift/unshift just fine, I got pull backwards. | |||
rjh_ | no, i was just goading you | ||
sorry :/ | |||
TimToady | he was shifting your leg | ||
rjh_ | heh :) | ||
Matt-W | I found a bug! | 19:52 | |
TimToady | is it a butterfly? | ||
Matt-W | rakudo: my $a = 0.14; $a *= 100; my $b = $a.floor; say $a == $b | 19:53 | |
p6eval | rakudo fb2fd4: OUTPUT«0» | ||
TimToady | welcome to the world of floating point | ||
pmichaud | anyway, back to if/while | ||
I have trouble seeing if foo() -> $y { ... } as meaning "does foo() bind to $y" as opposed to doing a boolean check | 19:54 | ||
Matt-W | rakudo: my $a = 0.14; $a *= 100; my $b = $a.floor; say $a == $b; say $a; say $b | ||
p6eval | rakudo fb2fd4: OUTPUT«01414» | ||
Matt-W | I find it very hard to blame floating point arithmetic when they stringify to the same string | ||
jnthn | pmichaud: fwiw, the same... | ||
TimToady | Matt-W: 0.14 is not exactly represented in floating point | ||
Matt-W | okay | ||
so can I have a sane number system? | |||
TimToady | rakudo: say 0.14.fmt("%16f") | 19:55 | |
StephenPollei | Matt-W, it happens that sometimes the stringify rounds some | ||
p6eval | rakudo fb2fd4: OUTPUT« 0.140000» | ||
pmichaud | rakudo: my $a = 0.14; $a *= 100; say $a.fmt('%.15f'); | ||
p6eval | rakudo fb2fd4: OUTPUT«14.000000000000002» | ||
masak | pmichaud: both errors still persist after clean install. | ||
TimToady | rakudo: say 0.14.fmt("%.16f") | ||
p6eval | rakudo fb2fd4: OUTPUT«0.1400000000000000» | ||
TimToady | rakudo: say 0.14.fmt("%.20f") | ||
p6eval | rakudo fb2fd4: OUTPUT«0.14000000000000001332» | ||
Matt-W | I think I'll just rip all my hair out now | ||
pmichaud | Matt-W: but if stringification is your criteria, then | 19:56 | |
StephenPollei | p6 has Rat if you need it | ||
pmichaud | rakudo: my $a = 0.14; $a *= 100; my $b = $a.floor; say $a eq $b; say $a; say $b | ||
p6eval | rakudo fb2fd4: OUTPUT«11414» | ||
masak | StephenPollei: p6 yes, r no... | ||
TimToady | pugs: my Rat $a = 0.14; say $a.fmt("%.20f"); | ||
p6eval | pugs: ( no output ) | ||
StephenPollei | otherwise with float point it's good idea never to test equality but if it's within epsilon | ||
TimToady | pugs: my $a = 14/100; say $a.fmt("%.20f"); | ||
pmichaud | ...is 0.14 a Rat? | ||
p6eval | pugs: ( no output ) | ||
Tene | japhb: how's it going? | 19:57 | |
Matt-W | okay | ||
so | |||
using string operations to manipulate numbers | |||
japhb | Tene: delayed by sudden need for sandwich. | ||
pmichaud | I sometimes find myself wanting an "approx equal" operator. I've been using ~==~ for that lately. | ||
Matt-W | I've never been bitten by floating point like this before | ||
pmichaud | Unfortunately it looks too much like a longhorn cattle. | ||
StephenPollei | by p6 I mieant perl6 and I thought it was in S02 and others, unless I'm wrong | ||
TimToady | what's the non-Texas form of that? | ||
Tene | ≈ | 19:58 | |
pmichaud | There is no non-Texas form. :-) | ||
Tene | ? | ||
TimToady | nothing else approximates Texas... | ||
pmichaud | longhorn cattle are unique to Texas :-P | ||
japhb | Tene: but I did think of a possible issue. How would I import the OpenGL functions in *pir*? (For example, if I wanted to write OpenGL::Simple, say, and I decided to write it in PIR, how would I do the import after loading OpenGL.pbc? Right now, there's a hand-coded import function in the OpenGL that you can call, but I'm hoping your work makes that redundant.) | 19:59 | |
StephenPollei | ≈ and ~==~ might be useful but often you have to specify the epsilon | ||
pmichaud | StephenPollei: adverb | ||
$a ~==~ $b :epsilon(0.1) | |||
StephenPollei | yes I keep forgeting , I need to get used to perl6ish stuff | 20:00 | |
Tene | japhb: I can make it redundant shortly... speaking of which, do you expect to ever have any interest in importing a library written in a HLL from PIR? | ||
Matt-W | pmichaud: would that get given to the infix op as a named parameter? | ||
japhb | Tene: yes | ||
Tene | japhb: Okay. | ||
pmichaud | Matt-W: yes. | ||
Matt-W | pmichaud: cool. does that work in rakudo? | 20:01 | |
pmichaud | Matt-W: no. | ||
Tene | japhb: I'm thinking an 'import' method on the 'parrot' compiler... what sort of API do you expect? | ||
Matt-W | aww | ||
pmichaud | Tene: my expectation has been 'import' method. | ||
Tene: however, I need to review TimToady's latest changes to S11 | |||
StephenPollei | rakudo: my Rat $a = 14 div 100; say $a | ||
p6eval | rakudo fb2fd4: OUTPUT«Malformed declaration at line 2, near "Rat $a = 1"in Main (src/gen_setting.pm:0)» | ||
pmichaud | rakudo doesn't have Rats yet. | 20:02 | |
Matt-W puts Rat on his christmas list | |||
pmichaud | You want a Rat for christmas? | ||
Tene | import(lang,list)? import(lang,delimited-string)? | ||
pmichaud | hmmmm.... | ||
Matt-W | I want a non-floating-point non-integer numeric type :) | ||
pmichaud | Tene: why 'lang'? | ||
Tene | pmichaud: japhb just said the he expects to want to import foreign libraries from PIR. | 20:03 | |
masak | pmichaud: I'm one step closer to encircling my problem. it doesn't trigger for small things like -e 'say "OH HAI"', but it triggers for a precompiled lib/Form/Grammar.pir in Matt-W's Form. | ||
pmichaud: when I remove the .pir file, everything works. | |||
Tene | pmichaud: I could have a multi, though | ||
Matt-W | masak: not a very productive hackathon really, is it | ||
StephenPollei | also is S02 serious that there is going to be a rat and a Rat .. I don't know of any handware where rat is native, or am I overreading into what native means | ||
masak | Matt-W: you don't get this error? | ||
Matt-W | masak: works fine here | 20:04 | |
masak | Matt-W: how bleeding is your Rakudo? | ||
Tene | masak: is the directory that contains perl6.pbc in your parrot search path? | ||
masak | ditto Parrot. | ||
Tene | masak: if not, how do you expect 'load_bytecode' to find it? | ||
pmichaud | Tene: I think I need to review S11 a bit more first before committing to a design. But I'll do that tonight. | ||
masak | Tene: what's a Parrot search path? | ||
pmichaud | Tene: the 'load_bytecode' is working for me no matter what directory I'm in. | ||
Tene | masak: the places that parrot looks for stuff when you say 'load_bytecode' | ||
japhb | Tene: even if I personally didn't think I would use it, I would still want to see it supported. It should be possible to do from PIR anything an HLL do. IOW, it should be a first-class language, just special to Parrot because it's "core". | 20:05 | |
Tene | pmichaud: you must have a different setup from masak | ||
skids_ | Speaking of Rat, do we have a "require BigNum" or something specced? Or is it default, in which case is there a "no Bignum"? | ||
pmichaud | Tene: sure, we're wondering what that difference might be | ||
because I don't have anything special in my setup afaik | |||
Tene | masak: run: | ||
strace -estat -o perl6.log perl6 whatever.pl | |||
then nopaste the perl6.log | |||
pmichaud | my guess is that masak might be getting a different perl6 binary | 20:06 | |
i.e., one that is looking for perl6.pbc in the wrong place. | |||
masak | I need to install strace, it seems. | ||
pmichaud | masak: how are you invoking perl6? | ||
with a full path, or just as 'perl6'? | |||
Tene | pmichaud: I'll add a method to languages/parrot/parrot.pir, and if you don't like it, you can change it later, yes? | ||
pmichaud | Tene: sure, as long as it doesn't become spec. | ||
masak | pmichaud: I symlink from /usr/local/bin/perl6 into the fakecutable in the Rakudo directory. | 20:07 | |
Tene | pmichaud: the 'parrot' compiler isn't specced at all anywhere yet. | ||
pmichaud: this is just a utility method for when writing PIR. | |||
pmichaud | I know, but we still have to be careful about what people come to reply upon. | ||
StephenPollei | skids, I think Int in Bignum-ish , not sure about Num | ||
Tene | Okay. | ||
masak | pmichaud: that's how I usually do. but here I call the perl6 fakecutable directly, just to be safe. | ||
pmichaud | Technically the PGE stuff isn't specced anywhere either (outside of S05), but I still have to fundamentally deal with deprecation issues. | ||
masak: and there's not some other libparrot floating around on the system that might be getting in the way? | 20:08 | ||
masak | pmichaud: how do I test that? | ||
I really don't think so. | |||
pmichaud | I don't know. I really don't think so either, but I'm at a loss as to why you might be running into these issues. | 20:09 | |
I need a break -- bbiab | 20:10 | ||
[particle]1 | back from power-outage-induced lunch | 20:11 | |
masak | I have four Rakudo/Parrot setups (locally) built on my computer right now: the one I usually run, one installed by proto, another installed by another copy of proto, and the one I just built. | ||
pmichaud | maybe try from a fresh shell? Perhaps it's hashed the wrong copy. | ||
masak | neither should interfere with any other. | ||
masak tries from a fresh shell | |||
pmichaud | I'm grasping at straws, yes. | 20:12 | |
masak | it works now. :) | 20:13 | |
pmichaud++ | |||
Matt-W: now, where were we? :) | 20:14 | ||
TimToady | std: $a == $b :ϵ(1e-10) | ||
p6eval | std 27012: OUTPUT«Potential difficulties: Variable $a is not predeclared at /tmp/B1GzYvDNha line 1:------> $a == $b :ϵ(1e-10) Variable $b is not predeclared at /tmp/B1GzYvDNha line 1:------> $a == $b :ϵ(1e-10)ok 00:02 36m» | ||
masak | oh right, I was to add a test. | ||
20:15
pmurias joined
|
|||
pmichaud | having: $a == $b :ϵ might be nice :-) | 20:15 | |
masak | oh wait. :/ I tested the wrong thing. it still fails when I precompile... | ||
I guess I'll simply have to run un-precompiled tonight. | |||
pmichaud | masak: what are you precompiling? | ||
skids_ wonders whether TimToady forgets the "my" like everyone else, or just likes to show off STD's error handling. | |||
masak | pmichaud: Matt-W's Form. | 20:16 | |
pmichaud: you can easily compile it by doing './proto install form' | |||
pmichaud | masak: and then you're running it directly with Parrot? | ||
masak | pmichaud: then I'm running 'perl6 -e "use Form::Grammar"' | ||
pmichaud | Hmm. | ||
StephenPollei | $a == $b :ϵ(1e-10) looks nice TimToady++ | ||
Tene | masak: strace log? | ||
masak | so, .pm file works, .pir file doesn't. | ||
pmichaud | I didn't try that on my system. | 20:17 | |
masak | Tene: I'll try to find strace for Mac OS X. | ||
Tene | masak: oh, OS X. No idea. | ||
TimToady | skids_: never attribute to malice that which can be easily explained by stupidity :) | ||
Tene | I think they have something else there... | ||
bkeeler | dtrace | ||
japhb | Tene: Does c.'export'() just add subnames to the DEFAULT tag for now? If so, what will be the syntax to add something to a different tag, or to multiple tags? | ||
masak | ah, dtruss. | ||
skids_ | Does :ϵ have a default. I mean other than 50 points for the medium speed space invader? | 20:18 | |
pmichaud | japhb: they'll be additional parameters to 'export' | ||
I don't know yet if they'll be named or positional | |||
japhb | pmichaud: OK, thanks. | 20:19 | |
Tene | japhb: it just adds to the 'DEFAULT' and 'ALL' tags. The syntax for anything else is whatever you want it to be. :) | ||
skids_ | Oh I guess :ϵ would be ϵ => 1. Alas. | ||
japhb | heh | ||
20:20
mizioumt1 left
|
|||
pmichaud | actually, :ϵ is ϵ => True | 20:20 | |
(which numifies to 1, but "true" could be taken to mean some other constant in this case) | |||
s/constant/value/ | |||
TimToady | so $a == $b :ϵ is integer comparison :) | 20:21 | |
pmichaud | oh? | ||
TimToady | I'm just shifting your leg | ||
pmichaud | 2.3 == 1.4 :ϵ # not integer comparison | ||
2.3 == 1.4 :ϵ(1) # not integer comparison | 20:22 | ||
TimToady | I agree it could sigwise match Bool and do something else | ||
StephenPollei | almost but not quite integer comparisom Int(4.5) == Int(5.2) and 4.5 == 5.2 :ϵ -- differ | ||
masak | Tene: I don't really expect this to help/enlighten: gist.github.com/124489 | ||
skids_ | Could be taken as "reasonable defloatification" for (Int, Num) | ||
pmichaud | I like the sigwise match bool | ||
Tene | No, not helpful. :) | ||
pmichaud | and it could use $*EPSILON or something as the default :-) | 20:23 | |
TimToady | well, some small percentage of the large magnitude value | ||
japhb | TimToady: How would you express matching to a particular number of significant bits, so that the looseness of the equality match is automatically proportional to the magnitude of the operands? | ||
TimToady | *larger | ||
StephenPollei | well I see $.EPSILON being part of class more helpful | ||
TimToady | yes, though for floaters you want sigbits as japhb suggests | 20:24 | |
StephenPollei | japhb, I think yet another adverb might be needed | ||
TimToady | just different for single vs double precision, for instance | ||
japhb | Right. | ||
skids_ | There is a letter for relative error I think... | ||
StephenPollei | num is always double iirc, and Num I don't know | 20:25 | |
japhb | skids_: that would be perfect | ||
TimToady | yes, but num32 is not always double :) | ||
japhb | StephenPollei: smaller nums are spec'ed. | ||
Down to num16, at my suggestion. :-) | |||
StephenPollei | yes I show the native by size ones | ||
I also wondered what that mean for cpus without floating point, I guess the compiler decides | 20:26 | ||
masak | Matt-W: just made my first commit. :) | ||
TimToady is looking forward to ubiquitous num128s so time doesn't have to return a Rat | |||
skids_ | en.wikipedia.org/wiki/Relative_error | ||
TimToady | Num is defined to allow Rat internals lazily converted to Num, though it's still more than a bit handwavey | 20:27 | |
StephenPollei | nad it isn't speced how much is matissa and how much is exponent .. hopefully terms right | ||
TimToady | anyway :ϵ is close enough for now; I'll leave the rest to smart people :) | 20:28 | |
20:28
gegloe left
|
|||
pmichaud | Isn't that the definition of :ϵ ? ;-) | 20:29 | |
TimToady | 1..10 :Δ(3) | ||
skids_ | Rat still needs some sort of .num, .den specced IIRC. Also, have the advatages/disadvantages of Rat does Pair been weighed? | ||
pmichaud | note that ".num" is taken. | ||
japhb | skids_: so 1.1 == 1.0 :η(...) then, but what should the ... be? | ||
pmichaud | TimToady: in S11, how much do you think is likely to change...? | ||
(w.r.t need/defines/etc) | |||
TimToady | defines is still a bit wobbly, syntaxwise | 20:30 | |
pmichaud | is it "generally correct" now, or do you think there's a good chance it will major shift? | ||
TimToady | thinking about "defines *" | ||
or maybe making that the default | |||
it's all just syntax now | |||
pmichaud | also, are tags simply identifiers that begin with a colon? | ||
skids_ | japhb: I meant there is a greek letter used for that, not that it's specced -- but that would be a number < 1 usually. | 20:31 | |
Tene | japhb: do you expect that foreign namespaces will be imported too? | ||
TimToady | they're just adverbials, syntactically | ||
japhb | Tene: urm. Explain what you mean by that, please. | ||
pmichaud | the spec doesn't show them parsing as adverbial, though. | ||
Tene | japhb: if I do: | ||
TimToady | are you referring to :MY<:ALL>? | 20:32 | |
japhb | skids_: I am just wondering if it's more useful to have a decimal number in the eta adverb, or some number of sigbits. | ||
pmichaud | yes | ||
Tene | compiler.import('perl6','Foo::Bar') would you expect that ['perl6';'Foo';'Bar'] is also available as ['parrot';'Foo';'Bar'] ? | ||
pmichaud | I was also referring to is export(...), but I see there they could be adverbial | ||
Tene | I guess that's not as much of an issue for PIR, but other languages often expect that. | ||
TimToady | it's handling the string ':ALL' specially | ||
pmurias | ruoso_: ping | ||
DanielC | Yay \o/ I now have full RPN calculator with bottom-up grammar. It's actually quite simple, but I had to learn the basics of grammars first. | ||
TimToady | :MY<$x $y> | ||
ruoso_ | pmurias, pong | ||
skids_ | japhb: potentially putting 1/η in there would be prettier. | 20:33 | |
TimToady | '$x' and '$y' are just strings here | ||
pmichaud | right. | ||
20:33
rocket_guatemala joined
|
|||
pmichaud | I was looking for ":ALL is a string there". | 20:33 | |
(which I got) | |||
TimToady | unless we go with something supra-declarational like defines (my $x, my $y) | ||
pmichaud | in the case of | ||
sub bar is export(:DEFAULT :others) {...} # :DEFAULT, :ALL, :others | |||
those are named parameters, syntactically? | |||
TimToady | sec... | 20:34 | |
pmichaud | sorry, named arguments | ||
pmurias | ruoso_: if new signatures will be used for subs and methods how will we bootstrap them? | ||
japhb | Tene: that makes sense. Might want to be able to turn that off, but as a default it makes sense to me. | ||
pugs_svn | r27013 | rocket++ | Created the t/spec/S19-command-line-options folder and started moving the t/run tests into it. | ||
r27013 | rocket++ | Moved 01-dash-uppercase-i.t to t/spec/S19-command-line-options and added smartlinks to it. | |||
Tene | japhb: I'll leave it commented out for now, and when someone wants it, they can work out the semantics. | ||
japhb | skids_: true. Now figuring out a good syntax for that without confusing mathemeticians ... | ||
Tene: OK | |||
japhb can barely keep up with IRC today and still continue to actually code ... | 20:35 | ||
ruoso_ | pmurias, I think it might be a mildew option like "--core-stage x" where that modifies the emitted code... | ||
TimToady | is export is sugar for :export, so the question is whether :export(:DEFAULT :others) is treated as arglist or inside () | ||
ruoso_ | probably '--target-stage x' | ||
masak | Matt-W: oh! I see now why you dreaded the numeric parsing. :D | 20:36 | |
pmurias | ruoso_: the other option would be to use the default signature when defining Signature | ||
ruoso_ | what do you mean? | ||
pmurias | using the implicit :(*@_,*%_) signature | ||
but that seems inelegant | |||
TimToady | if :() is just (), then they're not named params, just as foo((:a :b)) aren't | 20:37 | |
pmichaud | right | ||
TimToady | arguable the same for :MY() | ||
pmichaud | also, S11 doesn't seem to give an example of importing from a tagset (via use) | ||
TimToady | though :MY($x, $y) is problematic | ||
japhb | Tene: oooh, just ran across a problem. What about renames? My custom exporter currently does this because it needs to rename a couple NCI functions before exporting: | ||
gl_namespace.'export_to'(to_namespace, export_list) | |||
gl_namespace.'export_to'(to_namespace, export_renames) | |||
Tene | japhb: will this work for you: nopaste.snit.ch/16793 ? | ||
pmurias | ruoso_: wouldn't it be better to use a pragma instead of a compiler flag? | ||
pmichaud | unless it's | 20:38 | |
pmurias | ruoso_: like use adhoc-signatures; ? | ||
TimToady | but we could go for defines my(:TAG, $x, $y) possibly | ||
Tene | japhb: That's currently not handled at all. | ||
ruoso_ | pmurias, the Perl 6 code will be the same | ||
pmurias, it's not the code that changes, but the compiler | |||
pmichaud | use Sense <common @horse>; | ||
TimToady | and then it looks more like a real my declaration | ||
pmichaud | "common" is referring to the sub? | ||
or is it a tag? | 20:39 | ||
TimToady | not a tag | ||
was thinking sub | |||
but that's also a problem | |||
pmichaud | yes | ||
Tene | japhb: if you work out an API for it with pmichaud, I'll implement it. | ||
Might take me a bit. | |||
pmurias | ruoso_: could you explain? | 20:40 | |
TimToady | use Sense my(&common, @horse) would also need to have the my redefined like defines would do explicitly | ||
pmichaud | Tene/japhb: I'll have an API when I get S11 worked out | ||
jnthn | rakudo: multi foo(Int, Any) { }; multi foo(Any, Int) { }; foo(1,1) | ||
p6eval | rakudo fb2fd4: OUTPUT«Ambiguous dispatch to multi 'foo'. Ambiguous candidates had signatures::(Int ::TYPE_CAPTURE17, Any ::TYPE_CAPTURE18):(Any ::TYPE_CAPTURE19, Int ::TYPE_CAPTURE20)in Main (/tmp/Ohi1kel73X:2)» | ||
TimToady | unless we do something like use Sense defines my(&common, @horse) | ||
masak | Matt-W: I'm wondering if not some, most or all of the 'regex' keywords in Form::Grammar::Format couldn't be 'token' instead... | ||
ruoso_ | pmurias, eventually we might recompile the CORE code using the next --target-stage and get a more high-level code redefining the types... | ||
pmurias, so the CORE is plain Perl 6 | 20:41 | ||
but the compiler evolves from a stage 0 compiler | |||
that only uses the SMOP c implemented types | |||
to later using the types defined in the CORE to build the CORE | |||
and that's bootstrap | |||
so the code in the CORE is always the same | |||
Tene | pmichaud: Okay. | ||
pmurias | shower& | 20:42 | |
Tene | japhb: do you need renaming to get OpenGL working at all? Or will that just be nice eventually? | ||
TimToady | Module my ($x, $y) our ($z) # infix declarators in general? | ||
20:44
[particle]1 left
|
|||
japhb | Tene: (re: your PIR module loading paste): So the parent code loads the 'parrot' language, and asks its compiler object to import module 'Foo'. The parrot compiler object then knows to do a load_bytecode for the Foo.pbc. At :load time, Foo.pbc loads the 'parrot' compiler object again, registers its exports, and returns to the parrot compiler, which then does an 'import' operation, making use of the newly created export tags. Then finally | 20:45 | |
the original compiler.import('Foo') returns, and you're ready to go. Do I have that all right? | |||
pmichaud | seems like the infix declarators would want to follow 'defines' | ||
TimToady | Module defines (my ($x, $y); our $z) is more likely to extned well | ||
japhb | Tene: Actually required. Can't get the callbacks working without the rename. | ||
TimToady | nod | ||
masak | Matt-W: ping | ||
pmichaud | and tagsets? | 20:46 | |
20:46
REPLeffect joined
|
|||
Tene | japhb: that's right | 20:46 | |
TimToady | my (:foo, $x, $y) maybe | ||
japhb | Excellent. Let's hope the compiler object doesn't leak when reentered. ;-) | ||
20:46
ST47 joined
|
|||
pmichaud | is there a my/our default? | 20:46 | |
20:47
simcop2387 joined
|
|||
pmichaud | Module defines (:foo, $x, $y) | 20:47 | |
or is the my/our required? | |||
TimToady | defines :(:foo) | ||
pmichaud | what about caller and context? | ||
TimToady | yeah | ||
it just doesn't quite mesh with normal binding either | |||
pmichaud | or maybe just context | 20:48 | |
Tene | japhb: If you paste some code showing what you'd like to do, I'll implement it, as long as you're comfortable potentially changing it in a few days after pmichaud potentially decides on API changes here. | ||
TimToady | maybe context is a declarator then :) | ||
pmichaud | there is that possibilty. | ||
maybe every trait is really a declarator. :-| | |||
japhb | I'm fine with potential energy. | ||
pmichaud | since "is also" became "augment" | ||
and "is context" might become a declarator.... | |||
TimToady | lets make all types into declarators, and use * to dereference things | 20:49 | |
ruoso_ enjoys the idea of using simply "my $*a" instead of "my $a is context" | |||
pmichaud | we still want the sense of context<rw> I suspect | 20:50 | |
ruoso_ | "my $*a is rw"? | ||
20:50
[particle]1 joined
|
|||
pmichaud | that makes it sound like the variable itself is rw | 20:50 | |
japhb | Tene: It would be nice if c.import() took all of: a space separated stringified list (as it does now), a real array, or a rename hash. The latter two make it match the design of namespace.'export_to'(), which I use now. | ||
pmichaud | we run into trouble with | ||
sub foo($*a is rw) { ... } | |||
which is different from sub foo($a is rw is context) { ... } | 20:51 | ||
Tene | japhb: it's import that you need renames for? | ||
japhb | japhb: Tene: mind you, I'm not sure how you express the rename operation when you're just adding to tagsets. | ||
20:51
rocket_guatemala left
|
|||
ruoso_ | hmmm... | 20:51 | |
20:51
jferrero joined
|
|||
ruoso_ too tired to think | 20:52 | ||
TimToady | I need to go to $job | ||
japhb | Tene: It doesn't matter to me if 'export' or 'import' actually does the rename. Just that a function called ['parrot'; 'OpenGL'; 'glutcbFoo'] needs to be named ['perl6'; 'OpenGL'; 'glutFoo'] somehow. | ||
TimToady | anyway, apart from all that, it's just syntax :)( | ||
pmichaud | TimToady: ultimately, you see tags more like named arguments than strings, yes? | 20:53 | |
Tene | japhb: I'd very much prefer that it happens in export, so that any other language that loads it will also see the renamed versions. | ||
TimToady | yes, though processed more like slurpy args than bound like named | ||
pmichaud | so, more like pairs than strings | ||
japhb | I guess you need to mark the rename in 'export', then 'import' knows what to do with the mark. | ||
Tene | Right. | 20:54 | |
pmichaud | Tene/japhb: A rename simply means that the exported symbol has a different name in the EXPORT::* namespace | ||
Tene | Exactly | ||
japhb | pmichaud: speclink? | 20:55 | |
Tene | japhb: so, maybe passing a hash to export() ? | ||
pmichaud | hash... probably not | ||
japhb | Tene: yes, that's what I meant five minutes ago, but I typo'ed confusingly. | ||
Sigh. This is the problem with being too tired to keep up. | |||
Should have been: "Tene: It would be nice if c.export() took all of ..." | 20:56 | ||
Tene | ah | ||
:) | |||
pmichaud | I think I have enough info from TimToady now to indicate how I'd like import/export to work | ||
I'll think it through tonight and either write up a spec or implementation tomorrow. | |||
japhb | I guess then I will put this on the back burner until then. | 20:58 | |
pmichaud | it shouldn't be too difficult for us to implement | ||
20:58
bkeeler left
|
|||
pmichaud | other than the syntax (in Perl 6) :-P | 20:58 | |
jnthn | pmichaud: I've got some progress on the "Perl6MultiSub everywhere" branch. | ||
pmichaud | jnthn: nice | ||
faster? slower? | 20:59 | ||
jnthn | pmichaud: Like, we can actually build and startup now and pass some of the sanity tests. | ||
A tiny bit but not much slower, but I didn't do any signature caching yet. | |||
pmichaud | is there a strong reason to switch over if it's not significantly faster? | ||
jnthn | Several. 1) Being able to actually overload operators and various other builtins that we can't now. 2) Be able to toss the gen_junction special case code since it should all be handled by the auto-threading in Perl6MultiSub. 3) Correct dispatch semantics in line with the Perl 6 algorithm. | 21:01 | |
pasteling | "japhb" at 76.191.190.8 pasted "Tene, pmichaud: Rough draft of OpenGL.pir symbol export (to be called by :load routine)" (49 lines, 1.3K) at sial.org/pbot/37059 | ||
pmichaud | I thought we could solve (1) and (2) by writing the operators in setting | ||
jnthn | 4) Won't need the hack in infix:= any more. | ||
pmichaud | and (3) also | ||
for (4), we could manually switch it over to a Perl6MultiSub instead of having it happen automatically, yes? | 21:02 | ||
21:02
decasm left
|
|||
jnthn | We could do all of those things yes. | 21:02 | |
Though we would pay the price of !SIGNATURE_BIND | |||
And also, we'll run into various other issues that I'm running into now. | 21:03 | ||
Example: | |||
pmichaud | we could have a pragma/trait that removes the call to SIGNATURE_BIND | ||
jnthn | .sub 'infix:+' :multi('Complex', _) | ||
pmichaud | but in some sense we need/want SIGNATURE_BIND even for the operators | ||
jnthn | .sub 'infix:+' :multi(_, 'Complex') | ||
We can't just translate this into Perl 6. | |||
pmichaud | why is that an issue? | ||
jnthn | Because it's an ambiguous dispatch. | ||
If you dispatch with two complex numbers, under Perl 6 MMD that's an error. | 21:04 | ||
Because the candidates are tied. | |||
pmichaud | Perl 6 already supports that, though. | ||
jnthn | ? | ||
pmichaud | (looking up reference | ||
ruoso_ decommute & | 21:05 | ||
21:05
ruoso_ left
|
|||
jnthn | We get away with it now in Rakudo because we're using Parrot's MMD algorithm. | 21:05 | |
pmichaud | yes, I know. I'm saying that commutativity of types is already in the spec. | 21:06 | |
pmurias | sleep& | ||
21:06
pmurias left
|
|||
jnthn | Explain? | 21:07 | |
pmichaud | there's a way to specify multiple signatures on a sub (or, at least, there was) | ||
jnthn | Ah, that. | ||
Yes, we don't support that in Rakudo at the moment... | 21:08 | ||
pmichaud | all that the infix:+(Complex) case is doing is handling the case where either argument is a Complex. | ||
jnthn | Right. | ||
pmichaud | support that, and then the multi issue you just gave goes away | ||
jnthn | Sure, we'd have to write the 3 signatures, but they could share a body. | ||
pmichaud | exactly. | 21:09 | |
jnthn | Hmm. I hadn't planned to do that, but maybe it's better sooner than later. | ||
pmichaud | that's all that the current :multi(...) is doing in Rakudo/Parrot | ||
jnthn | Sure, I know that. | ||
pmichaud | that might be a bigger win than trying to convert things to Perl6MultiSub, if we're not seeing a significant speed improvement | ||
jnthn | I'm just pointing out that there's some things like this that crop up when looking at making the switch to the Perl 6 multi-dispatch algorithm. | ||
pmichaud | right. | ||
jnthn | We're just at a point now where we don't need to cheat on these things any more, and I'd rather we stopped doing so and got the semantics correct. | 21:10 | |
pmichaud | and I still like the idea of converting to Perl6MultiSub lazily (if that's at all possible) | ||
I think the better non-cheat is to move them into settings | |||
rather than try to keep them working in PIR | 21:11 | ||
jnthn | Well the whole point of the branch I'm working on is that we don't have to convert at all. | ||
We just create the correct, mapped PMC in the first place. | |||
pmichaud | fair enough. | ||
If it doesn't give us a speed hit, I'm okay with doing it. | |||
jnthn | (Since in theory, not having to convert will be less work at startup.) | 21:12 | |
pmichaud | (big speed hit, small speed hit okay) | ||
I just don't know that it's worth troubleshooting many cases that really ought to move to setting anyway | |||
as you said, let's fix it so that we don't need to cheat at all :-) | |||
jnthn | Speed hit is like a few percent. | ||
Or less. | |||
pmichaud | that's no problem. | 21:13 | |
I'd only be worried about 10%-20% or more. | |||
and I'm more concerned about runtime speed than startup. | |||
jnthn | And I kinda wonder if we're losing rather than winning because hll_map can be slow (as you noted for Int etc) | ||
pmichaud | well, hll_map on subs shouldn't be an issue. | ||
and hll_map to a PMC type shouldn't be an issue. | 21:14 | ||
I think it's primarily when we hll_map to a ['parrot';'Object'] | |||
jnthn | Yes | ||
That's going to be slower. :-( | |||
Not sure how much we can improve on that. | 21:15 | ||
pmichaud | I'm not sure what that's going to mean for things overall, unfortunately. | ||
It might mean we have to come up with our own Perl6Object PMC type | |||
masak | rakudo: Perl6::Grammar.parse("say <OH HAI>", :action(Perl6::Grammar::Actions.new)); say ?$/ | ||
pmichaud | which would mean ditching P6object altogether, or turning it into a PMC type | ||
p6eval | rakudo fb2fd4: OUTPUT«1» | ||
masak | \o/ | ||
pmichaud | masak: for non-declarational things, I think :action(...) might not be needed | 21:16 | |
jnthn | Well, to do a bunch of S09 things I'd figured we'd might need to do somehting like that. | ||
masak | pmichaud: now, is there any way I can look into $/ ? | ||
pmichaud | masak: sure, it's just a match object. | ||
masak | pmichaud: please show me. | ||
pmichaud | rakudo: Perl6::Grammar.parse("say <OH HAI>"); say $/<TOP>; | 21:17 | |
jnthn | .oO( .perl ) |
||
p6eval | rakudo fb2fd4: OUTPUT«Use of uninitialized value» | ||
masak | jnthn: I tried. it doesn't have one. | ||
pmichaud | rakudo: my $match = Perl6::Grammar.parse("say <OH HAI>"); say $match<TOP>; | ||
p6eval | rakudo fb2fd4: OUTPUT«Use of uninitialized value» | ||
jnthn | aww. | ||
masak | neither can it be turned into a Hash. | ||
pmichaud | rakudo: my $match = Perl6::Grammar.parse("say <OH HAI>"); say $match.hash | 21:18 | |
p6eval | rakudo fb2fd4: OUTPUT«No result objectin Main (/tmp/fVyY03YoaO:2)» | ||
pmichaud | rakudo: my $match = Perl6::Grammar.parse("say <OH HAI>"); say $match.PARROT | ||
p6eval | rakudo fb2fd4: OUTPUT«Method 'PARROT' not found for invocant of class 'Perl6;Grammar'» | ||
pmichaud | okay, I have to rework the inheritance a bit more. | ||
masak | just wanted to alert you to the remaining issues. :) | ||
jnthn | rakudo: my $match = Perl6::Grammar.parse("say <OH HAI>"); say $match<statement_block> | ||
p6eval | rakudo fb2fd4: OUTPUT«say <OH HAI>» | ||
jnthn | pmichaud: There you go. :-) | 21:19 | |
pmichaud | rakudo: my $match = Perl6::Grammar.parse("say <OH HAI>"); _dumper($match); | ||
masak | jnthn: hm, introspection by guessing... :P | ||
p6eval | rakudo fb2fd4: OUTPUT«Could not find non-existent sub _dumper» | ||
jnthn | masak: No, by looking at grammar.pg :-P | ||
"Educated guessing" ;-0 | |||
masak | jnthn: not sure that scales well... | ||
pmichaud | rakudo: class Perl6::Grammar is also { method perl() { Grammar::perl(self); } }; my $match = Perl6::Grammar.parse("say <OH HAI>"); say $match.perl; | 21:20 | |
p6eval | rakudo fb2fd4: OUTPUT«Null PMC access in invoke()in method Perl6::Grammar::perl (/tmp/HDQYLrGhRA:2)called from Main (/tmp/HDQYLrGhRA:2)» | ||
pmichaud | rakudo: class Perl6::Grammar is also { method perl() { Match::perl(self); } }; my $match = Perl6::Grammar.parse("say <OH HAI>"); say $match.perl; | ||
p6eval | rakudo fb2fd4: OUTPUT«Method '!_perl' not found for invocant of class 'Perl6;Grammar'» | ||
pmichaud | bah. | 21:21 | |
I'll have to rework the inheritance a bit. | |||
jnthn: I'll need to run for a bit (more) | |||
jnthn | pmichaud: OK. I'm getting tired and making dumb mistakes anyway, so think I'm going to stop coding here anyway. | ||
pmichaud | on Perl6MultiSub, to the extent that it makes existing (source) code simpler, I'm very happy with it. If it makes the source code more complicated, I'd prefer to stick with our existing approach (and work on moving things to settings) unless we get a speed improvement. | 21:22 | |
masak | pmichaud: I think that last one worked, but struck an error inside the Match somewhere, like the RT bug I submitted the other day. | ||
pmichaud | it worked, but PCT::Grammar ends up not having a '!_perl' method. | ||
because it's not really inheriting from Match | |||
which if it did, would solve the .perl problem | 21:23 | ||
thus | |||
jnthn | pmichaud: I think from what I've seen today moving things to setting is going to be a better way to go. | ||
pmichaud | I'll have to rework the inheritance a bit. | ||
jnthn: I'm in agreement with that. | |||
jnthn | pmichaud: But I think I want to get the alternative signatures syntax in place too. | ||
pmichaud | yes, that's also very important to this. | ||
jnthn | Sure. I hadn't realized that until now. | ||
pmichaud | I'll see if I can get the "is equiv()" stuff in place. | ||
with "is equiv()", we can move more operators to setting | 21:24 | ||
jnthn | OK, great. | ||
Combining the load init blocks together would also be a win. | |||
pmichaud | I'll look at that also. | ||
jnthn | I'm also thinking we need to try and speed up signature creation some. | ||
pmichaud | that would be a big win. | ||
jnthn | Right, I'm just not sure how best to do it yet. | 21:25 | |
pmichaud | we may get a bit of a win if/when I can switch ro<->rw | ||
21:25
hanekomu_ is now known as hanekomu
|
|||
pmichaud | the existing sig creation stuff was more "straightforward, works" than "fast" | 21:25 | |
jnthn | Aye. | ||
pmichaud | as I said, I'm much more concerned about runtime performance than startup cost. | ||
(startup cost is easier to explain away to people who say "performance stinks" :-) | 21:26 | ||
jnthn | Sure, but we can't ignore startup cost completely either. | ||
pmichaud | no, but we can point out ways that it's likely to be improved | ||
that's harder to do with runtime performance right now. | 21:27 | ||
jnthn | True. | ||
We'll know better with profiling tools. | |||
Plus when the everlasting calling conventions refactor lands. | |||
pmichaud | oh, if you have any comments to add to the emails I sent to rdice earlier, they might be helpful. :-) | ||
21:27
gegloe joined
|
|||
pmichaud | chromatic expressed an interest in working on that. | 21:28 | |
jnthn | I intend to, will today or probably tomorrow since I will be more coherent then. | ||
pmichaud | as in "soon" | ||
jnthn | The profiler or the claling conventions? | ||
The profiler I know about. | |||
pmichaud | calling conventions | ||
jnthn | Oh, wow. | ||
That would be good. | |||
We might actually get them fast. :-) | |||
Or fastish. | |||
pmichaud | as in "make it work immediately after 1.4 is released" (since it's unlikely to be ready before 1.3 releases, and allison doesn't want significant changes between 1.3 and 1.4) | ||
21:29
skids_ left
|
|||
jnthn | Ideally, I'd like to work in August on trying to get our signature stuff straightened out a bit. | 21:29 | |
So that's just a bit after 1.4... | 21:30 | ||
pmichaud | sounds good, I'm not sure how calling convention will play out. | ||
jnthn | Sure, me either...gets frustrating waiting and wodnering. | ||
pmichaud | I'm more than a little disappointed that it won't be here in 1.4, especially since I flagged it as critically important at PDS | ||
(I flagged it as critically important for 1.0, even, but it got dropped from the list somehow) | |||
jnthn | Right, it's slipped many months now. | 21:31 | |
21:32
eternaleye joined
|
|||
pmichaud | afk for a while | 21:33 | |
jnthn | k | ||
21:33
Whiteknight joined
|
|||
masak | rakudo: module A { role B {}; class C does B {} } | 21:39 | |
p6eval | rakudo fb2fd4: OUTPUT«Null PMC access in find_method()in Main (/tmp/w0Ci3yOnXG:2)» | ||
21:46
[particle]1 left
|
|||
masak | wow! I was naughty and wrote the implementation before the tests... so I git-stashed the implementation, wrote a few tests, made sure they failed, unstashed, and watched them pass! git++ | 21:51 | |
21:52
iblechbot left
|
|||
viklund_ | tdd ftw!!! | 21:52 | |
21:53
eternaleye left
|
|||
masak | tla ftw too :) | 21:53 | |
viklund_ | what's too short for? | 21:54 | |
masak | "I Think You Know". | 21:55 | |
Matt-W: I notice you're not testing for interesting failure modes in t/06-form.t. | 22:09 | ||
Matt-W: I'm momentarily stuck with the numeric field stuff, so I might add a few tests for that. | 22:10 | ||
22:15
nihiliad left
22:16
snarkyboojum joined
|
|||
masak | rakudo: say 'abcdefghi'.comb(/<[aei]>/).perl | 22:18 | |
p6eval | rakudo fb2fd4: OUTPUT«["a", "e", "i"]» | ||
masak | rakudo: my $a="bacadae"; for $a.comb("a") -> $c { say $c } | ||
p6eval | rakudo fb2fd4: OUTPUT«No applicable candidates found to dispatch to for 'comb'in Main (/tmp/NDXRKfHIWJ:2)» | 22:19 | |
masak | rakudo: my $a="bacadae"; for $a.comb(/a/) -> $c { say $c } | ||
p6eval | rakudo fb2fd4: OUTPUT«aaa» | ||
22:20
M_o_C left
|
|||
masak | rakudo: say /foo/ ~~ Regex | 22:23 | |
p6eval | rakudo fb2fd4: OUTPUT«1» | ||
22:23
clintongormley left
|
|||
masak | the signature at src/setting/Any-str.pm:134 still says Code. should it be Regex instead, like in S32? | 22:24 | |
rakudo: say 'abcdef'.comb({1}).perl | |||
p6eval | rakudo fb2fd4: OUTPUT«Method 'to' not found for invocant of class 'Int'» | ||
masak submits rakudobug | 22:25 | ||
(I can change the source too, if someone just nods.) | |||
22:37
frew|work joined,
snarkyboojum left
22:44
snarkyboojum joined
|
|||
jnthn | bratislava.pm.org/down/doc/Perl6-Sp...r27013.pdf # jozef++ from my PM group does pod2docbook stuff and managed to PDF-ize the Perl 6 spec! | 22:48 | |
22:50
eternaleye joined
|
|||
DanielC | jnthn: I managed to make the RPN calculator (several hours ago). It's very nice. In the end I completely rewrote the program. | 22:50 | |
masak | jnthn: nice! | ||
DanielC | jnthn: I have a very nice grammar for it, and it can handle complex expressions like '5 4 + 3 / 5 3 - *' | ||
jnthn | DanielC: Awesome! | ||
22:50
alester left
|
|||
DanielC | jnthn: I'll put it somewhere in perl6-examples. | 22:50 | |
22:53
ashizawa left
|
|||
masak | DanielC++ | 22:53 | |
DanielC | :-) | ||
masak | ok, heading home for the night. | ||
DanielC commits | |||
masak | see y'all tomorrow. | 22:54 | |
22:54
masak left
|
|||
DanielC | night | 22:54 | |
22:55
ashizawa joined,
Whiteknight left
|
|||
jnthn is tired | 22:59 | ||
So, rest time | |||
night all | 23:00 | ||
DanielC | night | ||
23:02
presh is now known as bigpresh
23:03
nsh joined
23:05
justatheory joined
23:06
bigpresh is now known as bigpresh_,
Muixirt left
23:08
frew|work left
23:17
skids_ joined
23:26
bigpresh_ left,
bigpresh joined,
bigpresh left
23:27
hanekomu left,
bigpresh joined,
bigpresh left
23:28
bigpresh joined,
bigpresh left,
bigpresh_ joined,
bigpresh_ left
23:29
bigpresh_ joined,
bigpresh_ left
23:30
bigpresh_ joined
23:32
kate21de1 joined,
Lectus joined
23:34
Limbic_Region joined
23:35
unitxt left
23:41
hercynium joined
|
|||
sjohnson | the camel book shuold have on the front page | 23:44 | |
"Review the core modules at perldoc.perl.org/5.8.8/index-modules-A.html" | |||
i can't believe how many times i've reinvented the wheel | |||
23:48
kate21de left
23:50
rewt joined
23:53
amoc joined
|
|||
Khisanth | sjohnson: no, search CPAN :) | 23:58 | |
23:59
DemoFreak left
|