Haskell 类型类和 C++模板类

Question

是否可以使用 C++（或 C#）模板来模拟 Haskell 的类型类功能？

这样做有意义吗？或者这样做有什么回报吗？

我试图用 C++ 创建一个 Functor 类，但没成功。我尝试了这样的事情：

#include <iostream>
using namespace std;

//A function class to make types more readable
template <class input, class output> class Function {
private:
  output (*ptrfunc )(input);
public:
  Function(output (* ptr)(input)) {
    ptrfunc = ptr;
  }
  output call(input x) {return  (*ptrfunc)(x);}
  output operator() (input x) { return call(x);}
};


//the functor "typeclass"
template <class a> class Functor{
public:
  template <class b> Functor<b> fmap(Function<a,b> func);
};

// an container type to be declared "instance" of functor:
template <class a> class List : public Functor<a> { 
private:
  a * ptrList;
  int size;
public:
  List(int n) {  //constructor;
    ptrList = new a[n]; 
    size = n;
  }
  List(List<a> const& other) { //copy constructor
    size = other.size;
    ptrList = new a[size];
    for(int i = 0; i<size; i++)
      (*this)[i] = other[i];
  }
  ~List() { delete ptrList;} //destructor
  a& operator[](int i) { return ptrList[i];} // subscript operator just for easy notation
  const a& operator[](int i) const { return ptrList[i];}// subscript operator just for easy notation

  template <class b> List<b> fmap(Function<a,b> func) { //"instance" version of fmap
    List<b> temp(size);
    for(int i = 0; i < size; i++)
      temp[i] = func((*this)[i]);
    return temp;
  }
};


int test(int k) { return 2 * k;}

int main(void) {
  Function<int, int> func(&test);
  List<int> lista(10);
  for(int i = 0; i < 10; i++)
    lista[i] = i;
  List<int> lista2(lista.fmap(func));
  for(int i = 0; i < 10; i++)
    cout << lista2[i] << " ";
  cout << endl;
  return 0;
}

它做了它应该做的事情，但是在 C++ 中使用这种模式有意义吗？它真的与haskell中的模式相同吗：

data List a = -- some stuff 

class  Functor f  where
fmap :: (a -> b) -> f a -> f b

instance (Functor List) where
-- some stuff    

对我来说似乎不是同一件事，因为在Functor f中，f是一种* -> * 类型构造函数，并且在我上面的 Functor 定义中，a 不是模板 a，而是“包含”数据类型本身。

有没有办法解决这个问题？更重要的是：尝试将这种模式复制到 C++ 是否有意义？在我看来，C# 比 C++ 更类似于函数式编程风格。有没有办法在 C# 中做到这一点？

Answer 1

是否可以使用 C++（或 C#）模板模拟 Haskell 的类型类功能？

我对 C++ 模板不够熟悉，无法回答这个问题。不过我可以谈谈 C# 泛型类型。

简短的回答是，不。 “高级”类型类的 Haskell 系统比 C# 中的泛型类型系统更强大。

对于仍在阅读本文但不熟悉 Haskell 的读者来说，简要讨论“高级类型”的含义可能会有所帮助。在 C# 中，您可以这样做：

interface IEnumerable<T> { ... }

“通用”类型“单一类型参数的 IEnumerable”本身并不是真正的“类型”，它是一种模式，您可以通过替换类型参数（“int ") 用于类型参数 ("T")。从这个意义上说，它比普通类型“更高”。

您可以对泛型类型的类型参数施加约束：

class C<T> where T : IEnumerable<int>

泛型类型 C 可以使用任何类型参数构造，只要类型参数是可通过引用或装箱转换隐式转换为 IEnumerable。

但 Haskell 类型系统比这更进一步。它支持“类型类”，其中您可以对 T 施加的约束是“T 上定义了一个相等运算符”之类的内容。在 C# 中，运算符被定义为静态方法，并且没有类似于静态方法的接口。在 C# 中，我们无法基于任意静态方法泛化多种类型。

通常为 Haskell 给出的一个例子是“monad”模式。在 C# 表示法中，假设我们有一个类型：

class MyMonad<T>
{
    public static MyMonad<TOut> Bind<TIn, TOut>(MyMonad<TIn>, Func<TIn, MyMonad<TOut>>) { ... }
    public MyMonad(T t) { ... }
}

monad 只是一种模式；一元类型是任何泛型类型，它具有静态泛型方法 Bind 和与上述模式匹配的构造函数。在 Haskell 中，你可以使用更高的类型来描述该模式；在 C# 中，我们在类型系统中没有工具来概括静态方法和构造函数等内容。

或者，您可能会说使用实例绑定器会更惯用：

class MyMonad<T>
{
    public MyMonad<TOut> Bind<TOut>(MyMonad<T>, Func<T, MyMonad<TOut>>) { ... }
    public MyMonad(T t) { ... }
}

这有帮助吗？不。即使把构造函数的问题放在一边，我们也无法想出一个捕获这种模式的接口。我们可以尝试：

interface IMonad<T>
{
    public IMonad<TOut> Bind<TOut>(IMonad<T>, Func<T, IMonad<TOut>>);
}

但是这是不对的。这就是说，一个 monad 是一个接受一个 monad 和一个返回一个 monad 的函数，并返回一个 monad 的东西。这意味着您可以有两个 IMonad 实现，例如 Maybe 和 Sequence，然后有一个活页夹它需要一个序列并返回一个可能！这没有任何意义；我们想要捕获的模式是

highertype Monad makes a pattern with TheImplementingType<T> like
{
    public TheImplementingType<TOut> Bind<TOut>(TheImplementingType<T>, Func<T, TheImplementingType<TOut>>);
}

，但我们无法在 C# 中表达它。

让我们考虑一下您的 Functor 示例。在 C# 中，我们可能有一个类型

class List<T> 
{
    public static List<TOut> Map<TIn, TOut>(Func<TIn, TOut> mapper, List<TIn> list) 
    { ... }

，或者更惯用地讲，一个实例方法：

class List<T> 
{
    public List<TOut> Map<TOut>(Func<T, TOut> mapper) 
    { ... }

或者，再更惯用地讲，我们可能有静态方法作为扩展方法。 （事实上​​，这个方法确实存在于C#中的序列运算符库中；它可以通过在IEnumerable上组合“Select”和“ToList”来构建）。

任何。没关系。要点是，在 Haskell 中的代码中：

class  Functor f  where 
fmap :: (a -> b) -> f a -> f b 

您可以说“任何公开满足上述模式的映射操作的泛型类型都被称为‘函子’”，然后您可以创建采用函子的方法。我们没有任何方法可以在 C# 中概括“在用户级别提供映射操作的所有类型”。

为了解决类型系统的这种限制，我们所做的就是选择一些最强大的高级类型并将它们直接构建到语言中。语言本身可以识别更高的类型，例如序列模式（在 foreach 循环处理中）、广义 monad 模式（在查询理解中；“SelectMany”是任意 monad 上的“Bind”）、延续模式（在“await”中出现） C# 5)、“Maybe” monad（可空值类型）等等。

因此，为了解决您的特定问题，是的，没问题，进行投影的概念不是在类型系统中捕获的，而是在语言中捕获的。 /em> 带有 LINQ 查询推导式。如果您说，

from x in y select z

那么任何类型的表达式 y 具有采用 y 和从 x 到 z 的映射的 Select 方法都可以工作。该模式已内置到 C# 语言中。但如果您想描述一些其他“更高”的模式，那么您就不走运了。

如果类型系统中有一个工具来描述更高的类型，那就太好了，但更有可能的是，我们将保持类型系统不变，并根据需要将更多模式烘焙到语言中。

我经常看到尝试在 C# 中模拟高阶类型的地方在这个问题中进行了描述：

为什么这个通用约束在看起来有循环引用时会编译

这里的想法是开发人员希望开发类型“动物”，这样：

abstract class Animal
{
    public abstract void MakeFriends<T>(T newFriend)
    where T : THISTYPE;
}

虚构的“where T : THISTYPE”试图传达这样的想法：猫只能与另一只猫交朋友，狗只能与另一只狗交朋友，等等。 （暂时忽略这样一个事实，即这种模式意味着 MakeFriends 在形式参数类型上具有虚拟协变性，它不是类型安全的，因此可能会违反里氏替换原则。）这个概念可以用更高的类型来表达，但不能用C# 类型系统。人们有时会使用这样的模式：

abstract class Animal<T> where T : Animal<T>
{
    public abstract void MakeFriends(T newFriend);
}
class Cat : Animal<Cat>
{
    public override void MakeFriends(Cat newFriend){ ... }
}

然而，这实际上并不能强制执行所需的约束，因为当然没有什么可以阻止你说：

class Dog : Animal<Cat>
{
    public override void MakeFriends(Cat newFriend){ ... }
}

现在狗可以与猫成为朋友，这违反了动物作者的意图。 C# 类型系统的功能根本不足以表示您可能需要的所有类型的约束。您必须使用更高的类型才能使其正常工作。

Answer 2

C++0x 原本打算引入与 Haskell 的类型类非常相似的概念，但该功能被否决了。再耐心等待十年，他们可能最终会进入这门语言。

Answer 3

来自此博客的作者关于 Haskell 和 C++ 的帖子：

在 C++ 中进行编译时计算的能力是被发现的，而不是内置于该语言中的。

虽然可以在 C++ 模板中模拟许多 Haskell 功能，但翻译后的语法确实很难看。这主要是因为 C++ 中的元编程是一个意外，而不是最初设想的功能。

Answer 4

尽管帖子中单独列出了 C# 和 C++，但与 Scala（2.8，目标是JVM）代替。 Scala 与 C# 非常相似，因为它是一种强/静态单调度“OO”语言——但它具有比 C#3/4 更强大的类型系统（但是，功能并不完全重叠）。

我不熟悉 Haskell，但多年来我读过各种文章并听到过许多论点，我相信您正在寻找的类型类功能可以通过 隐式（示例），即使不像 Haskell 那样惯用。

另一方面，F# 作为一种“函数式语言”，对类型类构造的支持很差（或者不存在？这不是我的领域，但我相信不可能在 F# 中创建 Monad 类型）。发挥语言的优势绝对是值得的。

快乐编码。

Answer 5

也许我在这里缺少一些 Haskell 元级别，但是如果没有声明，使用 STL 的实际示例将如下所示：

struct Test : public std::unary_function<Foo,SomeResult> {
    SomeResult operator()( const Foo& foo ) const;
};

std::vector<Foo> foos;
...

std::vector<SomeResult> results;
std::transform( foos.begin(), foos.end(), results.begin(), Test() );
....