Jenis elemen tak terduga saat menangani koleksi di Julia – Beragampengetahuan

Oleh: Blog Bogumił Kamiński

Repost dari:

Hari ini saya ingin menulis tentang topik yang agak rumit
Elemen desain Julia. Masalahnya terkadang sulit
untuk memprediksi jenis elemen dari koleksi keluaran yang dihasilkan oleh
operasi yang mengubah koleksi input.

Uraian di atas sepertinya rumit, tapi intinya
ditemui dalam praktik, jadi izinkan saya menjelaskannya dengan contoh.

Posting ini ditulis di bawah Julia 1.9.0-rc1.

Katakanlah Anda memiliki beberapa koleksi masukan [1, 2, 3] dan kamu
ingin menghitung akar kuadrat dari semua elemennya.

Mari kita lihat tiga cara standar untuk melakukannya:

julia> x = [1, 2, 3]
3-element Vector{Int64}:
 1
 2
 3

julia> sqrt.(x)
3-element Vector{Float64}:
 1.0
 1.4142135623730951
 1.7320508075688772

julia> map(sqrt, x)
3-element Vector{Float64}:
 1.0
 1.4142135623730951
 1.7320508075688772

julia> [sqrt(v) for v in x]
3-element Vector{Float64}:
 1.0
 1.4142135623730951
 1.7320508075688772

Seperti yang Anda lihat di setiap kasus, jenis elemen yang sesuai adalah
Float64sudah ditentukan untuk koleksi yang dikembalikan.

Perilaku ini berguna karena pengguna tidak perlu berpikir
tentang menentukan jenis elemen keluaran. Pada kenyataannya,
dikombinasikan dengan transformasi menggunakan identity fungsi,
perilaku ini dapat digunakan untuk penyempitan kenyamanan
tipe elemen bawah dari beberapa koleksi:

julia> y = Any[1, 2, 3]
3-element Vector{Any}:
 1
 2
 3

julia> identity.(y)
3-element Vector{Int64}:
 1
 2
 3

julia> map(identity, y)
3-element Vector{Int64}:
 1
 2
 3

julia> [v for v in y]
3-element Vector{Int64}:
 1
 2
 3

Pola ini berguna jika kita memiliki input data yang tidak diketahui
tipe elemen, tetapi nanti kita ingin melakukan penyempitan tipe elemen
saat menanganinya (salah satu manfaat utama dari penyempitan tersebut
adalah vektor pemrosesan dari Any nilainya lambat jadi kami biasanya ingin menghindarinya).

Deteksi tipe elemen keluaran otomatis berfungsi dengan baik di sebagian besar waktu.
Sayangnya, saat kami bekerja dengan koleksi kosong, hal itu menjadi sulit diprediksi.
Berikut adalah contoh sederhana:

julia> String.([])
Any[]

julia> map(String, [])
String[]

julia> [String(v) for v in []]
Any[]

julia> string.([])
AbstractString[]

julia> map(string, [])
Any[]

julia> [string(v) for v in []]
Any[]

Seperti yang Anda lihat dari itu mengembang, mapdan memahami menggunakan set yang berbeda dari
aturan untuk secara otomatis menentukan jenis elemen yang dihasilkan. Tentu saja peraturan ini
ada dan dapat dipelajari, tetapi masalahnya adalah masalah yang tidak sepele.

Masalahnya adalah saat Anda menulis kode produksi
(mis. Anda sedang mengembangkan paket) Anda ingin memastikan
Apa jenis elemen dari koleksi yang sering Anda buat
Anda tidak dapat mengetahui sebelumnya jika koleksi input yang akan diberikan pengguna
akan kosong atau tidak.

Dalam situasi ketika jenis elemen koleksi penting
dihasilkan oleh beberapa transformasi akan saya gunakan pemahaman
dengan anotasi tipe elemen keluaran:

julia> [string(v) for v in []]
Any[]

julia> String[string(v) for v in []]
String[]

Anotasi semacam itu memiliki konsekuensi tambahan yang akan dilakukannya
mengonversi elemen yang dihasilkan ke tipe target jika diperlukan:

julia> using Test

julia> s = ["a", GenericString("a")]
2-element Vector{AbstractString}:
 "a"
 "a"

julia> [string(v) for v in s]
2-element Vector{AbstractString}:
 "a"
 "a"

julia> typeof.([string(v) for v in s])
2-element Vector{DataType}:
 String
 GenericString

julia> String[string(v) for v in s]
2-element Vector{String}:
 "a"
 "a"

julia> typeof.(String[string(v) for v in s])
2-element Vector{DataType}:
 String
 String

Perhatikan bahwa dalam contoh awalan dipahami dengan
String memastikan bahwa hasil operasi telah
String tipe elemen dan semua nilai yang dihasilkan memiliki tipe ini.

Biarkan saya mengomentari aktivitas terkait yang umum. Bagaimana jika kita
ingin menginisialisasi beberapa wadah dengan nilai tertentu tetapi
kami ingin tipe elemennya lebih luas? Ini bukan buatan
kasus – sering terjadi dengan missing (di mana kita menginisialisasi
beberapa wadah memiliki nilai ini hanya untuk penggantian nanti missing dengan yang sesuai
nilai-nilai).

Menggunakan fill function adalah hal pertama yang bisa kita coba:

julia> fill(missing, 3)
3-element Vector{Missing}:
 missing
 missing
 missing

Namun, wadahnya diproduksi dengan Missing jenis elemen yang
tidak berguna jika nantinya kita juga ingin menyimpan bilangan bulat di dalamnya.

Seseorang dapat menggunakan pemahaman anotasi dengan jenis elemen keluaran yang sesuai
alih-alih:

julia> Union{Int, Missing}[missing for _ in 1:3]
3-element Vector{Union{Missing, Int64}}:
 missing
 missing
 missing

Model dengan missing diperlukan cukup sering bagi kita untuk memiliki
fungsi kustom dalam paket Missings.jl dapat digunakan
untuk mendapatkan hasil yang diinginkan lebih nyaman:

julia> using Missings

julia> missings(Int, 3)
3-element Vector{Union{Missing, Int64}}:
 missing
 missing
 missing

Untungnya, dalam penggunaan interaktif, ada masalah dengan penginstalan
jenis elemen yang sesuai untuk beberapa koleksi
sering terjadi. Namun, ketika saya menulis program produksi, saya melakukannya
pasti selalu berpikir jika saya perlu menggunakan pemahaman dengan
spesifikasi tipe elemen untuk memastikan stabilitas tipe kode saya.

Terkait