hare: Update for hare 0.25.2

Allocations may return `!nomem`.

Author: einsiedlerspiel

README.md

@@ -572,7 +572,7 @@ groovy ./stepX_YYY.groovy
 
 ### Hare
 
-The hare implementation was tested against Hare 0.24.2.
+The hare implementation was tested against Hare 0.25.2.
 
 ```
 cd impls/hare

impls/hare/Dockerfile

@@ -1,4 +1,4 @@
-FROM ubuntu:25.04
+FROM debian:testing
 MAINTAINER Lou Woell <[email protected]>
 LABEL org.opencontainers.image.source=https://github.com/kanaka/mal
 LABEL org.opencontainers.image.description="mal test container: hare"

impls/hare/mal/core.ha

@@ -765,7 +765,7 @@ fn apply(args: []MalType) (MalType | error) = {
 	case 0 =>
 		yield [];
 	case =>
-		yield alloc([nil...], length);
+		yield alloc([nil...], length)!;
 	};
 	defer free(ls);
 
@@ -896,7 +896,7 @@ fn malkeyword(args: []MalType) (MalType | error) = {
 
 	match(args[0]){
 	case let s: string =>
-		let name = strings::lpad(s.data, ':', len(s.data) + 1);
+		let name = strings::lpad(s.data, ':', len(s.data) + 1)!;
 		defer free(name);
 		return make_symbol(name);
 	case let k: symbol =>

impls/hare/mal/env.ha

@@ -7,9 +7,9 @@ export fn env_init(outer: nullable * env = null) *env ={
 	const new = alloc(env {
 		outer = outer,
 		data = hm_init(),
-	});
+	})!;
 
-	append(gc.memory.envs, new);
+	append(gc.memory.envs, new)!;
 	return new;
 };
 

impls/hare/mal/gc.ha

@@ -70,7 +70,7 @@ fn finish_memory(memory: memory) void = {
 
 fn mark_hash(hm: hashmap) void = {
 
-	append(gc.marked.hashs, hm);
+	append(gc.marked.hashs, hm)!;
 	mark(hm.meta);
 
 	for(let v .. hm.data){
@@ -85,7 +85,7 @@ fn mark_env(envi: *env) void = {
 		if(e == envi) return void;
 	};
 
-	append(gc.marked.envs, envi);
+	append(gc.marked.envs, envi)!;
 	mark(envi.data);
 
 	match(envi.outer){
@@ -114,21 +114,21 @@ fn mark (val: MalType) void = {
 		for(let x .. gc.marked.vecs){
 			if(x == v) return void;
 		};
-		append(gc.marked.vecs, v);
+		append(gc.marked.vecs, v)!;
 		mark_col(v.data);
 		mark(v.meta);
 	case let l: list =>
 		for(let x .. gc.marked.lists){
 			if(x == l) return void;
 		};
-		append(gc.marked.lists, l);
+		append(gc.marked.lists, l)!;
 		mark_col(l.data);
 		mark(l.meta);
 	case  let f: function =>
 		for(let x .. gc.marked.funcs){
 			if(x == f) return void;
 		};
-		append(gc.marked.funcs, f);
+		append(gc.marked.funcs, f)!;
 		mark(f.meta);
 		mark(f.body);
 		mark_col(f.args);
@@ -137,14 +137,14 @@ fn mark (val: MalType) void = {
 		for(let x .. gc.marked.intrinsics){
 			if(x == i) return void;
 		};
-		append(gc.marked.intrinsics, i);
+		append(gc.marked.intrinsics, i)!;
 		mark(i.meta);
 	case let m: macro =>
 		let m = m:function;
 		for(let x .. gc.marked.funcs){
 			if(x == m) return void;
 		};
-		append(gc.marked.funcs, m);
+		append(gc.marked.funcs, m)!;
 		mark(m.meta);
 		mark(m.body);
 		mark_col(m.args);
@@ -164,13 +164,13 @@ fn mark (val: MalType) void = {
 		for(let x .. gc.marked.strings){
 			if(x == s) return void;
 		};
-		append(gc.marked.strings, s);
+		append(gc.marked.strings, s)!;
 		mark(s.meta);
 	case let a: atom =>
 		for(let x .. gc.marked.atoms){
 			if(x == a) return void;
 		};
-		append(gc.marked.atoms, a);
+		append(gc.marked.atoms, a)!;
 		mark(*a);
 	case => void;
 	};

impls/hare/mal/hashmap.ha

@@ -26,9 +26,9 @@ export fn hm_init(gcd: bool = true) hashmap = {
 	let new: hashmap = alloc(struct {
 		data: []hmap = [],
 		meta: MalType = nil,
-	});
+	})!;
 
-	if(gcd) append(gc.memory.hashs, new);
+	if(gcd) append(gc.memory.hashs, new)!;
 
 	return new;
 };
@@ -50,7 +50,7 @@ fn new(
 		child: [4](size | void) = [void...],
 	};
 
-	append(hm.data, new);
+	append(hm.data, new)!;
 
 	match(p.child) {
 	case void =>
@@ -180,7 +180,7 @@ fn hm_copy(hm: hashmap, filter: [](string | symbol) = []) hashmap = {
 
 	if(len(filter) == 0){
 		for(let e .. hm.data) {
-			append(new.data, e);
+			append(new.data, e)!;
 		};
 	} else {
 		for :map (let e .. hm.data) {

impls/hare/mal/printer.ha

@@ -43,7 +43,7 @@ fn print_string(
 	print_readable: bool
 ) void = {
 
-	let runes = strings::torunes(s.data);
+	let runes = strings::torunes(s.data)!;
 
 
 	if(!print_readable){

impls/hare/mal/reader.ha

@@ -153,7 +153,7 @@ fn read_collection(
 		case  hash_end =>
 			return unbalanced;
 		case let form: MalType =>
-			append(res, form);
+			append(res, form)!;
 			continue;
 		case io::EOF =>
 			return unexpected_eof;
@@ -180,7 +180,7 @@ fn read_string(s: str) (string | error) = {
 
 	let strbuf = memio::dynamic();
 	defer io::close(&strbuf)!;
-	let runes = strings::torunes(s);
+	let runes = strings::torunes(s)!;
 
 	for (let i: size = 0; i < len(runes); i += 1) {
 		let rn = switch (runes[i]) {

impls/hare/mal/types.ha

@@ -51,9 +51,9 @@ export fn make_intrinsic(
 	const new = alloc(struct {
 		eval: *fn([]MalType) (MalType | error) = func,
 		meta: MalType = nil,
-	});
+	})!;
 
-	append(gc.memory.intrinsics, new);
+	append(gc.memory.intrinsics, new)!;
 	return new;
 };
 
@@ -66,7 +66,7 @@ export fn make_func(
 
 	let arg_list: []MalType = [];
 	if(len(args) > 0) {
-		arg_list = alloc([nil...], len(args));
+		arg_list = alloc([nil...], len(args))!;
 		arg_list[0..] = args;
 	};
 
@@ -75,9 +75,9 @@ export fn make_func(
 		envi: *env= envi,
 		args: []MalType = arg_list,
 		body: MalType = body,
-		meta: MalType = nil });
+		meta: MalType = nil })!;
 
-	append(gc.memory.funcs, new);
+	append(gc.memory.funcs, new)!;
 	return new;
 };
 
@@ -91,14 +91,14 @@ export fn make_list(s: size, init: []MalType = []) list = {
 	const new: list = alloc(struct {
 		data: []MalType = [],
 		meta: MalType = nil,
-	});
+	})!;
 
 	if (s == 0) return new;
 
-	new.data = alloc([nil...], s);
+	new.data = alloc([nil...], s)!;
 	new.data[0..len(init)] = init;
 
-	append(gc.memory.lists, new);
+	append(gc.memory.lists, new)!;
 	return new;
 };
 
@@ -112,14 +112,14 @@ export fn make_vec(s: size, init: []MalType = []) vector = {
 	const new: vector = alloc(struct {
 		data: []MalType = [],
 		meta: MalType = nil,
-	});
+	})!;
 
 	if (s == 0) return new;
 
-	new.data = alloc([nil...], s);
+	new.data = alloc([nil...], s)!;
 	new.data[0..len(init)] = init;
 
-	append(gc.memory.vecs, new);
+	append(gc.memory.vecs, new)!;
 	return new;
 };
 
@@ -144,22 +144,22 @@ export fn make_symbol(name: str) symbol = {
 		return s;
 	};
 
-	const new = strings::dup(name): symbol;
+	const new = strings::dup(name)!: symbol;
 	hm_add(gc.memory.symbols: hashmap, new, new);
 
 	return new;
 };
 
 export fn make_string(s: str) string = {
 
-	const new_str = strings::dup(s);
+	const new_str = strings::dup(s)!;
 
 	const new = alloc(struct {
 		data: str = new_str,
 		meta: MalType = nil,
-	});
+	})!;
 
-	append(gc.memory.strings, new);
+	append(gc.memory.strings, new)!;
 	return new;
 };
 
@@ -170,8 +170,8 @@ fn free_string(s: string) void = {
 
 export fn make_atom(ref: MalType) atom = {
 
-	const new = alloc(ref);
-	append(gc.memory.atoms, new);
+	const new = alloc(ref)!;
+	append(gc.memory.atoms, new)!;
 	return new;
 };
 

impls/hare/step4_if_fn_do.ha

@@ -112,14 +112,14 @@ fn eval_list(ls: mal::list, env: *mal::env) (mal::MalType | mal::error) = {
 		let args: []mal::MalType = [];
 		defer free(args);
 		for(let arg .. ls.data[1..]){
-			append(args, eval(arg, env)?);
+			append(args, eval(arg, env)?)!;
 		};
 		return func.eval(args);
 	case let func: mal::function =>
 		let args: []mal::MalType = [];
 		defer free(args);
 		for(let arg .. ls.data[1..]){
-			append(args, eval(arg, env)?);
+			append(args, eval(arg, env)?)!;
 		};
 		let local = mal::env_init(func.envi);
 		mal::env_bind(local, func.args, args);