ConversionCheckedTripleEquals

Provides === and !== operators that return Boolean, delegate the equality determination to an Equality type class, and require that either the types of the two values compared are in a subtype/supertype relationship, or that an implicit conversion is available that can convert from one type to the other.

Recommended Usage: Trait ConversionCheckedTripleEquals is useful (in both production and test code) when you need determine equality for a type of object differently than its equals method—either you can't change the equals method, or the equals method is sensible generally, but you're in a special situation where you need something else—and/or you want a compile-time type check that allows types that are implicitly convertable in either (or both) directions.

This trait is the middle ground of the three triple equals traits, in between TripleEquals, the most lenient, and TypeCheckedTripleEquals, the most strict. If TripleEquals is mixed in or imported, the === can be used with any two types and still compile. If TypeCheckedTripleEquals is mixed in or imported, however, only types in a subtype or supertype relationship with each other (including when both types are exactly the same) will compile. ConversionCheckedTripleEquals is slightly more accomodating, because in addition to compiling any use of === that will compile under TypeCheckedTripleEquals, it will also compile type types that would be rejected by TypeCheckedTripleEquals, so long as an implicit conversion (in either direction) from one type to another is available.

For example, under TypeCheckedTripleEquals, the following use of === will not compile, because Int and Long are not in a subtype/supertype relationship. (I.e., Int is not a subtype or supertype of Long):

scala> import org.scalactic._
import org.scalactic._

scala> import TypeCheckedTripleEquals._
import TypeCheckedTripleEquals._

scala> 1 === 1L
<console>:14: error: types Int and Long do not adhere to the equality constraint selected for
the === and !== operators; they must either be in a subtype/supertype relationship, or, if
ConversionCheckedTripleEquals is in force, implicitly convertible in one direction or the other;
the missing implicit parameter is of type org.scalactic.CanEqual[Int,Long]
              1 === 1L
                ^

Trait TypeCheckedTripleEquals rejects types Int and Long because they are not directly related via subtyping. However, an implicit widening conversion from Int to Long does exist (imported implicitly from scala.Predef), so ConversionCheckedTripleEquals will allow it:

scala> import ConversionCheckedTripleEquals._
import ConversionCheckedTripleEquals._

scala> 1 === 1L
res1: Boolean = true

The implicit conversion can go in either direction: from the left type to the right type, or vice versa. In the above expression the implicit conversion goes from left to right (the Int on the left to the Long on the right). It also works the other way:

scala> 1L === 1
res2: Boolean = true

This trait will override or hide implicit methods defined by its sibling traits, TripleEquals or TypeCheckedTripleEquals, and can therefore be used to temporarily turn on or off conversion checking in a limited scope. Here's an example, in which TypeCheckedTripleEquals will cause a compiler error:

import org.scalactic._
import TypeCheckedTripleEquals._

object Example {

  def cmp(a: Int, b: Long): Int = {
    if (a === b) 0       // This line won't compile
    else if (a < b) -1
    else 1
  }

 def cmp(s: String, t: String): Int = {
   if (s === t) 0
   else if (s < t) -1
   else 1
 }
}

Because Int and Long are not in a subtype/supertype relationship, comparing 1 and 1L in the context of TypeCheckedTripleEquals will generate a compiler error:

Example.scala:9: error: types Int and Long do not adhere to the equality constraint selected for
the === and !== operators; they must either be in a subtype/supertype relationship, or, if
ConversionCheckedTripleEquals is in force, implicitly convertible in one direction or the other;
the missing implicit parameter is of type org.scalactic.CanEqual[Int,Long]
    if (a === b) 0      // This line won't compile
          ^
one error found

You can “relax” the type checking (i.e., by additionally allowing implicitly convertible types) locally by importing the members of ConversionCheckedTripleEquals in a limited scope:

package org.scalactic.examples.conversioncheckedtripleequals

import org.scalactic._
import TypeCheckedTripleEquals._

object Example {

  def cmp(a: Int, b: Long): Int = {
    import ConversionCheckedTripleEquals._
    if (a === b) 0
    else if (a < b) -1
    else 1
  }

 def cmp(s: String, t: String): Int = {
   if (s === t) 0
   else if (s < t) -1
   else 1
 }
}

With the above change, the Example.scala file compiles fine. Conversion checking is enabled only inside the first cmp method that takes an Int and a Long. TypeCheckedTripleEquals is still enforcing its type constraint, for example, for the s === t expression in the other overloaded cmp method that takes strings.

Because the methods in ConversionCheckedTripleEquals (and its siblings) override all the methods defined in supertype TripleEqualsSupport, you can achieve the same kind of nested tuning of equality constraints whether you mix in traits, import from companion objects, or use some combination of both.

In short, you should be able to select a primary constraint level via either a mixin or import, then change that in nested scopes however you want, again either through a mixin or import, without getting any implicit conversion ambiguity. The innermost constraint level in scope will always be in force.

An alternative way to solve an unwanted compiler error caused by an over-zealous type constraint is with a widening type ascription. Here are some examples:

scala> import org.scalactic._
import org.scalactic._

scala> import ConversionCheckedTripleEquals._
import ConversionCheckedTripleEquals._

scala> List(1, 2, 3) === Vector(1, 2, 3)
<console>:14: error: types List[Int] and scala.collection.immutable.Vector[Int] do not adhere to the equality constraint selected for the === and !== operators; the missing implicit parameter is of type org.scalactic.CanEqual[List[Int],scala.collection.immutable.Vector[Int]]
              List(1, 2, 3) === Vector(1, 2, 3)
                            ^

Although you could solve the above type error with TraversableEqualityConstraints, you could also simply widen the type of one side or the other to Any. Because Any is a supertype of everything, the type constraint will be satisfied:

scala> List(1, 2, 3) === (Vector(1, 2, 3): Any)
res1: Boolean = true

scala> (List(1, 2, 3): Any) === Vector(1, 2, 3)
res2: Boolean = true

You could alternatively widen a type to a more specific common supertype than Any. For example, since List[Int] and Vector[Int] are both subtypes of Seq[Int], so you could widen either type to Seq[Int] to satisfy the type checker:

scala> List(1, 2, 3) === (Vector(1, 2, 3): Seq[Int])
res3: Boolean = true

scala> (List(1, 2, 3): Seq[Int]) === Vector(1, 2, 3)
res4: Boolean = true

Source: ConversionCheckedTripleEquals.scala

Linear Supertypes

LowPriorityConversionCheckedConstraint, TripleEqualsSupport, AnyRef, Any

Known Subclasses

ConversionCheckedTripleEquals

Type Members

class CheckingEqualizer[L] extends AnyRef

Class used via an implicit conversion to enable two objects to be compared with === and !== with a Boolean result and an enforced type constraint between two object types.
Class used via an implicit conversion to enable two objects to be compared with === and !== with a Boolean result and an enforced type constraint between two object types. For example:
```
assert(a === b)
assert(c !== d)
```
You can also check numeric values against another with a tolerance. Here are some examples:
```
assert(a === (2.0 +- 0.1))
assert(c !== (2.0 +- 0.1))
```
Definition Classes
TripleEqualsSupport
class Equalizer[L] extends AnyRef

Class used via an implicit conversion to enable any two objects to be compared with === and !== with a Boolean result and no enforced type constraint between two object types.
Class used via an implicit conversion to enable any two objects to be compared with === and !== with a Boolean result and no enforced type constraint between two object types. For example:
```
assert(a === b)
assert(c !== d)
```
You can also check numeric values against another with a tolerance. Here are some examples:
```
assert(a === (2.0 +- 0.1))
assert(c !== (2.0 +- 0.1))
```
Definition Classes
TripleEqualsSupport

Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def !==[T](right: Spread[T]): TripleEqualsInvocationOnSpread[T]

Returns a TripleEqualsInvocationOnSpread[T], given an Spread[T], to facilitate the “<left> should !== (<pivot> +- <tolerance>)” syntax of Matchers.
Returns a TripleEqualsInvocationOnSpread[T], given an Spread[T], to facilitate the “<left> should !== (<pivot> +- <tolerance>)” syntax of Matchers.
right
the Spread[T] against which to compare the left-hand value
returns
a TripleEqualsInvocationOnSpread wrapping the passed Spread[T] value, with expectingEqual set to false.

Definition Classes
TripleEqualsSupport
def !==(right: Null): TripleEqualsInvocation[Null]

Returns a TripleEqualsInvocation[Null], given a null reference, to facilitate the “<left> should !== null” syntax of Matchers.
Returns a TripleEqualsInvocation[Null], given a null reference, to facilitate the “<left> should !== null” syntax of Matchers.
right
a null reference
returns
a TripleEqualsInvocation wrapping the passed null value, with expectingEqual set to false.

Definition Classes
TripleEqualsSupport
def !==[T](right: T): TripleEqualsInvocation[T]

Returns a TripleEqualsInvocation[T], given an object of type T, to facilitate the “<left> should !== <right>” syntax of Matchers.
Returns a TripleEqualsInvocation[T], given an object of type T, to facilitate the “<left> should !== <right>” syntax of Matchers.
right
the right-hand side value for an equality assertion
returns
a TripleEqualsInvocation wrapping the passed right value, with expectingEqual set to false.

Definition Classes
TripleEqualsSupport
final def ##(): Int

Definition Classes
AnyRef → Any
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def ===[T](right: Spread[T]): TripleEqualsInvocationOnSpread[T]

Returns a TripleEqualsInvocationOnSpread[T], given an Spread[T], to facilitate the “<left> should === (<pivot> +- <tolerance>)” syntax of Matchers.
Returns a TripleEqualsInvocationOnSpread[T], given an Spread[T], to facilitate the “<left> should === (<pivot> +- <tolerance>)” syntax of Matchers.
right
the Spread[T] against which to compare the left-hand value
returns
a TripleEqualsInvocationOnSpread wrapping the passed Spread[T] value, with expectingEqual set to true.

Definition Classes
TripleEqualsSupport
def ===(right: Null): TripleEqualsInvocation[Null]

Returns a TripleEqualsInvocation[Null], given a null reference, to facilitate the “<left> should === null” syntax of Matchers.
Returns a TripleEqualsInvocation[Null], given a null reference, to facilitate the “<left> should === null” syntax of Matchers.
right
a null reference
returns
a TripleEqualsInvocation wrapping the passed null value, with expectingEqual set to true.

Definition Classes
TripleEqualsSupport
def ===[T](right: T): TripleEqualsInvocation[T]

Returns a TripleEqualsInvocation[T], given an object of type T, to facilitate the “<left> should === <right>” syntax of Matchers.
Returns a TripleEqualsInvocation[T], given an object of type T, to facilitate the “<left> should === <right>” syntax of Matchers.
right
the right-hand side value for an equality assertion
returns
a TripleEqualsInvocation wrapping the passed right value, with expectingEqual set to true.

Definition Classes
TripleEqualsSupport
final def asInstanceOf[T0]: T0

Definition Classes
Any
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
implicit def conversionCheckedConstraint[A, B](implicit equivalenceOfA: Equivalence[A], cnv: (B) ⇒ A): CanEqual[A, B]

Provides an A CanEqual B instance for any two types A and B, enforcing the type constraint that B is implicitly convertible to A, given an implicit Equivalence[A].
Provides an A CanEqual B instance for any two types A and B, enforcing the type constraint that B is implicitly convertible to A, given an implicit Equivalence[A].
The returned Constraint's areEqual method uses the implicitly passed Equivalence[A]'s areEquivalent method to determine equality.
This method is overridden and made implicit by subtraits ConversionCheckedTripleEquals) and overriden as non-implicit by the other subtraits in this package.
equivalenceOfA
an Equivalence[A] type class to which the Constraint.areEqual method will delegate to determine equality.
cnv
an implicit conversion from B to A
returns
an A CanEqual B instance whose areEqual method delegates to the areEquivalent method of the passed Equivalence[A].

Definition Classes
ConversionCheckedTripleEquals → TripleEqualsSupport
def convertEquivalenceToAToBConstraint[A, B](equivalenceOfB: Equivalence[B])(implicit ev: <:<[A, B]): CanEqual[A, B]

Provides a A CanEqual B for any two types A and B, enforcing the type constraint that A must be a subtype of B, given an explicit Equivalence[B].
Provides a A CanEqual B for any two types A and B, enforcing the type constraint that A must be a subtype of B, given an explicit Equivalence[B].
This method is used to enable the Explicitly DSL for TypeCheckedTripleEquals by requiring an explicit Equivalance[B], but taking an implicit function that provides evidence that A is a subtype of B.
The returned Constraint's areEqual method uses the implicitly passed Equivalence[B]'s areEquivalent method to determine equality.
This method is overridden and made implicit by subtraits LowPriorityTypeCheckedConstraint (extended by TypeCheckedTripleEquals), and overriden as non-implicit by the other subtraits in this package.
equivalenceOfB
an Equivalence[B] type class to which the Constraint.areEqual method will delegate to determine equality.
ev
evidence that A is a subype of B
returns
an A CanEqual B instance whose areEqual method delegates to the areEquivalent method of the passed Equivalence[B].

Definition Classes
ConversionCheckedTripleEquals → TripleEqualsSupport
implicit def convertEquivalenceToAToBConversionConstraint[A, B](equivalenceOfB: Equivalence[B])(implicit ev: (A) ⇒ B): CanEqual[A, B]

Provides an A CanEqual B instance for any two types A and B, enforcing the type constraint that A is implicitly convertible to B, given an explicit Equivalence[B].
Provides an A CanEqual B instance for any two types A and B, enforcing the type constraint that A is implicitly convertible to B, given an explicit Equivalence[B].
This method is used to enable the Explicitly DSL for ConversionCheckedTripleEquals by requiring an explicit Equivalance[B], but taking an implicit function that converts from A to B.
The returned Constraint's areEqual method uses the implicitly passed Equivalence[B]'s areEquivalent method to determine equality.
This method is overridden and made implicit by subtraits LowPriorityConversionCheckedConstraint (extended by ConversionCheckedTripleEquals), and overriden as non-implicit by the other subtraits in this package.
returns
an A CanEqual B instance whose areEqual method delegates to the areEquivalent method of the passed Equivalence[B].

Definition Classes
LowPriorityConversionCheckedConstraint → TripleEqualsSupport
def convertEquivalenceToBToAConstraint[A, B](equivalenceOfA: Equivalence[A])(implicit ev: <:<[B, A]): CanEqual[A, B]

Provides an A CanEqual B instance for any two types A and B, enforcing the type constraint that B must be a subtype of A, given an explicit Equivalence[A].
Provides an A CanEqual B instance for any two types A and B, enforcing the type constraint that B must be a subtype of A, given an explicit Equivalence[A].
This method is used to enable the Explicitly DSL for TypeCheckedTripleEquals by requiring an explicit Equivalance[B], but taking an implicit function that provides evidence that A is a subtype of B. For example, under TypeCheckedTripleEquals, this method (as an implicit method), would be used to compile this statement:
```
def closeEnoughTo1(num: Double): Boolean =
  (num === 1.0)(decided by forgivingEquality)
```
The returned Constraint's areEqual method uses the implicitly passed Equivalence[A]'s areEquivalent method to determine equality.
This method is overridden and made implicit by subtraits TypeCheckedTripleEquals) and overriden as non-implicit by the other subtraits in this package.
ev
evidence that B is a subype of A
returns
an A CanEqual B instance whose areEqual method delegates to the areEquivalent method of the passed Equivalence[A].

Definition Classes
ConversionCheckedTripleEquals → TripleEqualsSupport
implicit def convertEquivalenceToBToAConversionConstraint[A, B](equivalenceOfA: Equivalence[A])(implicit ev: (B) ⇒ A): CanEqual[A, B]

Provides an A CanEqual B instance for any two types A and B, enforcing the type constraint that B is implicitly convertible to A, given an explicit Equivalence[A].
Provides an A CanEqual B instance for any two types A and B, enforcing the type constraint that B is implicitly convertible to A, given an explicit Equivalence[A].
This method is used to enable the Explicitly DSL for ConversionCheckedTripleEquals by requiring an explicit Equivalance[A], but taking an implicit function that converts from B to A. For example, under ConversionCheckedTripleEquals, this method (as an implicit method), would be used to compile this statement:
```
def closeEnoughTo1(num: Double): Boolean =
  (num === 1.0)(decided by forgivingEquality)
```
The returned Constraint's areEqual method uses the implicitly passed Equivalence[A]'s areEquivalent method to determine equality.
This method is overridden and made implicit by subtraits ConversionCheckedTripleEquals) and overriden as non-implicit by the other subtraits in this package.
equivalenceOfA
an Equivalence[A] type class to which the Constraint.areEqual method will delegate to determine equality.
returns
an A CanEqual B instance whose areEqual method delegates to the areEquivalent method of the passed Equivalence[A].

Definition Classes
ConversionCheckedTripleEquals → TripleEqualsSupport
implicit def convertToCheckingEqualizer[T](left: T): CheckingEqualizer[T]

Converts to an CheckingEqualizer that provides === and !== operators that result in Boolean and enforce a type constraint.
Converts to an CheckingEqualizer that provides === and !== operators that result in Boolean and enforce a type constraint.
This method is overridden and made implicit by subtraits TypeCheckedTripleEquals and ConversionCheckedTripleEquals, and overriden as non-implicit by the other subtraits in this package.
left
the object whose type to convert to CheckingEqualizer.

Definition Classes
ConversionCheckedTripleEquals → TripleEqualsSupport
Exceptions thrown
NullPointerException if left is null.
def convertToEqualizer[T](left: T): Equalizer[T]

Converts to an Equalizer that provides === and !== operators that result in Boolean and enforce no type constraint.
Converts to an Equalizer that provides === and !== operators that result in Boolean and enforce no type constraint.
This method is overridden and made implicit by subtrait TripleEquals and overriden as non-implicit by the other subtraits in this package.
left
the object whose type to convert to Equalizer.

Definition Classes
ConversionCheckedTripleEquals → TripleEqualsSupport
Exceptions thrown
NullPointerException if left is null.
def defaultEquality[A]: Equality[A]

Returns an Equality[A] for any type A that determines equality by first calling .deep on any Array (on either the left or right side), then comparing the resulting objects with ==.
Returns an Equality[A] for any type A that determines equality by first calling .deep on any Array (on either the left or right side), then comparing the resulting objects with ==.
returns
a default Equality for type A

Definition Classes
TripleEqualsSupport
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def hashCode(): Int

Definition Classes
AnyRef → Any
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
implicit def lowPriorityConversionCheckedConstraint[A, B](implicit equivalenceOfB: Equivalence[B], cnv: (A) ⇒ B): CanEqual[A, B]

Provides an A CanEqual B instance for any two types A and B, enforcing the type constraint that A is implicitly convertible to B, given an implicit Equivalence[B].
Provides an A CanEqual B instance for any two types A and B, enforcing the type constraint that A is implicitly convertible to B, given an implicit Equivalence[B].
The returned Constraint's areEqual method uses the implicitly passed Equivalence[B]'s areEquivalent method to determine equality.
This method is overridden and made implicit by subtraits LowPriorityConversionCheckedConstraint (extended by ConversionCheckedTripleEquals), and overriden as non-implicit by the other subtraits in this package.
cnv
an implicit conversion from A to B
returns
an A CanEqual B instance whose areEqual method delegates to the areEquivalent method of the passed Equivalence[B].

Definition Classes
LowPriorityConversionCheckedConstraint → TripleEqualsSupport
def lowPriorityTypeCheckedConstraint[A, B](implicit equivalenceOfB: Equivalence[B], ev: <:<[A, B]): CanEqual[A, B]

Provides an A CanEqual B for any two types A and B, enforcing the type constraint that A must be a subtype of B, given an implicit Equivalence[B].
Provides an A CanEqual B for any two types A and B, enforcing the type constraint that A must be a subtype of B, given an implicit Equivalence[B].
The returned Constraint's areEqual method uses the implicitly passed Equivalence[A]'s areEquivalent method to determine equality.
This method is overridden and made implicit by subtraits LowPriorityTypeCheckedConstraint (extended by TypeCheckedTripleEquals), and overriden as non-implicit by the other subtraits in this package.
equivalenceOfB
an Equivalence[B] type class to which the Constraint.areEqual method will delegate to determine equality.
ev
evidence that A is a subype of B
returns
an A CanEqual B instance whose areEqual method delegates to the areEquivalent method of the passed Equivalence[B].

Definition Classes
ConversionCheckedTripleEquals → TripleEqualsSupport
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def toString(): String

Definition Classes
AnyRef → Any
def typeCheckedConstraint[A, B](implicit equivalenceOfA: Equivalence[A], ev: <:<[B, A]): CanEqual[A, B]

Provides an A CanEqual B instance for any two types A and B, enforcing the type constraint that B must be a subtype of A, given an implicit Equivalence[A].
Provides an A CanEqual B instance for any two types A and B, enforcing the type constraint that B must be a subtype of A, given an implicit Equivalence[A].
The returned Constraint's areEqual method uses the implicitly passed Equivalence[A]'s areEquivalent method to determine equality.
This method is overridden and made implicit by subtraits TypeCheckedTripleEquals) and overriden as non-implicit by the other subtraits in this package.
ev
evidence that B is a subype of A
returns
an A CanEqual B instance whose areEqual method delegates to the areEquivalent method of the passed Equivalence[A].

Definition Classes
ConversionCheckedTripleEquals → TripleEqualsSupport
def unconstrainedEquality[A, B](implicit equalityOfA: Equality[A]): CanEqual[A, B]

Provides an A CanEqual B instance for any two types A and B, with no type constraint enforced, given an implicit Equality[A].
Provides an A CanEqual B instance for any two types A and B, with no type constraint enforced, given an implicit Equality[A].
The returned Constraint's areEqual method uses the implicitly passed Equality[A]'s areEqual method to determine equality.
This method is overridden and made implicit by subtraits TripleEquals and overriden as non-implicit by the other subtraits in this package.
equalityOfA
an Equality[A] type class to which the Constraint.areEqual method will delegate to determine equality.
returns
an A CanEqual B instance whose areEqual method delegates to the areEqual method of the passed Equality[A].

Definition Classes
ConversionCheckedTripleEquals → TripleEqualsSupport
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )

Related Docs: object ConversionCheckedTripleEquals | package scalactic

trait ConversionCheckedTripleEquals extends LowPriorityConversionCheckedConstraint

Type Members

class CheckingEqualizer[L] extends AnyRef

class Equalizer[L] extends AnyRef

Value Members

final def !=(arg0: Any): Boolean

def !==[T](right: Spread[T]): TripleEqualsInvocationOnSpread[T]

def !==(right: Null): TripleEqualsInvocation[Null]

def !==[T](right: T): TripleEqualsInvocation[T]

final def ##(): Int

final def ==(arg0: Any): Boolean

def ===[T](right: Spread[T]): TripleEqualsInvocationOnSpread[T]

def ===(right: Null): TripleEqualsInvocation[Null]

def ===[T](right: T): TripleEqualsInvocation[T]

final def asInstanceOf[T0]: T0

def clone(): AnyRef

implicit def conversionCheckedConstraint[A, B](implicit equivalenceOfA: Equivalence[A], cnv: (B) ⇒ A): CanEqual[A, B]

def convertEquivalenceToAToBConstraint[A, B](equivalenceOfB: Equivalence[B])(implicit ev: <:<[A, B]): CanEqual[A, B]

implicit def convertEquivalenceToAToBConversionConstraint[A, B](equivalenceOfB: Equivalence[B])(implicit ev: (A) ⇒ B): CanEqual[A, B]

def convertEquivalenceToBToAConstraint[A, B](equivalenceOfA: Equivalence[A])(implicit ev: <:<[B, A]): CanEqual[A, B]

implicit def convertEquivalenceToBToAConversionConstraint[A, B](equivalenceOfA: Equivalence[A])(implicit ev: (B) ⇒ A): CanEqual[A, B]

implicit def convertToCheckingEqualizer[T](left: T): CheckingEqualizer[T]

def convertToEqualizer[T](left: T): Equalizer[T]

def defaultEquality[A]: Equality[A]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

implicit def lowPriorityConversionCheckedConstraint[A, B](implicit equivalenceOfB: Equivalence[B], cnv: (A) ⇒ B): CanEqual[A, B]

def lowPriorityTypeCheckedConstraint[A, B](implicit equivalenceOfB: Equivalence[B], ev: <:<[A, B]): CanEqual[A, B]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

final def synchronized[T0](arg0: ⇒ T0): T0

def toString(): String

def typeCheckedConstraint[A, B](implicit equivalenceOfA: Equivalence[A], ev: <:<[B, A]): CanEqual[A, B]

def unconstrainedEquality[A, B](implicit equalityOfA: Equality[A]): CanEqual[A, B]

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

Inherited from LowPriorityConversionCheckedConstraint

Inherited from TripleEqualsSupport

Inherited from AnyRef

Inherited from Any

Ungrouped