TypeScript Academy · Lekcja

Kanały błędów i zależności

Śledź typowane błędy i wstrzyknięte zależności w efektach

Kanały błędów i zależności to bezpłatna lekcja TypeScript Academy na CoddyKit. To lekcja 4 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.

Kanały błędów i zależności

Dwa kanały sprawiają, że Effect jest tak potężny: typowany kanał błędów (E) oraz kanał wymagań (R). W tej lekcji pokazano, jak kończyć działanie efektu typowanymi błędami oraz jak dostarczać zależności za pomocą Context i Layer.

Typowane błędy za pomocą Effect.fail

Effect.fail umieszcza wartość w kanale błędów. Klasy z tagami ułatwiają rozróżnianie błędów.

import { Effect } from "effect";

class NotFound { readonly _tag = "NotFound"; }
class Forbidden { readonly _tag = "Forbidden"; }

const load = Effect.fail(new NotFound());
// Effect<never, NotFound, never>

Błędy łączą się w unie podczas kompozycji

Sekwencjonowanie efektów z różnymi błędami łączy je w kanale E, dzięki czemu typ wymienia każdy możliwy sposób niepowodzenia.

// Effect<A, NotFound, never> then Effect<B, Forbidden, never>
// => Effect<B, NotFound | Forbidden, never>

Obsługa błędów

Effect.catchAll lub catchTag obsługują błędy, usuwając je z kanału albo zastępując je innymi. Obsługa NotFound zawęża kanał E.

import { Effect, pipe } from "effect";

const safe = pipe(
  Effect.fail(new NotFound()),
  Effect.catchTag("NotFound", () => Effect.succeed("default"))
);
// Effect<string, never, never> -- error handled

Obsługa a propagacja

Jeśli błąd nie zostanie obsłużony, pozostaje w kanale E i jest propagowany do wywołującego, który musi go obsłużyć albo propagować dalej. Kompilator gwarantuje, że żadne błędy nie zostaną po cichu utracone.

Deklarowanie zależności

Usługę deklaruje się jako Context.Tag. Efekty, które z niej korzystają, otrzymują tę usługę w swoim kanale R.

import { Context, Effect } from "effect";

class Random extends Context.Tag("Random")<
  Random,
  { readonly next: Effect.Effect<number> }
>() {}

const program = Effect.gen(function* () {
  const random = yield* Random;
  return yield* random.next;
});
// Effect<number, never, Random>

Wymagania są widoczne w typie

Proszę zauważyć, że kanał R zawiera teraz Random. Efekt nie może zostać uruchomiony, dopóki to wymaganie nie zostanie spełnione; kompilator egzekwuje tę zasadę.

Zapewnianie zależności za pomocą warstwy

Layer opisuje sposób tworzenia usługi. Dostarczenie warstwy spełnia wymaganie i usuwa je z kanału R.

import { Effect, Layer } from "effect";

const RandomLive = Layer.succeed(Random, {
  next: Effect.sync(() => Math.random()),
});

const runnable = Effect.provide(program, RandomLive);
// Effect<number, never, never> -- R cleared

Kompozycja warstw

Warstwy mogą zależeć od innych warstw i łączyć się ze sobą, tworząc pełny graf zależności. Effect łączy je we właściwej kolejności na podstawie ich typów.

import { Layer } from "effect";
// Layer.merge(DatabaseLive, LoggerLive)
// Layer that provides both services

Testowanie przez zamianę warstw

Ponieważ zależności są jawne, w testach można dostarczyć inną warstwę, na przykład deterministyczny Random, bez zmieniania testowanego programu. To jedna z najważniejszych zalet śledzenia wymagań.

import { Layer, Effect } from "effect";

const RandomTest = Layer.succeed(Random, {
  next: Effect.succeed(0.5),
});
// Effect.provide(program, RandomTest) -> deterministic

Dlaczego to ma znaczenie

Kanały błędów i wymagań zamieniają niewidoczne założenia w kontrakty sprawdzane przez kompilator: każdy błąd musi zostać obsłużony lub zadeklarowany, a każda zależność musi zostać dostarczona. Dzięki temu duże programy Effect są niezawodne i łatwe do testowania.

Szybki test

Proszę sprawdzić swoje rozumienie kanałów błędów i zależności.

Podsumowanie

Kanał błędów śledzi typowane niepowodzenia (Effect.fail, zawężane przez catchTag/catchAll), które podczas kompozycji łączą się w unie, natomiast kanał wymagań śledzi usługi zadeklarowane za pomocą Context.Tag i spełniane przez Layer za pośrednictwem Effect.provide. Razem sprawiają, że błędy i zależności są sprawdzane przez kompilator, a testowanie staje się łatwe dzięki zamianie warstw.

Często zadawane pytania

Czy lekcja „Kanały błędów i zależności” jest bezpłatna?

Tak — pełny tekst „Kanały błędów i zależności” 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 „Kanały błędów i zależności”?

Śledź typowane błędy i wstrzyknięte zależności w efektach Ć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 4 z 4.

Ile czasu zajmuje lekcja „Kanały błędów i zależności”?

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