<:<

@implicitNotFound(msg = "Cannot prove that ${From} <:< ${To}.") 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.

Type Params
From

a type which is proved a subtype of To

To

a type which is proved a supertype of From

See also

=:= for expressing equality constraints

Example

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.
}
Companion
object
Source
typeConstraints.scala
trait From => To
class Object
trait Matchable
class Any
class From =:= To

Value members

Abstract methods

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

Source
typeConstraints.scala

Concrete methods

override def andThen[C](r: To => C): From => C
Definition Classes
Source
typeConstraints.scala
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)

Source
typeConstraints.scala
override 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.

Value Params
f

some value of type From

Returns

f, but with a (potentially) different type

Definition Classes
Source
typeConstraints.scala
override def compose[C](r: C => From): C => To
Definition Classes
Source
typeConstraints.scala
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)

Source
typeConstraints.scala
def liftCo[F[_]]: F[From] <:< F[To]

Lift this evidence over a covariant type constructor F.

Lift this evidence over a covariant type constructor F.

Source
typeConstraints.scala
def liftContra[F[_]]: F[To] <:< F[From]

Lift this evidence over a contravariant type constructor F.

Lift this evidence over a contravariant type constructor F.

Source
typeConstraints.scala
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

Source
typeConstraints.scala
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

Source
typeConstraints.scala

Inherited methods

override def toString(): String
Definition Classes
Function1 -> Any
Inherited from
Function1
Source
Function1.scala