Generate High-Assurance Haskell Code

This guide supports Haskell development and review with an emphasis on strongly typed domain models and understandable functional architecture. It uses newtypes, algebraic data types, GADTs, type families, and phantom types where they help express invariants. The objective is to make valid states and operations clearer, while avoiding abstractions that add complexity without improving the design.

Pure functions form the core of the recommended architecture, with IO isolated at explicit boundaries. The guide favors safe, total alternatives to partial functions, small modules, clear signatures, and deliberate use of language extensions. Typeclasses and algebraic abstractions should serve clarity and explainable laws rather than appear merely because they are available.

Use this overview when implementing or reviewing Haskell domain logic, parsing, concurrency, project organization, or tests. Concurrency topics include STM, async, lightweight threads, and exception-safe resource handling. Parsing and data interchange include Aeson and Megaparsec, while effect organization includes monad stacks.

Performance work covers strictness, profiling, fusion, allocation, and latency. Recommendations should respond to measurements and the actual project rather than presume that a more advanced type technique or stricter evaluation is automatically faster. Cabal and Stack are both named for build configuration, dependency hygiene, and module structure.

This overview supplies design guidance rather than a runnable implementation, dependency manifest, or concrete benchmark. It specifies the style and scope of assistance. It should not be treated as evidence that a particular Haskell program is correct, its resources are safe, or its performance has been measured.

Inputs include the intended behavior, existing code or project structure, relevant constraints, and the success criteria for the change or review. Missing requirements, permissions, and validation boundaries should be clarified before relying on an implementation.

Expected outputs are idiomatic Haskell with explicit types, pure logic separated from effects, practical concurrency patterns, parsing examples, and suitable Cabal or Stack improvements. Examples should run in GHCi or compile directly. QuickCheck and Hspec support property-based reasoning and test coverage. The result should explain why its types, abstractions, and extensions are useful, balancing maintainability with rigor and environment-specific validation.