Where clauses for more expressive bounds

Add `where` clauses, which provide a more expressive means of specifying trait parameter bounds. A `where` clause comes after a declaration of a generic item (e.g., an impl or struct definition) and specifies a list of bounds that must be proven once precise values are known for the type parameters in question.

Main benefits:

- Express bounds on types derived from type parameters, e.g. `Option<T>` where `T` is a type parameter.
- Permits true multiple dispatch.

[Rendered view.](https://github.com/nikomatsakis/rfcs/blob/where-clauses/active/0000-where.md)
On Tue, Jun 24, 2014 at 02:28:40PM -0700, Kevin Ballard wrote:
> Looking at this a bit more, I'm confused. The trait coherence rules documented above say that you can't implement the same trait twice on a given type, even if the type parameters to the trait differ. But here you're defining multiple `Add` implementations on the single type `()`. Isn't that a violation of the same coherence rule that prevented `Add<Complex, Complex>` + `Add<int, Complex>` on `Complex`?

There is exactly one impl for `()`, so there is no coherence
violation. However, over the last day or so, I did realize that the
proposal doesn't work quite how I described it: I'd have to change the
rules regarding so-called "trivial" obligations that do not involve
type parameters. You *still* want the *caller* to verify those
obligations in order to use the

    () : Trait<A,B,C>

style. This is because, not knowing the types A and B, the callee
doesn't have enough information to completely resolve the impl. This
is fine. (Simpler, really.)