unshift

[Ray Andrews <rayandrews@xxxxxxxxxxx>]

    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.