kawa shell concept

[Per Bothner <per at bothner dot com>]

Below is the current state of my ideas for
"Kawa shell" support.  Nothing is implemented so far.

Note this integrates with how lazy values are handled.  If you
evaluate a (run ...) in a REPL, the output from the command is
"printed" to the repl output.  Likewise, you can use the output
whenever a string (or a bytevector) is expected.  No need for
special `quotes`.  It would help to have an expanded string literal
syntax that supports embedded expressions.  (I have a number of goals
for string literals, which makes it non-trivial.)

I'll probably implement something in this vein after 1.12 is released.
I'm uncertain about command names, option names (keywords), macro
vs procedure (probably both), handling Unix's byte vs text ambiguity,
etc etc, but I'm comfortable with the basic concept.

               Running programs - Shell-like control of processes

   We define a new Scheme process type implemented using a class
   ProcessRunner , which extends Lazy<CharSequence>.

   The basic Scheme function is something like:

 (run keywords... "command-name" "command-options" ...)

   This evaluates to a ProcessRunner result.

   When output is "displayed" (as in the REPL) it is automatically forced,
   and so the command's standard output is copied to the REPL's output.

    Output to variable

 (define x (run ...))
 (define x ::string (run ...)) ;; forced

    Input from string

   An expression following the keyword parameter in: is evaluated to a 
string
   and connected to the standard input of the process:

 (run in: "abc" "tr" "a-z" "A-Z") --> "ABC"

    Pipe

 (run in: (run "command1") "command2")

    path-chars and path-bytes

 (path-chars (filepath "/tmp/xxx"))

   path-chars returns the contents of the path as a lazy[string].
   path-bytes returns the contents of the path as a lazy[bytes].

    Input redirection from file

 (run in-file: "filename" "command")

   is equivalent to:

 (run in: (path-bytes (filepath "filename")) "command")

    exit code

   Waits for the process to exit, and returns the exit code.

 (process-wait (run ...))

    Using shell

 (run shell: #t "ls -l")

   In general (on Unix):

 (run shell: #t keywords... "command-name" "command-options" ...)

   is equivalent to:

 (run keywords... "/bin/sh" "-c" "command-name" "command-options" ...)

   Other options xs(See Python's subprocess.)

   bufsize: size controls buffering.

   executeable: filename

   preexec_fn: procedure Call procedure in the child process just 
before the
   child is executed. (Unix only.)

   close_fds: #f causes all file descriptors except 0, 1 and 2 to be closed
   before the child process is executed. (Unix only). Or, on Windows, if
   close_fds is true then no handles will be inherited by the child 
process.
   Note that on Windows, you cannot set close_fds to true and also redirect
   the standard handles by setting stdin, stdout or stderr.

   cwd: path-or-string the child's current directory will be changed to cwd
   before it is executed. Note that this directory is not considered when
   searching the executable, so you can’t specify the program's path 
relative
   to cwd.

   env: env-map A mapping that defines the environment variables for 
the new
   process; these are used instead of inheriting the current process
   environment, which is the default behavior.

Questions

    Encoding: bytes vs chars

    Should run be a syntax or function?

   Should "command-name" "command-options" be self-quoting symbols or
   strings?
   E.g. (run /bin/ls -l) or (run "/bin/ls" "-l") ?
   Perhaps both forms (with different names)?
   Perhaps (run /bin/ls ,@(get-ls-options))

    Which keyword options?

  References

   [1]Python subprocess

References

   Visible links
   1. http://docs.python.org/library/subprocess.html
--
	--Per Bothner
per@bothner.com   http://per.bothner.com/