(defun maproc-impl (cmd-lambda put-expr get-expr)
  (tree-bind (pipe-rd . pipe-wr) (pipe)
    (with-stream (cmd-stdout (open-fileno pipe-wr "w"))
      (with-stream (cmd-out (open-fileno pipe-rd "r"))
        (match-case (fork)
          (0 (close-stream cmd-out)
             (with-stream (cmd-in (let ((*stdout* cmd-stdout))
                                    [cmd-lambda]))
               [put-expr cmd-in])
             (exit* 0))
          (nil (error "fork failed"))
          (@pid (close-stream cmd-stdout)
                (let ((out [get-expr cmd-out]))
                  (wait pid)
                  out)))))))

(defun map-command-lines (command lines)
  (maproc-impl (lambda () (open-command command "w"))
               (lambda (strm) (put-lines lines strm))
               (lambda (strm) (let ((lines (get-lines strm)))
                                (prog1 lines (len lines))))))

(defun map-command-str (command str)
  (maproc-impl (lambda () (open-command command "w"))
               (lambda (strm) (put-string str strm))
               (lambda (strm) (get-string strm))))

(defun map-process-lines (program args lines)
  (maproc-impl (lambda () (open-process program "w" args))
               (lambda (strm) (put-lines lines strm))
               (lambda (strm) (let ((lines (get-lines strm)))
                                (prog1 lines (len lines))))))

(defun map-process-str (program args str)
  (maproc-impl (lambda () (open-process program "w" args))
               (lambda (strm) (put-string str strm))
               (lambda (strm) (get-string strm))))

(prinl (map-command-lines "tr '[a-z]' '[A-Z]'" '#"a b c"))
(prinl (map-process-lines "tr" '#"[a-z] [A-Z]" '#"a b c"))
(prinl (map-command-str "tr '[a-z]' '[A-Z]'" "abc"))
(prinl (map-process-str "tr" '#"[a-z] [A-Z]" "abc"))