»ö« Welcome to Perl 6! | perl6.org/ | evalbot usage: 'perl6: say 3;' or rakudo:, niecza:, std:, or /msg p6eval perl6: ... | irclog: irc.perl6.org/ | UTF-8 is our friend! Set by sorear on 4 February 2011. |
|||
00:01
att joined
00:12
att left
00:23
colomon joined
|
|||
jnthn disappears for the night | 00:23 | ||
00:34
havenn left
00:37
havenn joined,
colomon left
00:40
havenn left
|
|||
noteventime | Are there any reasons (apart from performance?) for using methods over multis? | 00:43 | |
00:55
Trashlord left
01:00
Chillance left
01:05
att joined
01:09
Trashlord joined
01:11
whiteknight left
|
|||
TimToady | noteventime: well, in theory the multis can be faster than the methods, since the candidate list can be statically determined, and possibly trimmed down to one if the types are knowable | 01:22 | |
really, you should just ask yourself, "Is this something the object should be in charge of, or is it something in the semantic space between objects?" | 01:23 | ||
if you find yourself contorting symmetric semtantics into asymmetric calls for the sake of OO, it's a code smell | 01:25 | ||
1.add(2) is not very perly | |||
noteventime | Timbus: I'm generally not very fond of object oriented programming, preferring algebraic data types and closures. Multis seem like a reasonable compromise kind of thing. Also I never understood the point with single dispatch OO in a language which doesn't do static type checking (as far as I can see you might just as well store closures in a record type). | 01:31 | |
TimToady: sorry, I misstabed | 01:32 | ||
(I thought erc didn't do that :/) | |||
I really quite like what Perl 6 is doing in the whole OO department though, reminds me of CLOS (though I don't know enough about any of them to know if that's just a superficial similarity due to both supporting multiple dispatch). | 01:35 | ||
sorear | in practice method calls will probably be faster than multis | 01:42 | |
01:43
noam_ joined
01:46
noam left
|
|||
TimToady | noteventime: it's not just a superficial resemblance; both languages are fundamentally FP underneath, and methods are just closures that some dispatcher has found; multis are just closures that a different dispatcher has found | 01:52 | |
01:53
whiteknight joined
|
|||
noteventime | Timbus: Interesting, are there some kind of formal semantics for reasoning about the object system? | 01:56 | |
TimToady* (I'm really sorry, I don't know what's up with ERC, it has never behaved like this before) | 02:00 | ||
02:10
isBEKaml left
|
|||
[Coke] is sad that the haskell daemon hasn't appeared to answer my question! | 02:10 | ||
02:10
mucker left
|
|||
noteventime | Haskell daemon? | 02:14 | |
TimToady | not really, but there is sufficient introspection of the metaobjects that such could probably be defined as a sublanguage | ||
[Coke] | noteventime: our resident Haskell expert who might be able to help me patch Pugs. | ||
TimToady | decommuting & | 02:15 | |
02:15
wolfman2000 joined
02:18
wolfman2000 left
|
|||
noteventime | [Coke]: Unless it's Pugs specific you could always try the excellent #haskell :) | 02:18 | |
02:19
wolfman2000 joined
|
|||
sorear | oh, is #haskell excellent again? | 02:23 | |
I was the most active human in 2007 but it started sucking and I left | 02:24 | ||
noteventime | sorear: Well, I haven't been very active lately, but I remember it as being really great | 02:25 | |
sorear: In what way did it start sucking? I'm pretty sure I haven't been seeing a lot of trolling/flaming or anything like that | |||
[Coke] | oh, maybe sorear can answer my question. ; | 02:27 | |
;) | |||
02:29
noam_ left
02:34
tokuhirom joined
02:35
jaldhar joined
|
|||
sorear | noteventime: a culture appeared where it was unacceptable to ever talk negatively about Haskell | 02:36 | |
it used to be I could talk honestly about Haskell's strengths and weaknesses | |||
noteventime | sorear: You might have a point there actually | 02:38 | |
[Coke] | good thing that happened, or you'd be working on pugs instead of niecza. ;) | ||
noteventime | Not that I'm trying to defend it or anything, but doesn't that tend to happen to almost all larger tech communities | 02:39 | |
sorear | noteventime: the motto of Haskell used to be "Avoid success at all costs" | ||
noteventime | Some kind of over defensiveness against trolls | ||
Hopefully this doens't come out as offensive, but why would one want target CLR any longer? Migrating/interoperating with legacy code? | 02:43 | ||
geekosaur | noteventime, library availability | ||
noteventime | Wouldn't the JVM be a better target for that? | ||
I guess it might just be a matter of taste, but I can't remember seeing a lot of CLR things | 02:44 | ||
It might just be that I don't mingle in the areas that do though | |||
geekosaur | there's enough stuff on CLR, easily | ||
I'm not real familiar with the CLR bytecode but I would not be surprised if it were easier to design for; JVM bytecode is very Java-centric and often painful for languages tht don't work like Java does | 02:45 | ||
02:45
thou left
|
|||
geekosaur | CLR has had *some* thought put into not being really tightly bound to C# | 02:45 | |
noteventime | That might be true too | 02:46 | |
Though hasn't that changed with things like Clojure? | |||
geekosaur has worked a little with jvm bytecode. it really does have a tight relationship with javathink | |||
clojure does a lot of working around it | |||
scala chose to work with it instead by staying fairly close to java | |||
noteventime | I remember issues with it lacking tail recursion optimisation | ||
sorear | noteventime: CLR startup is a lot faster/uses way less memory than JVM (comparing mono to HotSpot) | 02:47 | |
noteventime | Though I never quite figured out why tail recursion couldn't be optimised in the frontend | ||
02:47
NamelessTee left
|
|||
geekosaur | sometimes it can | 02:47 | |
sorear | noteventime: no-one has ever been sued for using the CLR; people have been sued for picking Java | ||
noteventime: Indirect tail calls | |||
return $foo(); | |||
the #1 reason I don't use Java is that HotSpot is unusably slow on my machine | 02:48 | ||
noteventime | Haha, like my mother once told me "Ahh Java, it's that thing where you get a cup of coffee down by the clock and then everything locks up" :) | 02:50 | |
sorear | I've looked into the possibility of porting niecza to the JVM; the biggest yucky spot seems to be that the JVM is hostile to functional programming | 02:52 | |
if you want to be able to refer to 10,000 first class functions in the JVM, you need 10,000 classes, 10,000 .class files on disk... | |||
[Coke] | pugs: say Int | 02:53 | |
p6eval | pugs b927740: OUTPUT«Int» | ||
noteventime | At the risk of sounding really stupid, how much of an issue is that for perl? It is "just" the closures, or are there deeper reasons? | ||
[Coke] | anyone know where that's defined? | ||
sorear | noteventime: every function in a perl program can potentially be the target of &foo | ||
noteventime | sorear: Sure, but you already treat functions as objects, don't you? | 02:54 | |
Or is that just syntactic sugar? | |||
sorear | noteventime: treating functions as objects | ||
noteventime: treating functions as P6-objects requires compiling each one to a JVM-class | 02:55 | ||
any function object can be called! | |||
noteventime: iow, I don't understand your question. | 02:56 | ||
geekosaur | ^^ that is what I meant by javathink embedded in the bytecode | ||
noteventime | sorear: I mean, on the perl side, doesn't Perl 6 do something like Ruby's everything-is-an-object? | ||
geekosaur | it's also why functional languages for the jvm tend to come with hugeous runtime jars | ||
sorear | noteventime: that's not relevant at all | ||
noteventime | Sorry if I'm being thick, 4 in the morning and I just started reading a little about perl 6 today | ||
sorear | noteventime: think about it | 02:57 | |
noteventime: if I have an object that wraps a function, how is the object supposed to hold a reference to the function? | |||
and please don't say "java.lang.reflect.Method" | |||
02:57
sisar left
|
|||
noteventime | I don't know, I'm not familiar with Java runtime or idioms, it just seemed that the JVM should be able to optimise it. Doens't it do something like anonymous classes to get something similar to closures? | 02:58 | |
geekosaur | last I checked all anonymous classes were ugly hacks underneath | 02:59 | |
sorear | noteventime: sort of, but they're not really anonymous | ||
noteventime | Only time I had to do in Java was in a really horrible intro to programming course at university | ||
sorear | noteventime: they get names like Foo$30, and are saved in Foo$30.class | ||
noteventime | Ok, that explains it | ||
sorear | noteventime: s/closures/all first-clas functions/ | ||
noteventime | Right | 03:00 | |
I remember, gave me lots of headache | |||
sorear | on the internet people misuse the word "closure" far more often than they use it correctly | ||
people just shouldn't use it at all :| | |||
noteventime | I thought you could do something like a function pointer at least | ||
sorear | nope! | ||
on the CLR you can. | 03:01 | ||
noteventime | You can't do anything like a function pointer even in java bytecode? | ||
sorear | No. | ||
noteventime | I see, that makes things a lot more clear :) | ||
I thought the issue was just related to closures | 03:02 | ||
Each time I hear something new about java it surprises me with how horrible it is | 03:03 | ||
I kinda dislike beating on the language like that, but I can't say anything positive about it | 03:05 | ||
sorear | java is a definite improvement on the things that came before it, for the purposes for which it was developed | ||
noteventime | sorear: Before it? As in C++ or do you mean COBOL? | 03:06 | |
Because I'd probably rather use C++ than Java to be honest | |||
sorear | I do mostly mean C++ | ||
that's what the second part of my sentence was for | |||
C++ is not very useful for a locked-down browser or smartphone runtime | 03:07 | ||
noteventime | Right, that's true | ||
Sounds like you'd like better operating system security though | |||
sorear | Defense in depth | 03:08 | |
OS-level security is not a panacea | |||
noteventime | Neither is Java though ;) | ||
sorear | it's slow, unportable, and often doesn't work at all | ||
you combine it with runtime security to achieve somehting even better | 03:09 | ||
noteventime | Possibly, I guess I couln't really say, I have absolutely no experience with such environments | 03:10 | |
sorear: Wouldn't something like FreeBSDs jails work though? | 03:11 | ||
Or would that be too slow? | |||
sorear | noteventime: nothing that allows user code to run on the bare CPU is ever going to be trustworthy | ||
noteventime | (I have no idea about its details, just that it's something like a chroot which includes file handles, processes e.t.c.) | 03:12 | |
sorear | every few years some CPU bug is discovered that allows unprivileged code to break the sandbox | ||
or at least crash the processor | |||
noteventime | So the reasoning is that a CPU isn't patchable? | 03:13 | |
03:14
orafu left
|
|||
noteventime | Otherwise I don't see why a VM should be less prone to such issues | 03:14 | |
03:14
orafu joined
|
|||
sorear | noteventime: the adversary will act before you have a chance to patch your system. | 03:15 | |
noteventime | sorear: Why couldn't that be true for a virtual machine too though? | 03:16 | |
03:16
colomon joined
|
|||
noteventime | It still has to issue syscalls of some kind somewhere | 03:16 | |
sorear | Non sequitur | 03:17 | |
o/ colomon | 03:18 | ||
noteventime | sorear: What I mean is, there could just as well be a bug in the virtual machine that allowed some kind of arbitrary code execution | ||
colomon | o/ ... but he's off at a concert and his wife stole his computer! :) | ||
sorear | noteventime: en.wikipedia.org/wiki/Defense_in_depth | 03:19 | |
noteventime | Maybe I'm just missing the particular kind of issues you could run into. If everything runs in a VM it seems to me an issue in the VM would be as critical as an issue on the CPU would be when everything ran on bare CPU. Unless you use multiple VMs to separate the processes, in which case it seems to be the same thing as having something like jails. | 03:21 | |
sorear: I'll think about it in the morning, perhaps I'm just too tired :) thanks for the info | |||
03:23
Guest54925 joined
|
|||
Guest54925 | Hello | 03:23 | |
sorear | you use a secured VM in a separate processor inside a chroot on a decent OS with a good processor | ||
Guest54925 | Can someone assist me with a PERL loop? | ||
sorear | five dubious fences add up to a decent barrier | ||
Guest54925: it's not PERL, it's Perl | 03:24 | ||
and you want #perl-help | |||
Guest54925 | Thanks | ||
sorear | this is the channel for the Perl 6 redesign | ||
Guest54925 | How can I find #perl-help? | 03:25 | |
timotimo | why not? doesn't Perl have a Print Eval Read Loop? | ||
sorear | Guest54925: google it. when you find the right server, read the documentation for your IRC client to find out how to join. | ||
noteventime | timotimo: Not REPL loop :) (I read REPL at first too) | 03:26 | |
sorear | it's probably either on MAGnet or Freenode | ||
noteventime | opps | ||
Sorry, I missed the joke, I must real be too tired | |||
sorear | I don't know which, and I have a knee-jerk reaction to minimally help anyone who says PERL | ||
it's like a reverse code word | 03:27 | ||
noteventime | sorear: Like lisp people dislike people who say LISP :) | ||
sorear | LISP actually means something | ||
noteventime | or at least meant something | ||
03:27
Guest54925 left
|
|||
sorear | if you say LISP, it means you're using one of the broken dialects from the 50s that don't handle funargs correctly, like MACLISP or elisp | 03:27 | |
noteventime | Though I doubt that's (with the possible exception of elisp) what the people saying LISP intend | 03:29 | |
sorear: Maybe saying PERL means you really want PEARL? | |||
shachaf | sorear: I've generally understood that "LISP" referred to any dialect, and "Lisp" refers to Common Lisp. | 03:30 | |
timotimo | i thought lisp was "list processor", so shouldn't it be LisP? | 03:32 | |
noteventime | I wonder if there ever was a word processor called WORP | ||
timotimo | hah, that gives way to lots of star trek references and puns | 03:33 | |
"warp 6!" - "whoa, microsoft hasn't even released worp 4 yet!" | |||
03:37
aindilis joined
03:38
whiteknight left
03:39
NamelessTee joined
03:45
Tedd1^ joined
03:47
Tedd1 left
03:48
aindilis left,
aindilis joined
04:11
marmalade left
04:18
BinGOs joined
04:27
tokuhirom left
04:34
fsergot left
04:47
araujo left
04:49
autark left
05:07
noteventime left
|
|||
japhb | When fixing things in the spec, is the date/version stamp in the header supposed to be updated on all changes, or just the non-typo ones? | 05:32 | |
05:32
NamelessTee left
|
|||
dalek | ecs: 186ae88 | (Geoffrey Broadwell)++ | S32-setting-library/Exception.pod: Fix typo |
05:34 | |
ecs: bb4c5e5 | (Geoffrey Broadwell)++ | S02-bits.pod: Fix double thinko; remove trailing whitespace in same lines |
|||
ecs: f8d2de3 | (Geoffrey Broadwell)++ | S32-setting-library/Basics.pod: Remove extra whitespace introduced by automated change |
|||
05:36
birdwindupbird joined
|
|||
dalek | ecs: 86b688a | (Geoffrey Broadwell)++ | S32-setting-library/Containers.pod: Clarify wording in splice() description |
05:37 | |
05:47
kaare_ joined
|
|||
TimToady | new entry: rosettacode.org/wiki/Factors_of_a_M...ber#Perl_6 | 05:48 | |
japhb: there's no fixed boundary, whatever you think is substantial | 05:49 | ||
05:53
packetknife joined
|
|||
TimToady | incidentally, that RC entry breaks rakudo with: splice() not implemented in class 'Mu' | 05:53 | |
sorear | afk power outage, be back tomorrow... | 05:58 | |
06:05
packetknife left
|
|||
Timbus | rakudo: my @a := 1,2, * + @a[0] ... *; say @a[4]; | 06:07 | |
p6eval | rakudo 715aed: OUTPUT«use of uninitialized value of type Nil in numeric contextuse of uninitialized value of type Nil in numeric contextuse of uninitialized value of type Nil in numeric contextsplice() not implemented in class 'Mu' in method reify at src/gen/CORE.setting:4515 in … | ||
Timbus | niecza: my @a := 1,2, * + @a[0] ... *; say @a[4]; | 06:10 | |
p6eval | niecza v15-2-gd19c478: OUTPUT«5» | ||
Timbus | well then. take that, haskell. | ||
06:20
kaare_ left
|
|||
moritz | \o | 06:32 | |
06:34
kaare_ joined
06:35
kaare_ left
07:07
packetknife joined,
thou joined
07:16
havenn joined
07:18
packetknife left
07:19
colomon left
07:21
noam joined
07:22
GlitchMr joined
07:36
colomon joined
|
|||
geekosaur | hmf. mono from macports still can't use mono-sgen with niecza | 07:38 | |
07:42
colomon left
|
|||
japhb | TimToady, Roger that, thanks. | 07:55 | |
08:02
araujo joined,
araujo left,
araujo joined
08:16
colomon joined
08:18
am0c left
08:24
am0c joined
08:36
sisar joined
08:43
Patterner left
08:48
Psyche^ joined,
Psyche^ is now known as Patterner,
snearch joined
08:51
zipf joined
08:53
zipf left,
zipf joined,
zipf left,
havenn left
09:10
birdwindupbird left
09:14
Patterner left
09:17
birdwindupbird joined
09:27
Psyche^ joined,
Psyche^ is now known as Patterner
09:49
MayDaniel joined
09:59
tarch_ joined
10:14
snearch left
10:18
tarch_ left
10:30
sisar left
|
|||
dalek | kudo/nom: 06cf161 | moritz++ | src/core/Complex.pm: Implement constant i for complex numbers constant i = 1i; had bootstrappy problems last I tried, but now we can simply write Complex.new(0, 1) on the RHS. jnthn++ |
10:34 | |
10:40
am0c left
|
|||
tadzik | gist.github.com/1965528 enum exportation bug | 10:44 | |
10:47
JimmyZ_ joined
|
|||
JimmyZ_ | nom: say pi; pi.WHAT | 10:47 | |
p6eval | nom 715aed: OUTPUT«3.14159265» | ||
JimmyZ_ | nom: say pi; say pi.WHAT | 10:48 | |
p6eval | nom 715aed: OUTPUT«3.14159265Num()» | ||
JimmyZ_ | nom: constant pi = 3.1415926535897832; say pi; say pi.WHAT; | ||
p6eval | nom 715aed: OUTPUT«3.14159265358978Rat()» | ||
JimmyZ_ | nom: constant pi = 3.14159265; say pi; say pi.WHAT; | ||
p6eval | nom 715aed: OUTPUT«3.14159265Rat()» | ||
JimmyZ_ | niecza: say pi; say pi.WHAT | 10:52 | |
p6eval | niecza v15-2-gd19c478: OUTPUT«3.1415926535897931Num()» | ||
JimmyZ_ | niecza: constant pi = 3.1415926535897831; say pi; say pi.WHAT; | ||
p6eval | niecza v15-2-gd19c478: OUTPUT«3.1415926535897833Rat()» | ||
jnthn | afty o/ | 10:59 | |
tadzik: Looks like it's export the enum itself, but not the individual symbols. | |||
tadzik: RT it (got a few things to do before I get Perl 6 tuits today), but I should be able to fix it fairly easily. | 11:00 | ||
JimmyZ_ | afternoon | 11:01 | |
tadzik | cool | 11:02 | |
now that I think about Perl 6 module infrastructure compared to CPAN, it's a bit like The Pirate Bay with magnet links compared to TPB serving .torrent files | 11:05 | ||
CPAN has lots of .tar.* archives, we have lots of URLs to META.info files, which contain everything you need to know to obtain and install a module | 11:06 | ||
I like how accidental evolution leads to such things | |||
jnthn | :) | 11:08 | |
jnthn has to write his talk today also :) | 11:09 | ||
Or at least start on it. | |||
tadzik | yeah | ||
I just started thinking "what the hell am I going to talk about for 20 minutes" ;) | |||
jnthn | Just take like 20 rage faces and talk about an aspect of the module ecosystem that reflects each one. :) | 11:10 | |
jnthn sketched his out last night and thinks he'll fill his 40 minutes quite easily | |||
arnsholt | I have a trollface on slide two of my lecture for monday =) | 11:18 | |
11:19
noam left
11:20
noam joined
|
|||
tadzik | :) | 11:21 | |
11:46
am0c joined
11:51
NamelessTee joined
11:52
noteventime joined
12:02
aindilis left
12:03
aindilis joined
12:06
wayland76 joined
12:07
whiteknight joined
12:21
mj41 joined
12:29
robins is now known as robinsmidsrod
12:52
zipf joined
12:53
colomon left
13:04
zipf left
13:23
vlkv joined
13:24
vlkv is now known as gv
13:28
leprevost joined
|
|||
moritz | perl6: constant x = 4; say x x x | 13:31 | |
p6eval | pugs b927740: OUTPUT«***  Unexpected "=" expecting ":" or "(" at /tmp/MaoEZDJM7g line 1, column 12» | ||
..rakudo 06cf16, niecza v15-2-gd19c478: OUTPUT«4444» | |||
13:31
fglock joined
|
|||
JimmyZ_ | perl6: constant x = 4; say x*x | 13:32 | |
p6eval | pugs b927740: OUTPUT«***  Unexpected "=" expecting ":" or "(" at /tmp/hxFj01BllG line 1, column 12» | ||
..rakudo 06cf16, niecza v15-2-gd19c478: OUTPUT«16» | |||
JimmyZ_ | perl6: constant x = 4; say xxx | ||
p6eval | rakudo 06cf16: OUTPUT«===SORRY!===CHECK FAILED:Undefined routine '&xxx' called (line 1)» | ||
..niecza v15-2-gd19c478: OUTPUT«===SORRY!===Undeclared routine: 'xxx' used at line 1Unhandled exception: Check failed at /home/p6eval/niecza/boot/lib/CORE.setting line 1362 (die @ 3)  at /home/p6eval/niecza/src/STD.pm6 line 1147 (P6.comp_unit @ 33)  at /home/… | |||
..pugs b927740: OUTPUT«***  Unexpected "=" expecting ":" or "(" at /tmp/lSV50o2OA5 line 1, column 12» | |||
dalek | ast: 9f76350 | moritz++ | S16-io/say-and-ref.t: RT #80186, IO.say |
13:33 | |
JimmyZ_ | nom: constant * = 4; say*x* | 13:34 | |
p6eval | nom 06cf16: OUTPUT«===SORRY!===Method 'sorry' not found for invocant of class 'Perl6::Grammar'» | ||
JimmyZ_ | new bug! | 13:35 | |
13:35
snearch joined
|
|||
jnthn | That looks...familiar. | 13:35 | |
moritz: ^^ | 13:36 | ||
moritz: Is this an error reporting bug like the one fixed recently? | |||
13:36
wayland76 left
|
|||
moritz | jnthn: might be. I'll investigate | 13:37 | |
though I really think it's just a mistyped s/panic/soory/ | 13:38 | ||
jnthn: yep. And you did it :-) | 13:40 | ||
- || <.panic: "Missing initializer on constant declaration"> | |||
+ || <.sorry: "Missing initializer on constant declaration"> | |||
you probably took that from STD or so | |||
anyway, I'll fix | |||
masak | good afternoon, #perl6 | 13:42 | |
jnthn | moritz: d'oh | 13:43 | |
sorry! | |||
o/ masak | |||
moritz | :-) | ||
std: constant * = 3 | |||
p6eval | std 137d5f5: OUTPUT«===SORRY!===Missing initializer on constant declaration at /tmp/TrCHxNq6Ic line 1:------> constant ⏏* = 3Preceding context expects a term, but found infix = instead at /tmp/TrCHxNq6Ic line 1:------> constant * ⏏… | ||
moritz | it seems to parse it as constant () * = 3 | 13:44 | |
13:44
sisar joined
|
|||
moritz | why the heck to we parse anonymous constant declarations? What's the point? | 13:44 | |
after the constant, rakudo expects [ <identifier> | <variable> | <?> ] | 13:45 | ||
jnthn | std: my $x = constant = 42 | ||
p6eval | std 137d5f5: OUTPUT«ok 00:01 110m» | ||
13:45
donri_ joined
|
|||
jnthn | nom: my $x = constant = 42; say $x | 13:45 | |
p6eval | nom 06cf16: OUTPUT«42» | ||
jnthn | I guess it's a way to force pre-computation of some value | ||
moritz | but that doesn't make $x a constant, right? | ||
jnthn | No but if it was an expression on the RHS of the = it'd force its evaluation at BEGIN time | ||
moritz | wouldn't BEGIN do the same? | ||
jnthn | But my $x = BEGIN 1 + 2; is perhaps clearer | 13:46 | |
Yeah | |||
13:46
donri_ left
|
|||
moritz | I'd rather have 'constant' without a variable or identifier give a better error message | 13:46 | |
but I guess it's TimToady++'s call here | |||
jnthn | *nod* | 13:48 | |
moritz | I have to admit it's cute, but it's also obscure | 13:50 | |
13:50
havenn joined
|
|||
dalek | kudo/nom: 4bacfdc | moritz++ | src/Perl6/Grammar.pm: throw more X::Syntax::Missing errors. Also fixes error reporting from constant declarators |
13:51 | |
jnthn | \o/ | ||
13:51
buubot_backup left
|
|||
sisar | those who are gonna give a talk on Monday, will it be recorded and put up online ? | 13:52 | |
moritz | if you mean at GPW, I don't think so | 13:53 | |
jnthn | Mine is on Tue :) | ||
I'll upload the slides | |||
moritz | same for those :-) | ||
sisar | i can live with slides... | ||
moritz is working on his slides right now | 13:54 | ||
but they are in German, mostly | |||
sisar | jnthn: what's your talk about ? | ||
moritz: dang | |||
dalek | ast: 157d7b7 | moritz++ | S32-exceptions/misc.t: more tests for "constant" parse errors |
||
moritz | sisar: but you can read the example code anyway, the identifers are all English :-) | 13:56 | |
jnthn | sisar: Meta-programming | ||
Introspection, runtime type creation, custom meta-classes, etc. | |||
moritz has about 25 slides, and a writer's block. Need 40. | 13:57 | ||
sisar | moritz: what are you talking about ? | ||
moritz | sisar: Perl 6 features and which compilers implements them today | 13:59 | |
so the least advanced of all these talks | 14:00 | ||
14:00
noteventime left
|
|||
moritz | nom: constant x = 'foo'; sub f(Int) { }; f x | 14:00 | |
p6eval | nom 06cf16: OUTPUT«Nominal type check failed for parameter ''; expected Int but got Str instead in sub f at /tmp/PvjNAmMsAK:1 in block <anon> at /tmp/PvjNAmMsAK:1» | ||
moritz | jnthn: it's a bit sad that this isn't caught at CHECK time | 14:01 | |
jnthn | Hm | ||
Wonder why it ain't... | |||
moritz | sisar: fwiw conferences.yapceurope.org/gpw2012/...2012-03-06 has the list of Perl 6 talks | 14:05 | |
jnthn | Wow, one room on Tuesday is pretty much Perl 6 room :d | 14:07 | |
sisar | moritz: now i can stop bothering you. thanks. | ||
moritz | jnthn: yes :-) | ||
jnthn: I would have prefered to do the talks before the hackathon, but that wasn't quite possible | 14:08 | ||
(for two reasons: 1) so that people can first learn what it's all about, then join us hacking and 2) that masak++ doesn't waste the high-bandwith time with making slides :-) | |||
... or other people besides masak. Did I mention that I'm not done either? :-) | 14:09 | ||
jnthn | Me either but I have at least started :) | ||
Got sketched out all the stuff I want to do, so now it's just writing slides and code. | 14:10 | ||
14:11
buubot_backup joined
|
|||
masak | moritz: you know me too well. | 14:14 | |
fwiw, I'm preparing the talk now. | |||
moritz | well, don't we all pattern-match? | 14:15 | |
:-) | |||
14:16
buubot_backup left
|
|||
dalek | kudo/nom: 8b5ee17 | jnthn++ | src/Perl6/Actions.pm: Annotate lookups of stuff with term:name that are known at compile time with the statically known type. Gets us some better static analysis, including with constants, as pointed out by moritz++. |
14:19 | |
moritz | niecza: say pi.WHAT | 14:20 | |
jnthn | > constant x = 'foo'; sub f(Int) { }; f x | ||
CHECK FAILED: | |||
p6eval | niecza v15-2-gd19c478: OUTPUT«Num()» | ||
jnthn | Calling 'f' will never work with argument types (Str) (line 1) Expected: :(Int ) | ||
moritz | \o/ | 14:21 | |
14:23
icwiener joined
|
|||
jnthn wonders if moritz is adding a slide on compile time analysis :) | 14:27 | ||
moritz | jnthn: I have one that shows a dispatch failure detected at CHECK time | ||
and also a bit role composition stuff shown at compile time | 14:28 | ||
jnthn | Nice | 14:29 | |
moritz | github.com/moritz/perltalk/blob/ma....talk#L134 | ||
jnthn | Entwickler: for Rakudo - probably tadzik++ should be on it too :) | 14:31 | |
moritz | oh right :-) | 14:32 | |
14:33
att left
14:38
buubot_backup joined,
sisar left,
Chillance joined
14:45
buubot_backup left
|
|||
tadzik | hm? | 14:49 | |
14:50
att joined
|
|||
moritz | tadzik: jnthn++ just said I should mention you as a rakudo dev. He's right, of course :-) | 14:50 | |
tadzik | oh :) | ||
masak | tadzik++ | 14:51 | |
tadzik | oh, while we're at it, yes, I'm preparing my talk too ;) | 14:53 | |
moritz didn't want to start a witch hunt with his comment :-) | 14:54 | ||
anybody got a cute example of list comprehension? | 14:55 | ||
masak | ooh, Form.pm could be a nice GSoC project. | 14:56 | |
14:56
noam_ joined
|
|||
jnthn woulda expected one on Rosettacode, but the features page doesn't link to such an example | 14:57 | ||
And the spec example is boring and better done with sequences. | 14:58 | ||
14:58
noam left
|
|||
masak | moritz: my @perfect_squares = ($_ if $_ == [+] divisors $_ for 1 .. 100); | 14:59 | |
er, @perfect_numbers, sorry. | 15:02 | ||
@primes is perhaps a more well-known example. my @primes = ($_ if 1 == divisors $_ for 1 .. 100); | 15:03 | ||
basically, the use cases that make sense for list comprehensions rather than pure sequences are the ones where a predicate is involved. | 15:05 | ||
15:14
havenn left
15:28
havenn joined
15:32
DarthGandalf left
15:35
DarthGandalf joined
|
|||
mikemol | jnthn: Believe me, I wish there were a good task on RC for list comprehensions; it's embarassing to admit I don't know what people are talking about there; I never touched Lisp. | 15:46 | |
15:48
Patterner left
15:49
Psyche^ joined,
Psyche^ is now known as Patterner
15:54
PacoAir joined
|
|||
moritz | mikemol: "list comprehension" just means that a loop returns a list, and you use that return value | 15:58 | |
16:01
MayDaniel left
16:04
PacoAir left
|
|||
masak | Wikipedia has some good examples and explanations: en.wikipedia.org/wiki/List_comprehension | 16:05 | |
16:05
icwiener left
|
|||
masak | list comprehensions have their roots in set builder notation. | 16:05 | |
16:05
icwiener joined
|
|||
TimToady | the usual syntax has a couple of problems from a p6 perspective | 16:05 | |
it uses symbols before their declaration | |||
and it puts the conditional on the wrong side of the loop from a nesting perspective | 16:06 | ||
though one could fake that with a proper list infix that did a grep | 16:07 | ||
but the big one is declaring loop vars after use | |||
16:14
buubot_backup joined
|
|||
dalek | p: 764faf9 | jnthn++ | src/HLL/World.pm: Now, if we ask for a reference to an object in SC, we can just add it, since we can serialize whatever. |
16:16 | |
kudo/nom: efad32e | jnthn++ | src/Perl6/Metamodel/BOOTSTRAP.pm: Make it a bit easier to create Attribute meta-object instances. |
|||
TimToady never considered that constant could be anonymous; probably a copy-pasto from enum rule | 16:23 | ||
masak | +1 on disallowing anon constant | 16:24 | |
TimToady | already working on it | 16:25 | |
masak | the idiom looks too much like = () = to me | ||
TimToady++ | |||
jnthn | Heh, I just assumed it was for consistency and implemented it :) | 16:26 | |
masak | jnthn++ | ||
it would be very consistent, of course. | 16:27 | ||
but probably the kind that is a hobgoblin. | |||
jnthn | Mmmmm....Hobgoblin! :D | 16:28 | |
masak | "The beer of the little mind" :P | 16:29 | |
dalek | d: 292f669 | larry++ | STD.pm6: disallow anonymous constant declarations |
16:30 | |
masak | nom: $*IN; say "alive" | 16:34 | |
p6eval | nom efad32: OUTPUT«alive» | ||
masak | nom: $*ARGS; say "alive" | 16:35 | |
p6eval | nom efad32: OUTPUT«alive» | ||
TimToady | std: $*MASAK; say "ok 00:01 110m" | 16:36 | |
masak | is there a &slurp that should default to reading from the Perl 6 equivalent of <ARGV> ? | ||
p6eval | std 137d5f5: OUTPUT«ok 00:01 109m» | ||
flussence | are $?constants still a thing? | 16:37 | |
masak | I want it to read from $*IN, or from a file if one was provided. | ||
flussence: sure. | |||
flussence was getting slightly confused by all this new sigil-less stuff | 16:38 | ||
TimToady | perl6: say $*ARGFILES.slurp | ||
p6eval | pugs b927740: OUTPUT«*** Unsafe function 'slurp' called under safe mode at /tmp/3DgYqFqstR line 1, column 5 - line 2, column 1» | ||
..rakudo efad32: OUTPUT«Method 'slurp' not found for invocant of class 'ArgFiles' in block <anon> at /tmp/wmiNFxrY0O:1» | |||
..niecza v15-2-gd19c478: OUTPUT«Unhandled exception: Unable to resolve method slurp in class ArgFiles at /tmp/9D_a0CwwSj line 1 (mainline @ 2)  at /home/p6eval/niecza/lib/CORE.setting line 3838 (ANON @ 3)  at /home/p6eval/niecza/lib/CORE.setting line 3839 (module-CORE @ 65)  at /h… | |||
TimToady | perl6: say $*ARGFILES.lines | 16:39 | |
p6eval | rakudo efad32: OUTPUT«Land der Berge, Land am Strome, Land der Äcker, Land der Dome, Land der Hämmer, zukunftsreich! Heimat bist du großer Söhne, Volk, begnadet für das Schöne, vielgerühmtes Österreich, vielgerühmtes Österreich! Heiß umfehdet, wild umstritten liegst dem Erdteil du inmi… | ||
..niecza v15-2-gd19c478: OUTPUT«Land der Berge, Land am Strome, Land der Äcker, Land der Dome, Land der Hämmer, zukunftsreich! Heimat bist du großer Söhne, Volk, begnadet für das Schöne, vielgerühmtes Österreich, vielgerühmtes Österreich! Heiß umfehdet, wild umstritten liegst dem Erdteil… | |||
..pugs b927740: OUTPUT«*** No such method in class Scalar: "&lines" at /tmp/fOvP8tG7S4 line 1, column 5 - line 2, column 1» | |||
TimToady | looks like ArgFiles needs to be taugh about delegating to IO or some such | ||
*taught | |||
btw, the equivalent in P5 only slurps one file at a time, iirc | 16:40 | ||
masak | moritz: new backtraces are excellent. | ||
moritz++ | |||
16:40
jferrero left
|
|||
masak | moritz: do you think we should also hide MAIN_HELPER? I do. | 16:40 | |
jnthn | Sounds reasonable | 16:41 | |
masak: Should just be annotating it with "is hidden-from-backtrace" or some such | 16:42 | ||
16:43
tokuhirom joined
16:45
aindilis left,
aindilis joined
16:46
sisar joined
16:50
am0c left,
xenu joined
16:51
marmalade joined
16:54
kaare_ joined
|
|||
tadzik | masak: do you recall if anyone ever tried to implement what's in S22? | 16:54 | |
16:55
tokuhirom left
|
|||
masak | tadzik: I think not. | 16:55 | |
I remember when that one was written, but it probably remained a gleam in the authors' eyes. | |||
16:55
jferrero joined
|
|||
masak | I'd say it has "borrow what could work, ignore the rest" status. | 16:55 | |
tadzik | I have a feeling that no one ever paid attention to it when implementing ecosystem as we have now | 16:56 | |
as in: evolution, not intelligent design | |||
masak | nothing wrong with design of the kind you refer to. | 17:00 | |
tadzik | of course | ||
masak | but it has to have its roots in need, not want. | ||
if the distinction makes sense :) | |||
there's something of a scratch-your-own-itch and eat-your-own-dogfood there that can't be ignored. | 17:01 | ||
cognominal | reading the commit log, /me sees "attribute meta object instance". /me is not sure to understand what it is | 17:02 | |
I suppose that attributes are seen as object and they have their palace in the metaoo system | 17:03 | ||
indeed I see an Attribute.HOW | 17:04 | ||
masak | cognominal: attributes have properties that you might want to modify in your OO system. therefore, they have their own HOW. | ||
cognominal: in Moose, they're even more important since Moose rests so heavily on attributes and so lightly on methods. | |||
jnthn | cognominal: It's just an attribute that represents at attribute | 17:06 | |
cognominal | I can guess that is stuff like ownProperty in js, which defines if an attribute belongs to the current object or is inherited. | ||
jnthn | cognominal: Most declarative things in Perl 6 lead to compile-time creation of some kind of object that describes what it is and how it works. | ||
masak | TimToady: what's your take on the capture-inside-of-regex-interpolation thing I found the other day? <{ '(.) $0' }> | 17:07 | |
cognominal | I got the general idea, I don't have grasped all the details. | ||
17:07
aindilis left
|
|||
TimToady | masak: that runs as a subrule, so $0 is local to the <{ }> | 17:07 | |
jnthn | cognominal: Well, maybe I should give my meta-programming talk I'm working on at the moment in France some time this year then :) | ||
17:07
aindilis joined,
icwiener left
|
|||
cognominal | you bet. | 17:08 | |
Anyway if you don't come. I will study it thoroughly to present it but that would be so much better if you do that in person. | 17:09 | ||
TimToady | perl6: say 'fooo' ~~ /<{ '(.) $0' }> $0/ | ||
p6eval | niecza v15-2-gd19c478: OUTPUT«Use of uninitialized value in string context at /home/p6eval/niecza/lib/CORE.setting line 1222 (warn @ 3)  at /home/p6eval/niecza/lib/CORE.setting line 230 (Mu.Str @ 10)  at <unknown> line 0 (ExitRunloop @ 0)  at /tmp/DYY8o1sGD9 line 1 (ANON @ 9)  … | ||
..rakudo efad32: OUTPUT«#<failed match>» | |||
..pugs b927740: OUTPUT«Error eval perl5: "if (!$INC{'Pugs/Runtime/Match/HsBridge.pm'}) { unshift @INC, '/home/p6eval/.cabal/share/Pugs-6.2.13.20111008/blib6/pugs/perl5/lib'; eval q[require 'Pugs/Runtime/Match/HsBridge.pm'] or die $@;}'Pugs::Runtime::Match::HsBridge'"*** '<HAND… | |||
jnthn | cognominal: Are the dates announced yet? | 17:10 | |
masak | TimToady: oh, ok. | ||
nom: grammar G { regex TOP { <.panic "OH NOES"> }; method panic($m) {} }; G.parse("") | |||
p6eval | nom efad32: OUTPUT«Unmarshallable foreign language value passed for parameter '$m' in method panic at /tmp/aiw2289Jtt:1 in regex TOP at /tmp/aiw2289Jtt:1 in method parse at src/gen/CORE.setting:8175 in block <anon> at /tmp/aiw2289Jtt:1» | ||
masak | jnthn: ^^^ | ||
TimToady | perl6: say 'fooo' ~~ /$<x> = <{ '(.) $0' }> $<x>[0]/; # maybe this works | ||
p6eval | niecza v15-2-gd19c478: OUTPUT«Potential difficulties: Apparent subscript will be treated as regex at /tmp/avehYCl3bE line 1:------> ay 'fooo' ~~ /$<x> = <{ '(.) $0' }> $<x>⏏[0]/; # maybe this worksMatch()» | ||
..rakudo efad32: OUTPUT«#<failed match>» | |||
..pugs b927740: OUTPUT«Error eval perl5: "if (!$INC{'Pugs/Runtime/Match/HsBridge.pm'}) { unshift @INC, '/home/p6eval/.cabal/share/Pugs-6.2.13.20111008/blib6/pugs/perl5/lib'; eval q[require 'Pugs/Runtime/Match/HsBridge.pm'] or die $@;}'Pugs::Runtime::Match::HsBridge'"*** '<HAND… | |||
cognominal | journeesperl.fr/fpw2012/ | 17:11 | |
jnthn: journeesperl.fr/fpw2012/newtalk | |||
:) | |||
TimToady | perl6: say 'fooo' ~~ /$<x> = <{ '(.) $0' }> $(<x>[0])/; # maybe this works | ||
p6eval | niecza v15-2-gd19c478: OUTPUT«Match()» | ||
..rakudo efad32: OUTPUT«Method 'x' not found for invocant of class 'Cursor' in <anon> at /tmp/RLSn5XbrOk:1 in regex <anon> at /tmp/RLSn5XbrOk:1 in method ACCEPTS at src/gen/CORE.setting:8188 in block <anon> at /tmp/RLSn5XbrOk:1» | |||
..pugs b927740: OUTPUT«Error eval perl5: "if (!$INC{'Pugs/Runtime/Match/HsBridge.pm'}) { unshift @INC, '/home/p6eval/.cabal/share/Pugs-6.2.13.20111008/blib6/pugs/perl5/lib'; eval q[require 'Pugs/Runtime/Match/HsBridge.pm'] or die $@;}'Pugs::Runtime::Match::HsBridge'"*** '<HAND… | |||
17:12
jferrero left
|
|||
masak | jnthn: yes, please do. I haven't even seen your talk, and I'm already looking forward to seeing it a second time :P | 17:12 | |
jnthn | I love how cognominal links me to the submit talk page rather than the homepage of the FPW site :P | ||
tadzik | :) | ||
TimToady | perl6: say 'foooo' ~~ /$<x> = <{ '(.) $0' }> $<x>/; | ||
p6eval | niecza v15-2-gd19c478: OUTPUT«#<match from(1) to(5) text(oooo) pos([].list) named({"x" => #<match from(1) to(3) text(oo) pos([#<match from(1) to(2) text(o) pos([].list) named({}.hash)>].list) named({}.hash)>}.hash)>» | 17:13 | |
..rakudo efad32: OUTPUT«=> <oooo> x => <oo> 0 => <o>» | |||
..pugs b927740: OUTPUT«Error eval perl5: "if (!$INC{'Pugs/Runtime/Match/HsBridge.pm'}) { unshift @INC, '/home/p6eval/.cabal/share/Pugs-6.2.13.20111008/blib6/pugs/perl5/lib'; eval q[require 'Pugs/Runtime/Match/HsBridge.pm'] or die $@;}'Pugs::Runtime::Match::HsBridge'"*** '<HAND… | |||
masak | jnthn: why is the thing Unmarshallable above? | ||
jnthn: (it's some ways up, between TimToady's p6eval spammings) :) | |||
17:14
jferrero joined
|
|||
jnthn | masak: yeah, I missed it :P | 17:14 | |
17:14
birdwindupbird left
|
|||
jnthn | masak: I'm...not sure. Is that not missing a colon? | 17:14 | |
moritz missed it too | |||
jnthn | nom: grammar G { regex TOP { <.panic: "OH NOES"> }; method panic($m) {} }; G.parse("") | 17:15 | |
p6eval | nom efad32: OUTPUT«Cannot look up attributes in a type object in regex TOP at /tmp/y3W_qodcCF:1 in method parse at src/gen/CORE.setting:8175 in block <anon> at /tmp/y3W_qodcCF:1» | ||
jnthn | nom: grammar G { regex TOP { <.panic: "OH NOES"> }; method panic($m) { die "painfully" } }; G.parse("") | ||
p6eval | nom efad32: OUTPUT«painfully in method panic at /tmp/WB4nBiLzf1:1 in regex TOP at /tmp/WB4nBiLzf1:1 in method parse at src/gen/CORE.setting:8175 in block <anon> at /tmp/WB4nBiLzf1:1» | ||
masak | jnthn++ | 17:16 | |
jnthn | masak: It's because you used the syntax that makes <begin blah blah> work | ||
masak | oh. | ||
jnthn | masak: That compiles blah blah as a regex | ||
masak: And then you were passing a Parrot Sub off to panic. | |||
masak | oops. | ||
Unmarshellable. | 17:17 | ||
jnthn | :P | ||
moritz | Un-marshmellow-ish | ||
jnthn | Derivational morphology. I uses it. | ||
cognominal | jnthn, When I talk to people, I have a lot of trouble to explain the ultimated goal of the rakudo project which is to eventually compile any dynamic languages and make them interact. People have no idea of what is involved. They are already unaware of the system that makes possible to (dynamically) link .o files. They don't realize that the same thing for dynamic languages are more complicated by two orders of magnitude or so | 17:18 | |
. And when they suddenly realize the scope, they think that we (well I certainly mean the non lurker unlike me) will not be able to pull it. | |||
moritz | huh | ||
cognominal | *ultimate | ||
jnthn | Huh. | ||
moritz | rakudo's goal is to compiler Perl 6 | ||
jnthn | The goal of Rakudo is to be an awesome Perl 6 compiler. | ||
You're thinking of Parrot. | |||
moritz | and maybe some parts of p5, to the way that the specs require it | ||
TimToady | jnthn: You just need more hemidemisemiaffixishnesslessnessless. | ||
er, *ness | 17:19 | ||
cognominal | if it was only so you would not bother with all this meta stuff. | ||
masak | not so. | ||
all this meta stuff is cool even without the language interop. | |||
moritz | and not only cool, but necessary | ||
jnthn | Right. | ||
cognominal | and once this stuff is done, the goal, assumed or not, will eventually follow thru. | ||
jnthn | It's the way we implement large chunks of Perl 6 in a decent way, a way to make the language extensible, etc. | 17:20 | |
Yes, it's true, representation poly and so forth make interop easier to implement. | |||
TimToady | but putting that goal first leads to...parroty things... | ||
jnthn | But it's not the only goal. | ||
And was far from the primary one. | 17:21 | ||
For 6model at least. | |||
dalek | kudo/nom: b8a20ce | moritz++ | src/core/Main.pm: hide MAIN_HELPER from bactraces. masak++ |
||
kudo/nom: 141cd63 | moritz++ | src/core/Num.pm: steal more precises definitions of pi and e from niecza++ |
|||
moritz | efad32ee431c12145ba2aa99c4de2a4673135a73 looks like talk-driven design. jnthn++ :-) | 17:22 | |
jnthn | ooh, strasbourg. I've never been there :) | ||
TimToady | parrot's model of interop development was a bit on the order of Ready! Fire! Aim! | ||
you can't really do interop without a good metamodel | 17:23 | ||
masak | nom: grammar G { regex TOP { (foo) <.panic: "!$0!"> }; method panic($m) { die $m } }; G.parse("foo") | ||
p6eval | nom efad32: OUTPUT«!! in method panic at /tmp/SAKd6FG6zc:1 in regex TOP at /tmp/SAKd6FG6zc:1 in method parse at src/gen/CORE.setting:8175 in block <anon> at /tmp/SAKd6FG6zc:1» | ||
masak | why doesn't this output '!foo!'? | 17:24 | |
jnthn | hm | ||
moritz | because of impedance mismatch | ||
jnthn | .oO( mis-Match ) |
||
masak | moritz: those are words. what do you mean by them? | ||
also, is there a workaround? :) | 17:25 | ||
moritz | yes, a block | ||
jnthn | nom: grammar G { regex TOP { (foo) { $/.CURSOR.panic: "!$0!" } }; method panic($m) { die $m } }; G.parse("foo") | ||
p6eval | nom efad32: OUTPUT«Method 'match' not found for invocant of class 'Any'» | ||
cognominal | to paraphrase a known ahphorism, I see the future this way "Every compiling system attempts to expand until it support genericity, hygienic macros and a metaobject system. Those which cannot so expand are replaced by ones which can." | ||
masak | oh, so it's kinda similar to the problem in .subst ? | ||
moritz | the problem is basically that the regex engine doesn't publish match variables unless it is deemed necessary | ||
and when parsing argument strings, that doesn't happen (but it should) | 17:26 | ||
jnthn | moritz: Yeah, it's that. | ||
moritz: Just hit on the same conclusion. | |||
masak | sounds RT-able to me. | ||
cognominal | I forget to mention a type inferencing system, but perl 6 and rakudo are not there yet. | ||
masak submits rakudobug | 17:27 | ||
jnthn | cognominal: Rakudo does various bits of type-driven analysis and (very) limited inference. | ||
nom: constant x = 'lol'; multi foo(Int) { }; foo(x) | |||
p6eval | nom efad32: OUTPUT«===SORRY!===CHECK FAILED:Calling 'foo' will never work with argument types (Str) (line 1) Expected any of: :(Int )» | ||
17:27
isBEKaml joined
|
|||
cognominal | I agree but I am talking of a more systematic stuff like does haskell. | 17:27 | |
moritz | that's just propagation, not really inference, is it? | ||
jnthn | moritz: Well, we didn't decalre that x was of type Str anywhere | 17:28 | |
moritz: So in a sense it "figured it out" | |||
moritz | point taken | ||
jnthn | moritz: Though in this case the figuring was very easy (just do .WHAT) | ||
moritz | WAT? | ||
jnthn | :P | ||
TimToady | nom: constant x = 101; multi foo(Int) { }; foo(~x) | 17:29 | |
p6eval | nom efad32: OUTPUT«No applicable candidates found to dispatch to for 'foo'. Available candidates are::(Int ) in block <anon> at /tmp/pY4ppADszW:1» | ||
TimToady | dint figger that one out | ||
moritz | right, because it didn't constant-fold prefix:<~> | ||
jnthn | Well, it may have been able to figger it without constant folding too | ||
TimToady | it shouldn't have to constant fold to know that ~ is returning a string | 17:30 | |
cognominal | anyway, my point is that it would be good the share the feeling of necessity of stuff is done in rakudo. People who wrongly see perl6 as perl5 improved clearly don't get it. | ||
jnthn | TimToady: Yeah, if we declare it on the proto it can do that. | ||
cognominal | s :1st /the/to/ | ||
moritz | TimToady: well, that'd need a return type annotation on the proto or so | ||
which we don't have yet, I guess | |||
jnthn | Yeah, at the moment that won't be considered or enforced. | 17:31 | |
All doable. :) | |||
moritz | just needs sufficiently advanced tuits :-) | ||
TimToady | cognominal: however, there's a tendency in type-inferencey languages to assume the user is as smart as the inferencer, which can lead to vast confusion among mere mortals | 17:32 | |
so we need to tread carefully there | |||
jnthn | The hard part isn't always figuring out that a piece of code could never work, but explaining why. | ||
17:32
buubot_backup left
|
|||
TimToady | you need to be able to present the chain of reasoning in a clear fashion | 17:32 | |
cognominal | yes indeed, the way these systems "think" is so different we do. | 17:33 | |
jnthn | moritz: Well, Germany has lots of beer ;) | ||
TimToady | just saying "That won't work for some reason" is about like saying "Syntax error" without a line number | ||
cognominal | :) | ||
so true. | 17:34 | ||
well, they give a reason but it is not human readable. | |||
TimToady | "No applicable candidates found" is already a bit gobbledygooky in my opinion | 17:35 | |
cognominal | We tend to work with context, and inferecing types tends to use too much context for us to process. | 17:36 | |
17:36
isBEKaml left
17:38
isBEKaml joined
|
|||
TimToady | Cannot figure out which foo to call; available signatures are: | 17:39 | |
something more like that | |||
17:40
Trashlord left
17:41
Trashlord joined,
havenn left
|
|||
TimToady | and it should say the type signature of what you did pass, and maybe the values if there are constraints | 17:41 | |
17:41
jferrero left,
isBEKaml left
17:42
buubot_backup joined
17:45
jferrero joined
17:46
buubot_backup left
|
|||
TimToady | niecza: constant x = 101; multi foo(Int) { }; foo(~x) | 17:46 | |
p6eval | niecza v15-2-gd19c478: OUTPUT«Unhandled exception: No candidates for dispatch to &foo; candidates are: Int at /tmp/qxnuzgp8NE line 1 (mainline @ 2)  at /home/p6eval/niecza/lib/CORE.setting line 3838 (ANON @ 3)  at /home/p6eval/niecza/lib/CORE.setting line 3839 (module-CORE @ 6… | ||
TimToady | niecza's message is even less sensical; there are no candidates, and here they are | 17:47 | |
Error messages should avoid overly precise words like "dispatch", "candidates", "applicable" | 17:48 | ||
the user is just trying to call foo | |||
Cannot call foo; none of these signatures match: | 17:50 | ||
jnthn | TimToady: The message you suggested would seem to cover ambiguous or no possible candidates. | ||
OK, that's better | |||
What about the ambiguous case? | |||
TimToady | then it should say ambiguous | ||
Cannot call foo; too many signatures match: | 17:51 | ||
:) | |||
jnthn | "Ambiguous call to '%Ss'; these signatures all matched:\n%Ss" ? | 17:52 | |
17:52
jferrero left
|
|||
TimToady | that's not half bad | 17:52 | |
would still like to see the actual arg types(+gisted values?) at some point | 17:54 | ||
jnthn | Yeah, I already got them into the compile-time errors. Will try and get 'em into the runtime ones soon also. | 17:55 | |
17:55
jferrero joined
|
|||
TimToady is hard to please, except when he's not... | 17:55 | ||
dalek | kudo/nom: a89da25 | jnthn++ | src/binder/multidispatch.c: Improve multi-dispatch error text; TimToady++. |
17:56 | |
jnthn | It needs to become a typed exception anyways at some point soon. | 17:58 | |
TimToady | also, from a writerly perspective, the original message had a passive verb; those can usually be strengthened into some active verb | ||
jnthn | Happily, the message improved. | 17:59 | |
TimToady | \o/ | ||
thanks | |||
jnthn | When we do the typed exception, I can just pass the capture of args that failed and the signatures available/ambiguous in the object | 18:00 | |
cognominal | jnthn++ # integrating bs makes nom so much faster. | 18:01 | |
jnthn | Then it'll be dead easy to render the error however we want it. | ||
moritz | and let me figure out the hard stuff :-) | ||
jnthn | \o/ | ||
moritz: I think joining strings together and calling .gist on stuff is easier in Perl 6 than it is in C ;) | |||
moritz: We'll be sure to figure out how to do typed exceptions from C land while at GPW. | 18:02 | ||
18:03
jferrero left
|
|||
moritz | and from meta model land | 18:06 | |
I have some vague, sketchy ideas that might work out | 18:07 | ||
but jnthn++ as probably much less vague and more realistic ideas :-) | 18:08 | ||
18:08
buubot_backup joined
18:10
noam_ left
18:11
noam_ joined
|
|||
cognominal | I agree that what piss me the most currently is C error messages that don't give the parrot/perl 6 line that triggered them. | 18:12 | |
18:14
noam_ left,
noam_ joined
|
|||
jnthn | moritz: Do you mention grammars at all in your talk? | 18:14 | |
18:15
Trashlord left
|
|||
cognominal | I wish you fun at gpw. | 18:16 | |
18:19
lutok joined
18:25
noam joined
18:27
noam_ left
18:28
jferrero joined
18:29
noam left
|
|||
TimToady | jnthn: a nit, but I'd s/matched/match/ in your ambiguous message; introducing unnecessary temporal information tends to cloud abstract statements | 18:31 | |
this is why literary critics always write about authors in the present tense | |||
"In this passage Morris artfully weaves archaicisms with more modern notions" | 18:32 | ||
18:33
JimmyZ_ left
|
|||
dalek | kudo/nom: 4bdb94a | jnthn++ | src/binder/multidispatch.c: Present for TimToady++. |
18:35 | |
18:36
jferrero left
|
|||
masak | jnthn++ # commit message | 18:40 | |
TimToady | nit one, perl two... | 18:41 | |
moritz | jnthn: I plan to | 18:44 | |
18:45
ascrazy joined
18:46
shinobicl_ joined
18:47
MayDaniel joined,
MayDaniel left,
MayDaniel joined
18:51
jferrero joined,
noteventime joined
18:52
localhost left
18:54
localhost joined
|
|||
jnthn | dinner & | 18:57 | |
18:57
shinobicl_ left
|
|||
TimToady | I also think we should simplify these: s/Nominal type check/Type check/ and s/Constraint type check/Constraint/ | 18:59 | |
so it's just: | |||
Constraint failed... | |||
Type check failed... | |||
moritz | -1 | ||
"Constraint failed" could be a PRE too | 19:00 | ||
or some other invariant | |||
TimToady | then it should say PRE | ||
the rest of the message indicates it's in a parameter binding | |||
cognominal | jnthn, if you go back to Paris, you come to get to use the word used by Jean Dujardin at the academy award : putain! Explained here: www.youtube.com/watch?v=GSeaDQ6sPs0 | ||
TimToady | we talk about nominal type checks, but I think the word does not carry sufficient weight to inflict it on the user | 19:01 | |
and PRE should probably be talking about invariants, not constraints, as you yourself just pointed out | 19:02 | ||
constraints in Perl 6 are pretty consistently subset types (either named or anonymous), so "type" is redundant | 19:03 | ||
so I stand by my proposal | |||
19:04
icwiener joined,
kmwallio joined
19:10
jferrero left
19:11
birdwindupbird joined
19:12
att left
19:13
ascrazy left
19:15
jferrero joined
19:18
ascrazy joined,
havenn joined
19:19
noam joined
19:22
havenn left
19:24
att joined
|
|||
noteventime | I'm slightly confused, does Parrot use LLVM nowadays? | 19:25 | |
moritz | no | ||
there are plans to use LLVM for the parrot's JIT compiler that is in planning | |||
noteventime | Ok, it's just some experimental extra you can enable | ||
moritz | but you can compile parrot with LLVM-GCC and with clan | ||
*clang | 19:26 | ||
noteventime | Or did I misread something as a release log, that wasn't? | ||
moritz | maybe | ||
noteventime | "New --with-llvm option to Configure.pl, which will link to LLVM if it is available" <- Maybe that just means I can compile it with clang? | 19:27 | |
Or wait, does it mean it uses the LLVM linker? | 19:28 | ||
moritz | I'm reading parrot.org/news/2012/Parrot-4.1.0 and see no mention of LLVM at all | ||
noteventime | www.parrot.org/news/2011/Parrot-3.3.0 <- Thats the one I saw | ||
moritz | oh. That's a bit older :-) | ||
noteventime | It wasn't really imporant though, I was just curious | ||
moritz: I read something about Parrot and LLVM and that's the release blurb I got when I googled it | 19:30 | ||
moritz reads config/auto/llvm.pm and can't make much sense of it either | |||
jnthn: ok, I now have some few slides on grammars | 19:39 | ||
19:40
pjcj joined,
havenn joined,
syslq__ joined,
syslq__ left
|
|||
noteventime | Why use grammars rather than some kind of parser combinator library? Is it "just" a matter of performance or is there something deeper? | 19:44 | |
moritz | why use some kind of parser combinator library instead of grammars? | 19:45 | |
the advantage of grammars is that they harmonize quite well with the OO system | |||
they just use it | |||
so you can take advantage of all the neat stuff (role composition for example) | |||
in grammars too | 19:46 | ||
noteventime | Couldn't that be achieved by having classes containing parser combinators though? I'm not saying it'd a better approach, coming from Haskell I was just curious if there are any strong reasons against doing parser combinators. | 19:47 | |
(I mean, having methods returning parser generators, making it possible for roles to fill them in) | 19:48 | ||
moritz | could probably be | ||
but currently it sounds more complicated, without any obvious benefits | |||
19:51
leprevost left
|
|||
noteventime | Well, you wouldn't have to have them be a language feature, which might be considered a benefit. | 19:51 | |
TimToady | as soon as you use the word "combinator" you've scared away 2/3 of your potential users :) | 19:52 | |
mathw | I'm not sure you could get the syntax as good if they were combinators | ||
noteventime | That's a good point | ||
mathw | Parsec's good, but it's still not as elegant as Perl 6 grammars IMO | ||
moritz | well, Perl 6 is malleable enough that you can surely implement that as a library | ||
noteventime | TimToady: The people using "combinator" might consider that an additional benefit ;) | ||
mathw | moritz: yes but the grammars being built into the language is one of the ways in which that mallability is accomplished | 19:53 | |
TimToady | Perl 6 is not aiming primarily to please the intelligensia | ||
noteventime | I'm not saying grammars aren't a nice idea, I like them, especially in this age of DSLs :) | ||
geekosaur | noteventime, you'r actually missing a point. it's not about "build parser into the language", it's about "make regular expressions composable" | 19:54 | |
moritz | and reusable | ||
geekosaur | think of it as part of regex syntax, intended to make them easier to think about and reuse | ||
moritz | but we don want a parser built into the language, and we have that :-) | ||
19:55
mj41 left
|
|||
moritz | s/don/do/ | 19:55 | |
19:55
skipper joined,
kmwallio left
|
|||
noteventime | geekosaur: And having composable regular expressions seems to do largely the same thing as having a parser combinator library | 19:55 | |
mathw | it helps that it's the same parser that's used by the compiler | ||
TimToady | noteventime: yes, that "benefit" of the typical FP language is something we're trying very hard to avoid | ||
noteventime | TimToady: Typical FP language meaning Haskell and OCaml? | 19:56 | |
geekosaur | noteventime, but regexes are perl. so we should prefer something that isn't? | ||
TimToady | it's the job of Perl to educate people wherever they are, not to chase them away if they don't meet some high standard | ||
noteventime | geekosaur: As I said, I'm not saying it would have been a better choice, I just wondered if there were any obvious reasons for using it that I had missed | 19:57 | |
TimToady: I wasn't being very serious :) | |||
geekosaur | (so why continue once that was answered?) | ||
masak | how can I fail a rule in present-day Rakudo? | ||
19:57
havenn left
|
|||
TimToady | <!> | 19:57 | |
well, that's supposed to work | 19:58 | ||
masak | TimToady: doesn't that just fail the current alternation? | ||
I want to fail the rule. | |||
TimToady | uh, ::: <!> then | ||
jnthn | Another one is that we parse Perl 6 with Perl 6 grammars, so your language tweaks can be meta-circular. | ||
noteventime | geekosaur: Because I didn't quite understand the reasons that were given | ||
masak | TimToady: ::: not yet implemented | ||
TimToady: "...in present-day Rakudo" | |||
TimToady | noteventime: well, we're not trying to chase you away either :) | ||
20:00
mj41 joined
|
|||
moritz | masak: there's probably some nasty hack with { return self.'!cursor_fail'() } or something | 20:00 | |
masak | yeech. | ||
moritz | step back. What are you trying to do? | ||
TimToady | put a ||<!> on the outer construct, maybe | ||
jnthn | Wait, ::: doesn't immediately failing the rule though, iirc? | ||
noteventime | geekosaur: Sorry if I sounded negative, I really do like the language | ||
jnthn | ::: fails it if it gets backtracked over | ||
TimToady | that's why I put a <!> after it | 20:01 | |
jnthn | TimToady: oh! | ||
I misread. | |||
masak | TimToady: that might work, thanks. | ||
jnthn | Sorry. | ||
masak: Did b do :::? | |||
moritz | alpha: /a ::: a/ | ||
p6eval | alpha : ( no output ) | ||
masak | jnthn: alpha definitely did. | ||
moritz | b: /a ::: a/ | 20:02 | |
p6eval | b 1b7dd1: OUTPUT«===SORRY!===::: not yet implemented at line 22, near " a/"» | ||
masak | because PGE did. | ||
jnthn | No, then. | ||
20:02
ruoso left
|
|||
moritz | but notice that the semantics have changed since the alpha days | 20:02 | |
jnthn | Yeah...PGE ain't easy to look at for inspiration though. Whereas nqp-rx is. | ||
TimToady | niecza: 'ab' ~~ /a ::: b/ | ||
jnthn | But I can probably figure out how to do ::: without too much trouble anyway. | ||
p6eval | niecza v15-2-gd19c478: ( no output ) | ||
TimToady | niecza: say 'ab' ~~ /a ::: b/ | ||
p6eval | niecza v15-2-gd19c478: OUTPUT«#<match from(0) to(2) text(ab) pos([].list) named({}.hash)>» | ||
masak | moritz: I'm parsing things with the structure ABBBBBABBBB, and I started to emit error messages when I come upon an unknown kind of B. but I don't want it to flag up an A. | 20:03 | |
TimToady | niecza: say 'acb' ~~ /a [ c ::: <!> ] b/ | ||
p6eval | niecza v15-2-gd19c478: OUTPUT«Match()» | ||
masak | moritz: so in a sense, I'm stuck in an inner loop, wrongly flagging up things that are OK in the outer loop. | ||
TimToady | niecza: say 'ab' ~~ /a [ c ::: <!> ] b/ | ||
p6eval | niecza v15-2-gd19c478: OUTPUT«Match()» | ||
TimToady | niecza: say 'ab' ~~ /a [ c ::: <!> ]? b/ | ||
p6eval | niecza v15-2-gd19c478: OUTPUT«#<match from(0) to(2) text(ab) pos([].list) named({}.hash)>» | ||
TimToady | niecza: say 'acb' ~~ /a [ c ::: <!> ]? b/ | 20:04 | |
p6eval | niecza v15-2-gd19c478: OUTPUT«Match()» | ||
TimToady | looks like niecza does it right | ||
20:04
ruoso joined
|
|||
masak | niecza++ | 20:04 | |
jnthn | masak: Can probably implement it for you later today. | ||
:: is the harder one. | |||
TimToady | yes, well, that's an instruction to the LTMer | 20:05 | |
20:05
ribayr left
|
|||
masak | jnthn: \o/ | 20:05 | |
20:05
PacoAir joined
|
|||
TimToady | so backtrack over :: can actually go out many levels, unlike :: | 20:05 | |
er, ::: | |||
:: goes out to whatever level the LTM is alternating at | 20:06 | ||
we could do all of this with arguments to <commit> | |||
<commit 'LTM'>, <commit &ROUTINE>, etc | 20:07 | ||
masak | heh. moritz++' suggestion { return self.'!cursor_fail'() } seems to abort the whole *program*, not just the grammar parse. | 20:08 | |
TimToady | then you could commit to any rule in your outer dynamic scope | ||
20:08
skipper left
|
|||
TimToady | and <commit> as currently defined defaults to <commit 'TOP'> or some such, more or less, give or take a few aspirin | 20:09 | |
masak | g'ah, this is really frustrating! everytime I think I've worked around the thing, it turns out I've only aborted the current... group or alternation, not the whole rule. | 20:10 | |
maybe I'm really wanting something like ~ | 20:11 | ||
nope, that didn't work either. | 20:12 | ||
TimToady wonders if there's a way to install a CATCH block in a rule | 20:13 | ||
moritz | TimToady: recently I was wondering how one would export a CATCH block | ||
TimToady: for a custom exception / backtrace printer | |||
masak | nom: grammar G { regex TOP { <outer>* }; regex outer { A <inner>* }; regex inner { B | (.) { say "Unknown B: $0" } } }; say G.parse("ABBBBABBB") | ||
p6eval | nom 4bdb94: OUTPUT«Unknown B: A=> <ABBBBABBB> outer => <ABBBBABBB> inner => <B> inner => <B> inner => <B> inner => <B> inner => <A> 0 => <A> inner => <B> inner => <B> inner => <B>» | 20:14 | |
TimToady | we might have to relax the highlander rule for that | ||
or wrap CATCHes somehow | |||
masak | how do I get Rakudo to stop considering "A" an unknown "B" above? | ||
TimToady: what's the highlander rule? | |||
TimToady | There kin only be one! | 20:15 | |
20:15
havenn joined
|
|||
masak | ah, 'course. | 20:15 | |
masak clarly has watched too little of that genre | |||
20:15
PacoAir left
20:16
wolfman2000 left
|
|||
TimToady only knows about it from RFC 9 | 20:16 | ||
"Highlander Variable Types" | 20:17 | ||
moritz | fwiw the feature matrix still says - for run, qx in niecza | ||
masak | TimToady: that's what I was thinking of too. | 20:18 | |
ah well, I turned off my nice "Unknown B" warnings. seems I can't have them just now. | |||
TimToady | I really don't understand how you think a cut could help that | 20:21 | |
TimToady should eat breakfast now that it's after noon, maybe | 20:22 | ||
masak | a cut? I wanted to abort the rule at that point. if <inner> reports failure, the * quantifier is satisfied and <outer> succeeds. | 20:23 | |
the equivalent of the rule saying "this is not for me to handle". | |||
20:25
icwiener left
20:26
havenn left
|
|||
tadzik leaves for GPW | 20:27 | ||
20:29
ascrazy left
|
|||
masak | tadzik: see you on the other side! | 20:29 | |
20:30
havenn joined
|
|||
moritz wishes tadzik a good travel | 20:35 | ||
jnthn | tadzik: Safe travels :) | 20:36 | |
TimToady | nom: grammar G { regex TOP { <outer>* }; regex outer { A <inner>* }; regex inner { B | (.) { say "Unknown B: $0" <!> } } }; say G.parse("ABBBBABBB") | 20:45 | |
p6eval | nom 4bdb94: OUTPUT«===SORRY!===Preceding context expects a term, but found infix !> instead at line 1, near " } } }; sa"» | 20:46 | |
TimToady | nom: grammar G { regex TOP { <outer>* }; regex outer { A <inner>* }; regex inner { B | (.) { say "Unknown B: $0" } <!> } }; say G.parse("ABBBBABBB") | ||
p6eval | nom 4bdb94: OUTPUT«Unknown B: A=> <ABBBBABBB> outer => <ABBBB> inner => <B> inner => <B> inner => <B> inner => <B> outer => <ABBB> inner => <B> inner => <B> inner => <B>» | ||
TimToady | why not just that? | ||
20:47
ascrazy joined
|
|||
masak | TimToady: because it still prints "Unknown B: A" | 20:51 | |
20:51
birdwindupbird left
|
|||
masak | TimToady: the trick wasn't about aborting the rule after printing that, the trick was about aborting the rule before that. | 20:51 | |
if it encounters a C, it's fine for it to squawk. but not if it encounters an A. | 20:52 | ||
moritz | then just write B | <!before A> (.) { ... } <!> | 20:53 | |
or quantify <inner> with *? maybe? | |||
20:55
Trashlord joined
20:56
isBEKaml joined
|
|||
masak | hm. :) | 20:57 | |
20:58
snearch left
|
|||
moritz | masak: searching for an advanced, NYI language feature instead of using existing ones is a disease that the early adaptors should be immune against *SCNR* | 20:59 | |
masak | moritz: oh, come *on*. :P | 21:01 | |
that is so not fair -- I didn't pout once, and was honestly looking for a workaround. | |||
moritz | ok, you are right | 21:02 | |
sorry | |||
masak | I believe moritz++ was referring to strangelyconsistent.org/blog/attitude | ||
which is still relevant and something I try to keep in mind. | |||
fwf, I'm having fun building Yet Another Presentation Framework this evening. | 21:04 | ||
this is it, folks. the Ultimate Framework. | |||
moritz | does it mean it's a superset of my own framework? :-) | 21:05 | |
21:05
GlitchMr left
|
|||
masak | maybe in some very loose sense. | 21:07 | |
21:15
kmwallio joined
21:17
isBEKaml left
|
|||
moritz will have to do some JS hacking tomorrow, and doesn't look forward to it :/ | 21:19 | ||
TimToady | I still fail to see how you expect a cut-like operation to read your mind about whether there's an A there or not if you never test for A | 21:32 | |
masak | IWBNI heredocs were listed at perl6.org/compilers/features | 21:34 | |
TimToady: I'm willing to test for A. but I can't seem to do it outside of an alternation or a non-capturing group, and <!> will only abort that alternation or non-capturing group. | |||
21:36
noam left,
fglock left
|
|||
TimToady | niecza: grammar G { regex TOP { <outer>* }; regex outer { A <inner>* }; regex inner { B | <?before A > ::: <!> | (.) { say "Unknown B: $0" } <!> } }; say G.parse("ABBBBABBB") | 21:38 | |
p6eval | niecza v15-2-gd19c478: OUTPUT«#<match from(0) to(9) text(ABBBBABBB) pos([].list) named({"outer" => (#<match from(0) to(5) text(ABBBB) pos([].list) named({"inner" => (#<match from(1) to(2) text(B) pos([].list) named({}.hash)>, #<match from(2) to(3) text(B) pos([].list) named({}.hash)>, #… | ||
21:38
QnD joined
|
|||
TimToady | well, that's the way I said first thing, it's just rakudo don't do it yet | 21:39 | |
QnD | anyone in here know anything about active perl dev | ||
TimToady | as in from ActiveState? | ||
QnD | yeh | ||
TimToady | as far as I know there's no ActiveState development of Perl 6...</rimshot> | ||
a #perl-help or #perl channel might be more useful there | 21:40 | ||
QnD | i need to know how to load activeperl for other OS's so i can crosscompile | ||
21:40
noam joined
|
|||
QnD | k | 21:40 | |
TimToady | there have historically been activestate mailing lists, maybe you can hunt those up | ||
masak | TimToady: yes, that was the first thing I said, but my question was about how to do it in present-day Rakudo... :) | 21:41 | |
TimToady | here, have a lollipop | ||
QnD | activestate used to be cool with giving out info.... now they are too big for their boots | ||
TimToady | so the way to do it in present-day Rakudo is to patch it :P | 21:42 | |
QnD | thx... cheers | 21:43 | |
masak | apparently. :) | ||
21:43
QnD left
|
|||
TimToady | hmm, I have an idea | 21:45 | |
21:45
noam_ joined
21:46
plobsing joined
|
|||
TimToady | perl6: grammar G { regex TOP { <outer>* }; regex outer { A <inner>* }; regex inner { B | [(.) { say "Unknown B: $0" }]?? } }; say G.parse("ABBBBABBB") | 21:47 | |
p6eval | rakudo 4bdb94, niecza v15-2-gd19c478: OUTPUT«(timeout)» | ||
..pugs b927740: OUTPUT«*** No such method in class G: "&parse" at /tmp/VlYubNqekx line 1, column 124 - line 2, column 1» | |||
TimToady | perl6: grammar G { regex TOP { <outer>* }; regex outer { A <inner>* }; regex inner { B | [(.) { say "Unknown B: $0" }]?? <!> } }; say G.parse("ABBBBABBB") | 21:48 | |
p6eval | niecza v15-2-gd19c478: OUTPUT«Unknown B: A#<match from(0) to(9) text(ABBBBABBB) pos([].list) named({"outer" => (#<match from(0) to(5) text(ABBBB) pos([].list) named({"inner" => (#<match from(1) to(2) text(B) pos([].list) named({}.hash)>, #<match from(2) to(3) text(B) pos([].list) named… | ||
..rakudo 4bdb94: OUTPUT«Unknown B: A=> <ABBBBABBB> outer => <ABBBB> inner => <B> inner => <B> inner => <B> inner => <B> outer => <ABBB> inner => <B> inner => <B> inner => <B>» | |||
..pugs b927740: OUTPUT«*** No such method in class G: "&parse" at /tmp/5eLZZnvd6g line 1, column 128 - line 2, column 1» | |||
21:48
havenn left,
noam left
21:49
kaare_ left
|
|||
TimToady | perl6: grammar G { token TOP { <outer>* }; token outer { A <inner>* }; regex inner { B | [(.) { say "Unknown B: $0" }]?? <!> } }; say G.parse("ABBBBABBB") | 21:50 | |
p6eval | niecza v15-2-gd19c478: OUTPUT«Unknown B: A#<match from(0) to(9) text(ABBBBABBB) pos([].list) named({"outer" => (#<match from(0) to(5) text(ABBBB) pos([].list) named({"inner" => (#<match from(1) to(2) text(B) pos([].list) named({}.hash)>, #<match from(2) to(3) text(B) pos([].list) named… | ||
..pugs b927740: OUTPUT«*** No such method in class G: "&parse" at /tmp/Gdl79TKEwQ line 1, column 128 - line 2, column 1» | |||
..rakudo 4bdb94: OUTPUT«Unknown B: A=> <ABBBBABBB> outer => <ABBBB> inner => <B> inner => <B> inner => <B> inner => <B> outer => <ABBB> inner => <B> inner => <B> inner => <B>» | |||
21:50
noam_ left
|
|||
TimToady | that ought to fail with 0 reps the first time, and backtrack to 1 rep (and a warning) only if the whole pattern fails, I'd think | 21:51 | |
perl6: grammar G { token TOP { <outer>* }; token outer { A <inner>* }; regex inner { B || [(.) { say "Unknown B: $0" }]?? <!> } }; say G.parse("ABBBBABBB") | 21:52 | ||
p6eval | niecza v15-2-gd19c478: OUTPUT«Unknown B: A#<match from(0) to(9) text(ABBBBABBB) pos([].list) named({"outer" => (#<match from(0) to(5) text(ABBBB) pos([].list) named({"inner" => (#<match from(1) to(2) text(B) pos([].list) named({}.hash)>, #<match from(2) to(3) text(B) pos([].list) named… | ||
..pugs b927740: OUTPUT«*** No such method in class G: "&parse" at /tmp/xmzeg5iDxt line 1, column 129 - line 2, column 1» | |||
..rakudo 4bdb94: OUTPUT«Unknown B: A=> <ABBBBABBB> outer => <ABBBB> inner => <B> inner => <B> inner => <B> inner => <B> outer => <ABBB> inner => <B> inner => <B> inner => <B>» | |||
TimToady | perl6: grammar G { token TOP { <outer>* $ }; token outer { A <inner>* }; regex inner { B || [(.) { say "Unknown B: $0" }]?? <!> } }; say G.parse("ABBBBABBB") | 21:53 | |
p6eval | niecza v15-2-gd19c478: OUTPUT«Unknown B: A#<match from(0) to(9) text(ABBBBABBB) pos([].list) named({"outer" => (#<match from(0) to(5) text(ABBBB) pos([].list) named({"inner" => (#<match from(1) to(2) text(B) pos([].list) named({}.hash)>, #<match from(2) to(3) text(B) pos([].list) named… | 21:54 | |
..rakudo 4bdb94: OUTPUT«Unknown B: A=> <ABBBBABBB> outer => <ABBBB> inner => <B> inner => <B> inner => <B> inner => <B> outer => <ABBB> inner => <B> inner => <B> inner => <B>» | |||
..pugs b927740: OUTPUT«*** No such method in class G: "&parse" at /tmp/9gw6cevc66 line 1, column 131 - line 2, column 1» | |||
TimToady | not clear why the ?? isn't working | ||
perl6: grammar G { token TOP { <outer>* $ }; token outer { A <inner>* }; regex inner { B || <!> || (.) { say "Unknown B: $0" } <!> } }; say G.parse("ABBBBABBB") | 21:56 | ||
p6eval | niecza v15-2-gd19c478: OUTPUT«Unknown B: A#<match from(0) to(9) text(ABBBBABBB) pos([].list) named({"outer" => (#<match from(0) to(5) text(ABBBB) pos([].list) named({"inner" => (#<match from(1) to(2) text(B) pos([].list) named({}.hash)>, #<match from(2) to(3) text(B) pos([].list) named… | ||
..pugs b927740: OUTPUT«*** No such method in class G: "&parse" at /tmp/IiWG4hQHx0 line 1, column 134 - line 2, column 1» | |||
..rakudo 4bdb94: OUTPUT«Unknown B: A=> <ABBBBABBB> outer => <ABBBB> inner => <B> inner => <B> inner => <B> inner => <B> outer => <ABBB> inner => <B> inner => <B> inner => <B>» | |||
TimToady | perl6: grammar G { token TOP { <outer>* $ }; regex outer { A <inner>* }; regex inner { B || <!> || (.) { say "Unknown B: $0" } <!> } }; say G.parse("ABBBBABBB") | 21:58 | |
p6eval | niecza v15-2-gd19c478: OUTPUT«Unknown B: A#<match from(0) to(9) text(ABBBBABBB) pos([].list) named({"outer" => (#<match from(0) to(5) text(ABBBB) pos([].list) named({"inner" => (#<match from(1) to(2) text(B) pos([].list) named({}.hash)>, #<match from(2) to(3) text(B) pos([].list) named… | ||
..rakudo 4bdb94: OUTPUT«Unknown B: A=> <ABBBBABBB> outer => <ABBBB> inner => <B> inner => <B> inner => <B> inner => <B> outer => <ABBB> inner => <B> inner => <B> inner => <B>» | |||
..pugs b927740: OUTPUT«*** No such method in class G: "&parse" at /tmp/bxRvS7HBpj line 1, column 134 - line 2, column 1» | |||
TimToady gives up spamming for now | 21:59 | ||
masak | it's a tricky one to workaround, fershure. | 22:01 | |
22:03
fglock joined
|
|||
dalek | p/kill_props_vtables: 572970e | bacek++ | src/ (2 files): Update to latest parrot with replaceing prop VTABLEs with standalone functions |
22:06 | |
jnthn | Well, that'll save some pointless virtualism. bacek++ | 22:07 | |
22:21
PacoAir joined
22:25
mj41 left
|
|||
masak | nom: my $foo = "OH HAI"; say "<b>$foo</b>" | 22:35 | |
p6eval | nom 4bdb94: OUTPUT«Method 'at_key' not found for invocant of class 'Str' in method postcircumfix:<{ }> at src/gen/CORE.setting:1196 in block <anon> at /tmp/oxbLthoO2u:1» | ||
masak | nom: my $foo = "OH HAI"; say "<b>$foo\</b>" | ||
p6eval | nom 4bdb94: OUTPUT«<b>OH HAI</b>» | ||
masak | oh, that works now. someone++ | ||
22:42
havenn joined
22:43
skipper joined
|
|||
cognominal | I have the feeling that my macbook ventilator is more sollicitated but for a shorter time with compiling nom with bs | 22:45 | |
*solicited? | 22:46 | ||
masak | phenny: "ventilateur"? | ||
phenny | masak: "fan" (fr to en, translate.google.com) | ||
cognominal | oops | 22:47 | |
masak | from Latin "vannus" -- "winnowing basket". | ||
cognominal | when my French hit the fan... | ||
masak | :) | ||
cognominal | *hits | ||
masak | "pardon my French..." | ||
22:47
havenn left
22:48
skipper left
22:51
PacoAir left
|
|||
cognominal | :) | 22:51 | |
22:51
PacoAir joined
22:52
fglock left,
PacoAir_ joined
22:57
PacoAir__ joined,
PacoAir left,
PacoAir__ is now known as PacoAir
22:59
PacoAir_ left
|
|||
cognominal | "Le président de la chaîne Starbucks, Howard Schultz, pose devant le premier-café boutique de Paris, avenue de l'Opéra" Avec un mug. On voit le fin connaisseur de la culteur française. Je doit être comme ma mère qui me fait une scène quand je bois dans une canette, mais je ne peux pas boire du chocolat ou du café dans un gobelet en carton. | 23:04 | |
masak | guten nacht, #perl6 | ||
cognominal | oops | ||
wrong channel again :( | |||
jnthn | C'est affreux! | ||
masak | "Avec un mug." :) | ||
knowing this channel, he's gonna throw it at a wall. | |||
jnthn | .oO( at a Wall ) |
23:05 | |
masak | "I've decided never to develop Perl 6, and to put Jon Orwant in anger management therapy." | 23:06 | |
cognominal | :) | 23:07 | |
23:07
snearch joined
|
|||
cognominal | well in French Perl conferences we do serve coffee in a platic cup because we are cheap. | 23:08 | |
but people don't have to pay for it so we have a excuse. | |||
masak | Jon Orwant incident, plastic cup version: "I've decided to release Perl 5.8" | 23:10 | |
heh, fan fiction. it's fun. | |||
Jon Orwant incident, cup doesn't break: "We need to harden Perl 5 and make it more secure." | 23:11 | ||
jnthn | .oO( Nej, d e fan! ) |
||
masak | phenny: "Nej, det är fan!" | 23:12 | |
phenny: "Nej, det är fan!"? | |||
phenny | masak: "No, it's hell!" (sv to en, translate.google.com) | ||
jnthn is still working out the exact usage of that word | 23:13 | ||
I hear it daily, however :) | |||
masak | Jon Orwant incident, cup goes through a window: "We need a dedicated Windows port of Perl." | ||
cognominal | :the mug transmogrified to a strawberry? | 23:14 | |
masak | only in a universe where the cup hits the wall and breaks, does Mr Wall get to break backwards compat. :) | ||
23:14
ascrazy left
|
|||
jnthn | And the result was smashing. :) | 23:15 | |
masak | jnthn: it's a complex word, to be sure. I count uses as a noun, adverb, and interjection. | ||
cognominal | is that wat to fuck or shit is to english? | 23:16 | |
*what | |||
jnthn | My impression is it's not that strong. | ||
masak | only because secularism is on the rise. | ||
religious swears simply don't have that strong a feel anymore. | 23:17 | ||
jnthn | English swears seem pretty fashionable here. | ||
masak | everything from the Anglophone culture is immediately cool here. | 23:18 | |
jnthn | Even I'm cool in Sweden. | ||
Though that's mostly due to the weather. :P | 23:19 | ||
23:19
PacoAir left
|
|||
[Coke] stares at his haskell problem. | 23:19 | ||
cognominal | I am reading Miles Davis autobriography, there is many "shit" and/or "motherfucker" per page. And in one of my favorite movie "The big Lebowsky" uses "fucking" every other sentences. | 23:20 | |
masak | [Coke]: what *is* your Haskell problem? | ||
cognominal | s/uses/The dude uses/ | ||
23:22
PacoAir joined
|
|||
masak tries again to leave | 23:22 | ||
'night, #perl6 | |||
jnthn | see you dans l'aeroport, masak :) | 23:23 | |
[Coke] | masak: gah, I was going to tell you my problem. ;) | 23:30 | |
masak: o/ | |||
In case he lied, see feather.perl6.nl/~coke/pugs.patch; with it, "Int" throws a multi error, before it says ::Int. | 23:36 | ||
geekosaur | 404... | 23:40 | |
23:41
havenn joined
|
|||
[Coke] | s/patch/diff/ | 23:43 | |
jnthn | Time for sleep...'night | 23:52 | |
23:53
gv left
|
|||
[Coke] | jnthn: ~~ | 23:53 | |
geekosaur | mmmmmmrgh was hoping it was a haskell type error, I have a little clue about those, pugs multis are a bit beyond me (I should probably try to wrap my head around that again) | 23:55 |