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

Question

是否存在任何语言:

是静态(强)类型的

支持泛型(模板)

支持特征/多重继承/接口(interface)委托(delegate)

允许函数重载(也允许继承成员)

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

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)

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

C++ 几乎有可能，但无法解析组合变量

的重载函数

斯卡拉 编译错误:trait 继承了两次；即使被间接继承欺骗，它仍然会产生错误；另见other guy's question about multiple generic mixin inheritance in Scala

埃菲尔编译错误:没有函数重载

锡兰 特征不能有变量(并且没有 protected 成员，因此在派生类中存储数据没有技巧，Ceylon 中的特征是无用的)

幻想 没有泛型/模板

Kotlin 编译错误:父类(super class)型出现两次；委托(delegate)看起来很独特，但它没有用，因为既不能访问 protected 成员，也不能访问委托(delegate)给

的变量。

锈 没有函数重载； trait 不能存储数据；特征不能有定义的方法(带有主体) - 正在处理的问题；

OCaml 编译错误:没有函数重载；它也没有检查我的函数的参数类型，那么它到底有多“静态类型”？!

卷发 编译错误:没有函数重载；它也不会检查函数体，除非它被调用，那么它到底是如何“静态类型化”的呢？它是完全编译的还是解释的？!

戈苏 是个坏笑话，它根本不可用:不能用一种方法编写和实现简单的接口(interface)(错误:ClassFormatError:非法字段修饰符)。谁真正使用这种语言？!

顺便说一句:当我尝试将 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++ 中，使用模板和部分特化，有可能使用肮脏的技巧来更简单地使用特征:

#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

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

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

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

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指示。因此，数量仅取决于当前类中成员函数的数量，而不取决于基类。

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

如果基类只共享一些但不是所有的成员函数，那就更棘手了。