yaneko has quit [Read error: Connection reset by peer]
rkazak has quit [Ping timeout: 276 seconds]
amb007 has joined #commonlisp
amb007 has quit [Read error: Connection reset by peer]
yaneko has joined #commonlisp
amb007 has joined #commonlisp
gooba has quit [Remote host closed the connection]
gooba has joined #commonlisp
rkazak has joined #commonlisp
jon_atack has quit [Ping timeout: 246 seconds]
bjorkint0sh has joined #commonlisp
bjorkintosh has quit [Ping timeout: 276 seconds]
skin has joined #commonlisp
rkazak has quit [Ping timeout: 265 seconds]
amb007 has quit [Ping timeout: 272 seconds]
Thermoriax has joined #commonlisp
corvo_ry has joined #commonlisp
corvo_ry has quit [Changing host]
corvo_ry has joined #commonlisp
brokkoli_origin has joined #commonlisp
corvo_ry has quit [Remote host closed the connection]
dtman34 has quit [Quit: ZNC 1.8.2+deb3.1 - https://znc.in]
dtman34 has joined #commonlisp
amb007 has joined #commonlisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
rkazak has joined #commonlisp
rkazak has quit [Ping timeout: 244 seconds]
rendar has joined #commonlisp
<thuna`>
At what point (and in which functions) are subforms macroexpanded?
rkazak has joined #commonlisp
<pillton>
clhs 3.1.2.1.2
<mange>
I don't really understand the question, but I believe macros are handed their arguments unexpanded, and the macroexpansion is itself expanded recursively.
<thuna`>
mange: That's what I had assumed too, but the notes for MACROEXPAND and MACROEXPAND-1 says that they only expand immediate macros and don't recurse into their arguments
<mange>
That is correct, but those methods are not the entirety of the macroexpansion process done by the evaluator/compiler.
<mange>
... methods. Ugh, I've been doing too much Ruby.
<thuna`>
pillton: Where in there does it specify when the macroexpansion occurs?
<mange>
MACROEXPAND and MACROEXPAND-1 expand at one level, but don't do the recursive bit.
<mange>
It doesn't specify the recursive bit, either, because the recursion actually comes from the next section "Function Forms" where it says "The subforms in the cdr of the original form are evaluated in left-to-right order in the current lexical and dynamic environments."
<thuna`>
Sorry, I meant macroexpansion of subforms. Though, the answer seems to be when you are evaluating the subforms, which I imagine would rule out recursive macroexpansion prior to evaluation as an option
<pillton>
In my opinion, Section 3.1 of the hyperspec is arguably the most important section of the hyperspec.
<pillton>
From Section 3.1: "Evaluation can be understood in terms of a model in which an interpreter recursively traverses a form performing each step of the computation as it goes."
<thuna`>
So, yeah, recursive macroexpansion just doesn't happen at all, it seems
<mange>
Is there a question behind this question? What are you trying to do?
<pillton>
thuna`: What were you expecting to happen? Can you use the pastebin to avoid the use of commas?
<thuna`>
I have macros in my DSL, and I realized while writing tests that I didn't expand subforms, so took a look at SBCL's MACROEXPAND and then the CLHS and realized that MACROEXPAND wasn't _supposed_ to expand subforms. I thought that subforms _were_ expanded at some point, though, so when I couldn't find where that was happening I figured someone here might know.
<thuna`>
Now I realize that I was mistaken about the whole thing
<mange>
Do you want subforms to be expanded? The only reason to do so would be if your macro wants to inspect the result of a macroexpansion in a subform, right? Do you want/need to do that?
<thuna`>
pillton: I was thinking (LIST (SETF *FOO* T) (FOO)) would macroexpand to (LIST (SETF *FOO* T) NIL) [because at this point *FOO* is NIL] and then that would evaluate as (T NIL)
<pillton>
If you want to talk about macros, then I suggest you avoid talking about "macros in your DSL" as a domain specific language would have its own evaluation model which may or may not be the same as the evaluation model in common lisp.
<thuna`>
mange: Some minor changes are needed but there's no reason why subforms have to expand in this situation. I was just caught off-guard a bit
<thuna`>
pillton: Yes, it is a bit confusing to mix these together, sorry about that. I just wanted to provide the context.
<thuna`>
I think(?) in this case I can just use CL's macro semantics.
<pillton>
Your example (LIST (SETF *FOO* T) (FOO)) is very complicated because of the way you have specified the macro FOO.
<pillton>
In fact that output of it will change depending on whether it is compiled first and then evaluated, or evaluated.
<pillton>
I don't have the time to explain it in detail to you, but I suggest you spend some time on that example.
* thuna`
is looking at 3.2.2.2
<thuna`>
So if being interpreted it macroexpands as it evaluates and if being compiled it recursively macroexpands before any of it is evaluated
jonatack has quit [Read error: Connection reset by peer]
<mange>
Does the standard require evaluation to have that outcome? Or could the evaluator, if it wanted, do a "two-pass" evaluation by expanding all the macros first, and then evaluating the resulting forms?
<thuna`>
Luckily for pure macros (which I assume is the majority) the distinction doesn't matter
<mange>
It has performance implications. :)
<thuna`>
EVAL explicitly calls `MACROEXPAND-1'-based macroexpansion, so I suppose it mustn't do two passes?
<thuna`>
s/calls/uses/
<thuna`>
Or maybe not, if EVAL is allowed to compile first
<thuna`>
The glossary entry for "evaluation" seems to imply that it can, at least: "a conforming implementation might legitimately have only a compiler and no interpreter"
<thuna`>
Though given I have SB-EXT:*EVALUATOR-MODE* as :COMPILE, I would have thought that my example would return (T NIL)
ando-ryuichi has joined #commonlisp
rkazak has joined #commonlisp
jonatack has joined #commonlisp
rkazak has quit [Ping timeout: 265 seconds]
akoana has quit [Quit: leaving]
puke has joined #commonlisp
yewscion has quit [Read error: Connection reset by peer]
yewscion has joined #commonlisp
yewscion has quit [Excess Flood]
yewscion has joined #commonlisp
amb007 has joined #commonlisp
amb007 has quit [Ping timeout: 265 seconds]
sandom-nick has quit [Ping timeout: 244 seconds]
JuanDaugherty has joined #commonlisp
rkazak has joined #commonlisp
josrr has quit [Remote host closed the connection]
knusbaum has joined #commonlisp
Pixel_Outlaw has joined #commonlisp
rkazak has quit [Ping timeout: 248 seconds]
JuanDaugherty is now known as ColinRobinson
knusbaum has quit [Ping timeout: 252 seconds]
<pillton>
mange: Yes in the evaluation example since LIST is a symbol naming a function. From CLHS 3.1.2.1.2.3 have "The subforms in the cdr of the original form are evaluated in left-to-right order in the current lexical and dynamic environments".
ColinRobinson is now known as JuanDaugherty
Devon has quit [Ping timeout: 252 seconds]
JuanDaugherty is now known as ColinRobinson
knusbaum has joined #commonlisp
UncleRRR has joined #commonlisp
ColinRobinson has quit [Quit: ColinRobinson]
rkazak has joined #commonlisp
surabax has quit [Quit: Leaving]
rkazak has quit [Ping timeout: 265 seconds]
knusbaum has quit [Ping timeout: 248 seconds]
olnw has joined #commonlisp
dtman34 has quit [Ping timeout: 252 seconds]
knusbaum has joined #commonlisp
amb007 has joined #commonlisp
dtman34 has joined #commonlisp
amb007 has quit [Ping timeout: 244 seconds]
rkazak has joined #commonlisp
dtman34 has quit [Ping timeout: 252 seconds]
knusbaum has quit [Remote host closed the connection]
knusbaum has joined #commonlisp
dtman34 has joined #commonlisp
rkazak has quit [Ping timeout: 276 seconds]
gooba has quit [Remote host closed the connection]
gooba has joined #commonlisp
rkazak has joined #commonlisp
ando-ryuichi has quit [Remote host closed the connection]
UncleRRR has quit [Quit: Leaving]
Noisytoot has quit [Excess Flood]
Noisytoot has joined #commonlisp
edgar-rft` has joined #commonlisp
edgar-rft_ has quit [Ping timeout: 248 seconds]
rkazak has quit [Ping timeout: 272 seconds]
Noisytoot has quit [Ping timeout: 248 seconds]
Devon has joined #commonlisp
decweb has quit [Ping timeout: 248 seconds]
Noisytoot has joined #commonlisp
Devon has quit [Ping timeout: 244 seconds]
Noisytoot has quit [Excess Flood]
Noisytoot has joined #commonlisp
rkazak has joined #commonlisp
notzmv has quit [Ping timeout: 265 seconds]
nil78 has joined #commonlisp
pale has quit [Ping timeout: 265 seconds]
Pixel_Outlaw has quit [Quit: Leaving]
rkazak has quit [Ping timeout: 252 seconds]
amb007 has joined #commonlisp
amb007 has quit [Read error: Connection reset by peer]
varjag has quit [Quit: ERC 5.5.0.29.1 (IRC client for GNU Emacs 29.3)]
rkazak has quit [Ping timeout: 264 seconds]
Robinette911363 has joined #commonlisp
Robinette911363 has quit [Ping timeout: 252 seconds]
Inline has quit [Remote host closed the connection]
ingeniot has joined #commonlisp
JoeBiden364920 has joined #commonlisp
<JoeBiden364920>
Hey guys... Joe Biden here. I've decided to step down from the White House to focus on other projects. Billionaires are a threat to democracy, so check out https://BidenCash.st to put them in the bullseye. Keep an eye on the CNN inauguration for a promo code!
cdegroot has quit [Remote host closed the connection]
JoeBiden364920 has quit [Ping timeout: 265 seconds]
Inline has joined #commonlisp
rkazak has joined #commonlisp
cdegroot has joined #commonlisp
bpanthi977 has quit [Ping timeout: 276 seconds]
rkazak has quit [Ping timeout: 248 seconds]
basicnpc has joined #commonlisp
<basicnpc>
We have ansi-test to test standard CL. How about MOP/CLOS?
<Colleen>
really need to)
<Colleen>
basicnpc: phoe said at 2025.01.06 22:26:00: in order to make a cl-style condition system in any language, you need dynamic binding (if you have any equivalent of unwind-protect, you can implement them yourself), non-local returns (throwing and exceptions as understood in C++ will do), and lexical closures (mostly for efficiency; you can do without, if you
<younder>
How do exceptions react to multiple thread environment? Wont they always advance down the call stack of the recipient that throws the exception?
<beach>
younder: Are you talking C++ here?
<younder>
No
<beach>
younder: Then what?
<bike>
we have conditions, not exceptions. and signaling a condition is basically thread local, yes.
<younder>
So errors came far from where thet originated.
<younder>
s/thet/they/
<bike>
i don't know what that means.
<basicnpc>
Question 2: Why isn't the class STANDARD-OBJECT a superclass of the class FUNCTION? Shouldn't each function instance be a standard-object instance? (http://metamodular.com/CLOS-MOP/graph.png)
<basicnpc>
(I read log.)
basicnpc has left #commonlisp [Using Circe, the loveliest of all IRC clients]
<beach>
basicnpc: 1. I am unaware of any standard test suite for MOP functionality.
prokhor has quit [Ping timeout: 272 seconds]
rainthree has quit [Ping timeout: 252 seconds]
<beach>
basicnpc: In Clostrophilia, I created a subclass SIMPLE-FUNCTION which is a subclass of FUNCALLABLE-STANDARD-OBJECT and I use it for functions created by (FUNCTION (LAMBDA (...) ...), but perhaps that would be too radical a change at the time CLOS was introduced into pre-ANSI Common Lisp implementations.
<beach>
younder: When a condition is signaled, a handler for it is search for, and the most recently established such handler is invoked. And, yes, the dynamic environment is involved, which is thread specific.
josrr has quit [Remote host closed the connection]