epony has quit [Remote host closed the connection]
thmprover has quit [Quit: For He Was Great of Heart]
bilegeek has joined #lisp
DHARMAKAYA has quit [Quit: Turning off a portion of this simulation.]
wikipedofile has quit [Quit: Leaving]
wikipedofile has joined #lisp
sebboh has joined #lisp
raeda_ has quit [Quit: Leaving]
slyrus_ has joined #lisp
DHARMAKAYA has joined #lisp
slyrus_ has quit [Ping timeout: 252 seconds]
contrapunctus has joined #lisp
Kundry_Wag has joined #lisp
wikipedofile has quit [Quit: Leaving]
Kundry_Wag has quit [Ping timeout: 240 seconds]
wikipedofile has joined #lisp
Alfr is now known as Guest74161
Alfr has joined #lisp
curtosis has joined #lisp
epony has joined #lisp
Guest74161 has quit [Ping timeout: 250 seconds]
<beach>
Good morning everyone!
<wikipedofile>
how do you pronounce lisp?
nij` has joined #lisp
<wikipedofile>
1) Llthp
<wikipedofile>
2) Lorsp
<wikipedofile>
3) LISP (Faggot)
<wikipedofile>
4) Lasp
<nij`>
Hi! For people who have experience with other languages, have you seen any documentation that's comprehensive as CLHS?
<wikipedofile>
i have not! it's a great tool
slyrus_ has joined #lisp
nicktick has quit [Ping timeout: 240 seconds]
<nij`>
including other lisps? like racket, .. etc?
<nij`>
I've heard that they have great documentations.
<lukego>
speaking of CLHS, is there a way to recognize links to the glossary? for years and years now I've had the problem of constantly landing in the glossary when I am hoping to get somewhere else
slyrus_ has quit [Ping timeout: 240 seconds]
curtosis has quit [Quit: My Mac Mini has gone to sleep. ZZZzzz…]
<beach>
nij`: Python does not have a standard. You need to look into true languages, i.e., those with an independent standard.
<beach>
nij`: Python is more a "programming system" than a "language".
<jcowan>
Python is a language with a reference implementation.
<nij`>
What are some true languages?
<nij`>
no-defun-allowed: thanks :D
<beach>
nij`: Put differently, since Python does not have a standard, its documentation is not meant for people implementing Python systems, so it can be less detailed than a standard.
<beach>
nij`: Bye "true language", I mean a language that has a standard that is independent from any implementation of it, and that is controlled by a different organization than any organization providing implementations.
<jcowan>
Languages with US or international standards are: Ada, APT (a numerical control language), Basic, C, C++, Cobol, Common Lisp, Dibol, Forth, Fortran, Mumps/M, PANCM, Pascal, PL/B (aka Databus), PL/I, Rexx, Scheme, Smalltalk, SQL.
yonkunas has quit [Quit: Connection closed for inactivity]
<beach>
jcowan: Thanks!
<no-defun-allowed>
Ruby has an ISO standard, but from memory it is far from the latest version (Ruby 1.6?)
<nij`>
:-D
<beach>
I hear the situation is the same for C#.
<mfiano>
Missed Prolog and a few more
<beach>
nij`: As I often point out, a project leader or manager who chooses a language without an independent standard for some project, should be fired, because that person jeopardizes the future of the project and perhaps of the company too.
semz has quit [Ping timeout: 250 seconds]
<jcowan>
That's overblown: some projects (and indeed some companies) won't last long enough for that to matter.
xkapastel has quit [Quit: Connection closed for inactivity]
<jcowan>
Yes, I missed Prolog and Ruby
<nij`>
haha beach that sounds like most of them are doing
<nij`>
so.. i can also find C's specification that's as comprehensive as cl?
<no-defun-allowed>
Perhaps they shouldn't have spent so much on the HMS Titanic, because it sunk in the end.
<nij`>
hmm.. the list seems to contain some fairly old langs
<beach>
nij`: Yes, The standards document for C is quite detailed.
<beach>
nij`: That's the good thing about standards. They don't go away over time.
<nij`>
until one day no one uses english anymore
<beach>
nij`: Many do that because they have no training or insight into what it means to be project leaders for programming projects.
<nij`>
I wonder if there's a way to encode info so that even aliens can surely decode
<nij`>
beach: or maybe they just want to ship and earn some livings quickly
<no-defun-allowed>
They don't have to write standards, only use them. Or is there some other reason that one would not ship as soon?
<nij`>
by the way, why is asdf:*central-registry* unrecommended?
<beach>
nij`: no-defun-allowed is right. Choosing a language without a standard does not make things faster. Just worse.
cowona has joined #lisp
frost-lab has joined #lisp
slyrus_ has joined #lisp
<imode>
pretty sure a lot of companies are operating just fine on languages without a formal standard.
<imode>
sure, they suffer a bit more. but there's usually a de-facto implementation somewhere, even with the standard.
semz has joined #lisp
semz has quit [Changing host]
semz has joined #lisp
<imode>
people who build the services you use typically care about the standards of protocols more than they do the standards of their languages, because they're not using obscure languages with dubious long term support... *ahem* some of them aren't.
<no-defun-allowed>
And our hearts are with them...
<beach>
imode: Yes, many do. But some others don't. And none of them seem to write up a risk analysis to see the consequences when things go bad.
<imode>
as someone who's involved with much of the infrastructure powering Amazon, trust me, that's the farthest thing from a risk.
<imode>
the real risk is the tools and languages developed in-house with no documentation around them, let alone a standard.
<imode>
finding maintainers is a risk.
<imode>
overcoming promotion driven development cycles with competent maintenence teams is a risk.
<imode>
"does a language have a standard" is not on any radar.
<beach>
imode: Large companies can afford to have a team that takes up the role of the supplier of the "programming system" they want to use, but that's not the case for many small and medium-sized companies that I see choosing languages without a standard.
slyrus_ has quit [Ping timeout: 265 seconds]
<imode>
small and medium-sized companies are not going to last long enough in their current state to care about language standards.
<jcowan>
Exactly.
<imode>
and by "last long enough" I mean have a product that extracts enough "feature juice" from a particular language to suddenly break when the reference implementation changes.
<imode>
this is by no means me arguing against language standardization. that's the good shit.
<no-defun-allowed>
A presentation run by AWS employees was one of the last "influences" for myself writing a lock-freee hash table.
DHARMAKAYA has quit [Quit: Turning off a portion of this simulation.]
karlosz has joined #lisp
<imode>
most of AWS' design decisions, internally and externally, make you want to write everything from scratch.
<imode>
fwiw we have a custom lisp powering most of the stuff I do.
<no-defun-allowed>
Particuarly that the premise was complaining about garbage collection pauses and generally poor throughput, then using one lock for the in-memory database. Great presentation!
karlosz has quit [Ping timeout: 240 seconds]
<no-defun-allowed>
And then says "we matched the performance of <bleep> DB on this test only involving trivial reads and writes, my work here is done." What a crock of shit. But I am supposed to paying attention in class, so I'll shut up now.
<imode>
I mean. outdo them.
<no-defun-allowed>
At that point, sure, you can afford to be an idiot.
aartaka_d has joined #lisp
<imode>
calling people idiots is usually frowned upon.
srhm has quit [Quit: Konversation terminated!]
<no-defun-allowed>
Yes, I'm careful about saying it out loud.
<imode>
judging software developers by the things they don't know isn't really a productive activity unless you care about stroking your own ego.
aartaka has quit [Ping timeout: 252 seconds]
aartaka has joined #lisp
aartaka_d has quit [Ping timeout: 246 seconds]
<no-defun-allowed>
Or, given that they sell servers, maybe fooling potential customers into writing slow programs makes more money.
<imode>
I can safely say that between the inefficiency hypothesis and the ignorance hypothesis, the latter has more evidence.
slyrus_ has joined #lisp
slyrus__ has joined #lisp
slyrus_ has quit [Read error: Connection reset by peer]
bjorkintosh has joined #lisp
slyrus__ has quit [Ping timeout: 268 seconds]
bitmapper has joined #lisp
aeth_ has joined #lisp
aeth has quit [Disconnected by services]
Inline has quit [Quit: Leaving]
aeth_ is now known as aeth
jonatack has quit [Ping timeout: 240 seconds]
jonatack has joined #lisp
aartaka has quit [Read error: Connection reset by peer]
aartaka_d has joined #lisp
refpga has joined #lisp
karlosz has joined #lisp
slyrus_ has joined #lisp
gaqwas has joined #lisp
gaqwas has quit [Changing host]
gaqwas has joined #lisp
refpga has quit [Remote host closed the connection]
refpga has joined #lisp
waleee-cl has quit [Quit: Connection closed for inactivity]
slyrus_ has quit [Ping timeout: 240 seconds]
refpga has quit [Remote host closed the connection]
remby has joined #lisp
rumbler31 has joined #lisp
tempest_nox has quit [Remote host closed the connection]
slyrus_ has joined #lisp
rumbler31 has quit [Ping timeout: 240 seconds]
shka_ has joined #lisp
slyrus_ has quit [Ping timeout: 240 seconds]
slyrus_ has joined #lisp
DHARMAKAYA has joined #lisp
slyrus_ has quit [Ping timeout: 240 seconds]
cobax has quit [Ping timeout: 240 seconds]
Stanley00 has joined #lisp
Stanley00 has quit [Ping timeout: 240 seconds]
bilegeek has quit [Quit: Leaving]
anticrisis has quit [Read error: Connection reset by peer]
anticrisis has joined #lisp
slyrus_ has joined #lisp
Oladon has quit [Quit: Leaving.]
gaqwas has quit [Ping timeout: 252 seconds]
slyrus_ has quit [Ping timeout: 252 seconds]
karlosz has quit [Quit: karlosz]
slyrus_ has joined #lisp
hjudt has joined #lisp
slyrus_ has quit [Read error: Connection reset by peer]
slyrus_ has joined #lisp
HDurer has quit [Remote host closed the connection]
slyrus_ has quit [Ping timeout: 260 seconds]
remby has quit [Quit: remby]
slyrus_ has joined #lisp
attila_lendvai_ has joined #lisp
slyrus_ has quit [Ping timeout: 240 seconds]
rjcks has joined #lisp
sveit has quit [Ping timeout: 240 seconds]
thonkpod has quit [Ping timeout: 260 seconds]
simplegauss has quit [Ping timeout: 245 seconds]
thonkpod has joined #lisp
simplegauss has joined #lisp
sveit has joined #lisp
johannes_ has joined #lisp
gzj has joined #lisp
wxie has quit [Remote host closed the connection]
orivej has joined #lisp
gzj has quit [Read error: Connection reset by peer]
gzj has joined #lisp
daphnis has joined #lisp
gzj has quit [Remote host closed the connection]
gzj has joined #lisp
wxie has joined #lisp
slyrus_ has joined #lisp
rjcks has quit [Quit: leaving]
DHARMAKAYA has quit [Quit: Turning off a portion of this simulation.]
slyrus_ has quit [Ping timeout: 246 seconds]
gzj has quit [Remote host closed the connection]
gzj has joined #lisp
gzj has quit [Remote host closed the connection]
gzj has joined #lisp
karlosz has joined #lisp
amk has joined #lisp
slyrus_ has joined #lisp
aartaka_d has quit [Read error: Connection reset by peer]
aartaka has joined #lisp
slyrus_ has quit [Ping timeout: 260 seconds]
bitmapper has quit [Quit: Connection closed for inactivity]
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
slyrus_ has joined #lisp
surabax has joined #lisp
slyrus_ has quit [Ping timeout: 246 seconds]
pve has joined #lisp
imode has quit [Ping timeout: 268 seconds]
fourier has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
kevingal has quit [Remote host closed the connection]
andrei-n has quit [Ping timeout: 260 seconds]
kevingal has joined #lisp
bb010g has quit [Quit: Connection closed for inactivity]
sabra has joined #lisp
vv8 has quit [Quit: EXIT]
vv8 has joined #lisp
<nij`>
Fasl v.s. machine binary code, which one is faster?
<jdz>
mu
<no-defun-allowed>
A Lisp implementation does not (usually) directly execute from a FASL.
scm has joined #lisp
<nij`>
?
andrei-n has joined #lisp
<Xach>
nij`: fasl is a generic term for a file that is loaded into a lisp, in theory faster than compiling and loading a source code file. it cannot be meaningfully compared to machine binary code for execution speed.
<no-defun-allowed>
Runtime performance shouldn't be affected by whether the program was loaded from a FASL or a binary object file (though those aren't mutually exclusive; from memory ECL uses object files [think foo.o] as FASLs). Or is there another meaning of "faster"?
nicktick has joined #lisp
ljavorsk has quit [Remote host closed the connection]
<nij`>
Hmm. IIUC, fasl is good while being loaded? After it's loaded, the loaded part is binary anyways?
ljavorsk has joined #lisp
<Alfr>
nij`, it's implementation dependent.
scm has quit [Quit: Leaving]
kmeow has quit [Remote host closed the connection]
<nij`>
i see
<nij`>
i just watched phoe's chat with another youtube guy this jan. i haven't had much coding experience.. but it sounds like the way cl handles conditions is very natural.
<nij`>
is it the case that many other languages, especially those major ones, don't have such conditions handling system?
<no-defun-allowed>
Yes.
<nij`>
I'm very surprised..
<no-defun-allowed>
I am not.
OlCe has quit [Remote host closed the connection]
rodriga has joined #lisp
OlCe has joined #lisp
attila_lendvai_ has quit [Ping timeout: 260 seconds]
<no-defun-allowed>
"Modern" programming languages frequently drop out even boring exception systems, which might help with handling every error case somehow, but makes it tedious to "bubble up" exceptions, let alone use restarts to fix them in a modular manner.
<nij`>
How do they handle errors than?
<nij`>
then*? Just to kill them all?
slyrus_ has joined #lisp
<no-defun-allowed>
By using special return values. The "innovation" is that they can't be confused with success values (as in C) as either kind of value is extracted in a different way.
<nij`>
I wonder if that's really worse, industrial-wise speaking. Maybe that's more about the KISS principle..i dk.
<no-defun-allowed>
Often the handlers written just crash, which I would argue can be done nicer with exceptions, by leaving the decision of whether to crash or not to someone else.
slyrus_ has quit [Ping timeout: 260 seconds]
slyrus_ has joined #lisp
<nij`>
I see.
<no-defun-allowed>
At this point I'm pretty sure there is no point to ever calling something simple.
<nij`>
"Let the program crashes and let the programmers fix them."
<nij`>
This seems fairly simple to me.
frost-lab has quit [Quit: Connection closed]
slyrus_ has quit [Read error: Connection reset by peer]
OlCe has quit [Ping timeout: 246 seconds]
slyrus_ has joined #lisp
<no-defun-allowed>
Some people would say C is simple, as you can point to any expression in isolation and understand what it does. But then I'd say you just write more not-simple code, and any expression isn't doing much at all.
saganman has joined #lisp
<nij`>
Ah yes. The simplicity of tools and actions are almost always contradicting each other.
<nij`>
And (eq 'simple 'easy) => f
<nij`>
But I get what you mean.
<nij`>
I'm just wondering if the powerful condition handling system of CL is something that's really good for the both sides, or it's another kind of curse of lisp.
OlCe has joined #lisp
<no-defun-allowed>
Again with some goddamn "curse"?
<saganman>
lol
<nij`>
Uhh is it not polite to say it here. I apologize in advance..
<no-defun-allowed>
I suppose Dylan also has restarts, but it is mostly CL with Pascal syntax and without interactivity (as long as the debugger won't run on non-Windows).
attila_lendvai has joined #lisp
<saganman>
aren't there lot of ways for conditional handling in lisp?
slyrus_ has quit [Ping timeout: 260 seconds]
<no-defun-allowed>
Oh no, I am sure most #lisp people would believe that nonsense. Can't be making your life any easier.
<nij`>
What's "that"? Curse of Lisp?
<no-defun-allowed>
saganman: As in control flow? The "condition system" is just one abstraction over control flow.
<no-defun-allowed>
Yes.
<saganman>
yeah
attila_lendvai has quit [Remote host closed the connection]
<nij`>
Oooops.. I foudd it making a whole lot of sense.. will be happy if someone'd take time educating me.
<saganman>
it has lot more ways than other programming languages
attila_lendvai has joined #lisp
attila_lendvai has joined #lisp
attila_lendvai has quit [Changing host]
<nij`>
I'd imagine it'd be a drawback for industrial people.
<no-defun-allowed>
(I would also say that some standard CL functions have other ideas of returning non-normal values. GETF takes a default value, FIND, POSITION, ASSOC and others return NIL, GETHASH returns two values and so on.)
<no-defun-allowed>
How would better error handling be a drawback?
<nij`>
If there are many ways to do X, for individuals it's better, but for a group it's harder.
<nij`>
They'd have to communicate which one to use, but with the freedom it's hard to specify.
<MrtnDk[m]>
I wonder if nij` is nij and is they're trying to post Guix stuff to NixOS or some other distribution?
<MrtnDk[m]>
nij` even ...
<nij`>
Im nij.
bitmapper has joined #lisp
<MrtnDk[m]>
OK
<nij`>
MrtnDk[m]: I wasn't trying to post guix stuff to nixos @@ why?
<no-defun-allowed>
There is still only one way to establish restarts and signal conditions and so on. It just happens to be better at it.
<no-defun-allowed>
Any "professional" group tends to set standards on what constructs should be preferred, e.g. the Google Lisp style guide.
attila_lendvai has quit [Remote host closed the connection]
attila_lendvai has joined #lisp
attila_lendvai has quit [Changing host]
attila_lendvai has joined #lisp
<nij`>
Yeah but if the language they use is stupid enough, the workers are regulated automatically.
<MrtnDk[m]>
nij Sorry, my typo. I was wondering if you're just a Guix user, or if you're trying to port (not post, that was a typo) something.
<nij`>
But on the other hand.. they'll have to write more ugly codes.. which will turn into another type of cost anyway.
<no-defun-allowed>
Then you have unproductive and unsatisfied workers. And in any other context, you are just restraining the creative process.
<nij`>
MrtnDk[m]: I was trying to use Guix and learned something. Got a bit burned out yesterday partly because I have no experience with Scheme.
<nij`>
But it's been fun. I don't mind learning very slowly.
<no-defun-allowed>
I may flip the argument around (as Alan Kay did once), and say that you are stuck with the "tyranny of a single implementation" in that case.
<no-defun-allowed>
My previous statement on unproductive workers is very similar to the statement on the importance of an average snippet of C code.
<nij`>
no-defun-allowed: I get that. I still believe that both ways have their pros and cons, and the curse of Lisp is a real thing. Could be a (wildly) naive viewpoint though.. I don't deny.
<no-defun-allowed>
Well, what can I say.
<nij`>
If you are willing to, you could share why you don't think that's a thing. I'm not here for a war, but to really learn great viewpoints from you.
<nij`>
(Really :) But I don't want to be pushy.)
daphnis has quit [Ping timeout: 252 seconds]
<no-defun-allowed>
Same thing I told you last time: "Man, your head is haunted, you have bats in your belfry!"
<nij`>
On the haskell thing xD?
<nij`>
To take off bats from my belfry, the best thing I could do is to talk to experienced people.
<no-defun-allowed>
The last time you bored me with this phantasm of the "curse of Lisp".
<nij`>
:(
<nij`>
BTW (a completely different question..), can I dry-run asdf and see what packages it will grab, given a (defsystem..)?
<Shinmera>
"grab"?
<nij`>
no-defun-allowed: Hey cool off. I'm just a naive noob who wants to learn. Sorry to have bored you though.
<nij`>
Shinmera: yeah.. like which path will it be looking at.
<Shinmera>
what do paths have to do with packages
<nij`>
Shinmera: for example, in `:depends-on ("optima.ppcre" "command-line-arguments")`, asdf will look for "optima.ppcre" in my machine.
elflng has quit [Ping timeout: 240 seconds]
<no-defun-allowed>
You want to know where a system is stored?
<nij`>
But there might be many "optima.ppcre". I'd hope to dry run and see a list of all "optima.ppcre" it finds (with the first thing being what it will load).
<Shinmera>
there may not be many.
<nij`>
Shinmera: On guix there will be, I suppose.
<Shinmera>
I explained this to you before. ASDF can only know of one system definition at once.
<no-defun-allowed>
I know of asdf:system-relative-pathname, and there is likely another function for finding the pathname of the asd file used.
<nij`>
Shinmera: ASDF will look for the asd files by how it's configured, and load the first one it's found. Is that right? (based on my impression of skimming through the manual this morning)
<Shinmera>
I don't know about first found, but what it find depends on its configuration, sure.
<no-defun-allowed>
nij`: I'm sorry that I came off that way. In summary, my view is that one requires incompatible experiments in order to make a _good_ decision, rather than _a_ decision (which is apparently preferable to some people).
ljavorsk has quit [Ping timeout: 240 seconds]
Kundry_Wag has joined #lisp
hypercube has quit [Ping timeout: 252 seconds]
<no-defun-allowed>
But as Shinmera said, ASDF only uses one system per name. And systems are not packages.
<nij`>
Yeah.. but I'd hope I can _dry-run_ ASDF, sort of like using ASDF as a search engine, and see what file it _would_ load if not being dry-run.
<flip214>
nij`: run ASDF with an invalid source directory and catch the conditions that are thrown ;)
<Shinmera>
You can't, really. Even figuring out where the systems are may load systems.
OlCe has quit [Ping timeout: 246 seconds]
Bike has joined #lisp
<nij`>
flip214: ? what do you mean?
<no-defun-allowed>
Is that because of :defsystem-depends-on? I am not that familiar with ASDF.
<Shinmera>
no-defun-allowed: that, and ASD files being Lisp source files that can generally do whatever they want.
<no-defun-allowed>
True.
<Alfr>
nij`, asdf:locate-system
<Shinmera>
no-defun-allowed: systems might even be defined programmatically with no canonical file to define them
<nij`>
Alfr: (asdf:locate-system :asdf) doesn't return where asdf is XD!
<nij`>
Oh, but it did for local-time.
<nij`>
Hmm.. this is good, but i'd hope I can dry-run.
slyrus_ has joined #lisp
<nij`>
And also, I'd hope asdf can search all systems that satisfy the requirement given in the (defsystem..) code.
<Alfr>
nij`, unless asdf.asd can be found with your source-registry configuration, it won't show.
<no-defun-allowed>
Also possible, yes.
<nij`>
no-defun-allowed: dry-run is possible?
<no-defun-allowed>
I meant that systems can be produced without a defsystem, as Shinmera pointed out.
<no-defun-allowed>
Loosely speaking, loading a system can run arbitrary code in here and there and a few other places, so a dry run would not be possible.
slyrus_ has quit [Ping timeout: 252 seconds]
<Shinmera>
not just loading a system, but even just loading its definition.
wsinatra has joined #lisp
<no-defun-allowed>
Yep.
skapata has joined #lisp
daphnis has joined #lisp
andrei-n has quit [Quit: Leaving]
waleee-cl has joined #lisp
<nij`>
So what I need (to write perhaps on my own) is a function that intakes the definition and the current configuration of asdf, and outputs a list of paths that would be loaded.
MrFantastik has joined #lisp
jeosol has quit [Quit: Connection closed]
<MrFantastik>
is there a preffered pastebin for this channel?
<MrFantastik>
I've been shamed for using pastebin before
<Alfr>
nij`, you might want to look into asdf's make-plan.
<MrFantastik>
So i feel like its prudent to ask
<Bike>
you have QUERYSTRING quoted, which you probably don't want
<MrFantastik>
the example for :query in quri uses quotes
<MrFantastik>
but that is correct I don't want lol
<contrapunctus>
I noticed that a Lisp program had a package definition which exported :foo, but the function it meant to exported was called bar. And when you think about it, that's duplication...is there a way to specify that a symbol is to be exported, within the defining form itself?
<MrFantastik>
but I'm not sure how to proceed
<Bike>
wel, the example isn't doing what you want, then
<nij`>
Alfr!! That seems what I want but isn't well documented in the manual.
<Bike>
probably you just want to backquote
<contrapunctus>
meant to * export
<Alfr>
nij`, you'll have to dive into the sources, it think.
<MrFantastik>
backquote has same result
<Bike>
i meant: `(("output" . "firefox") ("search" . ,querystring))
<Bike>
the comma means "actually evaluate this part"
<MrFantastik>
interesting!
<MrFantastik>
that works
<Bike>
regular quotation means, straightforwardly, do not evaluate this
<Alfr>
nij`, tough beware, it will load the .asd files, so whatever actions happen in these will be run.
<Bike>
so with your first attempt you construct a cons of ("SEARCH" . QUERYSTRING), a string and a symbol
<Bike>
and it interprets the symbol as a designator for the string "QUERYSTRING", thus the result
<Bike>
contrapunctus: i don't think it's really duplication - one defines the function/whatever and one defines the interface. If you want to keep a function but unexport it later you can just remove it from the package exports list later without touching the function code.
<Bike>
contrapunctus: but if you really want you could define a macro that calls EXPORT
<nij`>
Alfr: yeah I'd have to extract the parts that make the pure plan.
<nij`>
Thanks a lot :)
<contrapunctus>
Bike: thanks, glad to know there's another way.
jeosol has joined #lisp
varjag has quit [Quit: ERC (IRC client for Emacs 26.3)]
<Alfr>
nij`, .asd-files can contain arbitrary lisp expressions, you won't be able to always get away with simply reading these files.
<MrFantastik>
working version of what I was trying to do
<MrFantastik>
might be useful for fellow stumpwm users :)
<nij`>
What does google-search-suggestion do?
<nij`>
contrapunctus has left #lisp ["Disconnected: Replaced by new connection"]
contrapunctus has joined #lisp
<MrFantastik>
return a list of suggestions that google would suggest for you
contrapunctus has left #lisp ["Disconnected: closed"]
<MrFantastik>
the idea being when running a search from a stumpwm menu, I can add autocompletion to it and suggestions
contrapunctus has joined #lisp
<nij`>
Oh I see! That's great :D
<nij`>
How hard is it to decouple with google? - so I can use it with other search engine?
OlCe has joined #lisp
<beach>
Xach, jackdaniel: Thanks!
<MrFantastik>
it would be pretty easy, remove the nth 1 on line 15 any swap (google-search-uri querystring) with whatever search engine you prefer
<nij`>
MrFantastik: I've been always wanted to extend my stumpwm.. but with the power of emacs' selecting packages like ivy or helm.
<nij`>
Have you thought about that?
<nij`>
Same goes for the browser nyxt..
<beach>
nij`: Were you seriously suggesting that returning special values to indicate errors is as good as a condition system?
tfb has joined #lisp
<nij`>
beach: No. I can see the good part of CL's condition system. I'm just wondering if that will make it harder for a (large) group of people.
<beach>
On the contrary.
<MrFantastik>
nij` yea I've done a bit of work on that for mine, I think that it could be possible with stumpwm:select-from-menu
<beach>
Returning special values in extremely error prone because all "intermediate function" will have to know about every error situation. An "intermediate function" is a function that neither knows how to handle an error nor how to trigger one. I can't even imagine how a group of people would have to deal with all possible error values for all possible intermediate functions.
<MrFantastik>
the only issue i could see with it is updating the list of items that you are completing on with new keypresses
<MrFantastik>
not really a problem for something like a helm style completion system, but a bit of an issue for a search engine
<nij`>
MrFantastik: you mean to have a better stumpwm menu? Or to have a emacs drop down available so we can select using ivy?
<nij`>
Oh I suppose it's the former.
<nij`>
Hmm.
random-nick has joined #lisp
<MrFantastik>
yes the former
<nij`>
Have you thought of making use of ivy/helm?
<MrFantastik>
I use helm in emacs
<MrFantastik>
never thought about using it in stumwpm though
<nij`>
beach: Ah.. that could be my thinking gap. I wasn't aware of the intermediate functions. When I wrote a program, I tried to let all functions handle all errors.. which quickly dries me out.
ebrasca has joined #lisp
<nij`>
MrFantastik: I mean.. if we have a good selecting functionality for stumpwm one day, we will have to write one for nyxt.
<nij`>
And so on.
<nij`>
Given that most (many?) lispers use emacs, I figured why not just make calling ivy/helm easier?
<beach>
nij`: And you could never use functions like MAPCAR.
<tfb>
nij`: not having a condition system (or, exceptions at least) is a way of being very sure that large programs are unsafe, because *every single function* needs to check for unexpected error returns. And ... they won't.
<nij`>
They had been developed for a while and are quite sophisticated.
<nij`>
beach: OH! Why is that the case?!
<beach>
nij`: You would have to write a special version of it so that it would check for errors every time it invokes its first argument.
<MrFantastik>
stumwpm:select-from-menu is fairly robust for creating custom menus
<nij`>
tfb: Yes. I'm very enlightened by this conversation. So I shouldn't write error check for all functions.. but just a tiny part of them?
<nij`>
Well, beach, say we have (mapcar #'f '(x1 x2 x3)).
<MrFantastik>
there is also an option to show a menu for state transitions which is similar to the thing in emacs that shows a help in the modeline
<nij`>
If f knows gives error, we can know that's from f, right?
<MichaelRaskin>
tfb: with a strong enough type system and a bit of helpers for passing-through the errors you can keep safety. Rust does. Of course you lose restarts
<tfb>
nij`: most of your functions won't even know an error happened: they'll call something and ... it will never return because it raised an exception which got handled somewhere up the stack
<MrFantastik>
which-key-mode
<nij`>
MrFantastik: How about recency and frequency?
<beach>
nij`: Yes, then after calling (funcall #'f x1), MAPCAR would have to check for an error and return some other error, before calling #'f on x2.
<nij`>
And can you configure it so that it uses your matching/sorting algorithm?
<MrFantastik>
nij neither of those are built in
contrapunctus has left #lisp ["Disconnected: Replaced by new connection"]
contrapunctus has joined #lisp
<MrFantastik>
you can configure the mathching algorithm and sorting algo though
hypercube has joined #lisp
<MrFantastik>
you pass the elements that you would like to match against and an optional function for matching
<nij`>
cool. i will look more into stumpwm's manual for this! thanks for sharing :) MrFantastik
<MrFantastik>
the source for them isn't too daunting either
contrapunctus has joined #lisp
<nij`>
Oh yes, based on experience I think going for their source is better.
<MrFantastik>
I don't think its supported atm
<MrFantastik>
I would like that though too
<MrFantastik>
maybe it will happen in mahogony
<nij`>
I think it's very inconvenient to have more than a window in a frame..
<nij`>
! How did mahogony go?
Necktwi has joined #lisp
<nij`>
Uhrr.. it's for wayland.
<MrFantastik>
most linux distro's are switching to wayland
<MrFantastik>
although I'm not looking forward to biting that bullet
<MrFantastik>
I'm already comfortable with my X bugs, now I need to learn a whole new class of bugs!
johannes_ has quit [Quit: leaving]
<edgar-rft>
wayland gives us 3D bugs!
pjb has joined #lisp
<nij`>
XD
daphnis has quit [Ping timeout: 240 seconds]
daphnis has joined #lisp
<Nilby>
I never thought 36 years later, someone would invent a window system with a worse user experience than X11. I guess I'll just have to wait until Excel implements the CL condition system.
<nij`>
?? Is wayland's user experience worse than that of x11?
<pjb>
nij`: AFAIK, yes. For example, you cannot run applications on remote hosts.
<pjb>
nij`: same problem with Display Postscript vs. Aqua.
<astronavt>
im not sure thats considered a "worse" experience for today's typical desktop usages
<pjb>
astronavt: I use X11 remotely almost every day.
<astronavt>
the bigger issue with wayland is that a lot of what people expect as standard desktop functionality (e.g. copy and paste) was left unspecified and the community had to develop their own set of protocols on top of wayland, which the compositor has to explicitly support/implement
slyrus_ has joined #lisp
<astronavt>
pjb: im sure, but you probably aren't the basic desktop/laptop user that the people who pushed wayland had in mind :)
<astronavt>
its a magnified version of the copy and paste issue - they put all this work into making a new low-ish level protocol and left everything else as an exercise to the reader
<beach>
Personally, I am really tired of frequently being someone they didn't have in mind.
<beach>
What? More than one workspace?
<beach>
What? You want to launch the document viewer on the same document, but twice?
<pjb>
Exactly.
<beach>
What? You don't want to restart your browser when the code is updated?
<astronavt>
hold on, my "not had in mind" part was just related to using it remote
<beach>
What? You don't want to turn off your applications when the OS kernel is updated?
<beach>
Who are you?
<astronavt>
lol
Josh_2 has joined #lisp
<astronavt>
its a bit like a programming language, really - they invented this core language that, in theory, solves all problems. but none of the actual user-facing "tooling" was implemented or even specified
<Josh_2>
Ello
jurov has quit [Ping timeout: 252 seconds]
<MichaelRaskin>
astronavt: well, and then the reality is that they only care about no-customisation Gnome users
<astronavt>
indeed
<MrFantastik>
reminds me of the systemd transition a few years ago
<astronavt>
look at all the successful hipster programming langs - they all come with their own test runner, docs generator, auto-formatter, etc.
<astronavt>
if they didn't, nobody would have started using them
<TMA>
What, you don't want the computer rebooting just because you went away from it for five minutes?
<MrFantastik>
I do like having code autoformatting
<MichaelRaskin>
astronavt: pretty sure Julia did not have an official auto-formatter and might still not have it
slyrus_ has quit [Ping timeout: 265 seconds]
<MrFantastik>
saves me from the most annoying of code review criticisms
<astronavt>
thats fair, although julia is somewhat of an odd case, being domain-specific by design
<astronavt>
meanwhile look at how polished the julia repl is
heisig has joined #lisp
<MichaelRaskin>
I mean, they can _talk_ about domain specificity, but by now the only thing I like better about Common Lisp for any domain, is less ecosystem churn in the sense that a random library might get bugs fixed but won't get a redesign.
daphnis has quit [Ping timeout: 265 seconds]
<MichaelRaskin>
(It helps that Julia's design explicitly references the things I like most about Common Lisp)
<astronavt>
thats a good point
<astronavt>
i havent seen e.g. a webserver implemented in julia but i don't see any reason why you wouldn't want to
<astronavt>
and its really wonderful for its intended problem domain as wellp
<astronavt>
well*
daphnis has joined #lisp
<MrFantastik>
what is the intended problem domain for julia?
<MrFantastik>
scientific computing?
<MichaelRaskin>
Yes
<MrFantastik>
I find it more cumbersome than python for most things
<MrFantastik>
I'm not used to julia though so ¯\_(ツ)_/¯
<Bike>
because you're supposed to use all the source registry stuff instead
jurov has joined #lisp
<nij`>
Got ya!
* nij`
is caught another time by Alfr that he hasn't read chapter8+9.
<nij`>
Well I started from the first section.. and is almost there.
<Alfr>
nij`, lol
slyrus_ has quit [Ping timeout: 240 seconds]
<nij`>
haha yeah my question is about 4.2, proving that i'm reading. thanks anyways!
luckless_ has joined #lisp
slyrus_ has joined #lisp
luckless has quit [Ping timeout: 240 seconds]
Sheilong has joined #lisp
slyrus_ has quit [Ping timeout: 260 seconds]
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
hypercube has quit [Ping timeout: 252 seconds]
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
tfb has quit [Remote host closed the connection]
tfb has joined #lisp
orivej has quit [Ping timeout: 240 seconds]
tfb has quit [Remote host closed the connection]
tfb has joined #lisp
tfb has quit [Remote host closed the connection]
tfb has joined #lisp
tfb has quit [Remote host closed the connection]
tfb has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
tfb has quit [Remote host closed the connection]
amb007 has joined #lisp
tfb has joined #lisp
tfb has quit [Remote host closed the connection]
tfb has joined #lisp
tfb has quit [Remote host closed the connection]
hiroaki_ has joined #lisp
tfb has joined #lisp
xsperry has quit []
<nij`>
Stumpish is a shell interface to stumpwm: https://github.com/stumpwm/stumpwm-contrib/blob/master/util/stumpish/stumpish . I wonder how it talks to the running stumpwm without invoking any swank/slynk server. The key seems to be on line#83, where `xprop ..` is invoked to send the command to stumpwm. Has anyone heard of such magic to interact with an on-live lisp program?
amb007 has quit [Read error: Connection reset by peer]
tfb has quit [Remote host closed the connection]
amb007 has joined #lisp
tfeb has joined #lisp
<Bike>
xprop is part of x11
<Bike>
it works because stump is the x server (i think, i'm not good with X terms)
slyrus_ has joined #lisp
<Bike>
so probably wouldn't work for lisp programs generally
OlCe has quit [Ping timeout: 246 seconds]
aartaka_d has joined #lisp
OlCe has joined #lisp
aartaka has quit [Ping timeout: 260 seconds]
slyrus_ has quit [Ping timeout: 260 seconds]
<nij`>
Hmm.. but the command must go from some entry into the lisp of stumpwm, right?
<Bike>
xprop associates the root window with a property list including :STUMPWM_COMMAND "some command", basically, and then stumpwm reads that and sets a STUMPWM_COMMAND_RESULT property
<Bike>
any lisp program with an x window easily identifiable from the stumpish analog could do something like this, i think
<Bike>
so, not lisp programs in a shell for instance
<Nilby>
X properties is a really bad way to communicate to a running lisp. Probably better to start swank in your target lisp, and then send commands with swank-client from another lisp.
OlCe has quit [Ping timeout: 260 seconds]
<nij`>
yes it's a very degenerated way.. hmm
<Bike>
it definitely seems a little hackish, or at least worse than sockets
saganman has left #lisp ["WeeChat 1.6"]
<nij`>
Nilby: the problem I had with swank/slynk for stumpwm is that.. sometimes if I accidentally kill the server that links with the running stumpwm, stumpwm crashes.
rogersm has quit [Quit: Leaving...]
slyrus_ has joined #lisp
<Bike>
wouldn't the stumpwm be running the swank server?
<Bike>
sounds like a job for handler-case anyway
sjl has joined #lisp
<nij`>
? What ya mean?
<nij`>
You can run a swank server within stumpwm. And then connect to that swank server from emacs. Yes.
ramHero has quit [Remote host closed the connection]
<nij`>
Oh, btw, how do I search for listening swank/slynk servers on my localhost? `M-x sly-list-connections` only shows those that are connected.
<Bike>
you said "the server that links with the running stumpwm" as if the server was outside of stumpwm and communicating with it
<Bike>
and with handler-case i just mean you should make the code running the swank server error tolerant so the whole thing doesn't crash if the swank server hits an unexpected problem
<Bike>
doesn't seem like anything unique to swank
<nij`>
I see.
hypercube has joined #lisp
OlCe has joined #lisp
cage_ has joined #lisp
DHARMAKAYA has joined #lisp
tfeb has quit []
hypercube has quit [Ping timeout: 240 seconds]
xsperry has joined #lisp
Nilby has quit [Ping timeout: 258 seconds]
<gendl>
Hi, is there a defacto standard Abstract Associative Map for CL?
slyrus_ has quit [Ping timeout: 252 seconds]
<gendl>
something which has a consistent set of accessor/setter functions, and maybe uses a plist or alist under-the-hood for small maps, and automatically converts itself to & from a hash table when the map size exceeds or shrinks below a certain threshhold value?
<pjb>
Well, a generalized accessor. The actual access is determined from the indexed object.
slyrus_ has quit [Ping timeout: 252 seconds]
slyrus_ has joined #lisp
slyrus_ has quit [Ping timeout: 265 seconds]
amb007 has quit [Read error: Connection reset by peer]
ramHero has joined #lisp
amb007 has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
hiroaki_ has quit [Ping timeout: 260 seconds]
amb007 has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
imode has joined #lisp
jurov has quit [Ping timeout: 240 seconds]
mindCrime has joined #lisp
gitgood has joined #lisp
slyrus_ has joined #lisp
slyrus_ has quit [Ping timeout: 240 seconds]
jurov has joined #lisp
aindilis` has quit [Ping timeout: 265 seconds]
yitzi has joined #lisp
orivej has joined #lisp
slyrus_ has joined #lisp
karlosz has joined #lisp
slyrus_ has quit [Ping timeout: 260 seconds]
orivej has quit [Ping timeout: 260 seconds]
orivej_ has joined #lisp
klltkr has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
remby has joined #lisp
gaqwas has joined #lisp
slyrus_ has joined #lisp
slyrus_ has quit [Ping timeout: 246 seconds]
flazh has joined #lisp
slyrus_ has joined #lisp
mindCrime has quit [Ping timeout: 240 seconds]
hypercube has quit [Ping timeout: 265 seconds]
cosimone has joined #lisp
slyrus_ has quit [Ping timeout: 260 seconds]
Inline has joined #lisp
yitzi has quit [Quit: yitzi]
yitzi has joined #lisp
contrapunctus has left #lisp ["Disconnected: Replaced by new connection"]
contrapunctus has joined #lisp
contrapunctus has left #lisp ["Disconnected: closed"]
contrapunctus has joined #lisp
rumbler31 has joined #lisp
karlosz has quit [Ping timeout: 268 seconds]
slyrus_ has joined #lisp
slyrus_ has quit [Ping timeout: 260 seconds]
heisig has quit [Quit: Leaving]
aindilis has joined #lisp
Sauvin has quit [Read error: Connection reset by peer]
hiroaki_ has joined #lisp
OlCe has quit [Ping timeout: 240 seconds]
slyrus_ has joined #lisp
varjag has joined #lisp
slyrus_ has quit [Ping timeout: 240 seconds]
jeosol has quit [Quit: Connection closed]
jeosol has joined #lisp
bilegeek has quit [Quit: Leaving]
daphnis has quit [Ping timeout: 240 seconds]
tainguyen has joined #lisp
slyrus_ has joined #lisp
cosimone has quit [Read error: Connection reset by peer]
slyrus_ has quit [Ping timeout: 246 seconds]
yitzi has quit [Quit: yitzi]
yitzi has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
terpri_ has joined #lisp
terpri has quit [Remote host closed the connection]
tainguyen has quit [Ping timeout: 240 seconds]
srhm has joined #lisp
Lord_of_Life has quit [Read error: Connection reset by peer]
rumbler31 has quit [Remote host closed the connection]
aeth_ has joined #lisp
Lord_of_Life has joined #lisp
aeth has quit [Disconnected by services]
aeth_ is now known as aeth
slyrus_ has joined #lisp
ljavorsk has joined #lisp
slyrus_ has quit [Ping timeout: 260 seconds]
tainguyen has joined #lisp
remby has left #lisp ["Good Bye"]
yitzi has quit [Quit: yitzi]
eden has quit [Ping timeout: 240 seconds]
slyrus_ has joined #lisp
slyrus_ has quit [Ping timeout: 268 seconds]
terpri_ is now known as terpri
daphnis has joined #lisp
slyrus_ has joined #lisp
long4mud has joined #lisp
slyrus_ has quit [Ping timeout: 260 seconds]
slyrus_ has joined #lisp
slyrus_ has quit [Ping timeout: 265 seconds]
cage_ has quit [Quit: Leaving]
mindCrime has joined #lisp
Lord_of_Life_ has joined #lisp
Lord_of_Life has quit [Ping timeout: 240 seconds]
Lord_of_Life_ is now known as Lord_of_Life
slyrus_ has joined #lisp
slyrus_ has quit [Ping timeout: 252 seconds]
hypercube has joined #lisp
karlosz has joined #lisp
raeda has joined #lisp
yitzi has joined #lisp
aartaka has joined #lisp
nij has joined #lisp
krjli has joined #lisp
aartaka_d has quit [Ping timeout: 260 seconds]
aartaka_d has joined #lisp
aartaka has quit [Ping timeout: 240 seconds]
Codaraxis_ has joined #lisp
Codaraxis has quit [Read error: Connection reset by peer]
OlCe has joined #lisp
Elzington__ has quit [Quit: Leaving]
wsinatra has quit [Quit: WeeChat 3.1]
slyrus_ has joined #lisp
gaqwas has quit [Ping timeout: 240 seconds]
akoana has joined #lisp
aeth_ has joined #lisp
aeth has quit [Disconnected by services]
aeth_ is now known as aeth
dunk has quit [Ping timeout: 250 seconds]
gendl has quit [Ping timeout: 250 seconds]
Balooga has quit [Ping timeout: 250 seconds]
abrantesasf has joined #lisp
travv0 has quit [Ping timeout: 245 seconds]
p_l has quit [Ping timeout: 245 seconds]
bytesighs has quit [Ping timeout: 258 seconds]
conjunctive has quit [Ping timeout: 258 seconds]
XachX has quit [Ping timeout: 258 seconds]
jmercouris has quit [Ping timeout: 260 seconds]
alanz has quit [Ping timeout: 260 seconds]
chewbranca has quit [Ping timeout: 248 seconds]
pent has quit [Ping timeout: 250 seconds]
sgithens has quit [Ping timeout: 245 seconds]
dunk has joined #lisp
rme has quit [Ping timeout: 258 seconds]
Balooga has joined #lisp
b20n has quit [Ping timeout: 246 seconds]
entel has quit [Ping timeout: 260 seconds]
parisienne has quit [Ping timeout: 245 seconds]
physpi has quit [Ping timeout: 245 seconds]
gendl has joined #lisp
jcowan has quit [Ping timeout: 246 seconds]
rme has joined #lisp
alanz has joined #lisp
b20n has joined #lisp
XachX has joined #lisp
travv0 has joined #lisp
parisienne has joined #lisp
jmercouris has joined #lisp
conjunctive has joined #lisp
p_l has joined #lisp
pent has joined #lisp
entel has joined #lisp
jcowan has joined #lisp
bytesighs has joined #lisp
physpi has joined #lisp
chewbranca has joined #lisp
sgithens has joined #lisp
rodriga has quit [Ping timeout: 240 seconds]
shka_ has quit [Ping timeout: 265 seconds]
slyrus_ has quit [Ping timeout: 252 seconds]
cosimone has joined #lisp
rumbler31 has joined #lisp
<jmercouris>
anyone know how to reliably determine the graphics card driver being used?
<jmercouris>
is there something like a *hardware-features* :D?
<Bike>
that sounds like a question for your operating system
<jmercouris>
I always figure I should ask because the spec has surprised me many many times
<Bike>
lspci for example
rumbler31 has quit [Ping timeout: 260 seconds]
<jmercouris>
right, or modinfo perhaps
<Bike>
but no, there's nothing in the standard. if you look in the "Environment" section you can see what query functions there are. basically just a version and "type"
kevingal has quit [Remote host closed the connection]
daphnis has quit [Ping timeout: 252 seconds]
<Bike>
the nature of both of which is basically up to the implementation
contrapunctus has left #lisp ["Disconnected: Replaced by new connection"]
contrapunctus has joined #lisp
slyrus_ has quit [Ping timeout: 240 seconds]
MrFantastik has quit [Ping timeout: 240 seconds]
long4mud has joined #lisp
contrapunctus has left #lisp ["Disconnected: closed"]
contrapunctus has joined #lisp
OlCe has quit [Ping timeout: 252 seconds]
__jrjsmrtn__ has joined #lisp
_jrjsmrtn has quit [Ping timeout: 268 seconds]
slyrus_ has joined #lisp
slyrus_ has quit [Ping timeout: 268 seconds]
defaultxr has quit [Ping timeout: 252 seconds]
Inline has quit [Quit: Leaving]
slyrus_ has joined #lisp
Lycurgus has quit [Quit: Exeunt]
attila_lendvai has quit [Ping timeout: 252 seconds]
slyrus_ has quit [Ping timeout: 252 seconds]
varjag has quit [Quit: ERC (IRC client for Emacs 28.0.50)]
ljavorsk has quit [Ping timeout: 252 seconds]
surabax has quit [Quit: Leaving]
DHARMAKAYA has quit [Quit: Turning off a portion of this simulation.]
actuallybatman has joined #lisp
random-nick has quit [Ping timeout: 265 seconds]
frgo has quit [Remote host closed the connection]
frgo has joined #lisp
mmontone has joined #lisp
cosimone has quit [Remote host closed the connection]
pve has quit [Quit: leaving]
slyrus_ has joined #lisp
slyrus_ has quit [Ping timeout: 240 seconds]
slyrus_ has joined #lisp
nicktick has quit [Ping timeout: 240 seconds]
mindCrime has quit [Ping timeout: 240 seconds]
hjudt has quit [Ping timeout: 252 seconds]
slyrus_ has quit [Ping timeout: 265 seconds]
slyrus_ has joined #lisp
ebrasca has quit [Ping timeout: 268 seconds]
X-Scale` has joined #lisp
slyrus_ has quit [Ping timeout: 240 seconds]
X-Scale has quit [Ping timeout: 252 seconds]
X-Scale` is now known as X-Scale
MrFantastik has joined #lisp
xkapastel has joined #lisp
<MrFantastik>
can I override the behavior of a library's function in a let statement and have it return to its original implementation when i exit that context?