I have toyed with the compose template in std.functional and ran
into some problems.
rikki_cattermole on discord helped me a lot to solve my problem.
However, what still remains (for me) to understand is why.
Source code for `compose`:
https://github.com/dlang/phobos/blob/master/std/functional.d#L1161
`compose` pipes together given functions. And returns a TEMPLATED
function.
Why does it return a templated function? At compile-time, compose
definitly knows, what kinds of function it composes together. So
with std.traits, it could put there a definitve type, depending
on the given function(s).
I somewhat see, that inside compose itself, this probably solves
some issues with casting (maybe).
However, the last composition, i.e. the one which is returned,
does not need to be templated, since it is known, what parameter
has the last function.
In my case, I failed to understand, that it returns a
non-initialized template function, which lead into compile
problems.
In general I can imagine that this leads to weird compile errors,
which are hard to understand. (types, casting, etc.)
My main question is why? Is there something, which I am missing,
that explains, why it is beneficial to return a templated
function?
(maybe, because I might want to compose together templated
non-initialized functions?)
