Re: Is it possible to return mutable and const range from a single method?

[Ali Çehreli via Digitalmars-d-learn]

On 8/22/22 09:36, realhet wrote:

> It gives the protection I was needed but is it possible to make this
> prettier?
>      auto allParents(){
>        struct ParentRange{
>          A act;
>          @property bool empty() const{ return act is null; }
>          @property A front() { return act; }
>          void popFront(){ act = act.getParent; }
>        }
>        return ParentRange(getParent);
>      }
>
>      auto allParents()const {
>        struct ConstParentRange{
>          A act;
>          @property bool empty() const{ return act is null; }
>          @property const(A) front() inout { return act; }
>          void popFront(){ act = act.getParent; }
>        }
>        return ConstParentRange(cast()getParent);
>      }

In other words, is it possible to combine the double implementation 
above? The following looks at typeof(this) to pick the type. My test 
asserts seem to pass:

import std;

class A{
    inout(A) getParent() inout{ return null; }

    void nonConstMemberFunc() {}
    void constMemberFunc() const {}

    this(A p){
    }
}

class B : A{
    A parent;

    override inout(A) getParent() inout{ return parent; }

    struct ConstOrMutable(T) {
      // This alias is not strictly necessary; 'static if'
      // could define 'act' instead.
      static if (is (T == const)) {
        alias X = const(A);

      } else {
        alias X = A;
      }

      X act;
      @property auto empty() const { return act is null; }
      @property auto front() { return act; }
      void popFront() { act = act.getParent; }
    }

    auto allParents() inout {
      return ConstOrMutable!(typeof(this))(cast()getParent());
    }

    this(A p){
        super(p);
        parent = p;
    }
}

auto test(inout A a, void delegate(inout A) fun){
    auto p = a.getParent;
    fun(p);
}

void main()
{
    auto a = new A(null);
    auto b = new B(a);

    assert( __traits(compiles, b.constMemberFunc()));
    assert( __traits(compiles, b.nonConstMemberFunc()));

    const c = b;
    assert( __traits(compiles, c.constMemberFunc()));
    assert(!__traits(compiles, c.nonConstMemberFunc()));
}

Ali