Move cli_testing_examples under crates/cli/tests

crates/cli/tests/cli_testing_examples/algorithms/README.md

@@ -0,0 +1,15 @@
+# Algorithm examples
+
+To run:
+
+```bash
+cargo run fibonacci.roc
+cargo run quicksort.roc
+```
+
+To run in release mode instead, do:
+
+```bash
+cargo run --release fibonacci.roc
+cargo run --release quicksort.roc
+```

crates/cli/tests/cli_testing_examples/algorithms/fibonacci-platform/host.zig

@@ -0,0 +1,130 @@
+const std = @import("std");
+const builtin = @import("builtin");
+const str = @import("glue").str;
+const RocStr = str.RocStr;
+const testing = std.testing;
+const expectEqual = testing.expectEqual;
+const expect = testing.expect;
+const maxInt = std.math.maxInt;
+
+const mem = std.mem;
+const Allocator = mem.Allocator;
+
+// NOTE the LLVM backend expects this signature
+// extern fn roc__mainForHost_1_exposed(i64, *i64) void;
+extern fn roc__mainForHost_1_exposed(i64) i64;
+
+const Align = 2 * @alignOf(usize);
+extern fn malloc(size: usize) callconv(.C) ?*align(Align) anyopaque;
+extern fn realloc(c_ptr: [*]align(Align) u8, size: usize) callconv(.C) ?*anyopaque;
+extern fn free(c_ptr: [*]align(Align) u8) callconv(.C) void;
+extern fn memcpy(dst: [*]u8, src: [*]u8, size: usize) callconv(.C) void;
+extern fn memset(dst: [*]u8, value: i32, size: usize) callconv(.C) void;
+
+const DEBUG: bool = false;
+
+export fn roc_alloc(size: usize, alignment: u32) callconv(.C) ?*anyopaque {
+    if (DEBUG) {
+        var ptr = malloc(size);
+        const stdout = std.io.getStdOut().writer();
+        stdout.print("alloc:   {d} (alignment {d}, size {d})\n", .{ ptr, alignment, size }) catch unreachable;
+        return ptr;
+    } else {
+        return malloc(size);
+    }
+}
+
+export fn roc_realloc(c_ptr: *anyopaque, new_size: usize, old_size: usize, alignment: u32) callconv(.C) ?*anyopaque {
+    if (DEBUG) {
+        const stdout = std.io.getStdOut().writer();
+        stdout.print("realloc: {d} (alignment {d}, old_size {d})\n", .{ c_ptr, alignment, old_size }) catch unreachable;
+    }
+
+    return realloc(@as([*]align(Align) u8, @alignCast(@ptrCast(c_ptr))), new_size);
+}
+
+export fn roc_dealloc(c_ptr: *anyopaque, alignment: u32) callconv(.C) void {
+    if (DEBUG) {
+        const stdout = std.io.getStdOut().writer();
+        stdout.print("dealloc: {d} (alignment {d})\n", .{ c_ptr, alignment }) catch unreachable;
+    }
+
+    free(@as([*]align(Align) u8, @alignCast(@ptrCast(c_ptr))));
+}
+
+export fn roc_panic(msg: *RocStr, tag_id: u32) callconv(.C) void {
+    const stderr = std.io.getStdErr().writer();
+    switch (tag_id) {
+        0 => {
+            stderr.print("Roc standard library crashed with message\n\n    {s}\n\nShutting down\n", .{msg.asSlice()}) catch unreachable;
+        },
+        1 => {
+            stderr.print("Application crashed with message\n\n    {s}\n\nShutting down\n", .{msg.asSlice()}) catch unreachable;
+        },
+        else => unreachable,
+    }
+    std.process.exit(1);
+}
+
+export fn roc_dbg(loc: *RocStr, msg: *RocStr, src: *RocStr) callconv(.C) void {
+    const stderr = std.io.getStdErr().writer();
+    stderr.print("[{s}] {s} = {s}\n", .{ loc.asSlice(), src.asSlice(), msg.asSlice() }) catch unreachable;
+}
+
+export fn roc_memset(dst: [*]u8, value: i32, size: usize) callconv(.C) void {
+    return memset(dst, value, size);
+}
+
+extern fn kill(pid: c_int, sig: c_int) c_int;
+extern fn shm_open(name: *const i8, oflag: c_int, mode: c_uint) c_int;
+extern fn mmap(addr: ?*anyopaque, length: c_uint, prot: c_int, flags: c_int, fd: c_int, offset: c_uint) *anyopaque;
+extern fn getppid() c_int;
+
+fn roc_getppid() callconv(.C) c_int {
+    return getppid();
+}
+
+fn roc_getppid_windows_stub() callconv(.C) c_int {
+    return 0;
+}
+
+fn roc_shm_open(name: *const i8, oflag: c_int, mode: c_uint) callconv(.C) c_int {
+    return shm_open(name, oflag, mode);
+}
+fn roc_mmap(addr: ?*anyopaque, length: c_uint, prot: c_int, flags: c_int, fd: c_int, offset: c_uint) callconv(.C) *anyopaque {
+    return mmap(addr, length, prot, flags, fd, offset);
+}
+
+comptime {
+    if (builtin.os.tag == .macos or builtin.os.tag == .linux) {
+        @export(roc_getppid, .{ .name = "roc_getppid", .linkage = .Strong });
+        @export(roc_mmap, .{ .name = "roc_mmap", .linkage = .Strong });
+        @export(roc_shm_open, .{ .name = "roc_shm_open", .linkage = .Strong });
+    }
+
+    if (builtin.os.tag == .windows) {
+        @export(roc_getppid_windows_stub, .{ .name = "roc_getppid", .linkage = .Strong });
+    }
+}
+
+pub export fn main() u8 {
+    const stdout = std.io.getStdOut().writer();
+
+    var timer = std.time.Timer.start() catch unreachable;
+
+    const result = roc__mainForHost_1_exposed(10);
+
+    const nanos = timer.read();
+    const seconds = (@as(f64, @floatFromInt(nanos)) / 1_000_000_000.0);
+
+    stdout.print("{d}\n", .{result}) catch unreachable;
+
+    const stderr = std.io.getStdErr().writer();
+    stderr.print("runtime: {d:.3}ms\n", .{seconds * 1000}) catch unreachable;
+
+    return 0;
+}
+
+fn to_seconds(tms: std.os.timespec) f64 {
+    return @as(f64, @floatFromInt(tms.tv_sec)) + (@as(f64, @floatFromInt(tms.tv_nsec)) / 1_000_000_000.0);
+}

crates/cli/tests/cli_testing_examples/algorithms/fibonacci-platform/main.roc

@@ -0,0 +1,9 @@
+platform "fibonacci"
+    requires {} { main : I64 -> I64 }
+    exposes []
+    packages {}
+    imports []
+    provides [mainForHost]
+
+mainForHost : I64 -> I64
+mainForHost = \a -> main a

crates/cli/tests/cli_testing_examples/algorithms/fibonacci.roc

@@ -0,0 +1,13 @@
+app "fibonacci"
+    packages { pf: "fibonacci-platform/main.roc" }
+    imports []
+    provides [main] to pf
+
+main = \n -> fib n 0 1
+
+# the clever implementation requires join points
+fib = \n, a, b ->
+    if n == 0 then
+        a
+    else
+        fib (n - 1) b (a + b)

crates/cli/tests/cli_testing_examples/algorithms/quicksort-platform/host.zig

@@ -0,0 +1,160 @@
+const std = @import("std");
+const builtin = @import("builtin");
+const str = @import("glue").str;
+const RocStr = str.RocStr;
+const testing = std.testing;
+const expectEqual = testing.expectEqual;
+const expect = testing.expect;
+
+const mem = std.mem;
+const Allocator = mem.Allocator;
+
+extern fn roc__mainForHost_1_exposed(input: RocList) callconv(.C) RocList;
+
+const Align = 2 * @alignOf(usize);
+extern fn malloc(size: usize) callconv(.C) ?*align(Align) anyopaque;
+extern fn realloc(c_ptr: [*]align(Align) u8, size: usize) callconv(.C) ?*anyopaque;
+extern fn free(c_ptr: [*]align(Align) u8) callconv(.C) void;
+extern fn memcpy(dst: [*]u8, src: [*]u8, size: usize) callconv(.C) void;
+extern fn memset(dst: [*]u8, value: i32, size: usize) callconv(.C) void;
+
+const DEBUG: bool = false;
+
+export fn roc_alloc(size: usize, alignment: u32) callconv(.C) ?*anyopaque {
+    if (DEBUG) {
+        var ptr = malloc(size);
+        const stdout = std.io.getStdOut().writer();
+        stdout.print("alloc:   {d} (alignment {d}, size {d})\n", .{ ptr, alignment, size }) catch unreachable;
+        return ptr;
+    } else {
+        return malloc(size);
+    }
+}
+
+export fn roc_realloc(c_ptr: *anyopaque, new_size: usize, old_size: usize, alignment: u32) callconv(.C) ?*anyopaque {
+    if (DEBUG) {
+        const stdout = std.io.getStdOut().writer();
+        stdout.print("realloc: {d} (alignment {d}, old_size {d})\n", .{ c_ptr, alignment, old_size }) catch unreachable;
+    }
+
+    return realloc(@as([*]align(Align) u8, @alignCast(@ptrCast(c_ptr))), new_size);
+}
+
+export fn roc_dealloc(c_ptr: *anyopaque, alignment: u32) callconv(.C) void {
+    if (DEBUG) {
+        const stdout = std.io.getStdOut().writer();
+        stdout.print("dealloc: {d} (alignment {d})\n", .{ c_ptr, alignment }) catch unreachable;
+    }
+
+    free(@as([*]align(Align) u8, @alignCast(@ptrCast(c_ptr))));
+}
+
+export fn roc_panic(msg: *RocStr, tag_id: u32) callconv(.C) void {
+    const stderr = std.io.getStdErr().writer();
+    switch (tag_id) {
+        0 => {
+            stderr.print("Roc standard library crashed with message\n\n    {s}\n\nShutting down\n", .{msg.asSlice()}) catch unreachable;
+        },
+        1 => {
+            stderr.print("Application crashed with message\n\n    {s}\n\nShutting down\n", .{msg.asSlice()}) catch unreachable;
+        },
+        else => unreachable,
+    }
+    std.process.exit(1);
+}
+
+export fn roc_dbg(loc: *RocStr, msg: *RocStr, src: *RocStr) callconv(.C) void {
+    const stderr = std.io.getStdErr().writer();
+    stderr.print("[{s}] {s} = {s}\n", .{ loc.asSlice(), src.asSlice(), msg.asSlice() }) catch unreachable;
+}
+
+export fn roc_memset(dst: [*]u8, value: i32, size: usize) callconv(.C) void {
+    return memset(dst, value, size);
+}
+
+extern fn kill(pid: c_int, sig: c_int) c_int;
+extern fn shm_open(name: *const i8, oflag: c_int, mode: c_uint) c_int;
+extern fn mmap(addr: ?*anyopaque, length: c_uint, prot: c_int, flags: c_int, fd: c_int, offset: c_uint) *anyopaque;
+extern fn getppid() c_int;
+
+fn roc_getppid() callconv(.C) c_int {
+    return getppid();
+}
+
+fn roc_getppid_windows_stub() callconv(.C) c_int {
+    return 0;
+}
+
+fn roc_shm_open(name: *const i8, oflag: c_int, mode: c_uint) callconv(.C) c_int {
+    return shm_open(name, oflag, mode);
+}
+fn roc_mmap(addr: ?*anyopaque, length: c_uint, prot: c_int, flags: c_int, fd: c_int, offset: c_uint) callconv(.C) *anyopaque {
+    return mmap(addr, length, prot, flags, fd, offset);
+}
+
+comptime {
+    if (builtin.os.tag == .macos or builtin.os.tag == .linux) {
+        @export(roc_getppid, .{ .name = "roc_getppid", .linkage = .Strong });
+        @export(roc_mmap, .{ .name = "roc_mmap", .linkage = .Strong });
+        @export(roc_shm_open, .{ .name = "roc_shm_open", .linkage = .Strong });
+    }
+
+    if (builtin.os.tag == .windows) {
+        @export(roc_getppid_windows_stub, .{ .name = "roc_getppid", .linkage = .Strong });
+    }
+}
+
+// warning! the array is currently stack-allocated so don't make this too big
+const NUM_NUMS = 100;
+
+const RocList = extern struct { elements: [*]i64, length: usize, capacity: usize };
+
+const Unit = extern struct {};
+
+pub export fn main() u8 {
+    const stdout = std.io.getStdOut().writer();
+
+    var raw_numbers: [NUM_NUMS + 1]i64 = undefined;
+
+    // set refcount to one
+    raw_numbers[0] = -9223372036854775808;
+
+    var numbers = raw_numbers[1..];
+
+    for (numbers, 0..) |_, i| {
+        numbers[i] = @mod(@as(i64, @intCast(i)), 12);
+    }
+
+    var roc_list = RocList{ .elements = numbers, .length = NUM_NUMS, .capacity = NUM_NUMS };
+
+    var timer = std.time.Timer.start() catch unreachable;
+
+    // actually call roc to populate the callresult
+    const callresult: RocList = roc__mainForHost_1_exposed(roc_list);
+
+    // stdout the result
+    const length = @min(20, callresult.length);
+    var result = callresult.elements[0..length];
+
+    const nanos = timer.read();
+    const seconds = (@as(f64, @floatFromInt(nanos)) / 1_000_000_000.0);
+
+    for (result, 0..) |x, i| {
+        if (i == 0) {
+            stdout.print("[{}, ", .{x}) catch unreachable;
+        } else if (i == length - 1) {
+            stdout.print("{}]\n", .{x}) catch unreachable;
+        } else {
+            stdout.print("{}, ", .{x}) catch unreachable;
+        }
+    }
+
+    const stderr = std.io.getStdErr().writer();
+    stderr.print("runtime: {d:.3}ms\n", .{seconds * 1000}) catch unreachable;
+
+    return 0;
+}
+
+fn to_seconds(tms: std.os.timespec) f64 {
+    return @as(f64, @floatFromInt(tms.tv_sec)) + (@as(f64, @floatFromInt(tms.tv_nsec)) / 1_000_000_000.0);
+}

crates/cli/tests/cli_testing_examples/algorithms/quicksort-platform/main.roc

@@ -0,0 +1,9 @@
+platform "quicksort"
+    requires {} { quicksort : List I64 -> List I64 }
+    exposes []
+    packages {}
+    imports []
+    provides [mainForHost]
+
+mainForHost : List I64 -> List I64
+mainForHost = \list -> quicksort list

crates/cli/tests/cli_testing_examples/algorithms/quicksort.roc

@@ -0,0 +1,59 @@
+app "quicksort"
+    packages { pf: "quicksort-platform/main.roc" }
+    imports []
+    provides [quicksort] to pf
+
+quicksort = \originalList ->
+    n = List.len originalList
+
+    quicksortHelp originalList 0 (n - 1)
+
+quicksortHelp : List (Num a), U64, U64 -> List (Num a)
+quicksortHelp = \list, low, high ->
+    if low < high then
+        when partition low high list is
+            Pair partitionIndex partitioned ->
+                partitioned
+                |> quicksortHelp low (partitionIndex - 1)
+                |> quicksortHelp (partitionIndex + 1) high
+    else
+        list
+
+partition : U64, U64, List (Num a) -> [Pair U64 (List (Num a))]
+partition = \low, high, initialList ->
+    when List.get initialList high is
+        Ok pivot ->
+            when partitionHelp low low initialList high pivot is
+                Pair newI newList ->
+                    Pair newI (swap newI high newList)
+
+        Err _ ->
+            Pair low initialList
+
+partitionHelp : U64, U64, List (Num c), U64, Num c -> [Pair U64 (List (Num c))]
+partitionHelp = \i, j, list, high, pivot ->
+    if j < high then
+        when List.get list j is
+            Ok value ->
+                if value <= pivot then
+                    partitionHelp (i + 1) (j + 1) (swap i j list) high pivot
+                else
+                    partitionHelp i (j + 1) list high pivot
+
+            Err _ ->
+                Pair i list
+    else
+        Pair i list
+
+swap : U64, U64, List a -> List a
+swap = \i, j, list ->
+    when Pair (List.get list i) (List.get list j) is
+        Pair (Ok atI) (Ok atJ) ->
+            list
+            |> List.set i atJ
+            |> List.set j atI
+
+        _ ->
+            # to prevent a decrement on list
+            # turns out this is very important for optimizations
+            list