4 ms·
> Why would I want implicit laziness everywhere? For the same reason you want automatic memory management: so you can fob off the job of figuring out where the
by lisper 10y ago
> Why would I want implicit laziness everywhere?
For the same reason you want automatic memory management: so you can fob off the job of figuring out where the thunks should go onto the compiler, just as you fob off the job of figuring out where the calls to malloc and free should go. At least that's the theory. It seems plausible to me. I think it's an open question whether my failure to grok Haskell is due to a problem with Haskell or the ossification of my brain.
- AnimalMuppet 10y agoNot trying to troll you here... To what degree do you use Lisp as an FP language? As a pure FP language? The forced purity may make Haskell a very different language. And, to return to your original complaint: If you dislike new languages, I bet XML drives you straight up the wall...
- lisper 10y ago> To what degree do you use Lisp as an FP language? As a pure FP language? It depends on what I'm doing, but I generally write in an OO style more than a functional style. Real problems have state. > If you dislike new languages I want to be clear that this is just a general observation. I don't dislike new things because they are new, I tend to dislike them because they are generally bad. But they are not all bad. Clojure is cool. WebASM is very cool. The work that has been done on Javascript compilers is nothing short of miraculous (even though the language itself still sucks). > I bet XML drives you straight up the wall Kind of, but not really. Yes, I dislike XML because it is nothing but S-expressions with a more complicated syntax. But it doesn't drive me up a wall because when I need to deal with XML I just parse it into S-exprs, do what I need to do, and render the results back into XML.
- bbcbasic 10y agoPure FP deals with state!
- kazinator 10y agoState is something that is best just embraced rather than "dealt with".
- bbcbasic 10y agoAn analogy to that is that OO doesn't embrace IO. Yet weirdly enough that makes OO-IO better than older languages that have built in commands to write to disk. Haskell doesn't have state but you have multiple models to choose from, from simple folds to STM or State or Reader or Writer Monads all of which serve different purposes and do different jobs well.
- kazinator 10y agoOOP absolutely embraces I/O. I/O begs to be OOP and makes, hands down, the best use case for illustrating OOP.
- bbcbasic 10y agoWhat I am getting at is that OOP languages like C++ have no IO commands built in it is all delegated to libraries. Haskell has no state support built in, it is all delegated to libraries. So: C++ has excellent IO support, but the language doesn't embrace IO at all. Haskell has excellent State support, but the language doesn't embrace State at all.
- kazinator 10y agoC++ I/O libraries in fact depend on the sequencing semantics built into the language. If we make two calls to the library, they happen in that order; consequently, the I/O happens in that order. We can do wrong things like: f(cout << x, cout << y) where we don't know whether x is sent to cout first or y. C++ statements could be added to C++ (e.g. as a compiler extension). They would be straightforward to use; C++ doesn't inherently reject that the way Haskell and its ilk reject sequencing and state.
- kazinator 10y agoI dislike XML because it's a nested tree of internal nodes and typeless character string leaves. In XML I have no way to place "255" and "FF" in such a way that XML understands them to be the same object, of integer type.
- lisper 10y agoSure you do. <base10>255</base10> <base16>FF</base16>
- kazinator 10y agoIt's not the same. Here is why: the program correctness doesn't depend on when (or even whether!) that automatic memory management happens. Lisp systems have been bootstrapped without having a working garbage collector upfront. Short-lived Lisp images run as processes in a conventional OS might never have a chance to collect garbage. Laziness has precise semantics which has to unfold properly, or else things don't work. Delaying evaluation is not the same thing as delaying reclamation. They are opposite in a sense, because we only allow something to be reclaimed when it is "of no value".
- bbcbasic 10y agoFailure to grok Haskell is probably due to the lack of easy accessible literature on it. Plus with so few other people groking it there isn't as much osmosis available.