# Module `Tuple.Hashable`

The difference between `Hashable`

and `Hashable_t`

functors is that the former's result type doesn't contain type `t`

and the latter does. Therefore, `Hashable`

can't be used to combine two pairs into 4-tuple. but `Hashable_t`

can. On the other hand result of `Hashable_t`

cannot be combined with `Comparable`

.

example: module Four_ints = Tuple.Hashable_t (Tuple.Hashable_t (Int)(Int)) (Tuple.Hashable_t (Int)(Int))

If instead we used `Hashable`

compiler would complain that the input to outer functor doesn't have type `t`

.

On the other hand: module Foo = struct type t = String.t * Int.t include Tuple.Comparable (String) (Int) include Tuple.Hashable (String) (Int) end

If we used `Hashable_t`

above, the compiler would complain that we have two types `t`

defined.

Unfortunately, it is not possible to define just one functor that could be used in both cases.

### Parameters

### Signature

`include Ppx_sexp_conv_lib.Sexpable.S with type t := t`

`val t_of_sexp : Sexplib0.Sexp.t -> t`

`val sexp_of_t : t -> Sexplib0.Sexp.t`

`include Core_kernel.Hashable.S with type t := t`

`include Core_kernel.Hashable.Common`

`val compare : t -> t -> Core_kernel__.Import.int`

`val hash_fold_t : Base.Hash.state -> t -> Base.Hash.state`

`val hash : t -> Base.Hash.hash_value`

`val hashable : t Core_kernel.Hashtbl.Hashable.t`

`module Table : Core_kernel.Hashtbl.S with type key = t`

`module Hash_set : Core_kernel.Hash_set.S with type elt = t`

`module Hash_queue : Core_kernel.Hash_queue.S with type key = t`