00:34 lucasb left 13:52 lucasb joined 16:32 Ven`` joined
Ven`` masak: I'm glad you like me sometimes :P 16:35
I think we'll never need to generate unquotes. After all, we can just make an II"M"E (Immediately Invocated Macro Expression) and nest them if needs be. 16:36
and I think I'm starting to *like* that Alma's hygiene doesn't require unquotes all over the place 16:38
At least I still haven't found an issue with it. But I'm sure "no hygiene" is the reason CL doesn't want to do that.
Also I'm often wondering "will that even work", and, well, declaring the name isn't, but otherwise... 16:40
17:07 Ven`` left 17:09 Ven`` joined 17:13 Ven`` left 17:17 lucasb left 18:21 lucasb joined 19:42 Ven`` joined
masak :) 21:08
Ven``: I'm curious; in CL, is there a programmatic way to generate a comma/unquote? 21:10
Ven`` masak: no, not really: 21:11
masak I suspected not
Ven`` * ,1
debugger invoked [...]: Comma not inside a backquote.
masak right
but I don't mean syntax 21:12
I mean a way to create a (quoted) piece of code with a comma in it
Ven`` did you imply lisp has syntax? ..:) just joking
masak like, if you wanted to build an unquote but for some reason can't type it out
Ven`` er, I guess ``,,1 technically?
gives `,1
no, I don't think so. ' is (quote), but I'm not sure about the rest 21:14
masak I think I mean something that *isn't* a comma itself
like, ' means (quote ...)
` means, um, (quasiquote ...) ?
does , expand into some list-y expression?
Ven`` no, there's no (quasiquote)-like 21:16
masak (and secretly, I'm hoping the answer is "no, there isn't because it doesn't even make *sense*, because the comma makes a *hole* in the syntax, it isn't syntax in itself...")
Ven`` probably because the semantics are very removed from everything else
masak because the above 21:17
Ven`` yup
masak maybe it makes sense to say that the comma is implicitly parameterized on/connected to its surrounding backtick 21:22
Ven`` which, tbh, is probably one of the things that have convinced me 21:23
masak interestingly, this mechanism is also the deciding characteristic of slangs -- although even so, quasiquotes are a bit special because they riff off of the language they are _in_, adding holes 21:28
Ven`` I guess 21:33
rather they create a version of the language where everything is quoted, except for those holes
masak hmmm -- I'll have to think about whether I think that's true for Perl 6/Alma 21:34
well, obviously, we're in a quasiquote, so everything's quoted
but as you said yourself, we also have more/easier access to the surrounding unquoted scope
than does CL
Ven`` I don't think that's important 21:38
data vs code is
masak well
in that case
Ven`` 1 + 1 vs Q.Infix.new(Q.LitInt.new, Q.LitInt.new)
masak a quasi language definitely produces data, not code
I think I see clearly what you mean now
Ven`` :)
masak and that's also a way to see why unquotes don't make sense out in the code language 21:39
there's nothing to unquote from if we're not already quasiquoted
Ven`` right, you can go from data to code, but nowhere outside from that
well, I should probably get some sleep 21:42
masak code takes itself to seriously. you give it some stuff, and it actually _executes_ it. so gauche.
too*
Ven`` very french
masak anyway, sleep well
but it's also very French to be abstract, like data :) 21:43
Ven`` I need to take a look at how far from reality my gist is
well, `macro {{{foo}}} {}` most probably is...:)
masak that one should be fine 21:45
Ven`` oh?
masak if we want, we can even make it exactly that
I've been thinking about whether to allow that kind of thing
Ven`` I didn't realize.
masak similarly `1 {{{op}}} 2` could be made to work, I think
we could put defaults aside from "term" in various places 21:46
it's mostly a question of how complicated we want to make the rule for that
this is the part that is not at all like Lisp :) because we actually have syntax, and grammatical categories
Ven`` well the question was more about installing names to outside-of-the-macro
masak oh, ok 21:47
well
Ven`` *especially a macro*
masak there's now Q.Identifier (used mostly for naming things) and Q.Term.Identifier (used mostly for lookup)
the thing in `{{{foo}}}` would be the former
but if it's the latter, I don't think that's a big problem, because we can convert silently
Ven`` ok, but how do you call it? `defsuccinct(my swap, ...)`? 21:48
masak oh, ok
I need to look a little bit at how Python does its annotations, and then decide how much of that we can use (given we have macros and Python doesn't) 21:49
but `@succinct macro swap(` is what I have in mind
Ven`` yeah, annotations are a special case
I didn't really mean that
masak that is, `@succinct` is the macro-macro here
Ven`` those can cheart 21:50
-r
21:51 Ven`` left