Documentation

Coinductive (potentially-infinite) structures that guarantee _productivity_ rather than termination.

This type class is lawless on its own, but there exist types that can’t implement the corresponding embed operation. Laws are induced by implementing either Steppable (which extends this) or Corecursive (which doesn’t).

Inductive structures that can be reasoned about in the way we usually do – with pattern matching.

Structures you can walk through step-by-step.

An implementation of == for any Recursive instance. Note that this is actually more general than Ord’s compare, as it can compare between different fixed-point representations of the same functor.

NB: Use recursiveCompare' if you need to use a custom comparator for f.

Since: 0.6.1.0

Like recursiveCompare, but allows you to provide a custom comparator for f.

Since: 0.6.1.0

An implementation of == for any Recursive instance. Note that this is actually more general than Eq’s ==, as it can compare between different fixed-point representations of the same functor.

NB: Use recursiveEq' if you need to use a custom comparator for f.

Like recursiveEq, but allows you to provide a custom comparator for f.

Since: 0.6.1.0

An implementation of showsPrec for any Recursive instance.

Like recursiveShowsPrec, but allows you to provide a custom display function for f.

Since: 0.6.1.0

An implementation of readPrec for any Steppable instance.

NB: Use steppableReadPrec' if you need to use a custom parsing function for f.

NB: This only requires Steppable, but the inverse operation is recursiveShowsPrec, which requires Recursive instead.

Since: 0.6.1.0

Like steppableReadPrec, but allows you to provide a custom display function for f.

Since: 0.6.1.0

Rules of renaming data names

Default PatternFunctorRules: append F or $ to data type, constructors and field names.

Extract a pattern functor and relevant instances from a simply recursive type.

e.g.

data Expr a
    = Lit a
    | Add (Expr a) (Expr a)
    | Expr a :* [Expr a]
  deriving stock (Show)

extractPatternFunctor defaultRules ''Expr

will create

data ExprF a x
    = LitF a
    | AddF x x
    | x :*$ [x]
  deriving stock (Functor, Foldable, Traversable)

instance Projectable (->) (Expr a) (ExprF a) where
  project (Lit x)   = LitF x
  project (Add x y) = AddF x y
  project (x :* y)  = x :*$ y

instance Steppable (->) (Expr a) (ExprF a) where
  embed (LitF x)   = Lit x
  embed (AddF x y) = Add x y
  embed (x :*$ y)  = x :* y

instance Recursive (->) (Expr a) (ExprF a) where
  cata φ = φ . fmap (cata φ) . project

instance Corecursive (->) (Expr a) (ExprF a) where
  ana ψ = embed . fmap (ana ψ) . ψ

Notes:

• extractPatternFunctor works properly only with ADTs. Existentials and GADTs aren't supported, as we don't try to do better than GHC's DeriveFunctor.
• we always generate both Recursive and Corecursive instances, but one of these is always unsafe. In future, we should check the strictness of the recursive parameter and generate only the appropriate one (unless overridden by a rule).