kevingal has quit [Remote host closed the connection]
xsperry has quit [Remote host closed the connection]
hjudt has joined #lisp
<jcowan>
pjb: Quite so. But if there is no indirection, then you have to find and change all existing references to the string if you are extending it past the original allocation. That is equivalent to GC.
Oladon has quit [Quit: Leaving.]
zaquest has quit [Quit: Leaving]
zaquest has joined #lisp
lotuseater has quit [Quit: ERC (IRC client for Emacs 27.1)]
<pjb>
jcowan: indeed. On Macintosh OS, most heap objects were referenced via Handlers which were indirect pointers. So the Memory Manager could move them updating only the pointer, and not the handle which could be copied in other objects or variables.
<pjb>
a lisp implementation could easily use handles to refer objects, instead of direct pointers, if that helped the memory manager/garbage collector.
hjudt has quit [Ping timeout: 240 seconds]
<White_Flame>
and indirecting through symbols to find values/functions sort of does that already
<pjb>
yep
hjudt has joined #lisp
<andreyorst[m]>
does anybody know any clever semi-nontrivial yet somewhat short examples of condition system usage? I'm porting CL's condition system to Lua, and wanted to make sure I got everything right. Example from the Practical common Lisp book works, and a bunch from the lisp wiki too, so if anyone can link some more examples it would be helpful. Thanks!
nij has quit [Ping timeout: 276 seconds]
hjudt has quit [Ping timeout: 260 seconds]
theBlackDragon has quit [Ping timeout: 252 seconds]
hjudt has joined #lisp
b3rb has joined #lisp
b3rb has left #lisp [#lisp]
contrapunctus has left #lisp ["Disconnected: closed"]
contrapunctus has joined #lisp
spaethnl has quit [Ping timeout: 252 seconds]
raeda_ has joined #lisp
ebrasca has quit [Ping timeout: 246 seconds]
andreyorst[m] has quit [Ping timeout: 268 seconds]
contrapunctus has left #lisp ["Disconnected: closed"]
hjudt has quit [Ping timeout: 260 seconds]
hjudt has joined #lisp
raeda has quit [Ping timeout: 252 seconds]
mindCrime_ has quit [Ping timeout: 260 seconds]
Guester8 has joined #lisp
hjudt has quit [Remote host closed the connection]
contrapunctus has joined #lisp
drl has quit [Quit: Leaving]
hiroaki has quit [Ping timeout: 260 seconds]
contrapunctus has left #lisp ["Disconnected: closed"]
hypercube has quit [Ping timeout: 276 seconds]
drl has joined #lisp
pbaille has joined #lisp
pbaille has quit [Ping timeout: 252 seconds]
contrapunctus has joined #lisp
hjudt has joined #lisp
hjudt has quit [Ping timeout: 260 seconds]
orivej has quit [Ping timeout: 240 seconds]
contrapunctus has left #lisp ["Disconnected: Broken pipe"]
orivej has joined #lisp
raeda_ has quit [Ping timeout: 252 seconds]
raeda has joined #lisp
contrapunctus has joined #lisp
elderK has joined #lisp
KingRiver has joined #lisp
hjudt has joined #lisp
mindCrime_ has joined #lisp
Oladon has joined #lisp
KingRiver has quit [Read error: Connection reset by peer]
<jeosol>
Recently discovered C-c x for slime-export-symbol-at-point and it updates the (:export ...) section of the package with the symbol
<jeosol>
Definitely beats going up and down and typing the symbols yourself ... :-)
gaqwas has quit [Ping timeout: 252 seconds]
CrazyPython has quit [Read error: Connection reset by peer]
<stylewarning>
Do people use CLSQL for non-PG DBs?
<stylewarning>
jeosol: wow, how convenient
<dieggsy>
jeosol: sweet
<astronavt>
great idea
<no-defun-allowed>
stylewarning: I considered it once. Does that count? :)
<stylewarning>
no-defun-allowed: it counts as 5% of one vote
<jeosol>
stylewarning: I did use it with postgresql but with comments that it's bit-rotted, I moved away. I didn't have much problems though for my simple use-case
elderK has quit [Quit: WeeChat 3.1]
sauvin_ has joined #lisp
<stylewarning>
Maybe I’ll consider some NoSQL option. My use-case is lightweight
<jeosol>
btw, I was hoping to have a conversion with you guys about productivity coding with Lisp. It's a beauty working with slime and all. As some of you know, I am working a large physics application for a few years. I once described it to someone during a work meeting, he said there is no way I wrote all that code in the time I said. By the way, he is
<jeosol>
not so much a software person, but seems to think it's impossible to do
myall has joined #lisp
myall has quit [Changing host]
myall has joined #lisp
hjudt has joined #lisp
Sauvin has quit [Ping timeout: 276 seconds]
<no-defun-allowed>
"Be realistic, demand the impossible!"
<no-defun-allowed>
(Unless it is undecidable, in which case you should rethink your project.)
<jeosol>
no-defun-allowed: was that in response to my comment:
<no-defun-allowed>
Yes.
<jeosol>
I have already written the code - using CLOS mostly. Thanks to working though Sonja's book early one.
<jeosol>
In my case, I was rewriting more robust versions of graduate school codes. Started with matlab, then C++, then finally to lisp
<beach>
Good morning everyone!
<stelleonard>
I do rather like lisp for symbol processing
KingRiver has quit [Read error: Connection reset by peer]
semz has quit [Ping timeout: 250 seconds]
moon-child has joined #lisp
rumbler31 has quit [Remote host closed the connection]
CrashTestDummy3 has joined #lisp
CrashTestDummy2 has quit [Ping timeout: 260 seconds]
semz has joined #lisp
semz has joined #lisp
semz has quit [Changing host]
xkapastel has quit [Quit: Connection closed for inactivity]
orivej has quit [Ping timeout: 240 seconds]
drl has quit [Quit: Leaving]
contrapunctus has left #lisp ["Disconnected: closed"]
contrapunctus has joined #lisp
Bike has quit [Quit: Lost terminal]
<mister_m>
hm I am trying to create a property list to use with make-instance by reading input from a file, and using, for example, (list (make-symbol "input") "value") as a property list for the &rest portion of (apply #'make-instance 'my-class ...), but the resulting initarg is invalid. My class has a slot with an :initarg of :input, but the symbol I end up with as a result of make-symbol is #:|input| and doesn't seem to be compatible. How can I
<mister_m>
get a symbol compatible with my class's :initarg value?
<beach>
mister_m: You have two problems. First, using make-symbol creates an uninterned symbol, but what you need is a symbol in the keyword package.
<beach>
mister_m: Second, even though you would write :input, the name of the symbol is in upper-case.
<mister_m>
I see, I didn't realize I couldn't use an uninterned symbol
<beach>
mister_m: So you first have to upcase the string and then intern it in the keyword package.
<mister_m>
makes sense, thank you
<beach>
Oh, you can use an uninterned symbol, but it won't be the symbol :input.
hjudt has quit [Ping timeout: 240 seconds]
hjudt has joined #lisp
KingRiver has quit [Ping timeout: 246 seconds]
<beach>
When you write :input, that means a specific symbol in the keyword package, and trying a completely different one to pass to MAKE-INSTANCE just won't work.
Josh_2 has quit [Ping timeout: 252 seconds]
<pjb>
and you would have the difficulty of using the same uninterned symbol: you'd have to keep a reference of it at compilation time (when the initarg is defined) and at run-time when it's used.
<beach>
I am pretty sure first-class continuations could be used for non-local control transfer.
<beach>
h4ck3r9696: And I really like the terminology that phoe created, i.e., calling it "exceptions" only when they are dumb like in most languages, and "conditions" when they are like those in Common Lisp.
nature has joined #lisp
hypercube has quit [Quit: WeeChat 3.1]
mindCrime_ has joined #lisp
karlosz has joined #lisp
hjudt has quit [Ping timeout: 240 seconds]
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
orivej has quit [Ping timeout: 260 seconds]
<h4ck3r9696>
okay, thanks, i'll look into it!
<ChoHag>
h4ck3r9696: Bear in mind that scheme's continuations are undelimited and drag along the whole computation.
<Nilby>
In scheme terms, you need catch, throw, and dynmaic-wind. You could use continuations if you assume infinite stack or every function is pure and tail recursive.
<h4ck3r9696>
I know, i'm making myown scheme and i wanted to make it more lisp-like
shifty has quit [Ping timeout: 265 seconds]
shifty has joined #lisp
lmm014 has joined #lisp
aartaka_d has joined #lisp
<beach>
Oh, YAY, another implementation!
<h4ck3r9696>
it's just for fun
<beach>
Sure. A toy.
<beach>
Right?
<h4ck3r9696>
like anything that isn't SBCL
<beach>
Is there something wrong with SBCL?
<h4ck3r9696>
it's the only lisp implementation that matters
<beach>
That's a bold statement.
aartaka has quit [Ping timeout: 260 seconds]
<Nilby>
Look at srfi-12 it says
<Nilby>
"This SRFI cannot be fully implemented in R5RS because it requires special support from the system,"
<h4ck3r9696>
i can tweak the interpreter, so i don't think it will be problematic to implement
<Nilby>
but it also says: "defines an exception system whose essence can be implemented with CALL-WITH-CURRENT-CONTINUATION"
<beach>
h4ck3r9696: So your implementation is based on an interpreter?
<h4ck3r9696>
yes, a toy for now
lmm014 has quit [Remote host closed the connection]
<h4ck3r9696>
but i'm planning to create a native compiler
lmm014 has joined #lisp
<h4ck3r9696>
Nibly: Well, that's good
<beach>
h4ck3r9696: And you are doing this in order to learn how, yes?
<h4ck3r9696>
i'm making a game
<h4ck3r9696>
and i needed a scripting language
<h4ck3r9696>
so i thought, why not make my own?
<beach>
And what language is the game written in?
<h4ck3r9696>
in C
<beach>
Why not Common Lisp?
<beach>
Then you wouldn't need a separate scripting language.
<h4ck3r9696>
because i want a small memory footprint
<Nilby>
srfi-34 basically calls catch+sepcials=guard and throw->raise
<v0|d>
beach: another day another implementation :)
<beach>
h4ck3r9696: And why is that? And how small?
<beach>
v0|d: Yes, I am always curious about people's reasons for this kind of stuff.
<v0|d>
gambit-c was pretty small.
<h4ck3r9696>
beach: the less memory used by the language, the more can be used for other things
<h4ck3r9696>
but i'm really doing it to learn programming language desing
<h4ck3r9696>
*design
<v0|d>
h4ck3r9696: try reading the compilers source.
lmm014 has quit [Ping timeout: 246 seconds]
<v0|d>
you'll have more fun and more to learn.
<h4ck3r9696>
i don't think i'm fluent enough in common lisp to read the sbcl source code
<v0|d>
h4ck3r9696: try ecl
<v0|d>
h4ck3r9696: if you are into C.
<beach>
v0|d: And more feelings of horror. :)
<h4ck3r9696>
i'll try that
<phoe>
>the more can be used for other things
<v0|d>
beach: yep only the horror belongs to somebody else :p
<beach>
True.
<phoe>
h4ck3r9696: the less time you spend writing your own code, the more can be used for other things too
<phoe>
and debugging implementations is a major pain in the butt, especially on the low level
<v0|d>
I can't make any of students read a codebase, everybody is into writing something.
infra_red[m] has quit [*.net *.split]
Shinmera has quit [*.net *.split]
TMA has quit [*.net *.split]
amb007 has quit [Read error: Connection reset by peer]
<beach>
I think it's fine to write an implementation of something like Scheme in order to learn about compiler design.
rogersm has quit [Quit: Leaving...]
amb007 has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
<h4ck3r9696>
but common lisp might be too slow for what i want
<h4ck3r9696>
i need fast 3D matrix multiplication
<beach>
But the other reasons were not so convincing.
<ChoHag>
h4ck3r9696: There is cffi.
<phoe>
h4ck3r9696: then get a library that does fast matrix multiplication
<v0|d>
h4ck3r9696: fortran/lapack?
<beach>
h4ck3r9696: It would be way more efficient to write a C or assembly routine for a major Common Lisp implementation, than to resort to C for the entire thing.
<phoe>
mfiano wrote one of them AFAIK, and he's writing games in CL
<Nilby>
If you want small memory footprint you could use pdp1 lisp. It used about 8k.
<phoe>
which I guess is some definition for fast enough matrix multiplication
<beach>
h4ck3r9696: That is why I said that your "learning" reason is fine, but the others are way less convincing.
<h4ck3r9696>
yep, i guess so
<h4ck3r9696>
but for the moment, i'm not good enough at common lisp to make a big project
<h4ck3r9696>
that basically the main reason
<h4ck3r9696>
*that's
aartaka has joined #lisp
<phoe>
time to learn then!
<beach>
h4ck3r9696: I say, don't let anyone tell you what you can and can not do. But also, don't fool yourself with bogus arguments.
aartaka_d has quit [Ping timeout: 252 seconds]
<beach>
h4ck3r9696: I mean, it takes way less time to learn Common Lisp than to implement a scheme compiler for the purpose of scripting a C application.
mindCrime_ has quit [Ping timeout: 252 seconds]
<h4ck3r9696>
i know, but this is all for fun
<v0|d>
beach: will you be presenting at els2021?
<beach>
Fun and learning are good arguments. Not knowing Common Lisp right now is less convincing.
<phoe>
v0|d: according to the program, he will
<v0|d>
mon or tue?
<beach>
v0|d: Yes, Tuesday 14:30.
<phoe>
and according to the contents of my hard drive, he will
<v0|d>
great.
<joga>
fast matrix stuff eh... use gpu? :)
<beach>
v0|d: But it's recorded, and I can give you a link to the recording if you prefer. :)
<v0|d>
beach: no worries, i'll be there, looking forward to listen, good luck
infra_red[m] has joined #lisp
Shinmera has joined #lisp
TMA has joined #lisp
<beach>
Thanks.
amb007 has quit [Read error: Connection reset by peer]
random-nick has joined #lisp
<madrik>
Should I #' lambda forms or not? Different sources tell me different things. Is it only esthetics?
<beach>
Don't use #' with lambda expressions as forms.
aartaka_d has joined #lisp
amb007 has joined #lisp
aartaka has quit [Ping timeout: 265 seconds]
<madrik>
I know it's just a macro that expands into a FUNCTION form.
<beach>
You may consider #'(lambda ...) as obsolete and existing only for hysterical raisins.
<pjb>
I agree, normally you should not use #' with lambda. However depends on whether #' is the standard reader macro, of if you changed the read table.
<madrik>
The only argument I've heard for #' before lambda is that it expressly indicates the function-ness of the form.
<pjb>
And (lambda …) depends on whether it's cl:lambda or a lambda in another package.
<madrik>
Why would one shadow lambda?
<pjb>
(and then, even cl:lambda may depend on whether it's the standard read-table, or a read-table that has been changed to read in another package).
<beach>
madrik: That argument is not a very strong one.
<pjb>
madrik: for example, to implement instrumentation of the code. cf. eg. cl-stepper.
<pjb>
IBCL could use the readtable trick so that cl:lambda for user code is not the Common Lisp LAMBDA… But instead it only tricked on in-package.
karlosz has quit [Quit: karlosz]
<pjb>
err, defpackage actually.
<pjb>
So if you write cl:defpackage you don't get ibcl:defpackage, but if you write defpackage, you get ibcl:defpackage.
<pjb>
It's important to keep in a corner of your mind the assumption with which you're working. Sometimes they're wrong.
<madrik>
pjb: Indeed.
<pjb>
What's called the application condition for theorems in maths and physics…
<madrik>
And on the subject of assumptions, how freely does one use CHECK-TYPE?
shifty has quit [Ping timeout: 252 seconds]
<pjb>
For example people aways forget that entropy can only increase, but only in CLOSED systems. 1- we assume the whole universe is a closed system. 2- all the system with which we work ARE NOT closed systems!
<pjb>
madrik: you can be quite liberal with check-type.
<pjb>
madrik: personnaly, I would use it on API functions. Perhaps not on internal functions.
<pjb>
madrik: the reason why I may refrain using them on internal functions is because check-type invokes the interactive debugger to resolve problems. You may want to avoid that on inner functions. But you would definitely want that for API functions and in general, functions closer to the user.
<pjb>
Ie. definitely on functions receiving data from I/O.
monolithic has joined #lisp
<phoe>
madrik: freely, as in?
<phoe>
everywhere you need a type-checking assertion, use check-type
<madrik>
phoe: frequently, liberally, but not quite wantonly.
<phoe>
pjb: a solution for internal functions is ASSERT TYPEP with an empty list of places
<pjb>
Basically also, I would use check-type before any type declaration.
<madrik>
E.g., I learned about DEFTYPE, and thought it was possible to go overboard defining such types as positive-integer, nonnegative-real-number, etc.
<pjb>
For example (check-type i fixnum) (locally (declare (type fixnum i) (the fixnum (truncate i 2))))
lmm014 has quit [Ping timeout: 252 seconds]
<pjb>
The post assertion of check-type is that the place holds an object of that type, therefore you can tell the compiler that the object is of that type. (some compilers are dumb).
<pyc>
Is there an equivalent of C's "hello\n" (newline within a string) in CL?
<pjb>
pyc: not really.
<pjb>
pyc: you just insert a newline
<pjb>
"hello
<pjb>
world"
<madrik>
Maybe a format string to the effect?
hjudt has joined #lisp
<madrik>
But not quite
<pjb>
pyc: now, with format you can use ~& or ~%: (format nil "hello~%world") but this is not a string literal.
<pjb>
pyc: You could use #.(format nil "hello~%world") to make it a string literal…
<pyc>
pjb: Oh, I want something like (let search-string "hello\n" ...) so that I can later do (search search-string my-string).
<no-defun-allowed>
I used funny-looking type specifiers for integers to let type inference avoid bounds checks on multiplication and all.
<pjb>
pyc: but actually we have the other, with ~newline: we can have newline in literal format control strings, and use ~newline to specify how this literal newline ust be interpreted:
<pjb>
(format nil "hello~
<pjb>
world") #| --> "helloworld" |#
<no-defun-allowed>
Stuff like (mod #.(floor most-positive-fixnum 16))
<pjb>
Note that with ~newline, the prefix spaces on the following lines are ignored too. This let you indent nicely long string literals.
<pjb>
pyc: Using (format nil "hello~%") or #.(format nil "hello~%") wouldn't be too surprising. (let ((search-string (format nil "hello~%"))) (search search-string text)).
<pjb>
pyc: but you may also consider using cl-ppcre (cl-ppcre:scan (format nil "hello~%") (format nil "bonjour~% how do you hello~% world!")) #| --> 20 ; 26 ; #() ; #() |#
<pjb>
pyc: sorry, I meant: (cl-ppcre:scan "hello\\n" (format nil "bonjour~% how do you hello~% world!")) #| --> 20 ; 26 ; #() ; #() |#
<pjb>
pyc: cl-ppcre regexps are perl regexps, there "\\n" is interpreted as you want. (but it's not a newline character there, just a backslash and a n that is parsed by cl-ppcre.
rgherdt has left #lisp ["Leaving"]
<pyc>
pjb: thanks!
<pjb>
pyc: finally, if you really need it (ie. you have a lot of strings with such escapes, you can of course define your own reader macro for #\"
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
rumbler31 has joined #lisp
mindCrime_ has quit [Ping timeout: 252 seconds]
lmm014 has joined #lisp
rumbler31 has quit [Ping timeout: 265 seconds]
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
andreyorst[m] has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
lmm014 has quit [Ping timeout: 252 seconds]
amb007 has joined #lisp
madrik has quit [Ping timeout: 252 seconds]
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
<mfiano>
Yes, don't use #'(lambda ...). There is at least one place where a lambda expression is mandated by the standard, not a function, and it's more verbose anyway.
sm2n_ is now known as sm2n
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
vegansbane6963 has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
vv8 has joined #lisp
waleee-cl has joined #lisp
jeosol has joined #lisp
lotuseater has joined #lisp
vv8 is now known as undecidedvisrain
undecidedvisrain is now known as undvrainbowvital
undvrainbowvital is now known as undvrainbowvita8
lmm014 has joined #lisp
hjudt has quit [Ping timeout: 240 seconds]
lmm014 has quit [Ping timeout: 240 seconds]
lmm014 has joined #lisp
hjudt has joined #lisp
shifty has joined #lisp
tlaxkit has joined #lisp
pbaille has quit [Read error: Connection reset by peer]
pbaille_ has joined #lisp
hendursaga has quit [Remote host closed the connection]
hendursaga has joined #lisp
pbaille has joined #lisp
cage_ has joined #lisp
pbaille_ has quit [Read error: Connection reset by peer]
pbaille_ has joined #lisp
dm1les has joined #lisp
lmm014 has quit [Remote host closed the connection]
pbaille has quit [Ping timeout: 240 seconds]
supercoven has joined #lisp
pbaille has joined #lisp
pbaille_ has quit [Ping timeout: 240 seconds]
pbaille_ has joined #lisp
shifty has quit [Ping timeout: 246 seconds]
pbaille has quit [Ping timeout: 260 seconds]
shifty has joined #lisp
fourier has joined #lisp
leeren has quit [Quit: leeren]
leeren has joined #lisp
leeren has quit [Quit: leeren]
jeosol has quit [Quit: Connection closed]
rumbler31 has joined #lisp
rumbler31 has quit [Remote host closed the connection]
orivej has joined #lisp
<pyc>
In Common Lisp, the format specifier ~a is same as ~A, right? Similarly #\space is same as #\Space, right? is there any popular coding convention about which form to choose?
<beach>
I haven't seen any such convention.
<Xach>
I prefer ~A to ~a, I find it easier to read. I also prefer #\Caps to #\lowercase
<Xach>
If you wish to be friendly to readers, always use #\space or #\Space instead of #\ .
<pyc>
Xach: thanks!
<pyc>
Xach: I use #\space currently. Any disadvantage of using #\ ?
<no-defun-allowed>
I thought Norvig and Pitman said ~A sticks out more, but it could be anyone else.
<CL-ASHOK>
Which would be better: (in-package :my-package) or (in-package 'my-package)
<beach>
(in-package #:my-package)
<CL-ASHOK>
' is a symbol and : is a keyword...
<CL-ASHOK>
why #:?
<p_l>
' is not a symbol
<p_l>
it's a macro for (quote ...)
<beach>
Because then you clearly indicate to the reader of your code that the package of the symbol you give is not important. Only the name.
<CL-ASHOK>
sorry you are right :)
<pyc>
CL-ASHOK: ' is most definitely not a symbol. why do you say that?
<CL-ASHOK>
@pyc just stupid :D
<CL-ASHOK>
@beach what does the "#" do?
<pyc>
reader macro
<p_l>
CL-ASHOK: : is similarly defined as reader macro that will read the symbol as one with no value and PACKAGE set to "KEYWORD" - so every time you use :, you'll always get the same symbol from the same package
<p_l>
CL-ASHOK: #: is actually a separate reader macro, which creates uninterned symbol, so it's not a keyword
<CL-ASHOK>
ah
<CL-ASHOK>
makes sense
<CL-ASHOK>
thanks guys
<beach>
CL-ASHOK: The @ convention is not used on IRC. Just type the nick of the person followed by : and use completion for that.
<CL-ASHOK>
so : creates keyword (which can be accessed in code), while #: implies its not going to be used anywhere else
<CL-ASHOK>
beach: Thanks :)
<beach>
CL-ASHOK: It can be used elsewhere, but it means that it has no home package, so you clearly say that the package is not important.
<p_l>
#: will create a new "symbol object" every time you use it, but it won't attach it to any package
surabax_ has joined #lisp
<p_l>
This is useful in various situations, for example you might want to use a symbol only for it's name value one time (used to be somewhat common in package definitions) to avoid polluting the namespace with it
<beach>
I consider the "pollution" argument as being a bit weaker. The argument that it is the most specific construct is better.
surabax has quit [Ping timeout: 252 seconds]
amk has joined #lisp
<pyc>
anyone knows what the name of the book "Let Over Lambda" means? is it a pun? if so I am not getting it.
<beach>
"LoL"
<beach>
Also referring to the fact that LET can be seen as a special case of a compound form with a lambda expression in its CAR.
<CL-ASHOK>
pyc: I think its because they use let a lot with lambda expressions
<beach>
... which in fact is not true, but it is widely believed to be the case.
lmm014 has joined #lisp
<beach>
One might think that (let ((<some-var> <some-form>)) ... <some-var>) would be the same as ((lambda (<some-var>) ... <some-var>) <some-form>) would always be equivalent.
surabax_ has quit [Ping timeout: 240 seconds]
amk has quit [Remote host closed the connection]
<beach>
But they aren't when <some-var> is a lambda-list keyword. Try translating (let ((&rest 10)) (+ x 20)) to the other form.
<CL-ASHOK>
beach: "... it means that it has no home package..." --> If I use ":" then it will intern in the keyword package? Wouldn't that mean its a good thing, since a package name is like a keyword and it would not be good to have any clashes with other keywords with the same name (which may happen if its uninterned)?
<beach>
CL-ASHOK: Uninterned symbols never clash, because a new symbol is created every time.
<Xach>
Uninterned symbols never clash!
amk has joined #lisp
CL-ASHOK has quit [Ping timeout: 240 seconds]
saganman has joined #lisp
saganman has joined #lisp
saganman has quit [Changing host]
Sheilong has joined #lisp
CrazyPython has joined #lisp
perrier-jouet has joined #lisp
<nij>
I guess what CL-ASHOK is concerned with is that a package should correspond to a keyword.
<nij>
But if you use #:.. it creates a different keyword everytime that corresponds to the same package.
<beach>
WHAT?
<nij>
s/different keyword/different symbol/
<beach>
Right, and what is this "same package" business?
amb007 has quit [Ping timeout: 246 seconds]
amb007 has joined #lisp
<gendl__>
beach: nij is saying it generates a separate symbol object but with the same symbol-name, so it refers to the same package object if used with e.g. defpackage or in-package.
<beach>
Oh, I see. Thanks.
<beach>
I am notorious for having difficulties understanding what people say/write, unless it is very precise.
* beach
can't "fill in the blanks".
<gendl__>
he’s talking about using e.g. #:my-package in one place in code, then #:my-package again in another place.
<beach>
I think I understand.
<gendl__>
I never actually thought about that. So from a memory storage point of view, :my-package would be more space-efficient.
pbaille_ has quit [Remote host closed the connection]
leo_song has quit [Read error: Connection reset by peer]
pbaille has joined #lisp
<beach>
At least temporarily, sure.
<gendl__>
... because these things actually get stored in fasls and in the code section of memory, right?
<beach>
I suppose.
<phoe>
note that gensyms are GCable if used only temporarily, so even if you allocate more of them then they get cleaned by the GC
leo_song has joined #lisp
<gendl__>
I’m guessing intuitively that the difference would normally be negligible. But maybe it would be something fun to experiment around with on a rainy Sunday afternoon.
tlaxkit has quit [Quit: Konversation terminated!]
mrchampion has joined #lisp
<raeda_>
pyc: I have a copy of LOL. The title refers to creating a closure: the lambda captures the let's environment
surabax has joined #lisp
pbaille has quit [Ping timeout: 240 seconds]
CL-ASHOK has joined #lisp
<CL-ASHOK>
gendl__: "he’s talking about using e.g. #:my-package in one place in code, then #:my-package again in another place." --> Precisely, since I would define it within (defpackage and then re-use it later in the package itself)
<CL-ASHOK>
beach: I'm unclear on it myself, so my words would only be confusing :)
pbaille has joined #lisp
<beach>
CL-ASHOK: The main point is that (in-package #:my-package) is very close to (in-package "MY-PACKAGE") because IN-PACKAGE takes a string designator, so if the symbol is given, its name is used which is "MY-PACKAGE".
<CL-ASHOK>
beach and Xach: Wouldn't it be a good thing for the symbols to clash (hence interning them is good), since it forces less ambiguity when writing code? Perhaps its a question of how many programmers work on a project - a single programmer perhaps should intern his package name and a large group working together perhaps should not?
<beach>
But #:my-package looks less ugly, because you would typically use lower case when you define your package.
<beach>
CL-ASHOK: Whether you use an interned or an uninterned symbol has absolutely no effect on sharing.
aartaka_d has quit [Read error: Connection reset by peer]
<beach>
CL-ASHOK: In both cases only the SYMBOL-NAME is used, so the result is the same.
<beach>
CL-ASHOK: The point here is not about semantics, but about the message you send to the person reading your code.
<CL-ASHOK>
beach: thanks, that's a good reminder. I remember reading that, but that explains it nicely
jonatack has quit [Ping timeout: 260 seconds]
<beach>
CL-ASHOK: If you use an interned symbol, you may give the reader of your code the impression that the package of that symbol is somehow important in this context.
<beach>
CL-ASHOK: Maybe you have a tool that reads this code some other way than the compiler, and that tool requires the symbol to be in a particular package.
<CL-ASHOK>
beach: but isn't ":my-package" in the global keyword package or I misunderstood?
jonatack has joined #lisp
<beach>
CL-ASHOK: Yes, and you are telling your maintainer "by the way, it has to be the keyword symbol here, because the package is important".
<beach>
So you are lying to your maintainer.
pbaille has quit [Ping timeout: 268 seconds]
<CL-ASHOK>
beach: OK, yes I just got what you meant
hjudt has quit [Ping timeout: 240 seconds]
ebrasca has joined #lisp
<CL-ASHOK>
now it clicks
<beach>
CL-ASHOK: But if you use #:my-package, you are telling the maintainer "Yes, this is a symbol, but since it has no package, I can't possibly take advantage of its package"
hjudt has joined #lisp
<CL-ASHOK>
beach: sorry to be obtuse, this I don't get "since it has no package, I can't possibly take advantage of its package" --> why would someone want to take advantage of the package?
<beach>
I just told you.
<beach>
Maybe you have a tool (the editor?) that reads the code and requires it to be a particular package.
<CL-ASHOK>
Ahhh
<CL-ASHOK>
Got it
<CL-ASHOK>
Thanks!
<beach>
"In this project of mine, all the arguments to IN-PACKAGE must be keyword symbols, because I have this tool that scans my code and extracts all those symbols"
<CL-ASHOK>
copying this chat for future reference :)
<beach>
No need. The channel is logged.
<beach>
Programmers often forget that the compiler is frequently just one of many tools that might be reading the code.
<CL-ASHOK>
is there a search tool to find Q&A answered previously in #lisp (over the last many years)?
<beach>
yes, click the "search" button on the log site.
<CL-ASHOK>
Nice!
jonatack_ has joined #lisp
jonatack_ has quit [Client Quit]
<beach>
The tymoon.eu log, that is.
<CL-ASHOK>
Cheers
jonatack has quit [Read error: Connection reset by peer]
<beach>
Whew! That was taxing. :)
<ebrasca>
Hi
<beach>
Hello ebrasca.
<CL-ASHOK>
beach: Lisp has too many advanced concepts in it :)
<beach>
Well, most of this discussion was about communication with the maintainer. The semantics of Common Lisp are much simpler than those of most languages.
pbaille has joined #lisp
rumbler31 has joined #lisp
<CL-ASHOK>
That is true
jonatack has joined #lisp
pbaille has quit [Ping timeout: 240 seconds]
rumbler31 has quit [Ping timeout: 260 seconds]
mparlaktuna has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
jonatack has quit [Ping timeout: 240 seconds]
jonatack has joined #lisp
amb007 has joined #lisp
lmm014 has quit [Remote host closed the connection]
aartaka has joined #lisp
dra has joined #lisp
lmm014 has joined #lisp
theBlackDragon has joined #lisp
cosimone has joined #lisp
lmm014 has quit [Remote host closed the connection]
lmm014 has joined #lisp
<jcowan>
beach: Has anyone written either a denotational or an operational semantics for a large part of CL?
<beach>
Not that I am aware of.
<beach>
Sounds like fun, though.
hypercube has joined #lisp
lmm014_ has joined #lisp
<Nilby>
Wow. Imagine the formal semantics for loop and format?
<beach>
LOOP should not be too hard. It can be specified in terms of expansion.
<jcowan>
Usually you do full macroexpansion and then provide the semantics of what's left. Format is another matter: arguably a different language altogether.
lmm014 has quit [Ping timeout: 252 seconds]
<beach>
Yes, FORMAT is different.
<jcowan>
In addition, some things like LET are treated as primitive in CL, but obviously need not be.
<Nilby>
Judging by every implemtation, I think LOOP is pretty hard.
<beach>
Except see my argument why LET can't be easily expanded to ((lambda ...)...).
<Nilby>
and yes I've looked at the new SICL LOOP
<beach>
Nilby: It's a tricky macro, and most implementations seem to use the (not so great) MIT LOOP.
<Nilby>
It's funny, recently looked at an old MIT LOOP and it seemed much more tractable than the current one in use.
<jcowan>
beach: pointer to this argument?
mparlaktuna has quit [Ping timeout: 276 seconds]
dra has quit [Quit: Leaving]
hypercube has quit [Quit: WeeChat 3.1]
mparlaktuna has joined #lisp
<lukego>
jcowan: it's not a large part of CL but I've recently been digging into ACL2 and wow that's an amazing system that's very strongly Common Lisp flavored.
<jcowan>
yes indeed
<jcowan>
I've never tried to use it, but I admire its rigor
skapata has joined #lisp
<jcowan>
of course the most common type of rigor is rigor mortis. :-)
<beach>
jcowan: That it MIT LOOP is not so great?
<lukego>
yeah I was surprised to find that it seems to be alive and humming along, always assumed it would be something archaic and dying
<jcowan>
The same might be said of CL!
<beach>
jcowan: It allows for clause orders that are not conforming.
mparlaktuna has quit [Ping timeout: 250 seconds]
<beach>
jcowan: And it assigns iteration variables out of range.
<jcowan>
What's an example, then? (I have a concrete-operational mind.)
<jcowan>
(To be clear, I am talking about LET expansion)
<beach>
Give me a few minutes...
<beach>
Oh, sorry.
<phoe>
(let ((&key 42)) (+ &key 24))
<beach>
yes.
<phoe>
so basically, LLKs used as variables
<phoe>
a very hard-to-encounter edge case, but a nasty one
<Nilby>
So is sicl-loop ready such that I can load it on other implementations and put in a for-as-X clause for my pet generic sequence?
<beach>
Nilby: Yes, I think so. Xach has been using it to check for non-conforming LOOP constructs in Quicklisp projects.
<jcowan>
I admit that is awesome. (Most Schemes that have LLKs make sure they aren't identifiers by using #!key or the like.)
<Nilby>
beach: Cool! I'll try give it a spin.
<beach>
Nilby: In fact, nothing bad happens to you if you just load it into SBCL. You will trip the package lock, but if you accept, then it just works it seems.
pbaille has joined #lisp
CL-ASHOK has quit [Ping timeout: 240 seconds]
saganman has quit [Quit: Leaving]
mparlaktuna has joined #lisp
rodentrabies has quit [Quit: Idle for 30+ days]
nature has quit [Ping timeout: 240 seconds]
gourdhen has quit [Ping timeout: 265 seconds]
gourdhen_ has joined #lisp
long4mud has quit [Ping timeout: 246 seconds]
lmm014_ has quit [Remote host closed the connection]
mparlaktuna has quit [Ping timeout: 276 seconds]
hjudt has quit [Ping timeout: 246 seconds]
<nij>
Sorry I was away ~2hrs ago to help gardening.
<nij>
Yeah sorry for my sloppiness in using the right terminology. I understand it creates misunderstanding when I do that.. I will be more careful.
hypercube has joined #lisp
hypercube has quit [Remote host closed the connection]
hypercube has joined #lisp
hypercube has quit [Client Quit]
hypercube has joined #lisp
hypercube has quit [Client Quit]
<dieggsy>
so i much prefer quri, but it's someone else's codebase - what's the puri equivalent of quri:make-uri ?
<dieggsy>
...i can't seem to find one lol
dukester has joined #lisp
<pjb>
nij: in that case, packages are named by strings. package operators use: - package designators, which are either a package (itself), or string designators designating a package name, or - string designators (to designate symbols whose names are also strings). String designators are either characters designating a 1-char string containing it, symbols (whose name designates string equal to it), or strings.
<pjb>
nij: because of this designator hierarchy, you can (defpackage #\A (:use "CL" cl :cl #:cl #.(find-package "CL") #| <-- !! |# ) (:export #\F "F" f :f #:f))
mparlaktuna has joined #lisp
andreyorst[m] has quit [Remote host closed the connection]
<jcowan>
pjb: What hair. I sketched out a runtime package system for Scheme once, and my first decision was to heave all that overboard and say that the argument to a package procedure is a package object, period.
hjudt has joined #lisp
<pjb>
jcowan: yes, but in CL, packages are used at read-time, which occurs usually at compilation-time, therefore we must be able to declare things about packages possibly before or while they are defined.
<pjb>
Also, syntactically, it's easier to use symbols.
<jcowan>
That was another decision: don't attempt to integrate the package system with R[67]RS library system, which exists only at macroexpansion time.
mparlaktuna has quit [Ping timeout: 276 seconds]
<jcowan>
Another blocker is that there just isn't enough demand for a symbol/package system used at runtime.
slyrus has joined #lisp
gourdhen_ has quit [Ping timeout: 276 seconds]
gourdhen has joined #lisp
saganman has joined #lisp
hjudt has quit [Ping timeout: 240 seconds]
White__Flame is now known as White_Flame
heisig has quit [Quit: Leaving]
josrr has joined #lisp
<josrr>
dieggsy: I think you should use (make-instance 'puri:uri …)
<dieggsy>
josrr: you're exactly right, and now that you've said that it seems obvious heh. thanks!
hjudt has joined #lisp
<Nilby>
So I managed to make an sbcl un-killable, not even a zombie. Is there even any O/S that isn't crap?
andreyorst[m] has joined #lisp
Nilby has quit [Ping timeout: 250 seconds]
zigpaw1076132 has joined #lisp
Inoperable has quit [Ping timeout: 260 seconds]
zigpaw107613 has quit [Ping timeout: 260 seconds]
charles` has quit [Ping timeout: 276 seconds]
<pjb>
If Nilby had stayed a tad longer, I would have advised a kill -9
<pjb>
or two.
slyrus_ has joined #lisp
Inoperable has joined #lisp
klltkr has joined #lisp
jeosol has joined #lisp
slyrus_ has quit [Ping timeout: 240 seconds]
<nij>
pjb i see, thanks :)
lmm014 has joined #lisp
lmm014_ has joined #lisp
thrashdin has joined #lisp
thrashdin is now known as aun
lmm014 has quit [Ping timeout: 246 seconds]
rumbler31 has joined #lisp
rumbler31 has quit [Ping timeout: 252 seconds]
luckless has joined #lisp
dukester has left #lisp ["Leaving"]
shifty has joined #lisp
hjudt has quit [Ping timeout: 240 seconds]
raeda has joined #lisp
raeda_ has quit [Ping timeout: 252 seconds]
hjudt has joined #lisp
mindCrime_ has joined #lisp
theothornhill has joined #lisp
imode has joined #lisp
aun has quit [Quit: Connection closed]
cosimone has quit [Remote host closed the connection]
hypercube has joined #lisp
saganman has quit [Quit: Leaving]
hypercube has quit [Client Quit]
hypercube has joined #lisp
oxum has joined #lisp
nij has quit [Ping timeout: 276 seconds]
oxum has quit [Client Quit]
DHARMAKAYA has joined #lisp
nature has joined #lisp
mindCrime_ has quit [Ping timeout: 260 seconds]
CrashTestDummy2 has joined #lisp
cage_ has quit [Quit: Leaving]
CrashTestDummy3 has quit [Ping timeout: 260 seconds]
mindCrime_ has joined #lisp
johnjay has quit [Ping timeout: 240 seconds]
hypercube has quit [Ping timeout: 276 seconds]
hypercube has joined #lisp
hypercube has quit [Quit: WeeChat 3.1]
nij has joined #lisp
<nij>
Hi beach! Which parts of COMMONDOC aren't you convinced yet? And, when you mean to parse dpANS, do you want the macro to stay as they are, or you don't mind if it's parsed with all macros unwinded?
_jrjsmrtn has joined #lisp
__jrjsmrtn__ has quit [Ping timeout: 240 seconds]
lmm014_ has quit [Remote host closed the connection]
shifty has quit [Ping timeout: 252 seconds]
shifty has joined #lisp
lmm014 has joined #lisp
mindCrime_ has quit [Ping timeout: 252 seconds]
lmm014 has quit [Remote host closed the connection]
lmm014 has joined #lisp
<sm2n>
huh, this is kind of interesting. Apparently a researcher who was trying to make a formal model for OOP ended up reinventing generic functions a la CLOS independently via theory
<Inline>
there are still some beef in OOP
<sm2n>
this was while trying to give a nicer foundation to more "traditional" class-based message-passing OOP
<Inline>
i saw some objections to some defaults or some such on some websites
<sm2n>
defaults?
ChoHag has quit [Read error: Connection reset by peer]
<Inline>
erm, peter gabriel, dreamsongs.com, hexsoft.com etc..
<sm2n>
while I know who these people are, I don't follow what you are trying to say
lmm014 has quit [Ping timeout: 240 seconds]
<Inline>
welp, there are some objections to the standard as far as i understand
<sm2n>
oh
<sm2n>
well everyone has their pet peeves, that's normal
<Inline>
with respect to standard-class and standard-object etc...
<Inline>
yah
<Inline>
not sure how much would be affected by such a thing in user-code
<Inline>
even the adaption implementation wise is not clear
shifty has quit [Ping timeout: 260 seconds]
mindCrime_ has joined #lisp
shifty has joined #lisp
ChoHag has joined #lisp
<Nilby>
pjb: it was for real stuck. no amount of -9 could kill it "D" status in ps. But I've given up unix and now I'm just gonna run Mezzano
<Inline>
erm, i get some non ok exit codes from some parts in sbcl
<Inline>
while compiling sbcl on voidlinux, it's mostly either threads-impure.lisp or so or something relating to mutexes
Lord_of_Life has quit [Ping timeout: 252 seconds]
Lord_of_Life has joined #lisp
<Inline>
not sure if the installed ones resolved that problem, while the git version still seems to have that problem
<Inline>
heh
ChoHag has quit [Remote host closed the connection]
lmm014 has joined #lisp
drl has quit [Quit: Leaving]
shifty has quit [Ping timeout: 240 seconds]
shifty has joined #lisp
<Inline>
Nilby: when the exit codes are not ok maybe that's why it stalls instead of terminating cleanly
<Inline>
exit code| return code| exit status
<Nilby>
no it was wedged inside the kernel, nothing to do with exit codes
actuallybatman has joined #lisp
<jcowan>
pjb: even kill -9 does not work with a process holding a "short-term" lock such as a file. Normally that's okay, but if the open() is taking a long time (NFS especially, but also some Fuse file systems), you are SOL. Reboot.
lmm014 has quit [Ping timeout: 240 seconds]
nij has quit [Ping timeout: 276 seconds]
<Nilby>
There was no NFS, i couldn't even connect with gdb, but it's okay, since I'm going to no only use stupid unix as a bootloader for Mezzano
shifty has quit [Ping timeout: 265 seconds]
ChoHag has joined #lisp
lmm014 has joined #lisp
lmm014 has quit [Ping timeout: 268 seconds]
travv0 has quit [Ping timeout: 246 seconds]
spikhoff has quit [Ping timeout: 246 seconds]
p_l has quit [Ping timeout: 250 seconds]
jcowan has quit [Ping timeout: 260 seconds]
entel has quit [Ping timeout: 260 seconds]
chewbranca has quit [Ping timeout: 245 seconds]
brownxoat has quit [Read error: Connection reset by peer]
p_l has joined #lisp
brownxoat has joined #lisp
IIsi50MHz has quit [Ping timeout: 245 seconds]
chewbranca has joined #lisp
spikhoff has joined #lisp
IIsi50MHz has joined #lisp
entel has joined #lisp
waleee-cl has quit [Ping timeout: 250 seconds]
johnjay has joined #lisp
travv0 has joined #lisp
jcowan has joined #lisp
spikhoff has quit [Max SendQ exceeded]
waleee-cl has joined #lisp
supercoven has quit [Read error: Connection reset by peer]
mindCrime_ has quit [Ping timeout: 260 seconds]
waleee-cl has quit [Max SendQ exceeded]
jladd has quit [Ping timeout: 250 seconds]
lmm014 has joined #lisp
dbotton has quit [Ping timeout: 250 seconds]
entel has quit [Max SendQ exceeded]
spikhoff has joined #lisp
waleee-cl has joined #lisp
drmeister has quit [Ping timeout: 245 seconds]
dbotton has joined #lisp
jladd has joined #lisp
entel has joined #lisp
jlpeters has quit [Ping timeout: 250 seconds]
karlosz has joined #lisp
jladd has quit [Max SendQ exceeded]
lmm014 has quit [Ping timeout: 240 seconds]
rvirding has quit [Ping timeout: 246 seconds]
waleee-cl has quit [Max SendQ exceeded]
CEnnis91 has quit [Ping timeout: 250 seconds]
pent has quit [Ping timeout: 245 seconds]
dunk has quit [Ping timeout: 245 seconds]
grfn has quit [Ping timeout: 258 seconds]
gendl__ has quit [Ping timeout: 260 seconds]
mpontillo has quit [Ping timeout: 260 seconds]
b20n has quit [Ping timeout: 260 seconds]
alanz has quit [Ping timeout: 260 seconds]
dnm has quit [Ping timeout: 258 seconds]
dnm has joined #lisp
parisienne has quit [Ping timeout: 260 seconds]
drmeister has joined #lisp
mpontillo has joined #lisp
b20n has joined #lisp
jlpeters has joined #lisp
waleee-cl has joined #lisp
Balooga has quit [Ping timeout: 250 seconds]
billstclair has quit [Ping timeout: 258 seconds]
CEnnis91 has joined #lisp
grfn has joined #lisp
spikhoff has quit [Ping timeout: 240 seconds]
rvirding has joined #lisp
dunk has joined #lisp
parisienne has joined #lisp
alanz has joined #lisp
buoy49 has quit [Ping timeout: 250 seconds]
pent has joined #lisp
gendl__ has joined #lisp
<ebrasca>
Can we make a better Lisp? Why let don't hendle multiple values? Like (let ((a b (function args)))...
jladd has joined #lisp
spikhoff has joined #lisp
billstclair has joined #lisp
Balooga has joined #lisp
<no-defun-allowed>
Do you really need a new standard for that?
buoy49 has joined #lisp
<ebrasca>
I am sure there ara other things we can make better.
<kevingal>
Tear it all down!! Or just do (let ((a (function args)) (b a)) ...)
<gigamonkey>
ebrasca: knock yourself out. you can even build on Common Lisp. (defpackage better-lisp ...) and go to town. See if it catches on.
<kevingal>
Wait, that should be let*.
<ebrasca>
let* does mean something else.
<ebrasca>
(let* ((a 1) (b (1+ a)))...
<kevingal>
You mean, if (function args) returns multiple values?
<ebrasca>
Yes
<ebrasca>
you get a and b
<kevingal>
(multiple-value-bind (a b) (function args) ...) might do the trick?
<ebrasca>
But it leads you into nesting.
<ebrasca>
And you can have 1 function with both of the funtionality.
anticrisis has joined #lisp
CL-ASHOK has joined #lisp
<ebrasca>
What if you like (let* ((a b (funtion0 args)) (c d (function1 args)) (e (+ a b c d))) body) ?
<theothornhill>
Why not create your own multiple-value-bind* ?
<theothornhill>
If nesting is a concern, I mean
<ebrasca>
Because it complicate things. Instead of making things more easy , I am adding complexity.
<ebrasca>
Now there is let , m-v-b and my let.
<ebrasca>
Instead of 1 function making it more easy to learn.
<theothornhill>
I can agree on destructuring by itself though - would be nice to have something like the js syntax (It exists in macros, doesn't it)?
hjudt has quit [Remote host closed the connection]
<gigamonkey>
Bad news: you'd be adding complexity either way. Because there will still be old implementations that only support old-style LET. Maybe if you can come up with a backwards compatible syntax for the new LET it could catch on. But the world isn't goin to suddenly throw away all old code and old implementations even if there's a "better" new thing.
<theothornhill>
Yeah
<theothornhill>
But lots of people add their own utility libs
<gigamonkey>
Totally. And if you get benefit from them, they may even catch on with others.
<gigamonkey>
But that's very different from changing the definition of CL:LET.
<kevingal>
Suggested name for your new macro: 'bet'.
<kevingal>
(stands for better).
<ebrasca>
gigamonkey: I think my idea is compatible with old code , old let rune the same on the new let.
<gigamonkey>
I was recently reminded of this talk I gave a decade+ ago about Lisp standardization: https://soundcloud.com/zach-beane/peter-seibel-common-lisp I'd humbly suggest that anyone who wants to make a "new, better Lisp" might want to take a listen.
<theothornhill>
Absolutely. Speaking of the definition of things in lisp - I've been looking into renewing the dpans spec, and creating a new latex version of the whole spec, with all macros removed. Any ideas for how I'd convert that afterwards to something usable in say, commondoc?
hjudt has joined #lisp
<ebrasca>
Normal let binds 1 to 1 (a 1) , new let allow you to multiple bind (a b (function0 args)).
<theothornhill>
I found a wild perl-script buried in archive.org from 1996 that expands tex-macros automatically, so it suddenly is feasible
pbaille has quit [Remote host closed the connection]
<kevingal>
What's the dpans spec?
<theothornhill>
But not really sure if that gets more maintainable than creating a parser dedicated to the dpans spec...
pbaille has joined #lisp
White_Flame has quit [Ping timeout: 252 seconds]
<theothornhill>
If I'm not mistaken it is the draft for ANSI standardization of common lisp. It is needed to use that since the hyperspec is proprietary. So if we want to improve that, we have to start from scratch
<ebrasca>
My idea is to have CL with the same overall funtionality but with less duplication and easy to learn.
<gigamonkey>
theothornhill: beware of the extremely unclear copyright ownership dragons that lurk there. not saying don't do it but beware.
<gigamonkey>
theothornhill: I don't think there is any 'from scratch' as you don't have right to start from that draft and make derived works any more than you can start from the HyperSpec.
<theothornhill>
gigamonkey: Yeah, I've heard things... It seemed to me the spec itself though was "safe" to use, considering it isn't derived from the hyperspec
<theothornhill>
Hmm. So that draft is also licensed?
<kevingal>
Do I remember beach talking about a similar project the other day?
<CL-ASHOK>
But CL already has a reasonably large eco system around it, I think its too much effort to reinvent the wheel
<gigamonkey>
I mean, it's copywritten by whoever wrote it. It wasn't placed into the public domain, as far as I know.
<CL-ASHOK>
Wow, so the actual CL spec is not open source and freely available for all?
<gigamonkey>
No, it's an ANSI standard that you can buy from ANSI.
<gigamonkey>
Though don't because they seem to have lost the original postscript or whatever and what you get is like a bad photocopy.
<theothornhill>
gigamonkey: amazing
pbaille has quit [Ping timeout: 240 seconds]
<theothornhill>
So that means the project is dead already. Nice.
<gigamonkey>
Seriously, you'd actually probably enjoy that talk I linked above. It's about a lot of this.
<theothornhill>
I've already bookmarked it :)
<gigamonkey>
Including some thoughts (now ten years old, of course) about how we can, nonetheless, proceed.
<CL-ASHOK>
Thanks. I wonder if it goes into the public domain eventually? It would be an interesting copyright case if derivative works would be allowed
<theothornhill>
Well everything does at some point
<saturn2>
ebrasca: you can just make your own package to use in place of COMMON-LISP
<gigamonkey>
Well, everything older than Mickey Mouse likely does at some point.
White_Flame has joined #lisp
<theothornhill>
Hehe
<CL-ASHOK>
Its a very interesting topic, but I guess I'm going too much off topic now
<theothornhill>
Well, one thing I discovered while wasting time on this was that there are two prominent lispers that uses sjl as initials
<ebrasca>
saturn2: Thanks, I think I first like to make other things! ( I only have 1 or 2 things that I thing can be better )
<gigamonkey>
dude, get back to us when you have at least 100. (I kept a list when I was writing PCL and it was probably way longer than that.)
<theothornhill>
gigamonkey: you could make a parser for the dpans spec that generates a new HyperSpec for PCL2. (I saw you requested ideas for binary formats O:-) )
<gigamonkey>
359 items. ;-)
andreyorst[m] has quit [Remote host closed the connection]
<ebrasca>
I don't like cl21, why Regular Expression. How Running external programs is going to help OS writen in CL21?
hypercube has joined #lisp
<nij>
<nij>
ebrasca: I don't understand..
<ebrasca>
Why CL need to run other not CL programs?
<theothornhill>
nij: nice! I found this script buried deep in the nineties - perhaps it could be of use? I've experimented a little with recreating the whole spec as one file with all macros expanded, and it can be done with that script https://hg.sr.ht/~theo/clms/browse/tme.pl?rev=tip
<theothornhill>
nij: With tme.pl and texexpander the whole spec can easily be turned into a single document
xkapastel has joined #lisp
<nij>
theothornhill: Have you tried to turn that into the format of CommonDoc?!
<nij>
I'm also hoping that CLHS can be freed.
<nij>
But if gigamonkey is right, we should beware of the copyright issue of dpANS... there's a copy but I dont know. I'm a #lisp noob and a legal noob as well.
<theothornhill>
Not yet into commondoc. Only a single latex document. Was able to parse it to html using pandoc, so should be doable
<theothornhill>
nij: Yeah - I was encouraged couple of days ago, but now I'm sad
<nij>
Why sad? Cuz of the legal issue?
White_Flame has joined #lisp
<theothornhill>
Yeah. Felt like we were onto something, but now it seems a little futile. I guess it is impossible to legally copy the dpans
<nij>
We need a safe way to find out. But how? Isn't there a license with dpANS?
<theothornhill>
I didn't see one. That just means its licensed to all the authors, if I'm not mistaken. Which makes it hard, since I guess not all are easy to get hold of
<nij`>
As Pitman made CLHS, he must have known the legal issue..
<theothornhill>
lotuseater: Didn't count, but there are quite a few
<mfiano>
There was plans to place dPANS3 into the public domain, but it was never finished
<lotuseater>
ah cool
<mfiano>
Therefor it is copyrighted by all those involved
<nij`>
mfiano: how does dpANS3 differ from the one we posted? (in xach's github)
<mfiano>
They are the same
varjag has quit [Remote host closed the connection]
nij has quit [Ping timeout: 250 seconds]
<nij`>
But.. it is placed in the public domain.. no? In xach's repo.
<nij`>
s/in the/in a/
Volt_ has quit [Ping timeout: 268 seconds]
<mfiano>
Some people believe it is because of its intention to be, but with no formal notice, it cannot be.
<White_Flame>
best way to find out the legal status of something is to copy it and wait for a takedown notice
* nij`
feels like he should get a local copy asap..
<nij`>
White_Flame: Can they sue legally right away?
<White_Flame>
the thing is, it costs money to do that. _would_ somebody bother sinking money into a real lawsuit for something like the CL spec?
<White_Flame>
at best, you'd get a notice
<theothornhill>
I'm guessing no
Volt_ has joined #lisp
<mfiano>
I would guess that depends on the claimed losses
<nij`>
Or maybe someone should put a copy on some site like b-ok.org
<nij`>
I dunno if that's legal. But even if it is.. it should be hard to catch (?)
<lotuseater>
oh i like that site
<nij`>
lotuseater: gotcha! you should be put to jail :D
<White_Flame>
and xach has already copied the stuff in question
<White_Flame>
in a much more publicly findable way
<nij`>
theothornhill: with the parsed version you have, do you think it's easy to create hyperlinks?
karlosz has quit [Quit: karlosz]
<lotuseater>
no why that nij`? ^^
<nij`>
Oh haha nvm lotuseater we all know you just love it but never use it :)
<nij`>
Here's another one I love but never used :| http://libgen.rs/
<lotuseater>
ehm ..
<nij`>
It's a sin! No one should use it.
<lotuseater>
I like open knowledge
<nij`>
Hehehe
<lotuseater>
even worse is if a company thinks it can "own" mathematics
<nij`>
theothornhill: like.. how far do you think you can turn it into a CommonDoc version, with a great Master Index :D?
<theothornhill>
nij`: That's where I'm a little unclear as to what's the best way to link. Now the expander just expands all the way to be tex primitives, and it might be better to attach links to something a little less generic. Not sure
<theothornhill>
I think we can go pretty far. My first instinct was to go to markdown or something similar
<theothornhill>
I'm working now on some ways to do it reproducible. Right now there are some manual steps to get things right
aartaka has quit [Read error: Connection reset by peer]
<theothornhill>
lotuseater: yeah, could be
<nij`>
theothornhill - I think there are some special macros used that are intended to create links?
<nij`>
Or did Pitman add the links by himself in CLHS?
<lotuseater>
hm ok, pandoc helps if another format is needed
<nij`>
I'd say if we can parse it in CommonDoc then it'd be awesome.. something that has a programmatic structures.
<theothornhill>
Not sure. If so, I think I need to rewrite the perlscript to account for those cases, and yuck
Nilby has quit [Remote host closed the connection]
aartaka has joined #lisp
<theothornhill>
nij`: Yeah I agree
<nij`>
Then it will be truly freed. Weeeeee
<theothornhill>
Yeah! If legal :P
<nij`>
theothornhill: :( I guess you just have to alter a few cases.
<nij`>
We can see how xach views this? xach had a copy on github so that's a progress.
<nij`>
Maybe it's just some work undone.
<jcowan>
gigamonkey: I wish you could get the derivative rights to PCL back, so that other P-books could be written.
<theothornhill>
nij`: maybe. It's a pretty gnarly script. Doable, of course, but I'd rather do it in lisp than perl
<lotuseater>
with the power of FORMAT? :)
<theothornhill>
I love format
<nij`>
I now worry that if all macros are expanded.. then some sementic meaning goes away.
pbaille has quit [Ping timeout: 240 seconds]
<theothornhill>
nij`: Yea, it does. That's what I'm looking into right now
<lotuseater>
or replacing complex TeX macros with lisp
White_Flame has quit [Ping timeout: 260 seconds]
<lotuseater>
ok, no correlation, sry
White_Flame has joined #lisp
<nij`>
We need help from phoe and beach :-) They have thought about this before iirc.
jonatack has quit [Quit: jonatack]
jonatack has joined #lisp
jeosol has quit [Quit: Connection closed]
<dieggsy>
jcowan: what happened with the PCL rights ?
josrr has quit [Quit: rcirc on GNU Emacs 27.2]
fourier has quit [Ping timeout: 246 seconds]
<theothornhill>
nij`: I think getting some input from phoe on whats needed from the macro expander to fit in nicely with CLUS. I think I remember him speaking about the macros being hard to deal with since they are all over the place
<jcowan>
Apress has them
aartaka has quit [Ping timeout: 268 seconds]
andreyorst[m] has joined #lisp
varjag has joined #lisp
pbaille has joined #lisp
<gigamonkey>
jcowan: what do you mean by "other P-books"?
<gigamonkey>
I mean, I still own the copyright to PCL but have licensed most publication rights to Apress.
<gigamonkey>
I mean, it's not like you'd start from the text of PCL to write any of those.
<jcowan>
the first two would obviously be nnn-commercial
<gigamonkey>
There was a Practical Python that came out before PCL.
pbaille has quit [Ping timeout: 252 seconds]
<gigamonkey>
And a Practical O'Caml that came out after and got thoroughly, and publicly, roasted by the tech reviewer.
<jcowan>
I think I would for Lisps.
<dieggsy>
gigamonkey: do you have a link to this roasting
<gigamonkey>
In theory if Apress ever lets PCL go "out of print" all the rights revert back to me but I'm not sure what that means in a world of Print On Demand books.
<jcowan>
It talks about the right things in the right order, and we now have enough Scheme de facto standardized to make it usable, perhaps with some chapters missing
<jcowan>
Your contract with Apress should define "out of print"
<gigamonkey>
Yeah, well, it was written before P.O.D. was a big thing. I don't think it really does.
<gigamonkey>
like in the days when they actually paid, in advance to print copies that sat in inventory somewhere, it was out of print when they stopped printing new copies.
<jcowan>
sometimes it tries to redirect you if a POST is running very slowly, I think
amb007 has quit [Remote host closed the connection]
aartaka has joined #lisp
<jcowan>
it's reasonable to redirect a GET timeout
<jcowan>
gigamonkey: If you feel like doing a favor for the non-CL Lisp communities, you can certainly ask for the rights back even if you are not legally entitled to them.
pbaille has joined #lisp
<dieggsy>
huh, it might not be working for me because my stupid internet provider tries to handle not found on its own
<dieggsy>
it serves some "verizon - not found" page instead. that's annoying
surabax has quit [Quit: Leaving]
pbaille has quit [Ping timeout: 240 seconds]
shifty has joined #lisp
nij` has quit [Quit: ERC (IRC client for Emacs 27.1)]
amb007 has joined #lisp
<gigamonkey>
jcowan: Apress loves putting out derivitive works. I'm sure if someone wants to write a Practical Scheme they could talk to Apress about it. And if they really want to start from PCL I guess they'd have to do a deal with me. But I doubt Apress is just going to let go of the rights.
<jcowan>
The PO'C comments say that APress turned down a later proposal for Practical C
shifty has quit [Ping timeout: 240 seconds]
<gigamonkey>
Oh, found my contract "The Work shall be deemed out-of-print if it is not available for sale in reasonable quantities in normal trade channels".
<gigamonkey>
So as long as the P.O.D. folks keep doing their thing, it will never go "out of print".
akoana has joined #lisp
hjudt has quit [Ping timeout: 265 seconds]
theothornhill has quit [Ping timeout: 260 seconds]
<edgar-rft>
as long as the "demand" folks will not fail doing their job :-)
<saturn2>
gigamonkey: very interesting talk, thank you
hjudt has joined #lisp
random-nick has quit [Ping timeout: 252 seconds]
Inline has quit [Ping timeout: 260 seconds]
<jcowan>
I read the other essays at your site, and I'm extremely impressed with all of them.
<jcowan>
I also looked a little bit into the old blog and the "forgotten ~U". Scheme's format is based on combinators rather than a stringly DSL, and it supports both 2^10 and 10^3 prefix scaling.
<gigamonkey>
jcowan: thanks!
andreyorst[m] has quit [Remote host closed the connection]
jeosol has joined #lisp
slyrus_ has joined #lisp
_paul0 has quit [Quit: Leaving]
paul0 has joined #lisp
slyrus_ has quit [Ping timeout: 260 seconds]
<gigamonkey>
jcowan: link to Scheme's format that you're talking about? All the docs I can find seem to be for something lifted from CL.
<jcowan>
see the "Implementation" section for links to three implementations.
<jcowan>
Bug me or #scheme if you are readimng the code and find anything obscure.
<gigamonkey>
Yeah, I get the urge. On the other hand I actually think sometimes it's better to have the format be just a bunch of maximally concise line noise.
<jcowan>
Until six months from now.
<jcowan>
Granted, you can ram all that into your head, but once you reach the limit of what cl:format does, that's it.