有没有静态鸭子类型的语言？

Question

Can I specify interfaces when I declare a member?

在考虑了这个问题一段时间后，我突然想到静态鸭子类型的语言可能真的有效。为什么预定义的类不能在编译时绑定到接口？示例：

public interface IMyInterface
{
  public void MyMethod();
}

public class MyClass  //Does not explicitly implement IMyInterface
{
  public void MyMethod()  //But contains a compatible method definition
  {
    Console.WriteLine("Hello, world!");
  }
}

...

public void CallMyMethod(IMyInterface m)
{
  m.MyMethod();
}

...

MyClass obj = new MyClass();
CallMyMethod(obj);     // Automatically recognize that MyClass "fits" 
                       // MyInterface, and force a type-cast.

您知道支持这种功能的任何语言吗？它对 Java 或 C# 有帮助吗？它在某些方面存在根本缺陷吗？我知道你可以继承 MyClass 并实现接口或使用适配器设计模式来完成同样的事情，但这些方法看起来像是不必要的样板代码。

Answer 1

这个问题的全新答案Go has exactly this feature。我认为它真的很酷也很聪明（尽管我很想看看它在现实生活中的表现如何），并且对它的思考表示赞赏。

据记录 in the official documentation (as part of the Tour of Go, with example code):

接口是隐式实现的

一个类型通过实现它的方法来实现一个接口。有 没有明确的意图声明，没有“implements”关键字。

隐式接口将接口的定义与其 实现，然后可以出现在任何包中 预先安排。

Answer 2

在 C++ 中使用模板怎么样？

class IMyInterface  // Inheritance from this is optional
{
public:
  virtual void MyMethod() = 0;
}

class MyClass  // Does not explicitly implement IMyInterface
{
public:
  void MyMethod()  // But contains a compatible method definition
  {
    std::cout << "Hello, world!" "\n";
  }
}

template<typename MyInterface>
void CallMyMethod(MyInterface& m)
{
  m.MyMethod();  // instantiation succeeds iff MyInterface has MyMethod
}

MyClass obj;
CallMyMethod(obj);     // Automatically generate code with MyClass as 
                       // MyInterface

我还没有真正编译过这段代码，但我相信它是可行的，并且是对原始提议（但不工作）代码的一个相当简单的 C++ 化。

Answer 3

根据定义，静态类型语言在编译时检查类型，而不是运行时。上述系统的一个明显问题是编译器会在程序编译时检查类型，而不是在运行时。

现在，您可以在编译器中构建更多智能，以便它可以派生类型，而不是让程序员显式声明类型；编译器可能会看到 MyClass 实现了 MyMethod() 方法，并相应地处理这种情况，无需显式声明接口（如您所建议的那样）。这样的编译器可以利用类型推断，例如Hindley-Milner。

当然，像 Haskell 之类的一些静态类型语言已经做了一些与您的建议类似的事情类似； Haskell 编译器能够推断类型（大部分时间），而无需显式声明它们。但是很明显，Java/C# 没有这个能力。

Answer 4

我不明白这一点。为什么不明确说明该类实​​现了接口并完成了它？实现接口是告诉其他程序员这个类应该按照接口定义的方式运行。仅在方法上具有相同的名称和签名并不能保证设计者的意图是使用该方法执行类似的操作。可能是这样，但为什么要把它留给解释（和滥用）呢？

您可以在动态语言中成功“摆脱”这一点的原因更多地与 TDD 有关，而不是与语言本身有关。在我看来，如果该语言能够为使用/查看代码的其他人提供此类指导，那么您应该使用它。它实际上提高了清晰度，值得添加几个额外的字符。在您无权执行此操作的情况下，适配器的作用与显式声明接口与其他类的关联方式相同。

Answer 5

F# 支持静态鸭子类型，但有一个问题：您必须使用成员约束。详细信息可在此blog entry 中找到。

引用博客中的示例：

let inline speak (a: ^a) =
    let x = (^a : (member speak: unit -> string) (a))
    printfn "It said: %s" x
    let y = (^a : (member talk: unit -> string) (a))
    printfn "Then it said %s" y

type duck() =
    member x.speak() = "quack"
    member x.talk() = "quackity quack"
type dog() =
    member x.speak() = "woof"
    member x.talk() = "arrrr"

let x = new duck()
let y = new dog()
speak x
speak y

Answer 6

ML 系列中的大多数语言都支持具有推理和约束类型方案的结构类型，这是令人讨厌的语言设计器术语，看起来很可能就是您所说的“静态鸭子-在原始问题中输入”。

这个家族中比较流行的语言包括：Haskell、Objective Caml、F# 和 Scala。当然，与您的示例最匹配的是Objective Caml。这是您的示例的翻译：

open Printf

class type iMyInterface = object
  method myMethod: unit
end

class myClass = object
  method myMethod = printf "Hello, world!"
end

let callMyMethod: #iMyInterface -> unit = fun m -> m#myMethod

let myClass = new myClass

callMyMethod myClass

注意：您使用的某些名称必须更改以符合 OCaml 的标识符大小写语义概念，否则，这是一个非常简单的翻译。

另外，值得注意的是，callMyMethod 函数中的类型注释和iMyInterface 类类型的定义都不是绝对必要的。 Objective Caml 可以推断您示例中的所有内容，而无需任何类型声明。

Answer 7

TypeScript!

好吧，好吧...所以它是一个 javascript 超集，可能不构成“语言”，但这种静态鸭子类型在 TypeScript 中至关重要。

Answer 8

Boo 绝对是一种静态鸭式语言：http://boo.codehaus.org/Duck+Typing

摘录：

Boo 是一种静态类型语言， 像 Java 或 C#。这意味着你的嘘声 应用程序的运行速度将与 那些用其他静态类型编码的 .NET 或 Mono 的语言。但是使用 有时是静态类型的语言 将你限制在一个僵化和 冗长的编码风格，带有 有时必要的类型声明 （如“x as int”，但这不是 由于 boo 的类型，经常需要 推理），有时是必要的 类型转换（请参阅转换类型）。嘘 支持类型推断和 最终泛型在这里有所帮助，但是...

有时候放弃是合适的 静电提供的安全网 打字。也许你只是想探索 无需过多担心的 API 方法签名或者你可能是 创建与外部对话的代码 COM 对象等组件。任何一个 选择不应该是你的方式 我的。

除了普通类型，如 object, int, string...boo 有一个 称为“鸭子”的特殊类型。术语 受到红宝石编程的启发 语言的鸭子打字功能（“如果 像鸭子一样走路，像鸭子一样嘎嘎叫 鸭子，一定是鸭子”）。

Answer 9

新版本的 C++ 朝着静态鸭子类型的方向发展。你可以有一天（今天？）写这样的东西：

auto plus(auto x, auto y){
    return x+y;
}

如果x+y没有匹配的函数调用，它将无法编译。

至于你的批评：

为您传递给它的每种不同类型创建一个新的“CallMyMethod”，因此它并不是真正的类型推断。

但它是类型推断（你可以说foo(bar)，其中foo 是一个模板函数），并且具有相同的效果，除了它更省时并且在编译代码中占用更多空间。

否则，您将不得不在运行时查找该方法。您必须找到一个名称，然后检查该名称是否包含具有正确参数的方法。

或者，您必须存储所有关于匹配接口的信息，并查看与接口匹配的每个类，然后自动添加该接口。

在任何一种情况下，这都允许您隐式地意外破坏类层次结构，这对新功能不利，因为它违背了 C#/Java 程序员的习惯。使用 C++ 模板，您已经知道自己处于雷区（而且他们还在添加功能（“概念”）以允许限制模板参数）。

Answer 10

Scala 中的结构类型会做这样的事情。

见Statically Checked “Duck Typing” in Scala

Answer 11

Crystal 是一种静态鸭类型语言。 Example:

def add(x, y)
  x + y
end

add(true, false)

对add 的调用导致此编译错误：

Error in foo.cr:6: instantiating 'add(Bool, Bool)'

add(true, false)
^~~

in foo.cr:2: undefined method '+' for Bool

  x + y
    ^

Answer 12

Visual Basic 9 的预发布设计支持使用动态接口的静态鸭子类型，但为了按时发布，他们删除了功能*。

Answer 13

D (http://dlang.org) 是一种静态编译语言，通过 wrap() 和 unwrap() (http://dlang.org/phobos-prerelease/std_typecons.html#.unwrap) 提供鸭子类型。

Answer 14

听起来像 Mixins 或 Traits：
http://en.wikipedia.org/wiki/Mixin
http://www.iam.unibe.ch/~scg/Archive/Papers/Scha03aTraits.pdf

Answer 15

在我的编程语言Heron 的最新版本中，它通过称为as 的结构子类型强制运算符支持类似的东西。所以而不是：

MyClass obj = new MyClass();
CallMyMethod(obj);

你会写：

MyClass obj = new MyClass();
CallMyMethod(obj as IMyInterface);

就像在您的示例中一样，在这种情况下，MyClass 不必显式实现 IMyInterface，但如果确实如此，则转换可能会隐式发生，并且可以省略 as 运算符。

我在this article 中写了更多关于我称之为显式结构子类型的技术。