maps.c

Go to the documentation of this file.

/* -*- C -*-
 * Serene programming language
 * Copyright (C) 2019-2026 Sameer Rahmani <[email protected]>
 *
 * This library is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this library.  If not, see <https://www.gnu.org/licenses/>.
 */
#include "serene/rt/maps.h"
 
#include "serene/rt/context.h"
#include "serene/rt/core.h"
#include "serene/rt/engine.h"
#include "serene/rt/errors.h"
#include "serene/rt/impl/hashmap.h"
#include "serene/rt/protocols.h"
#include "serene/utils.h"
 
static bool srn_vmap_cmp(const hmap_t *hmap, const hmap_key_t *a, const hmap_key_t *b) {
  srn_value_t *va  = (srn_value_t *)a->data;
  srn_value_t *vb  = (srn_value_t *)b->data;
  srn_value_t *res = srn_value_eq(hmap->map_ctx, va, vb);
  switch (TYPE(res)) {
  case VFalse:
    return false;
  case VTrue:
    return true;
  default:
    PANIC("Should never happen");
  }
}
 
[[gnu::nonnull(1)]]
static hmap_hash_t srn_vmap_hash(const hmap_t *hmap, const hmap_key_t *k) {
  PANIC_IF_NULL(k);
  PANIC_IF_NULL(k->data);
  srn_value_t *v = (srn_value_t *)k->data;
 
  PANIC_IF_NULL(v);
  return srn_value_hash(hmap->map_ctx, v);
}
 
static const hmap_control_t value_map = {
  .cmp    = &srn_vmap_cmp,
  .hash   = &srn_vmap_hash,
  .insert = hmap_insert_ctl,
  .lookup = hmap_lookup_ctl,
  // The key bytes are a shallow srn_value_t struct; copying them into the
  // map's pinned context keeps the retained key valid independently of the
  // assoc'ing caller's context. Anything the value points at (its payload,
  // metadata) is still the caller's to keep alive.
  .copy_key = &hmap_copy_key,
};
 
srn_value_t *srn_map_empty(srn_context_t *ctx, srn_metadata_t *metadata) {
  PANIC_IF_NULL(ctx);
  srn_map_t *m = ALLOC(ctx, srn_map_t);
  m->inner     = hmap_empty(ctx);
  return srn_value_make(ctx, VMap, metadata, (void *)m);
}
 
srn_value_t *srn_map_assoc(
  srn_context_t *ctx, srn_metadata_t *metadata, srn_value_t *map, srn_value_t *key,
  srn_value_t *value
) {
  PANIC_IF_NULL(ctx);
  PANIC_IF_NULL(map);
  PANIC_IF_NULL(key);
  PANIC_IF_NULL(value);
 
  if (!IS_A(map, VMap)) {
    return srn_errors_make_error(ctx, metadata, ABSURD, "expected a map");
  }
 
  // Hashing panics on the unhashable tags, and a panic from a data driven
  // value is wrong in an API that reports failures as values.
  if (!srn_value_hashable(key)) {
    return srn_errors_make_error(ctx, metadata, ABSURD, "map key is not hashable");
  }
 
  hmap_key_t k = {.data = key, .len = sizeof(*key)};
 
  srn_map_t *old = AS_MAP(map);
  srn_map_t *neu = ALLOC(ctx, srn_map_t);
 
  neu->inner = value_map.insert(&value_map, &old->inner, &k, value);
  return srn_value_make(ctx, VMap, metadata, (void *)neu);
}