Packages

sealed abstract class <:<[-From, +To] extends (From) => To with Serializable

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.

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; or for lower-bounds, use: L <:< T, where L is the required lower bound.

In case of any confusion over which method goes in what direction, all the "Co" methods (including apply) go from left to right in the type ("with" the type), and all the "Contra" methods go from right to left ("against" the type). E.g., apply turns a From into a To, and substituteContra replaces the Tos in a type with Froms.

In part contributed by Jason Zaugg.

From

a type which is proved a subtype of To

To

a type which is proved a supertype of From

Annotations
@implicitNotFound(msg = "Cannot prove that ${From} <:< ${To}.")
Source
typeConstraints.scala
Example:
  1. scala.Option#flatten

    sealed trait Option[+A] {
      // def flatten[B, A <: Option[B]]: Option[B] = ...
      // won't work, since the A in flatten shadows the class-scoped A.
      def flatten[B](implicit ev: A <:< Option[B]): Option[B]
        = if(isEmpty) None else ev(get)
      // Because (A <:< Option[B]) <: (A => Option[B]), ev can be called to turn the
      // A from get into an Option[B], and because ev is implicit, that call can be
      // left out and inserted automatically.
    }
See also

=:= for expressing equality constraints

Linear Supertypes
Known Subclasses
Type Hierarchy
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. <:<
  2. Serializable
  3. Function1
  4. AnyRef
  5. Any
Implicitly
  1. by UnliftOps
  2. by any2stringadd
  3. by StringFormat
  4. by Ensuring
  5. by ArrowAssoc
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. Protected

Abstract Value Members

  1. abstract def substituteBoth[F[-_, +_]](ftf: F[To, From]): F[From, To]

    Substitute To for From and From for To in the type F[To, From], given that F is contravariant in the first argument and covariant in the second.

    Substitute To for From and From for To in the type F[To, From], given that F is contravariant in the first argument and covariant in the second. Essentially swaps To and From in ftf's type.

    Equivalent in power to each of substituteCo and substituteContra.

    This method is impossible to implement without throwing or otherwise "cheating" unless From <: To, so it ensures that this really represents a subtyping relationship.

    returns

    ftf, but with a (potentially) different type

Concrete Value Members

  1. def andThen[C](r: <:<[To, C]): <:<[From, C]

    If From <: To and To <: C, then From <: C (subtyping is transitive)

  2. def andThen[C](r: (To) => C): (From) => C

    Composes two instances of Function1 in a new Function1, with this function applied first.

    Composes two instances of Function1 in a new Function1, with this function applied first.

    returns

    a new function f such that f(x) == g(apply(x))

    Definition Classes
    <:<Function1
  3. def apply(f: From): To

    Coerce a From into a To.

    Coerce a From into a To. This is guaranteed to be the identity function.

    This method is often called implicitly as an implicit A <:< B doubles as an implicit view A => B.

    f

    some value of type From

    returns

    f, but with a (potentially) different type

    Definition Classes
    <:<Function1
  4. def compose[C](r: <:<[C, From]): <:<[C, To]

    If From <: To and C <: From, then C <: To (subtyping is transitive)

  5. def compose[C](r: (C) => From): (C) => To

    Composes two instances of Function1 in a new Function1, with this function applied last.

    Composes two instances of Function1 in a new Function1, with this function applied last.

    returns

    a new function f such that f(x) == apply(g(x))

    Definition Classes
    <:<Function1
  6. def liftCo[F[+_]]: <:<[F[From], F[To]]

    Lift this evidence over a covariant type constructor F.

  7. def liftContra[F[-_]]: <:<[F[To], F[From]]

    Lift this evidence over a contravariant type constructor F.

  8. def substituteCo[F[+_]](ff: F[From]): F[To]

    Substitute the From in the type F[From], where F is a covariant type constructor, for To.

    Substitute the From in the type F[From], where F is a covariant type constructor, for To.

    Equivalent in power to each of substituteBoth and substituteContra.

    This method is impossible to implement without throwing or otherwise "cheating" unless From <: To, so it ensures that this really represents a subtyping relationship.

    returns

    ff, but with a (potentially) different type

  9. def substituteContra[F[-_]](ft: F[To]): F[From]

    Substitute the To in the type F[To], where F is a contravariant type constructor, for From.

    Substitute the To in the type F[To], where F is a contravariant type constructor, for From.

    Equivalent in power to each of substituteBoth and substituteCo.

    This method is impossible to implement without throwing or otherwise "cheating" unless From <: To, so it ensures that this really represents a subtyping relationship.

    returns

    ft, but with a (potentially) different type

  10. def toString(): String

    Creates a String representation of this object.

    Creates a String representation of this object. The default representation is platform dependent. On the java platform it is the concatenation of the class name, "@", and the object's hashcode in hexadecimal.

    returns

    a String representation of the object.

    Definition Classes
    Function1 → AnyRef → Any
  11. def unlift: PartialFunction[From, B]

    Converts an optional function to a partial function.

    Converts an optional function to a partial function.

    Implicit
    This member is added by an implicit conversion from <:<[From, To] toUnliftOps[From, B] performed by method UnliftOps in scala.Function1.This conversion will take place only if To is a subclass of Option[B] (To <: Option[B]).
    Definition Classes
    UnliftOps
    Example:
    1. Unlike Function.unlift, this UnliftOps.unlift method can be used in extractors.

      val of: Int => Option[String] = { i =>
        if (i == 2) {
          Some("matched by an optional function")
        } else {
          None
        }
      }
      
      util.Random.nextInt(4) match {
        case of.unlift(m) => // Convert an optional function to a pattern
          println(m)
        case _ =>
          println("Not matched")
      }