[Proposal] Structural Typing with dynamic keyword.

[Jason5Lee]

Problem

C# provides dynamic keyword that allows us to write duck-typing code. However, this style of duck-typing is considered low-performance and hard to debug. A better way is structural typing. In this way, we specify an interface as the structural of the dynamic object. When converting a normal object into the structural dynamic type, the compiler or runtime would check whether it CAN (may not really DO) implement this interface, and results in compile error or runtime exception if it can't. In this way, we can approach duck-typing without sacrificing compile-time type checking or intellisense, and we can do more things to optimize.

Proposal

We can use dynamic<IA> to represent a dynamic object with structural interface IA.

interface IA
{
    void A();
}

class A1 : IA
{
    void A() {}
}

class A2
{
    void A() {}
}

class B
{
    void B() {}
}

class Program
{
    static void Test(dynamic<IA> a)
    {
        a.A();
        a.B(); //Compile Error. Interface IA doesn't have method B().
        return a;
    }
    static void Main(string[] args)
    {
        Test(new A1()); //OK, class A1 implements IA.
        Test(new A2()); //OK, even class A2 doesn't implement IA, it CAN implement it.
        Test(new B()); // Compile Error. class B cannot implements IA.
        object o = new A2();
        Test(o); // Compile Error: object class cannot implements IA.
        Test((dynamic<IA>)o); // OK, o references to an instance of A2 that can implements IA.
        o = new B();
        Test((dynamic<IA>)o); // Runtime exception: o references to an instance of B that cannot implements IA.
    }
}

Now let's think about optimization. First, in Test(new A1());, because class A1 implements IA, it doesn't need dynamic binding at all, we can directly cast it to IA. Though in Test(new A2()); we do need dynamic binding as class A2 doesn't implements IA, we can do some optimizations base on the fact that method A must exist because of type checking.

[Unknown6656]

How would it work with multiple interfaces?

dynamic<Iface1, Iface2, Iface 3> foo;
//or
dynamic<Iface1 : Iface2 : Iface 3> bar;

[ufcpp]

see

• Champion "Type Classes (aka Concepts, Structural Generic Constraints)"
• Exploration: Shapes and Extensions
• Discussion: Union and Intersection types
• [Proposal][Roslyn] Add structural typing support
• dynamic interface Proposal.

[bondsbw]

@Unknown6656

How would it work with multiple interfaces?

With intersection types, it would be

dynamic<Iface1 & Iface2 & Iface3> foo;

[HaloFour]

For the most part this proposal seems to be covered by shapes, except for the run time coercion. I don't really see a good way of implementing that doesn't involve reflection. Without the actual interface implementation you lose virtual dispatch and don't really have an alternative. I don't see the CLR providing that kind of functionality, although perhaps the shapes proposal can offer a kind of "unboxing" where the type can be negotiated and a duck-typing wrapper can be emitted at runtime. That seems like a lot of voodoo to put on the compiler, though.

[MkazemAkhgary]

I would rather having keyword defined like aspect rather that all this dynamic<T> noise.

interfaces or classes can not implement or inherit from aspect, since it doesn't really make sense. aspects could expand each other by inheriting from each other.

public aspect ABar
{
    void Bar();
}
public aspect AFoo : ABar
{
    void Foo();
}

No as far as classes or interfaces meets requirements to be duck typed, they can be assigned to aspect.

AFoo x = foo; // only compiles if foo has both definitions for Foo and Bar.