✓
Passing This code compiles and runs correctly.
Code
// AoC 2015 Day 10 Part 1 — look-and-say. Statement example: "1" after 5
// rounds → 312211, length 6 (the real puzzle runs 40 rounds on a personal
// input — see the scale note below).
//
// GREEN (was RED on "ownership transfer of a phantom-obligation resource
// across fold iterations"). The pristine spelling never needed to hand an
// owned buffer across rounds: the SEQUENCE IS A NUMBER (day 11's ratified
// base-N encoding, here base 10), so a round is a PURE scalar transform
// and five rounds are five chained binds — nothing owned crosses
// anything. Inside a round, a left-to-right recursive walk carries
// (rest, scale, open-run digit, run count, packed output); each finished
// run packs two decimal positions (count, digit). Counts stay < 10 and
// sequences fit i64 exactly at statement scale — the same honesty
// boundary day 11 draws with its fixed 8-letter alphabet. A 40-round
// personal input overflows any fixed word and moves onto growable
// surfaces; this pin pins the statement's numbers, where the arithmetic
// spelling is the clean one. Digit access is div/mod only; parse-int
// decodes the input line once.
import std/io
import std/fs
import std/string
// Digit count (n ≥ 1).
pub tor dig-walk { r: i64, c: i64 } -> i64
dig-walk = if(r == 0)
| then -> c
| else |> dig-walk(r: @divTrunc(r, 10), c: c + 1): t -> t
pub tor digits { n: i64 } -> i64
digits = dig-walk(r: n, c: 0)
// Ten to the k.
pub tor pow10 { k: i64 } -> i64
pow10 = if(k <= 0)
| then -> 1
| else |> pow10(k: k - 1): t -> t * 10
// Consume the digit under `scale`: extend the open run or flush it into
// the packed output (two positions per run: count, then digit).
pub tor say-walk { rest: i64, scale: i64, d: i64, cnt: i64, out: i64 } -> i64
say-walk = if(scale == 0)
| then -> out * 100 + cnt * 10 + d
| else |> say-split(rest, scale, d, cnt, out): t -> t
pub tor say-split { rest: i64, scale: i64, d: i64, cnt: i64, out: i64 } -> i64
say-split = if(@mod(@divTrunc(rest, scale), 10) == d)
| then |> say-walk(rest, scale: @divTrunc(scale, 10), d, cnt: cnt + 1, out): t -> t
| else |> say-walk(rest, scale: @divTrunc(scale, 10), d: @mod(@divTrunc(rest, scale), 10), cnt: 1, out: out * 100 + cnt * 10 + d): t -> t
// One look-and-say round: seed the first digit, walk the rest.
pub tor say-round { n: i64 } -> i64
say-round = digits(n): L
|> pow10(k: L - 1): P
|> say-walk(rest: n, scale: @divTrunc(P, 10), d: @mod(@divTrunc(n, P), 10), cnt: 1, out: 0): r -> r
std/fs:read-lines(path: "tests/regression/810_AOC_2015/810_101_day10_part1/input.txt")
! line l |> std/string:from-page(text: l)
| ok h |> std/string:parse-int(s: h)
| ok n0 |> std/string:free(s: h)
|> say-round(n: n0): a
|> say-round(n: a): b
|> say-round(n: b): c2
|> say-round(n: c2): d2
|> say-round(n: d2): e2
|> digits(n: e2): ln
|> std/io:print.ln("{{ e2:d }}")
|> std/io:print.ln("{{ ln:d }}")
| err _ |> _
| err _ |> _
| done _ |> _
| failed e |> std/io:print.ln("FAILED {{ e:s }}")
Supporting Files
1
Actual
312211
6
Expected output
✓ Zig✓ C#312211
6
Emitted Zig source
// Access compiler flags via the per-user compiler_env module
const CompilerEnv = @import("compiler_env").CompilerEnv;
pub const panic = if (@import("builtin").mode == .Debug)
@import("std").debug.FullPanic(@import("std").debug.defaultPanic)
else
@import("std").debug.simple_panic;
const __koru_bare = struct {
extern fn posix_memalign(memptr: *?*anyopaque, alignment: usize, size: usize) c_int;
extern fn free(ptr: ?*anyopaque) void;
fn bareAlloc(_: *anyopaque, len: usize, alignment: @import("std").mem.Alignment, _: usize) ?[*]u8 {
var p: ?*anyopaque = null;
const a = @max(alignment.toByteUnits(), @sizeOf(usize));
if (posix_memalign(&p, a, len) != 0) return null;
return @ptrCast(p);
}
fn bareResize(_: *anyopaque, _: []u8, _: @import("std").mem.Alignment, _: usize, _: usize) bool { return false; }
fn bareRemap(_: *anyopaque, _: []u8, _: @import("std").mem.Alignment, _: usize, _: usize) ?[*]u8 { return null; }
fn bareFree(_: *anyopaque, memory: []u8, _: @import("std").mem.Alignment, _: usize) void { free(@ptrCast(memory.ptr)); }
const vtable = @import("std").mem.Allocator.VTable{ .alloc = bareAlloc, .resize = bareResize, .remap = bareRemap, .free = bareFree };
const allocator = @import("std").mem.Allocator{ .ptr = undefined, .vtable = &vtable };
};
const __koru_backing = if (@import("builtin").link_libc) @import("std").heap.c_allocator else if (@import("builtin").os.tag == .freestanding) __koru_bare.allocator else @import("std").heap.page_allocator;
var __koru_leak_count: @import("std").atomic.Value(usize) = .init(0);
fn __koru_alloc(ctx: *anyopaque, len: usize, alignment: @import("std").mem.Alignment, ret_addr: usize) ?[*]u8 {
_ = ctx;
const r = __koru_backing.rawAlloc(len, alignment, ret_addr);
if (comptime @import("builtin").mode == .Debug) {
if (r != null) _ = __koru_leak_count.fetchAdd(1, .monotonic);
}
return r;
}
fn __koru_resize(ctx: *anyopaque, memory: []u8, alignment: @import("std").mem.Alignment, new_len: usize, ret_addr: usize) bool {
_ = ctx;
return __koru_backing.rawResize(memory, alignment, new_len, ret_addr);
}
fn __koru_remap(ctx: *anyopaque, memory: []u8, alignment: @import("std").mem.Alignment, new_len: usize, ret_addr: usize) ?[*]u8 {
_ = ctx;
return __koru_backing.rawRemap(memory, alignment, new_len, ret_addr);
}
fn __koru_free(ctx: *anyopaque, memory: []u8, alignment: @import("std").mem.Alignment, ret_addr: usize) void {
_ = ctx;
__koru_backing.rawFree(memory, alignment, ret_addr);
if (comptime @import("builtin").mode == .Debug) {
_ = __koru_leak_count.fetchSub(1, .monotonic);
}
}
const __koru_vtable = @import("std").mem.Allocator.VTable{ .alloc = __koru_alloc, .resize = __koru_resize, .remap = __koru_remap, .free = __koru_free };
pub fn koru_allocator() @import("std").mem.Allocator {
return .{ .ptr = undefined, .vtable = &__koru_vtable };
}
pub inline fn __koru_intcast(comptime T: type, x: anytype) T {
if (comptime (@import("builtin").mode == .Debug or @import("builtin").mode == .ReleaseSafe))
return @as(T, @intCast(x));
const dst = @typeInfo(T);
const src = @typeInfo(@TypeOf(x));
if (comptime (dst == .int and src == .int and dst.int.bits == src.int.bits and dst.int.signedness != src.int.signedness))
return @as(T, @bitCast(x));
return @as(T, @intCast(x));
}
pub fn koru_leak_check() void {
if (comptime @import("builtin").mode != .Debug) return;
if (__koru_leak_count.load(.acquire) == 0) return;
if (comptime @import("builtin").target.os.tag == .freestanding) {
if (comptime @import("builtin").cpu.arch == .wasm32 or @import("builtin").cpu.arch == .wasm64) {
@panic("KORU LEAK CHECK FAILED: the produced program leaked");
} else {
const __klc = struct { extern var stdout: ?*anyopaque; extern fn fputs(__s: [*:0]const u8, __st: ?*anyopaque) c_int; };
var __lb: [128]u8 = undefined;
const __lm = "KORU LEAK CHECK FAILED: allocations still outstanding at end of run: ";
@memcpy(__lb[0..__lm.len], __lm);
var __ln: usize = __lm.len;
var __lv = __koru_leak_count.load(.acquire);
var __ld: [20]u8 = undefined;
var __lk: usize = 0;
while (__lv > 0) : (__lk += 1) { __ld[__lk] = @intCast('0' + __lv % 10); __lv /= 10; }
for (0..__lk) |__li| { __lb[__ln] = __ld[__lk - 1 - __li]; __ln += 1; }
__lb[__ln] = '\n'; __ln += 1; __lb[__ln] = 0;
_ = __klc.fputs(@as([*:0]const u8, @ptrCast(&__lb)), __klc.stdout);
@trap();
}
} else {
@import("std").debug.print("KORU LEAK CHECK FAILED: the produced program leaked (trace above)\n", .{});
@import("std").process.exit(1);
}
}
pub const main_module = struct {
pub const dig_walk_event = struct {
pub const Input = struct {
r: i64,
c: i64,
};
pub const Output = i64;
pub inline fn handler(__koru_event_input: @This().Input) @This().Output {
return __koru_handler_impl(__koru_event_input.r, __koru_event_input.c);
}
fn __koru_handler_impl(__koru_p_0: i64, __koru_p_1: i64) @This().Output {
const __koru_event_input: @This().Input = .{ .r = __koru_p_0, .c = __koru_p_1 };
// >>> SUBFLOW: tests/regression/810_AOC_2015/810_101_day10_part1/input.k:28
var r = __koru_event_input.r;
var c = __koru_event_input.c;
_ = &r;
_ = &c;
_ = &__koru_event_input;
__koru_self_loop: while (true) {
if (r == 0) {
{ return c;
}
} else {
{ {
const __koru_reentry_0 = @divTrunc(r, 10);
const __koru_reentry_1 = c + 1;
r = __koru_reentry_0;
c = __koru_reentry_1;
}
continue :__koru_self_loop;
}
}
}
unreachable;
}
};
pub const digits_event = struct {
pub const Input = struct {
n: i64,
};
pub const Output = i64;
pub inline fn handler(__koru_event_input: @This().Input) @This().Output {
return __koru_handler_impl(__koru_event_input.n);
}
fn __koru_handler_impl(__koru_p_0: i64) @This().Output {
const __koru_event_input: @This().Input = .{ .n = __koru_p_0 };
// >>> SUBFLOW: tests/regression/810_AOC_2015/810_101_day10_part1/input.k:34
const n = __koru_event_input.n;
_ = &n;
_ = &__koru_event_input;
const result = main_module.dig_walk_event.handler(.{ .r = n, .c = 0 });
const __ret1 = result;
_ = &result;
return __ret1;
}
};
pub const pow10_event = struct {
pub const Input = struct {
k: i64,
};
pub const Output = i64;
pub inline fn handler(__koru_event_input: @This().Input) @This().Output {
return __koru_handler_impl(__koru_event_input.k);
}
fn __koru_handler_impl(__koru_p_0: i64) @This().Output {
const __koru_event_input: @This().Input = .{ .k = __koru_p_0 };
// >>> SUBFLOW: tests/regression/810_AOC_2015/810_101_day10_part1/input.k:39
const k = __koru_event_input.k;
_ = &k;
_ = &__koru_event_input;
if (k <= 0) {
{ return 1;
}
} else {
{ const t = main_module.pow10_event.handler(.{ .k = k - 1 });
_ = &t;
return t * 10;
}
}
}
};
pub const say_walk_event = struct {
pub const Input = struct {
rest: i64,
scale: i64,
d: i64,
cnt: i64,
out: i64,
};
pub const Output = i64;
pub inline fn handler(__koru_event_input: @This().Input) @This().Output {
return __koru_handler_impl(__koru_event_input.rest, __koru_event_input.scale, __koru_event_input.d, __koru_event_input.cnt, __koru_event_input.out);
}
fn __koru_handler_impl(__koru_p_0: i64, __koru_p_1: i64, __koru_p_2: i64, __koru_p_3: i64, __koru_p_4: i64) @This().Output {
const __koru_event_input: @This().Input = .{ .rest = __koru_p_0, .scale = __koru_p_1, .d = __koru_p_2, .cnt = __koru_p_3, .out = __koru_p_4 };
// >>> MUTUAL-LOOP: say_walk say_split
var rest = __koru_event_input.rest;
var scale = __koru_event_input.scale;
var d = __koru_event_input.d;
var cnt = __koru_event_input.cnt;
var out = __koru_event_input.out;
_ = &rest;
_ = &scale;
_ = &d;
_ = &cnt;
_ = &out;
_ = &__koru_event_input;
__koru_self_loop: switch (@as(enum { say_walk, say_split }, .say_walk)) {
.say_walk => {
if (scale == 0) {
{ return out * 100 + cnt * 10 + d;
}
} else {
{ continue :__koru_self_loop .say_split;
}
}
},
.say_split => {
if ((blk: { const __koru_l = @mod(@divTrunc(rest, scale), 10); const __koru_r = d; const __koru_lo = @typeInfo(@TypeOf(__koru_l)) == .optional; const __koru_ro = @typeInfo(@TypeOf(__koru_r)) == .optional; const __koru_lp = if (__koru_lo) @typeInfo(@TypeOf(__koru_l)).optional.child else @TypeOf(__koru_l); const __koru_rp = if (__koru_ro) @typeInfo(@TypeOf(__koru_r)).optional.child else @TypeOf(__koru_r); const __koru_ls = __koru_str: { const __koru_ty = @typeInfo(__koru_lp); if (__koru_ty == .array) break :__koru_str __koru_ty.array.child == u8; if (__koru_ty == .pointer) { const __koru_ptr = __koru_ty.pointer; if (__koru_ptr.size == .slice and __koru_ptr.child == u8) break :__koru_str true; break :__koru_str __koru_ptr.size == .one and @typeInfo(__koru_ptr.child) == .array and @typeInfo(__koru_ptr.child).array.child == u8; } break :__koru_str false; }; const __koru_rs = __koru_str: { const __koru_ty = @typeInfo(__koru_rp); if (__koru_ty == .array) break :__koru_str __koru_ty.array.child == u8; if (__koru_ty == .pointer) { const __koru_ptr = __koru_ty.pointer; if (__koru_ptr.size == .slice and __koru_ptr.child == u8) break :__koru_str true; break :__koru_str __koru_ptr.size == .one and @typeInfo(__koru_ptr.child) == .array and @typeInfo(__koru_ptr.child).array.child == u8; } break :__koru_str false; }; if (__koru_ls and __koru_rs) { const __koru_ln = if (__koru_lo) __koru_l == null else false; const __koru_rn = if (__koru_ro) __koru_r == null else false; break :blk (__koru_ln == __koru_rn) and (__koru_ln or @import("std").mem.eql(u8, if (__koru_lo) __koru_l.? else __koru_l, if (__koru_ro) __koru_r.? else __koru_r)); } else break :blk __koru_l == __koru_r; })) {
{ {
const __koru_reentry_0 = @divTrunc(scale, 10);
const __koru_reentry_1 = cnt + 1;
scale = __koru_reentry_0;
cnt = __koru_reentry_1;
}
continue :__koru_self_loop .say_walk;
}
} else {
{ {
const __koru_reentry_0 = @divTrunc(scale, 10);
const __koru_reentry_1 = @mod(@divTrunc(rest, scale), 10);
const __koru_reentry_2 = 1;
const __koru_reentry_3 = out * 100 + cnt * 10 + d;
scale = __koru_reentry_0;
d = __koru_reentry_1;
cnt = __koru_reentry_2;
out = __koru_reentry_3;
}
continue :__koru_self_loop .say_walk;
}
}
},
}
unreachable;
}
};
pub const say_split_event = struct {
pub const Input = struct {
rest: i64,
scale: i64,
d: i64,
cnt: i64,
out: i64,
};
pub const Output = i64;
pub inline fn handler(__koru_event_input: @This().Input) @This().Output {
return __koru_handler_impl(__koru_event_input.rest, __koru_event_input.scale, __koru_event_input.d, __koru_event_input.cnt, __koru_event_input.out);
}
fn __koru_handler_impl(__koru_p_0: i64, __koru_p_1: i64, __koru_p_2: i64, __koru_p_3: i64, __koru_p_4: i64) @This().Output {
const __koru_event_input: @This().Input = .{ .rest = __koru_p_0, .scale = __koru_p_1, .d = __koru_p_2, .cnt = __koru_p_3, .out = __koru_p_4 };
// >>> MUTUAL-LOOP: say_split say_walk
var rest = __koru_event_input.rest;
var scale = __koru_event_input.scale;
var d = __koru_event_input.d;
var cnt = __koru_event_input.cnt;
var out = __koru_event_input.out;
_ = &rest;
_ = &scale;
_ = &d;
_ = &cnt;
_ = &out;
_ = &__koru_event_input;
__koru_self_loop: switch (@as(enum { say_split, say_walk }, .say_split)) {
.say_split => {
if ((blk: { const __koru_l = @mod(@divTrunc(rest, scale), 10); const __koru_r = d; const __koru_lo = @typeInfo(@TypeOf(__koru_l)) == .optional; const __koru_ro = @typeInfo(@TypeOf(__koru_r)) == .optional; const __koru_lp = if (__koru_lo) @typeInfo(@TypeOf(__koru_l)).optional.child else @TypeOf(__koru_l); const __koru_rp = if (__koru_ro) @typeInfo(@TypeOf(__koru_r)).optional.child else @TypeOf(__koru_r); const __koru_ls = __koru_str: { const __koru_ty = @typeInfo(__koru_lp); if (__koru_ty == .array) break :__koru_str __koru_ty.array.child == u8; if (__koru_ty == .pointer) { const __koru_ptr = __koru_ty.pointer; if (__koru_ptr.size == .slice and __koru_ptr.child == u8) break :__koru_str true; break :__koru_str __koru_ptr.size == .one and @typeInfo(__koru_ptr.child) == .array and @typeInfo(__koru_ptr.child).array.child == u8; } break :__koru_str false; }; const __koru_rs = __koru_str: { const __koru_ty = @typeInfo(__koru_rp); if (__koru_ty == .array) break :__koru_str __koru_ty.array.child == u8; if (__koru_ty == .pointer) { const __koru_ptr = __koru_ty.pointer; if (__koru_ptr.size == .slice and __koru_ptr.child == u8) break :__koru_str true; break :__koru_str __koru_ptr.size == .one and @typeInfo(__koru_ptr.child) == .array and @typeInfo(__koru_ptr.child).array.child == u8; } break :__koru_str false; }; if (__koru_ls and __koru_rs) { const __koru_ln = if (__koru_lo) __koru_l == null else false; const __koru_rn = if (__koru_ro) __koru_r == null else false; break :blk (__koru_ln == __koru_rn) and (__koru_ln or @import("std").mem.eql(u8, if (__koru_lo) __koru_l.? else __koru_l, if (__koru_ro) __koru_r.? else __koru_r)); } else break :blk __koru_l == __koru_r; })) {
{ {
const __koru_reentry_0 = @divTrunc(scale, 10);
const __koru_reentry_1 = cnt + 1;
scale = __koru_reentry_0;
cnt = __koru_reentry_1;
}
continue :__koru_self_loop .say_walk;
}
} else {
{ {
const __koru_reentry_0 = @divTrunc(scale, 10);
const __koru_reentry_1 = @mod(@divTrunc(rest, scale), 10);
const __koru_reentry_2 = 1;
const __koru_reentry_3 = out * 100 + cnt * 10 + d;
scale = __koru_reentry_0;
d = __koru_reentry_1;
cnt = __koru_reentry_2;
out = __koru_reentry_3;
}
continue :__koru_self_loop .say_walk;
}
}
},
.say_walk => {
if (scale == 0) {
{ return out * 100 + cnt * 10 + d;
}
} else {
{ continue :__koru_self_loop .say_split;
}
}
},
}
unreachable;
}
};
pub const say_round_event = struct {
pub const Input = struct {
n: i64,
};
pub const Output = i64;
pub inline fn handler(__koru_event_input: @This().Input) @This().Output {
return __koru_handler_impl(__koru_event_input.n);
}
fn __koru_handler_impl(__koru_p_0: i64) @This().Output {
const __koru_event_input: @This().Input = .{ .n = __koru_p_0 };
// >>> SUBFLOW: tests/regression/810_AOC_2015/810_101_day10_part1/input.k:60
const n = __koru_event_input.n;
_ = &n;
_ = &__koru_event_input;
const result = main_module.digits_event.handler(.{ .n = n });
const L = result;
_ = &result;
const P = main_module.pow10_event.handler(.{ .k = L - 1 });
_ = &P;
const r = main_module.say_walk_event.handler(.{ .rest = n, .scale = @divTrunc(P, 10), .d = @mod(@divTrunc(n, P), 10), .cnt = 1, .out = 0 });
_ = &r;
return r;
}
};
// >>> FLOW: tests/regression/810_AOC_2015/810_101_day10_part1/input.k:64 ~std.fs:read_lines()
pub fn flow0() void {
const result_0: koru_std.koru_fs.read_lines_event.Output = __koru_proc_0: {
const path = ("tests/regression/810_AOC_2015/810_101_day10_part1/input.txt"); _ = &path;
const __koru_rl_file = @import("std").fs.cwd().openFile(path, .{}) catch |err| {
const __koru_rl_msg = switch (err) {
error.FileNotFound => "File not found",
error.AccessDenied => "Access denied",
error.IsDir => "Path is a directory",
else => "Failed to open file",
};
break :__koru_proc_0 .{ .failed = __koru_rl_msg };
};
defer __koru_rl_file.close();
// No artificial cap: read the whole file, bounded only by real memory.
// An over-RAM file fails LOUDLY as OutOfMemory rather than silently at an
// arbitrary limit. (`read-lines` should ultimately stream line-by-line for
// constant memory on >RAM inputs; that's a separate capability, not this
// bug — the bug was the silent 10MB cap.)
const __koru_rl_content = __koru_rl_file.readToEndAlloc(koru_allocator(), @import("std").math.maxInt(usize)) catch |err| {
const __koru_rl_msg = switch (err) {
error.OutOfMemory => "Out of memory reading file",
else => "Failed to read file",
};
break :__koru_proc_0 .{ .failed = __koru_rl_msg };
};
defer koru_allocator().free(__koru_rl_content);
// HYGIENE: this body INLINES into the consumer's frame (effect
// lowering), so locals are __koru-prefixed to never collide with
// user bindings in the surrounding flow.
var __koru_rl_n: usize = 0;
var __koru_rl_it = @import("std").mem.splitScalar(u8, __koru_rl_content, '\n');
while (__koru_rl_it.next()) |__koru_rl_raw| {
// A trailing newline yields one final empty slice - not a line.
if (__koru_rl_raw.len == 0 and __koru_rl_it.peek() == null) break;
const __koru_rl_l = if (__koru_rl_raw.len > 0 and __koru_rl_raw[__koru_rl_raw.len - 1] == '\r') __koru_rl_raw[0 .. __koru_rl_raw.len - 1] else __koru_rl_raw;
{ const l = __koru_rl_l; _ = &l; const result_e0_0 = koru_std.koru_string.from_page_event.handler(.{ .text = l });
_ = &result_e0_0;
switch (result_e0_0) {
// >>> BRANCH: tests/regression/810_AOC_2015/810_101_day10_part1/input.k:66 | ok h |>
.ok => |h| {
... [truncated - 33KB total]Emitted C# source
static class main_module {
public static void __koru_stdout_write(dynamic s) => global::System.Console.Out.Write(s);
public static void __koru_stderr_write(dynamic s) => global::System.Console.Error.Write(s);
// The mutable handle carrier — `*String`-style resources are
// `new __KoruBox { data = … }` because C# anonymous types are
// read-only: `s.data = …` (std/string append/clear, handle
// mutation generally) needs a settable member.
public class __KoruBox { public dynamic data; }
// Textification for `{{ … }}` operands: C# bool ToStrings as
// `True` where Koru prints `true`, and the operand's static type
// is unknown at this boundary — a `(x) is bool` inline test would
// be a compile error on statically-typed operands instead. Generic
// on purpose: `dynamic` boxed every value-type operand — measured
// ~1s/10M elements on 012_threat_scanner — while T specializes to
// the operand's own ToString() with no box.
public static string __koru_str<T>(T v) => v is bool b ? (b ? "true" : "false") : v?.ToString();
public static class dig_walk_event {
public struct Input {
public long r;
public long c;
}
public static long handler(Input __koru_input) {
var r = __koru_input.r;
var c = __koru_input.c;
if (r == 0) {
{ return c;
}
} else {
{ var t = main_module.dig_walk_event.handler(new dig_walk_event.Input { r = (long)(((r) / (10))), c = (long)(c + 1)});
return (long)(t);
}
}
return default;
}
}
public static class digits_event {
public struct Input {
public long n;
}
public static long handler(Input __koru_input) {
var n = __koru_input.n;
var __ret1 = main_module.dig_walk_event.handler(new dig_walk_event.Input { r = (long)(n), c = (long)(0)});
return (long)(__ret1);
return default;
}
}
public static class pow10_event {
public struct Input {
public long k;
}
public static long handler(Input __koru_input) {
var k = __koru_input.k;
if (k <= 0) {
{ return 1;
}
} else {
{ var t = main_module.pow10_event.handler(new pow10_event.Input { k = (long)(k - 1)});
return (long)(t * 10);
}
}
return default;
}
}
public static class say_walk_event {
public struct Input {
public long rest;
public long scale;
public long d;
public long cnt;
public long @out;
}
public static long handler(Input __koru_input) {
var rest = __koru_input.rest;
var scale = __koru_input.scale;
var d = __koru_input.d;
var cnt = __koru_input.cnt;
var @out = __koru_input.@out;
if (scale == 0) {
{ return @out * 100 + cnt * 10 + d;
}
} else {
{ var t = main_module.say_split_event.handler(new say_split_event.Input { rest = (long)(rest), scale = (long)(scale), d = (long)(d), cnt = (long)(cnt), @out = (long)(@out)});
return (long)(t);
}
}
return default;
}
}
public static class say_split_event {
public struct Input {
public long rest;
public long scale;
public long d;
public long cnt;
public long @out;
}
public static long handler(Input __koru_input) {
var rest = __koru_input.rest;
var scale = __koru_input.scale;
var d = __koru_input.d;
var cnt = __koru_input.cnt;
var @out = __koru_input.@out;
if (((((((rest) / (scale))) % (10)) + (10)) % (10)) == d) {
{ var t = main_module.say_walk_event.handler(new say_walk_event.Input { rest = (long)(rest), scale = (long)(((scale) / (10))), d = (long)(d), cnt = (long)(cnt + 1), @out = (long)(@out)});
return (long)(t);
}
} else {
{ var t = main_module.say_walk_event.handler(new say_walk_event.Input { rest = (long)(rest), scale = (long)(((scale) / (10))), d = (long)(((((((rest) / (scale))) % (10)) + (10)) % (10))), cnt = (long)(1), @out = (long)(@out * 100 + cnt * 10 + d)});
return (long)(t);
}
}
return default;
}
}
public static class say_round_event {
public struct Input {
public long n;
}
public static long handler(Input __koru_input) {
var n = __koru_input.n;
var L = main_module.digits_event.handler(new digits_event.Input { n = (long)(n)});
var P = main_module.pow10_event.handler(new pow10_event.Input { k = (long)(L - 1)});
var r = main_module.say_walk_event.handler(new say_walk_event.Input { rest = (long)(n), scale = (long)(((P) / (10))), d = (long)(((((((n) / (P))) % (10)) + (10)) % (10))), cnt = (long)(1), @out = (long)(0)});
return (long)(r);
return default;
}
}
public static class std_fs_read_lines_event {
public struct Input {
public string path;
}
public struct Output {
public string tag;
public long done;
public string failed;
}
public interface IOps {
void line(string __koru_arg);
}
public static Output handler<H>(Input __koru_input, H ops) where H : struct, IOps {
void line(string __koru_arg) => ops.line(__koru_arg);
var path = __koru_input.path;
string __koru_rl_content;
if (global::System.IO.Directory.Exists(path)) {
return new Output { tag = "failed", failed = "Path is a directory" };
}
try {
__koru_rl_content = global::System.IO.File.ReadAllText(path);
} catch (global::System.IO.FileNotFoundException) {
return new Output { tag = "failed", failed = "File not found" };
} catch (global::System.IO.DirectoryNotFoundException) {
return new Output { tag = "failed", failed = "File not found" };
} catch (global::System.UnauthorizedAccessException) {
return new Output { tag = "failed", failed = "Access denied" };
} catch (global::System.OutOfMemoryException) {
return new Output { tag = "failed", failed = "Out of memory reading file" };
} catch (global::System.IO.IOException) {
return new Output { tag = "failed", failed = "Failed to read file" };
} catch (global::System.Exception) {
return new Output { tag = "failed", failed = "Failed to open file" };
}
long __koru_rl_n = 0;
var __koru_rl_lines = __koru_rl_content.Split('\n');
for (long __koru_rl_i = 0; __koru_rl_i < __koru_rl_lines.Length; __koru_rl_i++) {
var __koru_rl_raw = __koru_rl_lines[__koru_rl_i];
// A trailing newline yields one final empty slice — not a line.
if (__koru_rl_raw.Length == 0 && __koru_rl_i == __koru_rl_lines.Length - 1) break;
var __koru_rl_l = (__koru_rl_raw.Length > 0 && __koru_rl_raw[__koru_rl_raw.Length - 1] == '\r') ? __koru_rl_raw.Substring(0, __koru_rl_raw.Length - 1) : __koru_rl_raw;
line(__koru_rl_l);
__koru_rl_n += 1;
}
return new Output { tag = "done", done = __koru_rl_n };
return default;
}
}
public static class std_string_from_page_event {
public struct Input {
public string text;
}
public struct Output {
public string tag;
public dynamic ok;
public string err;
}
public static Output handler(Input __koru_input) {
var text = __koru_input.text;
return new Output { tag = "ok", ok = new __KoruBox { data = text } };
return default;
}
}
public static class std_string_take_event {
public struct Input {
public dynamic s;
}
public static dynamic handler(Input __koru_input) {
var s = __koru_input.s;
return (dynamic)(s);
}
}
public static class std_string_release_event {
public struct Input {
public dynamic s;
}
public static dynamic handler(Input __koru_input) {
var s = __koru_input.s;
return (dynamic)(s);
}
}
public static class std_string_free_event {
public struct Input {
public dynamic s;
}
public static dynamic handler(Input __koru_input) {
var s = __koru_input.s;
// GC is the implementation. There is no allocator to hand the bytes back
// to, so the honest body is empty — this is a port, not a stub.
return default;
}
}
public static class std_string_len_event {
public struct Input {
public dynamic s;
}
public static long handler(Input __koru_input) {
var s = __koru_input.s;
return (long)(s.data.Length);
}
}
public static class std_string_parse_int_event {
public struct Input {
public dynamic s;
}
public struct Output {
public string tag;
public long ok;
public string err;
}
public static Output handler(Input __koru_input) {
var s = __koru_input.s;
if (!global::System.Text.RegularExpressions.Regex.IsMatch(s.data, "^[+-]?[0-9]+$")) {
return new Output { tag = "err", err = "not an integer" };
}
return new Output { tag = "ok", ok = long.Parse(s.data) };
return default;
}
}
public static class std_control_if_event {
public struct Input {
public dynamic expr;
}
public struct Output {
public string tag;
public dynamic then;
public dynamic @else;
}
public static Output handler(Input __koru_input) {
var expr = __koru_input.expr;
throw new global::System.Exception("if: |template| proc is inlined at call sites and must never be called");
}
}
public static class koru_start_event {
public struct Input {
}
public struct Output {
public string tag;
public dynamic done;
}
public static Output handler(Input __koru_input) => new Output { tag = "done" };
}
public static class koru_end_event {
public struct Input {
}
public struct Output {
public string tag;
public dynamic done;
}
public static Output handler(Input __koru_input) => new Output { tag = "done" };
}
public static void flow0() {
var __koru_handlers_0 = new __koru_handlers_0 { };
var result_4 = main_module.std_fs_read_lines_event.handler(new std_fs_read_lines_event.Input { path = (string)("tests/regression/810_AOC_2015/810_101_day10_part1/input.txt")}, __koru_handlers_0);
if (result_4.tag == "done") {
var _auto_8 = result_4.done;
}
if (result_4.tag == "failed") {
var e = result_4.failed;
__koru_stdout_write("FAILED " + __koru_str(e) + "\n");
}
}
public static void flow1() {
main_module.koru_start_event.handler(new koru_start_event.Input { });
}
public static void flow2() {
main_module.koru_end_event.handler(new koru_end_event.Input { });
}
struct __koru_handlers_0 : std_fs_read_lines_event.IOps {
public void line(string __koru_arm_1) {
var l = __koru_arm_1;
var result_2 = main_module.std_string_from_page_event.handler(new std_string_from_page_event.Input { text = (string)(l)});
if (result_2.tag == "ok") {
var h = result_2.ok;
var result_3 = main_module.std_string_parse_int_event.handler(new std_string_parse_int_event.Input { s = h});
if (result_3.tag == "ok") {
var n0 = result_3.ok;
{
var __koru_p_s = h;
// GC is the implementation. There is no allocator to hand the bytes back
// to, so the honest body is empty — this is a port, not a stub.
}
var a = main_module.say_round_event.handler(new say_round_event.Input { n = (long)(n0)});
var b = main_module.say_round_event.handler(new say_round_event.Input { n = (long)(a)});
var c2 = main_module.say_round_event.handler(new say_round_event.Input { n = (long)(b)});
var d2 = main_module.say_round_event.handler(new say_round_event.Input { n = (long)(c2)});
var e2 = main_module.say_round_event.handler(new say_round_event.Input { n = (long)(d2)});
var ln = main_module.digits_event.handler(new digits_event.Input { n = (long)(e2)});
__koru_stdout_write("" + __koru_str(e2) + "\n");
__koru_stdout_write("" + __koru_str(ln) + "\n");
}
if (result_3.tag == "err") {
var _auto_6 = result_3.err;
{
var __koru_p_s = h;
// GC is the implementation. There is no allocator to hand the bytes back
// to, so the honest body is empty — this is a port, not a stub.
}
}
}
if (result_2.tag == "err") {
var _auto_7 = result_2.err;
}
}
}
}
static class Program {
static void Main() {
main_module.flow1();
main_module.flow0();
main_module.flow2();
}
}
Flows
subflow ~dig-walk click a branch to expand · @labels scroll to their anchor
if (r == 0)
subflow ~digits click a branch to expand · @labels scroll to their anchor
dig-walk (r: n, c: 0)
subflow ~pow10 click a branch to expand · @labels scroll to their anchor
if (k <= 0)
subflow ~say-walk click a branch to expand · @labels scroll to their anchor
if (scale == 0)
subflow ~say-split click a branch to expand · @labels scroll to their anchor
if (@mod(@divTrunc(rest, scale), 10) == d)
subflow ~say-round click a branch to expand · @labels scroll to their anchor
digits (n)
flow ~read-lines click a branch to expand · @labels scroll to their anchor
read-lines (path: "tests/regression/810_AOC_2015/810_101_day10_part1/input.txt")
Test Configuration
MUST_RUN LANGUAGES: zig cs