TypeCheckedLegacyTripleEquals

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
class LegacyCheckingEqualizer[L] extends AnyRef

Class used via an implicit conversion to enable any two objects to be compared with === and !== with an Option[String] result and an enforced type constraint between two object types.
Class used via an implicit conversion to enable any two objects to be compared with === and !== with an Option[String] 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))
```
The benefit of using assert(a === b) rather than assert(a == b) in ScalaTest code is that a TestFailedException produced by the former will include the values of a and b in its detail message.
Note: This class has "Legacy" in its name because its approach to error messages will eventually be replaced by macros. Once ScalaTest no longer supports Scala 2.9, this class will be deprecated in favor of class Equalizer. Instead of obtaining nice error messages via the Option[String] returned by the methods of this class, the error messages will be obtained by a macro. The "legacy" approach to good error messages will continue to be used, however, until ScalaTest no longer supports Scala 2.9, since macros were introduced to Scala (in experimental form) in 2.10.
The primary constructor takes one object, left, whose type is being converted to Equalizer. The left value may be a null reference, because this is allowed by Scala's == operator.
Definition Classes
TripleEqualsSupport
class LegacyEqualizer[L] extends AnyRef

Class used via an implicit conversion to enable any two objects to be compared with === and !== with an Option[String] 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 an Option[String] 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))
```
The benefit of using assert(a === b) rather than assert(a == b) in ScalaTest code is that a TestFailedException produced by the former will include the values of a and b in its detail message.
Note: This class has "Legacy" in its name because its approach to error messages will eventually be replaced by macros. Once ScalaTest no longer supports Scala 2.9, this class will be deprecated in favor of class Equalizer. Instead of obtaining nice error messages via the Option[String] returned by the methods of this class, the error messages will be obtained by a macro. The "legacy" approach to good error messages will continue to be used, however, until ScalaTest no longer supports Scala 2.9, since macros were introduced to Scala (in experimental form) in 2.10.
The primary constructor takes one object, left, whose type is being converted to Equalizer. The left value may be a null reference, because this is allowed by Scala's == operator.
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( ... )
def conversionCheckedConstraint[A, B](implicit equivalenceOfA: Equivalence[A], cnv: (B) ⇒ A): Constraint[A, B]

Provides a Constraint[A, B] class for any two types A and B, enforcing the type constraint that B is implicitly convertible to A, given an implicit Equivalence[A].
Provides a Constraint[A, B] class 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 ConversionCheckedLegacyTripleEquals, 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
a Constraint[A, B] whose areEqual method delegates to the areEquivalent method of the passed Equivalence[A].

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

Provides a Constraint[A, 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 Constraint[A, 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 LowPriorityTypeCheckedLegacyConstraint (extended by TypeCheckedLegacyTripleEquals), 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
a Constraint[A, B] whose areEqual method delegates to the areEquivalent method of the passed Equivalence[B].

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

Provides a Constraint[A, B] class for any two types A and B, enforcing the type constraint that A is implicitly convertible to B, given an explicit Equivalence[B].
Provides a Constraint[A, B] class 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 LowPriorityConversionCheckedLegacyConstraint (extended by ConversionCheckedLegacyTripleEquals), and overriden as non-implicit by the other subtraits in this package.
returns
a Constraint[A, B] whose areEqual method delegates to the areEquivalent method of the passed Equivalence[B].

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

Provides a Constraint[A, B] 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 a Constraint[A, B] 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 TypeCheckedLegacyTripleEquals, and overriden as non-implicit by the other subtraits in this package.
ev
evidence that B is a subype of A
returns
a Constraint[A, B] whose areEqual method delegates to the areEquivalent method of the passed Equivalence[A].

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

Provides a Constraint[A, B] class for any two types A and B, enforcing the type constraint that B is implicitly convertible to A, given an explicit Equivalence[A].
Provides a Constraint[A, B] class 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 ConversionCheckedLegacyTripleEquals, 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
a Constraint[A, B] whose areEqual method delegates to the areEquivalent method of the passed Equivalence[A].

Definition Classes
TypeCheckedLegacyTripleEquals → TripleEqualsSupport
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
TypeCheckedLegacyTripleEquals → 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
TypeCheckedLegacyTripleEquals → TripleEqualsSupport
Exceptions thrown
NullPointerException if left is null.
implicit def convertToLegacyCheckingEqualizer[T](left: T): LegacyCheckingEqualizer[T]

Converts to a LegacyCheckingEqualizer that provides === and !== operators that result in Option[String] and enforce a type constraint.
Converts to a LegacyCheckingEqualizer that provides === and !== operators that result in Option[String] and enforce a type constraint.
This method is overridden and made implicit by subtraits TypeCheckedLegacyTripleEquals and ConversionCheckedLegacyTripleEquals, and overriden as non-implicit by the other subtraits in this package.
left
the object whose type to convert to LegacyCheckingEqualizer.

Definition Classes
TypeCheckedLegacyTripleEquals → TripleEqualsSupport
Exceptions thrown
NullPointerException if left is null.
def convertToLegacyEqualizer[T](left: T): LegacyEqualizer[T]

Converts to a LegacyEqualizer that provides === and !== operators that result in Option[String] and enforce no type constraint.
Converts to a LegacyEqualizer that provides === and !== operators that result in Option[String] and enforce no type constraint.
This method is overridden and made implicit by subtrait LegacyTripleEquals and overriden as non-implicit by the other subtraits in this package.
left
the object whose type to convert to LegacyEqualizer.

Definition Classes
TypeCheckedLegacyTripleEquals → 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
def lowPriorityConversionCheckedConstraint[A, B](implicit equivalenceOfB: Equivalence[B], cnv: (A) ⇒ B): Constraint[A, B]

Provides a Constraint[A, B] class for any two types A and B, enforcing the type constraint that A is implicitly convertible to B, given an implicit Equivalence[B].
Provides a Constraint[A, B] class 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 LowPriorityConversionCheckedLegacyConstraint (extended by ConversionCheckedLegacyTripleEquals), and overriden as non-implicit by the other subtraits in this package.
cnv
an implicit conversion from A to B
returns
a Constraint[A, B] whose areEqual method delegates to the areEquivalent method of the passed Equivalence[B].

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

Provides a Constraint[A, 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 a Constraint[A, 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 LowPriorityTypeCheckedLegacyConstraint (extended by TypeCheckedLegacyTripleEquals), 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
a Constraint[A, B] whose areEqual method delegates to the areEquivalent method of the passed Equivalence[B].

Definition Classes
LowPriorityTypeCheckedConstraint → 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
implicit def typeCheckedConstraint[A, B](implicit equivalenceOfA: Equivalence[A], ev: <:<[B, A]): Constraint[A, B]

Provides a Constraint[A, B] 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 a Constraint[A, B] 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 TypeCheckedLegacyTripleEquals, and overriden as non-implicit by the other subtraits in this package.
ev
evidence that B is a subype of A
returns
a Constraint[A, B] whose areEqual method delegates to the areEquivalent method of the passed Equivalence[A].

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

Provides a Constraint[A, B] class for any two types A and B, with no type constraint enforced, given an implicit Equality[A].
Provides a Constraint[A, B] class 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 LegacyTripleEquals, 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
a Constraint[A, B] whose areEqual method delegates to the areEqual method of the passed Equality[A].

Definition Classes
TypeCheckedLegacyTripleEquals → 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: trait TypeCheckedLegacyTripleEquals | package scalactic

object TypeCheckedLegacyTripleEquals extends TypeCheckedLegacyTripleEquals

Type Members

class CheckingEqualizer[L] extends AnyRef

class Equalizer[L] extends AnyRef

class LegacyCheckingEqualizer[L] extends AnyRef

class LegacyEqualizer[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

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

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

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

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

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

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

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

implicit def convertToLegacyCheckingEqualizer[T](left: T): LegacyCheckingEqualizer[T]

def convertToLegacyEqualizer[T](left: T): LegacyEqualizer[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

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

implicit def lowPriorityTypeCheckedConstraint[A, B](implicit equivalenceOfB: Equivalence[B], ev: <:<[A, B]): Constraint[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

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

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

final def wait(): Unit

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

final def wait(arg0: Long): Unit

Inherited from TypeCheckedLegacyTripleEquals

Inherited from LowPriorityTypeCheckedConstraint

Inherited from TripleEqualsSupport

Inherited from AnyRef

Inherited from Any

Ungrouped