On Wed, Jul 31, 2024 at 6:40 PM organicoman via Std-Proposals
<std-proposals_at_[hidden]> wrote:
>
>
>
> Another thing, we keep hearing about how we need this proposal because “this isn’t how type theory works,” but this is not true, and is a misunderstanding of both how C++ implements types and of type theory itself.
> First off, if you want a really type-theory savvy language, you should probably be using Idris or Haskell or Coq, not C++. But the fundamental misunderstanding seems to be that a template instantiation is a dependently typed function.
>
> ```cpp
> template<typename T>
> int X(int) { /* ...*/ }
> ```
> It is not. The type of any specialization of this “function" is not
> * -> int -> int,
> because this is not a function at all, it is a template of how to create a function. For any specialization (e.g. X<int>, X<bool>, etc), the type of the resulting functions is just
> int -> int.
>
> This is called a mapping from int to int that means, if two functions stamped from the same template have the same mapping, then the same input gives the same output.
> But with current C++ it is not the case.
> Example:
> template<int I>
> int foo (int j)
> {
> return I * j;
> }
>
> int main()
> {
> auto f1 = &foo<5>;
> auto f2 = &foo<-3>;
>
> if(std::is_same_v<decltype(f1), decltype(f2)>)
> cout << " f1(1) must equal f2(1) is" << boolalpha<< (f1(1)==f2(1));
> }
>
> Try this snippet, and reason about it. That's all what i can say.

But `foo<5>` and `foo<-3>` do not "have the same mapping" of `int` to
`int`. As such, there is no reason to expect `f1(1)` and `f2(1)` to be
equal.

Two instantiations of the same template with different parameters
generate different things. That's *how templates work*.`foo<5>` and
`foo<-3>` are expected to be different functions with different
behavior. Two different functions that have the same type are still
*two different functions*.