[Issue 4998] New: make IFTI use the template constraint when determining the type of literals
d-bugmail at puremagic.com
d-bugmail at puremagic.com
Wed Oct 6 04:25:52 PDT 2010
http://d.puremagic.com/issues/show_bug.cgi?id=4998
Summary: make IFTI use the template constraint when determining
the type of literals
Product: D
Version: D2
Platform: Other
OS/Version: Linux
Status: NEW
Severity: enhancement
Priority: P2
Component: DMD
AssignedTo: nobody at puremagic.com
ReportedBy: schveiguy at yahoo.com
--- Comment #0 from Steven Schveighoffer <schveiguy at yahoo.com> 2010-10-06 04:25:24 PDT ---
One of the annoyances of IFTI is that it interprets literals the same as auto
does. This means, you cannot wrap functions that you don't know the argument
types.
A simple example:
void foo(short s) {}
void foo2(T)(T t) {foo(t);}
void main()
{
foo(1); // ok
foo2(1); // fail
}
This becomes very important with operators and opDispatch, since you use IFTI
almost exclusively.
What we really need is a way to direct IFTI to use a specific function to look
up what a literal should be. Trying different types to build the function
might be difficult, it might require several passes over the code, and
conditional compilation based on type can make this very messy.
However, we have a perfect place to direct IFTI -- the template constraint. It
is evaluated before instantiation, so you have the right place to intercept it.
What I'm proposing is, when a IFTI is evaluating a function, it should not
assume a type for a literal until it evaluates the template constraint. If a
clause in the template constraint is of the form:
is(typeof(<some expression using T instance>))
Where T is automatically determined by IFTI from a literal, then the compiler
will try to use all possible types for the literal to find the most suitable
match. For instance, if the above code is written:
void foo2(T)(T t) if(is(typeof(foo(t)))) {foo(t);}
Then the compiler can appropriately instantiate foo2!short when called with
foo2(1). This might be tricky, but I think it will work.
As an alternative, we can add another "special" case for an is expression to
better define what we want. Something like:
void foo2(T, S...)(T t) if(is(foo(T) S == overload))
which says "If I was to call foo(t) where t is of type T (which could be a
tuple or multiple types), evaluate to true if it can be done, and assign the
parameter tuple that would be used to type S"
Wrapping/intercepting calls for a type is very difficult to get right without
this kind of thing, especially when you want to allow passing literals to a
function.
--
Configure issuemail: http://d.puremagic.com/issues/userprefs.cgi?tab=email
------- You are receiving this mail because: -------
More information about the Digitalmars-d-bugs
mailing list