Original code [was "Re: String expansion script"]

[blazar]

#!/usr/bin/perl -ln

use strict;
use warnings;

sub expand;
sub doit;

print for expand $_;

sub expand {
    local $_=shift;
    return doit $`, (split /:/, $1), $' if /\{([\w:]+)\}/;
    return doit $`, $1 .. $2 , $' if /\[(\w+):(\w+)\]/;
    $_;
}

sub doit {
    my ($pre,$post)=(shift,pop);
    map { my $pre=$pre . $_; 
        map $pre . $_, expand $post } @_;
}

__END__

Original description:

("specifications" have changed too)

This is another short program that for me is a complete application, and I hope that this time there's not a common utility to do the same...

Basically it expands strings of the form

foo[01:100]bar-{fred:barney:wilma}

to the list

foo01bar-fred
foo02bar-fred
...
foo100bar-fred
foo01bar-barney
...
foo100bar-wilma

More info here!

[ambrus]

I've just noticed your new (fixed) script. I like the new input syntax better than the old one. I also like this syntax: /dev/hd[a:d][,1:8], and broken ranges: [1:5,7:10].

Pity it still can't handle brackets embedded in each other, such as /dev/[hd[a:d][1:8],fd[0:1]], but that'd be difficult to implement properly.

(Also, this code prints a warning on empty input lines.

[blazar]

Of course it shouldn't be too hard with Text::Balanced. I would still be delighted to do it in one single regex. I'm not really sure if this is actually impossible, but for sure it's hard.

I'm puzzled by the possibility of doing it with a single regex and the help of a few pre- and post- transformations. I have a well definite idea of how to do that, but it won't be so easy either... first or later I suspect that my hubris will take over and eventually I'll do it!

Update: I'm not bothered by the fact that this has been downvoted, but I'd be very glad to know why it has... however to show with an example (of a somewhat related problem) what I meant with the above, I refer you to Re: Shuffling cards, but in that case the state of affairs is particularly simple because I can trust input strings which in turn are (guaranteed to be) particularly simple.