Haskell实例终止规则及类型检查规则学习资源咨询

Hey there! Great question—digging into instance termination rules is such a smart move to avoid those frustrating "constraint ... is no smaller than the instance head" errors and steer clear of UndecidableInstances unless you truly understand the tradeoffs. Let me break down where to find solid, accessible details and walk through the core ideas to make this clearer.

These are the best places to get precise, practical explanations:

• GHC User's Guide: This should be your first port of call. The sections on Instance Resolution and specifically Termination Conditions for Instance Declarations dive deep into the rules GHC enforces. It explains exactly what "smaller than" means here—usually tied to type term size, or how functional dependencies can reduce constraint complexity. You’ll find concrete examples of valid vs. invalid instances, and why the checker rejects certain cases to prevent infinite loops during type checking.
• Haskell 2010 Report: While it’s more formal than the GHC guide, it lays out the baseline instance resolution rules that GHC builds upon. The Instance Declarations section covers the foundational termination principles, which helps you understand how GHC’s extended checks (like those for functional dependencies and type families) fit into the bigger picture.
• Type Classes: Exploring the Design Space: This academic paper is way more approachable than the CHR one you mentioned. It breaks down instance resolution (including termination checks) with real-world examples that directly map to the errors you’re encountering. It avoids overly dense formalisms while still being precise enough to deepen your understanding.

Let’s unpack that confusing "constraint no smaller than instance head" message:

• The type checker’s number one goal here is to guarantee that instance resolution will terminate. So when you write an instance like instance Foo (a, b) where ..., any constraints in that instance (say Foo a) must be "smaller" than the instance head (Foo (a, b)). Here, a is a subterm of (a, b), so it’s clearly smaller—this instance is valid.
• If you write something like instance Foo a where ... with a constraint Foo (a, b), that’s a red flag. The constraint is larger than the instance head, which could lead to infinite recursion: the checker would keep trying to resolve Foo a by looking for Foo (a, b), which then requires resolving Foo ((a, b), b), and so on forever.
• For classes with functional dependencies (like class Bar a b | a -> b), the checker uses the dependency to know that resolving Bar a b can be narrowed down by fixing a. This helps satisfy termination even if the constraint looks similar to the instance head.

• Structure instances so constraints are strictly smaller than the instance head—use subterms, or lean on functional dependencies to reduce complexity.
• Be cautious with type families: if a type family’s right-hand side expands to create larger constraints, you’re likely to hit termination issues.
• Test incrementally: write a small instance, verify it compiles, and understand why before adding more layers of complexity.

内容的提问来源于stack exchange，提问作者jack malkovick