containers: add typed int_hash / float_hash / bitvec_hash

R13 audit identified the missing hash callbacks for Int/Float/BitVec --
all three ship a typed compare but no hash, so they can't drop into a
Map without the caller rolling their own helper.

Following the Vec/Map callback pattern (typed signature -- callers
cast to GenericHash at the use site, as VecFind / MapInitFull_9
already do for compare), each new hash function keeps the type-safe
shape:

  u64 int_hash(Int *value, u32 size);
  u64 float_hash(Float *value, u32 size);
  u64 bitvec_hash(BitVec *bv, u32 size);

Bodies are FNV-1a:
- Int: magnitude bytes only (Int is unsigned by design).
- Float: significand magnitude + i64 exponent bytes + sign bit, so
  +1.5e3 / -1.5e3 / 1.5e2 all land in different buckets.
- BitVec: live bit bytes + a length tail-mix, so bitvectors that
  share a byte prefix but differ in length still distinguish.

The 'size' parameter is the GenericHash callback's value-slot size --
ignored here because the real length lives inside the value itself.

Drops .audit-questions.md item 1 (the hash gap) -- only the Debug.c
pre-existing warnings carve-out remains parked.

Author: brightprogrammer

Include/Misra/Std/Container/BitVec/Compare.h

@@ -144,6 +144,25 @@ extern "C" {
     ///
     int BitVecCompare(BitVec *bv1, BitVec *bv2);
 
+    ///
+    /// Hash a `BitVec` for use as a map key. FNV-1a over the live bits
+    /// with the bit length mixed in at the tail, so two bitvectors that
+    /// share a byte prefix but differ in length still land in different
+    /// buckets. Typed signature; cast to `GenericHash` at the `Map` /
+    /// `Vec` callback site.
+    ///
+    /// bv[in]   : BitVec to hash.
+    /// size[in] : Ignored. Included for `GenericHash`-cast compatibility.
+    ///
+    /// SUCCESS : Returns a stable hash of the bit pattern + length.
+    ///
+    /// USAGE:
+    ///   Map(BitVec, u64) counts = MapInit(bitvec_hash, BitVecCompare, alloc);
+    ///
+    /// TAGS: BitVec, Hash, GenericHash
+    ///
+    u64 bitvec_hash(BitVec *bv, u32 size);
+
     ///
     /// Compare two bitvectors as unsigned integers.
     /// Treats bitvectors as unsigned binary numbers (LSB first).

Include/Misra/Std/Container/Float/Compare.h

@@ -28,6 +28,25 @@ extern "C" {
     ///
     int float_compare_with_error(Float *lhs, Float *rhs, bool *error);
     int float_compare(Float *lhs, Float *rhs);
+
+    ///
+    /// Hash a `Float` for use as a map key. FNV-1a over the significand
+    /// magnitude bytes, the exponent, and the sign so `+1.5e3`,
+    /// `-1.5e3`, and `1.5e2` land in different buckets. Typed signature;
+    /// cast to `GenericHash` at the `Map` / `Vec` callback site.
+    ///
+    /// value[in] : Float to hash.
+    /// size[in]  : Ignored. Included for `GenericHash`-cast compatibility.
+    ///
+    /// SUCCESS : Returns a stable hash of the float's representation.
+    ///
+    /// USAGE:
+    ///   Map(Float, u64) counts = MapInit(float_hash, float_compare, alloc);
+    ///
+    /// TAGS: Float, Hash, GenericHash
+    ///
+    u64 float_hash(Float *value, u32 size);
+
 #ifndef __cplusplus
 #    define FLOAT_COMPARE_DISPATCH(rhs)                                                                                \
         _Generic(                                                                                                      \

Include/Misra/Std/Container/Int/Compare.h

@@ -28,6 +28,24 @@ extern "C" {
     ///
     int int_compare(Int *lhs, Int *rhs);
 
+    ///
+    /// Hash an `Int` for use as a map key. FNV-1a over the magnitude
+    /// bytes. Typed signature; cast to `GenericHash` at the
+    /// `Map` / `Vec` callback site (the standard pattern -- see
+    /// `MapInitFull_9` and `VecFind`).
+    ///
+    /// value[in] : Int to hash.
+    /// size[in]  : Ignored. Included for `GenericHash`-cast compatibility.
+    ///
+    /// SUCCESS : Returns a stable hash of the integer's magnitude.
+    ///
+    /// USAGE:
+    ///   Map(Int, u64) counts = MapInit(int_hash, int_compare, alloc);
+    ///
+    /// TAGS: Int, Hash, GenericHash
+    ///
+    u64 int_hash(Int *value, u32 size);
+
 #ifndef __cplusplus
 #    define INT_COMPARE_DISPATCH(rhs)                                                                                  \
         _Generic(                                                                                                      \

Source/Misra/Std/Container/BitVec.c

@@ -654,6 +654,30 @@ bool BitVecEqualsRange(BitVec *bv1, u64 start1, BitVec *bv2, u64 start2, u64 len
     return true;
 }
 
+// FNV-1a over the live bit-vector bytes plus a length tail-mix so two
+// bitvectors that share a byte prefix but differ in length still hash
+// to distinct buckets. Typed signature -- callers cast to GenericHash
+// at the Map / Vec callback site.
+u64 bitvec_hash(BitVec *bv, u32 size) {
+    u64 hash = 1469598103934665603ULL;
+
+    (void)size;
+    ValidateBitVec(bv);
+
+    u64       bit_count  = bv->length;
+    u64       byte_count = bit_count == 0 ? 0 : BYTES_FOR_BITS(bit_count);
+    const u8 *bytes      = (const u8 *)bv->data;
+    for (u64 i = 0; i < byte_count; i++) {
+        hash ^= (u64)bytes[i];
+        hash *= 1099511628211ULL;
+    }
+    for (u64 i = 0; i < sizeof(bit_count); i++) {
+        hash ^= (bit_count >> (i * 8u)) & 0xFFu;
+        hash *= 1099511628211ULL;
+    }
+    return hash;
+}
+
 int BitVecCompare(BitVec *bv1, BitVec *bv2) {
     ValidateBitVec(bv1);
     ValidateBitVec(bv2);

Source/Misra/Std/Container/Float.c

@@ -759,6 +759,34 @@ int float_compare(Float *lhs, Float *rhs) {
     return float_compare_with_error(lhs, rhs, NULL);
 }
 
+// FNV-1a over significand magnitude bytes, exponent, and sign. Typed
+// signature -- callers cast to GenericHash at the Map/Vec callback
+// site (see MapInitFull_9 / VecFind for the pattern).
+u64 float_hash(Float *value, u32 size) {
+    u64 hash = 1469598103934665603ULL;
+
+    (void)size;
+    ValidateFloat(value);
+
+    u64       bits      = IntBitLength(&value->significand);
+    u64       bytes     = bits == 0 ? 0 : CEIL_DIV(bits, 8u);
+    const u8 *magnitude = (const u8 *)BitVecData(&value->significand.bits);
+    for (u64 i = 0; i < bytes; i++) {
+        hash ^= (u64)magnitude[i];
+        hash *= 1099511628211ULL;
+    }
+    // Mix exponent bytes (little-endian view of the signed i64).
+    i64 exp = value->exponent;
+    for (u64 i = 0; i < sizeof(exp); i++) {
+        hash ^= ((u64)exp >> (i * 8u)) & 0xFFu;
+        hash *= 1099511628211ULL;
+    }
+    // Sign byte so +N and -N hash differently.
+    hash ^= (u64)(value->negative ? 1u : 0u);
+    hash *= 1099511628211ULL;
+    return hash;
+}
+
 int float_compare_int_with_error(Float *lhs, Int *rhs, bool *error) {
     Float rhs_value = FloatInit(lhs->significand.bits.allocator);
     int   cmp       = 0;

Source/Misra/Std/Container/Int.c

@@ -919,6 +919,26 @@ Str IntToHexStr(Int *value) {
     return IntToStrRadix(value, 16, false);
 }
 
+// FNV-1a over the significant magnitude bytes. `size` is the
+// GenericHash callback's value-slot size; ignored since Int's real
+// length lives inside the value itself. `Int` is unsigned by design,
+// so there's no sign byte to mix in.
+u64 int_hash(Int *value, u32 size) {
+    u64 hash = 1469598103934665603ULL;
+
+    (void)size;
+    ValidateInt(value);
+
+    u64       bits      = IntBitLength(value);
+    u64       bytes     = bits == 0 ? 0 : CEIL_DIV(bits, 8u);
+    const u8 *magnitude = (const u8 *)BitVecData(INT_BITS(value));
+    for (u64 i = 0; i < bytes; i++) {
+        hash ^= (u64)magnitude[i];
+        hash *= 1099511628211ULL;
+    }
+    return hash;
+}
+
 int int_compare(Int *lhs, Int *rhs) {
     ValidateInt(lhs);
     ValidateInt(rhs);