habamax has left #commonlisp [ERC 5.4 (IRC client for GNU Emacs 28.2)]
seok9 has quit [Quit: Client closed]
seok9 has joined #commonlisp
random-nick has quit [Ping timeout: 246 seconds]
Krystof has quit [Ping timeout: 246 seconds]
Gleefre has quit [Remote host closed the connection]
akoana has joined #commonlisp
Oddity has quit [Ping timeout: 250 seconds]
jmd_ has quit [Ping timeout: 240 seconds]
dnhester26 has quit [Ping timeout: 240 seconds]
zaymington has joined #commonlisp
seok9 has quit [Quit: Client closed]
seok9 has joined #commonlisp
zaymington has quit [Ping timeout: 265 seconds]
rbcarleton has joined #commonlisp
zaymington has joined #commonlisp
seok9 has quit [Quit: Client closed]
seok9 has joined #commonlisp
zaymington has quit [Remote host closed the connection]
zaymington has joined #commonlisp
zaymington has quit [Ping timeout: 250 seconds]
nij- has joined #commonlisp
<nij->
Hmm.. I still don't understand why this returns 1 not (1): https://bpa.st/NUGLI
<ixelp>
View paste NUGLI
<nij->
<nij->
Why should fdefinition look at the global binding instead of the local binding?
<|3b|>
because that's what the spec says to do, if nothing else
<hayley>
Because it does.
<|3b|>
one possible reason it says to do that is that they thought it was more important to be able to optimize calls to local functions than to be able to redefine them during execution of the enclosing scope
<|3b|>
(and/or didn't even think about the possibility of redefining local functions)
<nij->
I see. So the right question is.. if I want to redefine the local functions, is there any compliant option?
<|3b|>
(hi 1) could be compiled as 1 in CL
<nij->
I see. With the possibility of dynamic re-definition, such optimization is not possible.
<|3b|>
instead of "maintain a stack of bindings of HI", "look up function binding of HI in that stack" "make a full call to that binding" etc
<nij->
?
<|3b|>
same way you can't (let ((x 1)) (setf (symbol-value 'x) 2) x) and get 2
<nij->
This has me confused to. If symbol-value isn't doing the job, there should be other functions that do, no?
<nij->
too*
<|3b|>
symbol-value is a single global property of the symbol, so it can't store local bindings
<|3b|>
if it did you couldn't have threads
<|3b|>
same as symbol-function (equivalent to fdefinition for symbols)
<nij->
right, that's what symbol-value do.
<nij->
But aren't there local-symbol-value?
* |3b|
's suggestion is probably less efficient than it has to be, now that i think about it though
<|3b|>
nope
<|3b|>
again, (let ((x 1)) x) should be compiled to 1
<|3b|>
(or at least could be, and one would hope for it to be aside from maybe during debugging)
<nij->
ok.. I will take it as a fact.
<nij->
I just want to define a function with a symbol name that doens't pollute the global space.
<nij->
How about something like (let (name (gensym)) (defun name ()) (funcall name))?
<nij->
It doesn't work.. but there maybe a way to let it work - to name a function with a symbol name that is generated by (gensym).
makomo has joined #commonlisp
<|3b|>
you can make a function named by an uninterned symbol in lots of ways, hard to call it though
<|3b|>
might as well just make a completely anonymous function
<nij->
Oh! Here you go! (let ((symbol (defun #:hi () 2))) (funcall symbol))
<|3b|>
(defun #1=#:name () (funcall '#1#)) for example, or (compile (gensym) '(lambda ()...))
<|3b|>
or build the defun form with a macro
<|3b|>
yeah, that too
<gilberth>
Why put the function to symbol's function, when you cannot name that symbol anyway? This puzzles me. Why just use an anonymous function?
<nij->
Cuz my 'memoize! macro should take in a symbol and redefine the fdef of that symbol to the memoized function.
<|3b|>
for the recursive case a completely anonymous function is hard, you you can still (labels ((x () (x))) #'x) for something without a global name (and without creating extra symbols)
<nij->
And when I test the macro, I need to come up with a function with a symbol name, without polluting the global space.
tyson2 has quit [Remote host closed the connection]
<|3b|>
why is it a macro? just to save a ' ?
<gilberth>
Which again brings me to the conclusion that this MEMORIZE macro has a flawed interface.
NicknameJohn has joined #commonlisp
<gilberth>
I mean, does it parallel TRACE and you memorize and unmemorize functions interactively? Or isn't it rather that some function you write should be always memorized and perhaps that memorization is crucial for time complexity even?
<|3b|>
if it were a function, you could possibly avoid the problem of repeated calls by doing (memoize! 'memoize!) :p
<gilberth>
|3b|: lol
<nij->
Oh.. it can just be a function.
<nij->
It's just an exercise of mine..
* |3b|
wonders if (setf fdefinition) deletes compiler macros, if not they would have confusing interactions with your memoize!
<|3b|>
or inline definitions for that matter
<|3b|>
apparently not, and it confuses sbcl :p
<gilberth>
Heh, how is SBCL confused? His idea of the world again out of sync with reality?
<gilberth>
Anyhow, it would annoy me when a DEFUN would uninstall compiler macros.
<|3b|>
yeah, i think it gets confused because the type of the function doesn't match or something, but then gets confused trying to complain about that
<|3b|>
yeah, good point
<gilberth>
So it complains that it cannot complain?
<|3b|>
something like that
azimut has quit [Ping timeout: 240 seconds]
avocadoist has joined #commonlisp
<|3b|>
actually looks like it wasn't confused by the redefinition, it correctly complains that the inlined definition has a different result type from the current definition, but gets confused while trying to complain
ezakimak has joined #commonlisp
<jcowan>
gilberth: "the name of the path of the home of the user" is copied from French, or at least strongly reinforced by French
<gilberth>
jcowan: Are you sure that it specifically is French? German grammar works the same only that we use the genitive. And I bet a dozen other indogermanic languages.
<gilberth>
Actually when an "s" suffix is used it is called the "Saxon genitive" in German grammar.
akoana has quit [Quit: leaving]
<jcowan>
Right, Saxon being short for Anglo-Saxon.
<jcowan>
There are 3 possibilities in German: 1) Das ist meines Vaters Auto. 2) Das ist das Auto von meinem Vater. 3) Das ist das Auto meines Vaters.
<jcowan>
1 is now very limited: only a few nouns plus proper names can appear in the possessor slot.
<gilberth>
2) does only work in spoken German. It is not considered proper German.
<jcowan>
someone wrote a book about it called "Der Dativ ist dem Genitiv sein Tod"
<gilberth>
There are more, when you include spoken German. "Das is Paul's Auto", "Das ist das Auto vom Paul", "Das ist Paul sein Auto.", "Das Auto ist Paul sein." :-)
<jcowan>
It is analogous to the English of-genitive, but you can see that it uses different prepositions, "off" vs. "from"
<jcowan>
Really, "ist Paul sein"? Weird.
<gilberth>
jcowan: By ears always hurt when the dative is used where the genitive is called for. Like "Wegen dem Regen". Causes physical pain!
<jcowan>
"of" began life as a weak form of "off"
<gilberth>
jcowan: Weird indeed. But you can shuffle words in German as you like.
<jcowan>
You actually say "wegen des Regens"? When were you born, 1848?
<gilberth>
A bit later in 1974. And yes, I say "Wegen des Regens."
<jcowan>
Wow.
<jcowan>
I guess the right question is "do you generalize that to any noun after "wegen"? "wegen des Regens" is a fixed phrase.
<gilberth>
"wegen" always comes with genitive. Always.
<jcowan>
Anyway, my point was that type 3 is normal in German, whereas English uses type 1 and falls back to type 2.
<gilberth>
Yep, 3) is the most common.
<jcowan>
and 1 will not work with just any possessor
<gilberth>
2) you hear often in spoken German. But you better don't use it in written German.
<gilberth>
And as in English you use the "s" suffix with people names.
<jcowan>
But it's fine to say "the woman's doctor's friend's clothes"
<jcowan>
1) is a general and extensible construction
<gilberth>
I was told that I overuse "'s" and should rather use "of". It's not "the stack's top" but the "top of the stack".
<gilberth>
At least when writing.
<gilberth>
But I still struggle with English. It looks easy only on a first superficial glimpse. And we're off-topic again and people will get angry at me.
<jcowan>
That's true: 1) is blocked when the possessor is an inanimate object
<jcowan>
And yes, English is subtle. I have a grammar of English that is 2000 pages long.
<jcowan>
And yes, we're off-topic.
<gilberth>
We can hide in #lispcafe, if you like.
<jcowan>
Sure
nij- has quit [Ping timeout: 265 seconds]
shka has joined #commonlisp
occ has quit [Ping timeout: 268 seconds]
_whitelogger has joined #commonlisp
tetsuo9_ has quit [Ping timeout: 248 seconds]
habamax has joined #commonlisp
occ has joined #commonlisp
ronald has quit [Ping timeout: 256 seconds]
ronald has joined #commonlisp
Lycurgus has joined #commonlisp
tetsuo9 has joined #commonlisp
tetsuo9 has quit [Remote host closed the connection]
tetsuo9 has joined #commonlisp
dre has joined #commonlisp
waleee has quit [Ping timeout: 265 seconds]
Lycurgus has quit [Quit: Exeunt: personae.ai-integration.biz]
Noisytoot has quit [Ping timeout: 240 seconds]
eddof13 has joined #commonlisp
eddof13 has quit [Client Quit]
dtman34 has quit [Quit: ZNC 1.8.2+deb2+b1 - https://znc.in]
zaymington has joined #commonlisp
<beach>
Just one more thing which relates to how we write documentation, I often recommend avoiding the genitive 's for non-proper nouns in technical documentation. It has the great advantage that the important word comes first. So rather than "the employer's locations' zip code" you get "the zip code of the location of the employer".
* beach
now immediately regrets having uttered that phase.
remexre has joined #commonlisp
remexre has quit [Changing host]
<contrapunctus>
* phrase
<beach>
Yes, thanks.
dtman34 has joined #commonlisp
* beach
's increasing dyslexia is visible when the spell checker doesn't capture mistakes.
rainthree has joined #commonlisp
rgherdt has joined #commonlisp
<jackdaniel>
"the increasing dyslexia of beach is visible ..." ;)
<jackdaniel>
good morning
<beach>
Hello jackdaniel. I consider "beach" to be a proper noun.
<beach>
So my advice doesn't apply.
<jackdaniel>
I'm jesting
dtman34 has quit [Ping timeout: 240 seconds]
<hayley>
Don't worry, the output of my classmates had similar not-wrong-words. Like "quiet professional".
igemnace has joined #commonlisp
phantomics has joined #commonlisp
<hayley>
"appropriate brakes" and "has mentioned before" too.
dre has quit [Quit: Leaving]
<beach>
Nice ones.
mgl has joined #commonlisp
msavoritias has joined #commonlisp
Cymew has joined #commonlisp
notzmv has joined #commonlisp
zaymington has quit [Ping timeout: 265 seconds]
pve has joined #commonlisp
Krystof has joined #commonlisp
mingus has joined #commonlisp
Inline has joined #commonlisp
mingus1 has joined #commonlisp
mingus has quit [Ping timeout: 265 seconds]
mingus1 is now known as mingus
attila_lendvai has joined #commonlisp
scymtym has quit [Ping timeout: 246 seconds]
Brucio-61 has quit [Ping timeout: 260 seconds]
nij- has joined #commonlisp
nij- has quit [Ping timeout: 246 seconds]
habamax has quit [Quit: ERC 5.4 (IRC client for GNU Emacs 28.2)]
Brucio-61 has joined #commonlisp
Inline has quit [Ping timeout: 250 seconds]
attila_lendvai_ has joined #commonlisp
attila_lendvai has quit [Ping timeout: 246 seconds]
scymtym has joined #commonlisp
scymtym_ has joined #commonlisp
Gleefre has joined #commonlisp
<pve>
Good morning! Could anyone tell me roughly what goes on inside an "effective method"?
semz has quit [Quit: ZNC 1.8.2+deb2build5 - https://znc.in]
<jackdaniel>
the answer is simple - it is executed! perhaps you wonder how the effective method is constructed?
seok9 has quit [Quit: Client closed]
seok9 has joined #commonlisp
<pve>
jackdaniel: well I'm trying to understand how all of this works, so how it is constructed is probably relevant
<beach>
pve: Basically, a bunch of individual methods glued together by code that call those individual methods in the right order.
<pve>
but inside the effective method, is it like (if (typep arg 'foo) (call-this-method) (call-that-method)) ...
<beach>
pve: Also, local definitions in each method of CALL-NEXT-METHOD and NEXT-METHOD-P.
<jackdaniel>
pve: it is more that for each set of arguments of specific classes there is a separate effective method
<pve>
ah, so no looking at types inside the effective method?
<beach>
Correct. As jackdaniel said, dispatch is done once to determine which effective method to execute.
<beach>
pve: Besides, dispatch would not be done by the use of TYPEP.
<pve>
ok, that helps
<pve>
but where is the effective method stored? I'm looking at the slots of a couple of my methods and there doesn't seem to be anything indicating an effective method
<beach>
The glue that I mentioned is determined by the method combination.
<jackdaniel>
and it is called an effective method because it combines things like: binding call-next-method, possibly inlining after and before methods (depending on the actual method combination implementation) etc etc
<beach>
pve: They are stored in the generic function object.
semz has joined #commonlisp
<jackdaniel>
if you call a function compute-effective-method then you will receive the effective method itself
<jackdaniel>
the function is called lazily, because it would be quite cumbersome to go over all possible argument class combinations
<pve>
beach: aha, because the generic function "chooses" the apropriate effective method?
<beach>
Correct.
<pve>
jackdaniel: so if I have an effective method from compute-effective-method, could I "manually" call it? Without going through the generic function?
<jackdaniel>
no, because the effective method is not a function
<jackdaniel>
it is a form (more or less I suppose)
<jackdaniel>
some implementations take a step to make it a function accessible with compute-effective-method-FUNCTION, but that's not guaranteed I think
<Shinmera>
the effective method still needs the entire generic function call chain (due to call-next-method, next-method-p), so it requires context to operate that you cannot provide.
<jackdaniel>
also there's make-method-lambda, but if you expect me to know how it works then you are mistaken! :)
* jackdaniel
leaves to grab something to eat, see you \o
<pve>
jackdaniel: alright, thanks
<pve>
I tried compute-effective-method and got back a (call-method ...) form, so indeed not something I could call.
<pve>
(I'm still mulling over how to get "super" to work in my smalltalk, I've a couple of routes I could take, none of which seem easy)
dieggsy has quit [Remote host closed the connection]
Lord_of_Life_ has joined #commonlisp
Lord_of_Life has quit [Ping timeout: 268 seconds]
Lord_of_Life_ is now known as Lord_of_Life
<pve>
But since I have subclassed generic-function, could I, in theory, have *two* effective methods per generic function, one for normal calls, and another special effective method for super calls? (i.e. where we pretend that the "self" argument is of the superclass type)
<pve>
no idea if that's a reasonable approach..
<pve>
I clearly need to think about this some more :)
<jcowan>
here's an interesting method combination challenge: I don't know if it's doable (probably)
<jackdaniel>
the challenge is: write the method combination that computes what is the challenge :)
<jcowan>
In the Beta language, the equivalent of call-next-method invokes the next available less specialized method rather than the next available specialized method. Define-method-combination supports this via the optional "order" argument.
<jcowan>
However, in Racket there is more flexibility. Each method is tagged "java" or "beta", and there are two varieties of call-next-method, "super" and "inner" (which in CL might be spelled "call-next-supermethod" and "call-next-submethod")
awkravchuk has joined #commonlisp
<jcowan>
Specifically, if you call "inner", it looks down the class tree and invokes the next beta-marked method. "super" looks up the class tree to the next method and calls if it is java-marked; if not, there is no next supermethod.
<jackdaniel>
and here I thought that clos (even without mop) is metacomplicated ;)
<jcowan>
specifically, Fig. 3 shows a chain of java and beta methods and how they work in the presence of inner and super calls. The rest of the paper motivates such a thing.
<jackdaniel>
but the article seems interestng, thanks
<jcowan>
the idea is that whereas super allows you to override the whole behavior of the supermethod in arbitrary ways (you don't have to call "super" at all), the Beta style permits only a controlled specialization, because the generalized code is always run, and the specialized code is run only under its control
<jcowan>
by convention, calling a next method in the either direction that is not accessible is a no-op rather than an error
<hayley>
Add nested classes and "outer" from Newspeak too.
mingus1 has joined #commonlisp
<scymtym>
call it hyper dispatch: next methods in four orthogonal directions
alendvai__ has joined #commonlisp
attila_lendvai_ has quit [Ping timeout: 240 seconds]
Gleefre has quit [Remote host closed the connection]
Gleefre has joined #commonlisp
<Nilby>
pve: I you have a simple linear class hierarchy and methods with the object always first, maybe you could do something like this: https://plaster.tymoon.eu/view/3834#3834
occ has quit [Ping timeout: 240 seconds]
<Nilby>
s/I/If/
rainthree has quit [Ping timeout: 246 seconds]
rgherdt has quit [Remote host closed the connection]
rainthree has joined #commonlisp
semarie has quit [Remote host closed the connection]
semarie has joined #commonlisp
santiagopim has joined #commonlisp
czy has quit [Ping timeout: 268 seconds]
karlosz has joined #commonlisp
kevingal has joined #commonlisp
Perflosopher has quit [Ping timeout: 256 seconds]
Perflosopher has joined #commonlisp
Inline has joined #commonlisp
euandreh has joined #commonlisp
seok9 has quit [Quit: Client closed]
seok9 has joined #commonlisp
mgl has quit [Quit: Client closed]
NicknameJohn has quit [Ping timeout: 268 seconds]
kevingal has quit [Ping timeout: 240 seconds]
Guest39 has joined #commonlisp
<Guest39>
hello all i am learning to use slime, and was wondering if there was a way to send the current line of code of block selected visually to the repl and get the results in the repl
<Guest39>
is that possible ?
random-nick has joined #commonlisp
<beach>
It is usually not meaningful to send anything other than a top-level form, and for that, SLIME has a few commands.
Inline has quit [Ping timeout: 256 seconds]
alendvai__ is now known as attila_lendvai
attila_lendvai_ has joined #commonlisp
attila_lendvai has quit [Ping timeout: 240 seconds]
<Nilby>
Guest39: you select the line and do slime-eval-region which is usually on C-c C-r
<Guest39>
Nilby the issue is more why it doesn't go back to the code window?
<Guest39>
after evaluation?
<Guest39>
i don't want to switch everytime
<beach>
Usually those commands don't switch windows.
<Nilby>
Guest39: You may be able to do "C-c s r" which will pop you to the slime repl buffer
<beach>
It sounds like Guest39 doesn't want to go to the REPL window, but stay in the Code window.
rgherdt has joined #commonlisp
notzmv has quit [Ping timeout: 250 seconds]
<Nilby>
Hmmm. For me if I do C-c C-r it doesn't change any windows. It stays in the code window echoing the result in the message line.
<Guest39>
Nilby sure but i want the same line put in the repl and the output in the repl window
<Guest39>
i fixed it changing the code of slime
<Guest39>
as a test
<Guest39>
i mean of the related function
<Guest39>
but i guess this is absolutely not the right approach now i want to understand how i can write a wrapper which overwrites that keybinding
Guest39 has quit [Quit: Client closed]
Guest39 has joined #commonlisp
attila_lendvai_ is now known as attila_lendvai
mgl has joined #commonlisp
rgherdt has quit [Remote host closed the connection]
<Nilby>
Guest39: Maybe slime-selector could help. I bind it with (define-key global-map [(control c) ?s] 'slime-selector) . Also the mark-sexp command may be useful.
kevingal has joined #commonlisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
occ has joined #commonlisp
Gleefre has quit [Remote host closed the connection]
kevingal has quit [Ping timeout: 248 seconds]
Gleefre has joined #commonlisp
kevingal has joined #commonlisp
Cymew has quit [Ping timeout: 240 seconds]
Guest39 has quit [Quit: Client closed]
varjag has quit [Quit: ERC (IRC client for Emacs 27.1)]
seok9 has quit [Quit: Client closed]
seok9 has joined #commonlisp
santiagopim has quit [Ping timeout: 256 seconds]
Gleefre has quit [Remote host closed the connection]
Noisytoot has joined #commonlisp
Gleefre has joined #commonlisp
<pve>
Nilby: Oh, that looks intriguing. I do have a simple hierarchy exactly like that, and I tried to do something similar yesterday, but "method-function" seems to be the secret I couldn't figure out.
<pve>
thanks for showing me that
tibfulv has quit [Remote host closed the connection]
<pve>
Nilby: In the call to compute-applicable-methods-using-classes I had to change "args" to (mapcar #'class-of args), but after that it actually works!
<pve>
I can't believe this..
tibfulv has joined #commonlisp
<Nilby>
It's a hack, but my opinion is if something exists you should be able to use it.
<pve>
you mean "hack" in the sense that it may not work on all implementations, or as in quick 'n' dirty?
<Nilby>
As in quick an dirty. It should be portable as long as you have the MOP
<pve>
i mean, is the function returned by method-function supposed to be used like this?
<pve>
well in any case, if you don't mind I'd like to use this code to implement my "super", looks like it's pretty much exactly what I need :)
<Nilby>
If something is a function you should be able to call it. If anything CLOS is extremely flexible and mailable.
<Nilby>
pve: Of course. I think I did something similar to get smalltalk-like behavior from CLOS.
<pve>
Thanks, wow that's a load off my back. Future pve can deal with a potential "proper" solution.
<Nilby>
I'm glad that could actually help :)
morganw has joined #commonlisp
<pve>
but just so i understand this, the "method-function" is not the same as the effective-method? So, for example, a call-next-method would fail inside it?
<pve>
or my understanding was that the effctive-method makes things like call-next-method possible
<pve>
(not beind able to call call-next-method is ok in my case, if I have call-super)
<pve>
oh I remember, the effective methods are stored in the generic function
<Nilby>
You could still call-next-method in the method body. But the method function that call-super pick is unlikely to be the effective-method
habamax has quit [Ping timeout: 240 seconds]
ec_ has joined #commonlisp
<pve>
ah, ok
<bike>
the method function is the function for a single method. it can use call-next-method because it receives the next methods in an argument. the effective method is the total combination of methods used for a given set of arguments
<bike>
in the MOP, a standard method function is defined to recieve the list of arguments to the generic function as its first argument, and the list of next methods as its second argument.
<beach>
As I recall, the method function does not include definitions of call-next-method and next-method-p, but only the body of the method source. It is MAKE-METHOD-LAMBDA that defines those.
<bike>
The method function is produced by make-method-lambda
<beach>
Er, are you sure about that terminology?
<Nilby>
pve: I guess if you want to call-next-method in subsequent methods maybe you shouldn't use NIL as the next-methods arg of funcall like I did.
<pve>
oh so *that's* what make-method-lambda does, I was never really clear on that.
<bike>
if you want to be more precise, make-method-lambda returns a lambda expression which evaluates to the method function
<beach>
Let me verify that...
<bike>
so make-method-lambda in general returns a lambda expression that includes definitions for call-next-method and next-method-p. of course there are all kinds of tricks that can be implemented on top of that
<beach>
Yes, that I know. It is just that I am not sure which part is called the "method function", whether it is before or after MAKE-METHOD-LAMBDA did its work.
Gleefre has quit [Ping timeout: 245 seconds]
<bike>
well, fundamentally the method-function is what you get from the mop:method-function reader. that will be post-m-m-l. the pre-m-m-l method body isn't actually stored (or at least isn't portably accessible afterward)
<beach>
Right you are!
<bike>
i have spent far too much time thinking about make-method-lambda
<beach>
Heh! Why?
<bike>
oh, just in the course of implementing it
<beach>
I see. It apparently upset PCos a lot. :)
<bike>
actually passing a list of arguments and list of next methods would be kind of slow, so in clasp we do this whole tricky thing where the method function is actually a funcallable instance that stores a different function with a different calling convention
<pve>
And the :function initarg when making a method instance must be a function of two arguments, the arguments to the generic functions, and a list of next methods?
<bike>
Well, for a standard method yes
attila_lendvai has quit [Read error: Connection reset by peer]
jeffrey has joined #commonlisp
<bike>
For your own methods you can kind of whatever you want, but then you'll have to override other stuff to make it work
<bike>
kind of do whatever you want*
<bike>
(compute-effective-method specifically, i believe. i have not done this myself but it's briefly described in AMOP)
attila_lendvai has joined #commonlisp
<pve>
right, so I call this function with an empty "next methods" argument if I feel like it?
<pve>
*I can
<bike>
You can indeed, and then if it does call-next-method it will signal a no-next-method error
<pve>
right, ok, I think I'm beginning to understand this a little
<beach>
bike: So the funcallable-instance function is the one that takes two arguments, but you actually call the additional one?
<bike>
Right. So if you use mop:method-function you still get the standard-conformant function
<beach>
Got it. That's clever.
<bike>
I stole it from SBCL, which is good, because it would have taken me quite a while to think up
<beach>
I see. One thing to do would be to check whether the method is defined in the null lexical environment, and just manipulate the lambda expression instead. Then it could be fully integrated into the effective method.
<beach>
You would still have to create the function for MOP:METHOD-FUNCTION of course.
<bike>
I don't think I understand
<beach>
Even with your optimization, you still have to call the method function.
<beach>
So it has to be a function.
Gleefre has joined #commonlisp
<beach>
But, if the method is defined in the null lexical environment, no function has to be called. Then you don't have to worry about calling conventions and you can incorporate the body of the method into the effective method, and ultimately into the generic function itself. No?
<jackdaniel>
yes, I think that pcl originally had such optimization (at least I think I saw it in ecl)
<jcowan>
beach: subject to the usual constraints on inlining, yes.
<beach>
jcowan: I think that takes care of itself, because when the method is redefined, the effective method and the dispatch functions are recomputed.
<jackdaniel>
indeed, make-method-lambda does inline the method-lambda when the method itself is not a closure
<beach>
jackdaniel: Good to know.
<jcowan>
I was thinking of recursive methods, but of course a method itself cannot be recursive, it has to recurse through the gf.
<bike>
I think whether you want to inline the method functions is a bit of a separate concern with diffferent weighing factors, like whether you're worried about code being duplicated in a bunch of effective methods
zaymington has joined #commonlisp
<jackdaniel>
sure, I think that the insight beach wanted to share was that it is _possible_ to inline it when it is not a closure. did I get that right beach?
<beach>
Yes.
<bike>
i see that now
<jackdaniel>
today I have learned about savage hack in ecl compiler and I can say that I don't like it
<jackdaniel>
apply is treated specially by the compiler if the last argument is .combined-method-args., then that special variable is treated as a stack frame (not a list)
eddof13 has joined #commonlisp
Inline has joined #commonlisp
kevingal has quit [Ping timeout: 248 seconds]
zaymington has quit [Ping timeout: 250 seconds]
zaymington has joined #commonlisp
mgl has quit [Quit: Client closed]
remexre has quit [Remote host closed the connection]
mgl has joined #commonlisp
remexre has joined #commonlisp
chrcav has quit [Ping timeout: 240 seconds]
zaymington has quit [Ping timeout: 248 seconds]
chrcav has joined #commonlisp
shka has quit [Ping timeout: 240 seconds]
zxcvz has joined #commonlisp
NotThatRPG is now known as NotThatRPG_away
NotThatRPG_away has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
shka has joined #commonlisp
Inline has quit [Ping timeout: 256 seconds]
attila_lendvai_ has joined #commonlisp
attila_lendvai has quit [Read error: Connection reset by peer]
ec_ has quit [Ping timeout: 240 seconds]
ec_ has joined #commonlisp
amb007 has quit [Ping timeout: 240 seconds]
amb007 has joined #commonlisp
<Shinmera>
Any cmucl knowers here know whether cmucl only supports cooperative threads or also system threads?
<Shinmera>
the manual is hilariously useless
amb007 has quit [Ping timeout: 240 seconds]
amb007 has joined #commonlisp
awkravchuk has quit [Remote host closed the connection]
zxcvz1 has joined #commonlisp
zxcvz has quit [Ping timeout: 250 seconds]
zxcvz1 is now known as zxcvz
<jackdaniel>
Shinmera: no native threads
makomo has quit [Ping timeout: 265 seconds]
Gleefre has quit [Remote host closed the connection]
Inline has joined #commonlisp
seok9 has quit [Quit: Client closed]
mgl has quit [Quit: Client closed]
seok9 has joined #commonlisp
alcor has joined #commonlisp
waleee has joined #commonlisp
Gleefre has joined #commonlisp
NotThatRPG has joined #commonlisp
johnjaye has quit [Ping timeout: 240 seconds]
johnjaye has joined #commonlisp
szkl has joined #commonlisp
johnjaye has quit [Ping timeout: 240 seconds]
cage has joined #commonlisp
amb007 has quit [Ping timeout: 248 seconds]
amb007 has joined #commonlisp
ec_ has quit [Ping timeout: 240 seconds]
ec_ has joined #commonlisp
matt` has joined #commonlisp
johnjaye has joined #commonlisp
matt` has quit [Remote host closed the connection]
NicknameJohn has joined #commonlisp
dcb has joined #commonlisp
Inline has quit [Ping timeout: 268 seconds]
random-nick has quit [Ping timeout: 256 seconds]
random-nick has joined #commonlisp
rainthree has quit [Quit: Leaving]
m5zs7k has quit [Ping timeout: 246 seconds]
m5zs7k has joined #commonlisp
bjork1intosh has quit [Remote host closed the connection]
bjork1intosh has joined #commonlisp
LispTyro has joined #commonlisp
seok9 has quit [Quit: Client closed]
seok9 has joined #commonlisp
eddof13 has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
msavoritias has quit [Ping timeout: 268 seconds]
eddof13 has joined #commonlisp
buffet has quit [Quit: WeeChat 3.7.1]
azimut_ has joined #commonlisp
azimut has quit [Ping timeout: 240 seconds]
jeffrey has quit [Ping timeout: 246 seconds]
dino_tutter has quit [Quit: Leaving]
scymtym_ has quit [Ping timeout: 240 seconds]
scymtym has quit [Ping timeout: 240 seconds]
Brucio-61 has quit [Ping timeout: 260 seconds]
zxcvz has quit [Quit: zxcvz]
alendvai__ has joined #commonlisp
seok9 has quit [Quit: Client closed]
attila_lendvai_ has quit [Ping timeout: 265 seconds]
seok9 has joined #commonlisp
scymtym has joined #commonlisp
Gleefre has quit [Remote host closed the connection]