<pierpa>
luckily, every CL implementation has a built-in disassembler! :)
<White_Flame>
yeah, disassembly is great to learn from, especially when it comes to performance, or simple curiosity of how things are implemented
<mega_beginner>
I'm a creature of great curiosity
<White_Flame>
I have a (asm (..params..) ..body..) macro which disassembles a lambda with optimizations cranked, just to see what SBCL can pull off
pagnol has quit [Ping timeout: 276 seconds]
fikka has quit [Ping timeout: 256 seconds]
pagnol has joined #lisp
<mega_beginner>
Next thing I'll have to read up on is incremental compilation, and how things are referenced in light of that technique (compiled to raw address label or hash table lookup for example). I have to leave though
<mega_beginner>
Thanks for another good discussion
mega_beginner has quit []
pjb` has joined #lisp
fyodost has joined #lisp
fikka has joined #lisp
pjb has quit [Ping timeout: 265 seconds]
pjb`` has joined #lisp
pjb` has quit [Ping timeout: 256 seconds]
fikka has quit [Ping timeout: 248 seconds]
orivej has quit [Ping timeout: 264 seconds]
Khisanth has quit [Ping timeout: 265 seconds]
pjb`` has quit [Ping timeout: 256 seconds]
edgar-rft has joined #lisp
rumbler31 has joined #lisp
JuanDaugherty has joined #lisp
pagnol has quit [Ping timeout: 256 seconds]
pagnol has joined #lisp
Axe_Yell__ has joined #lisp
Axe_Yell_ has quit [Remote host closed the connection]
rumbler31 has quit [Ping timeout: 276 seconds]
Oddity has joined #lisp
Axe_Yell__ has quit [Read error: Connection reset by peer]
Axe_Yell___ has joined #lisp
Guest30914 has quit [Quit: Leaving]
fikka has joined #lisp
uint has quit [Remote host closed the connection]
Axe_Yell___ has quit [Quit: El Psy Congroo.]
SlowJimmy has joined #lisp
fikka has quit [Ping timeout: 260 seconds]
dddddd has quit [Remote host closed the connection]
FreeBirdLjj has joined #lisp
fikka has joined #lisp
Khisanth has joined #lisp
pagnol has quit [Ping timeout: 264 seconds]
FreeBirdLjj has quit [Ping timeout: 264 seconds]
fikka has quit [Ping timeout: 264 seconds]
pagnol has joined #lisp
housel has quit [Read error: Connection reset by peer]
pagnol has quit [Ping timeout: 240 seconds]
pagnol has joined #lisp
Oladon has quit [Quit: Leaving.]
<epony>
White_Flame once you have an asm you're always on the hunt for asms
<epony>
flames look pretty feeble tonight
<epony>
now consider this, garbage free garbage processor
<epony>
looking for examples
<epony>
must be a time lapse..
Oladon has joined #lisp
fikka has joined #lisp
<aeth>
pillton: No. I was just saying that all that's missing from the CL library ecosystem.
<epony>
define ecosystem
<epony>
aeth did you read on the backlog?
fikka has quit [Ping timeout: 240 seconds]
himmAllRIght17 has joined #lisp
<aeth>
what part of the backlog?
<epony>
you're commenting on pillton
fikka has joined #lisp
<epony>
I'm interested at what point it starts getting "ecosystem" before other discussion points are closed.
<aeth>
makomo: Accessors aren't just methods defined by defclass automatically. They're anything with a reader and/or writer. CAR is an accessor and e.g. WITH-ACCESSORS should work with it.
<epony>
aeth what about view class?
<epony>
aeth you must consider an operation outside operative clause
fikka has quit [Ping timeout: 240 seconds]
<pillton>
aeth: Ok. The return type in specialization-store is needed to allow compile-time optimizations to occur when one store function is composed with another.
shifty has joined #lisp
pierpal has joined #lisp
<aeth>
pillton: My original point in full, which I didn't communicate well (but no one was really responding to it and I didn't want to flood the channel with corrections) is that there are effectively three incredibly similar operations.
<aeth>
pillton: It's pretty easy to write a macro on top of defun to handle things that otherwise would require declare/declaim/etc. At the very least, it's the easiest of the three to do.
<aeth>
Then there's type-generic, i.e. defspecialization.
<aeth>
The thing that's missing, then, is CLOS defmethod-style dispatch that's "completed" with inlining and with full support for keyword/optional
<aeth>
i.e. defspecialization, but for defmethod.
<pillton>
This is where I get lost. specialization-store supports dispatch on optional and keyword arguments.
karswell_ has joined #lisp
<epony>
a surgeon is called on an emergency, a relative is accepted in emergency in a different location
karswell has quit [Remote host closed the connection]
<epony>
operate or fail
fikka has joined #lisp
<epony>
you're never found... before you get lost
pierpal has quit [Ping timeout: 240 seconds]
<aeth>
pillton: I thought that defspecialization was not a replacement for defmethod, though?
<epony>
aeth what are the three operations?
<epony>
aeth you're a failure in logic.
<epony>
2.
<aeth>
epony: I don't understand a single thing that you are saying.
buffergn0me has joined #lisp
<epony>
aeth I see you say there are three ways to operate..
<aeth>
oh
<epony>
ohhh
<epony>
this backlog
<aeth>
epony: Three ways to do type-like things. function-with-types, type-dispatch, and class-dispatch.
<epony>
missing the word operate now?
<aeth>
Function-with-types can be done with type declarations where supported. Clumsy syntax, but you can make a macro handle it fairly easily.
<pillton>
aeth: It isn't because defmethod dispatches on class where specialization-store dispatches on type. Types cannot be ordered like classes so specialization-store cannot give the same guarantees during dispatch.
fikka has quit [Ping timeout: 268 seconds]
<epony>
aeth in case you're not comprehending, the operating relative is a common scenario
brendyn has joined #lisp
SlowJimmy has quit [Quit: good bye cruel world]
<epony>
pillton aeth solvent?
<epony>
ask and you shall be given
hph^ has quit [Ping timeout: 268 seconds]
<pierpa>
someone's drunk here?
<aeth>
Are you using Google Translate?
<epony>
nice
<epony>
now, back to basics, it is imperative that you accept a third operator in a linear clause
<pillton>
aeth: One could create a metaclass for specialization store which is only defined for types which are classes and dispatches according to CLOS' rules. The only difference between CLOS and specialization store is the way it handles initforms for optional and keyword arguments.
<epony>
meta bullshit
<pillton>
epony: Please go away if you aren't going to contribute.
<aeth>
epony: This is a technical channel. If you're using something like Google Translate, what we're saying is going to be lost in translation.
<mfiano>
Seems to be a bot, and not a very interesting one at that.
<aeth>
Words have very precise meanings here, some of which are specific to just Common Lisp as defined in the HyperSpec.
<epony>
mfiano a bot? you can do better than cat-v
<aeth>
mfiano: I'm not sure if epony is drunk/on-drugs, bot, using Google Translate, or crazy.
<aeth>
mfiano: but I think bot now
<mfiano>
/ignore epony
<mfiano>
solved
<epony>
mfiano now you don't have to hide your head when you get tapped on a gov tip
<aeth>
pillton: That can work?
<pillton>
aeth: What can?
<aeth>
pillton: Repurposing specialization-store for a defmethod* with inlining
<aeth>
I assumed it would have to be done through some MOP
<epony>
what a time waste..
<pillton>
aeth: Yes. Sure. The MOP for specialization store is very abstract.
<aeth>
s/with inlining/with inlining and improved handling of optional and keyword/
fikka has joined #lisp
<epony>
I'm curious, why do you respond so slow, aeth and pillton... if you're happy doing something else but thinking.
<pillton>
aeth: The major difference between CLOS and specialization is that the initforms are evaluated by the store function and are used to determine the specialization.
<pillton>
specialiation store*
skapata has quit [Remote host closed the connection]
<epony>
obviously I am pointing to a weak position and you are stuck on "if you don't contribute"
<epony>
I see a lunatic person trying to fence himself with circles above their head.
<aeth>
pillton: I base every vector function on an inline function on multiple values to simplify the definition of the specializations. I then wrote two macros to define the three common specialization patterns for the file (create a new vecn, replace the contents of a given vecn, or just directly work with the body because it's not returning a vecn)
<epony>
aeth cease and desist now.
<pillton>
aeth: Nice. I will have to look in to it. To see if anything can be added to my template-function system.
fikka has quit [Ping timeout: 264 seconds]
<aeth>
oh, there's two more pieces of information to understand that file. array-of-n is just a convenience function to either get multiple values from an array or replace an array with given multiple values (this composes rather nicely, except for the length having to be specified)
<aeth>
and define-function is just syntactic sugar over the declarations of defun to make specialization-store more of a drop-in replacement
<epony>
aeth syntactic sugar
<aeth>
I think it costs one line of assembly to do things this way (multiple values), but it makes the implementation so elegant and trivial that I went with it.
<epony>
assembly
<epony>
you went?
<epony>
one line of assembly
<epony>
aeth you must desist now.
<pillton>
aeth: Great. I designed specialization store for these kinds of problems. I am glad it is working out for you.
Oddity has quit [Ping timeout: 260 seconds]
quazimodo has joined #lisp
<epony>
pillton you can not revive him, he is dead.
<aeth>
pillton: Just to check because it's been a while, an inline inlines the whole thing (assuming type declarations are used), but a named specialization will be able to inline the function call (again assuming declarations), right? (Unless it's both named and inlined, in which case it's just like inline)
<epony>
aeth You can happily retire.
<epony>
aeth bots are not that hostile.
<epony>
aeth I see your middle school marks show up.
JuanDaugherty has quit [Quit: Exeunt]
Oddity has joined #lisp
<epony>
aeth ADMIT you're an ignorant MONKEY or you can NOT pass.
fikka has joined #lisp
* epony
reloads
<epony>
this is where it ends fellows suck mu jewish cock.
<epony>
LISP is a language not a text editor.
<pillton>
aeth: It doesn't inline the function call. It avoids the dispatch at runtime by replacing the store function call with a function invocation.
<epony>
You're wasting your time and not producing functions.
<aeth>
pillton: oh sorry, I guess I meant inline the function invocation? Or something
<epony>
one line of assembly pig.
<aeth>
pillton: it essentially puts the #<FDEFN FOO> there in the SBCL disassembly iirc
<epony>
aeth I think you're dead.
fikka has quit [Ping timeout: 248 seconds]
<mfiano>
pillton: This looks interesting.
<epony>
sure it dows
<mfiano>
It might solve my dispatching performance concerns for my math library. The last couple says I've been trying to write something with compiler macros and introspect-environment to solve that...looks like this is already a thing.
<mfiano>
I don't really understand it yet. I'll have to read the wiki later.
<mfiano>
Thanks
robotoad has quit [Quit: robotoad]
<epony>
mfiano one honest person
viaken has joined #lisp
<epony>
takes a whole to shake off the clowns
<epony>
a whole lot of while
<epony>
aeth hi there bafoon
fisxoj has joined #lisp
<epony>
don't get pissy pants
slyrus1 has quit [Quit: slyrus1]
<epony>
we have a lot more to discuss
housel has quit [Read error: Connection reset by peer]
<epony>
one line assembly, phew you're an effort..
<epony>
Could have stitched a chute from asspants
<epony>
no teardropt no nothing
smasta has joined #lisp
<epony>
and these people are the people that you trust commanding the future enterprise of corporate success
<epony>
It takes a one little nigga from kazah to smash that to pieces.
<epony>
Absurdly ridiculous.
<epony>
I feel sorry for you people.
<epony>
Can someone the fuck quote me a list principle?
robotoad has joined #lisp
rumbler31 has joined #lisp
<epony>
Primary directive 1?
<epony>
ARE YOU NOT ASHAMED OF THIS ALL?
<epony>
WHY DO YOU PAY FOR THIS?
<epony>
How can you communicate science when you live inside a bomb shelter.
fikka has joined #lisp
<epony>
Why the fuck you call "science" metrics data.
housel has joined #lisp
<epony>
I think you should be a BIT more cautious when you wave the word (ro)bot(nik).
<epony>
I am commanding you to operate on a prime directive of peace.
<epony>
You must and must always do as the prime directive says.
rumbler31 has quit [Ping timeout: 268 seconds]
<epony>
You must serve the prime directive to produce the directives.
<epony>
At this point the directive is to cease and desist.
fikka has quit [Ping timeout: 255 seconds]
jmsb has joined #lisp
<aeth>
pillton: Are any of your math projects public? I'd be interested to see something that uses specialization-store and/or template-function.
<epony>
hahaha
nostrovus has joined #lisp
pierpa has quit [Quit: Page closed]
al-damiri has quit [Quit: Connection closed for inactivity]
nostrovus has left #lisp [#lisp]
asarch has joined #lisp
gigetoo has quit [Ping timeout: 260 seconds]
__holden__ has quit [Ping timeout: 256 seconds]
fikka has joined #lisp
fisxoj has quit [Quit: fisxoj]
fikka has quit [Ping timeout: 256 seconds]
<beach>
Good morning everyone!
AetherWind has joined #lisp
<epony>
was
<epony>
respawning
igemnace has joined #lisp
<epony>
I don't know if the name was robert or david or ..
fikka has joined #lisp
<epony>
you are the person
pierpal has joined #lisp
<epony>
beach please let us have a quick talk, in a case of a third operative who do you victimise?
pierpal has quit [Client Quit]
pierpal has joined #lisp
<epony>
beach your turn.
shangul has joined #lisp
fikka has quit [Ping timeout: 248 seconds]
azimut has quit [Ping timeout: 256 seconds]
epony was kicked from #lisp by p_l [I'm tired and you appear to be at least drunk]
<p_l>
huh, that was quite a lot of spam
<p_l>
beach: 'morning
<beach>
I just /ignore d epony
<p_l>
I figured, but it's still disruptive behaviour from him
Beep-Lord has quit [Ping timeout: 240 seconds]
papachan has quit [Ping timeout: 276 seconds]
<p_l>
and well, I still have the operator bit, should use it from time to time
azimut has joined #lisp
<pillton>
aeth: No not yet. I started work on a matrix/container library which uses it. A lot of the effort there is to do with iterating over the elements.
fikka has joined #lisp
<pillton>
aeth: I haven't had much time to do anything since (i) the birth of my third child and (ii) I no longer use CL at work.
<aeth>
ah
fikka has quit [Ping timeout: 260 seconds]
pagnol_ has joined #lisp
<beach>
p_l: Absolutely.
pagnol has quit [Ping timeout: 240 seconds]
<aeth>
pillton: How did you use CL at work?
<pillton>
aeth: I work in computer vision / machine learning.
fikka has joined #lisp
<pillton>
aeth: It would be good to look in to partial specialization as an alternative to what we are doing.
FreeBirdLjj has joined #lisp
<pillton>
aeth: One aspect I like in template-function is the ability to request a specific specialization. It would be good if you could do this for arbitrary functions.
fikka has quit [Ping timeout: 240 seconds]
FreeBirdLjj has quit [Ping timeout: 240 seconds]
<aeth>
pillton: By partial specialization, do you mean this? ((v1 vec3) v2) instead of this? ((v1 vec3) (v2 vec3)) in e.g. vec= (which is probably where it would make the most sense), with e.g. an etypecase to handle the vec2, vec3, and vec4 cases in the specialization defined for v1 being vec3?
<pillton>
aeth: Yes. Something like, take this lambda and produce a new lambda which is optimized for arguments of this type.
<aeth>
(and the 3 would be one top-level form in my very specific case where I define all three at once)
fikka has joined #lisp
ym has quit [Remote host closed the connection]
ym has joined #lisp
<pillton>
Yeah. I think the problem with math is that the user has all of the information e.g. floating point precision, argument ranges etc. Specialization store still tries to go down the path of making the library provide everything.
proshlo has left #lisp ["ERC (IRC client for Emacs 26.1)"]
<aeth>
Ah, yeah, precision. I haven't gotten into that yet. Right now, I assume single-float. I'll have to double the types (dvec2, dvec3, and dvec4) for double float. The problem with doubles is that multiple-values no longer becomes an elegant simplification because they're boxed and cons unless they're already part of an array.
fikka has quit [Ping timeout: 276 seconds]
<aeth>
Where I do work with double-floats right now, I have to make sure they're in an array or typed struct slot and then if I return a scalar value, I coerce it to single-float first.
<aeth>
This would mess with the dot-product, but it's inline so the user probably has the same freedom to do that if they don't want to cons the result.
Beep-Lord has joined #lisp
<aeth>
I can see how precision can make specialization-store problematic. Now you need (dvec3 vec3) and (vec3 dvec3) versions for each consing function, making a total of 4 (the other two would be two vec3 and two dvec3). Worse, a destructive, non-consing vrsion needs dvec3 and vec3 *destination* vectors for at least the two mixed ones (total so far, 6) if not the other two (now, 8)
fikka has joined #lisp
smasta has quit [Quit: WeeChat 2.1]
<aeth>
So it goes from 2 versions (pure and destructive) to 4+8=12 versions if you can mix double and single precision vectors
<aeth>
e.g. (vec+-into! destination-vec3-or-dvec3 some-vec3-or-dvec3 another-vec3-or-dvec3)
<pillton>
This is the problem template-function tries to solve. You specify it once and generate the code on demand.
<pillton>
The compile time functionality of the iteration component of the matrix library I was talking about before is important as well.
fikka has quit [Ping timeout: 256 seconds]
<mfiano>
pillton: I just tested specialization-store. I'm not sure why it's so slow
<pillton>
You will have to be more specific.
<mfiano>
It seems to take 1s for 1 million iterations of a simple inlined specialization, whereas a non-inlined function with the same body takes about 0.2s
fikka has joined #lisp
doesthiswork has quit [Quit: Leaving.]
rumbler31 has joined #lisp
littlelisper has joined #lisp
<pillton>
I can't help if I can't see what you have done.
littlelisper has quit [Client Quit]
rumbler31 has quit [Ping timeout: 245 seconds]
fikka has quit [Ping timeout: 255 seconds]
Pixel_Outlaw has quit [Quit: Leaving]
fikka has joined #lisp
fikka has quit [Ping timeout: 265 seconds]
fikka has joined #lisp
orivej has joined #lisp
<aeth>
pillton: Would there be some way to make specialization-store aware of inferred types in SBCL?
fikka has quit [Ping timeout: 276 seconds]
buffergn0me has quit [Ping timeout: 268 seconds]
<pillton>
I don't know how SBCL infers types. I don't know the requirements of the type inferrer's transformations either.
fikka has joined #lisp
caltelt_ has joined #lisp
<MichaelRaskin>
beach: good morning
<beach>
Hello MichaelRaskin. Great progress it seems. Congratulations.
<asarch>
One stupid question: is defstruct a deprecated command (in flavor of defclass)?
<beach>
asarch: No, not in that sense of the word.
<beach>
asarch: But I never use it myself because of the weird semantics.
<aeth>
asarch: defstruct is, in my experience, useful for two things: (1) quickly defining accessors for a sequence (this is a special kind of defstruct) or (2) creating a data structure where :type for the slots is important.
<aeth>
Implementations don't really respect :type in CLOS slots. CCL is the only one in my testing that errors by default when you violate :type with a CLOS object. SBCL does so with (debug 3)
fikka has quit [Ping timeout: 268 seconds]
pierpal has quit [Quit: Poof]
<Beep-Lord>
/quit
pierpal has joined #lisp
Beep-Lord has left #lisp ["WeeChat 1.6"]
Bike has quit [Quit: Lost terminal]
<MichaelRaskin>
beach: yes, it seems that it basically has everything that is needed to declare it «implementation-side support for debugger». Except performance, probably.
<asarch>
Thank you!
* asarch
takes notes...
<beach>
MichaelRaskin: Performance might not matter much in such situations.
logicmoo has quit [Ping timeout: 264 seconds]
<MichaelRaskin>
Well, there are two sides of performance (time to walk/compile and time to run) and I have bad feelings about both, although it might still be better to have an option to step/trace than not to have it at all
uint has joined #lisp
<beach>
asarch: Presumably, the main advantage of structs is that the implementation can represent them more efficiently than it can represent standard objects, because standard objects require an indirection so that they can be redefined. However, that advantage is also the main disadvantage in a language such as Common Lisp, because existing instances may not be possible to update when the struct definition changes.
<beach>
asarch: And that's a major inconvenience for people who work with images that execute for a long time. For example, in SICL, the plan is to implement structure instances with an indirection header as well. As a consequence, structs in SICL will have neither the advantages nor the inconveniences of structs in other implementations.
<beach>
MichaelRaskin: I guess you need to do some benchmarks.
<beach>
Far from being finished, but close to being completely specified.
fyodost has quit [Read error: Connection reset by peer]
fikka has joined #lisp
<asarch>
Thank you very much guys :-)
<asarch>
Thank you
<makomo>
morning
<makomo>
aeth: i just saw your comment about CAR being an accessor as well and being able to use it with WITH-ACCESSORS. is that true though?
<makomo>
oh, nevermind, i misread the clhs
<beach>
makomo: That should work.
<beach>
WITH-ACCESSOR merely introduces local symbol macros that can then be used as aliases for calls to the accessors.
housel has quit [Remote host closed the connection]
fikka has quit [Ping timeout: 260 seconds]
<makomo>
beach: mhm, just saw the equivalent expansion in clhs. thought i saw WITH-SLOTS somewhere for some reason
<makomo>
so then the proper terminology for a CLOS accessor would be "slot accessor" or something similar?
<beach>
Oh, yes, I see. No, WITH-SLOTS won't work for CONSes
<beach>
Yes, slot accessor sounds right.
<aeth>
makomo: The only catch afaik is that the accessors for WITH-ACCESSORS have to be of the form (foo x). e.g. AREF is an accessor and can't be used with WITH-ACCESSORS in most cases. (0D arrays exist)
<makomo>
the clhs is a bit misleading though. the "syntax" part at the top talks about "slots" and "instances"
<beach>
Indeed.
<makomo>
aeth: i see
<makomo>
so now how can we be sure that the fact that CAR and others work with WITH-ACCESSOR isn't just a consequence of the implementation via SYMBOL-MACRO? :-)
<makomo>
beach: oh. i always read those parts at the bottom as "this is how it *might* be implemented"
fikka has joined #lisp
rumbler31 has joined #lisp
<makomo>
and also "any extra functionality that we accidentally added by using a "wider abstraction" is not to be relied on"
<beach>
makomo: Also, take not of good terminology. A CONS cell is definitely a CLOS object if there every was any definition of that term.
<aeth>
oh, hmm
<aeth>
Then the glossary is *very* confusing for me.
<beach>
makomo: If you want to distinguish an instance of a standard class from other instances, then the correct terminology is "standard object".
<makomo>
beach: ah, true
<makomo>
beach: when you say "standard class" and "standard object", are you referring to STANDARD-{CLASS,OBJECT} or are you just using the term casually?
rumbler31 has quit [Ping timeout: 268 seconds]
fikka has quit [Ping timeout: 268 seconds]
<makomo>
terms*
<beach>
makomo: The former.
gigetoo has joined #lisp
<makomo>
so then "instance" there refers to classes themselves, since they're object as well, right?
<makomo>
oibjects*
<makomo>
objects*
<beach>
makomo: But the terms "standard class" and "standard object" are also defined in the glossary.
<beach>
makomo: Sure, a standard class is a standard object as well.
<beach>
makomo: But most standard objects are not classes.
nickenchuggets has quit [Quit: Leaving]
caltelt_ has quit [Ping timeout: 256 seconds]
<beach>
makomo: Not that the expression "A is a B" means that "A is an instance of the class B", so "A is a standard object" means that A is an instance of the class STANDARD-OBJECT as the glossary explains.
<makomo>
beach: hah, the recursion. it's a bit scary :-)
<makomo>
beach: mhm
<beach>
makomo: It can be an instance of a subclass of STANDARD-OBJECT of course.
<beach>
The arrows show inheritance, and the colors show metaclasses.
milanj has quit [Quit: This computer has gone to sleep]
<makomo>
beach: the dashes boxes are MOP classes?
<makomo>
dashed*
<beach>
makomo: They are all MOP classes. The dashed ones are not meant to be instantiated.
<beach>
They are "abstract classes".
<makomo>
oh i see, right
asarch has quit [Quit: Leaving]
<makomo>
beach: but not all of these exist within the CLHS? for example, CLASS' precedence list doesn't contain SPECIALIZER
<beach>
Correct. The Common Lisp HyperSpec only specifies a subset of them.
<makomo>
mhm, so this is the full MOP hiearchy
<beach>
But the Common Lisp HyperSpec also explicitly allows intermediate classes in the precedence list.
<beach>
makomo: It is what is specified in the AMOP book.
<beach>
makomo: You will also need structure class, conditions, etc.
<makomo>
beach: yup, true
<makomo>
beach: is there a class which is its own superclass? is that even valid? i recall that an instance of a class can only be instantiated if all of its superclass classes are defined, but the class itself can be defined without the superclasses being defined yet -- i'm not sure if this in any way inhibits tricks like those?
<beach>
No, a class can not be its own superclass. The class hierarchy is a DAG.
<makomo>
because it's stuck in my head that i saw such a class somewhere, but i think it was just that i confused it with the first member of the class precedence list
<LdBeth>
STANDARD-CLASS?
<beach>
A class can be its own metaclass, though, like STANDARD-CLASS.
<makomo>
that might be it
<beach>
makomo: Yes, the class precedence list always starts with the class itself, by definition.
<makomo>
yup
<beach>
makomo: That does not mean that the class is its own superclass.
<makomo>
yes, of course :-)
fikka has joined #lisp
<beach>
LdBeth: The superclass of STANDARD-CLASS is usually CLASS.
Inline has quit [Quit: Leaving]
<makomo>
beach: huh, that isn't easy to think about. there are multiple meta layers here since STANDARD-CLASS itself is a metaclass right?
<beach>
Correct. You need to read the AMOP book to fully understand it.
<makomo>
definitely
<makomo>
but i think the biggest problems with stuff like that is just the recursivity
<makomo>
takes some time to get used to
<LdBeth>
and CLASS is a subclass of STANDARD-OBJECT
<beach>
But, think about it this way: Every object must be an instance of some class, and that includes classes. Therefor, there must be a cycle somewhere in the class->metaclass relation.
<makomo>
problem*
<makomo>
beach: yup, that's the spooky part :-)
<beach>
makomo: The way they decided to do that is that the metaclass of STANDARD-CLASS is STANDARD-CLASS.
<makomo>
beach: i see, so that's the core of cycle? are there any others?
<beach>
That's the only one.
<makomo>
hmm interesting
johnvonneumann has joined #lisp
johnvonneumann is now known as Guest22407
fikka has quit [Ping timeout: 245 seconds]
doesthiswork has joined #lisp
<makomo>
beach: there's a footnote in one of the early pages in the book that says that "self-referentiality is not essential to the basic notion of the metaobject protocol"
<makomo>
by "the basic notion", do they mean the availability of a meta interface, i.e. being able to customize the implementation itself?
<beach>
I would have to look that up. I don't know what "self-referentiality" is.
<makomo>
while the "self-referentiality/reflective" part is just a characteristic of how the meta interface itself is implemented?
<makomo>
page 7 in the book
<LdBeth>
'#1=(#1# . #1#)
<makomo>
beach: by self-referentiality i think they refer to the fact that objects within the system represents parts of the system that implements them
shangul has quit [Ping timeout: 265 seconds]
<makomo>
i.e. metaobjects
<beach>
That might be true. But the combination of the two rules 1. A class is also an instance of a class, and 2. Every class has a metaclass, then I think you automatically have a cycle.
<makomo>
represent*
<beach>
makomo: Yes, OK, so you can break one of those rules in other systems if you like.
<mfiano>
pillton: Yeah, specialization-store for _library_ math code seems useless to me, since types aren't known at compile time without users annotating them. I see the utility in the library, but I don't think there is any for me :)
<makomo>
beach: yeah i mean, perhaps you could invent some other way of customizing a CLOS that doesn't utilize CLOS itself
<beach>
What would be the fun of that? :)
orivej has quit [Ping timeout: 260 seconds]
<beach>
This way it is much simpler.
<beach>
You can use the same mechanisms that the application programmer uses in order to implement CLOS itself.
<makomo>
they later say, but i never understood this part, "In on-going work that extends the ideas presented in this book, we are adding a metaobject protocol to Scheme, but we are using CLOS (not Scheme) as the language for expressing adjustments, so issues of self-reference don't arise."
Guest22407 has quit [Remote host closed the connection]
<makomo>
beach: that i agree with that :-)
<makomo>
s/that/hah/
johnvonneumann_ has joined #lisp
fikka has joined #lisp
<makomo>
i don't get how they're using CLOS to customize Scheme, where's the connection?
<makomo>
or do they have a Scheme implementation written in CL?
<beach>
I am afraid I don't know.
<makomo>
that's their example of self-referentiality not being needed for a MOP
<beach>
Yes, I see.
<makomo>
although the word "metaobject" then loses its meaning, doesn't it? since the metainterface is now implemented in some other manner
<makomo>
you no longer have objects representing parts of the system that builds them
<makomo>
beach: also, the fact that AMOP uses CLOS itself while implementing CLOS can be a bit confusing sometimes, because you don't know whether MAKE-INSTANCE just refers to a function they haven't defined yet or to the MAKE-INSTANCE of the host CLOS
johnvonneumann__ has joined #lisp
johnvonneumann_ has quit [Read error: Connection reset by peer]
<makomo>
they've decided to go all out in the book :-)
johnvonneumann__ has quit [Remote host closed the connection]
fikka has quit [Ping timeout: 256 seconds]
<beach>
Sure, the term "metaobject" can be a bit confusing.
<beach>
makomo: The book kind of assumes that everything is already in place and works as expected. They do not discuss bootstrapping much at all.
<makomo>
beach: they mention some of it in Appendix C but that's all i think
<beach>
makomo: The PCL implementation (which is theirs too) kind of assumes a CLtL1 Common Lisp implementation and they add CLOS to that.
<beach>
Yeah.
<makomo>
that's the most interesting part :^(
<beach>
SICL, on the other hand does not start with a CLtL1. It assumes a fully conforming host implementation that also includes the MOP.
<makomo>
whew
fikka has joined #lisp
<beach>
That way, I can write (defclass t () () (:metaclass built-in-class))
<beach>
And (defclass standard-class (class) (...))
Smokitch has joined #lisp
jmsb has quit [Remote host closed the connection]
<beach>
Other implementations need a different notation for classes early in the bootstrapping process.
<makomo>
beach: very interesting
dmiles has quit [Read error: Connection reset by peer]
<makomo>
it's still not clear to me how you break free from the shackles of the CL implementation that's hosting you
<beach>
I use first-class global environments for that.
<makomo>
right, but those are a concept of SICL, not SBCL right?
<beach>
But they are implemented as standard classes, so I can load their definition into SBCL and use it.
<beach>
Then the compiler is written to that it takes such an environment as an argument.
<makomo>
beach: true, but SBCL itself can't use them right? the compiler you're talking about is SICL's compiler (written in CL as well)?
<beach>
This one of my favorites from other implementations (in this case ECL): (defparameter +standard-class-slots+ (append +class-slots+ '((optimize-slot-access) (forward))))
fikka has quit [Ping timeout: 265 seconds]
<beach>
makomo: Correct, SBCL can't use them.
<beach>
You are right.
<makomo>
beach: haha, that example is pretty neat
<beach>
Yeah, it's just a different notation for defclass. Go figure.
<beach>
I need to go. Monday mornings are crazy around here. I'll be back in two hours or so.
<makomo>
beach: alright, thanks for the answers :-)
fikka has joined #lisp
<pillton>
mfiano: I think you have misunderstood what I wrote.
<mfiano>
No I understand its uses.
dmiles has joined #lisp
fikka has quit [Ping timeout: 265 seconds]
gector has quit [Read error: Connection reset by peer]
gector has joined #lisp
flamebeard has joined #lisp
fikka has joined #lisp
shifty has quit [Ping timeout: 240 seconds]
buffergn0me has joined #lisp
Folkol_ has joined #lisp
igemnace has quit [Read error: Connection reset by peer]
shrdlu68 has joined #lisp
igemnace has joined #lisp
terpri has quit [Ping timeout: 260 seconds]
fikka has quit [Ping timeout: 260 seconds]
shka_ has joined #lisp
quazimodo has quit [Ping timeout: 240 seconds]
Oladon has quit [Quit: Leaving.]
fikka has joined #lisp
doesthiswork has quit [Quit: Leaving.]
fikka has quit [Ping timeout: 256 seconds]
fikka has joined #lisp
MichaelRaskin has quit [Quit: MichaelRaskin]
xificurC has joined #lisp
buffergn0me has quit [Ping timeout: 260 seconds]
EvW has joined #lisp
smasta has joined #lisp
fikka has quit [Ping timeout: 264 seconds]
shrdlu68 has quit [Ping timeout: 260 seconds]
vlatkoB has joined #lisp
shrdlu68 has joined #lisp
EvW has quit [Ping timeout: 240 seconds]
smasta has quit [Client Quit]
smasta has joined #lisp
MoziM has joined #lisp
shangul has joined #lisp
fikka has joined #lisp
shka_ has quit [Ping timeout: 260 seconds]
EvW has joined #lisp
fikka has quit [Ping timeout: 264 seconds]
EvW has quit [Ping timeout: 256 seconds]
* beach
is hoping the rest of the day will be less chaotic.
daniel-s has joined #lisp
MichaelRaskin has joined #lisp
<xificurC>
beach: isn't it like 10am there
<MichaelRaskin>
Yes, it is almost 10am in Bordeaux
<xificurC>
then there's plenty of time for the day to settle :)
Fredman97 has joined #lisp
verisimilitude has joined #lisp
schweers has joined #lisp
<verisimilitude>
I came to criticize some of your earlier advice, beach.
<verisimilitude>
You advise against using any package except for CL in a DEFPACKAGE.
<verisimilitude>
You're also the first I've ever seen give such bizarre advice.
fikka has joined #lisp
<verisimilitude>
I think it's self-evident why this is bad, but I'll explain; you claim that it opens you up to package interface changes; not only is this rather rare for a Common Lisp library, practically, but I fail to see how this is worth the horrible inconvenience when all that would be needed is to test the program against the latest version of a library, which is likely to be the last version, since the package likley hasn't been updated.
<beach>
verisimilitude: I am sorry you don't like my advice.
* xificurC
was apparently wrong
<verisimilitude>
I don't find it good practice to give advice on Common Lisp that amounts to ``Don't use this feature at all.''; it's not C++.
<beach>
xificurC: Heh!
<verisimilitude>
Do you care to defend this advice at all?
<beach>
Not really. It makes me tired to debate such things.
<beach>
I have said what I had to say.
<verisimilitude>
Well, that's boring.
<beach>
Yeah, I am pretty boring. Sorry about that.
<verisimilitude>
In that case, what would you like to discuss?
<xificurC>
just shows how incompetent beach is, can't even defend his own words, right verisimilitude?
<MichaelRaskin>
I would say in general the advice given by beach is often a bit idealistic. This reduce the usefulness of defending it against cynical crticism (obviously the library will never be updated anyway)
<MichaelRaskin>
reduces
<verisimilitude>
I don't know beach well enough to judge its competence.
fikka has quit [Ping timeout: 245 seconds]
<xificurC>
verisimilitude: you seem to know him enough to talk about him as an object
<xificurC>
"its competence"
<jackdaniel>
rule of he thumb is not engaging in discussions with people who plan to argue (for a sake of arguing)
<xificurC>
I hope Freud joins the channel do discuss that
<beach>
xificurC: "person" is a subclass of "object" :)
<xificurC>
hey, another boring one
<verisimilitude>
Well, some people get offended if you call people a male and get it wrong, even though I'd wager almost everyone here is.
<jackdaniel>
while many advices shared by people may be arguable, calling them plain wrong is, ekhm, wrong ;)
<xificurC>
jackdaniel: you're wrong!
<verisimilitude>
One dumbass here threatened me over a Rust joke, which was amusing, but stupid.
<jackdaniel>
either way, please refrain from offtopic
* xificurC
shuts his mouth and goes to write some code
<verisimilitude>
Anyway, I meant that many Common Lisp libraries are simply finished, MichaelRaskin.
shrdlu68 has quit [Remote host closed the connection]
shrdlu68 has joined #lisp
<White_Flame>
and if the interface changes, the compiler will whine anyway
Simedux has joined #lisp
<MichaelRaskin>
As the passive post-abandonment maintainer of cl-emb I would say that many libraries are finished enough to use but in the ideal world could see some more development.
<verisimilitude>
Anyway, if you really wanted to protect yourself, you'd simply use IMPORT-FROM or SHADOWING-IMPORT-FROM; either of those are better than using package qualifiers constantly.
<MichaelRaskin>
Not always better but not always worse, in my (cynical) opinion
fikka has joined #lisp
igemnace has quit [Remote host closed the connection]
<xificurC>
(defstruct image-info name path from tag) now (apply #'make-image-info info) turns a plist into a struct. Is there something prebuilt to do the reverse?
<verisimilitude>
You want to turn a struct into a property list?
<xificurC>
yes.
<xificurC>
or a class, doesn't matter, can change
<verisimilitude>
From memory, no, there's no default functionality for this, unless your struct is already represented as a list or vector, in which case it would be trivial to do.
<verisimilitude>
CLOS has no standard functionality for traversing all slots of an object, so no.
<xificurC>
not even MOP?
<verisimilitude>
YWhat you should do, xificurC, is define a macro that defines this for you, however.
hhdave has joined #lisp
<verisimilitude>
You can even shadow DEFSTRUCT or DEFCLASS to do this.
<xificurC>
yeah, I'll leap that far when it pays off
<xificurC>
not for 1 struct
<verisimilitude>
Well, just do it manually, then, yes.
dddddd has joined #lisp
varjag has joined #lisp
Cymew has joined #lisp
<flip214>
Well, I'm on beach's side here ... on both accounts (CL in DEFPACKAGE, and avoid discussions that feel senseless)
<verisimilitude>
Why, flip214?
<beach>
Thanks flip214.
<xificurC>
don't poke the bear
<beach>
flip214: Can we discuss the GC specification? Do you have time?
<verisimilitude>
I've pointed out several reasons why I believe the advice is poor; it would be nice to discuss why you disagree with these points.
<beach>
[that is something I would like to discuss]
<flip214>
verisimilitude: xificurC: at least SBCL has SB-PCL:CLASS-SLOTS and CLASS-DIRECT-SLOTS
<flip214>
beach: here, or in PM, or in some other channel?
<beach>
Here is fine if it is OK with you (and other participants).
<flip214>
verisimilitude: xificurC: and CLOSER-MOP has that too
<verisimilitude>
Well, ANSI Common Lisp doesn't, flip214.
<beach>
flip214: First question: Why do you think it would be a good idea to avoid nursery collections?
<verisimilitude>
So, you can't rely on it.
<beach>
flip214: They are not expensive and they would give a precise idea of what is live in the global heap.
<aeth>
Only (:use #:cl)? Of course. Everything else is asking for trouble with several possible exceptions: (1) alexandria and (2) stuff you yourself write. But I've been surprised by both from time to time.
kuribas has joined #lisp
fraya has joined #lisp
<kuribas>
how are sequence functions defined generically?
daniel-s has quit [Remote host closed the connection]
<verisimilitude>
I can't help but find it bothersome when a program uses this ALEXANDRIA for a single macro or so.
<beach>
kuribas: Most implementations would use ordinary functions and dispatch on the type of the sequence.
<beach>
kuribas: With an explicit type test.
<kuribas>
beach: so they are not extensible?
Fredman97 has quit [Read error: Connection reset by peer]
<verisimilitude>
They can use the more specific functions and a TYPECASE; it's handled by the implementation in any way, though.
<beach>
kuribas: They don't have to be according to the Common Lisp HyperSpec.
<aeth>
verisimilitude: I don't mind when libraries use alexandria and uiop because they're literally everywhere (and they have some name conflicts between them!)
<beach>
kuribas: But some implementations have a default case that invokes a generic function for types that are not in the Common Lisp HyperSpec. SBCL does that for instance.
<verisimilitude>
From memory, you can't define a subclass of a standard class, kuribas.
<flip214>
beach: because performance. everything that can be avoided gives better performance.
hph^ has joined #lisp
hph^ has quit [Max SendQ exceeded]
<beach>
verisimilitude: Sure you can. But not necessarily of a built-in class.
fraya has quit [Remote host closed the connection]
hph^ has joined #lisp
hph^ has quit [Max SendQ exceeded]
<flip214>
You'll need to forgive me, when thinking multithreading I'm nearly always thought-bound about the high-performance proxy stuff -- I can't seem to turn that off ;/
<beach>
flip214: I see. But I suspect performance would be worse if you avoid it, because then you would retain objects in the global heap that aren't really live.
<verisimilitude>
In that case, I'll doublecheck what I wrote, beach.
<kuribas>
beach: so to define your own sequence you have to define a class?
<kuribas>
data directed programming in common lisp is done with OO?
<beach>
flip214: Fair enough.
<beach>
flip214: Now some information for you: the header object IS the object, so when the header object does not move, the object does not move.
<beach>
flip214: However, in the global collector neither header nor rack moves.
<beach>
flip214: In the nursery they both do.
<flip214>
beach: I still feel that a purely IO-bound thread that does no allocations (because it's working with a reused buffer) doesn't need to do local GC, and neither needs to hold up the global GC.
<beach>
kuribas: That's typically the best option, yes.
kuribas has quit [Quit: ERC (IRC client for Emacs 24.5.1)]
<flip214>
beach: so in the nursery the objects identity changes?
<beach>
flip214: Yes, I see. I would have to think about that one. On the other hand, in that case, the GC will be very fast, because there is no compaction.
<beach>
Yes, they do.
kuribas has joined #lisp
<beach>
But since those objects are limited to the application thread, the pointers can be updated with no interaction with other threads.
<verisimilitude>
system class n. a class that may be of type built-in-class in a conforming implementation and hence cannot be inherited by classes defined by conforming programs.
<beach>
flip214: The other thing is that I suspect that global collections will be infrequent.
<verisimilitude>
SEQUENCE is a system class, so I was right.
<beach>
flip214: So most of the time, a nursery GC will happen because there is no more space in the nursery.
<beach>
flip214: Therefore GC can not be avoided anyway.
milanj has joined #lisp
<beach>
verisimilitude: No, you said "standard class".
nowhereman_ has quit [Read error: Connection reset by peer]
<verisimilitude>
Well, I meant the classes provided by the implementation
<verisimilitude>
.
nowhereman_ has joined #lisp
<beach>
verisimilitude: But that's not what "standard class" means.
<beach>
verisimilitude: Look in the glossary, "standard class" means an instance of STANDARD-CLASS.
edgar-rft has quit [Quit: edgar-rft]
<beach>
verisimilitude: Is that something you would like to debate?
<verisimilitude>
STANDARD-CLASS is also a system class.
terpri has joined #lisp
<verisimilitude>
Don't be a jackass, beach.
<verisimilitude>
We can deebate your own mistaken thoughts, first.
<jackdaniel>
please refrain from calling people names, *especially* when you are wrong
<jackdaniel>
scratch the second part, never call people names
<verisimilitude>
I usually do, jackdaniel, but I don't care for the lack of defending an idea in this case.
<verisimilitude>
Anyway, I should've written ``system'' instead of ``standard''; I was clearly wrong there.
<beach>
verisimilitude: "you can't define a subclass of a standard class" is just wrong.
<jackdaniel>
it is "just" class, which has a few subclasses (standard-class and built-in-class being that)
shrdlu68 has joined #lisp
<verisimilitude>
I am wrong; I meant to write ``system''.
<jackdaniel>
beach: assuming we count MOP as part of CL
<verisimilitude>
I don't.
random-nick has joined #lisp
Smokitch has quit [Ping timeout: 240 seconds]
<beach>
jackdaniel: I don't think we need to assume that.
<verisimilitude>
CLOS is the part of Common Lisp I use the least and have the least familiarity with.
<verisimilitude>
If an implementation isn't forced to provide it, it's not part of CL in a meaningful sense.
<verisimilitude>
It's a popular extension.
<verisimilitude>
So, I was correct then, jackdaniel?
<jackdaniel>
I don't know, I'd have to dig into the spec to confirm my pervious assertion (and honestly I don't have time for that)
Fredman97 has joined #lisp
<beach>
jackdaniel: For example, if you couldn't do that, then you could not define your own class hierarchy, because whenever you use DEFCLASS, you create a standard class.
<beach>
jackdaniel: Notice the difference between "a subclass of A standard class" and "a subclass of STANDARD-CLASS".
<jackdaniel>
beach: do you mean an instance of standard class? because there is a difference
<beach>
Yes, big difference.
<verisimilitude>
Since STANDARD-CLASS is a SYSTEM-CLASS, it seems like I'm right.
<verisimilitude>
Still, there's some other material I'm still reading to confirm.
<beach>
verisimilitude: Being right seems very important to you.
<beach>
I gave up on that many decades ago.
<verisimilitude>
Well, you feel free to that.
<verisimilitude>
I came here because I was bored, beach.
<jackdaniel>
so let me clarify: of course you can subclass a class being instance of a standard-class, I have doubts regarding subclassing standard-class itself without mop
<beach>
jackdaniel: That's different, sure.
<jackdaniel>
and while wording was sloppy, I think verisimilitude had the latter in mind
<beach>
jackdaniel: And yes, "a standard class" means "an instance of STANDARD-CLASS" which is what you get when you use DEFCLASS. That was the assertion, i.e. "you can't define a subclass of a standard class", where "a standard class" means "an instance of STANDARD-CLASS".
<beach>
jackdaniel: I don't think verisimilitude knows CLOS well enough to know the difference.
<verisimilitude>
I meant the class itself.
<verisimilitude>
This was in the context of SEQUENCE.
<jackdaniel>
sequence is a built-in class
<verisimilitude>
You can't subclass SEQUENCE at all.
<beach>
verisimilitude: No you did not, because we were talking about subclassing SEQUENCE.
<beach>
verisimilitude: SEQUENCE and STANDARD-CLASS are two different classes.
<verisimilitude>
SEQUENCE is a class, beach.
<jackdaniel>
and there is a extension (implemented at least in sbcl and abcl) which allows subclassing sequence
<jackdaniel>
verisimilitude: please look at the diagram I've linked
<xificurC>
one leaves for 10 minutes and the troll is winning
<jackdaniel>
sequence is a built-in class
<jackdaniel>
and standard-class is something else
Folkol_ has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<verisimilitude>
Being right seems important to you, beach, so I gladly admit that I was mostly wrong here, due to poor wording.
<verisimilitude>
Well, more poor writing on my part, then, jackdaniel.
<xificurC>
verisimilitude: you came to "discuss" because you were bored. Sounds like trolling to me
<verisimilitude>
It's so queer to me how different this venue is to those I'm accustomed to.
merodix has joined #lisp
<verisimilitude>
Why would you be on IRC if you weren't bored, for one.
<xificurC>
verisimilitude: I hope you're joking
smasta has quit [Ping timeout: 240 seconds]
<beach>
flip214: You are right that I have to be careful about the global GC protocol so that there aren't any racks that can not be reclaimed. I have not made up my mind yet. But one thing would be to not allow arbitrary interrupts and restrict them to safe points. That seems to be a pretty standard solution.
<verisimilitude>
No; most everywhere I typically go people are on IRC out of boredom.
<beach>
verisimilitude: Not here.
<beach>
verisimilitude: We have joint projects to discuss.
<xificurC>
verisimilitude: read the logs of this channel and think again
<verisimilitude>
Well, that's another interesting difference, then.
<verisimilitude>
So do the bored people.
<xificurC>
there's #lispcafe or w/e for pseudo-talks like this
<makomo>
"system class n. a class that may be of type built-in-class in a conforming implementation" and then also "System Class BUILT-IN-CLASS" -- does this mean that BUILT-IN-CLASS itself could be an instance of BUILT-IN-CLASS? :D
<verisimilitude>
I wasn't aware; I'll keep that in mind.
Fredman97 has quit [Quit: Leaving]
Fredman97 has joined #lisp
<beach>
flip214: Regarding race condition in the nursery collector, I don't think there are any. The bit would be set at the beginning of the GC, or not at all. But yes, there may be a mostly no-op GC following it if the global collection is then triggeredd.
<beach>
triggered.
<beach>
flip214: Again, I am hoping a global collection will be fairly infrequent.
<beach>
makomo: No, BUILT-IN class is a standard class, i.e. an instance of STANDARD-CLASS.
<makomo>
hmm, but it does have STANDARD-OBJECT as its superclass
<beach>
makomo: OK, fine. It's a standard class in the MOP.
<xificurC>
why does one need to use return in the finally clause of LOOP?
<beach>
xificurC: Because LOOP returns NIL by default.
<beach>
Why does it do that? I have no idea.
<xificurC>
beach: haha, ok
<loke>
beach: What else would it return?
Folkol_ has joined #lisp
<xificurC>
it's not finally if it's not, ehm, final
<verisimilitude>
It could return a collected value.
<beach>
loke: Yeah, good point.
<loke>
beach: I mean, LOOP returns the “reasonable”“ value, as in the list when you use COLLECT, etc.
<xificurC>
loke: the result of the finally clause?
<beach>
loke: Indeed.
<makomo>
^^
<verisimilitude>
That is, listing some other things LOOP can return other than NIL.
<loke>
xificurC: Because that would conflict with the use of COLLECT
<makomo>
loke: add a rule that would say that if there are both COLLECT and FINALLY, then the result of COLLECT will be returned :-)
<verisimilitude>
On that topic, I never use keywords when using LOOP; what of you all?
<beach>
flip214: I think I will allow for objects to be directly allocated in the global heap, and FFI buffers could be one such possibility.
<jackdaniel>
makomo: having something "as superclass" and having something "as metaclass" are two different things
<loke>
makomo: Sure. There is certainly a justifable argument for that. However, that's not what they settled on and now the spec is what it is :-)
<makomo>
loke: indeed :D
<jackdaniel>
built-in-class is a subclass of class (same as standard-class), but its metaclass is standard-class
<xificurC>
loke: you mean like (loop for i from 1 to 10 collect i finally (1+ i)) you expect the collected value to be returned? (which does happen)
<verisimilitude>
This (LOOP FOR I FROM 0 TO 10 COLLECTING I) looks much better than (LOOP :FOR I :FROM 0 :TO 10 :COLLECTING I), I think.
<makomo>
jackdaniel: right, but i was getting at the fact that instances of STANDARD-CLASS always have STANDARD-OBJECT as their superclasses
drot has joined #lisp
<makomo>
i.e. since it has STANDARD-OBJECT as its superclass, its metaclass must be STANDARD-CLASS
<beach>
jackdaniel: The question, though, would be that, since built-in-class is a system class, could there be some other possibility than for it to be a standard class.
<makomo>
exactly
<loke>
verisimilitude: Agreed
<loke>
verisimilitude: The arguments for using keywords are all stupid
<verisimilitude>
It just complicates LOOP further to permit it, as well.
<makomo>
the glossary says that "system class" is "a class that may be of type built-in-class"
<xificurC>
loke: what about (loop for i from 1 to 10 collect i into one collect i into two finally (1+ i))
<flip214>
beach: sorry about the delay, had to answer the door.
<makomo>
and built-in-class itself is a system class
<beach>
flip214: No problem, I am just submitting stuff for you in the meantime. If you are busy, that's fine.
<xificurC>
loke: you have to write e.g. finally (return (list one two)) whereas it's kind of obvious what you are about to return
<flip214>
if the object headers are of a fixed size, you might not need to compact them - just create a singly-linked list of free elements during GC, so identity is preserved and no pointers need updating.
orivej has joined #lisp
<makomo>
verisimilitude: i always use keywords. it looks much nicer to me
<makomo>
and you can clearly see the distinction between LOOP's special symbols and the user's stuff
<flip214>
with a fixed size (and that being a nice round 2 words!) there'll be no waste anyway
<verisimilitude>
That's one advantage, I suppose.
<beach>
flip214: [this is another one of your remarks] I think by using a single word for the bits, and by using CAS, I get atomic operations.
<beach>
flip214: I do want to compact the nurseary.
<beach>
flip214: That's how I keep track of exact age of objects. They are sorted by age.
<jackdaniel>
I can't think of any, all metaobjects inherit from standard-object
<flip214>
ah, okay. I forgot. (sorted by age)
<beach>
flip214: That way, I don't run the risk of promoting objects that were just allocated, and then immediately survived a GC, which is a problem with other collectors.
eMBee has joined #lisp
<flip214>
yeah, I understand the atomic bit-changes here. Just feels a bit complicated, my mind doesn't see the need for anything but a simple "owner-thread" lock yet.
<beach>
flip214: But I take advantage of that in the global collector so that objects won't move there, avoiding communication between threads.
<beach>
flip214: concurrency is not my strong point. I am counting on loke to help me out here.
<makomo>
jackdaniel: i'm only asking if it's *possible* for BUILT-IN-CLASS to be an instance of BUILT-IN-CLASS (like STANDARD-CLASS is an instance of STANDARD-CLASS)
<makomo>
jackdaniel: you said that BUILT-IN-CLASS' metaclass is STANDARD-CLASS -- is this stated in the MOP?
<beach>
flip214: I think a semaphore and a lock are still different. A semaphore can be signaled by a thread that didn't wait on it.
<beach>
makomo: It would be weird, and I haven't thought about such possibilities.
<jackdaniel>
makomo: standard-object is an instance of standard-class by definition
<makomo>
beach: heheh, semaphores and locks :-)
<beach>
Yeah. :)
<jackdaniel>
makomo: so if built-in-class inherits from standard-object, it is also sa standard-class
<makomo>
beach: yeah i guess, but i'm just curious
<beach>
jackdaniel: I am not sure that follows.
<makomo>
jackdaniel: that's what i thought too when beach told me its metaclass is STANDARD-CLASS
<makomo>
i.e. i used the reverse logic "its superclass is STANDARD-OBJECT, so its metaclass must be STANDARD-CLASS"
<beach>
Yeah, I don't think that is correct logic.
<Xof>
that's definitely not true
<Xof>
standard-generic-function is a counterexample
<jackdaniel>
either way, that has no practical implications for my programs, so I'm not interesting in diving deeper into closology
<makomo>
but the CLHS says that it is a "system class" which means its metaclass *might* be BUILT-IN-CLASS
<makomo>
Xof: i don't see that STANDARD-GENERIC-FUNCTION has SYSTEM-OBJECT as its superclass
<makomo>
and it's also listed as a "system class" within clhs
<jackdaniel>
makomo: funcallable-standard-object exists only in MOP, and it inherits from function and standard-object
<jackdaniel>
and it is a transitive superclass for standard-generic-function
<makomo>
jackdaniel: i see, so within the context of MOP, STANDARD-GENERIC-FUNCTION *does* have STANDARD-OBJECT as its superclass then?
<jackdaniel>
yes
<makomo>
and i presume its metaclass is STANDARD-CLASS then?
<jackdaniel>
according to Xof's assertion it is not, but I'd check in MOP if I were you
<makomo>
Xof: ah, so you were talking in the context of MOP as well?
<jackdaniel>
but once again, I'm detaching from this MOP discussion
<makomo>
jackdaniel: you've said that 2-3 times already, obviously you're interested :D
<jackdaniel>
no, I'm just a very bad quitter
<makomo>
haha
<Xof>
standard-generic-function has standard-object in its superclass list and has metaclass funcallable-standard-class
<makomo>
Xof: ah i see
<makomo>
but BUILT-IN-CLASS' metaclass is indeed STANDARD-CLASS as beach said, within the context of MOP
<jackdaniel>
yes, but not for the reason I've suggested
Smokitch has joined #lisp
<makomo>
i guess that's why clhs says "might" in the definition of "system class" -- it might be something else, like STANDARD-CLASS as the MOP says
<makomo>
jackdaniel: yup
<makomo>
but if we threw away the MOP, which is "just" an extension anyway, then BUILT-IN-CLASS could perhaps be its own metaclass, like STANDARD-CLASS is
<makomo>
heh, but the fact that STANDARD-CLASS is its own metaclass is due to the MOP. clhs says that STANDARD-CLASS is a system class as well ;-)
* jackdaniel
whispers (because it is a heresy) one could say that clos+mop may be a bit overengineered
<makomo>
trust the natural recursion :^)
m00natic has joined #lisp
<flip214>
beach: a lock that gets unlocked will restart the thread waiting for the lock as well ;)
<LdBeth>
MOP is an option, not a requirement
<beach>
flip214: I need to think about it. Anyway, thanks for your thorough comments, as usual.
<flip214>
beach: you're _really_ welcome!
Folkol_ has quit [Ping timeout: 260 seconds]
fikka has quit [Ping timeout: 240 seconds]
_cosmonaut_ has joined #lisp
fikka has joined #lisp
m3tti has joined #lisp
quazimodo has joined #lisp
<MichaelRaskin>
beach: by the way, I have a feeling that compile performance impact of my debugger hooks is worse than runtime. I would say 30x to 70x for compile time (mostly the actual compilation of all the hook calls) and 30x to 40x for runtime with callbacks that do nothing
<beach>
MichaelRaskin: That's interesting. Though the orders of magnitude are similar.
chens has joined #lisp
<beach>
Xof: You are a smart person. Would you have time to take a quick look at my GC specification to determine whether it has some obvious flaws?
<MichaelRaskin>
And that's after I stopped wrapping single variable reads
<beach>
Xof: I fully understand if the answer is "no".
<beach>
MichaelRaskin: Wow, that's some overhead.
<MichaelRaskin>
Yes, especially for compilation, as I need a let to be able to have a breakpoint just-after a form with its result known…
lumm has joined #lisp
Smokitch_ has joined #lisp
Smokitch has quit [Read error: Connection reset by peer]
Smokitch_ is now known as Smokitch
<MichaelRaskin>
beach: maybe that hook for faster rejection of irrelevant callbacks is not worth it when it is overridable (and it costs code size)
<beach>
Hard to tell.
<MichaelRaskin>
Well, I would say that 50x compile time is actually horrible
<beach>
It could become very slow.
housel has joined #lisp
<MichaelRaskin>
Not really: even if it accepts nothing it doesn't save that much compared to callback that always starts (and gets the data) and never does anything.
<MichaelRaskin>
So the main callback can filter just as well
<beach>
OK.
guaqua has quit [Ping timeout: 265 seconds]
<MichaelRaskin>
30x is a lot of slowdown to fit a few calls
scymtym has quit [Ping timeout: 256 seconds]
Kaisyu has quit [Quit: Connection closed for inactivity]
<Xof>
beach: time :-(
<Xof>
Thank you for the vote of confidence, though!
<beach>
Xof: Sure. No problem.
<Xof>
I might have time mid-July or later
<beach>
I'll take it. :)
<beach>
Seriously, don't worry.
<beach>
Xof: I thought you must be bored, since you are on IRC. :)
<beach>
Though of course, in our job it is not unusual to be simultaneously overworked and bored.
<Xof>
I'm multitasking!
<Xof>
I'm in teaching demos for our new staff recruitment round
<Xof>
therefore, I have to pretend to be a student
<Xof>
so, being on Social Media while someone is trying to teach me something I don't care about very much :-)
margeas has joined #lisp
guaqua has joined #lisp
vlatkoB_ has joined #lisp
vlatkoB has quit [Ping timeout: 256 seconds]
Folkol_ has joined #lisp
kuribas has quit [Quit: ERC (IRC client for Emacs 24.5.1)]
verisimilitude has quit [Quit: ERC Version 5.3 (IRC client for Emacs)]
<beach>
Sounds bad.
chens has quit [Remote host closed the connection]
Patternmaster has quit [Ping timeout: 240 seconds]
AetherWind has quit [Quit: Leaving]
<shka>
lparallel:psort keeps exhausting stack space for me
<shka>
am I doing something wrong?
Patternmaster has joined #lisp
<shka>
it kinda looks like recursive implementation of merge sort that went wrong
<beach>
shka: Is it your implementation?
<shka>
no, it is from otherwise excelent lparallel
<beach>
Merge sort should only use logarithmic space on the stack.
<shka>
well, it should
<beach>
So even if you sort a very large data set, the stack space should be modest.
<shka>
i will check lparallel source code
sakalli has quit [Ping timeout: 265 seconds]
<shka>
beach: odly enough it is not even merge sort to begin with
<beach>
That could very well explain it.
<shka>
it is quicksort
<shka>
but at least i think i know how can i bypass the issue
<beach>
Quicksort has a very bad case where it takes up linear stack space if you do it recursively, and quadratic time.
<shka>
that's exactly what lparallel is doing :/
<beach>
That is why I suggested the merge sort project the other day.
<shka>
well, ok, i see exactly what you meant
<beach>
What are you sorting? A list or a vector?
<shka>
vector, obviously
<Xof>
~>
<Xof>
oops
<shka>
Xof: :-)
<Xof>
luckily that wasn't my passwor
<Xof>
d
<shka>
happend to me the other day
<shka>
anyway, i will simply write my own parallel sort
<shka>
... or not
<shka>
sort does not accept :start and :end arguments
<shka>
what a shame
Fredman97 has quit [Ping timeout: 255 seconds]
<shka>
beach: well, i guess that this project become whole more attractive to me :P
<beach>
Heh!
<shka>
also, sort seriously should accept bounds key arguments
<MichaelRaskin>
Well, for sorting lists it makes less sense
<shka>
sorting large list is not a good idea to begin with!
<schweers>
shka: if my memory serves me correctly, sorting lists is faster than sorting vectors in sbcl.
<MichaelRaskin>
Well, actually merge sort on large lists is pretty OK
<schweers>
s/in/on/
<MichaelRaskin>
I think for large lists sorting pre-sorted list is slower than sorting a reverse-sorted list in SBCL
<shka>
schweers: that would be surprising
<schweers>
I know, I was surprised
<schweers>
best check it, my memory has a hisory of performing badly.
<shka>
not today
<shka>
list size overhead is not acceptable for my dataset
lumm has quit [Ping timeout: 245 seconds]
<beach>
shka: Then you are between a rock and a hard spot.
Folkol_ has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<beach>
shka: Either you use quicksort and you have that bad worst case.
<beach>
shka: Or else you use merge sort which requires O(n) extra space, so the same as a list.
<beach>
... unless, of course, you take on the project I suggested.
<shka>
beach: i can use sort from sbcl, it will work just fine but just takes more time
<beach>
OK.
<shka>
but yes, i see appeal of this project
<shka>
i won't be able to tackle this for two weeks
pagnol_ has quit [Ping timeout: 240 seconds]
<shka>
or 3
<schweers>
beach: did you suggest that quicksort can be implemented without recursion? Am I missing something really obvious?
<shka>
but if i can put it into lparallel, it would be great
<beach>
schweers: I don't know whether I suggested that. But I am pretty sure it can.
<schweers>
beach: I mean this quote: “<beach> Quicksort has a very bad case where it takes up linear stack space if
<schweers>
you do it recursively, and quadratic time.”
rumbler31 has joined #lisp
<MichaelRaskin>
Well, you can always replace recursion with a loop with your own fully controlled stack data structure
<schweers>
By without recursion you mean using some alternate stack?
<beach>
schweers: Yes, I see. I didn't think to hard about it.
<MichaelRaskin>
Well, worst-case quicksort is just quadratic-time in any case.
<beach>
schweers: One easy way would be to recurse on the shorter of the two parts, and iterate on the other.
<MichaelRaskin>
You might be able to keep it logarithmic-stack with tail-call-optimisations (easy if you roll your own stack control)
<beach>
That would keep it logarithmic.
<beach>
MichaelRaskin: Or you can just implement it as iteration.
EvW1 has joined #lisp
light2yellow has joined #lisp
<Xof>
worst-case quicksort is n log n time
<Xof>
(fun fact!)
<beach>
Define "quicksort" then. :)
<Xof>
quicksort, choosing the median as pivot
milanj has quit [Quit: This computer has gone to sleep]
<beach>
That's now how I have seen it described. I have always seen it as choosing an arbitrary pivot.
<MichaelRaskin>
Xof: think of the children^W constants!
<Xof>
MichaelRaskin: yeah, "not generally used in practice" :-)
MichaelRaskin has quit [Ping timeout: 268 seconds]
MichaelRaskin has joined #lisp
Folkol_ has joined #lisp
<MichaelRaskin>
If only you could reuse some of the work for finding later medians…
<MichaelRaskin>
But it is easier to do heap sort. No extra space, no worst case gotchas.
<beach>
No problem. You can start by sorting the entire vector.
<Xof>
:-)
Ukari has quit [Read error: Connection reset by peer]
<MichaelRaskin>
By heapsort
<shka>
i heared you like sorting
<shka>
so in order to sort you have to first sort
rtt has joined #lisp
<beach>
I maintain my suggested project using merge sort with O(1) extra space if there is no stack space available.
<shka>
i makes a lot of sense
<shka>
the only drawback is that you need to have separate code for each implementation
<beach>
MichaelRaskin: Fast Stable Merging and Sorting in Constant Extra Space, by Bing-Chao Huang and Michael A. Langston.
<MichaelRaskin>
Yes, already found it
<beach>
MichaelRaskin: Practical In-place Mergesort by Jyrki Katajainen, tomi Pasanen, Jukka Teuhola.
<beach>
MichaelRaskin: But my suggested project has the same twist as some previous papers of ours. Namely use the stack if there is space.
<beach>
Because I suspect that those algorithms are not as fast as standard merge sort.
<MichaelRaskin>
That's true.
<MichaelRaskin>
But using stack doesn't buy you _that_ much compared to strategic one-time allocation anyway
<beach>
Wow, the more I think about it, the more preposterous I find the idea of coming to IRC because of boredom.
<MichaelRaskin>
(if you allocate the same amount as you were going to put on stack)
<beach>
MichaelRaskin: Sure, but you would have to know that you have that much memory available in the heap, and you many not have.
<beach>
Especially if you sort big vectors.
<TMA>
beach: that's just O(1) space merge; you still need to keep track what subsequence are you trying to merge, and as there are O(N) subsequences at the tails, you need O(logN) bits of storage to remember which subsequence you are merging
<beach>
TMA: I don't remember the details, but what you are saying seems to contradict the results of both those papers.
<MichaelRaskin>
I think the real answer is we want O(1) cells, and a call is always more than log n bits
<MichaelRaskin>
a cell
<beach>
TMA: But I think O(log n) bits would be quite reasonable in practice.
<TMA>
beach: I think I have read at least one of them. they are not concened with the recursive subdivision and recombination that takes O(logN) space but only with the merge step, which ordinarily takes O(N) space but they brought it down to O(1)
<beach>
TMA: Interesting.
<beach>
TMA: If I ever take up that project, I'll definitely read those papers with what you are saying in mind.
<MichaelRaskin>
That part is actually easy to bring down to O(1) if you are single-threaded
rumbler31 has quit [Remote host closed the connection]
<MichaelRaskin>
Because for merging you can enumerate the needed merges in advance without any care for data contents
<beach>
Personally, I am less interested in the theoretical result than in an implementation that is fast for most cases and uses little space when it has to.
<TMA>
the other twist might be that they might be using the convention that pointer size is O(1) irrespective of N
<MichaelRaskin>
That is definitely so
MoziM has quit [Ping timeout: 256 seconds]
<beach>
I think I would have done that.
<MichaelRaskin>
Because you are about allocating O(1) extra records. And integers are usually pointer-length etc.
MoziM has joined #lisp
<TMA>
[that is wrong from the theoretical standpoint ... you cannot store the number of elements in less than O(log_2(N)) bits ... although you can do away with O(1) with the additional requirement that N < 2^k (because O(k) = O(1))
<TMA>
]
<MichaelRaskin>
TMA: there is more than one theoretical model used for complexity definitions, though
Murii has quit [Read error: Connection reset by peer]
milanj has joined #lisp
<MichaelRaskin>
I am not sure making a stable heapsort is a worse idea than implementing the constant-space merges
<TMA>
if I can assume N < 2^128, I can keep track of the 'subsequence to merge next' in one pointer of 128 bits and one level indicator of 7 bits ... <2^32 its 32 bits and 5 bits ... for practical purposes (finite universe) those are both O(1), but ... :)
travv0 has quit [Quit: Connection closed for inactivity]
<beach>
MichaelRaskin: Do you know how to make a stable heapsort?
<MichaelRaskin>
I think I have a few ideas that should work, but I haven't verified I don't miss something
shangul has quit [Ping timeout: 264 seconds]
Murii has joined #lisp
shangul has joined #lisp
nowhereman_ has quit [Ping timeout: 260 seconds]
<beach>
MichaelRaskin: Also, merge sort is chosen because it divides the sequence in two, each with the same number of elements. So the constant time overhead is minimized. I don't see how heapsort can be guaranteed to have such good behavior.
<MichaelRaskin>
Well, the constants are of course a bit worse than merge sort, especially merge sort with extra memory available
<beach>
OK.
Folkol_ has joined #lisp
pagnol_ has joined #lisp
Fredman has joined #lisp
<shka>
An mprotect call failed with ENOMEM. This probably means that the maximum amount
<shka>
grrrrr
<shka>
you are making me mad sbcl!
Fredman97 has quit [Ping timeout: 240 seconds]
jkordani has joined #lisp
pierpal has quit [Read error: Connection reset by peer]
pierpal has joined #lisp
loli has joined #lisp
nowhereman_ has joined #lisp
mejja has joined #lisp
Bike has joined #lisp
fikka has quit [Ping timeout: 264 seconds]
doesthiswork has joined #lisp
karswell_ has quit [Read error: Connection reset by peer]
karswell_ has joined #lisp
fikka has joined #lisp
housel has quit [Remote host closed the connection]
sakalli has joined #lisp
fikka has quit [Ping timeout: 264 seconds]
pierpal has quit [Ping timeout: 264 seconds]
housel has joined #lisp
Ukari has joined #lisp
pfdietz_ has quit []
sjl has quit [Quit: WeeChat 2.1]
hph^ has quit [Ping timeout: 248 seconds]
fikka has joined #lisp
sjl has joined #lisp
xrash has joined #lisp
fikka has quit [Ping timeout: 248 seconds]
warweasle has joined #lisp
scymtym has joined #lisp
trittweiler has joined #lisp
dyelar has joined #lisp
fikka has joined #lisp
rtt has quit [Quit: WeeChat 2.0.1]
shifty has joined #lisp
Inline has joined #lisp
eli_oat has joined #lisp
light2yellow has quit [Quit: light2yellow]
igemnace has joined #lisp
Satou has joined #lisp
FreeBirdLjj has joined #lisp
kuwze has joined #lisp
<Satou>
Does anyone here use Drakma for http requests? I cannot seem to be able to find a way to send a file through POST
<MichaelRaskin>
I think :parameters '(("upload" . #p"/tmp/file.txt")) worked for me last time when I tried.
<Satou>
Right now I use :parameters `(("file" . ,filepath)) which the filepath gets passed through as a function argument. Thanks MichaelRaskin, I'm going to try that
<MichaelRaskin>
You might want (truename filepath)
<MichaelRaskin>
Drakma documentation also provides some advanced options
<Myon>
(this is already after updating build-app and cl-asdf to what's in Debian unstable, where it works)
<Myon>
svillemot: ^
eli_oat has quit [Quit: Leaving.]
<Satou>
MichaelRaskin, Well, it's seems I'm making some progress, but I cannot use yason to parse the output of that (my goal is to make an IPFS API client in CL)
<Satou>
Here's an example, but I cannot seem to be able to use yason:parse on the flexi-stream it returns afterwards. I get a #\F fell through ECASE exception
<schweers>
I have a package question: I have a package #:FOO which :USEs a package #:BAR. I want to change this fact [i.e. #:FOO should no longer :USE #:BAR]. Any tips on how to do this without restarting the lisp?
<lieven>
UNUSE-PACKAGE
karswell_ has quit [Ping timeout: 240 seconds]
<schweers>
lieven: thank you very much, that was exactly what I was looking for!
flamebeard has quit []
koenig has quit [Ping timeout: 240 seconds]
<Xach>
such an obscure name!!!
<Bike>
eternally-disuse-package
<lieven>
yeah it should have been something like ROBSTCK in the old Lisp naming tradition
koenig has joined #lisp
<jackdaniel>
I like the ROBSTCK name, thanks for the idea ;)
<svillemot>
Myon: it's not obvious at first glance, and I don't have the time to investigate now, sorry
orivej has quit [Ping timeout: 264 seconds]
mindCrime has joined #lisp
nowhereman_ has quit [Ping timeout: 256 seconds]
nowhere_man has joined #lisp
EvW has quit [Ping timeout: 265 seconds]
EvW has joined #lisp
varjag has quit [Quit: ERC (IRC client for Emacs 24.5.1)]
eli_oat has quit [Quit: Leaving.]
shrdlu68 has quit [Ping timeout: 268 seconds]
shrdlu68 has joined #lisp
comborico1611 has joined #lisp
kajo has joined #lisp
pagnol_ has quit [Ping timeout: 256 seconds]
mangul has joined #lisp
<MichaelRaskin>
Satou: I think it formats the flexi-stream object and tries to parse that
pierpal has joined #lisp
<Satou>
any way to work around that?
skapata has joined #lisp
shangul has quit [Ping timeout: 260 seconds]
<MichaelRaskin>
Try reading data yourself, outputting it and also feeding it to yason as a string
<Satou>
so, no flexi streams for that (sorry, I'm pretty new to CL)
Folkol_ has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
eli_oat has joined #lisp
<Satou>
I've set drakma's header-stream to *standard-output*. What it returns is a bad request (400)
shrdlu68 has quit [Ping timeout: 256 seconds]
FreeBirdLjj has quit [Remote host closed the connection]
Folkol_ has joined #lisp
shrdlu68 has joined #lisp
<oni-on-ion>
check with curl ?
<Satou>
cl-curl oni-on-ion ?
<oni-on-ion>
command line curl; bad request (400) is from the server.
smurfrobot has quit [Remote host closed the connection]
<Satou>
command line curl works, I belive I'm not querying the API properly with drakma.
<oni-on-ion>
hmm
<Satou>
I have a PHP version of what I want to do
<MichaelRaskin>
Satou: no, no headers-stream
eli_oat has quit [Quit: Leaving.]
<Satou>
why not? that's just for me to know if the request was successfull
<MichaelRaskin>
I would start with force-binary instead of want-stream.
scymtym has quit [Read error: Connection reset by peer]
<Satou>
thanks, I'm gonna take a look at it
<MichaelRaskin>
Then Just parse the octet array with babel or trivial-utf8
<MichaelRaskin>
Also, print _all_ the return values from http-request to see server headers
<Satou>
I have to go for now, but I'll be back in a few hours. Thank you MichaelRaskin, oni-on-ion
<MichaelRaskin>
multiple-value-bind and drakma documentation should help with that
Satou has quit [Quit: exit();]
scymtym has joined #lisp
<oni-on-ion>
i think the URL request is different for both of his scenarios. just read about drakma myself yesterday
eli_oat has joined #lisp
shifty has quit [Ping timeout: 240 seconds]
buffergn0me has joined #lisp
EvW has quit [Ping timeout: 245 seconds]
dieggsy has joined #lisp
sendai_ has joined #lisp
azimut has quit [Ping timeout: 264 seconds]
EvW1 has joined #lisp
rumbler31 has joined #lisp
rumbler31 has quit [Remote host closed the connection]
eli_oat has quit [Quit: Leaving.]
EvW1 has quit [Ping timeout: 240 seconds]
smasta has joined #lisp
Folkol_ has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
pierpal has quit [Quit: Poof]
pierpal has joined #lisp
al-damiri has joined #lisp
nsrahmad has joined #lisp
igemnace has quit [Remote host closed the connection]
<gendl>
Hi, does anyone know about the Slime error with "error in process filter: Wrong number of arguments" which started happening in Emacs 26.1? Apparently it is fixed in the latest slime, but not the one available through Quicklisp yet. How would I go about getting the latest Slime ahead of next QL release?
smurfrobot has joined #lisp
shrdlu68 has left #lisp [#lisp]
schweers has quit [Ping timeout: 255 seconds]
merodix has quit [Remote host closed the connection]
<gendl>
edit: I see Version 21 released here: https://github.com/slime/slime/releases, while Version 20 came with latest quicklisp. I'll go ahead and try installing version 21 (although I'm very spoiled on Slime installation with quicklisp-slime-helper).
<fiddlerwoaroof>
Has anyone had issues with cl+ssl after saving an image?
<fiddlerwoaroof>
gendl: yes, that error happens because an API changedi in emacs 26
<Fade>
gendl: set an explicit load path in your emacs' slime configuration.
igemnace has joined #lisp
<MichaelRaskin>
Well, there might be problems if your pre- and post- environment is different and it cannot just reload the library by name
<Fade>
check out the slime repo and point emacs at it.
<fiddlerwoaroof>
I don't know if the latest release has the fix, but the git HEAD version did when I encountered this problem
<MichaelRaskin>
fiddlerwoaroof: I just hack the library paths before saving
<gendl>
Fade: all I do now is load quicklisp/slime-helper.el
smasta has quit [Ping timeout: 240 seconds]
<gendl>
I don't have anything else regarding slime in my emacs configuration
<fiddlerwoaroof>
MichaelRaskin: this is on the same machine
<MichaelRaskin>
Environment variables?
<fiddlerwoaroof>
The error I'm getting when I run the image is [2018-06-25 08:56:24 [ERROR]] SSL initialization error: Can't create new SSL CTX
<Fade>
gendl: well, my emacs config is a bit eccentric, but there's a commented example in it setting an explicit load path: https://github.com/fade/dot-emacs
<fiddlerwoaroof>
I'm running the binary from the same shell as the one I used to dump it
<beach>
flip214: Am I understanding you right that you don't feel confident telling me whether or not the GC specification you checked for me seems reasonable?
buffergn0me has quit [Ping timeout: 256 seconds]
pjb`` has joined #lisp
akkad has quit [Remote host closed the connection]
pjb`` is now known as pjb
slyrus1 has joined #lisp
Beep-Lord has joined #lisp
Satou has joined #lisp
m00natic has quit [Remote host closed the connection]
hhdave has quit [Ping timeout: 240 seconds]
raynold has joined #lisp
nickenchuggets has joined #lisp
nickenchuggets has joined #lisp
nickenchuggets has quit [Changing host]
knusbaum1 has quit [Ping timeout: 264 seconds]
sendai_ has quit [Ping timeout: 248 seconds]
dieggsy has quit [Remote host closed the connection]
pagnol_ has quit [Ping timeout: 245 seconds]
littlelisper has joined #lisp
smasta has quit [Ping timeout: 256 seconds]
lumm has joined #lisp
Arcaelyx has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
dieggsy has joined #lisp
<littlelisper>
can anyone please explain me what set-macro-character and get-macro-character do, in a simple language?
eli_oat has joined #lisp
<flip214>
beach: well, you wrote that you'll make the paper more explicit -- that's what I'm waiting for before giving an (a final) opinion.
<flip214>
I hope that I can clean up all the things on my mind currently (do a brain-GC, more or less ;) to then be able to think about your paper in honest.
<littlelisper>
Beep-Lord: i get that they are used to make custom reader. but just tell me what it does on a high level
<flip214>
right now, I'm feeling out-of-memory and can't process any deep thoughts... I hope to change that later this week (Friday)
<Beep-Lord>
littlelisper, I have no idea; I've never used reader macros.
<littlelisper>
Beep-Lord: ok, i ll try to make sense of clhs
<flip214>
littlelisper: the macro character "#" dispatches to various reader function based (loosely) on the next character; this dispatch table can be read and set with this functions
<Beep-Lord>
littlelisper, it probably makes more sense than clhs
<pjb>
littlelisper: to udnerstand them you have to read chapter 2. notably 2.2 Reader Algorithm.
<Bike>
littlelisper: when you set the reader macro function on some character, it means that when the reader hits that character at the start of something, it calls that function to get the read object.
<pjb>
littlelisper: basically, READ knows how to parse and read only 1- symbols, 2- integers, 3- floating-point numbers. That's all.
<pjb>
littlelisper: all the rest is actually parsed by reader macros.
<pjb>
so the syntax of lisp is actually very simple, since it is almost entirely customizable.
<pjb>
err, also ratios, like 1/2.
<mfiano>
interesting, so #\/ knows how to read an integer before and after itself?
<mfiano>
ah :)
<littlelisper>
ah, thats alot
smasta has joined #lisp
<littlelisper>
(set-macro-character #\] (get-macro-character #\))). does this mean that the reader replaces ']' by ')'?
<pjb>
littlelisper: if reading something starting with ) makes any sense! The reader macro on #\) just signals an error.
<pjb>
littlelisper: notice that to read lists, READ uses a function similar to READ-DELIMITED-LIST (but not this function, since it is not able to read dotted-list). This function can be used in a reader macro for #\[ to read lists terminated by #\].
dmiles has quit [Ping timeout: 255 seconds]
<pjb>
Now, the reader macro for #\) will probably mention #\( in its error message. This may not be the best choice for #\], since it would be confusing to the user. It would be better to implement your own reader macro for #\] with a specific error message.
<littlelisper>
ok, i understand abit about reader macros now
<pjb>
Notice that you also want to make #\] a terminating reader macro, so you can write [a b c] and not have to write [ a b c ] ; <- notice the space.
<pjb>
Happily, this is what happens by default (the optional non-terminating-p parameter is nil by default).
logicmoo has joined #lisp
<littlelisper>
would the space be an issue?
<pjb>
If the macro was non-terminating, it would be that if there was no space before, it wouldn't be interpreted as a reader macro, but as a consituent character of the previous token.
<pjb>
Just try it: (set-macro-character #\[ #'open-bracket-macro-character t)
<pjb>
then: '[a b c] d] ]
<pjb>
'[ foo[bar]baz foo [bar] baz ]
orivej has joined #lisp
<pjb>
Sometimes it's useful.
<pjb>
For example, # is a non-terminating reader macro: (quote (a#b c##d)) #| --> (|A#B| |C##D|) |#
<gendl>
Fade: I just upgraded Slime the quick & easy (and probably dangerous) way -- manually copied the slime-2.21 into quicklisp/dists/quicklisp/software/slime-v2.21, then edited quicklisp/dists/quicklisp/installed/systems/swank.txt to point to that one.
<gendl>
It works, but I don't know what's going to happen when I next update quicklisp.
akkad has quit [Client Quit]
<gendl>
Anyway, I usually install quicklisp clean each time anyway rather than trying to update in-place. That's probably overkill, but another reason I do it is to keep down the size of the quicklisp directories that we distribute ourselves with Gendl and Genworks GDL releases.
shka_ has joined #lisp
<beach>
flip214: Got it, thanks.
Fredman has quit [Ping timeout: 255 seconds]
Beep-Lord has quit [Ping timeout: 256 seconds]
vitali has quit [Ping timeout: 255 seconds]
scymtym has quit [Ping timeout: 255 seconds]
_cosmonaut_ has joined #lisp
Arcaelyx has joined #lisp
brendyn has quit [Ping timeout: 240 seconds]
MichaelRaskin has joined #lisp
<MichaelRaskin>
beach: some cleanups help, but I am not sure how to break 30x slowdown in compilation speed. Or 30x runtime slowdown, but runtime doesn't feel completely absurd, at least.
akkad has joined #lisp
_cosmonaut_ has quit [Ping timeout: 256 seconds]
kuwze has quit [Ping timeout: 260 seconds]
eli_oat has quit [Quit: Leaving.]
eli_oat has joined #lisp
slyrus1 has quit [Quit: slyrus1]
igemnace has quit [Quit: WeeChat 2.1]
smasta has quit [Ping timeout: 240 seconds]
nowhere_man has quit [Ping timeout: 268 seconds]
smasta has joined #lisp
Beep-Lord has joined #lisp
varjag has joined #lisp
myrkraverk has quit [Ping timeout: 240 seconds]
Satou has quit [Quit: exit();]
dieggsy has quit [Remote host closed the connection]
myrkraverk_ has joined #lisp
<Fade>
well, that's a way forward, I guess.
<Fade>
it seems more complicated to me, but as they say, mileage varies. :)
fikka has quit [Ping timeout: 240 seconds]
myrkraverk_ is now known as myrkraverk
milanj has quit [Quit: This computer has gone to sleep]
sauvin has quit [Read error: Connection reset by peer]
fikka has joined #lisp
<makomo>
gendl: your software is interesting stuff and a good showcase of what CL software looks like
fikka has quit [Ping timeout: 276 seconds]
<makomo>
gendl: i think that you should make your videos' titles more descriptive though
<makomo>
gendl: for example "G102 Video 3" isn't very informative (and has no description either), and i think that's it's very interesting to see
<makomo>
including "common lisp" somewhere in the description as well would allow people to find common lisp stuff more easily as well :-)
<makomo>
gendl: just a few suggestions from me
<makomo>
(i'm watching the video because i'm interested in what the software does and how it's used btw)
<makomo>
i doubt i would ever find it if you hadn't showed up here and mentioned Gendl :-)
random-nick has quit [Read error: Connection reset by peer]
slyrus_ has quit [Ping timeout: 256 seconds]
fikka has joined #lisp
fikka has quit [Ping timeout: 276 seconds]
Fredman has joined #lisp
Fredman has quit [Remote host closed the connection]
fikka has joined #lisp
slyrus_ has joined #lisp
comborico1611 has quit [Quit: comborico1611]
skeuomorf has joined #lisp
fikka has quit [Ping timeout: 260 seconds]
<Smokitch>
What is the difference between generic dispatch and multiple dispatch? And is generic dispatch just called generic because of generic functions?
<Bike>
they're not different things
<dlowe>
"generic dispatch" is the process of calling the correct method given a generic function.
<dlowe>
"multiple dispatch" is the process of deciding which method is correct by using the types of multiple arguments.
<dlowe>
In other languages with "objects," typically generic dispatch is only based on the type of one of the parameters.
dieggsy has joined #lisp
fikka has joined #lisp
<makomo>
and where does the adjective "generic" come from? i suppose it's just from the name "generic function", i.e. "the dispatch within a generic function"
dieggsy has left #lisp [#lisp]
<makomo>
in that sense, "dispatch" == "generic dispatch"
fikka has quit [Ping timeout: 256 seconds]
<dlowe>
I speculate that it's generic with respect to applying the function. The normal function call is a specific case of a generic function.
random-nick has joined #lisp
herr_jth has joined #lisp
fikka has joined #lisp
fikka has quit [Ping timeout: 255 seconds]
skeuomorf has quit [Ping timeout: 240 seconds]
milanj has joined #lisp
eli_oat has quit [Quit: Leaving.]
fikka has joined #lisp
eli_oat has joined #lisp
Beep-Lord has quit [Ping timeout: 256 seconds]
fikka has quit [Ping timeout: 260 seconds]
herr_jth has quit [Remote host closed the connection]
warweasle has quit [Quit: later]
karlosz has joined #lisp
fikka has joined #lisp
eli_oat has quit [Quit: Leaving.]
slyrus has quit [Quit: slyrus]
slyrus has joined #lisp
fikka has quit [Ping timeout: 265 seconds]
nickenchuggets has quit [Read error: Connection reset by peer]
nickenchuggets has joined #lisp
fikka has joined #lisp
Jesin has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
mflem has joined #lisp
scymtym has joined #lisp
fikka has joined #lisp
ebrasca has quit [Remote host closed the connection]
smurfrobot has quit [Remote host closed the connection]
fikka has quit [Ping timeout: 268 seconds]
pierpal has quit [Quit: Poof]
pierpal has joined #lisp
<Myon>
svillemot: thanks for looking anyway
EvW has joined #lisp
fikka has joined #lisp
Arcaelyx has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
Smokitch has quit []
pierpa has joined #lisp
zachk has joined #lisp
zachk has quit [Read error: Connection reset by peer]
zachk has joined #lisp
fikka has quit [Ping timeout: 255 seconds]
nowhere_man has joined #lisp
zachk has quit [Changing host]
zachk has joined #lisp
trittweiler has quit [Ping timeout: 276 seconds]
fikka has joined #lisp
fikka has quit [Ping timeout: 265 seconds]
eli_oat has joined #lisp
fikka has joined #lisp
Smokitch has joined #lisp
NotSpooky has joined #lisp
fikka has quit [Ping timeout: 256 seconds]
eli_oat has quit [Quit: Leaving.]
<MichaelRaskin>
beach: and of course it is a completely different story what to do when a condition is signalled in the debugged thread…
Arcaelyx has joined #lisp
smasta has quit [Ping timeout: 268 seconds]
Beep-Lord has joined #lisp
random-nick has quit [Read error: Connection reset by peer]
mangul has quit [Remote host closed the connection]
mangul has joined #lisp
vlatkoB_ has quit [Read error: Connection reset by peer]
shka_ has quit [Ping timeout: 240 seconds]
al-damiri has quit [Quit: Connection closed for inactivity]
<varjag>
is there a simple way to convince hunchentoot to not treat + as whitespace in request parameters?
lel has quit [Ping timeout: 256 seconds]
zigpaw has quit [Quit: Ping timeout (120 seconds)]
lel has joined #lisp
zigpaw has joined #lisp
margeas has quit [Ping timeout: 260 seconds]
margeas has joined #lisp
<TMA>
varjag: it's defined so in the URL encoding scheme, that you can use + instead of %20
<TMA>
varjag: nothing hunchentoot specific
RemoteFox has left #lisp [#lisp]
<White_Flame>
%2B should be a literal plus sign
<White_Flame>
but you should probably be using a function to safely encode your parameters instead of special casing it
pagnol_ has joined #lisp
karlosz has quit [Quit: karlosz]
makomo has quit [Ping timeout: 276 seconds]
mangul has quit [Remote host closed the connection]
kajo has quit [Ping timeout: 276 seconds]
shangul has joined #lisp
uint has quit [Quit: leaving]
<varjag>
+ is permissible in post parameters
<varjag>
iirc
<varjag>
and it happens in base64 encoded argument
<varjag>
yes am replacing with %2B in the client for now, was just wondering
karlosz has joined #lisp
<White_Flame>
oh, you're using POST? what's the content-type of the header?
karlosz has quit [Client Quit]
karlosz has joined #lisp
housel has quit [Remote host closed the connection]
housel has joined #lisp
<varjag>
good Q. it's whatever swift's URLRequest has on default
slyrus has quit [Quit: slyrus]
<varjag>
can't see it documented anywhere
<varjag>
any way to check it in 'toot easy handler?
slyrus has joined #lisp
<White_Flame>
the default is probably application/x-www-form-urlencoded
<White_Flame>
and yeah, that assumes + are spaces
Arcaelyx_ has joined #lisp
<White_Flame>
you can alteratively use multipart/form-data, which is used for file uploads
<varjag>
i see.. thanks!
kajo has joined #lisp
mindCrime has quit [Ping timeout: 268 seconds]
Arcaelyx has quit [Ping timeout: 276 seconds]
sjl has quit [Ping timeout: 256 seconds]
<MichaelRaskin>
beach: also an interesting question what exactly should happen for step-over for a form that contains a go or throw that might land inside or outside that form.
nowhere_man has quit [Ping timeout: 240 seconds]
<White_Flame>
in my experience in other languages with thrown exceptions, that tends to just continue running, unless you have "pause on exceptions" set
<MichaelRaskin>
We-ell
smurfrobot has joined #lisp
<MichaelRaskin>
If I already take 30x hit for both compilation and runtime, adding actual logic for handling that might be a good idea…
<MichaelRaskin>
Not sure I can do portable signal handling right…
paul0 has joined #lisp
<MichaelRaskin>
But at least go could be nice. For LOOP, for example.
smurfrobot has quit [Ping timeout: 256 seconds]
Bike has quit [Ping timeout: 260 seconds]
varjag has quit [Quit: ERC (IRC client for Emacs 25.2.1)]
nowhere_man has joined #lisp
<White_Flame>
is there a moderator for #lispcafe? kinda needs it as epony went there from here
Trystam has joined #lisp
pagnol_ is now known as pagnol
Tristam has quit [Ping timeout: 248 seconds]
Trystam is now known as Tristam
<pjb>
White_Flame: AFAIK, anybody can become operator. See with freenode…
spoken-tales has joined #lisp
<White_Flame>
#lispcafe is a single-octothorpe channel, not a double- one
<White_Flame>
so somebody owns the chanserv permissions
<White_Flame>
(to my understanding)
SaganMan has quit [Ping timeout: 245 seconds]
spoken-tales has quit [Quit: ERC (IRC client for Emacs 26.1)]
<mfiano>
That would be rindolf
<mfiano>
And I have already emailed them, because Freenode staff doesn't care about it.
spoken-tales has joined #lisp
fisxoj has joined #lisp
<White_Flame>
phoe and zaquest also have ops, so ping for #lispcafe problems
pagnol has quit [Ping timeout: 264 seconds]
spoken-tales has quit [Quit: ERC (IRC client for Emacs 26.1)]
spoken-tales has joined #lisp
spoken-tales has left #lisp [#lisp]
paul0 has quit [Quit: Leaving]
pjb has quit [Remote host closed the connection]
pjb has joined #lisp
Bike has joined #lisp
pjb is now known as Guest41964
<MichaelRaskin>
beach: I am not sure throw between the instances of a recursive function can be distinguished in a portable way.
karlosz has quit [Ping timeout: 240 seconds]
raynold has quit []
<White_Flame>
why not? if there's a potential throw destination in a stack frame, you can't tail recurse
<White_Flame>
erm, you can't perform tail recursion optimization
Guest41964 has quit [Remote host closed the connection]
EvW has quit [Remote host closed the connection]
EvW has joined #lisp
<MichaelRaskin>
Hm right, in the function-wrapper I can also set a global frame counter
robotoad has quit [Quit: robotoad]
<White_Flame>
sure, manually externalize your own stack of active handlers so you can let TCO do its thing unfettered
caltelt_ has joined #lisp
rumbler31 has joined #lisp
karlosz has joined #lisp
pierpal has quit [Ping timeout: 276 seconds]
smasta has joined #lisp
fraya has quit [Quit: Leaving]
Khisanth has quit [Ping timeout: 265 seconds]
spoken-tales has joined #lisp
subroot has joined #lisp
lonjil has joined #lisp
Khisanth has joined #lisp
jack_rabbit has joined #lisp
margeas has quit [Quit: Konversation terminated!]
spoken-tales has quit [Remote host closed the connection]