What is Either and what does it represent?

Either is an fp-ts type that represents success or failure as `Right(value)` for success or `Left(error)` for failure, enabling typed synchronous error handling.

How do I convert throwing code like JSON.parse into an Either?

Use `E.tryCatch(fn, toError)` to convert throwing code into an Either, which captures the error in a `Left` or the result in a `Right`.

How do I chain multiple Either-returning operations so the chain stops at the first error?

Use `pipe` and `E.flatMap(fn)` to chain multiple validations; the chain automatically stops and returns the first `Left` error encountered.

What's the difference between using Either versus plain try/catch?

Either makes the error type explicit and compiler-tracked, and operations are chainable; plain try/catch doesn't track error types at compile time and isn't composable in the same way.

How do I extract a value from an Either or provide a fallback?

Use `E.getOrElse(err => default)` to get the `Right` value or a fallback, or `E.match(onLeft, onRight)` to pattern-match both branches.

Skill

Implement Typed Error Handling with fp-ts Either

Name: Either Quick Reference
Availability: OnlineOnly
Author: Antigravity

A compact fp-ts Either cheat sheet: creating, transforming, and extracting typed success/failure values.

Get skill

Works with github

Antigravity

Own this? Claim it

Spark score

out of 100

Updated last month

Version 1.0.0

Add to Favorites

Why it matters

Leverage fp-ts Either for robust, type-safe synchronous error handling in your TypeScript projects. This skill provides a quick reference for managing success and failure states, ideal for validation and converting throwing code.

Outcomes

What it gets done

Quick reference for fp-ts Either type for synchronous error handling.

Examples for creating, transforming, and extracting values from Either.

Demonstrates validation and converting throwing code to Either.

Compares Either pattern with traditional try/catch for explicit error typing.

Install

Add it to your toolbox

Run in your project directory:

curl -fsSL https://spark.entire.vc/get/ag-fp-either-ref | bash

Overview

Either Quick Reference

A compact fp-ts Either cheat sheet covering creation, transformation, and extraction of typed success/failure values, with patterns for validation chains and converting throwing code. Use it as a quick reference for typed synchronous error handling in fp-ts, when a compact cheat sheet is wanted rather than a full tutorial.

What it does

A compact cheat sheet for fp-ts's Either type - success as Right(value) or failure as Left(error) - covering creation (E.right, E.left, E.fromNullable, E.tryCatch for wrapping try/catch), transformation (E.map, E.mapLeft, E.flatMap, E.filterOrElse), and extraction (E.getOrElse, E.match, E.toUnion). It shows common patterns - chaining validations that stop at the first error, and converting a throwing JSON.parse call into a typed Either via E.tryCatch - and contrasts a try/catch block, where errors aren't reflected in the type system, against the same logic expressed as a piped Either chain where errors are explicit in the types.

import * as E from 'fp-ts/Either'

E.right(value)           // Success
E.left(error)            // Failure

When to use - and when NOT to

Use it as a quick reference for typed synchronous error handling in fp-ts - validation, fallible operations, or converting throwing code to Either - when a compact cheat sheet is wanted rather than a full tutorial.

Inputs and outputs

Input: a TypeScript function or validation that can fail synchronously. Output: an Either<Error, Value> expression using the referenced creation, transform, or extraction functions.

Who it's for

TypeScript developers using fp-ts who want error type-safety for synchronous operations and a fast lookup rather than documentation.

FAQ

Common questions

Discussion