具有特征和函数重载的静态类型语言？

Question

是否存在任何种语言：

• 是静态（强）类型的
• 支持泛型（模板）
• 支持特征/多重继承/接口委托
• 允许函数重载（也允许继承成员）

基本上，在伪代码中，我想要这个：

class Template<SomeType> { void function(SomeType i) {} }
class Composed extends Template<int>, Template<double> { };
Composed composed;
composed.function(3); //calls function(int)
composed.function(2.5); //calls function(double)

从 wiki 列表 http://en.wikipedia.org/wiki/Multiple_inheritance#Implementations 我尝试用以下编程语言编写代码（我还包括最新的尚未发布的 1.0 版（2013 年）语言，如 Kotlin、锡兰）：

• C++ 几乎可以，但无法解析 composed 变量的重载函数
• Scala 编译错误：trait 继承了两次；即使被间接继承欺骗，它仍然会产生错误；另见other guy's question about multiple generic mixin inheritance in Scala
• 埃菲尔编译错误：没有函数重载
• Ceylon trait 不能有变量（并且没有受保护的成员，因此在派生类中存储数据没有技巧，Ceylon 中的特征是无用的）
• Fantom 没有泛型/模板
• Kotlin 编译错误：超类型出现两次；委托看起来很独特，但它没有用，因为既不能访问受保护的成员，也不能访问委托给的变量
• Rust 没有函数重载； trait 不能存储数据；特征不能有定义的方法（带有主体） - 正在处理的问题；
• OCaml 编译错误：没有函数重载；它也没有检查我的函数的参数类型，那么它到底有多“静态类型”？！
• Curl 编译错误：没有函数重载；它也不会检查函数体，除非它被调用，那么它到底是如何“静态类型化”的呢？它是完全编译的还是解释的？！
• Gosu 是一个糟糕的笑话，它根本不可用：不能用一种方法编写和实现简单的接口（错误：ClassFormatError: Illegal field modifiers）。谁真正使用这种语言？！

顺便说一句：当我尝试将 Java 对侦听器的支持放入单独的类时，我想到了这个问题（在许多类中有：List ... addListener(...) ... removeListener(. ..))

C++几乎可以工作：

template <typename T>
class Template { public: void function(T i) {} };
class Composed : public Template<int>, public Template<double> { };

Composed composed;
composed.Template<int>::function(3); //i want: composed.function(3);
((Template<double>&)composed).function(2.5); //i want: composed.function(2.5);

编辑：在 C++ 中，问题是隐藏继承函数。也可以看看 Function with same name but different signature in derived class 和 Why does an overridden function in the derived class hide other overloads of the base class?

编辑 2：在 C++ 中，使用模板和部分特化，有可能使用肮脏的技巧来更简单地使用 trait：

#include <iostream>
#include <typeinfo>

class Void { };
template <class A, class B> class CleverTrait;
template <class A, class B> class CleverTrait;
template <class A> class CleverTrait<A, Void>
{
public:
    void function(A arg) { std::cout << "Hello for type " << typeid(A).name() << std::endl; }
};
template <class A, class B> class CleverTrait<A, CleverTrait<B, Void> > : public CleverTrait<B, Void>
{
public:
    using CleverTrait<B, Void>::function;
    void function(A arg) { std::cout << "Hello for type " << typeid(A).name() << std::endl; }
};

class ComposedByClever : public CleverTrait<double, CleverTrait<int, Void> > { };

int main()
{
    ComposedByClever composedByClever;
    composedByClever.function(5);
    composedByClever.function(2.3);
    return 0;
}

这意味着这个 C++ 中的特定示例有效，但是如果不相关的特征共享函数名，则无法在 C++ 中继承和使用所有函数。

编辑 3：我还应该检查任何支持 mixins 的编程语言：http://en.wikipedia.org/wiki/Mixins#Programming_languages_that_use_mixins

• D 有效，但只能通过字符串操作 mixin，所以 在这种情况下会破坏重构：mixin(GenerateSomething!("IfClassNameHereManualRenaming"));

编辑4：添加“Gosu”语言注释。

编辑 5：Gosu 编程语言已更新 0.10.2，修复了接口损坏问题。然而，即使他们声称已经具体化了泛型和委托，委托+具体化的泛型也不起作用。

Answer 1

C++：类似于 CRTP (see comment to OP) 的奇怪想法本来应该更像：

#include <typeinfo>
#include <iostream>

struct Dummy
{
private:
  // dummy type to prevent overload resolution from ever choosing this overload
    struct ParamDummy { explicit ParamDummy(); };
public:
    void function(ParamDummy);
};

template<typename T, typename Base = Dummy>
struct Template
    : Base
{
    using Base::function;
    void function(T i) { std::cout << typeid(T).name() << std::endl; }
};

struct SecondBaseClass
{
    void function2() { std::cout << "function2" << std::endl; }
};

struct Composed
    : Template<int, Template<double>>, SecondBaseClass
{};

int main()
{
    Composed c;
    c.function(5.0);
    c.function(5);
    c.function2();
}

对于Template 中的每个不同的成员函数名称，您需要一个using 指令。因此，数量仅取决于当前类中成员函数的数量，而不取决于基类。

它在某些方面与多重继承不同，但它允许简单的函数重载。

如果基类只共享一些而不共享所有成员函数，那就更麻烦了。