Re: A Recurring Question
On Monday, 18 April 2016 at 20:24:40 UTC, Jesse Phillips wrote:
On Sunday, 17 April 2016 at 15:23:50 UTC, w0rp wrote:
void main() {
// Print all directories from this one up to and including
/.
getcwd()
.unaryRecurrence!dirName
.until("/", OpenRight.no)
.each!writeln;
}
FYI, OS independent version:
void main() {
// Print all directories from this one up to and including
/.
getcwd()
.unaryRecurrence!dirName
.until(rootName(getcwd()), OpenRight.no)
.each!writeln;
}
Probably should also make a call to absolutePath.
Nice!
Re: A Recurring Question
On Monday, 18 April 2016 at 12:02:24 UTC, thedeemon wrote:
On Sunday, 17 April 2016 at 15:23:50 UTC, w0rp wrote:
auto unaryRecurrence(alias func, T)(T initialValue) {
return recurrence!((values, index) =>
func(values[0]))(initialValue);
}
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.
It really looks like "iterate" combinator from Haskell's
standard library:
iterate :: (a -> a) -> a -> [a] Source
iterate f x returns an infinite list of repeated applications
of f to x:
iterate f x == [x, f x, f (f x), ...]
http://hackage.haskell.org/package/base-4.8.2.0/docs/Prelude.html#v:iterate
(which could be a hint to stdlib-includability and naming)
If it's good enough for Haskell, maybe it's good enough for us.
"iterate" does sound like a decent name.
Re: A Recurring Question
On Sunday, 17 April 2016 at 15:23:50 UTC, w0rp wrote:
void main() {
// Print all directories from this one up to and including
/.
getcwd()
.unaryRecurrence!dirName
.until("/", OpenRight.no)
.each!writeln;
}
FYI, OS independent version:
void main() {
// Print all directories from this one up to and including /.
getcwd()
.unaryRecurrence!dirName
.until(rootName(getcwd()), OpenRight.no)
.each!writeln;
}
Probably should also make a call to absolutePath.
Re: A Recurring Question
On Sunday, 17 April 2016 at 15:23:50 UTC, w0rp wrote:
auto unaryRecurrence(alias func, T)(T initialValue) {
return recurrence!((values, index) =>
func(values[0]))(initialValue);
}
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.
It really looks like "iterate" combinator from Haskell's standard
library:
iterate :: (a -> a) -> a -> [a] Source
iterate f x returns an infinite list of repeated applications of
f to x:
iterate f x == [x, f x, f (f x), ...]
http://hackage.haskell.org/package/base-4.8.2.0/docs/Prelude.html#v:iterate
(which could be a hint to stdlib-includability and naming)
A Recurring Question
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])
