Packages

sealed abstract class =:=[From, To] extends <:<[From, To] with Serializable

An instance of A =:= B witnesses that the types A and B are equal. It also acts as a A <:< B, but not a B <:< A (directly) due to restrictions on subclassing.

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.

From

a type which is proved equal to To

To

a type which is proved equal to From

Annotations
@implicitNotFound(msg = "Cannot prove that ${From} =:= ${To}.")
Source
typeConstraints.scala
Example:
  1. An in-place variant of scala.collection.mutable.ArrayBuffer#transpose

    implicit class BufOps[A](private val buf: ArrayBuffer[A]) extends AnyVal {
      def inPlaceTranspose[E]()(implicit ev: A =:= ArrayBuffer[E]) = ???
      // Because ArrayBuffer is invariant, we can't make do with just a A <:< ArrayBuffer[E]
      // Getting buffers *out* from buf would work, but adding them back *in* wouldn't.
    }
See also

<:< for expressing subtyping constraints

Linear Supertypes
<:<[From, To], java.io.Serializable, (From) => To, AnyRef, Any
Type Hierarchy
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. =:=
  2. <:<
  3. Serializable
  4. Function1
  5. AnyRef
  6. 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 a type constructor of two arguments.

    Substitute To for From and From for To in the type F[To, From], given that F is a type constructor of two arguments. 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 type equality.

    returns

    ftf, but with a (potentially) different type

    Definition Classes
    =:=<:<

Concrete Value Members

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

    If From = To and To = C, then From = C (equality is transitive)

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

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

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

    Definition Classes
    <:<
  3. 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
  4. 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
  5. def compose[C](r: =:=[C, From]): =:=[C, To]

    If From = To and C = From, then C = To (equality is transitive)

  6. def compose[C](r: <:<[C, From]): <:<[C, To]

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

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

    Definition Classes
    <:<
  7. 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
  8. def flip: =:=[To, From]

    If From = To then To = From (equality is symmetric)

  9. def liftCo[F[_]]: =:=[F[From], F[To]]

    Lift this evidence over any type constructor F.

    Lift this evidence over any type constructor F.

    Definition Classes
    =:=<:<
  10. def liftContra[F[_]]: =:=[F[To], F[From]]

    Lift this evidence over the type constructor F, but flipped.

    Lift this evidence over the type constructor F, but flipped.

    Definition Classes
    =:=<:<
  11. def substituteCo[F[_]](ff: F[From]): F[To]

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

    Substitute the From in the type F[From], where F is any 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 type equality.

    returns

    ff, but with a (potentially) different type

    Definition Classes
    =:=<:<
  12. def substituteContra[F[_]](ft: F[To]): F[From]

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

    Substitute the To in the type F[To], where F is any 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 type equality.

    returns

    ft, but with a (potentially) different type

    Definition Classes
    =:=<:<
  13. 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
  14. 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")
      }