morganw has quit [Remote host closed the connection]
varjag has quit [Quit: ERC 5.4.1 (IRC client for GNU Emacs 29.0.50)]
nature has quit [Quit: leaving]
<Josh_2>
I wouldn't be alright in Paris
<rotateq>
phew
<rotateq>
he wrote around 8h ago in #sicl as 'spiaggia' "greetings from train to paris"
occ has joined #commonlisp
<rotateq>
i've never been to paris yet
<rotateq>
better visit nice people in bordeaux first ^^
pranavats has left #commonlisp [Error from remote client]
pranavats has joined #commonlisp
Oladon has quit [Quit: Leaving.]
perrierjouet has quit [Quit: WeeChat 3.4]
Josh_2 has quit [Remote host closed the connection]
perrierjouet has joined #commonlisp
dlowe has joined #commonlisp
dlowe has quit [Remote host closed the connection]
s-liao has joined #commonlisp
ec has quit [Quit: ec]
ec has joined #commonlisp
rotateq has quit [Ping timeout: 240 seconds]
<Catie>
Hey, does anyone know if there's a way to get SLY/SLIME to insert a tilde when it auto-fills in the middle of a format control string? Or does everyone just manually insert their tildes?
<White_Flame>
My shortcut for inserting a single tilde is the tilde key (?)
<White_Flame>
what sort of autofill do you mean?
<Catie>
Oh, Emacs' auto-fill. Like when it inserts a line break right in the middle of a constant string you're writing to wrap before a certain number of characters
<White_Flame>
sorry, no clue. my emacs/slime just left-justifies if I hit enter in th emiddle of the newline instead of indenting
ec has quit [Quit: ec]
<White_Flame>
*middle of a string
ec has joined #commonlisp
<Catie>
Oh me too, but in the case I'm describing I didn't hit enter
molson_ has joined #commonlisp
<Catie>
So I've got this format control string, and it's really long. As I'm typing it in, I hit the 80 character mark, and Emacs gives me a newline. So now I've got this newline embedded in my format control string, which I do not want. To keep it from being a part of the finished string, I have to go back to where Emacs auto-filled my line and type a tilde myself. I'm wondering if that's how it is for everyone, or if ther
<Catie>
e's some sort of SLIME setting I'm missing to get what I'm deciding to call auto-tilde
<White_Flame>
I websearched for what auto fill mode is, and I've never had it. it's not on by default, is it?
<White_Flame>
and yeah, it sounds like it would mess up such string literals
<Catie>
I don't think so, but I use it all the time. I guess I also assumed most people used auto-fill-mode
<mfiano>
I can't stand auto-fill mode for programming major modes
molson has quit [Ping timeout: 250 seconds]
<White_Flame>
(I'm no emacs power user, just wanted to understand the question :) )
<Catie>
White_Flame: Oh yeah, absolutely! I can see how that whole thing was completely nonsensical if you don't use auto-fill-mode
<edgar-rft>
it's time to use the emacs power :-)
<Catie>
mfiano: Well shucks. Guess I shouldn't have assumed it was more common
<White_Flame>
edgar-rft: it's time to get past sequential streams of monospaced characters :-P
<mfiano>
Emacs! Vim! VSCode! Atom! With our powers combined...they are all subsumed by the former.
* mfiano
really feels old now, on top of lame.
<moon-child>
eight megabytes and constantly swapping
taiju has joined #commonlisp
<moon-child>
White_Flame: emacs is just sequential streams of monospaced characters with a cherry on top though
<White_Flame>
I know
<White_Flame>
I use emacs not because I think it's great, but because it happens to be the best supported CL environment
<Catie>
That's not true! It's also got the most convoluted representation of a font you can possibly imagine
<White_Flame>
*CL dev environment
<moon-child>
fructure-cl when
random-nick has quit [Ping timeout: 240 seconds]
dec0d3r_ has joined #commonlisp
dec0d3r has quit [Remote host closed the connection]
s-liao has quit [Quit: Client closed]
<ns12>
Hello, is Hunchentoot supported on FreeBSD? Hunchentoot happens to work on FreeBSD, but is that just luck or is there an effort made to support it on FreeBSD?
<EdLangley[m]>
ns12: what do you mean by "supported"
<ns12>
EdLangley[m]: The developers making a commitment of making sure that new releases don't break the functionality of Hunchentoot on FreeBSD.
<EdLangley[m]>
That sort of arrangement is relatively uncommon for any lisp library on any platform
<Bike>
does hunchentoot interact directly with the operating system, even?
<EdLangley[m]>
It probably uses usocket?
<Bike>
from a glance it uses cl-fad and usocket and stuff
<Catie>
That it runs on FreeBSD is pretty good evidence that it doesn't
<Bike>
that's where the bsd compatibility would be at issue
<ns12>
If not mistaken, Hunchentoot can also run on Microsoft Windows. But I don't know if that's just luck, or if the developers actually tested Hunchentoot on Windows to make sure that it would work on Windows.
<EdLangley[m]>
But, the underlying compatibility layers work on just about every system sbcl runs on
<Bike>
again, i think the supported operating systems would be an issue about the libraries hunchentoot uses, rather than hunchentoot itself
<Catie>
"All lisps which are supported by the compatibility layers usocket and Bordeaux Threads", is an implicit statement that it also supports the operating systems those compatibility layers support
<moon-child>
(or, perhaps more to the point, that it does not use any nonportable code aside from those)
aportnoy has joined #commonlisp
masinter has quit [Ping timeout: 256 seconds]
<mfiano>
You mean non-standard.
<mfiano>
By definition, they are portability libraries.
<White_Flame>
which use & abstract non-portable calls :)
<moon-child>
depends how you qualify 'portable', I guess
<moon-child>
by 'portable', I mean 'portable to any conformant common lisp implementation'
Bike has quit [Quit: Lost terminal]
<ns12>
I wonder what operating system the Hunchentoot developers use to run their tests.
<ns12>
But cl-test-grid only shows test results for Linux.
<remexre>
is there any reason why uiop:call-with-temporary-file would be failing to create files (with permission denied) in a directory where touch creates them just fine?
<moon-child>
strace?
<remexre>
oh, good idea
<ns12>
remexre: Are you sure that uiop:call-with-temporary-file is trying to create the file in the directory that you think it is?
<moon-child>
^ was my guess, but strace reveals all
<moon-child>
(or dtrace, if you happen to be on a Good Operating System)
<remexre>
pretty sure
<remexre>
an access() call for the path gets ENOENT, then openat(..., O_RDWR|O_CREAT|O_EXCL, 0666) gets EPERM
<remexre>
er, EACCES
<moon-child>
'The temporary file’s pathname will be [...] within directory (defaulting to the temporary-directory) if the prefix isn’t absolute'
<moon-child>
assuming you are not explicitly passing a directory, check what temporary-directory is
<remexre>
it's asdf calling it, and (based on the path) it's using the temporary I configured in ASDF_OUTPUT_TRANSLATIONS (as expected)
<remexre>
yeah, temporary-directory is a directory I also have write access to, but the strace doesn't show anything going on there
occ has quit [Ping timeout: 250 seconds]
danieli has quit [Remote host closed the connection]
danieli has joined #commonlisp
danieli has quit [Read error: Connection reset by peer]
lisp123 has joined #commonlisp
azimut has quit [Remote host closed the connection]
<sveit>
on a lighter note, is there some idiomatic way to bind a let-like list? i mean something like (destructuring-bind (name &optional value) EXPR BODY) but which works as well when EXPR is just a symbol? right now I do something like replacing EXPR with (if (listp EXPR) EXPR (list EXPR))
<semz>
Alexandria has ensure-list which does the final part
aportnoy has quit [Ping timeout: 250 seconds]
Catie has quit [Quit: Going home]
ec has quit [Ping timeout: 276 seconds]
occ has joined #commonlisp
<lisp123>
sveit: You should just write this
<lisp123>
You could have a function called SAFE-LIST
<lisp123>
Alternatively, what I do sometimes is use Generic Functions in this situation (one for EXPR being a list, one for EXPR being an atom)
<lisp123>
I used to simply coerce to list, but I find that is implicit behaviour that can cause problems way down the line. So I tend to restructure my code accordingly so sensible methods can be written for the different possibilities
<EdLangley[m]>
ENSURE-LIST from alexandria is what I use here too
occ has quit [Ping timeout: 240 seconds]
<lisp123>
(simply writing two methods, just to achieve the above you have, where the only change is for EXPR IMO is a bad way to do it, so I would look at the overall code and reconfigure to a way that makes more 'natural' sense)
occ has quit [Read error: Connection reset by peer]
lisp123 has quit [Remote host closed the connection]
spiaggia has joined #commonlisp
<spiaggia>
Good morning everyone!
waleee has quit [Ping timeout: 268 seconds]
lisp123 has joined #commonlisp
<aeth>
sveit, lisp123: What I do in that case is I use TYPECASE (or one of its ETYPECASE/CTYPECASE variants)
<aeth>
It's common and simple enough that you could probably turn that into a macro, I guess, but I don't mind having a two-line TYPECASE, where one branch has a DESTRUCTURING-BIND on a list and the other is just directly binding a symbol.
<lisp123>
Devon: Most serious Emacs packages are written in Elisp with a CL compatibility layer
<contrapunctus>
lisp123: _sobs_ yes! Yes!
<EdLangley[m]>
Another thing you could do is write all your code using explicit package prefixes like: (cl:remove-if ....)
<lisp123>
But in general it makes no sense to load Elisp in CL, because Elisp is mostly used for its API and not the language itself (and then you are entering the topic of porting Emacs into CL)
<EdLangley[m]>
Then define corresponding aliases in elisp like (defalias cl:remove-if 'cl-remove-if)
<lisp123>
contrapunctus: :D It's like an implicit acceptance that all the features of CL are actually pretty useful
semz_ has joined #commonlisp
<contrapunctus>
lisp123: When I started writing Common Lisp I was like, 'thank goodness for real namespaces, and thank goodness I never have to write `cl-loop` or `cl-first` again.'
<Devon>
Emacs C code looks like hand-compiled lisp, perhaps it could be automatically do-compiled.
<ns12>
But Schemers don't seem to be in a hurry to add CL stuff.
<lisp123>
ns12: I heard they try to implement CLOS every once in a while
<lisp123>
I like Scheme though, it has a lot of different ideas, but now its off topic so I'll get back to work
<EdLangley[m]>
EIEIO has some nice stuff
<ns12>
lisp123: MIT Scheme has SOS. But I think there is substantial opposition to a standardized object oriented framework.
<Devon>
er, do-compiled/de-compiled
<lisp123>
ns12: Yeah I heard they like to keep the overall language footprint small. Anyways, time to shut up :)
semz has quit [Ping timeout: 250 seconds]
<contrapunctus>
ns12: CHICKEN has `format`, some CLOS-likes, some `loop` -likes, keyword arguments, ...and Guile has `defmacro`
<EdLangley[m]>
&context + the derived-mode specializer is really nice for emacs configuration
<lisp123>
contrapunctus: lol indeed (re the packages & name space) (although sometimes I borrow the Emacs style of writing when I don't want to create a new package per se)
<moon-child>
I made s7 a 'loop' (+extensions I should probably port back to cl), it has 'format' already, and it has its own prototypical oo
occ has joined #commonlisp
<moon-child>
it also has first-class lexical environments, years before sicl :)
<EdLangley[m]>
I just name all my emacs stuff using : and :: to separate the "package" from the "name"
<lisp123>
EdLangley[m]: Nicely done
lisp123 has quit [Quit: Leaving...]
spiaggia has quit [Ping timeout: 240 seconds]
tyson2 has quit [Remote host closed the connection]
s-liao has joined #commonlisp
jealousmonk has quit [Quit: ERC (IRC client for Emacs 27.1)]
notzmv has quit [Ping timeout: 268 seconds]
azimut has quit [Remote host closed the connection]
azimut has joined #commonlisp
etimmons_ has joined #commonlisp
etimmons has quit [Ping timeout: 268 seconds]
aartaka has joined #commonlisp
etimmons_ is now known as etimmons
Bike has quit [Quit: Connection closed]
Bike has joined #commonlisp
mfiano has quit [Remote host closed the connection]
mfiano has joined #commonlisp
wyrd has joined #commonlisp
masinter has joined #commonlisp
jeosol has joined #commonlisp
s-liao has quit [Ping timeout: 256 seconds]
Charles[m]1 has joined #commonlisp
s-liao has joined #commonlisp
Bike has quit [Quit: Connection closed]
spiaggia has joined #commonlisp
s-liao has quit [Ping timeout: 256 seconds]
dec0d3r_ has quit [Quit: Leaving]
MichaelRaskin has quit [Quit: MichaelRaskin]
mgl has joined #commonlisp
taiju has quit [Remote host closed the connection]
wheelsucker has quit [Remote host closed the connection]
wheelsucker has joined #commonlisp
lisp123w has joined #commonlisp
<lisp123w>
Hey, so I was thinking of extending hyperspec.el for some of the other libraries I use
<lisp123w>
Is there a common project to do this? Otherwise IMO we should create one
<lisp123w>
(of course it assumes documentation is written, but at least for the packages that do have this, it will be useful)
taiju has joined #commonlisp
pranavats has left #commonlisp [Error from remote client]
etimmons has quit [Ping timeout: 256 seconds]
etimmons has joined #commonlisp
<contrapunctus>
lisp123w: slime-hyperdoc.el ?
<contrapunctus>
I couldn't find a hyperspec.el package (there's `clhs` though) or library
<contrapunctus>
...oh, it's in slime/lib/ 🤔️
notzmv has joined #commonlisp
s-liao has joined #commonlisp
<lisp123w>
contrapunctus: Yeah, that one. I had a look at hyperdoc but very complicated for something very basic. But thanks, looks like that is what its meant for
Algernon69 has joined #commonlisp
Cymew has joined #commonlisp
Algernon91 has joined #commonlisp
<lisp123w>
Reading the documentation of hyperdoc further, looks not too bad. Just need to REGISTER-DOCUMENTATION against it
<lisp123w>
Does anyone use it?
<lisp123w>
Seems like something every library writer should..
Algernon69 has quit [Ping timeout: 268 seconds]
pranavats has joined #commonlisp
<contrapunctus>
lisp123w: I'd start by 'just' adding Elisp-like docstrings (describing each argument, its possible values, and the return values) for each definition in a library...
<lisp123w>
contrapunctus: Indeed, that would be very good
s-liao has quit [Ping timeout: 256 seconds]
<lisp123w>
Anyone know if there is a slime/sly function to get package of the symbol at point, written in elisp?
<lisp123w>
Without having to connect to a lisp image
<spiaggia>
I can't see how such a thing would be possible.
<contrapunctus>
Strange... `M-x slime-documentation` is neither displaying class `:documentation` nor even a function's docstring 🤔️
<lisp123w>
spiaggia: Parse the string for a ":", if not parse the file for the most recent IN-PACKAGE, adjusting for :USE / :IMPORT-FROM / etc.? Anything I'm missing
<lisp123w>
I guess if the defpackage was in another file, then it breaks
<spiaggia>
You don't know which file the DEFPACKAGE form might be in.
<spiaggia>
Exactly.
<spiaggia>
And it typically is.
<lisp123w>
:( Oh well. Yes you are right
Jing has joined #commonlisp
<contrapunctus>
Is it a bad idea to be creating the package at the top of the Lisp file itself? ._.
<moon-child>
you would also need to figure out which symbols are in :USEd packages
<moon-child>
contrapunctus: supposing you have multiple files in one package?
<spiaggia>
contrapunctus: It is a bad idea if several source files should be in the same package.
<spiaggia>
contrapunctus: Which is typically the case.
attila_lendvai has joined #commonlisp
s-liao has joined #commonlisp
<contrapunctus>
Ah...I've been making a separate package for each file 😶️
<spiaggia>
Wow, so if two files are in the same library, client code needs to choose which package according to the file the function or class is in??
<spiaggia>
... or do you write huge files?
<moon-child>
(or small libraries?)
<spiaggia>
Or that.
<contrapunctus>
welp
<phoe>
_death: the slime/swank update link seems correct, it removes the use of SB-KERNEL:%SIMPLE-FUN-SELF which was a symbol that was removed
<phoe>
re: type specification errors, let me merge that
amb007 has quit [Ping timeout: 256 seconds]
amb007 has joined #commonlisp
masinter has quit [Ping timeout: 240 seconds]
rogersm has quit [Quit: Leaving...]
MajorBiscuit has joined #commonlisp
Major_Biscuit has joined #commonlisp
s-liao has quit [Ping timeout: 256 seconds]
MajorBiscuit has quit [Ping timeout: 240 seconds]
lisp123w has left #commonlisp [ERC (IRC client for Emacs 26.3)]
<contrapunctus>
lisp123w: imagine a Lisp file meant to be created at a project root (similar to system definitions), with a plist or alist having the keys `tutorial`, `how-tos`, `explanation`, and `reference` . Values could be strings, URLs/file paths, etc. Users could issue commands to view these, and tools could display the strings, or launch the URLs/files according to the user's configured applications.
<contrapunctus>
(Of course, such tools a probably trivial to make, but the real question is writing the docs 😜️)
<contrapunctus>
tools * are
<contrapunctus>
...hm, that'd be a useful tool for all kinds of projects, not just Lisp projects 🤔️
etimmons has quit [Ping timeout: 240 seconds]
s-liao has joined #commonlisp
etimmons has joined #commonlisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
amb007 has quit [Read error: Connection reset by peer]
<contrapunctus>
A partial example of what such a definition might look like for McCLIM - https://paste.rs/DWg
amb007 has joined #commonlisp
pve has joined #commonlisp
shka has joined #commonlisp
attila_lendvai has quit [Quit: Leaving]
dstein64 has quit [Ping timeout: 256 seconds]
dstein64 has joined #commonlisp
occ has quit [Read error: Connection reset by peer]
spiaggia has quit [Quit: ERC (IRC client for Emacs 26.3)]
karlosz has joined #commonlisp
dstein64 has quit [Ping timeout: 256 seconds]
attila_lendvai has joined #commonlisp
dstein64 has joined #commonlisp
karlosz has quit [Quit: karlosz]
s-liao has quit [Ping timeout: 256 seconds]
Jing has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
taiju has quit [Remote host closed the connection]
attila_lendvai has quit [Quit: Leaving]
lisp123 has joined #commonlisp
<lisp123>
contrapunctus: Thanks! That's some good food for thought
Jing has joined #commonlisp
rotateq has joined #commonlisp
dstein64 has quit [Ping timeout: 250 seconds]
lisp123 has quit [Ping timeout: 240 seconds]
karlosz has joined #commonlisp
karlosz has quit [Client Quit]
dstein64 has joined #commonlisp
Algernon666 has joined #commonlisp
Algernon91 has quit [Ping timeout: 268 seconds]
Lord_of_Life_ has joined #commonlisp
Lord_of_Life has quit [Ping timeout: 240 seconds]
Lord_of_Life_ is now known as Lord_of_Life
silasfox has joined #commonlisp
kevingal has joined #commonlisp
random-nick has joined #commonlisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
kevingal has quit [Ping timeout: 240 seconds]
kevingal has joined #commonlisp
kagevf_ has quit [Ping timeout: 240 seconds]
perrierjouet has quit [Quit: WeeChat 3.4]
sheb has joined #commonlisp
Algernon666 has quit [Read error: No route to host]
Algernon69 has joined #commonlisp
kagevf has joined #commonlisp
amb007 has quit [Read error: Connection reset by peer]
<flip214>
I don't need no satisfies.... just want to determine which function to run for special cases of lisp forms - so I want to distinguish (IF ...) from 2 and from a general function call, that sort of thing
<flip214>
yeah, I'd like to avoid having to manually specify a priority
<phoe>
the thing is that types only answer the yes/no question - I have no idea if there exists an algorithm for checking which type specifier is "more specific" than the other
<flip214>
well, for (T atom (cons) (cons symbol) (cons 'foo)) (and that's all I need right now, I believe) there's a sort order that's unique enough
<phoe>
hmm
<phoe>
so, first, remove all types that the value is not TYPEP of
<phoe>
then, if type A is SUBTYPEP of type B and type B is *NOT* a subtypep of type A,, remove the "larger" type
<phoe>
iterate until you have only type or until SUBTYPEP is not capable of answering anymore
tyson2 has joined #commonlisp
<flip214>
I'd hoped to get a stable list which I'd just go through until some element matches
dec0d3r has joined #commonlisp
dec0d3r has quit [Remote host closed the connection]
<pjb>
flip214: typep is not an order predicate. it's not asymetric! (loop with ss = '((CONS SYMBOL) (CONS) ATOM T) for a in ss collect (loop for b in ss collect (typep a b))) #| --> ((t t nil t) (t t nil t) (nil nil t t) (nil nil t t)) |#
<pjb>
flip214: therefore sorting with it will give you random results.
aartaka has quit [Ping timeout: 256 seconds]
perrierjouet has joined #commonlisp
<phoe>
the issue with TYPEP is that you're effectively checking if a piece of Lisp data (a type specifier) is of a given type - so e.g. CONS is going to be of type SYMBOL and not of type (CONS SYMBOL) - whereas (CONS), a type specier that's 100% TYPE= to CONS, will give you inverse results
<phoe>
so the results are effectively accidental and the real danger is that the results of that accident look useful
<phoe>
optionally improve it to remove type specifiers which are TYPE= to one another to reduce noise
<phoe>
because (EQL 42) and (INTEGER 42 42) are TYPE=
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
<_death>
phoe: well, %simple-fun-self is not %simple-fun-next.. the latter was removed in 2021 whereas the former was removed in 2017
<phoe>
_death: !
<phoe>
OK, that needs to be fixed, thank you
wyrd has quit [Ping timeout: 276 seconds]
<phoe>
do you have a commit related to the latter?
<phoe>
I swear that I mixed the two up
<_death>
I didn't try to find it
<phoe>
OK, let me have a look then
s-liao has joined #commonlisp
spiaggia has joined #commonlisp
<rotateq>
hi spiaggia :) hope you're alright over there
<spiaggia>
On the train to go back home.
<rotateq>
okay, i was also on the hop and read your greeting lately
Bike has joined #commonlisp
<phoe>
_death: fixed, thank you
aartaka has joined #commonlisp
rotateq has quit [Quit: tschav mit 'v']
s-liao has quit [Quit: Client closed]
<edgar-rft>
beach travels faster than irc :-)
Dynom has joined #commonlisp
<_death>
phoe: cool.. now we can see that slime was updated in may 2020 and the symbol was removed in feb 2021, at least according to the dates of the commits..
<_death>
phoe: do you know if the asdf patches to quicklisp libraries happened before or after the warning was instituted?
ec has joined #commonlisp
ec has quit [Client Quit]
<phoe>
_death: I mixed up two situations
<phoe>
one was related to %simple-fun-self and the other to %simple-fun-next
<phoe>
that's the reason for this hole
<_death>
phoe: yeah, I'm not talking about that
<phoe>
and I'm not able to chase and fix it at the moment, apologies
<phoe>
_death: regarding the warnings - I do not know that
<phoe>
there was a similar situation for both of these symbols
<phoe>
and if either of them are missing, it's capable of breaking slime
jpl01 has joined #commonlisp
<_death>
phoe: but it's another facet of the issue, what comes first.. the breakage or the foresight
cyberbanjo has joined #commonlisp
attila_lendvai has joined #commonlisp
spiaggia has quit [Remote host closed the connection]
spiaggia has joined #commonlisp
cosimone has joined #commonlisp
aartaka has quit [Ping timeout: 240 seconds]
santiagopim has quit [Remote host closed the connection]
spiaggia has quit [Remote host closed the connection]
spiaggia has joined #commonlisp
lisp123 has quit [Remote host closed the connection]
cosimone has quit [Read error: Connection reset by peer]
lispy has quit [Remote host closed the connection]
cosimone has joined #commonlisp
Bike has quit [Quit: Connection closed]
Bike has joined #commonlisp
cosimone has quit [Remote host closed the connection]
cosimone has joined #commonlisp
spiaggia has quit [Remote host closed the connection]
spiaggia has joined #commonlisp
Josh_2 has joined #commonlisp
rain3 has joined #commonlisp
<Josh_2>
Afternoon
jealousmonk has joined #commonlisp
vats has joined #commonlisp
domovod has joined #commonlisp
VincentVega has joined #commonlisp
waleee has joined #commonlisp
lisp123 has joined #commonlisp
djuber has joined #commonlisp
aartaka has joined #commonlisp
lisp123 has quit [Ping timeout: 256 seconds]
cage has joined #commonlisp
kevingal has quit [Ping timeout: 250 seconds]
euandreh has quit [Quit: WeeChat 3.3]
hhdave has quit [Ping timeout: 256 seconds]
euandreh has joined #commonlisp
kevingal has joined #commonlisp
cage has quit [Ping timeout: 256 seconds]
hhdave has joined #commonlisp
spiaggia has quit [Remote host closed the connection]
spiaggia has joined #commonlisp
spiaggia has quit [Client Quit]
silasfox has quit [Quit: WeeChat 3.4]
cage has joined #commonlisp
ec has joined #commonlisp
aportnoy has joined #commonlisp
occ has joined #commonlisp
mgl has quit [Quit: Client closed]
amb007 has quit [Read error: Connection reset by peer]
aartaka has quit [Read error: Connection reset by peer]
aartaka has joined #commonlisp
amb007 has joined #commonlisp
wheelsucker has quit [Remote host closed the connection]
wheelsucker has joined #commonlisp
mgl has joined #commonlisp
<Josh_2>
Slow day huh
bendersteed has joined #commonlisp
<Josh_2>
I have been having fun with MOP
aportnoy has quit [Quit: Leaving]
<_death>
CLeaning the house?
<Josh_2>
Yes I defined by house a metaclass, makes cleaning pretty easy
<_death>
what does your metaclass do?
<Josh_2>
My actual metaclass (not my house) extracts all the slots required for various combinations of processors and allows me to compile various execution paths at compile time rather than choosing them at runtime
<Josh_2>
seems to be working quite well
<_death>
I assume you mean "processors" in the "takes input, gives output" sense rather than the hardware sense?
rgherdt has joined #commonlisp
lisp123 has joined #commonlisp
amb007 has quit [Read error: Connection reset by peer]
marcoxa has joined #commonlisp
amb007 has joined #commonlisp
cgenie[m] has quit [Quit: You have been kicked for being idle]
<jeosol>
Recently seem some articles and become aware of some ASDF (update, backwards compatibility, ...) issues within our great community of lispers. Here's me saying hopefully, we can put the issues behind and reach some decision agreeable for everyone.
<jeosol>
hi phoe: long time. read your article in the above thread
<jeosol>
phoe: wedding is all done now?
<phoe>
jeosol: yes, thank you
<jeosol>
phoe: congratulations!!! my man
<Bike>
oh, congratulations.
<phoe>
I wasn't particularly vocal about it around around here
<jeosol>
You are in poland if I recall. Hope this Russian-Ukraine not affecting our Euro bros - don't mean to bring politics but looking out for our bros and girls across the pond. Hopefully it's just sabre rattling
<phoe>
nonetheless, thanks!
<phoe>
jeosol: we should continue this in #lispcafe
<phoe>
an interesting topic but not for #commonlisp
<jeosol>
ok doki phoe:
Jing has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
didi has joined #commonlisp
treflip has joined #commonlisp
<didi>
phoe: Ah, so it's not just me that miss SBCL's warning on missing generic function declarations. Also, interesting stuff about the warning when safety is off. This shows the power of compromise, I guess.
<lisp123>
didi: Whats the benefit (apart from a bit of code clarity) on missing generic function declarations, and was it a warning or a style warning?
<Josh_2>
_death: yep
<jeosol>
What is the go to library if I am looking at using queues to manage job tasks. I am trying to essentially, enqueue messages (strings) and the dequeue them say N messages at a time (if up to N) and then run the tasks encoded in those strings in parallel using N threads.
<Josh_2>
lparallel has queues
<jeosol>
cl-rabbitmq (and rabbitmq) but that seems like a lot of moving parts to manage
<didi>
lisp123: I don't remember the specifics, but it helped me organize my programs as I like to declare generic functions on the top of the file.
<rotateq>
there's damn-fast-priority-queues by phoe :P
<jeosol>
josh_2: while I am aware of lparallel, I haven't used it's queue, so will check it out. Thx
<Josh_2>
didi: I have seen beach do the same, personally I put defgenerics before the first use
<jeosol>
rotateq: really?
<rotateq>
yes really
<lisp123>
didi: Fair enough
<rotateq>
hm maybe sbcl comes with its own queues in some package
<phoe>
and then your metaclasses still don't want to mesh together
<phoe>
and only after a while you realize that this DEFMETHOD implicitly created a generic function #'CL-USER:VALIDATE-SUPERCLASS instead of adding a method on SB-MOP:VALIDATE-SUPERCLASS
<lisp123>
phoe: Thanks for the useful example
fitzsim has quit [Read error: Connection reset by peer]
<rotateq>
validate-superlisp123 :)
<phoe>
jeosol: you can try using my DFPQ with a counter to emulate a FIFO but I have no idea if it's going to work well, especially in a multithreaded environment - lparallel queue should work better and be thread-safe above all
fitzsim has joined #commonlisp
<didi>
Josh_2: Interesting. I sometimes define the methods inside the generic function declaration.
<phoe>
that works too, but you can't define everything at DEFGENERIC site if you want users to extend your method
Cymew has quit [Ping timeout: 250 seconds]
<jeosol>
phoe: well, for now, I am now trying to get a place to part the jobs and persistent of course (hence looking at rabbitmq). If everything works well, I dequeue the strings myself, and have another routine that can run then in parallel, with N specified as a variable
<phoe>
no idea if there's anything in-Lisp for doing this though that can recover from power losses and such
<jeosol>
I am getting the cl-rabbit to work with rabbitmq but has more dependencies I may not like
<jeosol>
cl-bunny (i guess was in common lisp) has many examples following the main rabbitmq tutorial, and I check one of the simple example and it works.
<jeosol>
phoe: thanks for that link. I use postgresql already, I guess write to db, after processing, if successful, remove message from db
<jeosol>
that could be approach
dstein64 has quit [Ping timeout: 256 seconds]
<phoe>
oh, then you can use it for queueing too - it's a relatively recent public discovery that one can use postgres for job queueing, and a somewhat amusing one at that
<didi>
Speaking of extending methods, I struggle between defining a top class or not. The issue rises when I want to define a default method for all subclasses. If I define a top class, I need to define a subclass of this top class if I want to use the default method. If I don't define a top class, hence define a default method without class specialization, I can just duck type.
marcoxa has quit [Remote host closed the connection]
marcoxa has joined #commonlisp
<jeosol>
phoe: reading the link, it's seems the option is more manageable appears to allow selecting N jobs without conflicts from other connections
<phoe>
didi: default method? what do you mean
<phoe>
if you define a class that isn't meant to be instantiated directly but inherited from, then you can nonetheless define a method specialized on that class
<foxfromabyss>
I would assume that `found where keyword expected getting LOOP clause after IF` is referring to `for` assignment because of `where`, but i can't spot the issue
Oladon has joined #commonlisp
<phoe>
IF (loop ...) DO (...)
<phoe>
you are missing the DO
kevingal has quit [Remote host closed the connection]
<phoe>
same stuff after ELSE
<foxfromabyss>
>_<
<phoe>
in LOOP, the DO is required
<phoe>
and I often end up forgetting that myself xD
<foxfromabyss>
the cookbok only shows examples with keywords
<Bike>
the error message is saying it expected a loop keyword like DO after the if conditional.
<phoe>
it's just too easy to forget about it
<foxfromabyss>
where do i complain so that the cookbook gets better?
<Shinmera>
I should revive that project. Got a bunch of hash-based RNGs I'd like to implement
treflip has quit [Remote host closed the connection]
karlosz has quit [Quit: karlosz]
marcoxa has quit [Ping timeout: 240 seconds]
Algernon91 has quit [Ping timeout: 268 seconds]
<sveit>
does anyone know of an example of the :interactive keyword parameter for restart-case that's relatively user friendly (prompting for multiple arguments, works with SLY/SLIME)
<jmercouris>
I don't understand why UIOP:run-program is failing for my use case: http://dpaste.com/AGRNGD6BL
<jmercouris>
if I run the exact same thing in a terminal "kill -9 76012" it will work!
marcoxa has joined #commonlisp
<phoe>
(uiop:launch-program '("kill" "-9" "1542142")) works on my machine
<phoe>
try to check the process output stream for errors maybe?
Cymew has joined #commonlisp
<jmercouris>
phoe: OK
<jmercouris>
I will try that
<jmercouris>
error output result is nil
<jmercouris>
hm
<foxfromabyss>
thanks !
didi has left #commonlisp [O bella ciao bella ciao bella ciao, ciao, ciao.]
<jmercouris>
phoe: so again, "Kill -9 77011" works in a terminal
<jmercouris>
but (uiop:run-program (list "kill" "9" "77011")) doesn't
<phoe>
are you sure the PID is still valid?
<jmercouris>
Yes
<jmercouris>
I tested first Lisp and THEN the terminal
<etimmons>
Shouldn't it be "-9"
<phoe>
s/9/-9/?
<phoe>
you are trying to kill a process with PID 9 with that command, which fails
<jmercouris>
it should be -9 yes
<jmercouris>
I thought UIOP run program somehow magically knew this
<phoe>
how can it know this
<jmercouris>
I don't know, it seems to know this
<jmercouris>
I frequently don't put dashes
<phoe>
it's not uiop, it's the underlying shell commands
<jmercouris>
well, putting the dash in helped
<jmercouris>
thanks phoe
<phoe>
run-program does no magic of its own
<jmercouris>
so apparently we frequently do not need dashes in commands, but sometimes we do?
<jmercouris>
I don't understand
<jmercouris>
well, just the unix things
<phoe>
ask your favorite unix program why it does this
ec has quit [Ping timeout: 276 seconds]
djuber` has joined #commonlisp
<jmercouris>
I will not ask
<jmercouris>
that path only leads to insanity
<jmercouris>
I just resolutely accept
ec has joined #commonlisp
<pjb>
jmercouris: options are prefixed by a dash, arguments are not.
<_death>
jmercouris: each program is free to handle the arguments passed to it as it wishes
<pjb>
jmercouris: rm -f ./-f # to forcibly (option -f) remove the file -f (argument).
<jackdaniel>
options are keywords of sorts
djuber has quit [Ping timeout: 268 seconds]
<jackdaniel>
s/keywords/keyword arguments/
kevingal has joined #commonlisp
vats has quit [Ping timeout: 256 seconds]
azimut has quit [Remote host closed the connection]
azimut has joined #commonlisp
marcoxa has quit [Ping timeout: 256 seconds]
Cymew has quit [Ping timeout: 240 seconds]
<opcode>
I have a package I wrote that I'm loading via quicklisp, but the top level defparameter'd variables aren't being set after load. Do I need to encase those in a (when eval load)?
<Bike>
no, (eval-when (eval load) ...) is essentially the default. what does your code look like?
<opcode>
At the top level it's just (defparameter *whatever* :foo)
<opcode>
And I export that in my defpackage declaration
<opcode>
But when I import that into a new file, sly complains that the variable isn't set
<phoe>
import what into a new file
<opcode>
One sec switching from phone to laptop
<phoe>
importing isn't a concept defined for files, importing is something you do to symbols
<foxfromabyss>
I am looking for a small webserver in CL. I need to parse 1 format of query string on one URL path
<foxfromabyss>
Is Hunchentoot still the go-to? Or is it overkill?
karlosz has joined #commonlisp
Oladon has quit [Quit: Leaving.]
<White_Flame>
hunchentoot is solid
<opcode>
phoe: for example i'm doing (ql:quickload "mypackage")
rain3 has quit [Ping timeout: 268 seconds]
<opcode>
where mypackage is in the local-projects repository
<opcode>
but if I try to access at the REPL e.g. mypackage:*some-global*
<opcode>
it complains the variable is unbound
<semz_>
Hunchentoot makes it pretty easy to ignore the parts you don't need
semz_ is now known as semz
<phoe>
opcode: where is mypackage:*some-global* defined?
<foxfromabyss>
i see, thanks!
<opcode>
in the top level of mypackage.lisp
<phoe>
do you have (in-package "mypackage") before you define that variable?
<opcode>
yep
<phoe>
weird, can you post your code online somewhere?
<opcode>
yeah i can do that, just gotta clean it up because it has API keys in it
<opcode>
glad to know it *should* work
<opcode>
i felt like i was taking crazy pills
<opcode>
one sec
<phoe>
oh wait
<phoe>
you have "mypackage", right? that's lowercase
<opcode>
yes i do everything in lisp lowercase
<phoe>
so you should need to access your symbol like |mypackage|:*some-global*
<opcode>
wait what
<phoe>
the Lisp reader upcases symbol names by default
<phoe>
ever wondered why, when you type 'car in the REPL, the system replies by printing CAR in uppercase?
<phoe>
package names follow the same rule
<opcode>
I just assumed it was a historical artifact like FORTRAN vs Fortran
<phoe>
(defpackage #:package ...) results in a package named "PACKAGE"
<phoe>
(defpackage "package" ...) results in a package named "package"
<phoe>
Lisp is actually case sensitive, and you discovered one of the places where it matters
<opcode>
oh for pete's peppers
<phoe>
and where it's worth to use gensyms for package names
<phoe>
so, (defpackage #:package ...) and (in-package #:package)
<phoe>
and you should be golden
<opcode>
is that what "#:foo" is? a gensym? I've never know what those are called
<opcode>
hard to google
<sm2n>
that's an uninterned symbol
<opcode>
k
<Xach>
"apparently uninterned"
<phoe>
homeless
<opcode>
k
<opcode>
like, uh, a symbol literal
<Xach>
aye
<phoe>
well, not really
<phoe>
it is a symbol literal all right, but a special one
<phoe>
it has no home package
<opcode>
ok
<opcode>
gotta pick up my 4 year old from preschool but I bet that'll fix it, thanks
<etimmons>
It's worth noting that if the package name is the issue, the error shouldn't be that the variable is unbound, it should complain about being unable to find the package
<etimmons>
Unless you also happened to define the package with the correct case earlier
kevingal has quit [Remote host closed the connection]
unyu has quit [Quit: WeeChat 3.4]
marcoxa has joined #commonlisp
White_Flame has quit [Remote host closed the connection]
White_Flame has joined #commonlisp
triffid has quit [Remote host closed the connection]
triffid has joined #commonlisp
karlosz has quit [Quit: karlosz]
shka has quit [Ping timeout: 240 seconds]
cosimone has quit [Quit: ERC (IRC client for Emacs 27.1)]
varjag has joined #commonlisp
johnjaye has joined #commonlisp
patrick_ has joined #commonlisp
attila_lendvai has quit [Ping timeout: 240 seconds]
patrick_ is now known as pm
pm is now known as karmichammer
sheb has quit [Quit: Leaving]
MajorBiscuit has joined #commonlisp
karlosz has joined #commonlisp
Dynom has quit [Quit: WeeChat 3.4]
karmichammer has quit [Changing host]
karmichammer has joined #commonlisp
<marcoxa>
Hi everybody...
<phoe>
hey hi
wyrd has joined #commonlisp
<marcoxa>
after a long time I found some thime to work on CDR, so there are some news about it (which also include phoe :) ). You can see an announcement on my blog (https://within-parens.blogspot.com/2022/01/cdr-is-next.html) where you can find the link for the new web site.
<marcoxa>
Enjoy...
<phoe>
marcoxa: is your blog linked to Planet Lisp?
<marcoxa>
Yes. But I post little. My day job gets in the way (luckily that includes inflicting Common Lisp to students).
<phoe>
OK - thanks!
<marcoxa>
Bye now... Time to sleep :)
marcoxa has quit [Quit: Time to sleep...]
wyrd has quit [Ping timeout: 276 seconds]
parjanya has joined #commonlisp
wyrd has joined #commonlisp
karmichammer has quit [Ping timeout: 250 seconds]
foxfromabyss has quit [Ping timeout: 256 seconds]
rotateq has quit [Quit: ERC (IRC client for Emacs 27.2)]
varjag has quit [Quit: ERC 5.4.1 (IRC client for GNU Emacs 29.0.50)]
cage has quit [Quit: rcirc on GNU Emacs 27.1]
karmichammer has joined #commonlisp
karmichammer has quit [Ping timeout: 256 seconds]
karmichammer has joined #commonlisp
karmichammer has quit [Ping timeout: 240 seconds]
Algernon69 has joined #commonlisp
<yottabyte>
So what do people do with large apps with lots of functions, methods, etc., when they want to make changes? I've only worked on small lisp programs. Are there like static code analyzers people set up or some way to document the code? I know Clojure has spec but I've never actually used it
<yottabyte>
Or maybe they just have a test suite which will fail if methods/functions/arguments are changed, etc.?
<pjb>
yottabyte: to be sustainable, large applications need to be structured modularly, so you can change or add those small functions without having any major impact on the rest.
<pve>
yottabyte: you could try to structure the large app so that it looks like many small lisp programs working together
karmichammer has joined #commonlisp
<pjb>
yottabyte: for example, an important point is the DRY principle. Don't Repeat Yourself. Ie. don't copy-and-paste code, but instead factorize things out so that you write a thing only in one place. Then when you want to make a change, you need to change only this one place.
<yottabyte>
And what do people do, use asdf to bundle everything together?
<pjb>
of course.
<yottabyte>
Gotcha
<White_Flame>
yottabyte: one thing to do is make sure to restart your image often