implement base set functionality

testsuite/set-comprehension/main.tri

···
+rule keys(1)
+rule keys(4)
+
+rule values(1, 1)
+rule values(1, 2)
+rule values(2, 2)
+rule values(2, 3)
+rule values(3, 3)
+rule values(3, 4)
+rule values(4, 4)
+rule values(4, 5)
+
+proc main!() {
+  let ins = [| value for keys(i) and values(i, value) |]
+  assert ins == [| 1, 2, 4, 5 |]
+}

testsuite/set-empty/main.tri

···
+proc main!() {
+  let set = [||]
+  assert typeof set === 'set
+}

testsuite/set-init/main.tri

···
+proc main!() {
+  let set = [|'a, 'b, 1, 2|]
+  assert typeof set === 'set
+  # assert is 'a in set
+}

trilogy-llvm/core/trilogy_record.c

···
         record->len = 0;
         record->contents = calloc_safe(new_cap, sizeof(trilogy_tuple_value));
         for (size_t i = 0; i < old_cap; ++i) {
-            trilogy_record_insert(
-                record, &old_contents[i].fst, &old_contents[i].snd
-            );
+            if (old_contents[i].fst.tag != TAG_UNDEFINED) {
+                trilogy_record_insert(
+                    record, &old_contents[i].fst, &old_contents[i].snd
+                );
+            }
         }
         free(old_contents);
     }
···
         record->contents[empty].fst = *key;
         record->contents[empty].snd = *value;
         record->len++;
+        *key = trilogy_undefined;
+        *value = trilogy_undefined;
     } else {
         // If it is found, delete the new key, destroy the old value, and then
         // insert the new value.
         trilogy_value_destroy(key);
         trilogy_value_destroy(&record->contents[found].snd);
         record->contents[found].snd = *value;
+        *value = trilogy_undefined;
     }
 }
 

trilogy-llvm/core/trilogy_set.c

···
 #include <stdint.h>
 #include <stdlib.h>
 
+// This is hash map with basic open-addressed linear probing, all values are
+// `unit` as it is a set.
+
 trilogy_set_value* trilogy_set_init(trilogy_value* tv, trilogy_set_value* set) {
     assert(tv->tag == TAG_UNDEFINED);
     tv->tag = TAG_SET;
···
     return trilogy_set_init(tv, set);
 }
 
+trilogy_set_value* trilogy_set_init_cap(trilogy_value* tv, size_t cap) {
+    trilogy_set_value* set = malloc_safe(sizeof(trilogy_set_value));
+    set->rc = 1;
+    set->len = 0;
+    set->cap = cap;
+    set->contents =
+        cap == 0 ? NULL : calloc_safe(cap, sizeof(trilogy_tuple_value));
+    return trilogy_set_init(tv, set);
+}
+
 trilogy_set_value*
 trilogy_set_clone_into(trilogy_value* tv, trilogy_set_value* set) {
     assert(set->rc != 0);
···
     return trilogy_set_init(tv, set);
 }
 
+static size_t trilogy_set_find(
+    trilogy_set_value* set, trilogy_value* key, size_t* insert_to
+) {
+    if (insert_to) *insert_to = set->cap;
+    size_t h = ((size_t)trilogy_value_hash(key)) % set->cap;
+    for (;; h = h == set->cap - 1 ? 0 : h + 1) {
+        trilogy_tuple_value* entry = &set->contents[h];
+        if (entry->fst.tag == TAG_UNDEFINED &&
+            entry->snd.tag == TAG_UNDEFINED) {
+            // Returning cap to indicate not found. Otherwise, return value is
+            // in range. Insert here only if we haven't already found a better
+            // spot.
+            if (insert_to && *insert_to == set->cap) *insert_to = h;
+            return set->cap;
+        }
+        if (entry->fst.tag == TAG_UNDEFINED) {
+            // Key unset, but value not undefined: entry was deleted. Skip it as
+            // if it were filled, since it might have been filled at time of
+            // insert. We can insert here if the value is not found later, and
+            // we haven't already found a better spot.
+            if (insert_to && *insert_to == set->cap) *insert_to = h;
+            continue;
+        }
+        if (trilogy_value_structural_eq(key, &entry->fst)) {
+            if (insert_to) *insert_to = h;
+            return h;
+        }
+    }
+}
+
+static void trilogy_set_maintainance(trilogy_set_value* set) {
+    // Maximum load factor = 75%
+    if (set->len >= set->cap - set->cap / 4) {
+        size_t old_cap = set->cap;
+        trilogy_tuple_value* old_contents = set->contents;
+        size_t new_cap = old_cap <= SIZE_MAX / 2 ? old_cap * 2 : SIZE_MAX;
+        if (new_cap == 0) new_cap = 8;
+        set->cap = new_cap;
+        set->len = 0;
+        set->contents = calloc_safe(new_cap, sizeof(trilogy_tuple_value));
+        for (size_t i = 0; i < old_cap; ++i) {
+            if (old_contents[i].fst.tag != TAG_UNDEFINED) {
+                trilogy_set_insert(set, &old_contents[i].fst);
+            }
+        }
+        free(old_contents);
+    }
+}
+
+void trilogy_set_insert(trilogy_set_value* set, trilogy_value* value) {
+    trilogy_set_maintainance(set);
+    size_t empty = set->cap;
+    size_t found = trilogy_set_find(set, value, &empty);
+    if (found == set->cap) {
+        // If it's not found, insert the new value and mark it with a `unit`.
+        set->contents[empty].fst = *value;
+        set->contents[empty].snd = trilogy_unit;
+        set->len++;
+        *value = trilogy_undefined;
+    } else {
+        // If it is found, delete the new value as if consumed, but we don't
+        // have to change anything about the set's contents.
+        trilogy_value_destroy(value);
+    }
+}
+
+void trilogy_set_append(trilogy_set_value* set, trilogy_value* tv) {
+    trilogy_set_value* tail = trilogy_set_untag(tv);
+    uint64_t tail_len = tail->len;
+    if (tail->rc == 1) {
+        for (uint64_t i = 0; i < tail->cap; ++i) {
+            trilogy_tuple_value* entry = &tail->contents[i];
+            if (entry->fst.tag != TAG_UNDEFINED) {
+                trilogy_set_insert(set, &entry->fst);
+            }
+        }
+    } else {
+        for (uint64_t i = 0; i < tail_len; ++i) {
+            trilogy_value clone = trilogy_undefined;
+            trilogy_value_clone_into(&clone, &tail->contents[i]);
+            trilogy_set_insert(set, &clone);
+        }
+    }
+    trilogy_value_destroy(tv);
+}
+
+void trilogy_set_delete(trilogy_set_value* set, trilogy_value* value) {
+    size_t found = trilogy_set_find(set, value, NULL);
+    if (found != set->cap) {
+        // Only if it's found does it need to be destroyed. Remove the value (to
+        // mark as empty), and destroy the it. The marker `unit` does not need
+        // to be adjusted.
+        trilogy_value_destroy(&set->contents[found].fst);
+        set->len--;
+    }
+}
+
+bool trilogy_set_contains(trilogy_set_value* set, trilogy_value* value) {
+    return trilogy_set_find(set, value, NULL) != set->cap;
+}
+
 trilogy_set_value* trilogy_set_untag(trilogy_value* val) {
     if (val->tag != TAG_SET) rte("set", val->tag);
     return trilogy_set_assume(val);
···
         free(set);
     }
 }
+
+bool trilogy_set_structural_eq(trilogy_set_value* lhs, trilogy_set_value* rhs) {
+    if (lhs->len != rhs->len) return false;
+    for (uint64_t i = 0; i < lhs->cap; ++i) {
+        trilogy_tuple_value* entry = &lhs->contents[i];
+        if (entry->fst.tag == TAG_UNDEFINED) continue;
+        size_t rhs_index = trilogy_set_find(rhs, &entry->fst, NULL);
+        if (rhs_index == rhs->cap) return false;
+    }
+    return true;
+}

trilogy-llvm/core/trilogy_set.h

···
 
 trilogy_set_value* trilogy_set_init(trilogy_value* tv, trilogy_set_value* set);
 trilogy_set_value* trilogy_set_init_empty(trilogy_value* tv);
+trilogy_set_value* trilogy_set_init_cap(trilogy_value* tv, size_t cap);
 trilogy_set_value*
 trilogy_set_clone_into(trilogy_value* tv, trilogy_set_value* arr);
+
+void trilogy_set_insert(trilogy_set_value* set, trilogy_value* value);
+void trilogy_set_append(trilogy_set_value* set, trilogy_value* value);
+void trilogy_set_delete(trilogy_set_value* set, trilogy_value* value);
+bool trilogy_set_contains(trilogy_set_value* set, trilogy_value* key);
+
+bool trilogy_set_structural_eq(trilogy_set_value* lhs, trilogy_set_value* rhs);
 
 trilogy_set_value* trilogy_set_untag(trilogy_value* val);
 trilogy_set_value* trilogy_set_assume(trilogy_value* val);

trilogy-llvm/core/trilogy_value.c

···
         }
         return true;
     }
-    case TAG_RECORD:
+    case TAG_RECORD: {
         trilogy_record_value* lhs_rec = trilogy_record_assume(lhs);
         trilogy_record_value* rhs_rec = trilogy_record_assume(rhs);
         return trilogy_record_structural_eq(lhs_rec, rhs_rec);
-        break;
-    case TAG_SET:
+    }
+    case TAG_SET: {
+        trilogy_set_value* lhs_set = trilogy_set_assume(lhs);
+        trilogy_set_value* rhs_set = trilogy_set_assume(rhs);
+        return trilogy_set_structural_eq(lhs_set, rhs_set);
+    }
     default:
-        internal_panic("unimplemented\n");
+        internal_panic("unreachable\n");
         return false;
     }
 }

trilogy-llvm/core/types.h

···
      */
     size_t cap;
     /**
-     * An array of length `cap` containing the values of this set.
+     * An array of length `cap` containing the values of this set. This is a
+     * tuple, same as record as a set is just a record with `unit` for every
+     * value.
      */
-    trilogy_value* contents;
+    trilogy_tuple_value* contents;
 } trilogy_set_value;
 
 typedef struct trilogy_record_value {

trilogy-llvm/src/bare.rs

···
             .unwrap();
     }
 
+    pub(crate) fn trilogy_set_init_cap(
+        &self,
+        value: PointerValue<'ctx>,
+        cap: usize,
+        name: &str,
+    ) -> PointerValue<'ctx> {
+        let f = self.declare_bare(
+            "trilogy_set_init_cap",
+            self.context.ptr_type(AddressSpace::default()).fn_type(
+                &[
+                    self.context.ptr_type(AddressSpace::default()).into(),
+                    self.usize_type().into(),
+                ],
+                false,
+            ),
+        );
+        self.builder
+            .build_call(
+                f,
+                &[
+                    value.into(),
+                    self.usize_type().const_int(cap as u64, false).into(),
+                ],
+                name,
+            )
+            .unwrap()
+            .try_as_basic_value()
+            .unwrap_left()
+            .into_pointer_value()
+    }
+
+    pub(crate) fn trilogy_set_assume(
+        &self,
+        t: PointerValue<'ctx>,
+        name: &str,
+    ) -> PointerValue<'ctx> {
+        let f = self.declare_bare(
+            "trilogy_set_assume",
+            self.context.ptr_type(AddressSpace::default()).fn_type(
+                &[self.context.ptr_type(AddressSpace::default()).into()],
+                false,
+            ),
+        );
+        self.builder
+            .build_call(f, &[t.into()], name)
+            .unwrap()
+            .try_as_basic_value()
+            .unwrap_left()
+            .into_pointer_value()
+    }
+
+    pub(crate) fn trilogy_set_insert(&self, set: PointerValue<'ctx>, value: PointerValue<'ctx>) {
+        let f = self.declare_bare(
+            "trilogy_set_insert",
+            self.context.void_type().fn_type(
+                &[
+                    self.context.ptr_type(AddressSpace::default()).into(),
+                    self.context.ptr_type(AddressSpace::default()).into(),
+                ],
+                false,
+            ),
+        );
+        self.builder
+            .build_call(f, &[set.into(), value.into()], "")
+            .unwrap();
+    }
+
+    pub(crate) fn trilogy_set_append(&self, set: PointerValue<'ctx>, value: PointerValue<'ctx>) {
+        let f = self.declare_bare(
+            "trilogy_set_append",
+            self.context.void_type().fn_type(
+                &[
+                    self.context.ptr_type(AddressSpace::default()).into(),
+                    self.context.ptr_type(AddressSpace::default()).into(),
+                ],
+                false,
+            ),
+        );
+        self.builder
+            .build_call(f, &[set.into(), value.into()], "")
+            .unwrap();
+    }
+
     pub(crate) fn trilogy_record_init_cap(
         &self,
         value: PointerValue<'ctx>,

trilogy-llvm/src/expression/mod.rs

···
                 Some(val)
             }
             Value::Array(arr) => self.compile_array(arr, name),
-            Value::Set(..) => todo!(),
+            Value::Set(set) => self.compile_set(set, name),
             Value::Record(record) => self.compile_record(record, name),
             Value::ArrayComprehension(comp) => self.compile_array_comprehension(comp, name),
-            Value::SetComprehension(..) => todo!(),
+            Value::SetComprehension(comp) => self.compile_set_comprehension(comp, name),
             Value::RecordComprehension(comp) => self.compile_record_comprehension(comp, name),
             Value::Sequence(seq) => {
                 self.di.push_block_scope(expression.span);
···
         Some(output_clone)
     }
 
+    fn compile_set_comprehension(
+        &self,
+        expr: &ir::Iterator,
+        name: &str,
+    ) -> Option<PointerValue<'ctx>> {
+        let output = self.allocate_value("acc");
+        self.trilogy_set_init_cap(output, 8, "");
+        self.bind_temporary(output);
+
+        let done_function = self.add_continuation("done");
+        let (done_continuation, done_continuation_point) =
+            self.capture_current_continuation_as_break(done_function, "for_break");
+        let next_iteration = self.compile_iterator(&expr.query, done_continuation)?;
+        self.bind_temporary(next_iteration);
+        if let Some(value) = self.compile_expression(&expr.value, "element") {
+            let set_val = self.use_temporary(output).unwrap();
+            let set = self.trilogy_set_assume(set_val, "");
+            self.trilogy_set_insert(set, value);
+            let next_iteration = self.use_temporary(next_iteration).unwrap();
+            self.void_call_continuation(next_iteration);
+        }
+
+        self.become_continuation_point(done_continuation_point);
+        self.begin_next_function(done_function);
+        let output_clone = self.allocate_value(name);
+        self.trilogy_value_clone_into(output_clone, self.use_temporary(output).unwrap());
+        Some(output_clone)
+    }
+
     fn compile_record_comprehension(
         &self,
         expr: &ir::Iterator,
···
                 self.trilogy_array_append(array_value, temporary);
             } else {
                 self.trilogy_array_push(array_value, temporary);
+            }
+        }
+        let target = self.use_temporary(target).unwrap();
+        Some(target)
+    }
+
+    fn compile_set(&self, pack: &ir::Pack, name: &str) -> Option<PointerValue<'ctx>> {
+        let target = self.allocate_value(name);
+        self.bind_temporary(target);
+        self.trilogy_set_init_cap(target, pack.values.len(), "set");
+        for element in &pack.values {
+            let temporary = self.compile_expression(&element.expression, "set.el")?;
+            let target = self.use_temporary(target).unwrap();
+            let set_value = self.trilogy_set_assume(target, "");
+            if element.is_spread {
+                self.trilogy_set_append(set_value, temporary);
+            } else {
+                self.trilogy_set_insert(set_value, temporary);
             }
         }
         let target = self.use_temporary(target).unwrap();

trilogy-llvm/src/pattern_match.rs

···
             }
             Value::Wildcard => { /* always passes with no action */ }
             Value::Array(array) => self.match_array(array, value, on_fail, bound_ids)?,
-            Value::Set(..) => {}
-            Value::Record(..) => {}
+            Value::Set(..) => todo!(),
+            Value::Record(..) => todo!(),
             // Not patterns:
             Value::Pack(..) => unreachable!(),
             Value::Sequence(..) => unreachable!(),