PseudoInterface

PseudoInterface is a term used in software design to describe a construct or pattern that exposes a defined set of methods and properties that an object should provide, without requiring an explicit interface declaration. It represents a contract by convention rather than by language-enforced nominal types. The concept is common in languages that support duck typing or structural typing, and it is used to enable polymorphism across otherwise unrelated types.

In dynamically typed languages, pseudo-interfaces rely on duck typing: if an object implements the expected methods, it can be used wherever the contract is assumed. In languages with nominal typing, developers may document pseudo-interfaces or implement them with mixins, abstract base classes, or type-level constructs that approximate the contract. Some modern typing systems formalize the idea; for example, Python's Protocols and TypeScript's structural typing express interface-like behavior without requiring a class to declare an explicit interface. When discussed under the label pseudo-interface, the emphasis is on the "shape" of an object, not on its declared type.

Advantages of using pseudo-interfaces include flexible code design, easier decoupling, and improved documentation and testing. They also support polymorphic cooperation between disparate components. Limitations include a lack of compile-time enforcement in many languages, which can lead to runtime errors if an object unexpectedly lacks a required method. Tooling such as linters, type checkers, and IDEs can mitigate these risks by validating conformance to the expected shape.

See also: duck typing, interface, structural typing, Protocol (Python), static typing.