Class scala.=:=

@implicitNotFound(msg = "Cannot prove that ${From} =:= ${To}.")

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.

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.
}

Abstract methods

Source

override def substituteBoth[F[_, _]](ftf: F[To, From]): F[From, To]

Concrete methods

Source

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

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

Source

override def apply(f: From): 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.

Source

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

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

Source

def flip: To =:= From

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

Source

override def liftCo[F[_]]: F[From] =:= F[To]

Source

override def liftContra[F[_]]: F[To] =:= F[From]

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

Source

override def substituteCo[F[_]](ff: F[From]): F[To]

Source

override def substituteContra[F[_]](ft: F[To]): F[From]

Inherited methods

Source

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

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

Source

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

Source

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

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

Source

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

Source

override def toString(): String