Quali altre lingue supportano lo stile di interfaccia di Go senza una dichiarazione esplicita?

Question

Sono un discreto programmatore di hobby e ho una buona familiarità con C++, D, Java, C# e altri.

Con l'eccezione di Go, quasi tutte le lingue richiedono che dichiari esplicitamente che sto implementando un'interfaccia. Questo è ridicolo borderline, dal momento che oggi abbiamo compilatori per le lingue come Haskell, che può fare inferenza di tipo quasi del programma completo con pochissimi suggerimenti.

Quello che sto cercando è un linguaggio di programmazione che fa questo:

interface ITest { 
    void Test(); 
} 

class Test { 
    void Test() { } 
} 

void main() { 
    ITest x; 
    x = new Test; 
} 

Quali sono le lingue vedrebbe questo, e automaticamente la bandiera Test come attuazione ITest?

ETA: Non sto cercando la digitazione anatra. Sto cercando lingue rigorosamente tipizzate con inferenza.

Answer 1

D ha qualcosa chiamato wrap nella sua libreria standard, Phobos, che può fare ciò che stai cercando. Ecco un esempio copiato da unittest della funzione:

interface A { 
    int run(); 
} 

interface B { 
    int stop(); 
    @property int status(); 
} 

class X { 
    int run() { 
    return 1; 
    } 

    int stop() { 
    return 2; 
    } 

    @property int status() { 
    return 3; 
    } 
} 

auto x = new X(); 

auto ab = x.wrap!(A, B); 
A a = ab; 
B b = ab; 
assert(a.run() == 1); 
assert(b.stop() == 2); 
assert(b.status == 3); 

L'opera sarà disponibile a partire da v2.064, ed è già in git TESTA.

Answer 2

Praticamente qualsiasi linguaggio dinamico (javascript, python, ecc.) Supporta questo modello. Ma suppongo che tu sia interessato alle lingue che verificano in modo statico che il tipo soddisfi l'interfaccia in questione.

C++

Questo supporto non è esattamente quello che chiedono, però, perché non userebbe ITest direttamente. Invece si dovrebbe utilizzare un modello che semplicemente accedere ai membri necessari del tipo

// C# style solution 
void UseIt(ITest p) { 
    p.Test(); 
} 

// C++ style solution 
template <typename T> 
void UseIt(T p) { 
    p.Test(); 
} 

Il metodo C++ UseIt funziona per qualsiasi tipo che ha un membro accessibili Test. Non esiste un'interfaccia necessario qui

class C1 { 
public: 
    void Test() { } 
} 

class C2 { } 

UseIt<C1>(C1()); // Ok 
UseIt<C2>(C2()); // Error! 

dattiloscritto

tipografico implementa direttamente il modello che hai descritto. Alla fine della giornata il dattiloscritto è solo un sottile involucro su javascript e quindi dinamico. Ma fornisce annotazioni sul tipo di tempo compilato. E 'il supporto per le interfacce corrisponde esattamente al modello che hai descritto nella domanda

• http://blogs.msdn.com/b/typescript/archive/2013/01/24/interfaces-walkthrough.aspx

F #

F # ha il supporto simile al C++ tramite vincoli membri sulle dichiarazioni in linea

let inline UseIt<^T when ^T : (member Test: unit -> unit)> s = ...