Infinite range of nullable elements

[Roland Hadinger via Digitalmars-d-learn]

At this moment I'm tempted to implement a function taking a range 
of elements E and returning an infinite range of Nullable!E.

With this function ("cushion" for a lack of better name) I could 
do:

    auto a = [0,1,2,3,4,5,6,7,8,9];

    foreach (e ; a.cushion.take(20))
        writeln(e); // exactly 20 elements

This would allow chaining together algorithms that need to look 
ahead in a range.

Here's how I would implement the basic behaviour (could be 
extended to also forward bidirectional and random access 
functions):

---
    auto cushion(R)(R r)
        if (isInputRange!R)
    {
        static if (isInfinite!R) { return r; } else {

            struct _Cushion(R)
            {
                R r;

                alias E = ElementType!R;
                alias NE = Nullable!E;

                @property bool empty() { return false; }

                @property NE front()
                {
                    return !r.empty ? NE(r.front) : NE();
                }

                void popFront()
                {
                    if (!r.empty) r.popFront();
                }
            }

            return _Cushion!R(r);
        }
    }

---

I didn't find anything like this Phobos. Did I miss something? Is 
this a bad idea for some reason?