Heh:

> A paper defining conditional expressions and proposing their use in Algol was sent to the Communications of the ACM but was arbitrarily demoted to a letter to the editor, because it was very short.

Someone should have realized a short letter from John McCarthy is likely more significant than most long papers from other researchers.

Did John Mccarthy invent the IF statement for all languages?

The if-expression and if-statement are different things.

if-statements result in conditional execution of different statements, but do not return values themselves. Borrowing C's syntax for if statements the following is not allowed:

  int next = if (odd(current)) { 3*current + 1; } else {current / 2;};

That's not a valid expression in C.

if-expressions return a value, and C does have an if-expression with its ternary operator:

  int next = odd(current)? 3*current + 1 : current / 2;

if-statements are ubiquitous to nearly every programming language. Even when they aren't done with the if keyword and more familiar syntax, even unstructured languages with conditional branching instructions and goto permit you to write something like an if-statement (just disguised by the usually more verbose unstructured form).

if-expressions are less universally available (though I'm unsure of any higher-level-than-assembly language still in popular use that doesn't have an if-expression equivalent).

Go doesn't have if-expressions, which makes propagating errors even more painful.

How does this differ semantically from the C ternary operator? Not syntactically, in its outcome and expression of a testable boolean clause, and a left or right side choice which is the assignment value?

Not much.

But syntax matters; a ternary expression tells me at a glance that there's no funny stuff going on, it's just making a choice between two expressions.

In Go I have to scan every single branch when reading to make sure.

I'm still curious if the if / funarg conversations in the lisp team predated and influenced algol lexical scoping.

Algol and Lisp were both specified in 1968, but Algol only introduced lexical scoping two years later. So probably yes. I don't have evidence though.

Algol 60 had lexical scoping in 1960 (while Lisp was in development) and this was known to be equivalent to the lambda calculus by the folks working on it by 1965 or so - https://dl.acm.org/doi/10.1145/363744.363749

I think the consensus is that Scheme was the first Lisp to fully embrace lexical scope, in 1975?

[edited for clarity and punctuation]

But james slagle issue came before algol was finished, and IIRC some algol document mentions the funarg problem too, so there was crosspollinisation.

There is also the fact that if you have assoc lists, you can trivially easily write a badly performing but correctly lexical lisp interpreter in dynamic lisp, and I suspect this was consciously known. Maybe not enough people cared?

I believe Algol 60 had downward-funarg-only lexical scoping, whereby if you return a function with a captured environment, the coach turns into a pumpkin (unless it is somehow disallowed).

Lambda Calculus specifies the real deal; functions can calculate functions.

search for 'funarg'

I found this on page 5 rather than 11.

Thanks! Page 11 also has a good bit about scoping.