Yah, mengetik lemah vs kuat cukup jelas. Lebih jauh, karena yang paling dekat dengan penggunaan umum 'pengetikan kuat' adalah untuk merujuk hal-hal yang membuatnya sulit untuk mengetik, yang tidak meninggalkan apa pun untuk menggambarkan sistem tipe yang lebih kuat. Ini seperti mengatakan jika Anda dapat membawa kurang dari 30 pon Anda lemah, dan semua orang yang dapat mengangkat lebih banyak berada dalam kategori 'kuat' yang sama - perbedaan yang menyesatkan.
Jadi saya lebih suka definisi:
- Sistem yang diketik dengan lemah menggunakan tipe untuk mencegah Anda melakukan hal-hal tertentu (seperti kesalahan)
- Sistem yang diketik dengan kuat menggunakan tipe untuk melakukan sesuatu untuk Anda
Apa yang saya maksudkan dengan melakukan sesuatu untuk Anda? Nah, mari kita periksa menulis API konversi gambar dalam kerangka Servant (di Haskell, tetapi Anda tidak benar-benar perlu mengetahuinya untuk mengikuti, Anda akan melihat ...)
{-# LANGUAGE
TypeOperators,
DataKinds
#-}
import Codec.Picture
import Data.Proxy
import Network.Wai.Handler.Warp (run)
import Servant
import Servant.JuicyPixels
main :: IO ()
main = run 8001 conversion
Ini mengatakan bahwa kami ingin beberapa modul termasuk paket Servant dan plugin JuicyPixels untuk Servant, dan bahwa titik masuk utama program adalah menjalankan fungsi 'konversi' pada port 8001 sebagai server menggunakan backend Warp. Abaikan sedikit bahasa.
conversion :: Application
conversion = serve (Proxy :: Proxy ConversionApi) handler
Ini mengatakan bahwa fungsi konversi adalah server di mana API harus cocok dengan tipe 'ConversionApi' dan permintaan ditangani oleh fungsi handler
type ConversionApi
= ReqBody '[BMP, GIF, JPEG 50, PNG, TIFF, RADIANCE] DynamicImage
:> Post '[BMP, GIF, JPEG 50, PNG, TIFF, RADIANCE] DynamicImage
Ini menentukan ConvesionApijenisnya. Dikatakan bahwa kita harus menerima jenis konten yang masuk yang ditentukan oleh daftar '[BMP, GIF, JPEG 50, PNG, TIFF, RADIANCE], dan menanganinya sebagai DynamicImage, dan kita harus mengembalikan DynamicImage yang dikonversi ke dalam rentang konten yang sama. jenis. Jangan khawatir tentang apa:> artinya, anggap saja itu sebagai sihir bahagia untuk saat ini.
Jadi, mengingat definisi yang saya sukai, sistem yang diketik dengan lemah sekarang dapat memastikan hal-hal seperti:
- Anda tidak mengembalikan jenis konten keluar yang salah
- Anda tidak menguraikan permintaan masuk sebagai jenis konten yang salah
- Jika server kami lebih rumit, itu akan mencegah kami membuat URI yang salah bentuk, tetapi kami sebenarnya tidak mengembalikan halaman HTML mana pun untuk memuat tautan (dan tipenya memastikan bahwa kami tidak bisa!)
- Sistem pengetikan yang sangat ambisius dan lemah bahkan mungkin memeriksa untuk memastikan bahwa kami menangani semua jenis konten yang masuk dan keluar secara menyeluruh, memungkinkan tipe itu juga bertindak sebagai dokumen spesifikasi, bukan hanya sebagai kendala.
Semua tujuan yang tinggi, tetapi sebenarnya tidak cukup untuk memenuhi syarat sebagai sistem yang diketik dengan kuat, mengingat definisi di atas. Dan sekarang kita harus sampai pada bagian yang sulit dari penulisan kode yang mengikuti spesifikasi ini. Dalam sistem tipe yang sangat kuat , kami menulis:
handler = return
Dan kemudian kita selesai. Itu dia, tidak ada lagi kode untuk ditulis . Ini adalah server web yang sepenuhnya operasional (modulo semua kesalahan ketik yang saya lewatkan). Tipe telah memberitahu kompiler segala yang diperlukan untuk membuat server web kami dari tipe dan paket (modul secara teknis) yang kami definisikan dan impor.
Jadi, bagaimana Anda belajar melakukan ini pada skala aplikasi utama? Yah, itu benar-benar tidak jauh berbeda dari menggunakannya dalam aplikasi skala kecil. Jenis yang absolut tidak peduli berapa banyak kode yang ditulis terkait dengan mereka.
Inspeksi tipe run time adalah sesuatu yang Anda mungkin ingin hindari, karena itu mengukir sejumlah besar manfaat dan memungkinkan tipe untuk membuat proyek Anda lebih rumit untuk dikerjakan, daripada memiliki tipe yang menyederhanakan hal-hal.
Karena itu, sebagian besar hanya soal praktik memodelkan hal-hal dengan tipe. Dua cara utama untuk memodelkan sesuatu (atau membangun sesuatu secara umum) adalah dari atas ke bawah dan dari atas ke bawah. Top down dimulai dengan tingkat operasi tertinggi, dan ketika Anda membangun model Anda memiliki bagian-bagian di mana Anda menunda pemodelan sampai nanti. Pemodelan bottom-up berarti Anda memulai dengan operasi dasar, sama seperti Anda memulai dengan fungsi-fungsi dasar, kemudian membangun model yang lebih besar dan lebih besar sampai Anda sepenuhnya menangkap operasi proyek. Bottom up lebih konkret dan kemungkinan lebih cepat untuk dibangun, tetapi top-down mungkin lebih baik menginformasikan model tingkat bawah Anda tentang bagaimana mereka harus benar-benar berperilaku.
Jenis adalah bagaimana program berhubungan dengan matematika, secara harfiah, jadi tidak ada batas atas seberapa rumitnya mereka bisa, atau titik di mana Anda bisa 'selesai' belajar tentang matematika. Hampir semua sumber daya di luar program universitas tingkat tinggi semuanya didedikasikan untuk bagaimana jenis bekerja dalam beberapa bahasa tertentu, jadi Anda perlu memutuskan itu juga.
Yang terbaik yang bisa saya tawarkan, tipe dapat dikelompokkan seperti:
- Ketik yang sangat lemah, hal-hal seperti JavaScript tempat [] + {} didefinisikan
- Ketikan yang lemah seperti Python, di mana Anda tidak dapat melakukan [] + {}, tetapi itu tidak dicentang hingga Anda mencobanya
- Ketikan yang lemah seperti C atau Java, di mana Anda tidak dapat melakukan [] + {}, tetapi itu diperiksa pada waktu kompilasi, namun Anda tidak memiliki fitur tipe yang lebih canggih
- Mengangkangi batas antara mengetik dengan lemah dan sangat, seperti metaprogramming template C ++, dan kode Haskell yang lebih sederhana di mana tipe hanya properti penguat.
- Sepenuhnya ke Sangat diketik, seperti program Haskell yang lebih rumit di mana jenis melakukan hal-hal, seperti yang ditunjukkan di atas
- Yang diketik sangat kuat, seperti Agda atau Idris, di mana tipe dan nilai berinteraksi dan dapat saling membatasi. Ini sekuat sistem tipe dapatkan, dan pemrograman di dalamnya sama dengan menulis bukti matematika tentang apa yang program Anda lakukan. Catatan: pengkodean dalam Agda tidak secara harfiah menulis bukti matematis, tipe adalah teori matematika, dan fungsi dengan tipe tersebut adalah contoh konstruktif yang membuktikan teori-teori tersebut.
Secara umum, semakin jauh dalam daftar ini Anda pergi, semakin banyak jenis yang bisa lakukan untuk Anda, tetapi pada bagian paling bawah, Anda naik ke stratosfer dan udaranya semakin tipis - ekosistem paket jauh lebih kecil dan Anda ' Saya harus menulis lebih banyak hal sendiri vs telah menemukan perpustakaan yang relevan. Hambatan untuk masuk juga semakin tinggi saat Anda turun, karena Anda harus benar-benar memahami jenis sistem yang cukup untuk menulis program skala besar.