Variables with scoped destruction in closures

[Nordlöw via Digitalmars-d-learn]

The following code


import std.algorithm.iteration : filter;
import std.algorithm.mutation : move;
import std.range : iota;

static private struct S
{
     import core.memory : GC;
     @disable this(this);

     this(int x)
     {
         _ptr = cast(typeof(_ptr))GC.malloc((*_ptr).sizeof);
         *_ptr = x;
     }

     ~this() { GC.free(_ptr); }  // scoped destruction

     @property auto ref value() @safe pure nothrow @nogc { return 
*_ptr; }
     alias value this;

     int* _ptr;
}

auto below1(size_t n,
             S s = S.init)
{
     // this could work, if the compiler could infer that
     // `s` can be implicitly converted to an r-value
     return 0.iota(n).filter!(_ => _ < s);
}

auto below2(size_t n,
             S s = S.init)
{
     // this should work, because `s` is an r-value
     return 0.iota(n).filter!(_ => _ < s.move());
}

unittest
{
     S s = S(42);
     s.value = 43;
     s.value = 42;
     assert(s.value == 42);

     // both these fail
     100.below1(s.move());
     100.below2(s.move());
}



fails to compile with DMD Git master with error message

t_scope.d(23,6): Error: variable t_scope.below.s has scoped 
destruction, cannot build closure

It illustrates one the simplest cases where a container-type 
cannot be used inside a lambda closure needed by D's great lazy 
ranges.

Can somebody explain why not even `below2` compiles eventhough 
`s.move()` is inferred to be an r-value?

Until this gets fixed in the compiler, is there something I can 
do in the mean-while to make it possible to use instances of `S` 
inside of range lambda closures?