Yaya.Retrofit

This module re-exports a subset of Fold, intended for when you want to define recursion scheme instances for your existing recursive types.

This is not the recommended way to use Yaya, but it solves some real problems: 1. you have existing directly-recursive types and you want to start taking advantage of recursion schemes without having to rewrite your existing code, or 2. a directly-recursive type has been imposed on you by some other library and you want to take advantage of recursion schemes.

The distinction between these two cases is whether you have control of the data declaration. In the first case, you probably do. In that case, you should only generate the safe instances, and ensure that all the recursive type references are strict (if you want a Recursive instance). If you don't have control, then you may need to generate all instances.

Another difference when you have control is that it means you may migrate away from direct recursion entirely, at which point this import should disappear.

Documentation

class Corecursive c t f | t -> f where

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

Methods

ana :: Coalgebra c f a -> a `c` t

Instances

Corecursive (->) (Nu f :: Type) (f :: Type -> Type)

Defined in Yaya.Fold

Methods

ana :: forall (a :: k). Coalgebra (->) f a -> a -> Nu f

Functor f => Corecursive (->) (Cofix f :: Type) (f :: Type -> Type)

Defined in Yaya.Fold.Native.Internal

Methods

ana :: forall (a :: k). Coalgebra (->) f a -> a -> Cofix f

Corecursive (->) (NonEmpty a :: Type) (AndMaybe a :: Type -> Type)

Defined in Yaya.Fold.Native

Methods

ana :: forall (a0 :: k). Coalgebra (->) (AndMaybe a) a0 -> a0 -> NonEmpty a

Corecursive (->) ([a] :: Type) (XNor a :: Type -> Type)

Defined in Yaya.Fold.Native

Methods

ana :: forall (a0 :: k). Coalgebra (->) (XNor a) a0 -> a0 -> [a]

Corecursive (->) (Maybe a :: Type) (Const (Maybe a) :: Type -> Type)

Defined in Yaya.Fold

Methods

ana :: forall (a0 :: k). Coalgebra (->) (Const (Maybe a)) a0 -> a0 -> Maybe a

Functor f => Corecursive (->) (Cofree f a :: Type) (EnvT a f :: Type -> Type)

Defined in Yaya.Fold.Native

Methods

ana :: forall (a0 :: k). Coalgebra (->) (EnvT a f) a0 -> a0 -> Cofree f a

Functor f => Corecursive (->) (Free f a :: Type) (FreeF f a :: Type -> Type)

Defined in Yaya.Fold.Native

Methods

ana :: forall (a0 :: k). Coalgebra (->) (FreeF f a) a0 -> a0 -> Free f a

Corecursive (->) (Either a b :: Type) (Const (Either a b) :: Type -> Type)

Defined in Yaya.Fold

Methods

ana :: forall (a0 :: k). Coalgebra (->) (Const (Either a b)) a0 -> a0 -> Either a b

class Projectable c t f | t -> f where

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).

Methods

project :: Coalgebra c f t

Instances

Projectable (->) Void Identity

Defined in Yaya.Fold

Methods

project :: Coalgebra (->) Identity Void

Projectable (->) Natural Maybe

Defined in Yaya.Fold

Methods

project :: Coalgebra (->) Maybe Natural

Functor f => Projectable (->) (Mu f :: Type) (f :: Type -> Type)

Defined in Yaya.Fold

Methods

project :: Coalgebra (->) f (Mu f)

Functor f => Projectable (->) (Nu f :: Type) (f :: Type -> Type)

Defined in Yaya.Fold

Methods

project :: Coalgebra (->) f (Nu f)

Projectable (->) (Fix f :: Type) (f :: Type -> Type)

Defined in Yaya.Fold.Native

Methods

project :: Coalgebra (->) f (Fix f)

Projectable (->) (Cofix f :: Type) (f :: Type -> Type)

Defined in Yaya.Fold.Native.Internal

Methods

project :: Coalgebra (->) f (Cofix f)

Projectable (->) (NonEmpty a :: Type) (AndMaybe a :: Type -> Type)

Defined in Yaya.Fold

Methods

project :: Coalgebra (->) (AndMaybe a) (NonEmpty a)

Projectable (->) ([a] :: Type) (XNor a :: Type -> Type)

Defined in Yaya.Fold

Methods

project :: Coalgebra (->) (XNor a) [a]

Projectable (->) (Maybe a :: Type) (Const (Maybe a) :: Type -> Type)

Defined in Yaya.Fold

Methods

project :: Coalgebra (->) (Const (Maybe a)) (Maybe a)

Projectable (->) (Cofree f a :: Type) (EnvT a f :: Type -> Type)

Defined in Yaya.Fold

Methods

project :: Coalgebra (->) (EnvT a f) (Cofree f a)

Projectable (->) (Free f a :: Type) (FreeF f a :: Type -> Type)

Defined in Yaya.Fold

Methods

project :: Coalgebra (->) (FreeF f a) (Free f a)

Projectable (->) (Either a b :: Type) (Const (Either a b) :: Type -> Type)

Defined in Yaya.Fold

Methods

project :: Coalgebra (->) (Const (Either a b)) (Either a b)

class Recursive c t f | t -> f where

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

Methods

cata :: Algebra c f a -> t `c` a

Instances

Recursive (->) Void Identity

Defined in Yaya.Fold

Methods

cata :: forall (a :: k1). Algebra (->) Identity a -> Void -> a

Recursive (->) Natural Maybe

Defined in Yaya.Fold.Native

Methods

cata :: forall (a :: k1). Algebra (->) Maybe a -> Natural -> a

Recursive (->) (Mu f :: Type) (f :: Type -> Type)

Defined in Yaya.Fold

Methods

cata :: forall (a :: k1). Algebra (->) f a -> Mu f -> a

Functor f => Recursive (->) (Fix f :: Type) (f :: Type -> Type)

Defined in Yaya.Fold.Native

Methods

cata :: forall (a :: k1). Algebra (->) f a -> Fix f -> a

Recursive (->) (Maybe a :: Type) (Const (Maybe a) :: Type -> Type)

Defined in Yaya.Fold

Methods

cata :: forall (a0 :: k1). Algebra (->) (Const (Maybe a)) a0 -> Maybe a -> a0

Recursive (->) (Either a b :: Type) (Const (Either a b) :: Type -> Type)

Defined in Yaya.Fold

Methods

cata :: forall (a0 :: k1). Algebra (->) (Const (Either a b)) a0 -> Either a b -> a0

class Projectable c t f => Steppable c t f | t -> f where

Structures you can walk through step-by-step.

Methods

embed :: Algebra c f t

Instances

Steppable (->) Void Identity

Defined in Yaya.Fold

Methods

embed :: Algebra (->) Identity Void

Steppable (->) Natural Maybe

Defined in Yaya.Fold

Methods

embed :: Algebra (->) Maybe Natural

Functor f => Steppable (->) (Mu f :: Type) (f :: Type -> Type)

Defined in Yaya.Fold

Methods

embed :: Algebra (->) f (Mu f)

Functor f => Steppable (->) (Nu f :: Type) (f :: Type -> Type)

Defined in Yaya.Fold

Methods

embed :: Algebra (->) f (Nu f)

Steppable (->) (Fix f :: Type) (f :: Type -> Type)

Defined in Yaya.Fold.Native

Methods

embed :: Algebra (->) f (Fix f)

Steppable (->) (Cofix f :: Type) (f :: Type -> Type)

Defined in Yaya.Fold.Native.Internal

Methods

embed :: Algebra (->) f (Cofix f)

Steppable (->) (NonEmpty a :: Type) (AndMaybe a :: Type -> Type)

Defined in Yaya.Fold

Methods

embed :: Algebra (->) (AndMaybe a) (NonEmpty a)

Steppable (->) ([a] :: Type) (XNor a :: Type -> Type)

Defined in Yaya.Fold

Methods

embed :: Algebra (->) (XNor a) [a]

Steppable (->) (Maybe a :: Type) (Const (Maybe a) :: Type -> Type)

Defined in Yaya.Fold

Methods

embed :: Algebra (->) (Const (Maybe a)) (Maybe a)

Steppable (->) (Cofree f a :: Type) (EnvT a f :: Type -> Type)

Defined in Yaya.Fold

Methods

embed :: Algebra (->) (EnvT a f) (Cofree f a)

Steppable (->) (Free f a :: Type) (FreeF f a :: Type -> Type)

Defined in Yaya.Fold

Methods

embed :: Algebra (->) (FreeF f a) (Free f a)

Steppable (->) (Either a b :: Type) (Const (Either a b) :: Type -> Type)

Defined in Yaya.Fold

Methods

embed :: Algebra (->) (Const (Either a b)) (Either a b)

recursiveCompare :: (Recursive (->) t f, Steppable (->) u f, Functor f, Foldable f, Ord1 f) => t -> u -> Ordering

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

recursiveCompare' :: (Recursive (->) t f, Steppable (->) u f, Functor f, Foldable f) => (f () -> f () -> Ordering) -> t -> u -> Ordering

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

Since: 0.6.1.0

recursiveEq :: (Recursive (->) t f, Steppable (->) u f, Functor f, Foldable f, Eq1 f) => t -> u -> Bool

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.

recursiveEq' :: (Recursive (->) t f, Steppable (->) u f, Functor f, Foldable f) => (f () -> f () -> Bool) -> t -> u -> Bool

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

Since: 0.6.1.0

recursiveShowsPrec :: (Recursive (->) t f, Show1 f) => Int -> t -> ShowS

An implementation of showsPrec for any Recursive instance.

recursiveShowsPrec' :: Recursive (->) t f => Algebra (->) f (Int -> ShowS) -> Int -> t -> ShowS

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

Since: 0.6.1.0

steppableReadPrec :: (Steppable (->) t f, Read1 f) => ReadPrec t

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

steppableReadPrec' :: Steppable (->) t f => (ReadPrec t -> ReadPrec [t] -> ReadPrec (f t)) -> ReadPrec t

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

Since: 0.6.1.0

data PatternFunctorRules

Rules of renaming data names

Constructors

PatternFunctorRules

Fields

• patternType :: Name -> Name
• patternCon :: Name -> Name
• patternField :: Name -> Name

defaultRules :: PatternFunctorRules

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

extractPatternFunctor :: PatternFunctorRules -> Name -> Q [Dec]

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).