support putting things with identity in hashmap

Author: p7g

README.md

@@ -346,6 +346,7 @@ least for now:
 - `__gc_collect`: Have the garbage collector run immediately. It has a scary
   name because it seems like a scary thing to do.
 - `__dis`: Print the disassembly of the given function directly to stdout.
+- `id`: Get the ID of the given value if it has one.
 
 ## Standard Library
 

intrinsics.c

@@ -52,7 +52,8 @@
 	X("toint", toint, 1) \
 	X("__gc_collect", __gc_collect, 0) \
 	X("__dis", __dis, 1) \
-	X("arguments", arguments, 0)
+	X("arguments", arguments, 0) \
+	X("id", id, 1)
 
 INTRINSIC_LIST(DECL);
 
@@ -558,5 +559,19 @@ static int arguments(size_t argc, struct cb_value *argv,
 	result->type = CB_VALUE_ARRAY;
 	result->val.as_array = args;
 
+	return 0;
+}
+
+static int id(size_t argc, struct cb_value *argv, struct cb_value *result)
+{
+	result->type = CB_VALUE_INT;
+
+	if (cb_value_id(argv[0], &result->val.as_int)) {
+		struct cb_value err;
+		cb_value_from_fmt(&err, "Value of type %s has no identity", cb_value_type_friendly_name(argv[0].type));
+		cb_error_set(err);
+		return 1;
+	}
+
 	return 0;
 }

lib/hashmap.cb

@@ -16,10 +16,15 @@ export struct HashMap {
 
 struct Bucket { key, value, prev, next }
 
-let default_hash = hash::primitive;
-
 function do_hash(self, key) {
-  return hash::hash(key) & self.cap - 1;
+  try {
+    return hash::hash(key) & self.cap - 1;
+  } catch (exc) {
+    if (!trait::implements(key, hash::Hashable)) {
+        return id(key) & self.cap - 1;
+    }
+    throw exc;
+  }
 }
 
 function grow(self) {

tests/test_hashmap.cb

@@ -30,6 +30,13 @@ export function test_basics() {
     test::assert(hashmap::has(m, 1), "has 1");
     test::assert(hashmap::get(m, 1) == "one", "1 is one");
     test::assert(hashmap::size(m) == 3);
+
+    let s = struct {};
+    test::assert(!hashmap::has(m, s));
+    hashmap::set(m, s, "S");
+    test::assert(hashmap::has(m, s));
+    test::assert(hashmap::get(m, s) == "S");
+    test::assert(hashmap::size(m) == 4);
 }
 
 function iterlength(it) {

value.c

@@ -865,4 +865,50 @@ CB_INLINE size_t cb_function_upvalue_count(const struct cb_function *func)
 	} else {
 		return func->nupvalues;
 	}
+}
+
+int cb_value_id(struct cb_value value, intptr_t *id_out)
+{
+	union {
+		void *as_ptr;
+		intptr_t as_int;
+	} result;
+
+	switch (value.type) {
+	case CB_VALUE_NULL:
+	case CB_VALUE_INT:
+	case CB_VALUE_DOUBLE:
+	case CB_VALUE_BOOL:
+	case CB_VALUE_CHAR:
+	case CB_VALUE_INTERNED_STRING:
+	case CB_VALUE_STRING:
+		return 1;
+
+	case CB_VALUE_BYTES:
+		result.as_ptr = value.val.as_bytes;
+		break;
+
+	case CB_VALUE_ARRAY:
+		result.as_ptr = value.val.as_array;
+		break;
+
+	case CB_VALUE_FUNCTION:
+		result.as_ptr = value.val.as_function;
+		break;
+
+	case CB_VALUE_STRUCT_SPEC:
+		result.as_ptr = value.val.as_struct_spec;
+		break;
+
+	case CB_VALUE_STRUCT:
+		result.as_ptr = value.val.as_struct;
+		break;
+
+	case CB_VALUE_USERDATA:
+		result.as_ptr = value.val.as_userdata;
+		break;
+	}
+
+	*id_out = result.as_int;
+	return 0;
 }

value.h

@@ -133,6 +133,7 @@ ssize_t cb_value_from_fmt(struct cb_value *val, const char *fmt, ...);
 struct cb_bytes *cb_bytes_new(size_t size);
 struct cb_value cb_bytes_new_value(size_t size);
 size_t cb_function_upvalue_count(const struct cb_function *func);
+int cb_value_id(struct cb_value value, intptr_t *id_out);
 
 const char *cb_value_type_name(enum cb_value_type type);
 const char *cb_value_type_of(struct cb_value *val);

vim/syntax/cbcvm.vim

@@ -30,7 +30,7 @@ syn keyword cbcvmStructure struct nextgroup=cbcvmFunction skipwhite
 syn keyword cbcvmIntrinsics print println tostring typeof string_chars
             \ string_from_chars string_bytes string_concat ord chr truncate32
             \ tofloat read_file read_file_bytes argv __upvalues apply now toint
-            \ __gc_collect __dis arguments
+            \ __gc_collect __dis arguments id
 syn match cbcvmBraces "[{}\[\]]"
 syn match cbcvmParens "[()]"