Editing Multiple dispatch (section)

====Expressiveness and modularity====

In most popular programming languages, source code is delivered and deployed in granules of functionality which we will here call ''packages''; actual terminology for this concept varies between language.  Each package may contain multiple type, value, and function definitions, packages are often compiled separately in languages with a compilation step, and a non-cyclical dependency relationship may exist.  A complete program is a set of packages, with a ''main package'' which may depend on several other packages, and the whole program consisting of the transitive closure of the dependency relationship.

The so-called [[expression problem]] relates to the ability for code in a depending package to extend behaviors (functions or datatypes) defined in a base package from within an including package, without modifying the source to the base package.  Traditional single-dispatch OO languages make it trivial to add new datatypes but not new functions; traditional functional languages tend to have the opposite effect, and multiple dispatch, if implemented correctly, allows both.  It is desirable for an implementation of multiple dispatch to have the following properties:

* It is possible to define different "cases" of a multi-method from within different packages without modifying the source of a base package.
* Inclusion of another package in the program should not change the behavior of a given multi-method call, when the call does not use any datatypes defined in the package.
* Conversely, if a datatype is defined in a given package, and a multi-method extension using that type is also defined in the same package, and a value of that type is passed (through a base type reference or into a generic function) into another package with no dependency on that package, and then the multi-method is invoked with that value as an argument, the multi-method case defined in the package which includes the type should be employed.  To put it another way—within a given program, the same multi-method invoked with the same set of arguments should resolve to the same implementation, regardless of the location of the call site, and whether or not a given definition is "in scope" or "visible" at the point of the method call.