Duck typing

Concept examples

Consider the following pseudo-code for a duck-typed language:

function calculate(a, b, c) => return (a + b) * c example1 = calculate (1, 2, 3) example2 = calculate ([1], [2, 3], 2) example3 = calculate ('apples ', 'and oranges, ', 3) print to_string example1 print to_string example2 print to_string example3

In the example, each time the calculate function is called, objects without related inheritance may be used (numbers, lists and strings). As long as the objects support the "+" and "*" methods, the operation will succeed. If translated to Ruby or Python, for example, the result of the code would be:

9 [1, 2, 3, 1, 2, 3] apples and oranges, apples and oranges, apples and oranges,

Thus, duck typing can work the same as polymorphism, but without inheritance. The only restriction that function calculate places on its arguments is that they implement the "+" and "*" methods.

The duck test can be seen in the following example (in Python). As far as the function in_the_forest is concerned, the Person object is a duck:

In statically typed languages

Certain usually statically typed languages such as Boo and the version 4 release of C# have extra type annotations that instruct the compiler to arrange for type checking of classes to occur at run-time rather than compile time, and include run-time type checking code in the compiled output.

Structural type systems

Duck typing is similar to, but distinct from structural typing. Structural typing is a static typing system that determines type compatibility and equivalence by a type's structure, whereas duck typing is dynamic and determines type compatibility by only that part of a type's structure that is accessed during run time.

The OCaml, Scala, Go, Elm, and Gosu languages support structural typing to varying degrees.

Protocols and Interfaces

Protocols and interfaces can provide some of the benefits of duck typing, but duck typing is distinct in that no explicit interface is defined. For example, if a third party library implements a class that cannot be modified, a client cannot use an instance of it with an interface unknown to that library even if the class does in fact satisfy the interface requirements. (A common solution to this problem is the Adapter pattern.) Duck typing would allow this. Again, all of an interface must be satisfied for compatibility.

Templates or generic types

Template, or generic functions or methods apply the duck test in a static typing context; this brings all the advantages and disadvantages of static versus dynamic type checking in general. Duck typing can also be more flexible in that only the methods actually called at run time need to be implemented, while templates require implementation of all methods that cannot be proven unreachable at compile time.

Examples include the languages C++ and D with templates, which developed from Ada generics.

Criticism of the term itself

Use of the term "duck typing" has been considered superfluous in light of the fact that other terms, such as dynamic binding, express the concept more clearly. To proponents of static type checking, duck typing suggests the absence of typing, making its incorporation of the term typing appear incoherent.

History

Alex Martelli made an early (2000) use of the term in a message to the comp.lang.python newsgroup:

In other words, don't check whether it IS-a duck: check whether it QUACKS-like-a duck, WALKS-like-a duck, etc, etc, depending on exactly what subset of duck-like behaviour you need to play your language-games with.

In C#

As of C# 4.0 the compiler and runtime collaborate to implement dynamic member lookup.

In the following C# 6.0 code, the parameter duck of the method Program.InTheForest is declared as dynamic.

In CFML

The Web application scripting language CFML allows function arguments to be specified as having type any. For this sort of argument, an arbitrary object can be passed in and method calls are bound dynamically at runtime. If an object does not implement a called method, a runtime exception is thrown that can be caught and handled gracefully. In ColdFusion 8, this can be picked up as a defined event onMissingMethod() rather than through an exception handler. An alternative argument type of WEB-INF.cftags.component restricts the passed argument to be a ColdFusion Component (CFC), which provides better error messages should a non-object be passed in.

Other CFML application servers such as Lucee work analogously to ColdFusion's CFML implementation.

In Cobra

In addition to static typing, Cobra allows one to declare objects of type 'dynamic' and send any message to them. At run-time the message passing will either succeed or throw an exception. The 'dynamic' type is the default for object variables and method arguments when a type has not been explicitly declared for them. This feature was inspired by Objective-C.

In Common Lisp

Common Lisp includes an object-oriented system (Common Lisp Object System, or shorter CLOS) providing classes with multiple inheritance and generic functions that can specialize on multiple arguments. The combination of CLOS and Lisp's dynamic typing make duck typing a common programming style in Common Lisp.

With Common Lisp one also does not need to query the types, since at runtime an error will be signaled when a generic function is not applicable. The error can be handled with the condition system of Common Lisp. Methods are defined outside of classes and can also be defined for specific objects.

The usual development style of Common Lisp (by using a Lisp REPL like SLIME) allows also the interactive repair:

? (defclass cat () ()) #<STANDARD-CLASS CAT> ? (quack (make-instance 'cat)) > Error: There is no applicable method for the generic function: > #<STANDARD-GENERIC-FUNCTION QUACK #x300041C2371F> > when called with arguments: > (#<CAT #x300041C7EEFD>) > If continued: Try calling it again 1 > (defmethod quack ((a-cat cat)) (print "The cat imitates a duck.")) #<STANDARD-METHOD QUACK (CAT)> 1 > (continue) "The cat imitates a duck."

This way software can be developed by extending partially working duck typed code.

In Go

In Go, any type that has the methods required for an interface can act as that interface, regardless of whether or not it was explicitly defined or intended. Because of this, multiple sources use the term duck typing when describing Go interfaces. However, Go typically checks for compatibility at compile-time, which is why the Go designers describe the interfaces as a form of structural typing.

Although in general duck typing can be implemented with reflection, the support for reflection in Go is limited. Calling methods through reflection requires the use of interface type assertions. The runtime validates that the underlying type of a value supports all methods defined in the given interface. In duck typing, the runtime validates each method invokation separately.

In Groovy

Groovy uses duck typing by default when calling a method.

In Java

In Java duck typing may be achieved with reflection.

Running the DuckTyping class will produce the following output:

I'm a Duck, I can walk... I'm a Duck, I can swim... I'm a Duck, I can quack... I'm a Person, I can walk... I'm a Person, I can swim... Method not found: Person.quack()

In JavaScript

The function inTheForest() above checks that the object passed to it has a member quack and a member feathers before attempting to invoke them. More explicit tests could also be made, wherein the runtime types of the members are also checked:

In Julia

Julia uses multiple dispatch, generic functions, optional type annotations and automatic type inference by default, the type Any is the super-type of the whole hierarchy.

In Lua

Lua supports duck typing as part of the Metatable weak-typing system. Any reference to a table's member function is checked dynamically at run-time. If an object does not implement the requested function, a run-time error is produced. If a data member is requested, but does not exist, a nil value is returned.

Output:

Quaaaaaack! The duck has white and gray feathers. The person imitates a duck. The person takes a feather from the ground and shows it.

In Objective-C

Objective-C, a cross between C and Smalltalk, allows one to declare objects of type 'id' and send any message to them (provided the method is declared somewhere), like in Smalltalk. The sender can test an object to see, if it responds to a message, the object can decide at the time of the message whether it will respond to it or not, and, if the sender sends a message a recipient cannot respond to, an exception is raised. Thus, duck typing is fully supported by Objective-C.

Output:

Quaaaack! The person imitates a duck.

In Perl

Perl looks for method definitions in package set with bless function.

Output:

Quaaaaaack! The duck has white and gray feathers. The person imitates a duck. The person takes a feather from the ground and shows it.

In PHP

PHP leans towards the Java convention of using inheritance and the user land type system (type hinting method arguments or using instanceof class or interface) in favour of duck typing. Below is an example of duck typing:

Output:

Quack Flap, Flap I try to imitate a duck quack I take an airplane

In PowerShell

This is the concept example from the beginning of the page.

In Python

Duck typing is heavily used in Python, with the canonical example being file-like classes (for example, cStringIO allows a Python string to be treated as a file).

Output:

Quack, quack! Flap, Flap! I'm Quackin'! I'm Flyin'!

According to the EAFP principle, instead of checking to see, if some purportedly Duck-like object has a quack() method (using if hasattr(mallard, "quack"): ...), it's usually preferable to wrap the attempted quack with proper exception handling:

Or, a more common use of the principle is to just let the exception "bubble up", that is, to let the exception be raised, and let whatever function or method called the code in question deal with it (or, if nothing deals with it, to let the exception be raised to the user). This gives better feedback on bad input, and avoids masking bugs.

In Ruby

Output:

Quaaaaaack! The duck has white and gray feathers. The person imitates a duck. The person takes a feather from the ground and shows it.

In Smalltalk

Duck typing is fundamental to Smalltalk. Variables have no data type, and can hold any object. Behavior is triggered by messages sent between objects. Any arbitrary string can be sent to any object as a message. The receiving object checks its method list for a matching behavior. This is the only approximation of type-checking in the language.

Moreover, a message with no matching method is not necessarily an error. In this case, the receiving object triggers its own doesNotUnderstand: method, inherited from Object. The default implementation raises an error, but this can be overridden to perform arbitrary operations based on the original message.

In Typescript

Typescript is unusual, in that it is a statically-typed language that uses duck-typing pervasively at compile time. Compile-time type checking is always based on type signatures, never inheritance. Run time type checking is done using the "instanceof" operator, which is not duck-typed.

This is similar to Go's "structural typing", but it applies to both classes and interfaces. Unlike Go, Typescript has an "implements" keyword to declare that a type should implement a particular interface. It is not required—if a class implements all the members of interface IFoo, it can be used as an IFoo. An explicit "implements" keyword provides compile-time errors, if a developer fails to correctly implement an interface that he or she had intended to.

In the following example, it is legal to assign a Seagull object to a Duck variable, even though neither class inherits from the other. Because Seagull implements both talk() and swim() methods, it can be used as a Duck. A Parrot object cannot be assigned to a Duck variable because it does not implement any swim() method. A Fish object cannot be assigned to a Duck variable. Even though it implements both talk() and swim() methods, the talk() method has the wrong signature (returning a void rather than a string).