MonadFailDesugaring changes do-notation pattern matching in GHC 8.8+

Answer

In GHC 8.8 the fail method left Monad and was moved to MonadFail. With the MonadFailDesugaring extension (on by default), a pattern‑match failure inside a do block desugars to MonadFail.fail. If a transformer type has no MonadFail instance, the code will not type‑check under GHC 8.8+ even though a Monad instance exists. Disabling the extension restores the old desugaring to Monad.fail, but it does not automatically provide a MonadFail instance; the code may still fail to compile or, if the instance is added later, the failure will surface at runtime.

Why adding MonadFail is safer

• Preserves the public API: users still see a Monad instance and can use fail via the MonadFail class without changing import paths.
• Ensures compile‑time checks for pattern‑match failures across all GHC versions that support MonadFailDesugaring.
• Avoids subtle runtime errors that would otherwise be hidden when the extension is disabled.

Practical steps for a transformer library

1. Add a minimal MonadFail instance. For most transformers the default implementation can simply delegate to the underlying monad or use error "pattern match failure".

   instance (Monad m) => MonadFail (MyT m) where
     fail = lift . fail
   

2. Use conditional compilation for older GHCs. If you still need to support GHC 8.6, guard the instance with #if MIN_VERSION_GHC(8,8,0).

   #if MIN_VERSION_GHC(8,8,0)
   instance (Monad m) => MonadFail (MyT m) where
     fail = lift . fail
   #endif
   

3. Avoid disabling MonadFailDesugaring. Turning it off changes desugaring semantics and does not solve the missing instance problem. It also makes the code less future‑proof because the extension may be re‑enabled in downstream projects.
4. Document the behavior. Make it clear in the library documentation that pattern‑match failures in do blocks are handled via MonadFail and that users should provide or rely on the default instance.

Does disabling the extension preserve pre‑8.8 semantics?

Not entirely. While disabling MonadFailDesugaring reverts the desugaring to Monad.fail, it does not add a MonadFail instance. If your transformer lacks one, the code will still fail to compile. Moreover, the public API changes because callers would need to import MonadFail explicitly to use fail. Therefore the safest path is to add MonadFail instances rather than rely on disabling the extension.

When to ask for more detail

If your library contains many do blocks with pattern matches, adding a MonadFail instance for each transformer is the recommended approach. If you suspect that some of your transformers never use pattern matches, you could conditionally provide the instance only where needed. In that case, we’d want to know which transformers actually use pattern matches in do blocks to avoid unnecessary boilerplate.

Question for you: Does your library contain do blocks that perform pattern matching on the result of a monadic action?