implement glue patterns

testsuite/glue-patterns/main.tri

···
+proc main!() {
+  let "hello" <> world = "hello world";
+  assert world == " world"
+
+  let hello <> "world" = "hello world";
+  assert hello == "hello "
+
+  let "hello" <> "world" = "helloworld";
+
+  for "goodbye" <> world = "hello world" { exit 1 }
+}

trilogy-llvm/core/core.c

···
     trilogy_value_clone_into(&contents, &s->contents);
     trilogy_tuple_init_new(rv, &atom, &contents);
 }
+
+bool unglue_start(trilogy_value* rv, trilogy_value* lhs, trilogy_value* rhs) {
+    trilogy_string_value* lhs_str = trilogy_string_assume(lhs);
+    trilogy_string_value* rhs_str = trilogy_string_assume(rhs);
+    return trilogy_string_unglue_start(rv, lhs_str, rhs_str);
+}
+
+bool unglue_end(trilogy_value* rv, trilogy_value* lhs, trilogy_value* rhs) {
+    trilogy_string_value* lhs_str = trilogy_string_assume(lhs);
+    trilogy_string_value* rhs_str = trilogy_string_assume(rhs);
+    return trilogy_string_unglue_end(rv, lhs_str, rhs_str);
+}

trilogy-llvm/core/core.h

···
 void append(trilogy_value* rv, trilogy_value* arr, trilogy_value* val);
 
 void glue(trilogy_value* rv, trilogy_value* lhs, trilogy_value* rhs);
+void unglue_start(trilogy_value* rv, trilogy_value* lhs, trilogy_value* rhs);
+void unglue_end(trilogy_value* rv, trilogy_value* lhs, trilogy_value* rhs);
 
 void cons(trilogy_value* rv, trilogy_value* lhs, trilogy_value* rhs);
 

trilogy-llvm/core/trilogy_string.c

···
     return trilogy_string_init_new(rt, len, ptr);
 }
 
+bool trilogy_string_unglue_start(
+    trilogy_value* rt, trilogy_string_value* lhs, trilogy_string_value* rhs
+) {
+    if (rhs->len < lhs->len) return false;
+    if (strncmp(lhs->contents, rhs->contents, lhs->len) != 0) return false;
+    trilogy_string_init_new(rt, rhs->len - lhs->len, rhs->contents + lhs->len);
+    return true;
+}
+
+bool trilogy_string_unglue_end(
+    trilogy_value* rt, trilogy_string_value* lhs, trilogy_string_value* rhs
+) {
+    if (lhs->len < rhs->len) return false;
+    size_t keep_len = lhs->len - rhs->len;
+    if (strncmp(lhs->contents + keep_len, rhs->contents, rhs->len) != 0)
+        return false;
+    trilogy_string_init_new(rt, keep_len, lhs->contents);
+    return true;
+}
+
 void trilogy_string_destroy(trilogy_string_value* val) { free(val->contents); }

trilogy-llvm/core/trilogy_string.h

···
 int trilogy_string_compare(
     trilogy_string_value* lhs, trilogy_string_value* rhs
 );
+
+bool trilogy_string_unglue_start(
+    trilogy_value* rt, trilogy_string_value* lhs, trilogy_string_value* rhs
+);
+bool trilogy_string_unglue_end(
+    trilogy_value* rt, trilogy_string_value* lhs, trilogy_string_value* rhs
+);

trilogy-llvm/src/bare.rs

···
             .into_pointer_value()
     }
 
+    pub(crate) fn unglue_start(
+        &self,
+        out: PointerValue<'ctx>,
+        lhs: PointerValue<'ctx>,
+        rhs: PointerValue<'ctx>,
+        name: &str,
+    ) -> IntValue<'ctx> {
+        let f = self.declare_bare(
+            "unglue_start",
+            self.context.bool_type().fn_type(
+                &[
+                    self.context.ptr_type(AddressSpace::default()).into(),
+                    self.context.ptr_type(AddressSpace::default()).into(),
+                    self.context.ptr_type(AddressSpace::default()).into(),
+                ],
+                false,
+            ),
+        );
+        self.builder
+            .build_call(f, &[out.into(), lhs.into(), rhs.into()], name)
+            .unwrap()
+            .try_as_basic_value()
+            .unwrap_left()
+            .into_int_value()
+    }
+
+    pub(crate) fn unglue_end(
+        &self,
+        out: PointerValue<'ctx>,
+        lhs: PointerValue<'ctx>,
+        rhs: PointerValue<'ctx>,
+        name: &str,
+    ) -> IntValue<'ctx> {
+        let f = self.declare_bare(
+            "unglue_end",
+            self.context.bool_type().fn_type(
+                &[
+                    self.context.ptr_type(AddressSpace::default()).into(),
+                    self.context.ptr_type(AddressSpace::default()).into(),
+                    self.context.ptr_type(AddressSpace::default()).into(),
+                ],
+                false,
+            ),
+        );
+        self.builder
+            .build_call(f, &[out.into(), lhs.into(), rhs.into()], name)
+            .unwrap()
+            .try_as_basic_value()
+            .unwrap_left()
+            .into_int_value()
+    }
+
     #[expect(
         clippy::too_many_arguments,
         reason = "this is a crazy C function sorry"

trilogy-llvm/src/pattern_match.rs

···
 use crate::codegen::{Codegen, Merger};
-use crate::types::{TAG_ARRAY, TAG_NUMBER, TAG_RECORD, TAG_SET, TAG_STRUCT, TAG_TUPLE};
+use crate::types::{TAG_ARRAY, TAG_NUMBER, TAG_RECORD, TAG_SET, TAG_STRING, TAG_STRUCT, TAG_TUPLE};
 use inkwell::IntPredicate;
 use inkwell::basic_block::BasicBlock;
 use inkwell::values::{IntValue, PointerValue};
···
         on_fail: PointerValue<'ctx>,
         bound_ids: &mut Vec<Id>,
     ) -> Option<()> {
+        // NOTE: app.argument         => lhs
+        //       application.argument => rhs
         match &application.function.value {
             Value::Builtin(builtin) => self.compile_match_apply_builtin(
                 *builtin,
···
                     }
                     Some(())
                 }
-                Value::Builtin(Builtin::Glue) => todo!(),
+                Value::Builtin(Builtin::Glue) => {
+                    let value_ref = self.use_temporary(value).unwrap();
+                    let tag = self.get_tag(value_ref, "");
+                    let is_string = self
+                        .builder
+                        .build_int_compare(
+                            IntPredicate::EQ,
+                            tag,
+                            self.tag_type().const_int(TAG_STRING, false),
+                            "",
+                        )
+                        .unwrap();
+                    self.pm_cont_if(is_string, on_fail);
+
+                    let output = self.allocate_value("unglued");
+                    self.bind_temporary(output);
+                    if matches!(app.argument.value, Value::String(..)) {
+                        // If left side is a string literal, compare to the start of the string
+                        let lhs = self
+                            .compile_expression(&app.argument, "glue_pattern_lhs")
+                            .unwrap();
+                        let is_ok = self.unglue_start(output, lhs, value_ref, "did_unglue");
+                        self.pm_cont_if(is_ok, on_fail);
+                        self.match_pattern(&application.argument, output, on_fail, bound_ids)?;
+                    } else if matches!(application.argument.value, Value::String(..)) {
+                        // If right side is a string literal, compare to the end of the string
+                        let rhs = self
+                            .compile_expression(&application.argument, "glue_pattern_rhs")
+                            .unwrap();
+                        let is_ok = self.unglue_end(output, value_ref, rhs, "did_unglue");
+                        self.pm_cont_if(is_ok, on_fail);
+                        self.match_pattern(&app.argument, output, on_fail, bound_ids)?;
+                    } else {
+                        panic!(
+                            "invalid glue pattern: one side should be a string literal, the other should be a pattern"
+                        );
+                    }
+                    if let Some(temp) = self.use_owned_temporary(output) {
+                        self.trilogy_value_destroy(temp);
+                    }
+                    Some(())
+                }
                 _ => panic!("only some operators are usable in pattern matching"),
             },
             _ => panic!("only builtins can be applied in pattern matching context"),