According to Wikipedia:
http://en.wikipedia.org/wiki/C%2B%2B14#Function_return_type_deduction

C++14 is able to compile code like this:


auto correct(int i) {
    if (i == 1)
        return i;
    else
        return correct(i - 1) + i;
}


But not like this:

auto correct(int i) {
    if (i != 1)
        return correct(i - 1) + i;
    else
        return i;
}


D isn't able to compile both. Is it a good idea to allow the first function in D too?

Bye,
bearophile

On Wed, 14 Jan 2015 22:29:08 +0000
bearophile via Digitalmars-d <digitalmars-d@puremagic.com> wrote:

> According to Wikipedia: http://en.wikipedia.org/wiki/C%2B%2B14#Function_return_type_deduction
> 
> C++14 is able to compile code like this:
> 
> 
> auto correct(int i) {
>      if (i == 1)
>          return i;
>      else
>          return correct(i - 1) + i;
> }
> 
> 
> But not like this:
> 
> auto correct(int i) {
>      if (i != 1)
>          return correct(i - 1) + i;
>      else
>          return i;
> }
> 
> 
> D isn't able to compile both. Is it a good idea to allow the first function in D too?
> 
> Bye,
> bearophile
i'm pretty sure that D *SHOULD* compile the first sample. the spec says that return type for `auto` function is taken from the first `return` operator parser met. so for the second `return` the return type is already known.

i think that this is not just "let it compile", but a bug in compiler. something should be fixed: either compiler or specs.

ketmar:

> the spec says that return type for `auto` function is taken
> from the first `return` operator parser met. so for the
> second `return` the return type is already known.

Do you mean the C++14 spec or the D spec?

The D specs I see are (from: http://dlang.org/function.html ):


> Auto Functions
> 
> Auto functions have their return type inferred from any
> ReturnStatements in the function body.
> 
> An auto function is declared without a return type. If it does not
> already have a storage class, use the auto storage class.
> 
> If there are multiple ReturnStatements, the types of them must be
> implicitly convertible to a common type. If there are no
> ReturnStatements, the return type is inferred to be void.

Bye,
bearophile

On Wed, 14 Jan 2015 23:07:57 +0000
bearophile via Digitalmars-d <digitalmars-d@puremagic.com> wrote:

> ketmar:
> 
> > the spec says that return type for `auto` function is taken from the first `return` operator parser met. so for the second `return` the return type is already known.
> 
> Do you mean the C++14 spec or the D spec?
D spec. i'm not really interested in C++ progress, and certainly not that much that i'll read any of it's specs.

> The D specs I see are (from: http://dlang.org/function.html ):
> 
> 
> > Auto Functions
> > 
> > Auto functions have their return type inferred from any ReturnStatements in the function body.
> > 
> > An auto function is declared without a return type. If it does
> > not
> > already have a storage class, use the auto storage class.
> > 
> > If there are multiple ReturnStatements, the types of them must
> > be
> > implicitly convertible to a common type. If there are no
> > ReturnStatements, the return type is inferred to be void.
i bet that i read somewhere in specs that return type for `auto` function is defined by first `return` parser sees. yet strangely i can't find it right now. maybe that was changed recently, but i'm almost sure that this is not false memory of mine.

On Wednesday, 14 January 2015 at 22:37:22 UTC, ketmar via Digitalmars-d wrote:
> On Wed, 14 Jan 2015 22:29:08 +0000
> bearophile via Digitalmars-d <digitalmars-d@puremagic.com> wrote:
>
>> According to Wikipedia:
>> http://en.wikipedia.org/wiki/C%2B%2B14#Function_return_type_deduction
>> 
>> C++14 is able to compile code like this:
>> 
>> 
>> auto correct(int i) {
>>      if (i == 1)
>>          return i;
>>      else
>>          return correct(i - 1) + i;
>> }
>> 
>> 
>> But not like this:
>> 
>> auto correct(int i) {
>>      if (i != 1)
>>          return correct(i - 1) + i;
>>      else
>>          return i;
>> }
>> 
>> 
>> D isn't able to compile both. Is it a good idea to allow the first function in D too?
>> 
>> Bye,
>> bearophile
> i'm pretty sure that D *SHOULD* compile the first sample. the spec says
> that return type for `auto` function is taken from the first `return`
> operator parser met. so for the second `return` the return type is
> already known.
>
> i think that this is not just "let it compile", but a bug in compiler.
> something should be fixed: either compiler or specs.

Well, the error the compiler prints is:

Error: forward reference to inferred return type of function call 'correct'

I played with it a bit and it seems to deduce a common type from all the return statements, which would be more in the style of D anyways (take type deduction for arrays). For example, the following code prints "float" rather than "int":

    import std.stdio;

    auto one(int i)
    {
        if(i > 0)
            return cast(int)i;
        else
            return cast(float)i;
    }

    void main()
    {
        writeln(typeid(typeof(one(10))));
    }

Xinok:

> I played with it a bit and it seems to deduce a common type from all the return statements,

Right, this works according to the D specs (but this is different from the feature I have suggested in the original post).

Bye,
bearophile

On Wednesday, 14 January 2015 at 22:29:09 UTC, bearophile wrote:
> According to Wikipedia:
> http://en.wikipedia.org/wiki/C%2B%2B14#Function_return_type_deduction
>
> C++14 is able to compile code like this:
>
>
> auto correct(int i) {
>     if (i == 1)
>         return i;
>     else
>         return correct(i - 1) + i;
> }
> ...

According to the wiki link:

"If multiple return expressions are used in the function's
implementation, then they must all deduce the same type."

So this will NOT work:

auto Correct(int i) {
     if (i == 1){
         return (int)5;
     }else{
         return (float)10;
     }
}

Error:

prog.cpp: In function 'auto Correct(int)':
prog.cpp:8:19: error: inconsistent deduction for 'auto': 'int'
and then 'float'
      return (float)10;
                    ^

So could you please tell me a good use case to for using "return
type deduction"?

Matheus.

Xinok:

>     auto one(int i)
>     {
>         if(i > 0)
>             return cast(int)i;
>         else
>             return cast(float)i;
>     }

With recent D2 compilers I suggest you to get used to write code like that like this:


    auto one(int i)
    {
        if(i > 0)
            return int(i);
        else
            return float(i);
    }

It's better to minimize the usage of cast().

Bye,
bearophile

On Thu, 15 Jan 2015 00:05:30 +0000
Xinok via Digitalmars-d <digitalmars-d@puremagic.com> wrote:

> Well, the error the compiler prints is:
> 
> Error: forward reference to inferred return type of function call 'correct'
> 
> I played with it a bit and it seems to deduce a common type from all the return statements, which would be more in the style of D anyways (take type deduction for arrays). For example, the following code prints "float" rather than "int":
> 
>      import std.stdio;
> 
>      auto one(int i)
>      {
>          if(i > 0)
>              return cast(int)i;
>          else
>              return cast(float)i;
>      }
> 
>      void main()
>      {
>          writeln(typeid(typeof(one(10))));
>      }
i remember that there was some discussion about this, but it's all i can remember about it. ;-)

there were some inconsistencies with deducing return type, AFAIR, but i don't remember if it leads to some fixes or not. if ony i wasn't so lazy and take some notes...

On Thursday, 15 January 2015 at 00:13:38 UTC, MattCoder wrote:
> So could you please tell me a good use case to for using "return
> type deduction"?

Templates.