<drakonis>
especially the ones that talk about the sacred cows
waleee-cl has joined #commonlisp
molson__ has joined #commonlisp
mon_aaraj has quit [Ping timeout: 256 seconds]
s-liao43 has joined #commonlisp
molson_ has quit [Ping timeout: 250 seconds]
molson has quit [Ping timeout: 250 seconds]
molson has joined #commonlisp
mon_aaraj has joined #commonlisp
s-liao has quit [Quit: Client closed]
mon_aaraj has quit [Ping timeout: 268 seconds]
<Common-Lisp>
good write-up, interesting stuff
mon_aaraj has joined #commonlisp
<Common-Lisp>
I'm not sure how actionable their suggestions are, though
random-nick has quit [Ping timeout: 240 seconds]
waleee-cl has quit [Ping timeout: 250 seconds]
ec has quit [Ping timeout: 276 seconds]
asarch has quit [Quit: Leaving]
Everything has quit [Quit: leaving]
sloanr has joined #commonlisp
<fitzsim>
I read the blog post; good suggestion to put projects on gitlab.common-lisp.net
<fitzsim>
I'm trying to create a project there but I get "The form contains the following error: Namespace is not valid"
<fitzsim>
it seems like I'm an "external" user for some reason; I'll stick to sr.ht for now, I guess
<fitzsim>
(for cl-starter-script)
Jing has joined #commonlisp
Common-Lisp has quit [Quit: Leaving]
sloanr has quit [Ping timeout: 256 seconds]
<beach>
Good morning everyone!
<Josh_2>
Hey
mon_aaraj has quit [Ping timeout: 256 seconds]
mon_aaraj has joined #commonlisp
<sveit_>
hi. i am trying to use both local and global inlined functions to replace macros, and was wondering if for this purpose flet or let-assigned functions are generally friendlier to the compiler (specifically SBCL)? In certain cases that I haven't been able to predict it seems the functions are not reliably inlined when using flet
<sm2n>
sveit_: if you need reliable inlining, isn't (declare (inline)) what you want?
<beach>
sveit_: How did you determine that the function wasn't inlined? Did you read the disassembly?
<beach>
sveit_: And why do you absolutely want functions to be inlined? Don't you trust the compiler to make this call?
<sveit_>
yes, i read the disassembly
<moon-child>
well, I would not trust the compiler. But I would also not make such decisions without benchmarking
<sveit_>
i am doing this in some performance-sensitive code that needs to increment certain counters, so i have functions floating around like (let ((counter 0)) (flet ((incf-counter (step) (incf counter-var step))) (declare (inline incf-counter))...)) where #'incf-counter is passed to other (also inlined) functions taht only funcall it
<sveit_>
i /was/ doing this with macros that wrote the inner functions that would increment inner-counter, but it is much cleaner to pass such functions around. it seems that, somewhat unpredictably to me, some of the outer flets are not properly inlined
<sveit_>
on the other hand sometimes such things /are/ inlined, and i haven't been able to understand the pattern
<EdLangley[m]>
It's explicitly not required, so it's probably better to use macros here
<EdLangley[m]>
If it's important to ensure that the code is actually inlined.
<moon-child>
sveit_: sounds like you want COMPILER-MACROLET...too bad it doesn't exist!
<sveit_>
EdLangley[m]: i'm aware, but SBCL is intelligent enough that it would be great to trade some code clarity for trusting the compiler to do some magic :)
<EdLangley[m]>
Compiler macros are optional too, iirc
<moon-child>
sure, but if you are optimizing, you are already trusting to the performance characteristics of a given implementation or a few given implementations; so you can count on whatever behaviour they exhibit wrt compiler macros
<moon-child>
and, whereas inlining is a black art, compiler-macro expansion is a relatively simple matter
masinter has joined #commonlisp
<sm2n>
Are there implementations worth doing performance engineering on today that don't respect (declare (inline))?
<aeth>
(declaim (inline foo)) unless a FLET or something
s-liao43 has quit [Ping timeout: 256 seconds]
<aeth>
modern optimizing compilers (not SBCL, and not Common Lisp in general) tend to ignore this sort of thing these days because they think they know better than you
<aeth>
afaik
<sm2n>
I mean in CL
<sm2n>
I know C compilers ignore inline pragmas for instance
<moon-child>
gcc has __attribute__((always_inline)) and will actually respect it
<moon-child>
ffwiw
<moon-child>
s/f//
s-liao has joined #commonlisp
tyson2 has quit [Remote host closed the connection]
dre has joined #commonlisp
semz_ has joined #commonlisp
semz_ has quit [Changing host]
semz_ has joined #commonlisp
Bike has quit [Quit: Lost terminal]
semz has quit [Ping timeout: 250 seconds]
mon_aaraj has quit [Ping timeout: 256 seconds]
mon_aaraj has joined #commonlisp
mon_aaraj has quit [Ping timeout: 268 seconds]
mon_aaraj has joined #commonlisp
<White_Flame>
sveit_: if you pass around #'incf-counter, then it becomes a closure, and closures aren't inlinable
s-liao has quit [Quit: Client closed]
aartaka has joined #commonlisp
sloanr has joined #commonlisp
mon_aaraj has quit [Ping timeout: 268 seconds]
mon_aaraj has joined #commonlisp
tophullyte has quit [Ping timeout: 250 seconds]
sloanr has quit [Remote host closed the connection]
sloanr has joined #commonlisp
<beach>
fe[nl]ix: I must have completely missed the fact that you seem interested in having an IDE for Common Lisp. Are you aware of the bits and pieces being worked on by scymtym and (somewhat) myself?
<beach>
Maybe I need to get more organized about reading blog posts.
<sveit_>
are there "extra" registers in SBCL assembly? I am seeing things like writes to "NL1", which I am not familiar with and can't seem to find on google
prov[m] has joined #commonlisp
<White_Flame>
can you paste it?
<sveit_>
sure, disassembly under SBCL HEAD for (defun my-incf (input) (declare (type fixnum input)) (+ input 7)):
<moon-child>
objdump does not seem able to disassemble that instruction
<moon-child>
hmm, it is unable to disassemble one of them
<moon-child>
cmp r0, nl1 is disassembled as cmp x10, x1 by objdump
<sveit_>
moon-child: not directly relevant but i'd be interested to learn how you are doing this (I assume you're copying the opcodes into some kind of file and running it through objdump?)
<White_Flame>
so just register aliases?
<moon-child>
sveit_: I used gas's .word directive
<moon-child>
on x86 I have more fine-grained tools, but I haven't spent much time with arm yet
<moon-child>
White_Flame: well, objdump knows nothing of the instruction that sbcl identifies as stp nl1, nl0, [tmp]. So I assume something fucky is going on
nwoob has joined #commonlisp
jealousmonk has quit [Quit: ERC (IRC client for Emacs 27.1)]
<nwoob>
I'm learning CL from David S. Touretzky book. Since I am familiar with Javascript, I am thinking to write programs mentioned in book in both JS and CL for learning.
<nwoob>
Is this good approach?
<sveit_>
i also wonder what is being computed by [THREAD, #40], but I at least have some rough idea of what is going on there
<moon-child>
iirc it just pegs a register as a tls pointer
<White_Flame>
byte offset 40 into the thread local space
<moon-child>
x30 maybe
<moon-child>
x21 looks like
NeoCron has joined #commonlisp
<sveit_>
is there a way to just directly take the raw opcodes and disassemble them in some other tool (i am not that experienced with writing assembly)
<White_Flame>
there are some web-based ones
<White_Flame>
and I think radare does it, too
Doraemon has quit [Ping timeout: 240 seconds]
notzmv has quit [Ping timeout: 240 seconds]
<White_Flame>
(I'm not very arm/m1 familiar)
<White_Flame>
but I think it's an appropriate question for #sbcl if nobody's jumping to answer in here
masinter has quit [Ping timeout: 240 seconds]
<sveit_>
well i put it through onlinedisassembler.com and it seems fairly consistent that NL1 really means X1. I'm sure if I were more experienced in assembly that something like this must have been going on would have been "obvious", but I'm still not comfortable with all the prefixes in front of register
<sveit_>
they seem to be underdocumented even in the usual case
<sveit_>
but i'll ask on #sbcl about whether these aliases are documented tomorrow
pillton has joined #commonlisp
s-liao has joined #commonlisp
karlosz has joined #commonlisp
Cymew has joined #commonlisp
MajorBiscuit has joined #commonlisp
nwoob has quit [Ping timeout: 240 seconds]
attila_lendvai has joined #commonlisp
sloanr has quit [Remote host closed the connection]
sloanr has joined #commonlisp
wyrd has quit [Ping timeout: 276 seconds]
shka has joined #commonlisp
frgo_ has quit [Ping timeout: 256 seconds]
Algernon69 has joined #commonlisp
Algernon91 has joined #commonlisp
Algernon69 has quit [Ping timeout: 240 seconds]
nwoob has joined #commonlisp
dickbar__ has joined #commonlisp
sloanr has quit [Remote host closed the connection]
sloanr has joined #commonlisp
qeqeqw has joined #commonlisp
Cymew has quit [Ping timeout: 250 seconds]
nwoob has quit [Ping timeout: 256 seconds]
gaqwas has joined #commonlisp
Lord_Nightmare has joined #commonlisp
sloanr has quit [Remote host closed the connection]
sloanr has joined #commonlisp
sloanr has quit [Remote host closed the connection]
sloanr has joined #commonlisp
treflip has joined #commonlisp
sloanr has quit [Remote host closed the connection]
sloanr has joined #commonlisp
wyrd has joined #commonlisp
notzmv has joined #commonlisp
rogersm has joined #commonlisp
nwoob has joined #commonlisp
mgl has joined #commonlisp
pve has joined #commonlisp
sloanr has quit [Remote host closed the connection]
sloanr has joined #commonlisp
karlosz has quit [Ping timeout: 250 seconds]
amb007 has quit [Ping timeout: 256 seconds]
amb007 has joined #commonlisp
<nwoob>
can someone please tell me where can I ask database related questions
<phoe>
#lispcafe might help you if it's tangentially related to any Lisp (or not)
<nwoob>
thanks phoe
wyrd has quit [Ping timeout: 276 seconds]
wyrd has joined #commonlisp
gaqwas has quit [Ping timeout: 250 seconds]
sloanr has quit [Remote host closed the connection]
sloanr has joined #commonlisp
pillton has quit [Quit: ERC (IRC client for Emacs 27.2)]
sloanr has quit [Remote host closed the connection]
sloanr has joined #commonlisp
sloanr has quit [Remote host closed the connection]
sloanr has joined #commonlisp
<mgl>
If the asdf system xxx/test depends on something not yet in quicklisp, does that break xxx in quicklisp?
<phoe>
mgl: I don't understand the problem
<phoe>
the system XXX/TEST will not be included in Quicklisp if it cannot be loaded due to missing dependencies
<phoe>
if XXX and XXX/TEST are defined in the same file (which is very likely), it means that XXX transitively won't be included in Quicklisp either
lisp123win has left #commonlisp [ERC (IRC client for Emacs 26.3)]
<mgl>
Yes, that was the question.
<phoe>
oh! OK, I understood then
<phoe>
then you'll need to include dependencies for all systems defined in xxx.asd
<mgl>
Thanks. If I put the test system in a different file, then it will be fine?
<phoe>
no idea - if it's included in the same tarball/repository then Quicklisp might nonetheless try to recognize and load it
<phoe>
and that'll explode anyway
<phoe>
so that's a question to Xach
frgo has joined #commonlisp
sloanr has quit [Remote host closed the connection]
sloanr has joined #commonlisp
frgo has quit [Ping timeout: 268 seconds]
sloanr has quit [Remote host closed the connection]
sloanr has joined #commonlisp
mgl has quit [Quit: Client closed]
mgl has joined #commonlisp
sloanr has quit [Remote host closed the connection]
sloanr has joined #commonlisp
Lord_of_Life_ has joined #commonlisp
Lord_of_Life has quit [Ping timeout: 256 seconds]
<Krystof>
sveit_: we have different names for registers because those registers have special meanings (either to Lisp-land, to the Garbage Collector, or both)
qeqeqw has quit [Ping timeout: 250 seconds]
sloanr has quit [Remote host closed the connection]
Lord_of_Life_ is now known as Lord_of_Life
<Krystof>
On arm you see the results of a partitioned register set: NLx I *think* stands for Non-Lisp, but whatever the name, they're registers that are guaranteed never to hold lisp pointers. (So the Garbage Collector can ignore them, and the compiler can put untagged data in them)
sloanr has joined #commonlisp
<Krystof>
THREAD holds a pointer to thread-local storage; NULL holds NIL; I can't remember if there is a ZERO on arm64, but if there is, it holds 0.
<Krystof>
CSP / CFP are "control" (i.e. Lisp) stack pointer and frame pointer
<Krystof>
and so on
treflip has quit [Remote host closed the connection]
mon_aaraj has quit [Ping timeout: 240 seconds]
iamFIREcracker has joined #commonlisp
mon_aaraj has joined #commonlisp
iamFIREc1 has quit [Ping timeout: 240 seconds]
sloanr has quit [Remote host closed the connection]
sloanr has joined #commonlisp
VincentVega has joined #commonlisp
mon_aaraj has quit [Ping timeout: 240 seconds]
mon_aaraj has joined #commonlisp
qeqeqw has joined #commonlisp
iamFIREc1 has joined #commonlisp
iamFIREcracker has quit [Read error: Connection reset by peer]
sloanr has quit [Remote host closed the connection]
sloanr has joined #commonlisp
karlosz has joined #commonlisp
frgo has joined #commonlisp
s-liao has quit [Ping timeout: 256 seconds]
random-nick has joined #commonlisp
lispy has joined #commonlisp
waleee-cl has joined #commonlisp
qeqeqw has quit [Ping timeout: 250 seconds]
rotateq has joined #commonlisp
<rotateq>
Good morning you smart people. :)
kevingal has joined #commonlisp
<jackdaniel>
don't say that, some people take that to heart and lose healthy humbleness ;)
<lispy>
Good morning, thank you for acknowledging my genius
sabra has joined #commonlisp
<jackdaniel>
:)
Algernon91 has quit [Read error: Connection reset by peer]
<sabra>
nwoob: I would think so
<sabra>
Hello everyone
Algernon91 has joined #commonlisp
kevingal has quit [Ping timeout: 250 seconds]
kevingal has joined #commonlisp
<phoe>
hey sabra
<phoe>
thanks for the json update!
sloanr has quit [Remote host closed the connection]
sloanr has joined #commonlisp
<sabra>
thank you. The original was so out of date
nwoob has quit [Ping timeout: 256 seconds]
<rotateq>
jackdaniel: of course I didn't include myself ^^ but yes, there is always more to learn, even for a master/expert
<rotateq>
ah okay, web stuff still is not much for me ^^
<sabra>
researchers I support sometimes get gigs of data in json form from who knows where. No web stuff here
<rotateq>
uff okay, i appreciate it much then
VincentV` has joined #commonlisp
iamFIREcracker has joined #commonlisp
VincentVega has quit [Ping timeout: 240 seconds]
sloanr has quit [Remote host closed the connection]
sloanr has joined #commonlisp
iamFIREc1 has quit [Ping timeout: 240 seconds]
<rotateq>
but when i see XML data format it seems to me it's a very exhausting one and that so much work is unnecessarily doubled and tripled by bringing it to a computable layout
nwoob has joined #commonlisp
nwoob has quit [Ping timeout: 268 seconds]
sloanr has quit [Remote host closed the connection]
sloanr has joined #commonlisp
Algernon91 has quit [Ping timeout: 268 seconds]
Algernon91 has joined #commonlisp
mon_aaraj has quit [Ping timeout: 240 seconds]
mgl has quit [Quit: Client closed]
sabra_ has joined #commonlisp
tyson2 has joined #commonlisp
sabra has quit [Ping timeout: 250 seconds]
mon_aaraj has joined #commonlisp
cosimone has joined #commonlisp
lispy has quit [Quit: Leaving]
<yitzi>
sabra: Thanks for your review of shasht. I'll look into the rough edges that you did find. I appreciate the your detailed reviews as always!
karlosz has quit [Ping timeout: 240 seconds]
<sabra_>
Yitzi: thanks. Let me know if there is anything I can do or should correct or update
<yitzi>
Will do!
<yitzi>
sabra_: Aside from the some of the issues that you mentioned that I obviously need to look at I did notice that you said that "[123.456e78]" fails...
<yitzi>
shasht reading of floating point is affected by `*read-default-float-format*` so setting that to 'double-float or doing `(shasht:read-json* :stream "[123.456e78]" :float-format 'double-float)` should work.
<sabra_>
yitzi: Thank you. Will correct today
<yitzi>
There could be a better way to handle that issue. I am open to suggestions/criticism.
wyrd has quit [Ping timeout: 276 seconds]
wyrd has joined #commonlisp
<sabra_>
That works. That may work for all the other libraries that failed that as well
<yitzi>
Awesome. I don't think it is an ideal solution, but it does follow the core CL behavior so at least it is not unexpected.
<sabra_>
yitzi: That does fix that for most of the libraries. Will correct immediately.
<yitzi>
sabra_: Oh that is great! Glad I could help out.
<sabra_>
Will put a changelog at the top
<yitzi>
sabra_: Can you give me the test case that caused shasht to hang on nil? I am probably just being dense, but I am not seeing it.
s-liao has joined #commonlisp
<yitzi>
sabra_: nvm. I have found it.
frodef has quit [Ping timeout: 250 seconds]
frodef has joined #commonlisp
sabra_ has quit [Ping timeout: 250 seconds]
sabra has joined #commonlisp
mgl has joined #commonlisp
mon_aaraj has quit [Ping timeout: 250 seconds]
sloanr has quit [Remote host closed the connection]
sloanr has joined #commonlisp
mon_aaraj has joined #commonlisp
cosimone has quit [Remote host closed the connection]
Bike has joined #commonlisp
s-liao has quit [Quit: Client closed]
sloanr has quit [Remote host closed the connection]
sloanr has joined #commonlisp
kevingal has quit [Quit: No Ping reply in 180 seconds.]
<Xach>
phoe: you are incorrect about transitive inclusion
<Xach>
phoe: if XXX builds but XXX/TEST does not, XXX will still be included.
kevingal has joined #commonlisp
qeqeqw has joined #commonlisp
<phoe>
Xach: TIL! thank you
<phoe>
if they are defined in the same ASD file, how does Quicklisp work in that situation though?
<phoe>
does Quicklisp automatically prune system definitions for systems that do not build?
<Xach>
Quicklisp tries to build every system it can find. If it builds, it is indexed in systems.txt and can be found via QL's system search function. If it doesn't, it isn't.
<mgl>
Xach: Thank you.
s-liao has joined #commonlisp
Guest291 has joined #commonlisp
Guest291 has quit [Client Quit]
sabra_ has joined #commonlisp
sabra has quit [Ping timeout: 256 seconds]
sloanr has quit [Remote host closed the connection]
sloanr has joined #commonlisp
s-liao has quit [Client Quit]
mon_aaraj has quit [Ping timeout: 240 seconds]
mon_aaraj has joined #commonlisp
mon_aaraj has quit [Ping timeout: 240 seconds]
mon_aaraj has joined #commonlisp
sloanr has quit [Remote host closed the connection]
sloanr has joined #commonlisp
mon_aaraj has quit [Ping timeout: 256 seconds]
Cymew has joined #commonlisp
mon_aaraj has joined #commonlisp
attila_lendvai has quit [Ping timeout: 240 seconds]
<fe[nl]ix>
beach: I'm not aware of the work being done. what are you referring to ?
<beach>
fe[nl]ix: scymtym maintains Clouseau, the inspector. And we are both working on Second Climacs as an editor. I have a paper about debugging and McCLIM has a backtrace inspector "debugger".
<beach>
And scymtym has done work on incremental analysis of Common Lisp code. He occasionally shows a demo here.
<beach>
Based on Eclector.
<beach>
scymtym: Any demo links for incremental syntax analysis?
<beach>
The main thing holding Second Climacs back is that I can't make up my mind about the data structure for computing indentation.
<phoe>
there was a little bit shown during one of the Online Lisp Meeting, IIRC
<beach>
Indeed. But I think there are some better demos around.
<phoe>
that's an OLM idea!
mon_aaraj has quit [Ping timeout: 250 seconds]
mon_aaraj has joined #commonlisp
<fe[nl]ix>
beach: thanks
<beach>
Sure.
<fe[nl]ix>
my interest was more in the discussion because I don't have time to work on it
<beach>
I can understand that.
<fe[nl]ix>
and the list of features I'd need in order to switch to it as my main editor is pretty large
<beach>
I can understand that too.
<fe[nl]ix>
I'll try mcclim again
<fe[nl]ix>
last time I tried to do anything with it I have up after 5 minutes because it was full of bugs
treflip has joined #commonlisp
<beach>
When was that?
sloanr has quit [Remote host closed the connection]
sloanr has joined #commonlisp
sabra_ has quit [Ping timeout: 240 seconds]
sabra has joined #commonlisp
foxfromabyss has joined #commonlisp
<fe[nl]ix>
years ago
<fe[nl]ix>
perhaps around 2015
<beach>
It is being actively maintained and improved by jackdaniel and many others. I am sure they would appreciate "issues" that you find.
<beach>
It is quite usable as it is, but there are some very nice improvements being worked on.
jealousmonk has joined #commonlisp
<foxfromabyss>
Hi! I have a question :)
<foxfromabyss>
Let's say I have a class `(defclass point () (x y))` and a list `(list p1 p2 p3 p4)`
<foxfromabyss>
And I would like to splice(?) the values of the class instances into the list, so that it looks like `(list x1 y1 x2 y3 x3 y3 x4 y4)`
<foxfromabyss>
I initially tried to do that with `mapcar` but that obviously doesn't work, since I would need to return multiple values for that which is not supported by `mapcar` afaik
<foxfromabyss>
What would be a clean and concise way of doing that ^?
<phoe>
foxfromabyss: there's a pastebin in the channel topic; please use that one!
<phoe>
(at least for multiline messages)
<foxfromabyss>
Very sorry about that, will do that in the future
<Xach>
foxfromabyss: (loop for p in points collect (x p) collect (y p))
<phoe>
also, I'd use MAPCAN over (lambda (point) (list (point-x point) (point-y point)))
<Xach>
loop is the most elegant lisp construct
<phoe>
or loop, as Xach said
<foxfromabyss>
i thought loops were not The Lisp Way :D
<Xach>
(loop for a in approaches maximizing (elegance a))
<foxfromabyss>
huh :3
<Xach>
foxfromabyss: now you know better
<phoe>
LOOP is exactly *not* the lisp way
<foxfromabyss>
thanks!
<beach>
foxfromabyss: Now you know that they are.
<phoe>
at the same time, LOOP is exactly *very* the lisp way
<phoe>
it's not the lisp way because it doesn't have many parens and doesn't feel "lispy" the same way the rest of the language does
<foxfromabyss>
i see, thanks a lot
<phoe>
it's very the lisp way because CL allows you to design sublanguages meant for specific things, like iteration, formatting text, regex matching, pattern matching et al
<phoe>
the moment you reconcile these two approaches you will attain one of the first steps for lisp enlightenment™
<foxfromabyss>
hm... very smart
<phoe>
it's the Lisp way
<phoe>
absorb the paradigm that you need, and then use that paradigm
tyson2 has quit [Ping timeout: 250 seconds]
<White_Flame>
Schrödinger's Sexpr
nwoob has joined #commonlisp
<phoe>
if you need functional programming, do it; if you need OOP, do it; if you need declarative programming, do it; if you need imperative control like GOTO, do it; if you need to mix all four, do it; if you need to design another four paradigms, just do it as well
<phoe>
CL is there to help you with all that
<jackdaniel>
except that when you join the irc channel everyone will shun you down if you don't go full-clos road (or be caustious to not speak about it:)
<phoe>
hey! not me
nwoob has quit [Client Quit]
* phoe
waves his hands in futility
* jackdaniel
doesn't point with his finger
<White_Flame>
I'm a post-OO person
<foxfromabyss>
and here i thought CL was FP with a slice of OOP..
<jackdaniel>
re mcclim, I'm not sure whether these are small things, many important parts are rewritten and there may be regressions
<phoe>
foxfromabyss: the fun thing is that it can be
<White_Flame>
foxfromabyss: it's a multi-paradigm language
<phoe>
but doesn't have to be
<random-nick>
post-based OOP? isn't that called message passing?
<rotateq>
foxfromabyss: even some older professors at universities still think that or can't distinguish from generic LISP
<random-nick>
foxfromabyss: CL is a general purpose language with the speciality of being general purpose
<beach>
fe[nl]ix: Check out the links posted by scymtym.
<random-nick>
pretty much any paradigm can be implemented in CL or has already been implemented in CL
<beach>
scymtym: Thanks!
<foxfromabyss>
i see i see..
<foxfromabyss>
unrelated, is it possible to `defmethod` on a list?
<jackdaniel>
on a cons
<jackdaniel>
or null
<jackdaniel>
both are system classes
<beach>
So is LIST.
<jackdaniel>
oh, indeed
<rotateq>
yes :) but not on BIT
<beach>
foxfromabyss: You can specialize to anything that the standard says is a class.
<foxfromabyss>
gotcha, thanks
<beach>
Sure.
<foxfromabyss>
even more unrelated: i am using the Sketch library for some visualizations. Is it possible to render the image and save it to memory, instead of displaying it?
<foxfromabyss>
sorry if I am asking too many dumb questions, googling was not too much of a success tbh
sloanr has quit [Remote host closed the connection]
sloanr has joined #commonlisp
<beach>
Your questions are not dumb.
<rotateq>
foxfromabyss: you're welcome :)
<rotateq>
And what beach says.
theothornhill has quit [Remote host closed the connection]
srhm has quit [Remote host closed the connection]
zoglesby has quit [Remote host closed the connection]
sm2n has quit [Remote host closed the connection]
Schnouki has quit [Remote host closed the connection]
sirufer has quit [Remote host closed the connection]
payphone has quit [Remote host closed the connection]
axvr has quit [Remote host closed the connection]
mcoll has quit [Remote host closed the connection]
Schnouki has joined #commonlisp
payphone has joined #commonlisp
srhm has joined #commonlisp
theothornhill has joined #commonlisp
zoglesby has joined #commonlisp
axvr has joined #commonlisp
sirufer has joined #commonlisp
sm2n has joined #commonlisp
Cymew has quit [Ping timeout: 268 seconds]
mcoll has joined #commonlisp
<phoe>
looks like it should be possible to get out the contents of the foreign SDL2-WINDOW object somehow, but I have no idea how
<phoe>
I'd open an issue on GitHub and ask for adding that to the manual - it does sound like a good use case
ec has joined #commonlisp
pjb has quit [Read error: Connection reset by peer]
cosimone has joined #commonlisp
<foxfromabyss>
gotcha, thanks for taking a look at it.
<foxfromabyss>
I'll probably do just what you suggested :)
sabra has quit [Quit: Konversation terminated!]
sloanr has quit [Remote host closed the connection]
sloanr has joined #commonlisp
Catie has joined #commonlisp
taiju has quit [Remote host closed the connection]
<rotateq>
hobo: wow, looks like cellular automatons!
<rotateq>
and yes, DSLs are great with them. or also combining with the power of CLOS
sloanr has quit [Remote host closed the connection]
semz_ is now known as semz
sloanr has joined #commonlisp
<hobo>
That was the set from the first real attempt. I've since been playing with colorizing it, generating segments of the whole image in separate threads, and have started writing some scaffolding for image analysis.
<rotateq>
running on GPU :)
perrierjouet has quit [Quit: WeeChat 3.4]
perrierjouet has joined #commonlisp
Jing has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
attila_lendvai has joined #commonlisp
sloanr has quit [Remote host closed the connection]
sloanr has joined #commonlisp
semz has quit [Quit: Leaving]
semz has joined #commonlisp
semz has quit [Changing host]
semz has joined #commonlisp
semz has quit [Quit: Leaving]
semz has joined #commonlisp
MajorBiscuit has quit [Ping timeout: 268 seconds]
tyson2 has joined #commonlisp
Danishman has joined #commonlisp
rgherdt has joined #commonlisp
sloanr has quit [Remote host closed the connection]
sloanr has joined #commonlisp
<mgl>
Apart from the slightly related declaration DECLARATION, is there any support for user defined declarations in any implementation?
<White_Flame>
it's mostly part of the compiler infrastructure, so "support" is still going to be in the guts of things
<White_Flame>
what sort of thing are you looking to declare?
<mgl>
Nothing concrete, just wondering whether some lisps provide user defined declarations that a macro can access through its environment object.
<White_Flame>
ah
<White_Flame>
I haven't noticed that explicitly documented, but just adding to to the environment doesn't sound like it should be too difficult.
<EdLangley[m]>
I think all the in scope declarations are accessible in sbcl through internal APIs
<EdLangley[m]>
I also submitted an issue on Trucler about providing a portable interface to this functionality
Algernon666 has joined #commonlisp
<phoe>
mgl: I guess it's doable via CLTL2 interface?
<phoe>
see e.g. #'introspect-environment:declaration-information
<mgl>
declarations, then it makes more sense to implement this.
<mgl>
s/namespec/namespace/
<phoe>
declaration locative, as in?
<phoe>
you want to get a list of all declarations? if yes, (trivial-cltl2:declaration-information 'declaration) will give you the custom-defined ones
<mgl>
mgl-pax terminology, sorry. Locatives specify what role of a symbol to consider. E.g. the same symbol might denote a function and compiler macro.
<phoe>
OK, understandable
mon_aaraj has quit [Ping timeout: 268 seconds]
<mgl>
Anyway, thanks a lot. I'll have a stab at this.
<phoe>
in the worst case, try calling (ignore-errors (trivial-cltl2:declaration-information symbol)) then and see what you get
<phoe>
and then refine it into something that isn't an ugly hack
<phoe>
or ask for a list of all custom declarations first via (d-i 'declaration) and check if the symbol in question is on the list first
mon_aaraj has joined #commonlisp
masinter has joined #commonlisp
Algernon666 has quit [Read error: Connection reset by peer]
Algernon666 has joined #commonlisp
VincentV` has quit [Ping timeout: 256 seconds]
cage has joined #commonlisp
sloanr has quit [Remote host closed the connection]
sloanr has joined #commonlisp
Algernon666 has quit [Ping timeout: 268 seconds]
<mgl>
For the record, while trivial-cltl2 has reader conditionals for major implementations, so far no lisp other than SBCL implements both define-declaration and declaration-information.
<mgl>
(or if they do, then declaration-information returns NIL in the previous example)
igemnace has quit [Ping timeout: 240 seconds]
nij- has joined #commonlisp
sloanr has quit [Remote host closed the connection]
sloanr has joined #commonlisp
mon_aaraj has quit [Ping timeout: 240 seconds]
mon_aaraj has joined #commonlisp
sloanr has quit [Remote host closed the connection]
sloanr has joined #commonlisp
Algernon666 has joined #commonlisp
perrierjouet has quit [Quit: WeeChat 3.4]
perrierjouet has joined #commonlisp
jeosol has joined #commonlisp
foxfromabyss has quit [Ping timeout: 256 seconds]
sloanr has quit [Remote host closed the connection]
sloanr has joined #commonlisp
karlosz has joined #commonlisp
Algernon666 has quit [Ping timeout: 268 seconds]
karlosz has quit [Quit: karlosz]
amb007 has quit [Ping timeout: 268 seconds]
sloanr has quit [Remote host closed the connection]
sloanr has joined #commonlisp
amb007 has joined #commonlisp
varjag has joined #commonlisp
sloanr has quit [Remote host closed the connection]
sloanr has joined #commonlisp
<contrapunctus>
I was reading demo.lisp in the Clobber repository to figure out how to use it, and I'm not sure what `clobber:define-save-info` does (other than "it defines a save-info method", from the macro definition), or why (and how) client code is supposed to use it... https://github.com/robert-strandh/Clobber/blob/master/demo.lisp#L19
treflip has quit [Remote host closed the connection]
<Josh_2>
Beach is probably away from his pc now
<contrapunctus>
Josh_2: hey ^^ I see
<Josh_2>
Hi contrapunctus, how's things?
<contrapunctus>
Josh_2: same old, how is that Matrix bot coming along? 🙂️
<Josh_2>
Not much has changed with the bot, I upgraded it to the second version of my matrix-api library a few days ago which has resulted in 100% uptime since. Other than that I have not done anything with it for months
<Josh_2>
it has been serving its purpose very effectively :)
<contrapunctus>
cool 😀️
<EdLangley[m]>
Interesting, I’ve been experimenting with writing my own matrix bot
<EdLangley[m]>
Where’s this api library?
<Josh_2>
I have written a library that wraps all of the matrix api, the admin api and the spaces api
<Josh_2>
my bot is FOSS but the documentation is old
nij- has quit [Quit: Using Circe, the loveliest of all IRC clients]
<Josh_2>
contrapunctus: Currently I am designing a new MOP for use in my new project, the MOP is really awesome! Its great how you can encapsulate so much behaviour behind a simple class like interface
<Josh_2>
luv me sum compile time computing, simple az
<rotateq>
a new MOP? like a new CL standard what CL21 tries to do?
<Josh_2>
oops yes
<Josh_2>
my mistake, I am simply designing a protocol using metaclasses
<rotateq>
no problem! :)
<rotateq>
and hmm, first 2 years ago i found some cl21 ideas not bad, now i see that it violates things and you can't really rely anymore
<Josh_2>
I've never used cl21
<rotateq>
better leave it so then ^^
<edgar-rft>
we're sorry to tell that CL21 is outdated since January 1. :-)
<rotateq>
edgar-rft: nooo, 21st century :D
<Josh_2>
I like the 20th century version :P
sloanr has quit [Remote host closed the connection]
<EdLangley[m]>
I have a little thing I use to get better hash table printing
<EdLangley[m]>
Which is probably the biggest annoyance I have with CL :)
molson has quit [Ping timeout: 240 seconds]
molson__ has quit [Ping timeout: 240 seconds]
<Josh_2>
Just inspect it ;)
<rotateq>
EdLangley[m]: fair enough :) but that is more due to implementations
<EdLangley[m]>
Anyways, you can solve it with the pretty printer
<rotateq>
ah on the has-table page is this gopher link to TAoCP3 :D
<EdLangley[m]>
Load fset, then that file, the run the setup function
<Bike>
The standard doesn't require hash tables to be printed nicely or anything
<Josh_2>
alexandria:hash-table-plist ezpz
<rotateq>
as long as it's running in 30 years still the same way. or more "i was there gandalf, 3000 years ago ..."
<EdLangley[m]>
Josh_2: the pretty printer lets you control the formatting of arbitrary types
<EdLangley[m]>
Which is pretty useful here
<Josh_2>
I dont think I have noticed this problem before, I just tend to inspect hash-tables
<Josh_2>
but I suppose that is one extra click than required
<rotateq>
yes with print-object generic function for example too
<EdLangley[m]>
Yeah
<EdLangley[m]>
You shouldn’t define methods for classes you don’t own
<EdLangley[m]>
Unless you defined the generic function
<rotateq>
who "owns" there? are we in C++ landscape?
<Xach>
EdLangley[m]: that is extremely false
<Xach>
On further reflection, withdrawing "extremely"!
* Xach
goes to reflect in a corner
<gabc>
Is there even a way to have methods without the generic function?
<EdLangley[m]>
It’s just the standard advice, right? Don’t define a method for a generic function unless you control either one of the classes in the specializers or you defined the generic function.
<rotateq>
(incf *defcon-level*)
<Josh_2>
gabc: you can define methods at runtime but I do not know if this creates the generic for you
<EdLangley[m]>
Otherwise you run the risk of violating other library’s expectations.
<moon-child>
EdLangley[m]: why?
<Bike>
it's not. it's common for libraries/etc to define generic functions with the expectation that they'll be extended.
<Josh_2>
EdLangley[m]: but this is exactly how you extend the functionality of someones library
<rotateq>
gabc: no methods are instances of generic functions (or do i miss some terminology?)
<EdLangley[m]>
Bike: yeah, but my rule doesn’t rule that out
<moon-child>
suppose module X defines generic function F and module Y defines class O. I want to pass instances of O to module X. Specialising F for O seems like the obvious thing to do
<Bike>
for a standard example, it's probably not an issue to define print-object or make-load-form for someone else's class.
<EdLangley[m]>
I think this is in LUV
<gabc>
rotateq: that's my assumption, and if you don't have the generic function explicit it's made implicitely
<Bike>
methods are not instances of generic functions, but they are attached to them
<Bike>
and if you use defmethod without a previous defgeneric the generic function is indeed made implicitly
<rotateq>
yes gabc, when calling first time DEFMETHOD and the protocol checks for it. but this way you can't have another method-combination (direectly)
<rotateq>
thanks Bike
<Josh_2>
Bike: but what if you define a method without using defmethod?
<random-nick>
hmm, am I reading the spec wrong or does MOP not allow for you to define a new kind of specialization and use it in a method on a standard-generic-function?
<Bike>
Josh_2: using make-instance? then no, it's up to you
<random-nick>
well, in an useful way
<Bike>
random-nick: a new kind of specializer, you mean?
<mfiano>
With the MOP, what is the way to get all of the effective slot _names_ of a finalized class?
<random-nick>
Bike: eg. if you wanted to define a equal-specializer
<random-nick>
or something like that
<Bike>
mfiano: (mapcar #'slot-definition-name (class-slots class)) should do it
<EdLangley[m]>
There’s a second proposal for that random-nick
<Bike>
random-nick: right. that part of mop is pretty weak, yeah. there was an extension proposal for it but i don't think it was implemented
<EdLangley[m]>
Only sbcl implements it, afaik
<mfiano>
Bike: Ah, class-slots. I was searching for a symbol containing "effective"
<EdLangley[m]>
(Maybe partially, I forget the details here, but I’ve seen relevant commit messages in sbcl)
<rotateq>
oh nice, with scymtym as one author. he seems not being soo far from me in distance ^^
Oddity has quit [Remote host closed the connection]
perrierjouet has quit [Quit: WeeChat 3.4]
perrierjouet has joined #commonlisp
<_death>
moon-child: the problem is when someone else also defines an F method specialized on O.. then you have two possibly incompatible definitions.. so one solution is to create your own class MY-O that is a subclass of O and specialize on that and make sure to pass instances of that to F
Oladon has quit [Quit: Leaving.]
ec has quit [Ping timeout: 276 seconds]
ec has joined #commonlisp
cage has quit [Quit: rcirc on GNU Emacs 27.1]
<EdLangley[m]>
There is a valid use-case here when you want to bridge two unrelated libraries but this is still dangerous for the reasons _death mentions
<EdLangley[m]>
Another option would be to create an adapter system that’s intended to be the bridge
<EdLangley[m]>
To work, this would require community buy-in :)
<gabc>
At least the definition of methods are package-local, right? So if I do them in my package they aren't global, right?
<EdLangley[m]>
Or use the client technique beach uses where the generic functions have an argument specifically intended to be used by the user to switch between sets of implementations
<moon-child>
gabc: no
<moon-child>
how could they be?
<gabc>
uh good point
rgherdt has quit [Remote host closed the connection]
foxfromabyss has joined #commonlisp
morganw has joined #commonlisp
rogersm has quit [Read error: Connection reset by peer]
molson has joined #commonlisp
qeqeqw has quit [Ping timeout: 250 seconds]
nij- has joined #commonlisp
<hobo>
haha
<hobo>
oops, wrong window
<nij->
A modern webpage is similar to a interactive program hosted in the browser. If it were CL (but not JS) that dominated the web, it'd be possible to launch a slynk server from-within the webpage, and hack it through emacs. CL didn't dominate the web, but I suspect something like this is possible. Is there some script I can run from-within a webpage that effectly enables me to hack the page with CL, sly, and emacs?
jeosol has quit [Quit: Client closed]
<Josh_2>
If I have a list like '(a b c d) how can I compute every possible combination of those elements?
<Josh_2>
the order doesn't matter
<Josh_2>
just like '(a) '(b) '(c) '(d) '(a b) '(a c) '(a d) etc
<Josh_2>
'(a d) and '(d a) being equiv
<Bike>
meaning you only get (a d), or you get both (a d) and (d a)?
<_death>
(dotimes (i n) (alexandria:map-combinations fn objects :length i))
<nij->
Josh_2: (length (comb '(a b c d e f))) ; => 64
<Josh_2>
That has worked other than the nil on the end :)
<Josh_2>
I almost had yours working _death
<Josh_2>
Fortunately this will be done at compile-time so efficiency doesn't matter
<Alfr>
Josh_2, to get all (that's 2^n) subsets, you can consider the numbers 0 to 2^n-1, every number n corresponds to a selection for elements, e.g. bit i set, choose element i to be part of the n-th set.
<EdLangley[m]>
nij-: Clojurescript works like this
<Alfr>
Josh_2, that's assuming all elements are distinct in the given list.
<nij->
Josh_2: NIL is also a combination :-(
<Josh_2>
:(
<EdLangley[m]>
I haven’t really seen a CL equivalent
<nij->
EdLangley[m]: yes but it's not CL .. :'(
<nij->
EdLangley[m]: There's js+swank.. and there's parenscirpt. So I guess something like this should work.
<EdLangley[m]>
Although, it’s not too hard to rig something up with parenscript
<mfiano>
I usually do what _death suggested
<EdLangley[m]>
And there is a CL-in-js implementation
<nij->
EdLangley[m]: which impl did you mean?!?!
<mfiano>
Josh_2: something like: (let ((list '(a b c d)) (result nil)) (dotimes (i (length list)) (alexandria:map-combinations (lambda (x) (when x (push x result))) list :length i)) result)
<_death>
the way clog works is by sending arbitrary js via a websocket.. you can generate that js using parenscript
<nij->
Josh_2 just to compare the length of code.. (defun comb (list) (let ((l (length list))) (cond ((= l 0) nil) ((= l 1) (list list nil)) (t (append (mapcar (lambda (x) (cons (car list) x)) (comb (cdr list))) (comb (cdr list)))))))
<EdLangley[m]>
It’s a subset of CL, but it might be useful
<EdLangley[m]>
You can also use something like htmx and just use html over the wire
<EdLangley[m]>
And do all the logic in the backend
gaqwas has joined #commonlisp
<mfiano>
Josh_2: Also might want to nreverse the retval, if you want them in increasing order
<Josh_2>
I had to append the original list but otherwise it works, thanks mfiano
<mfiano>
APPEND? THat is usually a red flag.
<mfiano>
I dont seewhy it is needed here.
<Josh_2>
Well because I also want the original list as part of the combinations
<mfiano>
Oh do :length (1+ i)
mon_aaraj has quit [Ping timeout: 268 seconds]
rotateq has quit [Quit: ERC (IRC client for Emacs 27.2)]
<nij->
EdLangley[m]: I understand that Parentscript can turn on a server that runs its own webpage. Do you know if it can hack a page that's already running?
<Josh_2>
Okay that worked thanks
<Josh_2>
two working solutions, tyvm
<mfiano>
Not the first time zero-indexing got me today.
mon_aaraj has joined #commonlisp
<mfiano>
Josh_2: with the 1+ you can remove the WHEN test
<mfiano>
Fixed code: (let ((list '(a b c d)) (result nil)) (dotimes (i (length list)) (alexandria:map-combinations (lambda (x) (push x result)) list :length (1+ i))) (nreverse result))
<mfiano>
Also note that you can use :copy nil if you have unshared data
<mfiano>
For less consing
<Josh_2>
Thanks
mon_aaraj has quit [Ping timeout: 268 seconds]
foxfromabyss has quit [Quit: Client closed]
ec has quit [Remote host closed the connection]
mon_aaraj has joined #commonlisp
ec has joined #commonlisp
theos has joined #commonlisp
theos has left #commonlisp [holy cow]
elderK has joined #commonlisp
<EdLangley[m]>
nij-: JavaScript has eval and friends
<EdLangley[m]>
Do you can rig up a system for live code reload
<EdLangley[m]>
s/D/S/
karlosz has joined #commonlisp
mon_aaraj has quit [Ping timeout: 240 seconds]
mon_aaraj has joined #commonlisp
Algernon91 has joined #commonlisp
wyrd has quit [Ping timeout: 276 seconds]
pve has quit [Quit: leaving]
elderK has quit []
elderK has joined #commonlisp
MajorBiscuit has joined #commonlisp
foxfromabyss has joined #commonlisp
kevingal has quit [Remote host closed the connection]
VincentVega has joined #commonlisp
Algernon91 has quit [Read error: Network is unreachable]
rotateq has joined #commonlisp
VincentVega has left #commonlisp [ERC (IRC client for Emacs 27.2)]