A look inside "filter" function defintion

[Meta]

On Monday, 1 August 2022 at 23:35:13 UTC, pascal111 wrote:
> This is the definition of "filter" function, and I think it 
> called itself within its definition. I'm guessing how it works?
>
> '''D
> template filter(alias predicate)
> if (is(typeof(unaryFun!predicate)))
> {
>     /**
>     Params:
>         range = An $(REF_ALTTEXT input range, isInputRange, 
> std,range,primitives)
>         of elements
>     Returns:
>         A range containing only elements `x` in `range` for
>         which `predicate(x)` returns `true`.
>      */
>     auto filter(Range)(Range range) if 
> (isInputRange!(Unqual!Range))
>     {
>         return FilterResult!(unaryFun!predicate, Range)(range);
>     }
> }
> '''
>
> I think this line needs explanation:
>
> '''D
> return FilterResult!(unaryFun!predicate, Range)(range);
> '''

To give a vastly simplified answer, the term "eponymous template" 
essentially means that if you have an item declared inside a 
template that has a same name as the template:
```D
template SomeTemplate(T)
{
     alias SomeTemplate = T;
}
```

It is not a compile error. Instead, when you use the template:
```D
SomeTemplate!int n;
```

The compiler rewrites your code like to:
```D
SomeTemplate!int.SomeTemplate n;
```

Because normally when you instantiate a template, you have to 
refer to the declarations inside it by name:
```D
template SomeOtherTemplate(T)
{
     alias SomeAlias = T;
}

//SomeOtherTemplate!int n; Error: `SomeOtherTemplate!int` is used 
as a type
SomeOtherTemplate!int.SomeAlias n; //Ok
```

Except in the special case I outlined above. It's essentially a 
hack that was brought over from C++. It makes using templates 
more ergonomic.