Sigh, I just realised you need to have the stylesheet to see the documentation properly --- so here is a new version with the style sheet inlined. -- Daan. ----- Original Message ----- From: Daan Leijen To: Simon Marlow ; libraries@haskell.org Sent: Friday, May 09, 2003 12:45 PM Subject: Re: Subprocesses (was: [ANNOUNCE] shell-haskell 1.0.0) Hi all, I have implemented a generalised library for communicating with child processes some time ago for windows (but it is easy to implement for unix's too). I believe that the interface encompasses all current mechanism around (system, runProcess, popen, launch). Basically, it allows one to create pipes in Haskell that can be read and written just like normal file "Handle"s. Furthermore, you can start a child process that can get its stdin, stdout, and stderr redirected to one of those pipes. This "runProcess" call is basically the same to "Posix.runProcess". I have attached the documentation and description of the functions to this mail in HTML format. It also contains an example of a "spawn" function that closely resemebles the "launch" function of shell-haskell. I think that this interface is a good starting point for a discussion on the final library interface for sub-processes. All the best, Daan. ----- Original Message ----- From: "Simon Marlow" To: Sent: Friday, May 09, 2003 12:03 PM Subject: Subprocesses (was: [ANNOUNCE] shell-haskell 1.0.0)

Libraries people,

There are currently two ways to create and communicate with external processes:

- System.Cmd.system (very basic, doesn't give you access to the process's output but you can use shell primitives to redirect its input/output).

- Posix.runProcess (can specify Handles for the process's input/output, but it doesn't create pipes so you can't actually communicate with the subprocess using these Handles.).

- POpen.popen (can specify an input String, and gives you lazy output Strings. No interactive communication is possible.)

Ok, *three* ways. System.Cmd.system, Posix.runProcess, POpen.popen, and shell-haskell. Er. *Four* ways.

David Sankel's shell-haskell creates pipes for stdin/stdout/stderr, and lets you communicate interactively with the sub-process via Handles. It could do with a way to specify the environment and working directory of the sub-process (ala POpen and runProcess), but apart from that it seems to be the most flexible of the four. It could be simplified slightly by using one Handle rather than two for stdin/stdout.

We should think about what functionality we want to provide in the core libraries. My preference would be to go for a full version with three pipes (like shell-haskell) and perhaps one or two more specialised versions covering common cases (I don't know what these should be, though).

What do people think?

Cheers, Simon

-----Original Message----- From: haskell-admin@haskell.org [mailto:haskell-admin@haskell.org] On Behalf Of David Sankel Sent: 06 May 2003 03:06 To: haskell@haskell.org Subject: [ANNOUNCE] shell-haskell 1.0.0

=================== shell-haskell 1.0.0 ===================

shell-haskell provides utilities to communicate with other process's via Haskell code. This library can be used for something as simple as getting the output of another program or as complex as interacting with an interpreter.

see

http://www.electronconsulting.com/shell-haskell

for details.

David J. Sankel _______________________________________________ Haskell mailing list Haskell@haskell.org http://www.haskell.org/mailman/listinfo/haskell

_______________________________________________ Libraries mailing list Libraries@haskell.org http://www.haskell.org/mailman/listinfo/libraries

I was wondering what the state of the System.Process module described on http://haskell.org/hawiki/ExternalCommands is? I have tried to use the various POpen-like implementations out there, but _none_ of them works with the most current GHC. Is there any way to communicate with external programs at the moment? Posix-only would be suffice at the moment. Peter

Glynn Clements wrote:

...

I have tried to use the various POpen-like implementations out there, but _none_ of them works with the most current GHC. Is there any way to communicate with external programs at the moment? Posix-only would be suffice at the moment.

There's the DIY solution, i.e. a direct translation of how popen() is implemented in C, e.g.:

...

module Main where

import IO import System import System.Posix

main = do (rfd, wfd) <- createPipe pid <- forkProcess (proc rfd wfd) closeFd wfd hRead <- fdToHandle rfd str <- hGetContents hRead putStr str stat <- getProcessStatus True False pid case stat of (Just (Exited code)) -> exitWith code _ -> exitWith (ExitFailure 127) where proc rfd wfd = do closeFd rfd dupTo wfd stdOutput executeFile "/bin/ls" False ["-l"] Nothing

The above has been (briefly) tested with ghc 6.2.1.

I had forgotten about Simon's System.Process module (at the time of the announcement, I was still on GHC 5.04.2, so I couldn't test it). Here's a version of the above code which uses runProcess:

module Main where

import IO ( hGetContents , hClose ) import System ( exitWith ) import System.Process ( runProcess , waitForProcess ) import System.Posix ( createPipe , fdToHandle )

main = do (rfd, wfd) <- createPipe hRead <- fdToHandle rfd hWrite <- fdToHandle wfd handle <- runProcess "/bin/ls" ["-l"] Nothing Nothing (Just hWrite) Nothing hClose hWrite str <- hGetContents hRead putStr str code <- waitForProcess handle exitWith code

And another version which uses runInteractiveProcess:

module Main where

import IO ( hGetContents ) import System ( exitWith ) import System.Process ( runInteractiveProcess , waitForProcess )

main = do (_, hOut, _, handle) <- runInteractiveProcess "/bin/ls" ["-l"] Nothing str <- hGetContents hOut putStr str code <- waitForProcess handle exitWith code

This last one isn't quite the same as popen(), as it automatically associates each of the three standard descriptors with their own pipe, whereas popen() only redirects one of stdin or stdout, while the other one and stderr are inherited from the caller. -- Glynn Clements