final def !=(arg0: Any): Boolean

Definition Classes: AnyRef → Any

final def ##(): Int

Definition Classes: AnyRef → Any

final def ==(arg0: Any): Boolean

Definition Classes: AnyRef → Any

val AnyHashOrd: Hash[Any] with Ord[Any]

Ord (and thus also Equal) instance for Any values.

Ord (and thus also Equal) instance for Any values. Note that since values of type Any contain no information, all values of type Any can be treated as equal to each other.

implicit val BigDecimalHashOrd: Hash[BigDecimal] with Ord[BigDecimal]

The Hash and Ord instance for BigDecimal.

implicit val BigIntHashOrd: Hash[BigInt] with Ord[BigInt]

The Hash and Ord instance for BigInt.

implicit val BooleanHashOrd: Hash[Boolean] with Ord[Boolean]

Hash and Ord (and thus also Equal) instance for Boolean values.

implicit val ByteHashOrd: Hash[Byte] with Ord[Byte]

Hash and Ord (and thus also Equal) instance for Byte values.

implicit def CauseHash[A]: Hash[Cause[A]]

Hash (and thus also Equal) instance for Cause[A].

Hash (and thus also Equal) instance for Cause[A]. Note, that it doesn't take Hash[A] nor Equal[A] into account.

implicit val CharHashOrd: Hash[Char] with Ord[Char]

Hash and Ord (and thus also Equal) instance for Char values.

implicit def ChunkEqual[A](implicit arg0: Equal[A]): Equal[Chunk[A]]

Derives an Equal[Chunk[A]] given an Equal[A].

implicit val ClassHash: Hash[Class[_]]

Hash (and thus also Equal) instance for Class values.

implicit def DeriveEqual[F[_], A](implicit arg0: DeriveEqual[F], arg1: Equal[A]): Equal[F[A]]

Derives an Equal[F[A]] given a Derive[F, Equal] and an Equal[A].

def DoubleEqualWithEpsilon(epsilon: Double = 1 / (1024d * 1024 * 1024 * 1024)): Equal[Double]

Equal instance for Double for imprecise equality with configurable tolerance.

implicit val DoubleHashOrd: Hash[Double] with Ord[Double]

Hash and Ord (and thus also Equal) instance for Double values.

Note that to honor the contract

* that a value is always equal to itself, comparing Double.NaN with itself will return true.

* of a total ordering, Double.NaN will be treated as greater than any other number.

implicit val DurationScalaHashOrd: Hash[scala.concurrent.duration.Duration] with Ord[scala.concurrent.duration.Duration]

Hash and Ord (and thus also Equal) instance for Scala Duration values.

implicit val DurationZIOHashOrd: Hash[zio.Duration] with Ord[zio.Duration]

Hash and Ord (and thus also Equal) instance for ZIO Duration values.

implicit def EitherEqual[A, B](implicit arg0: Equal[A], arg1: Equal[B]): Equal[Either[A, B]]

Derives an Equal[Either[A, B]] given an Equal[A] and an Equal[B].

implicit val EqualCommutativeIdentityBoth: CommutativeBoth[Equal] with IdentityBoth[Equal]

The CommutativeBoth and IdentityBoth (and thus AssociativeBoth) instance for Equal.

implicit val EqualCommutativeIdentityEither: CommutativeEither[Equal] with IdentityEither[Equal]

The CommutativeEither and IdentityEither (and thus AssociativeEither) instance for Equal.

implicit val EqualContravariant: Contravariant[Equal]

The Contravariant instance for Equal.

implicit def ExitEqual[E, A](implicit arg0: Equal[A]): Equal[Exit[E, A]]

Derives an Equal[Exit[E, A]] given an Equal[A] and Equal[B].

implicit lazy val FiberIdHashOrd: Hash[FiberId]

Hash and (and thus also Equal) instance for FiberId values.

def FloatEqualWithEpsilon(epsilon: Float = 1 / (1024f * 1024)): Equal[Float]

Equal instance for Float for imprecise equality with configurable tolerance.

implicit val FloatHashOrd: Hash[Float] with Ord[Float]

Hash and Ord (and thus also Equal) instance for Float values.

Note that to honor the contract

* that a value is always equal to itself, comparing Float.NaN with itself will return true.

* of a total ordering, Float.NaN will be treated as greater than any other number.

implicit val IntHashOrd: Hash[Int] with Ord[Int]

Hash and Ord (and thus also Equal) instance for Int values.

implicit def ListEqual[A](implicit arg0: Equal[A]): Equal[List[A]]

Derives an Equal[List[A]] given an Equal[A].

implicit val LongHashOrd: Hash[Long] with Ord[Long]

Hash and Ord (and thus also Equal) instance for Long values.

implicit def MapPartialOrd[A, B](implicit arg0: Equal[B]): PartialOrd[Map[A, B]]

Derives a PartialOrd[Map[A, B]] (and thus Equal[Map[A, B]]) given an Equal[B].

Derives a PartialOrd[Map[A, B]] (and thus Equal[Map[A, B]]) given an Equal[B]. Due to the limitations of Scala's Map, this uses object equality on the keys.

implicit def NonEmptyChunkEqual[A](implicit arg0: Equal[A]): Equal[NonEmptyChunk[A]]

Derives an Equal[NonEmptyChunk[A]] given an Equal[A].

implicit val NothingHashOrd: Hash[Nothing] with Ord[Nothing]

Hash and Ord (and thus also Equal) instance for Nothing values.

Hash and Ord (and thus also Equal) instance for Nothing values. Note that since there are not values of type Nothing the equals method of this instance can never be called but it can be useful in deriving instances for more complex types.

implicit def OptionEqual[A](implicit arg0: Equal[A]): Equal[Option[A]]

Derives an Equal[Option[A]] given an Equal[A].

implicit def SetHashPartialOrd[A]: Hash[Set[A]] with PartialOrd[Set[A]]

PartialOrd and Hash (and thus also Equal) instance for Set[A] values.

PartialOrd and Hash (and thus also Equal) instance for Set[A] values. Due to the limitations of Scala's Set, this uses object equality and hash code on the elements.

implicit val ShortHashOrd: Hash[Short] with Ord[Short]

Hash and Ord (and thus also Equal) instance for Short values.

implicit val StackTraceHash: Hash[StackTrace]

Hash (and thus also Equal) instance for StackTrace values.

implicit val StringHashOrd: Hash[String] with Ord[String]

Hash and Ord (and thus also Equal) instance for String values.

lazy val ThrowableHash: Hash[Throwable]

Hash (and thus also Equal) instance for Throwable values.

Hash (and thus also Equal) instance for Throwable values. Comparison is based on: Class, message and cause (stack trace is ignored).

Note: This is intentionally not in the implicit scope, because it would allow comparing _all_ Throwables across hierarchies defined by users, which would typically be a mistake.

implicit def TryEqual[A](implicit arg0: Equal[A]): Equal[Try[A]]

Derives an Equal[Try[A]] given an Equal[A].

implicit def Tuple10Equal[A, B, C, D, E, F, G, H, I, J](implicit arg0: Equal[A], arg1: Equal[B], arg2: Equal[C], arg3: Equal[D], arg4: Equal[E], arg5: Equal[F], arg6: Equal[G], arg7: Equal[H], arg8: Equal[I], arg9: Equal[J]): Equal[(A, B, C, D, E, F, G, H, I, J)]