fix command.roc, misc improvements

Author: Anton-4

Cargo.lock

@@ -40,8 +40,8 @@ repository = "https://github.com/roc-lang/basic-cli"
 
 [workspace.dependencies]
 # Core Roc types
-# roc-nightly: 2026-03-06
-roc_std_new = { git = "https://github.com/roc-lang/roc", rev = "a02d2287afd24d9f13baff3a5c6059e795b01661" }
+# roc-nightly: 2026-03-30
+roc_std_new = { git = "https://github.com/roc-lang/roc", rev = "c593bfd81918bde53955fd0f5ad964ce479d521f" }
 
 # Internal crates
 roc_io_error = { path = "crates/roc_io_error" }

Cargo.toml

@@ -43,50 +43,56 @@ cleanup() {
 # Set up trap to ensure cleanup runs on exit
 trap cleanup EXIT
 
-# Get nightly version info from Cargo.toml
-source ci/get_roc_nightly_url.sh
-NEED_DOWNLOAD=false
-
 echo "=== basic-cli CI ==="
 echo ""
 
-# Check if cached roc exists and matches pinned version
-# Derive directory name from archive name (strip .tar.gz or .zip extension)
-ROC_DIR="${ROC_NIGHTLY_ARCHIVE%.tar.gz}"
-ROC_DIR="${ROC_DIR%.zip}"
-if [ -d "$ROC_DIR" ] && [ -f "$ROC_DIR/roc" ]; then
-    CACHED_VERSION=$("./$ROC_DIR/roc" version 2>/dev/null || echo "unknown")
-    if echo "$CACHED_VERSION" | grep -q "$ROC_NIGHTLY_COMMIT"; then
-        echo "roc already at correct version: $CACHED_VERSION"
+if [ -n "${ROC:-}" ]; then
+    # Use user-specified roc binary
+    ROC_BIN_DIR="$(cd "$(dirname "$ROC")" && pwd)"
+    export PATH="$ROC_BIN_DIR:$PATH"
+else
+    # Get nightly version info from Cargo.toml
+    source ci/get_roc_nightly_url.sh
+    NEED_DOWNLOAD=false
+
+    # Check if cached roc exists and matches pinned version
+    # Derive directory name from archive name (strip .tar.gz or .zip extension)
+    ROC_DIR="${ROC_NIGHTLY_ARCHIVE%.tar.gz}"
+    ROC_DIR="${ROC_DIR%.zip}"
+    if [ -d "$ROC_DIR" ] && [ -f "$ROC_DIR/roc" ]; then
+        CACHED_VERSION=$("./$ROC_DIR/roc" version 2>/dev/null || echo "unknown")
+        if echo "$CACHED_VERSION" | grep -q "$ROC_NIGHTLY_COMMIT"; then
+            echo "roc already at correct version: $CACHED_VERSION"
+        else
+            echo "Cached roc ($CACHED_VERSION) doesn't match nightly ($ROC_NIGHTLY_COMMIT)"
+            echo "Removing stale roc directory..."
+            rm -rf "$ROC_DIR"
+            NEED_DOWNLOAD=true
+        fi
     else
-        echo "Cached roc ($CACHED_VERSION) doesn't match nightly ($ROC_NIGHTLY_COMMIT)"
-        echo "Removing stale roc directory..."
-        rm -rf "$ROC_DIR"
         NEED_DOWNLOAD=true
     fi
-else
-    NEED_DOWNLOAD=true
-fi
 
-if [ "$NEED_DOWNLOAD" = true ]; then
-    echo "Downloading Roc nightly $ROC_NIGHTLY_COMMIT..."
-    echo "URL: $ROC_NIGHTLY_URL"
+    if [ "$NEED_DOWNLOAD" = true ]; then
+        echo "Downloading Roc nightly $ROC_NIGHTLY_COMMIT..."
+        echo "URL: $ROC_NIGHTLY_URL"
 
-    # Clean up any old nightly directories
-    rm -rf roc_nightly-*
+        # Clean up any old nightly directories
+        rm -rf roc_nightly-*
 
-    curl -fOL "$ROC_NIGHTLY_URL"
-    tar -xzf "$ROC_NIGHTLY_ARCHIVE"
-    rm -f "$ROC_NIGHTLY_ARCHIVE"
+        curl -fOL "$ROC_NIGHTLY_URL"
+        tar -xzf "$ROC_NIGHTLY_ARCHIVE"
+        rm -f "$ROC_NIGHTLY_ARCHIVE"
 
-    # Add to GITHUB_PATH if running in CI
-    if [ -n "${GITHUB_PATH:-}" ]; then
-        echo "$(pwd)/$ROC_DIR" >> "$GITHUB_PATH"
+        # Add to GITHUB_PATH if running in CI
+        if [ -n "${GITHUB_PATH:-}" ]; then
+            echo "$(pwd)/$ROC_DIR" >> "$GITHUB_PATH"
+        fi
     fi
-fi
 
-# Ensure roc is in PATH
-export PATH="$(pwd)/$ROC_DIR:$PATH"
+    # Ensure roc is in PATH
+    export PATH="$(pwd)/$ROC_DIR:$PATH"
+fi
 
 echo ""
 echo "Using roc version: $(roc version)"

ci/all_tests.sh

@@ -11,9 +11,9 @@ cd $env(EXAMPLES_DIR)
 spawn ./path
 
 set expected_output [normalize_output {
-is_file: Try.Ok(True)
-is_dir: Try.Ok(False)
-is_sym_link: Try.Ok(False)
+is_file: Ok(True)
+is_dir: Ok(False)
+is_sym_link: Ok(False)
 }]
 
 expect $expected_output {

ci/expect_scripts/path.exp

@@ -20,9 +20,9 @@ main! = |_args| {
 	# To run a command with environment variables.
 	Cmd.new("env")
 		.clear_envs() # You probably don't need to clear all other environment variables, this is just an example.
+		.env("BAZ", "DUCK")
 		.env("FOO", "BAR")
-		.envs([("BAZ", "DUCK"), ("XYZ", "ABC")]) # Set multiple environment variables at once with `envs`
-		.args(["-v"])
+		.env("XYZ", "ABC")
 		.exec_cmd!()?
 
 	# To execute and just get the exit code (prints to your terminal).

examples/command.roc

@@ -208,8 +208,8 @@ Cmd :: {
     ## ```
     env : Cmd, Str, Str -> Cmd
     env = |cmd, key, value| {
-        ..cmd,
-        envs: cmd.envs.concat([key, value]),
+        new_envs = cmd.envs.append(key).append(value)
+        { args: cmd.args, clear_envs: cmd.clear_envs, envs: new_envs, program: cmd.program }
     }
 
     ## Add multiple environment variables to the command.
@@ -219,11 +219,8 @@ Cmd :: {
     ## ```
     envs : Cmd, List((Str, Str)) -> Cmd
     envs = |cmd, pairs| {
-        flat = pairs.fold([], |acc, (k, v)| acc.concat([k, v]))
-        {
-            ..cmd,
-            envs: cmd.envs.concat(flat),
-        }
+        new_envs = flatten_str_pairs(pairs, cmd.envs, 0)
+        { args: cmd.args, clear_envs: cmd.clear_envs, envs: new_envs, program: cmd.program }
     }
 
     ## Clear all environment variables before running the command.
@@ -266,6 +263,20 @@ host_exec_exit_code! : Cmd => Try(I32, IOErr)
 # TODO use OutputFromHostSuccess and OutputFromHostFailure once #9216 is fixed
 host_exec_output! : Cmd => Try({stderr_bytes : List(U8), stdout_bytes : List(U8)}, (Try({stderr_bytes : List(U8), stdout_bytes : List(U8), exit_code : I32}, IOErr)))
 
+flatten_str_pairs : List((Str, Str)), List(Str), U64 -> List(Str)
+flatten_str_pairs = |pairs, acc, idx| {
+    if idx >= pairs.len() {
+        acc
+    } else {
+        match pairs.get(idx) {
+            Ok(pair) =>
+                flatten_str_pairs(pairs, acc.append(pair.0).append(pair.1), idx + 1)
+            Err(_) =>
+                acc
+        }
+    }
+}
+
 to_str : Cmd -> Str
 to_str = |cmd| {
     my_trim = |trimmed_str| {if trimmed_str.is_empty() "" else "envs: ${trimmed_str}"}

platform/Cmd.roc

@@ -1,11 +1,22 @@
 import IOErr exposing [IOErr]
 
+## See Stdout.roc for explanation of why hosted functions use IOErr directly.
+host_stderr_line! : Str => Try({}, IOErr)
+host_stderr_write! : Str => Try({}, IOErr)
+host_stderr_write_bytes! : List(U8) => Try({}, IOErr)
+
 Stderr := [].{
     ## Write the given string to [standard error](https://en.wikipedia.org/wiki/Standard_streams#Standard_error_(stderr)),
     ## followed by a newline.
     ##
     ## > To write to `stderr` without the newline, see [Stderr.write!].
     line! : Str => Try({}, [StderrErr(IOErr), ..])
+    line! = |msg| {
+        match host_stderr_line!(msg) {
+            Ok(val) => Ok(val)
+            Err(ioerr) => Err(StderrErr(ioerr))
+        }
+    }
 
     ## Write the given string to [standard error](https://en.wikipedia.org/wiki/Standard_streams#Standard_error_(stderr)).
     ##
@@ -14,10 +25,22 @@ Stderr := [].{
     ##
     ## > To write to `stderr` with a newline at the end, see [Stderr.line!].
     write! : Str => Try({}, [StderrErr(IOErr), ..])
+    write! = |msg| {
+        match host_stderr_write!(msg) {
+            Ok(val) => Ok(val)
+            Err(ioerr) => Err(StderrErr(ioerr))
+        }
+    }
 
     ## Write the given bytes to [standard error](https://en.wikipedia.org/wiki/Standard_streams#Standard_error_(stderr)).
     ##
     ## Most terminals will not actually display content that are written to them until they receive a newline,
     ## so this may appear to do nothing until you write a newline!
     write_bytes! : List(U8) => Try({}, [StderrErr(IOErr), ..])
+    write_bytes! = |bytes| {
+        match host_stderr_write_bytes!(bytes) {
+            Ok(val) => Ok(val)
+            Err(ioerr) => Err(StderrErr(ioerr))
+        }
+    }
 }

platform/Stderr.roc

@@ -1,5 +1,10 @@
 import IOErr exposing [IOErr]
 
+## See Stdout.roc for explanation of why hosted functions use closed error types.
+host_stdin_line! : {} => Try(Str, [EndOfFile, StdinErr(IOErr)])
+host_stdin_bytes! : {} => Try(List(U8), [EndOfFile, StdinErr(IOErr)])
+host_stdin_read_to_end! : {} => Try(List(U8), IOErr)
+
 Stdin := [].{
     ## Read a line from [standard input](https://en.wikipedia.org/wiki/Standard_streams#Standard_input_(stdin)).
     ##
@@ -8,6 +13,13 @@ Stdin := [].{
     ## program having gotten stuck. It's often helpful to print a prompt first, so
     ## the user knows it's necessary to enter something before the program will continue.
     line! : {} => Try(Str, [EndOfFile, StdinErr(IOErr), ..])
+    line! = |arg| {
+        match host_stdin_line!(arg) {
+            Ok(val) => Ok(val)
+            Err(EndOfFile) => Err(EndOfFile)
+            Err(StdinErr(ioerr)) => Err(StdinErr(ioerr))
+        }
+    }
 
     ## Read bytes from [standard input](https://en.wikipedia.org/wiki/Standard_streams#Standard_input_(stdin)).
     ## This function can read no more than 16,384 bytes at a time. Use [read_to_end!] if you need more.
@@ -16,8 +28,21 @@ Stdin := [].{
     ## which disables defaults terminal bevahiour and allows reading input
     ## without buffering until Enter key is pressed.
     bytes! : {} => Try(List(U8), [EndOfFile, StdinErr(IOErr), ..])
+    bytes! = |arg| {
+        match host_stdin_bytes!(arg) {
+            Ok(val) => Ok(val)
+            Err(EndOfFile) => Err(EndOfFile)
+            Err(StdinErr(ioerr)) => Err(StdinErr(ioerr))
+        }
+    }
 
     ## Read all bytes from [standard input](https://en.wikipedia.org/wiki/Standard_streams#Standard_input_(stdin))
     ## until [EOF](https://en.wikipedia.org/wiki/End-of-file) in this source.
     read_to_end! : {} => Try(List(U8), [StdinErr(IOErr), ..])
+    read_to_end! = |arg| {
+        match host_stdin_read_to_end!(arg) {
+            Ok(val) => Ok(val)
+            Err(ioerr) => Err(StdinErr(ioerr))
+        }
+    }
 }

platform/Stdin.roc

@@ -1,11 +1,25 @@
 import IOErr exposing [IOErr]
 
+## These hosted functions return Try({}, IOErr) directly - matching the host's ABI.
+## They must NOT use open tag unions ([..]) because the compiler would extend them
+## with error variants from the calling context, changing the memory layout and
+## causing a mismatch with what the host actually writes.
+host_stdout_line! : Str => Try({}, IOErr)
+host_stdout_write! : Str => Try({}, IOErr)
+host_stdout_write_bytes! : List(U8) => Try({}, IOErr)
+
 Stdout := [].{
     ## Write the given string to [standard output](https://en.wikipedia.org/wiki/Standard_streams#Standard_output_(stdout)),
     ## followed by a newline.
     ##
     ## > To write to `stdout` without the newline, see [Stdout.write!].
     line! : Str => Try({}, [StdoutErr(IOErr), ..])
+    line! = |msg| {
+        match host_stdout_line!(msg) {
+            Ok(val) => Ok(val)
+            Err(ioerr) => Err(StdoutErr(ioerr))
+        }
+    }
 
     ## Write the given string to [standard output](https://en.wikipedia.org/wiki/Standard_streams#Standard_output_(stdout)).
     ##
@@ -14,10 +28,22 @@ Stdout := [].{
     ##
     ## > To write to `stdout` with a newline at the end, see [Stdout.line!].
     write! : Str => Try({}, [StdoutErr(IOErr), ..])
+    write! = |msg| {
+        match host_stdout_write!(msg) {
+            Ok(val) => Ok(val)
+            Err(ioerr) => Err(StdoutErr(ioerr))
+        }
+    }
 
     ## Write the given bytes to [standard output](https://en.wikipedia.org/wiki/Standard_streams#Standard_output_(stdout)).
     ##
     ## Note that many terminals will not actually display content that is written to them until they receive a newline,
     ## so this may appear to do nothing until you write a newline!
     write_bytes! : List(U8) => Try({}, [StdoutErr(IOErr), ..])
+    write_bytes! = |bytes| {
+        match host_stdout_write_bytes!(bytes) {
+            Ok(val) => Ok(val)
+            Err(ioerr) => Err(StdoutErr(ioerr))
+        }
+    }
 }