In Haskell, what you are talking about sounds like type-based search. Like, if you know you're looking for a function of type `[Int] -> Int`, you probably want `sum` or `product` (which are of the compatible type `Num n => [n] -> n`). Am I right?
My first guess is that this kind of search is possible in other languages, yet easier and more accurate in Haskell and ML because their type system is paranoid, not because it is expressive.
Unrelated to that link: "Paranoid" and "expressive" are... hard to relate to each other. I certainly can't call them opposing forces in type signatures. It's a more complicated relationship. Type signatures that can carry lots of information can be both very "paranoid" (excluding many possibilities) while at the same time being very expressive (permitting many possibilities). In English that doesn't make much sense, but it makes perfect sense in the context of something like Haskell's type system, or other similarly carefully-crafted ones.
But it seems to suggest many non-exact matches, like google does. Useful in a search engine, but not for seeking an exact function - though I guess it doesn't hurt to have too many results, provided the exact ones are always first. (I don't know enough Haskell to be certain)
In Haskell, what you call a union type is more often called "sum type", or "tagged union". You declare them this way (your syntax was quite good):
data IntOrNothing = AnInteger Int
| Nothing
You can use it that way:
test :: IntOrNothing -> bool -- optional type declaration
test AnInteger i -> True
test Nothing -> False
This is not overloading. This is the same function. I also can write it this way:
test :: IntOrNothing -> bool -- optional type declaration
test intOrNot = case intOrNot of
AnInteger i -> True
Nothing -> False
So, the "choice" of union type is in the world of values, not in the world of types. Therefore, it isn't particularly relevant in the case of a type-based search.
My first guess is that this kind of search is possible in other languages, yet easier and more accurate in Haskell and ML because their type system is paranoid, not because it is expressive.