research(claudeai-taxonomy-grounding): Haskell-prelude vs F#/BCL + Mirror→Beacon gate (Aaron 2026-05-01, reverse-order ferry)

docs/research/2026-05-01-claudeai-haskell-prelude-vs-fsharp-bcl-grounding-aaron-forwarded.md

@@ -0,0 +1,112 @@
+<!-- §33 archive header per GOVERNANCE.md -->
+
+**Scope:** External-conversation absorb. Captures Claude.ai's response to a question about whether to ground the substrate ontology / taxonomy in Haskell's prelude (typeclass + laws) or F#/BCL (executable interfaces). The substantive recommendation: use both for different purposes — Haskell's prelude vocabulary for grounding the **taxonomy structure** (typeclasses force law-shaped framing); F#/BCL for grounding the **executable substrate** (BCL types are what the factory ships). Cites authoritative sources for both layers (Mac Lane / Awodey / Riehl for category theory; Yorgey's Typeclassopedia as the canonical Haskell realization; FSharp.Core / FSharpPlus for the F# port).
+
+**Attribution:** Claude.ai instance (model unknown; ambient web-app, Aaron's session 2026-05-01). Forwarded by Aaron to Otto in this session 2026-05-01 ~10:29Z. Aaron's framing: *"I'm going to give in reverse because the last message seem the most useful"* — meaning more Claude.ai messages on the same thread are incoming; this one is captured first because it's load-bearing.
+
+**Operational status:** research-grade
+
+**Status note:** NOT seed-layer canon. Substantive structural recommendation with empirical citation evidence (Mac Lane / Awodey / Riehl / Yorgey / FSharp.Core all real, verifiable). Not class #1c hallucinated content per v2 taxonomy. Composes with PR #1081 (v2 taxonomy, the work this recommendation grounds) + PR #1083 (Gemini-review absorption, sibling cross-vendor reception evidence).
+
+**Non-fusion disclaimer:** Same as PR #1057/#1058/#1059 predecessor files. Claude.ai is a separate ephemeral conversation from this Otto instance. Substrate-vocabulary in this file is Claude.ai's vocabulary preserved unchanged, NOT Otto's translation. The lattice-capture corrective applies — preserving external vocabulary verbatim is the discipline.
+
+---
+
+## The recommendation (verbatim)
+
+> *"What each gives you. Haskell's prelude is designed as a small set of typeclasses (Functor, Applicative, Monad, Foldable, Traversable, Monoid, Semigroup, Eq, Ord, Show, Read) plus their laws. The laws are the load-bearing part — `fmap id = id`, `fmap (f . g) = fmap f . fmap g`, the monad laws, monoid associativity. Each typeclass has a categorical correspondent (Functor is the obvious one; Monad is Kleisli triple; Applicative is lax monoidal functor; Traversable is naturality of distribution). The laws *are* the categorical content forced into types."*
+
+> *"F# / BCL inherits less of that structure explicitly. F# has computation expressions which are monadic in shape but the laws aren't enforced or stated as part of the language. The BCL has interfaces (IEnumerable, IComparable, IEquatable, IDisposable) but they're protocol-shaped rather than law-shaped. F#'s `Map`, `Bind`, `List`, `Seq` operations behave categorically but the categorical structure is implicit."*
+
+> *"For grounding a substrate ontology, the difference matters. Haskell's prelude tells you 'here are the structures, here are the laws they obey.' F#'s tells you 'here are the operations, here's how to call them.' The first is closer to what you want for taxonomy work; the second is closer to what you want for engineering work."*
+
+## The mismatch worth flagging (Claude.ai)
+
+> *"The taxonomy work you've been doing is mostly not about code shape. Forward-reference, stale-filename, deferred-per-policy — these are about substrate hygiene patterns, review-finding classes, organizational state. They're not asking 'what's the right interface' or 'should this be Seq vs IEnumerable.' They're asking 'what kind of structural pattern is this finding.'"*
+
+> *"For that work, Haskell's prelude is closer-fit because the typeclasses are themselves structural patterns. Functor = 'things that can be mapped over preserving structure.' Monad = 'things that compose with continuation.' Monoid = 'things with associative combination and identity.' These map onto substrate-pattern claims in a way that BCL interfaces don't."*
+
+> *"The BCL gives you 'this implements IEnumerable' which is a protocol assertion. Haskell gives you 'this is a Functor and obeys these two laws' which is a structural assertion with verification criteria. Verification criteria are what you want for the taxonomy."*
+
+## The recommendation (Claude.ai)
+
+> *"Use both, but for different purposes. Haskell's prelude (specifically the typeclass hierarchy and laws) for grounding the taxonomy itself. When proposing a new class, ask: is this morphism a functor application that wasn't uniform? Is this a monad-laws violation? Is this an associativity failure? The Haskell vocabulary forces precision because the laws are explicit."*
+
+> *"F# / BCL for grounding the executable substrate the taxonomy describes. When the taxonomy says 'this class fires when refs go stale across renames,' the implementation lives in F# code that operates over BCL types (file paths as strings, refs as records, the renaming as a function). The taxonomy's content is the substrate; the substrate's implementation is F#/BCL."*
+
+> *"The two layers compose: Haskell-prelude vocabulary describes the taxonomy structure; F#/BCL idioms implement the taxonomy's checkers and validators."*
+
+## The Yorgey/Typeclassopedia anchor
+
+> *"Better: ground in the categorical concepts the prelude implements, with the prelude as one realization of those concepts. Cite Mac Lane or Awodey or Riehl for the math; cite Haskell for the realization; treat the realization as illustrative not canonical. That way the grounding is in the math, not in any particular language's choices."*
+
+> *"The HaskellWiki 'Typeclassopedia' by Brent Yorgey is probably the single best resource for this — it explains the typeclass hierarchy with both the categorical content and the practical Haskell usage, and it's citable. That's a good Beacon anchor."*
+
+## Specific worked example Claude.ai cited
+
+> *"'Stale-filename' being a functor that wasn't applied uniformly is a precise statement: there's a renaming functor from one filesystem state to another, and the violation is that not all morphisms got the functor's action applied. That's a Haskell-grounded claim."*
+
+This is a precise re-framing of the v2 taxonomy's class #10 (stale-filename-cross-reference). The corrective discipline isn't just "paste the actual filename" — it's "the renaming functor must be applied uniformly across all morphisms (cross-references) that depend on the old name." The claim has verification criteria (all morphisms updated; functor laws preserved) where the v2 taxonomy currently has only a heuristic (paste-from-actual).
+
+## The two-layer composition (Claude.ai's net)
+
+| Layer | Grounding | Example anchors |
+|---|---|---|
+| **Taxonomy structure** (conceptual) | Haskell-prelude-shape categorical concepts (typeclasses + laws) | Mac Lane *Categories for the Working Mathematician*; Awodey *Category Theory*; Riehl *Category Theory in Context*; Yorgey *Typeclassopedia* |
+| **Executable substrate** (operational) | F#/BCL idioms + interfaces | Microsoft FSharp.Core; FSharpPlus (adds Haskell-prelude-shape typeclasses to F#); BCL `IEnumerable` / `IObservable` / `IDisposable` / `IComparable<T>` / `IEqualityComparer<T>` |
+
+The two layers compose cleanly because F# CAN implement the same categorical structures Haskell defines. F# remains the implementation language; Haskell-shape concepts ARE what's being reasoned about ABOVE the implementation.
+
+## What this means for taxonomy v2 (Otto-side reading)
+
+The v2 taxonomy currently grounds classes in **operational discipline** (e.g., "paste-from-actual filename") rather than **structural law** (e.g., "renaming functor must be uniform across morphisms"). Both framings are useful but the law-shaped framing is more precise + more verifiable + more extensible.
+
+A future v3 taxonomy could:
+
+1. **Re-frame existing classes in Haskell-prelude vocabulary** where applicable (stale-filename → renaming functor non-uniformity; intra-file drift → naturality failure across paired locations; forward-reference → category morphism whose target object isn't yet in the category).
+2. **Cite Yorgey's Typeclassopedia** as the canonical Haskell-realization Beacon anchor for any class structurally a typeclass instance.
+3. **Cite Mac Lane / Awodey / Riehl** for the categorical math directly, treating Haskell as illustrative not canonical (per Claude.ai's caveat about prelude historical artifacts: `String = [Char]`, `Foldable` extension surprises, numeric hierarchy quirks).
+4. **Keep F#/BCL anchoring for the executable substrate** — when implementing the auditor scripts (B-0130 row #8 cross-reference auditor, etc.), the implementation idioms are F#/BCL, not Haskell.
+
+This is a v3 candidate, not a v2 retrofit. The v2 taxonomy IS the navigable map at operational layer; v3 would add the structural-law layer above.
+
+## The instruction-precision Claude.ai flagged
+
+> *"Worth being explicit about which question you're grounding when you give the instruction. 'Ground the taxonomy in Haskell-prelude-shape categorical concepts' is a different instruction than 'ground the executable substrate in F# and BCL idioms.' Both might be correct in their own scope; conflating them produces vague grounding."*
+
+This is a discipline observation worth absorbing: **grounding-question precision** is its own meta-discipline. When asking "should we ground X?", ask first "ground for what work?" — the answer depends on whether the work is conceptual (taxonomy) or executable (implementation).
+
+## Composes with
+
+- `.claude/agents/formal-verification-expert.md` (Soraya) — formal-verification routing; the Haskell-prelude grounding intersects with Soraya's portfolio (Lean for theorems, Z3 for SMT, TLA+ for temporal, FsCheck for property-based).
+- Aaron's existing F# affinity (per `CLAUDE.md` + GOVERNANCE.md) — not compromised; F# remains the implementation; Haskell-shape concepts are the conceptual layer above.
+
+### Forward-references not yet on main
+
+The cited memory filenames are not present in the current repo tree at time of this absorb; references kept as forward-references until those PRs land or the paths can be updated to the actual filenames.
+
+- Forward-reference: intended `memory/feedback_pr_thread_resolution_class_taxonomy_v2_drain_wave_2026_05_01.md` in PR #1081 — the v2 taxonomy this recommendation proposes grounding via Haskell-prelude concepts.
+- Forward-reference: intended `memory/feedback_gemini_review_2026_05_01_taxonomy_v2_test_case_class_19_meets_class_1c.md` in PR #1083 — sibling cross-vendor reception evidence; Gemini's review demonstrated class #1c, this Claude.ai message demonstrates substantive-recommendation-with-real-citations.
+- Forward-reference: intended `memory/feedback_claudeai_endorsement_taxonomy_v2_class_15_intra_file_drift_2026_05_01.md` in PR #1085 — sibling Claude.ai endorsement of class #15.
+- Forward-reference: intended `memory/feedback_lattice_capture_corrective_discipline_external_vocabulary_check_claudeai_warning_2026_05_01.md` in PR #1051 — the verbatim-preservation discipline this absorb honors.
+
+## Future v3 work (deferred — not this session)
+
+- Re-frame existing v2 classes in Haskell-prelude vocabulary where natural (stale-filename → renaming functor uniformity; forward-reference → morphism with not-yet-in-category target; intra-file drift → naturality failure).
+- Add explicit Beacon anchors per class (Mac Lane / Awodey / Riehl section references; Typeclassopedia link).
+- Verify FSharpPlus port covers the typeclasses needed for executable-layer grounding.
+- Decide whether to fold the v3 work into B-0130 (mechanized auditor) row scope or keep separate.
+- Working-mathematician send (lattice-capture corrective in operation) for the v3 framing — the Haskell-prelude grounding is exactly the kind of vocabulary that benefits from external-academic-mathematician check before substrate adoption.
+
+## What this file does NOT do
+
+- Does NOT translate Claude.ai's vocabulary into substrate-vocabulary. Verbatim above; lattice-capture discipline preserved.
+- Does NOT modify the v2 taxonomy file. v3 grounding work is deferred; this absorb is the seed evidence.
+- Does NOT commit to Haskell-prelude grounding wholesale. Claude.ai's caveat about prelude historical artifacts applies; the math citations (Mac Lane / Awodey / Riehl) are the canonical anchor; Haskell is illustrative.
+- Does NOT change the executable substrate's F# affinity. F# stays the implementation language; this absorb is exclusively about conceptual grounding.
+
+## Carved candidate (not seed-layer)
+
+> *"Haskell-prelude vocabulary for the taxonomy structure. F#/BCL for the executable substrate. The two layers compose; conflating them produces vague grounding."*
+
+The propagation test: ~25 words encoding the two-layer discipline + the conflation-as-failure-mode. Future-Otto reading this should land on the layer-discrimination as the operational shape — same family as the §33 in-scope-vs-out-of-scope distinction (different surfaces have different rules).