protocols.h File Reference

#include "serene/rt/engine.h"

Include dependency graph for protocols.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
srn_value_t *	srn_value_eq (const srn_context_t *ctx, const srn_value_t *a, const srn_value_t *b)
	Check to values for equality. Return a boolean.
srn_hash_t	srn_value_hash (const srn_context_t *ctx, const srn_value_t *v)
	Compute the xxHash32 of a value using the engine seed.
bool	srn_value_hashable (const srn_value_t *v)
	Whether v can be a hash key.

Function Documentation

srn_value_eq()

srn_value_t * srn_value_eq	(	const srn_context_t *	ctx,
		const srn_value_t *	a,
		const srn_value_t *	b )

Check to values for equality. Return a boolean.

Definition at line 38 of file protocols.c.

                                                                                                {
  PANIC_IF_NULL(ctx);
  if (a == nullptr || b == nullptr || (a->type != b->type)) {
    return &false_v;
  }
 
  switch (a->type) {
  case VNil:
  case VTrue:
  case VFalse:
    // Tag-only values; matching tags means equal.
    return &true_v;
 
  case VI64:
    return equality_to_value(AS_I64(a) == AS_I64(b));
 
  case VF64:
    // IEEE compare: NaN != NaN, +0.0 == -0.0. Hash normalizes -0.0 -> +0.0
    // so the eq <=> hash invariant holds.
    return equality_to_value(AS_F64(a) == AS_F64(b));
 
  case VString:
    return equality_to_value(srn_string_eq(AS_STRING(a), AS_STRING(b)));
 
  case VSymbol:
    // Symbols are interned per namespace; pointer identity is enough.
    return equality_to_value(AS_SYMBOL(a) == AS_SYMBOL(b));
 
  case VKeyword:
    // Keywords are interned engine-wide; pointer identity is enough.
    return equality_to_value(AS_KEYWORD(a) == AS_KEYWORD(b));
 
  case VNamespace:
    // Namespaces are unique per engine; pointer identity suffices.
    return equality_to_value(AS_NS(a) == AS_NS(b));
 
  case VList: {
    srn_list_t *la = AS_LIST(a);
    srn_list_t *lb = AS_LIST(b);
    if (la->len != lb->len) {
      return &false_v;
    }
    srn_list_node_t *na = la->head;
    srn_list_node_t *nb = lb->head;
    while (na != nullptr) {
      if (srn_value_eq(ctx, na->value, nb->value) == &false_v) {
        return &false_v;
      }
      na = na->next;
      nb = nb->next;
    }
    return &true_v;
  }
 
  case VSeq: {
    srn_seq_t *sa = AS_SEQ(a);
    srn_seq_t *sb = AS_SEQ(b);
 
    if (sa->inner.len != sb->inner.len) {
      return &false_v;
    }
    for (size_t i = 0; i < sa->inner.len; i++) {
      seq_lookup_result_t ra = seq_get(&sa->inner, i);
      seq_lookup_result_t rb = seq_get(&sb->inner, i);
      // A lookup error inside the length is corruption, the same condition
      // the hash path panics on. Returning false here instead would make a
      // corrupted seq compare unequal to itself with no diagnostic.
      PANIC_IF(ra.maybe_error != nullptr || rb.maybe_error != nullptr, "Corrupted seq during eq");
      if (srn_value_eq(ctx, (srn_value_t *)ra.data, (srn_value_t *)rb.data) == &false_v) {
        return &false_v;
      }
    }
    return &true_v;
  }
 
  case VMap:
    // Identity equality for now. Two maps compare equal iff they share the
    // same underlying CHAMT instance. Structural map equality is parked until
    // there's a real need (and a corresponding hmap walker).
    return equality_to_value(AS_MAP(a) == AS_MAP(b));
 
  case VClosure:
    return equality_to_value(AS_CLOSURE(a) == AS_CLOSURE(b));
 
  case VError:
    return equality_to_value(AS_ERROR(a) == AS_ERROR(b));
 
  case VQuote:
    TODO("VQuote payload is not defined yet");
 
  default:
    PANIC("Unknown value tag in srn_value_eq");
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

srn_value_hash()

srn_hash_t srn_value_hash	(	const srn_context_t *	ctx,
		const srn_value_t *	v )

Compute the xxHash32 of a value using the engine seed.

The invariant srn_value_eq(a, b) == true_v => srn_value_hash(a) == srn_value_hash(b) must hold for every tag.

Definition at line 152 of file protocols.c.

                                                                          {
  PANIC_IF_NULL(ctx);
  PANIC_IF_NULL(v);
 
  srn_engine_t *engine = ctx->engine;
 
  switch (v->type) {
  case VNil: {
    return 0;
  }
  case VTrue: {
    return 1;
  }
  case VFalse: {
    return 2;
  }
 
  case VI64: {
    int64_t n = AS_I64(v);
    return srn_hash(engine, &n, sizeof(n));
  }
 
  case VF64: {
    double d = AS_F64(v);
    // If you find this weird is hell, you're not alone but apparently +0.0 and -0.0 compare equal
    // under IEEE rules but differ in the sign bit. So we have to normalize so the eq -> hash
    // invariant holds.
    // https://en.wikipedia.org/wiki/Signed_zero
    // https://docs.rs/fix_float
    if (d == 0.0) {
      d = 0.0;
    }
    return srn_hash(engine, &d, sizeof(d));
  }
 
  case VString: {
    srn_string_t *s = AS_STRING(v);
    return srn_hash(engine, s->buffer, s->len);
  }
 
  case VSymbol: {
    // Interned identity, hash the pointer bits.
    srn_symbol_t *sym = AS_SYMBOL(v);
    return srn_hash(engine, sym, sizeof(*sym));
  }
 
  case VKeyword: {
    // Interned; hash the pointer-sized payload (the name pointer).
    srn_keyword_t *k = AS_KEYWORD(v);
    return srn_hash(engine, k, sizeof(*k));
  }
 
  case VNamespace: {
    srn_namespace_t *ns = AS_NS(v);
    return srn_hash(engine, ns->name->buffer, ns->name->len);
  }
 
  case VList:
    // Lists are intentionally not hashable; they can't be used as map keys.
    // Use a seq or other container if you need a hashable sequence.
    PANIC("Lists are not hashable");
 
  case VSeq: {
    srn_seq_t *s = AS_SEQ(v);
    srn_hash_t h = srn_hash(engine, &s->inner.len, sizeof(s->inner.len));
 
    for (size_t i = 0; i < s->inner.len; i++) {
      seq_lookup_result_t r = seq_get(&s->inner, i);
      if (r.maybe_error != nullptr) {
        PANIC("Corrupted seq during hash");
      }
      srn_hash_t hi = srn_value_hash(ctx, (srn_value_t *)r.data);
      h             = combine2(engine, h, hi);
    }
    return h;
  }
 
  case VMap: {
    PANIC("Hashmaps are not hashable");
  }
 
  case VClosure: {
    PANIC("Closures are not hashable");
  }
 
  case VError: {
    srn_error_t *e = AS_ERROR(v);
    return srn_hash(engine, e, sizeof(*e));
  }
 
  case VQuote:
    TODO("VQuote payload is not defined yet");
 
  default:
    PANIC("Unknown value tag in srn_value_hash");
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

srn_value_hashable()

bool srn_value_hashable ( const srn_value_t * v )

nodiscard

Whether v can be a hash key.

srn_value_hash panics on the container and closure tags, so anything keying a map must pass this first and fail as an error value instead.

Definition at line 139 of file protocols.c.

                                              {
  PANIC_IF_NULL(v);
  switch (v->type) {
  case VList:
  case VMap:
  case VClosure:
  case VQuote:
    return false;
  default:
    return true;
  }
}

Here is the caller graph for this function: