buffergn0me has quit [Remote host closed the connection]
Kundry_Wag has quit [Ping timeout: 240 seconds]
buffergn0me has joined #lisp
<White_Flame>
thoughts on another stupid hack of mine: To READ multiple terms from a single string, encase the string with paren characters, and READ once into a list.
frgo has quit [Ping timeout: 244 seconds]
<White_Flame>
I think the only difference is that if there's an unclosed paren in the string, the location of the error would be different?
<noobly>
in the little schemere, there is a function as such: (define even? (lambda (n) (= (* (/ n 2) 2) n))). SO, because (* (/ n 2) 2) alwasy equals n, I've come to the conclusion that this either errata, a quirk of a specific scheme dialect. I'm using guile.. any help here?
<White_Flame>
this channel is about CL, not scheme. try #scheme. However, / might be an integer division or a divmod or something
<noobly>
White_Flame: those were my thoughts as well, and thanks I'll try #scheme.
<pillton>
noobly: Why? Just evaluate (/ 3 2) in the repl.
<pillton>
noobly: Then look up the specification for the function /.
<noobly>
pillton: good idea (duh), came out to 3/2. I wonder which scheme
<noobly>
*which scheme's wouldn't
<noobly>
and I'll try finding the specs, not quite sure how though (in emacs using guile, fwiw)
jmercouris has joined #lisp
<jmercouris>
so if I make a program with asdf:make, right, it has an entry point, how can I keep that program running without doing a while true loop?
<pillton>
jmercouris: Why do you want to keep it running?
<Bike>
what's wrong with a while true loop
mejja has quit [Quit: mejja]
<jmercouris>
Bike: will it not consume all CPU?
<jmercouris>
pillton: I want to keep the Lisp core for Next browser running
<Bike>
oh, right, you want like an event loop or whatever
<jmercouris>
Bike: so the thing is, all events come from s-xml-rpc, invoked by xml-rpc from the client program
<jmercouris>
I don't control that listening loop
<pillton>
See. Event loops don't compose.
<jmercouris>
pillton: what does that mean?
<jmercouris>
what if I used BT threads to run a loop that is sleeping 99% of the time to avoid the program closing
<sjl>
Is there some built-in function that takes a list and an element and appends that element to the list? I realize this will be slow.
<pillton>
jmercouris: I keep telling everyone that event loops don't compose.
<jmercouris>
that's kind of hacky, but it would work, right?
<sjl>
or am I stuck with (defun append1 (list el) (append list (list el)))?
<pillton>
jmercouris: You should wait for the thread which controls the event loop to terminate.
<jmercouris>
pillton: wait for the thread which controls the event loop...? how could I possibly know what thread s-xml-rpc is running on, or are you suggesting I make an event loop thread?
Kundry_Wag has joined #lisp
<LdBeth>
sjl: see nconc
noobly has quit [Quit: Page closed]
dorketch has joined #lisp
<jmercouris>
s-xml-rpc doesn't appear to start any new threads
<pillton>
jmercouris: Bah. s-xml-rpc is implemented weirdly.
dorketch has quit [Quit: WeeChat 2.1]
<jmercouris>
yes, it is a bit strange, but its what I'm using now
<jmercouris>
I may fork it
<jmercouris>
seems to open a bsd tcp socket on sbcl
<jmercouris>
interesting
<pillton>
jmercouris: Have the main thread wait on a mutex which a s-xml-rpc handler sets upon termination.
<jmercouris>
pillton: or why not just have a mutex that s-xml-rpc can set?
<jmercouris>
why have the mutex be part of s-xml-rpc?
<jmercouris>
are mutexs native to common lisp? or will I have to use a library or some bool or something?
<jmercouris>
I could also make a new thread for the main function, and then block...
Kundry_Wag has quit [Read error: Connection reset by peer]
Kundry_Wag has joined #lisp
jmercouris has quit [Remote host closed the connection]
voidlily_ has joined #lisp
<pillton>
Does your server which uses s-xml-rpc server export a quit function?
voidlily has quit [Read error: No route to host]
Kundry_Wag has quit [Read error: Connection reset by peer]
shifty has joined #lisp
jcowan has quit [Quit: Connection closed for inactivity]
ryan_vw has quit [Ping timeout: 268 seconds]
Kundry_Wag has joined #lisp
<sjl>
LdBeth: how would nconc do this?
<no-defun-allowed>
if you can chase the last cons in the list you can append to the end very quickly
elfmacs has joined #lisp
<no-defun-allowed>
eg the results of (macroexpand '(loop for n from 1 to 10 collect n)) might involve such cons chasing
<sjl>
Sure. I could also use the queue implementation I wrote a while ago... I'm looking for a portable built-in or one-liner equivalent
<sjl>
and don't care about performance
<no-defun-allowed>
(append foo (list 'baz))
<no-defun-allowed>
enjoy your O(n) though
<sjl>
which is what I pasted above, yep
<Bike>
how destructive is this?
<Bike>
i mean you can just throw nconc in there if you don't mind it
Kundry_Wag has quit [Read error: Connection reset by peer]
<sjl>
I'd prefer it to not be destructive if possible
<Bike>
i don't think you'll be able to improve on the append, then.
Kundry_Wag has joined #lisp
<sjl>
starting with a vector and v-p-e would work, but v-p-e's args are in the wrong order and CL doesn't have flip
anewuser has joined #lisp
<sjl>
well, if I had flip and could live with reversed output it could be (flip #'cons) I guess
Kundry_Wag has quit [Read error: Connection reset by peer]
Kundry_Wag has joined #lisp
Mr-Potter has quit [Ping timeout: 245 seconds]
clintm has joined #lisp
<sobol>
g
makomo has quit [Ping timeout: 268 seconds]
wusticality has joined #lisp
<LdBeth>
sjl: nconc does the same as append except destructively
<sjl>
exactly. if append doesn't solve the problem, nconc will only not solve the problem faster and more dangerously
AroPar has joined #lisp
AroPar has quit [Remote host closed the connection]
wusticality has quit [Ping timeout: 245 seconds]
stacksmith has quit [Read error: Connection reset by peer]
igemnace has joined #lisp
warweasle has quit [Quit: rcirc on GNU Emacs 24.4.1]
rumbler31 has joined #lisp
lmy9900 has joined #lisp
rumbler31 has quit [Ping timeout: 268 seconds]
Kundry_Wag has quit [Remote host closed the connection]
lmy9900_ has joined #lisp
Kundry_Wag has joined #lisp
pierpal has quit [Ping timeout: 250 seconds]
lmy9900 has quit [Ping timeout: 240 seconds]
rumbler31 has joined #lisp
Kundry_Wag has quit [Ping timeout: 244 seconds]
sunshavi has quit [Ping timeout: 245 seconds]
lmy9900_ has quit [Ping timeout: 244 seconds]
arescorpio has joined #lisp
lavaflow has joined #lisp
jcowan has joined #lisp
clintm has quit [Remote host closed the connection]
nirved has quit [Ping timeout: 276 seconds]
cmjones has joined #lisp
dale has quit [Quit: dale]
lmy9900_ has joined #lisp
lmy990___ has joined #lisp
lmy9900_ has quit [Ping timeout: 245 seconds]
lmy9900 has joined #lisp
lmy9900_ has joined #lisp
lmy990___ has quit [Ping timeout: 245 seconds]
lmy9900__ has joined #lisp
lmy9900 has quit [Ping timeout: 252 seconds]
lmy9900 has joined #lisp
lmy9900_ has quit [Ping timeout: 252 seconds]
lmy9900__ has quit [Ping timeout: 244 seconds]
lmy9900_ has joined #lisp
lmy9900__ has joined #lisp
warweasle has joined #lisp
lmy9900 has quit [Ping timeout: 244 seconds]
beach has joined #lisp
lmy9900 has joined #lisp
lmy9900_ has quit [Ping timeout: 268 seconds]
lmy9900_ has joined #lisp
lmy990___ has joined #lisp
lmy9900__ has quit [Ping timeout: 252 seconds]
X-Scale has quit [Ping timeout: 244 seconds]
frgo has joined #lisp
lmy9900__ has joined #lisp
lmy99____ has joined #lisp
lmy9900 has quit [Ping timeout: 268 seconds]
dddddd has quit [Remote host closed the connection]
lmy9900_ has quit [Ping timeout: 252 seconds]
lmy990___ has quit [Ping timeout: 245 seconds]
frgo has quit [Ping timeout: 244 seconds]
lmy9900__ has quit [Ping timeout: 240 seconds]
equwal has joined #lisp
arescorpio has quit [Read error: No route to host]
lmy9900 has joined #lisp
robotoad has quit [Quit: robotoad]
ryan_vw has joined #lisp
lmy99____ has quit [Ping timeout: 245 seconds]
lmy9900_ has joined #lisp
lmy9900__ has joined #lisp
lmy9900 has quit [Ping timeout: 246 seconds]
lmy9900 has joined #lisp
lmy990___ has joined #lisp
lmy9900_ has quit [Ping timeout: 245 seconds]
dorketch has joined #lisp
lmy9900__ has quit [Ping timeout: 245 seconds]
Zaab1t has joined #lisp
lmy9900__ has joined #lisp
lmy9900 has quit [Ping timeout: 240 seconds]
lmy990___ has quit [Ping timeout: 240 seconds]
lmy9900 has joined #lisp
mathrick has joined #lisp
lmy9900__ has quit [Ping timeout: 245 seconds]
X-Scale has joined #lisp
lmy9900 has quit [Ping timeout: 244 seconds]
lmy9900__ has joined #lisp
equwal has left #lisp ["ERC (IRC client for Emacs 25.3.1)"]
robotoad has joined #lisp
themsay has quit [Ping timeout: 268 seconds]
lmy9900 has joined #lisp
lmy9900_ has joined #lisp
lmy9900__ has quit [Ping timeout: 240 seconds]
lmy9900 has quit [Ping timeout: 244 seconds]
xkapastel has quit [Quit: Connection closed for inactivity]
Necktwi has quit [Quit: leaving]
lmy9900__ has joined #lisp
warweasle has quit [Quit: rcirc on GNU Emacs 24.4.1]
lmy990___ has joined #lisp
lmy9900_ has quit [Ping timeout: 268 seconds]
lmy9900 has joined #lisp
lmy9900__ has quit [Ping timeout: 268 seconds]
lmy9900__ has joined #lisp
lmy990___ has quit [Ping timeout: 245 seconds]
lmy9900 has quit [Ping timeout: 244 seconds]
lmy9900 has joined #lisp
lmy9900__ has quit [Ping timeout: 250 seconds]
lmy9900__ has joined #lisp
milanj has quit [Quit: This computer has gone to sleep]
lmy9900 has quit [Ping timeout: 245 seconds]
lmy9900 has joined #lisp
lmy9900_ has joined #lisp
lmy9900__ has quit [Ping timeout: 245 seconds]
SaganMan has joined #lisp
lmy99____ has joined #lisp
lmy9900 has quit [Ping timeout: 246 seconds]
lmy9900_ has quit [Ping timeout: 252 seconds]
lmy9900 has joined #lisp
lmy9900_ has joined #lisp
lmy9900__ has joined #lisp
lmy99____ has quit [Ping timeout: 246 seconds]
lmy9900 has quit [Ping timeout: 240 seconds]
lmy9900_ has quit [Ping timeout: 245 seconds]
lmy9900__ has quit [Ping timeout: 240 seconds]
lmy9900 has joined #lisp
<beach>
Good morning everyone!
d4ryus has quit [Ping timeout: 276 seconds]
<beach>
What is your intended use for CL-R? It is hard to give advice unless the purpose is clear. Like, why would you want to give up reflection?
<beach>
jcowan: ↑
lmy9900__ has joined #lisp
lmy990___ has joined #lisp
Necktwi has joined #lisp
lmy9900 has quit [Ping timeout: 252 seconds]
lmy9900 has joined #lisp
<beach>
jcowan: Another way of asking the same question, I guess: What problem with full Common Lisp is CL-R meant to solve?
<pfdietz>
Perhaps it's intended for more minimal, static compiled apps? Sort of a scheme-like CL?
<pfdietz>
Just guessing.
lmy9900_ has joined #lisp
<beach>
Maybe so.
lmy9900__ has quit [Ping timeout: 272 seconds]
Bike has quit [Quit: Lost terminal]
<beach>
I am not saying there is anything wrong with wanting such a thing. I am just curious about the goal.
lmy9900__ has joined #lisp
d4ryus has joined #lisp
lmy990___ has quit [Ping timeout: 252 seconds]
lmy9900 has quit [Ping timeout: 244 seconds]
jochens has joined #lisp
lmy9900_ has quit [Ping timeout: 252 seconds]
jochens has quit [Ping timeout: 252 seconds]
lmy9900_ has joined #lisp
lmy990___ has joined #lisp
anewuser has quit [Read error: Connection reset by peer]
lmy9900__ has quit [Ping timeout: 268 seconds]
lmy9_____ has joined #lisp
lmy9900_ has quit [Ping timeout: 240 seconds]
lmy9900 has joined #lisp
lmy990___ has quit [Ping timeout: 264 seconds]
dale has joined #lisp
<SaganMan>
Morning beach
<jcowan>
That is indeed what I have in mind, inspired by CLiCC and ISLisp
lmy9900_ has joined #lisp
<beach>
jcowan: So the problem is the size of the applications?
anewuser has joined #lisp
<jcowan>
I don't have in mind to actually write such a compiler, just lay down the work for what such a compiler might reasonably accept
lmy9_____ has quit [Ping timeout: 268 seconds]
<jcowan>
The hope would be to be able to get good performance from a more naive compiler than SBCL or SICL.
<beach>
So the problem is speed rather than size?
<jcowan>
(Do people pronounce SBCL to rhyme with SICL?)
Kundry_Wag has joined #lisp
lmy9900__ has joined #lisp
<jcowan>
Both, I'd say
* sjl
does not
<beach>
And for the size part, are you thinking of a small number of applications for an operating system like UNIX?
lmy9900 has quit [Ping timeout: 244 seconds]
lmy990___ has joined #lisp
<beach>
I am asking this, because if you give up either one, there are simpler ways of obtaining what you want.
<sjl>
I pronounce it ESS BEE-see ELL
<jcowan>
"The Lisp community must listen to the marketplace, which has shouted small, small, small and efficient, efficient, efficient for two decades [as of 1992]" (Henry Baker)
<jcowan>
His proposals are far more radical than anything I have in mind, and indeed in some ways more radical than Scheme or Racket
lmy9900_ has quit [Ping timeout: 246 seconds]
elfmacs has quit [Ping timeout: 252 seconds]
<beach>
jcowan: I am asking because, if think you might have a large number of applications, you can put most of the code in a shared library, so each application would be small.
<jcowan>
I was actually thinking about embedded processors and other highly constrained environments
<beach>
OK, now we are getting somewhere.
<jcowan>
ECL is the nearest approach so far
<beach>
Are you sure that's what Baker was referring to?
Kundry_Wag has quit [Ping timeout: 244 seconds]
lmy9900__ has quit [Ping timeout: 244 seconds]
<jcowan>
By 2018 standards, essentially all 1992 computers, to say nothing of 1972, were highly constrained environments.
lmy9900 has joined #lisp
<pillton>
Where is the quote from?
<jcowan>
With whole-program compilation, tree shaking is trivial: omit anything not in the call graph
<jcowan>
"A Critique of DIN Kernel Lisp", an early approach to ISLisp/EULisp
dorketch has joined #lisp
<LdBeth>
Will they call NodeJS small
<LdBeth>
Will they call NodeJS small
<LdBeth>
Will they call NodeJS small
lmy990___ has quit [Ping timeout: 264 seconds]
lmy9900__ has joined #lisp
jinkies has quit [Ping timeout: 272 seconds]
<jcowan>
Not when someone's library has the complete works of Shakespeare embedded in it. (Sorry, can't find the reference offhand.)
<beach>
jcowan: I strongly suspect you would have to give up a lot more than reflection.
<jcowan>
You can constrain according to your budget
<beach>
Not that simple.
lmy990___ has joined #lisp
<jcowan>
Reflection is just one idea
<beach>
Oh, I thought that was essential because of the -R thing.
lmy9900 has quit [Ping timeout: 272 seconds]
<beach>
For example, in order for CLOS to be efficient, you need the compiler at run time. So you probably need to give up CLOS as well in order to get both small size and good performance.
<beach>
And then the language is so far removed form Common Lisp that the CL part of the name is probably no longer justified.
<jcowan>
Why do you need the compiler at run time if you only have a fixed number of immutable classes, all known at compile time?
lmy9900 has joined #lisp
lmy9900__ has quit [Ping timeout: 268 seconds]
<beach>
Fair enough. With that restriction you may have a possibility.
<jcowan>
I'm also using the Google style guide as a, well, guide.
nanoz has joined #lisp
frgo has joined #lisp
lmy990___ has quit [Ping timeout: 252 seconds]
dorketch has quit [Quit: WeeChat 2.1]
<jcowan>
I also plan to flush everything deprecated.
* pillton
likes remove-if-not.
<aeth>
jcowan: The style guide is far from perfect.
<aeth>
jcowan: For instance, I've come to the exact opposite conclusion about "Using (declare (type ...)) is the least-desirable mechanism to use"
<jcowan>
Sure. Ditto with my other sources
frgo has quit [Ping timeout: 252 seconds]
<aeth>
jcowan: I've actually put a substantial amount of work into making macros that handle both declare and check-type at the same time to silence the critics because declare is simply too useful not to use in implementations that handle it reasonably.
<jcowan>
Am I right to think that (eval-when (:compile-toplevel) ...) has the effect of making any defuns it wraps available at compile time only? That would be the Right Thing for procedures at (Scheme) phase 1; that is, used only in the implementation of macros.
<jcowan>
Fare's page does not discuss this case.
<aeth>
I have never seen that before.
<aeth>
Macro-implementation functions tend to be available all of the time, possibly for easier debugging/testing, and they often are in a separate file to avoid a giant 300-line eval-when
pierpal has joined #lisp
lmy9900__ has joined #lisp
lmy9900 has quit [Ping timeout: 245 seconds]
Zaab1t has quit [Quit: bye bye friends]
lmy9900 has joined #lisp
lmy9900__ has quit [Ping timeout: 252 seconds]
<pillton>
jcowan: I don't understand why you would do it this way. Why don't you implement a CL compiler which isn't restricted to fast LOADing?
lmy9900_ has joined #lisp
lmy9900 has quit [Ping timeout: 245 seconds]
<jcowan>
Well, it doesn't seem to work anyhow. When I load this file into SBCL:
<jcowan>
and call (kons 1 2), I get told that qons is not defined.
lmy9900 has joined #lisp
<jcowan>
However, if I put (print (kons 1 2)) into the file, it does print 3.
<jcowan>
pillton: There are already plenty of full-CL compilers.
lmy9900_ has quit [Ping timeout: 244 seconds]
<jcowan>
The idea is that because CL-R is supposed to have full access to CL at compile time, you can write compile-time-only functions (for use in macros) that invoke features not part of CL-R.
<jcowan>
CL-R functions would be implemented in CL-R (or C or whatever) and then just compiled with the user's program.
anewuser has quit [Ping timeout: 244 seconds]
<pillton>
jcowan: They all have the load requirement though. i.e. Function bindings aren't immutable, class bindings aren't immutable, classes aren't immutable and so on.
<jcowan>
Right. In CL-R everything is immutable that possibly could be.
<jcowan>
(not variables, though)
<jcowan>
anyway, off to bed with me
ryan_vw has quit [Ping timeout: 245 seconds]
nanoz has quit [Ping timeout: 252 seconds]
lmy9900 has quit [Ping timeout: 252 seconds]
lmy9900 has joined #lisp
elderK has quit [Ping timeout: 268 seconds]
wusticality has joined #lisp
lmy9900__ has joined #lisp
lmy9900 has quit [Ping timeout: 252 seconds]
lmy9900 has joined #lisp
lmy9900_ has joined #lisp
wusticality has quit [Remote host closed the connection]
lmy9900__ has quit [Ping timeout: 245 seconds]
wusticality has joined #lisp
lmy9900 has quit [Ping timeout: 268 seconds]
sauvin has joined #lisp
lmy9900_ has quit [Ping timeout: 245 seconds]
lmy9900 has joined #lisp
lmy9900_ has joined #lisp
permagreen has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
rumbler31 has quit [Remote host closed the connection]
lmy990___ has joined #lisp
lmy9900 has quit [Ping timeout: 240 seconds]
shka_ has joined #lisp
SaganMan has quit [Ping timeout: 268 seconds]
lmy9900_ has quit [Ping timeout: 272 seconds]
wusticality has quit [Remote host closed the connection]
wusticality has joined #lisp
lmy9900 has joined #lisp
Kundry_Wag has quit [Ping timeout: 252 seconds]
vlatkoB has joined #lisp
NoNumber has joined #lisp
lmy9900_ has joined #lisp
lmy990___ has quit [Ping timeout: 268 seconds]
lmy9900__ has joined #lisp
lmy9900 has quit [Ping timeout: 246 seconds]
lmy9900 has joined #lisp
lmy9900_ has quit [Ping timeout: 252 seconds]
lmy9900_ has joined #lisp
lmy9900__ has quit [Ping timeout: 268 seconds]
lmy9900 has quit [Ping timeout: 245 seconds]
lmy9900 has joined #lisp
lmy990___ has joined #lisp
lmy9900_ has quit [Ping timeout: 272 seconds]
elderK has joined #lisp
lmy9900 has quit [Ping timeout: 272 seconds]
lmy99____ has joined #lisp
<elderK>
Moin all
lmy990___ has quit [Ping timeout: 272 seconds]
lmy9900 has joined #lisp
ryan_vw has joined #lisp
lmy9900_ has joined #lisp
lmy99____ has quit [Ping timeout: 240 seconds]
lmy990___ has joined #lisp
lmy99____ has joined #lisp
lmy9900 has quit [Ping timeout: 252 seconds]
Kundry_Wag has joined #lisp
lmy9900_ has quit [Ping timeout: 272 seconds]
pierpal has quit [Read error: Connection reset by peer]
pierpal has joined #lisp
lmy9900_ has joined #lisp
lmy990___ has quit [Ping timeout: 240 seconds]
lmy9900__ has joined #lisp
lmy99____ has quit [Ping timeout: 272 seconds]
Kundry_Wag has quit [Ping timeout: 246 seconds]
lmy990___ has joined #lisp
lmy9900_ has quit [Ping timeout: 246 seconds]
lmy9900_ has joined #lisp
<beach>
Hello elderK.
lmy9900__ has quit [Ping timeout: 246 seconds]
lmy990___ has quit [Ping timeout: 240 seconds]
lmy9900__ has joined #lisp
wigust has quit [Ping timeout: 240 seconds]
lmy990___ has joined #lisp
ryan_vw has quit [Ping timeout: 240 seconds]
lmy9900_ has quit [Ping timeout: 272 seconds]
lmy9900__ has quit [Ping timeout: 244 seconds]
orivej has quit [Ping timeout: 268 seconds]
lmy9900_ has joined #lisp
Inline has quit [Quit: Leaving]
lmy990___ has quit [Ping timeout: 250 seconds]
lmy9900 has joined #lisp
frgo has joined #lisp
dale has quit [Quit: dale]
lmy9900_ has quit [Ping timeout: 245 seconds]
lmy9900_ has joined #lisp
frgo has quit [Ping timeout: 240 seconds]
lmy9900 has quit [Ping timeout: 246 seconds]
lmy9900 has joined #lisp
antonv has quit [Ping timeout: 272 seconds]
gravicappa has joined #lisp
lmy9900__ has joined #lisp
frgo has joined #lisp
frodef has joined #lisp
lmy9900_ has quit [Ping timeout: 272 seconds]
lmy9900_ has joined #lisp
lmy990___ has joined #lisp
lmy9900 has quit [Ping timeout: 246 seconds]
<elderK>
beach: How's it going? :)
<elderK>
I'm still working on understanding nested quasiquotes and things :)
lmy9900 has joined #lisp
<elderK>
Slowly making progress. So much time thinking about it all, I'm dreaming about it.
<elderK>
I was doing backquote expansion in my dreams last night, coming to terms with ``(,,a) kind of thing.
<beach>
I am fine, thank you. Good luck with your nested backquotes.
<elderK>
Shorthand for that in my mind is now `(,b) to the next level. where b is a's value.
lmy9900__ has quit [Ping timeout: 240 seconds]
<elderK>
Good to hear :)
frgo has quit [Ping timeout: 272 seconds]
Kundry_Wag has joined #lisp
lmy9900_ has quit [Ping timeout: 268 seconds]
lmy990___ has quit [Ping timeout: 240 seconds]
lmy9900_ has joined #lisp
lmy9900__ has joined #lisp
lmy9900 has quit [Ping timeout: 240 seconds]
Kundry_Wag has quit [Ping timeout: 272 seconds]
wusticality has quit [Ping timeout: 244 seconds]
lmy9900 has joined #lisp
lmy9900_ has quit [Ping timeout: 268 seconds]
lmy9900__ has quit [Ping timeout: 245 seconds]
lmy9900_ has joined #lisp
lmy9900 has quit [Ping timeout: 250 seconds]
lmy9900 has joined #lisp
lmy9900__ has joined #lisp
lmy990___ has joined #lisp
lmy99____ has joined #lisp
lmy9900_ has quit [Ping timeout: 245 seconds]
lmy9900_ has joined #lisp
lmy9900 has quit [Ping timeout: 252 seconds]
lmy9900__ has quit [Ping timeout: 252 seconds]
lmy9900 has joined #lisp
lmy990___ has quit [Ping timeout: 240 seconds]
lmy9900 has quit [Client Quit]
lmy9900 has joined #lisp
lmy99____ has quit [Ping timeout: 268 seconds]
lmy9900_ has quit [Ping timeout: 252 seconds]
lmy9900_ has joined #lisp
equwal has joined #lisp
lmy9900 has quit [Ping timeout: 268 seconds]
shka_ has quit [Ping timeout: 244 seconds]
lmy9900_ has quit [Ping timeout: 244 seconds]
xkapastel has joined #lisp
milanj has joined #lisp
lmy9900 has joined #lisp
JohnMS_WORK has joined #lisp
lmy9900_ has joined #lisp
lmy9900 has quit [Ping timeout: 246 seconds]
lmy9900 has joined #lisp
lmy9900_ has quit [Ping timeout: 246 seconds]
lmy9900__ has joined #lisp
lmy990___ has joined #lisp
lmy9900 has quit [Ping timeout: 252 seconds]
lmy99____ has joined #lisp
lmy9900 has joined #lisp
lmy9900__ has quit [Ping timeout: 268 seconds]
lmy9900_ has joined #lisp
lmy990___ has quit [Ping timeout: 268 seconds]
scymtym has quit [Ping timeout: 268 seconds]
lmy99____ has quit [Ping timeout: 264 seconds]
lmy9900 has quit [Ping timeout: 240 seconds]
lmy9900 has joined #lisp
lmy9900_ has quit [Ping timeout: 264 seconds]
housel has quit [Read error: Connection reset by peer]
lmy9900_ has joined #lisp
equwal has quit [Ping timeout: 246 seconds]
lmy9900 has quit [Ping timeout: 250 seconds]
lmy9900__ has joined #lisp
<no-defun-allowed>
what packages are there for making ASCII-art cons trees? i remember seeing one in a book
<LdBeth>
#'no-defun-allowed: and there's one output to CLX also in there, althought only works on CMUCL
lmy9900 has joined #lisp
lmy9900_ has quit [Ping timeout: 244 seconds]
lmy990___ has joined #lisp
lmy9900__ has quit [Ping timeout: 252 seconds]
chens has quit [Ping timeout: 272 seconds]
lmy9900 has quit [Ping timeout: 268 seconds]
lmy9900 has joined #lisp
scymtym has joined #lisp
elfmacs has joined #lisp
lmy9900_ has joined #lisp
chens has joined #lisp
lmy9900__ has joined #lisp
lmy99____ has joined #lisp
lmy990___ has quit [Ping timeout: 268 seconds]
lmy9900 has quit [Ping timeout: 252 seconds]
lmy990___ has joined #lisp
lmy9900 has joined #lisp
lmy9900_ has quit [Ping timeout: 252 seconds]
jdz has quit [Read error: Connection reset by peer]
SaganMan has joined #lisp
lmy9900__ has quit [Ping timeout: 252 seconds]
lmy99____ has quit [Ping timeout: 252 seconds]
lmy9900__ has joined #lisp
lmy990___ has quit [Ping timeout: 252 seconds]
lmy990___ has joined #lisp
lmy9900 has quit [Ping timeout: 245 seconds]
lmy9900_ has joined #lisp
lmy9900__ has quit [Ping timeout: 245 seconds]
lmy99____ has joined #lisp
lmy990___ has quit [Ping timeout: 245 seconds]
nirved has joined #lisp
lmy990___ has joined #lisp
lmy9900_ has quit [Ping timeout: 252 seconds]
lmy9900 has joined #lisp
lmy99____ has quit [Ping timeout: 245 seconds]
lmy9900_ has joined #lisp
yvy has joined #lisp
lmy990___ has quit [Ping timeout: 246 seconds]
NoNumber has quit [Remote host closed the connection]
lmy9900 has quit [Ping timeout: 260 seconds]
SaganMan has quit [Ping timeout: 252 seconds]
lmy9900 has joined #lisp
jochens has joined #lisp
nowhere_man has joined #lisp
lmy9900_ has quit [Ping timeout: 260 seconds]
lmy990___ has joined #lisp
jdz has joined #lisp
lmy9900 has quit [Ping timeout: 240 seconds]
<jackdaniel>
jcowan: as of ECL, feel free to ask questions on #ecl channel, I'll try to answer what I can
lmy990___ has quit [Ping timeout: 240 seconds]
nowhere_man has quit [Ping timeout: 268 seconds]
<jackdaniel>
what may be interesting to you is that I plan to slowly convert ecl_min (which is an ad hoc lisp implementation for bootstrapping working inside ECL's CLR) to be a conforming EuLisp Level 0
<jcowan>
Ooh
<ecraven>
jackdaniel: wow, that sounds interesting!
<jackdaniel>
sure, but I'm suffering from a constant lack of time, this project is high on my priority list, but this list isn't short anyway
<jackdaniel>
so I can't promise any estimates (or, in fact, realization of that)
<jackdaniel>
(bb in ~2h)
nowhere_man has joined #lisp
rozenglass has quit [Remote host closed the connection]
lmy9900 has joined #lisp
<ogamita>
jackdaniel: isn't ecl_min a subset of CL?
<ogamita>
jackdaniel: I don't think EuLisp Level 0 is a subset of CL. IIRC, EuLisp is lisp-1.
SaganMan has joined #lisp
<jackdaniel>
it isn't CL subset (but it is indeed a lisp-2 right now)
<jackdaniel>
(unless you call anything with evaluator and lists a CL subset)
lmy9900__ has joined #lisp
<jackdaniel>
as of lisp-1 / lisp-2 here, it is strictly interpreted, so modifying evaluator here won't be a big problem
<jackdaniel>
two times "here", meh
lmy990___ has joined #lisp
lmy9900 has quit [Ping timeout: 268 seconds]
lmy99____ has joined #lisp
Bike has joined #lisp
lmy9900__ has quit [Ping timeout: 250 seconds]
lmy990___ has quit [Ping timeout: 244 seconds]
orivej has joined #lisp
hhdave has joined #lisp
lmy9900 has joined #lisp
<ogamita>
jackdaniel: if you can make a defpackage and load and run those programs in that package, then it's a subset of CL.
lmy9900__ has joined #lisp
<jackdaniel>
defpackage is not available in ecl_min until you load bunch of lsp files
lmy99____ has quit [Ping timeout: 244 seconds]
hhdave_ has joined #lisp
<ogamita>
jackdaniel: I mean, you defpackage in CL to define the subset language, exporting only what's in it.
hhdave has quit [Ping timeout: 245 seconds]
hhdave_ is now known as hhdave
edgar-rft has quit [Quit: Leaving]
<ogamita>
For example, if your bootstrap language doesn't have hash-tables, you can export everything but hash-table stuff (and but defpackage if it doesn't have it).
lmy9900 has quit [Ping timeout: 272 seconds]
lmy990___ has joined #lisp
<jackdaniel>
I don't quite follow, but if possibility to bootstrap CL from the base language (given sources in some form) is enough to make that language CL subset then fine, it is CL subset by such definition
<ogamita>
There are a few things that would require more work, as if it uses modular arithmetic. Then it may be a superset of a subset of CL: you would have to implement modular arithmetic in CL to run those programs as intended.
<jackdaniel>
otoh in this sense though C is also a subset of CL
<ogamita>
Nope.
<ogamita>
It's not the possibility to bootstrap CL, but the possibility to run on CL that makes it a subset language.
<jackdaniel>
well, I'm fine with any label you come with for ecl_min (I don't really care, if it is CL subset - even better)
<ogamita>
Only, not using all the CL features.
<ogamita>
The thing is that it would be better if it was CL, second best if it is a subset. Then you can use any CL implementation to bootstrap ecl!
lmy9900_ has joined #lisp
<jackdaniel>
many functions available in ecl_min are not available in Common Lisp
lmy9900__ has quit [Ping timeout: 272 seconds]
<jackdaniel>
only part of sources is compiled with CL, rest is part of libecl core runtime (implemented in C)
lmy99____ has joined #lisp
<jackdaniel>
so compiling ECL with another Common Lisp is not possible (unless you reimplement ECL's core runtime in Common Lisp)
<ogamita>
of course.
lmy9900__ has joined #lisp
<ogamita>
Wouldn't going toward this direction be better than toward EuLisp? Isn't it essentially dead?
lmy990___ has quit [Ping timeout: 245 seconds]
<jackdaniel>
going toward eulisp level 0 is for clear semantics of the bootstrap environment
<jackdaniel>
it is a minimal language with a good specification (in contrast to CL as a maximal language with a good specification)
<ogamita>
Do you mean eg. with respect to the interface with the underlying posix system?
lmy9900_ has quit [Ping timeout: 240 seconds]
<ogamita>
It's true that CL has a lot of implementation dependent elements there.
lmy9900 has joined #lisp
lmy99____ has quit [Ping timeout: 240 seconds]
<jackdaniel>
I mean with respect to doability to provide standarized language for bootstrap environment
<jackdaniel>
CLR implementation won't change with this regard
lmy9900_ has joined #lisp
<jackdaniel>
(safe and standarized, ecl_min at the beginning is very unsafe without any condition system for instance)
jetchisel has joined #lisp
lmy9900__ has quit [Ping timeout: 268 seconds]
<jackdaniel>
(by strictly interpreted I mean: it is minimally compiled to bytecodes and bytecodes are interpreted, not cons structures)
lmy9900 has quit [Ping timeout: 252 seconds]
lmy9900_ has quit [Ping timeout: 252 seconds]
<jackdaniel>
but before I even start to work on that higher on the stack are: green threads and delimited continuations (I have a working prototype locally), compiler refactor for different backends and fast gf dispatch
lmy9900_ has joined #lisp
<elderK>
makomo: I think I finally understand! At least, I was able to write my own once-only!
<elderK>
makomo: Slowly developing "mental analogues" for what I See.
<elderK>
:P I wound up clicking by working backwards.
<makomo>
elderK: great! :-)
<elderK>
I wrote the usual pattern that we use gensyms with. Then I thought, right, how do I generate that?
<elderK>
so, I got that part working.
<elderK>
Then there's the business of remapping a or whatever to the gensym, so when the body says ,a it's really referring to the gensymed stuff.
<elderK>
Once I wrote the expected expansion in a normal macro, I then worked backwards from that to try and replicate it.
yvy has quit [Read error: Connection reset by peer]
<makomo>
yup, that is a very good approach to developing macros imo -- you see a pattern (i.e. start from an example) and try to abstract it
<elderK>
makomo: So, I have learned for instance that ``(,,a) -> `(,b). I.e. we have two ,,s so we're going to patch something in. But we only replace the ,a, not the entire ,,a
<elderK>
Little things like that.
<elderK>
I was confused by seeing ,,@(....). But I figured out that it makes sense: Whatever is spliced in, the , kind of distributes.
<dim>
hi
lmy9900 has joined #lisp
<makomo>
elderK: exactly! :D
<elderK>
Then I learned that ,`(.....) is basically a nop. It just means "Carry the thing after the , into the expansion, verbatim."
<dim>
I have once again a bug report containing: There is no applicable method for the generic function #<STANDARD-GENERIC-FUNCTION PGLOADER.CATALOG:FORMAT-TABLE-NAME (1)> when called with arguments (NIL).
<elderK>
So for ,`(,b) well, the next level just has the (,b). When that's expanded, the value of b will be chunked in, etc.
<elderK>
:D
<makomo>
elderK: yup! great job :-)
<elderK>
makomo: I wound up doing some "silly things" like color-coding parts of the macro, to highlight "when things actually do shit"
<dim>
I'm fed up of having those function calls with a NIL argument where it should be an instance of something, usually that's because I'm using find or the like and it didn't raise any result
<elderK>
Mentally, it's still a little fuzzy. But it felt like jumping between realities :P lol
<elderK>
"You're in this level of the expansion." "Now we've gone up, in this level."
<dim>
is there in CL an approach like the Maybe option type that would help systematically address the NIL propagation>?
<elderK>
And thinking about what happens when.
<makomo>
elderK: yeah, ONCE-ONLY is *always* mentally fuzzy :D
<elderK>
makomo: I'm not sure if I've "succeeded yet." But, I can write my own once-only now.
<elderK>
From first-principles and a bit of time and tinkering :P
lmy9900_ has quit [Ping timeout: 268 seconds]
lmy9900__ has joined #lisp
<elderK>
:P Or it could just be that I've memorized PCL's version. I guess I'll try again in a week or so and see if I realy CAN do it from basics without referring to PCL :D
<jackdaniel>
dim: what is "Maybe" option?
<elderK>
jackdaniel: Maybe option is like std::optional<...> in C++
<elderK>
It's not returning null. It's basically returning a value wrapper. You can get the result from that, or say : Oh, it's null.
<elderK>
:P
<jackdaniel>
elderK: this doesn't tell me much (I knew some C++, but it could be before this option was introduced)
<elderK>
The value wrapper is never null. But what it stores, might be
<elderK>
Okay, well, imagine you have a wrapper. This wrapper can store a value of whatever. BUt it also has a flag that says whether it stores something ATM.
<elderK>
So, instead of returning null, you return an instance of this wrapper. And you can ask it: Hey, do you have a value?
<elderK>
And extract the value from it.
<elderK>
It's useful in situations where "null" is not a good error return value, because it would be a valid result, say.
lmy990___ has joined #lisp
<jackdaniel>
so how would this be different from specializing on null (in case of a method)?
<jackdaniel>
uhm
lmy9900 has quit [Ping timeout: 268 seconds]
<elderK>
jackdaniel: I can't really answer that :)
<elderK>
I don't often use them.
<elderK>
One benefit, at least in C++, is that it also adds a sense of assurance. Let's say you return some NULL and use it without checking. Well, you're going to crash MAYBE at some point. Depending on waht happens.
<elderK>
Where as having to indirect through the optional will throw an error right away.
<elderK>
Not sure if that helps :)
lmy9900 has joined #lisp
lmy9900__ has quit [Ping timeout: 245 seconds]
<dim>
jackdaniel: it's basically a way to say that if you receive NIL as an argument, just return NIL already
<dim>
in PostgreSQL you can also create function x(...) returns ... return null on null input ... ; which does the same thing, conceptually
<jackdaniel>
dim: how about specializing it (defmetho foo ((x null)) nil) ;?
<jackdaniel>
another approach would be using filtered-functions which add preprocessing step to generic functions
<dim>
well because I would have to do that for a lot of generic functions, and then I have to check that every call point knows how to handle NILs too, etc etc
<dim>
anyway, there's no silver bullet here I guess
lmy990___ has quit [Ping timeout: 250 seconds]
lmy9900_ has joined #lisp
fikka has quit [Ping timeout: 272 seconds]
<jackdaniel>
yes, this maybe operator looks like a common lisp type which is not a class, and you can't specialize on such types
lmy9900__ has joined #lisp
<jackdaniel>
dim: closest thing to handle such thing would be using filtered-functions, but I'm not sure if it buys you anything
<Bike>
conceptually it would be a class; the Maybe's equivalent to "nil" is a distinguished value not used for anything else, unlike nil
<Bike>
then haskell can use static typing information to avoid actually allocating anything when a function returns a Maybe.
<jackdaniel>
i.e you have a base class foo and two subclasses null-foo and sql-foo and if filtered function encounters nil it calls it with a null-foo instance
lmy9900_ has quit [Ping timeout: 240 seconds]
<jackdaniel>
(that way your method specialized on foo would handle proper data and null data when nil is passed there)
<jcowan>
I've just written implementations of Maybe and Either in Scheme, but not posted them yet: they would be easy to translate into CL
lmy990___ has joined #lisp
<jcowan>
jackdaniel: I'm trying to follow the ECL manual's instructions for building an executable. I get as far as calling c:build-program, but that symbol does not exist.
<scymtym>
but does Maybe automatically make all functions return Nothing when they receive Nothing as an argument? i thought that required Monad lifting or something like that
<jackdaniel>
Bike: I think that the gist of the problem comes from the fact, that NIL sneaks to the gf call, am I right dim?
lmy9900__ has quit [Ping timeout: 252 seconds]
<Bike>
scymtym: maybe itself is just an adt, it is indeed the monad operators that do that
<jackdaniel>
jcowan: did you (require 'cmp) ? also I don't think build-program is exported, you may have better luck with c::build-program
<jcowan>
Ah.
<scymtym>
Bike: yeah, that's what i thought. thanks
lmy9900__ has joined #lisp
shrdlu68 has joined #lisp
<jcowan>
forgot to require cmp
<dim>
jackdaniel: thanks for introducting filtered-functions, I like that approach... I'm not sure it's useful to prevent the class of bugs I have in mind now, though
<Bike>
as wikipedia more or less puts it, (>>= mx f) = (if (justp mx) (funcall f (just-value mx)) none)
<dim>
yeah the function isn't even called if you're having a Nothing instance, IIUC
lmy9900_ has joined #lisp
<jcowan>
but now when I run the executable my program runs and then drops into the ECL REPL. Is that expected? If I explicitly call (ext:quit) all is well.
<jackdaniel>
sorry, I have a meeting now, will answer afterwards
<elderK>
makomo: You know the , distributes in ,,@something?
<elderK>
makomo: Does ,@ distribute too? ,@,@something?
<makomo>
elderK: precisely :-)
<Bike>
so instead of a general >>= you have maybe-ref and either-ref
<makomo>
elderK: although some people don't agree with that (and neither do all of the implementations), but that's why we had that wager the other day
<elderK>
makomo: Interesting.
lmy9900 has joined #lisp
<jackdaniel>
makomo: did you look into the org file?
<Bike>
or, no, -bind, i see
<elderK>
makomo: Well, it seems if you expand it out the long way, then "collapse" it back into shorthand, you get what looks like distribution.
<Bike>
but still ungeneric
<Bike>
guess it lacks appeal without the static typing
lmy9900__ has joined #lisp
<jackdaniel>
(defclass foo (null) ()); but that won't work because null is a bultin-class
<makomo>
jackdaniel: i took a quick look but right now i have 4 exams coming up next week, all 1 day apart. i want to do it properly and make a detailed analysis, but i can't do that without failing my exams :-)
lmy9900_ has quit [Ping timeout: 244 seconds]
<makomo>
jackdaniel: i'll let you know when i get to it
lmy9900_ has joined #lisp
<jcowan>
Bike: I've specced out but haven't written a general monad library. But yes, without static types you have to pass the monad instance (a struct of functions) explicitly to each monad operation.
<Bike>
and that sucks
<jackdaniel>
elderK: only sbcl supports ,@,@ and imho it is not portable CL, I've pasted my analysis a few days ago
<Bike>
i mean, with a cl generic function, it could be done, but there'd be run time checks of course, and you'd have to trust the mfunctions are ok
<jcowan>
(monad-bind instance *obj* *mproc* ...)
igemnace has quit [Quit: WeeChat 2.3]
lmy990___ has joined #lisp
<dim>
well I guess in practical terms I have to care everywhere that I don't get a NIL where my code expects something else, and that's going to be a large amount of work because I didn't do that thoroughly from the beginning
<jcowan>
The trouble with using a gf is that you can only have one monad instance per CL's idea of a class, which is restrictive. When it comes to monoids (which it will), how would you provide both Sum and Product without wrapping numbers in a class, making them unusable as numbers?
lmy9900 has quit [Ping timeout: 252 seconds]
<jcowan>
sorry, didn't mean to use earmuffs there, a hangover from Markdown
lmy99____ has joined #lisp
<elderK>
jackdaniel: Thanks jackdaniel :) I was just thinking about it. It would be pretty crazy to see it used.
lmy9900__ has quit [Ping timeout: 272 seconds]
<Bike>
i don't follow.
<elderK>
jackdaniel: I'll have to consult the CLHS again to see if it's like, iono, disallowed.
<Bike>
i guess you can use a haskell object as being two different kinds of monads?
lmy9900 has joined #lisp
<elderK>
jackdaniel: Thank you
lmy990___ has quit [Ping timeout: 272 seconds]
<Bike>
forgot about that. static typing strikes again
lmy9900_ has joined #lisp
lmy99____ has quit [Ping timeout: 252 seconds]
HDurer has quit [Remote host closed the connection]
lmy9900__ has joined #lisp
lmy9900 has quit [Ping timeout: 252 seconds]
lmy9900_ has quit [Ping timeout: 250 seconds]
elfmacs has quit [Ping timeout: 252 seconds]
<elderK>
jackdaniel: Interesting read. And good points.
<elderK>
My mental model is the case where '`', ',' and ',@' are just shorthands for operators.
lmy9900__ has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<jackdaniel>
this discussion was not about intuition but about conforming Lisp code, I can imagine having such intuition
<jackdaniel>
and last statement (that first two strategies are incorrect) is not well thought through, reader doesn't necessarily return a cons structure, but still third strategy is more convenient and also conforming. either way, conclusion that ,@,@ can't be used in portable code due to ambiguity stands.
<elderK>
Aye, I see that. You've raised good points. Although, I'm not sure I can fully appreciate those points just yet :)
lmy9900 has joined #lisp
lmy9900_ has joined #lisp
lmy9900__ has joined #lisp
lmy9900 has quit [Ping timeout: 245 seconds]
solyd has joined #lisp
lmy9900_ has quit [Ping timeout: 246 seconds]
nowhere_man has quit [Ping timeout: 268 seconds]
lmy9900 has joined #lisp
thinkpad has quit [Quit: lawl]
lmy9900_ has joined #lisp
lmy9900__ has quit [Ping timeout: 272 seconds]
lmy9900 has quit [Ping timeout: 276 seconds]
thinkpad has joined #lisp
milanj has quit [Quit: This computer has gone to sleep]
<jcowan>
Bike: You declare two static type synonyms for Number, Sum and Product, each of which can be an instance of Monad.
<Bike>
right, yes
<jcowan>
not "synonyms", just new types operationally equivalent to the old ones.
[X-Scale] has joined #lisp
[X-Scale] is now known as X-Scale
<dim>
jackdaniel: more things happen in lisp than in C to this days, I guess? ;-)
<jackdaniel>
yes, I think that was a pretty uneducated sentence (that's why I found it funnY), also you may do more interesting things in Lisp
<aeth>
why is C so dead these days compared to Lisp?
<_death>
jackdaniel: I think the guy has a connection to ELS, so I wouldn't say "uneducated"
<jackdaniel>
it isn't dead, there is just not much to talk about (wrt C) - it is not extensible whatsoever. it evolves though
<jackdaniel>
_death: well, sentence implies, that it is suprising Lisp has a conference (like as if it is a dead language)
lmy9900_ has joined #lisp
<aeth>
idk, language popularity measurements are all pretty arbitrary and have wildly different results so I propose the language conference language popularity measurement. ;-)
<_death>
jackdaniel: maybe it's more about exposing the general readership to the fact that it exists ;)
<aeth>
maybe ELS is paying blogs to subtly link to them as part of a SEO campaign
<jackdaniel>
I've presented my interpretation of it, I'm not insisting in others agreeing with me, still I found it funny :)
<aeth>
your interpretation is probably the most correct
<LdBeth>
Well, more than 30 years, that’s quite impressive
Kundry_Wag has quit [Ping timeout: 268 seconds]
<shka__>
aeth: "iluminatti confirmed"
heisig has joined #lisp
nowhere_man has quit [Ping timeout: 268 seconds]
frgo has joined #lisp
<shrdlu68>
Someone describes something they made as "Written in Rust, a modern, low-level, high-performance language without garbage collection."
<shrdlu68>
I wonder how tool written in CL would be described.
<shrdlu68>
What is a "modern" language?
<jackdaniel>
jcowan: it is expected, default value of epilogue-code for :program is `(si::top-level t)
<Bike>
a language arising from the wide scale and far reaching transformations in western society beginning roughly after world war one
<jackdaniel>
you may provide your own funciton there, then you won't deal with a toplevel
<jcowan>
ok, tx
<shka__>
shrdlu68: it is a language
<jackdaniel>
remember to wrap your toplevel function in a handler-case if you want to avoid suprises
<jackdaniel>
(i.e unwind-protect not being executed on error which is not handled anywhere up the stack)
<shrdlu68>
I think "built with alien technology" is a popular one for CL.
<jcowan>
Bike: I would say that the modern (phase of) languages begins around 1650, at least in Europe.
<Bike>
it's debatable
fikka has joined #lisp
beach has quit [Disconnected by services]
<_death>
witten in Common Lisp, an ancient, multi-level, high-inducing language without garbage.
<_death>
*written
<shrdlu68>
Hehe
beach has joined #lisp
frgo has quit [Remote host closed the connection]
<shrdlu68>
I also like how some languages describe themselves as "concurrent".
<dim>
Common Lisp is first of all a very modern programming language for me, even more so when compared to Python, C, Java, PHP, or some others that I've been using
edgar-rft has joined #lisp
<dim>
there are so many useful things in the language, in ways that other just can't think about (multiple dispatch, control flow operators, conditions, standard types as classes, interactive debugging by default, running your own code at compile time with defvar/defparameter, and so much more, macros and reader macros of course)
<jackdaniel>
I agree
<shrdlu68>
"Scala combines object-oriented and functional programming in one concise, high-level language."
<jackdaniel>
i.e things like update-class and elaborate condition handling is something very modern and tailored especially for a lasting solutions
<_death>
Odin hanged himself upside down for nine days to discover the secret of Common Lisp...
<jackdaniel>
:-)
<shka__>
gosh, scala is abhorrent language
<_death>
only it used < and >
<jcowan>
_death: On a tree of conses, no doubt.
<_death>
YgdraCL
<dim>
jackdaniel: sometimes I want to play around with LFE (a Lisp on-top of Erlang), where hot code reloading in a distributed cluster is a normal thing to do... ;-)
* jcowan
snickers
<jackdaniel>
dim: is there some good resource describing this mechanism?
<dim>
it's Erlang 101 really
<jackdaniel>
OK, thanks
<jcowan>
I think it's fair to say that Go, Ada, and Algol 68 are concurrent languages: the concurrency is a language feature, not a library feature. (I grant that this distinction is not very relevant to the Lisps.)
smokeink has quit [Remote host closed the connection]
<dim>
what Erlang guys said is that if you want to have software that runs without downtime, first thing you need is being able to patch it while it's running, because you will have bugs, and specs will change
frgo has joined #lisp
<jackdaniel>
yes, that's why I've mentioned update-class as an example
<dim>
exactly, that's why I'm now thinking about Erlang ;-)
<jackdaniel>
change-class, sorry
Kundry_Wag has joined #lisp
<jcowan>
But note that in Erlang the unit of replacement is whole modules, not individual objects, and only one old version is allowed as opposed to an arbitrary number of versions in CL. (Granted, this restriction could be lifted in an Erlang runtime.)
orivej has joined #lisp
elfmacs has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
Kundry_Wag has quit [Ping timeout: 240 seconds]
<shrdlu68>
Oh man to be able to apply patches without thinking about a whole HA set-up!
<jcowan>
Version skew is still a problem even in shared-nothing architectures. I had to make a last-minute patch to my back-end change that added a new key to a JSON request from the front end, because we had to deal with the fact that for perhaps 15 minutes old front ends would be trying to talk to new back ends, which would crap out for lack of the field.
<jcowan>
The fact that we didn't think of this until the day before release is the disturbing part.
<zigpaw>
you also have the support for rolling updates in kubernetes - as an example of completly different approach to the zero-downtime problem.
<dim>
compatibility matrixes, dependencies, ordering pushes to productions of independant components, yeah it's hard
ak5 has quit [Ping timeout: 272 seconds]
<dim>
zigpaw: does it solve changing the current state in the application? that's what Erlang is very good about...
robdog has joined #lisp
<shrdlu68>
zigpaw: The kubernetes approach works only for completely stateless applications.
<shrdlu68>
Most codebases not written specifically with that in mind would require significant change.
lvo has joined #lisp
fikka has joined #lisp
nowhere_man has joined #lisp
rumbler31 has joined #lisp
confusedwanderer has joined #lisp
frodef has quit [Ping timeout: 272 seconds]
milanj has joined #lisp
rumbler31 has quit [Ping timeout: 244 seconds]
<dim>
yeah that's where Erlang is very strong, statefull and hot code reload, plus other things, I really enjoyed using it back when I had to
<shrdlu68>
So is CL :)
frodef has joined #lisp
<zigpaw>
shrdlu68: yes, as I have mentioned - it is a completly different approach. Inferior in some ways, but that's how other people are dealing with this problem.
<pfdietz>
jcowan: there is a tension in CL between inclusion of standard functionality, and minimality. The crux there is that all the symbols are visible in a lisp image, and have to be there because they can be obtained by creating those symbols at runtime (by reader or intern).
<ogamita>
dim: add methods for the NULL class! ie. move to the nullable monad!
<pfdietz>
(responding to a yesterday conversation)
<ogamita>
eg. CAR is in the nullable monad.
SaganMan has quit [Ping timeout: 246 seconds]
<ogamita>
dim: Lisp already has the MayBy type everywhere by default! (defun just (x) (assert x) x) (defun maybe (x) x) (defun nothing () nil)
<ogamita>
dim: so use (maybe (when (maybe x) …)) but since maybe is identity, just use (when x …) everywhere.
robotoad has quit [Quit: robotoad]
<ogamita>
and (defmethod numeric-foo ((x null)) 0) (defmethod list-foo ((x null)) nil) (defmethod vector-foo ((x null)) #()) etc.
<ogamita>
(or of course, you can go get a PhP about why MayBe Just Nothing is needed in Haskell).
<ogamita>
(with a lot of type theoric abstract formulas).
<ogamita>
Bike: Yes, if you want to distinguish bottom false, empty-{list,set,vector,string,thingy}, 0, 0.0, etc from the symbol NIL, yes, you may need a (defstruct maybe x) (defstruct nothing) (defgeneric just (m) (:method ((m maybe)) (maybe-x m)) (:method ((m nothing)) (error "There's nothing!")) (:method ((x t)) x))
notzmv has joined #lisp
<ogamita>
jcowan: actually, monads can be represented ("are") in CL method-combinations. So you assign each gf to a single monad, and it's independent of the class of the arguments.
jmercouris has joined #lisp
mercourisj has joined #lisp
<mercourisj>
is there a way to check if a system is loaded into an image?
lmy9900 has joined #lisp
<mercourisj>
(asdf:already-loaded-systems) ?
<jackdaniel>
what is a system (lisp standard-wise)?
thijso has joined #lisp
<mercourisj>
a defsystem entry within an asd file
<ogamita>
jackdaniel: nothing. User data.
<ogamita>
Some instance of some class.
<mercourisj>
oh, I see, sorry, I didn't understand your question jackdaniel
SaganMan has joined #lisp
<ogamita>
(actually, a graph of instances, since it's decomposed into components, files, etc).
<mercourisj>
I thought you were being pedantic with me :D
<jackdaniel>
asdf has component-loaded-p in its interfaces
<Xach>
mercourisj: asdf:registered-system and asdf:registered-systems, I think.
<ogamita>
mercourisj: in a way. If you know what a system is, you know where to search for a test whether there's a system accessible in the lisp image.
<jackdaniel>
registered is not loaded, is it?
heisig has quit [Quit: Leaving]
elfmacs has quit [Ping timeout: 272 seconds]
<jackdaniel>
registered doesn't mean loaded necessarily°
<jackdaniel>
you can't use symbols from package which is not created yet
<jackdaniel>
when you write cffi:foo reader goes to the cffi package (and it is done at read time)
<jackdaniel>
so first your read form (and access the package!), then you load the system by executing read form
<jackdaniel>
but execution should be performed first
<jackdaniel>
so it is not asdf thing but rather read/execution time
<mercourisj>
so (push guix-profile cffi:*foreign-library-directories*) needs to be wrapped in an eval-when of some sort?
<jackdaniel>
silly workaround would be: (push guix-profile (eval (read-from-string "cffi:*foreign-library-directories*"))
scymtym has quit [Ping timeout: 252 seconds]
<jackdaniel>
no, eval-when is also a form which is read by a reader
shifty has quit [Ping timeout: 268 seconds]
<mercourisj>
so you said the package is not yet created, (asdf:load-system "cffi"), does that not load the system and symbols?
<mercourisj>
would it have had to have ben (ql:quickload :cffi)?
<jackdaniel>
it does, but this is after reading the form
<jackdaniel>
error is *before* you execute them, so you loaded nothing
<jcowan>
pfdietz: I'm not sure what you're referring to
<mercourisj>
jackdaniel: so, you're saying the reader does not know of the package CFFI and thus signals an error?
<jackdaniel>
yes, that's what I'm saying
<jcowan>
ogamita: using nil for Nothing and anything else for Just doesn't work, because you need to be able to say "Just false" and "Just ()" which both come out nil on your formulaton.
pierpal has quit [Quit: Poof]
<jackdaniel>
less silly way would be abstracting (symbol-value (find-symbol (string '*foreign-library-directories*) (find-package 'cffi)))
<jcowan>
See the rationale of my MaybeEither document linked above
pierpal has joined #lisp
<pfdietz>
jcowan: talking about attempts to minimize lisp, as talked about yesterday.
<jcowan>
Ah
<mercourisj>
jackdaniel: I see
<mercourisj>
thanks
<jackdaniel>
yw
<jackdaniel>
apparently I'm quite silly myself, because I use read-from-string method couple of times in my lisprc file
<jackdaniel>
(by method I have a common meaning in mind, namely "way of doing things")
<mercourisj>
we are all silly sometimes
<jcowan>
ogamita: I also don't understand what you are getting at with one gf per monad (instance); it's the monadic operations (map, bind, sequence, join, >>, product, lift) that need to know which monad they are dealing with.
<Bike>
jcowan: the gethash return values are more of an actual maybe, not that they form a manipulable object
<jcowan>
True
<ogamita>
jcowan: indeed.
<ogamita>
You define monads with define-method-combination, and you define operations with (defgeneric … (:method-combination …))
<jcowan>
I don't know any way to do that in a dynamic language except to pass an object representing the monad. This is what Haskell actually does under the covers for all type classes.
<Bike>
jcowan: i think that's bsaically how to do it.
<Bike>
kind of like if cl:map took a type for the parameter as well as the return value
<ogamita>
With methods combinationsm you don't need to pass it an explicit monad; each gf knows what monad it works in.
* jcowan
looks at d-m-c, hitherto a dark corner for me
<Bike>
i, for one, have no idea what pjb is on about
varjag has joined #lisp
<Bike>
and i've written a d-m-c implementation
lmy9900 has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<Bike>
are the multiple monadic functions supposed to be methods of the same gf
lmy9900 has joined #lisp
<jcowan>
"Instead of trying to prove your opponent wrong, try to see in what sense he may be right." (Nozack's tolerance principle)
<jcowan>
The Loewenheim-Skolem theorem guarantees that there will always be such a sense. :-)
<Bike>
i'm trying and it's not working so far
<jackdaniel>
"Instead of treating discutants as opponents treat them as partners. Don't be afraid to 'call bullshit' when applicable." ;p
scymtym has joined #lisp
<ogamita>
I gave an example once on cll. I can't create a new one right now.
<elderK>
Guys, what's the difference between deposit-field and dpb?
<elderK>
They seem to be like, almost identical?
igemnace has joined #lisp
<jackdaniel>
one is right justified the other is not
<Bike>
oh hey, i don't see that wz guy in cll any more, just a bunch of italian spam
<ogamita>
Yes, the difference is in the shifting. Compare mask-field and ldb, it'll be more obvious.
<jackdaniel>
but it is very likely your implementation has condition-broadcast
frgo has quit [Remote host closed the connection]
frgo has joined #lisp
<jackdaniel>
ccl doesn't have condition variables (they are implemented with semaphores on bt), but sbcl and ecl both have broadcast for a condition variable
<shka__>
ok, thanks
lmy9900 has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
lvo has quit [Remote host closed the connection]
DGASAU has joined #lisp
<mercourisj>
you can specialize eql on object types? how do you do that?
<mercourisj>
I thought eql was a function, and not a method
<Inline>
when the method has additional info on what to dispatch on.....
<mercourisj>
I'm sorry, you've all now totally, completely lost me
<beach>
A specializer is either a class or an EQL specializer.
<Inline>
how many specializers are there ?
<jackdaniel>
mercourisj: go to clhs and read about defmethod
heisig has quit [Quit: Leaving]
<jackdaniel>
and how you may specialize your arguments
<mercourisj>
oh, that is what you guys are talking about
<elderK>
The only other way I am aware of to use "eql" in something regarding types, is with deftype. But I may be mistaken.
<Inline>
how do you specalize on integers from 10 to 20 ?
<Inline>
lol
<mercourisj>
I thought you meant somehow modifying the eql function to support comparison between arbitrary object types by writing your own comparator
<elderK>
Inline: Couldn't you define a type, (integer 10 20)
<elderK>
And specialize on that?
<mercourisj>
as it would be done in Java
<Inline>
no idea i thought there'd be some idiomatic way
<jackdaniel>
Inline: you can't specialize on types which are not classes
<elderK>
Ah, that's what I thought.
<elderK>
mercourisj: Nope :)
<jackdaniel>
(integer 10 20) is a type and integer is a class
<_death>
Inline: there are more sophisticated dispatch mechanism, not part of CL, such as predicate dispatch
<Inline>
oh
<Inline>
and where do i read about such stuff _death ?
<_death>
duckduckgo for it?
<Inline>
ah
<Inline>
ok
<jackdaniel>
you may read the implementation of filtered-functions to see how you may specialize dispatch mechanism
jibanes has joined #lisp
mercourisj has quit [Remote host closed the connection]
* beach
wonders what part of "A specializer is either a class or an EQL specializer" was not clear.
<jdz>
CLIM also has presentation types which I think allows to create finer grained specializers?
<jcowan>
EQL specializers would be better called singleton or specific-instance specializers imO
<shka__>
probabbly
<jackdaniel>
jdz: yes, but when you dig enough you find it amusing and horrific
<beach>
jcowan: Perhaps, but that is not what they are called, and it is best to stick to established terminology.
<jdz>
Right. When I was implementing my CLIM web framework I left presentation types for later, and never got around to doing them.
<ogamita>
beach: the way brains and consciousness work. The "classic" model, is that you have a lot of agents that detect each one interesting things, and when they do, they try to signal it, but since they compete with all the other agent, only the one or two most vocal agent get to raise above the level of consciousness and can be "reasoned" about.
<jdz>
Said as if it was known how brains work.
<ogamita>
beach: said otherwise, the problem is not "A specializer is either a class or an EQL specializer", it's how a given brain processes it in a given circumstance, with all its other agent competing.
Inline has quit [Read error: Connection reset by peer]
<ogamita>
beach: this is why sometimes a good "fucking" can help raise the level of a given agent, as in: "A specializer is either a class or a FUCKING EQL specializer"
Inline has joined #lisp
<ogamita>
of course, it works only if it's used parcimoniously. Not like in hollywood movies…
<beach>
I'll try to remember that.
razzy has joined #lisp
<jackdaniel>
jdz: for base usage they are fine, but more esoteric usages are allowed
<nirved>
in Keene's book "eql specializer" is called "individual method"
<Bike>
well that's a weird thing to call it
<nirved>
cause it specialized on an individual lisp object
frodef has quit [Ping timeout: 268 seconds]
<elderK>
Anyone here have any advice for when to use dyanmic-extent?
<jackdaniel>
elderK: you don't need to use it unless you know you need to use it
<Bike>
yeah, don't sweat it.
<elderK>
Ok :)
scymtym has quit [Ping timeout: 276 seconds]
<elderK>
How will I know when I need to use it? :D I figure I'll have a major performance or memory issue. I'll learn a bunch using time and friends. And then, if necessary, I'd use dynamic-extent along with other declarationey things?
<nirved>
elderK: check chapter 17-7 from Common Lisp Recipes
<elderK>
Thank oyu
jsc has joined #lisp
jsc is now known as status402
status402 has quit [Client Quit]
status402 has joined #lisp
gabot has quit [Ping timeout: 272 seconds]
ggole has joined #lisp
groovy2shoes has quit [Quit: moritura te salutat]
pierpal has quit [Quit: Poof]
pierpal has joined #lisp
status402 has quit [Quit: status402]
groovy2shoes has joined #lisp
<ogamita>
elderK: when you have a dumb compiler with a slow garbage collector?
<ogamita>
elderK: it allows to perform stack allocation. You'd use it as often as you'd use alloca instead of malloc… (ie. never).
<elderK>
ogamita: I was hoping dynamic-extent would be more intelligent than using alloca() in C. Using alloca() in C is okay in some cases but largely, not so much.
<elderK>
But stack variables? Sure. Or structures on the stack? That's pretty often.
<elderK>
Anywho, that was what I was hoping dynamic-extent could do. Then again, I figure SBCL is pretty smart and at sufficient levels of optimization, will do all of that anyway without being told.
<ogamita>
It's for the data. Lexical variables are already stored on the stack or in closures.
<jackdaniel>
elderK: if compiler can prove that they do not escape it will alloc them on a stack either way
<elderK>
And frankly, it'll probably be better at determining that than me specifying it :)
<jackdaniel>
otoh if you declare it dynamic-extent it may take your claim at face value, and given you were wrong - you may fail badly
<elderK>
Precisely :)
<elderK>
In that case, I'll ignore it until you know, one day far in the future, it seems necessary, as suggested earlier.
<elderK>
Ah, B movies :)
flamebeard has joined #lisp
jochens has joined #lisp
<beach>
nirved: No it isn't. She calls the METHOD with an EQL specializer that. But not the specializer itself.
<beach>
nirved: Since there is no specific term for such a method, neither in the Common Lisp HyperSpec nor in the AMOP, she is free to make up a term for it.
<elderK>
Out of curiosity: If I cannot specialize a method on a non-class type, like, how do you work around that?
<elderK>
I've seen some code where they seem to specialize on symbol, and use that to lookup a "metaclass" then dispatch based on that.
<elderK>
(Approach used in binary-types)
<beach>
elderK: The generic dispatch mechanism is designed to be fast. If you were to allow arbitrary types, it might be arbitrarily slow. Also, the order of applicability may be an issue, since it is not always obvious.
<beach>
elderK: Using types would basically be a scattered version of TYPECASE. There are libraries that allow you to do that.
<beach>
Or an SBCL extension.
<beach>
It is one of those cases where someone (not you) who doesn't understand much about programming-language design or compiler technology would accuse the creators of Common Lisp of incompetence for the failure of including such things in the standard, and immediately call upon the Common Lisp community to create an updated standard where it IS included.
<elderK>
beach: Should I be concerned with using find-class? I imagine class lookups are reasonably quick?
<elderK>
beach: Aye. I understand why they didn't - it makes sense.
<beach>
You should not be concerned about that. It is a hash-table lookup. But you almost never need it.
<elderK>
Especially since you know, "types" can be pretty flexible with deftype and all.
<beach>
When would you need it?
<elderK>
I'm just curious :) I see it used a lot in binary-types.
<beach>
It is not as though a method is tested for applicability using find-class every time you call the generic function.
<elderK>
It's like, say you have some gf, and you invoke it like (gf 'name args)
<elderK>
binary-types find-classes that symbol, and then dispatches to a method specialized on the returned class.
<elderK>
Instead of eql specializing on the name itself.
<beach>
That's an odd thing to do.
<elderK>
PCL does something similar it's "binary-classes"
<elderK>
I'm not sure why you'd want to do that instead of eql specializing on the name, instead.
<elderK>
Maybe it's a case where like, you have two "binary types" that have different names, but actually are handled the same or something.
<beach>
I am afraid I don't know.
<beach>
elderK: If I were you, I would not be so concerned with the performance of low-level stuff like that. Typically, badly designed algorithms and data structures are the main source of inefficiency.
varjag has quit [Quit: ERC (IRC client for Emacs 25.2.2)]
<elderK>
beach: That's what I figured :) But, you know, it never hurts to check.
<beach>
Of course, it is typical for people (again, not you) who are clueless about efficient algorithms and data structures to worry about micro optimizations, and then completely blow it anyway when it comes to the overall performance.
<elderK>
Aye. I've hit that a lot at University :P
<elderK>
Hell, I was the same many years ago :)
<elderK>
People optimizing a loop say, without realizing that the real performance cost is because say, they're using a list instead of something like a tree or hash table :P
<beach>
Apparently, not even professors of computer science can get a simple thing like binary search right. *sigh*.
<elderK>
Not knowing when to use which type of structure.
<dim>
the best possible optimisation is to remove the code entirely
<elderK>
dim: Agreed.
<dim>
we often implement things we don't need...
<elderK>
When I was working, I actually had to try and convince my boss, a senior who made way, way more than me, why using a hash table for dispatch would be faster than a 10k some line long if-else chain.
<elderK>
It was for their server dispatch. Each if was a string comparison, etc.
<elderK>
Thousands of lines of logic in the friggin' if chain, rather than factored out.
<elderK>
It was terrible.
<dim>
radix tree come to mind, or just, you know, interning the strings in symbols and maintaining a hash-table on the symbols...
<beach>
elderK: The SIZEOF method should probably normally be called with an instance of a binary type, in which case it is a simple accessor. The method that specializes on a symbol is probably provided for convenience.
<jackdaniel>
elderK: PCL usage is to be able to find a binary class corresponding to some kind of an identifier (i.e string)
<elderK>
beach: Notice the second method. It just uses (type-of object)
<jackdaniel>
thanks to that you may dispatch given i.e a string
<beach>
elderK: Notice the class binary-type.
<beach>
elderK: It has a :reader sizeof.
<elderK>
Aye.
<elderK>
Right, so specialized methds will be added for each type, right?
<beach>
So if you call sizeof not with a symbol, but with an instance of binary-type, which I am guessing is the normal case, then it is a simple slot reader.
<jackdaniel>
methods are not "inside" classes
<elderK>
jackdaniel: Yup, I know.
<elderK>
I need to read about the accessors that defclass creates. I am a bit confused as to like, the sizeof accessor.
<elderK>
You know, because there is a GF called sizeof, too.
nowhere_man has quit [Ping timeout: 276 seconds]
<beach>
elderK: It is a generic function with a method that specializes on the binary-type class.
<jackdaniel>
elderK: accessors are method pairs foo and (setf foo)
<elderK>
beach: Okay, cool. So, it is what I expected.
<beach>
When it says :reader sizeof, it is essentially the same as a method that calls slot-value on the slot. But it is typically much faster than such a method.
<beach>
So (defmethod sizeof ((object binary-type)) (slot-value object 'sizeof)) or something like that.
<elderK>
Okay, cool. That makes sense.
<elderK>
But it does make me wonder why the second sizeof method is even necessary.
<beach>
Then the explicit DEFMETHOD form adds another method to the sizeof generic function.
<elderK>
L137
<beach>
It probably isn't like I said. It is probably provided for convenience.
jochens_ has joined #lisp
<jcowan>
Essentially all binary search implementations were wrong for *decades*.
<beach>
jcowan: They still are.
<elderK>
jcowan: Are we talking BSTs or just, binary search in general?
<beach>
elderK: In the past, they were wrong because they would fail in situations such as when the object did not exist, or when there were multiple occurrences.
<elderK>
At Uni, I saw a lot of people fail when the "sequence" they were binary searching had an even number of elements.
<elderK>
beach: Right. So, people just assumed that when it stopped, it had found the thing?
<elderK>
That seems kind of uh, bad :P
<beach>
elderK: Not so much now. Now they just fail because they start by testing for equality, which makes them take 50% longer than they should.
frgo has quit []
<elderK>
It would be like hashing somewhere in an open-addressed hash table and not checking like, that the thing you've hit is actually what you want.
frgo has joined #lisp
<trittweiler>
You shouldn't test for equality at all. That's by definition only true once. It's the uncommon case :)
<beach>
And if you start by checking for that, you increase the execution time by 50% on the average.
<trittweiler>
(at most) once
<beach>
trittweiler: Exactly.
<elderK>
I'll have to read that post later :)
<beach>
elderK: Oh that problem does not exist in Common Lisp.
<beach>
We have bignums.
<elderK>
beach: I'd still like to learn from it all the same, just to avoid making the same mistakes when I work in other languages.
<beach>
I solve the problem by not working in other languages.
bradfonseca has joined #lisp
<elderK>
:) I intend to do the same :)
<beach>
But, as trittweiler points out, testing for equality should be done once.
<elderK>
I've been really investing serious time over the past few weeks, into CL.
<beach>
And that's where most algorithms are wrong.
<elderK>
trittweiler: I'd like to hear about how you deal with say, chained hash tables. I guess you could have a secondary hash and check those as you traverse the "chain" for some primary hash
<elderK>
Or you know, OA hash tables with different kinds of probing or something.
<elderK>
beach: I'd agree with you. I've been surprised by how often I've seen implementations of say, search trees, that perform comaprisons more than necessary.
<elderK>
although I guess that's a different kettle of fish, I still feel it should be avoided at all costs.
<trittweiler>
The other thing is that binary search should not be a binary thing, it should return the index of the item if found, or the index where the item would have to go if one wants it to be inserted. Of course in CL, there are multiple return values, so it easy and convenient to do that.
<elderK>
At least, when keys are not something like an integer :P
<trittweiler>
s/binary/boolean/2
Mr-Potter has joined #lisp
<elderK>
beach: I believe it was you, a few days ago, that suggested reading docstrings from files?
<elderK>
Like, instead of writing them inline in the source, reading them from a file.
<elderK>
I may be mistaken though.
<elderK>
I was wondering about that. Would you like, read-string or whatever at read time? (:documentation #.(read-doc-r-something)) ?
<beach>
You can use (setf documentation). It doesn't have to be near the thing it documents.
Kaisyu has quit [Quit: Connection closed for inactivity]
<elderK>
I see.
<beach>
That is what I recommend.
<elderK>
beach: Any chance you can link me to an example of like, the approach you recommend?
<elderK>
Like, used for real?
<beach>
Let me check. I probably use some auxiliary function, but still...
<elderK>
I imagine the project has a file somewhere that contains mappings of symbol -> documentation, and some other file that processes that and attaches the documentation to those symbols?
<elderK>
I've been kind of unsure how to best document my stuff, you see. So, seeing "good examples" would be really useful.
<beach>
elderK: It would be the Common Lisp compiler and ASDF that process those. Nothing special here.
Bronsa has quit [Remote host closed the connection]
<beach>
It is just a matter of using (SETF DOCUMENTATION).
flamebeard has quit []
<jcowan>
beach: I understand placing the CL: docstrings outside, but do you extend this to all function-likes?
<beach>
Notice how you can have very complete documentation strings without polluting the source code with irrelevant information.
Denommus has quit [Quit: ERC Version 5.3 (IRC client for Emacs)]
<elderK>
beach: I particularly like that aspect of this. Are those parameters only defined in the doc lisp?
<beach>
jcowan: You can extend it to most kinds of Common Lisp objects.
shka_ has joined #lisp
<elderK>
I imagine this file is processed the same as any other lisp source via ASDF?
<beach>
Yes.
<elderK>
Cool :)
<elderK>
Thank you for sharing
<beach>
Sure.
<shka_>
good evening
<elderK>
shka_: Good morning :)
<jcowan>
Okay, but what's the logic for making them external? What encouragement is there to keep them up to date as things change? (The CL spec doesn't change, that's why I see it as a special case.) I can barely keep comments *with* the code up to date.
<elderK>
jcowan: I guess it's no different than having say, "Doxygen docs" separate from C code. You have to maintain them yourself.
<beach>
jcowan: Documentation strings are for the protocol objects. Those had better not change.
<beach>
jcowan: If you change the protocol objects, you break client code.
<elderK>
beach: So, you don't bother documenting say, internal things? Helper functions and whatnot?
<beach>
Correct.
solyd has quit [Ping timeout: 268 seconds]
<beach>
I stick comments to those.
<elderK>
Sweet.
<beach>
Because they are meant for the maintainer.
<elderK>
I like that your documentation is all aligned :)
<beach>
That's due to the ~Newline format directive, with a @ modifier.
<elderK>
Like, each line starts at the same offset. Most docs I've seen are indented some on the first, and the rest are all flush.
sysfault has joined #lisp
<elderK>
I have to look that up, ~@.
<elderK>
Moment :)
sysfault has left #lisp ["Leaving"]
<beach>
No, ~newline.
<beach>
@ is a modifier (or whatever it's called).
<jcowan>
"It is not sufficient merely to prove a program correct; you have to test it too." This shows what a farce proof is.
<beach>
So I use #.(format nil "....")
<jcowan>
"Almost all theorems are correct, but almost all proofs have bugs." --Paul Pedersen, mathematician turned programmer
<elderK>
beach: Is that what your fmt function is doing?
<elderK>
It just seemed like it was forwarding every to format, but always resulting in a string
<elderK>
:) for some reason, I thought docstrings were like, not evaluated. Like, that they had to be specified as strings, rather than the result of a function.
<elderK>
beach: But your fmt calls are not being made with #.?
scymtym has joined #lisp
<jcowan>
Yes, if you only use docstrings for externally visible things, I understand your reasoning. But the fact is that protocols, unless dictated by standards or arms-length relationships, change all the time too. When $EMPLOYER announces a public API this year or next, it'll have to be carefully stabilized and versioned, but the various internal APIs will undoubtedly go on changing as $PRODUCT grows new features.
<elderK>
Wait, I'm an idiot.
<beach>
elderK: Right, (SETF DOCUMENTATION) is a function.
<elderK>
Those *...* parameters are /defining/ the docstrings. Nto being documented themselves.
<elderK>
D'oh :)
<beach>
jcowan: I am sorry to hear that you have to work in such conditions.
<elderK>
beach: Unfortunately, that has been my experience also.
<beach>
jcowan: I am also surprised to see that, because APIs are not stable, that implies that every internal function must have a docstring.
<elderK>
~_~ Then again, most APIs I've had the misfortunate of working with in some way, have been horribly designed. Almost schizophrenic.
<beach>
If your plan is to break client code, break the documentation too.
<elderK>
Like, professionally. I like to think of the APIs of my own personal things are much nicer :) But you know, YMMV.
<jackdaniel>
it is all about preferences
<jackdaniel>
i.e some think about docstrings as a short contextual information serving a purpose of a reminder
<beach>
Either way, *I* don't plan to break my protocols, so *I* don't see the problem with detached documentation strings. If you plan on breaking your protocols, sure, put short docstrings in the code.
<elderK>
jackdaniel: I guess having that as a docstring, rather than say, a comment, is more useful since you could find that stuff in apropos or something?
<jackdaniel>
that may be how people think, yes. I don't have strong opinions about the topic except that cl's documentation abstraction is not well suited for writing software documentation
<_death>
it's also possible for something to change in a non-breaking way, and the documentation still has to be updated.. I like to see a docstring when I go to a definition
vibs29 has quit [Ping timeout: 252 seconds]
dorketch has quit [Quit: WeeChat 2.1]
<elderK>
_death: Is there somewhere I can like, refer to, to learn about how... well, to ensure that the docstring appears properly aligned when viewed?
varjag has joined #lisp
<p_l>
Anything lisp-interesting in Boston in two weeks time?
<elderK>
I like to have my text all indented to the same level, for... personal reasons, I guess. But I'm not sure how this would appear when someone calls documentation, or say, hovers over it in SLIME
vibs29 has joined #lisp
frodef has joined #lisp
<elderK>
Such information would also be useful wrt (error ...) or (warn ...) messages :)
<jcowan>
Doing such things is inevitable in an environment where not everything can be planned, much less implemented, ahead of time, and actual customers have put their money where their mouth is and have a right to expect something rather than being told "Wait a few years and you can have it perfect." They need it now, not perfect, with a believable promise of improvement.
<_death>
elderK: the thing is that docstrings appear differently in different contexts.. for example they may appear one way if you use the DOCUMENTATION function to retrieve them, and another way if you stumble upon them in the source.. personally I think a good format is a short paragraph or a line describing the function, perhaps followed by more paragraphs detailing things.. Emacs's Lisp code has lots of nice docstrings and makes for good
<_death>
example in my opinion
<jcowan>
(This is about design, not implementation; of course that is always going to have bugs.)
<jcowan>
And yet I believe in what $EMPLOYER does, profoundly.
sauvin has quit [Remote host closed the connection]
DGASAU has quit [Read error: Connection reset by peer]
hhdave has quit [Ping timeout: 252 seconds]
<elderK>
_death: I do not use Emacs so any links you could provide would be appreciated.
<elderK>
I was wondering if there was some convention I could follow wrt say, writing the documentation or directives, that would ensure it would be properly... uh, rendered, in the right places.
<elderK>
Like say, tooltips vs. documentation
<_death>
elderK: since this makes the first paragraph "special", it's easier to live with the different indentation
frgo has quit [Remote host closed the connection]
<elderK>
_death: Right, so that explains the usual indent of the first line, then the rest flush.
DGASAU has joined #lisp
frgo has joined #lisp
<elderK>
Still, I've studied code that has say, 16+ lines in a docstring, sometimes more. It gets in the way.
<elderK>
although I imagine that might be a limitation of slimv - maybe emacs folds the documentation so it isn't so intrusive when viewing code.
<_death>
elderK: not many functions should have long docstrings..
<jcowan>
Well, understanding short-form DMC was easy, but long-form (aka RUN) DMC is another matter.
<_death>
elderK: also, you should consider trying emacs and slime
FreeBirdLjj has quit [Remote host closed the connection]
<elderK>
_death: Thank you for the link :)
<elderK>
jcowan: DMC?
frgo has quit [Ping timeout: 244 seconds]
matzy_ has joined #lisp
<pjb>
I'm not against storing the docstrings in a separate file. As long as you have an emacs command to display it automatically near the function you're editing, and to let you edit it along easily.
<elderK>
Morning pjb :)
<pjb>
As much as I wouldn't be against an emacs mode that would choose itself where to store toplevel forms, without you having to C-x C-f a specific file.
<pjb>
elderK: (eql pjb ogamita)
<pjb>
;-)
DGASAU has quit [Ping timeout: 272 seconds]
<elderK>
pjb: I know :) But I thought I'd say good morning all the same :)
<pjb>
ok. Good time of day!
<elderK>
beach: I'm having trouble finding information for ~@. Everything I can find is like, ~@ followed by some suffix.
<elderK>
pjb: Indeed. I'm a crazy nocturnal animal though :P
jack_rabbit has joined #lisp
<makomo>
elderK: find the CLHS format function and then take a look at all of the various format specifiers or w/e they're called
<elderK>
Hey makomo! :
<elderK>
:D
<makomo>
hi :D
<makomo>
procrastrinating the whole day... ugh ;_;
<elderK>
Interesting article on binary search, btw.
<elderK>
It's crazy how easy it is not to think of such cases.
rumbler31 has joined #lisp
<elderK>
To assume that say, the sum of two things will not wrap, etc.
<elderK>
so I see what beach means, why this would not affect CL
<pjb>
A lot of bugs or problems that occur in other languages, (and that let people get real actual PhD and to build whole cottage industries earning hundreds of millions each year) just cannot happen in lisp. This is why we're poor and with so few research grants.
Lycurgus has joined #lisp
<jcowan>
The existence of bignums in Lisp is irrelevant, because binary search happens within an array, and the array size limit is always a fixnum.
frgo has joined #lisp
fikka has quit [Ping timeout: 272 seconds]
<elderK>
Interesting. So, would you have to apply the same safe-guards in CL then?
<pjb>
jcowan: depends on whether (<= (* 2 array-total-size-limit) most-positive-fixnum) or not.
<pjb>
Well (<= (1- (* 2 array-total-size-limit)) most-positive-fixnum) more precisely.
<jcowan>
true
<jcowan>
No, because bignum arithmetic (no overflow) plus array bounds checking will give you an error instead of the wrong answer.
<pjb>
or -3 since the biggest index wil be (1- array-total-size-limit)
<pjb>
jcowan: nope, because of /2.
<pjb>
The problem is that with modular arithmetic, of when no overflow is detected, they get the wrong index.
<pjb>
s/of/or/
frgo has quit [Ping timeout: 250 seconds]
rippa has joined #lisp
DGASAU has joined #lisp
chens has quit [Read error: Connection reset by peer]
chens has joined #lisp
MichaelRaskin has joined #lisp
ebrasca has joined #lisp
<ebrasca>
Xach: Hi
pierpal has quit [Ping timeout: 252 seconds]
<ebrasca>
Xach: Are you main developer of quicklisp?
pierpal has joined #lisp
shifty has joined #lisp
fikka has joined #lisp
ak5 has joined #lisp
pierpal has quit [Read error: Connection reset by peer]
Kundry_Wag has joined #lisp
jochens_ has quit [Remote host closed the connection]
jochens has joined #lisp
jack_rabbit has quit [Read error: Connection reset by peer]
jack_rabbit has joined #lisp
Kundry_Wag has quit [Ping timeout: 250 seconds]
jochens has quit [Ping timeout: 250 seconds]
frgo has joined #lisp
pierpal has joined #lisp
frgo has quit [Ping timeout: 250 seconds]
pierpal has quit [Ping timeout: 250 seconds]
MightyJoe has joined #lisp
cyraxjoe has quit [Ping timeout: 264 seconds]
robdog has joined #lisp
mrpat has joined #lisp
frgo has joined #lisp
orivej has joined #lisp
DGASAU has quit [Ping timeout: 264 seconds]
frgo has quit [Remote host closed the connection]
pierpal has joined #lisp
frgo has joined #lisp
rumbler31 has quit [Remote host closed the connection]
pierpal has quit [Read error: Connection reset by peer]
ak5 has quit [Ping timeout: 240 seconds]
pierpal has joined #lisp
pierpal has quit [Read error: Connection reset by peer]
pierpal has joined #lisp
ggole has quit [Quit: ggole]
pierpal has quit [Read error: Connection reset by peer]
<beach>
elderK: Like I told you, it is not ~@. It is ~newline. @ is a modifier.
jinkies has joined #lisp
zooey has joined #lisp
<elderK>
beach: My bad :)
DGASAU has joined #lisp
pierpal has joined #lisp
jack_rabbit has quit [Read error: Connection reset by peer]
vlatkoB has quit [Remote host closed the connection]
<aeth>
And I think it is slower, except when inline, which can only happen when the type is declared (since CLtL2 doesn't expose the type inference, only the type declarations)
scymtym has quit [Remote host closed the connection]
jetchisel has quit [Ping timeout: 245 seconds]
SaganMan has quit [Quit: WeeChat 1.6]
pierpal has quit [Ping timeout: 250 seconds]
pierpal has joined #lisp
pierpal has quit [Read error: Connection reset by peer]
varjag has quit [Read error: Connection reset by peer]
nowhere_man has joined #lisp
orivej has quit [Ping timeout: 240 seconds]
confusedwanderer has quit [Remote host closed the connection]
neosloth has joined #lisp
DGASAU has quit [Ping timeout: 260 seconds]
varjag has joined #lisp
frgo has quit []
<elderK>
aeth: thanks :) Looks interesting!
maarhart has joined #lisp
<aeth>
Working with types probably means numbers or arrays, e.g. (simple-array single-float (3)) or (integer 0 42)
<elderK>
Whether I use it or not, it seems like it would be interesting to study :)
jack_rabbit has quit [Read error: Connection reset by peer]
notzmv has quit [Read error: Connection reset by peer]
frgo has joined #lisp
notzmv has joined #lisp
oni-on-ion has quit [Read error: No route to host]
v0|d has quit [Read error: Connection reset by peer]
bradfonseca has quit [Quit: Konversation terminated!]
igemnace has quit [Quit: WeeChat 2.3]
robotoad has quit [Quit: robotoad]
milanj has quit [Ping timeout: 246 seconds]
robotoad has joined #lisp
robotoad has quit [Client Quit]
rumbler31 has joined #lisp
rumbler31 has quit [Ping timeout: 250 seconds]
dorketch has joined #lisp
shenghi has quit [Ping timeout: 246 seconds]
v0|d has joined #lisp
solyd has joined #lisp
shenghi has joined #lisp
Kundry_Wag has joined #lisp
nowhere_man has quit [Ping timeout: 252 seconds]
solyd has quit [Quit: solyd]
Kundry_Wag has quit [Ping timeout: 246 seconds]
frodef has quit [Ping timeout: 272 seconds]
Kundry_Wag has joined #lisp
lmy9900 has joined #lisp
lmy9900 has quit [Client Quit]
fikka has joined #lisp
elderK has quit [Quit: WeeChat 1.9]
Kundry_Wag has quit [Ping timeout: 252 seconds]
varjag has quit [Quit: ERC (IRC client for Emacs 26.1)]
fikka has quit [Ping timeout: 268 seconds]
dorketch has quit [Quit: WeeChat 2.1]
<jcowan>
It's interesting in that you don't have full control of which method is chosen, only that it will work (and therefore all methods must produce the same results, just by different means)
robotoad has joined #lisp
jinkies has joined #lisp
<Bike>
that makes sense as a model for optimization, at least