On Monday, 23 July 2018 at 18:39:59 UTC, aliak wrote:
Hi,

I'm playing around with an Optional wrapper type. It stores a type T and a bool that defines whether a value is defined or not:

struct Optional(T) {
  T value;
  bool defined = false;
  this(U : T)(auto ref inout(U) value) inout {
    this.value = value;
    this.defined = true;
  }
}

To facilitate it's use I have two type constructors:

inout(Optional!T) some(T)(auto ref inout(T) value) {
    return inout(Optional!T)(value);
}

Optional!T no(T)() {
    return Optional!T();
}

The above produces a problem when working with strings. Basically the type information gets slightly altered so you can't do this:

auto a = [no!string, some("hello")];

You get a type mismatch:

* no!string = Optional!string
* some("hello") = immutable(Optional!(char[]))

I've created a short code gist, so basically I'm wondering how to get it to compile without changing what's in main()

https://run.dlang.io/is/BreNdZ

I guess I can specialize on string type T, but this is a more general problem that can be shown with:

struct S {}
alias Thing = immutable S;
Thing thing = S();

auto x = some(thing);
auto y = no!Thing;
auto arr = [x, y]; // no can do buddy

Cheers,
- Ali


I'm not being very helpful here, just throwing in more questions again:

Why does this fail while it works when replacing T with U in struct W(T)?? It's so odd. Both T and U seem to resolve to "string".

    struct W(T) {
        const T value;
        // Replacing `T value` with `U value` compiles
        this(U : T)(auto ref const T value) {
            pragma(msg, T); // string
            pragma(msg, U); // string
            this.value = value;
        }
    }

    auto defined(T)(auto ref const T value) {
        return W!T(value);
    }

    void main() {
        auto a = defined("hello");
    }

Is this a bug?

Reply via email to