¿Qué lenguajes de tipo estático admiten tipos de intersección para valores de retorno de funciones?

Nota inicial:

Esta pregunta se cerró después de varias ediciones porque carecía de la terminología adecuada para indicar con precisión lo que estaba buscando. Sam Tobin-Hochstadt luego publicó un comentario que me hizo reconocer exactamente qué era eso: lenguajes de programación que admiten tipos de intersección para valores de retorno de funciones.

Ahora que la pregunta ha sido reabierta, he decidido mejorarla reescribiéndola de una manera (con suerte) más precisa. Por lo tanto, algunas respuestas y comentarios a continuación pueden no tener sentido porque se refieren a ediciones anteriores. (Consulte el historial de edición de la pregunta en tales casos).

¿Existen lenguajes de programación populares tipados estáticamente y fuertemente (como Haskell, Java genérico, C #, F #, etc.) que admiten tipos de intersección para valores de retorno de funciones? Si es así, ¿cuál y cómo?

(Si soy sincero, me encantaría ver a alguien demostrar una forma de expresar los tipos de intersección en un lenguaje convencional como C # o Java).

Daré un ejemplo rápido de cómo se verían los tipos de intersección, usando un pseudocódigo similar a C #:

interface IX { … }
interface IY { … }
interface IB { … }

class A : IX, IY { … }
class B : IX, IY, IB { … }

T fn()  where T : IX, IY
{
    return … ? new A()  
             : new B();
}

Es decir, la función fndevuelve una instancia de algún tipo T, de la cual la persona que llama solo sabe que implementa interfaces IXy IY. (Es decir, a diferencia de los genéricos, la persona que llama no puede elegir el tipo concreto de T- la función sí. De esto supongo que Ten realidad no es un tipo universal, sino un tipo existencial).

PD: Soy consciente de que uno podría simplemente definir ay interface IXY : IX, IYcambiar el tipo de retorno de fna IXY. Sin embargo, eso no es realmente lo mismo, porque a menudo no puede atornillar una interfaz adicional IXYa un tipo definido previamente Aque solo se implementa IXy por IYseparado.

_{Nota al pie: Algunos recursos sobre tipos de intersección:}

_{El artículo de Wikipedia para "Sistema de tipos" tiene una subsección sobre los tipos de intersección .}

_{Informe de Benjamin C. Pierce (1991), "Programación con tipos de intersección, tipos de unión y polimorfismo"}

_{David P. Cunningham (2005), "Tipos de intersección en la práctica" , que contiene un estudio de caso sobre el lenguaje Forsythe, que se menciona en el artículo de Wikipedia.}

_{Una pregunta de desbordamiento de pila, "Tipos de unión y tipos de intersección" que obtuvo varias buenas respuestas, entre ellas esta que da un ejemplo de pseudocódigo de tipos de intersección similares a los míos anteriores.}

Scala tiene tipos de intersección completos integrados en el lenguaje:

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()

De hecho, la respuesta obvia es: Java

Si bien puede sorprenderle saber que Java admite tipos de intersección ... de hecho lo hace a través del operador de tipo "&". Por ejemplo:

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

Vea este enlace en múltiples límites de tipo en Java, y también esto desde la API de Java.

Pregunta original para "tipo ambiguo". Para eso la respuesta fue:

Tipo ambiguo, obviamente ninguno. La persona que llama necesita saber qué obtendrá, por lo que no es posible. Todo lo que cualquier lenguaje puede devolver es el tipo base, la interfaz (posiblemente generada automáticamente como en el tipo de intersección) o el tipo dinámico (y el tipo dinámico es básicamente solo escribir con los métodos de llamada por nombre, get y set).

Interfaz inferida:

Entonces, básicamente, desea que devuelva una interfaz IXYque se derive IX y, IY aunque esa interfaz no se declaró en ninguno Ao B, posiblemente porque no se declaró cuando se definieron esos tipos. En ese caso:

• Cualquiera que esté escrito dinámicamente, obviamente.
• No recuerdo que ningún lenguaje convencional estáticamente escrito pueda generar la interfaz (es el tipo de unión de Ay / Bo el tipo de intersección de IXy IY) en sí.
• GO , porque sus clases implementan la interfaz si tienen los métodos correctos, sin declararlos nunca. Entonces, simplemente declara una interfaz que deriva los dos allí y la devuelve.
• Obviamente, cualquier otro lenguaje donde se pueda definir el tipo para implementar la interfaz fuera de la definición de ese tipo, pero no creo recordar ningún otro que no sea GO.
• No es posible en ningún tipo en el que la implementación de una interfaz deba definirse en la definición del tipo en sí. Sin embargo, puede solucionarlos en la mayoría de ellos definiendo un contenedor que implemente las dos interfaces y delegue todos los métodos en un objeto envuelto.

PD Un lenguaje fuertemente tipado es aquel en el que un objeto de un tipo dado no puede ser tratado como objeto de otro tipo, mientras que un lenguaje débilmente tipado es aquel que tiene un reparto reinterpretado. Por lo tanto, todos los lenguajes escritos dinámicamente están fuertemente tipados , mientras que los lenguajes débilmente tipados son ensamblados, C y C ++, los tres están tipados estáticamente .

El lenguaje de programación Go tipo de cuenta de esto, pero sólo para los tipos de interfaz.

En Go, cualquier tipo para el que se definan los métodos correctos implementa automáticamente una interfaz, por lo que la objeción en su PS no se aplica. En otras palabras, solo cree una interfaz que tenga todas las operaciones de los tipos de interfaz que se combinarán (para lo cual hay una sintaxis simple) y todo funciona.

Un ejemplo:

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
}

Es posible que pueda hacer lo que quiera utilizando un tipo existencial acotado, que puede codificarse en cualquier idioma con genéricos y polimorfismo acotado, por ejemplo, C #.

El tipo de retorno será algo así (en código psuedo)

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

o en 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: no he probado esto.

El punto es que IABtiene que poder aplicar un IABFunc para cualquier tipo de retorno R, y IABFuncdebe poder trabajar en cualquiera de los Tsubtipos de ambos IAy IB.

La intención de DefaultIABes sólo para envolver un existentes Tque subtipos IAy IB. Tenga en cuenta que esto es diferente de su IAB : IA, IBen que DefaultIABsiempre se puede agregar a un existente Tmás adelante.

Referencias

• Tipos existenciales en C #

TypeScript es otro lenguaje escrito que admite tipos de intersección T & U(junto con tipos de unión T | U). Aquí hay un ejemplo citado de su página de documentación sobre tipos avanzados :

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;
}

Ceilán tiene soporte completo para los tipos de unión e intersección de primera clase .

Escribe un tipo de unión como X | Yy un tipo de intersección como X & Y.

Aún mejor, Ceilán presenta muchos razonamientos sofisticados sobre estos tipos, que incluyen:

• instanciaciones principales: por ejemplo, Consumer<X>&Consumer<Y>es del mismo tipo que Consumer<X|Y>si Consumeres contravariante en X, y
• disyunción: por ejemplo, Object&Nulles del mismo tipo que Nothingel tipo inferior.

Todas las funciones de C ++ tienen un tipo de retorno fijo, pero si devuelven punteros, los punteros pueden, con restricciones, señalar diferentes tipos.

Ejemplo:

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;
}

El comportamiento del puntero devuelto dependerá de qué virtualfunciones estén definidas, y puede hacer un downcast marcado con, por ejemplo,

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

Así es como funciona el polimorfismo en C ++.

Pitón

Está muy, muy fuertemente escrito.

Pero el tipo no se declara cuando se crea una función, por lo que los objetos devueltos son "ambiguos".

En su pregunta específica, un término mejor podría ser "polimórfico". Ese es el caso de uso común en Python es devolver tipos de variantes que implementan una interfaz común.

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

Dado que Python está fuertemente tipado, el objeto resultante será una instancia de Thiso Thaty no puede (fácilmente) ser coaccionado o lanzado a otro tipo de objeto.