Lambda the Ultimate

I think that in the current state it is, it doesn't quite live up to what it promises. It relies on some value being returned in every loop-branch (cause afaict, it doesn't go down the 'wrong' side of a loop branch). So a simple program like:


foo := [x | if cond: (x == 0) then: [:1] else [:foo doWith: x]].
foo doWith: 1.


Would hang. And then you'd have to apply the recommended pattern at the bottom. (Where you 'return' all possible values). Now, a naive solution (and this is already taking for granted we have typing) would then have to be:


pseudo: for i in Int: return i.
return (foo doWith: 1).


I think the idea in itself is interesting (and conceptually it seems to be smalltalk with non-det execution) though afaict, it doesn't quite live up to its idea yet.

Shouldn't that be:

Any universally powerful programming language must either offer consistent semantics, and allow the possibility of programs not halting.

(1) The author does not seem to distinguish between two cases: "yes AND no" and "yes OR no". It seems that, in YesNo, the latter is the case. Programs returning "yes OR no" are obviously not inconsistent - so it is not obvious in what sense should the YesNo language yield "inconsistent" results.

(2) The premise of YesNo, that all programs return values in the form "return 1", seems to be quite primitive. Supposing we give YesNo the ability to construct programs on the fly, we could write something like:

  construct program X.
  return (evaluate X).

I think that all of us would be delighted to see the output of YesNo for the case when the construction of X is a complicated piece of code or when X is a non-halting program.