On 09/01/2010 12:19 PM, Diego Martinelli wrote:
> Hi all!
> I'm digging the documentation of phobos but I am still learning D and I can't help
> myself.
> I feel like there's a lack of adapters between streams and ranges (something like
> istream_iterator/ostream_iterator in STL).

I've encountered a similar problem yesterday. It left me digging through the Phobos docs for an hour looking for an existing solution :-) Let's say I have a function (or any D expression,) and I want to turn consecutive calls to this function into range form. As an example, let's generate 10 random numbers between 30 and 50. My first attempt was something like this:

import std.range;
import std.random;

void main ()
{
        writeln(take(recurrence!("uniform(30, 50)")(), 10));
}

However, this doesn't work because recurrence refuses to take 0 arguments. Your post prompted me to steal some boilerplate code from the Phobos source and write this:

struct Rangeof(T)
{
    T delegate() _dg;
    T _buffer;
    bool _called = false;

    this(T delegate() dg) { _dg = dg; }
    @property bool empty() { return false; }
    void popFront()
    {
                if (!_called) {
                        _buffer = _dg();
                }
                _called = false;
    }
    @property ref T front()
    {
        if (!_called) {
                        _buffer = _dg();
                        _called = true;
                }
                return _buffer;
    }
}

auto rangeof(F)(F func) if (isCallable!F)
{
        return Rangeof!(ReturnType!(F))(func);
}

Rangeof!(T) rangeof(T)(lazy T exp) if (!isCallable!T)
{
        T callexp (){ return exp; }
        return rangeof(&callexp);
}

Now you can turn any expression or function into a proper input range, compatible with std.range stuff. Example:

writeln(take(rangeof(uniform(30, 50)), 10));

At the risk of overshooting my goal, here's an additional overload for std.range.take which can now also "take" from a function:

auto my_take(F)(F input, size_t n) if (!isInputRange!F && isCallable!F)
{
    return Take!(Rangeof!(ReturnType!(F)))(rangeof(input), n);
}

Which means one less step in usage:

writeln(my_take({ return uniform(30, 50); }, 10));


Oh, and I didn't test my code at all, apart from those examples. Feel free to use it if you like.

-Peter

Reply via email to