Result types & combinators.

export type Failure =
	| { kind: 'invalid'; field: 'coupon'; message: string }
	| { kind: 'not-found'; message: string }
	| { kind: 'unavailable'; retryAfterSeconds: number; message: string };

export type Result<T, E> = { ok: true; value: T } | { ok: false; error: E };

export type Position = 'hand-rolled' | 'own-combinators' | 'library' | 'effect-system';
export type ChainLength = 1 | 2 | 3 | 4;
export type FailureAt = 'none' | 'parse' | 'lookup' | 'price' | 'charge';

export type Observation = Readonly<{
	position: Position;
	chainLength: ChainLength;
	failureAt: FailureAt;
	result: 'success' | 'failure';
	completedSteps: number;
	propagation: string;
	spread: string;
	tradeoff: string;
}>;

const steps = ['parse', 'lookup', 'price', 'charge'] as const;

function ok<T>(value: T): Result<T, never> {
	return { ok: true, value };
}

function err<E>(error: E): Result<never, E> {
	return { ok: false, error };
}

function failureFor(step: FailureAt): Failure {
	switch (step) {
		case 'parse':
			return { kind: 'invalid', field: 'coupon', message: 'Enter a valid coupon.' };
		case 'lookup':
			return { kind: 'not-found', message: 'That coupon does not exist.' };
		case 'price':
			return {
				kind: 'unavailable',
				retryAfterSeconds: 5,
				message: 'Pricing is temporarily unavailable.'
			};
		case 'charge':
			return {
				kind: 'unavailable',
				retryAfterSeconds: 10,
				message: 'Payment is temporarily unavailable.'
			};
		case 'none':
			return { kind: 'invalid', field: 'coupon', message: 'No failure was selected.' };
	}
}

const subtotal = 100;
const couponFormat = /^[A-Z]+[0-9]{1,2}$/;

export function parseCoupon(input: string): Result<string, Failure> {
	const code = input.trim();
	return couponFormat.test(code)
		? ok(code)
		: err({ kind: 'invalid', field: 'coupon', message: 'Enter a valid coupon.' });
}

export function lookupCoupon(code: string): Result<number, Failure> {
	return code === 'SAVE10'
		? ok(10)
		: err({ kind: 'not-found', message: 'That coupon does not exist.' });
}

export function discountedTotal(percent: number): number {
	return (subtotal * (100 - percent)) / 100;
}

/** R1: every dependent step gets its own guard clause. */
export function checkout(input: string): Result<number, Failure> {
	const coupon = parseCoupon(input);
	if (!coupon.ok) return coupon;
	const percent = lookupCoupon(coupon.value);
	if (!percent.ok) return percent;
	return ok(discountedTotal(percent.value));
}

export function map<T, U, E>(result: Result<T, E>, transform: (value: T) => U): Result<U, E> {
	return result.ok ? ok(transform(result.value)) : { ok: false, error: result.error };
}

export function andThen<T, U, E>(
	result: Result<T, E>,
	next: (value: T) => Result<U, E>
): Result<U, E> {
	return result.ok ? next(result.value) : { ok: false, error: result.error };
}

export function mapError<T, E, F>(result: Result<T, E>, transform: (error: E) => F): Result<T, F> {
	return result.ok ? result : { ok: false, error: transform(result.error) };
}

export function unwrapOr<T, E>(result: Result<T, E>, fallback: T): T {
	return result.ok ? result.value : fallback;
}

/** R2: the same checkout, with propagation moved into helpers you now maintain. */
export function checkoutWithCombinators(input: string): Result<number, Failure> {
	return map(andThen(parseCoupon(input), lookupCoupon), discountedTotal);
}

// Stands in for an installed Result package so the lesson runs without a download. A real R3
// choice imports this class (and its async twin) from the library instead of defining it.
export class LibraryResult<T, E> {
	readonly result: Result<T, E>;

	private constructor(result: Result<T, E>) {
		this.result = result;
	}

	static from<T, E>(result: Result<T, E>): LibraryResult<T, E> {
		return new LibraryResult(result);
	}

	andThen<U>(next: (value: T) => Result<U, E>): LibraryResult<U, E> {
		return new LibraryResult(andThen(this.result, next));
	}

	map<U>(transform: (value: T) => U): LibraryResult<U, E> {
		return new LibraryResult(map(this.result, transform));
	}
}

/** R3: the library's type is now the signature every caller above this one sees. */
export function checkoutThroughLibrary(input: string): LibraryResult<number, Failure> {
	return LibraryResult.from(parseCoupon(input)).andThen(lookupCoupon).map(discountedTotal);
}

export type Effect<Requirements, E, A> = Readonly<{
	requires: Requirements;
	run: (requirements: Requirements) => Result<A, E>;
}>;

export type CheckoutServices = Readonly<{ pricing: string; payments: string }>;

export function checkoutAsEffect(input: string): Effect<CheckoutServices, Failure, number> {
	return {
		requires: { pricing: 'pricing-service', payments: 'payment-service' },
		run: () => checkoutWithCombinators(input)
	};
}

function runStep(
	value: string,
	step: (typeof steps)[number],
	failureAt: FailureAt
): Result<string, Failure> {
	return failureAt === step ? err(failureFor(step)) : ok(`${value} → ${step}`);
}

function runWithGuards(length: ChainLength, failureAt: FailureAt): Result<string, Failure> {
	let value = 'cart';
	for (const step of steps.slice(0, length)) {
		const result = runStep(value, step, failureAt);
		if (!result.ok) return result;
		value = result.value;
	}
	return ok(value);
}

function runWithOwnCombinators(length: ChainLength, failureAt: FailureAt): Result<string, Failure> {
	let result: Result<string, Failure> = ok('cart');
	for (const step of steps.slice(0, length)) {
		result = andThen(result, (value) => runStep(value, step, failureAt));
	}
	return result;
}

export function observe(
	position: Position,
	chainLength: ChainLength,
	failureAt: FailureAt
): Observation {
	const result =
		position === 'hand-rolled'
			? runWithGuards(chainLength, failureAt)
			: runWithOwnCombinators(chainLength, failureAt);
	const failureIndex =
		failureAt === 'none' ? -1 : steps.indexOf(failureAt as (typeof steps)[number]);
	const reachedFailure = failureIndex >= 0 && failureIndex < chainLength;
	const completedSteps = reachedFailure ? failureIndex : chainLength;
	const propagation =
		position === 'hand-rolled'
			? `${chainLength} operation${chainLength === 1 ? '' : 's'} need${chainLength === 1 ? 's' : ''} an explicit guard.`
			: `${chainLength} operation${chainLength === 1 ? '' : 's'} share one propagation vocabulary.`;
	const descriptions: Record<Position, { spread: string; tradeoff: string }> = {
		'hand-rolled': {
			spread: 'One function',
			tradeoff: 'No dependency; every deeper call site repeats the check.'
		},
		'own-combinators': {
			spread: 'Where helpers are used',
			tradeoff: 'No dependency; async twins and error widening become your maintenance job.'
		},
		library: {
			spread: 'Every signature above the call',
			tradeoff:
				'Combinators and edge cases are maintained elsewhere, but the type becomes a codebase commitment.'
		},
		'effect-system': {
			spread: 'The whole effectful boundary',
			tradeoff:
				'Requirements, retries, and timeouts compose; adopting or leaving is a large rewrite.'
		}
	};
	return {
		position,
		chainLength,
		failureAt,
		result: result.ok ? 'success' : 'failure',
		completedSteps,
		propagation,
		spread: descriptions[position].spread,
		tradeoff: descriptions[position].tradeoff
	};
}

export const checkoutInputs = ['SAVE10', 'SAVE5', 'save 10!'] as const;

/** One line per input, printed identically by the Go program. */
export function describeCheckout(input: string, result: Result<number, Failure>): string {
	return result.ok
		? `${JSON.stringify(input)}: total ${result.value}`
		: `${JSON.stringify(input)}: ${result.error.kind} (${result.error.message})`;
}

export function runExample(): string[] {
	return checkoutInputs.map((input) => describeCheckout(input, checkoutWithCombinators(input)));
}

for (const line of runExample()) console.log(line);

package main

import (
	"fmt"
	"regexp"
	"strconv"
	"strings"
)

const subtotal = 100

var couponFormat = regexp.MustCompile(`^[A-Z]+[0-9]{1,2}$`)

// Failure carries the same kinds as the TypeScript union: invalid, not-found, unavailable.
type Failure struct {
	Kind    string
	Message string
}

func (f *Failure) Error() string { return f.Kind + " (" + f.Message + ")" }

func parseCoupon(input string) (string, error) {
	code := strings.TrimSpace(input)
	if !couponFormat.MatchString(code) {
		return "", &Failure{Kind: "invalid", Message: "Enter a valid coupon."}
	}
	return code, nil
}

func lookupCoupon(code string) (int, error) {
	if code == "SAVE10" {
		return 10, nil
	}
	return 0, &Failure{Kind: "not-found", Message: "That coupon does not exist."}
}

func discountedTotal(percent int) int {
	return subtotal * (100 - percent) / 100
}

// checkout is Go's standard position: the (value, error) pair is the result type,
// and each dependent step forwards its error explicitly.
func checkout(input string) (int, error) {
	code, err := parseCoupon(input)
	if err != nil {
		return 0, err
	}
	percent, err := lookupCoupon(code)
	if err != nil {
		return 0, err
	}
	return discountedTotal(percent), nil
}


// Result is the helper you would own. Go methods cannot declare their own type parameters,
// so Map and AndThen are plain functions, and every standard-library call still returns a
// (value, error) pair that has to be converted with From.
type Result[T any] struct {
	Value T
	Err   error
}

func From[T any](value T, err error) Result[T] {
	return Result[T]{Value: value, Err: err}
}

func AndThen[T, U any](r Result[T], next func(T) (U, error)) Result[U] {
	if r.Err != nil {
		return Result[U]{Err: r.Err}
	}
	return From(next(r.Value))
}

func Map[T, U any](r Result[T], transform func(T) U) Result[U] {
	if r.Err != nil {
		return Result[U]{Err: r.Err}
	}
	return Result[U]{Value: transform(r.Value)}
}

func checkoutWithCombinators(input string) Result[int] {
	return Map(AndThen(From(parseCoupon(input)), lookupCoupon), discountedTotal)
}

var checkoutInputs = []string{"SAVE10", "SAVE5", "save 10!"}

// describeCheckout prints the same line as the TypeScript example for each input.
func describeCheckout(input string, result Result[int]) string {
	if result.Err != nil {
		return strconv.Quote(input) + ": " + result.Err.Error()
	}
	return fmt.Sprintf("%s: total %d", strconv.Quote(input), result.Value)
}

func main() {
	for _, input := range checkoutInputs {
		fmt.Println(describeCheckout(input, checkoutWithCombinators(input)))
	}
}