Methods to support multimethod function overloading with compile-time type checking

Claim 3

A method as set forth in claim 1, wherein each of said type definitions further comprises a set of precedence rules which in combination with the function argument order, define an ordering of the confusable function instances, and said method further comprises the step of ordering the function instances within each confusable set.

Claim 4

A method as set forth in claim 2, further comprising the step of verifying consistency among the ordered function instances resulting from said step of ordering.

Claim 5

A method as set forth in claim 3, further comprising the steps of: (a) identifying any consistency errors with respect to said ordered function instances; and (b) signaling an error condition upon the identification of any such consistency error.

Claim 6

A method as set forth in claim 3, further comprising the step of extracting, for each confusable set, information as to what the maximal static argument types of the functions are for each formal argument position.

Claim 7

A method as set forth in claim 5, further comprising the step of storing said first data structure, the ordered function instances for each confusable set, and the extracted maximal type information.

Claim 8

A method as set forth in claim 5, further comprising the step of providing said first data structure, the ordered function instances for each confusable set, and the extracted maximal type information to a compile-time type checking module wherein said static-type checking for overloaded functions in said data handling system may be performed.

Claim 11

A method as set forth in claim 8, further comprising the step of determining from the confusable sets selected via said step of selecting, the most specific applicable function instance for the static argument types of the function invocation.

Claim 12

A method as set forth in claim 9, further comprising the step of checking that the result type of said most specific applicable function instance is consistent with static invocation context.

Claim 13

A method as set forth in claim 10, further comprising the steps of: (a) identifying any consistency errors with respect to said most specific applicable function instance; and (b) signaling an error condition upon the identification of any most specific applicable function instance consistency error.

Claim 14

A method as set forth in claim 10, further comprising the step of identifying potentially applicable function instances which might be called due to allowable substitutions of subtype instances as actual arguments.

Claim 15

A method as set forth in claim 12, further comprising the step of creating a second data structure for the function instances, identified in the said step of identifying potentially applicable function instances, which may be utilized at the time of program execution to facilitate dynamic selection of the most specific applicable function instance for the types of all the actual arguments of the invocation.

Claim 16

A method as set forth in claim 13, wherein said second data structure is a decision table.

Claim 19

A method as set forth in claim 15, further comprising the step of utilizing a function precedence order to refine the search for applicable function instances among the potentially applicable function instances at runtime.

Claim 22

A method as set forth in claim 17, further comprising the step of utilizing a function precedence order and the extension of that partial order to a total order over a confusable set to refine the search for applicable function instances at compile time.

Claim 25

Apparatus for enabling compile time static-type checking to be performed for overloaded functions in a data handling system that supports multimethod function selection on typed data, including subtypes with multiple inheritance, wherein said system includes a set of type definitions, including specification of subtype relationships, and function definitions referring to at least one of the type definitions, the apparatus comprising: static-type checking preparation means for creating a partitioning of function instances into confusable sets based on said set of type definitions and function definitions, said static-type checking preparation means further comprising: (a) means for creating from said type definitions a first data structure for representing subtype relationships between data types; and (b) means for creating from said first data structure and said function definitions a plurality of confusable sets of function instances; whereby at compile time, confusable sets of function instances are identified 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; and whereby, at run time, one of the applicable functions is chosen for execution in accordance with the types of function arguments.

Claim 26

Apparatus for enabling compile time static-type checking to be performed for overloaded functions in a data handling system that supports multimethod function selection on typed data, including subtypes with multiple inheritance, wherein said system includes a set of type definitions, including specification of subtype relationships, and function definitions referring to at least one of the type definitions, the apparatus comprising: static-type checking preparation means for creating a partitioning of function instances into confusable sets based on said set of type definitions and function definitions, said static-type checking preparation means further comprising: (a) means for creating from said type definitions a first data structure for representing subtype relationships between data types; and (b) means for creating from said first data structure and said function definitions a plurality of confusable sets of function instances; whereby at compile time, confusable sets of function instances are identified 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; and whereby, at run time, one of the applicable functions is chosen for execution in accordance with the types of function arguments.

Claim 27

Apparatus as set forth in claim 20, wherein each of said type definitions further includes precedence rules which in combination with the function argument order, define an ordering of the confusable function instances, and further comprises means for ordering the function instances within each confusable set.

Claim 28

Apparatus as set forth in claim 21, further comprising means for verifying consistency among ordered functions in a confusable set.

Claim 29

Apparatus as set forth in claim 22, wherein said means for verifying further comprises: (a) means for identifying any consistency errors with respect to ordered function instances in a confusable set; and (b) means for signaling an error condition upon the identification of any such consistency error.

Claim 30

Apparatus as set forth in claim 22, further comprising means for extracting, for each confusable set, information as to what the maximal static argument types of the functions are for each formal argument position.

Claim 31

Apparatus as set forth in claim 24, further comprising means for storing said first data structure, the ordered function instances for each confusable set, and the extracted maximal type information.

Claim 32

Apparatus as set forth in claim 24, further comprising means for providing said first data structure, the ordered function instances for each confusable set, and the extracted maximal type information to a compile-time type checking module wherein said static-type checking for overloaded functions in said system may be performed.

Claim 33

Apparatus for performing static-type checking for overloaded function invocations in a programming language system that supports multimethod function selection on typed data, including subtypes with multiple inheritance, wherein said system includes a set of type definitions, including specification of subtype relationships, function definitions referring implicitly or explicitly to at least two of the type definitions, and precedence rules which in combination with the function argument order, define an ordering of the confusable function instances, for a given set of arguments, and further wherein said system includes a first data structure for representing subtype relationships as specified in said type definitions, a partitioning of function instances into confusable sets within which the function instances are ordered and, for each confusable set, information as to what the maximal static argument types of the functions are for each formal argument position, comprising: (a) means, operable at compile time, for identifying, within a source program input to said program language system for compilation, a function invocation; (b) means, operable at compile time, for selecting confusable sets that are potentially associated with the function invocation based on said maximal static argument information; and (c) means, operable at compile time, for 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, at run time, one of the applicable functions is chosen for execution in accordance with the types of function arguments.

Claim 34

Apparatus for performing static-type checking for overloaded function invocations in a programming language system that supports multimethod function selection on typed data, including subtypes with multiple inheritance, wherein said system includes a set of type definitions, including specification of subtype relationships, function definitions referring implicitly or explicitly to at least two of the type definitions, and precedence rules which in combination with the function argument order, define an ordering of the confusable function instances, for a given set of arguments, and further wherein said system includes a first data structure for representing subtype relationships as specified in said type definitions, a partitioning of function instances into confusable sets within which the function instances are ordered and, for each confusable set, information as to what the maximal static argument types of the functions are for each formal argument position, comprising: (a) means, operable at compile time, for identifying, within a source program input to said program language system for compilation, a function invocation; (b) means, operable at compile time, for selecting confusable sets that are potentially associated with the function invocation based on said maximal static argument information; and (c) means, operable at compile time, for 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, at run time, one of the applicable functions is chosen for execution in accordance with the types of function arguments.

Claim 35

Apparatus as set forth in claim 27, further comprising means for determining from the confusable sets selected, via said means for selecting, the most specific applicable function instance for the static argument types of the function invocation.

Claim 36

Apparatus as set forth in claim 28, further comprising means for checking that the result type of said most specific applicable function instance is consistent with static invocation context.

Claim 37

Apparatus as set forth in claim 29, further comprising: (a) means for identifying any consistency errors with respect to said most specific applicable function instance; and (b) means for signaling an error condition upon the identification of any most specific applicable function instance consistency error.

Claim 38

Apparatus as set forth in claim 30, further comprising means for identifying potentially applicable function instances which may be called due to allowable substitutions of subtype instances as actual arguments.

Claim 39

Apparatus as set forth in claim 31, further comprising means for creating a second data structure for the function instances identified by said means for identifying potentially applicable function instances which may be utilized at the time of program execution to facilitate dynamic selection of the most specific applicable function instance for the types of all the actual arguments of the invocation.

Claim 40

Apparatus as set forth in claim 32, wherein said second data structure is a decision table.

Claim 41

An execution module apparatus for executing object code compiled by a data handling system that supports function overloading and multimethod function selection on typed data, including subtypes with multiple inheritance, the execution module apparatus comprising: a program execution selector, including: means for selecting the most specific applicable function instance, according to a function precedence order, for types of all actual arguments of a function invocation, confusable sets of function instances having been identified at compile time 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, the function precedence order being based on the function instances of the identified confusable sets; and means for refining the search for applicable function instances among the potentially applicable function instances at runtime utilizing the function precedence order.

Claim 42

An execution module apparatus for executing object code compiled by a data handling system that supports function overloading and multimethod function selection on typed data, including subtypes with multiple inheritance, the execution module apparatus comprising: a program execution selector, including: means for selecting the most specific applicable function instance, according to a function precedence order, for types of all actual arguments of a function invocation, confusable sets of function instances having been identified at compile time 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, the function precedence order being based on the function instances of the identified confusable sets; and means for refining the search for applicable function instances among the potentially applicable function instances at runtime utilizing the function precedence order.

Claim 43

Apparatus for performing static-type checking for overloaded functions in a data handling system that supports multimethod function selection on typed data, including subtypes with multiple inheritance, comprising: (a) means for partitioning sets of overloaded function instances utilizing confusable sets; and (b) means for identifying function instances which are potentially applicable to a function invocation based on said partitioning; whereby, at compile time, the confusable sets of function instances are identified 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; and whereby, one of the applicable functions is chosen for execution at run time, in accordance with actual types of the function arguments.

Claim 44

Apparatus for performing static-type checking for overloaded functions in a data handling system that supports multimethod function selection on typed data, including subtypes with multiple inheritance, comprising: (a) means for partitioning sets of overloaded function instances utilizing confusable sets; and (b) means for identifying function instances which are potentially applicable to a function invocation based on said partitioning; whereby, at compile time, the confusable sets of function instances are identified 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; and whereby, one of the applicable functions is chosen for execution at run time, in accordance with actual types of the function arguments.

Claim 45

Apparatus as set forth in claim 35, further comprising means for utilizing a function precedence order and the extension of that partial order to a total order over a confusable set to refine the search for applicable function instances at compile time.

Claim 46

Apparatus for performing static-type checking for overloaded functions in a data handling system that supports multimethod function selection on typed data, including subtypes with multiple inheritance, comprising: (a) means for partitioning sets of overloaded function instances utilizing confusable sets; and (b) means for accelerating the selection of confusable sets that may contain function instances applicable to a function invocation, utilizing maximal static argument types of a confusable set; whereby, at compile time, confusable sets of function instances are identified 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; and whereby, one of the applicable functions is chosen for execution at run time, in accordance with actual types of the function arguments.

Claim 47

Apparatus for performing static-type checking for overloaded functions in a data handling system that supports multimethod function selection on typed data, including subtypes with multiple inheritance, comprising: (a) means for partitioning sets of overloaded function instances utilizing confusable sets; and (b) means for accelerating the selection of confusable sets that may contain function instances applicable to a function invocation, utilizing maximal static argument types of a confusable set; whereby, at compile time, confusable sets of function instances are identified 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; and whereby, one of the applicable functions is chosen for execution at run time, in accordance with actual types of the function arguments.

Claim 48

A computer program product, for use with 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, the computer program product comprising: a computer-readable recording medium; a set of type definitions, including specification of subtype relationships, recorded on the recording medium; 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, recorded on the recording medium; precedence rules which, in combination with the function argument order, define an ordering of the confusable function instances, for a given set of arguments, recorded on the recording medium; and the following computer program code means, recorded on the recording medium to be read and executed by the data handling system: means, operable at compile time, for 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; means, operable at compile time, for creating from said first data structure and said function definitions a partitioning of function instances into confusable sets; means, operable at compile time, for ordering the function instances within each confusable set; means, operable at compile time, for creating from said first data structure and said verifying consistency among the ordered function instances resulting from said step of ordering; means, operable at compile time, for creating from said first data structure and said identifying any consistency errors with respect to said ordered function instances; means, operable at compile time, for signaling an error condition upon the identification of any such consistency error; means, operable at compile time, for extracting, for each confusable set, information as to what the maximal static argument types of the functions are for each of the argument positions; means, operable at compile time, for 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; and means, operable at run time, for choosing one of the applicable functions for execution, in accordance with actual types of the function arguments.

Claim 49

A computer program product, for use with 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, the computer program product comprising: a computer-readable recording medium; a set of type definitions, including specification of subtype relationships, recorded on the recording medium; 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, recorded on the recording medium; precedence rules which, in combination with the function argument order, define an ordering of the confusable function instances, for a given set of arguments, recorded on the recording medium; and the following computer program code means, recorded on the recording medium to be read and executed by the data handling system: means, operable at compile time, for 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; means, operable at compile time, for creating from said first data structure and said function definitions a partitioning of function instances into confusable sets; means, operable at compile time, for ordering the function instances within each confusable set; means, operable at compile time, for creating from said first data structure and said verifying consistency among the ordered function instances resulting from said step of ordering; means, operable at compile time, for creating from said first data structure and said identifying any consistency errors with respect to said ordered function instances; means, operable at compile time, for signaling an error condition upon the identification of any such consistency error; means, operable at compile time, for extracting, for each confusable set, information as to what the maximal static argument types of the functions are for each of the argument positions; means, operable at compile time, for 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; and means, operable at run time, for choosing one of the applicable functions for execution, in accordance with actual types of the function arguments.

Claim 50

A computer program product, for use with 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, the computer program product comprising: a computer-readable recording medium; and a set of type definitions, including specification of subtype relationships, recorded on the recording medium; function definitions referring to at least one of the type definitions, recorded on the recording medium; precedence rules which, in combination with the function argument order, define an ordering of the confusable function instances, for a given set of arguments, recorded on the recording medium; a first data structure, recorded on the recording medium, for representing (i) subtype relationships as specified in said type definitions, 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, (ii) a partitioning of function instances into confusable sets within which the function instances are ordered, and (iii) for each confusable set, information as to what the maximal static argument types of the functions are for each of the argument positions; and the following computer program code means, recorded on the recording medium to be read and executed by the data handling system: means, operable at compile time, for inputting a source program to said system; means, operable at compile time, for selecting confusable sets that are potentially associated with a function invocation in said source program based on said maximal static argument information; means, operable at compile time, for determining from the confusable sets selected, via said step of selecting, the most specific applicable function instance for the static argument types of the function invocation; means, operable at compile time, for checking that the result type of said most specific applicable function instance is consistent with the static invocation context in which it occurs; means, operable at compile time, for identifying any consistency errors with respect to said most specific applicable function instance; means, operable at compile time, for signaling an error condition upon the identification of any most specific applicable function instance consistency error; means, operable at compile time, for identifying function instances from the confusable sets, the identified function instances having actual argument types such that the argument types of the identified function instances and the function invocation have subtype relationships so as to allow the identified function instances to be called from the function invocation; means, operable at compile time, for creating a second data structure for the function instances identified by the means for identifying which may be utilized at the time of program execution to facilitate dynamic selection of the most specific applicable function instance for the types of all the actual arguments of the invocation; means, operable at compile time, for 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; and means, operable at run time, for choosing one of the applicable functions for execution, in accordance with actual types of the function arguments.

Claim 51

A computer program product, for use with 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, the computer program product comprising: a computer-readable recording medium; and a set of type definitions, including specification of subtype relationships, recorded on the recording medium; function definitions referring to at least one of the type definitions, recorded on the recording medium; precedence rules which, in combination with the function argument order, define an ordering of the confusable function instances, for a given set of arguments, recorded on the recording medium; a first data structure, recorded on the recording medium, for representing (i) subtype relationships as specified in said type definitions, 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, (ii) a partitioning of function instances into confusable sets within which the function instances are ordered, and (iii) for each confusable set, information as to what the maximal static argument types of the functions are for each of the argument positions; and the following computer program code means, recorded on the recording medium to be read and executed by the data handling system: means, operable at compile time, for inputting a source program to said system; means, operable at compile time, for selecting confusable sets that are potentially associated with a function invocation in said source program based on said maximal static argument information; means, operable at compile time, for determining from the confusable sets selected, via said step of selecting, the most specific applicable function instance for the static argument types of the function invocation; means, operable at compile time, for checking that the result type of said most specific applicable function instance is consistent with the static invocation context in which it occurs; means, operable at compile time, for identifying any consistency errors with respect to said most specific applicable function instance; means, operable at compile time, for signaling an error condition upon the identification of any most specific applicable function instance consistency error; means, operable at compile time, for identifying function instances from the confusable sets, the identified function instances having actual argument types such that the argument types of the identified function instances and the function invocation have subtype relationships so as to allow the identified function instances to be called from the function invocation; means, operable at compile time, for creating a second data structure for the function instances identified by the means for identifying which may be utilized at the time of program execution to facilitate dynamic selection of the most specific applicable function instance for the types of all the actual arguments of the invocation; means, operable at compile time, for 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; and means, operable at run time, for choosing one of the applicable functions for execution, in accordance with actual types of the function arguments.

Claim 52

A computer program product, for use with 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, the computer program product comprising: a computer-readable recording medium; a set of type definitions, including specification of subtype relationships, recorded on the recording medium; function definitions referring to at least one of the type definitions, recorded on the recording medium; precedence rules which, in combination with the function argument order, define an ordering of the confusable function instances, for a given set of arguments, recorded on the recording medium; and the following computer program code means, recorded on the recording medium to be read and executed by the data handling system: means, operable at compile time, for 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; means, operable at compile time, for creating from said first data structure and said function definitions a partitioning of function instances into confusable sets; means, operable at compile time, for ordering the function instances within each confusable set; means, operable at compile time, for verifying consistency among the ordered function instances resulting from said step of ordering; means, operable at compile time, for identifying any consistency errors with respect to said ordered function instances; means, operable at compile time, for signaling an error condition upon the identification of any such consistency error; means, operable at compile time, for extracting, for each confusable set, information as to what the maximal static argument types of the functions are for each of the argument positions; means, operable at compile time, for inputting a program to said data handling system; means, operable at compile time, for selecting confusable sets that are potentially associated with a function invocation in said program based on said maximal static argument information; means, operable at compile time, for determining from the confusable sets selected, via said step of selecting, the most specific applicable function instance for the static argument types of the function invocation; means, operable at compile time, for checking that the result type of said most specific applicable function instance is consistent with the static invocation context in which it occurs; means, operable at compile time, for identifying any consistency errors with respect to said most specific applicable function instance; means, operable at compile time, for signaling an error condition upon the identification of any most specific applicable function instance consistency error; means, operable at compile time, for identifying function instances from the confusable sets, the identified function instances having actual argument types such that the argument types of the identified function instances and the function invocation have subtype relationships so as to allow the identified function instances to be called from the function invocation; means, operable at compile time, for creating a second data structure for the function instances identified by the means for identifying which may be utilized at the time of program execution to facilitate dynamic selection of the most specific applicable function instance for the types of all the actual arguments of the invocation; means, operable at compile time, for 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; and means, operable at compile time, for choosing one of the applicable functions for execution, in accordance with actual types of the function arguments.

Claim 53

A computer program product, for use with 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, the computer program product comprising: a computer-readable recording medium; a set of type definitions, including specification of subtype relationships, recorded on the recording medium; function definitions referring to at least one of the type definitions, recorded on the recording medium; precedence rules which, in combination with the function argument order, define an ordering of the confusable function instances, for a given set of arguments, recorded on the recording medium; and the following computer program code means, recorded on the recording medium to be read and executed by the data handling system: means, operable at compile time, for 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; means, operable at compile time, for creating from said first data structure and said function definitions a partitioning of function instances into confusable sets; means, operable at compile time, for ordering the function instances within each confusable set; means, operable at compile time, for verifying consistency among the ordered function instances resulting from said step of ordering; means, operable at compile time, for identifying any consistency errors with respect to said ordered function instances; means, operable at compile time, for signaling an error condition upon the identification of any such consistency error; means, operable at compile time, for extracting, for each confusable set, information as to what the maximal static argument types of the functions are for each of the argument positions; means, operable at compile time, for inputting a program to said data handling system; means, operable at compile time, for selecting confusable sets that are potentially associated with a function invocation in said program based on said maximal static argument information; means, operable at compile time, for determining from the confusable sets selected, via said step of selecting, the most specific applicable function instance for the static argument types of the function invocation; means, operable at compile time, for checking that the result type of said most specific applicable function instance is consistent with the static invocation context in which it occurs; means, operable at compile time, for identifying any consistency errors with respect to said most specific applicable function instance; means, operable at compile time, for signaling an error condition upon the identification of any most specific applicable function instance consistency error; means, operable at compile time, for identifying function instances from the confusable sets, the identified function instances having actual argument types such that the argument types of the identified function instances and the function invocation have subtype relationships so as to allow the identified function instances to be called from the function invocation; means, operable at compile time, for creating a second data structure for the function instances identified by the means for identifying which may be utilized at the time of program execution to facilitate dynamic selection of the most specific applicable function instance for the types of all the actual arguments of the invocation; means, operable at compile time, for 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; and means, operable at compile time, for choosing one of the applicable functions for execution, in accordance with actual types of the function arguments.