Hello List:

In tDlp book in section 5.6 entitled `Higher-Order Functions. Function Literals,
the first code example is:

-----------------------------------------------------------------
T[] find(alias pred, T)(T[] input)
	if (is(typeof(pred(input[0])) == bool)) {
	for(; input.length > 0; input = input[1 .. $]) {
		if (pred(input[0])) break;
		}
	return input;
	}
-----------------------------------------------------------------

I can play it. Nevertheless, it is not clear for me right now
what is the role played by `T' in the generic argument list (alias pred, T).
(Its meaning is bypassed in this section via a `deduction' way.)

Any hint is welcome.

Thanks in advance,
Jerome

On 20-01-2012 15:32, Jerome BENOIT wrote:
> Hello List:
>
> In tDlp book in section 5.6 entitled `Higher-Order Functions. Function
> Literals,
> the first code example is:
>
> -----------------------------------------------------------------
> T[] find(alias pred, T)(T[] input)
> if (is(typeof(pred(input[0])) == bool)) {
> for(; input.length > 0; input = input[1 .. $]) {
> if (pred(input[0])) break;
> }
> return input;
> }
> -----------------------------------------------------------------
>
> I can play it. Nevertheless, it is not clear for me right now
> what is the role played by `T' in the generic argument list (alias pred,
> T).
> (Its meaning is bypassed in this section via a `deduction' way.)
>
> Any hint is welcome.
>
> Thanks in advance,
> Jerome
>

It's important to realize that D does not have generics; rather, it has templates. What (alias pred, T) means is that it takes (virtually) any argument as the first template parameter (function literals included) and a type for the second parameter.

You can call this function like so:

auto ints = find!((x) { return x % 2 != 0; })([1, 2, 3, 4, 5]);

Here, the type parameter T gets deduced from the argument, which is an array of ints.

-- 
- Alex

Thanks.

Let go further.


On 20/01/12 15:58, Alex Rønne Petersen wrote:
> On 20-01-2012 15:32, Jerome BENOIT wrote:
>> Hello List:
>>
>> In tDlp book in section 5.6 entitled `Higher-Order Functions. Function
>> Literals,
>> the first code example is:
>>
>> -----------------------------------------------------------------
>> T[] find(alias pred, T)(T[] input)
>> if (is(typeof(pred(input[0])) == bool)) {
>> for(; input.length > 0; input = input[1 .. $]) {
>> if (pred(input[0])) break;
>> }
>> return input;
>> }
>> -----------------------------------------------------------------
>>
>> I can play it. Nevertheless, it is not clear for me right now
>> what is the role played by `T' in the generic argument list (alias pred,
>> T).
>> (Its meaning is bypassed in this section via a `deduction' way.)
>>
>> Any hint is welcome.
>>
>> Thanks in advance,
>> Jerome
>>
>
> It's important to realize that D does not have generics; rather, it has templates. What (alias pred, T) means is that it takes (virtually) any argument as the first template parameter (function literals included) and a type for the second parameter.
>
> You can call this function like so:
>
> auto ints = find!((x) { return x % 2 != 0; })([1, 2, 3, 4, 5]);
>
> Here, the type parameter T gets deduced from the argument, which is an array of ints.
>

What would be the non-deducible version ?

Jerome

Hello Again:

On 20/01/12 15:58, Alex Rønne Petersen wrote:
> On 20-01-2012 15:32, Jerome BENOIT wrote:
>> Hello List:
>>
>> In tDlp book in section 5.6 entitled `Higher-Order Functions. Function
>> Literals,
>> the first code example is:
>>
>> -----------------------------------------------------------------
>> T[] find(alias pred, T)(T[] input)
>> if (is(typeof(pred(input[0])) == bool)) {
>> for(; input.length > 0; input = input[1 .. $]) {
>> if (pred(input[0])) break;
>> }
>> return input;
>> }
>> -----------------------------------------------------------------
>>
>> I can play it. Nevertheless, it is not clear for me right now
>> what is the role played by `T' in the generic argument list (alias pred,
>> T).
>> (Its meaning is bypassed in this section via a `deduction' way.)
>>
>> Any hint is welcome.
>>
>> Thanks in advance,
>> Jerome
>>
>
> It's important to realize that D does not have generics; rather, it has templates. What (alias pred, T) means is that it takes (virtually) any argument as the first template parameter (function literals included) and a type for the second parameter.
>
> You can call this function like so:
>
> auto ints = find!((x) { return x % 2 != 0; })([1, 2, 3, 4, 5]);
>
> Here, the type parameter T gets deduced from the argument, which is an array of ints.

I am certainly still very confused here, but I guess it is important I get the point before to gig further D:
In (alias pred, T), are both `pred' and `T' parameters for the function find ? or is `T' some kind of parameter for `pred' ?

Thanks in advance,
Jerome  

>

On 20-01-2012 17:14, Jerome BENOIT wrote:
> Hello Again:
>
> On 20/01/12 15:58, Alex Rønne Petersen wrote:
>> On 20-01-2012 15:32, Jerome BENOIT wrote:
>>> Hello List:
>>>
>>> In tDlp book in section 5.6 entitled `Higher-Order Functions. Function
>>> Literals,
>>> the first code example is:
>>>
>>> -----------------------------------------------------------------
>>> T[] find(alias pred, T)(T[] input)
>>> if (is(typeof(pred(input[0])) == bool)) {
>>> for(; input.length > 0; input = input[1 .. $]) {
>>> if (pred(input[0])) break;
>>> }
>>> return input;
>>> }
>>> -----------------------------------------------------------------
>>>
>>> I can play it. Nevertheless, it is not clear for me right now
>>> what is the role played by `T' in the generic argument list (alias pred,
>>> T).
>>> (Its meaning is bypassed in this section via a `deduction' way.)
>>>
>>> Any hint is welcome.
>>>
>>> Thanks in advance,
>>> Jerome
>>>
>>
>> It's important to realize that D does not have generics; rather, it
>> has templates. What (alias pred, T) means is that it takes (virtually)
>> any argument as the first template parameter (function literals
>> included) and a type for the second parameter.
>>
>> You can call this function like so:
>>
>> auto ints = find!((x) { return x % 2 != 0; })([1, 2, 3, 4, 5]);
>>
>> Here, the type parameter T gets deduced from the argument, which is an
>> array of ints.
>
> I am certainly still very confused here, but I guess it is important I
> get the point before to gig further D:
> In (alias pred, T), are both `pred' and `T' parameters for the function
> find ? or is `T' some kind of parameter for `pred' ?
>
> Thanks in advance,
> Jerome
>>
>

Both pred and T are so-called template parameters. That is, they are statically resolved at compile time.

You could as well have called the function like so:

auto ints = find!((x) { return x % 2 != 0; }, int)([1, 2, 3, 4, 5]);

Notice how we have two parameter lists: The first one where we pass a function literal and the type int is the template parameter list. The second one is the actual runtime arguments to the function.

-- 
- Alex

On 20/01/12 17:23, Alex Rønne Petersen wrote:
> On 20-01-2012 17:14, Jerome BENOIT wrote:
>> Hello Again:
>>
>> On 20/01/12 15:58, Alex Rønne Petersen wrote:
>>> On 20-01-2012 15:32, Jerome BENOIT wrote:
>>>> Hello List:
>>>>
>>>> In tDlp book in section 5.6 entitled `Higher-Order Functions. Function
>>>> Literals,
>>>> the first code example is:
>>>>
>>>> -----------------------------------------------------------------
>>>> T[] find(alias pred, T)(T[] input)
>>>> if (is(typeof(pred(input[0])) == bool)) {
>>>> for(; input.length > 0; input = input[1 .. $]) {
>>>> if (pred(input[0])) break;
>>>> }
>>>> return input;
>>>> }
>>>> -----------------------------------------------------------------
>>>>
>>>> I can play it. Nevertheless, it is not clear for me right now
>>>> what is the role played by `T' in the generic argument list (alias pred,
>>>> T).
>>>> (Its meaning is bypassed in this section via a `deduction' way.)
>>>>
>>>> Any hint is welcome.
>>>>
>>>> Thanks in advance,
>>>> Jerome
>>>>
>>>
>>> It's important to realize that D does not have generics; rather, it
>>> has templates. What (alias pred, T) means is that it takes (virtually)
>>> any argument as the first template parameter (function literals
>>> included) and a type for the second parameter.
>>>
>>> You can call this function like so:
>>>
>>> auto ints = find!((x) { return x % 2 != 0; })([1, 2, 3, 4, 5]);
>>>
>>> Here, the type parameter T gets deduced from the argument, which is an
>>> array of ints.
>>
>> I am certainly still very confused here, but I guess it is important I
>> get the point before to gig further D:
>> In (alias pred, T), are both `pred' and `T' parameters for the function
>> find ? or is `T' some kind of parameter for `pred' ?
>>
>> Thanks in advance,
>> Jerome
>>>
>>
>
> Both pred and T are so-called template parameters.

Ok !

 That is, they are statically resolved at compile time.
>
> You could as well have called the function like so:
>
> auto ints = find!((x) { return x % 2 != 0; }, int)([1, 2, 3, 4, 5]);

It is getting clearer in my mind.

>
> Notice how we have two parameter lists: The first one where we pass a function literal and the type int is the template parameter list. The second one is the actual runtime arguments to the function.

I got this part of the story: I guess that I was confused by the alias.

Let assume that the predicate  must have now two parameters in such a way that
the first is of type T and the second of type TM.

auto ff = find!((x, m) { return x % m != 0; })([1, 2, 3, 4, 5]);

Here x would be of type T, and m of type TM.


What does look the code for find then ?

Thanks in advance,
Jerome

>

On 01/20/2012 08:43 AM, Jerome BENOIT wrote:

>>>>> -----------------------------------------------------------------
>>>>> T[] find(alias pred, T)(T[] input)
>>>>> if (is(typeof(pred(input[0])) == bool)) {
>>>>> for(; input.length > 0; input = input[1 .. $]) {
>>>>> if (pred(input[0])) break;
>>>>> }
>>>>> return input;
>>>>> }
>>>>> -----------------------------------------------------------------

> Let assume that the predicate must have now two parameters in such a way
> that
> the first is of type T and the second of type TM.
>
> auto ff = find!((x, m) { return x % m != 0; })([1, 2, 3, 4, 5]);
>
> Here x would be of type T, and m of type TM.
>
>
> What does look the code for find then ?

We must decide on what 'm' is on the find() line above. Do you want to provide it as a template parameter or a function parameter? Here is how it could be provided as a function parameter (the last '2' in the parameter list):

    auto ff = find!((x, m) { return x % m != 0; })([1, 2, 3, 4, 5], 2);

And here is a matching find() function template:

T[] find(alias pred, T, TM)(T[] input, TM m)
    if (is(typeof(pred(input[0], m)) == bool))
{
    for(; input.length > 0; input = input[1 .. $]) {
        if (pred(input[0], m)) break;
    }

    return input;
}

void main()
{
    auto ff = find!((x, m) { return x % m != 0; })([1, 2, 3, 4, 5], 2);
}

Notice that pred() now takes two parameters in find().

>
> Thanks in advance,
> Jerome
>
>>
>

Philippe Sigaud's template document covers everything about templates:

  https://github.com/PhilippeSigaud/D-templates-tutorial

(Just download the pdf there.)

I have a chapter about templates which intentionally covers little, leaving the rest of templates to a later chapter:

  http://ddili.org/ders/d.en/templates.html

The problem is, 'alias' template parameters are in that later chapter, which hasn't been translated yet.

Ali

> 
> Philippe Sigaud's template document covers everything about templates:
> 
>    https://github.com/PhilippeSigaud/D-templates-tutorial
> 
> (Just download the pdf there.)

This should be on the website.