<aeth>
I guess it's a bit early to ask, but will there be an ELS 2021?
<White_Flame>
electronic lisp symposium?
<aeth>
well, yeah, the next question is if it will be physical or not
<Gnuxie[m]>
It's a good question because the goverment consistently mishandles covid and brexit
rig0rmortis has quit [Quit: beep boop]
<no-defun-allowed>
I don't know how long I'd have to prepare beforehand to get from down under to Cambridge.
dbotton has joined #lisp
shifty has joined #lisp
cyraxjoe has quit [Quit: No Ping reply in 180 seconds.]
cyraxjoe has joined #lisp
EvW has quit [Ping timeout: 260 seconds]
iissaacc has quit [Ping timeout: 256 seconds]
kaftejiman has quit [Remote host closed the connection]
Inline has quit [Ping timeout: 272 seconds]
tfunnell has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
JohnTalent has joined #lisp
tfunnell has joined #lisp
<JohnTalent>
What is a good web framework for Common Lisp?
<moon-child>
JohnTalent: afaik clack and hutchentoot are popular. (Haven't made anything beyond a toy webapp in cl, so can't properly vouch for either.)
<JohnTalent>
moon-child: ok! :)
<dbotton>
what is key difference between them?
<JohnTalent>
Is there a non-duck types version of Common Lisp?
<JohnTalent>
s/types/typed
<no-defun-allowed>
Common Lisp isn't duck typed to begin with.
<moon-child>
JohnTalent: as far as static typing goes, there's https://github.com/stylewarning/coalton and typed racket. But nothing pure cl as far as I know
<JohnTalent>
no-defun-allowed: quack!
<no-defun-allowed>
JohnTalent: Is that so?
<sm2n>
JohnTalent, what exactly do you want?
<sm2n>
types are used for different purposes
<Bike>
there's only one version of the stand
<Bike>
ard
<JohnTalent>
sm2n: Not to have a stateful system using types.
<sm2n>
how are the statefullness of your system and types related?
<JohnTalent>
opps.
<JohnTalent>
I mean not to have states, but using types but using lisp.
<JohnTalent>
sm2n: It's a conjunction, not a union.
<Bike>
what are you talking about.
<JohnTalent>
Bike: programming languages, what are you talking about?
<sm2n>
you want to write code that uses immutable data structures, that also has types, in lisp?
<JohnTalent>
sm2n: exactly.
<Bike>
immutability is orthogonal to duck typing, no?
<sm2n>
sure, you can do that, just don't use setf, etc
<Bike>
and please don't blow me off, i'm trying to help, here.
<sm2n>
which is a common feature from the ml family
<JohnTalent>
Bike: The ability to have mutable structures cannot optimize for a true stateless system.
<Bike>
i'm just saying that if what you want is immutability, we'll be more helpful if you say you want immutability.
<sm2n>
generally, you can approximate any pure functional idiom to some extent in cl, but it will always fall short somewhere
<JohnTalent>
sm2n: Interesting. Thanks. I know a little haskell, but appreciate lisp's readability over Haskell.
<Bike>
as far as i know no lisp implementation does deforestation optimizations.
<sm2n>
if you want a lisp that makes heavy use of immutable data structures, I would recommend racket
<JohnTalent>
sm2n: neat, didn't know.
<sm2n>
there is also clojure but I can't recommend that in good conscience
<JohnTalent>
Doesn't sound like it's pure though.
<sm2n>
racket is a family of languages
<moon-child>
what's wrong with clojure?
<bhartrihari>
JohnTalent: Owl Lisp is pure, I think. But it's not as popular.
<JohnTalent>
yeah, clojure is just tapes and glue *trying* as much as possible to be pure.
<JohnTalent>
bhartrihari: !! :)
<sm2n>
moon-child, I haven't used it myself so I can't recommend it, and afaik it still gives you java stack traces
<sm2n>
I don't want to start a language war however
<moon-child>
sm2n: I don't actually know clojure; I was just curious
<sm2n>
anyway, it sounds like cl is not what you want JohnTalent, so I would suggest looking elsewhere
<no-defun-allowed>
(Also, there aren't many types in Clojure, so that'd be no good anyway.)
<bhartrihari>
sm2n: So does one need to understand java to be able to debug clojure code?
<sm2n>
I can't fathom why you'd have such requirements though
<sm2n>
that is my understanding, bhartrihari, but I have never used it personally
_whitelogger has joined #lisp
<no-defun-allowed>
Well, the original LISP (note upcased) was pure. But why?
<sm2n>
shen, I guess
<aeth>
SBCL (a CL implementation) has some degree of static typing through type declarations
<aeth>
You can technically get immutability and types with DEFSTRUCT... :read-only slots with a certain specified :type... Of course, it would be a non-optimized immutability, unlike, say, Haskell
<no-defun-allowed>
But why do you need a pure language? It's quite to draw up an "immutable" subset of Common Lisp.
epony has quit [Quit: system upgrades again]
<aeth>
no-defun-allowed: you either have optimized immutability (some CL libraries) or you have compiler-enforced immutability (e.g. the hypothetical struct that I just described), but you can't have both unless the language supports it.
<aeth>
I doubt it's a common enough idiom for implementations to bother optimizing... i.e. getting read only data structures via structs with all slots as read-only
<aeth>
This is absolutely what structs are for, though. Letting implementations be able to optimize it.
shinohai has quit [Read error: Connection reset by peer]
sympt has quit [Read error: Connection reset by peer]
jesse1010 has quit [Ping timeout: 240 seconds]
Alfr_ has joined #lisp
zaquest has quit [Quit: Leaving]
zaquest has joined #lisp
kapil_ has joined #lisp
Alfr has quit [Ping timeout: 240 seconds]
contrapunctus has left #lisp ["Disconnected: Replaced by new connection"]
contrapunctus has joined #lisp
contrapunctus has left #lisp ["Disconnected: Replaced by new connection"]
<beach>
Good morning everyone!
contrapunctus has joined #lisp
Stanley00 has joined #lisp
saganman has joined #lisp
Bike has quit [Quit: Lost terminal]
epony has joined #lisp
sts-q has joined #lisp
igemnace has joined #lisp
shifty has quit [Ping timeout: 256 seconds]
kreyren_ has quit [Ping timeout: 240 seconds]
ex_nihilo has joined #lisp
<bhartrihari>
Good morning beach, and everyone else!
sts-q has quit [Ping timeout: 256 seconds]
mindCrime has quit [Ping timeout: 240 seconds]
sts-q has joined #lisp
mindCrime has joined #lisp
mindCrime has quit [Ping timeout: 260 seconds]
<cjv>
Goodnight ;)
sz0 has joined #lisp
<beach>
cjv: Are you new here? I don't recognize your nick.
<cjv>
yeah I joined a few days ago
<beach>
Great! Welcome! What brings you to #lisp?
gravicappa has joined #lisp
<cjv>
oh just been writing a bunch of scheme lately
<cjv>
wanted to keep an eye on the common lisp folks too :-P
<beach>
Oh! Sorry to inform you that this channel is dedicated to Common Lisp.
<beach>
Ah, OK. :)
<cjv>
I'm aware
_whitelogger has joined #lisp
<cjv>
I personally don't write in a fully functional style
Oladon1 has quit [Quit: Leaving.]
<beach>
I see.
<cjv>
I was benchmarking SBCL and chez scheme recently on some toy tasks and was surprised to find they are almost exactly the same speed
<beach>
What kind of "tasks"? Numeric?
<beach>
Since what we do with CLOS is not "object-oriented" in the sense that Alan Kay meant it, and it is not "object-oriented" in the sense that Java or C++ do it, maybe we should call it something else, perhaps "protocol-oriented".
<cjv>
yeah, CLOS is very different from everything else out there
<beach>
For SBCL, you need to think about the OPTIMIZE settings. They could greatly influence the result, both in terms of performance and in terms of semantics.
<beach>
I guess that's true for other implementations as well, but I have less experience with those.
<cjv>
Yes, I should definitely profile it and figure out what is going on.
<beach>
For numerical code, you may want to read the paper(s) by Didier Verna. He managed to get the same performance out of SBCL for some problems, that he got out of GCC.
<cjv>
I'll take a look at that
<cjv>
I'm thinking of switching my code over to CL just because the library situation is so much better :)
<cjv>
Didier's website is so cool!
<beach>
I see. CLOS is not something you are thinking of making good use of?
<cjv>
I would start using it if I switched.
<beach>
OK.
<cjv>
Right now, I'm just using records.
MichaelRaskin has quit [Quit: MichaelRaskin]
<no-defun-allowed>
(I would call Smalltalk, Self, Erlang et al message passing-oriented, Java and C++ vtable-oriented, and CLOS generic function-oriented.)
<beach>
Hmm. OK.
<no-defun-allowed>
I didn't think about it very long, but that's roughly how each group is polymorphic.
<beach>
Sounds right.
<cjv>
Common Lisp is more multiple dispatch no?
<beach>
Indeed.
<no-defun-allowed>
Yes, generic functions allow for multiple dispatch and method combination.
<beach>
The "vtable" thing captures the class orientation vs the prototype orientation, but the name suggests implementation too much.
<no-defun-allowed>
Sure.
<beach>
In fact, I think C++ could benefit from not using tables at all, but instead my fast-dispatch technique. Especially when there is "diamond" inheritance, which complicates vtables as I recall.
<beach>
I seem to remember that a two-level vtable solves that problem, but that's even more memory access involved.
skapata has quit [Quit: Leaving]
<no-defun-allowed>
cjv: What I usually do is start by using standard classes and accessors where I'd use "records", then if and only if that representation is too slow, then I use structure classes or some specialised representation.
<moon-child>
is it poor form to use ` and , instead of list?
<moon-child>
(that is, `(,x ,y ,z) instead of (list x y z))
<no-defun-allowed>
The former lets you update classes while you're still testing things out, and accessors are also generic functions. (Note that structure classes, as well as any other class, can be dispatched on.)
<beach>
moon-child: Not really, no.
<no-defun-allowed>
It really depends, but I usually only use quasiquotation when constructing code. The purpose is to suggest what the list structure produced "looks like", so if it looks clearer to you, then you should use it.
<cjv>
no-defun-allowed That's good advice, thank you.
<no-defun-allowed>
The one advantage defstruct has over defclass is that it's less typing (though it picks accessor names that you may not like), so it may also be useful to define a macro for some shorthand DEFCLASS if you are picking slot initargs that the computer could pick for you.
shifty has joined #lisp
<White_Flame>
defstruct has performance and possibly footprint advantages, too
<White_Flame>
but semantically, right
<no-defun-allowed>
That is true; I should say "the one non-situational advantage", but if you're a fast typer and like repeating yourself, defclass/defstruct syntax might not be a problem.
<beach>
I wonder how much heisig's work on sealing and fast generic functions can compensate for that advantage.
ym555 has joined #lisp
<White_Flame>
if you can't inline it, not really
<beach>
I think his work makes it possible.
<White_Flame>
oh right, sealing. That could
<no-defun-allowed>
Probably quite a bit; but accessing the slot of a standard-instance requires one more memory access than a structure, no?
<beach>
Usually, yes. But maybe not with sealing?
<no-defun-allowed>
Oh, would he seal a class by inserting the slot vector inline in its instances, instead of using a reference to the slot vector?
<beach>
I don't know the details, but I am not excluding that possibility either.
<no-defun-allowed>
Okay, I didn't think that sealing could apply there before.
<beach>
It is still early in the morning for me, so I may not be able to think it through (yet).
<beach>
Not that I would take advantage of such a possibility anyway. :)
krid has quit [Ping timeout: 272 seconds]
<White_Flame>
but still, what we get with defstruct slot access is an inline mov dest, [src+slotoffset]
<no-defun-allowed>
Don't worry about it then.
<beach>
White_Flame: You would need to check the type as well, no?
<White_Flame>
if the type is declared/known/optimized
<White_Flame>
when I'm reading disassemblies, it's nearly always in a fixed-type block of code
<beach>
I see.
<beach>
Oh, and then we need to think about the interaction with the garbage collector. I think we have a tendency to forget that.
<White_Flame>
read/write barriers?
<White_Flame>
those should be fixed overhead no matter the purpose/style of the read/wrote
<White_Flame>
*write
<beach>
That's not what I was thinking about right then, but sure.
<beach>
Yeah, sure.
mathrick has joined #lisp
<beach>
Right then I was thinking of the cost of copying, but I guess copying or not might be an orthogonal decision as well.
phantomics has joined #lisp
narimiran has joined #lisp
zacts has joined #lisp
jprajzne has joined #lisp
iissaacc has quit [Ping timeout: 240 seconds]
myall has quit [Ping timeout: 244 seconds]
Necktwi has quit [Ping timeout: 256 seconds]
zacts has quit [Quit: leaving]
wxie has joined #lisp
_whitelogger has joined #lisp
<phoe>
morning
<easye>
hey ho, Mr. phoe
whiteline has joined #lisp
beach` has joined #lisp
<no-defun-allowed>
Hello phoe.
beach has quit [Disconnected by services]
beach` is now known as beach
karlosz has quit [Quit: karlosz]
daphnis has joined #lisp
gaqwas has joined #lisp
bilegeek has quit [Quit: Leaving]
Cymew has joined #lisp
Kaisyu has joined #lisp
bitmapper has quit [Quit: Connection closed for inactivity]
ljavorsk_ has joined #lisp
Necktwi has joined #lisp
toorevitimirp has quit [Ping timeout: 265 seconds]
frgo has quit [Remote host closed the connection]
gaqwas has quit [Remote host closed the connection]
aartaka has joined #lisp
iissaacc has joined #lisp
saganman has quit [Ping timeout: 240 seconds]
liberliver has joined #lisp
saganman has joined #lisp
saganman has quit [Client Quit]
jonatack has quit [Ping timeout: 260 seconds]
pve has joined #lisp
aartaka has quit [Read error: Connection reset by peer]
aartaka_d has joined #lisp
aartaka has joined #lisp
aartaka_d has quit [Ping timeout: 240 seconds]
rogersm has joined #lisp
saganman has joined #lisp
cjv has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
EvW has joined #lisp
cjv has joined #lisp
hendursa1 has joined #lisp
sz0 has quit [Quit: Connection closed for inactivity]
hendursaga has quit [Ping timeout: 240 seconds]
scymtym has quit [Ping timeout: 240 seconds]
EvW has quit [Ping timeout: 240 seconds]
davepdotorg has joined #lisp
wxie has quit [Ping timeout: 240 seconds]
frgo has joined #lisp
iissaacc has quit [Ping timeout: 265 seconds]
iissaacc has joined #lisp
cjv has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
daphnis has quit [Ping timeout: 260 seconds]
sts-q has quit [Quit: :ttl ( xyz )]
hendursa1 has quit [Ping timeout: 240 seconds]
sts-q has joined #lisp
hendursa1 has joined #lisp
rogersm has quit [Ping timeout: 244 seconds]
glamas has quit [Ping timeout: 240 seconds]
jonatack has joined #lisp
igemnace has quit [Ping timeout: 240 seconds]
spacebat2 has quit [Ping timeout: 240 seconds]
spacebat2 has joined #lisp
aartaka_d has joined #lisp
liberliver has quit [Quit: liberliver]
liberliver has joined #lisp
aartaka has quit [Ping timeout: 265 seconds]
glamas has joined #lisp
igemnace has joined #lisp
schweers has joined #lisp
rogersm has joined #lisp
scymtym has joined #lisp
EvW has joined #lisp
cosimone has joined #lisp
gaqwas[m] has left #lisp ["Kicked by @appservice-irc:matrix.org : Idle for 30+ days"]
cosimone_ has joined #lisp
cosimone has quit [Read error: Connection reset by peer]
cosimone_ is now known as cosimone
EvW has quit [Ping timeout: 244 seconds]
Mandus has quit [Ping timeout: 272 seconds]
Mandus has joined #lisp
rippa has joined #lisp
user2 has joined #lisp
user2 is now known as decentyousername
Lord_of_Life_ has joined #lisp
Lord_of_Life has quit [Ping timeout: 260 seconds]
Lord_of_Life_ is now known as Lord_of_Life
motersen has joined #lisp
IPmonger has quit [Quit: ZNC 1.7.5+deb4 - https://znc.in]
IPmonger has joined #lisp
_whitelogger has joined #lisp
Inline has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
galex-713 has quit [Ping timeout: 272 seconds]
Necktwi has quit [Read error: Connection reset by peer]
galex-713 has joined #lisp
jonatack has quit [Ping timeout: 265 seconds]
EvW has joined #lisp
iissaacc has quit [Ping timeout: 258 seconds]
dbotton_ has joined #lisp
dbotton has quit [Ping timeout: 240 seconds]
paul0 has quit [Quit: Leaving]
decentyousername has quit [Ping timeout: 240 seconds]
Inline has quit [Ping timeout: 240 seconds]
jonatack has joined #lisp
jonatack has quit [Read error: Connection reset by peer]
shangul has joined #lisp
decentyousername has joined #lisp
shinohai has quit [Ping timeout: 260 seconds]
gensym has joined #lisp
motersen has quit [Ping timeout: 272 seconds]
motersen has joined #lisp
ljavorsk_ has quit [Ping timeout: 256 seconds]
shinohai has joined #lisp
ggole has joined #lisp
EvW has quit [Ping timeout: 240 seconds]
EvW has joined #lisp
orivej has joined #lisp
<madnificent>
Very glad I finally got a hold of a printed copy of PCL. It's much nicer in printed form than in the online form I read ages ago. Would love to get hold of Closer-MOP too. If anyone has pointers to that (preferably in hardcover) I'm all ears.
<madnificent>
I try not to by from huge internet giants if possible.
liberliver has quit [Ping timeout: 240 seconds]
<jackdaniel>
is there a book titled closer-mop?
<jackdaniel>
or did you mean "the art of the metaobject protocol"?
<madnificent>
The art of the metaobject protocol. Sorry
Stanley00 has quit [Remote host closed the connection]
<madnificent>
Yeah! sorry. Was too excited about PCL I'm afraid ^_^
aartaka_d has quit [Read error: Connection reset by peer]
aartaka has joined #lisp
dbotton has joined #lisp
dbotton_ has quit [Ping timeout: 260 seconds]
hendursa1 has quit [Quit: hendursa1]
hendursaga has joined #lisp
blackadder has quit [Ping timeout: 256 seconds]
wsinatra has joined #lisp
kaftejiman has joined #lisp
shinohai has quit [Ping timeout: 258 seconds]
decentyousername has quit [Quit: WeeChat 2.3]
kaftejiman has quit [Remote host closed the connection]
dbotton_ has joined #lisp
EvW has quit [Ping timeout: 244 seconds]
dbotton has quit [Ping timeout: 272 seconds]
Inline has joined #lisp
jonatack has joined #lisp
jw4 has quit [Read error: Connection reset by peer]
dbotton_ has quit [Ping timeout: 272 seconds]
jw4 has joined #lisp
wsinatra has quit [Quit: WeeChat 2.9]
wsinatra has joined #lisp
dbotton has joined #lisp
EvW has joined #lisp
ebrasca has joined #lisp
Kaisyu has quit [Quit: Connection closed for inactivity]
saganman has joined #lisp
<saganman>
Hello. Morning Everyone
<jackdaniel>
hey
<saganman>
I'm living in emacs now.
<jackdaniel>
my condolences
<saganman>
lol, it is not bad
<saganman>
slime on left and irc on right
<jackdaniel>
sweet lemon, sour grapes
<jackdaniel>
s/lemon/lemons/
<saganman>
the book I'm reading says programmers prefer car, cadr over first, rest, why is that so?
<jackdaniel>
it is probably the book's author preference "imposed" on programmers
<Xach>
saganman: it is not so
<phoe>
which book is that
<jackdaniel>
semantically they have quite different meaning
<Xach>
saganman: what book is it?
<jackdaniel>
car cadr etc are cons accessors, first rest etc are list accessors
<saganman>
ah sorry, I misread
shinohai has joined #lisp
<saganman>
sorry Xach, nevermind
cg505_ has quit [Ping timeout: 240 seconds]
<Xach>
saganman: i remain interested in the book's title and author, even if it was a misread
<saganman>
Xach: It is Lisp by Horn and Winston
<phoe>
oh gods that's an ancient one
<saganman>
Oh
<phoe>
I haven't seen the third edition
<saganman>
I have the third edition.
<phoe>
I must have missed it, too
<phoe>
I didn't notice the third edition until now
<saganman>
I'm revising the basics, it has been years since I have written any code.
<madnificent>
I read about it too when I was learning lisp. The reasoning I read at the time stated that it's easier to combine with cadr caadr cddr etc. I guess there are cases where you'd prefer car and cadr, but probably not when treating a cons cell as part of a list.
<saganman>
phoe: back then I read this was the best lisp book
<madnificent>
saganman: I'd highly advise Practical Common Lisp if you want something hands-on and still going at a good pace.
<saganman>
madnificent: here the book says cad, cdr are still allowed because of their composite use
<saganman>
madnificent: thanks, I'll get that
<Xach>
the third edition has some good stuff
<Xach>
it covers clos nicely iirc
<Xach>
(w&h that is)
<Xach>
i also like horn's full name, "berthold klaus paul horn"
<saganman>
lol, that is his name
<saganman>
what's the command to clear slime screen?
<phoe>
C-c M-o on my machine
<saganman>
same
<saganman>
thanks, I'll make note
dbotton_ has joined #lisp
Necktwi has joined #lisp
aartaka_d has joined #lisp
dbotton has quit [Read error: Connection reset by peer]
gargaml has joined #lisp
dbotton has joined #lisp
scymtym has quit [Ping timeout: 244 seconds]
aartaka has quit [Ping timeout: 240 seconds]
parisienne___ has joined #lisp
Alfr_ has quit [Quit: Leaving]
Bourne has joined #lisp
Alfr has joined #lisp
parisienne___ has quit [Client Quit]
bitmapper has joined #lisp
<dlowe>
When I was learning, I tried On Lisp by pg, Lisp by Horn and Winston, and CLtL2, and only the last did anything for me.
<jackdaniel>
my first book (after few chapters of PCL which I have read later), was ANSI Common Lisp (by pg), and I find it being a great resource
<jackdaniel>
especially thanks to the excercises after each chapter which kind of force you to understand some concepts
<dlowe>
gigamonkey was writing PCL when I was learning it
<dlowe>
otherwise I definitely would have used that
pankajgodbole has joined #lisp
Bike has joined #lisp
<mseddon>
PCL is a pretty good book. Still, I think a little long in the tooth now, it'd be nice for a treatment that also covered ASDF 3 and quicklisp.
shifty has quit [Ping timeout: 264 seconds]
parisienne has joined #lisp
random-nick has joined #lisp
<dlowe>
Not sure how much ecosystem stuff should go into a book.
<jackdaniel>
depends on a book of course. some ended in pcl: most notably slime and emacs configuration basis
<jackdaniel>
s/basis/basics/
krid has joined #lisp
elinow has joined #lisp
Stanley00 has joined #lisp
Stanley00 has quit [Ping timeout: 256 seconds]
ludston has joined #lisp
<parisienne>
sorry I think I spammed the crap out of the channel :( my stupid bouncer freaked out because I haven't been in IRC for a month or so. no clue what happend ...
Inline has quit [Ping timeout: 244 seconds]
parisienne has quit []
parisienne has joined #lisp
<Bike>
there are no messages logged from your nick today, so if you mean something today i guess you probably didn't spam
<parisienne>
no clue ... all I know is half the channels in my list kicked me for flooding. I guess my bouncer was trying to reconnect ...
Cymew has quit [Ping timeout: 240 seconds]
larme has quit [Quit: WeeChat 2.3]
aartaka_d has quit [Read error: Connection reset by peer]
larme has joined #lisp
larme has quit [Client Quit]
<contrapunctus>
mseddon: "PCL is a pretty good book. Still, I think a little long in the tooth now, it'd be nice for a treatment that also covered ASDF 3 and quicklisp." As a newcomer trying to get into the CL ecosystem - amen!
scymtym has joined #lisp
larme has joined #lisp
larme has quit [Client Quit]
larme has joined #lisp
<beach>
parisienne: I didn't see any spam from you.
larme has quit [Client Quit]
larme has joined #lisp
<parisienne>
then its all good. said sorry in #clojure and here. don't care about the #nginx dudes :D
larme has quit [Client Quit]
<saganman>
car and cdr are actually from IBM 704 instruction set, woah
larme has joined #lisp
* easye
* easye
's other car is a cdr...
EvW has quit [Ping timeout: 240 seconds]
cg505 has joined #lisp
<parisienne>
Thank god this is not in the documentation: 'CAR and CDR stand for "Contents of the Address Register" and "Contents of the Decrement Register"'
<saganman>
it is a good practice to declare variables first and then assign right?
<easye>
parisienne: if you don't know that piece of information, it makes it harder to remember what the functions bound to the symbols actually do.
<easye>
saganman: I try not to have anything other than LET (and LET*) forms.
<saganman>
easye: no defvar, setq?
<saganman>
setf*
<easye>
well, actually LET/LET* bindings and the lambda lists to the functions.
<easye>
saganman: definitely not SETQ/SETF, but use DEFVAR/DEFPARAMETER when you absolutely need to.
dyelar has joined #lisp
<saganman>
easye: I heard this years ago when learning lisp, why no setq/setf?
<easye>
Avoiding SETF/SETQ makes ones code more "functional", where you have expcitly nested lexical structure.
<parisienne>
easye I think you meant saganman
<easye>
But this is more a piece of guidance to show how you often don't need SETF as much as you think you do, as a hard and fast rule.
<easye>
parisienne: pardon. Yes, I did..
skapata has joined #lisp
<schweers>
Maybe some rules need a disclaimer: this is meant for newcomers. Once you’ve graduated, there isn’t anything wrong with setf in general. On the contrary, I find the concept of places is something I miss in every other language.
<parisienne>
because I couldn't imagine how it would be useful information to tell somebody get the contents of the address register ;)
saganman has quit [Ping timeout: 244 seconds]
aartaka has joined #lisp
<easye>
parisienne: CAR/CDR are one of the few (only?) places where implementation details leaked into the standard.
<easye>
I think it would have broken too much code to not have it as part of ANSI. Still I try to use FIRST, SECOND, REST, and so forth when they are appropiate.
<easye>
But then I guess we wouldn't such things as CADDDR.
saganman` has joined #lisp
<saganman`>
I got dc
<schweers>
As jackdaniel said: they convey different intents to the reader.
<parisienne>
get the contents of the address decrement decrement decrement register? ;)
saganman` is now known as saganman
saganman has joined #lisp
saganman has quit [Changing host]
<parisienne>
from now on that is what I am going to use!
<saganman>
test
<parisienne>
test passed
<easye>
We can hear ya saganman
<saganman>
nice
aartaka has quit [Ping timeout: 272 seconds]
aartaka has joined #lisp
<beach>
saganman: I think they failed to tell you that a top-level SETF/SETQ of a variable without a preceding DEFVAR or DEFPARAMETER is undefined behavior. But DEFVAR and DEFPARAMETER are not "declarations"; they "define" or even "create" the variable.
<beach>
saganman: So it is not only good style, it is a requirement for conforming code.
<beach>
parisienne: Technically, it is "Contents of the Address part of Register" and "Contents of Decrement part of register". I.e. two parts of one and the same register, rather than two different registers.
<easye>
beach is of course right. Certain implementations (sbcl) won't allow toplevel SETF without DEFVAR/DEFPARAMETER to even compile.
<mfiano->
Not SBCL.
<mfiano->
It will be a warning. But still UB
<easye>
mfiano-: Corrected.
<saganman>
yes beach, I observed that with all the warnings
<beach>
OK, good. Now you just have to use the right terminology. :)
<saganman>
thanks for the tip beach
<beach>
Pleasure.
<parisienne>
easye: damn it, now I actually want to go and figure out how the implementation in the 1950 looked like ...
<dbotton_>
Is there a function that combines let and flet in to one
<beach>
No.
<beach>
And those are not functions.
<dbotton_>
what is the propern name?
uplime is now known as Frankenstein
<dbotton_>
proper
<jackdaniel>
operators
<jackdaniel>
operator may be a function, a macro or a special operator
<beach>
They happen to be special operators. But you can use "operator" for either a function, a macro, or a special operator.
<jackdaniel>
flet and let are special operators
<jackdaniel>
heh
<beach>
heh.
treflip has joined #lisp
<dbotton_>
thanks
<beach>
dbotton_: I believe there is some "bind" macro, perhaps in Alexandria.
<schweers>
btw, there is an operator (a macro, to be precice) which does combine them, called bind.
* jackdaniel
likes the idea of a bind macro, but found the source code quite off-putting
<schweers>
I must admit that I did not read it. I only wrote a few simple extensions and use it.
<jackdaniel>
I don't remember details
<schweers>
It has lots of whitespace at the end of lines ...
<beach>
dbotton_: What characterizes a "function" is that all the arguments are evaluated before the function is applied.
<dbotton_>
good to know
<dbotton_>
So the only standard way for sandwich the let's between flets if want to store results of a local operator between definitions or use results as part of next definition
<mfiano->
There is a macro, mvlet (also mvlet*) that allows multiple-value-bind to have LET/LET* syntax, and thus, you can intermix LET bindings in it, since 1 value is the same as 1+
<mfiano->
I steer away from bind-like macros, there are enough of them, and it really hurts code clarity
<jackdaniel>
I like the fact that multiple-values-bind is so verbose, because it is easy to spot places, which are not a subject of some compiler optimizations
frgo has quit [Remote host closed the connection]
<jackdaniel>
but other than that it is awful indeed :)
<schweers>
jackdaniel: how so? Could you elaborate on what you mean?
dbotton__ has joined #lisp
dbotton has quit [Read error: Connection reset by peer]
<jackdaniel>
for instance (in case of ecl), if you expect only one return value, you may simply use a construct: foo = bar(); (in transpiled code)
mindCrime has joined #lisp
<jackdaniel>
when you bind multiple values, you need to: check how many values were returned and assign them to each variable
<jackdaniel>
so you access an array allocated on a heap instead of simply taking value from the register
<mfiano->
(multiple-value-bind (a b) (floor 42.2) (multiple-value-bind (c d) (floor 42.6) (let ((e 42)) ...))) => (mvlet ((a b 42.2) (c d 42.6) e 42) ...)
<schweers>
So returning multiple values is more expensive? Or receiving them?
<jackdaniel>
(this may be mitigated if you can inline the code or something, but when you don't know about the called function, then you can't)
<jackdaniel>
in case of ecl - receiving them
<jackdaniel>
it is a minute cost, but if you are optimizing to get to C speed (i.e in a numerical code), then it is important
<schweers>
Does the caller indicate to the callee how many values are expected?
<jackdaniel>
another interesting case is multiple-value-prog1 which requires "saving" values on the stack
<jackdaniel>
(multiple-value-bind (a b c) (values 1) …) ; <- clearly not
<schweers>
I mean the compiled code. I know that I as a lisp programmer do not have to do so
<jackdaniel>
but that's in the microoptimization realm which is not important in almost all cases
<schweers>
I’m wondering how the callee knows whether to allocate and fill in the extra heap array
<jackdaniel>
allocation is not necessary, because array is pre-allocated in the environment
<jackdaniel>
and it always fills as many values as it returns (and sets number of return values to n)
<schweers>
essentially by the caller?
sjl_ has joined #lisp
<jackdaniel>
no, when a thread is started
<schweers>
Oh, I see!
<jackdaniel>
each thread has an array which holds returned values
<jackdaniel>
(this is implementation detail which differs probably among implementations; I'm only saying what's going on in ecl runtime)
<schweers>
I know, but I find it interesting
<schweers>
Thanks for explaining this.
<jackdaniel>
sure, if I embarassed myself by saying something incorrect please forget about it ;-)
* jackdaniel
gets back to code
<schweers>
I’ll try :)
<jackdaniel>
(m-v-b is still better and much faster than consing multiple values and destructuring them, so from the language perspective it is a win)
<jackdaniel>
compared to languages with functions which can't return multiple values
<schweers>
Doesn’t python do destructuring on a list or tuple?
<schweers>
Nevermind, we should talk about lisp, not python
contrapunctus has left #lisp ["Disconnected: closed"]
contrapunctus has joined #lisp
pankajgodbole has quit [Ping timeout: 240 seconds]
<dlowe>
it's fine in this case - destructuring involves the construction of an object to destructure, which isn't nearly as efficient
X-Scale` has joined #lisp
<dlowe>
I mean, lisp has destructuring too
<zacts>
hello
<dlowe>
also, CL has the idea of the primary return value, in case you want to ignore the other return values
X-Scale has quit [Ping timeout: 265 seconds]
X-Scale` is now known as X-Scale
<dlowe>
whereas in the destructuring approach, you have to explicitly ignore non-matching data
treflip has quit [Ping timeout: 256 seconds]
davepdotorg has quit [Remote host closed the connection]
davepdotorg has joined #lisp
midre has quit [Ping timeout: 240 seconds]
<dbotton_>
Is there a way for me to call an outer scope verion of an operate my flet or labels has shaddowed?
<schweers>
Why would you shadow it, if you need it?
<schweers>
You can just rename your inner function.
<dbotton_>
probably not smart, but the question is there is a way, a notation that would do it
<jackdaniel>
(funcall 'foo) looks for the function foo in the global environment, ignoring all intervening definitions
<schweers>
Or do you mean from within the function you’re defining via flet?
<schweers>
<dbotton_>
so that gets me global or could use the package
davepdotorg has quit [Ping timeout: 244 seconds]
<Bike>
there's no way to get at an outer binding that isn't global, if that's what you're asking.
<schweers>
The package has nothing to do with global or local
<Bike>
the binding is shadowed.
<dbotton_>
I was curious if there was some way to sort of access the previous scopes for operators or maybe even vars
midre has joined #lisp
<Bike>
No.
<Bike>
the bindings are shadowed.
<jackdaniel>
you may create a closure which captures the outer binding
<dbotton_>
I could go cl-user:foo no?
<Bike>
packages are unrelated.
<Bike>
you can get at a GLOBAL binding, like how jackdaniel said for example
<Bike>
but you can't get at a lexical binding that has been shadowed.
<jackdaniel>
that's a different thing, packages allow you to create /different/ symbols of the same name
<dbotton_>
sorry I was saying can access the global binding that way
<jackdaniel>
it is only that if you do not add package prefix, then the default package is taken (stored in a variable *package*)
<shka_>
dbotton_: within flet you can call the global with name
<shka_>
dbotton_: labels are recursive
<jackdaniel>
shka_: we have estabilished that earlier
<Bike>
you can get at global variable bindings with symbol-value, and function bindings with fdefinition plus several operators that do fdefinition implicitly.
<shka_>
jackdaniel: sorry, i missed it
<dbotton_>
so if I used the package name in flet still get the local binding?
<Bike>
it has nothing to do with the package name.
<Bike>
the package name is a property of the symbol. using or not using the package name does not impact what binding of the same symbol you get.
<dbotton_>
I see just tried it
<jackdaniel>
a silly way of accessing outer function would be i.e (flet ((foo () 42)) (let ((var-foo #'foo)) (flet ((foo () 15)) (funcall var-foo))))
gaqwas has joined #lisp
gaqwas has quit [Changing host]
gaqwas has joined #lisp
<dbotton_>
wow that was a good lesson
<dbotton_>
that would have been a bug hunt someday
<shka_>
uhm, i want to say that although jackdaniel calls this silly, it is situational very useful
mindCrime has quit [Ping timeout: 260 seconds]
<dbotton_>
his answer also answered my other question
<dbotton_>
from before
<dbotton_>
so packages are just name games
schweers has quit [Quit: ERC (IRC client for Emacs 27.1)]
<dbotton_>
not like ada packages
<dbotton_>
good to know
<Alfr>
I think phoe had a nice related example in #lispcafe in the last week.
<Bike>
packages are namespaces and that's it. i don't know if ada packages also include modularity or whatever.
<dbotton_>
(funcall 'foo) vs (funcall #'foo) also interesting
<dbotton_>
so what does the first call the global
<dbotton_>
and the second the local functio
<Bike>
(funcall 'foo) is basically shorthand for (funcall (fdefinition 'foo))
<Bike>
and fdefinition gets the global definition.
<jackdaniel>
dbotton_: if you are interested in some particular operator, just type it in l1sp.org (the second character is a digit "1")
<phoe>
the value returned by the special operator FUNCTION depends on the lexical context in which that operator appears
<jackdaniel>
it will provide you a few links - to the standard, if applicable to pcl, or to another resource
<phoe>
the value returned by the function FDEFINITION does not
kaftejiman has quit [Remote host closed the connection]
kaftejiman has joined #lisp
<dbotton_>
Does case use EQ or EQL for comparisson I have seen both said in different books and online docs
<dbotton_>
the land of list book says EQ and the hyperspec sample would have to be EQL and some other online stuff says EQL
Steeve has joined #lisp
<White_Flame>
land of lisp is pretty loosey goosey
<White_Flame>
when using symbols, EQL is equivalent to EQ comparisons
<White_Flame>
but EQL is the default comparator for most things in CL
<dbotton_>
its my bathroom read
<dbotton_>
yes but eql means i can use numbers for case
<White_Flame>
yep
<dbotton_>
he says no
<dbotton_>
and is eq
<White_Flame>
huh?
sonologico has joined #lisp
* White_Flame
doesn't have his copy at hand
<dbotton_>
land of lisp
<dbotton_>
in his book
<dbotton_>
and I am not on toilet at moment so dont have
<contrapunctus>
lol
<dbotton_>
but 100% he said eq and no nums
<White_Flame>
"These macros allow the conditional execution of a body of forms in a clause that is selected by matching the test-key on the basis of its identity. "
<White_Flame>
from CLHS
<White_Flame>
it doesn't explicitly say EQ or EQL there, but that certainly smells like EQ
<dbotton_>
that is why question
<decentyousername>
Good evening. What are the differences between declare, proclaim and declaim? The difference between declare and proclaim seems to be that declare is local and proclaim global. But I couldn't really figure out what declaim is useful for, after reading the hyperspec entry for all three.
theBlackDragon has quit [Ping timeout: 246 seconds]
<White_Flame>
yeah, surprising to me as well. I haven't hit anything there
Stanley00 has joined #lisp
<decentyousername>
also, hi.
bocaneri has quit [Read error: Connection reset by peer]
<White_Flame>
decentyousername: proclaim is a function, and only takes effect when it's evaluated
<White_Flame>
declaim is a macro, and so it affects things at compile-time which is usually the desired intent
<White_Flame>
you should default to using DECLAIM at the toplevel
<White_Flame>
and PROCLAIM for runtime global declarations (which are going to be exceedingly rare)
Stanley00 has quit [Ping timeout: 260 seconds]
saganman has left #lisp ["Killed buffer"]
<decentyousername>
Ok, so I use the proclaim function make runtime proclamations (global declarations), declaim for assisting the compiler, and declare for local stuff af the beginning of a block. Is that correct?
ebrasca has quit [Read error: Connection reset by peer]
ebrasca has joined #lisp
<White_Flame>
you're not going to be doing "runtime global declarations"
<Bike>
declaim also does global declarationis. it's basically proclaim but it additionally runs at top level compile time.
<White_Flame>
you're generally going to be doing static compile-time declarations as your intent, which is DECLAIM
<White_Flame>
(and yeah, compile-time vs run-time gets a little muddled in vernacular understanding in Lisp, as it's all technically runtime in the outside world's usage)
<decentyousername>
Alright, thanks for the input. I'll reread the spec pages now.
<White_Flame>
the spec pages must be interpreted for some of these issues ;)
<decentyousername>
not compiled? huehuehue
frgo has joined #lisp
<White_Flame>
compiling the interpretations of CLHS is a required step in lisp transcendence
frgo_ has joined #lisp
<decentyousername>
I might share the results of my compilation of interpretations of the CLHS in the distant future, when everone has already forgotten that I wrote the sentence you're currently reading.
frgo has quit [Ping timeout: 240 seconds]
davepdotorg has joined #lisp
davepdotorg has quit [Ping timeout: 260 seconds]
achilles has joined #lisp
Inline has joined #lisp
Jesin has quit [Quit: Leaving]
trn has quit [Ping timeout: 240 seconds]
hendursaga has quit [Remote host closed the connection]
hendursaga has joined #lisp
Jesin has joined #lisp
shangul has quit [Ping timeout: 240 seconds]
gravicappa has quit [Ping timeout: 256 seconds]
akoana has joined #lisp
edgar-rft has quit [Quit: Leaving]
bitmapper has joined #lisp
kaftejiman_ has joined #lisp
theBlackDragon has joined #lisp
kaftejiman has quit [Ping timeout: 246 seconds]
rtypo has joined #lisp
TwoNotes has joined #lisp
bilegeek has joined #lisp
kaftejiman__ has joined #lisp
kaftejiman_ has quit [Ping timeout: 240 seconds]
Harag has joined #lisp
<Harag>
here is a bit of a weird question... some time in the last year I happend upon a video of a famed lisper/prof that was selling the next best thing in programming where more than one thing/function could answer a question/give a result ... he used circuit diagrams as examples in his talk
TwoNotes has quit [Ping timeout: 240 seconds]
<_death>
not sure, but maybe Sussman and Art of the Propagator
<Harag>
yes thats it
<Harag>
thanx
trn has joined #lisp
sgithens_ has joined #lisp
decentyousername has quit [Ping timeout: 272 seconds]
Alfr_ has joined #lisp
nmg has joined #lisp
alanz_ has joined #lisp
jlpeters_ has joined #lisp
boeg_ has joined #lisp
banjiewen_ has joined #lisp
vutral_ has joined #lisp
rusua_ has joined #lisp
Grauwolf_ has joined #lisp
Faed has joined #lisp
Stanley00 has joined #lisp
decentyousername has joined #lisp
<decentyousername>
LOL, _death is our intelligent search engine.
<decentyousername>
a million times better than Google.
gargaml has quit [Quit: WeeChat 2.9]
jlpeters has quit [Ping timeout: 244 seconds]
alanz has quit [Ping timeout: 244 seconds]
thecoffemaker has quit [Ping timeout: 244 seconds]
boeg has quit [Ping timeout: 244 seconds]
rusua has quit [Ping timeout: 244 seconds]
vutral has quit [Ping timeout: 244 seconds]
sgithens has quit [Ping timeout: 244 seconds]
banjiewen has quit [Ping timeout: 244 seconds]
santiagopim[m]1 has quit [Ping timeout: 244 seconds]
ioa has quit [Ping timeout: 244 seconds]
jlpeters_ is now known as jlpeters
hansbauer[m] has quit [Ping timeout: 244 seconds]
sgithens_ is now known as sgithens
rogersm has quit [Ping timeout: 244 seconds]
banjiewen_ is now known as banjiewen
MrtnDk[m] has quit [Ping timeout: 244 seconds]
vutral_ is now known as vutral
nmg_ has quit [Ping timeout: 244 seconds]
gingerale has quit [Ping timeout: 244 seconds]
Grauwolf has quit [Ping timeout: 244 seconds]
sebboh has quit [Ping timeout: 244 seconds]
Fade has quit [Ping timeout: 244 seconds]
<aeth>
so what you're saying is... _death is a possible bot...
Alfr has quit [Ping timeout: 244 seconds]
alanz_ is now known as alanz
boeg_ is now known as boeg
mindCrime has joined #lisp
thecoffemaker has joined #lisp
bilegeek has quit [Quit: Leaving]
PuercoPop has joined #lisp
<decentyousername>
aeth, is he though?
ioa has joined #lisp
<decentyousername>
Now you're making question my reality. After all Lisp is was originally designed for AI.
sebboh has joined #lisp
wsinatra has quit [Quit: WeeChat 2.9]
gingerale has joined #lisp
<decentyousername>
aeth: Maybe you've already created a generally intelligent bot that answers Lisp related questions.
MrtnDk[m] has joined #lisp
bilegeek has joined #lisp
rogersm has joined #lisp
mjl has quit [Ping timeout: 264 seconds]
Stanley00 has quit [Ping timeout: 240 seconds]
cosimone has joined #lisp
hansbauer[m] has joined #lisp
santiagopim[m]1 has joined #lisp
diamondbond has quit [Ping timeout: 246 seconds]
<aeth>
the thing is, does this mean that _death passes or fails the Turing test?
<aeth>
having the correct answer in one line kind of seems like failing the Turing test to me
mjl has joined #lisp
<phoe>
I mean, if it means anything, I have seen _death once or twice
kaftejiman__ has quit [Remote host closed the connection]
<phoe>
he looks nothing like a bot
rippa has quit [Quit: {#`%${%&`+'${`%&NO CARRIER]
kaftejiman__ has joined #lisp
<phoe>
the weirder thing, though, is that he looks nothing like the grim reaper, too
<decentyousername>
phoe: notice the underscore. He's an undercover grim reaper. Basically deaths right hand.
<_death>
there was such a system, called The LISP Tutor
<phoe>
;; unless he's The Garbage Collector, and just has a real nice interface
diamondbond has joined #lisp
<jasom>
remember, sb-posix won't pass its tests if root is writable by all users.
<jasom>
every time I build sbcl in a chroot I forget this fact
<decentyousername>
btw. I'm currently rereading PCL. I came back from hiatus and need to refresh my mind.
slyrus has quit [Quit: Leaving]
<decentyousername>
that book is good. I also managed to get a friend to read it along side.
narimiran has quit [Ping timeout: 256 seconds]
<_death>
(well, it didn't answer questions about Lisp.. but maybe there's progress)
<aeth>
oh, interesting, so _death doesn't answer questions not about lisp
<aeth>
_death: are you written in Lisp?
davepdotorg has joined #lisp
<_death>
according to xkcd I was hacked in perl
davepdotorg has quit [Ping timeout: 256 seconds]
jw4 has quit [Ping timeout: 260 seconds]
sts-q has quit [Quit: -- PANIC -- Serial read char not implemented.]
mindCrime has quit [Excess Flood]
mindCrime has joined #lisp
<_death>
there were many question answering systems written in Lisp.. in the wikipedia entry for question answering, the Unix Consultant is mentioned.. it was written by Wilensky (who wrote a Lisp book).. but the UC paper says it was written in language called PEARL... eerie, isn't it?
jw4 has joined #lisp
<_death>
it also has a big diagram with "DEATH-EVENT" right in the middle
<_death>
Package for Efficient Access to Representation in Lisp
ebrasca has quit [Remote host closed the connection]
dbotton_ has quit [Quit: Leaving]
IAmRasputin has quit [Ping timeout: 256 seconds]
jw4 has quit [Ping timeout: 260 seconds]
jw4 has joined #lisp
shifty has joined #lisp
cosimone has quit [Remote host closed the connection]
cosimone has joined #lisp
IAmRasputin has joined #lisp
dbotton has joined #lisp
aartaka has quit [Read error: Connection reset by peer]
cosimone has quit [Remote host closed the connection]
cosimone has joined #lisp
dbotton__ has quit [Ping timeout: 265 seconds]
IAmRasputin has quit [Ping timeout: 265 seconds]
davepdotorg has joined #lisp
dbotton_ has joined #lisp
dbotton has quit [Ping timeout: 240 seconds]
davepdotorg has quit [Ping timeout: 256 seconds]
motersen has quit [Ping timeout: 240 seconds]
cosimone has quit [Remote host closed the connection]
cosimone has joined #lisp
froggey has quit [Ping timeout: 256 seconds]
froggey has joined #lisp
aeth has quit [Ping timeout: 272 seconds]
Harag has left #lisp ["ERC (IRC client for Emacs 26.3)"]
madage has quit [Ping timeout: 240 seconds]
aeth has joined #lisp
ioa has quit [Ping timeout: 240 seconds]
achilles has quit [Remote host closed the connection]
ioa has joined #lisp
madage has joined #lisp
galex-713 has quit [Ping timeout: 272 seconds]
random-nick has quit [Ping timeout: 260 seconds]
IAmRasputin has joined #lisp
decentyousername has quit [Ping timeout: 272 seconds]
davepdotorg has joined #lisp
luna_is_here has joined #lisp
IAmRasputin has quit [Ping timeout: 256 seconds]
Grauwolf_ is now known as Grauwolf
davepdotorg has quit [Ping timeout: 256 seconds]
alanz has quit [Ping timeout: 272 seconds]
paul0 has joined #lisp
alanz has joined #lisp
ffwacom has quit [Ping timeout: 272 seconds]
conjunctive has quit [Ping timeout: 272 seconds]
ffwacom has joined #lisp
conjunctive has joined #lisp
mgsk has quit [Ping timeout: 272 seconds]
theBlackDragon has quit [Quit: Boom.]
frgo_ has quit [Remote host closed the connection]
frgo has joined #lisp
mgsk has joined #lisp
rgherdt has quit [Ping timeout: 272 seconds]
pent has quit [Ping timeout: 272 seconds]
cosimone has quit [Ping timeout: 240 seconds]
pent has joined #lisp
TwoNotes has joined #lisp
shka_ has quit [Ping timeout: 240 seconds]
pve has quit [Quit: leaving]
Steeve has quit [Quit: end]
davepdotorg has joined #lisp
davepdotorg has quit [Ping timeout: 264 seconds]
EvW has quit [Ping timeout: 244 seconds]
shifty has quit [Quit: Leaving]
shifty has joined #lisp
notzmv has quit [Read error: Connection reset by peer]