OK, those links were very useful. I'll mention some things:
1) Heather Miller points out "Though, a bottom-line here is, of course,
that Try can be used outside of the context of Futures." (which disagrees
with a number of comments I've gotten that say Try is only for Futures). A
similar comment: "`Try` comes from Twitter, who use it frequently in their
codebase (see twitter/util on github), and who have found that it results
in more readable and less error-prone code for this success/failure use
case of `Either`."
2) As mentioned elsewhere, Josh has noted that Failure requires an
Exception argument, and all the attendant baggage. Which argues against its
use to replace Either for error reporting.
There seem to be two camps:
(A) the early adopters who seem to be able to absorb all things equally
easily, and have no trouble mapping names to concepts. These folks seem to
feel that Left and Right are perfectly reasonably ways to report errors;
some even go as far as to say that "names have no meaning."
(B) The less-assured and less-vocal, to whom things don't instantly make
sense. I argue that this is the vast majority of your users -- maybe not
now, but these are the masses that you hope will eventually adopt this
language. To these people, the use of Left and Right to report errors seems
... odd, to say the least, and certainly counterintuitive. They argue (as I
do) not for the continuation of the "Either experiment" but instead to use
meaningful names to report errors.
I'll say it again: Error handling is one of the fundamental parts of
programming. Trying to explain the state of Scala error handling as it
exists, to a beginner, falls somewhere between quite difficult and
downright embarrassing. Some of the arguments I've seen in support of
further obfuscation *should* be embarrassing, but are instead taken
seriously. I come away from all of this truly wondering about the state of
the language -- it can do some amazing things, but at the same time it
seems like something as fundamental as errors has not been thought out, and
is being driven in seemingly random directions. It's quite frustrating; at
times I think there is tremendous possibility in Scala, but then I see
things like this and wonder if it can ever reach the state where an average
programmer can actually grasp it. If they have to jump through as many
hoops as I have to figure out how to deal with something as basic as
errors, then I am not so hopeful.
I suppose it doesn't help that I am also looking at Go, where they have put
tremendous focus on simplicity, consistency and the beginner experience,
and thought about errors (and how to report them simply and in a way that
doesn't cross process boundaries) from the start.
Apologies for venting. As I say, it's frustrating.
-- Bruce Eckel