mt-lang 0.3.14 → 0.3.17

data/std/jobs.mt

@@ -53,7 +53,7 @@ function noop_completion(arg: ptr[void]) -> void:
 function stop_pool_state(state: ptr[PoolState]) -> void:
     let mutex = unsafe: read(state).mutex
     mutex.lock()
-    defer mutex.unlock()
+    defer: mutex.unlock()
     unsafe: read(state).stopping = true
     let condition = unsafe: read(state).condition
     condition.broadcast()
@@ -229,7 +229,7 @@ extending Pool:
 
         let mutex = unsafe: read(state).mutex
         mutex.lock()
-        defer mutex.unlock()
+        defer: mutex.unlock()
 
         if unsafe: read(state).stopping:
             return Result[bool, Error].failure(error = jobs_error(-1, "jobs pool is stopping"))
@@ -270,7 +270,7 @@ extending Pool:
 
         let mutex = unsafe: read(state).mutex
         mutex.lock()
-        defer mutex.unlock()
+        defer: mutex.unlock()
         return unsafe: read(state).queued_jobs
 
 
@@ -280,7 +280,7 @@ extending Pool:
 
         let mutex = unsafe: read(state).mutex
         mutex.lock()
-        defer mutex.unlock()
+        defer: mutex.unlock()
         return unsafe: read(state).queued_jobs + read(state).running_jobs
 
 

data/std/json.mt

@@ -375,12 +375,12 @@ function build_raw_value(value: Value) -> Result[ptr[cjson.JSON], Error]:
 
 function render_with_mode(value: Value, pretty: bool) -> Result[string.String, Error]:
     let raw_value = build_raw_value(value)?
-    defer cjson.delete(raw_value)
+    defer: cjson.delete(raw_value)
 
     if pretty:
         let rendered_ptr = cjson.print(raw_value) else:
             return Result[string.String, Error].failure(error = error_message("json print failed"))
-        defer raw.cJSON_free(unsafe: rendered_ptr)
+        defer: raw.cJSON_free(unsafe: rendered_ptr)
         return Result[
             string.String,
             Error
@@ -388,13 +388,13 @@ function render_with_mode(value: Value, pretty: bool) -> Result[string.String, E
 
     let rendered_ptr = cjson.print_unformatted(raw_value) else:
         return Result[string.String, Error].failure(error = error_message("json print failed"))
-    defer raw.cJSON_free(unsafe: rendered_ptr)
+    defer: raw.cJSON_free(unsafe: rendered_ptr)
     return Result[string.String, Error].success(value = string.String.from_str(text.chars_as_str(rendered_ptr)))
 
 
 public function parse(text_value: str) -> Result[Value, Error]:
     var storage = arena.create(text_value.len + 1)
-    defer storage.release()
+    defer: storage.release()
 
     let c_text = storage.to_cstr(text_value)
     let raw_value = raw.cJSON_Parse(c_text) else:
@@ -406,7 +406,7 @@ public function parse(text_value: str) -> Result[Value, Error]:
             return Result[Value, Error].failure(error = error_message("json parse failed"))
         return Result[Value, Error].failure(error = Error(message = string.String.from_str(error_text)))
 
-    defer raw.cJSON_Delete(raw_value)
+    defer: raw.cJSON_Delete(raw_value)
     return convert_raw_value(unsafe: ptr[cjson.JSON]?<-raw_value)
 
 

data/std/log.mt

@@ -34,7 +34,7 @@ public function log(level: Level, message: str) -> void:
     if int<-level < int<-global_level:
         return
     var output = string.String.create()
-    defer output.release()
+    defer: output.release()
     output.append("[")
     output.append(level_label(level))
     output.append("] ")

data/std/mem/tracking.mt

@@ -47,7 +47,7 @@ extending Tracker:
             return
 
         var sb = string.String.create()
-        defer sb.release()
+        defer: sb.release()
 
         sb.append("[tracking] ")
         sb.append(fmt.format(f"#{this.entries.len()} leaked allocation(s):\n").as_str())

data/std/net/channel.mt

@@ -154,7 +154,7 @@ function build_packet(
     content: span[ubyte]
 ) -> bytes.Bytes:
     var buffer = vec.Vec[ubyte].with_capacity(header_bytes + content.len)
-    defer buffer.release()
+    defer: buffer.release()
 
     buffer.append_array(encode_uint(header_magic))
     buffer.append_array(encode_uint(sequence))
@@ -275,7 +275,7 @@ async function send_connected_packet(
         ack_bits = unsafe: read(protocol).received_mask
 
     var framed = build_packet(sequence, ack, ack_bits, packet_flags, content)
-    defer framed.release()
+    defer: framed.release()
 
     (await socket.send(framed.as_span()))?
     return Result[bool, net.Error].success(value = true)
@@ -297,7 +297,7 @@ async function send_packet_to(
         ack_bits = unsafe: read(protocol).received_mask
 
     var framed = build_packet(sequence, ack, ack_bits, packet_flags, content)
-    defer framed.release()
+    defer: framed.release()
 
     (await socket.send_to(framed.as_span(), destination))?
     return Result[bool, net.Error].success(value = true)
@@ -475,7 +475,7 @@ extending Channel:
 
     public async editable function recv() -> Result[Option[Message], net.Error]:
         var packet = (await this.socket.recv(this.config.max_payload_bytes + header_bytes))?
-        defer packet.release()
+        defer: packet.release()
 
         let header = decode_header(packet)?
         let protocol = unsafe: ptr_of(this.protocol)

data/std/net/clock.mt

@@ -137,7 +137,7 @@ public async function measure_offset(
 ) -> Result[ClockSync, Error]:
     let t1 = libuv.hrtime()
     var request = build_request(t1)
-    defer request.release()
+    defer: request.release()
     (await socket.send_to(request.as_span(), peer)).map_error(proc(_: net.Error) -> Error:
         clock_error(err_send_failed, "failed to send sync request")
     )?
@@ -154,8 +154,8 @@ public async function measure_offset(
                     )
                 Result.success as dp:
                     var datagram = dp.value
-                    defer datagram.data.release()
-                    defer datagram.source.release()
+                    defer: datagram.data.release()
+                    defer: datagram.source.release()
                     if is_clock_packet(datagram.data.as_span()):
                         let parse_result = parse_response(datagram.data.as_span())
                         match parse_result:
@@ -182,15 +182,15 @@ public async function respond_to_sync(
             match recv_result:
                 Result.success as dp:
                     var datagram = dp.value
-                    defer datagram.data.release()
-                    defer datagram.source.release()
+                    defer: datagram.data.release()
+                    defer: datagram.source.release()
                     if is_clock_packet(datagram.data.as_span()):
                         let parse_result = parse_request(datagram.data.as_span())
                         match parse_result:
                             Result.success as tp:
                                 let t2 = libuv.hrtime()
                                 var resp = build_response(tp.value, t2)
-                                defer resp.release()
+                                defer: resp.release()
                                 let _ = await socket.send_to(resp.as_span(), datagram.source)
                             Result.failure:
                                 pass

data/std/net/discovery.mt

@@ -130,17 +130,17 @@ public async function announce(
             return
         Result.success as addr_p:
             var announce_addr = addr_p.value
-            defer announce_addr.release()
+            defer: announce_addr.release()
 
             match net.udp_bind(announce_addr):
                 Result.failure:
                     return
                 Result.success as bp:
                     var socket = bp.value
-                    defer socket.release()
+                    defer: socket.release()
 
                     var response = build_response(game_port, ubyte<-0, max_players, game_name)
-                    defer response.release()
+                    defer: response.release()
 
                     while true:
                         let recv_task = socket.recv_from(1500)
@@ -177,7 +177,7 @@ public async function discover_on(
             )
         Result.success as la:
             var local_addr = la.value
-            defer local_addr.release()
+            defer: local_addr.release()
 
             match net.udp_bind_on(runtime, local_addr):
                 Result.failure:
@@ -186,7 +186,7 @@ public async function discover_on(
                     )
                 Result.success as bp:
                     var socket = bp.value
-                    defer socket.release()
+                    defer: socket.release()
 
                     match socket.set_broadcast(true):
                         0:
@@ -207,10 +207,10 @@ public async function discover_on(
                             )
                         Result.success as broad_addr:
                             var broadcast_addr = broad_addr.value
-                            defer broadcast_addr.release()
+                            defer: broadcast_addr.release()
 
                             var probe = build_probe()
-                            defer probe.release()
+                            defer: probe.release()
 
                             var results = vec.Vec[ServerInfo].create()
 

data/std/net/lobby.mt

@@ -256,7 +256,7 @@ public async function discover_lobbies_on(
             return Result[vec.Vec[LobbyInfo], net.Error].failure(error = p.error)
         Result.success as p:
             var conn = p.value
-            defer conn.release()
+            defer: conn.release()
             match await conn.connect_to_peer():
                 Result.failure as pe:
                     return Result[vec.Vec[LobbyInfo], net.Error].failure(error = pe.error)
@@ -389,7 +389,7 @@ async function drain_lobby_client(client: ref[LobbyClient]) -> void:
         if conn_state == sess.ConnectionState.connected:
             client.pending_join = false
             var encoded = encode_string(client.pending_name.as_str())
-            defer encoded.release()
+            defer: encoded.release()
             let _ = await client.mux.mux_send(lobby_channel, type_join_request, encoded.as_span(), mux.flag_reliable)
 
     while true:
@@ -455,7 +455,7 @@ async function handle_join_request(host: ref[LobbyHost], msg: ref[mux.MuxedMessa
             return
         Result.success as name_payload:
             var player_name = name_payload.value
-            defer player_name.release()
+            defer: player_name.release()
 
             var first_free: int = -1
             var slot_index: ubyte = 0
@@ -469,7 +469,7 @@ async function handle_join_request(host: ref[LobbyHost], msg: ref[mux.MuxedMessa
 
             if first_free < 0:
                 var reject_data = encode_join_reject(reject_reason_full)
-                defer reject_data.release()
+                defer: reject_data.release()
                 let _ = await host.mux.mux_send(
                     msg.peer_id,
                     lobby_channel,
@@ -489,7 +489,7 @@ async function handle_join_request(host: ref[LobbyHost], msg: ref[mux.MuxedMessa
             unsafe: read(slot_ptr).occupied = true
 
             var accept_data = encode_join_accept(msg.peer_id, slot)
-            defer accept_data.release()
+            defer: accept_data.release()
             let _ = await host.mux.mux_send(
                 msg.peer_id,
                 lobby_channel,
@@ -516,7 +516,7 @@ async function handle_discover_request(host: ref[LobbyHost], msg: ref[mux.MuxedM
     var w = bin.Writer.with_capacity(256)
     encode_lobby_info_payload(ref_of(w), host.info)
     var payload = w.finish()
-    defer payload.release()
+    defer: payload.release()
     let _ = await host.mux.mux_send(
         msg.peer_id,
         lobby_channel,
@@ -650,7 +650,7 @@ async function broadcast_player_joined(
     w.write_uint(uint<-new_player_name.len)
     w.write_bytes(text.as_byte_span(new_player_name))
     var payload = w.finish()
-    defer payload.release()
+    defer: payload.release()
 
     var peer_index: ptr_uint = 0
     let peer_count = host.mux.peer_count()
@@ -801,11 +801,11 @@ public async function respond_to_beacon(
             match recv_result:
                 Result.success as dp:
                     var datagram = dp.value
-                    defer datagram.data.release()
-                    defer datagram.source.release()
+                    defer: datagram.data.release()
+                    defer: datagram.source.release()
                     if is_beacon_probe(datagram.data.as_span()):
                         var response = build_beacon_response(info)
-                        defer response.release()
+                        defer: response.release()
                         let _ = await socket.send_to(response.as_span(), datagram.source)
                 Result.failure:
                     pass

data/std/net/manager.mt

@@ -418,7 +418,7 @@ async function process_stored_peer_id_events(manager: ref[NetworkManager]) -> vo
                 let player_id = join_event.player_id
                 join_event.release()
                 var assign_data = build_assign_id(player_id)
-                defer assign_data.release()
+                defer: assign_data.release()
                 let _ = await manager.mux_session.mux_send(
                     player_id,
                     channel_system,

data/std/net/mux.mt

@@ -382,7 +382,7 @@ async function send_single_conn(
     send_flags: ubyte
 ) -> Result[bool, net.Error]:
     var frame = encode_frame(channel_id, type_id, send_flags, data)
-    defer frame.release()
+    defer: frame.release()
     if (send_flags & flag_reliable) != 0:
         let result = await mux.conn.send_reliable(frame.as_span(), 0)
         return result
@@ -399,7 +399,7 @@ async function send_single_session(
     send_flags: ubyte
 ) -> Result[bool, net.Error]:
     var frame = encode_frame(channel_id, type_id, send_flags, data)
-    defer frame.release()
+    defer: frame.release()
     if (send_flags & flag_reliable) != 0:
         let result = await mux.session.send_reliable(peer_id, frame.as_span(), 0)
         return result
@@ -436,7 +436,7 @@ async function send_fragmented_conn(
             break
         let chunk = unsafe: span[ubyte](data = data.data + offset, len = chunk_len)
         var frame = encode_fragment_frame(channel_id, type_id, frag_flags, group_id, frag_index, total, chunk)
-        defer frame.release()
+        defer: frame.release()
         if (send_flags & flag_reliable) != 0:
             let _ = await mux.conn.send_reliable(frame.as_span(), 0)
         else:
@@ -477,7 +477,7 @@ async function send_fragmented_session(
             break
         let chunk = unsafe: span[ubyte](data = data.data + offset, len = chunk_len)
         var frame = encode_fragment_frame(channel_id, type_id, frag_flags, group_id, frag_index, total, chunk)
-        defer frame.release()
+        defer: frame.release()
         if (send_flags & flag_reliable) != 0:
             let _ = await mux.session.send_reliable(peer_id, frame.as_span(), 0)
         else:

data/std/net/nat.mt

@@ -53,7 +53,7 @@ public async function detect(
             )
         Result.success as pr:
             var public_1 = pr.value
-            defer public_1.release()
+            defer: public_1.release()
 
             let local_result = socket.local_address()
             match local_result:
@@ -78,7 +78,7 @@ public async function detect(
                             )
                         Result.success as ar:
                             var public_2 = ar.value
-                            defer public_2.release()
+                            defer: public_2.release()
 
                             if not public_1.public_address.equal(public_2.public_address):
                                 return Result[NatResult, Error].success(
@@ -107,7 +107,7 @@ public async function detect_default(
             )
         Result.success as pp:
             var primary = pp.value
-            defer primary.release()
+            defer: primary.release()
 
             let alt_result = net.ipv4(google_alternate, google_port)
             match alt_result:
@@ -117,6 +117,6 @@ public async function detect_default(
                     )
                 Result.success as ap:
                     var alternate = ap.value
-                    defer alternate.release()
+                    defer: alternate.release()
 
                     return await detect(socket, primary, alternate)

data/std/net/packet.mt

@@ -50,7 +50,7 @@ function decode_packet_length(header: bytes.Bytes) -> ptr_uint:
 
 function frame_bytes(content: span[ubyte]) -> bytes.Bytes:
     var framed = vec.Vec[ubyte].with_capacity(frame_header_bytes + content.len)
-    defer framed.release()
+    defer: framed.release()
 
     let header = encode_packet_length(content.len)
     framed.append_array(header)
@@ -157,7 +157,7 @@ extending Stream:
             return Result[ptr_uint, Error].failure(error = packet_error(-3, "packet exceeds 32-bit frame limit"))
 
         var framed = frame_bytes(content)
-        defer framed.release()
+        defer: framed.release()
 
         let write_result = await this.stream.write_bytes(framed.as_span())
         match write_result:
@@ -175,7 +175,7 @@ extending Stream:
                 return Result[bytes.Bytes, Error].failure(error = error_from_net(payload.error))
             Result.success as payload:
                 var header = payload.value
-                defer header.release()
+                defer: header.release()
                 let packet_length = decode_packet_length(header)
                 if packet_length > this.max_packet_bytes:
                     let discard_result = await discard_exactly(this.stream, packet_length)

data/std/net/punch.mt

@@ -104,8 +104,8 @@ function poll_recv(
             return Option[PunchResult].none()
         Result.success as dp:
             var dg = dp.value
-            defer dg.data.release()
-            defer dg.source.release()
+            defer: dg.data.release()
+            defer: dg.source.release()
             return result_from_datagram(dg, remote_candidates)
 
 
@@ -114,7 +114,7 @@ public async function punch(
     remote_candidates: vec.Vec[Candidate]
 ) -> Result[PunchResult, Error]:
     var probe = build_punch_probe()
-    defer probe.release()
+    defer: probe.release()
     var recv_task = socket.recv_from(512)
 
     var c: uint = 0

data/std/net/rpc.mt

@@ -63,7 +63,7 @@ public async function call_and_wait(
     payload: span[ubyte]
 ) -> Result[bytes.Bytes, Error]:
     var call_packet = build_call(request_id, payload)
-    defer call_packet.release()
+    defer: call_packet.release()
 
     let send_result = await conn.mux_send(channel_id, call_type_id, call_packet.as_span(), mux.flag_reliable)
     match send_result:
@@ -78,7 +78,7 @@ public async function call_and_wait(
         match msg_opt:
             Option.some as mp:
                 var msg = mp.value
-                defer msg.release()
+                defer: msg.release()
                 if msg.type_id == response_type_id and msg.channel_id == channel_id:
                     let id_result = parse_request_id(msg.payload.as_span())
                     match id_result:
@@ -110,7 +110,7 @@ public async function send_reply(
     payload: span[ubyte]
 ) -> Result[bool, Error]:
     var reply_packet = build_reply(request_id, payload)
-    defer reply_packet.release()
+    defer: reply_packet.release()
     let send_result = await conn.mux_send(channel_id, response_type_id, reply_packet.as_span(), mux.flag_reliable)
     match send_result:
         Result.failure:

data/std/net/session.mt

@@ -312,7 +312,7 @@ extending Connection:
         if this.state == ConnectionState.connected:
             if frame >= this.last_heartbeat_sent + this.heartbeat_interval:
                 var hb = build_heartbeat(frame)
-                defer hb.release()
+                defer: hb.release()
                 let send_result = await this.channel.send(hb.as_span())
                 match send_result:
                     Result.failure:
@@ -395,7 +395,7 @@ extending Connection:
             ))
 
         var framed = build_user_data(data)
-        defer framed.release()
+        defer: framed.release()
         let send_result = await this.channel.send(framed.as_span())
         match send_result:
             Result.failure as payload:
@@ -415,7 +415,7 @@ extending Connection:
             ))
 
         var framed = build_user_data(data)
-        defer framed.release()
+        defer: framed.release()
         let send_result = await this.channel.send_reliable(framed.as_span(), frame)
         match send_result:
             Result.failure as payload:
@@ -444,7 +444,7 @@ extending Connection:
             Result.success as ksp:
                 key = ksp.value
         var req = build_connect_request(this.protocol_version, key)
-        defer req.release()
+        defer: req.release()
         let send_result = await this.channel.send_reliable(req.as_span(), this.last_heartbeat_sent)
         match send_result:
             Result.failure as send_payload:
@@ -463,7 +463,7 @@ extending Connection:
             ))
 
         var d = build_disconnect(disconnect_reason_local)
-        defer d.release()
+        defer: d.release()
         let send_result = await this.channel.send_reliable(d.as_span(), 0)
         this.state = ConnectionState.disconnected
         match send_result:
@@ -588,7 +588,7 @@ async function drain_outgoing_conn(conn: ref[Connection]) -> Result[bool, net.Er
                 return Result[bool, net.Error].success(value = true)
             Option.some as payload:
                 var outgoing = payload.value
-                defer outgoing.release()
+                defer: outgoing.release()
                 if outgoing.reliable:
                     let _ = await conn.channel.send_reliable(
                         outgoing.payload.as_span(),
@@ -648,13 +648,13 @@ extending Session:
             if unsafe: read(peer_ptr).channel_state == ConnectionState.connected:
                 if frame >= unsafe: read(peer_ptr).last_heartbeat_sent + this.config.heartbeat_interval:
                     var hb = build_heartbeat(frame)
-                    defer hb.release()
+                    defer: hb.release()
                     let peer_id = unsafe: read(peer_ptr).peer_id
                     let peer_address_result = find_peer_address(ref_of(this), peer_id)
                     match peer_address_result:
                         Result.success as addr_payload:
                             var addr = addr_payload.value
-                            defer addr.release()
+                            defer: addr.release()
                             let send_result = await this.host.send(addr, hb.as_span())
                             match send_result:
                                 Result.failure:
@@ -748,9 +748,9 @@ extending Session:
                 return Result[bool, net.Error].failure(error = payload.error)
             Result.success as payload:
                 var address = payload.value
-                defer address.release()
+                defer: address.release()
                 var framed = build_user_data(data)
-                defer framed.release()
+                defer: framed.release()
                 let send_result = await this.host.send(address, framed.as_span())
                 match send_result:
                     Result.failure as send_payload:
@@ -773,9 +773,9 @@ extending Session:
                 return Result[bool, net.Error].failure(error = payload.error)
             Result.success as payload:
                 var address = payload.value
-                defer address.release()
+                defer: address.release()
                 var framed = build_user_data(data)
-                defer framed.release()
+                defer: framed.release()
                 let send_result = await this.host.send_reliable(address, framed.as_span(), frame)
                 match send_result:
                     Result.failure as send_payload:
@@ -794,9 +794,9 @@ extending Session:
                 return Result[bool, net.Error].failure(error = payload.error)
             Result.success as payload:
                 var address = payload.value
-                defer address.release()
+                defer: address.release()
                 var d = build_disconnect(reason)
-                defer d.release()
+                defer: d.release()
                 let send_result = await this.host.send_reliable(address, d.as_span(), 0)
                 match send_result:
                     Result.failure:
@@ -1054,7 +1054,7 @@ async function drain_outgoing_session(session: ref[Session]) -> Result[bool, net
                 return Result[bool, net.Error].success(value = true)
             Option.some as payload:
                 var outgoing = payload.value
-                defer outgoing.release()
+                defer: outgoing.release()
                 if outgoing.reliable:
                     let send_result = await session.host.send_reliable(
                         outgoing.address,

data/std/net/stun.mt

@@ -150,7 +150,7 @@ public function parse_binding_response(
             let xaddr = read_uint_be(data, offset + 8z)
             let ip = xaddr ^ stun_magic_cookie
             var ip_str = format_ipv4(ip)
-            defer ip_str.release()
+            defer: ip_str.release()
             let addr_result = net.ipv4(ip_str.as_str(), int<-port)
             match addr_result:
                 Result.failure:
@@ -185,7 +185,7 @@ public async function resolve_public_address(
             let tid = transaction_id_from_bytes(rp.value)
             rp.value.release()
             var request = build_binding_request(tid)
-            defer request.release()
+            defer: request.release()
             let send_result = await socket.send_to(request.as_span(), stun_server)
             match send_result:
                 Result.failure:
@@ -233,7 +233,7 @@ public async function resolve_public_address_on(
             )
         Result.success as bp:
             var socket = bp.value
-            defer socket.release()
+            defer: socket.release()
             return await resolve_public_address(socket, stun_server)
 
 
@@ -248,5 +248,5 @@ public async function resolve(
             )
         Result.success as la:
             var local_addr = la.value
-            defer local_addr.release()
+            defer: local_addr.release()
             return await resolve_public_address_on(aio.current_runtime(), local_addr, stun_server)

data/std/net/turn.mt

@@ -188,7 +188,7 @@ public function parse_allocate_response(
                 let xaddr = read_uint_be(data, offset + 8z)
                 let ip = xaddr ^ stun_magic_cookie
                 var ip_str = format_ipv4(ip)
-                defer ip_str.release()
+                defer: ip_str.release()
                 let addr_result = net.ipv4(ip_str.as_str(), int<-port)
                 match addr_result:
                     Result.success as ap:
@@ -220,7 +220,7 @@ public async function allocate(
             let tid = transaction_id_from_bytes(rp.value)
             rp.value.release()
             var request = build_allocate_request(tid)
-            defer request.release()
+            defer: request.release()
             let send_result = await socket.send_to(request.as_span(), turn_server)
             match send_result:
                 Result.failure:
@@ -363,7 +363,7 @@ public function parse_data_indication(
                 let xaddr = read_uint_be(data, offset + 8z)
                 let ip = xaddr ^ stun_magic_cookie
                 var ip_str = format_ipv4(ip)
-                defer ip_str.release()
+                defer: ip_str.release()
                 let addr_result = net.ipv4(ip_str.as_str(), int<-port)
                 match addr_result:
                     Result.success as ap:
@@ -417,7 +417,7 @@ public async function send_data(
                     return Result[ptr_uint, Error].failure(error = bp.error)
                 Result.success as bp:
                     var packet = bp.value
-                    defer packet.release()
+                    defer: packet.release()
                     let send_result = await socket.send_to(packet.as_span(), turn_server)
                     match send_result:
                         Result.failure as sp: