From 3ee432d4277546b38aea0ce119269d168446e507 Mon Sep 17 00:00:00 2001
From: Timm Stelzer <timmstelzer@gmail.com>
Date: Sat, 4 May 2024 23:07:02 +0200
Subject: [PATCH] DIRTY [skip ci]

---
 workspace/cli/src/index.ts                    |  23 +-
 workspace/core/src/Classify.ts                | 103 +-------
 workspace/core/src/DisplayConfig.ts           |  21 ++
 workspace/core/src/Json.ts                    |   2 -
 workspace/core/src/Show.ts                    |  73 +++++-
 workspace/core/src/Show/DisplayConfig.ts      |  35 ---
 workspace/core/src/Test.ts                    | 233 ++----------------
 workspace/core/src/index.ts                   |   4 +-
 workspace/core/src/internal/Classify.ts       | 103 ++++++++
 workspace/core/src/internal/DisplayConfig.ts  |  17 ++
 workspace/core/src/internal/Test.ts           | 221 +++++++++++++++++
 .../core/src/{Show => internal}/common.ts     |   2 +-
 workspace/core/src/{Show => internal}/diff.ts |  51 ++--
 .../src/{Show => internal}/format-diff.ts     |   0
 .../core/src/{Show => internal}/stats.ts      |  41 ++-
 .../core/src/{Show => internal}/summarize.ts  |  67 ++---
 workspace/examples/src/as-library/async.ts    |   8 +-
 workspace/examples/src/as-library/complex.ts  |  88 -------
 workspace/examples/src/as-library/simple.ts   |   8 +-
 19 files changed, 537 insertions(+), 563 deletions(-)
 create mode 100644 workspace/core/src/DisplayConfig.ts
 delete mode 100644 workspace/core/src/Json.ts
 delete mode 100644 workspace/core/src/Show/DisplayConfig.ts
 create mode 100644 workspace/core/src/internal/Classify.ts
 create mode 100644 workspace/core/src/internal/DisplayConfig.ts
 create mode 100644 workspace/core/src/internal/Test.ts
 rename workspace/core/src/{Show => internal}/common.ts (98%)
 rename workspace/core/src/{Show => internal}/diff.ts (63%)
 rename workspace/core/src/{Show => internal}/format-diff.ts (100%)
 rename workspace/core/src/{Show => internal}/stats.ts (67%)
 rename workspace/core/src/{Show => internal}/summarize.ts (78%)
 delete mode 100644 workspace/examples/src/as-library/complex.ts

diff --git a/workspace/cli/src/index.ts b/workspace/cli/src/index.ts
index b1b60a0..5042540 100644
--- a/workspace/cli/src/index.ts
+++ b/workspace/cli/src/index.ts
@@ -6,11 +6,11 @@ import * as PT from '@creative-introvert/prediction-testing';
 import * as P from './prelude.js';
 
 export type Config<I = unknown, O = unknown, T = unknown> = {
-    testSuite: PT.TestSuite<I, O, T>;
+    testSuite: PT.Test.TestSuite<I, O, T>;
     dirPath: string;
     filePostfix: string;
     testSuiteName: string;
-    displayConfig?: Partial<PT.Show.DisplayConfig> | undefined;
+    displayConfig?: Partial<PT.DisplayConfig.DisplayConfig> | undefined;
     showInput?: undefined | ((input: I) => string);
     showExpected?: undefined | ((expected: T) => string);
     showResult?: undefined | ((result: O, expected: T) => string);
@@ -38,13 +38,13 @@ const labels = Options.text('labels').pipe(
 
 const createFilterLabel =
     (maybeLables: P.O.Option<readonly PT.Classify.Label[]>) =>
-    (tr: PT.TestResult<unknown, unknown, unknown>) =>
+    (tr: PT.Test.TestResult<unknown, unknown, unknown>) =>
         P.O.match(maybeLables, {
             onNone: () => true,
             onSome: labels => labels.includes(tr.label),
         });
 
-const TestRunSchema = P.Schema.parseJson(PT.TestRunSchema);
+const TestRunSchema = P.Schema.parseJson(PT.Test.TestRunSchema);
 
 const readPreviousTestRun = P.E.gen(function* () {
     const {testSuiteName, dirPath, filePostfix} = yield* Config;
@@ -67,9 +67,9 @@ const summarize = Command.make('summarize', {labels}, ({labels}) =>
 
         const filterLabel = createFilterLabel(labels);
         const previousTestRun = yield* readPreviousTestRun;
-        const testRun = yield* PT.testAll(testSuite).pipe(
+        const testRun = yield* PT.Test.all(testSuite).pipe(
             P.Stream.filter(filterLabel),
-            PT.runFoldEffect,
+            PT.Test.runFoldEffect,
         );
 
         if (testRun.testResultIds.length === 0) {
@@ -114,7 +114,7 @@ const diff = Command.make('diff', {ci}, ({ci}) =>
 
         const previousTestRun = yield* readPreviousTestRun;
 
-        const testRun = yield* PT.testAll(testSuite).pipe(
+        const testRun = yield* PT.Test.all(testSuite).pipe(
             P.Stream.filter(next =>
                 P.pipe(
                     P.O.flatMap(previousTestRun, prevTestRun =>
@@ -128,7 +128,7 @@ const diff = Command.make('diff', {ci}, ({ci}) =>
                     P.O.getOrElse(() => true),
                 ),
             ),
-            PT.runFoldEffect,
+            PT.Test.runFoldEffect,
         );
 
         if (testRun.testResultIds.length === 0) {
@@ -145,8 +145,7 @@ const diff = Command.make('diff', {ci}, ({ci}) =>
                 }),
                 '',
                 PT.Show.diff({
-                    testRun,
-                    diff: PT.diff({testRun, previousTestRun}),
+                    diff: PT.Test.diff({testRun, previousTestRun}),
                 }),
             ].join('\n'),
         );
@@ -164,7 +163,9 @@ const write = Command.make('write', {}, () =>
 
         yield* fs.makeDirectory(dirPath, {recursive: true});
 
-        const testRun = yield* PT.testAll(testSuite).pipe(PT.runFoldEffect);
+        const testRun = yield* PT.Test.all(testSuite).pipe(
+            PT.Test.runFoldEffect,
+        );
         const filePath = `${dirPath}/${testSuiteName}.${filePostfix}.json`;
         yield* fs.writeFileString(filePath, JSON.stringify(testRun, null, 2));
         yield* P.Console.log(`Wrote to "${filePath}"`);
diff --git a/workspace/core/src/Classify.ts b/workspace/core/src/Classify.ts
index f24018c..19bd2e4 100644
--- a/workspace/core/src/Classify.ts
+++ b/workspace/core/src/Classify.ts
@@ -1,109 +1,14 @@
-import * as P from './prelude.js';
+import * as internal from './internal/Classify.js';
 
-export const Label = {
-    TN: 'TN',
-    TP: 'TP',
-    FP: 'FP',
-    FN: 'FN',
-} as const;
+export type Label = 'TP' | 'TN' | 'FP' | 'FN';
 
-export type Label = (typeof Label)[keyof typeof Label];
-
-export const LabelSchema: P.Schema.Schema<Label> = P.Schema.Literal(
-    'TP',
-    'TN',
-    'FP',
-    'FN',
-);
-
-export const defaultIsNil = <I>(x: I): boolean => x === null || x === undefined;
+export const values = internal.values;
 
 export type Classify<O, T> = (output: O, expected: T) => Label;
 
-export const make =
-    <O, T>(
-        isEqual: (output: O, expected: T) => boolean,
-        isOutputNil: (output: O) => boolean = defaultIsNil,
-        isExpectedNil: (expected: T) => boolean = defaultIsNil,
-    ): Classify<O, T> =>
-    (output, expected) => {
-        const eq = isEqual(output, expected);
-        const oNil = isOutputNil(output);
-        const eNil = isExpectedNil(expected);
-
-        if (oNil && eNil) {
-            return Label.TN;
-        }
-
-        if (!oNil && !eNil && eq) {
-            return Label.TP;
-        }
-
-        if ((!oNil && eNil) || (!oNil && !eNil && !eq)) {
-            return Label.FP;
-        }
-
-        return Label.FN;
-    };
-
 export type Stats = Record<Label, number> & {
     precision: number;
     recall: number;
 };
 
-export const StatsSchema: P.Schema.Schema<Stats> = P.Schema.Struct({
-    TP: P.Schema.Number,
-    TN: P.Schema.Number,
-    FP: P.Schema.Number,
-    FN: P.Schema.Number,
-    precision: P.Schema.Number,
-    recall: P.Schema.Number,
-});
-
-export const Stats = {
-    empty: (): Stats => ({
-        TP: 0,
-        TN: 0,
-        FP: 0,
-        FN: 0,
-        precision: 0,
-        recall: 0,
-    }),
-};
-
-export const precision = (m: Stats): number => {
-    const r = m.TP / (m.TP + m.FP);
-    return isNaN(r) ? 0 : r;
-};
-
-export const recall = (m: Stats): number => {
-    const r = m.TP / (m.TP + m.FN);
-    return isNaN(r) ? 0 : r;
-};
-
-export const min = (xs: number[]): number =>
-    xs.reduce((min, x) => (x < min ? x : min), Infinity);
-
-export const max = (xs: number[]): number =>
-    xs.reduce((max, x) => (x > max ? x : max), -Infinity);
-
-export const mean = (xs: number[]): number | undefined => {
-    if (xs.length === 0) {
-        return undefined;
-    }
-
-    return xs.reduce((a, b) => a + b, 0) / xs.length;
-};
-
-export const median = (xs: number[]): number | undefined => {
-    if (xs.length === 0) {
-        return undefined;
-    }
-
-    const sorted = xs.slice().sort((a, b) => a - b);
-    const index = Math.floor(sorted.length / 2);
-
-    return sorted.length % 2 === 0
-        ? (sorted[index - 1] + sorted[index]) / 2
-        : sorted[index];
-};
+export const LabelSchema = internal.LabelSchema;
diff --git a/workspace/core/src/DisplayConfig.ts b/workspace/core/src/DisplayConfig.ts
new file mode 100644
index 0000000..8213bbd
--- /dev/null
+++ b/workspace/core/src/DisplayConfig.ts
@@ -0,0 +1,21 @@
+import * as internal from './internal/DisplayConfig.js';
+
+export type DisplayConfig = {
+    /** @default true */
+    colorize: boolean;
+    /** @default 2 */
+    columnPadding: number;
+    corner: string;
+    cornerLeft: string;
+    cornerRight: string;
+    cornerTop: string;
+    cornerTopLeft: string;
+    cornerTopRight: string;
+    cornerBottomLeft: string;
+    cornerBottomRight: string;
+    cornerBottom: string;
+    horizontal: string;
+    vertical: string;
+};
+
+export const makeDefault = internal.makeDefault;
diff --git a/workspace/core/src/Json.ts b/workspace/core/src/Json.ts
deleted file mode 100644
index 345d38b..0000000
--- a/workspace/core/src/Json.ts
+++ /dev/null
@@ -1,2 +0,0 @@
-export type Literal = string | number | boolean | null;
-export type Json = Literal | {[key: string]: Json} | Json[];
diff --git a/workspace/core/src/Show.ts b/workspace/core/src/Show.ts
index ce04e25..d598ed7 100644
--- a/workspace/core/src/Show.ts
+++ b/workspace/core/src/Show.ts
@@ -1,4 +1,69 @@
-export {summarize} from './Show/summarize.js';
-export {diff} from './Show/diff.js';
-export {stats} from './Show/stats.js';
-export {DisplayConfig} from './Show/DisplayConfig.js';
+import type {Stats} from './Classify.js';
+import type {Diff} from './Test.js';
+import type {TestRun} from './internal/Test.js';
+import type * as P from './prelude.js';
+
+export {summarize} from './internal/summarize.js';
+export {diff} from './internal/diff.js';
+export {stats} from './internal/stats.js';
+
+export type DiffContext = {
+    diff: Diff;
+};
+
+export type DiffColumnNames =
+    | 'TP'
+    | 'TN'
+    | 'FP'
+    | 'FN'
+    | 'precision'
+    | 'recall';
+
+export type DiffColumn = {
+    name: DiffColumnNames;
+    label: string;
+    make: (ctx: DiffContext) => string[];
+};
+
+export type StatsContext = {
+    stats: Stats;
+};
+
+export type StatsColumnNames =
+    | 'TP'
+    | 'TN'
+    | 'FP'
+    | 'FN'
+    | 'precision'
+    | 'recall';
+
+export type StatsColumn = {
+    name: StatsColumnNames;
+    label: string;
+    make: (ctx: StatsContext) => string[];
+};
+
+export type SummarizeContext = {
+    i: number;
+    ids: string[];
+    testRun: TestRun;
+    previousTestRun: P.O.Option<TestRun>;
+};
+
+export type SummarizeColumnNames =
+    | 'index'
+    | 'hash'
+    | 'input'
+    | 'tags'
+    | 'label'
+    | 'expected'
+    | 'result'
+    | 'result_diff'
+    | 'prev_result'
+    | 'prev_result_diff';
+
+export type SummarizeColumn = {
+    name: SummarizeColumnNames;
+    label: string;
+    make: (ctx: SummarizeContext) => string[];
+};
diff --git a/workspace/core/src/Show/DisplayConfig.ts b/workspace/core/src/Show/DisplayConfig.ts
deleted file mode 100644
index 9820069..0000000
--- a/workspace/core/src/Show/DisplayConfig.ts
+++ /dev/null
@@ -1,35 +0,0 @@
-export type DisplayConfig = {
-    /** @default true */
-    colorize: boolean;
-    /** @default 2 */
-    columnPadding: number;
-    corner: string;
-    cornerLeft: string;
-    cornerRight: string;
-    cornerTop: string;
-    cornerTopLeft: string;
-    cornerTopRight: string;
-    cornerBottomLeft: string;
-    cornerBottomRight: string;
-    cornerBottom: string;
-    horizontal: string;
-    vertical: string;
-};
-
-export const DisplayConfig = {
-    default: (): DisplayConfig => ({
-        colorize: true,
-        columnPadding: 2,
-        corner: '┼',
-        cornerLeft: '├',
-        cornerRight: '┤',
-        cornerTop: '┬',
-        cornerTopLeft: '┌',
-        cornerTopRight: '┐',
-        cornerBottomLeft: '└',
-        cornerBottomRight: '┘',
-        cornerBottom: '┴',
-        horizontal: '─',
-        vertical: '│',
-    }),
-};
diff --git a/workspace/core/src/Test.ts b/workspace/core/src/Test.ts
index b22117a..1dde77f 100644
--- a/workspace/core/src/Test.ts
+++ b/workspace/core/src/Test.ts
@@ -1,13 +1,11 @@
-import {createHash} from 'node:crypto';
-import {isDeepStrictEqual} from 'node:util';
-
-import * as P from './prelude.js';
-import * as Classify from './Classify.js';
+import type {Classify, Label, Stats} from './Classify.js';
+import type * as P from './prelude.js';
+import * as internal from './internal/Test.js';
 
 export type TestSuite<I = unknown, O = unknown, T = unknown> = {
     testCases: TestCase<I, T>[];
     program: Program<I, O>;
-    classify?: Classify.Classify<O, T>;
+    classify?: Classify<O, T>;
 };
 
 export type TestCase<I, T> = {
@@ -20,230 +18,33 @@ export type Program<I, O> = (input: I) => P.E.Effect<O>;
 
 export type ID = string;
 
-export type _TestResult<I = unknown, O = unknown, T = unknown> = {
+export type TestResult<I = unknown, O = unknown, T = unknown> = {
     id: ID;
     input: I;
     result: O;
     expected: T;
-    label: Classify.Label;
+    label: Label;
     tags: Readonly<string[]>;
 };
 
-export class TestResult<
-    I = unknown,
-    O = unknown,
-    T = unknown,
-> extends P.Data.TaggedClass('TestResult')<_TestResult<I, O, T>> {
-    constructor(args: Omit<_TestResult<I, O, T>, 'id'>) {
-        const id = ID.create(args.input);
-        super({...args, id});
-    }
-}
-
-export const TestResultSchema: P.Schema.Schema<_TestResult> = P.Schema.Struct({
-    id: P.Schema.String,
-    input: P.Schema.Unknown,
-    result: P.Schema.Unknown,
-    expected: P.Schema.Unknown,
-    label: Classify.LabelSchema,
-    tags: P.Schema.Array(P.Schema.String),
-});
-
-export type _TestRun<I = unknown, O = unknown, T = unknown> = {
-    testResultsById: Record<ID, _TestResult<I, O, T>>;
+export type TestRun<I = unknown, O = unknown, T = unknown> = {
+    testResultsById: Record<ID, TestResult<I, O, T>>;
     testResultIds: ID[];
-    stats: Classify.Stats;
+    stats: Stats;
 };
 
-export class TestRun<
-    I = unknown,
-    O = unknown,
-    T = unknown,
-> extends P.Data.TaggedClass('TestRun')<_TestRun<I, O, T>> {
-    static empty<I, O, T>(): _TestRun<I, O, T> {
-        return new TestRun({
-            testResultsById: {},
-            testResultIds: [],
-            stats: Classify.Stats.empty(),
-        });
-    }
-}
-
-export const TestRunSchema: P.Schema.Schema<_TestRun> = P.Schema.Struct({
-    testResultsById: P.Schema.Record(P.Schema.String, TestResultSchema),
-    testResultIds: P.Schema.mutable(P.Schema.Array(P.Schema.String)),
-    stats: Classify.StatsSchema,
-});
-
-export type Diff = Record<Classify.Label, number> & {
+export type Diff = Record<Label, number> & {
     precision: number;
     recall: number;
 };
 
-export const diff = <I, O, T>({
-    testRun: {stats},
-    previousTestRun,
-}: {
-    testRun: _TestRun<I, O, T>;
-    previousTestRun: P.O.Option<_TestRun<I, O, T>>;
-}): Diff =>
-    previousTestRun.pipe(
-        P.O.match({
-            onNone: () => stats,
-            onSome: ({stats: previousStats}) => ({
-                TP: stats.TP - previousStats.TP,
-                TN: stats.TN - previousStats.TN,
-                FP: stats.FP - previousStats.FP,
-                FN: stats.FN - previousStats.FN,
-                precision: stats.precision - previousStats.precision,
-                recall: stats.recall - previousStats.recall,
-            }),
-        }),
-    );
-
-export const ID = {
-    create: <I>(input: I): ID => {
-        return createHash('sha256').update(JSON.stringify(input)).digest('hex');
-    },
-};
-
-export const test = <I, O, T>({
-    testCase: {input, expected, tags},
-    program,
-    classify,
-}: {
-    testCase: TestCase<I, T>;
-    program: Program<I, O>;
-    classify: Classify.Classify<O, T>;
-}): P.E.Effect<TestResult<I, O, T>> => {
-    return program(input).pipe(
-        P.E.map(
-            result =>
-                new TestResult<I, O, T>({
-                    input,
-                    result,
-                    expected,
-                    tags: tags ?? [],
-                    label: classify(result, expected),
-                }),
-        ),
-    );
-};
-
-export const testAll = <I, O, T>({
-    testCases,
-    program,
-    classify = Classify.make(
-        isDeepStrictEqual,
-        Classify.defaultIsNil,
-        Classify.defaultIsNil,
-    ),
-}: TestSuite<I, O, T>): P.Stream.Stream<_TestResult<I, O, T>> =>
-    P.pipe(
-        P.Stream.fromIterable(testCases),
-        P.Stream.mapEffect(testCase => test({testCase, program, classify})),
-    );
-
-export const runFoldEffect = <I, O, T>(
-    testResults$: P.Stream.Stream<_TestResult<I, O, T>>,
-): P.E.Effect<_TestRun<I, O, T>> =>
-    testResults$.pipe(
-        P.Stream.runFoldEffect(TestRun.empty<I, O, T>(), (run, result) =>
-            P.E.gen(function* () {
-                const {id} = result;
-
-                if (run.testResultsById[id] !== undefined) {
-                    yield* P.Console.warn(
-                        `Skipped duplicate test case. id=${id}`,
-                    );
-                    return run;
-                } else {
-                    run.testResultsById[id] = result;
-                    run.testResultIds.push(id);
-                    run.stats[result.label]++;
-                }
-
-                return run;
-            }),
-        ),
-        P.E.map(run => {
-            run.stats.precision = Classify.precision(run.stats);
-            run.stats.recall = Classify.recall(run.stats);
-            return run;
-        }),
-    );
-
-/**
- * Convenience function to run all tests and return the results.
- */
-export const runAll = <I, O, T>({
-    testCases,
-    program,
-    classify = Classify.make(
-        isDeepStrictEqual,
-        Classify.defaultIsNil,
-        Classify.defaultIsNil,
-    ),
-}: TestSuite<I, O, T>) =>
-    testAll({testCases, program, classify}).pipe(runFoldEffect, P.E.runPromise);
-
 export type TestResultPredicate<I, O, T> = (args: {
-    testResult: _TestResult<I, O, T>;
-    previousTestResult: P.O.Option<_TestResult<I, O, T>>;
+    testResult: TestResult<I, O, T>;
+    previousTestResult: P.O.Option<TestResult<I, O, T>>;
 }) => boolean;
 
-/** Filters results. Note, tests still run, but results are filtered out. */
-export const filterTestRun: {
-    <I, O, T>(
-        predicates: TestResultPredicate<I, O, T>[],
-    ): (args: {
-        testRun: _TestRun<I, O, T>;
-        previousTestRun: P.O.Option<_TestRun<I, O, T>>;
-    }) => _TestRun<I, O, T>;
-    <I, O, T>(
-        args: {
-            testRun: _TestRun<I, O, T>;
-            previousTestRun: P.O.Option<_TestRun<I, O, T>>;
-        },
-        predicates: TestResultPredicate<I, O, T>[],
-    ): _TestRun<I, O, T>;
-} = P.dual(
-    2,
-    <I, O, T>(
-        {
-            testRun,
-            previousTestRun,
-        }: {
-            testRun: _TestRun<I, O, T>;
-            previousTestRun: P.O.Option<_TestRun<I, O, T>>;
-        },
-        predicates: TestResultPredicate<I, O, T>[],
-    ) =>
-        P.pipe(
-            testRun.testResultIds.reduce((m, id) => {
-                const testResult = testRun.testResultsById[id];
-                const previousTestResult = previousTestRun.pipe(
-                    P.O.map(a => a.testResultsById[id]),
-                );
-                const isMatch = predicates.every(p =>
-                    p({testResult, previousTestResult}),
-                );
-
-                if (isMatch) {
-                    if (m.testResultsById[id] === undefined) {
-                        m.testResultsById[id] = {} as TestResult<I, O, T>;
-                    }
-                    m.testResultsById[id] = testResult;
-                    m.testResultIds.push(id);
-                    m.stats[testResult.label]++;
-                }
-
-                return m;
-            }, TestRun.empty<I, O, T>()),
-            run => {
-                run.stats.precision = Classify.precision(run.stats);
-                run.stats.recall = Classify.recall(run.stats);
-                return run;
-            },
-        ),
-);
+export const all = internal.testAll;
+export const runAll = internal.runAll;
+export const runFoldEffect = internal.runFoldEffect;
+export const diff = internal.diff;
+export const TestRunSchema = internal.TestRunSchema;
diff --git a/workspace/core/src/index.ts b/workspace/core/src/index.ts
index 9dc7ec7..95ce757 100644
--- a/workspace/core/src/index.ts
+++ b/workspace/core/src/index.ts
@@ -1,3 +1,5 @@
-export * from './Test.js';
+export * as Test from './Test.js';
 export * as Show from './Show.js';
 export * as Classify from './Classify.js';
+export * as Error from './Error.js';
+export * as DisplayConfig from './DisplayConfig.js';
diff --git a/workspace/core/src/internal/Classify.ts b/workspace/core/src/internal/Classify.ts
new file mode 100644
index 0000000..ef0135b
--- /dev/null
+++ b/workspace/core/src/internal/Classify.ts
@@ -0,0 +1,103 @@
+import * as P from '../prelude.js';
+import type {
+    Classify as TClassify,
+    Label as TLabel,
+    Stats as TStats,
+} from '../Classify.js';
+
+export const values = {
+    TN: 'TN',
+    TP: 'TP',
+    FP: 'FP',
+    FN: 'FN',
+} as const;
+
+export const LabelSchema: P.Schema.Schema<TLabel> = P.Schema.Literal(
+    'TP',
+    'TN',
+    'FP',
+    'FN',
+);
+
+export const defaultIsNil = <I>(x: I): boolean => x === null || x === undefined;
+
+export const makeClassify =
+    <O, T>(
+        isEqual: (output: O, expected: T) => boolean,
+        isOutputNil: (output: O) => boolean = defaultIsNil,
+        isExpectedNil: (expected: T) => boolean = defaultIsNil,
+    ): TClassify<O, T> =>
+    (output, expected) => {
+        const eq = isEqual(output, expected);
+        const oNil = isOutputNil(output);
+        const eNil = isExpectedNil(expected);
+
+        if (oNil && eNil) {
+            return values.TN;
+        }
+
+        if (!oNil && !eNil && eq) {
+            return values.TP;
+        }
+
+        if ((!oNil && eNil) || (!oNil && !eNil && !eq)) {
+            return values.FP;
+        }
+
+        return values.FN;
+    };
+
+export const StatsSchema: P.Schema.Schema<TStats> = P.Schema.Struct({
+    TP: P.Schema.Number,
+    TN: P.Schema.Number,
+    FP: P.Schema.Number,
+    FN: P.Schema.Number,
+    precision: P.Schema.Number,
+    recall: P.Schema.Number,
+});
+
+export const emptyStats = (): TStats => ({
+    TP: 0,
+    TN: 0,
+    FP: 0,
+    FN: 0,
+    precision: 0,
+    recall: 0,
+});
+
+export const precision = (m: TStats): number => {
+    const r = m.TP / (m.TP + m.FP);
+    return isNaN(r) ? 0 : r;
+};
+
+export const recall = (m: TStats): number => {
+    const r = m.TP / (m.TP + m.FN);
+    return isNaN(r) ? 0 : r;
+};
+
+export const min = (xs: number[]): number =>
+    xs.reduce((min, x) => (x < min ? x : min), Infinity);
+
+export const max = (xs: number[]): number =>
+    xs.reduce((max, x) => (x > max ? x : max), -Infinity);
+
+export const mean = (xs: number[]): number | undefined => {
+    if (xs.length === 0) {
+        return undefined;
+    }
+
+    return xs.reduce((a, b) => a + b, 0) / xs.length;
+};
+
+export const median = (xs: number[]): number | undefined => {
+    if (xs.length === 0) {
+        return undefined;
+    }
+
+    const sorted = xs.slice().sort((a, b) => a - b);
+    const index = Math.floor(sorted.length / 2);
+
+    return sorted.length % 2 === 0
+        ? (sorted[index - 1] + sorted[index]) / 2
+        : sorted[index];
+};
diff --git a/workspace/core/src/internal/DisplayConfig.ts b/workspace/core/src/internal/DisplayConfig.ts
new file mode 100644
index 0000000..1cfc327
--- /dev/null
+++ b/workspace/core/src/internal/DisplayConfig.ts
@@ -0,0 +1,17 @@
+import type {DisplayConfig} from '../DisplayConfig.js';
+
+export const makeDefault = (): DisplayConfig => ({
+    colorize: true,
+    columnPadding: 2,
+    corner: '┼',
+    cornerLeft: '├',
+    cornerRight: '┤',
+    cornerTop: '┬',
+    cornerTopLeft: '┌',
+    cornerTopRight: '┐',
+    cornerBottomLeft: '└',
+    cornerBottomRight: '┘',
+    cornerBottom: '┴',
+    horizontal: '─',
+    vertical: '│',
+});
diff --git a/workspace/core/src/internal/Test.ts b/workspace/core/src/internal/Test.ts
new file mode 100644
index 0000000..6ae64be
--- /dev/null
+++ b/workspace/core/src/internal/Test.ts
@@ -0,0 +1,221 @@
+import {createHash} from 'node:crypto';
+import {isDeepStrictEqual} from 'node:util';
+
+import * as P from '../prelude.js';
+import type {Classify, Label, Stats} from '../Classify.js';
+import {
+    LabelSchema,
+    StatsSchema,
+    defaultIsNil,
+    emptyStats,
+    makeClassify,
+    precision,
+    recall,
+} from './Classify.js';
+import type {
+    Diff,
+    Program,
+    TestCase,
+    TestSuite,
+    ID,
+    TestResult as _TestResult,
+    TestRun as _TestRun,
+} from '../Test.js';
+
+export const makeID = <I>(input: I): ID => {
+    return createHash('sha256').update(JSON.stringify(input)).digest('hex');
+};
+
+export class TestResult<
+    I = unknown,
+    O = unknown,
+    T = unknown,
+> extends P.Data.TaggedClass('TestResult')<_TestResult<I, O, T>> {
+    constructor(args: Omit<_TestResult<I, O, T>, 'id'>) {
+        const id = makeID(args.input);
+        super({...args, id});
+    }
+}
+
+export const TestResultSchema: P.Schema.Schema<_TestResult> = P.Schema.Struct({
+    id: P.Schema.String,
+    input: P.Schema.Unknown,
+    result: P.Schema.Unknown,
+    expected: P.Schema.Unknown,
+    label: LabelSchema,
+    tags: P.Schema.Array(P.Schema.String),
+});
+
+export class TestRun<
+    I = unknown,
+    O = unknown,
+    T = unknown,
+> extends P.Data.TaggedClass('TestRun')<_TestRun<I, O, T>> {
+    static empty<I, O, T>(): _TestRun<I, O, T> {
+        return new TestRun({
+            testResultsById: {},
+            testResultIds: [],
+            stats: emptyStats(),
+        });
+    }
+}
+
+export const TestRunSchema: P.Schema.Schema<_TestRun> = P.Schema.Struct({
+    testResultsById: P.Schema.Record(P.Schema.String, TestResultSchema),
+    testResultIds: P.Schema.mutable(P.Schema.Array(P.Schema.String)),
+    stats: StatsSchema,
+});
+
+export const diff = <I, O, T>({
+    testRun: {stats},
+    previousTestRun,
+}: {
+    testRun: _TestRun<I, O, T>;
+    previousTestRun: P.O.Option<_TestRun<I, O, T>>;
+}): Diff =>
+    previousTestRun.pipe(
+        P.O.match({
+            onNone: () => stats,
+            onSome: ({stats: previousStats}) => ({
+                TP: stats.TP - previousStats.TP,
+                TN: stats.TN - previousStats.TN,
+                FP: stats.FP - previousStats.FP,
+                FN: stats.FN - previousStats.FN,
+                precision: stats.precision - previousStats.precision,
+                recall: stats.recall - previousStats.recall,
+            }),
+        }),
+    );
+
+export const test = <I, O, T>({
+    testCase: {input, expected, tags},
+    program,
+    classify,
+}: {
+    testCase: TestCase<I, T>;
+    program: Program<I, O>;
+    classify: Classify<O, T>;
+}): P.E.Effect<TestResult<I, O, T>> => {
+    return program(input).pipe(
+        P.E.map(
+            result =>
+                new TestResult<I, O, T>({
+                    input,
+                    result,
+                    expected,
+                    tags: tags ?? [],
+                    label: classify(result, expected),
+                }),
+        ),
+    );
+};
+
+export const testAll = <I, O, T>({
+    testCases,
+    program,
+    classify = makeClassify(isDeepStrictEqual, defaultIsNil, defaultIsNil),
+}: TestSuite<I, O, T>): P.Stream.Stream<_TestResult<I, O, T>> =>
+    P.pipe(
+        P.Stream.fromIterable(testCases),
+        P.Stream.mapEffect(testCase => test({testCase, program, classify})),
+    );
+
+export const runFoldEffect = <I, O, T>(
+    testResults$: P.Stream.Stream<_TestResult<I, O, T>>,
+): P.E.Effect<_TestRun<I, O, T>> =>
+    testResults$.pipe(
+        P.Stream.runFoldEffect(TestRun.empty<I, O, T>(), (run, result) =>
+            P.E.gen(function* () {
+                const {id} = result;
+
+                if (run.testResultsById[id] !== undefined) {
+                    yield* P.Console.warn(
+                        `Skipped duplicate test case. id=${id}`,
+                    );
+                    return run;
+                } else {
+                    run.testResultsById[id] = result;
+                    run.testResultIds.push(id);
+                    run.stats[result.label]++;
+                }
+
+                return run;
+            }),
+        ),
+        P.E.map(run => {
+            run.stats.precision = precision(run.stats);
+            run.stats.recall = recall(run.stats);
+            return run;
+        }),
+    );
+
+/**
+ * Convenience function to run all tests and return the results.
+ */
+export const runAll = <I, O, T>({
+    testCases,
+    program,
+    classify = makeClassify(isDeepStrictEqual, defaultIsNil, defaultIsNil),
+}: TestSuite<I, O, T>) =>
+    testAll({testCases, program, classify}).pipe(runFoldEffect, P.E.runPromise);
+
+export type TestResultPredicate<I, O, T> = (args: {
+    testResult: _TestResult<I, O, T>;
+    previousTestResult: P.O.Option<_TestResult<I, O, T>>;
+}) => boolean;
+
+/** Filters results. Note, tests still run, but results are filtered out. */
+export const filterTestRun: {
+    <I, O, T>(
+        predicates: TestResultPredicate<I, O, T>[],
+    ): (args: {
+        testRun: _TestRun<I, O, T>;
+        previousTestRun: P.O.Option<_TestRun<I, O, T>>;
+    }) => _TestRun<I, O, T>;
+    <I, O, T>(
+        args: {
+            testRun: _TestRun<I, O, T>;
+            previousTestRun: P.O.Option<_TestRun<I, O, T>>;
+        },
+        predicates: TestResultPredicate<I, O, T>[],
+    ): _TestRun<I, O, T>;
+} = P.dual(
+    2,
+    <I, O, T>(
+        {
+            testRun,
+            previousTestRun,
+        }: {
+            testRun: _TestRun<I, O, T>;
+            previousTestRun: P.O.Option<_TestRun<I, O, T>>;
+        },
+        predicates: TestResultPredicate<I, O, T>[],
+    ) =>
+        P.pipe(
+            testRun.testResultIds.reduce((m, id) => {
+                const testResult = testRun.testResultsById[id];
+                const previousTestResult = previousTestRun.pipe(
+                    P.O.map(a => a.testResultsById[id]),
+                );
+                const isMatch = predicates.every(p =>
+                    p({testResult, previousTestResult}),
+                );
+
+                if (isMatch) {
+                    if (m.testResultsById[id] === undefined) {
+                        m.testResultsById[id] = {} as TestResult<I, O, T>;
+                    }
+                    m.testResultsById[id] = testResult;
+                    m.testResultIds.push(id);
+                    m.stats[testResult.label]++;
+                }
+
+                return m;
+            }, TestRun.empty<I, O, T>()),
+            run => {
+                run.stats.precision = precision(run.stats);
+                run.stats.recall = recall(run.stats);
+                return run;
+            },
+        ),
+);
diff --git a/workspace/core/src/Show/common.ts b/workspace/core/src/internal/common.ts
similarity index 98%
rename from workspace/core/src/Show/common.ts
rename to workspace/core/src/internal/common.ts
index 0e51458..8f0de7e 100644
--- a/workspace/core/src/Show/common.ts
+++ b/workspace/core/src/internal/common.ts
@@ -1,7 +1,7 @@
 import colors from 'ansi-colors';
 import {sum} from 'effect/Number';
 
-import type {DisplayConfig} from './DisplayConfig.js';
+import type {DisplayConfig} from '../DisplayConfig.js';
 
 export const showBorder = (
     cfg: DisplayConfig,
diff --git a/workspace/core/src/Show/diff.ts b/workspace/core/src/internal/diff.ts
similarity index 63%
rename from workspace/core/src/Show/diff.ts
rename to workspace/core/src/internal/diff.ts
index 9b812ba..c41ed63 100644
--- a/workspace/core/src/Show/diff.ts
+++ b/workspace/core/src/internal/diff.ts
@@ -1,10 +1,6 @@
 import colors from 'ansi-colors';
-import * as jdp from 'jsondiffpatch';
 
-import type * as P from '../prelude.js';
-import type * as Test from '../Test.js';
-import {DisplayConfig} from './DisplayConfig.js';
-import type {Stats} from '../Classify.js';
+import type {DisplayConfig} from '../DisplayConfig.js';
 import {
     colorNegative,
     colorPositive,
@@ -13,66 +9,65 @@ import {
     showRow,
     showTitle,
 } from './common.js';
+import {makeDefault} from './DisplayConfig.js';
+import type {Diff} from '../Test.js';
+import type {DiffColumn, DiffColumnNames, DiffContext} from '../Show.js';
 
-type Context = {
-    diff: Test.Diff;
-};
-
-type ColumnNames = 'TP' | 'TN' | 'FP' | 'FN' | 'precision' | 'recall';
-
-type Column = {
-    name: ColumnNames;
-    label: string;
-    make: (ctx: Context) => string[];
-};
-
-const columns: Column[] = [
+const columns: DiffColumn[] = [
     {
         name: 'TP',
         label: 'TP',
-        make: ({diff}: Context) => [colorPositive(diff.TP)(diff.TP.toString())],
+        make: ({diff}: DiffContext) => [
+            colorPositive(diff.TP)(diff.TP.toString()),
+        ],
     },
     {
         name: 'TN',
         label: 'TN',
-        make: ({diff}: Context) => [colorPositive(diff.TN)(diff.TN.toString())],
+        make: ({diff}: DiffContext) => [
+            colorPositive(diff.TN)(diff.TN.toString()),
+        ],
     },
     {
         name: 'FP',
         label: 'FP',
-        make: ({diff}: Context) => [colorNegative(diff.FP)(diff.FP.toString())],
+        make: ({diff}: DiffContext) => [
+            colorNegative(diff.FP)(diff.FP.toString()),
+        ],
     },
     {
         name: 'FN',
         label: 'FN',
-        make: ({diff}: Context) => [colorNegative(diff.FN)(diff.FN.toString())],
+        make: ({diff}: DiffContext) => [
+            colorNegative(diff.FN)(diff.FN.toString()),
+        ],
     },
     {
         name: 'precision',
         label: 'precision',
-        make: ({diff}: Context) => [
+        make: ({diff}: DiffContext) => [
             colorPositive(diff.precision)(diff.precision.toFixed(2)),
         ],
     },
     {
         name: 'recall',
         label: 'recall',
-        make: ({diff}: Context) => [
+        make: ({diff}: DiffContext) => [
             colorPositive(diff.recall)(diff.recall.toFixed(2)),
         ],
     },
 ];
 
-export const diff = <I, O, T>({
+export const diff = ({
     diff,
     displayConfig,
     selectColumns = ['TP', 'TN', 'FP', 'FN', 'precision', 'recall'],
 }: {
-    diff: Test.Diff;
+    diff: Diff;
     displayConfig?: Partial<DisplayConfig>;
-    selectColumns?: ColumnNames[];
+    selectColumns?: DiffColumnNames[];
 }): string => {
-    const cfg = {...DisplayConfig.default(), ...displayConfig};
+    const cfg = {...makeDefault(), ...displayConfig};
     const _columns = columns.filter(c => selectColumns.includes(c.name));
 
     const display = {
diff --git a/workspace/core/src/Show/format-diff.ts b/workspace/core/src/internal/format-diff.ts
similarity index 100%
rename from workspace/core/src/Show/format-diff.ts
rename to workspace/core/src/internal/format-diff.ts
diff --git a/workspace/core/src/Show/stats.ts b/workspace/core/src/internal/stats.ts
similarity index 67%
rename from workspace/core/src/Show/stats.ts
rename to workspace/core/src/internal/stats.ts
index bc869b2..42ffd50 100644
--- a/workspace/core/src/Show/stats.ts
+++ b/workspace/core/src/internal/stats.ts
@@ -1,10 +1,6 @@
 import colors from 'ansi-colors';
-import * as jdp from 'jsondiffpatch';
 
-import type * as P from '../prelude.js';
-import type * as Test from '../Test.js';
-import {DisplayConfig} from './DisplayConfig.js';
-import type {Stats} from '../Classify.js';
+import type {DisplayConfig} from '../DisplayConfig.js';
 import {
     colorNegative,
     colorPositive,
@@ -13,57 +9,48 @@ import {
     showRow,
     showTitle,
 } from './common.js';
+import type {TestRun} from './Test.js';
+import {makeDefault} from './DisplayConfig.js';
+import type {StatsColumn, StatsColumnNames, StatsContext} from '../Show.js';
 
-type Context = {
-    stats: Stats;
-};
-
-type ColumnNames = 'TP' | 'TN' | 'FP' | 'FN' | 'precision' | 'recall';
-
-type Column = {
-    name: ColumnNames;
-    label: string;
-    make: (ctx: Context) => string[];
-};
-
-const columns: Column[] = [
+const columns: StatsColumn[] = [
     {
         name: 'TP',
         label: 'TP',
-        make: ({stats}: Context) => [
+        make: ({stats}: StatsContext) => [
             colorPositive(stats.TP)(stats.TP.toString()),
         ],
     },
     {
         name: 'TN',
         label: 'TN',
-        make: ({stats}: Context) => [
+        make: ({stats}: StatsContext) => [
             colorPositive(stats.TN)(stats.TN.toString()),
         ],
     },
     {
         name: 'FP',
         label: 'FP',
-        make: ({stats}: Context) => [
+        make: ({stats}: StatsContext) => [
             colorNegative(stats.FP)(stats.FP.toString()),
         ],
     },
     {
         name: 'FN',
         label: 'FN',
-        make: ({stats}: Context) => [
+        make: ({stats}: StatsContext) => [
             colorNegative(stats.FN)(stats.FN.toString()),
         ],
     },
     {
         name: 'precision',
         label: 'precision',
-        make: ({stats}: Context) => [stats.precision.toFixed(2)],
+        make: ({stats}: StatsContext) => [stats.precision.toFixed(2)],
     },
     {
         name: 'recall',
         label: 'recall',
-        make: ({stats}: Context) => [stats.recall.toFixed(2)],
+        make: ({stats}: StatsContext) => [stats.recall.toFixed(2)],
     },
 ];
 
@@ -72,11 +59,11 @@ export const stats = <I, O, T>({
     displayConfig,
     selectColumns = ['TP', 'TN', 'FP', 'FN', 'precision', 'recall'],
 }: {
-    testRun: Pick<Test._TestRun<I, O, T>, 'stats'>;
+    testRun: Pick<TestRun<I, O, T>, 'stats'>;
     displayConfig?: Partial<DisplayConfig>;
-    selectColumns?: ColumnNames[];
+    selectColumns?: StatsColumnNames[];
 }): string => {
-    const cfg = {...DisplayConfig.default(), ...displayConfig};
+    const cfg = {...makeDefault(), ...displayConfig};
 
     const _columns = columns.filter(c => selectColumns.includes(c.name));
 
diff --git a/workspace/core/src/Show/summarize.ts b/workspace/core/src/internal/summarize.ts
similarity index 78%
rename from workspace/core/src/Show/summarize.ts
rename to workspace/core/src/internal/summarize.ts
index 4ba70f8..228f50b 100644
--- a/workspace/core/src/Show/summarize.ts
+++ b/workspace/core/src/internal/summarize.ts
@@ -2,51 +2,32 @@ import colors from 'ansi-colors';
 import * as jdp from 'jsondiffpatch';
 
 import * as P from '../prelude.js';
-import type * as Test from '../Test.js';
 import {formatDiff} from './format-diff.js';
-import {DisplayConfig} from './DisplayConfig.js';
+import type {DisplayConfig} from '../DisplayConfig.js';
 import {showBorder, showHeader, showRow, showTitle} from './common.js';
-
-type Context = {
-    i: number;
-    ids: string[];
-    testRun: Test._TestRun;
-    previousTestRun: P.O.Option<Test._TestRun>;
-};
-
-type ColumnNames =
-    | 'index'
-    | 'hash'
-    | 'input'
-    | 'tags'
-    | 'label'
-    | 'expected'
-    | 'result'
-    | 'result_diff'
-    | 'prev_result'
-    | 'prev_result_diff';
-
-type Column = {
-    name: ColumnNames;
-    label: string;
-    make: (ctx: Context) => string[];
-};
-
-const columns: Column[] = [
+import type {_TestRun} from './Test.js';
+import {makeDefault} from './DisplayConfig.js';
+import type {
+    SummarizeColumn,
+    SummarizeColumnNames,
+    SummarizeContext,
+} from '../Show.js';
+
+const columns: SummarizeColumn[] = [
     {
         name: 'index',
         label: '#',
-        make: ({i, ids}: Context) => [`${i + 1}/${ids.length}`],
+        make: ({i, ids}: SummarizeContext) => [`${i + 1}/${ids.length}`],
     },
     {
         name: 'hash',
         label: 'hash',
-        make: ({i, ids}: Context) => [ids[i].slice(0, 8)],
+        make: ({i, ids}: SummarizeContext) => [ids[i].slice(0, 8)],
     },
     {
         name: 'input',
         label: 'input',
-        make: ({i, ids, testRun}: Context) =>
+        make: ({i, ids, testRun}: SummarizeContext) =>
             JSON.stringify(
                 testRun.testResultsById[ids[i]].input,
                 null,
@@ -56,13 +37,13 @@ const columns: Column[] = [
     {
         name: 'tags',
         label: 'tags',
-        make: ({i, ids, testRun}: Context) =>
+        make: ({i, ids, testRun}: SummarizeContext) =>
             testRun.testResultsById[ids[i]].tags as string[],
     },
     {
         name: 'label',
         label: 'lbl',
-        make: ({i, ids, testRun, previousTestRun}: Context) => {
+        make: ({i, ids, testRun, previousTestRun}: SummarizeContext) => {
             const hasPrevious = previousTestRun.pipe(
                 P.O.map(_ => _.testResultsById[ids[i]].result),
                 P.O.isSome,
@@ -83,7 +64,7 @@ const columns: Column[] = [
     {
         name: 'expected',
         label: 'expected',
-        make: ({i, ids, testRun}: Context) =>
+        make: ({i, ids, testRun}: SummarizeContext) =>
             JSON.stringify(
                 testRun.testResultsById[ids[i]].expected,
                 null,
@@ -93,7 +74,7 @@ const columns: Column[] = [
     {
         name: 'result',
         label: 'result',
-        make: ({i, ids, testRun}: Context) =>
+        make: ({i, ids, testRun}: SummarizeContext) =>
             JSON.stringify(
                 testRun.testResultsById[ids[i]].result,
                 null,
@@ -103,7 +84,7 @@ const columns: Column[] = [
     {
         name: 'result_diff',
         label: 'diff result',
-        make: ({i, ids, testRun}: Context) =>
+        make: ({i, ids, testRun}: SummarizeContext) =>
             formatDiff(
                 jdp.diff(
                     testRun.testResultsById[ids[i]].expected,
@@ -114,7 +95,7 @@ const columns: Column[] = [
     {
         name: 'prev_result',
         label: 'previous result',
-        make: ({i, ids, testRun, previousTestRun}: Context) =>
+        make: ({i, ids, testRun, previousTestRun}: SummarizeContext) =>
             previousTestRun.pipe(
                 P.O.map(_ =>
                     JSON.stringify(
@@ -129,7 +110,7 @@ const columns: Column[] = [
     {
         name: 'prev_result_diff',
         label: 'diff previous result',
-        make: ({i, ids, testRun, previousTestRun}: Context) =>
+        make: ({i, ids, testRun, previousTestRun}: SummarizeContext) =>
             previousTestRun.pipe(
                 P.O.map(
                     _ =>
@@ -160,12 +141,12 @@ export const summarize = <I, O, T>({
         'prev_result_diff',
     ],
 }: {
-    testRun: Test._TestRun<I, O, T>;
-    previousTestRun?: P.O.Option<Test._TestRun<I, O, T>>;
+    testRun: _TestRun<I, O, T>;
+    previousTestRun?: P.O.Option<_TestRun<I, O, T>>;
     displayConfig?: Partial<DisplayConfig> | undefined;
-    selectColumns?: ColumnNames[];
+    selectColumns?: SummarizeColumnNames[];
 }) => {
-    const cfg = {...DisplayConfig.default(), ...displayConfig};
+    const cfg = {...makeDefault(), ...displayConfig};
 
     const ids = testRun.testResultIds;
 
diff --git a/workspace/examples/src/as-library/async.ts b/workspace/examples/src/as-library/async.ts
index 5eca3ae..902d569 100644
--- a/workspace/examples/src/as-library/async.ts
+++ b/workspace/examples/src/as-library/async.ts
@@ -9,7 +9,7 @@ const program = (input: Input) =>
         Effect.delay(Duration.millis(500)),
     );
 
-const testCases: PT.TestCase<Input, Result>[] = [
+const testCases: PT.Test.TestCase<Input, Result>[] = [
     {input: 0, expected: 0},
     {input: 1, expected: 1},
     {input: 2, expected: 2},
@@ -19,7 +19,7 @@ const testCases: PT.TestCase<Input, Result>[] = [
 
 console.time('async');
 
-await PT.testAll({
+await PT.Test.all({
     testCases,
     program,
 }).pipe(
@@ -27,8 +27,8 @@ await PT.testAll({
         console.timeLog('async', 'got a result');
         return Effect.void;
     }),
-    PT.runFoldEffect,
-    Effect.tap(testRun => Console.log(PT.Show.summary({testRun}))),
+    PT.Test.runFoldEffect,
+    Effect.tap(testRun => Console.log(PT.Show.summarize({testRun}))),
     Effect.runPromise,
 );
 
diff --git a/workspace/examples/src/as-library/complex.ts b/workspace/examples/src/as-library/complex.ts
deleted file mode 100644
index 4ba2f17..0000000
--- a/workspace/examples/src/as-library/complex.ts
+++ /dev/null
@@ -1,88 +0,0 @@
-import {isDeepStrictEqual} from 'node:util';
-
-import * as PT from '@creative-introvert/prediction-testing';
-import {Console, Effect, Option, Stream, pipe} from 'effect';
-import * as diff from 'deep-object-diff';
-
-type Input = number;
-type Result = {foo: number};
-
-// Function under test.
-const program = (foo: Input) => Effect.succeed({foo: foo * 1.1});
-
-const testCases: PT.TestCase<Input, Result>[] = [
-    {input: 0, expected: {foo: 0}},
-    {input: 1, expected: {foo: 1}},
-    {input: 2, expected: {foo: 2}},
-    {input: 3, expected: {foo: 3}},
-    {input: 4, expected: {foo: 4}},
-];
-
-// An (optional) custom classifier. By default, it uses deep equality.
-const classify = PT.Classify.make<Result, Result>(
-    (output, expected) => Math.abs(expected.foo - output.foo) <= 0.2,
-);
-
-// Simulate a previous run with different results.
-const previousTestRun = PT.testAll({
-    testCases,
-    program: (foo: Input) => Effect.succeed({foo}),
-    classify,
-}).pipe(PT.runFoldEffect, Effect.runSync);
-
-void pipe(
-    PT.testAll({testCases, program, classify}),
-    // Tests are a stream, so you can hook into that.
-    Stream.tap(testResult => {
-        console.log(PT.Show.single({testResult}));
-        return Effect.void;
-    }),
-    // Collect test results.
-    PT.runFoldEffect,
-    // Show summary.
-    Effect.tap(testRun =>
-        Console.log(
-            PT.Show.summary({
-                testRun,
-                // With custom renderers. Default = JSON.stringify.
-                showInput: input => `input=${input}`,
-                showExpected: expected => `${expected.foo.toFixed(2)} +/- 0.2`,
-                // showResult gets the result and the expected value.
-                showResult: (result, expected) => {
-                    if (isDeepStrictEqual(result, expected)) {
-                        return JSON.stringify(result);
-                    }
-                    return JSON.stringify(
-                        Object.entries(
-                            diff.detailedDiff(expected, result),
-                        ).reduce(
-                            (m, [k, v]) => {
-                                if (Object.keys(v).length !== 0) {
-                                    m[k] = v;
-                                }
-                                return m;
-                            },
-                            {} as Record<string, unknown>,
-                        ),
-                    );
-                },
-                previousTestRun: Option.some(previousTestRun),
-            }),
-        ),
-    ),
-    // Show stats.
-    Effect.tap(testRun => Console.log(PT.Show.stats({testRun}))),
-    // Show diff to previous run.
-    Effect.tap(testRun =>
-        Console.log(
-            PT.Show.diff({
-                testRun,
-                diff: PT.diff({
-                    testRun,
-                    previousTestRun: Option.some(previousTestRun),
-                }),
-            }),
-        ),
-    ),
-    Effect.runSync,
-);
diff --git a/workspace/examples/src/as-library/simple.ts b/workspace/examples/src/as-library/simple.ts
index ccdf141..7093f5a 100644
--- a/workspace/examples/src/as-library/simple.ts
+++ b/workspace/examples/src/as-library/simple.ts
@@ -1,7 +1,7 @@
 import * as PT from '@creative-introvert/prediction-testing';
 import {Effect, Option} from 'effect';
 
-type TestCase = PT.TestCase<
+type TestCase = PT.Test.TestCase<
     {BRAND: string; MODEL?: number; MACHINE_TYPE?: string},
     {BRAND: string; MODEL?: number}
 >;
@@ -26,12 +26,12 @@ const testCases: TestCase[] = [
     },
 ];
 
-const testRun1 = await PT.runAll({
+const testRun1 = await PT.Test.runAll({
     testCases,
     program: input => Effect.sync(() => input),
 });
 
-const testRun2 = await PT.runAll({
+const testRun2 = await PT.Test.runAll({
     testCases,
     program: input =>
         Effect.sync(() => ({...input, MODEL: input?.MODEL ?? 0 + 100})),
@@ -46,7 +46,7 @@ console.log(
 
 console.log(PT.Show.stats({testRun: testRun1}));
 
-const diff = PT.diff({
+const diff = PT.Test.diff({
     testRun: testRun1,
     previousTestRun: Option.some(testRun2),
 });