<aeth>
no, but I always look forward to the results
<edgar-rft>
ELS 2020 this time takes place via telepathy
<aeth>
If we were all using Lisps, then yes, it would have
<aeth>
edgar-rft: Too bad this is all too early for VR/AR (called "XR" for "extended reality") to be commonplace or we could have something almost as good as telepathy.
terpri has quit [Remote host closed the connection]
terpri has joined #lisp
pilne has quit [Quit: Tis but a scratch]
sulami has joined #lisp
terpri has quit [Remote host closed the connection]
terpri has joined #lisp
Oladon has quit [Quit: Leaving.]
terpri_ has joined #lisp
<aeth>
beach: I think I do have a talk I could give in 2021 or 2022, though...
<no-defun-allowed>
I'll try to visit next year. Dunno how it will affect my study, or how my study will affect it, though.
sulami has quit [Ping timeout: 256 seconds]
terpri has quit [Ping timeout: 240 seconds]
ArthurStrong has joined #lisp
<aeth>
no-defun-allowed: unfortunately, it's during weekdays, so I'm guessing you would need to take several days off, speaking to your professors ahead of time
<no-defun-allowed>
It's also approximately on the other side of the planet.
<aeth>
well, that just means add one more day (for the plane back... the plane there would be on a Sunday)
sz0 has quit []
sz0 has joined #lisp
<beach>
aeth: It would either have to be a "lightning talk" of 5 minutes, or you would have to write a paper that will be peer reviewed, and only if it is accepted by the referees would you then be allowed to give a 20 minute talk.
<beach>
It would be silly to go half-way around the globe and only stay for a few days.
<beach>
When I went to Aotearoa, I stayed for a year.
nicktick1 has quit [Quit: Leaving.]
nicktick has joined #lisp
<aeth>
beach: heh, it would be very amusing to try to summarize what I'm doing in 5 minutes.
nicktick has joined #lisp
nicktick has quit [Changing host]
<no-defun-allowed>
Stupid question about talks: say I want to present about my work on Netfarm, which is (to my knowledge) a novel combination of not novel techniques for solving some problems other techniques create.
<beach>
aeth: Right. So then you need to think about writing a peer-reviewed paper.
<no-defun-allowed>
Should I focus on the implementation of those, or the concepts themselves (I would guess the former for a Lisp symposium), and all (most) of the components or just one?
<no-defun-allowed>
I guess an answer would also affect what I write about, too.
<beach>
no-defun-allowed: You put yourself in the shoes of members of the program committee, and you write something that is likely to make them give an "accept". It is hard to be more specific with the limited information we have so far.
<no-defun-allowed>
And would it be unwise to try to submit a paper to the first symposium I attend?
<beach>
Not at all.
<aeth>
beach: I'm writing a Scheme source-to-source compiler in and to Common Lisp. I'm probably a few days of work (so not necessarily a few days) away from getting it to read, compile, and load Scheme files.
<no-defun-allowed>
Sure, that is what I would have to do to get the paper accepted, but I suppose I don't know what I should write about that relates to my programming.
<beach>
no-defun-allowed: If it is rejected, you typically get detailed remarks that will make it possible to submit a better version the following year, or to some other conference.
<beach>
no-defun-allowed: Write something up and we will figure it out together.
<no-defun-allowed>
Or, I guess I have a similar problem to the one that sometimes causes me to hesitate asking some questions in #lisp: is it on topic for ELS to just present something that was written in Lisp that may not have been much more interesting had it not been written in Lisp, or should it be something that takes advantage of (Common) Lisp features?
<aeth>
ASDF integration is going to be tricky, but I'll probably be able to do a mapping between r7rs's library system and ASDF's systems so e.g. (scheme base) would be the CL package and the ASDF system airship-scheme/scheme/base (almost like ASDF's package inferred system, except not enforcing a one-package-per-file style)
<no-defun-allowed>
beach: Alright, when I have time I'll write a draft.
<beach>
no-defun-allowed: There is no such preference for ELS papers.
<no-defun-allowed>
Right then.
<beach>
aeth: Demonstrative pronouns like "this" should typically be followed by a noun phrase. Otherwise it become vague what is being referred to.
<no-defun-allowed>
beach: Thank you very much in advance.
<aeth>
beach: ah, in the Overview. Yes, I actually had worse prose there and quickly rewrote that part to be grammatically correct
<beach>
aeth: Does "This" in "This allows programs..." refer to the fact that it is new, that it is Scheme, that it is implemented in Common Lisp, or that it is designed to run in a Common Lisp environment.
<aeth>
yes
gravicappa has joined #lisp
<aeth>
well, besides the new part
<beach>
"This includes..."
<aeth>
oh, that was (I thought) unambiguously the built-ins, i.e. "the host data structures include"
<aeth>
I'll revise that
<aeth>
I'll replace the first "This" with "The embedded nature"
<aeth>
"The embedded nature of this architecture"?
<aeth>
no-defun-allowed: (= 1 (signum (- x y))) gets you "x is bigger than y" while (= x (max x y)) gets you "x is greater than or equal to y"
<aeth>
so it depends on which one you want and both have their uses
<aeth>
asarch: I don't think C has signum :-)
<aeth>
Or max, actually
<aeth>
well, maybe it has max in a library.
<no-defun-allowed>
Someone suggested (/ (+ a b (sqrt (expt (- a b) 2))) 2) there.
<asarch>
I know, I just was wondering how could be the Common Lisp way
swills has quit [Ping timeout: 256 seconds]
<no-defun-allowed>
I like that way, partly because I was able to pretend I was clever for all of five seconds when I realised Pythagoras' theorem "extended" to one dimension, ie ||x|| = sqrt(x^2)
<asarch>
Did you see the polymorphic lambdas in C++?
<no-defun-allowed>
No, why would I care?
<asarch>
That would be such a pain to debug
<no-defun-allowed>
Cool. I don't write C++.
<no-defun-allowed>
Maybe you should tell ##c++ your opinion? They're probably Stockholmed enough that they would disagree, but it would be relevant there and only there.
dale has quit [Quit: My computer has gone to sleep]
<beach>
aeth: I have not paid attention to such occurrences. What "wrapping effort" are you referring to?
swills has joined #lisp
Kundry_W_ has quit [Ping timeout: 264 seconds]
narimiran has joined #lisp
<aeth>
beach: I distinguish between predicates and procedures (to use Scheme terminology), and autoconvert nil to #f in predicates for convenience (or for standards compliance when implementing a standard Scheme procedure) because Scheme has a separate #f from nil
ArthurStrong has quit [Quit: leaving]
sauvin has joined #lisp
torbo has quit [Remote host closed the connection]
akoana has left #lisp ["Leaving"]
dddddd has quit [Ping timeout: 256 seconds]
Lord_of_Life has quit [Read error: Connection reset by peer]
asarch has quit [Quit: Leaving]
vlatkoB has joined #lisp
Lord_of_Life has joined #lisp
Oddity has quit [Read error: Connection reset by peer]
sulami has joined #lisp
GeissT has quit [Quit: Leaving]
Oddity has joined #lisp
Kundry_Wag has joined #lisp
sulami has quit [Ping timeout: 250 seconds]
Kundry_Wag has quit [Ping timeout: 256 seconds]
<aeth>
I also do a continuation passing style wrapping, but that should be OK unless there's weird control flow
ecraven has quit [Quit: bye]
ecraven has joined #lisp
<beach>
Why is it called a "wrapping"?
terpri has joined #lisp
Cymew has joined #lisp
terpri has quit [Remote host closed the connection]
terpri has joined #lisp
sulami has joined #lisp
sulami has quit [Ping timeout: 256 seconds]
random-nick has joined #lisp
sulami has joined #lisp
frgo has quit [Remote host closed the connection]
frgo has joined #lisp
vivit has quit [Ping timeout: 240 seconds]
<aeth>
beach: I add a function that does nil->false or false->nil, is there a better name?
<beach>
Looks good to me.
ebzzry has quit [Read error: Connection reset by peer]
ggole has joined #lisp
ebzzry has joined #lisp
frgo_ has joined #lisp
frgo has quit [Ping timeout: 252 seconds]
Codaraxis has quit [Ping timeout: 240 seconds]
Codaraxis has joined #lisp
Kundry_Wag has joined #lisp
v_m_v has joined #lisp
heisig has joined #lisp
Kundry_Wag has quit [Ping timeout: 260 seconds]
arduo has joined #lisp
arduo has quit [Remote host closed the connection]
Bourne has joined #lisp
Codaraxis_ has joined #lisp
tiwEllien has joined #lisp
Codaraxis has quit [Ping timeout: 250 seconds]
froggey has quit [Ping timeout: 256 seconds]
froggey has joined #lisp
Lord_of_Life_ has joined #lisp
v_m_v has quit [Remote host closed the connection]
xyz123 has joined #lisp
Lord_of_Life has quit [Ping timeout: 256 seconds]
Lord_of_Life_ is now known as Lord_of_Life
Kundry_Wag has joined #lisp
xyz123 has quit [Remote host closed the connection]
msk has quit [Remote host closed the connection]
msk has joined #lisp
Kundry_Wag has quit [Ping timeout: 264 seconds]
orivej has quit [Ping timeout: 240 seconds]
sulami has quit [Ping timeout: 265 seconds]
sulami has joined #lisp
Kevslinger has quit [Quit: Connection closed for inactivity]
davepdotorg has quit [Remote host closed the connection]
davepdotorg has joined #lisp
gxt has quit [Remote host closed the connection]
Inline has joined #lisp
gxt has joined #lisp
tiwEllien has quit [Quit: WeeChat 2.7.1]
v_m_v has joined #lisp
sunwukong has joined #lisp
Kundry_Wag has joined #lisp
tiwEllien1 has joined #lisp
jayspeer has joined #lisp
dddddd has joined #lisp
davsebam1e has joined #lisp
Kundry_Wag has quit [Ping timeout: 265 seconds]
davsebamse has quit [Ping timeout: 264 seconds]
__jrjsmrtn__ has joined #lisp
_jrjsmrtn has quit [Ping timeout: 260 seconds]
pilne has joined #lisp
xkapastel has joined #lisp
jayspeer has quit [Quit: work vpn breaks freenode -- see ya!!]
Oddity has quit [Ping timeout: 256 seconds]
Oddity has joined #lisp
amazoniantoad has quit [Quit: Connection closed for inactivity]
Kundry_Wag has joined #lisp
markovojvodic84 has quit [Ping timeout: 260 seconds]
karlosz has quit [Quit: karlosz]
Kundry_Wag has quit [Ping timeout: 256 seconds]
narimiran has quit [Ping timeout: 260 seconds]
v_m_v has quit [Remote host closed the connection]
jonatack has quit [Quit: jonatack]
jonatack has joined #lisp
davepdot_ has joined #lisp
davepdotorg has quit [Ping timeout: 265 seconds]
Inline has quit [Remote host closed the connection]
markoong has joined #lisp
Bike has joined #lisp
sonologico has quit [Ping timeout: 246 seconds]
Inline has joined #lisp
sonologico has joined #lisp
narimiran has joined #lisp
rippa has joined #lisp
Kundry_Wag has joined #lisp
markong has joined #lisp
danielboston26 has joined #lisp
markoong has quit [Ping timeout: 258 seconds]
danielboston26 has quit [Client Quit]
davd has joined #lisp
arduo has joined #lisp
Josh_2 has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
Davd[m] has joined #lisp
EvW has joined #lisp
xkapastel has quit [Quit: Connection closed for inactivity]
FreeBirdLjj has joined #lisp
sunwukong has quit [Quit: Leaving]
FreeBirdLjj has quit [Ping timeout: 260 seconds]
davepdot_ has quit [Remote host closed the connection]
davepdotorg has joined #lisp
gxt has quit [Ping timeout: 240 seconds]
gxt has joined #lisp
markoong has joined #lisp
markong has quit [Ping timeout: 260 seconds]
heisig has quit [Read error: Connection reset by peer]
krid has joined #lisp
cosimone has joined #lisp
gxt has quit [Ping timeout: 240 seconds]
lalilulelo has joined #lisp
Lycurgus has joined #lisp
gxt has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
lavaflow has quit [Ping timeout: 265 seconds]
xkapastel has joined #lisp
dgtlcmo has joined #lisp
Kevslinger has joined #lisp
<flip214>
parenscript translates PARSE-INTEGER to parseInteger... which doesn't exist in JS. Is there a more extensive "standard library" or replacement table than *PS-LISP-LIBRARY* ?
<phoe>
flip214: parse-int?
davd has left #lisp [#lisp]
<flip214>
phoe: I know about the JS function. But is there some way to have Parenscript do some limited translation automatically?
<flip214>
If I write "parse-int" in the CL code it won't work on the host side, unless I create a workaround there...
Lycurgus has quit [Remote host closed the connection]
<phoe>
sounds like you'd need to do that - or extend parenscript with your parse-integer function
rippa has quit [Read error: Connection reset by peer]
sjl_ has joined #lisp
gigetoo has quit [Ping timeout: 240 seconds]
gigetoo has joined #lisp
<Shinmera>
you'll need a wrapper either way, their signatures only coincide for the one-arg case.
<phoe>
^
<flip214>
well, is there some library (in QL?) that provides such wrappers?
<phoe>
don't think so
<phoe>
I'm afraid you'll need to DIY
<dlowe>
extending parenscript and submitting it upstream seems like the nicest option
Necktwi has quit [Read error: Connection reset by peer]
dale_ has joined #lisp
dale_ is now known as dale
niceplace has quit [Ping timeout: 264 seconds]
niceplaces has joined #lisp
sulami has quit [Remote host closed the connection]
gxt has quit [Ping timeout: 240 seconds]
spainisnotequal has joined #lisp
EvW has quit [Ping timeout: 272 seconds]
monokrom has joined #lisp
Necktwi has joined #lisp
cosimone has quit [Quit: Terminated!]
spainisnotequal has quit [Quit: Ping timeout (120 seconds)]
ym has quit [Quit: Leaving]
vivit has joined #lisp
vivit has quit [Changing host]
vivit has joined #lisp
Necktwi has quit [Ping timeout: 264 seconds]
ebrasca has quit [Remote host closed the connection]
Inline has quit [Ping timeout: 246 seconds]
h11 has quit [Read error: Connection reset by peer]
h11 has joined #lisp
markoong has quit [Read error: Connection reset by peer]
markoong has joined #lisp
vlatkoB has quit [Ping timeout: 256 seconds]
vlatkoB has joined #lisp
<flip214>
dlowe: yeah, guess so. having something hang on the symbol property list, or a hashtable...
Necktwi has joined #lisp
<dlowe>
I don't know anything about parenscript's internals but being able to map parse-integer into parseInt seems like a fundamental operation it would need
<phoe>
if explaining the condition system was hard
<phoe>
now let me try explaining the even more intricate restart system that builds on the condition system and complicates it further in interesting ways
* phoe
sigh
<Bike>
it's just hore hooks
<phoe>
that is a bad typo
bitmapper has joined #lisp
frgo has joined #lisp
* jcowan
snickers
<jcowan>
Riastradh pruned it considerably for the Scheme proposal, and I pruned it even more, so what's left is "the essence of restarts", I think
<jcowan>
in particular, I found for myself I needed to sort out the difference between ambient restarters (in the dynamic environment) from restarters attached to conditions from free-standing restarters.
iAmDecim has joined #lisp
<beach>
jcowan: If you are going to implement something like the Common Lisp condition system for Scheme, you should probably read what Kent Pitman wrote about the aspects he thinks he did wrong.
<jcowan>
I will, thanks.
davepdot_ has joined #lisp
ebzzry has quit [Read error: Connection reset by peer]
gko has quit [Ping timeout: 260 seconds]
Mandus has joined #lisp
davepdotorg has quit [Ping timeout: 240 seconds]
t58 has joined #lisp
<jcowan>
One thing we have done on the condition side is to force the condition *signaler* to decide whether the handler can return to its caller: there is both raise and raise-continuable. If a handler returns to a raise, another condition is raised.
<jcowan>
this raise bypasses the most recent handler, just as a condition raised *in* the handler does
remexre has quit [Ping timeout: 268 seconds]
<Bike>
so, error and cerror?
<Bike>
not exactly, since invoke-debugger doesn't signal
<Bike>
and a handler has to explicitly continue for cerror, rather than just return
<fiddlerwoaroof_>
jcowan: does this mean that a handler can't swallow all the conditions signaled in its dynamic extent?'
<jcowan>
Similar except for the absence of invoke-debugger
<Bike>
it sounds more like throw/catch really... like, if you throw and there's no catch, a control error is signaled
<jcowan>
however, there is an interactor provided by the implementation that looks inside a restarter and figures out what variables to collect and what restarters are available
<Bike>
or how C++ does std::terminate (except std::terminate is dumber, because C++)
<jcowan>
But catch can never return to the point of throw, correct?
<Bike>
it can't, no. i just meant in this raise-cant-continue aspect
<jcowan>
fiddlerwoaroof_: A handler can definitely do anything it wants.
* jcowan
nods
fiddlerwoaroof_ is now known as fiddlerwoaroof
orivej has joined #lisp
<fiddlerwoaroof>
Ok, I think I've misunderstood the description
<jcowan>
It's just that if the handler chain attempts to return to the caller, it will fail to do so.
<jcowan>
What I don't understand about the condition system is why there are classes like error, warning, etc. and also functions with the same names
<jcowan>
For all I can tell to the contrary, the fact that a condition is a subtype of warning has no effect on how it is signaled or handled
<phoe>
;; caught NITPICK: there's no function named WARNING
<fiddlerwoaroof>
Isn't it just a convention that the "standard" way to raise a condition of class FOO is to call the function FOO?
<phoe>
jcowan: that is correct
<Bike>
jcowan: i mean, handlers can specialize on warning, but otherwise no
ioa has quit [*.net *.split]
copec has quit [*.net *.split]
eeeeeta has quit [*.net *.split]
AdmiralBumbleBee has quit [*.net *.split]
akkad has quit [*.net *.split]
* jcowan
nods
akkad has joined #lisp
<phoe>
you can even SIGNAL an error or ERROR a warning or ERROR a condition that isn't an error or warning
<Bike>
the error, warn, and signal functions have different effects, of course, and those effects are suited to those classes' semantic intents
ioa has joined #lisp
copec has joined #lisp
* jcowan
nods
<phoe>
the condition types are there for the programmer to utilize, especially if they write code that deals with Lisp in general
AdmiralBumbleBee has joined #lisp
<phoe>
it may want to separate errors from warnings from (and condition (not (or warning error)))s
<fiddlerwoaroof>
nvm, I'm confusing conditions with restarts
tiwEllien1 has quit [Quit: tiwEllien1]
<Bike>
so, hang on, in your system can a handler decline to handle the condition, and then a later handler can get at it and do whatever?
<phoe>
fiddlerwoaroof: :D
lavaflow has joined #lisp
frgo_ has joined #lisp
<fiddlerwoaroof>
One thing it took me a long time to realize was that HANDLER-BIND and HANDLER-CASE take type specifiers, not conditions
eeeeeta has joined #lisp
<fiddlerwoaroof>
So, I can replace two identical handler clauses with (and condition1 condition2), etc.
<fiddlerwoaroof>
or, (OR ...)
<phoe>
fiddlerwoaroof: yes, all the magic of type specifiers
EvW1 has joined #lisp
libertyprime has joined #lisp
<fiddlerwoaroof>
I discovered this when trying to deal with libraries that signal simple conditions for things one generally wants to be able to handle
* jcowan
nods
<pjb>
aeth: SIGNUM contains a hidden IF.
<jcowan>
The Scheme analogue of handler-bind doesn't know from types, but handler-case does.
frgo has quit [Ping timeout: 256 seconds]
<pjb>
aeth: like ABS. You need to implement them without IF if you want to use them in an IF-less solution.
<Bike>
having the type system there is convenient, but if i was designing the system myself i wouldn't have done that
<Bike>
not sure what i would do, exactly, but the type system is just... complicated.
<jcowan>
I can't find the specific Pitman paper you are referring to, btw.
<fiddlerwoaroof>
Bike: I think it's better than having both the type system + something else
<pjb>
aeth: SQUARE doesn't contain an IF, but SQRT does (it loops until) so abs = sqrt o square is no good, unless you proide an IF-less SQRT.
<Bike>
actually i suppose if the types were parsed ahead of time it might be okay
shangul has quit [Ping timeout: 265 seconds]
emacsomancer has quit [Read error: Connection reset by peer]
<jcowan>
Which you can: just expand the Taylor series to enough terms that any further terms would be lost in the error
<Bike>
...eh?
<pjb>
jcowan: yes.
<pjb>
taylor series don't converge very fast usually…
<jcowan>
The ones for the trig functions are pretty good: I've certainly seen them used
eeeeeta is now known as eta
emacsomancer has joined #lisp
tiwEllien1 has joined #lisp
libertyprime has quit [Read error: No route to host]
<pjb>
jcowan: does the hardware loop (in time) or duplicates silicon (in space)?
tiwEllien has joined #lisp
<jcowan>
It uses mul/div/sqrt pipeline stages. The point is that it's finite and can't get stuck, unlike Newton
<jcowan>
By all means read the paper and then tell me.
<pjb>
jcowan: well, the problem is more about the essence of IF.
<jcowan>
without if there is no meaningful iteration.
<jcowan>
("My computer can run infinite loops twice as fast as your computer!")
<pjb>
jcowan: perhaps no observer in the quantum world!
<pjb>
In lambda-calculus, it's implemented thanks to lazy evaluation.
libertyprime has joined #lisp
Oddity has quit [Ping timeout: 256 seconds]
Jesin has quit [Quit: Leaving]
iAmDecim has quit [Ping timeout: 256 seconds]
Oddity has joined #lisp
sonologico__ has joined #lisp
Bourne has quit [Read error: Connection reset by peer]
karlosz has joined #lisp
<phoe>
Am I correct to say that the only places where the restart system interacts with the condition system is the macro WITH-CONDITION-RESTARTS, the standard-defined restarts ABORT, CONTINUE, ..., and the Lisp debugger?
Jesin has joined #lisp
sonologico has quit [Ping timeout: 246 seconds]
<Xach>
phoe: when i think of restarts and conditions, i think of find-restart and invoke-restart. do you consider those a part of your list already?
sonologico__ has quit [Remote host closed the connection]
sonologico__ has joined #lisp
<phoe>
Xach: my list? what do you mean?
<phoe>
also, find-restart does not necessarily have to do anything with conditions; neither does invoke-restart
<phoe>
the first accepts a restart name, the latter a restart designator and args for the restart function
<fiddlerwoaroof>
Depending on the context (format stream "(~{~s~})" '())
<fiddlerwoaroof>
But, that might not be practical
<jmercouris>
it is a macro where I want to either dump the arglist like ,arglist or show () to indicate rather than nil
Bike has quit [Read error: Connection reset by peer]
<jmercouris>
when arglist is nil, ,arglist will show NIL
<jmercouris>
which makes sense... of course
Bike has joined #lisp
<jmercouris>
I know what I will do, I'll handle it in a let above where I need it
<jmercouris>
the problem was that it was in a quoted form
<phoe>
jmercouris: why?
<jmercouris>
I'll show you in a second
<phoe>
Can I somehow get a list of all restarts that are applicable *only* to a given condition? That is, minus restarts that are applicable to everything?
<phoe>
...I could (compute-restarts condition) and set-difference that with (compute-restarts), I guess.
<fiddlerwoaroof>
(compute-restarts condition)
<Bike>
that's probably it, yeah.
<fiddlerwoaroof>
Ah, missed a bit :)
<fiddlerwoaroof>
phoe: what are you working on? It sounds interesting
<fiddlerwoaroof>
jmercouris: I usually do (,@arglist)
<jmercouris>
that will insert spurious () around it sometimes
<jmercouris>
when arglist is non-null
<fiddlerwoaroof>
arglist is always going to be a list, right?
<jmercouris>
yes
<fiddlerwoaroof>
() => () (a b c) => (a b c)
<jmercouris>
oh I missed the @
<fiddlerwoaroof>
ah
<Bike>
you shouldn't think of it as "inserting spurious ()". that's a sensible frame if you're printing, but think about the actual objects - a list.
<Bike>
i mean you already figured out this problem, but, you know, in the future
<jmercouris>
yes, that's a good point
Cymew has quit [Ping timeout: 264 seconds]
jmercouris has quit [Remote host closed the connection]
<phoe>
"
<phoe>
"spurious ()" looks like kinda sloppy list handling to me
<phoe>
it's not that it inserts spurious () on its own, it's that it was given wrong arguments
<Bike>
actually, why is this macro building its own form back, anyway?
<phoe>
that's like complaining that using LIST instead of LIST* inserts spurious () around the last CDRs
<Bike>
maybe &whole could be used instead?
<phoe>
^
ufaucernio has joined #lisp
mrcom has quit [Read error: Connection reset by peer]
gxt has joined #lisp
mrcom has joined #lisp
v88m has joined #lisp
iAmDecim has quit [Ping timeout: 256 seconds]
ufaucernio has quit [Ping timeout: 265 seconds]
Lycurgus has joined #lisp
Lycurgus has left #lisp [#lisp]
Codaraxis__ has joined #lisp
libertyprime has quit [Ping timeout: 260 seconds]
Codaraxis_ has quit [Ping timeout: 256 seconds]
efm_ has joined #lisp
efm has quit [Ping timeout: 265 seconds]
<phoe>
Is (restart-case (invoke-restart 'foo) (foo (x) (* x x))) valid code?
<Bike>
well, you're not giving the restart enough arguments
<Bike>
but otherwise sure, i guess?
<phoe>
oh right - found it, thanks
<phoe>
I was dumb
<Bike>
i forgive you.
<phoe>
thank you
efm_ has quit [Quit: Konversation terminated!]
efm has joined #lisp
<jcowan>
phoe: My only other point is that copying the *whole* of section 1 into sectiomn 2 and translating the code is overkill and makes it hard to read. Instead, just present the cl code and a few words for each fragment to make it clear what it's for.
<phoe>
jcowan: point taken, I will possibly rewrite that chapter completely to shorten it all up.
<Bike>
i guess the weird thing is that (restart-bind ((foo (lambda (x) (* x x)))) (invoke-restart 'foo (invoke-restart 'foo 7))) => 2401
nicktick has quit [Quit: Leaving.]
<Bike>
now there are some hooks
jprajzne has quit [Read error: Connection reset by peer]
jprajzne has joined #lisp
<phoe>
Bike: why weird though
<aeth>
pjb: SIGNUM on x86-64 probably contains a hidden IF, but SIGNUM could exist as an architectural primitive depending on the machine's asm, afaik. CL doesn't just run on x86-64. Of course, you'd probably still get a few conditionals in the generic version unless the compiler knows it's a float or fixnum.
<Bike>
phoe: just cos it's not how restarts are normally used. it makes sense, of course
<phoe>
Bike: usually you rarely get to see restart return values
<Bike>
usually you don't use restart-bind
<Bike>
not sure i've ever seen it in source code, actually
<phoe>
usually you just hit #\Q on your keyboard and return to the slime repl
<pjb>
aeth: usually, hardware provides two flags, N and Z, but you still have to test them to produce -1, 0 or 1.
iAmDecim has joined #lisp
<pjb>
aeth: if you're lucky, you can read the flag register, and manipulate it arithmetically to get the wanted result.
<fiddlerwoaroof>
Bike: the only time I've seen RESTART-BIND is in implementations of RESTART-CASE
<Bike>
well, yes.
lucasb has joined #lisp
<fiddlerwoaroof>
It and custom method combinations are things I really want to see a compelling use for :)
<phoe>
fiddlerwoaroof: well, I will try to convince you
<fiddlerwoaroof>
I think I may have used RESTART-BIND in the past to implement type coercions
<pjb>
fiddlerwoaroof: method combinations are monads.
<fiddlerwoaroof>
Perhaps, but I've generally been able to get away with only using the default method combinations
<phoe>
I actually started using method combinations recently
<fiddlerwoaroof>
I once tried to implement http routing as a method combination, but no implementation implements the spec (IMO)
<phoe>
I hacked^Wmodified a GF to actually perform some matching for me; with my m-c, methods get called in turn and the first one that returns non-nil produces the value for the GF
<phoe>
I still remember Bike wincing at that idea, but hey, it works
<fiddlerwoaroof>
that's the OR method combination?
<phoe>
yes, except I had to work with a multiple-value-or since I had multiple values
<Bike>
yeah, that just sounds like OR... i don't remember this
<Bike>
well, nobody uses a lot of define-method-combination anyway
<fiddlerwoaroof>
Yeah
<Bike>
ecl doesn't support :arguments, w hich seems a bit more basic to me
<phoe>
I wish I could actually use it
<phoe>
I mean, hacks like these make it more useful for me
<fiddlerwoaroof>
Me too, I would have used this
<fiddlerwoaroof>
And I considered patching my sbcl every time I upgraded to make this work
seisatsu has quit [Ping timeout: 272 seconds]
Jesin has quit [Quit: Leaving]
<phoe>
this is one thing that I miss from base CL - ability to define groups of equal functions that are then grouped and combined in some way
xkapastel has quit [Quit: Connection closed for inactivity]
<phoe>
and define-method-combination as I hacked it there is the cleanest way I've found to perform it so far without pulling external libraries
seisatsu has joined #lisp
Jesin has joined #lisp
sonologico___ has joined #lisp
sonologico has quit [Ping timeout: 265 seconds]
msk has quit [Ping timeout: 260 seconds]
rippa has joined #lisp
lxbarbosa has joined #lisp
frgo has joined #lisp
frgo_ has quit [Read error: Connection reset by peer]
z147 has joined #lisp
pioneer42 has left #lisp [#lisp]
msk has joined #lisp
msk_ has joined #lisp
msk has quit [Ping timeout: 250 seconds]
<phoe>
FIND-RESTART accepts an optional condition argument; is macro WITH-CONDITION-RESTARTS the only way of actually associating conditions with restarts?
ggole has quit [Quit: Leaving]
<phoe>
wait a second
<phoe>
WITH-CONDITION-RESTARTS actually expects a condition *object*
<phoe>
I misunderstand how this utility works then
<phoe>
we must already have a condition object to associate it with restarts
<Bike>
it only does so in the specific case of the form being a literal (error ...) or something, in which case it can take it apart into a make-condition, use the condition in with-condition-restarts, and then actually signal.
efm_ has joined #lisp
<phoe>
wtf
<Bike>
e.g. see sb-impl::munge-restart-case-exprssion in sbcl.
<Bike>
yeah, it's kind of weird honestly.
efm has quit [Ping timeout: 256 seconds]
<Bike>
but (restart-case (error ...) ...) is real common.
msk has joined #lisp
frgo_ has joined #lisp
xkapastel has joined #lisp
frgo has quit [Read error: No route to host]
Josh_2 has quit [Remote host closed the connection]
Josh_2 has joined #lisp
msk_ has quit [Ping timeout: 260 seconds]
<phoe>
why is this in the standard and not an implementation detail
<phoe>
I mean, I'd need a use case for that
efm_ has quit [Ping timeout: 250 seconds]
<phoe>
;; that isn't implementing handler-case
<Bike>
so that the programmer can have the expectation that the condition is actually associated.
<phoe>
s/handler/restart/
<Bike>
a use case for with-condition-restarts?
cosimone has joined #lisp
sonologico__ has joined #lisp
<phoe>
yes, for that one
<phoe>
something that isn't SB-KERNEL::-type of implementation internal
<flip214>
I've got a function with RESTART-CASE. If I run that from the repl, I can choose the restarts; if the function is called from another from within a HANDLER-CASE, (COMPUTE-RESTARTS) doesn't show my restarts as available.
narimiran has quit [Quit: leaving]
<Bike>
show code?
Josh_2` has joined #lisp
<Shinmera>
does handler-case handle the condition?
Josh_2 has quit [Read error: Connection reset by peer]
<Shinmera>
well handler-case unwinds the stack, so
<Bike>
yeah, you'll need to use restart-bind.
<flip214>
ouch, that again
<flip214>
restart-bind or handler-bind?
<Bike>
handler-bind, sorry.
<Shinmera>
This is why I get a bit miffed when people talk about restarts as if that part was the best thing about CL's error handling. It's not. Handler-bind is the magic part. You could simulate restarts easily with exceptions if you had handler-bind.
<flip214>
thanks, that was it again
terpri_ has joined #lisp
<phoe>
so this is an edge case where we have multiple conditions being signaled and/or nested debugger sessions
<phoe>
so we can figure out which restarts are available for which condition object
terpri has quit [Ping timeout: 252 seconds]
lemoinem is now known as Guest13309
Guest13309 has quit [Killed (moon.freenode.net (Nickname regained by services))]
lemoinem has joined #lisp
sonologico___ has quit [Remote host closed the connection]
sonologico___ has joined #lisp
sonologico___ has quit [Remote host closed the connection]
sonologico___ has joined #lisp
asarch has quit [Quit: Leaving]
<Bike>
yeah. really i suppose i'd only mention it in your tutorial alongside the debugger
gxt has quit [Remote host closed the connection]
gxt has joined #lisp
sonologico__ has quit [Remote host closed the connection]
<phoe>
wait a second
<phoe>
the list of restarts inside the debugger - does the spec say how it is computed?
<phoe>
(compute-restarts), or (compute-restarts condition)?
<Bike>
i don't believe the spec even mandates that a debugger exists
<Bike>
nonetheless, if there's an actual debugger and it didn't pass the condition to compute-restarts, it would be kind of dumb for no reason
amerlyq has quit [Quit: amerlyq]
<phoe>
the spec speaks about associating conditions with restarts only to be quiet about whether the debugger actually utilizes that functionality
<phoe>
huh
<Bike>
i don't think it would be good to specify the debugger
<Bike>
i mean, i think a disabled debugger mode like sbcl has is fine, and then no restarts are computed at all
sonologico__ has joined #lisp
<phoe>
yes
<Bike>
and the display is ultimately just a UI... i mean, the debugger generally lets you execute arbitrary code, so if you really want you can (compute-restarts) yourself and invoke something.
<phoe>
can I get a REPL inside sldb? or am I stuck to slime-eval-in-frame?
<phoe>
that's a sorta-related question
<Bike>
you could execute a repl in-frame, i guess :p
<Bike>
but no, i don't know of any way to do that
<Bike>
i mean, other than that.
<fiddlerwoaroof>
Launch a clim listener in frame :)
sonologico__ has quit [Remote host closed the connection]
<fiddlerwoaroof>
This might be a useful thing to add to slime-mrepl
sonologico__ has joined #lisp
jprajzne has quit [Quit: jprajzne]
sonologico___ has quit [Ping timeout: 265 seconds]
jprajzne has joined #lisp
<phoe>
fiddlerwoaroof: tempting
<phoe>
very tempting
gxt has quit [Remote host closed the connection]
gxt has joined #lisp
jprajzne has quit [Client Quit]
jprajzne has joined #lisp
gxt has quit [Remote host closed the connection]
<phoe>
so, if I understand correctly
<phoe>
the only reason why COMPUTE-RESTARTS, FIND-RESTART et al actually accept a condition object
gxt has joined #lisp
markong has joined #lisp
markoong has quit [Ping timeout: 240 seconds]
<phoe>
is to filter out some other possible restarts that were created for other condition objects that might have been signaled in the same dynamic scope
<phoe>
is that correct?
<phoe>
because AFAIU, unless we have multiple signals in dynamic scope, this is not a issue that we will run into
Lord_of_Life_ has joined #lisp
<phoe>
we need a condition to be signaled, we need a bound handler to bind a new restart and associate that restart with the signaled condition object
<phoe>
and then all of this, again, for a different condition
<phoe>
I'll go to hell if I put stuff like that in a condition/restart tutorial
Lord_of_Life has quit [Ping timeout: 240 seconds]
Lord_of_Life_ is now known as Lord_of_Life
gxt has quit [Remote host closed the connection]
gxt has joined #lisp
<Shinmera>
Is this the time to ask for volunteers to implement eval-in-frame in Dissect
sonologico__ has quit [Remote host closed the connection]
gxt has quit [Remote host closed the connection]
gxt has joined #lisp
sonologico__ has joined #lisp
gxt has quit [Remote host closed the connection]
sonologico__ has quit [Remote host closed the connection]
gxt has joined #lisp
tiwEllien has quit [Quit: tiwEllien]
markoong has joined #lisp
<phoe>
well then, for now I'll just go ahead and treat these functions as if they didn't accept a condition argument
<phoe>
and possibly complicate stuff at the end
markong has quit [Ping timeout: 260 seconds]
twelvemonkeys has quit [Ping timeout: 240 seconds]
twelvemonkeys has joined #lisp
<phoe>
why does this code fail on me? (restart-case (invoke-restart-interactively 'foo) (foo (x) (* x x)))
<phoe>
AFAIU it should be equivalent to (restart-case (invoke-restart 'foo 42) (foo (x) (* x x))) except I interactively give it the arguments
efm has joined #lisp
<Shinmera>
there's no :interactive clause for the restart.
<phoe>
oh right
<phoe>
I need to explicitly specify it myself
krid has quit [Ping timeout: 258 seconds]
ukari has joined #lisp
<pjb>
phoe: what word don't you understand in: Too few arguments in call to #<Anonymous Function #x3020027D8B9F>: 0 arguments provided, at least 1 required.
Kundry_W_ has joined #lisp
<phoe>
pjb: there are tons of anonymous functions. Without context which actual function was invoked, this error message is as useful as a lone "The value NIL is not of type NUMBER".
<phoe>
I understand the error message perfectly, I didn't know where exactly it was signaled from.
<pjb>
phoe: yep, more care should be given in identifying the source of errors…
Kundry_Wag has quit [Ping timeout: 256 seconds]
<phoe>
pjb: note that in (restart-case (invoke-restart-interactively 'foo) (foo (x) (* x x))), I *nowhere* provide zero args to an one-arg anonymous function. If I explicitly passed a lambda somewhere, or an empty arglist, I would figure out that something is wrong with it, but in this case, that argument passing is implicit. I had to re-read the spec to find that an empty list is passed in that case.
krid has joined #lisp
sjl_ has quit [Ping timeout: 256 seconds]
rippa has quit [Quit: {#`%${%&`+'${`%&NO CARRIER]
jprajzne has quit [Quit: jprajzne]
jprajzne has joined #lisp
markong has joined #lisp
strongsaxophone has joined #lisp
<strongsaxophone>
How could I read lisp docs ( like defintion of a function in terminal ( something like pydoc for python or man .3 for c )
<no-defun-allowed>
(documentation 'princ 'function) ; ⇒ "Output an aesthetic but not necessarily READable printed representation of OBJECT on the specified STREAM." on SBCL
enigma has quit [Client Quit]
<pjb>
phoe: indeed. The problem is implicit from te definition of the restart foo…
jprajzne has quit [Client Quit]
markoong has quit [Ping timeout: 265 seconds]
jprajzne has joined #lisp
krid has quit [Ping timeout: 256 seconds]
amerlyq has joined #lisp
markoong has joined #lisp
markong has quit [Ping timeout: 265 seconds]
<strongsaxophone>
no-defun-allowed: the output of (documentation 'princ 'function) is nil for me , also I tried it with defvar
<phoe>
strongsaxophone: which CL implementation are you on?
<strongsaxophone>
clisp in archlinux
<strongsaxophone>
I installed it with pacman
<aeth>
DESCRIBE seems to be more reliable for me
<phoe>
hah, clisp seems to contain no docstrings
<aeth>
I think CLISP might be the one that literally launches the Hyperspec in the web browser for DESCRIBE on CL symbols, though
<phoe>
aeth: yes, it just attempted to download the hyperspec on me when I called DESCRIBE
<strongsaxophone>
phoe: What CL implementation are you use ?
<aeth>
This channel is mostly SBCL and CCL.
<phoe>
SBCL here; I strongly suggest it
<aeth>
It used to have a lot of CLISP users, but most left when it didn't have a new release in years (it's been over a decade now at this point afaik)
<aeth>
s/most left/most left CLISP/
<aeth>
Technically, CLISP is alive on life support... active enough for new commits, but not active enough for a new official release.
<aeth>
If you insist on using CLISP, building it yourself to get the latest version is probably the recommended way to do it... but for most purposes, just using SBCL or CCL will be better.
keja_ has quit [Ping timeout: 268 seconds]
gravicappa has quit [Ping timeout: 256 seconds]
<strongsaxophone>
I'm agree to use sbcl which now I find that in pacman DB :)
<aeth>
While CL has a culture of writing portable code, portability libraries don't support every implementation, so the more libraries something uses, the more likely it is to not work on an obscure CL. I use a bunch of libraries that don't support CLISP and I don't really notice anymore because I've stopped testing on CLISP.
<aeth>
ECL has mostly replaced CLISP's niche of having an ultra-portable C-based interpreter that should run anywhere that GCC runs. I don't think implementations that use CLISP to bootstrap in the build-from-scratch process have ported that effort to ECL yet, though.
<phoe>
hmmm - I was wrong
<phoe>
RESTART-BIND's :TEST-FUNCTION argument accepts a condition and can run arbitrary code
<phoe>
I can play with that a lil bit
<jackdaniel>
sbcl recently landed support for bootstrapping from ecl (that led to ecl fixing some issues)
<aeth>
I retract my statement on bootstrapping then.
<phoe>
jackdaniel: good to know!
<jackdaniel>
that said clisp has some portability advantage which ecl doesn't have for now: boehm gc does not build on all platforms
<jackdaniel>
but there are plans to bring back an in-house gc (although not sure when)
<aeth>
ah
<aeth>
Here's hoping that such efforts happen.
<jackdaniel>
example of such platforms: minix3 and wasm userland
<jackdaniel>
but you know how it is -- plans are easy ,)
<jackdaniel>
that said, time to sleep, good night \o
<aeth>
Basically, your Intel computers all have Minix installed.
<fiddlerwoaroof>
I had an amazing time trying to build sbcl on SPARC
<aeth>
On ring -3
<fiddlerwoaroof>
I couldn't get any binaries that worked on my SPARC machine and/or were new enough to bootstrap modern sbcl, so I spent a couple days getting a different implementation to work so I could bootstrap sbcl
<fiddlerwoaroof>
Only to realize that SBCL didn't support threads on SPARC/Solaris
xlei has quit [Ping timeout: 256 seconds]
xlei has joined #lisp
stepnem has quit [Ping timeout: 265 seconds]
stepnem has joined #lisp
Oladon has joined #lisp
iAmDecim has quit [Ping timeout: 256 seconds]
cosimone has quit [Ping timeout: 260 seconds]
sonologico has joined #lisp
iAmDecim has joined #lisp
dddddd has quit [Ping timeout: 256 seconds]
z147 has quit [Quit: z147]
sonologico__ has joined #lisp
akoana has joined #lisp
sonologico has quit [Ping timeout: 272 seconds]
EvW1 has quit [Ping timeout: 265 seconds]
msk has quit [Ping timeout: 264 seconds]
random-nick has quit [Quit: quit]
sonologico__ has quit [Remote host closed the connection]
strongsaxophone has quit [Quit: leaving]
sonologico has joined #lisp
sonologico has quit [Remote host closed the connection]
sonologico has joined #lisp
sonologico has quit [Remote host closed the connection]
markovojvodic84 has joined #lisp
t58 has quit [Quit: Night]
notzmv has quit [Ping timeout: 250 seconds]
notzmv has joined #lisp
iAmDecim has quit [Ping timeout: 260 seconds]
lucasb has quit [Quit: Connection closed for inactivity]
<jcowan>
invoke-debugger might call (posix:exit 1) or (tagbody freeze (go freeze)) or (arduino:assert-pin 13)
<jcowan>
it's the Facade Pattern
Kevslinger has quit [Quit: Connection closed for inactivity]