A command to output each line forward then backwards

Question

I'm looking for a "meta-command" xyz such that:

(echo "foo"; echo "bar") | xyz rev

will return:

foo oof
bar rab

I'd like to avoid temporary files, i.e. I'm looking for a solution neater than:

tempfile=$(mktemp)
cat > $tempfile
cat $tempfile | rev | paste $tempfile -

(And of course I want a general solution, for any command, not just rev, you can assume that the command outputs exactly one line for each input line.)

Zsh solution would be also acceptable.

Answer 1

There will be a lot of problems in most cases due to the way that stdio buffering works. A work around for linux might be to use the stdbuf program and run the command with coproc, so you can explicitly control the interleaving of the output.

The following assumes that the command will output one line after each line of input.

#!/bin/bash
coproc stdbuf -i0 -o0 "$@"
IFS=
while read -r in ; do
    printf "%s " "$in"
    printf "%s\n" "$in" >&${COPROC[1]}
    read -r out <&${COPROC[0]}
    printf "%s\n" "$out"
done

If a more general solution is needed as the OP only required each line of input to the program to eventually output one line rather than immediately, then a more complicated approach is needed. Create an event loop using read -t 0 to try and read from stdin and the co-process, if you have the same "line number" for both then output, otherwise store the line. To avoid using 100% of the cpu if in any round of the event loop neither was ready, then introduce a small delay before running the event loop again. There are additional complications if the process outputs partial lines, these need to be buffered.

If this more general solution is needed, I would write this using expect as it already has good support for handling pattern matching on multiple input streams. However this is not a bash/zsh solution.

Answer 2

A shell function. This will work in any shell that supports <<< here-strings, including zsh and bash.

xyz() { 
    while read line
    do 
        printf "%s " "$line"
        "$@" <<<"$line"
    done
}

---

$ (echo "foo"; echo "bar") | xyz rev
foo oof
bar rab

Answer 3

In this particular case, I'd use perl:

printf '%s\n' foo bar | perl -Mopen=locale -lpe '$_ .= " " . reverse$_'
foo oof
bar rab

Which you could extend to also work with grapheme clusters:

$ printf '%s\n' $'complique\u301' |
    perl -Mopen=locale -lpe '$_ .= " " . join "", reverse/\X/g'
compliqué éuqilpmoc

Or zsh:

while IFS= read -r line; do
  print -r -- $line ${(j::)${(s::Oa)line}}
done

Though I would avoid using while read loops to process text, even in zsh (even if in this particular case, it's not so bad as only builtin commands are used).

In the general case, using temp files is probably the best approach. With zsh, you can do it with:

(){paste -d ' ' $1 <(rev <$1)} =(print -l foo bar)

(where =(...) takes care of creating and cleaning up the temp file).

Replacing it with pipes and some form of teeing is a recipe for deadlock in the general case. See these similar questions for some approaches and details about the deadlock situations:

• Split an input for different command and combine the result
• tee + cat: use an output several times and then concatenate results

Answer 4

This is a gawk implementation of the co-process approach outlined by icarus and therefore subject to the same stdio buffering considerations, also see this

{ echo foo; echo bar; } |  gawk -vcmd=rev '
 BEGIN {c=sprintf("stdbuf -i0 -o0 \"%s\"", cmd)}
 {
  printf "%s ", $0
  print |& c; fflush()
  c |& getline
  print
 }'

foo oof
bar rab

Answer 5

Named pipes to the rescue!

xyz() {
  pipe="/tmp/$$pipe"
  mkfifo "$pipe"
  tee "$pipe" | "$@" | paste "$pipe" -
  rm "$pipe"
}

Results on your example command:

$ (echo "foo"; echo "bar") | xyz rev
foo oof
bar rab

The above function does exactly what you describe.