3 ms·
> which means that you can understand the combined program by understanding foo and bar independently. If you can't represent the result of bar() as a value x t
by pron 11y ago
> which means that you can understand the combined program by understanding foo and bar independently. If you can't represent the result of bar() as a value x then that breaks down
Can you not understand this program by understanding both statements separately?
print("hi") ; print("there")
Why is that more understandable if the result of print is a value? (obviously, the result of read() is). In any case, describing everything as a value is a PFP idea (note that neither the Lisps nor the MLs do it), that some people like and others (like me) don't. In fact, I find the notion of treating every computation as a value (rather than possibly wrapping it as one), a not too great idea. Values are equational, computations are not (even pure ones). It's a nice abstraction to have at your disposal, but enforcing it everywhere is too much.
> You only don't need to care if the effects commute - and in that case you can actually automatically move them past each other in the monad world
You could, obviously, but when working with continuations, i.e. imperatively, or with Kiselyov's freer monads (which are inspired by continuations) you don't have to.
- lmm 11y ago> Can you not understand this program by understanding both statements separately? Maybe that one - I/O is a bad example, I don't really see the value of monads for I/O and I don't tend to use an I/O monad in my programs. Programs I can't understand by understanding statements separately are something like: openTransaction() writeToDatabase(1) rollbackTransaction() or val myLog = Buffer() myLog :+= "step 1" myLog :+= "step 2" doSomethingWith(myLog) and these cases (database transaction, writer) are things I do find it useful to manage with a monad. > Values are equational, computations are not (even pure ones). It's a nice abstraction to have at your disposal, but enforcing it everywhere is too much. You need some way to encapsulate/isolate the relevant state of a program partway through running - I think imperative programmers agree that global mutable state is bad. Mostly I see monads as a way to turn global mutable state (whether in the form of global variables, control flow, or something external to the program) into local state, so that you can see which bits of state you need to understand to understand a given line of code. I think that state has to be equational if we're to have any hope of being able to understand programs - if you can't say whether this time at line 20 the program is in the same state it was last time at line 20, or a different state from last time, how can you even begin to debug? > You could, obviously, but when working with continuations, i.e. imperatively, or with Kiselyov's freer monads (which are inspired by continuations) you don't have to. But will those approaches stop me from tripping myself up when effects don't commute? In scalaz-transfigure I do that with the Distributive typeclass - if one effect distributes over another then there will be an instance and you can freely move them past each other, if not then you get a compile error when you try and have to clarify what you want to happen.
- pron 11y ago> these cases (database transaction, writer) are things I do find it useful to manage with a monad. Yeah, I know, but some of us don't :) > You need some way to encapsulate/isolate the relevant state of a program partway through running That's exactly what continuations do. The question of global mutable state is an orthogonal one. > I think that state has to be equational if we're to have any hope of being able to understand programs - if you can't say whether this time at line 20 the program is in the same state it was last time at line 20, or a different state from last time, how can you even begin to debug? Well, we have been successfully writing programs like that for a long time. Now, don't get me wrong -- the equational abstraction is often very useful, but it has its price, and it's not a complete representation of the computation. > But will those approaches stop me from tripping myself up when effects don't commute? I don't understand. We don't trip over ourselves when writing imperative code, and when we do, it mostly has to do with IO or other OS state, and monads won't help you there. Linear types ("typestate") might, but even they are limited.
- lmm 11y ago> We don't trip over ourselves when writing imperative code Speak for yourself. Though I guess I'm more concerned with refactoring than with writing. In particular in imperative code it's very hard to tell the difference between semantically important ordering and accidental ordering. > when we do, it mostly has to do with IO or other OS state, and monads won't help you there. Yes they will? It's very normal to encapsulate something of that nature with a monad.
- pron 11y ago> it's very hard to tell the difference between semantically important ordering and accidental ordering. Not when effects are clearly marked. There is zero difference in that respect between continuations (i.e. imperative) and monads. It's only syntax and whatever your type system is. > It's very normal to encapsulate something of that nature with a monad. Sure, but a monad won't help you ensure their proper ordering.