10:35 Ven`` joined
Ven`` masak: Not sure how long til I've been here, but I have to say, this past month has been amazing with #474 going in 10:36
being able to implement `ff`/`fff` as well as `swap`/`++`/`--` is as big a milestone as `is parsed` (or almost ;-).)
masak yes, I'm very pleased 10:38
still committed to blogging about it, but I'm very slow to do so
also -- want to point out -- it's only the first half of the lexicality stuff that's actually landed. the second half is slightly gnarlier, and I haven't worked on it enough yet. but the first half was enough to unblock all the above things.
now gearing up for PerlCon (as evidenced by #481 10:39
and realizing, by that, that these two things stand out as wanting to work on Real Soon: (a) cheating, (b) regexes
also also -- `swap`/`++`/`--` are all still technically mis-implemented due to the Single Evaluation Rule thing. 10:43
(dunno if you saw, but I've snuck in documentation for that already, under "Evaluating expressions". it's not up on the site yet, because I'm holding off until I finish all of the Macrology chapter.) 10:45
fleshing out the Macrology chapter has been tough going, but also very useful to get a feel for what 007 is, or wants to be
SmokeMachine masak: are you reading my conversation with jnthn on #perl6? have you any idea of how to implement that? 10:54
masak: hi!
masak SmokeMachine: hi! backlogging. 10:56
Ven``: while you're here. do I understand your stance about `return` correctly that you'd be OK with `quasi` binding its own lexical `return`? 12:22
(reason I'm asking is I'm considering it. tempted, but not at all convinced.)
for example, the implementation in #464 could replace the `last` and the assignment above it with an early `return`, under that semantics. also, the last line could be `return result` instead of just `result` 12:23
12:38 Ven``` joined 12:40 Ven`` left
Ven``` masak: last I remember, I wanted `return` to behave dynamically 12:45
I'm not sure it can be an early return though, but `if n > 1 { return lag(); }` would :-) 12:46
masak I'm not sure there's an observable difference between my "`quasi` binding its own lexical `return`" and "`return` behaving dynamically" -- maybe you can point to an observable difference? 12:48
Ven``` Er, I don't actually remember what I argued, but the difference is `macro r { quasi { return; } }; sub f { r(); say 1; }; f();` printing 1 or not 12:58
masak right right 13:14
interestingly, since we last spoke, a lot more things in quasis have become "late-bound"
notably, `BEGIN` statements, and macro calls 13:15
"late" as in "at macro application time"
we could certainly make `return` fall under that regime as well; that'd grant you your wish
of course, then we'd have to do the same for `next`/`last`/`redo` for consistency, but I don't see the hard with that 13:16
so, OK. we no longer have a disagreement. I will create an issue detailing this.
but that doesn't solve the problem of "there's no mechanism to return early (possibly with a value) from a quasi", which is what keeps nagging me all the time 13:17
a *lot* of macro implementations want to do that
hm, maybe there should be a modifier or something to `quasi` saying "this quasi should bind `return`" 13:18
`quasi func` or something 13:19
Ven``` That's an interesting thing to think about 13:59
I think the common lisp notion of return coul dbe interesting to us here 14:01
i.e. being able to explicitly call `(block ...)` and maybe name them: `(block a (block b (return-from a)))` 14:02
.oO( I use clojure at work, but I still have to count my parenthesis manually... )
It pains me, but there's not a day I write Perl 6 where I don't get frustrated with $%@ / flattening / itemization and wish they weren't here :(. 17:03
17:09 Ven```` joined 17:10 Ven``` left
Ven```` The containers too. 17:21
17:37 lucasb joined
masak you once compared Locations to containers. part of me is uneasy about Locations, but unlike containers, they're meant to be compiled away in most cases. 18:38
20:14 Ven````` joined 20:15 Ven```` left 23:19 Ven`````` joined 23:20 Ven````` left