A Recurring Question

[w0rp via Digitalmars-d]

I recently found myself wanting an algorithm to apply f(x) 
repeatedly, generating an infinite sequence, for a variety of 
reasons. One of those reasons is to generate ancestor 
directories. Typically when I desire such a thing, I find myself 
trying to find the existing algorithm which does this already. I 
eventually realised that recurrence is exactly what I need, if I 
just simplify it a little for this case.


import std.range;
import std.algorithm;
import std.path;
import std.file;
import std.stdio;

auto unaryRecurrence(alias func, T)(T initialValue) {
     return recurrence!((values, index) => 
func(values[0]))(initialValue);
}

void main() {
     // Print all directories from this one up to and including /.
     getcwd()
     .unaryRecurrence!dirName
     .until("/", OpenRight.no)
     .each!writeln;
}


This is kind of neat. My question is, should something like this 
function be included in std.range? Either way, it turned into an 
example of something cool you can do with D.

While I was at it, I noticed that we could also consider a second 
form of recurrence which permits functions which accept a single 
argument, with only the Cycle. In that case, the range behind the 
recurrence could be potentially optimised to only hold the 
values, and forget about the index. It wouldn't be too far off 
from how foreach works. Then my function above would have had 
this lambda instead:

x => func(x[0])