Jump to page: 1 2
Thread overview
Let this() figure out T implicitly?
Feb 17, 2012
kraybourne
Feb 17, 2012
bearophile
Feb 17, 2012
kraybourne
Feb 17, 2012
Kevin Cox
Feb 17, 2012
kraybourne
Feb 17, 2012
Kevin Cox
Feb 17, 2012
Timon Gehr
Feb 17, 2012
kraybourne
Feb 17, 2012
Ali Çehreli
Feb 18, 2012
Timon Gehr
Feb 18, 2012
Ali Çehreli
Feb 18, 2012
Timon Gehr
February 17, 2012
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
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
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
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
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
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
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
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
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
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

« First   ‹ Prev
1 2