Overload Resolution of dynamic/object types

Last year sometime, I started doing some research about adding traditional overloads to PHP (you heard me, hehe). Basically I created a mechanism that allow devs to overload methods in PHP - which is quite interesting considering that we're talking about a loosely typed language - every variable essentially dynamic by default, minus type hinting

Sooo I remembered that C# 4.0 added similar logic to its codebase and decided to have a look at how C# resolves dynamic types within overloads.

Incidently the same can be said about the object type prior to C# 4.0, for intents and purposes the dynamic type is equivalent to object. eg. substitute dynamic for object prior to C# 4.0

Dynamic types does however get resolved at runtime, eg. late-binding (resolved by what the caller sent to it)

Lets have a quick look at my concerns, consider the following snippet:

 
using System;
 
namespace ConsoleApp
{
    class Program
    {
        static void f(Int32 x) { }
        static void f(dynamic x) {}
 
        static void f(Int32 x, dynamic y) {}
        static void f(dynamic x, Int32 y) {}
 
        static void Main(string[] args)
        {
            f(10); // Works
            f(10, 10); // Ambiguous - obvious
        }
    }
}
 

1. Passing value 10 to method f, will resolve to (Int32 x) - we assume that (Int32 x) defines an exclusion from (dynamic x)?
   
   
2. Passing values 10, 10 to method f, won't resolve - since its impossible to resolve, both methods are equally callable.

 
static void f(Int32 x, dynamic y, Int32 z) {}
static void f(dynamic x, Int32 y, dynamic z) {}
 

 
static void f(Int32 x, dynamic y, Int32 z) {}
static void f(dynamic x, dynamic y, Int32 z) {}
 

1. Cancel out matching types
2. Cancel out least matching types eg if x is Int32 -> (Int32 > dynamic)
3. In the end if we're not left with only one resolveable method, the methods are ambiguous

1. Cancel out matching types
2. Cancel out least matching types eg if x is Int32 -> (Int32 > dynamic)
3. Cancel out methods containing less matching types eg. the second method only contains one definite match, but our first method contains two matches - hence more resolveable.
4. In the end if we're not left with only one resolveable method, the methods are ambiguous

Post comment

Name	*
Email
Title
Body	*
Security Code	*
* Required fields