class Known
{
         void* data; // external data by c api
         int type;  // 0 for int, 1 for string, etc. ..
}

How can I implement a method like this?

Known  known;  // <-- suppose known.type == 1;
string s  = known.value(); // <-- automatic

I just know how to do this:

string s = know.value!string();

On Tuesday, 17 July 2012 at 13:56:29 UTC, Andrea Fontana wrote:
> class Known
> {
>          void* data; // external data by c api
>          int type;  // 0 for int, 1 for string, etc. ..
> }
>
> How can I implement a method like this?
>
> Known  known;  // <-- suppose known.type == 1;
> string s  = known.value(); // <-- automatic
>
> I just know how to do this:
>
> string s = know.value!string();

You can't. You could do

string s;
known.value(s);

where

void value(T)(ref T t);

Andrea Fontana:

> class Known
> {
>          void* data; // external data by c api
>          int type;  // 0 for int, 1 for string, etc. ..
> }
>
> How can I implement a method like this?
>
> Known  known;  // <-- suppose known.type == 1;
> string s  = known.value(); // <-- automatic

To do this Known.value() needs to return different types according to the run-time value of Known.type. This is not possible in a statically typed language... You need to find other solutions.

Bye,
bearophile

Better than nothing :)
Hope in better template deduction...

Il giorno mar, 17/07/2012 alle 16.22 +0200, Tobias Pankrath ha scritto:

> On Tuesday, 17 July 2012 at 13:56:29 UTC, Andrea Fontana wrote:
> > class Known
> > {
> >          void* data; // external data by c api
> >          int type;  // 0 for int, 1 for string, etc. ..
> > }
> >
> > How can I implement a method like this?
> >
> > Known  known;  // <-- suppose known.type == 1;
> > string s  = known.value(); // <-- automatic
> >
> > I just know how to do this:
> >
> > string s = know.value!string();
> 
> You can't. You could do
> 
> string s;
> known.value(s);
> 
> where
> 
> void value(T)(ref T t);

i'm not completely sure i understand your problem but i think you are looking for something like this:

http://pocoproject.org/docs/Poco.DynamicAny.html

maybe the c++ source code could be of some inspiration. this should be possible in d, too.

> class Known
> {
>          void* data; // external data by c api
>          int type;  // 0 for int, 1 for string, etc. ..
> }
>
> How can I implement a method like this?
>
> Known  known;  // <-- suppose known.type == 1;
> string s  = known.value(); // <-- automatic
>
> I just know how to do this:
>
> string s = know.value!string();

As bearophile said, you cannot change a value's type (which is a compile-time construct) with a runtime value, as is Known.type.

Second point, in D, the rhs is fully evaluated before being assigned to the
lhs, I think. So, known.value() must evaluate to *something*, without
knowing it will be assigned to a string.
In your example, what happens if known.type != 1?

You can use Phobos Variant, (or Algebraic if the range of types you plan to use is known beforehand). Then, you should test typeid before using it.

Yes I did it using Variant and it works fine

Il giorno mer, 18/07/2012 alle 16.42 +0200, Philippe Sigaud ha scritto:

> > class Known
> > {
> >          void* data; // external data by c api
> >          int type;  // 0 for int, 1 for string, etc. ..
> > }
> >
> > How can I implement a method like this?
> >
> > Known  known;  // <-- suppose known.type == 1;
> > string s  = known.value(); // <-- automatic
> >
> > I just know how to do this:
> >
> > string s = know.value!string();
> 
> As bearophile said, you cannot change a value's type (which is a compile-time construct) with a runtime value, as is Known.type.
> 
> Second point, in D, the rhs is fully evaluated before being assigned
> to the lhs, I think. So, known.value() must evaluate to *something*,
> without knowing it will be assigned to a string.
> In your example, what happens if known.type != 1?
> 
> You can use Phobos Variant, (or Algebraic if the range of types you plan to use is known beforehand). Then, you should test typeid before using it.
> 

On Tue, 17 Jul 2012 15:23:05 +0100, bearophile <bearophileHUGS@lycos.com> wrote:

> Andrea Fontana:
>
>> class Known
>> {
>>          void* data; // external data by c api
>>          int type;  // 0 for int, 1 for string, etc. ..
>> }
>>
>> How can I implement a method like this?
>>
>> Known  known;  // <-- suppose known.type == 1;
>> string s  = known.value(); // <-- automatic
>
> To do this Known.value() needs to return different types according to the run-time value of Known.type. This is not possible in a statically typed language... You need to find other solutions.

Unless we had overload based on return type, right?

e.g.

class Known
{
  string value()
  {
    if (type != 1)
      throw..;
    return cast(string)data;
  }

  int value()
  {
    if (type != 0)
      throw ..;
    return cast(int)data;
  }
}

The compiler could produce the correct code/call for the line

string s = known.value();

then, but it's not a feature we're likely to see any time soon.

R

-- 
Using Opera's revolutionary email client: http://www.opera.com/mail/

Or template inference based on return type like

T hello(T)()
{
    static if (is(T ==)) ....

}

string v = hello();

Il giorno mer, 18/07/2012 alle 17.38 +0100, Regan Heath ha scritto:

> On Tue, 17 Jul 2012 15:23:05 +0100, bearophile <bearophileHUGS@lycos.com> wrote:
> 
> > Andrea Fontana:
> >
> >> class Known
> >> {
> >>          void* data; // external data by c api
> >>          int type;  // 0 for int, 1 for string, etc. ..
> >> }
> >>
> >> How can I implement a method like this?
> >>
> >> Known  known;  // <-- suppose known.type == 1;
> >> string s  = known.value(); // <-- automatic
> >
> > To do this Known.value() needs to return different types according to the run-time value of Known.type. This is not possible in a statically typed language... You need to find other solutions.
> 
> Unless we had overload based on return type, right?
> 
> e.g.
> 
> class Known
> {
>    string value()
>    {
>      if (type != 1)
>        throw..;
>      return cast(string)data;
>    }
> 
>    int value()
>    {
>      if (type != 0)
>        throw ..;
>      return cast(int)data;
>    }
> }
> 
> The compiler could produce the correct code/call for the line
> 
> string s = known.value();
> 
> then, but it's not a feature we're likely to see any time soon.
> 
> R
>