✓
Passing This code compiles and runs correctly.
Code
// Asymmetric manual/auto discharge through a NESTED `if` is VALID. The outer `| then`
// runs an inner if whose both arms close f manually; the outer `| else |> _`
// auto-discharges. Whichever path runs, f is closed — no leak. Exercises auto-discharge
// coexisting with manual discharge reaching through a nested if.
//
// Grounding:
// Outer if structure: 330_022_if_manual_both_branches/input.kz:5-7
// Nested control nesting: 330_048_nested_for_in_if/input.kz:5-9
~import std/control
~import app/fs
const outer_condition = true;
const inner_condition = false;
~app/fs:open(path: "test.txt")
| opened f |> std/control:if(outer_condition)
| then |> std/control:if(inner_condition)
| then |> app/fs:close(file: f)
| else |> app/fs:close(file: f)
| else |> _
Actual
Opening file: test.txt
Closing file
Expected output
Opening file: test.txt
Closing file
Imported Files
// Library module: fs
// Defines filesystem operations with cleanup obligations
// Copied verbatim from 330_022_if_manual_both_branches/fs.kz
const std = @import("std");
// File type with phantom states
const File = struct {
handle: i32,
};
// Open a file - returns opened! state (requires cleanup)
~pub event open { path: []const u8 }
| opened *File<opened!>
~proc open|zig {
std.debug.print("Opening file: {s}\n", .{path});
const allocator = std.heap.page_allocator;
const f = allocator.create(File) catch unreachable;
f.* = File{ .handle = 42 };
return .{ .opened = f };
}
// Close a file - CONSUMES opened! state (disposes the resource)
~pub event close { file: *File<!opened> }
~proc close|zig {
std.debug.print("Closing file\n", .{});
}
Test Configuration
MUST_RUN