Które języki o typie statycznym obsługują typy przecięć dla zwracanych wartości funkcji?

Uwaga wstępna:

To pytanie zostało zamknięte po kilku edycjach, ponieważ brakowało mi odpowiedniej terminologii, aby dokładnie określić, czego szukałem. Sam Tobin-Hochstadt opublikował następnie komentarz, dzięki któremu rozpoznałem dokładnie, co to było: języki programowania obsługujące typy przecięć dla zwracanych wartości funkcji.

Teraz, gdy pytanie zostało ponownie otwarte, postanowiłem je poprawić, przepisując je w (mam nadzieję) bardziej precyzyjny sposób. Dlatego niektóre poniższe odpowiedzi i komentarze mogą nie mieć sensu, ponieważ odnoszą się do poprzednich edycji. (W takich przypadkach zapoznaj się z historią edycji pytania).

Czy są jakieś popularne statycznie i silnie typowane języki programowania (takie jak Haskell, ogólna Java, C #, F # itp.), Które obsługują typy przecięć dla zwracanych wartości funkcji? Jeśli tak, to jakie i jak?

(Szczerze mówiąc, bardzo chciałbym zobaczyć, jak ktoś demonstruje sposób wyrażania typów skrzyżowań w głównym nurcie, takim jak C # lub Java.)

Dam szybki przykład tego, jak mogą wyglądać typy skrzyżowań, używając jakiegoś pseudokodu podobnego do 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();
}

Oznacza to, że funkcja fnzwraca instancję pewnego typu T, o której program wywołujący wie tylko, że implementuje interfejsy IXi IY. (To znaczy, w przeciwieństwie do generycznych, osoba wywołująca nie może wybrać konkretnego typu T- funkcja działa. Z tego przypuszczam, że Tw rzeczywistości nie jest to typ uniwersalny, ale typ egzystencjalny.)

PS: Wiem, że można po prostu zdefiniować a interface IXY : IX, IYi zmienić typ zwracanego fnna IXY. Jednak tak naprawdę nie jest to to samo, ponieważ często nie można podłączyć dodatkowego interfejsu IXYdo wcześniej zdefiniowanego typu, Aktóry tylko implementuje IXi IYosobno.

_{Przypis: Niektóre zasoby na temat typów skrzyżowań:}

_{Artykuł w Wikipedii dla „Systemu typów” zawiera podrozdział o typach skrzyżowań .}

_{Raport Benjamina C. Pierce'a (1991), „Programowanie z typami skrzyżowań, typami Unii i polimorfizmem”}

_{David P. Cunningham (2005), „Typy skrzyżowań w praktyce” , który zawiera studium przypadku dotyczące języka Forsythe, o którym wspomniano w artykule w Wikipedii.}

_{Pytanie przepełnienia stosu, „Typy Unii i typy skrzyżowań”, które otrzymało kilka dobrych odpowiedzi, w tym to, które daje pseudokodowy przykład typów skrzyżowań podobny do mojego powyżej.}

Scala ma pełne typy skrzyżowań wbudowane w język:

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

W rzeczywistości oczywistą odpowiedzią jest: Java

Chociaż może Cię zaskoczyć informacja, że ​​Java obsługuje typy skrzyżowań ... tak naprawdę dzieje się to za pośrednictwem operatora powiązanego z typem „&”. Na przykład:

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

Zobacz ten link w wielu typach granic w Javie, a także w interfejsie API Java.

Pierwotne pytanie dotyczyło „dwuznacznego typu”. Dlatego odpowiedzią było:

Dwuznaczny typ, oczywiście żaden. Dzwoniący musi wiedzieć, co dostanie, więc nie jest to możliwe. Każdy język, który może zwrócić, jest albo typem bazowym, interfejsem (ewentualnie generowanym automatycznie jak w typie skrzyżowania) lub typem dynamicznym (a typ dynamiczny to po prostu typ z metodami wywoływania według nazw, pobierania i ustawiania).

Wnioskowany interfejs:

Więc w zasadzie chcesz, aby powrócić interfejs IXY, który wywodzi się IX i IY mimo, że interfejs nie został ogłoszony w jednej Alub B, ewentualnie, ponieważ nie został ogłoszony, gdy zostały określone te typy. W tym wypadku:

• Wszystko, co jest dynamicznie wpisywane, oczywiście.
• Nie pamiętam, aby jakikolwiek statycznie typowany język głównego nurtu byłby w stanie wygenerować interfejs (jest to typ uniiA i Blub typ przecięcia IXi IY).
• GO , ponieważ to klasy implementują interfejs, jeśli mają poprawne metody, bez ich deklarowania. Więc po prostu zadeklarujesz interfejs, który wyprowadza te dwa tam i zwrócisz go.
• Oczywiście każdy inny język, w którym można zdefiniować typ, aby zaimplementować interfejs poza definicją tego typu, ale nie sądzę, żebym pamiętał inny niż GO.
• Nie jest to możliwe w żadnym typie, w którym implementacja interfejsu musi być zdefiniowana w samej definicji typu. Można jednak obejść większość z nich, definiując opakowanie, które implementuje dwa interfejsy i przekazuje wszystkie metody do zawiniętego obiektu.

PS Język silnie typowany to taki, w którym obiekt danego typu nie może być traktowany jako obiekt innego typu, natomiast język słabo typowany to taki, który ma rzutowaną reinterpretację. Tak więc wszystkie języki dynamicznie typowane są silnie typowane , podczas gdy słabo typowane języki to asembler, C i C ++, wszystkie trzy są wpisywane statycznie .

Język programowania Go niby ma, ale tylko dla typów interfejsów.

W Go dowolny typ, dla którego zdefiniowano prawidłowe metody, automatycznie implementuje interfejs, więc sprzeciw w PS nie ma zastosowania. Innymi słowy, po prostu stwórz interfejs, który ma wszystkie operacje typów interfejsów, które mają być połączone (dla których istnieje prosta składnia) i wszystko działa.

Przykład:

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
}

Możesz być w stanie zrobić to, co chcesz, używając ograniczonego typu egzystencjalnego, który można zakodować w dowolnym języku z ogólnikami i ograniczonym polimorfizmem, np. C #.

Rodzaj zwrotu będzie podobny (w kodzie psuedo)

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

lub w 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);
    }
}

Uwaga: nie testowałem tego.

Chodzi o to, że IABmusi być w stanie zastosować IABFunc dla dowolnego typu zwrotu Ri IABFuncmusi być w stanie pracować na każdym Tpodtypie zarówno IAi IB.

Chodzi o DefaultIABto, aby owinąć istniejące, Tktóre podtypy IAi IB. Pamiętaj, że różni się on od twojego, IAB : IA, IBktóry DefaultIABzawsze można Tpóźniej dodać do istniejącego .

Bibliografia:

• Typy egzystencjalne w C #

TypeScript jest innym językiem pisanym, który obsługuje typy skrzyżowań T & U(wraz z typami unii T | U). Oto przykład cytowany ze strony dokumentacji na temat typów zaawansowanych :

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 ma pełne wsparcie dla najwyższej klasy typów złączy i skrzyżowań .

Piszemy typ połączenia jako X | Yi typ skrzyżowania jako X & Y.

Co więcej, Ceylon ma wiele wyrafinowanych argumentów na temat tych typów, w tym:

• główne instancje: na przykład, Consumer<X>&Consumer<Y>jest tego samego typu, Consumer<X|Y>jakby Consumerbył sprzeczny z X, i
• rozłączność: na przykład Object&Nulljest tego samego typu Nothing, co typ dolny.

Wszystkie funkcje w C ++ mają stały typ zwracania, ale jeśli zwracają wskaźniki, wskaźniki mogą, z ograniczeniami, wskazywać na różne typy.

Przykład:

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

Zachowanie zwróconego wskaźnika będzie zależeć od tego, jakie virtualfunkcje są zdefiniowane, i możesz wykonać sprawdzony downcast, powiedzmy,

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

Tak działa polimorfizm w C ++.

Pyton

Jest bardzo, bardzo mocno napisany.

Ale typ nie jest deklarowany podczas tworzenia funkcji, więc zwracane obiekty są „niejednoznaczne”.

W twoim konkretnym pytaniu lepszym terminem może być „polimorficzny”. To typowy przypadek użycia w Pythonie to zwracanie typów wariantów, które implementują wspólny interfejs.

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

Ponieważ Python jest silnie typowany, wynikowy obiekt będzie instancją Thislub Thatnie będzie (łatwo) mógł zostać przymuszony ani rzutowany na inny typ obiektu.