Std.Process

31 public declarations

• begin&Std.Process.Launch -> Result[Std.Process.Started, Str]

  Start a launch and answer without waiting for it.

  fn
• chunkSizeInt

  How many bytes a read asks for at once.

  fn
• closeInput&Std.Process.Started -> Result[(), Str]

  Tell a program there is no more input.

  fn
• describe&Std.Process.Finished -> Str

  A finished program described the way an error message should say it.

  fn
• drain&Std.Process.Started -> Result[Str, Str]

  Everything a program writes, read until it stops writing.

  fn
• Finished

  What a program left behind when it finished.

  type
• isAvailableStr -> Bool

  Whether a program can be found and run at all.

  fn
• isSuccess&Std.Process.Finished -> Bool

  Whether a program reported success.

  fn
• launchStr -> &Array[Str] -> Std.Process.Launch

  A launch of a program with arguments, inheriting this program's environment

  fn
• Launch

  How a program is to be started: what runs, its arguments, the variables it

  type
• Launching

  A launch with one thing changed, each answering a launch.

  trait
• linesStr -> &Array[Str] -> Result[Array[Str], Str]

  Run a program and answer with its output in lines.

  fn
• outputStr -> &Array[Str] -> Result[Str, Str]

  Run a program and answer with its output, treating a non-zero status as a

  fn
• pipeStr -> &Array[Str] -> Str -> &Array[Str] -> Result[Std.Process.Finished, Str]

  Feed one program's output into another's input, and answer what comes out.

  fn
• read&Std.Process.Started -> Result[Option[Bytes], Str]

  Read what a program has written since the last read.

  fn
• readErrors&Std.Process.Started -> Result[Option[Bytes], Str]

  The same for what a program wrote to its error stream.

  fn
• runStr -> &Array[Str] -> Result[Std.Process.Finished, Str]

  Run a program with arguments and no input, and collect what it produced.

  fn
• runLaunch&Std.Process.Launch -> Str -> Result[Std.Process.Finished, Str]

  Run a launch to completion with text on its input.

  fn
• startStr -> &Array[Str] -> Result[Std.Process.Started, Str]

  Start a program and answer without waiting for it.

  fn
• Started

  A program that was started and has not been waited for.

  type
• statusStr -> &Array[Str] -> Result[Int, Str]

  Run a program only for its status.

  fn
• stop&Std.Process.Started -> Result[Int, Str]

  Stop a program, and wait until it is actually gone.

  fn
• succeededStr -> &Array[Str] -> Bool

  Whether a program ran and reported success.

  fn
• trimmedOutput&Std.Process.Finished -> Str

  The output with trailing whitespace removed, which is what a program that

  fn
• wait&Std.Process.Started -> Result[Int, Str]

  Wait for a program to finish, and answer the status it left.

  fn
• waitWithin&Std.Process.Started -> Int -> Result[Option[Int], Str]

  Wait a bounded time, answering nothing if the program is still running.

  fn
• withinStr -> &Array[Str] -> Int -> Result[Option[Std.Process.Finished], Str]

  Run a program, and stop it if it takes longer than it is allowed.

  fn
• withInputStr -> &Array[Str] -> Str -> Result[Std.Process.Finished, Str]

  Run a program with arguments and text on its input.

  fn
• withStarted&Std.Process.Launch -> fn(&Std.Process.Started) -> Result[T, Str] -> Result[T, Str]

  An action given a started program that is stopped when the action returns.

  fn
• write&Std.Process.Started -> &Bytes -> Result[(), Str]

  Write to a program's input.

  fn
• writeText&Std.Process.Started -> Str -> Result[(), Str]

  Write text to a program's input.

  fn