benjamindc has quit [Remote host closed the connection]
benjamindc has joined #lisp
v0|d has joined #lisp
<moon-child>
Alfr_: these functions are already in the same file
<Alfr_>
moon-child, by any chance you're loading the file directly? Can't it reproduce with (load (compile-file ..)).
<moon-child>
ah, yes, that's it. Using compile-file I get no warning
<moon-child>
thanks!
<Alfr_>
moon-child, but you still can wrap these mutually recursive defuns in a (with-compilation-unit () ..) .
<Alfr_>
... if you don't want to compile first.
jibanes has quit [Ping timeout: 256 seconds]
jibanes has joined #lisp
heisig has quit [Quit: Leaving]
judson_ has joined #lisp
frost-lab has joined #lisp
luni has quit [Quit: Connection closed]
benjamindc has left #lisp ["ERC (IRC client for Emacs 27.1)"]
matta has quit [Ping timeout: 246 seconds]
dilated_dinosaur has quit [Ping timeout: 272 seconds]
varjag has quit [Ping timeout: 272 seconds]
kuroda has joined #lisp
kuroda has quit [Remote host closed the connection]
nicktick has quit [Ping timeout: 260 seconds]
karlosz has joined #lisp
random-nick has quit [Ping timeout: 265 seconds]
judson_ has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
Colleen has quit [Remote host closed the connection]
ebrasca has quit [Remote host closed the connection]
makomo has quit [Ping timeout: 260 seconds]
Colleen has joined #lisp
judson_ has joined #lisp
<pfdietz>
Or, you can declaim the later functions to have an ftype. Or, you can make the later functions be generic, and put defgenerics at the top of the file, above the defmethods.
rgherdt has quit [Ping timeout: 260 seconds]
mrios222 has quit [Remote host closed the connection]
notzmv has quit [Remote host closed the connection]
notzmv has joined #lisp
jibanes has quit [Ping timeout: 260 seconds]
jibanes has joined #lisp
karlosz has quit [Quit: karlosz]
jjong has joined #lisp
rumbler31 has joined #lisp
rumbler31 has quit [Ping timeout: 240 seconds]
mindCrime has quit [Excess Flood]
mindCrime has joined #lisp
abhixec has joined #lisp
bitmapper has quit [Quit: Connection closed for inactivity]
asarch has quit [Quit: Leaving]
hiroaki_ has quit [Ping timeout: 240 seconds]
hiroaki has joined #lisp
hiroaki has quit [Max SendQ exceeded]
hiroaki has joined #lisp
hiroaki has quit [Max SendQ exceeded]
plisp has joined #lisp
surabax has quit [Quit: Leaving]
Jeanne-Kamikaze has quit [Remote host closed the connection]
plisp has quit [Remote host closed the connection]
hiroaki has joined #lisp
madagest has quit [Remote host closed the connection]
Alfr has joined #lisp
Alfr_ has quit [Ping timeout: 264 seconds]
contrapunctus has left #lisp ["Disconnected: closed"]
contrapunctus has joined #lisp
madage has joined #lisp
charles` has joined #lisp
thmprover has joined #lisp
skapate has joined #lisp
skapata has quit [Ping timeout: 258 seconds]
skapate is now known as skapata
<beach>
Good morning everyone!
<beach>
And a happy new year!
<thmprover>
Good morning, beach, and a happy new year to you and yours!
<beach>
Thanks.
gioyik has joined #lisp
<beach>
gendl: Starting in 2000, my colleague organized the "Libre Software Meeting" or "Rencontres Mondiales de Logiciel Libre" in Bordeaux. It was a strange "conference" where people did not pay to attend, and some where in fact invited so they had their trip paid for.
<beach>
I volunteered to chair the track called "Very high-level languages for application development", which I turned into a mostly Common Lisp track. So from the start we had danb, Krystof, gilberth, and many others present.
<beach>
This meeting was were McCLIM was essentially created. We sketched how special variables were to be implemented in the presence of threads in SBCL. danb did Bordeaux threads and maybe also ASDF then. Over a few years, probably, because we organized the LSM/RMLL for a few years in Bordeaux before it became an even that moved every year.
karlosz has joined #lisp
<beach>
Maybe Krystof remembers more stuff, and remember them better, than I do.
karlosz has quit [Quit: karlosz]
mgxm has quit [Quit: ....]
mgxm has joined #lisp
karlosz has joined #lisp
mgxm has quit [Client Quit]
mgxm has joined #lisp
orivej has joined #lisp
judson_ has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
orivej has quit [Ping timeout: 240 seconds]
orivej has joined #lisp
akoana has quit [Quit: leaving]
reggie_ has joined #lisp
<jeosol>
Good morning beach and everyone
<jeosol>
Happy new year 2021 (15 more minutes at my location)
<beach>
You too!
reggie_ has quit [Remote host closed the connection]
<ck_>
and then four hours more until the date line has swept the planet, right?
reggie_ has joined #lisp
<beach>
Something like that.
reggie_ has quit [Remote host closed the connection]
reggie_ has joined #lisp
reggie_ has quit [Remote host closed the connection]
PuercoPop has quit [Remote host closed the connection]
<ck_>
I looked it up because I wasn't sure; there are two US islands in UTC-12. And also I did the arithmetic the wrong way, it's six hours from now.
hiroaki has quit [Ping timeout: 240 seconds]
<beach>
Most islands in that zone made a choice to be among the first to celebrate the new year.
<ck_>
most as in both of them?
abhixec has quit [Ping timeout: 272 seconds]
waleee-cl has quit [Quit: Connection closed for inactivity]
<beach>
I am sure there are thousands of islands near the date line.
judson_ has joined #lisp
<ck_>
According to a map, most of them are in +12, or even +13, that's what I meant earlier, was surprised that there even are marked islands in UTC-12. But ok. I guess it's off topic unless they do lisp
<lotuseater>
there is a chance for lispers to live there
Lycurgus has joined #lisp
<thmprover>
Say, is there an abstract machine (or virtual machine) that's particularly well suited for Lisp to target?
<aeth>
(nth 8 (multiple-value-list (get-decoded-time))) ; now it's on topic-ish
<Lycurgus>
prolly the one(s) in the lisp machine implementations if any
<aeth>
ck_: Except you have it backwards.
<ck_>
aeth: what part?
karlosz has quit [Quit: karlosz]
<Lycurgus>
also any string oriented like Hendry's MINT
<aeth>
You're talking about places where (= 12 (nth 8 (multiple-value-list (get-decoded-time)))) and talking about it like it's -12 while talking about (= -13 (nth 8 (multiple-value-list (get-decoded-time)))) like it's +13
<moon-child>
thmprover: something with hw-assisted gc and cons-aware cache algorithms
<thmprover>
Lycurgus: I don't know much about the Lisp Machines, is there some "toy model" describing their architecture?
<ck_>
aeth: so your point is that I got the lisp terminology wrong with respect to delta to UTC, and 24.1.4.1?
<thmprover>
moon-child: ah, well, I'm more interested in the theory side, gc and caching are very...applied...
<thmprover>
(applied, and useful)
<Lycurgus>
thmprover, unclear what you mean but wouldn't know. FWIU, the ancient archives have complete sources
<Lycurgus>
there's prolly a description of the lisp compiler somewhere
<Lycurgus>
OTOH, i have the MINT distro tape
<thmprover>
Lycurgus: I mean, something similar to the SECD machine, in the sense of simple and minimal while demonstrating the key parts of the instruction set for a Lisp Machine. (Or is that just an SECD machine?)
<Lycurgus>
and the book can apparently be gotten on amazon
<Lycurgus>
thmprover, FWIW here's my spin
<Lycurgus>
as an implementor, in practice either you want a real lisp machine to target or you will likely prefer a pragmatic approach to produce good code on
<Lycurgus>
implicitly defined target arches
<Lycurgus>
with something like an implied vm from that approach
<Lycurgus>
that's what I've mostly seen in implementations I looked into
<Lycurgus>
only did one a port of AKCL to OS/2
<thmprover>
Lycurgus, I completely agree with you; my curiosity was strictly academic.
<Lycurgus>
and used to build cmucl before sbcl
<thmprover>
I just wasn't sure if there was some "obvious virtual machine" like CAM/FAM/ZINC for ML, but for Lisp.
<Lycurgus>
there well may be more or less
<Lycurgus>
i.e. obviously the best after the review
<Lycurgus>
and as I stated there are categories
<Lycurgus>
eg (also) SNOBOL
<Lycurgus>
also there were/are user u programmable arches like the burroughs mid range series
<beach>
thmprover: For a theoretical machine to be applicable, you also need a very simple "Lisp" language.
<Lycurgus>
which had lisp compilers
reggie_ has joined #lisp
reggie_ has quit [Remote host closed the connection]
<thmprover>
Well, I know the SECD machine can be the target for a simple-ish Lisp compiler, which piqued my interest about what needs to be added to handle more complex Lisp constructs.
reggie_ has joined #lisp
reggie_ has quit [Remote host closed the connection]
<beach>
thmprover: simple compiler, but also a very simple subset of what we think of as "Lisp" today.
<beach>
thmprover: I would think "Purely functional" to start with.
<thmprover>
beach: I should also mention, my curiosity really is strictly academic (for use in a case-study in compiler correctness)
<thmprover>
beach: so, simple Lisp is perfectly fine :)
ym555 has quit [Ping timeout: 260 seconds]
<beach>
thmprover: But then you are in trouble because 1. There is no widely agreed-upon definition of "Lisp", and 2. The channel topic is Common Lisp.
<thmprover>
beach: trouble is my business ;) In all seriousness, I've been thinking about how to move from "A simple toy Scheme interpreter" to "A simple toy Common Lisp interpreter", what would need to change.
Lycurgus has quit [Quit: Exeunt]
<beach>
thmprover: Common Lisp is such a complex language, in particular with lots of imperative constructs, that I am pretty sure that there is no simple abstract machine that will help, unless, of course, you accept that the result will be so slow that it's unusable.
saturn2 has joined #lisp
saturn2 has quit [Quit: WeeChat 1.0.1]
<thmprover>
beach: like CLISP? Yeah, I have no illusions about performance, my goal is correctness. This is more an experiment with literate programming plus formal proofs, than a fancy new tool for production.
clone_of_saturn has joined #lisp
<beach>
Way worse than CLISP.
clone_of_saturn is now known as saturn2
<beach>
thmprover: For example, you could use Church numerals for integers.
<beach>
That's very simple.
<thmprover>
beach: true, but that may be too simple. I'm looking for a happy medium between the extremely simple pure lambda calculus VM, and the complicated real world.
<beach>
That's a very tough thing to help you with, because it is not obvious what is too simple and what is too complicated for you.
<beach>
thmprover: For instance, something like RISC-V or a tiny subset of x86-64 can run Common Lisp just fine.
<thmprover>
beach: well, as I understand it (and I don't fully), a Lisp Machine boiled down to a sort of virtual machine atop a Risc processor.
<beach>
Sort of. I think it was a machine that could be microprogrammed. But the Lisp machine was not designed to be simple. It was designed to run Lisp efficiently, given the existing general-purpose processors and the compiler technology we had at the time.
charles` has quit [Ping timeout: 260 seconds]
<beach>
Take "CDR coding", for example. It makes things horribly complicated for the only reason that memory was expensive at the time.
<beach>
Didn't it also have out-of-band tag bits? Now, you can use the lower few bits of a 64-bit word without any problem, because machines are byte addressed, so there are more bits than you need.
alexshendi has joined #lisp
<alexshendi>
Hi! Good morning & happy new year.
<beach>
Hello alexshendi. You too!
<alexshendi>
I am trying to build SBCL 2.1.0 under NetBSD/arm64. I have tried to bootstrap using ecl and abcl. Both ultimately fail in the warm init phase (make-target-2.sh).
<thmprover>
beach: right, and while "CDR coding" is an important optimization, it's not a necessary component for an "abstract Lisp machine". I suppose my lack of knowledge about Lisp Machines may be the crux of my [immediate] problem.
<alexshendi>
Which pastebin can I use for this channel?
<beach>
plaster.tymoon.edu
<beach>
er, eu, not edu
<saturn2>
i believe the lisp machine had special instructions for accessing the various lisp data types, so you didn't have to choose between speed and memory safety
<beach>
saturn2: So you mean there was no need to check the type?
<beach>
But checking the type is easy these days, and type inference often makes it not necessary.
<saturn2>
no need to emit extra instructions to do that, right
<beach>
Yes, so another complication in the name of speed.
judson_ has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<lotuseater>
ah no, #\DOWNWARDS_ARROW is a valid char
judson_ has joined #lisp
judson_ has quit [Client Quit]
judson_ has joined #lisp
judson_ has quit [Client Quit]
judson_ has joined #lisp
judson_ has quit [Client Quit]
judson_ has joined #lisp
judson_ has quit [Client Quit]
skapata has quit [Remote host closed the connection]
judson_ has joined #lisp
judson_ has quit [Client Quit]
judson_ has joined #lisp
judson_ has quit [Client Quit]
judson_ has joined #lisp
judson_ has quit [Client Quit]
judson_ has joined #lisp
judson_ has quit [Client Quit]
judson_ has joined #lisp
judson_ has quit [Client Quit]
judson_ has joined #lisp
judson_ has quit [Client Quit]
judson_ has joined #lisp
judson_ has quit [Client Quit]
judson_ has joined #lisp
judson_ has quit [Client Quit]
judson_ has joined #lisp
judson_ has quit [Client Quit]
judson_ has joined #lisp
judson_ has quit [Client Quit]
<jeosol>
alexshendi: Are you trying to install a fresh SBCL?
judson_ has joined #lisp
judson_ has quit [Client Quit]
judson_ has joined #lisp
judson_ has quit [Client Quit]
<alexshendi>
jeosol: It's not in packages, so what alternative do I have?
judson_ has joined #lisp
judson_ has quit [Client Quit]
<alexshendi>
jeosol: So, yes.
judson_ has joined #lisp
judson_ has quit [Client Quit]
judson_ has joined #lisp
judson_ has quit [Client Quit]
judson_ has joined #lisp
<jeosol>
I haven't installed on a NetBSD/arm64 before. What command are you running? There is also a #sbcl channel and the guys may be able to address this.
judson_ has quit [Client Quit]
<jeosol>
which of the other implementation gave the error you linked in the pastebin?
judson_ has joined #lisp
judson_ has quit [Client Quit]
judson_ has joined #lisp
judson_ has quit [Client Quit]
judson_ has joined #lisp
judson_ has quit [Client Quit]
judson_ has joined #lisp
<alexshendi>
I have already posted on on #sbcl, thanks.
judson_ has quit [Client Quit]
nicktick has joined #lisp
judson_ has joined #lisp
judson_ has quit [Client Quit]
<alexshendi>
Actually both. Note that the error isn't from the host lisp implementation, but from the sbcl binary that was built using it.
judson_ has joined #lisp
judson_ has quit [Client Quit]
judson_ has joined #lisp
judson_ has quit [Client Quit]
judson_ has joined #lisp
judson_ has quit [Client Quit]
judson_ has joined #lisp
judson_ has quit [Client Quit]
<alexshendi>
The error message in the pastebin is actually from a build using abcl.
judson_ has joined #lisp
judson_ has quit [Client Quit]
judson_ has joined #lisp
judson_ has quit [Client Quit]
judson_ has joined #lisp
judson_ has quit [Client Quit]
judson_ has joined #lisp
judson_ has quit [Client Quit]
judson_ has joined #lisp
judson_ has quit [Client Quit]
judson_ has joined #lisp
Jach[m] has quit [Quit: Idle for 30+ days]
judson_ has quit [Client Quit]
judson_ has joined #lisp
judson_ has quit [Client Quit]
judson_ has joined #lisp
judson_ has quit [Client Quit]
gaqwas has joined #lisp
gaqwas has joined #lisp
gaqwas has quit [Changing host]
scymtym_ has joined #lisp
hendursa1 has joined #lisp
<solideogloria[m]>
<lotuseater "ah no, #\DOWNWARDS_ARROW is a va"> that is the unicode character ↓
scymtym has quit [Ping timeout: 260 seconds]
<solideogloria[m]>
not what the terminal returns to the program
hendursaga has quit [Ping timeout: 240 seconds]
mindCrime has quit [Ping timeout: 260 seconds]
shka_ has joined #lisp
gaqwas has quit [Remote host closed the connection]
pve has joined #lisp
gioyik has quit [Quit: WeeChat 3.0]
gaqwas has joined #lisp
cantstanya has quit [Remote host closed the connection]
cantstanya has joined #lisp
gproto23 has joined #lisp
gproto23 has quit [Client Quit]
galex-713 has quit [Ping timeout: 272 seconds]
toorevitimirp has joined #lisp
rotty has quit [Ping timeout: 240 seconds]
bilegeek has quit [Quit: Leaving]
orivej has quit [Ping timeout: 240 seconds]
galex-713 has joined #lisp
imode has quit [Quit: WeeChat 2.9]
imode has joined #lisp
imode has quit [Client Quit]
imode has joined #lisp
minion has quit [Remote host closed the connection]
specbot has quit [Remote host closed the connection]
rotty has joined #lisp
mindCrime has joined #lisp
imode has quit [Client Quit]
imode has joined #lisp
imode has quit [Client Quit]
imode has joined #lisp
imode has quit [Client Quit]
imode has joined #lisp
minion has joined #lisp
imode has quit [Client Quit]
specbot has joined #lisp
imode has joined #lisp
hnOsmium0001 has quit [Quit: Connection closed for inactivity]
imode has quit [Client Quit]
imode has joined #lisp
imode has quit [Client Quit]
imode has joined #lisp
imode has quit [Client Quit]
imode has joined #lisp
imode has quit [Client Quit]
imode has joined #lisp
mindCrime has quit [Ping timeout: 260 seconds]
amb007 has quit [Read error: Connection reset by peer]
imode has quit [Client Quit]
specbot has quit [Remote host closed the connection]
minion has quit [Remote host closed the connection]
imode has joined #lisp
<phoe>
is there a version of Flavors that runs on modern Common Lisp implementations?
rogersm has joined #lisp
amb007 has joined #lisp
makomo has joined #lisp
kam1 has joined #lisp
minion has joined #lisp
specbot has joined #lisp
scymtym__ has joined #lisp
<Krystof>
beach: another thing about RMLL, at least as I recall it was implemented in our track, was that the plenary-type talks did not take up all that much time (1 day of the 4 or 5, perhaps) and so the rest of the time was spent however the delegates wanted... which led to some good hacking times
scymtym_ has quit [Ping timeout: 260 seconds]
<Krystof>
it was also great because a bunch of us were able to meet in person for the first time. I'd met dan_b before (I think) but those meetings were my first encounter with gilbert, eric marsden, marc battyani, tim daly, ...
<Krystof>
andreas fuchs, maybe?
edgar-rft has joined #lisp
<beach>
Krystof: Yes, I agree it was great.
<beach>
I don't think I had met any of those before, including you.
makomo has quit [Ping timeout: 256 seconds]
imode has quit [Quit: WeeChat 2.9]
imode has joined #lisp
imode has quit [Client Quit]
varjag has joined #lisp
<Krystof>
and I had a great time! I remember going to Bordeaux twice for RMLL, and somewhere else once, I think
imode has joined #lisp
<beach>
Yeah, I went to a few other places as well. Dijon was one, and Metz.
<beach>
The entire idea was fantastic. The first year there were less than 200 participants, as I recall, but it grew to more than 1000 pretty fast.
imode has quit [Client Quit]
<beach>
It was just amazing to walk into the main entry hall of ENSERB and see all these people hacking away.
imode has joined #lisp
luni has joined #lisp
imode has quit [Client Quit]
bilal_ has joined #lisp
imode has joined #lisp
bilalkhan has quit [Ping timeout: 246 seconds]
scymtym__ is now known as scymtym
rgherdt has joined #lisp
Inline has joined #lisp
kam1 has quit [Ping timeout: 256 seconds]
luni has quit [Quit: Connection closed]
cosimone has joined #lisp
kam1 has joined #lisp
rogersm has quit [Remote host closed the connection]
random-nick has joined #lisp
sloanr has joined #lisp
vegansbane6 has joined #lisp
rogersm has joined #lisp
frgo has quit [Remote host closed the connection]
frgo has joined #lisp
bilal__ has joined #lisp
gko_ has joined #lisp
bilal_ has quit [Ping timeout: 260 seconds]
quazimodo has quit [Read error: Connection reset by peer]
rogersm has quit [Remote host closed the connection]
orivej has joined #lisp
Earendil_14 has joined #lisp
ym555 has joined #lisp
dilated_dinosaur has joined #lisp
dilated_dinosaur has quit [Client Quit]
dilated_dinosaur has joined #lisp
makomo has joined #lisp
liberliver has joined #lisp
nicktick has quit [Ping timeout: 240 seconds]
Inline has quit [Read error: Connection reset by peer]
Inline has joined #lisp
Inline__ has joined #lisp
Inline has quit [Disconnected by services]
Inline__ is now known as Inline
ebrasca has joined #lisp
lotuseater has quit [Ping timeout: 256 seconds]
imode has quit [Quit: WeeChat 2.9]
_whitelogger has joined #lisp
ym555_ has joined #lisp
ym555_ has quit [Client Quit]
amb007 has quit [Read error: Connection reset by peer]
ym555 has quit [Ping timeout: 264 seconds]
Inline__ has joined #lisp
Inline has quit [Ping timeout: 268 seconds]
pfdietz has quit [Ping timeout: 245 seconds]
amb007 has joined #lisp
surabax has joined #lisp
lotuseater has joined #lisp
Inline has joined #lisp
<zmagii>
Anyone know about the Lean programming language?
<beach>
C is a very unsafe language, whereas most Common Lisp implementations are safe by default.
<murtagh>
I see
<murtagh>
Is Common Lisp the most popular implementation of lisp?
<murtagh>
I mean more widely used?
<Cthulhux>
i think that would be scheme
<phoe>
"Lisp" is an overloaded term
<Cthulhux>
phoe: technically, ruby is a lisp..
<beach>
murtagh: There is no widely agreed-upon definition of "Lisp", which is part of the reason why this channel is about Common Lisp, which is quite well defined.
<phoe>
Lisp is a whole family of languages, including dialects like Scheme, Racket, Common Lisp, Clojure, Shen, Hy, Lisp Flavored Erlang, and what else
kam1 has quit [Ping timeout: 240 seconds]
<murtagh>
My end goal ofc is to make games no doubt
<beach>
Cthulhux: Please don't go there.
<phoe>
however you have wandered into #lisp which is a lair of Common Lisp programmers
<phoe>
##lisp is a more general channel that is about all Lisp dialects
<beach>
murtagh: I believe there is a channel #lispgames that is dedicated to games in Common Lisp.
<murtagh>
Oh ok
<murtagh>
Kk
<murtagh>
Thanks
<beach>
Pleasure. Good luck!
<Xach>
Furthermore, #lisp is the place where people who *like* common lisp congregate - not simply people who use it. It's not a support group for people who are forced to use it and hate it.
<murtagh>
Gotcha
<Xach>
Although those people do sometimes visit and ask for homework help
<murtagh>
What makes common lisp stand out.. From other lisps?
<murtagh>
I mean why do you guys like this impl for lisp
<phoe>
murtagh: it's a multiparadigm language meant for designing real-world applications
<beach>
murtagh: We just said that the term "Lisp" is not well defined.
<phoe>
I like its natural interactivity and livecoding
<Xach>
common lisp has a well-written standard, multiple mature implementations, the possibility of commercial support, examples of successful companies and applications with CL at their core (though not a zillion, they do exist), potential for fast code
<Xach>
if you like emacs, a nice development environment
<Xach>
i sometimes wish there were multiple multibillion-dollar companies racing to improve it, but then i think the result would not really be recognizable as the thing i like for very long.
hendursa1 has quit [Quit: hendursa1]
hendursaga has joined #lisp
bitmapper has joined #lisp
gxt has quit [Ping timeout: 240 seconds]
Inline has joined #lisp
VincentVega has quit [Ping timeout: 245 seconds]
luni has joined #lisp
gxt has joined #lisp
kam1 has joined #lisp
VincentVega has joined #lisp
gko_ has quit [Ping timeout: 265 seconds]
gxt has quit [Ping timeout: 240 seconds]
gxt has joined #lisp
<VincentVega>
Happy 2021, folks! A bit late to the party, but now that quickdocs is closed. what do you use? I just want to explore the existing projects. For emacs, there's MELPA which makes it easy as every project there has a very short description and you can search it.
<contrapunctus>
VincentVega: awesome-cl/cl-cookbook, but I'm just a newcomer. Would the querying functions of Quicklisp work?
kam1 has quit [Ping timeout: 260 seconds]
VincentVega70 has joined #lisp
VincentVega70 has quit [Remote host closed the connection]
VincentVega has quit [Ping timeout: 245 seconds]
<Xach>
quicklisp doesn't offer summary info
VincentVega has joined #lisp
<phoe>
quickref
<VincentVega>
phoe: ok, looks good!
kam1 has joined #lisp
ebrasca has quit [Read error: Connection reset by peer]
<VincentVega>
contrapunctus: thanks for awesome-cl, never heard of that one
ebrasca has joined #lisp
pagnol has quit [Ping timeout: 260 seconds]
birdwing has quit [Remote host closed the connection]
ebrasca has quit [Ping timeout: 246 seconds]
makomo has quit [Ping timeout: 256 seconds]
birdwing has joined #lisp
makomo has joined #lisp
izh_ has joined #lisp
attila_lendvai has joined #lisp
attila_lendvai has joined #lisp
makomo has quit [Ping timeout: 240 seconds]
attila_lendvai has quit [Ping timeout: 260 seconds]
luna_is_here has quit [Ping timeout: 272 seconds]
luna_is_here has joined #lisp
contrapunctus has left #lisp ["Disconnected: closed"]
narimiran has quit [Remote host closed the connection]
contrapunctus has joined #lisp
Josh_2 has joined #lisp
austincummings[m has quit [Quit: Idle for 30+ days]
narimiran has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
cosimone has quit [Quit: cosimone]
amb007 has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
cosimone has joined #lisp
amb007 has quit [Ping timeout: 272 seconds]
makomo has joined #lisp
amb007 has joined #lisp
FreeBirdLjj has joined #lisp
izh_ has quit [Quit: Leaving]
kam1 has quit [Read error: Connection reset by peer]
kam1 has joined #lisp
VincentVega has quit [Remote host closed the connection]
cosimone has quit [Quit: cosimone]
cosimone has joined #lisp
skapata has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
gutter has joined #lisp
<pve>
Hi! Is there a CL implementation that you would recommend for a Raspberry Pi?
<Xach>
pve: i have run sbcl and ccl, but not used them enough to endorse either one, sorry
kam1 has quit [Ping timeout: 264 seconds]
<pve>
Xach: ok thanks.. my main concern is whether sbcl or ccl are too heavyweight
<pve>
so I was thinking maybe ECL would be a good fit
<pve>
at least I'm under the impression that ECL is a bit more lightweight
<Xach>
pve: i would seriously try ccl before ecl
<pve>
Xach: hmm ok, never really tried ccl before in any serious capacity
<beach>
pve: You could ask no-defun-allowed.
perrier-jouet has quit [Quit: WeeChat 3.0]
<beach>
pve: Not here at the moment. You would have to ask in #sicl.
<pve>
beach: alright, will do, thanks
<Xach>
pve: did you have a specific task in mind?
aldessa has joined #lisp
<pve>
Xach: not really, would just like to play around with it for now
<Josh_2>
Ello
liberliver has joined #lisp
<pve>
at some point I'd like to give one to my son, but I fear he's still a bit too young for CL :)
dra has joined #lisp
<lotuseater>
i wish someone would have shown me all this stuff with 6
<aeth>
pve: Probably too low-level but you could probably hack together some 80s-style 2D game that he can just modify
v0|d has quit [Read error: Connection reset by peer]
<pve>
aeth: hey cool!
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
nullman has joined #lisp
FreeBirdLjj has quit [Remote host closed the connection]
FreeBirdLjj has joined #lisp
FreeBirdLjj has quit [Read error: Connection reset by peer]
perrier-jouet has joined #lisp
FreeBirdLjj has joined #lisp
FreeBirdLjj has quit [Remote host closed the connection]
FreeBirdLjj has joined #lisp
FreeBirdLjj has quit [Remote host closed the connection]
FreeBirdLjj has joined #lisp
FreeBirdLjj has quit [Remote host closed the connection]
Oladon has joined #lisp
Jeanne-Kamikaze has joined #lisp
aldessa has quit [Quit: Leaving]
toorevitimirp has quit [Remote host closed the connection]
judson_ has joined #lisp
<shka_>
aeth: how cool!
kam1 has joined #lisp
<phoe>
We have CL:CONSTANTP that accepts a Lisp form and a lexical environment, and answers true or false. Is it generally possible to have a hypothetical CONSTANT-VALUE operator that produces a value off a form that has been declared constant by CONSTANTP?
<jackdaniel>
phoe: yes
<jackdaniel>
i.e ecl's compiler has a function constant-value-p which returns two values: whether it is a constant, and if it is, the second value the value
<phoe>
oh! perfect
<jackdaniel>
see src/cmp/cmpopt-constant.lsp if you are interested about details
<aeth>
phoe: Portably, I guess could do something like this, which doesn't have an environment, but I think the only portable DEFCONSTANT is global, anyway: (and (constantp '+foo+) (symbol-value '+foo+))
rogersm has joined #lisp
<phoe>
aeth: portably, yes, but if an implementation answers that e.g. '(+ 1 2) is CONSTANTP, then it should be able to fetch that value
<phoe>
for use e.g. inside compiler macros
makomo has quit [Ping timeout: 246 seconds]
amb007 has quit [Read error: Connection reset by peer]
<jackdaniel>
you need a codewalker to analyae the lexenv too
<phoe>
CCL does not seem to recognize '(+ 1 2) as CONSTANTP, so that is going to work
<jackdaniel>
hence portable library does not exist
<aeth>
well, no, the codewalker will fail because you don't know what's going on
<aeth>
well, a portable one, at least
<aeth>
If you see a + it could be anything.
<jackdaniel>
you can't redefine cl functions
<aeth>
Well, I guess not because CL:+ is package-locked in SBCL and perhaps other implementations.
<phoe>
aeth: it can't be anything
<aeth>
But in general, you don't know what's going on.
<phoe>
CL functions must not be frebound
<phoe>
still, this gives me idea for writing a portalib that fills exactly this gap
<aeth>
phoe: That doesn't help the general case, only with CL:+, which was poorly chosen on my part. Unless the package you're using is package locked. It looks like Alexandria has this... #+sb-package-locks (:lock t)
<phoe>
I remember heisig complaining about this some time ago, too.
<phoe>
aeth: the general case is that I have a form, and an implementation tells me that this form is CONSTANTP
<aeth>
Idk which implementations other than SBCL implement the feature sb-package-locks, though
<phoe>
I want to get the value of that CONSTANTP form
<phoe>
possibly using implementation-dependent functionality, because it's required in the general case
<aeth>
phoe: If it's a symbol, then symbol-value, otherwise tree-walk or just slow-path.
<aeth>
But a tree-walk only works if it's package locked, otherwise it could stand for anything.
<phoe>
I don't want to manually tree-walk, I want the implementation to tell me the value
<phoe>
and so far it seems that SBCL, CCL, and ECL have functionalities for that
<aeth>
eval?
<phoe>
which means that creating a portalib for that would be viable.
<aeth>
Would eval work?
<phoe>
hmmmm
<phoe>
no
<aeth>
ah, no environment, unlike in Scheme
<phoe>
because EVAL takes no environment argument
<aeth>
In Scheme it does. :-)
<phoe>
the fact that a form is constant in some env doesn't mean it's constant in a null env
<aeth>
phoe: I guess SYMBOLP is the only thing you can do portably for the portable path, then? Since that's just global. i.e. (and (symbolp '+foo+) (constantp '+foo+)) then (symbol-value '+foo+)
<phoe>
yes
Aurora_v_kosmose has quit [Remote host closed the connection]
Aurora_v_kosmose has joined #lisp
kam1 has quit [Ping timeout: 246 seconds]
<jackdaniel>
you can't do that
<jackdaniel>
symbol-value does not accept the environment
<jackdaniel>
(constantp does)
<jackdaniel>
in other words you query the runtime, not the compilation unit symbol
jurov_ has joined #lisp
jurov has quit [Ping timeout: 272 seconds]
slyrus_ has quit [Read error: Connection reset by peer]
slyrus has joined #lisp
Lord_of_Life_ has joined #lisp
jurov has joined #lisp
Lord_of_Life has quit [Ping timeout: 256 seconds]
Lord_of_Life_ is now known as Lord_of_Life
jurov_ has quit [Ping timeout: 265 seconds]
andreyorst has quit [Ping timeout: 246 seconds]
andreyorst has joined #lisp
mindCrime has joined #lisp
gioyik has joined #lisp
v88m has quit [Ping timeout: 264 seconds]
hnOsmium0001 has joined #lisp
hiroaki has joined #lisp
<MetaYan>
The sb-cga issue that's been causing many failures in the Quicklisp reports now has a fix: https://github.com/nikodemus/sb-cga/pull/8 . Does anyone here have the possibility to merge it?
Oladon has quit [Quit: Leaving.]
andreyorst_ has joined #lisp
andreyorst_ has quit [Client Quit]
andreyorst_ has joined #lisp
xsperry has joined #lisp
makomo has joined #lisp
andreyorst_ has quit [Remote host closed the connection]
andreyorst_ has joined #lisp
judson_ has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
andreyorst_ has quit [Remote host closed the connection]
kam1 has joined #lisp
andreyorst_ has joined #lisp
birdwing has quit [Ping timeout: 268 seconds]
rogersm has quit [Quit: Leaving...]
v88m has joined #lisp
luna_is_here has quit [Quit: No Ping reply in 210 seconds.]
bendersteed has joined #lisp
luna_is_here has joined #lisp
andreyorst_ has quit [Ping timeout: 240 seconds]
andreyorst_ has joined #lisp
Aurora_v_kosmose has quit [Remote host closed the connection]
Aurora_v_kosmose has joined #lisp
rogersm has joined #lisp
attila_lendvai has joined #lisp
andreyorst_ has quit [Ping timeout: 256 seconds]
Aurora_v_kosmose has quit [Remote host closed the connection]
Aurora_v_kosmose has joined #lisp
rogersm has quit []
ebrasca has joined #lisp
attila_lendvai has quit [Remote host closed the connection]
kam1 has quit [Ping timeout: 265 seconds]
attila_lendvai has joined #lisp
jjong has quit [Ping timeout: 260 seconds]
kam1 has joined #lisp
kaftejiman has joined #lisp
andreyorst has quit [Remote host closed the connection]
mindCrime has quit [Ping timeout: 260 seconds]
h1xhk1xo has joined #lisp
h1xhk1xo has quit [Quit: Leaving]
Jeanne-Kamikaze has quit [Remote host closed the connection]
jw4 has quit [Read error: Connection reset by peer]
Aurora_v_kosmose has quit [Remote host closed the connection]
Aurora_v_kosmose has joined #lisp
jw4 has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
aartaka has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
galex-713 has quit [Read error: Connection reset by peer]
galex-713 has joined #lisp
jw4 has quit [Ping timeout: 240 seconds]
judson_ has joined #lisp
andreyorst has joined #lisp
jw4 has joined #lisp
kam1 has quit [Ping timeout: 272 seconds]
orivej has quit [Ping timeout: 240 seconds]
<makomo>
does anyone have a recommendation for a library that implements a mutable ordered set?
<phoe>
funny, I was thinking about ordered hash tables some time ago
ralt has joined #lisp
<makomo>
it's a bit annoying how fragmented the ecosystem is when it comes to data structures :/
narimiran has quit [Ping timeout: 256 seconds]
<shka_>
slyrus: i just rewrote select stuff
<Alfr>
phoe, how would that work?
<shka_>
it was way more complex then useful
<makomo>
Alfr: i suppose phoe meant ordered dictionaries/maps
<shka_>
makomo: skip-list would do?
<phoe>
Alfr: like Java's LinkedHashSet
<makomo>
shka_: i've taken a look at cl-data-structures :-), and was just about to ask you a bit about it. does the set interface have just those 3 functions? what about unions, intersections, differences?
<shka_>
yeah, they are missing :(
narimiran has joined #lisp
<shka_>
which is a shame, because i planned to add it
<shka_>
skip-lists are the best data structures for intersections actually
benjamindc has joined #lisp
<Alfr>
phoe, ah okay. It's insertion order, not inventing some H respecting < for every problem. Didn't know about it, thanks.
<shka_>
makomo: i certainly want to add unions, intersection and difference, i just didn't manage to get to it yet
<makomo>
shka_: mhm, i see. do you know of any other libraries that provide a mutable set?
<shka_>
nope, sorry
<makomo>
it's really weird to me that such a thing is impossible to find in CL :(
<shka_>
i know
<shka_>
if you want to contribute to the development of cl-ds, you are encouraged to implement the set intersection for skip-lists ;-)
rogersm has joined #lisp
rogersm has quit [Client Quit]
<makomo>
shka_: is there some sort of reference that you used while implementing the skip-list-based set or?
aeth has quit [Ping timeout: 265 seconds]
aeth has joined #lisp
<shka_>
hmmm, i think that i did this by the book
<shka_>
it is not particularly complex data structures, erase proved to be the most difficult part
liberliver has quit [Ping timeout: 272 seconds]
thmprover has joined #lisp
charles` has joined #lisp
<makomo>
shka_: any book in particular or did you just "wing it" from memory? ;)
<shka_>
makomo: by the book i meant the original article
<shka_>
describing the skip-list
<shka_>
but honestly, after you get the basic property of the one into your head, you can figure out the rest
<shka_>
*node
amb007 has quit [Read error: Connection reset by peer]
<shka_>
which is distinctly different to the tree balancing :-)
amb007 has joined #lisp
<shka_>
and RB-trees are the worst
narimiran has quit [Ping timeout: 246 seconds]
<makomo>
aha, i see
<makomo>
re rb-trees: for sure ;)
<mfiano>
what about rb-trees?
<shka_>
mfiano: they are PITA to implement
<shka_>
and equally PITA to understand
<mfiano>
balancing red-black trees is quite easy compared to other rebalancing such as AVL/WAVL
<shka_>
yeah, all autoabalancing trees are a mess
<mfiano>
Also, all self-balancing trees can be written in terms of 2 functions split and join, with the rest of the code shared among all implementations.
<shka_>
in theory :P
<mfiano>
Not in theory :)
<shka_>
seriously, internet is full of slightly broken RB trees implementations
<shka_>
anyway, good night all
<mfiano>
Maybe people should write tests to ensure the invariants. The algorithm is quite simple
<mfiano>
Just pick up a copy of CLRS and translate the pseudo code to Lisp
benjamindc has quit [Remote host closed the connection]
<mfiano>
I guess I recalled incorrectly: "all code except JOINisgeneric across the balancing schemes
<mfiano>
"
<contrapunctus>
I'm trying to write a Gemini CGI script. (I'm new to Gemini, web programming, _and_ CL. 😅) This is not a long-running application - does the "connect to remote Lisp image" workflow still make sense for it? 🤔
<shka_>
contrapunctus: i honestly don't understand your question, but connecting to the remote lisp is normally very useful
<contrapunctus>
shka_: most of the examples I've seen for remote interaction have been of programs with a constant event loop of sorts running.
<shka_>
contrapunctus: well, for what is worth i used to connect to the remote server with a decent hardware resources to crunch some data
<shka_>
no event loop involved
<shka_>
anyway, if you need to be on a remote server, then connect
<shka_>
easy
<contrapunctus>
shka_: what did your workflow look like? Start remote SBCL (running swank), create SSH tunnel, and M-x slime-connect, each time you want to work on it? 🤔
<shka_>
yeah, exactly that
<shka_>
also, set up emacs for easier debugging
<shka_>
oh, and i simply never disconnecting
luna_is_here has quit [Read error: Connection reset by peer]
<shka_>
*never did disconnecting
<contrapunctus>
And then I imagine you load your script into the remote image. Hm...
luna_is_here has joined #lisp
<shka_>
or just compile with C-c C-c
<shka_>
in emacs
<shka_>
it will send the it via the ssh tunnel and swank connection into the remote lisp
<shka_>
and use TRAMP for editing
<shka_>
eshell also works via tramp, same for magit
<contrapunctus>
Yeah...
<shka_>
so in summary, it was pretty nice
<shka_>
i recomend
<shka_>
anyway
<shka_>
bye!
<contrapunctus>
thanks, ciao
benjamindc has joined #lisp
bendersteed has quit [Read error: Connection reset by peer]
<benjamindc>
When I try to load my asd file I get an error: Execution of a form compiled with errors. Form: ("alexandria"). But when I prefix defsystem with asdf (e.g. asdf:defsystem), I don't get that error. But I see that it's standard not to use the prefix on code that I see on github. What am I doing wrong?
<Xach>
benjamindc: don't try to use LOAD to load system files.
easye has quit [Remote host closed the connection]
<Xach>
benjamindc: asdf:load-asd will work better
<benjamindc>
wonderful, that works. Thanks Xach
<Xach>
Also, I wouldn't say it's standard not to use the prefix - that is a way around the very problem you have.
<benjamindc>
Now I'm having the problem that when i run (asdf:test-system "systemname"), rove runs successfully, but doesn't run any tests.
<benjamindc>
I get "All 0 tests passed."
semz has joined #lisp
<benjamindc>
I'm using the :package-inferred-system class
frodef has joined #lisp
<frodef>
'evening
<benjamindc>
Hey frodef
<Xach>
I don't know about that, sorry. I'm not familiar with rove.
<frodef>
is there a good idiom for detecting the presence of any duplicates in a list?
shka_ has quit [Ping timeout: 260 seconds]
<frodef>
I have, basically, (= (length list) (remove-duplicates list))
<Xach>
frodef: is there any other interesting property of the list that might be exploited?
<frodef>
.. (length (remove-dupl ...)) that is.
skapate has joined #lisp
<Xach>
(it's not a sorted list of integers, is it?)
skapata has quit [Disconnected by services]
skapate is now known as skapata
<frodef>
no, the elements are rudimentary datastructures, really.
<frodef>
so there's a :TEST in there that I didn't put in explicitly.
<Xach>
a table would be faster but longer to make - i can't think of a well-known short idiom
<frodef>
ok, thanks, I was just getting this feeling I was missing something obvious :)
<Xach>
i might be missing something obvious too :~(
<frodef>
nah.. ;)
<Xach>
alexandria:has-duplicates-p
<Xach>
(does not exist)
<frodef>
In terms of efficiency I could easily whip up a simple loop, but I don't think it would be more readable/idiomatic.
<semz>
why not just write a helper function
<phoe>
frodef: duplicates under which test?
<semz>
would probably be clearer than an idiom
<phoe>
if it's eq or eql or equal or equalp I just add them into a hash table and return NIL if there's a FOUNDP
<phoe>
otherwise return T
<frodef>
phoe: general duplicates under any (provided) test.
<phoe>
no idea then
<frodef>
expected list-size in my case is about 2-4, so ... no hash-table :)
<semz>
If a function converts something to a string, is it ever a disadvantage if the resulting string has a fill pointer? I find the function much easier to write using FPs and feel it'd be silly to copy the entire thing just to end up with a simple-string.
<phoe>
semz: mostly speed I think, some code is more performant if it knows that it works on simple strings
<frodef>
semz: I can do a helper function, just that if there's already such a function or idiom, that'd be better.
<Xach>
semz: yeah, working on arrays with fill pointers is slower in general. if a consumer cares, it would have to convert.
<Xach>
it depends on the situation
<semz>
fwiw the array isn't adjustable
<semz>
still relevant?
<mfiano>
Yes
<Xach>
semz: yes
<semz>
grr
<mfiano>
It is no longer a simple-array if it has a fill-pointer
<mfiano>
and therefor not a simple-string, or perhaps even a simple-base-string
<Xach>
It can still be the right choice for you! It just helps to be aware that it's not without drawbacks.
benjamindc has quit [Remote host closed the connection]
<phoe>
CONSTANTP question: could someone provide me an example where the &environment argument passed to CONSTANTP matters? Like, where it changes the actual outcome of the function?
cosimone has quit [Quit: cosimone]
<frodef>
I guess an env could hold e.g. a symbol-macro that transforms a symbol to e.g an integer?
<phoe>
right, this is one example
<frodef>
duplicates-p: (loop for x = (pop list) while list thereis (find x list :test ...))
<frodef>
... (loop while list thereis (find (pop list) list :test test :key key))
<Xach>
frodef: points for brevity if not efficiency
edgar-rft has quit [Quit: Leaving]
<frodef>
Xach: hm.. can't really see a more efficient (general) solution, can you?
<semz>
(cons x y) has duplicates iff y contains x or y contains duplicates, so it's enough to check cdrs
<semz>
cuts the run time in half
<semz>
assuming of course that your test is symmetric
<semz>
but afaik most built-in functions barf when given asymmetric tests anyway
<frodef>
semz: I don't follow, really..?
<semz>
once you've checked for 1 in '(1 2 3), there's no need to check 2 against all of '(1 2 3) again because (test 2 1) = (test 1 2) was already done earlier
<Xach>
it popped the earlier entry
<Xach>
frodef: i bet i was too hasty, i'll think more about it
<semz>
there's no need to pop
imode has joined #lisp
<semz>
(loop for x on list thereis (find (car x) (cdr x) ...)) should do the trick
benjamindc has joined #lisp
<semz>
or member, rather than find
<frodef>
semz: that is pretty much the same, though probably less confusing.
<semz>
oh i see
aorst has joined #lisp
<frodef>
semz: the penny popped? :)
<semz>
yeah i was the one who misread, sorry
<Xach>
i like that formulation
<semz>
i'm going to shamelessly use this as an argument that my solution trips less people up :-)
<frodef>
semz: I tend to agree :)
<Xach>
you could tweak it slightly to (loop for (item . rest) on list thereis (find item rest ...))?