// Type Constraints --------------------------------------------------------------

  /** An instance of `A <:< B` witnesses that `A` is a subtype of `B`.
   *
   * Requiring an implicit argument of the type `A <:< B` encodes the generalized constraint `A <: B`.
   *
   * @note we need a new type constructor `<:<` and evidence `conforms`, as
   * reusing `Function2` and `identity` leads to ambiguities in case of type errors (any2stringadd is inferred)
   * to constrain any abstract type T that's in scope in a method's argument list (not just the method's own type parameters)
   * simply add an implicit argument of type `T <:< U`, where U is the required upper bound (for lower-bounds, use: `L <:< T`,
   * where L is the required lower bound).
   * in part contributed by Jason Zaugg
   */
  @implicitNotFound(msg = "Cannot prove that ${From} <:< ${To}.")
  sealed abstract class <:<[-From, +To] extends (From => To) with Serializable
  implicit def conforms[A]: A <:< A = new (A <:< A) { def apply(x: A) = x }
  // not in the <:< companion object because it is also intended to subsume identity (which is no longer implicit)

  /** An instance of `A =:= B` witnesses that the types `A` and `B` are equal.
   *
   * @see <:< for expressing subtyping constraints
   */
  @implicitNotFound(msg = "Cannot prove that ${From} =:= ${To}.")
  sealed abstract class =:=[From, To] extends (From => To) with Serializable
  object =:= {
    implicit def tpEquals[A]: A =:= A = new (A =:= A) {def apply(x: A) = x}
  }