On Wednesday, 20 June 2018 at 12:08:28 UTC, Jonathan M Davis
wrote:
On Wednesday, June 20, 2018 11:43:52 DigitalDesigns via
Digitalmars-d wrote:
alias f = void delegate();
Tuple!(f)[] fs;
fs ~= tuple(() { });
fails but
fs ~= Tuple!(f)(() { });
passes.
in tuple, it is seeing the lambda as void and thinks I'm trying
to append a tuple of void. I don't see why the compiler can't
see
that it works.
The types don't match.
---
import std.typecons;
alias f = void delegate();
void main()
{
pragma(msg, typeof(tuple((){})));
pragma(msg, typeof(Tuple!f((){})));
}
---
prints
Tuple!(void function() pure nothrow @nogc @safe)
Tuple!(void delegate())
tuple is instantiated and evaluated independently of what's
done with the result, so the fact that you're then appending it
to a Tuple!f[] is irrelevant. By the point it tries to append,
it's already determined the type of what it's trying to append,
and because you didn't specify the type, it's what it gets
inferred as, which is not the same type as you have in the
array.
- Jonathan M Davis
But here's the kicker!!! Trust me, it will be good!!
They are the same types! That alone says that the compiler is not
doing enough work! I mean, it is well established that the array
is of type f and the lambda is of type f!!
See, what the compiler is not doing is realizing that a lambda
can be implicitly cast to any other lambda with the same
signature. If it understood that then it should have no problem
with casting the tuple implicitly.
Tuple!(void function() pure nothrow @nogc @safe)
Tuple!(void delegate())
a function can always be cast to a delegate(delegate is a super
type as it inherits function in type logic) and the lambda may be
a function or delegate depending on context. Hence the compiler
can always assume an implicit cast of functions to delegates when
type checking on tuple.
This seems to be the missing logic either in the compiler or
possibly with tuple. If tuple could support an implicit cast or
simply upcast all functions to delegates then the code would
work...
but it seems tuple does no upcasting.
Tuple!(double)[] f;
f ~= tuple(3); // change 3 to 3.3 and it works fine!
has the same problem. We know int inherits from double(it is a
sub-type in the class of types).
This is the same problem as general implicit casting which D can
do.
Just seems that it fails for tuples because it does not apply the
implicit casts per argument.
It's easy to see that if one has n types in a tuple then it can
be implicitly converted if all the types are implicitly converted.
Conv(T(a1,...,an)) = T(Conv(a1),...,Conv(an))
