jon.recoil.org

Module Flambda_kind.With_subkind

type full_kind
module Nullable : sig ... end
module Non_null_value_subkind : sig ... end
type t = full_kind
val anything : kind -> t
val kind : t -> kind
val non_null_value_subkind : t -> Non_null_value_subkind.t
val nullable : t -> Nullable.t
val has_useful_subkind_info : t -> bool
val any_value : t
val naked_immediate : t
val naked_float32 : t
val naked_float : t
val naked_int8 : t
val naked_int16 : t
val naked_int32 : t
val naked_int64 : t
val naked_nativeint : t
val naked_vec128 : t
val naked_vec256 : t
val naked_vec512 : t
val region : t
val boxed_float : t
val boxed_int32 : t
val boxed_int64 : t
val boxed_nativeint : t
val boxed_vec128 : t
val tagged_immediate : t
val rec_info : t
val float_array : t
val immediate_array : t
val value_array : t
val generic_array : t
val unboxed_vec128_array : t
val unboxed_vec256_array : t
val unboxed_vec512_array : t
val unboxed_product_array : t
val block : Tag.t -> t list -> t
val float_block : num_fields:int -> t
val of_naked_number_kind : Naked_number_kind.t -> t
val naked_of_boxable_number : Boxable_number.t -> t
val boxed_of_boxable_number : Boxable_number.t -> t
val from_lambda_value_kind : Lambda.value_kind -> machine_width:Target_system.Machine_width.t -> t
val from_lambda_values_and_unboxed_numbers_only : Lambda.layout -> machine_width:Target_system.Machine_width.t -> t
val compatible : t -> when_used_at:t -> bool
val erase_subkind : t -> t
include Flambda2_algorithms.Container_types.S with type t := t
include Flambda2_algorithms.Container_types_intf.Thing with type t := T.t
include Hashtbl.HashedType with type t := T.t
val equal : T.t -> T.t -> bool

The equality predicate used to compare keys.

val hash : T.t -> int

A hashing function on keys. It must be such that if two keys are equal according to equal, then they have identical hash values as computed by hash. Examples: suitable (equal, hash) pairs for arbitrary key types include

  • ((=), hash) for comparing objects by structure (provided objects do not contain floats)
  • ((fun x y -> compare x y = 0), hash) for comparing objects by structure and handling Stdlib.nan correctly
  • ((==), hash) for comparing objects by physical equality (e.g. for mutable or cyclic objects).
include Map.OrderedType with type t := T.t
val compare : T.t -> T.t -> int

A total ordering function over the keys. This is a two-argument function f such that f e1 e2 is zero if the keys e1 and e2 are equal, f e1 e2 is strictly negative if e1 is smaller than e2, and f e1 e2 is strictly positive if e1 is greater than e2. Example: a suitable ordering function is the generic structural comparison function Stdlib.compare.

val print : Format.formatter -> T.t -> unit
module Map : Flambda2_algorithms.Container_types_intf.Map with type key = t and module Set = Set
val equal_ignoring_subkind : t -> t -> bool
val must_be_gc_scannable : t -> bool