<phoe>
third, stop when you reach the CATCH tag and continue execution from there
<beach>
Notice the "Events 2 and 3 are actually performed interleaved, in the order corresponding to the reverse order in which they were established. The effect of this is that the cleanup clauses of an unwind-protect see the same dynamic bindings of variables and catch tags as were visible when the unwind-protect was entered."
<phoe>
beach: regarding ENSURE-CLASS-USING-CLASS, what should I specialize on in case of the first parameter?
<no-defun-allowed>
somewhat related: do you prefer block/return-from or catch/throw? they seem somewhat similar.
<beach>
phoe: Your own subclass of some standard class.
<phoe>
(find-class 'my-class) ?
<phoe>
after I've done (defclass my-class ...), that is
<phoe>
no-defun-allowed: block-return from are legical
<phoe>
lexical
<phoe>
catch/throw is dynamic
<beach>
no-defun-allowed: What phoe said. So block/return is typically faster.
<no-defun-allowed>
right
<phoe>
so (block nil (return-from nil 42))
<beach>
And also more predictable.
<phoe>
catch/throw will also work there
<no-defun-allowed>
should check quickly if i use throw in anything important
<beach>
no-defun-allowed: Sometimes you don't have a choice.
<no-defun-allowed>
that's true
<phoe>
generally: you shouldn't, unless you have very good reason to
<beach>
If the "catch" is in one module and the "throw" in another, then you can't use block/return.
<no-defun-allowed>
yes, that is correct
<no-defun-allowed>
for the most part i do have a choice i think
<phoe>
in most of the cases where one could use THROW they should use SIGNAL instead
<phoe>
since conditions (HANDLER-CASE in particular) are a more general and more useful abstraction built on top of THROW/CATCH.
<beach>
phoe: To determine what methods you are allowed to define, imagine that your software is going to be distributed and that it will coexist with other software. If there is a potential conflict with some other software doing the same as yours, then you are not allowed to do it.
dented42 has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<phoe>
beach: E-C-U-C has two mandatory arguments, the second of which is going to be (EQL 'SOME-SYMBOL-OF-MINE) in my :AFTER method.
<beach>
Hmm. OK, that might fly.
<phoe>
Where 'SOME-SYMBOL-OF-MINE is in my package.
<beach>
Yes, I understand.
<phoe>
I assume that also specializing the class on (EQL (FIND-CLASS 'SOME-SYMBOL-OF-MINE)) won't hurt, though.
<beach>
Er, hold on...
<beach>
Never mind.
<beach>
Yes, that might fly as well.
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Ping timeout: 252 seconds]
<phoe>
<insert a complaint about DEFINE-CONDITION not obeying the MOP here>
nowhere_man has joined #lisp
<phoe>
Okay, so, so far I've burned myself on MAKE-CONDITION not calling INITIALIZE-INSTANCE, DEFINE-CONDITION not calling ENSURE-CLASS-USING-CLASS, and CHANGE-CLASS being useless on condition objects
kushal has quit [Remote host closed the connection]
kushal has joined #lisp
<phoe>
It's hard to go 100% CLOS+MOP when you have this historical luggage of conditions not being standard-objects poking at you
<beach>
I maintain that I think they should not be standard objects.
<beach>
But instead a separate pair like funcallable-standard-object and funcallable-standard-class.
<beach>
... so condition and condition-class in this case.
<beach>
But they could still use the MOP machinery of course.
dented42 has joined #lisp
<phoe>
No no, as far as I understand, SBCL's PCL is built at the very end of their build order while conditions are baked-in very early.
<beach>
Yes, but there is no particular reason to do it that way.
<beach>
In SICL, the MOP hierarchy is built first.
<phoe>
That's because you flip the build priorities around. (:
<beach>
I don't care about SBCL. My opinion remains valid, until someone convinces me otherwise.
<phoe>
I understand your opinion and agree with it. I'm now thinking of what and how to do about this.
zxcvz has joined #lisp
<beach>
There are huge advantages to maintenance by using the MOP machinery for other aspects of the standard.
<beach>
Of course, if, for reasons of bootstrapping, you first have to implement things without the MOP, there is no particular reason to implement things a second time, this time using the MOP.
graphene has quit [Remote host closed the connection]
graphene has joined #lisp
roshanavand has quit [Ping timeout: 252 seconds]
roshanavand has joined #lisp
* beach
is off to the biennial neighborhood party, and will be away most of the afternoon.
dale has quit [Quit: dale]
<no-defun-allowed>
have fun!
nika has quit [Quit: Leaving...]
pjb has joined #lisp
nanoz has joined #lisp
mn3m has quit [Ping timeout: 252 seconds]
<aeth>
phoe: It looks like you've discovered a place where the language is underspecified imo
igemnace has quit [Quit: WeeChat 2.2]
varjag has joined #lisp
lavaflow has quit [Ping timeout: 252 seconds]
<pjb>
hi
rstoye has joined #lisp
rstoye has left #lisp [#lisp]
<phoe>
aeth: it's not underspecified. Conditions were left out of CLOS purposefully; to the best of my understanding, that happened because X3J13 did not have enough time to integrate the condition system into CLOS.
<phoe>
AFAIR they also suspected that a subset of CL would be delivered "without CLOS".
dddddd has joined #lisp
<pjb>
On the other hand, most implementation define conditions as clos objects, AFAIK.
<phoe>
pjb: CCL, ECL, ABCL, LW, ACL do.
<phoe>
SBCL doesn't.
<pjb>
yes, definitely most.
marvin2 has joined #lisp
gravicappa has quit [Ping timeout: 244 seconds]
lnostdal has quit [Ping timeout: 272 seconds]
cage_ has joined #lisp
random-nick has joined #lisp
GoldRin has joined #lisp
dented42 has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
frodef has joined #lisp
lnostdal has joined #lisp
varjag has quit [Quit: ERC (IRC client for Emacs 26.1)]
varjag has joined #lisp
v0|d has joined #lisp
scymtym has quit [Ping timeout: 268 seconds]
orivej has joined #lisp
<random-nick>
is QUOTE supposed to return the same object that was passed to it or just an object that is equal?
<phoe>
random-nick: EQ
<phoe>
the same object.
<phoe>
or rather
<phoe>
THE object.
quazimodo has quit [Ping timeout: 252 seconds]
quazimodo has joined #lisp
<random-nick>
how can the compiler put literal lists into the function object? shouldn't it be a reference to the list allocated by the reader?
<random-nick>
is that possible because of the line "The consequences are undefined if literal objects (including quoted objects) are destructively modified."?
<phoe>
random-nick: what do you mean, literal lists into the function object?
<phoe>
by the time the compiler operates, there's nothing to be read; everything was already read and allocated.
<phoe>
including lists that were allocated by the reader.
Bike has joined #lisp
<phoe>
that line is a limitation for the programmer; (setf (cdr '(1 . 2)) 3) is undefined behavior.
<random-nick>
phoe: well, what I wanted to know is if the compiler can consider quoted objects to be constants
<phoe>
"quote forms are always considered constant forms and must be recognized as such by constantp."
<random-nick>
huh, I didn't know about constantp
<random-nick>
thank you
razzy has quit [Ping timeout: 252 seconds]
<p_l>
random-nick: since quoted forms are considered constant, compiler can move them however it wants
<p_l>
For example, SBCL will put them into "constants vector" before the function code in memory
<p_l>
... but with (safety 0) you can write to them
<p_l>
(yes, this was a hard to find bug once for me -_-;)
<jackdaniel>
you deserve it for having (safety 0) in your environment
<jackdaniel>
so-called fair punishment
scymtym has joined #lisp
<p_l>
yep!
<p_l>
(it was a learning moment, though)
flazh has joined #lisp
Kundry_Wag has joined #lisp
orivej has quit [Ping timeout: 244 seconds]
Kundry_Wag has quit [Ping timeout: 252 seconds]
Lycurgus has quit [Quit: Exeunt]
lavaflow has joined #lisp
<phoe>
Is there any MOP trickery that will allow me access to the method that is currently being executed?
<phoe>
(defmethod foo ((bar baz)) (print *current-method*)) ;; something like this
<_death>
write your own method combination?
<phoe>
Can't - the GF I'm using is using the standard method combination.
<phoe>
I mean, I know the method qualifiers and specializers, so I could go the long way and find the method - but I wonder if there is any dynavar or function that already serves this purpose.
<_death>
maybe a backtrace, but too hacky.. maybe you don't really want to solve _that_ problem
<Bike>
there is not.
<phoe>
Thanks. I'll go the long road then.
zxcvz_ has joined #lisp
zxcvz has quit [Quit: zxcvz]
zxcvz_ is now known as zxcvz
<pjb>
I still read GF as girlfriend, not as generic function…
SenasOzys has quit [Ping timeout: 252 seconds]
pjb has quit [Remote host closed the connection]
cage_ has quit [Quit: Leaving]
cage_ has joined #lisp
<_death>
generic functions are your friends.. whether they're girls or not is implementation-dependent
Nephromancer has joined #lisp
<Inline>
lol
zxcvz has quit [Quit: zxcvz]
SenasOzys has joined #lisp
<phoe>
_death: is there a portability library that can be used to check this behavior?
<phoe>
some kind of TRIVIAL-GIRLFRIEND:GIRLFRIENDP?
orivej has joined #lisp
cage_ has quit [Remote host closed the connection]
eminhi has joined #lisp
cage_ has joined #lisp
orivej has quit [Ping timeout: 268 seconds]
xuxuru has joined #lisp
<_death>
you can check if it's a feminist using the mop ;)
<Inline>
lol
SaganMan has joined #lisp
<phoe>
how?
Essadon has joined #lisp
<_death>
well, in practice generic functions are never girls, and so the early controversy about CLOS being object oriented was settled, and so this discussion doesn't belong to #lisp ;)
Achylles has joined #lisp
nika has joined #lisp
cl-arthur has joined #lisp
flazh has quit [Ping timeout: 252 seconds]
flazh has joined #lisp
kushal has quit [Remote host closed the connection]
kushal has joined #lisp
quazimodo has quit [Ping timeout: 252 seconds]
graphene has quit [Remote host closed the connection]
graphene has joined #lisp
<beach>
pjb: There is no such thing as a "CLOS object" in the standard. In fact, the best definition of that term would be "any Common Lisp datum".
pjb has joined #lisp
GoldRin has quit [Ping timeout: 268 seconds]
igemnace has joined #lisp
nebunez has joined #lisp
nebunez has quit [Remote host closed the connection]
nebunez has joined #lisp
nebunez has quit [Remote host closed the connection]
SenasOzys has quit [Remote host closed the connection]
SenasOzys has joined #lisp
josemanuel has joined #lisp
trittweiler has joined #lisp
random-nick has quit [Ping timeout: 240 seconds]
random-nick has joined #lisp
ealfonso has joined #lisp
warweasle has joined #lisp
bendersteed has joined #lisp
Achylles has quit [Ping timeout: 252 seconds]
graphene has quit [Remote host closed the connection]
graphene has joined #lisp
zfree has joined #lisp
nanoz has quit [Ping timeout: 252 seconds]
Achylles has joined #lisp
igemnace has quit [Ping timeout: 252 seconds]
igemnace has joined #lisp
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Ping timeout: 246 seconds]
cage_ has quit [Remote host closed the connection]
cage_ has joined #lisp
zxcvz has joined #lisp
Josh_2 has joined #lisp
warweasle is now known as warweasle_afk
nika has quit [Quit: Leaving...]
SenasOzys has quit [Ping timeout: 252 seconds]
bendersteed has quit [Quit: bye]
bendersteed has joined #lisp
SenasOzys has joined #lisp
bendersteed has quit [Quit: bye]
warweasle_afk has quit [Quit: rcirc on GNU Emacs 24.4.1]
v0|d has quit [Ping timeout: 268 seconds]
doubledup has quit [Read error: Connection reset by peer]
doubledup has joined #lisp
jack_rabbit has joined #lisp
doubledup has quit [Read error: Connection reset by peer]
doubledup has joined #lisp
igemnace has quit [Read error: Connection reset by peer]
igemnace has joined #lisp
mkolenda has quit [Remote host closed the connection]
mkolenda has joined #lisp
Kundry_Wag has joined #lisp
Achylles has quit [Ping timeout: 260 seconds]
Jesin has joined #lisp
Kundry_Wag has quit [Ping timeout: 252 seconds]
graphene has quit [Remote host closed the connection]
graphene has joined #lisp
Oladon has joined #lisp
Achylles has joined #lisp
razzy has joined #lisp
random-nick has quit [Read error: Connection reset by peer]
jack_rabbit has quit [Ping timeout: 252 seconds]
xuxuru has quit [Quit: xuxuru]
oni-on-ion has quit [Ping timeout: 252 seconds]
oni-on-ion has joined #lisp
scymtym has quit [Ping timeout: 260 seconds]
razzy has quit [Ping timeout: 252 seconds]
Bike has quit [Ping timeout: 272 seconds]
tripty has quit [Ping timeout: 252 seconds]
edgar-rft has quit [Remote host closed the connection]
tripty has joined #lisp
nanoz has joined #lisp
roscoe_tw has joined #lisp
scymtym has joined #lisp
nowolfer has joined #lisp
kajo has joined #lisp
xuxuru has joined #lisp
graphene has quit [Remote host closed the connection]
<p_l>
jackdaniel: has anyone compiled ECL with musl yet?
vlatkoB has quit [Remote host closed the connection]
<jackdaniel>
p_l: I had reports (mind, not recent) that it has been compiled succesfully with musl and uclibc
kajo has quit [Ping timeout: 250 seconds]
<p_l>
I guess I need to sit down and build that build environment I need
<p_l>
though I suspect SBCL will be primary development system and ECL the delivery one
<jackdaniel>
if you have ecl-specific questions just drop by on #ecl
X-Scale has joined #lisp
kajo has joined #lisp
slyrus1 has quit [Ping timeout: 252 seconds]
quipa has joined #lisp
kajo has quit [Ping timeout: 252 seconds]
zfree has quit [Quit: zfree]
gravicappa has joined #lisp
rjid has joined #lisp
<aeth>
Took me a while to find the correct answer to what beach says about there being no "CLOS object". If by "CLOS object" you mean "instance of a [standard-]class (created by defclass)", that is a "standard-object". Otherwise, "object".
<aeth>
The advantage of using the exactly correct term is that you can say (typep (make-condition 'error) 'standard-object) is NIL in major implementations only in SBCL. Now you have something people can run in their REPL.
<aeth>
pjb: ^
<aeth>
(And, actually, it's also NIL in CMUCL, obviously)
cage_ has quit [Quit: Leaving]
<aeth>
(I should have said "instance of a standard-class (created by defclass)" or "instance of a [standard-]class created by defclass". The combination of parens and brackets is a bit misleading.)
rjid has quit [Ping timeout: 256 seconds]
ggole has quit [Quit: ggole]
dueyfinster has joined #lisp
orivej has joined #lisp
<pjb>
aeth: instances of standard-class are classes.
<pjb>
instances of instances of standard-class are standard-objects.
<aeth>
pjb: thank you
<aeth>
I knew I still had a mistake in there
<aeth>
Being this meta gets... tricky to talk about
<djeis[m]>
Strictly speaking instances of standard-class are also standard-object's :p
<pjb>
The funny thing of course, is that classes are instances of objects that are classes. But the loop is only apparent, since the arrow going down is an is-instance-of, not a is-subclass-of.
<djeis[m]>
Given class is a subclass of standard-object.
<djeis[m]>
(typep (find-class 'integer) 'standard-object) ;; => t
<aeth>
Now how do structures fit in?
Achylles has joined #lisp
<djeis[m]>
That is exceedingly implementation dependent.
<djeis[m]>
I mean, presumably every structure would have some associated class which would be an instance of class, so (typep (class-of <x>) 'standard-object) ;; => t
<djeis[m]>
But exactly what that class is or inherits from is hard to say.
<trittweiler>
it's a subclass of structure-class
<djeis[m]>
On SBCL
<djeis[m]>
Oh, my bad.
<trittweiler>
structure-class and structure-object are in the standard :)
<djeis[m]>
For some reason I lost that one when I checked the index lol
<djeis[m]>
Answers my question tho- structure-class is a subclass of class.
<trittweiler>
and is a standard-object :)
azimut_ has joined #lisp
<aeth>
My impression of structures is that because redefinition is undefined, they *can* have a special allocation strategy (taking a slot's :type into account) with inline accessors (which can give the slot's :type information to the using function, for use in type inference), and that's the part that's undefined. (Some implementations just type check, and CLISP probably doesn't even do that.)
<djeis[m]>
Yup, as weird as that may be.
<djeis[m]>
aeth: yes, exactly.
k3nu has quit [Ping timeout: 268 seconds]
azimut has quit [Ping timeout: 245 seconds]
doubledup has quit [Quit: Leaving]
<trittweiler>
I think, you could have special allocation strategies also for objects. The physical size of the slot should always be at least 1 lisp-word, though, though (which is not worse than for T), so that it can change to an arbitrary Lisp-pointer. If the physical size was multiple lisp-words, you just use the first one upon change, and NOP the remaining ones.
<djeis[m]>
Given you can add and remove slots from standard-objects anyway there's no reason they couldn't have a specialized allocation strategy too, you just can't inline the accessor code for it.
<djeis[m]>
And it'd potentially make the accessor code a lot more complicated.
<djeis[m]>
But worries about being able to fit the new object layout inside the old one are already moot.
Bike has joined #lisp
robotoad has quit [Max SendQ exceeded]
<oni-on-ion>
is there more to close than defclass/defmethod/defgeneric and slots, ie is standard-object documented, could one display applicable methods for builtin classes if any?
robotoad has joined #lisp
<Bike>
that's kind of incoherent
<Bike>
except the last part. you can find methods specialized on builtin classes
<Bike>
same way you do for any specializer
<Bike>
there's mop:class-direct-methods e.g.
<Bike>
or was it specializer-direct-methods. yeah, that one.
<Bike>
compoute-applicable-methods(-using-classes) also works the same on builtin (classes) same as others
dueyfinster has joined #lisp
kajo has joined #lisp
<aeth>
defclass has :type, too. It's just not as respected as defstruct's :type (e.g. SBCL at default implementation levels ignores it) because it doesn't optimize the code and probably slows it.
<aeth>
s/defclass has/defclass slots have/
<aeth>
So no reason why you could have a special allocation strategy afaik. It would just slow down redefinition. The inlining afaik would be the only part that can't be done, yes.
<aeth>
If that happened then a structure class is just a standard class with non-generic, inlinable accessors (not necessarily inline, could just have a constant ftype... I think in SBCL it's mostly or entirely the latter, but a similar result with the type inference).
<Bike>
without compiler support, slot access would have to box and unbox, so it would be slower.
<aeth>
Bike: good point
<aeth>
You'd need those inline or constant ftype accessors so you don't have to box if the thing doesn't leave the scope of the accessing function, so e.g. (defun foo (a) (declare ((simple-array double-float (1)) a)) (aref a 0)) is bad but (defun foo (a) (declare ((simple-array double-float (1)) a)) (setf (aref a 0) (1+ (aref a 0))) a) is OK
light2yellow has joined #lisp
bendersteed has quit [Quit: bye alls]
xuxuru has quit [Quit: xuxuru]
mn3m has joined #lisp
ym has quit [Quit: Leaving]
robotoad has quit [Quit: robotoad]
robotoad has joined #lisp
Balooga_ has joined #lisp
gravicappa has quit [Remote host closed the connection]
dueyfinster has quit [Quit: My iMac has gone to sleep. ZZZzzz…]
random-nick has quit [Read error: Connection reset by peer]
Achylles has quit [Ping timeout: 252 seconds]
jasmith has joined #lisp
mfiano[m] has joined #lisp
dented42 has joined #lisp
robotoad has quit [Quit: robotoad]
Oladon has quit [Quit: Leaving.]
josemanuel has quit [Quit: leaving]
v0|d has joined #lisp
robotoad has joined #lisp
Copenhagen_Bram has joined #lisp
Achylles has joined #lisp
Essadon has quit [Ping timeout: 272 seconds]
Essadon has joined #lisp
mn3m has quit [Remote host closed the connection]
light2yellow has quit [Quit: wake up forgiven]
Kevslinger has joined #lisp
Roy_Fokker has joined #lisp
Arcaelyx has joined #lisp
rtypo has joined #lisp
pjb has quit [Ping timeout: 252 seconds]
igemnace has quit [Ping timeout: 272 seconds]
eminhi has quit [Remote host closed the connection]
vaporatorius has quit [Ping timeout: 246 seconds]
robotoad has quit [Quit: robotoad]
GoldRin has joined #lisp
anewuser has quit [Quit: anewuser]
igemnace has joined #lisp
Essadon has quit [Ping timeout: 252 seconds]
frodef has quit [Ping timeout: 252 seconds]
varjag has quit [Ping timeout: 244 seconds]
dented42 has quit [Ping timeout: 252 seconds]
kajo has quit [Quit: From my rotting body, flowers shall grow and I am in them and that is eternity. -- E. M.]
kajo has joined #lisp
robotoad has joined #lisp
GoldRin has quit [Remote host closed the connection]
GoldRin has joined #lisp
Essadon has joined #lisp
Elon_Satoshi has joined #lisp
Copenhagen_Bram has quit [Ping timeout: 252 seconds]
igemnace has quit [Quit: WeeChat 2.2]
pjb has joined #lisp
Balooga_ has quit [Quit: Balooga_]
trittweiler has quit [Ping timeout: 252 seconds]
jinkies has joined #lisp
Josh_2 has quit [Remote host closed the connection]
Arcaelyx_ has joined #lisp
kajo has quit [Ping timeout: 260 seconds]
Arcaelyx has quit [Ping timeout: 240 seconds]
Balooga_ has joined #lisp
<LdBeth>
hello
<no-defun-allowed>
hi
Elon_Satoshi has quit [Quit: So long, and thanks for all the fish! 2.2 Weechat is best Weechat]
Copenhagen_Bram has joined #lisp
robotoad has quit [Quit: robotoad]
pjb has quit [Ping timeout: 252 seconds]
r1b has joined #lisp
GoldRin has quit [Ping timeout: 252 seconds]
graphene has quit [Remote host closed the connection]