Question

I’m reading about Haskell denotational semantics (http://en.wikibooks.org/wiki/Haskell/Denotational_semantics) and I fail to see why, in a type, bottom “value” is placed at another level compared to “normal” values, eg why it can’t be pattern matched.

I believe that pattern patching bottom would cause trouble as bottom denotes also non-terminating computations, but why should non-terminating computations and errors be treated the same? (I’m assuming calling a partial function with unsupported argument can be considered as an error).

What useful properties would be lost, if all Haskell types included a pattern-matchable Java-null-like value instead of bottom?

In other words: why wouldn’t it be wise to make all Haskell functions total by lifting all types with null value?

(Do non-terminating computations need a special type at all?)

Answer 1

You can’t get rid of non-termination without restricting the turing-completeness of your language, and by the halting problem, we can’t generally detect non-termination and replace it by a value.

So every turing complete language has bottom.

The only difference between Haskell and Java is then that Java has bottom and null. Haskell doesn’t have the latter, which is handy because then we don’t have to check for nulls!

Put another way, since bottom is inescapable (in the turing complete world), then what’s the point of also making everything nullable too, other than inviting bugs?

Also note that while some functions in the Prelude are partial for historic reasons, modern Haskell style leans towards writing total functions nearly everywhere and using an explicit Maybe return type in functions such as head that would otherwise be partial.