Question

I’ve been thinking lately, would it be a good form of syntactic sugar in languages like Java and C#, to include a ‘duck’ type as a method parameter type? This would look as follows:

void myFunction(duck foo) {    foo.doStuff(); } 

This could be syntactic sugar for invoking doStuff() via reflection, or it could be implemented differently. Foo could be any type. If foo does not have a doStuff() method, this would throw a runtime exception. The point is that you would have the benefits of the more rigid pre-specified interface paradigm (performance, error checking) when you want them, i.e. most of the time. At the same time, you’d have a simple, clean-looking backdoor to duck typing, which would allow you to cleanly make changes not foreseen in the initial design without massive refactoring. Furthermore, it would likely be 100% backwards compatible and mesh cleanly with existing language constructs. I think this might help cut down on the overengineered just-in-case programming style that leads to confusing, cluttered APIs. Do you believe that something like this would be a good or bad thing in static OO languages like C# and Java?

Answer 1

The dynamic keyword supports these exact semantics and will be in C# 4.0.

It is not just for reflection, though. It is an implementation of dynamic dispatch which uses reflection only if no other mechanism is available.

This question also has lots of good information.