sum :: [a] -> a
sum = fold (+) 0

sum :: (a -> a -> a) -> a -> [a] -> a
sum (+) 0 = fold (+) 0

0 + x = x
x + 0 = x

data Add a = Add { plus :: a -> a -> a, zero :: a }

sum :: Add a -> [a] -> a
sum (Add (+) 0) = fold (+) 0

addInt :: Add Int
addInt = Add (+#) 0#

addDouble :: Add Double
addDouble = Add (+##) 0.0##

sumInt = [Int] -> Int
sumInt = sum addInt

class Add a where
    plus :: a -> a -> a
    zero :: a

instance Add Int where
    plus = (+#)
    zero = 0#

instance Add Double where
    plus = (+##)
    zero = 0.0#

sum :: Add a => [a] -> a

• "Наследования" классов, в том числе и множественного (включения другого словаря (словарей) в качестве поля (полей) в словарь)
  
• Реализации функций из словаря в терминах друг друга и функций из словарей, "наследником" которых этот словарь является
  
• И даже тех, с которыми он может опционально оказаться в одном "пакете" словарей для передачи через параметр
  
• Того, что у типа-словаря может быть несколько параметров типов
  
• Того, что словари могут сами быть полиморфными, инстансы могут быть объявлены для других классов типов — не обязательно для какого-то конкретного типа.
  
• Того, что можно объявлять синонимы для типов-словарей т.е. классов типов и даже групп таких классов.

sum :: {Add a} -> [a] -> a

K>class Add a where
K>    plus :: a -> a -> a
K>    zero :: a

K>instance Add Int where
K>    plus = (+#)
K>    zero = 0#

K>instance Add Double where
K>    plus = (+##)
K>    zero = 0.0#

K>

template<class a> struct Add; // без реализации, чтоб была ошибка компиляции для неизвестного типа

template<> struct Add<int> {
  static int plus(int x, int y) { return x+y; }
  static int zero() { return 0; }
};

template<> struct Add<double> {
  static double plus(double x, double y) { return x+y; }
  static double zero() { return 0.0; }
};

K>sum :: Add a => [a] -> a
K>

template<class a>
int sum(vector<a> v) {
  return std::accumulate( std::begin(v), std::end(v), Add<a>::plus, Add<a>::zero() );
}

// для вектора - честный итератор:
std::vector<a>::iterator std::begin(std::vector<a> v) { return v.begin(); }
std::vector<a>::iterator std::end(std::vector<a> v) { return v.end(); }
// для встроенного массива - указатель на первый/запоследний элемент:
a* std::begin(a[N] v) { return &v[0]; }
a* std::end(a[N] v) { return std::begin(v)+N; }

template<class V>
auto sum(V v) {
  typedef decltype(*std::begin(v)) a; // тип элемента контейнера
  return std::accumulate( std::begin(v), std::end(v), Add<a>::plus, Add<a>::zero() );
}

template<> struct Add<float> {
  static float zero() { return 0.0; }
};

Haskell type classes and various extensions can be emulated in C++ by C++ templates/traits and some amount of compile-time metaprogramming. ...C++ can easily handle other possible extensions to Haskell type classes.

sum :: forall a. Add a => [a] -> a

J>template<class a>
J>int sum(vector<a> v) {
J>  return std::accumulate( std::begin(v), std::end(v), Add<a>::plus, Add<a>::zero() );
J>}

http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.78.2151&rep=rep1&type=pdf

http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.78.2151&rep=rep1&type=pdf

Prelude> data D = D
Prelude> class C a where c :: a

==================== Tidy Core ====================
Result size of Tidy Core = {terms: 4, types: 7, coercions: 2}
-- тут сгенерировалась полиморфная функция, принимающая словарь.
c
c = \ @ a tpl -> tpl `cast` ...

-- пишем пустой инстанс:
Prelude> instance C D

-- компилятор выдает ворнинг
<interactive>:13:10: Warning:
    No explicit implementation for
      ‘c’
    In the instance declaration for ‘C D’

==================== Tidy Core ====================
Result size of Tidy Core = {terms: 5, types: 4, coercions: 3}

-- После чего генерирует функцию-заглушку, кидающую эксепшн
$cc
$cc = noMethodBindingError "<interactive>:13:10-12|c"#

-- и делает словарь с ней (когда функция класса одна - словарь это просто обернутая в newtype функция)
$fCD
$fCD = $cc `cast` ...

K>sum :: forall a. Add a => [a] -> a
K>

J>>template<class a>
J>>a sum(vector<a> v) {
J>>  return std::accumulate( std::begin(v), std::end(v), Add<a>::plus, Add<a>::zero() );
J>>}
K>

template<class a>
typename enable_if< CheckTypeClass<Add, a>, a >::type
sum(vector<a> v);

template<Add a>
a sum(vector<a> v);

template<class a>
struct CheckTypeClass<Add, a>
  : and_< is_same< decltype(Add<a>::plus), a(a, a) >
        , is_same< decltype(Add<a>::zero), a() >
        >
{};

static_assert(CheckTypeClass<Add,float>::value,"Add<float> is not correct");

main.cpp: In instantiation of 'struct CheckTypeClass<Add, float>':
main.cpp:34:40:   required from here
main.cpp:27:136: error: 'zero' is not a member of 'Add<float>'

Prelude Data.Monoid> let msum xs = foldr (<>) mempty xs

-- получается один код для всех типов:
==================== Simplified expression ====================
returnIO
  (: ((\ @ b $dMonoid xs -> foldr (<> $dMonoid) (mempty $dMonoid) xs)
      `cast` ...)
     ([]))


msum :: Monoid b => [b] -> b
-- это была параметрически полиморфная часть.
Prelude Data.Monoid> data D = D

-- а теперь пишем код специфический для данного типа.
Prelude Data.Monoid> instance Monoid D where D `mappend` D = D; mempty = D

==================== Tidy Core ====================
Result size of Tidy Core = {terms: 15, types: 13, coercions: 0}
-- ad-hoc для типа D
$cmappend
$cmappend = \ ds ds1 -> case ds of _ { D -> ds1 }

Rec {
-- собираем в словарь
$fMonoidD
$fMonoidD = D:Monoid D $cmappend $cmconcat
-- тут у нас дефолтная реализация
$cmconcat
$cmconcat = $dmmconcat $fMonoidD
end Rec }

template<class a> byte bestArchiverEver(a) { return byte(1); }

map :: (a -> b) -> [a] -> [b]

template<class a, class b> list<b> map( b(a), list<a> );

Prelude Data.Monoid> let msum xs = foldr (<>) mempty xs

==================== Simplified expression ====================
returnIO  -- на эти навороты можно внимания не обращать
  @ [()]  -- это из-за объявления в интерпретаторе
  (: @ () -- рассахаренная функция - лямбда ниже
     ((\ (@ b) ($dMonoid :: Monoid b) (xs :: [b]) ->
         foldr @ b @ b (<> @ b $dMonoid) (mempty @ b $dMonoid) xs)
      `cast` ...)
     ([] @ ())) 

-- сюда я явно параметр дописал, сейчас - думаю - будет понятнее.
msum :: forall a. Monoid b => [b] -> b

Prelude Data.Monoid> instance Monoid D where D `mappend` D = D; mempty = D

==================== Tidy Core ====================
Result size of Tidy Core = {terms: 15, types: 13, coercions: 0}

$cmappend :: D -> D -> D
$cmappend = \ (ds :: D) (ds1 :: D) -> case ds of _ { D -> ds1 }

Rec {
$fMonoidD :: Monoid D
$fMonoidD = D:Monoid @ D D $cmappend $cmconcat

$cmconcat :: [D] -> D
$cmconcat = $dmmconcat @ D $fMonoidD
end Rec }