<DusXMT>Does patch-shebang also fix shebangs of scripts which start with /usr/bin/env ?
<mark_wea`>jxself: on my Libreboot X60, sound doesn't work when I first boot into standalone guix. I need to do this after boot to get sound working: rmmod snd_hda_intel && modprobe snd_hda_codec_analog && modprobe snd_hda_intel
<paroneayea>the store monad thing has lead me to get interest enough to read up on monads
<paroneayea>the whole "carrying around a context in a functional manner" is exactly a problem I've been dealing with lately... except my solution was just to pass around a "context" object to each function with various variables attached ;p
*paroneayea taking a pretty lazy saturday of reading up on things :)
<philed>paroneayea: IMHO, monads only become cool as an abstraction. Carrying around contexts is something we've always been doing. But the stuff in your standard monad library in Haskell showed me what I'd been missing.
<tadni_>paroneayea: Sounds fun. I need to get moving in an hour and mow two lawns... then probably relax and update my blog and maybe start packaging clisp. :^P
<paroneayea>philed: yeah... well, I'm not convinced *yet* that using monads will make the things I want to do less heavy :)
<paroneayea>there seems to be a lot of overhead involved, just moved elsewhere?
<philed>I've only ever used them in earnest in statically typed languages. I'm somewhat sceptical of their utility in dynamically typed languages, but maybe my forays into Guile will convince me otherwise. :)
<philed>mark_weaver: Do you have any references to articles that discuss the issue in detail?
<philed>I've only enjoyed dynamic scoping in CL, at a time when I didn't have a clue about lazy evaluation.
<mark_weaver>philed: no, but it's a well-known problem with dynamic scoping.
<philed>Well, we were talking about carrying around contexts, and monads, and when you are doing things with monads, you typically force an evaluation order, which isn't going to play nicely with what you expect of laziness. I'm guessing it's still a problem.
<mark_weaver>lazy streams also force an evaluation order, and yet they obviously play well with laziness.
<mark_weaver>the problem is that when you delay evaluation of an expression (ultimately using 'lambda'), and then the promise is later forced, it's not clear what portions of the dynamic environment should come from when the lambda was evaluated, and what portions should come from the code that forced the promise.
<mark_weaver>for example, suppose you have a dynamic variable that specifies how much precision to use for inexact math operations.
<mark_weaver>you want to run some computation with high precision, so you set the associated dynamic variable.
<mark_weaver>but now, suppose that one of the things that code does is to consult some lazy streams. now, the code that computes some more elements of that lazy stream will run at high precision, which is not what you wanted.
<mark_weaver>in a system where lazy evaluation is used, dynamic environment settings tend to leak to code that you didn't have any way to anticipate.