All that buzz about RT is going nowhere.

Maybe, I’ve learned it wrong. But I’ve never heard of RT when I was absorbed in an imperative world. RT is a common term in functional programming. I’ve read the term and it’s “definition” just after a couple of Haskell’s tutorials.

To me, it’s simple as that: RT is the ability to switch sentences that refer to the same thing without changing the result.

In Haskell, you can do that freely. Even inside IO monad! If you do anything wrong, the compiler won’t let you continue. In Java, you can do that too, but you need to be aware of all the environment and sequencing in order to preserve the result.

Sequencing in the IO monad is enforced by the types, an IO String will not fit as a valid argument for a function that needs a String, so you will not be able to inline an IO String value, you are enforced to use the bind operator.

At the time of his writing, Strachey was heavily involved with the team developing the language CPL.

The most rigorous use of L-values and R-values was (is) BCPL (Martin Richards) — which some claims stands for “Basically Christopher’s Programming Language”. BCPL inspired C, and the rest is history.

Regarding IO and side effects, CPL, and BCPL were conventional for their day (and followed ALGOL 60) in leaving IO as being ‘implementation dependent’. These were all in the von Neumann/Turing/procedural model of computing. They all used destructive assignment.

BCPL supports assignment to L-values. In particular, the R-values of functions/procedures are just static cells holding pointers to the code body. Function application is just entering that code point using the current stack frame. So you can put an arbitrary expression to yield the code point:

(x > y -> SIN, COS) (z)                        // ... -> ... , ... is conditional expression, apply to z

Or put function calls on the LHS of assignments:

Array (x, y) := z                              // array update (note that arrays are not native)

Or change a function to point to a different code point:

TRIG := (x > y -> SIN, COS)                    // excellent way to perplex any reader
                                               // but can achieve something like anonymous funs

Strachey died tragically young. Oh, that he could have continued, and collaborated with the wealth of PL research going on at the time.

AntC

Monadic expressions (of Haskell) are a RT way of encoding an imperative language that isn’t necessarily RT. The potential side effects lie in the semantics of the encoded language (which isn’t Haskell, although you could consider it a part of Haskell). Similarily, the underlying implementation of a monad might or might not rely on unsafe/non-RT constructions.

From that point of view, Haskell with the IO monad is RT, but the execution of Haskell with IO is not RT.

In a similar manner, you might claim that C is RT and the side effects lie on a different level. But as a programmer, you don’t have separate access to the RT level so its existence is theoretical. In C, you just can’t replace the expression random() + random() with 2 * random() but in (non-unsafe) Haskell you can. In the end, you can twist the terms in various ways but you shouldn’t hide the clear differences between C and Haskell.