<beach>
Fine as usual. But how I am i off topic. :)
<whoman>
aeth, VSync nice ! i have On Lisp and PCL open in tabs. i found a small version of AMOP but i dont think it was the actual book. some day i will afford LoL
<whoman>
i dont usually do books but some things are better absorbed away from screens
<whoman>
beach, ah well good still =)
milanj has quit [Quit: This computer has gone to sleep]
rumbler31 has quit [Ping timeout: 268 seconds]
marusich has joined #lisp
<beach>
I am happy to say that I am again working on the SICL boot process. It involves several first-class global environments, and the way I did it before generated lots of confusing error messages during the debugging phase.
<beach>
I used to create those environments with as much host functionality as possible, so I often got an error that there was no applicable method for the argument combination in question.
<beach>
Now I just import or load the functions I absolutely need. That way, I get an error that a function does not exist, and I can think about whether to import or to load it and into which first-class global environment.
rpg has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
neoncontrails has joined #lisp
LocaMocha has joined #lisp
neoncontrails has quit [Remote host closed the connection]
pjb` is now known as pjb
<whoman>
beach, read a little sentence about SICP yesterday, from casual link (possibly HN)
<whoman>
('read' past tense )
<beach>
SICP or SICL?
quazimodo has quit [Ping timeout: 268 seconds]
<whoman>
SICL oops
<beach>
Ah, OK. That's surprising. I don't advertise it at all.
<whoman>
through some comments. i did not think it was an advertisement but actually it appeared more like a reflection on refreshments happening in the CL world
Guest72929 has joined #lisp
Shinmera has quit [Ping timeout: 276 seconds]
<whoman>
clasp being the other one listed. anyway, inspiring comments. ive got to dive deeper into the trees of lists of trees of lists
<beach>
I see.
fikka has joined #lisp
AxelAlex has quit [Quit: AxelAlex]
teddy_error has joined #lisp
teddy_error has quit [Client Quit]
raphaelss has quit [Remote host closed the connection]
eSVG has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
quazimodo has joined #lisp
Karl_Dscc has joined #lisp
Kevslinger has quit [Quit: Connection closed for inactivity]
zmt01 has joined #lisp
mejja has quit [Quit: mejja]
zmt00 has quit [Ping timeout: 268 seconds]
Shinmera has joined #lisp
Guest72929 has quit [K-Lined]
test1600 has quit [Quit: Leaving]
Guest72929 has joined #lisp
d4ryus1 is now known as d4ryus
Guest72929 has quit [Excess Flood]
flamebeard has joined #lisp
d4ryus has quit [Quit: WeeChat 1.9.1]
knobo has joined #lisp
dec0n has joined #lisp
safe has quit [Read error: Connection reset by peer]
Karl_Dscc has quit [Remote host closed the connection]
scymtym has quit [Ping timeout: 276 seconds]
zmt01 has quit [Quit: Leaving]
zmt00 has joined #lisp
vlatkoB has joined #lisp
mishoo_ has joined #lisp
jack_rabbit has joined #lisp
shrdlu68 has quit [Quit: Lost terminal]
d4ryus has joined #lisp
nika_ has joined #lisp
nika_ has quit [Client Quit]
nika_ has joined #lisp
Shinmera has quit [Quit: WeeChat 1.9.1]
raphaelss has joined #lisp
nowhereman_ has quit [Ping timeout: 240 seconds]
Colleen has joined #lisp
jack_rabbit has quit [Ping timeout: 248 seconds]
hajovonta has joined #lisp
zmt00 has quit [Quit: Leaving]
quazimodo has quit [Ping timeout: 248 seconds]
mson has quit [Quit: Connection closed for inactivity]
quazimodo has joined #lisp
fikka has joined #lisp
_cosmonaut_ has joined #lisp
fikka has quit [Ping timeout: 248 seconds]
<hajovonta>
good morning!
neoncontrails has joined #lisp
scymtym has joined #lisp
<beach>
Hello hajovonta.
juki has joined #lisp
vlatkoB has quit [Remote host closed the connection]
vlatkoB has joined #lisp
quazimodo has quit [Ping timeout: 255 seconds]
milanj has joined #lisp
Cymew has joined #lisp
<phoe>
hello
<beach>
Hello phoe.
<svetlyak40wt_>
hajovonta: Privet!
juki` has joined #lisp
Tobbi has joined #lisp
rumbler31 has joined #lisp
juki` has quit [Client Quit]
varjag has joined #lisp
<phoe>
Hey beach.
hhdave has joined #lisp
juki has quit [Ping timeout: 268 seconds]
rumbler31 has quit [Ping timeout: 248 seconds]
josh5tone has quit [Ping timeout: 250 seconds]
mishoo_ has quit [Ping timeout: 248 seconds]
scymtym_ has joined #lisp
quazimodo has joined #lisp
Tobbi has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
scymtym has quit [Ping timeout: 250 seconds]
josh5tone has joined #lisp
trosa-work has joined #lisp
python476 has joined #lisp
whoman has quit [Remote host closed the connection]
whoman has joined #lisp
wigust has joined #lisp
milanj_ has joined #lisp
zulu_inuoe_ has joined #lisp
mingus has quit [Remote host closed the connection]
angavrilov_ has joined #lisp
internet1cafe has joined #lisp
milanj has quit [Ping timeout: 240 seconds]
angavrilov has quit [Remote host closed the connection]
zulu_inuoe has quit [Ping timeout: 240 seconds]
thorondor[m] has quit [Ping timeout: 240 seconds]
internet_cafe has quit [Ping timeout: 240 seconds]
sz0 has quit [Quit: Connection closed for inactivity]
luis has quit [Ping timeout: 260 seconds]
amerlyq has quit [Ping timeout: 260 seconds]
amerlyq has joined #lisp
thorondor[m] has joined #lisp
luis has joined #lisp
fikka has joined #lisp
borei has quit [Ping timeout: 250 seconds]
BitPuffin|osx has quit [Ping timeout: 258 seconds]
khisanth_ has joined #lisp
Khisanth has quit [Ping timeout: 240 seconds]
flamebeard_ has joined #lisp
neoncontrails has quit [Remote host closed the connection]
foom has quit [Read error: Connection reset by peer]
foom has joined #lisp
galdor1 has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
jackdani1l has joined #lisp
foom2 has joined #lisp
fikka has joined #lisp
galdor has quit [Disconnected by services]
Zhivago has quit [Ping timeout: 255 seconds]
Ziemas_ has joined #lisp
foom has quit [Ping timeout: 240 seconds]
kini has quit [Remote host closed the connection]
juki has joined #lisp
scymtym_ has quit [*.net *.split]
flamebeard has quit [*.net *.split]
eSVG has quit [*.net *.split]
zaquest has quit [*.net *.split]
rgrau has quit [*.net *.split]
les has quit [*.net *.split]
greaser|q has quit [*.net *.split]
jerme_ has quit [*.net *.split]
alms_clozure has quit [*.net *.split]
vaporatorius has quit [*.net *.split]
kolko has quit [*.net *.split]
Lord_of_Life has quit [*.net *.split]
arrsim has quit [*.net *.split]
hdurer[m] has quit [*.net *.split]
MightyJoe has quit [*.net *.split]
jackdaniel has quit [*.net *.split]
lieven has quit [*.net *.split]
Ziemas has quit [*.net *.split]
wladz has quit [*.net *.split]
salva has quit [*.net *.split]
schweers has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
Cymew has quit [Remote host closed the connection]
kini has joined #lisp
flamebeard_ is now known as flamebeard
lieven has joined #lisp
lieven has quit [Changing host]
lieven has joined #lisp
hdurer[m] has joined #lisp
scymtym_ has joined #lisp
rgrau has joined #lisp
arrsim has joined #lisp
zaquest has joined #lisp
salva has joined #lisp
jerme_ has joined #lisp
Lord_of_Life has joined #lisp
greaser|q has joined #lisp
alms_clozure has joined #lisp
les has joined #lisp
eSVG has joined #lisp
MightyJoe has joined #lisp
vaporatorius has joined #lisp
kolko has joined #lisp
wladz has joined #lisp
hdurer[m] has quit [Changing host]
hdurer[m] has joined #lisp
kolko has quit [Max SendQ exceeded]
galdor1 is now known as galdor
kolko has joined #lisp
sellout has quit [Ping timeout: 260 seconds]
moei has quit [Ping timeout: 240 seconds]
bigos has joined #lisp
akr has quit [Ping timeout: 264 seconds]
jameser has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
fikka has joined #lisp
isoraqathedh has joined #lisp
moei has joined #lisp
akr has joined #lisp
sjl has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
dmiles has quit [Ping timeout: 240 seconds]
scymtym__ has joined #lisp
sjl has quit [Ping timeout: 268 seconds]
scymtym_ has quit [Ping timeout: 250 seconds]
fikka has joined #lisp
nika_ has quit []
dmiles has joined #lisp
margeas has joined #lisp
bkst has joined #lisp
nirved has joined #lisp
fikka has quit [Ping timeout: 248 seconds]
<phoe>
Is there a portability library for concurrent/synchronizes hash tables in CL?
scymtym__ has quit [Ping timeout: 240 seconds]
Cymew has joined #lisp
scymtym__ has joined #lisp
dmiles has quit [Ping timeout: 248 seconds]
fikka has joined #lisp
tripty has quit [Ping timeout: 276 seconds]
jackdani1l is now known as jackdaniel
tripty has joined #lisp
fikka has quit [Ping timeout: 248 seconds]
dmiles has joined #lisp
fikka has joined #lisp
scymtym__ has quit [Ping timeout: 240 seconds]
scymtym__ has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
dmiles has quit [Ping timeout: 248 seconds]
fikka has joined #lisp
bkst has quit [Ping timeout: 248 seconds]
dmiles has joined #lisp
dmiles has quit [Read error: Connection reset by peer]
eSVG has quit [Read error: Connection reset by peer]
dmiles has joined #lisp
eSVG has joined #lisp
m00natic has joined #lisp
Lord_of_Life has quit [Ping timeout: 250 seconds]
Cymew has quit [Remote host closed the connection]
nirved has quit [Ping timeout: 255 seconds]
akr has quit [Ping timeout: 255 seconds]
akr has joined #lisp
trigt[m] has quit [Ping timeout: 255 seconds]
hiq[m] has quit [Ping timeout: 255 seconds]
sz0 has joined #lisp
thorondor[m] has quit [Ping timeout: 240 seconds]
marusich has quit [Ping timeout: 240 seconds]
hdurer[m] has quit [Ping timeout: 250 seconds]
akr has quit [Ping timeout: 240 seconds]
bigos has quit [Ping timeout: 240 seconds]
Arcaelyx has quit [Read error: Connection reset by peer]
Zhivago has joined #lisp
nirved has joined #lisp
bigos has joined #lisp
happy_gnu[m] has quit [Ping timeout: 252 seconds]
Jach[m] has quit [Ping timeout: 248 seconds]
Guest34211 has quit [Ping timeout: 246 seconds]
dahs81[m] has quit [Ping timeout: 240 seconds]
ArthurAGleckler[ has quit [Ping timeout: 264 seconds]
Guest65632 has quit [Ping timeout: 264 seconds]
plll[m] has quit [Ping timeout: 240 seconds]
Sovereign_Bleak has quit [Ping timeout: 255 seconds]
dirb has quit [Ping timeout: 252 seconds]
RichardPaulBck[m has quit [Ping timeout: 252 seconds]
CharlieBrown has quit [Ping timeout: 252 seconds]
equalunique[m] has quit [Ping timeout: 255 seconds]
cryptomarauder[m has quit [Ping timeout: 248 seconds]
kammd[m] has quit [Ping timeout: 248 seconds]
astronavt[m] has quit [Ping timeout: 240 seconds]
Lord_of_Life has joined #lisp
Zhivago has quit [Changing host]
Zhivago has joined #lisp
l04m33[m] has quit [Ping timeout: 264 seconds]
marusich has joined #lisp
Arcaelyx has joined #lisp
knicklux has quit [Quit: Leaving]
scymtym__ has quit [Ping timeout: 240 seconds]
scymtym__ has joined #lisp
bkst has joined #lisp
norserob has quit [Remote host closed the connection]
bigos has quit [Remote host closed the connection]
pseudonymous has joined #lisp
nowhereman_ has joined #lisp
Tobbi has joined #lisp
shifty has quit [Ping timeout: 260 seconds]
Tobbi has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
pseudonymous has quit [Ping timeout: 255 seconds]
Tobbi has joined #lisp
BitPuffin|osx has joined #lisp
Cymew has joined #lisp
osune_ has joined #lisp
eSVG has quit [Ping timeout: 258 seconds]
Tobbi has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
wxie has joined #lisp
akr has joined #lisp
fikka has quit [Ping timeout: 250 seconds]
fikka has joined #lisp
jealousmonk has joined #lisp
trosa-work has quit [Remote host closed the connection]
bkst has quit [Ping timeout: 240 seconds]
fikka has quit [Ping timeout: 255 seconds]
rgrau has quit [Ping timeout: 250 seconds]
djinni` has quit [Quit: Leaving]
rawste has joined #lisp
Jach[m] has joined #lisp
happy_gnu[m] has joined #lisp
Guest53490 has joined #lisp
kammd[m] has joined #lisp
dirb has joined #lisp
equalunique[m] has joined #lisp
thorondor[m] has joined #lisp
l04m33[m] has joined #lisp
CharlieBrown has joined #lisp
astronavt[m] has joined #lisp
Guest44824 has joined #lisp
Sovereign_Bleak has joined #lisp
RichardPaulBck[m has joined #lisp
hiq[m] has joined #lisp
dahs81[m] has joined #lisp
cryptomarauder[m has joined #lisp
plll[m] has joined #lisp
hdurer[m] has joined #lisp
trigt[m] has joined #lisp
ArthurAGleckler[ has joined #lisp
<wxie>
hi
fikka has joined #lisp
<wxie>
Does anyone know a sample implementation of stable marriage problem in Common Lisp?
<wxie>
Right, I checked there and wondering why the Common Lisp implementation is missing.
<phoe>
D'oh, because no one wrote it. (:
djinni` has joined #lisp
nowhereman_ has quit [Ping timeout: 260 seconds]
<wxie>
Is it too tedious?
nowhereman_ has joined #lisp
<phoe>
No, I just guess nobody ended up doing it for any reason. Things in the programming world appear only if someone writes them.
<phoe>
The algorithm seems to be four functions in total. Translating it from any other language would be pretty simple.
<phoe>
It's just that nobody did it yet.
<wxie>
No, it is not so straight forward though to do it right.
<phoe>
You have both a very good explanation of the problem and the algorithms AND solutions in multiple other languages. Translating this to CL is nothing that I'd call complicated.
<phoe>
wxie: first you translate it from another programming language, and then fix up the code so it's a bit more idiomatic CL.
<phoe>
But then again, "unlispy" code, what is it?
<phoe>
I've seen CL being used to write object-oriented code, functional code, imperative code, linear code, declarative code, asynchronous code and a few of other lesser known paradigms. Hard to say that any of these were "unlispy".
<phoe>
The part of what I'd call "lispiness" is that a person X comes up and say "hey, I just invented this new programming paradigm!" and Common Lisp is all like "come at me bro"
<Xach>
however, if you put close parens on their own line
<phoe>
...well, indentation is an exception, right.
rpg has joined #lisp
<phoe>
But nothing that can't be fixed by a few backspaces in emacs, anyway.
<wxie>
for example, I come up with (push (cons (car pair) (cadr pair)) where pair is ((w1 . m1) (w2 . m2)). I am thinking if there is other ways to do it.
<phoe>
you're missing a close paren
nowhereman_ has quit [Ping timeout: 240 seconds]
<phoe>
push what where?
<wxie>
push to pairs
<wxie>
push cons to pairs
<phoe>
so basically, you have a two-element list, and you want to make a cons from that list, and push that cons to some kind of place called pairs.
<phoe>
that's an option, yes - especially if your inner loop will or may evolve into something bigger.
nowhereman_ has joined #lisp
hhdave_ has joined #lisp
hhdave has quit [Ping timeout: 276 seconds]
hhdave_ is now known as hhdave
<wxie>
phoe: I am not so sure about my idea of lispness because I have limited experience anyway.
<phoe>
wxie: you have some kind of idea of lispiness though, you're using it after all. (:
EvW has joined #lisp
<phoe>
And I'm just wondering whether and how much this idea matches actual CL and how it's used.
<wxie>
Right, for me lispiness means using list as much as possible, using setf or the like as little as possible.
<phoe>
And it's going to be interesting regarding the "how it's used" part because _death just showed some code that I wouldn't have written because I have a completely different coding style and, for example, I wouldn't have used fset.
<phoe>
That sounds pretty Scheme-like. They have a focus on functional programming and preference for immutability.
<phoe>
Common Lisp tends to not favorize functional programming, and it embraces mutability as a standard and expected feature for the language and its users.
<_death>
well, I tend to use different styles for different programs
<phoe>
favorize?... favoritize?..
<phoe>
le me check
<phoe>
let*
<_death>
favor
<phoe>
_death: so do I, and this fact only increases the complexity of the issue. (:
<phoe>
favor - thank you.
<wxie>
_death: I cannot open your link.
<_death>
wxie: strange, it's just a typical gist link
epicsage has quit [Remote host closed the connection]
aindilis has quit [Remote host closed the connection]
arbv has joined #lisp
BitPuffin|osx has quit [Ping timeout: 240 seconds]
Jesin has quit [Ping timeout: 276 seconds]
grublet has joined #lisp
neoncontrails has joined #lisp
schweers has quit [Ping timeout: 246 seconds]
jstoddard has joined #lisp
FreeBirdLjj has quit [Remote host closed the connection]
Jesin has joined #lisp
scymtym has joined #lisp
jmercouris has joined #lisp
marusich has quit [Quit: Leaving]
EvW has joined #lisp
rm8 has joined #lisp
damke_ has joined #lisp
Karl_Dscc has joined #lisp
damke has quit [Ping timeout: 240 seconds]
jmercouris has quit [Remote host closed the connection]
dyelar has quit [Ping timeout: 248 seconds]
zaquest has quit [Ping timeout: 268 seconds]
dyelar has joined #lisp
mson has joined #lisp
zaquest has joined #lisp
Niac_ has joined #lisp
schoppenhauer has quit [Read error: Connection reset by peer]
LocaMocha has joined #lisp
vap1 has joined #lisp
vaporatorius has quit [Ping timeout: 250 seconds]
Niac has quit [Ping timeout: 248 seconds]
_cosmonaut_ has quit [Ping timeout: 248 seconds]
schoppenhauer has joined #lisp
hhdave has quit [Ping timeout: 264 seconds]
neoncontrails has quit [Remote host closed the connection]
neoncontrails has joined #lisp
shifty has joined #lisp
varjag has joined #lisp
jmercouris has joined #lisp
fortitude has joined #lisp
raphaelss has joined #lisp
jmercouris has quit [Remote host closed the connection]
juki has joined #lisp
teddy_error has joined #lisp
rawste has quit [Ping timeout: 252 seconds]
Tobbi has joined #lisp
trosa-work has quit [Remote host closed the connection]
svetlyak40wt_ has quit []
fikka has quit [Ping timeout: 252 seconds]
m00natic has quit [Remote host closed the connection]
vtomole has joined #lisp
Tobbi has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
jealousmonk has quit [Quit: Leaving]
bkst has quit [Ping timeout: 250 seconds]
mkew64 has joined #lisp
quazimodo has joined #lisp
Ven has joined #lisp
d4ryus has quit [Read error: Connection reset by peer]
Ven is now known as Guest33619
<aeth>
My quick review of what I read of Common Lisp Recipes: The author seems to go with the community consensus on everything where the consensus exists except preferring his own cl-fad over uiop for path/file-related things, but you can't really fault someone for prefering their own library.
eschatologist has quit [Ping timeout: 240 seconds]
bkst has joined #lisp
<aeth>
The weakest part is probably if you're trying to make something graphical, but that's probably the weakest part of the CL ecosystem anyway, and that could definitely be enough material for its own book(s)... ideally after such libraries are more mature.
<aeth>
(I only bring that up at all because it was touched on in the book.)
eschatologist has joined #lisp
nowhere_man has quit [Ping timeout: 260 seconds]
turkja has quit [Ping timeout: 276 seconds]
juki` has joined #lisp
juki` has quit [Client Quit]
damke_ has quit [Ping timeout: 240 seconds]
juki has quit [Ping timeout: 240 seconds]
raynold has joined #lisp
<raynold>
ahh it's a wonderful day
davsebamse has quit [Ping timeout: 240 seconds]
davsebamse has joined #lisp
fikka has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
quazimodo has quit [Ping timeout: 268 seconds]
damke_ has joined #lisp
sz0 has quit [Quit: Connection closed for inactivity]
fikka has joined #lisp
cross has quit [Quit: leaving]
cross has joined #lisp
mkew64 has quit [Ping timeout: 240 seconds]
mkew64 has joined #lisp
fikka has quit [Ping timeout: 255 seconds]
LocaMocha has quit [Ping timeout: 268 seconds]
jack_rabbit has joined #lisp
mson has quit [Quit: Connection closed for inactivity]
milanj_ has quit [Read error: Connection reset by peer]
milanj_ has joined #lisp
epony has quit [Read error: Connection reset by peer]
epony has joined #lisp
fikka has joined #lisp
rgrau has quit [Read error: Connection reset by peer]
zmt00 has quit [Ping timeout: 240 seconds]
zachk has joined #lisp
zmt00 has joined #lisp
<mfiano>
aeth: He also prefers alternatives to his own cl-who
<mfiano>
There is also at least 1 thing that cl-fad does much better than UIOP, or at least until implementations such as SBCL update their ASDF
Guest33619 has left #lisp [#lisp]
vtomole has quit [Ping timeout: 260 seconds]
ski has quit [Ping timeout: 255 seconds]
davsebamse has quit [Ping timeout: 264 seconds]
fikka has quit [Ping timeout: 252 seconds]
<rpg>
mfiano: That may be, but there are lots of things that CL-FAD does worse than current UIOP. In particular, the treatment of directories versus files in pathnames, in CL-FAD is very weak.
<rpg>
That's because Fare did a ton of hard work to figure out how much information he could squeeze out of the various implementations.
<mfiano>
I completely agree, but Fare fixed a major performance issue I reported a long time ago that has not propagated to all of the common implementations yet.
<mfiano>
Yup, I've been waiting a while for SBCL to update ASDF, which I hear is happening soon. With UIOP, listing files in a directory with thousands of files takes minutes, compared to near instantaneously with cl-fad.
<mfiano>
But, this was fixed approximately 1.5 years ago if I were to estimate.
rpg has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
knicklux has joined #lisp
rpg has joined #lisp
Ven`` has joined #lisp
mkew64 has quit [Quit: leaving]
davsebamse has joined #lisp
Ven`` has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
damke_ has quit [Ping timeout: 240 seconds]
<osune>
hoi, for StumpWM I want to write a 'one-shot' hook. stumpwm:add/remove hook both take a symbol. To realize the 'one-shot' ability I need to write a closure which will take a function, calls the function and calls stumpwm:remove-hook on its own symbol. I wrote following function for this: https://pastebin.com/QGaWVgxZ ; It does what i expect: returning a new symbol which binds the closure. But the stumpwm:remove-hook call doesn't work
<osune>
(which is a remove on a list). What do I miss?
astronavt has joined #lisp
vlatkoB has quit [Remote host closed the connection]
ski has joined #lisp
damke_ has joined #lisp
<Bike>
What do you mean it doesn't work?
<osune>
Bike: after triggering the hook, which executes the supplied function correctly, the stumpwm:remove-hook call doesn't seem to affect the supplied hook list (a list with function binding symbols). The hook list still contains the gensym binding the closure.
<Bike>
It looks like remove-hook is a variable. it probably operates on the place.
<Bike>
which in this case is the variable bound by wrap-fn, so it doesn't matter
astronavt has quit [Ping timeout: 240 seconds]
<Bike>
but i'm just guessing. i haven't used stumpwm that extensively.
<osune>
currently my guess is that it has to do with the (gensym) call; but I'm not sure and I don't know where I could find a discussion about the differences of interned and uninterned symbols
<Bike>
no, that works with what i said.
<Bike>
all it setfs is your local variable.
rippa has quit [Quit: {#`%${%&`+'${`%&NO CARRIER]
<Bike>
the wrap-fn parameter.
<osune>
sorry I don't think i can follow. you mean it setfs my hook variable ?
knicklux has quit [Quit: Leaving]
<Bike>
yes.
<Bike>
it's basic. (defvar *foo* 9) (defun test (x) (setf x 3)) (test *foo*), then *foo* is still 9.
<osune>
... oh , i feel stupid.
<osune>
but that means I can not evaluate *foo*; which means I need a macro for that. Is this correct?
<Bike>
something like that.
clog has quit [Ping timeout: 240 seconds]
<osune>
thanks. just to be sure, is there anything which would achieve the same without using a macro here?
damke_ has quit [Ping timeout: 240 seconds]
<Bike>
you could pass the symbol naming the hook, and use setf of symbol-value.
damke_ has joined #lisp
clog has joined #lisp
jack_rabbit has quit [Quit: Leaving]
shka has joined #lisp
<osune>
thanks for your time
nirved has quit [Quit: Leaving]
damke has joined #lisp
juki has joined #lisp
damke_ has quit [Ping timeout: 240 seconds]
juki has quit [Quit: ERC (IRC client for Emacs 25.3.1)]
grumble has quit [Quit: We don't want to hate and despise one another. In this world there is room for everyone. And the good earth is rich and can provide for everyone. The way of life can be free and beautiful, but we have lost the way.]
grumble has joined #lisp
pseudonymous has joined #lisp
Ven`` has joined #lisp
Ven`` has quit [Client Quit]
wigust_ has quit [Ping timeout: 260 seconds]
jack_rabbit has joined #lisp
Ven`` has joined #lisp
papachan has joined #lisp
<drmeister>
What's the difference between "assignment" and "binding"?
<drmeister>
Yes - yes - I should know this by now.
<Bike>
assignment is mutating a binding.
<drmeister>
Very concise - thank you.
cpt_nemo has quit [Ping timeout: 258 seconds]
<Walex>
drmeister: that depends actually
astronavt has joined #lisp
<Walex>
drmeister: in most LISPs the two things are confused, but they are actually quite different, like in most other languages. Because of 'nconc' and 'eq' vs. 'equal'.
<shka>
good evening
<Walex>
drmeister: probably in the future 'Bike's hint will confuse you a lot.
fikka has joined #lisp
<drmeister>
Ok
astronavt has quit [Ping timeout: 252 seconds]
fikka has quit [Ping timeout: 240 seconds]
<Xach>
Walex: That doesn't seem especially likely.
<Bike>
did i fuck up, or... what
<Xach>
No. I'd be a bit wary of vague advice from someone who never participates and who spells it "LISP".
<osune>
Bike: thanks again. I was able to solve it with a macro
<Bike>
cool
<Walex>
Bike: technically you did not fuck up, for unintuitive meanings of "mutating" and "binding".
rumbler31 has quit [Ping timeout: 255 seconds]
<Walex>
Bike: the problem is that those meanings are unintuitive
kokonaisluku has joined #lisp
<Bike>
a binding is a pair of a name and a value, bound together. mutating means changing it. seems reasonable to me.
<jasom>
Most languages conflate binding and assignment far more than lisp does.
* drmeister
is not in any danger of spinning into confusion.
<koenig>
This is a genuine question, but the distinction has to do with the "lexical scope", doesn't it?
<Walex>
jasom: no, quite the opposite.
<jasom>
koenig: no
<Ober>
as a general view among cl folks, are there any other languages that qualify for the lisp label of the original intent. e.g. elisp
<jasom>
koenig: you can bind dynamic variables in lisp, and binding and assignment were different even before lisp had lexical bindings.
<koenig>
Hmm, ok, then keep discussing and I'll learn.
<jasom>
Ober: can I just point you to the comp.lang.lisp flamewar for that?
<drmeister>
I'm reading the Shivers paper on Control Flow Analysis in Scheme. He says:
<Walex>
koenig: the difference has to do with the difference between the environment made of atoms and the environment made of references.
<TMA>
drmeister: to bind === to associate a name with a place capable of holding value ; assignment is changing the value but not the place
<drmeister>
So I tossed out the question - what is the difference between "Binding" and "Assignment".
<Walex>
TMA: that's a notable improvement and quite close.
<aeth>
Someone should make a pc-cl-ppcre, or perl compatible common lisp portable perl compatible regular expressions... A reader macro on top of cl-ppcre for Perl regex syntax. Well, I guess more than one because there's e.g. /.../ and s/.../ etc.
<aeth>
Useful to not have to do \\
<jasom>
drmeister: to be common-lisp specific, let &c. and function entry establishes bindings and setf, setq &c. performs assignment
<Walex>
drmeister: that quote has little to do with LISP, and is rather confused itself.
<drmeister>
jasom: Thank you - that is helpful.
<jasom>
aeth: cl-interpol has a reader macro for regex literals
<jasom>
#/ I think
kokonaisluku has quit [Quit: ChatZilla 0.9.93 [Firefox 52.5.0/20171117140933]]
nowhere_man has joined #lisp
<Walex>
jasom: that is correct but not terribly helpful because "LISP" does assignment "conceptually" in a way that is very close to binding.
<jasom>
TMA: I don't like any definition that involves the phrase "changing the value" since that is ambiguous
<jasom>
e.g. rplacd does not perform assignment, but it changes a value
<jsnell>
TMA: no, you're unnecessarily introducing the concept of "place" there
<Bike>
it's a quote from olin shivers, a CS bigwig who does tons of scheme. if you have something to say that isn't a rejection please hurry along to that part.
<jsnell>
binding does not require a place
<aeth>
drmeister: Afaik it has to do with lexical environments (when working with lexical variables), i.e. binding establishes something in an environment and setting sets the first value it sees as it climbs up the environments
<Walex>
drmeister: the quote you provided actually uses "parameter binding" to mean "one time assignment".
<Walex>
aeth: that is better and close to TMA's one.
<aeth>
drmeister: It's made complicated because of *foo*s and +foo+s, of course
<Walex>
jasom: actually 'rplacd' does perform assignment, otherwise it is incomprehensible. If it did not there would not be any difference between 'eq' and 'equal'
<jasom>
drmeister: also note that both terms have different meanings in different contexts, just like all scientific terms
phoe has quit [Ping timeout: 248 seconds]
<jasom>
Walex: eq is orthogonal to bindings
<Walex>
jasom: it is precisely the difference between 'set' and 'rplacd' that is confusing in LISP-like languages.
<jasom>
and assignment
megalography has quit [Ping timeout: 248 seconds]
<Walex>
jasom: without assignment there cannot be a difference between 'eq' and 'equal'. Indeed the very notion of 'eq' ceases to have meaning.
<jsnell>
no, rplacd is not assignment
<TMA>
jsnell: true but untrue;
Bike has left #lisp [#lisp]
<jasom>
Walex: (let ((x (cons 1 2)) (y (cons 1 2)) (eq x y) (equal x y))
<jasom>
Walex: there is no assignment anywhere in that sample
<jasom>
Without mutation (which is a distinct concept from assignment) then it would be valid to make all equal things eq
<Walex>
jasom: 'cons' in most LISP dialects implies assignment, because 'rplacd' is possible.
<TMA>
jsnell: a binding does not require a place yet it does require something to store it which might as well be isomorphic to a place
<Walex>
jasom: in a pure functional language without assignment. '(eq (cons 1 2) (cons 1 2))' is always 't'.
rumbler31 has joined #lisp
<jasom>
TMA jsnell: I think the two of you are using different meanings for the word "place"
<TMA>
jsnell: a rplacd is an assigment of the cdr
<jasom>
Walex: it *may* be true, it is certainly to create a pure functional languge without assignment for which it is not
<jasom>
s/certainly/certainly possible/
<Walex>
jasom: sure, but it does not make any sense.
<Walex>
jasom: the only reason not to do hash-CONS is the possibility of 'rplacd' later.
<jasom>
Walex: or implementation simplicity
Tobbi has joined #lisp
<Walex>
jasom: in that case there is no need to have the 'eq' operator
<jasom>
Walex: except for when object identity could be used to improve performance because the simple implementation isn't helping you out
Lord_of_Life has quit [Changing host]
Lord_of_Life has joined #lisp
Lord_of_Life has joined #lisp
<jsnell>
TMA: nonsense. (defun foo() (let ((a 1)) (1+ a))) ;; I am definitely establishing a binding A => 1 there. but it is totally reasonable for an implementation to not have "1" stored anywhere during the actual execution
<Walex>
jasom: if there is no 'rplacd' having the 'eq' operator that can return a value different from 't' has no sense, because there is no way to act on that.
k-stz has joined #lisp
<Walex>
jsnell: that '(let ((a 1))' is really an assignment in the general sense of the word.
<jsnell>
jesus fucking christ
<jasom>
Walex: there is a cost to comparing structure, and you have to compare structure if you don't make the work to ensure that storage is identical for objects with identical structure
<Walex>
jasom: the only purpose of 'eq' is for asking: will 'rplacd' change both or just one?
Kundry_Wag has joined #lisp
<jasom>
Walex: or "This is a really large object to compare and I want to save cpu cycles because I know in this limited case that object identity is what I care about"
<Walex>
jasom: but object identity does not matter if there is no 'rplacd'. If the *implementation* has object identity, then the first thing in 'equal' is to compare object identity, it is an implementation dependent optimization.
<jasom>
Walex: yup, and I make implementation dependent optimizations all the time because I live in a place known as "the real world"
<aeth>
Instead of s/certainly/certainly possible/ people should say this: (regex-replace "certainly" * "certainly possible")
<Walex>
jasom: if there is no way to modify objects, is is certain that if two list heads are identically the same then the lists are the same list.
<jasom>
Walex: but the converse is not true
<jasom>
even in an immutable language it is not certain that two non-identical list heads are the same list
<jasom>
even in an immutable language it is not certain that two non-identical list heads are not the same list
<Walex>
jasom: yes, but cannot be detected by the language user.
<jasom>
Walex: it can if the language provides an eq
<jasom>
"Eq is no different from equal if the language does not provide eq"
<TMA>
jsnell: in what sense does the binding exists at runtime then? isn't the whole binding elided and nonexistent at runtime?
<Walex>
jasom: the issue here is that in a purely functional language having 'eq' only tells the user something about the implementation, not the computation possible in the language.
rawste has joined #lisp
<jasom>
Walex: why is that an issue
Kaisyu has quit [Quit: Connection closed for inactivity]
<Walex>
jasom: well, it is an issue, it is pointless.
<Walex>
jasom: well, it is [NOT] an issue, it is pointless.
<aeth>
Is this what people are arguing about? This is a purely functional CL subset, and I get NIL. It's possible that I'd still get NIL in a REPL specifically designed for only that purely functional subset. (eq "Hello" "Hello")
shka has quit [Ping timeout: 248 seconds]
<jasom>
it's pointless to use a faster comparison rather than a slower comparison?
<Walex>
jasom: it is not faster. It has the exact same speed as 'equal', if 'equal' is implemented reasonably.
<jasom>
aeth: Walex is saying that there is no need for eq in a purely functional CL subset because there is no case in which eq gives you more information than equal.
fikka has joined #lisp
<jasom>
Walex: your definition of "reasonably implemented" is "intern everything" then?
<Walex>
jasom: more computationally relevant information.
<aeth>
This tells me if they're the exact same list, not just equivalent lists
<jasom>
Walex: I see your point now
<Walex>
aeth: the distinction is impossible and emaningless iof there is no 'rplacd'
<jasom>
Walex: but what about (equal '(1 2 3 4 ... X) '(1 2 3 4 ... Y)) that is much slower than eq
<jasom>
they are only identical performance in the true case, not the false
phoe has joined #lisp
<Walex>
aeth: suppose that '(id ...)' returned a unique integer associated with a value, then 'eq' would be pretty much '(equal (id ...) (id ...))'. Then the question becomes what's the point of 'id'... In a purely functional language there is no point to it.
<Walex>
jasom: yes, but is again an implementation detail.
<jasom>
Walex: and I care about implementation details
<Walex>
jasom: sure, but functional languages are designed to abstract from implementation details, and let the comiler sort out them.
<jasom>
implementation details can make a difference even in asymptotic complexity of algorithms, so even to a theorist they should matter
nowhere_man has quit [Quit: Konversation terminated!]
nowhere_man has joined #lisp
<Walex>
jasom: you seem to have a reasonable apporach, so if you want I can explain what I think you (and 95% of compsci professors...) miss about this discussion.
Tobbi has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<jasom>
Walex: Pretty much all high-level languages abstract implementation details. Even C. But in C I have rewritten pointer-loops to be array-indexed loops (and vice-versa) because compilers generate much worse code for one than the other.
<Walex>
jasom: that's an unfortunate implementation of C...
<jasom>
Walex: even worse, some compilers generate much better loop code if you switch from incrementing to decrementing your loop variable!
<Walex>
jasom: as to functional abstraction, functional languages are designed to "abstract away" precisely the complexities of assignment.
<Walex>
jasom: bad implementations don't invalidate the concept...
<jasom>
though I sense that you use assignment ant mutation interchangably, whereas the common use I've seen they are distinct, but related, terms
<jasom>
Walex: All implementations are bad
<jasom>
Walex: I have only empirical evidence for this, but it's fairly large.
<Walex>
jasom: the OP was asking about concepts, and "LISP" like languages are a bad context because of that, because for legacy reasons 'set'/'let' and 'rplacd' are *explained* in different terms even if tehy are actually the same.
nowhere_man has quit [Ping timeout: 255 seconds]
<jasom>
Walex: seeing that this channel is specifically about common lisp, the most obvious answer is to assume the lisp definitions of those terms. This discussion started long before he mentioned the Shivers paper, so I had no other context to go on.
<Walex>
jasom: and in Common Lisp there is that unfortunate confusion, that's why I mentioned that as to 'Bike's answer
rumbler31 has quit [Remote host closed the connection]
<jasom>
I would say that binding establishes a new mapping between a name and a value, while assignment modifies an existing mapping between a name and a value.
<aeth>
Walex: LISP fell out of popularity by the early 1980s and almost completely vanished by 1990, at least in my amateur examining of historical documents. Afaik, it's now almost exclusively used by certain niche Lisps that happened to keep the old style in their name, e.g. AutoLISP, ISLISP, and newLISP (actually, perhaps just those three)
astronavt has joined #lisp
<Walex>
jasom: that has a few holes and from my point of view the big difference is the kind of value involved.
<Walex>
aeth: I am a sentimental old timer...
<Walex>
aeth: and I used "LISP" to indicate the general family.
<aeth>
Yes, but these days "LISP" is generally only used to indicate the general Lisp family by (1) users of AutoLISP, ISLISP and newLISP (all quite niche) and (2) people who never use a Lisp and probably only read about it in a textbook written in 1980
<aeth>
At least, in my observations of current usage.
<aeth>
In fact, scratch ISLISP from that list. The ISLISP website calls it the Lisp family. http://www.islisp.info/
<jasom>
Walex: though binding is tied very closely to scopes, since the same symbol in two different scopes is logically not the same variable
<Walex>
jasom: ahhaha getting there!
astronavt has quit [Ping timeout: 250 seconds]
<Walex>
jasom: at least where I think the distinction is more precise.
<jasom>
If a variable (which I'll use as "name + scope" pair) ever maps to two different values, then there has been assignment.
<Walex>
jasom: the problem with that, which getting close to my favourite understanding, is that "scope" is not a runtime entity.
<Walex>
jasom: so the same atom can be bound to two different variables in different scopes, and the same variable can be assigned different values at different times.
<jasom>
Walex: scope is an abstract concept. One could redefine an impure language as a pure one by merely saying each assignment creates a new scope (and the inverse transformation happens when pure languages are compiled to run on real hardware).
<Walex>
jasom: so the same atom can be bound to two different variables in different scopes, and the same variable can be assigned different values at different times. Can I get you to agree to that? :-)
<aeth>
s/newLISP mixes conventions./newLISP mostly uses the LISP convention to refer to the Lisp language family./
<jasom>
Walex: yes, but we may get into a disagreement at the word "value"
<aeth>
I was incorrect.
Kundry_Wag has quit [Ping timeout: 255 seconds]
Kundry_Wag has joined #lisp
<jasom>
Walex: is a cons cell still the same value after a rplacd? This will become very important soon.
<Walex>
jasom: ah but my "trap" is not about the word "value", but the word "variable" :-)
<jasom>
lisp has so many equalities because of different interpretations of the phrase "same value"
<Walex>
jasom: I am asking questions :-). When one uses 'rplacd' does the 'CDR' "variable" of a CONS cell get assigned a new value?
<jasom>
I would say it's not a variable because variables are not anonymous and cons cells can be anonymous
<Walex>
jasom: ahhhhhhhhhhhhhhaaaaaa there we got it almost.
orivej has joined #lisp
<jasom>
And I could tell you would think it a variable because you seemed to be using mutation and assignment interchangably, which is true if all "places" are "variables"
nowhere_man has joined #lisp
<Walex>
jasom: but we tentatively agreed that "the same atom can be bound to two different variables in different scopes", and idf that is true, if you remove the atom bond to it, what is the name of those variables?
Kundry_Wag has quit [Quit: ERC (IRC client for Emacs 24.5.1)]
<jasom>
I claimed a variable was a (name, scope) pair, so a variable without a name is ill-defined in my ontology.
Jesin has quit [Quit: Leaving]
jack_rabbit has quit [Quit: Leaving]
<jasom>
There is a natural isomorphism between assignment and mutation not by any coincidence, but becaus assignment is a very specific type of mutation.
pseudonymous has quit [Ping timeout: 250 seconds]
<Walex>
jasom: I rephrased that as "the same atom can be bound to two different variables in different scopes" to make clear that difference between the two bindings is not the scope, it is the "variable" bit....
<Walex>
IIRC (and not sure here about Common Lisp) you can have two atoms name the same "variable" in the same scope.
jack_rabbit has joined #lisp
<jasom>
Walex: give an example of what you mean?
<Walex>
jasom: well, in C++ if you know it: int a = 1; int &b = a; b = 2; assert (a == 2);
<jasom>
Walex: lisp does not allow that.
sjl has quit [Ping timeout: 260 seconds]
<jasom>
super interesting, but I gotta go afk for an hour or so
<Walex>
jasom: not perhaps for atom0-named variables, but CONS cells work like that.
<Zhivago>
walex: Some lisps had locatives, perhaps you're thinking of those.
<Zhivago>
But CL supports the idea of places rather than pointers.
<Walex>
Zhivago: I am using "variables" as the C-concept "r-value"
<Zhivago>
You could use a symbol-macro perhaps.
<Zhivago>
The C concept of r-value corresponds with value, not variable.
<Walex>
Zhivago: "locatives" were r-values to r-values, that is the equivalent of C's "*" types
<Walex>
Zhivago: that's almost exactly the point :-)
<Zhivago>
So, what is the point supposed to be here?
<Walex>
Zhivago: ahhhhh! Thanks for asking.
<Walex>
Zhivago: the point is that binding is in most languages (in LISP there is a twist) an immutable association between a symbol and a value, whether it be an l-value or an r-value; assignment creates a mutable
<Walex>
Zhivago: ooops, sorrym, I means in the previous lines "C-concept "l-value"" and "were l-values to l-values"
<Zhivago>
Waiting for the point.
<Walex>
Zhivago: the point is that binding is in most languages (in LISP there is a twist) an immutable association between a symbol and a value, whether it be an l-value or an r-value; assignment creates a mutable association between an l-value and an r-value.
<Walex>
Zhivago: the point is that an l-value ("anonymous variable")
<Walex>
Zhivago: the point is that an l-value ("anonymous variable") both *is* a value (and that cannot bchange) and *has* a value (and that can change).
<Zhivago>
An l-value in C is not a variable, but rather an object.
<Walex>
Zhivago: the word "object" is C has a very special meaning.
Karl_Dscc has quit [Remote host closed the connection]
<Zhivago>
Not really.
<Walex>
Zhivago: in C an l-value *is* a value in its own right, and can have a value *or not*.
<dwts>
hey guys, since most of you suggest using emacs with slime to evaluate code as you go, I was asking myself if there's an easy way to pipe output of a lisp program to an external program
<Zhivago>
An l-value is a kind of value -- if you like we can talk about this in ##c.
<Zhivago>
I think you're a bit confused about how C works, and that's off topic here.
<Xach>
dwts: i sometimes turn lisp programs into command-line programs to do that, but then that means there is no emacs or slime involved.
<Xach>
dwts: i use buildapp but there are other ways too
<Xach>
dwts: another option is to have your lisp program output to a file, and then pipe the file into something else
<Walex>
Zhivago: well, you seem very confused as not only C works, but also as how to "[Cvariables work even in "LISP" and Common Lisp.
<Xach>
dwts: you can also use run-program to pipe to another program. i think. i haven't done that much, or maybe at all.
bkst has joined #lisp
<Zhivago>
walex: That's nice.
<Xach>
Ignorance more frequently begets confidence than does knowledge.
<Walex>
Xach: that's precisely the point with Zhivago etc.
<Xach>
Experience suggests otherwise.
<dwts>
Xach: I was trying to do the cli program approach but a few active users at the point I asked the question adviced me against doing that until my program is "ready". My program isn't "ready" but it's close to a point that I want to start see if I can use it with other programs that's why I asked if there's a way to combine the two
<dwts>
Xach: let me check run-program
<dwts>
don't know what that is
<Xach>
dwts: out of curiosity, what is the thing your lisp program generates that is consumed by another program?
damke_ has joined #lisp
<dwts>
Xach: json output
<Walex>
Well, if you have ever used 'rplacd' Zhivago should understand how 'l-value's work (the Common Lisp equivalent that is).
neoncontrails has quit [Remote host closed the connection]
<Xach>
dwts: what program is it being fed to?
<dwts>
Xach: I'm using lisp to search through an API that returns a json ouput. And I would like to see my output pretty printed. I was thinking to pass that to jq
damke has quit [Ping timeout: 240 seconds]
<Xach>
dwts: oh. well, there is a lisp json pretty-printer, too. but i understand the general idea.
<jasom>
dwts: emacs supports sending a region of a buffer to an external filter
<jasom>
and the slime output is just a buffer
<dwts>
Xach: I'm sure there is, but until I write the code that does that in lisp, I need to see the ouptut pretty-printed
<dwts>
jasom: didn't know that this is possible
<jasom>
dwts: select the region, then C-u M-|
vancan1ty has joined #lisp
schoppenhauer has quit [Ping timeout: 240 seconds]
<dwts>
jasom: when I try to select the output, output disappears after trying to change buffer so I can't select anything. I'm getting the output through C-x C-e, if that helps.
<dwts>
maybe writing that to a file is easier as Xach suggested. But I was curious if there was a more elegant way when you go the non-cli route
<dwts>
oh, wait, the output is in messages, I'm an idiot!
wxie has joined #lisp
<Xach>
dwts: is it feasible to run it in the repl? Then the output will be in the repl.
<dwts>
Xach: yeah, I didn't think about doing it from the repl, this could work as welll
<Xach>
I use C-c C-c a lot more than C-x C-e, but that may just be personal habit.
<Xach>
I'm so used to a CL where there is only compiling
<dwts>
Xach: I would prefer the compiling approach as well. But I followed the C-x C-e route as suggested here
<dwts>
jasom: yes, that worked
<dwts>
thanks a lot
prxq has joined #lisp
Bike has joined #lisp
varjag has quit [Quit: ERC (IRC client for Emacs 25.2.1)]
Ven`` has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
Kaisyu has joined #lisp
EvW has quit [Ping timeout: 250 seconds]
astronavt has joined #lisp
wxie has quit [Quit: Bye.]
earl-ducaine has quit [Remote host closed the connection]
astronavt has quit [Ping timeout: 250 seconds]
schoppenhauer has joined #lisp
rawste has quit [Quit: Quitting…]
Ven`` has joined #lisp
osune has quit [Quit: ERC (IRC client for Emacs 25.3.1)]