Command line trick: track progress with `set -`

tl;dr: "$@" can be assigned to a list of items to process manually,
so $1 is the next one to process, and `shift` is invoked when we are
done with it.

In POSIX shell, variable types are pretty much restricted to scalar
strings.  It is of course possible to set a variable with the
concatenation of ${IFS}-separated strings, but it is usually a poor
replacement of a proper array.

Unless relying on some interpreter that does implement arrays as an
extension (e.g. bash), the only 'real' array is the "$@", the argument
vector.  Items can be accessed as $1, $2, ...etc,  it can be shifted
with the `shift` operator.  I think not everybody knows it is possible
to assign it like this:

.	$ set - arg1 arg2 ...

I believe it is not common to assign "$@".  For sure I never seen it
done in the wild, nor I felt the urge of doing it myself.  This until
a few days ago, when I was moving all phlog entries from my old phlog
(gopher://tilde.institute/1/~dacav) to here.

The migration was accomplished by processing each entry with a little
conversion script that I wrote for the purpose.  Given the small number
of entries I had to process, I decided to keep it simple, and make
up for its lack of generality by manually verifying and fixing each
converted entry.

Basically, I had to manually loop over entries, but I was easily
distracted by the manual verification I was doing at each step.
That's when I figured that I could an array to track my progress: the
"$@" of the interactive interpreter!

In short, my workflow became the following:

.	$ set - ./to-import/*
.	$ more $1               # view and decide if the entry should be kept
.	$ ./process-entry $1    # if we want to keep it, process it.  Then
.	$                       # verify the result and possibly fix it.
.	$ shift || echo done.	# proceed to the next entry...
.	$ more $1               # view and decide if the entry should be kept
.	$ ./process-entry $1

This is a quite generic trick, and I started using it each time I've
got a collection of objects to handle.