TypeScript Academy · Pelajaran

Pola HKT Ringan

Terapkan trik defungsionalisasi Kind/URI.

Pola HKT Ringan adalah pelajaran TypeScript Academy gratis di CoddyKit. Ini adalah pelajaran 3 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.

Defungsionalisasi

Trik di balik pengodean ini memiliki nama: defungsionalisasi. Alih-alih menggunakan fungsi tipe orde tinggi yang nyata, kita merepresentasikan setiap fungsi dengan tanda dan menyelesaikannya melalui satu pencarian orde pertama. Registri URItoKind adalah tabel pencarian tersebut.

type Kind<F extends URIS, A> = URItoKind<A>[F];
// One lookup replaces true type-function application

Tipe Kind

Kind<F, A> adalah tampilan publik dari pola ini. Bacalah sebagai "konstruktor F yang diterapkan pada A". Tipe ini menyembunyikan pengindeksan registri di balik nama yang bersih.

type A = Kind<"Array", number>;  // number[]
type B = Kind<"Option", string>; // string | null

Membatasi F ke URIS

F harus berupa URI yang terdaftar. Batasi dengan extends URIS agar hanya tanda yang valid yang dapat digunakan dan kesalahan pengetikan menjadi galat kompilasi.

type Kind<F extends URIS, A> = URItoKind<A>[F];

// Kind<"Arrey", number> -> error, not a valid URI

Menulis Tanda Tangan Generik

Sekarang kita dapat menulis tanda tangan Functor yang sebelumnya mustahil. Ganti setiap F<A> dengan Kind<F, A>, dan kompilator akan menerimanya.

interface Functor<F extends URIS> {
  map<A, B>(fa: Kind<F, A>, f: (a: A) => B): Kind<F, B>;
}

Penyelesaian dalam Praktik

Ketika Anda menetapkan F ke URI konkret, Kind diselesaikan menjadi tipe wadah nyata. Sebuah Functor<"Array"> memiliki map dari A[] ke B[].

type ArrayFunctor = Functor<"Array">;
// map: <A, B>(fa: A[], f: (a: A) => B) => B[]

Beberapa Argumen Tipe

Beberapa konstruktor menerima dua argumen, seperti Either<E, A>. fp-ts memperluas pola ini dengan URItoKind2 dan Kind2<F, E, A> untuk kind * -> * -> *. Gagasan ini dapat diperluas dengan menambahkan lebih banyak registri.

interface URItoKind2<E, A> {
  Either: { left: E } | { right: A };
}
type Kind2<F extends URIS2, E, A> = URItoKind2<E, A>[F];

Konvensi fp-ts

fp-ts menetapkan konvensi yang diikuti seluruh kursus ini: satu teks URI untuk setiap tipe data, registri URItoKind yang diperluas melalui penggabungan deklarasi, dan Kind untuk penyelesaian. Mengenali pola ini memungkinkan Anda membaca tanda tangan tipe fp-ts dan Effect.

// In fp-ts you will see exactly:
// declare module "fp-ts/HKT" { interface URItoKind<A> { ... } }

Rekaman Instans

Sebuah "instans" dari suatu abstraksi adalah nilai yang mengimplementasikannya untuk URI tertentu. Instans tersebut membawa map konkret. Kita akan menulis instans Array pada pelajaran berikutnya; berikut bentuknya.

declare const arrayFunctor: Functor<"Array">;
const out = arrayFunctor.map([1, 2, 3], n => n * 2); // number[]

Mengapa Ini Disebut "Ringan"

Pola ini disebut pola HKT ringan karena tidak memerlukan perubahan kompilator atau sintaks khusus, melainkan hanya antarmuka dan akses terindeks. Imbalannya adalah sedikit kerumitan tambahan (URI dan registri) untuk mendapatkan kode yang benar-benar generik terhadap wadah.

type Kind<F extends URIS, A> = URItoKind<A>[F];
// No magic, just a typed lookup table

Keterbatasan

Pola ini cukup bertele-tele, dan pesan galat dapat membingungkan karena menyebutkan pengodeannya, bukan domain Anda. Pola ini juga mengharuskan setiap wadah didaftarkan. Untuk sebagian besar aplikasi, Anda menggunakan pustaka yang sudah melakukan semua ini, bukan membangunnya sendiri.

// Trade-off: real abstraction power vs. encoding ceremony

Menyatukan Semuanya

Resep lengkap pola HKT ringan: tentukan URI, daftarkan dalam URItoKind, definisikan abstraksi menggunakan Kind<F, A>, dan sediakan instans untuk setiap URI. Itulah seluruh perangkat di balik pustaka fungsional generik dalam TypeScript.

type Kind<F extends URIS, A> = URItoKind<A>[F];
interface Functor<F extends URIS> {
  map<A, B>(fa: Kind<F, A>, f: (a: A) => B): Kind<F, B>;
}

Pemeriksaan Singkat

Uji pemahaman Anda tentang pola HKT ringan.

Ringkasan

Anda telah menyusun pola HKT ringan.

Defungsionalisasi menggantikan penerapan fungsi tipe dengan sebuah pencarian.
Kind<F, A> menyelesaikan URI dan argumen menjadi tipe konkret.
Tanda tangan generik menggunakan Kind, bukan F<A>.
Pola ini dapat diperluas ke dua argumen melalui Kind2 dan merupakan konvensi fp-ts.

Berikutnya: map generik dengan instans nyata.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Pola HKT Ringan” gratis?

Ya — teks lengkap “Pola HKT Ringan” 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 “Pola HKT Ringan”?

Terapkan trik defungsionalisasi Kind/URI. 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 3 dari 4.

Berapa lama pelajaran “Pola HKT Ringan” 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

← Kembali ke TypeScript Academy