+47

tests/composition.test.ts

reviewed

··· 1 1 + import { describe, it, expect } from "bun:test" 2 2 + import { pipe, flow, id, constant, flip, tap } from "../src/index" 3 3 + 4 4 + describe("Composition", () => { 5 5 + describe("pipe", () => { 6 6 + it("pipes single value", () => { 7 7 + expect(pipe(5)).toBe(5) 8 8 + }) 9 9 + 10 10 + it("pipes through functions", () => { 11 11 + const result = pipe(5, x => x + 1, x => x * 2, x => `result: ${x}`) 12 12 + expect(result).toBe("result: 12") 13 13 + }) 14 14 + }) 15 15 + 16 16 + describe("flow", () => { 17 17 + it("composes functions left-to-right", () => { 18 18 + const process = flow((x: number) => x + 1, x => x * 2, x => `result: ${x}`) 19 19 + expect(process(5)).toBe("result: 12") 20 20 + }) 21 21 + }) 22 22 + 23 23 + describe("utilities", () => { 24 24 + it("id returns input unchanged", () => { 25 25 + expect(id(42)).toBe(42) 26 26 + }) 27 27 + 28 28 + it("constant returns a function that always returns the value", () => { 29 29 + const always5 = constant(5) 30 30 + expect(always5()).toBe(5) 31 31 + }) 32 32 + 33 33 + it("flip swaps curried function arguments", () => { 34 34 + const sub = (a: number) => (b: number) => a - b 35 35 + const flipped = flip(sub) 36 36 + expect(sub(10)(3)).toBe(7) 37 37 + expect(flipped(3)(10)).toBe(7) 38 38 + }) 39 39 + 40 40 + it("tap performs side effect and returns value", () => { 41 41 + let sideEffect = 0 42 42 + const result = tap<number>(x => { sideEffect = x })(42) 43 43 + expect(result).toBe(42) 44 44 + expect(sideEffect).toBe(42) 45 45 + }) 46 46 + }) 47 47 + })

+37

tests/guards.test.ts

reviewed

··· 1 1 + import { describe, it, expect } from "bun:test" 2 2 + import { isString, isNumber, isBoolean, and, or, isPositive, isInteger } from "../src/index" 3 3 + 4 4 + describe("Guards", () => { 5 5 + describe("primitive guards", () => { 6 6 + it("isString checks for strings", () => { 7 7 + expect(isString("hello")).toBe(true) 8 8 + expect(isString(123)).toBe(false) 9 9 + }) 10 10 + 11 11 + it("isNumber checks for numbers", () => { 12 12 + expect(isNumber(42)).toBe(true) 13 13 + expect(isNumber("42")).toBe(false) 14 14 + }) 15 15 + 16 16 + it("isBoolean checks for booleans", () => { 17 17 + expect(isBoolean(true)).toBe(true) 18 18 + expect(isBoolean(0)).toBe(false) 19 19 + }) 20 20 + }) 21 21 + 22 22 + describe("compound guards", () => { 23 23 + it("and combines guards with intersection", () => { 24 24 + const isPositiveNumber = and(isNumber, isPositive) 25 25 + expect(isPositiveNumber(5)).toBe(true) 26 26 + expect(isPositiveNumber(-5)).toBe(false) 27 27 + expect(isPositiveNumber("5")).toBe(false) 28 28 + }) 29 29 + 30 30 + it("or combines guards with union", () => { 31 31 + const isStringOrNumber = or(isString, isNumber) 32 32 + expect(isStringOrNumber("hello")).toBe(true) 33 33 + expect(isStringOrNumber(42)).toBe(true) 34 34 + expect(isStringOrNumber(true)).toBe(false) 35 35 + }) 36 36 + }) 37 37 + })

+65

tests/pattern-matching.test.ts

reviewed

··· 1 1 + import { describe, it, expect } from "bun:test" 2 2 + import { match, matchOr, when, matchResult, matchOption, ok, err, some, none } from "../src/index" 3 3 + 4 4 + describe("Pattern Matching", () => { 5 5 + type Shape = 6 6 + | { _tag: "Circle"; radius: number } 7 7 + | { _tag: "Rectangle"; width: number; height: number } 8 8 + 9 9 + describe("match", () => { 10 10 + it("matches all variants exhaustively", () => { 11 11 + const area = (shape: Shape) => 12 12 + match(shape)({ 13 13 + Circle: ({ radius }) => Math.PI * radius * radius, 14 14 + Rectangle: ({ width, height }) => width * height, 15 15 + }) 16 16 + 17 17 + expect(area({ _tag: "Circle", radius: 2 })).toBeCloseTo(12.566, 2) 18 18 + expect(area({ _tag: "Rectangle", width: 3, height: 4 })).toBe(12) 19 19 + }) 20 20 + }) 21 21 + 22 22 + describe("matchOr", () => { 23 23 + it("uses default for unhandled variants", () => { 24 24 + const describe = matchOr<Shape, string>("unknown") 25 25 + const result = describe({ _tag: "Rectangle", width: 1, height: 1 })({ Circle: () => "a circle" }) 26 26 + expect(result).toBe("unknown") 27 27 + }) 28 28 + }) 29 29 + 30 30 + describe("when", () => { 31 31 + it("matches predicates in order", () => { 32 32 + const grade = (score: number) => 33 33 + when(score)( 34 34 + [s => s >= 90, () => "A"], 35 35 + [s => s >= 80, () => "B"], 36 36 + )(() => "F") 37 37 + 38 38 + expect(grade(95)).toBe("A") 39 39 + expect(grade(85)).toBe("B") 40 40 + expect(grade(65)).toBe("F") 41 41 + }) 42 42 + }) 43 43 + 44 44 + describe("matchResult", () => { 45 45 + it("matches Ok and Err", () => { 46 46 + const format = matchResult<number, string, string>( 47 47 + v => `value: ${v}`, 48 48 + e => `error: ${e}` 49 49 + ) 50 50 + expect(format(ok(42))).toBe("value: 42") 51 51 + expect(format(err("fail"))).toBe("error: fail") 52 52 + }) 53 53 + }) 54 54 + 55 55 + describe("matchOption", () => { 56 56 + it("matches Some and None", () => { 57 57 + const format = matchOption<number, string>( 58 58 + v => `found: ${v}`, 59 59 + () => "empty" 60 60 + ) 61 61 + expect(format(some(42))).toBe("found: 42") 62 62 + expect(format(none)).toBe("empty") 63 63 + }) 64 64 + }) 65 65 + })