From 1d719c6a4298e75209703b592d96b4128a199a58 Mon Sep 17 00:00:00 2001
From: hl-valdemar <valdemar.lorenzen@icloud.com>
Date: Wed, 22 Jul 2026 00:49:46 +0200
Subject: [PATCH] allow freeing immutable allocations

---
 std/mem/mem.hon | 59 +++++++++++++++++--------------------------------
 1 file changed, 20 insertions(+), 39 deletions(-)

diff --git a/std/mem/mem.hon b/std/mem/mem.hon
index b1d2d03..a726322 100644
--- a/std/mem/mem.hon
+++ b/std/mem/mem.hon
@@ -28,29 +28,20 @@ raw_free func(allocator Allocator, memory ?*mut u8, size usize, alignment usize)
 }
 
 eql func($T type, left, right []T) bool {
-	if left.len != right.len {
-		return false
-	}
-
-	i usize = 0
-	while i < left.len : i += 1 {
-		if left[i] != right[i] {
-			return false
-		}
+	if (left.len != right.len) return false
+	for (0..left.len) |i| if (left[i] != right[i]) {
+        return false
 	}
 	return true
 }
 
 # allocate memory for a slice of type `T` with `count` elements.
 alloc func($T type, allocator Allocator, count usize) []mut T ! AllocError {
-	if count == 0 {
-		return empty_slice(T, 0)
-	}
+	if (count == 0) return empty_slice(T, 0)
 
 	element_size usize :: sizeof!(T)
-	if element_size == 0 {
-		return empty_slice(T, count)
-	}
+	if (element_size == 0) return empty_slice(T, count)
+
 	if count > divtrunc!(maxval!(usize), element_size) {
 		return .out_of_memory
 	}
@@ -107,10 +98,14 @@ realloc func($T type, allocator Allocator, memory []mut T, new_count usize) []mu
 
 # free memory allocated for a slice of type `T`.
 # note: memory must be freed with the same allocator that was used to allocate it.
-free func($T type, allocator Allocator, memory []mut T) void {
-	if memory.len != 0 and sizeof!(T) != 0 {
-		raw_free(allocator, ptrcast!(u8, memory.ptr), memory.len * sizeof!(T), alignof!(T))
-	}
+free func($T type, allocator Allocator, memory []T) void {
+	if (memory.len == 0 or sizeof!(T) == 0) return
+	raw_free(allocator, ptrcast!(
+		u8,
+		constcast!(memory).ptr),
+		memory.len * sizeof!(T),
+		alignof!(T),
+	)
 }
 
 # get an empty slice of type `T` with `count` elements.
@@ -129,26 +124,18 @@ hide empty_storage [1]mut u64 = [0]
 hide malloc_alignment usize :: 16 # ponytail: aarch64-macos libc malloc alignment assumption.
 
 hide power_of_two func(value usize) bool {
-	if value == 0 {
-		return false
-	}
-
+	if (value == 0) return false
 	current usize = value
 	while current > 1 {
 		half usize = divtrunc!(current, 2)
-		if half * 2 != current {
-			return false
-		}
+		if (half * 2 != current) return false
 		current = half
 	}
-
 	return true
 }
 
 hide c_alloc func(_ ?@mut anyopaque, size usize, alignment usize) ?*mut u8 {
-	if power_of_two(alignment) == false {
-		return null
-	}
+	if (power_of_two(alignment) == false) return null
 
 	if alignment <= malloc_alignment {
 		return ptrcast!(u8, c.malloc(c_ulong(size)))
@@ -156,17 +143,13 @@ hide c_alloc func(_ ?@mut anyopaque, size usize, alignment usize) ?*mut u8 {
 
 	memory [1]mut ?*mut anyopaque = [null]
 	status c_int = c.posix_memalign((&memory).ptr, c_ulong(alignment), c_ulong(size))
-	if status != 0 {
-		return null
-	}
+	if (status != 0) return null
 
 	return ptrcast!(u8, memory[0])
 }
 
 hide c_realloc func(_ ?@mut anyopaque, memory ?*mut u8, old_size usize, new_size usize, alignment usize) ?*mut u8 {
-	if power_of_two(alignment) == false {
-		return null
-	}
+	if (power_of_two(alignment) == false) return null
 
 	if new_size == 0 {
 		c.free(memory)
@@ -181,9 +164,7 @@ hide c_realloc func(_ ?@mut anyopaque, memory ?*mut u8, old_size usize, new_size
 		new_memory ?*mut u8 = c_alloc(null, new_size, alignment)
 		if new_memory |new_bytes| {
 			copy_size usize = old_size
-			if new_size < copy_size {
-				copy_size = new_size
-			}
+			if (new_size < copy_size) copy_size = new_size
 			memcopy!(new_bytes[..copy_size], old_memory[..copy_size])
 			c.free(old_memory)
 		}