Quali lingue tipizzate staticamente supportano i tipi di intersezione per i valori di ritorno delle funzioni?

Scala ha i tipi di intersezione completi incorporati nella lingua:

trait IX {...}
trait IY {...}
trait IB {...}

class A() extends IX with IY {...}

class B() extends IX with IY with IB {...}

def fn(): IX with IY = if (...) new A() else new B()

In realtà, la risposta ovvia è: Java

Mentre potrebbe sorprendervi sapere che Java supporta i tipi di intersezione ... lo fa attraverso "&" tipo di operatore associato. Ad esempio:

<T extends IX & IY> T f() { ... }

Vedi questo link su più tipi di limiti in Java e anche questo dall'API Java.

La domanda originale ha richiesto "tipo ambiguo". Per questo la risposta è stata:

Tipo ambiguo, ovviamente nessuno. Il chiamante deve sapere cosa otterranno, quindi non è possibile. Tutto il linguaggio può restituire sia il tipo di base, l'interfaccia (possibilmente generata automaticamente come nel tipo di intersezione) o il tipo dinamico (e il tipo dinamico è fondamentalmente solo tipo con chiamata per nome, ottieni e imposta metodi).

Interfaccia dedotta:

Quindi in pratica vuoi che restituisca un'interfaccia IXY che deriva IX e IY sebbene quell'interfaccia non sia stata dichiarata in A o B , probabilmente perché wasn dichiarato quando sono stati definiti questi tipi. In tal caso:

• Tutto ciò che viene digitato in modo dinamico, ovviamente.
• Non ricordo alcun linguaggio mainstream tipizzato staticamente sarebbe in grado di generare l'interfaccia (è il tipo union di A e B o il tipo di intersezione di IX e IY ) stesso.
• GO , perché le sue classi implementano l'interfaccia se hanno i metodi corretti, senza mai dichiararli. Quindi dichiari solo un'interfaccia che ne deriva i due e la restituisce.
• Ovviamente qualsiasi altra lingua in cui il tipo può essere definito per implementare l'interfaccia al di fuori della definizione di quel tipo, ma non credo di ricordare altro che GO.
• Non è possibile in nessun tipo dove l'implementazione di un'interfaccia debba essere definita nella definizione del tipo stesso. Tuttavia, è possibile aggirare la maggior parte di essi definendo il wrapper che implementa le due interfacce e delega tutti i metodi a un oggetto spostato.

PS Un linguaggio tipografico strongmente è quello in cui un oggetto di un determinato tipo non può essere trattato come oggetto di un altro tipo, mentre debolmente la lingua dattiloscritta è quella che ha un cast reinterpretato. Pertanto tutti i linguaggi digitati dinamicamente sono tipizzati strongmente , mentre i linguaggi tipizzati debolmente sono assembly, C e C ++, tutti e tre digitati staticamente .

Il linguaggio di programmazione Go tipo di ha questo, ma solo per i tipi di interfaccia.

In Vai qualsiasi tipo per cui sono definiti i metodi corretti implementa automaticamente un'interfaccia, quindi l'obiezione nel tuo P.S. non si applica In altre parole, è sufficiente creare un'interfaccia che abbia tutte le operazioni dei tipi di interfaccia da combinare (per i quali esiste una sintassi semplice) e tutto funzioni correttamente.

Un esempio:

package intersection

type (
    // The first component type.
    A interface {
        foo() int
    }
    // The second component type.
    B interface {
        bar()
    }

    // The intersection type.
    Intersection interface {
        A
        B
    }
)

// Function accepting an intersection type
func frob(x Intersection) {
    // You can directly call methods defined by A or B on Intersection.
    x.foo()
    x.bar()

    // Conversions work too.
    var a A = x
    var b B = x
    a.foo()
    b.bar()
}

// Syntax for a function returning an intersection type:
// (using an inline type definition to be closer to your suggested syntax)
func frob2() interface { A; B } {
    // return something
}

Potresti essere in grado di fare ciò che vuoi usando un tipo esistenziale limitato, che può essere codificato in qualsiasi linguaggio con generici e polimorfismo limitato, ad es. C #.

Il tipo restituito sarà qualcosa di simile (nel codice psuedo)

IAB = exists T. T where T : IA, IB

o in C #:

interface IAB<IA, IB>
{
    R Apply<R>(IABFunc<R, IA, IB> f);
}

interface IABFunc<R, IA, IB>
{
    R Apply<T>(T t) where T : IA, IB;
}

class DefaultIAB<T, IA, IB> : IAB<IA, IB> where T : IA, IB 
{
    readonly T t;

    ...

    public R Apply<R>(IABFunc<R, IA, IB> f) {
        return f.Apply<T>(t);
    }
}

Nota: non l'ho provato.

Il punto è che IAB deve essere in grado di applicare un IABFunc per qualsiasi tipo di ritorno R , e un IABFunc deve essere in grado di lavorare su qualsiasi T che sottotipi sia IA che% % co_de.

L'intento di IB è solo quello di racchiudere un DefaultIAB esistente che sottotipi T e IA . Tieni presente che questo è diverso dal tuo IB in quanto IAB : IA, IB può sempre essere aggiunto a un DefaultIAB esistente in seguito.

References:

• Tipi esistenti in C #

TypeScript è un'altra lingua tipizzata che supporta i tipi di intersezione T & U (insieme ai tipi di unione T | U ). Ecco un esempio citato dalla relativa pagina della documentazione sui tipi avanzati :

function extend<T, U>(first: T, second: U): T & U {
    let result = <T & U>{};
    for (let id in first) {
        (<any>result)[id] = (<any>first)[id];
    }
    for (let id in second) {
        if (!result.hasOwnProperty(id)) {
            (<any>result)[id] = (<any>second)[id];
        }
    }
    return result;
}

Ceylon ha pieno supporto per l'unione di prima classe e tipi di intersezione .

scrivi un tipo di unione come X | Y e un tipo di intersezione come X & Y .

Ancora meglio, Ceylon offre molti ragionamenti sofisticati su questi tipi, tra cui:

• istanze principali: per esempio, Consumer<X>&Consumer<Y> è dello stesso tipo di Consumer<X|Y> se Consumer è controvariante in X , e
• disgiunzione: per esempio, Object&Null è dello stesso tipo di Nothing , il tipo in basso.

Le funzioni C ++ hanno tutte un tipo di ritorno fisso, ma se restituiscono puntatori i puntatori possono, con restrizioni, puntare a tipi diversi.

Esempio:

class Base {};
class Derived1: public Base {};
class Derived2: public Base{};

Base * function(int derived_type)
{
    if (derived_type == 1)
        return new Derived1;
    else
        return new Derived2;
}

Il comportamento del puntatore restituito dipende dalle funzioni virtual definite e puoi eseguire un downcast controllato con, ad esempio,

Base * foo = function(...);dynamic_cast<Derived1>(foo) .

Ecco come il polimorfismo funziona in C ++.

Python

È scritto molto, molto strongmente.

Ma il tipo non viene dichiarato quando viene creata una funzione, quindi gli oggetti restituiti sono "ambigui".

Nella tua domanda specifica, un termine migliore potrebbe essere "Polimorfico". Questo è il caso d'uso comune in Python è quello di restituire tipi di varianti che implementano un'interfaccia comune.

def some_function( selector, *args, **kw ):
    if selector == 'this':
        return This( *args, **kw )
    else:
        return That( *args, **kw )

Poiché Python è strongmente digitato, l'oggetto risultante sarà un'istanza di This o That e non può (facilmente) essere forzato o lanciato su un altro tipo di oggetto.