Can we unshift the positional params?  I have a complex function that 
has shifts throughout and at one point there's a while loop:

shift
while [ "$1" ]; do
     if [ a ]; then b; c  fi
     if [ d ]; then e; f  fi
     if [ g ]; then h; i  fi
...
shift
done

... works fine, but I'm thinking to restructure it:

shift
while [ "$1" ]; do
     if [ a ]; then b; c; continue fi
     if [ d ]; then e; f; continue fi
     if [ g ]; then h; i; continue fi
...
shift
done

... because only one 'if' test will be relevant per loop and the 
remaining 'if' tests might even do some bad stuff.  The problem of 
course is that if I 'continue', the final 'shift' is missed.  I could do 
this:

# shift
while [ "$2" ]; do
     shift
     if [ a ]; then b; c; continue fi
     if [ d ]; then e; f; continue fi
     if [ g ]; then h; i; continue fi
...
# shift
done

... except that the leading (commented) 'shift' might happen in any 
number of places and changing them all would be troublesome.  It can be 
done of course, but I'm wondering if we have some way of  faking this:

shift
unshift
while [ "$1" ]; do
     shift
     if [ a ]; then b; c; continue fi
     if [ d ]; then e; f; continue fi
     if [ g ]; then h; i; continue fi
...
# shift
done

... it looks pointless above, however note that the leading 'shift' 
might in fact have happened in any one of several different places all 
of which would need to be reworked and it's fragile, so the 'unshift' 
would take care of it in one place, at least temporarily.  I know we 
don't have an official unshift, but can it be faked?  Of course there's 
also this:

     ...
     if [ a ]; then b; c; shift; continue fi
     ...

... but I'm wondering about a more succinct logic.  The quick and dirty 
'unshift' idea would solve a temporary problem very nicely.