A post by Conor McBride

```
Hi
I'm sorry about the level of consternation this discussion seems to be
generating, so let me attempt to clarify my previous remarks.
The diagonalization argument which shows that any total language
misses some total programs is the usual one: Godel-code everything in
sight, then make the alleged universal program eat a twisted copy of
itself. It's the Epimenides/Cantor/Russell/Quine/Godel/Turing
argument. And it goes like this...
Suppose we have a programming language in which all expressions
compute to a value excluding bottom. For sake of argument, let's
code expressions and values as natural numbers (an ascii source file
is just a big number; so is a finite output). In particular, every
function f from Nat to Nat which lives in the language is quoted by a
code (quote f) :: Nat, and we know a total function which unquotes,
executing a coded f at a given argument
eval :: Nat -> (Nat -> Nat)
with spec
eval (quote f) x = f x
eval _ _ = 0
Given such a function, I can summon up its evil cousin, with spec:
evil :: Nat -> Nat
evil code = 1 + (eval code code)
Now, if eval is total, so is evil. But if evil lies within our language,
it will have a number. Without loss of generality, quote evil is a human
number and that number is 666. So, we get
evil 666
= 1 + (eval 666 666)
= 1 + evil 666
which is plainly untrue.
Hence evil is a total function which is not expressible in the language
(so eval better not be expressible either).
Of course, for any language of total functions, its Halting Problem is
trivial, but that's beside the point. There is no largest class of
recognizably terminating programs, because no such class can include
its own *evaluation* function, which is by definition terminating.
Given a total language L, we can always construct a strictly larger
language L', also recognizable, which also includes the eval function
for L.
Meanwhile, back in the cafe, why should Haskellers give a monkeys? Two
reasons: one pertinent now, one potential.
Firstly, when we make (or Haskell derives) recursive instance
declarations, we might like to know that
(1) the compiler will not go into a spin when attempting to compute the
object code which generates the dictionary for a given instance
(2) the code so generated will not loop at run-time
You might argue that (1) is not so important, because you can always
ctrl-C, but (2) is more serious, because if it fails, you get the
situation where the compiler approves your program, then breaks it
by inserting bogus code, promising to deliver an instance which does
not actually exist.
To guarantee these properties, we essentially need to ensure that the
instance declaration language is a terminating fragment of Prolog. The
various flags available now are either way too cautious or way too
liberal: what's a suitable middle way? There is no most general choice.
Secondly, might it be desirable to isolate a recognizable sublanguage of
Haskell which contains only total programs? Pedagogically, Turner argues
that it's useful to have a `safe' language in which to learn.
Rhetorically, making bottom a value is just sophistry to hide the fact
that looping and match failure are pretty bad side-effects available
within an allegedly pure language---preferable to core-dumps or wiping
your hard drive, but still bad. Logically, if you want to show a program
is correct, it helps if you can get its totality for free. Pragmatically,
there are fewer caveats to optimizing bottomless programs.
As we've seen, such a sublanguage (perhaps called `Ask', a part of Haskell
which definitely excludes Hell) cannot contain all the angels, but it
certainly admits plenty of useful ones who can always answer mundane
things you might Ask. It's ironic, but not disastrous that lucifer, the
evaluation function by which Ask's angels bring their light, is himself an
angel, but one who must be cast into Hell.
Yours religiously
Conor
```