overhaul progress

Author: Anton-4

build.roc

@@ -47,7 +47,6 @@ roc_version! = |roc_cmd|
     info!("Checking provided roc; executing `${roc_cmd} version`:")?
 
     Cmd.exec!(roc_cmd, ["version"])
-    |> Result.map_err(RocVersionCheckFailed)
 
 get_os_and_arch! : {} => Result OSAndArch _
 get_os_and_arch! = |{}|
@@ -78,7 +77,6 @@ build_stub_app_lib! = |roc_cmd, stub_lib_path|
     info!("Building stubbed app shared library ...")?
 
     Cmd.exec!(roc_cmd, ["build", "--lib", "platform/libapp.roc", "--output", stub_lib_path, "--optimize"])
-    |> Result.map_err(ErrBuildingAppStub)
 
 stub_file_extension : OSAndArch -> Str
 stub_file_extension = |os_and_arch|
@@ -130,7 +128,6 @@ cargo_build_host! = |debug_mode|
     args = cargo_build_args!({})?
 
     Cmd.exec!("cargo", args)
-    |> Result.map_err(ErrBuildingHostBinaries)
 
 copy_host_lib! : OSAndArch, Str => Result {} _
 copy_host_lib! = |os_and_arch, rust_target_folder|
@@ -142,7 +139,6 @@ copy_host_lib! = |os_and_arch, rust_target_folder|
     info!("Moving the prebuilt binary from ${host_build_path} to ${host_dest_path} ...")?
 
     Cmd.exec!("cp", [host_build_path, host_dest_path])
-    |> Result.map_err(ErrMovingPrebuiltLegacyBinary)
 
 preprocess_host! : Str, Str, Str => Result {} _
 preprocess_host! = |roc_cmd, stub_lib_path, rust_target_folder|
@@ -152,7 +148,6 @@ preprocess_host! = |roc_cmd, stub_lib_path, rust_target_folder|
     surgical_build_path = "${rust_target_folder}host"
 
     Cmd.exec!(roc_cmd, ["preprocess-host", surgical_build_path, "platform/main.roc", stub_lib_path])
-    |> Result.map_err(ErrPreprocessingSurgicalBinary)
 
 info! : Str => Result {} _
 info! = |msg|

examples/command.roc

@@ -1,7 +1,6 @@
 app [main!] { pf: platform "../platform/main.roc" }
 
 import pf.Stdout
-import pf.Stderr
 import pf.Cmd
 import pf.Arg exposing [Arg]
 
@@ -13,84 +12,43 @@ main! : List Arg => Result {} _
 main! = |_args|
 
     # Simplest way to execute a command (prints to your terminal).
-    Cmd.exec!("echo", ["Hello"]) ? |err| EchoHelloFailed(err)
+    Cmd.exec!("echo", ["Hello"])?
 
     # To execute and capture the output (stdout, stderr, and exit code) without inheriting your terminal.
-    output_example!({}) ? |err| OutputExampleFailed(err)
-
-    # To run a command with an environment variable.
-    env_example!({}) ? |err| EnvExampleFailed(err)
-
-    # To execute and just get the exit code (prints to your terminal).
-    status_example!({}) ? |err| StatusExampleFailed(err)
-
-    Ok({})
-
-# Execute command and capture the output (stdout, stderr, and exit code)
-output_example! : {} => Result {} _
-output_example! = |{}|
-
     cmd_output =
         Cmd.new("echo")
         |> Cmd.args(["Hi"])
-        |> Cmd.output!
-
-    print_output!(cmd_output)
-
-
-print_output! : Cmd.Output => Result {} _
-print_output! = |cmd_output|
+        |> Cmd.exec_output!()?
 
+    Stdout.line!(
+        """
+        stdout:${cmd_output.stdout_utf8}
+        stderr:${cmd_output.stderr_utf8_lossy}
+        """
+    )?
 
-    when cmd_output.status is
-        Ok(0) ->
-            stdout_utf8 = Str.from_utf8(cmd_output.stdout)?
-            Stdout.line!("Command output: ${stdout_utf8}")
-
-        Ok(exit_code) ->
-            stdout_utf8 = Str.from_utf8_lossy(cmd_output.stdout)
-            stderr_utf8 = Str.from_utf8_lossy(cmd_output.stderr)
-            err_data =
-                """
-                Command failed:
-                - exit code: ${Num.to_str(exit_code)}
-                - stdout: ${stdout_utf8}
-                - stderr: ${stderr_utf8}
-                """
-
-            Stderr.line!(err_data)
-
-        Err(err) ->
-            Stderr.line!("Failed to get exit code for command, error: ${Inspect.to_str(err)}")
-
-
-# Run command with an environment variable
-env_example! : {} => Result {} _
-env_example! = |{}|
-
-    cmd_output =
+    # To run a command with environment variables.
+    cmd_output_env =
         Cmd.new("env")
         |> Cmd.clear_envs # You probably don't need to clear all other environment variables, this is just an example.
         |> Cmd.env("FOO", "BAR")
         |> Cmd.envs([("BAZ", "DUCK"), ("XYZ", "ABC")]) # Set multiple environment variables at once with `envs`
         |> Cmd.args(["-v"])
-        |> Cmd.output!
+        |> Cmd.exec_output!()?
 
-    print_output!(cmd_output)
+    Stdout.line!(
+        """
+        stdout:${cmd_output_env.stdout_utf8}
+        stderr:${cmd_output_env.stderr_utf8_lossy}
+        """
+    )?
 
-# Execute command and capture the exit code
-status_example! : {} => Result {} _
-status_example! = |{}|
-    cmd_result =
+    # To execute and just get the exit code (prints to your terminal).
+    exit_code =
         Cmd.new("echo")
         |> Cmd.args(["Yo"])
-        |> Cmd.status!
+        |> Cmd.exec_exit_code!()?
 
-    when cmd_result is
-        Ok(0) -> Ok({})
+    Stdout.line!("Exit code: ${Num.to_str(exit_code)}")?
 
-        Ok(exit_code) ->
-            Stderr.line!("Command failed with exit code: ${Num.to_str(exit_code)}")
-
-        Err(err) ->
-            Stderr.line!("Failed to get exit code for command, error: ${Inspect.to_str(err)}")
+    Ok({})

flake.lock

@@ -9,9 +9,10 @@ module [
     exec_output!,
     exec!,
     exec_cmd!,
+    exec_exit_code!,
 ]
 
-import InternalCmd
+import InternalCmd exposing [to_str]
 import InternalIOErr exposing [IOErr]
 import Host
 
@@ -22,9 +23,9 @@ Cmd := InternalCmd.Command
 ## If you want to capture the output, use [exec_output!].
 ## ```
 ## # Call echo to print "hello world"
-## Cmd.exec!("echo", ["hello world"]) ? |err| CmdEchoFailed(err)
+## Cmd.exec!("echo", ["hello world"])?
 ## ```
-exec! : Str, List Str => Result {} [ExecFailed Str (List Str) I32, FailedToGetExitCode IOErr]
+exec! : Str, List Str => Result {} [ExecFailed Str I32, FailedToGetExitCode Str IOErr]
 exec! = |cmd_name, arguments|
     exit_code =
         new(cmd_name)
@@ -34,7 +35,8 @@ exec! = |cmd_name, arguments|
     if exit_code == 0i32 then
         Ok({})
     else
-        Err(ExecFailed(cmd_name, arguments, exit_code))
+        cmd_str = "${cmd_name} ${Str.join_with(arguments, " ")}"
+        Err(ExecFailed(cmd_str, exit_code))
 
 ## Execute a Cmd while inheriting stdin, stdout and stderr from parent.
 ## You should prefer using `exec!`, only use this if you want to use [env], [envs] or [clear_envs].
@@ -46,15 +48,15 @@ exec! = |cmd_name, arguments|
 ## |> Cmd.env("RUST_BACKTRACE", "1")
 ## |> Cmd.exec_cmd!()?
 ## ```
-exec_cmd! : Cmd => Result {} [ExecCmdFailed Cmd I32, FailedToGetExitCode IOErr]
-exec_cmd! = |cmd|
+exec_cmd! : Cmd => Result {} [ExecCmdFailed Str I32, FailedToGetExitCode Str IOErr]
+exec_cmd! = |@Cmd(cmd)|
     exit_code =
-        exec_exit_code!(cmd)?
+        exec_exit_code!(@Cmd(cmd))?
 
     if exit_code == 0i32 then
         Ok({})
     else
-        Err(ExecCmdFailed(cmd, exit_code))
+        Err(ExecCmdFailed(to_str(cmd), exit_code))
 
 ## Execute command and capture stdout, stderr and the exit code in [Output].
 ##
@@ -66,16 +68,16 @@ exec_output! : Cmd =>
                     Result
                         {stdout_utf8 : Str, stderr_utf8_lossy : Str}
                         [
-                            StdoutContainsInvalidUtf8([BadUtf8 { index : U64, problem : Str.Utf8Problem }]),
-                            NonZeroExitCode({exit_code: I32, stdout_utf8_lossy: Str, stderr_utf8_lossy: Str}),
-                            FailedToGetExitCode(IOErr)
+                            StdoutContainsInvalidUtf8({ cmd : Str, err: [BadUtf8 { index : U64, problem : Str.Utf8Problem }]}),
+                            NonZeroExitCode({cmd : Str, exit_code: I32, stdout_utf8_lossy: Str, stderr_utf8_lossy: Str}),
+                            FailedToGetExitCode({ cmd : Str, err : IOErr})
                         ]
 exec_output! = |@Cmd(cmd)|
     exec_res = Host.command_exec_output!(cmd)
 
     when exec_res is
         Ok({stdout_bytes, stderr_bytes}) ->
-            stdout_utf8 = Str.from_utf8(stdout_bytes) ? |err| StdoutContainsInvalidUtf8(err)
+            stdout_utf8 = Str.from_utf8(stdout_bytes) ? |err| StdoutContainsInvalidUtf8({ cmd: to_str(cmd), err})
             stderr_utf8_lossy = Str.from_utf8_lossy(stderr_bytes)
 
             Ok({stdout_utf8, stderr_utf8_lossy})
@@ -85,20 +87,20 @@ exec_output! = |@Cmd(cmd)|
                     stdout_utf8_lossy = Str.from_utf8_lossy(stdout_bytes)
                     stderr_utf8_lossy = Str.from_utf8_lossy(stderr_bytes)
 
-                    Err(NonZeroExitCode({exit_code, stdout_utf8_lossy, stderr_utf8_lossy}))
+                    Err(NonZeroExitCode({cmd : to_str(cmd), exit_code, stdout_utf8_lossy, stderr_utf8_lossy}))
                 Err(err) ->
                     Err(InternalIOErr.handle_err(err))
-                    |> Result.map_err(FailedToGetExitCode)
+                    |> Result.map_err(|er| FailedToGetExitCode({ cmd : to_str(cmd), err : er }))
 
 # TODO exec_output_bytes
 
 ## Execute command and inherit stdin, stdout and stderr from parent. Returns the exit code.
 ## Helper function.
-exec_exit_code! : Cmd => Result I32 [FailedToGetExitCode IOErr]
+exec_exit_code! : Cmd => Result I32 [FailedToGetExitCode Str IOErr]
 exec_exit_code! = |@Cmd(cmd)|
     Host.command_exec_exit_code!(cmd)
     |> Result.map_err(InternalIOErr.handle_err)
-    |> Result.map_err(FailedToGetExitCode)
+    |> Result.map_err(|err| FailedToGetExitCode(to_str(cmd), err))
 
 # This hits a compiler bug: Alias `6.IdentId(11)` not registered in delayed aliases! ...
 # ## Converts output into a utf8 string. Invalid utf8 sequences in stderr are ignored.

platform/Cmd.roc

@@ -2,6 +2,7 @@ module [
     Command,
     OutputFromHostSuccess,
     OutputFromHostFailure,
+    to_str,
 ]
 
 Command : {
@@ -20,4 +21,20 @@ OutputFromHostFailure : {
     exit_code : I32,
     stdout_bytes : List U8,
     stderr_bytes : List U8,
-}
+}
+
+to_str : Command -> Str
+to_str = |cmd|
+    envs_str =
+        cmd.envs
+        #|> List.map(|(key, value)| "${key}=${value}")
+        |> Str.join_with(" ")
+
+    clear_envs_str = if cmd.clear_envs then "true" else "false"
+    
+    """
+    cmd: ${cmd.program}
+    args: ${Str.join_with(cmd.args, " ")}
+    envs: ${envs_str}
+    clear_envs: ${clear_envs_str}
+    """