mt-lang 0.3.13 → 0.3.16

data/std/{cell.mt → box.mt}

@@ -3,42 +3,42 @@ import std.mem.heap as heap
 ## Explicit single-value heap storage.
 ##
 ## This is the intended escape hatch for shared mutable proc state.
-## Allocation stays visible at the call site via `cell.alloc(...)`.
-public struct Cell[T]:
+## Allocation stays visible at the call site via `box.alloc(...)`.
+public struct Box[T]:
     storage: own[T]?
 
 
-public function alloc[T](value: T) -> Cell[T]:
+public function alloc[T](value: T) -> Box[T]:
     let storage = heap.must_alloc[T](1)
     read(storage) = value
-    return Cell[T](storage = storage)
+    return Box[T](storage = storage)
 
 
-extending Cell[T]:
+extending Box[T]:
     public function as_ptr() -> ptr[T]:
         let storage = this.storage else:
-            fatal(c"cell.Cell.as_ptr released cell")
+            fatal(c"box.Box.as_ptr released box")
 
         return storage
 
 
     public function get() -> T:
         let storage = this.storage else:
-            fatal(c"cell.Cell.get released cell")
+            fatal(c"box.Box.get released box")
 
         return read(storage)
 
 
     public function set(value: T) -> void:
         let storage = this.storage else:
-            fatal(c"cell.Cell.set released cell")
+            fatal(c"box.Box.set released box")
 
         read(storage) = value
 
 
     public function replace(value: T) -> T:
         let storage = this.storage else:
-            fatal(c"cell.Cell.replace released cell")
+            fatal(c"box.Box.replace released box")
 
         let previous = read(storage)
         read(storage) = value

data/std/cookie.mt

@@ -94,7 +94,7 @@ function apply_attribute(cookie: ref[Cookie], attribute_text: str) -> void:
     match eq:
         Option.none:
             var normalized = ascii_lower(attribute_text)
-            defer normalized.release()
+            defer: normalized.release()
 
             if normalized.as_str().equal("secure"):
                 cookie.secure = true
@@ -106,7 +106,7 @@ function apply_attribute(cookie: ref[Cookie], attribute_text: str) -> void:
             let value_text = attribute_text.slice(e.value + 1, attribute_text.len - e.value - 1).trim_ascii_whitespace()
 
             var normalized_key = ascii_lower(key_text)
-            defer normalized_key.release()
+            defer: normalized_key.release()
 
             if normalized_key.as_str().equal("domain"):
                 cookie.domain = Option[string.String].some(value = string.String.from_str(value_text))

data/std/crypto.mt

@@ -23,7 +23,7 @@ public function sha256(data: span[ubyte]) -> bytes.Bytes:
 
 public function sha256_to_str(data: span[ubyte]) -> string.String:
     var digest = sha256(data)
-    defer digest.release()
+    defer: digest.release()
 
     var result = string.String.with_capacity(raw.SHA256_DIGEST_LENGTH * 2)
     var index: ptr_uint = 0

data/std/curl/runtime.mt

@@ -69,21 +69,21 @@ public function get_bytes(url: str) -> Result[bytes.Bytes, curl.Code]:
         return Result[bytes.Bytes, curl.Code].failure(error= curl.Code<-CURLE_URL_MALFORMAT_CODE)
 
     var scratch = arena.create(url.len + 1)
-    defer scratch.release()
+    defer: scratch.release()
 
     let url_cstr = scratch.to_cstr(url)
 
     let global_status = curl.global_init(curl.CURL_GLOBAL_NOTHING)
     if int<-global_status != CURLE_OK_CODE:
         return Result[bytes.Bytes, curl.Code].failure(error= global_status)
-    defer curl.global_cleanup()
+    defer: curl.global_cleanup()
 
     let handle = curl.easy_init() else:
         return Result[bytes.Bytes, curl.Code].failure(error= curl.Code<-CURLE_FAILED_INIT_CODE)
-    defer curl.easy_cleanup(handle)
+    defer: curl.easy_cleanup(handle)
 
     var body = vec.Vec[ubyte].create()
-    defer body.release()
+    defer: body.release()
 
     let write_function_status = easy_setopt_writefunction(handle, write_response_chunk)
     if int<-write_function_status != CURLE_OK_CODE:
@@ -199,7 +199,7 @@ function do_request(
     let global_status = curl.global_init(curl.CURL_GLOBAL_NOTHING)
     if int<-global_status != CURLE_OK_CODE:
         return Result[HttpResponse, HttpError].failure(error = http_error(global_status))
-    defer curl.global_cleanup()
+    defer: curl.global_cleanup()
 
     let handle = curl.easy_init() else:
         return Result[HttpResponse, HttpError].failure(
@@ -208,10 +208,10 @@ function do_request(
                 message = string.String.from_str("curl_easy_init failed")
             )
         )
-    defer curl.easy_cleanup(handle)
+    defer: curl.easy_cleanup(handle)
 
     var buffer = vec.Vec[ubyte].create()
-    defer buffer.release()
+    defer: buffer.release()
 
     let _wfn = easy_setopt_writefunction(handle, write_response_chunk)
     let _wdata = easy_setopt_writedata(handle, unsafe: ptr[void]<-ptr_of(buffer))
@@ -225,7 +225,7 @@ function do_request(
         )
 
     var scratch = arena.create(url.len + 1)
-    defer scratch.release()
+    defer: scratch.release()
 
     let url_cstr = scratch.to_cstr(url)
     let _url = easy_setopt_url(handle, url_cstr)
@@ -237,12 +237,12 @@ function do_request(
     if body.is_some():
         let body_content = body.unwrap()
         var body_scratch = arena.create(body_content.len + 1)
-        defer body_scratch.release()
+        defer: body_scratch.release()
         let _pf = easy_setopt_postfields(handle, body_scratch.to_cstr(body_content))
 
     if method.len > 0 and not method.starts_with("GET"):
         var method_scratch = arena.create(method.len + 1)
-        defer method_scratch.release()
+        defer: method_scratch.release()
         let _method = easy_setopt_customrequest(handle, method_scratch.to_cstr(method))
 
     if method.starts_with("HEAD"):

data/std/fs.linux.mt

@@ -89,7 +89,7 @@ function release_string_values(values: ref[vec.Vec[string.String]]) -> void:
 
 function path_kind(path: str) -> int:
     var storage = arena.create(path.len + 1)
-    defer storage.release()
+    defer: storage.release()
     return c.mt_fs_path_kind(storage.to_cstr(path))
 
 
@@ -170,7 +170,7 @@ public function is_directory(path: str) -> bool:
 
 public function read_text(path: str) -> Result[string.String, Error]:
     var storage = arena.create(path.len + 1)
-    defer storage.release()
+    defer: storage.release()
 
     var raw_text = zero[c.mt_fs_string]
     var raw_error = zero[c.mt_fs_error]
@@ -187,7 +187,7 @@ public function read_lines(path: str) -> Result[Entries, Error]:
             return Result[Entries, Error].failure(error= payload.error)
         Result.success as payload:
             var content = payload.value
-            defer content.release()
+            defer: content.release()
 
             var values = vec.Vec[string.String].create()
             let content_text = content.as_str()
@@ -216,7 +216,7 @@ public function read_lines(path: str) -> Result[Entries, Error]:
 
 public function read_bytes(path: str) -> Result[bytes.Bytes, Error]:
     var storage = arena.create(path.len + 1)
-    defer storage.release()
+    defer: storage.release()
 
     var raw_bytes = zero[c.mt_fs_string]
     var raw_error = zero[c.mt_fs_error]
@@ -229,7 +229,7 @@ public function read_bytes(path: str) -> Result[bytes.Bytes, Error]:
 
 public function metadata(path: str) -> Result[Metadata, Error]:
     var storage = arena.create(path.len + 1)
-    defer storage.release()
+    defer: storage.release()
 
     var raw_metadata = zero[c.mt_fs_metadata]
     var raw_error = zero[c.mt_fs_error]
@@ -248,7 +248,7 @@ public function metadata(path: str) -> Result[Metadata, Error]:
 
 public function write_text(path: str, content: str) -> Result[bool, Error]:
     var storage = arena.create(path.len + 1)
-    defer storage.release()
+    defer: storage.release()
 
     var raw_error = zero[c.mt_fs_error]
     let status_code = c.mt_fs_write_text(storage.to_cstr(path), content.data, content.len, raw_error)
@@ -260,7 +260,7 @@ public function write_text(path: str, content: str) -> Result[bool, Error]:
 
 public function write_bytes(path: str, content: span[ubyte]) -> Result[bool, Error]:
     var storage = arena.create(path.len + 1)
-    defer storage.release()
+    defer: storage.release()
 
     var raw_error = zero[c.mt_fs_error]
     let status_code = c.mt_fs_write_bytes(storage.to_cstr(path), content.data, content.len, raw_error)
@@ -272,7 +272,7 @@ public function write_bytes(path: str, content: span[ubyte]) -> Result[bool, Err
 
 public function set_permissions(path: str, mode: int) -> Result[bool, Error]:
     var storage = arena.create(path.len + 1)
-    defer storage.release()
+    defer: storage.release()
 
     var raw_error = zero[c.mt_fs_error]
     let status_code = c.mt_fs_set_permissions(storage.to_cstr(path), mode, raw_error)
@@ -284,7 +284,7 @@ public function set_permissions(path: str, mode: int) -> Result[bool, Error]:
 
 public function create_directories(path: str) -> Result[bool, Error]:
     var storage = arena.create(path.len + 1)
-    defer storage.release()
+    defer: storage.release()
 
     var raw_error = zero[c.mt_fs_error]
     let status_code = c.mt_fs_create_directories(storage.to_cstr(path), raw_error)
@@ -307,7 +307,7 @@ public function copy_entry(source_path: str, target_path: str) -> Result[bool, E
                 return Result[bool, Error].failure(error= payload.error)
             Result.success as payload:
                 var data = payload.value
-                defer data.release()
+                defer: data.release()
                 return write_bytes(target_path, data.as_span())
 
     if is_directory(source_path):
@@ -322,7 +322,7 @@ public function copy_entry(source_path: str, target_path: str) -> Result[bool, E
                 return Result[bool, Error].failure(error= payload.error)
             Result.success as payload:
                 var entries = payload.value
-                defer entries.release()
+                defer: entries.release()
 
                 var index: ptr_uint = 0
                 while index < entries.len():
@@ -334,9 +334,9 @@ public function copy_entry(source_path: str, target_path: str) -> Result[bool, E
                             ].failure(error= static_error("fs copy entry missing source entry"))
                         Option.some as entry_payload:
                             var child_source = path_ops.join(source_path, entry_payload.value)
-                            defer child_source.release()
+                            defer: child_source.release()
                             var child_target = path_ops.join(target_path, entry_payload.value)
-                            defer child_target.release()
+                            defer: child_target.release()
                             match copy_entry(child_source.as_str(), child_target.as_str()):
                                 Result.failure as child_payload:
                                     return Result[bool, Error].failure(error= child_payload.error)
@@ -357,7 +357,7 @@ public function copy_entry(source_path: str, target_path: str) -> Result[bool, E
 
 public function remove(path: str) -> Result[bool, Error]:
     var storage = arena.create(path.len + 1)
-    defer storage.release()
+    defer: storage.release()
 
     var raw_error = zero[c.mt_fs_error]
     let status_code = c.mt_fs_remove(storage.to_cstr(path), raw_error)
@@ -374,7 +374,7 @@ public function remove_tree(path: str) -> Result[bool, Error]:
                 return Result[bool, Error].failure(error= payload.error)
             Result.success as payload:
                 var entries = payload.value
-                defer entries.release()
+                defer: entries.release()
 
                 var index: ptr_uint = 0
                 while index < entries.len():
@@ -383,7 +383,7 @@ public function remove_tree(path: str) -> Result[bool, Error]:
                             return Result[bool, Error].failure(error= static_error("fs remove tree missing entry"))
                         Option.some as entry_payload:
                             var child_path = path_ops.join(path, entry_payload.value)
-                            defer child_path.release()
+                            defer: child_path.release()
                             match remove_tree(child_path.as_str()):
                                 Result.failure as child_payload:
                                     return Result[bool, Error].failure(error= child_payload.error)
@@ -401,9 +401,9 @@ public function remove_tree(path: str) -> Result[bool, Error]:
 
 public function rename(source_path: str, target_path: str) -> Result[bool, Error]:
     var source_storage = arena.create(source_path.len + 1)
-    defer source_storage.release()
+    defer: source_storage.release()
     var target_storage = arena.create(target_path.len + 1)
-    defer target_storage.release()
+    defer: target_storage.release()
 
     var raw_error = zero[c.mt_fs_error]
     let status_code = c.mt_fs_rename(
@@ -438,7 +438,7 @@ public function find_ancestor_containing(path: str, entry_name: str) -> Option[s
 
     while true:
         var candidate = path_ops.join(current.as_str(), entry_name)
-        defer candidate.release()
+        defer: candidate.release()
         let found = exists(candidate.as_str())
         if found:
             return Option[string.String].some(value= current)
@@ -486,7 +486,7 @@ public function temporary_directory() -> string.String:
 
 public function canonicalize(path: str) -> Result[string.String, Error]:
     var storage = arena.create(path.len + 1)
-    defer storage.release()
+    defer: storage.release()
 
     var raw_text = zero[c.mt_fs_string]
     var raw_error = zero[c.mt_fs_error]
@@ -505,7 +505,7 @@ public function create_temporary_directory(parent_dir: str, prefix: str) -> Resu
         ].failure(error= static_error("fs.create_temporary_directory requires a non-empty prefix"))
 
     var storage = arena.create(parent_dir.len + prefix.len + 2)
-    defer storage.release()
+    defer: storage.release()
 
     var raw_text = zero[c.mt_fs_string]
     var raw_error = zero[c.mt_fs_error]
@@ -529,7 +529,7 @@ public function create_temporary_directory(parent_dir: str, prefix: str) -> Resu
 
 public function create_temporary_directory_in_system_temp(prefix: str) -> Result[string.String, Error]:
     var root = temporary_directory()
-    defer root.release()
+    defer: root.release()
     return create_temporary_directory(root.as_str(), prefix)
 
 
@@ -541,7 +541,7 @@ public function create_temporary_file(parent_dir: str, prefix: str, suffix: str)
         ].failure(error= static_error("fs.create_temporary_file requires a non-empty prefix"))
 
     var storage = arena.create(parent_dir.len + prefix.len + suffix.len + 3)
-    defer storage.release()
+    defer: storage.release()
 
     var raw_text = zero[c.mt_fs_string]
     var raw_error = zero[c.mt_fs_error]
@@ -563,13 +563,13 @@ public function create_temporary_file(parent_dir: str, prefix: str, suffix: str)
 
 public function create_temporary_file_in_system_temp(prefix: str, suffix: str) -> Result[string.String, Error]:
     var root = temporary_directory()
-    defer root.release()
+    defer: root.release()
     return create_temporary_file(root.as_str(), prefix, suffix)
 
 
 public function list_entries(path: str) -> Result[Entries, Error]:
     var storage = arena.create(path.len + 1)
-    defer storage.release()
+    defer: storage.release()
 
     var raw_entries = zero[c.mt_fs_entries]
     var raw_error = zero[c.mt_fs_error]
@@ -644,7 +644,7 @@ function collect_files_recursive(path: str, output: ref[vec.Vec[string.String]])
             return Result[bool, Error].failure(error= payload.error)
         Result.success as payload:
             var entries = payload.value
-            defer entries.release()
+            defer: entries.release()
 
             var index: ptr_uint = 0
             while index < entries.len():

data/std/fs.windows.mt

@@ -89,7 +89,7 @@ function release_string_values(values: ref[vec.Vec[string.String]]) -> void:
 
 function path_kind(path: str) -> int:
     var storage = arena.create(path.len + 1)
-    defer storage.release()
+    defer: storage.release()
     return c.mt_fs_path_kind(storage.to_cstr(path))
 
 
@@ -170,7 +170,7 @@ public function is_directory(path: str) -> bool:
 
 public function read_text(path: str) -> Result[string.String, Error]:
     var storage = arena.create(path.len + 1)
-    defer storage.release()
+    defer: storage.release()
 
     var raw_text = zero[c.mt_fs_string]
     var raw_error = zero[c.mt_fs_error]
@@ -187,7 +187,7 @@ public function read_lines(path: str) -> Result[Entries, Error]:
             return Result[Entries, Error].failure(error= payload.error)
         Result.success as payload:
             var content = payload.value
-            defer content.release()
+            defer: content.release()
 
             var values = vec.Vec[string.String].create()
             let content_text = content.as_str()
@@ -216,7 +216,7 @@ public function read_lines(path: str) -> Result[Entries, Error]:
 
 public function read_bytes(path: str) -> Result[bytes.Bytes, Error]:
     var storage = arena.create(path.len + 1)
-    defer storage.release()
+    defer: storage.release()
 
     var raw_bytes = zero[c.mt_fs_string]
     var raw_error = zero[c.mt_fs_error]
@@ -229,7 +229,7 @@ public function read_bytes(path: str) -> Result[bytes.Bytes, Error]:
 
 public function metadata(path: str) -> Result[Metadata, Error]:
     var storage = arena.create(path.len + 1)
-    defer storage.release()
+    defer: storage.release()
 
     var raw_metadata = zero[c.mt_fs_metadata]
     var raw_error = zero[c.mt_fs_error]
@@ -248,7 +248,7 @@ public function metadata(path: str) -> Result[Metadata, Error]:
 
 public function write_text(path: str, content: str) -> Result[bool, Error]:
     var storage = arena.create(path.len + 1)
-    defer storage.release()
+    defer: storage.release()
 
     var raw_error = zero[c.mt_fs_error]
     let status_code = c.mt_fs_write_text(storage.to_cstr(path), content.data, content.len, raw_error)
@@ -260,7 +260,7 @@ public function write_text(path: str, content: str) -> Result[bool, Error]:
 
 public function write_bytes(path: str, content: span[ubyte]) -> Result[bool, Error]:
     var storage = arena.create(path.len + 1)
-    defer storage.release()
+    defer: storage.release()
 
     var raw_error = zero[c.mt_fs_error]
     let status_code = c.mt_fs_write_bytes(storage.to_cstr(path), content.data, content.len, raw_error)
@@ -272,7 +272,7 @@ public function write_bytes(path: str, content: span[ubyte]) -> Result[bool, Err
 
 public function set_permissions(path: str, mode: int) -> Result[bool, Error]:
     var storage = arena.create(path.len + 1)
-    defer storage.release()
+    defer: storage.release()
 
     var raw_error = zero[c.mt_fs_error]
     let status_code = c.mt_fs_set_permissions(storage.to_cstr(path), mode, raw_error)
@@ -284,7 +284,7 @@ public function set_permissions(path: str, mode: int) -> Result[bool, Error]:
 
 public function create_directories(path: str) -> Result[bool, Error]:
     var storage = arena.create(path.len + 1)
-    defer storage.release()
+    defer: storage.release()
 
     var raw_error = zero[c.mt_fs_error]
     let status_code = c.mt_fs_create_directories(storage.to_cstr(path), raw_error)
@@ -307,7 +307,7 @@ public function copy_entry(source_path: str, target_path: str) -> Result[bool, E
                 return Result[bool, Error].failure(error= payload.error)
             Result.success as payload:
                 var data = payload.value
-                defer data.release()
+                defer: data.release()
                 return write_bytes(target_path, data.as_span())
 
     if is_directory(source_path):
@@ -322,7 +322,7 @@ public function copy_entry(source_path: str, target_path: str) -> Result[bool, E
                 return Result[bool, Error].failure(error= payload.error)
             Result.success as payload:
                 var entries = payload.value
-                defer entries.release()
+                defer: entries.release()
 
                 var index: ptr_uint = 0
                 while index < entries.len():
@@ -359,7 +359,7 @@ public function copy_entry(source_path: str, target_path: str) -> Result[bool, E
 
 public function remove(path: str) -> Result[bool, Error]:
     var storage = arena.create(path.len + 1)
-    defer storage.release()
+    defer: storage.release()
 
     var raw_error = zero[c.mt_fs_error]
     let status_code = c.mt_fs_remove(storage.to_cstr(path), raw_error)
@@ -376,7 +376,7 @@ public function remove_tree(path: str) -> Result[bool, Error]:
                 return Result[bool, Error].failure(error= payload.error)
             Result.success as payload:
                 var entries = payload.value
-                defer entries.release()
+                defer: entries.release()
 
                 var index: ptr_uint = 0
                 while index < entries.len():
@@ -404,9 +404,9 @@ public function remove_tree(path: str) -> Result[bool, Error]:
 
 public function rename(source_path: str, target_path: str) -> Result[bool, Error]:
     var source_storage = arena.create(source_path.len + 1)
-    defer source_storage.release()
+    defer: source_storage.release()
     var target_storage = arena.create(target_path.len + 1)
-    defer target_storage.release()
+    defer: target_storage.release()
 
     var raw_error = zero[c.mt_fs_error]
     let status_code = c.mt_fs_rename(
@@ -501,7 +501,7 @@ public function temporary_directory() -> string.String:
 
 public function canonicalize(path: str) -> Result[string.String, Error]:
     var storage = arena.create(path.len + 1)
-    defer storage.release()
+    defer: storage.release()
 
     var raw_text = zero[c.mt_fs_string]
     var raw_error = zero[c.mt_fs_error]
@@ -520,7 +520,7 @@ public function create_temporary_directory(parent_dir: str, prefix: str) -> Resu
         ].failure(error= static_error("fs.create_temporary_directory requires a non-empty prefix"))
 
     var storage = arena.create(parent_dir.len + prefix.len + 2)
-    defer storage.release()
+    defer: storage.release()
 
     var raw_text = zero[c.mt_fs_string]
     var raw_error = zero[c.mt_fs_error]
@@ -544,7 +544,7 @@ public function create_temporary_directory(parent_dir: str, prefix: str) -> Resu
 
 public function create_temporary_directory_in_system_temp(prefix: str) -> Result[string.String, Error]:
     var root = temporary_directory()
-    defer root.release()
+    defer: root.release()
     return create_temporary_directory(root.as_str(), prefix)
 
 
@@ -556,7 +556,7 @@ public function create_temporary_file(parent_dir: str, prefix: str, suffix: str)
         ].failure(error= static_error("fs.create_temporary_file requires a non-empty prefix"))
 
     var storage = arena.create(parent_dir.len + prefix.len + suffix.len + 3)
-    defer storage.release()
+    defer: storage.release()
 
     var raw_text = zero[c.mt_fs_string]
     var raw_error = zero[c.mt_fs_error]
@@ -578,13 +578,13 @@ public function create_temporary_file(parent_dir: str, prefix: str, suffix: str)
 
 public function create_temporary_file_in_system_temp(prefix: str, suffix: str) -> Result[string.String, Error]:
     var root = temporary_directory()
-    defer root.release()
+    defer: root.release()
     return create_temporary_file(root.as_str(), prefix, suffix)
 
 
 public function list_entries(path: str) -> Result[Entries, Error]:
     var storage = arena.create(path.len + 1)
-    defer storage.release()
+    defer: storage.release()
 
     var raw_entries = zero[c.mt_fs_entries]
     var raw_error = zero[c.mt_fs_error]
@@ -659,7 +659,7 @@ function collect_files_recursive(path: str, output: ref[vec.Vec[string.String]])
             return Result[bool, Error].failure(error= payload.error)
         Result.success as payload:
             var entries = payload.value
-            defer entries.release()
+            defer: entries.release()
 
             var index: ptr_uint = 0
             while index < entries.len():

data/std/goap.mt

@@ -233,9 +233,9 @@ extending Planner[World, Goal, Context]:
 
     public editable function plan(context: ref[Context], initial_world: World, goal: Goal) -> PlanningResult[World]:
         var nodes = vec.Vec[SearchNode[World]].create()
-        defer nodes.release()
+        defer: nodes.release()
         var open_list = vec.Vec[ptr_uint].create()
-        defer open_list.release()
+        defer: open_list.release()
 
         nodes.push(
             SearchNode[World](