Hash

Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

Definition Classes
AnyRef → Any
def +[Caps1[x] <: Hash[x], R1 <: Any](that: ZLawful[Caps1, R1]): ZLawful[Caps1, R1]

Definition Classes
ZLawful
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
implicit def ChunkHash[A](implicit arg0: Hash[A]): Hash[Chunk[A]]

Derives a Hash[Chunk[A]] given a Hash[A].
implicit def DeriveHash[F[_], A](implicit derive: Derive[F, Hash], hash: Hash[A]): Hash[F[A]]

Derives a Hash[F[A]] given a Derive[F, Hash] and a Hash[A].
implicit def EitherHash[A, B](implicit arg0: Hash[A], arg1: Hash[B]): Hash[Either[A, B]]

Derives a Hash[Either[A, B]] given a Hash[A] and a Hash[B].
implicit val HashContravariant: Contravariant[Hash]

The contravariant instance for Hash.
implicit val HashIdentityBoth: IdentityBoth[Hash]

The IdentityBoth (and thus AssociativeBoth) instance for Hash.
implicit val HashIdentityEither: IdentityEither[Hash]

The IdentityEither (and thus AssociativeEither) instance for Hash.
implicit def ListHash[A](implicit arg0: Hash[A]): Hash[List[A]]

Derives a Hash[List[A]] given a Hash[A].
implicit def MapHash[A, B](implicit arg0: Hash[B]): Hash[Map[A, B]]

Derives a Hash[Map[A, B]] given a Hash[B].
Derives a Hash[Map[A, B]] given a Hash[B]. Due to the limitations of Scala's Map, this uses object equality and hash code on the keys.
implicit def NonEmptyChunkHash[A](implicit arg0: Hash[A]): Hash[NonEmptyChunk[A]]

Derives a Hash[NonEmptyChunk[A]] given a Hash[A].
implicit def OptionHash[A](implicit arg0: Hash[A]): Hash[Option[A]]

Derives a Hash[Option[A]] given a Hash[A].
implicit def Tuple10Hash[A, B, C, D, E, F, G, H, I, J](implicit arg0: Hash[A], arg1: Hash[B], arg2: Hash[C], arg3: Hash[D], arg4: Hash[E], arg5: Hash[F], arg6: Hash[G], arg7: Hash[H], arg8: Hash[I], arg9: Hash[J]): Hash[(A, B, C, D, E, F, G, H, I, J)]

Derives an Hash for a product type given an Hash for each element of the product type.
implicit def Tuple11Hash[A, B, C, D, E, F, G, H, I, J, K](implicit arg0: Hash[A], arg1: Hash[B], arg2: Hash[C], arg3: Hash[D], arg4: Hash[E], arg5: Hash[F], arg6: Hash[G], arg7: Hash[H], arg8: Hash[I], arg9: Hash[J], arg10: Hash[K]): Hash[(A, B, C, D, E, F, G, H, I, J, K)]

Derives an Hash for a product type given an Hash for each element of the product type.
implicit def Tuple12Hash[A, B, C, D, E, F, G, H, I, J, K, L](implicit arg0: Hash[A], arg1: Hash[B], arg2: Hash[C], arg3: Hash[D], arg4: Hash[E], arg5: Hash[F], arg6: Hash[G], arg7: Hash[H], arg8: Hash[I], arg9: Hash[J], arg10: Hash[K], arg11: Hash[L]): Hash[(A, B, C, D, E, F, G, H, I, J, K, L)]

Derives an Hash for a product type given an Hash for each element of the product type.
implicit def Tuple13Hash[A, B, C, D, E, F, G, H, I, J, K, L, M](implicit arg0: Hash[A], arg1: Hash[B], arg2: Hash[C], arg3: Hash[D], arg4: Hash[E], arg5: Hash[F], arg6: Hash[G], arg7: Hash[H], arg8: Hash[I], arg9: Hash[J], arg10: Hash[K], arg11: Hash[L], arg12: Hash[M]): Hash[(A, B, C, D, E, F, G, H, I, J, K, L, M)]

Derives an Hash for a product type given an Hash for each element of the product type.
implicit def Tuple14Hash[A, B, C, D, E, F, G, H, I, J, K, L, M, N](implicit arg0: Hash[A], arg1: Hash[B], arg2: Hash[C], arg3: Hash[D], arg4: Hash[E], arg5: Hash[F], arg6: Hash[G], arg7: Hash[H], arg8: Hash[I], arg9: Hash[J], arg10: Hash[K], arg11: Hash[L], arg12: Hash[M], arg13: Hash[N]): Hash[(A, B, C, D, E, F, G, H, I, J, K, L, M, N)]

Derives an Hash for a product type given an Hash for each element of the product type.
implicit def Tuple15Hash[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O](implicit arg0: Hash[A], arg1: Hash[B], arg2: Hash[C], arg3: Hash[D], arg4: Hash[E], arg5: Hash[F], arg6: Hash[G], arg7: Hash[H], arg8: Hash[I], arg9: Hash[J], arg10: Hash[K], arg11: Hash[L], arg12: Hash[M], arg13: Hash[N], arg14: Hash[O]): Hash[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)]

Derives an Hash for a product type given an Hash for each element of the product type.
implicit def Tuple16Hash[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P](implicit arg0: Hash[A], arg1: Hash[B], arg2: Hash[C], arg3: Hash[D], arg4: Hash[E], arg5: Hash[F], arg6: Hash[G], arg7: Hash[H], arg8: Hash[I], arg9: Hash[J], arg10: Hash[K], arg11: Hash[L], arg12: Hash[M], arg13: Hash[N], arg14: Hash[O], arg15: Hash[P]): Hash[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)]

Derives an Hash for a product type given an Hash for each element of the product type.
implicit def Tuple17Hash[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q](implicit arg0: Hash[A], arg1: Hash[B], arg2: Hash[C], arg3: Hash[D], arg4: Hash[E], arg5: Hash[F], arg6: Hash[G], arg7: Hash[H], arg8: Hash[I], arg9: Hash[J], arg10: Hash[K], arg11: Hash[L], arg12: Hash[M], arg13: Hash[N], arg14: Hash[O], arg15: Hash[P], arg16: Hash[Q]): Hash[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)]

Derives an Hash for a product type given an Hash for each element of the product type.
implicit def Tuple18Hash[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R](implicit arg0: Hash[A], arg1: Hash[B], arg2: Hash[C], arg3: Hash[D], arg4: Hash[E], arg5: Hash[F], arg6: Hash[G], arg7: Hash[H], arg8: Hash[I], arg9: Hash[J], arg10: Hash[K], arg11: Hash[L], arg12: Hash[M], arg13: Hash[N], arg14: Hash[O], arg15: Hash[P], arg16: Hash[Q], arg17: Hash[R]): Hash[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)]

Derives an Hash for a product type given an Hash for each element of the product type.
implicit def Tuple19Hash[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S](implicit arg0: Hash[A], arg1: Hash[B], arg2: Hash[C], arg3: Hash[D], arg4: Hash[E], arg5: Hash[F], arg6: Hash[G], arg7: Hash[H], arg8: Hash[I], arg9: Hash[J], arg10: Hash[K], arg11: Hash[L], arg12: Hash[M], arg13: Hash[N], arg14: Hash[O], arg15: Hash[P], arg16: Hash[Q], arg17: Hash[R], arg18: Hash[S]): Hash[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)]

Derives an Hash for a product type given an Hash for each element of the product type.
implicit def Tuple20Hash[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T](implicit arg0: Hash[A], arg1: Hash[B], arg2: Hash[C], arg3: Hash[D], arg4: Hash[E], arg5: Hash[F], arg6: Hash[G], arg7: Hash[H], arg8: Hash[I], arg9: Hash[J], arg10: Hash[K], arg11: Hash[L], arg12: Hash[M], arg13: Hash[N], arg14: Hash[O], arg15: Hash[P], arg16: Hash[Q], arg17: Hash[R], arg18: Hash[S], arg19: Hash[T]): Hash[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)]

Derives an Hash for a product type given an Hash for each element of the product type.
implicit def Tuple21Hash[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U](implicit arg0: Hash[A], arg1: Hash[B], arg2: Hash[C], arg3: Hash[D], arg4: Hash[E], arg5: Hash[F], arg6: Hash[G], arg7: Hash[H], arg8: Hash[I], arg9: Hash[J], arg10: Hash[K], arg11: Hash[L], arg12: Hash[M], arg13: Hash[N], arg14: Hash[O], arg15: Hash[P], arg16: Hash[Q], arg17: Hash[R], arg18: Hash[S], arg19: Hash[T], arg20: Hash[U]): Hash[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)]

Derives an Hash for a product type given an Hash for each element of the product type.
implicit def Tuple22Hash[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V](implicit arg0: Hash[A], arg1: Hash[B], arg2: Hash[C], arg3: Hash[D], arg4: Hash[E], arg5: Hash[F], arg6: Hash[G], arg7: Hash[H], arg8: Hash[I], arg9: Hash[J], arg10: Hash[K], arg11: Hash[L], arg12: Hash[M], arg13: Hash[N], arg14: Hash[O], arg15: Hash[P], arg16: Hash[Q], arg17: Hash[R], arg18: Hash[S], arg19: Hash[T], arg20: Hash[U], arg21: Hash[V]): Hash[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)]

Derives an Hash for a product type given an Hash for each element of the product type.
implicit def Tuple2Hash[A, B](implicit arg0: Hash[A], arg1: Hash[B]): Hash[(A, B)]

Derives a Hash for a product type given a Hash for each element of the product type.
implicit def Tuple3Hash[A, B, C](implicit arg0: Hash[A], arg1: Hash[B], arg2: Hash[C]): Hash[(A, B, C)]

Derives an Hash for a product type given an Hash for each element of the product type.
implicit def Tuple4Hash[A, B, C, D](implicit arg0: Hash[A], arg1: Hash[B], arg2: Hash[C], arg3: Hash[D]): Hash[(A, B, C, D)]

Derives an Hash for a product type given an Hash for each element of the product type.
implicit def Tuple5Hash[A, B, C, D, E](implicit arg0: Hash[A], arg1: Hash[B], arg2: Hash[C], arg3: Hash[D], arg4: Hash[E]): Hash[(A, B, C, D, E)]

Derives an Hash for a product type given an Hash for each element of the product type.
implicit def Tuple6Hash[A, B, C, D, E, F](implicit arg0: Hash[A], arg1: Hash[B], arg2: Hash[C], arg3: Hash[D], arg4: Hash[E], arg5: Hash[F]): Hash[(A, B, C, D, E, F)]

Derives an Hash for a product type given an Hash for each element of the product type.
implicit def Tuple7Hash[A, B, C, D, E, F, G](implicit arg0: Hash[A], arg1: Hash[B], arg2: Hash[C], arg3: Hash[D], arg4: Hash[E], arg5: Hash[F], arg6: Hash[G]): Hash[(A, B, C, D, E, F, G)]

Derives an Hash for a product type given an Hash for each element of the product type.
implicit def Tuple8Hash[A, B, C, D, E, F, G, H](implicit arg0: Hash[A], arg1: Hash[B], arg2: Hash[C], arg3: Hash[D], arg4: Hash[E], arg5: Hash[F], arg6: Hash[G], arg7: Hash[H]): Hash[(A, B, C, D, E, F, G, H)]

Derives an Hash for a product type given an Hash for each element of the product type.
implicit def Tuple9Hash[A, B, C, D, E, F, G, H, I](implicit arg0: Hash[A], arg1: Hash[B], arg2: Hash[C], arg3: Hash[D], arg4: Hash[E], arg5: Hash[F], arg6: Hash[G], arg7: Hash[H], arg8: Hash[I]): Hash[(A, B, C, D, E, F, G, H, I)]

Derives an Hash for a product type given an Hash for each element of the product type.
implicit def VectorHash[A](implicit arg0: Hash[A]): Hash[Vector[A]]

Derives a Hash[Vector[A]] given a Hash[A].
def apply[A](implicit hash: Hash[A]): Hash[A]

Summons an implicit Hash[A].
final def asInstanceOf[T0]: T0

Definition Classes
Any
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
val consistencyLaw: Laws[Hash]

For all values a1 and a2, if a1 is equal to a2 then the hash of a1 is equal to the hash of a2.
def default[A]: Hash[A]

Constructs a Hash[A] that uses the default notion of hashing embodied in the implementation of hashCode for values of type A.
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
val laws: Laws[Hash]

The set of all laws that instances of Hash must satisfy.
The set of all laws that instances of Hash must satisfy.

Definition Classes
Hash → ZLawful
def make[A](hash0: (A) ⇒ Int, equal0: (A, A) ⇒ Boolean): Hash[A]

Constructs an instance from a function.
def makeFrom[A](hash0: (A) ⇒ Int, equal0: Equal[A]): Hash[A]

Constructs an instance from a hash function and an Equal instance.
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
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 Hash | package prelude

object Hash extends Lawful[Hash]

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

def +[Caps1[x] <: Hash[x], R1 <: Any](that: ZLawful[Caps1, R1]): ZLawful[Caps1, R1]

final def ==(arg0: Any): Boolean

implicit def ChunkHash[A](implicit arg0: Hash[A]): Hash[Chunk[A]]

implicit def DeriveHash[F[_], A](implicit derive: Derive[F, Hash], hash: Hash[A]): Hash[F[A]]

implicit def EitherHash[A, B](implicit arg0: Hash[A], arg1: Hash[B]): Hash[Either[A, B]]

implicit val HashContravariant: Contravariant[Hash]

implicit val HashIdentityBoth: IdentityBoth[Hash]

implicit val HashIdentityEither: IdentityEither[Hash]

implicit def ListHash[A](implicit arg0: Hash[A]): Hash[List[A]]

implicit def MapHash[A, B](implicit arg0: Hash[B]): Hash[Map[A, B]]

implicit def NonEmptyChunkHash[A](implicit arg0: Hash[A]): Hash[NonEmptyChunk[A]]

implicit def OptionHash[A](implicit arg0: Hash[A]): Hash[Option[A]]

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

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

implicit def Tuple12Hash[A, B, C, D, E, F, G, H, I, J, K, L](implicit arg0: Hash[A], arg1: Hash[B], arg2: Hash[C], arg3: Hash[D], arg4: Hash[E], arg5: Hash[F], arg6: Hash[G], arg7: Hash[H], arg8: Hash[I], arg9: Hash[J], arg10: Hash[K], arg11: Hash[L]): Hash[(A, B, C, D, E, F, G, H, I, J, K, L)]

implicit def Tuple2Hash[A, B](implicit arg0: Hash[A], arg1: Hash[B]): Hash[(A, B)]

implicit def Tuple3Hash[A, B, C](implicit arg0: Hash[A], arg1: Hash[B], arg2: Hash[C]): Hash[(A, B, C)]

implicit def Tuple4Hash[A, B, C, D](implicit arg0: Hash[A], arg1: Hash[B], arg2: Hash[C], arg3: Hash[D]): Hash[(A, B, C, D)]

implicit def Tuple5Hash[A, B, C, D, E](implicit arg0: Hash[A], arg1: Hash[B], arg2: Hash[C], arg3: Hash[D], arg4: Hash[E]): Hash[(A, B, C, D, E)]

implicit def Tuple6Hash[A, B, C, D, E, F](implicit arg0: Hash[A], arg1: Hash[B], arg2: Hash[C], arg3: Hash[D], arg4: Hash[E], arg5: Hash[F]): Hash[(A, B, C, D, E, F)]

implicit def Tuple7Hash[A, B, C, D, E, F, G](implicit arg0: Hash[A], arg1: Hash[B], arg2: Hash[C], arg3: Hash[D], arg4: Hash[E], arg5: Hash[F], arg6: Hash[G]): Hash[(A, B, C, D, E, F, G)]

implicit def Tuple8Hash[A, B, C, D, E, F, G, H](implicit arg0: Hash[A], arg1: Hash[B], arg2: Hash[C], arg3: Hash[D], arg4: Hash[E], arg5: Hash[F], arg6: Hash[G], arg7: Hash[H]): Hash[(A, B, C, D, E, F, G, H)]

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

implicit def VectorHash[A](implicit arg0: Hash[A]): Hash[Vector[A]]

def apply[A](implicit hash: Hash[A]): Hash[A]

final def asInstanceOf[T0]: T0

def clone(): AnyRef

val consistencyLaw: Laws[Hash]

def default[A]: Hash[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

val laws: Laws[Hash]

def make[A](hash0: (A) ⇒ Int, equal0: (A, A) ⇒ Boolean): Hash[A]

def makeFrom[A](hash0: (A) ⇒ Int, equal0: Equal[A]): Hash[A]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

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

def toString(): String

final def wait(): Unit

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

final def wait(arg0: Long): Unit

Inherited from ZLawful[Hash, Any]

Inherited from AnyRef

Inherited from Any

Ungrouped