Bahasa yang diketik secara statis mana yang mendukung tipe persimpangan untuk nilai pengembalian fungsi?

Catatan awal:

Pertanyaan ini ditutup setelah beberapa pengeditan karena saya tidak memiliki terminologi yang tepat untuk menyatakan secara akurat apa yang saya cari. Sam Tobin-Hochstadt kemudian memposting komentar yang membuat saya mengenali persis apa itu: bahasa pemrograman yang mendukung tipe persimpangan untuk nilai-nilai fungsi kembali.

Sekarang pertanyaan telah dibuka kembali, saya telah memutuskan untuk memperbaikinya dengan menulis ulang dengan (mudah-mudahan) cara yang lebih tepat. Karenanya, beberapa jawaban dan komentar di bawah mungkin tidak lagi masuk akal karena merujuk pada suntingan sebelumnya. (Silakan lihat riwayat edit pertanyaan dalam kasus semacam itu.)

Apakah ada bahasa pemrograman yang populer secara statis & sangat diketik (seperti Haskell, Java generik, C #, F #, dll.) Yang mendukung tipe persimpangan untuk nilai pengembalian fungsi? Jika ya, yang mana, dan bagaimana?

(Jika saya jujur, saya akan sangat senang melihat seseorang menunjukkan cara bagaimana mengekspresikan jenis persimpangan dalam bahasa umum seperti C # atau Java.)

Saya akan memberikan contoh cepat tentang apa jenis persimpangan mungkin terlihat, menggunakan beberapa pseudocode mirip dengan 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();
}

Yaitu, fungsi fnmengembalikan sebuah instance dari beberapa tipe T, di mana si penelepon hanya tahu bahwa ia mengimplementasikan antarmuka IXdan IY. (Yaitu, tidak seperti dengan obat generik, penelepon tidak dapat memilih tipe konkret T- fungsinya. Dari sini saya kira itu Tsebenarnya bukan tipe universal, tetapi tipe eksistensial.)

PS: Saya sadar bahwa seseorang dapat dengan mudah mendefinisikan interface IXY : IX, IYdan mengubah tipe pengembalian fnke IXY. Namun, itu bukan hal yang benar-benar sama, karena sering kali Anda tidak dapat menghubungkan antarmuka tambahan IXYke tipe Ayang sebelumnya didefinisikan yang hanya mengimplementasikan IXdan IYsecara terpisah.

_{Catatan kaki: Beberapa sumber tentang tipe persimpangan:}

_{Artikel Wikipedia untuk "Tipe sistem" memiliki subbagian tentang jenis persimpangan .}

_{Laporan oleh Benjamin C. Pierce (1991), "Pemrograman Dengan Jenis Persimpangan, Jenis Serikat, dan Polimorfisme"}

_{David P. Cunningham (2005), "Jenis titik-temu dalam praktik" , yang berisi studi kasus tentang bahasa Forsythe, yang disebutkan dalam artikel Wikipedia.}

_{Pertanyaan A Stack Overflow, "jenis Union dan jenis persimpangan" yang mendapat beberapa jawaban yang baik, di antaranya satu ini yang memberikan contoh pseudocode dari jenis persimpangan sama dengan saya di atas.}

Scala memiliki tipe persimpangan penuh yang dibangun ke dalam bahasa:

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

Sebenarnya, jawaban yang jelas adalah: Jawa

Meskipun mungkin mengejutkan Anda mengetahui bahwa Java mendukung tipe persimpangan ... itu memang melalui operator terikat tipe "&". Sebagai contoh:

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

Lihat tautan ini pada beberapa batasan tipe di Java, dan juga ini dari Java API.

Pertanyaan awal meminta "tipe ambigu". Untuk itu jawabannya adalah:

Tipe ambigu, jelas tidak ada. Penelepon perlu tahu apa yang akan mereka dapatkan, jadi itu tidak mungkin. Semua bahasa apa pun dapat kembali adalah tipe dasar, antarmuka (mungkin dihasilkan secara otomatis seperti pada tipe persimpangan) atau tipe dinamis (dan tipe dinamis pada dasarnya hanya ketik dengan panggilan nama, dapatkan, dan atur metode).

Antarmuka yang disimpulkan:

Jadi pada dasarnya Anda ingin mengembalikan antarmuka IXYyang berasal IX dan IY meskipun antarmuka itu tidak dideklarasikan di salah satu Aatau B, mungkin karena tidak dideklarasikan ketika tipe tersebut didefinisikan. Dalam hal itu:

• Apa pun yang diketik secara dinamis, jelas.
• Saya tidak ingat bahasa mainstream yang diketik secara statis akan dapat menghasilkan antarmuka (itu adalah jenis persatuanA dan Batau tipe persimpangan IXdan IY) itu sendiri.
• GO , karena itu kelas mengimplementasikan antarmuka jika mereka memiliki metode yang benar, tanpa pernah mendeklarasikannya. Jadi, Anda hanya mendeklarasikan antarmuka yang mendapatkan keduanya di sana dan mengembalikannya.
• Tentunya bahasa lain di mana tipe dapat didefinisikan untuk mengimplementasikan antarmuka di luar definisi jenis itu, tapi saya rasa saya tidak ingat selain GO.
• Tidak mungkin dalam tipe apa pun di mana mengimplementasikan antarmuka harus didefinisikan dalam definisi tipe itu sendiri. Namun Anda dapat bekerja di sebagian besar dari mereka dengan mendefinisikan wrapper yang mengimplementasikan dua antarmuka dan mendelegasikan semua metode ke objek yang dibungkus.

PS A sangat bahasa diketik adalah satu di mana sebuah objek dari tipe yang diberikan tidak dapat diperlakukan sebagai objek jenis lain, sementara lemah bahasa diketik adalah salah satu yang memiliki pemain menafsirkan. Jadi semua bahasa yang diketik secara dinamis diketik dengan kuat , sementara bahasa yang diketik dengan lemah adalah assembly, C dan C ++, ketiganya diketik secara statis .

Go Bahasa Pemrograman jenis memiliki ini, tapi hanya untuk jenis antarmuka.

Di Go, tipe apa pun yang metode yang benar didefinisikan secara otomatis mengimplementasikan antarmuka, sehingga keberatan dalam PS Anda tidak berlaku. Dengan kata lain, buat saja sebuah antarmuka yang memiliki semua operasi dari jenis antarmuka yang akan digabungkan (yang ada sintaksinya sederhana) dan semuanya hanya berfungsi.

Sebuah contoh:

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
}

Anda mungkin dapat melakukan apa yang Anda inginkan dengan menggunakan tipe eksistensial terbatas, yang dapat dikodekan dalam bahasa apa pun dengan generik dan polimorfisme terikat, misalnya C #.

Jenis pengembalian akan menjadi seperti (dalam kode psuedo)

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

atau dalam 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);
    }
}

Catatan: Saya belum menguji ini.

Intinya adalah bahwa IABharus dapat menerapkan IABFunc untuk semua jenis pengembalian R, danIABFunc harus mampu bekerja pada Tsubtipe mana saja IAdan IB.

Maksudnya DefaultIABadalah hanya untuk membungkus yang ada Tsubtipe IAdanIB . Perhatikan bahwa ini berbeda dari IAB : IA, IBdi Anda yang DefaultIABselalu dapat ditambahkan ke yang sudah ada di Tkemudian hari.

Referensi:

• Jenis eksistensial dalam C #

TypeScript adalah bahasa yang diketik lain yang mendukung jenis persimpangan T & U(bersama dengan jenis serikat T | U). Berikut adalah contoh yang dikutip dari halaman dokumentasi mereka tentang tipe lanjutan :

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 memiliki dukungan penuh untuk jenis persatuan dan persimpangan kelas satu .

Anda menulis tipe gabungan sebagai X | Ydan tipe persimpangan sebagai X & Y.

Bahkan lebih baik, Ceylon menghadirkan banyak alasan canggih tentang jenis-jenis ini, termasuk:

• Instansiasi utama: misalnya, Consumer<X>&Consumer<Y>adalah tipe yang sama seperti Consumer<X|Y>jika Consumercontravarian di X, dan
• disjointness: misalnya, Object&Nulladalah tipe yang sama dengan Nothing, tipe bawah.

Fungsi-fungsi C ++ semuanya memiliki tipe pengembalian tetap, tetapi jika mereka mengembalikan pointer, pointer dapat, dengan batasan, menunjuk ke tipe yang berbeda.

Contoh:

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

Perilaku pointer yang dikembalikan akan tergantung pada virtualfungsi apa yang didefinisikan, dan Anda dapat melakukan pengecekan downcast dengan, katakanlah,

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

Begitulah cara polimorfisme bekerja di C ++.

Python

Ini sangat, sangat sangat diketik.

Tetapi tipe ini tidak dideklarasikan ketika sebuah fungsi dibuat, jadi objek yang dikembalikan "ambigu".

Dalam pertanyaan spesifik Anda, istilah yang lebih baik mungkin "Polimorfik". Itu kasus penggunaan umum dalam Python adalah untuk mengembalikan jenis varian yang mengimplementasikan antarmuka umum.

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

Karena Python diketik dengan kuat, objek yang dihasilkan akan menjadi turunan dari Thisdan Thatdan tidak dapat (dengan mudah) dipaksa atau dilemparkan ke jenis objek lain.