Thread overview | |||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
|
February 17, 2012 Let this() figure out T implicitly? | ||||
---|---|---|---|---|
| ||||
Hi! This doesn't work: import std.stdio; class Foo(T) { T t; this(T val) { t = val; } } void main() { auto o = new Foo(5); } _____ $ dmd foo foo.d(13): Error: class foo.Foo(T) is used as a type $ _ So I must auto o = new Foo!(int)(5); Then it compiles. Is it possible to have this() figure out the type some way? (In this particular example it's perhaps not such a big deal. But imagine a lot more args.) (Side note: What _does_ that error message mean? I don't get it.) thanks /krbrn |
February 17, 2012 Re: Let this() figure out T implicitly? | ||||
---|---|---|---|---|
| ||||
Posted in reply to kraybourne | kraybourne: > Then it compiles. Is it possible to have this() figure out the type some way? Usually people write a small global function helper. > (Side note: What _does_ that error message mean? I don't get it.) I think the meaning is: when a class template is not yet instantiated, it's not a type yet. Bye, bearophile |
February 17, 2012 Re: Let this() figure out T implicitly? | ||||
---|---|---|---|---|
| ||||
Posted in reply to kraybourne Attachments:
| The error message is saying that you are trying to use Foo as a type but
Foo is not a type, it is a template for a type.
On Feb 17, 2012 7:20 AM, "kraybourne" <stdin@kraybourne.com> wrote:
> Hi!
>
> This doesn't work:
>
> import std.stdio;
> class Foo(T)
> {
> T t;
> this(T val)
> {
> t = val;
> }
> }
>
> void main()
> {
> auto o = new Foo(5);
> }
> _____
>
> $ dmd foo
> foo.d(13): Error: class foo.Foo(T) is used as a type
> $ _
>
> So I must
>
> auto o = new Foo!(int)(5);
>
> Then it compiles. Is it possible to have this() figure out the type some
> way? (In this particular example it's perhaps not such a big deal. But
> imagine a lot more args.)
>
> (Side note: What _does_ that error message mean? I don't get it.)
>
> thanks
> /krbrn
>
|
February 17, 2012 Re: Let this() figure out T implicitly? | ||||
---|---|---|---|---|
| ||||
Posted in reply to bearophile | On 2/17/12 1:32 PM, bearophile wrote: > kraybourne: > >> Then it compiles. Is it possible to have this() figure out the type some >> way? > > Usually people write a small global function helper. Hm, so, something like this: Foo!(T) newFoo(T)(T val) { return new Foo!(T)(val); } ... auto o = newFoo(5); Works! Ha! How silly. Thanks! > > >> (Side note: What _does_ that error message mean? I don't get it.) > > I think the meaning is: when a class template is not yet instantiated, it's not a type yet. > > Bye, > bearophile |
February 17, 2012 Re: Let this() figure out T implicitly? | ||||
---|---|---|---|---|
| ||||
Posted in reply to Kevin Cox | On 2/17/12 1:51 PM, Kevin Cox wrote: > The error message is saying that you are trying to use Foo as a type but > Foo is not a type, it is a template for a type. > Ah, so module.Foo is really not a class, but a template? I think I get it! Thanks! (Is then module.Foo(int).Foo the actual class type? I think I've seen errors like that pop up...) > On Feb 17, 2012 7:20 AM, "kraybourne" <stdin@kraybourne.com > <mailto:stdin@kraybourne.com>> wrote: > > Hi! > > This doesn't work: > > import std.stdio; > class Foo(T) > { > T t; > this(T val) > { > t = val; > } > } > > void main() > { > auto o = new Foo(5); > } > _____ > > $ dmd foo > foo.d(13): Error: class foo.Foo(T) is used as a type > $ _ > > So I must > > auto o = new Foo!(int)(5); > > Then it compiles. Is it possible to have this() figure out the type > some way? (In this particular example it's perhaps not such a big > deal. But imagine a lot more args.) > > (Side note: What _does_ that error message mean? I don't get it.) > > thanks > /krbrn > |
February 17, 2012 Re: Let this() figure out T implicitly? | ||||
---|---|---|---|---|
| ||||
Posted in reply to kraybourne Attachments:
| Yes. At least as the compiler would say. It's a little odd but I believe
that is how the D Nam mangling works. I personally just think of
Foo!(Class) as the type.
On Feb 17, 2012 8:05 AM, "kraybourne" <stdin@kraybourne.com> wrote:
> On 2/17/12 1:51 PM, Kevin Cox wrote:
>
>> The error message is saying that you are trying to use Foo as a type but Foo is not a type, it is a template for a type.
>>
>>
> Ah, so module.Foo is really not a class, but a template? I think I get it! Thanks!
>
> (Is then module.Foo(int).Foo the actual class type? I think I've seen
> errors like that pop up...)
>
>
> On Feb 17, 2012 7:20 AM, "kraybourne" <stdin@kraybourne.com
>> <mailto:stdin@kraybourne.com>> wrote:
>>
>> Hi!
>>
>> This doesn't work:
>>
>> import std.stdio;
>> class Foo(T)
>> {
>> T t;
>> this(T val)
>> {
>> t = val;
>> }
>> }
>>
>> void main()
>> {
>> auto o = new Foo(5);
>> }
>> _____
>>
>> $ dmd foo
>> foo.d(13): Error: class foo.Foo(T) is used as a type
>> $ _
>>
>> So I must
>>
>> auto o = new Foo!(int)(5);
>>
>> Then it compiles. Is it possible to have this() figure out the type
>> some way? (In this particular example it's perhaps not such a big
>> deal. But imagine a lot more args.)
>>
>> (Side note: What _does_ that error message mean? I don't get it.)
>>
>> thanks
>> /krbrn
>>
>>
>
|
February 17, 2012 Re: Let this() figure out T implicitly? | ||||
---|---|---|---|---|
| ||||
Posted in reply to Kevin Cox | On 02/17/2012 02:07 PM, Kevin Cox wrote: > Yes. At least as the compiler would say. It's a little odd but I > believe that is how the D Nam mangling works. I personally just think > of Foo!(Class) as the type. > class Foo(T){ ... } Is syntactic sugar for template Foo(T){ class Foo{ ... } } Therefore the type is Foo!(Class).Foo. I'd prefer the compiler to output Foo!(Class) in error messages and for .stringof though, vote here: http://d.puremagic.com/issues/show_bug.cgi?id=7064 |
February 17, 2012 Re: Let this() figure out T implicitly? | ||||
---|---|---|---|---|
| ||||
Posted in reply to Timon Gehr | On 2/17/12 2:38 PM, Timon Gehr wrote: > On 02/17/2012 02:07 PM, Kevin Cox wrote: >> Yes. At least as the compiler would say. It's a little odd but I >> believe that is how the D Nam mangling works. I personally just think >> of Foo!(Class) as the type. >> > > class Foo(T){ ... } > > Is syntactic sugar for > > template Foo(T){ > class Foo{ ... } > } > > Therefore the type is Foo!(Class).Foo. Aaah, I see, clever, thx > I'd prefer the compiler to output > Foo!(Class) in error messages and for .stringof though, vote here: > > http://d.puremagic.com/issues/show_bug.cgi?id=7064 |
February 17, 2012 Re: Let this() figure out T implicitly? | ||||
---|---|---|---|---|
| ||||
Posted in reply to kraybourne | On Fri, 17 Feb 2012 07:19:28 -0500, kraybourne <stdin@kraybourne.com> wrote: > Hi! > > This doesn't work: > > import std.stdio; > class Foo(T) > { > T t; > this(T val) > { > t = val; > } > } > > void main() > { > auto o = new Foo(5); > } > _____ > > $ dmd foo > foo.d(13): Error: class foo.Foo(T) is used as a type > $ _ > > So I must > > auto o = new Foo!(int)(5); > > Then it compiles. Is it possible to have this() figure out the type some way? (In this particular example it's perhaps not such a big deal. But imagine a lot more args.) What you are asking for is IFTI (Implicit Function Template Instantiation) on constructors, and is perfectly possible, but not implemented: http://d.puremagic.com/issues/show_bug.cgi?id=6082 Vote up if you want to see it happen! -Steve |
February 17, 2012 Re: Let this() figure out T implicitly? | ||||
---|---|---|---|---|
| ||||
Posted in reply to Steven Schveighoffer | On 02/17/2012 09:08 AM, Steven Schveighoffer wrote: > What you are asking for is IFTI (Implicit Function Template > Instantiation) on constructors, and is perfectly possible, but not > implemented: > > http://d.puremagic.com/issues/show_bug.cgi?id=6082 What was the resolution for the case when the constructor is a template? I think that's why IFTI doesn't work for structs and classes in C++. Although, I can't get the following to compile in D anyway (that old and annoying error message again! :p): Error: no property 'opCall' for type 'deneme.B' import std.conv; class B { string s; this(T)(T t) // <-- Is the struct a template // or the constructor a template? { s = to!string(t); } } void main() { auto b0 = B(42); } I wasn't around when the static opCall() was designed but it is probably the very first thing that bugged me about D. :) I want B(42) to be object construction, not opCall(), which is not even defined. Ali |
Copyright © 1999-2021 by the D Language Foundation