TypeScript Academy · Lekcja

Lekki wzorzec HKT

Zaimplementuj sztuczkę defunkcjonalizacji Kind/URI

Lekki wzorzec HKT to bezpłatna lekcja TypeScript Academy na CoddyKit. To lekcja 3 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej TypeScript Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs TypeScript Academy zawiera 4 lekcji w sumie.

Defunkcjonalizacja

Trik stojący za tym kodowaniem ma swoją nazwę: defunkcjonalizacja. Zamiast prawdziwej funkcji typów wyższego rzędu reprezentujemy każdą funkcję za pomocą znacznika i rozstrzygamy ją jednym wyszukiwaniem pierwszorzędowym. Rejestr URItoKind jest właśnie taką tabelą wyszukiwania.

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

Typ Kind

Kind<F, A> jest publicznym elementem tego wzorca. Należy go odczytywać jako „konstruktor F zastosowany do A”. Ukrywa indeksowanie rejestru za przejrzystą nazwą.

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

Ograniczanie F do URIS

F musi być zarejestrowanym URI. Należy ograniczyć je za pomocą extends URIS, aby można było używać wyłącznie prawidłowych znaczników, a literówki stawały się błędami kompilacji.

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

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

Pisanie generycznych sygnatur

Teraz można zapisać wcześniej niemożliwą sygnaturę Functor. Zastąpienie każdego F<A> przez Kind<F, A> sprawia, że kompilator ją akceptuje.

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

Rozstrzyganie w praktyce

Po ustaleniu F jako konkretnego URI Kind rozstrzyga się do rzeczywistego typu kontenera. Functor<"Array"> ma metodę map przekształcającą A[] w B[].

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

Wiele argumentów typu

Niektóre konstruktory przyjmują dwa argumenty, tak jak Either<E, A>. fp-ts rozszerza ten wzorzec za pomocą URItoKind2 i Kind2<F, E, A> dla rodzaju * -> * -> *. Pomysł skaluje się przez dodawanie kolejnych rejestrów.

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

Konwencja fp-ts

fp-ts ustanowiło konwencję, której przestrzega cały ten kurs: jeden ciąg URI dla każdego typu danych, rejestr URItoKind rozszerzany przez scalanie deklaracji oraz Kind do rozstrzygania typu. Rozpoznanie tej konwencji pozwala czytać sygnatury typów fp-ts i Effect.

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

Rekord instancji

„Instancja” abstrakcji to wartość implementująca ją dla konkretnego URI. Instancja przechowuje konkretną metodę map. W następnej lekcji napiszemy instancję Array; tutaj przedstawiono jej kształt.

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

Dlaczego jest „lekki”

Nazywa się go wzorcem lekkiego HKT, ponieważ nie wymaga zmian w kompilatorze ani specjalnej składni, a jedynie interfejsów i dostępu indeksowanego. Kosztem jest odrobina ceremonii (URI i rejestry) w zamian za prawdziwie generyczny kod działający na kontenerach.

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

Ograniczenia

Wzorzec jest rozwlekły, a komunikaty o błędach mogą być niejasne, ponieważ opisują kodowanie zamiast domeny. Wymaga również zarejestrowania każdego kontenera. W większości aplikacji korzysta się z bibliotek, które już to zapewniają, zamiast budować takie kodowanie samodzielnie.

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

Złożenie wszystkich elementów

Pełny przepis na lekkie HKT: zdefiniować URI, zarejestrować je w URItoKind, zdefiniować abstrakcje za pomocą Kind<F, A> oraz udostępnić instancje dla poszczególnych URI. To cały zestaw narzędzi stojący za generycznymi bibliotekami funkcyjnymi w 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>;
}

Szybki test

Proszę sprawdzić zrozumienie wzorca lekkiego HKT.

Podsumowanie

Złożyli Państwo wzorzec lekkiego HKT.

Defunkcjonalizacja zastępuje zastosowanie funkcji typów wyszukiwaniem.
Kind<F, A> rozstrzyga URI oraz argument do konkretnego typu.
Sygnatury generyczne używają Kind zamiast F<A>.
Wzorzec skaluje się do dwóch argumentów za pomocą Kind2 i jest konwencją fp-ts.

Następnie: generyczne map z rzeczywistymi instancjami.

Często zadawane pytania

Czy lekcja „Lekki wzorzec HKT” jest bezpłatna?

Tak — pełny tekst „Lekki wzorzec HKT” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu TypeScript Academy, przejdź na CoddyKit PRO. Kurs TypeScript Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Lekki wzorzec HKT”?

Zaimplementuj sztuczkę defunkcjonalizacji Kind/URI Ćwiczysz TypeScript Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć TypeScript Academy?

Nie wymagamy żadnego doświadczenia. TypeScript Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 3 z 4.

Ile czasu zajmuje lekcja „Lekki wzorzec HKT”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji TypeScript Academy?

Tak. Każda lekcja TypeScript Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

← Powrót do TypeScript Academy