<harovali>
hi! trying to run cl-ncurses, my distro fails to provide the /usr/lib/libncurses.so file the library asks for. There are other files in my /usr fs which could be equivalent to what cl-ncurses expects, but I'm trying blind on it, any helpis welcome
Lord_of_Life_ has joined #lisp
shifty has quit [Ping timeout: 265 seconds]
shifty has joined #lisp
Lord_of_Life has quit [Ping timeout: 246 seconds]
Lord_of_Life_ is now known as Lord_of_Life
<pjb>
harovali: perhaps asking on the channel of your distro for the replacement they put for ncurses?
<pjb>
harovali: I would propose you to download, compile and install your own copy of ncurses. Probably in /usr/local/lib, in which case you may have to add this path to cffi:*foreign-library-directories*.
<harovali>
pjb: I'll try that , thank you very much
Ven`` has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
Ven`` has joined #lisp
Ven`` has quit [Client Quit]
shifty has quit [Ping timeout: 260 seconds]
shifty has joined #lisp
varjag has joined #lisp
z147x has quit [Ping timeout: 240 seconds]
Bad_K4rMa has joined #lisp
varjag has quit [Ping timeout: 260 seconds]
swills has quit [Ping timeout: 272 seconds]
EvW has quit [Ping timeout: 248 seconds]
swills has joined #lisp
<harovali>
pjb do you know if any ncurses version number is known to be needed for cl-ncurses?
smazga has quit [Quit: leaving]
longshi has joined #lisp
akoana has joined #lisp
orivej has quit [Ping timeout: 258 seconds]
karlosz has joined #lisp
clothespin has joined #lisp
terpri_ has quit [Quit: Leaving]
Bad_K4rMa has quit [Read error: Connection reset by peer]
|Pirx| has quit [Remote host closed the connection]
davepdotorg has joined #lisp
slyrus__ has joined #lisp
slyrus_ has quit [Ping timeout: 265 seconds]
slyrus_ has joined #lisp
davepdotorg has quit [Ping timeout: 268 seconds]
slyrus__ has quit [Ping timeout: 260 seconds]
igemnace has quit [Quit: WeeChat 2.7]
ahungry has joined #lisp
ebrasca has quit [Remote host closed the connection]
<beach>
Good morning everyone!
<ahungry>
mornin
FreeBird_ has joined #lisp
FreeBirdLjj has quit [Ping timeout: 260 seconds]
chocimir has joined #lisp
Bike has quit [Quit: Lost terminal]
ag4xo has quit []
ag4xo has joined #lisp
ag4xo has quit [Client Quit]
torbo has joined #lisp
Khisanth has quit [Ping timeout: 272 seconds]
Lord_of_Life has quit [Ping timeout: 240 seconds]
Lord_of_Life has joined #lisp
Bad_K4rMa has quit [Remote host closed the connection]
statusf90 has quit [Quit: statusf90]
mingus has quit [Ping timeout: 258 seconds]
froggey has quit [Ping timeout: 268 seconds]
Khisanth has joined #lisp
froggey has joined #lisp
Josh_2 has quit [Remote host closed the connection]
oni-on-ion has quit [Ping timeout: 260 seconds]
kscarlet has joined #lisp
chocimir has quit [Ping timeout: 260 seconds]
emys has joined #lisp
chocimir has joined #lisp
emys has quit [Ping timeout: 260 seconds]
dddddd has quit [Read error: Connection reset by peer]
emaczen has quit [Ping timeout: 268 seconds]
kscarlet has quit [Ping timeout: 265 seconds]
torbo has quit [Remote host closed the connection]
emys has joined #lisp
ebzzry has joined #lisp
Oladon has quit [Quit: Leaving.]
gravicappa has joined #lisp
davepdotorg has joined #lisp
davepdotorg has quit [Ping timeout: 240 seconds]
emys has quit [Ping timeout: 260 seconds]
vlatkoB has joined #lisp
oldtopman has joined #lisp
emys has joined #lisp
emys has quit [Ping timeout: 246 seconds]
emys has joined #lisp
swills has joined #lisp
quazimodo has quit [Ping timeout: 265 seconds]
quazimodo has joined #lisp
dale has quit [Quit: My computer has gone to sleep]
chocimir has quit [Ping timeout: 265 seconds]
emys has quit [Ping timeout: 246 seconds]
<ebzzry>
Is there a way to temporarily disable the package reader when reading the symbol X:Y ?
<ebzzry>
Can something be done with the current readtable to achieve that?
varjag has joined #lisp
hdasch has quit [Quit: ZNC 1.6.6+deb1ubuntu0.2 - http://znc.in]
<pjb>
ebzzry: you can put a reader macro on all the consituent characters, and from there, read the syntax you want.
<pjb>
ebzzry: note that some implementations use an a-list to implement readtables…
<pjb>
ebzzry: char-code-limit #| --> 1114112 |#
<ebzzry>
pjb: thanks!
emys has joined #lisp
hdasch has joined #lisp
X-Scale` has joined #lisp
X-Scale has quit [Ping timeout: 268 seconds]
Josh_2 has joined #lisp
X-Scale` is now known as X-Scale
<White_Flame>
ebzzry: if you only converted colon to a constituent, you'd get the symbol named "X:Y"
sauvin has joined #lisp
<White_Flame>
hmm, but it might be lower level than that
<White_Flame>
yeah, colon is constituent already
<beach>
ebzzry: I recommend you use Eclector. It lets you interpret tokens whatever way you like.
narimiran has joined #lisp
emys has quit [Ping timeout: 268 seconds]
gko_ has quit [Ping timeout: 272 seconds]
zaquest has quit [Quit: Leaving]
gko_ has joined #lisp
varjag has quit [Ping timeout: 268 seconds]
emys has joined #lisp
<ebzzry>
thanks!
madage has quit [Ping timeout: 240 seconds]
<pjb>
ebzzry: it may be easier to write foo\:bar or |FOO:BAR|
<ebzzry>
pjb: I agree. However, the syntax of the language is that there can be embedded colons inside it, like foo:bar.
emys has quit [Ping timeout: 265 seconds]
ahungry has quit [Remote host closed the connection]
emys has joined #lisp
madage has joined #lisp
quazimodo has quit [Read error: Connection reset by peer]
quazimodo has joined #lisp
scymtym has quit [Ping timeout: 258 seconds]
<beach>
ebzzry: READ is meant for reading Common Lisp expressions. If you want to read something else, it is usually a better idea to write a parser for it, rather than trying to twist READ into something that it was not meant for.
emys has quit [Ping timeout: 246 seconds]
akoana has left #lisp ["Leaving"]
malfort has quit [Remote host closed the connection]
malfort has joined #lisp
chocimir has joined #lisp
emaczen has joined #lisp
Roland has joined #lisp
brown121407 has quit [Ping timeout: 272 seconds]
emys has joined #lisp
scymtym has joined #lisp
varjag has joined #lisp
emys has quit [Ping timeout: 265 seconds]
nullman has quit [Ping timeout: 268 seconds]
davepdotorg has joined #lisp
emys has joined #lisp
xantoz_ is now known as xantoz
davepdotorg has quit [Ping timeout: 260 seconds]
nullman has joined #lisp
chocimir has quit [Ping timeout: 265 seconds]
cl-arthur has quit [Quit: Lost terminal]
tiwEllien has joined #lisp
emys has quit [Ping timeout: 268 seconds]
bendersteed has joined #lisp
Cymew has joined #lisp
emys has joined #lisp
emys has quit [Ping timeout: 248 seconds]
ggole has joined #lisp
wxie has joined #lisp
gxt has joined #lisp
emys has joined #lisp
vlatkoB has quit [Remote host closed the connection]
vlatkoB has joined #lisp
jprajzne has quit [Quit: jprajzne]
jprajzne has joined #lisp
montaropdf has joined #lisp
Roland has left #lisp [#lisp]
jprajzne has quit [Client Quit]
jprajzne has joined #lisp
hhdave has joined #lisp
raghavgururajan has quit [Read error: Connection reset by peer]
gko_ has quit [Ping timeout: 240 seconds]
raghavgururajan has joined #lisp
longshi has joined #lisp
cosimone has joined #lisp
william1_ has joined #lisp
<splittist>
For hysterical raisins I am a (the?) moderator of the beirc-devel mailing list. There is a bit of spam that needs deleting in the moderation queue, but I can't for the life of me recover my password to do so. Could some kind common-lisp.net admin assist?
<jackdaniel>
splittist: if you ask at #common-lisp.net channel you are more likely to get a response
<jackdaniel>
fwiw they are very prompt to help with problems
emaczen has quit [Ping timeout: 268 seconds]
<jackdaniel>
(intersection #lisp #common-lisp.net) is not #common-lisp.net :)
<splittist>
Of course. Thank you.
<jackdaniel>
sure
cosimone has quit [Quit: Terminated!]
emys has quit [Ping timeout: 265 seconds]
cosimone has joined #lisp
davepdotorg has joined #lisp
<montaropdf>
Any pointer to a document or package to use the LISP syntax as a database format?
<montaropdf>
I wnat to use LISP to keep records of transaction and to store various types of data in simple tables.
<jackdaniel>
library postmodern gives you a "lispy" syntax to sql, it is called s-sql
<jackdaniel>
(it is for postgres)
<_death>
there are also projects like cl-prevalence, rucksack, fact-base..
<montaropdf>
both datfly nd postmodern are libraries to work with database, I am looking for a database format made of LISP strings.
emys has joined #lisp
<aeth>
what you want really depends on what you mean by "types of data"
<aeth>
do you want serialization of arbitrary CL data structures?
wxie has quit [Ping timeout: 260 seconds]
jonatack has quit [Ping timeout: 265 seconds]
<jackdaniel>
is it a database then?
emys has quit [Ping timeout: 272 seconds]
emys has joined #lisp
fengshaun_ has quit [Quit: bibi!]
<montaropdf>
fact-base seems to be close to what I am looking for.
fengshaun has joined #lisp
<montaropdf>
My idea was to have one table per file, with the table definition at the top and transaction records or data records following the definition. the definition and records should be stored as LISP string: a record could look like (insert record-date field1 field2 field3...)
<montaropdf>
s/record-date/transaction-date/
<montaropdf>
And for data records: (field1 field2 field3...)
william1_ has quit [Ping timeout: 268 seconds]
<jackdaniel>
maybe defining a class and treating class = table, instance = record, slot = field would suffice?
<montaropdf>
This would allow me to use a simple text editor to edit the DB and use a companion library to create reports or transfert the whole stuff into a more traditional database format.
<montaropdf>
jackdaniel: I will explore that possibility.
<_death>
personally my goto solution would be sqlite
shangul has joined #lisp
nika_ has joined #lisp
emys has quit [Ping timeout: 260 seconds]
nika_ has quit [Read error: Connection reset by peer]
<no-defun-allowed>
You're supposed to not use goto, right?
nika_ has joined #lisp
<_death>
when Dijkstra starts lisping gimme a call (preferably a tail call)
* no-defun-allowed
hides TAGBODY
emys has joined #lisp
easye has joined #lisp
fowlduck has quit []
fowlduck has joined #lisp
bytesighs has quit []
bytesighs has joined #lisp
CEnnis91 has quit []
GreaseMonkey has quit [Read error: Connection reset by peer]
CEnnis91 has joined #lisp
greaser|q has joined #lisp
elderK has joined #lisp
shifty has quit [Ping timeout: 260 seconds]
shifty has joined #lisp
amerlyq has joined #lisp
emys has quit [Ping timeout: 272 seconds]
shifty has quit [Ping timeout: 265 seconds]
shifty has joined #lisp
<montaropdf>
no-defun-allowed: does goto exist in CL?
<jackdaniel>
montaropdf: it is a pair of tagbody and go operators
<montaropdf>
?????
<jackdaniel>
i.e (tagbody again (when (foo) (go again )))
<jackdaniel>
tagbody estabilishes lexical tags to which you may go (as you do with goto in C)
<montaropdf>
I see, something more to learn.
<jackdaniel>
it is usually the most useful when you write looping macros, not something you often encounter in hand-written code
<jdz>
I have one case of PROG in my application.
<jackdaniel>
however it happens, I'm looking at one instance right now
<jackdaniel>
(or when you write a state machine)
<jackdaniel>
I don't dislike prog, it seems like a good syntactic sugar
<montaropdf>
thanks for the information, I need to record that for future study.
<jackdaniel>
sure
<phoe>
I have one PROG that I wrote recently
<phoe>
it is a decent state machine abstraction
m00natic has joined #lisp
shifty has quit [Ping timeout: 272 seconds]
jonatack has joined #lisp
nika_ has quit [Read error: Connection reset by peer]
bendersteed has quit [Remote host closed the connection]
jeosol has quit [Remote host closed the connection]
dddddd has joined #lisp
<jackdaniel>
montaropdf: the part pjb did not mention is that do estabilishes an implicit tagbody
<jackdaniel>
"do" as a "DO" operator
drmeister has quit []
drmeister has joined #lisp
<montaropdf>
jackdaniel: is it in opposition to the "do" keyword in the "LOOP" macro?
<phoe>
nope, the two are different things
<Josh_2>
do is also a looping construct like loop or dotimes etc
<phoe>
the DO in LOOP is a keyword to execute side effects
<phoe>
(loop for i in '(1 2 3 4 5) do (print i))
<phoe>
the macro CL:DO is an iteration construct on its own
mingus has joined #lisp
<montaropdf>
I think I am in need to go to #clschool for sometimes ;)
wxie has quit [Ping timeout: 268 seconds]
orivej has quit [Ping timeout: 265 seconds]
gabiruh has joined #lisp
wxie has joined #lisp
ljavorsk_ has quit [Ping timeout: 268 seconds]
Lord_of_Life_ has joined #lisp
Lord_of_Life has quit [Ping timeout: 265 seconds]
Lord_of_Life_ is now known as Lord_of_Life
<jmercouris>
DO is an operator?
<jmercouris>
oh, nvm, I just re-read
sabrac has joined #lisp
<Cymew>
Someone posted some code written by Greenblatt. He seemed to have liked PROG and GO. It did look a bit like Fortran. ;)
<aap>
old lisp code was full of that
gxt has quit [Ping timeout: 240 seconds]
<splittist>
I have seen PROG described as the facility for allowing FORTRAN (as it was) programmers to code LISP (as it was)
<aap>
the very first ideas for lisp looked more like fortran anyway
<aap>
the prog feature was meant to be there from the beginning
<lieven>
CL even can do tricks like handing out closures over GO tags. (tagbody .... tag .... (f 1 #'(lambda () (go tag)) ...) and the function f can funcall the closure to return to the tag
<splittist>
aap: true. How else would you write computer programs than in units directly translatable to short runs of machine code?
<jackdaniel>
lieven: if it exits the scope of tagbody it is undefined behavior
<jackdaniel>
s/exits/escapes/
<lieven>
jackdaniel: yeah
<lieven>
jackdaniel: the SERIES system is implemented with this trick
<lieven>
it's a downward funarg in the jargon of the time, not a full continuation
FreeBird_ has quit [Ping timeout: 265 seconds]
FreeBirdLjj has joined #lisp
CEnnis91 has quit [Quit: Connection closed for inactivity]
<aap>
pjb: no, lisp as described in the first AI memos
gko_ has joined #lisp
XenophonF has joined #lisp
ebzzry has joined #lisp
<jmercouris>
montaropdf: I like it, please let me know when there is something to try
<montaropdf>
jmercouris: as I foresee it its primary use will be through a text editor to add transactions or modify data record, so you could already try it to verify it is as editor and programming language friendly as it seems as of now.
jonatack has quit [Quit: jonatack]
<montaropdf>
I will make a try of that sort during the week-end.
<jmercouris>
montaropdf: OK, I think it is ambitious for one week-end, good luck! :-)
<montaropdf>
jmercouris: I was speaking about trying the file format to hold data, not coding anything that could act on the data.
<montaropdf>
And it would be very ambitious to code that in a week-end
swills has quit [Ping timeout: 260 seconds]
swills has joined #lisp
<jmercouris>
I see :-D
swills has quit [Ping timeout: 260 seconds]
swills has joined #lisp
teej has quit []
teej has joined #lisp
raghavgururajan has quit [Read error: Connection reset by peer]
pfdietz has quit [Remote host closed the connection]
msk has quit [Remote host closed the connection]
msk has joined #lisp
physpi has quit []
physpi has joined #lisp
ralt has joined #lisp
<montaropdf>
BTW, any comments about the syntax consistency of the various forms/expressions described?
<jmercouris>
it seems fine to me
refpga has joined #lisp
<jmercouris>
the spec will evolve as you use it and discover the pain points
statusf90 has joined #lisp
<montaropdf>
of course, yet some early comments could remove some of those pain points ;)
pfdietz has joined #lisp
<jmercouris>
the only thing that comes to mind is this; the table definition need not contain sort information
<jmercouris>
that is the responsibility of the tools to persist and insert in order
<montaropdf>
So the index thing could go away entirely, for you?
wxie has quit [Ping timeout: 260 seconds]
Bike has joined #lisp
swills has quit [Ping timeout: 265 seconds]
shifty has quit [Ping timeout: 272 seconds]
shifty has joined #lisp
Josh_2 has joined #lisp
shifty has quit [Ping timeout: 265 seconds]
shifty has joined #lisp
ljavorsk has joined #lisp
swills has joined #lisp
LiamH has joined #lisp
shifty has quit [Ping timeout: 265 seconds]
<jmercouris>
yes
shifty has joined #lisp
<montaropdf>
note taken.
oni-on-ion has joined #lisp
shifty has quit [Ping timeout: 260 seconds]
<pfdietz>
To whom do I send a patch for hu.dwim.walker?
<Odin->
Isn't that a decent chunk of what needs to happen for Postmodern to support modern authentication?
<phoe>
given that it's Sabra who's asking the question, I guess that it's exactly that
<sabrac>
I have everything done except the normalization of the password - assuming I make ironclad a dependency.
<sabrac>
If the passwords and user names are ascii, everything works, but the standard requires that passwords and user names be normalized for different utf8 encodings
<Odin->
Interesting. I've been thinking about taking a try at that side of it for a while. Don't have anything done, though.
<Odin->
Postgres wants a slightly non-standard version, even.
asdf_asdf_asdf has joined #lisp
tiwEllien has quit [Ping timeout: 268 seconds]
Kevslinger has quit []
Kevslinger has joined #lisp
<sabrac>
By the way, what are people's thoughts on ironclad as a dependency? Xach thinks it is a pretty big dependency but I do not want to reinvent a subset of that wheel and get it wrong
<Odin->
Crypto is hard, and it's better to have it in one place.
<Odin->
There might be a better approach than a single system with all the crypto, though.
<sabrac>
Open to any and all suggestions
<pfdietz>
The problem isn't depending on Ironclad, it's that Ironclad solves a problem that is risky to solve (due to exposure to changes in internals of CL implementations).
<Odin->
I'm mainly suggesting that Ironclad could do with being made more modular, rather than not using it.
<sabrac>
I want to get this done and back to phoe's binary problem
<Odin->
... and hence use Ironclad. Which makes sense.
shifty has quit [Ping timeout: 260 seconds]
<Odin->
sabrac: Hrm.
<sabrac>
Odin: Hrm?
shifty has joined #lisp
<Odin->
sabrac: There are small, but significant, differences between the RFCs you linked to and the ones referenced in the SCRAM-SHA-1 RFC.
<Odin->
sabrac: Postgres appears to be using the latter, specifically.
CEnnis91 has joined #lisp
<sabrac>
yes. The RFCs I linked to obsoleted the ones that Postgres is using. I would like to look at both
<Odin->
As far as I can see the difference that's most likely to trip something up is that the new ones use NFC, but the older ones use NFKC.
<sabrac>
As you said, Postgres wants a slightly non-standard version
<Odin->
Yeah, but only for non-UTF-8 sequences.
tiwEllien has joined #lisp
<Odin->
NFKC translates significantly more code points than NFC.
HDurer has quit [Remote host closed the connection]
<sabrac>
You obviously are knowledgable in this space. Any implementations of NFKC you recommend I should look at?
<Odin->
I know a fair bit about Unicode, but haven't really dealt with it in CL too much.
jprajzne has quit [Client Quit]
jprajzne has joined #lisp
<Odin->
The saslprep handling is in a separate file in postgres. Useful.
tiwEllien has quit [Ping timeout: 265 seconds]
<Odin->
I can only see references to Unicode normalisation in the SBCL docs.
asdf_asdf_asdf has quit [Remote host closed the connection]
tiwEllien has joined #lisp
<Odin->
There's normalisation functions there.
shka_ has quit [Quit: WeeChat 1.9.1]
<Odin->
Doesn't seem to be mentioned in the CCL docs.
<galdor>
sabrac: just look at libicu and unicode specifications
<Odin->
This is something that really should be available in a portable 'unicode' library.
<galdor>
it's non trivial
<Odin->
I'm aware.
<galdor>
ICU defines a *lot* of operations
<Odin->
That's why it needs to be available.
<Odin->
I'm not talking about porting ICU to CL.
<Odin->
But at least having what sb-unicode appears to support available more widely would be ... useful.
cosimone has quit [Remote host closed the connection]
Cymew has quit [Ping timeout: 240 seconds]
avicenna has quit []
avicenna has joined #lisp
montaropdf has quit [Quit: See you soon.]
asdf_asdf_asdf has joined #lisp
tiwEllien has quit [Ping timeout: 240 seconds]
shifty has quit [Ping timeout: 268 seconds]
shifty has joined #lisp
ebrasca has joined #lisp
xkapastel has joined #lisp
varjagg has joined #lisp
teej has quit [Quit: Connection closed for inactivity]
varjagg has quit [Remote host closed the connection]
Bad_K4rMa has joined #lisp
ebrasca has quit [Read error: Connection reset by peer]
ebrasca has joined #lisp
Bad_K4rMa has quit [Remote host closed the connection]
ebrasca has quit [Read error: Connection reset by peer]
ebrasca has joined #lisp
clothespin has quit [Ping timeout: 260 seconds]
orivej has joined #lisp
Bike has quit [Remote host closed the connection]
efm has quit [Ping timeout: 268 seconds]
Bike has joined #lisp
smazga has joined #lisp
efm has joined #lisp
statusf90 has quit [Quit: statusf90]
rwcom7 has joined #lisp
rwcom has quit [Ping timeout: 265 seconds]
rwcom7 is now known as rwcom
varjag has quit [Quit: ERC (IRC client for Emacs 25.2.2)]
jmercouris has quit [Remote host closed the connection]
clothespin has joined #lisp
brown121407 has joined #lisp
efm_ has joined #lisp
efm has quit [Ping timeout: 268 seconds]
efm_ has quit [Client Quit]
cosimone has joined #lisp
gko_ has quit [Ping timeout: 272 seconds]
shifty has quit [Ping timeout: 240 seconds]
shifty has joined #lisp
emys has joined #lisp
EvW1 has quit [Ping timeout: 245 seconds]
cosimone has quit [Quit: Quit.]
davepdotorg has quit [Remote host closed the connection]
Bike has quit [Remote host closed the connection]
brown121408 has joined #lisp
karlosz has joined #lisp
davepdotorg has joined #lisp
brown121407 has quit [Ping timeout: 268 seconds]
ljavorsk has quit [Ping timeout: 260 seconds]
karlosz has quit [Client Quit]
pfdietz has quit [Remote host closed the connection]
emys has quit [Ping timeout: 245 seconds]
davepdotorg has quit [Ping timeout: 268 seconds]
emys has joined #lisp
jonatack has joined #lisp
Bike has joined #lisp
brown121408 has quit [Read error: Connection reset by peer]
brown121408 has joined #lisp
emys has quit [Ping timeout: 240 seconds]
asdf_asdf_asdf has quit [Remote host closed the connection]
<Xach>
sabrac: the ironclad issue springs more from how difficult it is to use one part without using the whole thing, and i don't always like using the whole thing because it is large and takes a long time to compile.
<Xach>
if you need multiple things it provides, then it is not a very big deal
<Xach>
but if you were just using it for e.g. one or two hashing functions, to me that seems heavyweight
emys has joined #lisp
varjagg has joined #lisp
shifty has quit [Ping timeout: 240 seconds]
shifty has joined #lisp
<sabrac>
Xach: yes, understood.
raghavgururajan has joined #lisp
<sabrac>
functions currently needed from ironclad are: ascii-string-to-byte-array, hex-string-to-byte-array, digest-sequence, hmac-digest, make-hmac, update-hmac, integer-to-octets, octets-to-integer, pbkdf2-hash-password and whatever they depend on within ironclad
copec has quit [Ping timeout: 246 seconds]
emys has quit [Ping timeout: 240 seconds]
asdf_asdf_asdf has joined #lisp
v88m has quit [Ping timeout: 240 seconds]
emys has joined #lisp
hhdave has quit [Quit: hhdave]
m00natic has quit [Remote host closed the connection]
shka_ has joined #lisp
zulu-inuoe has joined #lisp
shifty has quit [Ping timeout: 240 seconds]
emys has quit [Ping timeout: 268 seconds]
Abe has joined #lisp
shifty has joined #lisp
clothespin has quit [Ping timeout: 268 seconds]
Ven`` has joined #lisp
zulu-inuoe has quit [Read error: Connection reset by peer]
zulu-inuoe has joined #lisp
emys has joined #lisp
Abe has quit [Ping timeout: 240 seconds]
shifty has quit [Ping timeout: 265 seconds]
jprajzne has quit [Quit: jprajzne]
varjagg is now known as varjag
jprajzne has joined #lisp
pfdietz has joined #lisp
emys has quit [Ping timeout: 260 seconds]
emys has joined #lisp
xkapastel has quit [Quit: Connection closed for inactivity]
jprajzne has quit [Client Quit]
jprajzne has joined #lisp
statusf90 has joined #lisp
<Josh_2>
What does the "~&" format directive do?
<asdf_asdf_asdf>
This is ++i from other languages. "pre increment", "pre new-line".
<Bike>
outputs a newline if there's any text on the current line.
<pfdietz>
Related to the standard function fresh-line
raghavgururajan has quit [Read error: Connection reset by peer]
<Josh_2>
Thanks :)
<asdf_asdf_asdf>
Josh_2, it is new-line - 1, if was something do.
copec has joined #lisp
rippa has joined #lisp
slyrus__ has joined #lisp
slyrus_ has quit [Ping timeout: 260 seconds]
sjl has quit [Quit: WeeChat 2.2-dev]
sjl has joined #lisp
zclark has joined #lisp
asdf_asdf_asdf has quit [Remote host closed the connection]
tiwEllien has joined #lisp
slyrus_ has joined #lisp
v88m has joined #lisp
slyrus__ has quit [Ping timeout: 265 seconds]
akoana has joined #lisp
Bad_K4rMa has joined #lisp
<pjb>
Josh_2: there are actually very few implementations that launch missiles at you, develop a new plague virus, or expulse nasal daemons in case of undefined behavior. You can just try stuff out at the REPL!
<markasoftware>
I'm writing a Lisp function that scans through the body of a lambda to determine which lexical values and functions to put in its closure
davepdotorg has joined #lisp
<Bike>
like a common lisp lambda, or another lisp like language?
<markasoftware>
let's just say common lisp, but maybe a simplified version of it
<Bike>
alright.
<markasoftware>
do i need to have a special case for quote, so that I don't capture symbols inside of a quoted list?
<Bike>
well, you'll probably need to analyze all the special operators, sure
<markasoftware>
i.e, (find-closure-symbols (+ 1 2)) should return (+)
<markasoftware>
but (find-closure-symbols (quote (+ 1 2))) should not return +
jmercouris has joined #lisp
<Bike>
i mean you'll have to handle like (find-closure-symbols '(let ((x y)) x)) => (X), not (X Y) anyway
<Bike>
er, it should return (Y)
<markasoftware>
hmm that is a tricky one
<Bike>
or (find-closure-symbols '(lambda (x) x)) => (), not (X)
<Bike>
you'll have to actually walk the code
<markasoftware>
so, when let is in the car position of a list, i recurse only on the values
<Bike>
well you also have to analyze the body.
<Bike>
(let ((x y)) (+ x y z)) has Y Z free.
<markasoftware>
and that, yep
<Bike>
so, while analyzing the body (+ x y z), you have to make sure that the x is NOT added to the free list.
davepdotorg has quit [Ping timeout: 268 seconds]
<markasoftware>
It isn't any easier to do this in the lisp interpreter than it is to just write a macro, like Emacs did with lexical-let, is it?
<Bike>
i'm not sure what you mean.
<markasoftware>
Is it easier to implement lexical binding in C, with the interpreter? I can't imagine it would
<markasoftware>
rather than implementing it in lisp, as a macro.
<Bike>
i don't understand. The kind of analysis you're doing is usually part of a compiler.
<markasoftware>
ok
<Bike>
i suspect emacs lisp is not the best example, though.
<Bike>
SICP or something may be informative
<markasoftware>
Yeah, it probably is
<markasoftware>
thanks!
<Bike>
happy to be of service
emys has quit [Ping timeout: 272 seconds]
nowhereman_ has joined #lisp
emys has joined #lisp
ebzzry has quit [Ping timeout: 268 seconds]
mercourisj has joined #lisp
jmercouris has quit [Disconnected by services]
mercourisj is now known as jmercouris
nika_ has quit []
mrcom has quit [Ping timeout: 265 seconds]
z147 has joined #lisp
asdf_asdf_asdf has joined #lisp
ggole has quit [Quit: Leaving]
sjl_ has quit [Quit: WeeChat 2.3-dev]
amerlyq has quit [Quit: amerlyq]
swills has quit [Ping timeout: 268 seconds]
jmercouris has quit [Ping timeout: 268 seconds]
swills has joined #lisp
<pfdietz>
markasoftware: you are trying to write a code walker. This is not possible in a fully portable way in Common Lisp, unfortunately. And because macros can do arbitrary computations is not possible in general to trace back to the original lambda expression.
Bike has quit [Remote host closed the connection]
Bike has joined #lisp
<pfdietz>
The portability problem is because the code walker needs to maintain an env object as it goes through macrolets, and there's no standard API for doing that.
<pfdietz>
(I make the assumption here that there may be macros in the code for which you do not have the source.)
<pfdietz>
(Otherwise, you could solve the problem with an entire virtual CL implementation on top of the one you are using.)
slyrus__ has joined #lisp
FreeBirdLjj has quit [Remote host closed the connection]
slyrus_ has quit [Ping timeout: 268 seconds]
cl-arthur has joined #lisp
shka_ has quit [Ping timeout: 268 seconds]
shka_ has joined #lisp
<aeth>
pfdietz: That might actually be the easiest solution. It shouldn't be that hard to implement CL on top of CL. Maybe a 3 month project?
<aeth>
Of course, you're probably going to lose performance...
kajo has joined #lisp
<jackdaniel>
cl implementation may have custom special forms
<jackdaniel>
(as extensions), to which some standard macros may expand
emys has quit [Ping timeout: 246 seconds]
<aeth>
It almost certainly will have custom special forms if you expand macros past the point of the CL package, e.g. CL:LOOP. Although CL:DO usually is simple enough not to have any. And it's not required, e.g. CL:DOTIMES is usually implemented on top of CL:DO and CL:WITH-ACCESSORS usually uses CL:SYMBOL-MACROLET
emys has joined #lisp
<aeth>
If you run your own CL implementation on top of CL, though, you get full knowledge of any quirks as long as you don't do the laziest thing and transpile all of the source code to itself. (Some things might be unavoidable like different fixnum sizes unless you really want to slow things down, though.) It might mean slightly different behavior in edge cases inside vs. outside, though.
space_otter has joined #lisp
<aeth>
If this sounds like a ridiculous solution to code-walking, then maybe this shows why code-walkers are usually avoided!
<Bike>
or why implementation support would be nice
<jackdaniel>
that ^
<jackdaniel>
ecl has a walker module, but I don't know in what shape it is, I've never used it nor it has tests
<Bike>
does clos use it?
<aeth>
Bike: Even if you have a working code walker, there's still the issue of when you refactor code in the usual CL way and just C-k a piece of code from a giant function so you can put it in a smaller function for cleaner code. Oops! It has a (foo bar) somewhere in those lines and foo isn't a real thing! It's just an illusion from the code walker!
<jackdaniel>
Bike: possibly, it is defined in clos/ source subtree
<Bike>
aeth...huh?
<aeth>
Bike: My point is code walking functions should be recursive so if FOOBAR uses the macro, then if you spin off a BAR function, you can also use the same macro to get to the same state. e.g. maybe an HTML generator that has a code walker in embedded CL code in it
<Bike>
i don't understand your example. you're talking about cut pasting from source? how does a code walker come into it?
<aeth>
Take a (with-infix (- b + (sqrt b ^ 2 - 4 * a * c) / (2 * a)) and then say 'Oh, this is a bit messy, let's move "b ^ 2 - 4 * a * c" into its own function so the "- b -" function can share code with the "- b +" function"'. But depending on how it's written, you can't do that.
raghavgururajan has joined #lisp
<aeth>
Quite a few code-walker macros do some sort of initial and/or final step that will be completely broken by a function f calling a function g that also uses that macro.
swills has quit [Read error: Connection reset by peer]
<Bike>
I am... not remotely certain I understand what you're talking about or what it has to do with code walkers, but not being able to cut parts of a function out willy nilly doesn't seem like a problem unique to code walking macros.
<White_Flame>
code walkers don't walk through functions anyway; whatever lexically goes on in the extracted function is opaque to the caller's environment
<aeth>
Bike: Code walking macros happen to make it particularly undiscoverable. If a macro has a fake (foo 42) I can't just M-. into it. I'll have to read a 200-line opaque macro that should've been split up into tiny functions and then I'll understand why the macro author didn't support the mode of splitting up a 200 line function into tiny functions.
<aeth>
And then I'll waste weeks rewriting half of a library...
<pfdietz>
What is needed is implementation support for the environment datatype, so the code walker can do the right thing on macrolet and symbol-macrolet.
<Bike>
aeth: ok, cool? I'm not talking about that.
<aeth>
Bike: If you make something easy to do then more people will do it, even if it's a bad thing.
<pfdietz>
At a higher level, the problem is that macros can do anything. So you can lose traceability back to your code.
<Bike>
I'm talking about implementing floats and you're like "it's pretty nasty that they're not associative" like yes sure
swills has joined #lisp
nowhereman_ has quit [Ping timeout: 268 seconds]
<aeth>
Well, you said implementation support would be nice. If I don't like floats, then I think that objecting is a valid response.
<pfdietz>
I want to solve this problem: walk a lambda and flag every cons cell in there that's a form. I don't think that's possible in general.
<pfdietz>
("flag" as in "put into a list of forms")
<Bike>
I mean it's not like code walking is only good for weird macros.
<pfdietz>
I can expand all macros, but that gives me all the forms in the expansion, not in the original lambda.
<aeth>
Bike: I mean, code walking has its uses, but all of the really weird macros try to do it ime
<aeth>
And it's really an issue of API design whether you can think of an alternative imo.
<pfdietz>
I think this sort of issue motivated some of the divergence from CL you see in Scheme family languages. Or at least, that's the impression I get.
<White_Flame>
the place where I used it, I was finding all uses of variables whose names start with "?" and creating a LET binding around the form. The reason I don't just make a LET for all of them is because it's expensive to look up the value.
<Bike>
If you think code walking has its uses why are you complaining at me about this
<White_Flame>
but really, code walking situations are generally going to be in a limited focus, looking for very particular things
Bad_K4rMa has joined #lisp
<White_Flame>
it's just that everybody has different particulars :-P
<White_Flame>
but it also does mean that simple, incomplete codewalkers suffice for those various situations & limitations
<aeth>
Bike: No feature is truly necessary. If a feature is abused more than it is legitimately used, then it isn't a good feature. Of course, maybe the reason it's abused more than it is legitimately used is because you can't get a good code walker in portable CL, so bad macros are more likely to attempt it.
<pjb>
pfdietz: I don't know what you're babbling: I can expand macrolets and symbol-macrolets perfectly well: https://termbin.com/2dkg
<pfdietz>
If your macros there exploit the &environment you will have a problem.
narimiran has quit [Ping timeout: 240 seconds]
<pjb>
jackdaniel: 1- only sbcl has (or had) a specific special form. 2- implementations that do, should provide a macro that expand to a form that let you qualify the subforms.
<pjb>
pfdietz: what problem?
<pfdietz>
Let's suppose one of your macros there calls macroexpand on something else, and passes the environment argument along to that expansion.
<pjb>
I exploit it passing it to macroexpand as is intended (there are examples in clhs macroexpand).
<pfdietz>
How did you construct that environment object in a portable way, given that it depends on the macrolets?
<pjb>
I let the host CL do it.
shangul has quit [Ping timeout: 265 seconds]
<pjb>
That's the trick!
<Bike>
this is a new and exciting definition of code walking.
<cl-arthur>
Anyone know any good books/papers/resources on code walking?
<Josh_2>
This chat right now
<pfdietz>
Bike: it certainly is.
<pfdietz>
In this thread, we discover that we can walk code, if we have already walked it and added codewalk forms.
<pjb>
pfdietz: However we should indeed node that "The object that is bound to the environment parameter has dynamic extent." says 3.4.4 Macro Lambda Lists
<jackdaniel>
big lol presents a code walker (which makes some invalid assumption which blows on sbcl)
<aeth>
My earlier point in one line: I think it's a decently common deisgn pattern to use code walkers to embed CL within some big pile of s-expressions and then have an exit point back. e.g. "(with-html (html (body (cl (dotimes (i 10) (in-html (p \"Hello\"..." but now you can't have helper functions because in-html doesn't actually exist. And of course you have the typical issues like you probably can't flet it.
<aeth>
This could actually be solved, even the helper function problem, depending on how you do the code walker's environment.
swills has quit [Ping timeout: 268 seconds]
swills_ has joined #lisp
Bad_K4rMa has quit [Remote host closed the connection]
<cl-arthur>
Xach: Thanks!
kamog has quit [Remote host closed the connection]
<pjb>
But indeed, lexical environment objects having dynamic extend is sorry.
<cl-arthur>
jackdaniel: is 'big lol' the let over lambda book?
<jackdaniel>
cl-arthur: yes
<jackdaniel>
and there is land of lisp
<jackdaniel>
I'm not sure why one is big and one is small, maybe I've made it up
<shka_>
i prefer LOL for let over lambda and lol for land of lisp ;-)
<Bike>
well "over" is an adverb so it should be capitalized, but "of" shouldn't, so therefore Let Over Lambda = LOL is bigger than Land of Lisp = LoL
<Bike>
hm, or maybe it's being used as a preposition here... mysteries
<shka_>
… can we agree to not write any other lisp books that abbreviate to l o l, it is already confusing
<LdBeth>
Learning on Lisp
* LdBeth
Done
efm has quit [Ping timeout: 265 seconds]
arma has joined #lisp
arma has quit [Client Quit]
arma has joined #lisp
newcup has quit [Ping timeout: 246 seconds]
karlosz has joined #lisp
<pfdietz>
League of Lisp
<dlowe>
Lisp of Legends
<cl-arthur>
Lore of Lisp - oh wait, that one's called Lisp Lore :)
<Josh_2>
Lisp over Λ
<Josh_2>
That won't be confusing
rippa has quit [Quit: {#`%${%&`+'${`%&NO CARRIER]
<phoe>
LoL over LoL
nowhereman_ has joined #lisp
<pfdietz>
Lololol
<phoe>
Lisp: Official Lexicon
<LdBeth>
cl-arthur: there’s two books called lisp lore
<LdBeth>
One is about lisp machine and another is about programming techniques
<cl-arthur>
LdBeth: Are those 'Lisp Lore: A guide to programming the lisp machine' and 'Lisp, Lore, and Logic: An algebraic view of LISP programming, foundations and applications', or is my search failing to turn one up?
lemoinem has quit [Ping timeout: 240 seconds]
ebrasca has quit [Remote host closed the connection]
lemoinem has joined #lisp
<LdBeth>
cl-arthur: true
nowhereman_ has quit [Remote host closed the connection]
nowhereman_ has joined #lisp
nowhereman_ has quit [Ping timeout: 272 seconds]
kajo has quit [Ping timeout: 246 seconds]
scymtym has quit [Ping timeout: 248 seconds]
gravicappa has quit [Ping timeout: 240 seconds]
Bad_K4rMa has joined #lisp
Bike has quit [Quit: Bike]
raghavgururajan has quit [Read error: Connection reset by peer]
mbrock has joined #lisp
emys has quit [Ping timeout: 260 seconds]
mrcom has joined #lisp
kajo has joined #lisp
klltkr has joined #lisp
emys has joined #lisp
mbrock has quit [Remote host closed the connection]
emys has quit [Ping timeout: 245 seconds]
mathrick has quit [Ping timeout: 258 seconds]
scymtym has joined #lisp
slyrus_ has joined #lisp
kajo has quit [Remote host closed the connection]
slyrus__ has quit [Ping timeout: 265 seconds]
kajo has joined #lisp
zclark` has joined #lisp
zclark has quit [Ping timeout: 268 seconds]
Bad_K4rMa has quit [Remote host closed the connection]
arma has quit [Quit: arma]
Bike has joined #lisp
bitmapper has joined #lisp
zclark`` has joined #lisp
Ven`` has quit [Read error: Connection reset by peer]
zclark` has quit [Ping timeout: 268 seconds]
tiwEllien has quit [Ping timeout: 272 seconds]
davepdotorg has joined #lisp
davepdotorg has quit [Ping timeout: 268 seconds]
Frobozz has joined #lisp
Frobozz has quit [Remote host closed the connection]
quazimodo has quit [Quit: leaving]
<cl-arthur>
5
quazimodo has joined #lisp
Nistur has quit [Ping timeout: 260 seconds]
<cl-arthur>
oops, sorry.
fengshaun has quit [Ping timeout: 265 seconds]
Tordek has quit [Ping timeout: 265 seconds]
fengshaun has joined #lisp
swills_ has quit [Ping timeout: 268 seconds]
LiamH has quit [Quit: Leaving.]
swills has joined #lisp
sjl has quit [Quit: WeeChat 2.2-dev]
pfdietz has quit [Remote host closed the connection]