tdlp: higher-order functions

Jerome BENOIT g6299304p at rezozer.net
Fri Jan 20 08:43:18 PST 2012

```
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.
>>>>
>>>> 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' ?
>>
>> 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 ?