I imagine this should work.  The factorial code is straight from the docs.

import std.stdio;

void main()
{
    writefln(factorial(2));
}

template factorial(int n)
{
  static if (n == 1)
    const factorial = 1;
  else
    const factorial = n * factorial!(n-1);
}

C:\code\d\src>dmd template_ex_1.d
template_ex_1.d(8): template template_ex_1.factorial(int n) is not a function template
template_ex_1.d(5): template template_ex_1.factorial(int n) cannot deduce template function from argument types (int)

-Kramer

Kramer wrote:
> I imagine this should work.  The factorial code is straight from the docs.
> 
> import std.stdio;
> 
> void main()
> {
>     writefln(factorial(2));
> }
> 
> template factorial(int n)
> {
>   static if (n == 1)
>     const factorial = 1;
>   else
>     const factorial = n * factorial!(n-1);
> }
> 
> C:\code\d\src>dmd template_ex_1.d
> template_ex_1.d(8): template template_ex_1.factorial(int n) is not a function template
> template_ex_1.d(5): template template_ex_1.factorial(int n) cannot deduce template function from argument types (int)
> 
> -Kramer

You need to instantiate the template with a bang:

void main() {
    writefln(factorial!(2));
}

IFTI only applies to function templates, which this is not.

-- 
Kirk McDonald
Pyd: Wrapping Python with D
http://dsource.org/projects/pyd/wiki

Kirk McDonald wrote:
> Kramer wrote:
>> I imagine this should work.  The factorial code is straight from the docs.
>>
>> import std.stdio;
>>
>> void main()
>> {
>>     writefln(factorial(2));
>> }
>>
>> template factorial(int n)
>> {
>>   static if (n == 1)
>>     const factorial = 1;
>>   else
>>     const factorial = n * factorial!(n-1);
>> }
>>
>> C:\code\d\src>dmd template_ex_1.d
>> template_ex_1.d(8): template template_ex_1.factorial(int n) is not a function template
>> template_ex_1.d(5): template template_ex_1.factorial(int n) cannot deduce template function from argument types (int)
>>
>> -Kramer
> 
> You need to instantiate the template with a bang:
> 
> void main() {
>     writefln(factorial!(2));
> }
> 
> IFTI only applies to function templates, which this is not.
> 

Thanks.  I knew about the bang, but figured IFTI would be able to handle this and would consider this a function so I thought it might work.  I haven't worked with D in a while, so is there any reason why this isn't considered a function template?  What would I need to do so IFTI would be invoked?

Thanks in advance.

-Kramer

Kramer wrote:
> Kirk McDonald wrote:
> 
>> Kramer wrote:
>>
>>> I imagine this should work.  The factorial code is straight from the docs.
>>>
>>> import std.stdio;
>>>
>>> void main()
>>> {
>>>     writefln(factorial(2));
>>> }
>>>
>>> template factorial(int n)
>>> {
>>>   static if (n == 1)
>>>     const factorial = 1;
>>>   else
>>>     const factorial = n * factorial!(n-1);
>>> }
>>>
>>> C:\code\d\src>dmd template_ex_1.d
>>> template_ex_1.d(8): template template_ex_1.factorial(int n) is not a function template
>>> template_ex_1.d(5): template template_ex_1.factorial(int n) cannot deduce template function from argument types (int)
>>>
>>> -Kramer
>>
>>
>> You need to instantiate the template with a bang:
>>
>> void main() {
>>     writefln(factorial!(2));
>> }
>>
>> IFTI only applies to function templates, which this is not.
>>
> 
> Thanks.  I knew about the bang, but figured IFTI would be able to handle this and would consider this a function so I thought it might work.  I haven't worked with D in a while, so is there any reason why this isn't considered a function template?  What would I need to do so IFTI would be invoked?
> 
> Thanks in advance.
> 
> -Kramer

Function templates accept both runtime and compile-time parameters. This factorial template accepts only a single integer literal (which in this case is a compile-time parameter). It is just a templated integer constant, not a function.

A function template using IFTI might look something like this:

T func(T)(T t) {
    return t * 2;
}

We can explicitly instantiate the template and call the function like this:

writefln(func!(int)(20));

Or IFTI can derive the type of the function argument for us:

writefln(func(20));

-- 
Kirk McDonald
Pyd: Wrapping Python with D
http://dsource.org/projects/pyd/wiki

Kirk McDonald wrote:
> Kramer wrote:
>> Kirk McDonald wrote:
>>
>>> Kramer wrote:
>>>
>>>> I imagine this should work.  The factorial code is straight from the docs.
>>>>
>>>> import std.stdio;
>>>>
>>>> void main()
>>>> {
>>>>     writefln(factorial(2));
>>>> }
>>>>
>>>> template factorial(int n)
>>>> {
>>>>   static if (n == 1)
>>>>     const factorial = 1;
>>>>   else
>>>>     const factorial = n * factorial!(n-1);
>>>> }
>>>>
>>>> C:\code\d\src>dmd template_ex_1.d
>>>> template_ex_1.d(8): template template_ex_1.factorial(int n) is not a function template
>>>> template_ex_1.d(5): template template_ex_1.factorial(int n) cannot deduce template function from argument types (int)
>>>>
>>>> -Kramer
>>>
>>>
>>> You need to instantiate the template with a bang:
>>>
>>> void main() {
>>>     writefln(factorial!(2));
>>> }
>>>
>>> IFTI only applies to function templates, which this is not.
>>>
>>
>> Thanks.  I knew about the bang, but figured IFTI would be able to handle this and would consider this a function so I thought it might work.  I haven't worked with D in a while, so is there any reason why this isn't considered a function template?  What would I need to do so IFTI would be invoked?
>>
>> Thanks in advance.
>>
>> -Kramer
> 
> Function templates accept both runtime and compile-time parameters. This factorial template accepts only a single integer literal (which in this case is a compile-time parameter). It is just a templated integer constant, not a function.
> 
> A function template using IFTI might look something like this:
> 
> T func(T)(T t) {
>     return t * 2;
> }
> 
> We can explicitly instantiate the template and call the function like this:
> 
> writefln(func!(int)(20));
> 
> Or IFTI can derive the type of the function argument for us:
> 
> writefln(func(20));
> 

Ahhh, got it.  Thanks for the explanation; that helps a lot.

On Mon, 10 Jul 2006 00:14:36 -0500, Kramer wrote:


> What would I need to do so IFTI would be invoked?

// ------------------
 import std.stdio;

 void main()
 {
     writefln(factorial(2));
 }

 template factorial(T)
 {
    T factorial(T n)
    {
       if (n <= 1)
         return cast(T)1;
       else
         return cast(T)( n * factorial(n-1));
    }
 }
// ------------------

The example you gave at first was using a template to generate a compile-time literal. To turn that into a template that generates a function instead, you need to define the function inside the template. If you give it the same name as the template, IFTI becomes easier to use too.

-- 
Derek
(skype: derek.j.parnell)
Melbourne, Australia
"Down with mediocrity!"
10/07/2006 3:33:48 PM