claude changes + Cmd manual changes

Author: Anton-4

Cargo.lock

@@ -39,8 +39,8 @@ repository = "https://github.com/roc-lang/basic-cli"
 
 [workspace.dependencies]
 # Core Roc types
-# roc-nightly: 2026-02-09
-roc_std_new = { git = "https://github.com/roc-lang/roc", rev = "a6e81e8a8ce50bbb3f00e7a553d08f2bb919e8e0" }
+# roc-nightly: 2026-02-20
+roc_std_new = { git = "https://github.com/roc-lang/roc", rev = "c5d87ef595fdc1c8b28dfdb6ebbe5b44ddea966f" }
 
 # Internal crates
 roc_io_error = { path = "crates/roc_io_error" }

Cargo.toml

@@ -182,7 +182,7 @@ echo ""
 echo "=== Checking examples ==="
 for example in "${MIGRATED_EXAMPLES[@]}"; do
     echo "Checking: ${example}.roc"
-    roc check "examples/${example}.roc"
+    roc check --no-cache "examples/${example}.roc"
 done
 
 # roc build migrated examples
@@ -194,7 +194,7 @@ else
 fi
 for example in "${MIGRATED_EXAMPLES[@]}"; do
     echo "Building: ${example}.roc"
-    roc build "examples/${example}.roc"
+    roc build --no-cache "examples/${example}.roc"
     mv "./${example}" "examples/"
 done
 

ci/all_tests.sh

@@ -3,13 +3,12 @@ app [main!] { pf: platform "../platform/main.roc" }
 import pf.Stdin
 import pf.Stdout
 import pf.Stderr
-import pf.Arg exposing [Arg]
 
 # To run this example: check the README.md in this folder
 
-main! : List Arg => Result {} _
-main! = |_args|
+main! = |_args| {
     data = Stdin.bytes!({})?
     Stderr.write_bytes!(data)?
     Stdout.write_bytes!(data)?
-    Ok {}
+    Ok({})
+}

examples/bytes-stdin-stdout.roc

@@ -2,16 +2,15 @@ app [main!] { pf: platform "../platform/main.roc" }
 
 import pf.Stdout
 
-main! : List(Str) => Try({}, [Exit(I32)])
 main! = |args| {
     # Skip first arg (executable path), get the remaining args
     match args.drop_first(1) {
         [first_arg, ..] => {
-            Stdout.line!("received argument: ${first_arg}")
+            Stdout.line!("received argument: ${first_arg}")?
             Ok({})
         }
         [] => {
-            Stdout.line!("Error: I expected one argument, but got none.")
+            Stdout.line!("Error: I expected one argument, but got none.")?
             Err(Exit(1))
         }
     }

examples/command-line-args.roc

@@ -6,45 +6,44 @@ import pf.Cmd
 # Different ways to run commands like you do in a terminal.
 
 main! = |_args| {
-    # Simplest way to execute a command (prints to your terminal).
-    exec_result = Cmd.exec!("echo", ["Hello"])
-    match exec_result {
-        Ok({}) => {}
-        Err(_) => Stdout.line!("Error running echo")
-    }
-
-    # To execute and capture the output (stdout and stderr) without inheriting your terminal.
-    output_result = Cmd.exec_output!(Cmd.args(Cmd.new("echo"), ["Hi"]))
-    match output_result {
-        Ok(cmd_output) => Stdout.line!("{stderr_utf8_lossy: \"${cmd_output.stderr_utf8_lossy}\", stdout_utf8: \"${cmd_output.stdout_utf8}\"}")
-        Err(_) => Stdout.line!("Error capturing output")
-    }
-
-    # To run a command with environment variables.
-    env_cmd = Cmd.args(
-        Cmd.envs(
-            Cmd.env(
-                Cmd.clear_envs(Cmd.new("env")),
-                "FOO",
-                "BAR",
-            ),
-            [("BAZ", "DUCK"), ("XYZ", "ABC")],
-        ),
-        ["-v"],
-    )
-    env_result = Cmd.exec_cmd!(env_cmd)
-    match env_result {
-        Ok({}) => {}
-        Err(_) => Stdout.line!("Error running env")
-    }
-
-    # To execute and just get the exit code (prints to your terminal).
-    # Prefer using `exec!` or `exec_cmd!`.
-    exit_result = Cmd.exec_exit_code!(Cmd.args(Cmd.new("cat"), ["non_existent.txt"]))
-    match exit_result {
-        Ok(exit_code) => Stdout.line!("Exit code: ${exit_code.to_str()}")
-        Err(_) => Stdout.line!("Error getting exit code")
-    }
-
-    Ok({})
+	# Simplest way to execute a command (prints to your terminal).
+	Cmd.exec!("echo", ["Hello"])?
+
+	# To execute and capture the output (stdout and stderr) without inheriting your terminal.
+	cmd_output = 
+		Cmd.new("echo")
+			.args(["Hi"])
+			.exec_output!()?
+
+	Stdout.line!("${Str.inspect(cmd_output)}")?
+
+	# 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("FOO", "BAR")
+		.envs([("BAZ", "DUCK"), ("XYZ", "ABC")]) # Set multiple environment variables at once with `envs`
+		.args(["-v"])
+		.exec_cmd!()?
+
+	# To execute and just get the exit code (prints to your terminal).
+	# Prefer using `exec!` or `exec_cmd!`.
+	exit_code = 
+		Cmd.new("cat")
+			.args(["non_existent.txt"])
+			.exec_exit_code!()?
+
+	Stdout.line!("Exit code: ${exit_code.to_str()}")?
+
+    # TODO add exec_output_bytes
+
+	# To execute and capture the output (stdout and stderr) in the original form as bytes without inheriting your terminal.
+	# Prefer using `exec_output!`.
+	#cmd_output_bytes = 
+	#	Cmd.new("echo")
+	#		.args(["Hi"])
+	#		.exec_output_bytes!()?
+
+	#Stdout.line!("${Str.inspect(cmd_output_bytes)}")?
+
+	Ok({})
 }

examples/command.roc

@@ -6,30 +6,40 @@ import pf.Dir
 # Demo of all Dir functions.
 
 main! = |_args| {
-    # Create a directory
-    Dir.create!("empty-dir")?
+    dir_result = {
+        # Create a directory
+        Dir.create!("empty-dir")?
 
-    # Create a directory and its parents
-    Dir.create_all!("nested-dir/a/b/c")?
+        # Create a directory and its parents
+        Dir.create_all!("nested-dir/a/b/c")?
 
-    # Create a child directory
-    Dir.create!("nested-dir/child")?
+        # Create a child directory
+        Dir.create!("nested-dir/child")?
 
-    # List the contents of a directory
-    paths = Dir.list!("nested-dir")?
+        # List the contents of a directory
+        paths = Dir.list!("nested-dir")?
 
-    # Check the contents of the directory
-    expect List.len(paths) == 2
-    expect List.contains(paths, "nested-dir/a")
-    expect List.contains(paths, "nested-dir/child")
+        # Check the contents of the directory
+        expect List.len(paths) == 2
+        expect List.contains(paths, "nested-dir/a")
+        expect List.contains(paths, "nested-dir/child")
 
-    # Delete an empty directory
-    Dir.delete_empty!("empty-dir")?
+        # Delete an empty directory
+        Dir.delete_empty!("empty-dir")?
 
-    # Delete all directories recursively
-    Dir.delete_all!("nested-dir")?
+        # Delete all directories recursively
+        Dir.delete_all!("nested-dir")?
 
-    Stdout.line!("Success!")
+        _r = Stdout.line!("Success!")
 
-    Ok({})
+        Ok({})
+    }
+
+    match dir_result {
+        Ok({}) => Ok({})
+        Err(_) => {
+            _r = Stdout.line!("Error during directory operations")
+            Err(Exit(1))
+        }
+    }
 }

examples/dir.roc

@@ -5,15 +5,17 @@ import pf.Env
 
 # How to read environment variables with Env.var!
 
-main! : List(Str) => Try({}, [Exit(I32)])
 main! = |_args| {
-    editor = Env.var!("EDITOR")
+    result = Env.var!("EDITOR")
 
-    if Str.is_empty(editor) {
-        Stdout.line!("EDITOR is not set")
-    } else {
-        Stdout.line!("Your favorite editor is ${editor}!")
+    match result {
+        Ok(editor) => {
+            _r = Stdout.line!("Your favorite editor is ${editor}!")
+            Ok({})
+        }
+        Err(VarNotFound(name)) => {
+            _r = Stdout.line!("${name} is not set")
+            Ok({})
+        }
     }
-
-    Ok({})
 }

examples/env-var.roc

@@ -11,22 +11,41 @@ main! = |_args| {
     # Try to read a file that doesn't exist - should error
     result = File.read_utf8!("nonexistent-file.txt")
     match result {
-        Ok(content) => Stdout.line!("Unexpected success: ${content}")
-        Err(FileErr(NotFound)) => Stdout.line!("Expected error: File not found (NotFound)")
-        Err(FileErr(PermissionDenied)) => Stdout.line!("Error: Permission denied")
-        Err(FileErr(Other(msg))) => Stdout.line!("Error: ${msg}")
-        Err(_) => Stdout.line!("Error: Other file error")
+        Ok(content) => {
+            _r = Stdout.line!("Unexpected success: ${content}")
+        }
+        Err(FileErr(NotFound)) => {
+            _r = Stdout.line!("Expected error: File not found (NotFound)")
+        }
+        Err(FileErr(PermissionDenied)) => {
+            _r = Stdout.line!("Error: Permission denied")
+        }
+        Err(FileErr(Other(msg))) => {
+            _r = Stdout.line!("Error: ${msg}")
+        }
+        Err(_) => {
+            _r = Stdout.line!("Error: Other file error")
+        }
     }
 
     # Now demonstrate success path - create, read, then cleanup
-    # Using ? operator to propagate errors (works with open tag unions)
-    File.write_utf8!(file_name, "Hello from error-handling example!")?
+    file_result = {
+        File.write_utf8!(file_name, "Hello from error-handling example!")?
 
-    content = File.read_utf8!(file_name)?
-    Stdout.line!("${file_name} contains: ${content}")
+        content = File.read_utf8!(file_name)?
+        _r = Stdout.line!("${file_name} contains: ${content}")
 
-    # Cleanup
-    File.delete!(file_name)?
+        # Cleanup
+        File.delete!(file_name)?
 
-    Ok({})
+        Ok({})
+    }
+
+    match file_result {
+        Ok({}) => Ok({})
+        Err(_) => {
+            _r = Stdout.line!("Error during file operations")
+            Err(Exit(1))
+        }
+    }
 }

examples/error-handling.roc

@@ -8,16 +8,26 @@ import pf.File
 main! = |_args| {
     out_file = "out.txt"
 
-    Stdout.line!("Writing a string to out.txt")
+    _r = Stdout.line!("Writing a string to out.txt")
 
-    File.write_utf8!(out_file, "a string!")?
+    result = {
+        File.write_utf8!(out_file, "a string!")?
 
-    contents = File.read_utf8!(out_file)?
+        contents = File.read_utf8!(out_file)?
 
-    Stdout.line!("I read the file back. Its contents are: \"${contents}\"")
+        _r = Stdout.line!("I read the file back. Its contents are: \"${contents}\"")
 
-    # Cleanup
-    File.delete!(out_file)?
+        # Cleanup
+        File.delete!(out_file)?
 
-    Ok({})
+        Ok({})
+    }
+
+    match result {
+        Ok({}) => Ok({})
+        Err(_) => {
+            _r = Stdout.line!("Error during file operations")
+            Err(Exit(1))
+        }
+    }
 }