Apa perbedaan antara jenis Opsional dan Nullable

Swift punya Optionals. C # memiliki Nullabletipe.

Sejauh yang saya tahu keduanya melayani tujuan yang sama, selain nilai beberapa jenis mereka menyimpan informasi apakah variabel memiliki nilai atau tidak didefinisikan (tidak diinisialisasi).

Pertanyaannya, apakah Optionalshanya Nullabletipe dengan nama yang berbeda atau ada perbedaan konseptual lainnya?

Dengan kata lain, berbicara tentang konsep itu sendiri, atau dalam konteks bahasa yang tidak memiliki Optionalsatau Nullables, apakah penting istilah mana yang digunakan?

Ketika menerapkan fungsionalitas itu dalam bahasa apakah masalah apakah saya nama tipe Optionals<T>atauNullable<T>

Ada konotasi yang berbeda, meskipun mereka bekerja sangat mirip. Semua orang kecuali Microsoft (masukkan eye-roll di sini) menggunakan nulldan nullablehanya dalam konteks referensi. Optionsdan Maybesumumnya dipahami merujuk pada referensi dan nilai, terutama dalam bahasa pemrograman fungsional di mana transparansi referensial berarti tidak ada banyak perbedaan antara nilai dan referensi.

Dengan kata lain, berbicara tentang konsep itu sendiri, atau dalam konteks bahasa yang tidak memiliki Optionalsatau Nullables, apakah penting istilah mana yang digunakan?

Optionsadalah istilah yang paling sedikit menyebabkan kebingungan di antara khalayak luas. Hanya pemrogram C # yang akan menganggap Nullableberpotensi menerapkan ke jenis nilai, dan saya pikir sebagian besar dari mereka setidaknya menyadari apa Optionitu.

Dalam. NET, ada dua kategori tipe: referensi dan nilai (int, dobel, struct, enums dll). Di antara perbedaan mereka adalah fakta bahwa referensi bisa jadi null, sedangkan nilai tidak bisa. Jadi, jika Anda memiliki tipe nilai dan ingin menyampaikan semantik "opsional" atau "tidak dikenal", Anda dapat menghiasi itu Nullable<>. Catatan yang Nullable<>dibatasi oleh tipe untuk menerima hanya tipe nilai (memiliki where T : structklausa). Nullable<>juga memiliki harga khusus dari kompiler yang nullnilainya dilindungi dari NullReferenceExceptions:

string x = null;
x.ToString(); // throws a NullReferenceException

int? y = null;
y.ToString(); // returns ""

Dalam bahasa fungsional (seperti Scala, F #, Haskell, Swift dll) itu adalah umum untuk nulluntuk tidak ada . Ini karena secara keseluruhan orang menganggap keberadaan nullsebagai ide yang buruk , dan perancang bahasa telah memutuskan untuk mengatasi masalah ini dengan menolaknya.

Ini berarti bahwa sekali lagi kita perlu beberapa cara untuk mewakili nilai dalam bahasa ini. Masukkan Optiontipe (nomenklatur bervariasi, ini disebut Maybedalam Haskell). Ini melakukan pekerjaan yang mirip dengan Nullableyang membungkus jenis untuk menambahkan kasus di mana nilainya "Tidak Ada" atau "Tidak Diketahui" dll.

Perbedaan sebenarnya ada pada fungsi tambahan yang diberikan kepada Anda oleh bahasa yang menerapkan Option. Sebagai contoh, ambil Option.map(dalam pseudocode):

function Option<T2> Option.map(opt: Option<T1>, mapFunc: T1 -> T2) {
    if (opt is None) return None
    else return Option<T2>(mapFunc(opt.Value))
}

Fungsi perangkaian seperti Option.mapini adalah cara yang ampuh untuk menghindari pelat pelat nol yang biasa Anda lihat di mana-mana di C #:

if (service == null)
    return null;
var x = service.GetValue();
if (x == null || x.Property == null)
    return null;
return x.Property.Value;

Setara Nullable dalam C # adalah:

public static Nullable<T2> Map<T1, T2>(this Nullable<T1> nullable, Func<T1, T2> f)
    where T1 : struct
    where T2 : struct
{
    if (!nullable.HasValue) return (T2?)null;
    else return (T2?) f(nullable.Value);
}

Namun ini memiliki utilitas terbatas dalam C # karena hanya akan bekerja untuk tipe nilai.

Versi baru C # menawarkan operator "null propagation" ( ?.) yang mirip dengan Option.mapfungsi kecuali hanya berlaku untuk metode dan pengakses properti. Sampel di atas akan ditulis ulang

return service?.GetValue()?.Property?.Value;