1. A method, to be practiced at compile time by a data handling system that supports multimethod function selection on typed data, including subtypes with multiple inheritance, for enabling static-type checking to be performed at run time for overloaded functions, wherein said system includes (i) a set of type definitions, including specification of subtype relationships, (ii) function definitions referring to at least one of the type definitions, each function definition including a definition of arguments, including an argument order and argument positions, and (iii) precedence rules which, in combination with the function argument order, define an ordering of the confusable function instances, for a given set of arguments, the method comprising the steps of: (a) creating from said type definitions a first data structure for representing subtype relationships between data types, the subtype relationships including levels of specificity, such that, within a given subtype relation for a given set of the data types, there is a maximal static argument type which has a lowest level of specificity; (b) creating from said first data structure and said function definitions a partitioning of function instances into confusable sets; (c) ordering the function instances within each confusable set; (d) verifying consistency among the ordered function instances resulting from said step of ordering; (e) identifying any consistency errors with respect to said ordered function instances; (f) signaling an error condition upon the identification of any such consistency error; (g) extracting, for each confusable set, information as the maximal static argument types of the functions are for each of the argument positions; and identifying confusable sets of function instances as confusable sets which potentially contain all functions applicable to the function invocation, the applicable functions having arguments, the arguments having argument types which are supertypes or subtypes of the compile time argument types of the function invocation; whereby, one of the applicable functions is chosen for execution at run time, in accordance with actual types of the function arguments.
1. A method, to be practiced at compile time by a data handling system that supports multimethod function selection on typed data, including subtypes with multiple inheritance, for enabling static-type checking to be performed at run time for overloaded functions, wherein said system includes (i) a set of type definitions, including specification of subtype relationships, (ii) function definitions referring to at least one of the type definitions, each function definition including a definition of arguments, including an argument order and argument positions, and (iii) precedence rules which, in combination with the function argument order, define an ordering of the confusable function instances, for a given set of arguments, the method comprising the steps of: (a) creating from said type definitions a first data structure for representing subtype relationships between data types, the subtype relationships including levels of specificity, such that, within a given subtype relation for a given set of the data types, there is a maximal static argument type which has a lowest level of specificity; (b) creating from said first data structure and said function definitions a partitioning of function instances into confusable sets; (c) ordering the function instances within each confusable set; (d) verifying consistency among the ordered function instances resulting from said step of ordering; (e) identifying any consistency errors with respect to said ordered function instances; (f) signaling an error condition upon the identification of any such consistency error; (g) extracting, for each confusable set, information as the maximal static argument types of the functions are for each of the argument positions; and identifying confusable sets of function instances as confusable sets which potentially contain all functions applicable to the function invocation, the applicable functions having arguments, the arguments having argument types which are supertypes or subtypes of the compile time argument types of the function invocation; whereby, one of the applicable functions is chosen for execution at run time, in accordance with actual types of the function arguments. 2. A method as set forth in claim 1, further comprising the step of storing said first data structure, the ordered function instances for each confusable set, and the extracted maximal type information.