Waarom effectsystemen belangrijk zijn

Een effectensysteem maakt neveneffecten, mislukkingen en afhankelijkheden expliciet en combineerbaar in het typesysteem. In plaats van verborgen throw-instructies en impliciete I/O is elk effect een waarde die je kunt doorgeven, transformeren en combineren.

Gewone async/await met throw verbergt cruciale informatie: de functiesignatuur vermeldt niet welke fouten de functie kan gooien of welke bronnen deze nodig heeft.

Promise<User> vertelt je niets over manieren waarop het kan mislukken. Aanroepers weten niet welke fouten ze moeten afhandelen, waardoor ze óf te veel fouten onderscheppen óf gevallen volledig vergeten.

De bovenstaande functie is stilzwijgend afhankelijk van een database. Die afhankelijkheid wordt opgehaald uit een globale waarde of import, waardoor testen en vervangen onhandig worden en het werkelijke contract verborgen blijft.

Een effect is een beschrijving van een berekening, niet de berekening zelf. Het opbouwen ervan doet niets; je voert het later uit. Daardoor zijn effecten zuivere waarden die je net als gegevens kunt combineren.

Effecten dragen hun mogelijke fouten mee in het type, waardoor de compiler je dwingt ze bewust af te handelen of door te geven.

Effecten houden ook de vereiste diensten bij in hun type. Een berekening die een Database nodig heeft, zegt dat expliciet en kan pas worden uitgevoerd wanneer zo'n dienst is geleverd.

Omdat effecten waarden zijn, combineer je ze met operatoren (map, flatMap, zip), net als arrays of promises, terwijl fout- en afhankelijkheidskanalen automatisch worden meegedragen.

Er gebeurt niets totdat je het effect expliciet uitvoert (bijvoorbeeld met Effect.runPromise). Door beschrijving en uitvoering te scheiden, kun je opnieuw proberen, onderbreken en testen zonder neveneffecten opnieuw te activeren.

Een Promise is gretig (wordt onmiddellijk uitgevoerd), heeft ongetypeerde fouten en houdt geen rekening met afhankelijkheden. Een Effect is lui, heeft getypeerde fouten en houdt rekening met afhankelijkheden: het bevat strikt meer informatie.

Doordat effecten, fouten en afhankelijkheden expliciet zijn, dwingt de compiler een correcte afhandeling af, wordt code testbaar door afhankelijkheden te vervangen en kunnen complexe asynchrone stromen betrouwbaar worden gecombineerd. Dat is de motivatie achter bibliotheken zoals Effect-TS.

Effectsystemen maken neveneffecten, mislukkingen en afhankelijkheden expliciet. In tegenstelling tot gretige promises die blind zijn voor fouten en afhankelijkheden verbergen, is een effect een luie, combineerbare beschrijving van een berekening waarvan het type informatie bevat over succes, fouten en vereisten. Zo worden betrouwbare samenstelling en testbaarheid mogelijk.