Great to see your progress!
In my experience, recursive algorithms are really relatively easy to write and understand (i.e. compared to alternative solutions) once you get the principle.
If you're interested, here's an addition (I hope it's not too advanced 
)
There's just one issue with recursion: algorithms with branches (2+) tend to recalculate the same results over and over and over again (and again and again ...). If you try to make a seriously big list (like 9-tuples from a list A-Z: over 3 million items) the recursive processing is going to take way too much time.
You could then resort to memoization to speed up the process. See my explanation / demonstration below.
This is how long it takes (on my platform, in milliseconds; thx to @dardoro for the DURATION block!) to generate all combinations (not permutations) of 5 items from a list with letters A through Z (65,780 items):
I had my home-crafted fully-automatic functions memoizer (follow the above link) create a memoized version of the combinations generator:
Now this is how long (or actually: short) it takes for the memoized version to generate the same result:
If the number of items in each tuple increases, the processing time of the original generator (which is similar to your recursive version) explodes - I think it's in the order of (n!), approximately. By contrast, the memoized version will generate up to 9-tuples of the same list within reasonable time:
Since all results are kept, if you ask the memoized version of the generator to do the same thing again, all it has to do is look up the previous result.
Better not increase the tupleness (tupility?) beyond 9 (with a list of 26 items), or Snap! will crash because of memory overflow. 