how do I construct F!(T) to yield

void delegate() immutable

when T is void delegate()

?

[its been a long day]

On Friday, 6 December 2013 at 02:42:44 UTC, Ellery Newcomer wrote:
> how do I construct F!(T) to yield
>
> void delegate() immutable
>
> when T is void delegate()
>
> ?
>
> [its been a long day]

I don't think I understand what you mean:

void main() {
    F!(void delegate());
}

immutable(T) F(T)() {
    return () {};
}

Initially I thought you meant T was a void delegate but passing delegates as compile time parameters isn't really an option.

On 12/05/2013 09:33 PM, Jesse Phillips wrote:
>
> I don't think I understand what you mean:

this code illustrates it:

class Z {
    string a() immutable {
        return " 1";
    }
    string b() {
        return "2";
    }
}

template F(t) {
    alias immutable(t) F;
}
alias typeof(&Z.init.a) Texpected;
alias typeof(&Z.init.a) T;

static assert(is(F!(T) == Texpected));

void main() {}



above F doesn't work; immutable(void delegate()) and void delegate() immutable are different types (I think the latter means 'this' is immutable).
If t were a function pointer, you would apply the immutable to the pointer target like so:

alias immutable(pointerTarget!t)* F

On Saturday, 7 December 2013 at 01:18:06 UTC, Ellery Newcomer wrote:
> On 12/05/2013 09:33 PM, Jesse Phillips wrote:
>>
>> I don't think I understand what you mean:
>
> this code illustrates it:
>
> class Z {
>     string a() immutable {
>         return " 1";
>     }
>     string b() {
>         return "2";
>     }
> }
>
> template F(t) {
>     alias immutable(t) F;
> }
> alias typeof(&Z.init.a) Texpected;
> alias typeof(&Z.init.a) T;
>
> static assert(is(F!(T) == Texpected));
>
> void main() {}
>
>
>
> above F doesn't work; immutable(void delegate()) and void delegate() immutable are different types (I think the latter means 'this' is immutable).
> If t were a function pointer, you would apply the immutable to the pointer target like so:
>
> alias immutable(pointerTarget!t)* F

This declaration doesn't make sense to me:

    string a() immutable {
        return " 1";
    }

'a' is already immutable (unless you consider the vtable, at which point: final string a(); would be immutable).

The compiler spits out: static assert  (is(immutable(string delegate()) == string delegate() immutable)) is false

Which is strange because I don't see how immutability on 'a' means anything. And because of this I think your assertion is wrong:

    static assert(is(F!(T) == Texpected));

Is basically asking

    static assert(is(immutable(int) == int));

Which is not true, but this is (I've made modifications to your code):

class Z {
    string a() {
        return " 1";
    }
    string b() {
        return "2";
    }
}

template F(t) {
    alias immutable(t) F;
}
alias typeof(&Z.init.a) Texpected;
alias typeof(&Z.init.b) T;

static assert(is(immutable(int) : int)); // Implicitly converts to
static assert(is(int : immutable(int))); // Implicitly converts to
static assert(is(F!(T) : Texpected));    // Implicitly converts to
static assert(is(Texpected : F!(T) ));   // Implicitly converts to

void main() {}

On Saturday, 7 December 2013 at 19:36:50 UTC, Jesse Phillips wrote:
>
> This declaration doesn't make sense to me:
>
>     string a() immutable {
>         return " 1";
>     }

http://dlang.org/class.html#member-functions

On Saturday, 7 December 2013 at 23:02:18 UTC, Ellery Newcomer wrote:
> On Saturday, 7 December 2013 at 19:36:50 UTC, Jesse Phillips wrote:
>>
>> This declaration doesn't make sense to me:
>>
>>    string a() immutable {
>>        return " 1";
>>    }
>
> http://dlang.org/class.html#member-functions

That isn't really the type of a delegate though. Outside of a class that usage has no meaning or value. Even so, I don't actually understand what value it brings over declaring the function const (maybe only callable by an immutable instance?).

What is wrong with the current template which returns an immutable delegate type? It still store you're immutable member function.

class Z {
    string a() immutable {
        return " 1";
    }
}

template F(t) {
    alias immutable(t) F;
}
alias typeof(&Z.init.a) Texpected;
alias typeof(&Z.init.a) T;

static assert(is(F!(T) : Texpected));
static assert(is(Texpected : F!(T) ));

void main() {}

On Sunday, 8 December 2013 at 00:43:51 UTC, Jesse Phillips wrote:
>
> What is wrong with the current template which returns an immutable delegate type? It still store you're immutable member function.

It composes the wrong type. It composes a type that has different constness than the target type, which will likely cause problems due to transitive const.

Anyways, I'm trying to find a workaround to

https://d.puremagic.com/issues/show_bug.cgi?id=11694