Question

Can I specify interfaces when I declare a member?

After thinking about this question for a while, it occurred to me that a static-duck-typed language might actually work. Why can’t predefined classes be bound to an interface at compile time? Example:

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. 

Do you know of any languages that support such a feature? Would it be helpful in Java or C#? Is it fundamentally flawed in some way? I understand you could subclass MyClass and implement the interface or use the Adapter design pattern to accomplish the same thing, but those approaches just seem like unnecessary boilerplate code.

Answer 1

Statically-typed languages, by definition, check types at compile time, not run time. One of the obvious problems with the system described above is that the compiler is going to check types when the program is compiled, not at run time.

Now, you could build more intelligence into the compiler so it could derive types, rather than having the programmer explicitly declare types; the compiler might be able to see that MyClass implements a MyMethod() method, and handle this case accordingly, without the need to explicitly declare interfaces (as you suggest). Such a compiler could utilize type inference, such as Hindley-Milner.

Of course, some statically typed languages like Haskell already do something similar to what you suggest; the Haskell compiler is able to infer types (most of the time) without the need to explicitly declare them. But obviously, Java/C# don’t have this ability.