Bash – How to do multiple brace expansions without combinatorial explosion

bashbrace-expansioncommand line

I often use brace expansion on the command line, because it's handy.

Example

{foo,bar}

expands to:

foo bar

Multiple brace expansion also expand, e.g.:

{foo,bar}Q{foo,bar}

would expand to:

fooQfoo fooQbar barQfoo barQbar

This is expected behavior, where the brace expansions are used in order.

My Question

Now, I'd like the output of any brace expansion (or other short command line trick) to be:

fooQfoo barQbar

Note: I'm using bash 3.2

Best Answer

I couldn't figure out how to get this done using only curly braces. I don't see a way to achieve this either, so unless someone more clever than I can figure out a way I'd say it's not possible.

As an alternative

Sample Data

$ tree
.
|-- dir1
|   |-- file1
|   `-- file2
`-- dir2
    |-- file1
    `-- file2

Examples

$ seq 2 | xargs -i{} echo dir{}/file{}
dir1/file1
dir2/file2

This can be put into a command like this:

$ echo $(seq 2 | xargs -i{} echo dir{}/file{})
dir1/file1 dir2/file2

or this:

$ ls $(seq 2 | xargs -i{} echo dir{}/file{})
dir1/file1  dir2/file2

or this:

$ ls -l $(seq 2 | xargs -i{} echo dir{}/file{})
-rw-rw-r-- 1 saml saml 0 Sep  2 03:18 dir1/file1
-rw-rw-r-- 1 saml saml 0 Sep  2 03:31 dir2/file2

Why curly braces can't do this

If you look at your original example:

{foo,bar}Q{foo,bar}

The way this gets expanded is as follows:

fooQfoo fooQbar barQfoo barQbar

The mechanism that expanded this is called a Cartesian Product.

For example:

$ echo {A,B}{X,Y,Z}
AX AY AZ BX BY BZ

Or this:

$ echo {M,N}-{A,B}{X,Y,Z}
M-AX M-AY M-AZ M-BX M-BY M-BZ N-AX N-AY N-AZ N-BX N-BY N-BZ

There is no way to create a Cartesian Product that will result in:

fooQfoo barQbar

You're only option is to either resort to trickery such as this:

$ echo dir{1,2}/file{2,1}
dir1/file2 dir1/file1 dir2/file2 dir2/file1

And then put this into a Bash array:

$ a=(dir{1,2}/file{2,1})
$ echo ${a[@]:1:2}
dir1/file1 dir2/file2

The other option would be some "other method" such as the one I previously discussed above (using xargs) for example.

References

Cartesian Products in Bash

Related Solutions

Bash Command Line – Combining Multiple Process Substitutions

You could do:

eval paste '<(sort -n ../data/file-'{A,B,C}'.dat)'

Or to automate it as a function

sort_paste() {
  local n i cmd
  n=1 cmd=paste
  for i do
    cmd="$cmd <(sort -n -- \"\${$n}\")"
    n=$(($n + 1))
  done
  eval "$cmd"
}
sort_paste  ../data/file-{A,B,C}.dat

(in some ksh implementations, you need to replace local with typeset)

To adapt to any arbitrary command, (and to prove that eval can be safe when used properly), you could do:

xproc() {
  local n i cmd stage stage1 stage2 stage3
  cmd= xcmd= stage=1 n=1
  stage1='cmd="$cmd \"\${$n}\""'
  stage2='xcmd="$xcmd \"\${$n}\""'
  stage3='cmd="$cmd <($xcmd \"\${$n}\")"'
  for i do
    if [ -z "$i" ] && [ "$stage" -le 3 ]; then
      stage=$(($stage + 1))
    else
      eval 'eval "$stage'"$stage\""
    fi
    n=$(($n + 1))
  done
  eval "$cmd"
}

xproc paste '' sort -n -- '' ../data/file-{A,B,C}/dat

Bash – Undo tab expansion

You're giving the keystrokes, but not the readline bindings, this can explain differences in observed behaviour (try bind -p).

The only way I can think of to do exactly what you ask is to use a custom completion function that saves the buffer state, and a separate key binding which invokes a companion shell function to restore it.

In addition to @Mark Plotnick's excellent suggestion to use menu-complete, other readline/bash options are:

shell-backward-kill-word this removes a "shell word" which in the case of an expanded file or path will be the complete file or path name
backward-kill-word this removes a "readline word", which in the case of a file or path will be a file or directory name component, including the trailing /
undo which undoes each change atomically, but this almost certainly requires several attempts to fully remove a complete expansion, this is almost certainly the function you have bound to to ctrl-_ (bash default)
set-mark and kill-region are lesser used readline features, set-mark marks the current cursor position, and kill-region deletes from the mark to the cursor. This requires you to invoke set-mark (default meta-space) in advance so that you can later use kill-region to delete back to it (no default binding)
possible-completions (bound to meta-=) which lists the completions without modifying the command buffer

You could also write your own function to modify the input buffer, and bind it to a function (here's one I made earlier) but I don't see how that would be very much better than backward-kill-word in this case.

You can test bindings on the fly without using .inputrc using bash's bind command, e.g.:

bind "\C-o: backward-kill-word"
bind "\C-o: shell-backward-kill-word"

backward-kill-word is the best fit, default binding is metactrl-h. set-mark/kill-region would be better, but I can't think of a neat way to automate the use of this though.