I strongly agree. Adding stuff to nil can have unintended consequences:
http://github.com/raganwald/homoiconic/blob/master/2009-02-0...
While I'm using Haskell's notation, it seems likely that pretty much any strongly typed language could do something like this, at least ad hoc. (That is, Haskell hasn't actually written this into the typing system, it's just a direct use of the type system that it already had. But even a C++-like language could probably put this in there if it was written that way from day one; arguably, it's allowing the nulls to exist in the first place that is actually the hack.)
No. Or more precisely, in a dynamically typed language (which may or may not be strongly typed) there's no point in doing so, it won't buy you anything expressivity or correctness over nullable references.
Pretty much any statically typed language would benefit from making names/references non-nullable by default and moving nullability into the type system yes.
> it's allowing the nulls to exist in the first place that is actually the hack
How is it a hack? It's trivial to implement, but there's nothing hacky about it.
Haskell of course has its own troubles with bottom, and I note some people think we should be doing away with that, too.
It's not either. Types are simply implicitly defined as nullable, as they are in SQL.
The correct way to replace your nil checks with polymorphism is with the MissingObject pattern. Languages with explicit types should give you this for free. I think that even duck-typed languages should do this. (Every time you define a class Foo, you get MissingFoo automatically.) They can often be provided by libraries.