<aeth>
I finally figured it out, which is about two years later than if they had used a simpler example and/or more examples there.
kdridi_ has quit []
<Bicyclidine>
the iota thing is pointless, but otherwise it seems fine
Oladon has joined #lisp
<aeth>
The problem is that (1) you need to know about the fancier macro lambda lists and (2) the choice of using a list for the body is confusing
z3t0 has joined #lisp
thallia has quit [Ping timeout: 276 seconds]
thallia has joined #lisp
<pierpa>
reading the Hyperspec is a terrible way of learning about CL
ome has joined #lisp
<ome>
ahoy
<ome>
how is everyone?
<ome>
I am following PCL and it is getting boring.
<pierpa>
not worse than usual, ty. You?
<ome>
pierpa: I am not too bad myself.
<aeth>
pierpa: The HyperSpec is a reference for implementors, and many things (like destructuring-bind) imo seem to only make sense if you already know the form that it's talking about. It's imo unfortunate that it's essentially the sole reference of documentation to the language.
<ome>
Any lisp projects that need help? Maybe that way I can learn lisp more.
<aeth>
(And alternate references tend to just use the same source material as the HyperSpec.)
<stacksmith>
plerpa: At first it's impossible, then it's confusing and frustrating, then it makes more and more sense.
<Bicyclidine>
there's a link to destructuring lambda lists like two lines above the example
<stacksmith>
At this point I think I understand just about everything about destructuring lambda lists except for destructuring bind...
<aeth>
Bicyclidine: It's not a good way to teach destructuring-bind, though. You should have 6 or so examples, and build in complexity.
<Bicyclidine>
more examples would be ok i guess
<pierpa>
yes, it makes sense when one knows 99.9% of something and wants to check the remaining 0.1%
Tobbi has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<aeth>
stacksmith: Try refactoring something that has a lot of implicit variables in list structure.
<aeth>
where (car list) is foo, (cadr list) is bar, (caaddr list) is baz, (cadaddr list) is quux, etc.
<aeth>
i.e. (foo bar (baz quux))
<stacksmith>
aeth: It makes sense, I just haven't grokked it fully.
<stacksmith>
For instance, why doesn't let destructure...
<aeth>
stacksmith: like this? (let ((foo bar (baz quux)) some-list) (x 42)) ...)
<aeth>
That would be useful
<pierpa>
the more flexible a form the more error possibilities of error, and the more is difficult to give meaningful error messages
python476 has quit [Remote host closed the connection]
<pierpa>
oops, there's an error too much
<aeth>
It would also be useful if let used values like (let ((values x y) (floor 42 3)) ...)
<aeth>
setf uses values
markong has quit [Ping timeout: 252 seconds]
pfdietz_ has joined #lisp
<aeth>
You could get rid of destructuring-bind, multiple-value-bind, etc.
<stacksmith>
I haven't thought it through, but I think it should be completely compatible... plerpa: kind of agree, but then, it's pretty obvious when your let has even more braces than normal...
<aeth>
pierpa: I'm guessing it's not about errors, but about performance
<stacksmith>
It's compile-time...
<Bicyclidine>
there's a couple libraries that do what you describe
attila_lendvai has quit [Quit: Leaving.]
<Bicyclidine>
i like let being pretty simple, tho
<pierpa>
everyone has written this extended let macro. But none has gained much traction. And I don't see them used much
<aeth>
stacksmith: compilation performance! Almost irrelevant in 2018 for CL, of course.
<aeth>
But, I guess if you don't care about compilation performance at all you get C++
<pierpa>
the impact on performance should be negligible
<stacksmith>
General consensus seems to not worry too much about performance in macros etc. This is just a consp check.
ludston has quit [Ping timeout: 268 seconds]
<aeth>
Bicyclidine: I think all of the libraries do far, far, far too much, rather than simply combining in multiple-value-bind, destructuring-bind, and any other foo-bind that might also exist (are there others?)
<Bicyclidine>
too much but not enough makes you think
<aeth>
Apparently the others are handler-bind and restart-bind
<Bicyclidine>
that doesn't bind variables
thallia has quit [Ping timeout: 260 seconds]
vultyre has quit [Quit: Leaving]
fikka has quit [Ping timeout: 256 seconds]
<aeth>
stacksmith: Well, there *is* an ambiguity, too. When you're binding (values x y) are you binding the values x and y with a multiple-value-bind or are you binding values, x, and y with a destructuring-bind?
thallia has joined #lisp
<aeth>
(And both really should be merged into let and/or let*)
<pierpa>
so, 0.1 is not read in as exactly 0.1, but as something close
<Bicyclidine>
because only some numbers are representable exactly with binary floating point numbers
<Bicyclidine>
on account of they're binary
<pierpa>
yes, because, for example, 0.1 is not representable, but 0.5 is
<Bicyclidine>
please use this site or one of the other many similar sites to learn some basic facts about floating point arithmetic, it's good to know and also fascinating if you're a certain kind of fastidious
<stacksmith>
Values... I think it might not be completely insane to destructure values as a special case: values are also things that have no name, but perhaps could be bound?
<trocado>
ok, i'll read. thanks!
<Bicyclidine>
this is also not lisp specific, just to be clear
<trocado>
yes, i see that now
<stacksmith>
It almost makes sense to have a lambda-list-keyword &values...
<Bicyclidine>
the other thing is that 0.1 is probably a single
<Bicyclidine>
if you use a double it might not be as apparent that real numbers aren't real
<Bicyclidine>
stacksmith: how so
<aeth>
You might want the suffix "d0" like (* 0.1d0 13)
<aeth>
It will make the problems less obvious, but the problems with floating-point will still exist. The downside is that it will be slower and it will probably allocate unless you're careful (making it even slower).
<Bicyclidine>
i love problems
<stacksmith>
(defun foo (a b &values c d)...) (defun bar () (values 1 2)) (foo 10 11 (bar))
<Bicyclidine>
no
<Bicyclidine>
that violates the uh
<stacksmith>
It's not CL.
<Bicyclidine>
that means the compiler has to know that foo has that lambda list when it compiles the call
<pierpa>
that violates everything :)
<Bicyclidine>
which breaks redefinability and stuff
<Bicyclidine>
bad
<Bicyclidine>
you can have (defun foo (a b c d) ...) (multiple-value-call #'foo 10 11 (bar))
<stacksmith>
Yeah, like I said, I haven't really thought about it...
<aeth>
You'd only need a new defun
<Bicyclidine>
calling convention is hard
<aeth>
You *can* implement it (probably inefficiently) with a macro on top of defun that converts the lambda-list with &values into a &rest or &optional or whatever you're trying to go for
<stacksmith>
And also: why bother?
<aeth>
Actually, &optional would match what you're probably trying to go for
<aeth>
(defun foo (a b &optional c d ...) ...) (multiple-value-call #'foo 10 11 (bar))
<aeth>
Now it doesn't matter how many values bar returns, as long as it returns no more than what foo expects
<stacksmith>
interesting.
<stacksmith>
Of course now you can't have keywords...
fikka has joined #lisp
<Bicyclidine>
you can have optional and keyword, it's just that you'll hate yourself
<stacksmith>
That's what I mean...
<Bicyclidine>
if you already hate yourself you can save some time
<stacksmith>
With macros you could stick the whole thing into a destructuring list, I suppose.
thallia has quit [Ping timeout: 248 seconds]
<aeth>
I think you can mix &optional and &rest, so you can handle it arbitrarily. e.g. (defun foo (a b &optional c d &rest rest) (declare (ignore rest)) (values a b c d)) (multiple-value-call #'foo 42 43 (bar))
<aeth>
Now it handles bar returning any number of values
smurfrobot has joined #lisp
ludston has joined #lisp
thallia has joined #lisp
<aeth>
So you can just translate (a b &values c d) => (&optional c d &rest (gensym))
<aeth>
sorry, I mean: (a b &values c d) => (a b &optional c d &rest (gensym))
pagnol has quit [Quit: Ex-Chat]
fikka has quit [Ping timeout: 240 seconds]
smurfrobot has quit [Remote host closed the connection]
<Bicyclidine>
(multiple-value-bind (a b) ...) => (multiple-value-call (lambda (&optional a b &rest ignore) (declare (ignore ignore)) ...)
<Bicyclidine>
throw some more ellipses in there
<Bicyclidine>
just sprinkle randomly all over everything
<aeth>
s/throw some more ellipses in there/throw... some... more... ellipses... ("..." ...) in... there.../
<aeth>
ftfy
<Bicyclidine>
futfy
smurfrobot has joined #lisp
<stacksmith>
That's kind of nice.
<stacksmith>
It would be nice to make it easier to use multiple values...
shifty has joined #lisp
EvW1 has quit [Ping timeout: 265 seconds]
fikka has joined #lisp
fikka has quit [Ping timeout: 260 seconds]
findiggle has joined #lisp
smurfrobot has quit [Remote host closed the connection]
* |3b|
might also include the 100M count in label of table 5 for people who only skim the tables/figures, don't want them to think CL is that slow :)
<drmeister>
Good point
shka has joined #lisp
<beach>
|3b|: Where did you learn your proofreading skills?
* |3b|
just reads a lot
<beach>
Ah.
<drmeister>
I changed it to "Generic function call time (100M calls)."
<drmeister>
Bike: We completely forgot to mention that we added multithreading!
<beach>
I learned mine from more than three decades of proofreading papers by students and colleagues.
<shka>
good morning
<beach>
Hello shka.
<drmeister>
beach: You mentioned that we have a couple of days within which we can upload corrected versions - correct?
<beach>
I am not the one deciding, of course..
<beach>
But, usually, EasyChair allows you to upload modified versions after the deadline.
<pillton>
drmeister: The paper mentions CFFI support. Does it work the other way? Can you run two or more instances of clasp in the same process?
<beach>
It will take several days for the bidding process to be finished.
<drmeister>
pillton: I'm not sure what that means.
<drmeister>
Is there anything to say about multithreading other than we added it? It supports Bordeaux threads.
<beach>
drmeister: My advice is to upload a new version only if you think it might influence the decision by the program committee. If it is accepted, you have time to fix it until the deadline of the final version. If it is rejected, fixing it is a waste of time.
<beach>
drmeister: The jargon is that the paper should be ACCEPT-able.
<Zhivago>
Well, multi-threading by itself doesn't mean much -- so probably the kind of multi-threading is significant.
<drmeister>
What kinds of multi-threading are there? What kind did I implement? It's pthreads. Special variables are bound thread-locally. Hash-tables can be declared thread safe.
<Zhivago>
Co-operative, pre-emptive, real-time, etc, etc.
<drmeister>
Several internal databases were made thread safe - so it's not "trample town".
<pillton>
drmeister: You are advertising that clasp can compose with libraries that adhere to the C calling convention. Can I take a library written in clasp and call it from within another run time environment?
fikka has joined #lisp
marusich has quit [Ping timeout: 265 seconds]
<drmeister>
You would need to pass GC managed objects - so I'd say unless you can do that - no.
quazimodo has joined #lisp
dddddd has quit [Remote host closed the connection]
<drmeister>
Zhivago: So I guess I implemented pre-emptive multithreading?
shifty has quit [Ping timeout: 252 seconds]
<Zhivago>
Probably -- saying 'based on pthreads, supporting bordeaux' would probably answer all questions.
fikka has quit [Ping timeout: 240 seconds]
<Zhivago>
What invokes the GC in your system?
<Zhivago>
I guess it's the clasp allocator?
<beach>
I think that's a good guess.
fikka has joined #lisp
<drmeister>
Yeah - it's handled by the allocator.
ebzzry_ has quit [Read error: Connection reset by peer]
<drmeister>
Clasp supports boehm and MPS - and I don't worry about invoking the GC for either one.
fikka has quit [Ping timeout: 260 seconds]
<pillton>
drmeister: If you have already implemented the C callback API in CFFI then it is in theory possible to construct a foreign object pointing to a vector of callback functions. The question becomes more about how to start clasp and what assumptions it makes.
<drmeister>
pillton: I see what you mean. It's hard to answer the question though. Clasp supports the boehm and MPS garbage collectors. I don't know what assumptions they make.
Bike has quit [Quit: Lost terminal]
Murii has joined #lisp
dieggsy has quit [Ping timeout: 276 seconds]
findiggle has quit [Quit: ERC (IRC client for Emacs 27.0.50)]
<drmeister>
|3b|: What did you mean with this? " #7 also looks odd, (almost) same title as #1 but 2015, and don't see that title in els 2015 proceedings"
<drmeister>
I see - I added two additional references (pthreads and bordeaux) so the numbers changed
<drmeister>
Crap - we forgot to acknowledge Frank Goenninger for developing cffi - updating.
<beach>
That is one item that will not influence ACCEPT-ability.
fikka has joined #lisp
<drmeister>
I know - I'm just cleaning things up and adding folks editing suggestions.
smurfrobot has joined #lisp
<nydel>
i recently did a client update on quicklisp from inside itself. i haven't used asdf directly in a while. are others as well having trouble using quicklisp to acquire dependencies because of incompatibility with asdf3/latest? i'm trying to find the correct documentation/approach to loading systems, thank you for bearing with my sloppy explanation here
fikka has quit [Ping timeout: 248 seconds]
Pixel_Outlaw has quit [Remote host closed the connection]
<pfdietz>
Yes, there's been trouble with asdf lately.
<nydel>
i know this is common lisp channel not ql/asdf tech support. but the documentation is lacking.
fikka has joined #lisp
<nydel>
pfdietz: it's really great to hear that, thank you, i wasn't sure. almost all my programs are kind of hung up because they want to tell quicklisp to load, say bordeaux-threads, and quicklisp tries for a version of b-t that it is unable to load with the asdf it has
Oladon has quit [Quit: Leaving.]
<pillton>
nydel: I think you can go back in client time with (quicklisp-client:install-client :version "2017-03-06").
<pillton>
nydel: Use (quicklisp-client:available-client-versions) to get a (version . url) alist.
nydel has quit [Read error: Connection reset by peer]
smurfrobot has quit [Ping timeout: 248 seconds]
nydel has joined #lisp
damke_ has joined #lisp
igemnace has quit [Quit: WeeChat 2.0.1]
quazimodo has quit [Ping timeout: 240 seconds]
eschatologist has quit [Ping timeout: 264 seconds]
eschatologist has joined #lisp
damke has quit [Ping timeout: 264 seconds]
groovy2shoes has quit [Quit: moritura te salutat]
groovy2shoes has joined #lisp
<jack_rabbit>
Can anyone confirm an issue with current quicklisp drakma dist? Trying to get any https site: "Unknown &KEY argument: :VERIFY" when the library tries to call CL+SSL:MAKE-SSL-CLIENT-STREAM
<phoe>
"You can do surprising things when you have 64 kilobytes of fast RAM on one card"
<whoman>
=) =)
<whoman>
curious what "returning to the tower of babel" means
<jackdaniel>
if I had to guess it's about spread of different programming languages
yeoh has joined #lisp
<whoman>
yeah - but strange first text in a special lisp issue
<phoe>
it had its right to be strange back then
<phoe>
computing was niche, there was no real mainstream as it is today
fikka has joined #lisp
<whoman>
hm i dont know, there are a lot of ads in there that would suggest otherwise
flamebeard has joined #lisp
<Zhivago>
What was the strange first text?
<whoman>
sorry -"but i find it strange, that the first text in the lisp special edition magazine, is 'returning to the tower of babel'"
<whoman>
perhaps it is a contrast of lisp, i am unable to read the whole magazine. also perhaps it is a reference to different kinds of "lisping" in the magazine (i see pattern matching, and some other things...)
<Zhivago>
Building a tower so that you can reach heaven?
yeoh has quit [Quit: Leaving]
<whoman>
i suppose =)
<phoe>
before getting struck by God and, instead of building the tower, focusing on the Lisp-1 vs Lisp-2 debate?
Karl_Dscc has quit [Remote host closed the connection]
fikka has quit [Ping timeout: 256 seconds]
<nydel>
jackdaniel: what will you do about drakma? i'm having similar issues with drakma itself and other things. manual clone and load with asdf?
<phoe>
(I think we're going into #lispcafe zone with this)
<nydel>
jack_rabbit: sorry jackdaniel
<Zhivago>
Well, there's also the metacircular tower, although I'm not sure if they're referring to that.
<jack_rabbit>
nydel, No, my mistake was having a local copy that shadowed the quicklisp dist.
<nydel>
understood jack_rabbit i meant to address the first message to jackdaniel but i autocompleted incorrectly
<jack_rabbit>
nydel, Once I removed that local copy from the search path, quicklisp pulled the most recent version and loaded it. It is now working as expected.
<jack_rabbit>
You sure? I was the one with the drakma issue.
<nydel>
haha i'm NOT sure. sorry it's late.
<nydel>
i meant to address it to you.
<nydel>
in SBCL latest with quicklisp latest? hum.
<jack_rabbit>
yeah. What's the error?
fikka has joined #lisp
vlatkoB has joined #lisp
<nydel>
illegal function call in v2.0.4 drakma.asd - ((load-system test-op) (:drakma-test (EQL <#system "drakma">))
Tobbi has joined #lisp
<nydel>
immediate on ql:quickload 'drakma
<jack_rabbit>
eww.
<nydel>
not pretty. i'm realizing i'm too wiped out to be troubleshooting and not make mistakes. i will triple-check that i did everything right in the morning
<jack_rabbit>
are you missing asdf?
thallia has quit [Ping timeout: 268 seconds]
<nydel>
not //exactly// i mean i was wondering is this because this drakma is trying asdf3 and quicklisp does not do that?
<nydel>
that's the problem with most my other packages that i depend on (bordeaux-threads, hunchentoot, others) but usually it's a clearer "get asdf3.1 or higher to eval this to repl"
ludston has quit [Read error: Connection reset by peer]
thallia has joined #lisp
<jack_rabbit>
nydel, invalid function call signals to me that it's trying to evaluate a form as a function call when it should be part of args to a macro expansion.
<jack_rabbit>
(in this case)
<jack_rabbit>
since it's in the .asd file, it seems like there's something odd about your ASDF package.
<jack_rabbit>
What do you usually do when you get the "get asdf3.1 or higher to eval this to repl" message?
ludston has joined #lisp
<nydel>
abort to top, there's no other option. you could "retry" or "continue" 2 or 3 times but you end up repeating the same
d4ryus1 is now known as d4ryus
<jack_rabbit>
Yes, but is there something you've done to load the proper asdf?
<nydel>
it should be the asdf that is part of the current ql-client/dist ... but i may have made a mistake in which REPL i'm using, sorry i've been working for too long without a break --
<nydel>
if you try (ql:quickload 'bordeaux-threads) do you get 'asdf3.1 or higher please' ? if you would check
<jack_rabbit>
No, it loads properly
<jack_rabbit>
Have you tried (require "asdf")
<jackdaniel>
quicklisp first tries (require "ASDF") and if it doesn't help it loads bundled ASDF 2.26
<jack_rabbit>
mmmm
<jack_rabbit>
maybe an old CL?
<jackdaniel>
so that means that you have sbcl build which doesn't have bundled ASDF
<jack_rabbit>
right.
<nydel>
it is old sbcl. sorry. 1.0.1 ... need to get an update on this pubnix.
<jackdaniel>
it doesn't have to be old, ASDF is a contrib
<nydel>
on my local machine the system loads.
<jackdaniel>
oh, this is very old indeed
shka has left #lisp ["Konversation terminated!"]
<whoman>
=P
<phoe>
1.0.1 oh my gods
<nydel>
i'm a bit shocked it's that old.
<jack_rabbit>
nydel, where did you get that?
<phoe>
nydel: preserve it first
<phoe>
for museum purposes
<jack_rabbit>
lol
<phoe>
then upgrade ity
mishoo has joined #lisp
<jack_rabbit>
jackdaniel, According to the quicklisp site, all common CL distributions come with ASDF that's at least 3.1, Did I misunderstand what you mean by "contrib?"
<nydel>
drakma loaded as well. i've been moving quicklisp/asdf and packages around on an ancient sbcl.
<nydel>
for like 3.5 hours.
<nydel>
take breaks every 2h30min everyone, please.
<whoman>
^_^_^
<jack_rabbit>
nydel, what pubnix, out of curiosity
<jackdaniel>
jack_rabbit: you may or may not build your CL with ASDF
<jack_rabbit>
jackdaniel, ahhhh.
<jackdaniel>
because ASDF is just a library
<jack_rabbit>
Yes, I understand now.
<jackdaniel>
and it is not maintained by sbcl (or other implementation) developers
<whoman>
jack jack
<nydel>
SDF.org ... but it's the ONE system that is on its own and not part of the cluster.
<phoe>
ooooh, sdf
<nydel>
it's my responsibility on this one to request updates.
<phoe>
tell them to upgrade ecl as well.
<phoe>
they have 15.x over there AFAIK, if not 13.x
<jack_rabbit>
nydel, oh, neat. I'm an SDF'er as well.
<nydel>
ah! i love sdf. i do everything at the meta-array though because only clisp on cluster (security &or pkgsrc/netbsd8 beta related)
<jack_rabbit>
mmm
<nydel>
do you have a gopherhole or webspace there i might look at?
* phoe
runs off to work
smurfrobot has quit [Remote host closed the connection]
<jack_rabbit>
nydel, not yet on the gopherhole. I'm actually working on some of that now. my webspace I host elsewhere.
<nydel>
gopher has gotten so great lately. everyone sick of w3c is joining up and testing the limits. floodworks, sdf, tx.god.jp, bongusta agregator if you feel like poking around at by-date stuff
raynold has quit [Quit: Connection closed for inactivity]
visof has joined #lisp
visof has joined #lisp
visof has quit [Changing host]
wxie has joined #lisp
wxie has quit [Client Quit]
dddddd has joined #lisp
Chream_ has quit [Read error: Connection reset by peer]
Chream_ has joined #lisp
Chream_ has quit [Read error: Connection reset by peer]
<schoppenhauer>
hi. is it possible to mirror the quicklisp repo and use this mirror to install packages?
Chream_ has joined #lisp
<jackdaniel>
schoppenhauer: yes, but you have to create a proper structure and directory information
<jackdaniel>
ql allows installing distributions from remote locations
<schoppenhauer>
jackdaniel: how hard is this / how long does it take?
ramosus has left #lisp [#lisp]
<schoppenhauer>
the main problem I want to solve is to make my build process reproducible in some way.
<schoppenhauer>
and package locations and stuff change over time.
<Shinmera>
Just fix QL to a specific dist version then
Arcaelyx has joined #lisp
<flip214>
when building a binary (via CLON), libosicat.so is searched for in the ~/.cache/common-lisp/.../osicat/... path. having the .so in the current directory and setting LD_LIBRAY_PATH doesn't work. any idea how to get that working?
<jackdaniel>
schoppenhauer: fairly easy
<schoppenhauer>
Shinmera: what guarantees me that this specific dist version is still available in, say, 20 years?
<flip214>
Ideally, I'd like to have the SBCL core search for libosicat.so in a configurable path.
<Shinmera>
schoppenhauer: Xach's grace.
<schoppenhauer>
jackdaniel: is it documented anywhere?
<schoppenhauer>
Shinmera: what?
<jackdaniel>
flip214: most safe solution is to unload libraries before dumping the binary and load them again in init
<jackdaniel>
then you may configure exact path with cffi
<Shinmera>
schoppenhauer: You'll just have to trust Xach that it will still be there. What makes you think anything will still be there in 20 years? That's an eternity in software.
<flip214>
jackdaniel: you think that will work with libosicat as well?
<jackdaniel>
flip214: I don't see why wouldn't it
<Shinmera>
And two eternities in the web
<schoppenhauer>
Shinmera: that is why I want to mirror it
<flip214>
jackdaniel: because "osicat" sounds a bit too low-level for that to me
<jackdaniel>
flip214: I'd use cffi mechanism for unloading
<Shinmera>
schoppenhauer: My point is, since your requirements seem to be "how hard" and "how long does it take", fixing a version is going to be quite a bit easier than mirroring a dist.
<jackdaniel>
that's what we do for deliveries at least (and it works fairly well)
<flip214>
according to the page linked above I'd really want the "dont-save is true" part
<flip214>
but that means changing QL or so
<jackdaniel>
as I said - portable and safe solution is to unload all shared objects with cffi and load them back in init (of course that require cleanup and init functions in place, so one could say that it kills the fun with lisp ;)
<jmercouris>
so usocket is blocking read right? if I want to implement a "server", I need to create a new thread and listen on that, or am I wrong?
<jackdaniel>
jmercouris: you may check if data is available with function `listen'
<jmercouris>
is there some sort of usocket asynchronous callback hook or something perhaps?
<Shinmera>
jmercouris: No
<jmercouris>
Shinmera: no as in "you are correct", or no as in "you are wrong"?
<flip214>
Shinmera: because I only heard about that right now.
<Shinmera>
There is no async socket stuff.
<Shinmera>
Because it's not portable.
<jmercouris>
Ok
<jmercouris>
bt threads is portable no?
<Shinmera>
There are libraries to wrap around libev or whatever.
<Shinmera>
Sure
<jackdaniel>
I like clon because it provides good abtraction for cli options and for building binaries
<jmercouris>
so it is possible to make it portable though?
<Shinmera>
You can make threaded IO portable sure
<jmercouris>
jackdaniel: you mean `socket-listen` right?
<Shinmera>
If I remember correctly libev etc. don't work on all platforms, and are thus not portable in that sense.
<Shinmera>
But if you don't need actual async IO and threads will do, then it's a breeze
<jmercouris>
threads are all I need
<jmercouris>
I just don't want to block on the "main" thread
<Shinmera>
Sure, then thread away.
<jackdaniel>
jmercouris: if usocket gives you a stream, then listen should be the function you want
<jmercouris>
since I'm not so familiar with this kind of socket, can I listen and send on the same port?
<jmercouris>
how does that work exactly, lets say I have server/client A, server/client B
<jmercouris>
can they communicate with each other over the same channel, or do I need two ports?
<Shinmera>
A TCP connection represents a bivalent stream between two applications.
<jmercouris>
I see, so I only need one port/address
<flip214>
jackdaniel: *foreign-libraries*
schweers has joined #lisp
rstandy has joined #lisp
<Shinmera>
Well, you have one side that acts as the server side that accepts an arbitrary amount of applications. This server designates the port that is used.
<jmercouris>
So, my application binds to a specific TCP port, it takes it, and then clients can connect to that port and listen, right?
<Shinmera>
Sure.
<flip214>
jackdaniel: would you point me to your code that extracts the important data from this list, please?
<jmercouris>
Ok, I'm starting to visualize this
<jmercouris>
Right the reserved ports/space etc
<Shinmera>
Though "listen" is usually a term reserved for "listening for connections", which is what the server does.
figurehe4d has quit [Ping timeout: 276 seconds]
<jackdaniel>
flip214: I can't, sorry
<jackdaniel>
I could write it again for you if I had time, but I'm quite busy atm
<jmercouris>
Shinmera: so the server "listens" for connections and "reads" data from the port
<jackdaniel>
basically map close-foreign on this list
<jmercouris>
Shinmera: what happens if some client sends data to a specific port, but the server is not reading it, does it get lost? buffered? sent infinitely until it is recieved?
<jmercouris>
right, it is TCP, so it will wait for that confirmation
<flip214>
jackdaniel: the important part is to retain the correct information to _load_ them again.... that's what I'm asking ;/
<jackdaniel>
well, I know what libraries I need, so I load them one by one
<jackdaniel>
cl+ssl has a reload function though
<Shinmera>
jmercouris: It doesn't "read" data from the port, it reads data from the socket stream.
<jackdaniel>
check out define-foreign-library macro
<Shinmera>
jmercouris: The data is usually buffered, and the connection lives until it is terminated, or there's a timeout.
<jmercouris>
and the socket-stream is bound to a port and addres?
<jmercouris>
Shinmera: the data is buffered by whom?
<Shinmera>
The OS.
<jack_rabbit>
generally
<Shinmera>
The socket is bound to a port and address. It presents you with a stream to read/write from/to.
<jmercouris>
Ok, so it's a matter of terminology
<jmercouris>
I think I get it
<jmercouris>
I was just using the wrong word
<Shinmera>
The socket is a representation of a connection. The stream is a representation of a channel to exchange data over that connection.
<jmercouris>
Ok, that makes sense
<jmercouris>
so you said the socket, or connection, will remain open until time out or terminated
<Shinmera>
Yes.
<jmercouris>
what if I would like to have a persistent connection?
<jmercouris>
do I have to keep sending keep-alive type messages?
<Shinmera>
If it's local, probably not. If it's over the net, yes.
<jmercouris>
or is there a timeout length of infinity?
<jmercouris>
ok
<jmercouris>
ok, so just a recap to make sure I am heading in the right direction here
<jmercouris>
I will have my main lisp application, my server which will launch the clients
<jmercouris>
the server will bind that port so that no other program may use it
<jmercouris>
I can have an infinite amount of clients that connect to that port to listen or send data
SaganMan has joined #lisp
<jmercouris>
when a new client connects to a socket, is there a new stream, or are they all using the same stream?
<Shinmera>
Hold on, I'll bbl
<jmercouris>
ok
<jmercouris>
no rush
<SaganMan>
Morning!
<jack_rabbit>
each client has their own stream, and the server has many streams, one for each client.
<jack_rabbit>
jmercouris^
<jmercouris>
jack_rabbit: ok, I see, that is so the server can know who is sending what?
<jmercouris>
SaganMan: morning
<jack_rabbit>
Yes. Each stream is like a tube for passing data. Each client holds an end, and the server holds the other... a bunch of them.
<jack_rabbit>
it's a series of tubes.
<jmercouris>
lol nice
<jmercouris>
ok, I think I have enough to work with, thanks everyone
<jack_rabbit>
o/
<SaganMan>
I don't know how to communicate with server.
<SaganMan>
jack_rabbit: each server has it's own rules on how they communicate?
<jack_rabbit>
SaganMan, sure. That's what we would call a "protocol"
<SaganMan>
jack_rabbit: IP UDP, TCP?
<jack_rabbit>
Those are various protocols, yes.
<jack_rabbit>
very common ones at that.
<flip214>
SaganMan: other, more high-level, protocols are FTP and HTTP.
Kundry_Wag has joined #lisp
<jmercouris>
also protocol has another more abstract meaning, it just an agreement between two entities about how an operation will be performed
<jmercouris>
so, for example in java, where we don't have multiple inheritance, we use interfaces, or protocols to agree upon certain behavior
<jmercouris>
so if an object implements an interface, it agrees to be bound by the protocol as defined in the interface
attila_lendvai has quit [Read error: Connection reset by peer]
<jack_rabbit>
jmercouris, I have a feeling that that term has been inherited from the message-passing style of OOP.
attila_lendvai has joined #lisp
attila_lendvai has joined #lisp
attila_lendvai has quit [Changing host]
<jmercouris>
I don't know for sure, but that sounds pretty reasonable
<jack_rabbit>
Where the idea was that objects would speak with each other through protocols.
<jmercouris>
Yeah, it was also a word before computer science, and its application in CS is consistent with the real word
<jmercouris>
that's what I meant when I said "in the abstract sense", so it is hard to say from where it was pilfered, but yeah :D
Kundry_Wag has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
<jack_rabbit>
Yeah, I wasn't trying to contradict you. Just speculating about the origin.
attila_lendvai has quit [Read error: Connection reset by peer]
attila_lendvai has joined #lisp
<jmercouris>
no, yeah I gotcha :)
shifty has quit [Ping timeout: 268 seconds]
rstandy` has joined #lisp
trn has quit [Excess Flood]
trn has joined #lisp
rstandy has quit [Ping timeout: 240 seconds]
Murii has quit [Ping timeout: 256 seconds]
<schoppenhauer>
Shinmera: ok, you are probably right about mirroring, etc. … how can I fix a quicklisp version?
<schoppenhauer>
hm ok. no. this is just for moving back in time.
<jack_rabbit>
What is the issue?
Mandus has quit [Ping timeout: 276 seconds]
Mandus has joined #lisp
<flip214>
when DRAKMA gets an answer with "Content-Type: application/json;charset=UTF-8", this is returned as a vector of bytes. Can I receive a string directly, without using BABEL explicitly to convert?
<flip214>
there's no :external-format or so...
<flip214>
wait, there is, according to the docs...
dieggsy has joined #lisp
Chream_ has quit [Read error: Connection reset by peer]
Chream_ has joined #lisp
attila_lendvai has quit [Read error: Connection reset by peer]
<flip214>
well, *text-content-types* doesn't include application/json.
attila_lendvai has joined #lisp
attila_lendvai has joined #lisp
attila_lendvai has quit [Changing host]
Arcaelyx has quit [Ping timeout: 248 seconds]
fikka has quit [Ping timeout: 240 seconds]
<jack_rabbit>
Yeah, I can't help you there. Sorry.
fdund has joined #lisp
shrdlu68 has joined #lisp
fikka has joined #lisp
rumbler31 has quit [Remote host closed the connection]
<whoman>
i am not sure it matters, the string can be vectored with or without matching the content type of the content type.......... ?!
<schoppenhauer>
hm. ok, how can I install a specific version of quicklisp?
<Shinmera>
schoppenhauer: going back in dist time is exactly what it means to fix a specific version
<schoppenhauer>
Shinmera: It is?
<schoppenhauer>
Shinmera: I do not want to have to install a former version
Arcaelyx has joined #lisp
<whoman>
then why would you ask how to install a specific version....??
<jack_rabbit>
If you want to install a specific version that's not a former version, then you want the most recent version.
<Shinmera>
schoppenhauer: You said you wanted reproducible builds, which means fixing the version of the quicklisp ecosystem, yeah? How is that different from installing a (former) specific version?
Murii has joined #lisp
<schoppenhauer>
Shinmera: The problem I see is that I have to install the most current version first, before I can fix some version
jstypo has quit [Read error: Connection reset by peer]
<Xach>
schoppenhauer: no - the installer can accept the url of the version to use as well.
<Shinmera>
You don't, though.
<Xach>
schoppenhauer: also, the initial install really only fetches a few smallish index files - changing versions is also just downloading another set of smallish index files. it's fairly lightweight.
<Xach>
schoppenhauer: there is a program called "qlot" that aims to automate this kind of thing. i haven't tried it myself but it seems promising.
<schoppenhauer>
Xach: you mean I can pass the url to quicklisp-quickstart:install?
<Xach>
schoppenhauer: yes
<schoppenhauer>
Xach: ok. then I will try that.
<Xach>
schoppenhauer: the keyword is :dist-url
<schoppenhauer>
Xach: thx
rumbler31 has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
fdund has quit [Quit: .]
mood has quit [Quit: Gone.]
mood has joined #lisp
makomo_ has quit [Ping timeout: 255 seconds]
fikka has quit [Ping timeout: 264 seconds]
mood has quit [Client Quit]
jstypo has joined #lisp
learning has quit [Remote host closed the connection]
mood has joined #lisp
Kundry_Wag has joined #lisp
makomo_ has joined #lisp
SaganMan has quit [Ping timeout: 256 seconds]
Chream_ has quit [Ping timeout: 256 seconds]
python476 has quit [Ping timeout: 256 seconds]
dieggsy has quit [Remote host closed the connection]
rstandy` has quit [Quit: ERC (IRC client for Emacs 24.5.1)]
rstandy has joined #lisp
rstandy has quit [Remote host closed the connection]
rstandy has joined #lisp
Chream_ has joined #lisp
attila_lendvai has quit [Read error: Connection reset by peer]
Chream_ has quit [Read error: Connection reset by peer]
<schoppenhauer>
Xach: may I send you a feature request? ^^ when using ql:add-to-init-file, it should be possible to pass an argument like :interactive nil, such that in the end, it does not ask for pressing enter
ghard has joined #lisp
attila_lendvai has joined #lisp
attila_lendvai has joined #lisp
attila_lendvai has quit [Changing host]
BigSafari has joined #lisp
fikka has joined #lisp
visof has quit [Ping timeout: 260 seconds]
Chream_ has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
Mandus has quit [Ping timeout: 256 seconds]
attila_lendvai has quit [Read error: Connection reset by peer]
papachan has joined #lisp
fikka has quit [Ping timeout: 256 seconds]
attila_lendvai has joined #lisp
slyrus has joined #lisp
JenElizabeth has joined #lisp
Bike has joined #lisp
rstandy has quit [Quit: ERC (IRC client for Emacs 24.5.1)]
pfdietz_ has quit [Ping timeout: 256 seconds]
rumbler3_ has joined #lisp
<rumbler31>
jmercouris: usocket wraps each implementations own version of socket support. You might have better luck getting unix domain sockets by digging into a specific implementation
rumbler3_ has quit [Ping timeout: 248 seconds]
Kundry_Wag has joined #lisp
<jmercouris>
rumbler31: Yeah, I will go down that route in a little bit, for now I am going to just start development, and the only part that will need to change is the socket interface
<jmercouris>
rumbler31: usocket is definitely not my first choice, nor am I familiar with those kinds of sockets, but I don't imagine it would be too hard to adapt the interface
kozy has quit [Ping timeout: 256 seconds]
<rumbler31>
what kinds of sockets are you familiar with
Kundry_Wag has quit [Remote host closed the connection]
<jmercouris>
unix type sockets
<jmercouris>
those were the only kind I was familiar with actually, I didn't even know what "BSD style sockets" were until a few days ago
thodg has joined #lisp
<jmercouris>
I've never had to do much in the way of networking in my life
Mandus has joined #lisp
Kaisyu has quit [Quit: Connection closed for inactivity]
nowhereman_ has joined #lisp
Cymew has quit [Remote host closed the connection]
<Xach>
schoppenhauer: you can use without-prompting for that.
<Xach>
schoppenhauer: which works for any quicklisp prompt
<rumbler31>
jmercouris: are you writing code to talk to other applications that you didn't write? or are you in control of all sides of the communication channel
<jmercouris>
rumbler31: I am in control of all sides
<jmercouris>
rumbler31: I'm writing a lisp core/server, and then a graphical client in another language
Cymew has quit [Ping timeout: 255 seconds]
makomo has joined #lisp
makomo_ has quit [Ping timeout: 256 seconds]
_cosmonaut_ has quit [Ping timeout: 240 seconds]
learning has joined #lisp
learning has quit [Remote host closed the connection]
learning has joined #lisp
Kundry_Wag has joined #lisp
rippa has joined #lisp
<rumbler31>
I found usocket to be really approachable
<rumbler31>
and wireshark to help me verify my implementatinos
orivej has joined #lisp
chenbin has joined #lisp
Vicfred has quit [Quit: Leaving]
<jmercouris>
aha I didn't think of using wireshark for debugging, that is an excellent idea
<jmercouris>
I will do that
wheelsucker has joined #lisp
flamebeard has quit [Quit: Leaving]
zacts has quit [Quit: WeeChat 1.9.1]
zacts has joined #lisp
no26 has quit [Quit: Leaving]
Kundry_Wag has quit [Remote host closed the connection]
slyrus has quit [Ping timeout: 248 seconds]
orivej has quit [Ping timeout: 248 seconds]
saki has quit [Ping timeout: 248 seconds]
JenElizabeth has quit [Remote host closed the connection]
JenElizabeth has joined #lisp
saki has joined #lisp
JenElizabeth has quit [Remote host closed the connection]
aindilis has joined #lisp
BitPuffin has joined #lisp
ckonstanski has joined #lisp
<rumbler31>
note that if you're trying to debug localhost-only traffic on windows you can't inspect it, because windows doesn't promote localhost traffic to the level where it can be observed by wireshark
Kundry_Wag has joined #lisp
sjl has joined #lisp
smaster has quit [Ping timeout: 260 seconds]
<schoppenhauer>
Xach: sorry, what is without-prompting? I can't find something meaningful in google under "without-prompt"
<rumbler31>
and for localhost only traffic, the only thing you need are two tcp sockets, so 127.0.0.1 for the ip, and any unused port for your application. A common implementation feature is that you can ask the os to give you an unused port number on socket instantiation, s.t. you can pass to the 2nd socket instantiation
shrdlu68 has quit [Read error: Connection reset by peer]
smaster has joined #lisp
python476 has joined #lisp
fikka has quit [Ping timeout: 256 seconds]
Mandus has quit [Ping timeout: 276 seconds]
Mandus has joined #lisp
Mandus has quit [Ping timeout: 260 seconds]
Mandus has joined #lisp
anon_ has quit [Ping timeout: 248 seconds]
Kundry_Wag has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
visof has quit [Ping timeout: 256 seconds]
mathrick has quit [Ping timeout: 256 seconds]
heurist_ is now known as heurist
Kundry_Wag has quit [Ping timeout: 248 seconds]
varjagg has joined #lisp
Kundry_Wag has joined #lisp
learning has quit [Remote host closed the connection]
voidlily has quit [Remote host closed the connection]
anon has joined #lisp
anon is now known as Guest16495
warweasle has joined #lisp
Achylles has quit [Quit: Leaving]
learning has joined #lisp
<jmercouris>
rumbler31: I'm doing MacOS, so I should be OK
rumbler3_ has joined #lisp
thodg has quit [Ping timeout: 252 seconds]
attila_lendvai has quit [Read error: Connection reset by peer]
raynold has joined #lisp
attila_lendvai has joined #lisp
rumbler3_ has quit [Ping timeout: 264 seconds]
Oladon has joined #lisp
smaster has quit [Ping timeout: 240 seconds]
Karl_Dscc has joined #lisp
chenbin has quit [Ping timeout: 240 seconds]
hhdave has quit [Ping timeout: 276 seconds]
smaster has joined #lisp
Chream_ has quit [Ping timeout: 256 seconds]
SamSkulls has quit [Read error: Connection reset by peer]
smaster has quit [Ping timeout: 276 seconds]
trocado has joined #lisp
heurist` has joined #lisp
SamSkulls has joined #lisp
schweers has quit [Ping timeout: 260 seconds]
smaster has joined #lisp
heurist has quit [Ping timeout: 256 seconds]
juan-reynoso has joined #lisp
jsn` has joined #lisp
saki has quit [Read error: Connection reset by peer]
drewc has quit [Ping timeout: 256 seconds]
mlf has joined #lisp
fikka has joined #lisp
saki has joined #lisp
rumbler3_ has joined #lisp
jonh has left #lisp ["WeeChat 0.4.2"]
rumbler3_ has quit [Remote host closed the connection]
zooey has quit [Ping timeout: 255 seconds]
Kundry_Wag has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
zooey has joined #lisp
drewc has joined #lisp
nosaj88 has joined #lisp
nosaj88 has quit [Remote host closed the connection]
scymtym has quit [Ping timeout: 255 seconds]
BitPuffin has quit [Remote host closed the connection]
mathrick has joined #lisp
stacksmith has joined #lisp
rabbit_05 has quit [Ping timeout: 255 seconds]
smaster has quit [Ping timeout: 248 seconds]
Kundry_Wag has quit [Remote host closed the connection]
rumbler3_ has joined #lisp
Kundry_Wag has joined #lisp
smaster has joined #lisp
rumbler3_ has quit [Ping timeout: 256 seconds]
pfdietz_ has joined #lisp
pfdietz_ has quit [Ping timeout: 256 seconds]
LocaMocha has quit [Ping timeout: 264 seconds]
pfdietz_ has joined #lisp
<pfdietz_>
Nvm
fikka has quit [Ping timeout: 264 seconds]
<whoman>
oh yeah. we were all worried there
Pixel_Outlaw has joined #lisp
<jmercouris>
it always feels like I'm missing context
<jmercouris>
what do you mean "Nvm"? nevermind what?
<whoman>
context is definately missing there
fikka has joined #lisp
pfdietz_ has quit [Ping timeout: 276 seconds]
visof has joined #lisp
<nowhereman_>
I was still happily using Elephant in a 2015 project and recently discovered it's out of Quicklisp
<jmercouris>
You can still download it manually and add it to your project search path dir
pfdietz_ has joined #lisp
<nowhereman_>
Does anyone know why?
<jmercouris>
I can't remember the name for that directory, but you know what I mean
<phoe>
Xach: ^
<jackdaniel>
jmercouris: he most likely mistakenly wrote it here (instead of #sbcl, where some question regarding hppa support was issued)
<pjb>
nowhereman_: basically, QL systems are filtered with the most unstable implementation, that has a new version every month, so you have systems that are rejected every month.
<jackdaniel>
nowhereman_: I'd bet that it either broke on new ASDF or got incompatible with one of its dependencies
pfdietz_ has quit [Ping timeout: 260 seconds]
smaster has quit [Ping timeout: 268 seconds]
fikka has quit [Ping timeout: 260 seconds]
pfdietz_ has joined #lisp
<pfdietz_>
This irc client made me think I had sent something unintended.
smaster has joined #lisp
<jackdaniel>
hm, I wonder if with-gensyms can be substituted with with-clean-symbols (so we don't pollute namespace yet we don't need so many ugly commas)
<jackdaniel>
with-clean-symbols as defined in cmucl for instance (and a few other places since it is public domain)
nowhereman_ has quit [Read error: Connection reset by peer]
<phoe>
jackdaniel: no problem, as long as you don't `(foo ,foo)
nowhere_man has joined #lisp
<jackdaniel>
right, one should keep in mind, that we may want to use a symbol which is meaningful globally and the name may clash
<jackdaniel>
thank you, this is a very good argument against such substitution
<jackdaniel>
so the concern is more `(progn (list list)) sutuation, because list function symbol will be substituted too
fikka has joined #lisp
dieggsy has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
damke_ has joined #lisp
attila_lendvai has quit [Read error: Connection reset by peer]
Kundry_Wag has joined #lisp
attila_lendvai has joined #lisp
damke has quit [Ping timeout: 264 seconds]
pfdietz_ has quit [Ping timeout: 240 seconds]
attila_lendvai has quit [Read error: Connection reset by peer]
thallia has quit [Ping timeout: 260 seconds]
attila_lendvai has joined #lisp
attila_lendvai has joined #lisp
attila_lendvai has quit [Changing host]
thallia has joined #lisp
pfdietz_ has joined #lisp
attila_lendvai has quit [Read error: Connection reset by peer]
smaster has quit [Ping timeout: 240 seconds]
attila_lendvai has joined #lisp
attila_lendvai has joined #lisp
attila_lendvai has quit [Changing host]
smaster has joined #lisp
pfdietz_ has quit [Ping timeout: 276 seconds]
<phoe>
that one, too
<stacksmith>
Is anyone familiar with the history of multiple values in CL? Is it an after-the-fact bolt-on? There is a curious asymmetry with it - only a small set of specially-designed forms handles multiple values, and generally to convert it to a form usable by the rest of Lisp...
pfdietz_ has joined #lisp
<Bike>
how would a coherent version of values work, do you think?
<phoe>
stacksmith: there's a reason the first one is called "primary value"
<phoe>
in many cases, it is enough, just like with GETHASH
<phoe>
but in GETHASH's case, if you want to check if a value actually is present for the given key, you peek at the secondary value.
<stacksmith>
I am not questioning the need for it, or it in itself. I am curious about how it came about.
<phoe>
hm hmmm, I see.
<stacksmith>
Looking at the entire lambda-list system and even ad-hoc destructuring system for what goes _into_ a function, there seems to be an impedance mismatch for what comes out.
<stacksmith>
What comes out lacks the same rigorousness as I see it. There is no introspective description that lambda-lists provide, and no structure that is metaprogrammable. All you can do is bind it to a flat set of values, assign or pass on...
<stacksmith>
phoe: thanks for the link.
<Bike>
i'm really not sure what this metaprogrammable thing would look like, so i'm curious
<phoe>
stacksmith: you can always go the Java way.
<Bike>
personally i like the "unboxed vectors" i'm vaguely aware haskell has, but that would change the semantics a lot
<phoe>
define class called ComputationResult, return its instance, and then access the slots of that result in your client function.
<stacksmith>
Again - not criticizing or complaining.
Cymew has joined #lisp
attila_lendvai has quit [Read error: Connection reset by peer]
Cymew has quit [Ping timeout: 256 seconds]
pfdietz_ has quit [Ping timeout: 276 seconds]
attila_lendvai has joined #lisp
attila_lendvai has joined #lisp
attila_lendvai has quit [Changing host]
attila_lendvai has quit [Read error: Connection reset by peer]
vlatkoB has quit [Remote host closed the connection]
<stacksmith>
I've been spending a lot of time studying lambda lists and destructuring... It seems like there may be a smart way to create a symmetrical return structure description that would play nice with the lambda-lists on the other side. Like declaring a return lambda list that macros can use to shuffle values around, for instance. Again, not a criticism of CL, just one of those things that is spinning in my brain waiting for a good reaso
<jackdaniel>
stacksmith: multiple values must be returned that way if we want to make possible certain optimizations without unnecessary consing
attila_lendvai has joined #lisp
attila_lendvai has joined #lisp
attila_lendvai has quit [Changing host]
<pjb>
stacksmith: of course. When you define a grammar, you can use it parse as well as generate words of the language.
<jackdaniel>
(i.e more than one register may be designated for a return value)
<jackdaniel>
if it had a structure for multiple values you'd have to cons it on return
attila_lendvai has quit [Read error: Connection reset by peer]
<stacksmith>
jackdaniel: I get that it's an abstraction of some registers or stacked values that are returned. However the front end of parameters passed in is not that different
<pjb>
stacksmith: also, have a look at: make-parameter-list and make-flat-argument-list in COM.INFORMATIMAGO.COMMON-LISP.LISP-SEXP.SOURCE-FORM
pfdietz_ has joined #lisp
attila_lendvai has joined #lisp
attila_lendvai has joined #lisp
<stacksmith>
jackdaniel: mostly interested in metaprogramming aspects. After compilation it can be flattened just like arguments on the other side.
attila_lendvai has quit [Read error: Connection reset by peer]
<jackdaniel>
I mean – I've always imagined it is a program which modifies itself at runtime (i.e calling defun from the function), but that's not what people often mean by this word it seems
<pjb>
stacksmith: but you would want make-argument-list for destructuring-lambda-list, and it's not implemented yet for them. We'd have to generate a tree of expressions to build the required sexp.
<stacksmith>
jackdaniel: I mean macros and ability to generate code.
<pjb>
the fact is that usually, it's simple enough to just use backquote to generate the wanted result.
<jackdaniel>
my thought exactly, there is nothing awkward in having multiple-value-bind in macroexpansion
<jackdaniel>
and the programmer doesn't have to use it
<jackdaniel>
(only the abstraction vendor aka macro creator)
<stacksmith>
jackdaniel: things like loop present special problems which I haven't even figured out how to work around, except in very ugly ways.
attila_lendvai has quit [Read error: Connection reset by peer]
fourier has joined #lisp
<stacksmith>
pjb: digesting...
scymtym has joined #lisp
warweasle has quit [Quit: later]
<jackdaniel>
well, loop doesn't excel at extensibility (but most implementations ship MIT Loop which has some extensions to, hm, extend loop). you probably can't use it with many things as it is in the spec
<pjb>
stacksmith: actually, it's a method on make-argument-list-form that you would want to add, for destructuring-lambda-list.
attila_lendvai has joined #lisp
attila_lendvai has joined #lisp
attila_lendvai has quit [Changing host]
nowhere_man has quit [Ping timeout: 268 seconds]
<pjb>
Or rather, this method needs to be update for it. It's generic. But destructuring-lambda-list are special, since some parameters have no names (they're just sublists).
<stacksmith>
pjb: that's very interesting. I am stunned and annoyed that I haven't looked at it before...
<pjb>
For functions, it's more common, than for macros.
smaster has quit [Ping timeout: 256 seconds]
<Bike>
values are sort of tied to lambda lists in that the only special operator that can look into values is multiple value call, which does so through a function (and so, lambda list
<Bike>
the description of values types is pretty explicit about it, except it's also wrong for other stupid reasons blah
attila_lendvai has quit [Read error: Connection reset by peer]
trocado has quit [Ping timeout: 248 seconds]
attila_lendvai has joined #lisp
attila_lendvai has joined #lisp
attila_lendvai has quit [Changing host]
<stacksmith>
I suppose I am imagining a return-lambda-list syntax like (value &optional present-p) for say gethash; normally value would be bound as CL does it, but if the receiving site has a destructuring lambda-list (blah blah-p) it would provide both values...
<stacksmith>
pjb: still digesting the treasure-trove that is informatigo... Not used to gitlab.
<pjb>
there's a mirror on github
<stacksmith>
great.
<pjb>
stacksmith: theorically: (second (function-lambda-expression #'gethash)) ; but often not for compiled functions or implementation functions.
lnostdal has quit [Remote host closed the connection]
attila_lendvai has quit [Read error: Connection reset by peer]
Murii has quit [Quit: WeeChat 1.4]
<stacksmith>
pjb: apologies - i thought I tried that. I think my keyboard is eating m sporadically.
<cryptomarauder>
goodness quicklisp.lisp is a fantastic example of good lisp code, for beginners and hackers returning to the language. Refreshing even
Chream_ has joined #lisp
pfdietz_ has quit [Ping timeout: 252 seconds]
attila_lendvai has joined #lisp
attila_lendvai has joined #lisp
attila_lendvai has quit [Changing host]
<Xach>
Hey, thanks. There's some guy on a website who thinks it's really terrible. Only the bad reviews seem to stick with me...
Patternmaster has joined #lisp
Chream_2 has joined #lisp
<stacksmith>
Xach: unfortunately, people love complaining when things aren't to their liking... When they are, they just use the thing quietly... You have an army of admirers who should probably be more vocal.
saki has quit [Ping timeout: 268 seconds]
<phoe>
I <3 quicklisp
pfdietz_ has joined #lisp
<aeth>
It's so great to have the compiler error check for me, with errors found at compile time. I understand why people like this.
<Xach>
Oh, I get a ton of great and supportive feedback, and I really appreciate it.
<Xach>
I read lots of people who do open source projects and lament how thankless and grueling it is and I'm glad it's not like that to me.
<Xach>
Still, someone saying my code is crap makes me feel bad for a while.
<aeth>
I just rewrote an untested part of my code and I'm fairly confident that the part that I use in my examples (which might not be all of it) was rewritten correctly because I verify the macro. It's actually more powerful than relying on a compiler and a type system to do verification because I don't have to encode the verification via types.
jmercouris has joined #lisp
<aeth>
I actually caught mistakes 4 or 5 times, and was able to quickly fix them based on the error messages.
<aeth>
I might have to take a detour and compile time verify as much as possible in my program.
<aeth>
(I guess it's technically macro expansion time verification?)
rumbler3_ has quit [Ping timeout: 248 seconds]
smaster has joined #lisp
<phoe>
yep
<phoe>
macroexpansion time is a part of compilation time
jonh has joined #lisp
saki has joined #lisp
krwq has joined #lisp
<stacksmith>
pjb: I need bigger monitor! I keep typing informatigo...
<aeth>
Ugh, it looks like destructuring-bind's error is not standard.
<aeth>
"an error of type error should be signaled"
<pjb>
el mago de la informatica : informati mago
attila_lendvai has quit [Read error: Connection reset by peer]
<phoe>
in format imago
<dim>
Xach: your code can't be bad by any meaningful definition: it does a well defined job in a non surprising way, and for many users.
<pjb>
:-)
<aeth>
I wrote a little macro called do-destructuring-bind, which is essentially a combination of dolist and destructuring-bind (which showed up a *lot* in my code), but I want to give a more helpful error message when some sublist fails to match the destructuring-bind's lambda list.
attila_lendvai has joined #lisp
pfdietz_ has quit [Ping timeout: 255 seconds]
<aeth>
do-destructuring-bind is useful when there's something like let's bindings section, where there's an arbitrarily long, but structured list. Well, let's bindings section if let didn't permit non-list elements in its bindings section for an implicit nil like (let (foo) ...)
<aeth>
(do-destructuring-bind could be modified to handle that case, though, it would just take one conditional, with the destructuring bind only applying when listp on the sublist gensym)
Naergon has joined #lisp
<stacksmith>
pjb: Life would be a lot easier if there was a lambda-list that could be used to destructure any lambda-list... Or &lambda-list lambda-list-keyword...
visof has quit [Ping timeout: 256 seconds]
attila_lendvai has quit [Read error: Connection reset by peer]
<stacksmith>
Or If lambda-lists followed the lambda-list syntax.
<Shinmera>
There's libraries to destructure lambda lists. See lambda-fiddle.
<pjb>
or com.informatimago.common-lisp.lisp-sexp.source-form
<aeth>
Shinmera: I don't want to introduce a library for a 5 line macro, though.
<Xach>
dim: are you going to ELS?
<stacksmith>
xach: pjb: Yes, I found a few libraries for lambda-list, but I don't think any of them are complete and handle all cases...
<stacksmith>
pjb: thanks, btw. There is a lot of good stuf at informatimago.
<Bike>
parsing ordinary lambda lists is completely done by several libraries
attila_lendvai has joined #lisp
attila_lendvai has joined #lisp
attila_lendvai has quit [Changing host]
nullniverse has joined #lisp
orivej has joined #lisp
Chream_2 has quit [Read error: Connection reset by peer]
attila_lendvai has quit [Read error: Connection reset by peer]
Chream_ has joined #lisp
Oladon has quit [Quit: Leaving.]
attila_lendvai has joined #lisp
attila_lendvai has joined #lisp
attila_lendvai has quit [Changing host]
<emaczen>
How exactly do I shadow symbols in a package that uses another package?
pfdietz_ has joined #lisp
<phoe>
emaczen: normally
<phoe>
"The order in which the options appear in a defpackage form is irrelevant. The order in which they are executed is as follows: "
<phoe>
"1. :shadow and :shadowing-import-from. 2. :use. 3. :import-from and :intern. 4. :export. "
<phoe>
"Shadows are established first, since they might be necessary to block spurious name conflicts when the :use option is processed."
<whoman>
despite the appearance of simplicity on the surface, CL is actually founded on a lot of corner-cases
<phoe>
that were the result of actual decades of software development with Lisps that contributed to the Common.
milanj has quit [Quit: This computer has gone to sleep]
pfdietz_ has quit [Ping timeout: 265 seconds]
SAL9000_ has joined #lisp
SAL9000 has quit [Ping timeout: 260 seconds]
epony has quit [Remote host closed the connection]
marusich has joined #lisp
paul0 has joined #lisp
krwq has quit [Read error: Connection reset by peer]
SAL9000 has joined #lisp
milanj has joined #lisp
SAL9000_ has quit [Ping timeout: 276 seconds]
ludston_ has joined #lisp
Oladon has joined #lisp
<aeth>
whoman: All languages have corner cases. The issues is whether those cases are specified or implementation-specific.
fourier has quit [Ping timeout: 256 seconds]
<whoman>
phoe, aeth , true true
ludston has quit [Ping timeout: 255 seconds]
learning has quit [Remote host closed the connection]
hhdave has joined #lisp
<jmercouris>
Do all languages have corner case though?
aindilis has quit [Ping timeout: 256 seconds]
<jmercouris>
I mean that's a pretty bold statement, I don't mean to be pedantic, but I imagine there must be languages without corner cases
<k-hos>
corner cases for what
<aeth>
jmercouris: Probably any language that's useful for general purpose, turing-complete programming
vaporatorius has joined #lisp
vaporatorius has joined #lisp
vaporatorius has quit [Changing host]
<stacksmith>
Stating that any language might not have a corner case is a pretty bold statement!
Kundry_Wag has quit [Remote host closed the connection]
EvW has joined #lisp
Kundry_Wag has joined #lisp
rumbler31 has quit [Ping timeout: 256 seconds]
<stacksmith>
Is it possible to define a system that processes information that comes from outside in a way that eliminates the possibility of corner cases?
<emaczen>
So, could I easily shadow functions from the standard library like 'map?
vap1 has joined #lisp
<jmercouris>
I'll put javascript on the table as the most consistent language without any edge cases
dddddd has quit [Remote host closed the connection]
<phoe>
emaczen: yes
<jmercouris>
stacksmith: the language definition is not related to whether it can process imperfect external information
<phoe>
many packages actually depend on this by providing their own macros like DEFUN or DEFMETHOD
<phoe>
that you must use in place of CL:DEFUN and CL:DEFMETHOD for their magic to work.
<jmercouris>
though I can't think of a way to prove that
* phoe
puts jmercouris and stacksmith in #lispcafe
* jmercouris
resists in javascript
pfdietz_ has joined #lisp
<phoe>
jmercouris.putInChannel("#lispcafe");
<pfdietz_>
For example one of my favorite packages, Waters' COVER.
<phoe>
pfdietz_: for code coverage?
<Xof>
missing a trick by not using *macroexpand-hook* if you ask me
<pfdietz_>
Yes.
<phoe>
Xof: oh, indeed.
<emaczen>
phoe: can you point me to an example?
Karl_Dscc has quit [Remote host closed the connection]
<phoe>
emaczen: Qtools does that a lot
<phoe>
it provides its own FUNCTION, SETF and a bunch of other symbols
saki has quit [Ping timeout: 248 seconds]
<phoe>
and you are supposed to use CL+QT instead of CL in qtools projects.
saki has joined #lisp
<phoe>
which is CL with several shadowed symbols.
<emaczen>
phoe: am I going to run into a lot of problems? I primarily want to define my own sequence functions for custom datastructures and in the meantime I've been defining smap, sreduce etc....
<phoe>
emaczen: yes. All clients of your code must shadow the same symbols as you or use qualified names.
<phoe>
for example, LPARALLEL has pmap, preduce, pmapcar, ...
<emaczen>
phoe: I would define map as a method and if you give it a sequence it would just call cl:map
<pfdietz_>
:use in defpackage is name collisions waiting to happen.
<phoe>
emaczen: I assume you would take standard behaviour into account. Nonetheless, it's nothing I would advise.
Kundry_Wag has quit [Remote host closed the connection]
<phoe>
you basically just want to define MAP for more data structures. I think you can try, since nothing is stopping you, but expect issues along the way.
nullniverse has quit [Ping timeout: 256 seconds]
<emaczen>
phoe: I think I'll try this out when I have more time on my hands... lol
<emaczen>
phoe: It would be nice though...
<phoe>
emaczen: I know.
<emaczen>
phoe: I really like the CL seqeuence API and the keywords arguments etc
<Bike>
some implementations have an extensiont o let you define your own sequence types that work with map and co.
<Bike>
pfdietz_: right now we're about as fast as sbcl's dispatch, which is pretty good considering the compiler comparatively sucks
<pfdietz_>
I want your compiler to mature so I can torture it properly.
<pfdietz_>
Not sporting now.
<Bike>
working on it
<Bike>
turns out it's hard tho
<pfdietz_>
Yes it is.
<Bike>
and i see this inline thing considers classes final, oh well
<phoe>
yes, this is the cost.
<emaczen>
Well isn't it just for after you finish developing and have "static" code anyway?
<phoe>
yes, that is what it is meant for.
<Bike>
yes, but "no more methods" and "no more subclassing" are somewhat different kinds of static
<phoe>
still better than "no more interactivity", "no more error handling", "no more introspection" and "no more types" that some other languages offer after they're fully compiled
* phoe
goes to sleep
nowhere_man has joined #lisp
nowhereman_ has joined #lisp
varjagg has quit [Quit: ERC (IRC client for Emacs 25.2.1)]
nowhere_man has quit [Ping timeout: 268 seconds]
<pillton>
What do you mean by static dispatch?
<phoe>
pillton: not runtime
pfdietz_ has quit [Ping timeout: 260 seconds]
<phoe>
compile-time dispatch, that is
varjagg has joined #lisp
<pillton>
There is also specialization-store.
<pjb>
emaczen: you would have to start with a type-inference engine, to be able to determine at compilation time whether the arguments of a generic function call are of a type determined at compilation-time. Notice that this would involve mostly a global analysis, since compilation-units usually matching only files would be insufficient a scope.
<pjb>
emaczen: it would also be good to be able to determine at compilation time that a symbol will actually be fbound at run-time to a given generic function, (and not another or a non-generic function).
mishoo has quit [Ping timeout: 256 seconds]
rpg has joined #lisp
juan-reynoso has quit [Quit: Leaving]
shifty has joined #lisp
pfdietz_ has joined #lisp
Bike has quit [Ping timeout: 260 seconds]
hhdave has quit [Quit: hhdave]
pfdietz_ has quit [Ping timeout: 260 seconds]
pfdietz_ has joined #lisp
varjagg has quit [Quit: ERC (IRC client for Emacs 25.2.1)]
<razzy>
who-call-who is not imlemented on sbcl?
nullniverse has joined #lisp
<razzy>
i feel like i broke the universe :]
pfdietz_ has quit [Ping timeout: 260 seconds]
<drmeister>
It's about the middle of the month - so it's time for me to ask what people think about Common Lisp parser generators (sigh).
rumbler31 has joined #lisp
<drmeister>
I've got a lot of experience now writing esrap parsers.
<drmeister>
I like it very much. But I have a large parser written in C++ with Bison that I need to translate into Common Lisp.
<drmeister>
cl-yacc - that's my best choice for an LALR, Backus–Naur form parser generator - correct?
<drmeister>
So - yes - I figure I'll use two different parser generators in the same application (double sigh)
Kundry_Wag has joined #lisp
moei has quit [Quit: Leaving...]
Oladon has quit [Quit: Leaving.]
<drmeister>
I translated one C++/bison/backus-naur form parser into esrap and I don't want to do that again.
<Naergon>
Write an automatic translator? =)
rumbler31 has quit [Ping timeout: 240 seconds]
Kundry_Wag has quit [Ping timeout: 240 seconds]
<razzy>
should be possible to jump in code back and forth?
<pjb>
drmeister: or write a grammar translator. Use your parser generator to do that ;-)
<rpg>
logical pathnames really are a hot mess.... Put one in my ASDF:*CENTRAL-REGISTRY* and now every Quicklisp system with an inappropriate name causes a crash....
<pjb>
rpg: just a bug in asdf.
<pjb>
logical pathnames are really nice.
<pjb>
You have to know how to use them (which basically means: just say no to physical pathnames).
<pjb>
rpg: and crashes are bug in the implementations. What implementation do you use?
<rpg>
pjb: nope. A bug in the person who defined the cl-rrt.benchmark system....
<rpg>
pjb: I just mean an error by "crash". No lisp implementation actually crashed.
<pjb>
yes, so bug in asdf.
<rpg>
pjb: No. Bug in the system name.
<rpg>
ASDF tells you loud and clear that it will merge the system name into the path. So if you give a system name that can't be merged with a logical pathname, it's your fault, not ASDF's.
orivej has quit [Ping timeout: 248 seconds]
<pjb>
oh, right. So it's not logical pathnames fault, it's the person who named the system, indeed.
<pjb>
but cl-rrt.benchmark looks like a good pair of logical pathname components.
<rpg>
pjb: I'll have to check and see why SBCL choked on it.
<rpg>
ACL's "anything goes" philosophy was fine.
<pillton>
drmeister: Jasom might be able to help you make decision.
Kaisyu has joined #lisp
<pillton>
I don't know when he is on.
<drmeister>
I'll check with him - I might end up doing it in esrap