template <class T> const T* ident(const T* x) {
  return x;
}

T>>На этапе же выполнения остаётся только код скомпилированный для конечного числа типов. Либо компиляция не завершается.

Evaluation of the result does not cause any semantically observable side effect or output, such as mutation of mutable objects or output to I/O devices.

S>>>Evaluation of the result does not cause any semantically observable side effect or output, such as mutation of mutable objects or output to I/O devices.

T>>template <class T> const T* ident(const T* x) {
T>>  return x;
T>>}
T>>

T>>Я его упростил.

//data Nil = Nil
struct Nil {};

//data Cons a = Cons Integer a
template <int N, class A> struct Cons {
  static const int val = N;
  typedef A Rest;
};

//class ScalarProduct a where
//  scalarProduct :: a -> a -> Integer
template <class T1, class T2> struct scalarProd;

//instance ScalarProduct Nil where
//  scalarProduct Nil Nil = 0
template <> struct scalarProd<Nil, Nil> {
  static const int res = 0;
};

//instance ScalarProduct a => ScalarProduct (Cons a) where
//  scalarProduct (Cons n1 a1) (Cons n2 a2) = n1 * n2 + scalarProduct a1 a2
template <int N1, int N2, class A1, class A2>
struct scalarProd<Cons<N1, A1>, Cons<N2, A2> > {
  static const int res = N1 * N2 + scalarProd<A1, A2>::res;
};

//main' :: ScalarProduct a => Integer -> Integer -> a -> a -> Integer
template <int N, int I, class AS, class BS> struct make_quot;

//main' 0 _ as bs = scalarProduct as bs
template <int I, class AS, class BS> struct make_quot<0, I, AS, BS> {
  static const int res = scalarProd<AS, BS>::res;
};

//main' n i as bs = main' (n-1) (i+1) (Cons (2*i+1) as) (Cons (i^2) bs)
template <int N, int I, class AS, class BS> struct make_quot {
  static const int res = make_quot<N - 1, I + 1, Cons<2*I + 1, AS>, Cons<I*I, BS> >::res;
};

//main :: Integer -> Integer 
//main n = main' n 0 Nil Nil where
template <int N> struct make {
  static const int res = make_quot<N, 0, Nil, Nil>::res;
};

#include <iostream>

//main :: IO ()
//main = print $ make 5
int main(int argc, char* argv[]){
  std::cout << make<5>::res << std::endl;
}

id x = x

T>Впрочем как и большинство кода stl.

T>Вне зависимости от типа полиморфизма эта часть общая.

module Main where

import System.Environment

data Nil = Nil

data Cons a = Cons Integer a

class ScalarProduct a where scalarProduct :: a -> a -> Integer

instance ScalarProduct Nil where 
    scalarProduct Nil Nil = 0
instance ScalarProduct a => ScalarProduct (Cons a) where 
    scalarProduct (Cons n1 a1) (Cons n2 a2) = n1 * n2 + scalarProduct a1 a2

test :: Integer -> Integer
test n = test' n 0 Nil Nil where
  test' :: ScalarProduct a => Integer -> Integer -> a -> a -> Integer
  test' 0 _ as bs = scalarProduct as bs
  test' n i as bs = test' (n-1) (i+1) (Cons (2*i+1) as) (Cons (i^2) bs)
--  test' n i as bs = test' (n-1) (i+1) as (Cons (i^2) bs) 

main = print . test . read . head =<< getArgs