0Pricing
TypeScript Academy · Pelajaran

Masalah HKT dalam TypeScript

Pahami alasan konstruktor jenis generik sulit diterapkan.

Masalah HKT dalam TypeScript adalah pelajaran TypeScript Academy gratis di CoddyKit. Ini adalah pelajaran 1 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar TypeScript Academy, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus TypeScript Academy mencakup 4 pelajaran total.

Apa Itu Tipe Berkonstruktor Tingkat Tinggi

Tipe berkonstruktor tingkat tinggi (HKT) mengabstraksikan bukan tipe konkret, melainkan konstruktor tipe: sesuatu seperti Array atau Promise yang memerlukan argumen agar menjadi tipe nyata.

Array saja bukanlah tipe. Array<string> adalah tipe. Array adalah fungsi pada tipe, dan HKT memungkinkan kita membuat fungsi semacam itu menjadi generik.

type StringArray = Array<string>;
type NumberArray = Array<number>;
// Array by itself is a type constructor, not a type

Sekilas tentang Jenis

Sama seperti nilai memiliki tipe, konstruktor tipe memiliki jenis. Tipe biasa seperti number memiliki jenis *. Array memiliki jenis * -> *: berikan satu tipe, dan dapatkan kembali sebuah tipe. Menjadi generik atas hal-hal ini disebut "berkonstruktor tingkat tinggi".

type ValueLike = number;        // kind *
// Array needs one argument:    kind * -> *
// Map needs two arguments:     kind * -> * -> *

Tujuan: Functor<F>

Dalam bahasa yang mendukung HKT, Anda dapat menulis satu abstraksi Functor<F> dengan satu map yang bekerja untuk wadah apa pun F, baik itu larik, opsi, maupun janji. Satu antarmuka, banyak wadah.

interface Wish_Functor<F> {
  map<A, B>(fa: F<A>, f: (a: A) => B): F<B>;
}
// F<A> here is the wish - and TypeScript rejects it

Masalahnya

TypeScript tidak mendukung penerapan parameter tipe pada sebuah argumen. Anda tidak dapat menulis F<A> ketika F adalah parameter generik. Kompilator menghasilkan kesalahan "Tipe F bukan generik".

// interface Functor<F> {
//   map<A, B>(fa: F<A>, f: (a: A) => B): F<B>;
// }
// Error: Type F is not generic

Mengapa TS Tidak Memilikinya

Parameter tipe TypeScript bersifat tingkat pertama: parameter tersebut mencakup tipe konkret, bukan konstruktor tipe. Tidak ada sintaks untuk menyatakan bahwa "F adalah sesuatu yang menerima satu argumen tipe". Jadi, F<A> tidak bermakna bagi kompilator.

// You can pass number, string, User as F...
// but not Array, not Promise (the constructors themselves)

Masalah Nyata yang Dihadapi

Tanpa HKT, Anda harus menggandakan map untuk setiap wadah: satu untuk larik, satu untuk opsi, dan satu untuk janji. Logikanya identik, tetapi sistem tipe tidak dapat menyatukannya.

declare function mapArray<A, B>(fa: A[], f: (a: A) => B): B[];
declare function mapOption<A, B>(fa: A | null, f: (a: A) => B): B | null;
// Same shape, but no way to abstract over the container

Yang Ingin Kita Ungkapkan

Kita menginginkan satu tanda tangan: jika diberi wadah A dan fungsi A -> B, kembalikan wadah B dengan mempertahankan tipe wadah. Larik tetap menjadi larik; opsi tetap menjadi opsi.

// Wish: map<F, A, B>(fa: F<A>, f: (a: A) => B): F<B>
// where F is preserved across the call

Bahasa Lain

Haskell dan Scala memiliki HKT secara bawaan, sehingga kelas tipe seperti Functor, Applicative, dan Monad dapat diungkapkan di sana. TypeScript memerlukan solusi sementara untuk mendekati kemampuan yang sama.

// Haskell: class Functor f where fmap :: (a -> b) -> f a -> f b
// TypeScript: needs an encoding trick (next lessons)

Gagasan Pengodean

Solusi sementara yang umum adalah defungsionalisasi: alih-alih menerapkan F secara langsung, kita memberikan setiap wadah tanda teks (URI) dan menyimpan registri yang memetakan tanda tersebut beserta argumen ke tipe konkret. Penerapan tipe menjadi sebuah pencarian.

// Instead of F<A>, we write Kind<F, A> where F is a URI string
// and a registry resolves it to the real type

Yang Akan Anda Bangun

Dalam pelajaran-pelajaran berikutnya, Anda akan membangun pengodean HKT bergaya fp-ts langkah demi langkah: registri URItoKind, pencarian Kind, dan akhirnya Functor generik yang map-nya bekerja untuk setiap wadah terdaftar.

// Roadmap:
// 1. Type constructors via URI strings
// 2. Kind<F, A> resolution
// 3. Generic Functor + instances

Mengapa Ini Perlu Diketahui

Anda jarang menulis pengodean ini sendiri, tetapi pustaka seperti fp-ts dan Effect mengandalkannya. Memahami trik ini memungkinkan Anda membaca tipe pustaka tersebut, menulis abstraksi generik atas wadah, dan memahami kemampuan serta keterbatasan sistem tipe.

// Recognizing Kind<F, A> in library code is the payoff

Pemeriksaan Singkat

Uji pemahaman Anda tentang masalah HKT.

Ringkasan

Anda telah mengenal masalah tipe dengan konstruktor tingkat tinggi.

  • HKT mengabstraksikan konstruktor tipe seperti Array, bukan tipe konkret.
  • Parameter TypeScript bersifat orde pertama, sehingga F<A> tidak sah.
  • Hal ini menghalangi satu Functor generik dengan satu map.
  • Solusinya adalah pengodean menggunakan tanda URI dan sebuah registri.

Berikutnya: mendefinisikan konstruktor tipe melalui teks URI.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Masalah HKT dalam TypeScript” gratis?

Ya — teks lengkap “Masalah HKT dalam TypeScript” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus TypeScript Academy, upgrade ke CoddyKit PRO. Kursus TypeScript Academy mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Masalah HKT dalam TypeScript”?

Pahami alasan konstruktor jenis generik sulit diterapkan. Kamu berlatih TypeScript Academy dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai TypeScript Academy?

Tidak diperlukan pengalaman sebelumnya. TypeScript Academy di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 1 dari 4.

Berapa lama pelajaran “Masalah HKT dalam TypeScript” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran TypeScript Academy ini?

Ya. Setiap pelajaran TypeScript Academy menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

  1. Masalah HKT dalam TypeScript
  2. Mendefinisikan Konstruktor Jenis
  3. Pola HKT Ringan
  4. Functor dan Mapper Generik
← Kembali ke TypeScript Academy