icepic1984[m] has quit [Ping timeout: 240 seconds]
autrim64[m] has quit [Ping timeout: 248 seconds]
Gnuxie has quit [Ping timeout: 260 seconds]
joe_fen[m] has quit [Ping timeout: 260 seconds]
rodentrabies[m] has quit [Ping timeout: 260 seconds]
Mrtn[m] has quit [Ping timeout: 260 seconds]
yitzi has quit [Ping timeout: 252 seconds]
kakuhen has quit [Ping timeout: 252 seconds]
yosef36 has quit [Ping timeout: 256 seconds]
char[m] has quit [Ping timeout: 248 seconds]
infra_red[m] has quit [Ping timeout: 248 seconds]
dieggsy has quit [Ping timeout: 248 seconds]
CodeBitCookie[m] has quit [Ping timeout: 248 seconds]
Duuqnd has quit [Ping timeout: 240 seconds]
nosolls has quit [Ping timeout: 260 seconds]
opcode has quit [Ping timeout: 240 seconds]
Guest74 has joined #commonlisp
opcode has joined #commonlisp
Brucio-61 has joined #commonlisp
rodentrabies[m] has joined #commonlisp
Gnuxie has joined #commonlisp
joe_fen[m] has joined #commonlisp
Mrtn[m] has joined #commonlisp
istewart has quit [Ping timeout: 256 seconds]
kakuhen has joined #commonlisp
autrim64[m] has joined #commonlisp
yosef36 has joined #commonlisp
yitzi has joined #commonlisp
icepic1984[m] has joined #commonlisp
CodeBitCookie[m] has joined #commonlisp
igemnace has joined #commonlisp
knusbaum has joined #commonlisp
jack_rabbit has quit [Ping timeout: 256 seconds]
joe_fen[m] has quit [Ping timeout: 250 seconds]
Mrtn[m] has quit [Ping timeout: 250 seconds]
Duuqnd has joined #commonlisp
nosolls has joined #commonlisp
pfd has joined #commonlisp
char[m] has joined #commonlisp
dieggsy has joined #commonlisp
infra_red[m] has joined #commonlisp
igemnace has quit [Quit: WeeChat 3.5]
joe_fen[m] has joined #commonlisp
igemnace has joined #commonlisp
pranavats has left #commonlisp [Error from remote client]
Mrtn[m] has joined #commonlisp
pfd has quit [Ping timeout: 252 seconds]
Bike has quit [Quit: Lost terminal]
tibfulv has quit [Remote host closed the connection]
tibfulv has joined #commonlisp
waleee has quit [Ping timeout: 248 seconds]
mrcom has joined #commonlisp
Bike has joined #commonlisp
mrcom_ has joined #commonlisp
mrcom has quit [Client Quit]
MCSH has joined #commonlisp
mrcom_ has quit [Client Quit]
mrcom_ has joined #commonlisp
<MCSH>
Hi everyone, I have an issue with running clog on sbcl. After running (ql:quickload :clog) I get the error: Symbol "MAKE-SEMAPHORE" not found in the BORDEAUX-THREADS package. I'm not sure how to proceed, can anyone give me any pointers on what I should be checking?
<MCSH>
Bike, how do I check the version? I'm pretty sure it's newer than that but it wouldn't hurt to double check
<Bike>
well, first off you can check the file to see if it has this line
<Bike>
your local bt, i mean
<MCSH>
It's version 0.8.5
<Bike>
alright, well that predates make semaphore and is like five years old
<Bike>
so probably upgrade? maybe (ql:update-all-dists)?
azimut_ has joined #commonlisp
<MCSH>
I see, I tried that already but it keeps saying "1 dist to check. You already have the latest version of "quicklisp": 2022-04-01." Is that the right command to update packages?
azimut has quit [Ping timeout: 240 seconds]
<Bike>
hm, i think so
<Bike>
was your bordeaux-threads installed by quicklisp?
<MCSH>
Yes, it's inside the quicklisp directory
<Bike>
maybe nuke it and try again?
<MCSH>
Probably I'll end up doing that...
<mrcom>
Anybody aware of recent changes in Alexandria or SBCL which could result in compile-file "don't know how to dump" errors?
<beach>
mrcom: Is that the full message?
yauhsien has joined #commonlisp
<Alfr>
MCSH, does (asdf:system-source-directory :bordeaux-threads) show you the expected bt?
<mrcom>
No... some details--I've got a FOO structure, and one compilation unit creates a constant of that type with (alexandria:define-constant FOO-CONST (make-foo blah blah)).
<mrcom>
That file compiles to fasl and loads OK.
<mrcom>
A second file has a form (make-array howmany :elment-type 'FOO :initial-element FOO-CONST).
<mrcom>
compile-file on it results in "error: don't know how to dump #<FOO :MYID 0> (default MAKE-LOAD-FORM method called)."
<mrcom>
Honest officer, I didn't change a thing. I think...
<Bike>
might have been sbcl. you should probably define a make-load-form method there regardless.
<beach>
Also, the :ELEMENT-TYPE 'FOO is not going to have any effect I think.
<mrcom>
Yeah, it'll get promoted to T.
<Bike>
there's "optimization: fasls containing standard object literals are now smaller and load more efficiently." in the news
<mrcom>
But I tend to specify types for everything; it's often let SBCL complain about something dumb I did.
<mrcom>
Hmm. Maybe it's now pulling the literal into the second fasl at compile time and used to use the symbol?
<mrcom>
I've asked on #sbcl too...
<MCSH>
Bike, Nuking did not work
<Bike>
you quickloaded it again and still got this ancient version?
<MCSH>
I reinstalled quickload and still got the ancient version
<MCSH>
Alfr, Ah! It seems like no, it's loading another version from /usr/share, I have no idea which package installed it though, but that should give me a good lead
<MCSH>
That seems to have solved it, thank you both.
MCSH has quit [Remote host closed the connection]
<Nilby>
it seems when people get weird old versions it's mostly installed by debian
semz_ has joined #commonlisp
karlosz has joined #commonlisp
semz has quit [Ping timeout: 248 seconds]
karlosz has quit [Ping timeout: 246 seconds]
semz_ is now known as semz
slowButPresent has quit [Quit: ERC 5.4 (IRC client for GNU Emacs 28.1)]
ttree has quit [Read error: Connection reset by peer]
yauhsien has quit [Ping timeout: 240 seconds]
Bike has quit [Quit: Connection closed]
siabard__ has quit [Quit: Leaving]
pfd has quit [Ping timeout: 252 seconds]
Inline has quit [Quit: Leaving]
yauhsien has joined #commonlisp
yauhsien has quit [Remote host closed the connection]
yauhsien has joined #commonlisp
pfd has joined #commonlisp
yauhsien has quit [Remote host closed the connection]
yauhsien has joined #commonlisp
tyson2 has quit [Remote host closed the connection]
yauhsien has quit [Ping timeout: 240 seconds]
istewart has joined #commonlisp
yauhsien has joined #commonlisp
yauhsien has quit [Remote host closed the connection]
<jackdaniel>
you just replace {}[]()begin,end with uniform pair (), and pull the operator inside the list (instead of leaving it in front of the expression)
<jackdaniel>
parent thesis demistified
yauhsien has joined #commonlisp
zacque has quit [Quit: Goodbye :D]
<horroar>
Let's make it simple. dbotton: Did you figure my use of the term "the jew in charge" was hostile?
<jackdaniel>
it is enough that I consider it hostile, hang on, let me log in
<horroar>
jackdaniel: You really don't get to choose for jews; that's the real hostility.
jackdaniel has quit [Changing host]
jackdaniel has joined #commonlisp
horroar was banned on #commonlisp by jackdaniel [*!*roar@66.205.193.*]
horroar was kicked from #commonlisp by jackdaniel [\o]
horroar has quit [Quit: WeeChat 3.3]
<jackdaniel>
if you ever wondered, password managers do wonders with recalling, ehm, passwords
horroar has joined #commonlisp
<rotateq>
Thank you jackdaniel, as I've seen it similar. But maybe more operator effort is now needed.
<jackdaniel>
I don't think that I have permission to set operators
<jackdaniel>
(except for ephereral rights that vanish after reconnect)
<jackdaniel>
or to be exact, after rejoin to the channel
<jackdaniel>
either way, in my expierience, trolls after a few bans got bored; the thing that feeds them is attention
<jackdaniel>
so we should be good ,)
<jackdaniel>
s/ephereral/ephemeral
<rotateq>
What often works too is talking about mathematics.
<jackdaniel>
I don't understand this remark
<rotateq>
For scaring people away without intention. :)
<jackdaniel>
I don't think that there is such strong negative correllation between knowing math and behaving unacceptable, but that's offtopic either way
<rotateq>
Am I allowed to get us back to ontopic with a CLOS question I had in mind?
<jackdaniel>
go for it!
<rotateq>
When I use the :type option to specify another type than T for a slot and then again in a DEFCLASS form that inherits this slot, the two types are connected by AND.
<rotateq>
How would it be done that it does it with OR or replaces it completely?
<jackdaniel>
you can't - consider that you define an animal as a being with a brain
morganw has joined #commonlisp
<jackdaniel>
and then you define the foobarzaur, that is an animal but without a brain
<rotateq>
Good, that's an answer that fulfills me equally. :)
xantoz has joined #commonlisp
xantoz has quit [Client Quit]
xantoz has joined #commonlisp
<jackdaniel>
great; I have a thing to say about auxiliary methods and code maintainability - having them greatly increases a risk of non-obviosu bugs ,p
<jackdaniel>
(since we are at clos topic)
<rotateq>
And how a slot can be defined and behaves is defined via standard-effective-slot-definition and generic functions like slot-value-using-class, right?
<rotateq>
Oh okay.
<jackdaniel>
but sure, they are handy to /write/ code
<rotateq>
auxiliary methods are some that are needed in some other that are visible to the outside? just that i get it right
<jackdaniel>
I think that the slot protocol has more functions
<jackdaniel>
you have primary methods and auxiliary methods. the latter are :after, :before and :around
<rotateq>
ah okay then I know of course what you mean ^^
<jackdaniel>
probably there could be more if you are really interested in more esoteric method combinations
<rotateq>
:before-before, :after-after :D
yauhsien has quit [Read error: Connection reset by peer]
yauhsien has joined #commonlisp
pok has quit [Ping timeout: 276 seconds]
tyson2 has joined #commonlisp
azimut has quit [Ping timeout: 240 seconds]
random-nick has joined #commonlisp
xaotuk has quit [Ping timeout: 260 seconds]
xaotuk has joined #commonlisp
Brucio-61 has quit [Ping timeout: 240 seconds]
scymtym has quit [Ping timeout: 240 seconds]
yauhsien has quit [Remote host closed the connection]
<shka>
UIOP/LAUNCH-PROGRAM not present in ECL
<shka>
possible to implement?
<shka>
jackdaniel: i bet you know
ebrasca has quit [Remote host closed the connection]
Inline has quit [Quit: Leaving]
<jackdaniel>
wasn't uiop advertised as a stand alone library that you may pull from quicklisp? ,p
<jackdaniel>
just clone uiop to ~/quicklisp/local-projects and it will upgrade itself
Oddity has quit [Ping timeout: 252 seconds]
<jackdaniel>
I'm not planning to update asdf since 3.2 release (and forward) broke too many things - afaik these are still not fixed
<jackdaniel>
s/since/, since/
Lord_of_Life_ has joined #commonlisp
<jackdaniel>
(as in - important things for ecl, not some user-facing features)
<jackdaniel>
monotlithic builds is one
<shka>
jackdaniel: well, i feel like i miss something, you mean that uiop/launch-program is actually implemented for ECL?
Lord_of_Life has quit [Ping timeout: 256 seconds]
<jackdaniel>
afaik yes, in upstream uiop
<shka>
got it
<shka>
thanks
<jackdaniel>
that said I'd advise using run-program directly
Lord_of_Life_ is now known as Lord_of_Life
<jackdaniel>
last time I've checked launch-program and run-program in uiop had some horrible indirection ingrained
<shka>
oh
Inline has joined #commonlisp
varjag has joined #commonlisp
tyson2 has quit [Remote host closed the connection]
jmdaemon has quit [Ping timeout: 276 seconds]
<contrapunctus>
jackdaniel, what's a monolithic build? A statically-linked binary?
<shka>
would be nice to have a good portability layer for just run/launch program
<jackdaniel>
contrapunctus: yes, there were some problems with gather-op on recompilation too
<jackdaniel>
(because it tried to pack .so files in a single archive), but I think that this one is ifxed
<zacque>
Oh, ya, the test should be done at runtime
<jackdaniel>
fourt and fourthmost, cursory glance at this code is enough for me to feel compelled to give you an advice - don't bother with macros until you get a good grasp of programming without macros
<jackdaniel>
(programming in common lisp that is)
<jackdaniel>
otherwise all you'll manage to do is getting confused
<flip214>
jackdaniel: but confusion is the best way to realize how much there's still to learn!
<jackdaniel>
I have my doubts about that
<flip214>
Got me a good one when I wrote a macro that declares a class and a WITH-macro for that class
<flip214>
jackdaniel: well, how would you see that you don't understand something - unless you feel confused?
<jackdaniel>
I don't feel confused about rust, but I'm aware that I don't know anything about it ,)
<jackdaniel>
also, there is a difference between being confused by something new and confusing oneself with going too deep into the water
<zacque>
> "what makes you think that an atom doesn't need evaluation" <= Oh, makes sense! I'm being naive here. I thought simply comparing the symbol to NIL will do...
<zacque>
Thanks, I thought I'm ready for it. Ha!
xaotuk has joined #commonlisp
<jackdaniel>
if you want to check whether something has a known value at compilation time, you may do (when (constantp <foo>) (eval foo))
<jackdaniel>
s/<foo>/foo/
<zacque>
No, I want to define the semantics of IF with Common Lisp
<zacque>
For learning purpose
<rotateq>
zacque: But did you learn the basics by now? Or that the lambda list of CL:IF is (test then &optional else).
<rotateq>
Or ok not 'the' but 'some'.
<rotateq>
What would make a bit more sense can be to think about how to write IF with COND or COND with IF if this level is yet achieved. Or how WHEN and UNLESS are written.
<zacque>
Thanks! My confusion comes from me thinking that special operators in Lisp have to be defined as macros...
<zacque>
I'm not even sure where does that thinking come from!
<rotateq>
pjb: Looks like in the Baker paper. :)
<jackdaniel>
special operators may be defined by a wizard inside the implementation, they don't have to follow rules
<yitzi>
zacque: its usually the other way around. macros rely on special operators.
<rotateq>
zacque: No, you can view them as elementary, we have 25 special operators. Macros are programs that generate other programs.
<zacque>
With that realisation, I think I can define it easily as a function wrapper around CL:IF, see: https://paste.debian.net/1240695/
<zacque>
Since NIL is not yet defined to evaluated to itself, I'll simply check (EQ <FOO> 'NIL)
<jackdaniel>
what makes you think that nil does not evaluate to nil?
<jackdaniel>
perhaps you are in a situation, when the value of <foo> is not known to be nil at compilation time?
<zacque>
It does! But just that I haven't define that in the environment
<zacque>
Oh, maybe the first thing I should do is define NIL to evaluate to NIL and T => T...
<Bike>
IF as a function does not work. with your if, (if t (print "a") (print "b")) prints both.
<zacque>
Bike: Ah, you're right!
Inline has quit [Quit: Leaving]
<zacque>
I'll digest the solutions provided by jackdaniel and pjb
<_death>
one could define a FIF function.. it would receive test, consequent, and alternative functions, and pick which of the latter two to call based on the result of calling the first
<jackdaniel>
zacque: my solution is wrong
<jackdaniel>
because and/or are basically IF :)
<zacque>
Thanks! I'll check it later, gtg
zacque has quit [Quit: Goodbye :D]
<jackdaniel>
but it has plenty of parens and lambdas, so it is very lispy
Inline has joined #commonlisp
Guest74 has joined #commonlisp
<yitzi>
jackdaniel: +10000 points for lispiness. :)
<jackdaniel>
\o/
scymtym has quit [Ping timeout: 252 seconds]
rotateq has quit [Quit: ERC (IRC client for Emacs 26.3)]
attila_lendvai has quit [Ping timeout: 260 seconds]
dlowe has joined #commonlisp
scymtym has joined #commonlisp
Brucio-61 has joined #commonlisp
pve has joined #commonlisp
bastardbuddha has left #commonlisp [ERC 5.4 (IRC client for GNU Emacs 28.1)]
<dbotton>
jackdaniel: thanks, I saw the msg on phone this morning but ignored it.
<jackdaniel>
no need to thank me, harassing trolls gives me a kick
xaotuk has quit [Ping timeout: 260 seconds]
xaotuk has joined #commonlisp
tyson2 has joined #commonlisp
prokhor__ has quit [Ping timeout: 240 seconds]
cage has joined #commonlisp
xaotuk has quit [Ping timeout: 256 seconds]
varjag has quit [Quit: ERC (IRC client for Emacs 26.3)]
<lagash>
counter-trolling?
aeth has quit [Ping timeout: 256 seconds]
aeth has joined #commonlisp
<bollu>
Does common lisp allow one to wrap advice around any function?
<mrcom>
For anyone who so my msg about "can't dump..." (and cares), it appears that SBCL started treating a DEFCONST struct object as a literal in (more) places.
rotateq has joined #commonlisp
<beach>
bollu: Common Lisp does not have "advice".
<Bike>
bollu: there is no standard defadvice
<edgar-rft>
bollu: not in the emacs sense, in Common Lisp you can use :before, :after, and :around methods instead
<jackdaniel>
afaik ccl, lw and acl have such extension exported
<bollu>
I see
<jackdaniel>
and sbcl has it in its internals
<bollu>
edgar-rft Can I use the `:before method on any `defun`?
<jackdaniel>
no, :before is for generic functions with a standard method combination
<bollu>
mm
<edgar-rft>
bollu: no, only on defgeneric and defmethod
<bollu>
okay, thank you!
<jackdaniel>
if you declaim your function notinline, then you may replace it with a trampiline
<jackdaniel>
there you could put your advices at the expense of performance penatly for a trampoline
<jackdaniel>
(and for not inlining the code)
<mrcom>
What I was depending upon was it being treated as a singleton, so I had a latent bug in my code.
<bollu>
maybe this is an XY problem. I want to add some logging around my calls to `uiop:run-program`. I can just search and replace `uiop:run-program` with `run-program-wrapper`. I was hoping I could use some CL facility to make this nicer
tyson2 has quit [Remote host closed the connection]
<dlowe>
You could wrap uiop in a my-uiop package.
<dlowe>
and then use my-uiop:run-program, which would then call uiop:run-program
<dlowe>
you could also abuse sbcl's TRACE extensions which allow you to invoke a function
<_death>
probably a good idea to wrap it in your own function
tyson2 has joined #commonlisp
ec has joined #commonlisp
Bike has quit [Quit: Connection closed]
<bollu>
How does slime actually talk to common LISP? Where is the API documented?
<jackdaniel>
the api is not really documented, but slime has two components
<jackdaniel>
slime (emacs lisp library) and swank (common lisp library)
<White_Flame>
it is a socket connection, swank usually listens to a localhost-only port
<jackdaniel>
and they communicate via a socket (there are other models of communication)
<bollu>
jackdaniel What protocol do they speak over the socket?
<bollu>
HTTP?
<bollu>
zeromq?
<bollu>
something else? :)
<jackdaniel>
SWANK protocol
<bollu>
I see
<bollu>
where can I read some documentation about the SWANK protocol?
<beach>
Didn't Xof create an implementation for R as well?
<White_Flame>
if you have the repl and *slime-events* visible, and you enter (+ 1 1) in the repl, you'll see messages for the parameter documentation for #'+, as well as the presentation rendering for the results
tyson2 has quit [Remote host closed the connection]
<White_Flame>
max 16MB message length
pve has quit [Ping timeout: 246 seconds]
<jackdaniel>
after that it starts swapping :)
<White_Flame>
eight megawords and constantly swapping
<White_Flame>
(or I guess megashorts in this architecture)
<bollu>
=)
<bollu>
Naive question: why is there no """21st century""" Common LISP IDE if it seems somewhat easy to talk to a LISP Repl via SWANK?
<White_Flame>
there have been slime connectors in eclipse and such
<bollu>
I see
<rotateq>
just 21st century? and when it comes to 01.01.2100?
<jackdaniel>
you may use (I've heard) vscode to work with cl
<jackdaniel>
there is also lsp-server being developed, but I don't know about its state
<White_Flame>
but it's also more of an editor than an IDE, eg no project management, no connection between files, etc
<jackdaniel>
there are atom, sublime and vim packages working with swank
<bollu>
Right
<beach>
bollu: I guess it's because nobody wrote such a thing.
<bollu>
I'm reasonably happy with emacs; I was more wondering about the state of the ecosystem
<bollu>
beach mm, understood
<Demosthenex>
bollu: sorry, how is emacs not a "21st century" editor?
<jackdaniel>
bollu: I've mentioned numerous well regarded IDE programs that have support for common lisp
<White_Flame>
I, for one, am a reluctant emacs user because it's simply the common case for lisp dev
<Demosthenex>
it's the ultimate nanotech swiss army chainsaw from the future
<beach>
bollu: We are (very slowly) working on such a thing, but it won't use a wire protocol to talk to a Common Lisp implementation. It will run in one.
<rotateq>
What's with climacs?
<beach>
rotateq: Second Climacs would perhaps be one component of such a thing.
<rotateq>
Okay.
Bike has joined #commonlisp
<bollu>
beach by "it will run in one", do you mean the IDE will run within a common lisp implementation?
<beach>
Correct.
<Demosthenex>
that only makes sense.
<beach>
Well, at least one participant in this channels has said something to the effect of "I will NEVER use an IDE that runs in the same Common Lisp image as the code being developed."
<rotateq>
Sounds like a statement from Dijkstra.
<rotateq>
like his statements with APL
<rotateq>
beach: Did this participant give a reason?
<jackdaniel>
that's not unreasonable given that lisp images happen to get corrupted. I know that SICL plans to make a "safe" system that may always recover itself from user program errors, but people act on things they know
<beach>
I think the reasoning is that the Common Lisp system might crash, and then you would also lose your editing session. But then, I think the Common Lisp system should be fixed so that it doesn't crash.
<jackdaniel>
perhaps this person will change their attitude when they will learn that sicl is indeed that sturdy
<beach>
It is true that many (all?) current implementations allow the programmer to do unsafe things, and then it could indeed crash.
<_death>
an operating system can enforce process quotas and limit their effect on the rest of the system.. if you want everything to be in a single Lisp image, you probably need to implement such mechanisms
<jackdaniel>
16GB and swapping
<beach>
_death: I think there are several possible levels of safety. At the very least, the system should not crash as a result of a silly mistake such as blowing the call stack or allocating too much live data.
<Demosthenex>
jackdaniel: clearly you've met my windoze vm.
<beach>
_death: But if the programmer really wants to do things like FFI, then it is hard to prevent I guess.
<mrcom>
bollu: When you're comparing development environments you're really comparing, for example, Java+Jetbeans vs. Lisp+Emacs.
<_death>
beach: right, but a crash is not the only scenario.. consider (loop) for example
<beach>
Yeah, that's another silly mistake that must be allowed without a disastrous result.
<mrcom>
"Wouldn't it be nice if you could do a one-click refactor and rename a function." Yep, it would.
<mrcom>
However, that's a relatively simple thing for Java. You basically just replace one set of text with another. All of the code needs to be parsed, but it's just static text in the end.
<mrcom>
Lisp development, on the other hand, is a living, breathing thing. Typically you're right in the middle of an actively running program.
Everything has joined #commonlisp
<mrcom>
Just replacing the text is theoretically more complicated. Technically, you need to handle reader macros, compiler macros, normal macros. All of which can arbitrarily modify not only the text but the state of the program.
<White_Flame>
also when renaming a defun, there might be symbol-only references to it, etc
<mrcom>
In addition, your live image already has references to the thing in question.
<mrcom>
Yeah.
<White_Flame>
however, these are complexities that the IDE should assist with, not just leave you to text buffer editing as it does now :-P
<_death>
or no references at all.. (funcall (read))
<mrcom>
Emacs basically throws up its hands as being too intractable a problem and just lets you change text characters.
<jackdaniel>
(loop (print (eval (read))))
<mrcom>
It also lets you include tooks (like Slime) to modify things on the fly.
yauhsien has quit [Remote host closed the connection]
<mrcom>
White_Flame: Yep, but a very daunting problem. I think it's been addressed piecemeal with... Emacs code.
<White_Flame>
how?
<mrcom>
Slime mainly.
<White_Flame>
what part?
<White_Flame>
I've not seen any feature that would do this
<mrcom>
meta-. for example.
<White_Flame>
that doesn't help
<mrcom>
Oh but it does. It just doesn't *fix*.
<jackdaniel>
it is true that lisp implementations maintain various pieces of image information
<White_Flame>
I would see something like walking you through all locations of a symbol, and giving you quick access to change them to the new name vs leave it as is, if it's not a function call or #' reference to the symbol
<jackdaniel>
i.e who-calls-function and source location could be used to identify pieces of text that would need to be changed and recompiled
<White_Flame>
of course, direct function calls and #' references should change automatically
<White_Flame>
plus, it should also auto-undefine the current fdefinition
<White_Flame>
as leaving the old function around is a big source of bugs, too
<mrcom>
White_Flame: What about calls to alexandria:symbolicate?
<White_Flame>
right, those are less tractable
<White_Flame>
however, those often don't hit static function names
<mrcom>
Yep. Piecemeal.
<White_Flame>
or I should say literal function names
<mrcom>
BTW, I'm agreeing with everyting you're saying. It's just daunting.
yauhsien has joined #commonlisp
<Guest74>
I'd love to live in a world where a perfect programmable common lisp editor existed that could be run in your main process.
<lagash>
bring back Lisp machines!
<Guest74>
meanwhile, I'm constantly reminded of the negative consequences of running my window manager in my main process.
<mrcom>
Well, there's MCCLIM.
yauhsien has quit [Ping timeout: 256 seconds]
<Demosthenex>
i'm on stumpwm. rock solid.
<Demosthenex>
and i'm flattered they accepted my spatial navigation module into their contrib repo
<Demosthenex>
i'm worried about trying mu4e in emacs for email, because mutt is always up. i can't imagine also using an emacs WM.
<Guest74>
I should probably look at how stump manages errors because of nonconforming apps. asynchronous clx errors are a nuisance. I'm not sure what the experience of emacs wm users is, i think there's one of them around here somewhere.
slowButPresent has joined #commonlisp
<_death>
in fact you could try and do general Lisp development in the stumpwm process, to find out about possible issues :)
slowButPresent has quit [Client Quit]
<Catie>
I think I've done that, and boy have I found possible issues
karlosz has joined #commonlisp
<Guest74>
it's mainly when i'm doing window manager dev that stuff goes sideways.
<_death>
yeah, I've a binding to start swank there, that's sometimes useful
epolanski has quit [Quit: Connection closed for inactivity]
Everything has left #commonlisp [#commonlisp]
<_death>
however I need to remember to disconnect from it and connect to a new lisp process..
<Catie>
That's the part that bites me too
<_death>
,sa oops
<Guest74>
i know the logically thing is to start a new process, but
<Catie>
Hope you didn't have any important windows open
karlosz_ has joined #commonlisp
<jackdaniel>
that's one of a few things that lisp-based environment could help - you could adopt disconnected frames again without forsaking their state
<Guest74>
my main problem is if something crashes and emacs doesnt save changes to some buffers and i have no clue which of those buffers it is.
karlosz has quit [Ping timeout: 256 seconds]
karlosz_ is now known as karlosz
karlosz has quit [Client Quit]
<horroar>
Neither does emacs, or it would have saved the changes :^)
<horroar>
I don't think you'll get the result you want, which is certainty, without developing in a new process or VM, Guest74.
horroar was banned on #commonlisp by jackdaniel [*!*boar@66.205.193.*]
horroar was kicked from #commonlisp by jackdaniel [horroar]
<Guest74>
but i like everything living in the same image. what I dislike is the tooling.
<_death>
probably smalltalkers faced the same issues
<jackdaniel>
damn, I'm getting faster with bans by minute, it is true that practice makes a champion
<_death>
apply for k-line privileges
<jackdaniel>
where's the fun in that ;)
<jackdaniel>
well, if it becomes a bother I will probably contact someone, but next step would be banning by ip I suppose (if they didn't get that they are not welcome here)
waleee has joined #commonlisp
karlosz has joined #commonlisp
pfd has quit [Ping timeout: 252 seconds]
karlosz_ has joined #commonlisp
karlosz has quit [Ping timeout: 256 seconds]
karlosz_ is now known as karlosz
karlosz has quit [Quit: karlosz]
slowButPresent has joined #commonlisp
slowButPresent has quit [Changing host]
slowButPresent has joined #commonlisp
Guest74 has quit [Ping timeout: 276 seconds]
tyson2 has joined #commonlisp
ec has quit [Quit: ec]
ec has joined #commonlisp
ec has quit [Client Quit]
ec has joined #commonlisp
analogsalad has quit [Quit: bye]
<jmes>
If I have a list of symbols, say '(a b c) where they refer to 1 2 & 3, how do I get at those numerical values? I know I could use (list a b c) but I must access the symbols themselves and their values
<Catie>
SYMBOL-VALUE would get you the global binding
<jmes>
Catie: Ah, that's exactly what I was looking for, thanks! I knew there was a function but my memory (and searching) failed me
<Catie>
Yeah, no worries!
yauhsien has joined #commonlisp
borodust has quit [Ping timeout: 260 seconds]
yauhsien has quit [Ping timeout: 240 seconds]
ns12 has quit [Quit: bye]
<pjb>
jmes: (loop for name in '(a b c) collect (position name #(nil a b c))) #| --> (1 2 3) |#
ns12 has joined #commonlisp
<bollu>
Can I get a list of all symbols in slime, for a quick "go to this symbol"
karlosz has joined #commonlisp
<_death>
(apropos-list "") is an interesting way to get stuck ;)
<_death>
seems due to list-delete-duplicates*
treflip has quit [Quit: zzzzzzz]
borodust has joined #commonlisp
<_death>
anyway it consists of around 404K elements
<_death>
with my image
slowButPresent has quit [Quit: ERC 5.4 (IRC client for GNU Emacs 28.1)]
<pjb>
bollu: slime is emacs lisp code. There's no package in emacs lisp, so it's hard to filter out symbols "in slime"…
<pjb>
bollu: you could do (let (l) (do-symbols (s) (when (and (<= 5 (length (symbol-name s))) (string= "slime" (subseq (symbol-name s) 0 5))) (push s l))) l)
yauhsien has joined #commonlisp
tyson2 has quit [Remote host closed the connection]
<pjb>
bollu: now, if you think about it, you could perhaps refine your question. For example, often what one would want is a list of command in the current mode. C-h m would give you that. It may be more useful than asking silly questions.
azimut has joined #commonlisp
analogsalad has joined #commonlisp
yauhsien has quit [Remote host closed the connection]
yauhsien has joined #commonlisp
Oddity has joined #commonlisp
<_death>
what's interesting is that had sbcl's apropos-list had used remove-duplicates rather than delete-duplicates, it wouldn't have lost so bad.. the latter seems optimized for space efficiency (don't cons) at the price of time complexity
yauhsien has quit [Ping timeout: 246 seconds]
<_death>
another weird thing about its definition is that it uses pushnew if a package designator is provided, again giving bad time complexity
istewart has joined #commonlisp
pfd has joined #commonlisp
yauhsien has joined #commonlisp
istewart has quit [Ping timeout: 252 seconds]
yauhsien has quit [Ping timeout: 256 seconds]
yauhsien has joined #commonlisp
karlosz has quit [Quit: Client closed]
yauhsien has quit [Remote host closed the connection]
yauhsien has joined #commonlisp
pfd has quit [Quit: Client closed]
jeosol has joined #commonlisp
yauhsien has quit [Remote host closed the connection]
mfiano has quit [Quit: WeeChat 3.5]
mfiano has joined #commonlisp
kpoeck has joined #commonlisp
pfd has joined #commonlisp
aartaka has quit [Ping timeout: 246 seconds]
yauhsien has joined #commonlisp
aartaka has joined #commonlisp
yagamisato has quit [Ping timeout: 248 seconds]
yagamisato has joined #commonlisp
yagamisato has joined #commonlisp
yagamisato has quit [Changing host]
yauhsien has quit [Ping timeout: 256 seconds]
Guest74 has joined #commonlisp
rotateq has quit [Ping timeout: 260 seconds]
akoana has joined #commonlisp
n1to has joined #commonlisp
rogersm has quit [Quit: Leaving...]
rotateq has joined #commonlisp
morganw has quit [Remote host closed the connection]
cage has quit [Quit: rcirc on GNU Emacs 27.1]
ebrasca has joined #commonlisp
aartaka has quit [Ping timeout: 256 seconds]
slowButPresent has joined #commonlisp
Dynom has quit [Quit: WeeChat 3.5]
Guest74 has quit [Quit: Connection closed]
kpoeck has quit [Quit: Client closed]
kiki_lamb has joined #commonlisp
jeosol has quit [Quit: Client closed]
easye` has joined #commonlisp
dlowe has quit [Remote host closed the connection]
kpoeck has joined #commonlisp
aartaka has joined #commonlisp
pfd has quit [Quit: Client closed]
yauhsien has joined #commonlisp
kpoeck has quit [Quit: Client closed]
kpoeck has joined #commonlisp
dra has joined #commonlisp
aartaka has quit [Ping timeout: 256 seconds]
analogsalad has quit [Quit: bye]
yauhsien has quit [Remote host closed the connection]
yauhsien has joined #commonlisp
tyson2 has joined #commonlisp
kpoeck has quit [Quit: Client closed]
yauhsien has quit [Ping timeout: 256 seconds]
n1to has quit [Quit: Leaving]
pfd has joined #commonlisp
kpoeck has joined #commonlisp
xaotuk has joined #commonlisp
yauhsien has joined #commonlisp
luna-is-here has joined #commonlisp
Madsy has quit [Ping timeout: 246 seconds]
orestarod has quit [Ping timeout: 252 seconds]
dec0d3r has joined #commonlisp
prokhor__ has joined #commonlisp
yauhsien has quit [Remote host closed the connection]
yauhsien has joined #commonlisp
yauhsien has quit [Ping timeout: 265 seconds]
Sankalp has quit [Ping timeout: 240 seconds]
Sankalp has joined #commonlisp
yauhsien has joined #commonlisp
szkl has quit [Quit: Connection closed for inactivity]
yauhsien has quit [Remote host closed the connection]
yauhsien has joined #commonlisp
yauhsien has quit [Ping timeout: 252 seconds]
xaotuk has quit [Ping timeout: 240 seconds]
random-nick has quit [Ping timeout: 246 seconds]
dra has quit [Ping timeout: 252 seconds]
prokhor_ has joined #commonlisp
prokhor__ has quit [Remote host closed the connection]