-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | Generic representation of tree transformations
--   
--   This library is based on ideas described in the paper:
--   
--   <ul>
--   <li>Jeroen Bransen and Jose Pedro Magalhaes. <i>Generic
--   Representations of Tree Transformations</i>.
--   <a>http://dreixel.net/research/pdf/grtt_draft.pdf</a></li>
--   </ul>
@package transformations
@version 0.1.0.0

module Generics.MultiRec.LR

-- | The <tt>LRBase</tt> class defines two functions, <tt>leftb</tt> and
--   <tt>rightb</tt>, which should produce different values.
class LRBase a
leftb :: LRBase a => a
rightb :: LRBase a => a

-- | The <tt>LR</tt> class defines two functions, <tt>leftf</tt> and
--   <tt>rightf</tt>, which should produce different functorial values.
class LR phi (f :: (* -> *) -> * -> *)
leftf :: LR phi f => phi ix -> (forall ix'. El phi ix' => phi ix' -> r ix') -> [f r ix]
rightf :: LR phi f => phi ix -> (forall ix'. El phi ix' => phi ix' -> r ix') -> [f r ix]
left :: (Fam phi, LR phi (PF phi)) => phi ix -> ix
right :: (Fam phi, LR phi (PF phi)) => phi ix -> ix
safeHead :: [t] -> t
instance LR phi f => LR phi ([] :.: f)
instance (El phi ix, LR phi f, EqS phi) => LR phi (f :>: ix)
instance LR phi f => LR phi (C c f)
instance (LR phi f, LR phi g) => LR phi (f :*: g)
instance (LR phi f, LR phi g) => LR phi (f :+: g)
instance LR phi U
instance LRBase a => LR phi (K a)
instance El phi xi => LR phi (I xi)
instance LRBase a => LRBase [a]
instance LRBase Bool
instance LRBase Char
instance LRBase Integer
instance LRBase Int

module Generics.MultiRec.HZip
class HZip phi f
hzipM :: (HZip phi f, Monad m) => (forall ix. El phi ix => phi ix -> r ix -> r' ix -> m (r'' ix)) -> f r ix -> f r' ix -> m (f r'' ix)

-- | Monadic zip but argument is not monadic
hzip :: (HZip phi f, Monad m) => (forall ix. El phi ix => phi ix -> r ix -> s ix -> t ix) -> phi ix -> f r ix -> f s ix -> m (f t ix)

-- | Unsafe zip
hzip' :: HZip phi f => (forall ix. El phi ix => phi ix -> r ix -> s ix -> t ix) -> phi ix -> f r ix -> f s ix -> f t ix

-- | Combine two structures monadically only
combine :: (Monad m, HZip phi f) => (forall ix. El phi ix => phi ix -> r ix -> r' ix -> m ()) -> phi ix -> f r ix -> f r' ix -> m ()

-- | Generic equality
geq :: (Fam phi, HZip phi (PF phi)) => phi ix -> ix -> ix -> Bool

-- | Monadic generic equality (just for the sake of the monad!)
geq' :: (Monad m, Fam phi, HZip phi (PF phi)) => phi ix -> I0 ix -> I0 ix -> m ()
instance HZip phi f => HZip phi ([] :.: f)
instance HZip phi f => HZip phi (C c f)
instance HZip phi f => HZip phi (f :>: xi)
instance (HZip phi a, HZip phi b) => HZip phi (a :*: b)
instance (HZip phi a, HZip phi b) => HZip phi (a :+: b)
instance HZip phi U
instance Eq a => HZip phi (K a)
instance El phi xi => HZip phi (I xi)

module Generics.MultiRec.Rewriting.Rules

-- | Specifies a rule as a value of a datatype.
data RuleSpec a
(:~>) :: a -> a -> RuleSpec a

-- | Returns the left-hand side of a rule.
lhsR :: RuleSpec a -> a

-- | Returns the right-hand side of a rule.
rhsR :: RuleSpec a -> a

-- | Extends a pattern functor with a case for a metavariable.
type Ext phi = K Metavar :+: PF phi
type Metavar = Int

-- | Recursively extends a type with a case for a metavariable.
type Scheme phi = HFix (Ext phi)

-- | Allows metavariables on either side of a rule.
data Rule phi a
Rule :: phi ix -> RuleSpec (Scheme phi ix) -> Rule phi ix

-- | Constructs a metavariable.
metavar :: phi ix -> Metavar -> Scheme phi ix
pf :: phi ix -> PF phi (Scheme phi) ix -> Scheme phi ix
class Builder phi a where type family Target a :: *
base :: Builder phi a => phi (Target a) -> a -> RuleSpec (Target a)
diag :: Builder phi a => phi (Target a) -> a -> [RuleSpec (Target a)]
rule :: (Fam phi, Builder phi r, HZip phi (PF phi), El phi (Target r), EqS phi, HFunctor phi (PF phi)) => r -> Rule phi (Target r)
mergeSchemes :: HZip phi (PF phi) => phi ix -> Scheme phi ix -> Scheme phi ix -> Scheme phi ix
insertMVar :: (Fam phi, HZip phi (PF phi), El phi ix) => Metavar -> phi ix -> I0 ix -> I0 ix -> Scheme phi ix
instance (Builder phi a, Fam phi, LR phi (PF phi), El phi b) => Builder phi (b -> a)
instance Builder phi (RuleSpec a)

module Generics.MultiRec.Ord
class HOrd phi f
hcompare :: HOrd phi f => (forall ix. phi ix -> r ix -> r ix -> Ordering) -> phi ix -> f r ix -> f r ix -> Ordering
class Ord1 f
compare1 :: Ord1 f => (a -> a -> Ordering) -> f a -> f a -> Ordering
gcompare :: (Fam phi, HOrd phi (PF phi)) => phi ix -> ix -> ix -> Ordering
instance Ord1 []
instance (Ord1 f, HOrd phi g) => HOrd phi (f :.: g)
instance HOrd phi f => HOrd phi (f :>: ix)
instance HOrd phi f => HOrd phi (C c f)
instance (HOrd phi f, HOrd phi g) => HOrd phi (f :*: g)
instance (HOrd phi f, HOrd phi g) => HOrd phi (f :+: g)
instance HOrd phi U
instance Ord a => HOrd phi (K a)
instance El phi xi => HOrd phi (I xi)

module Generics.MultiRec.Any
data Any phi
Any :: phi ix -> ix -> Any phi

-- | Unify an <a>Any</a> with an <tt>a</tt>.
matchAny :: EqS phi => phi ix -> Any phi -> Maybe ix

module Generics.MultiRec.Transformations.ZipperState
type ZipperMonad phi r a b = StateT (ZipperState phi r a) Maybe b
type ZipperState phi r a = ([Any phi], Loc phi r a)
upMonad :: (EqS phi, El phi a) => ZipperMonad phi I0 a (Any phi)
downMonad :: (EqS phi, El phi a) => ZipperMonad phi I0 a (Any phi)
leftMonad :: (EqS phi, El phi a) => ZipperMonad phi I0 a (Any phi)
rightMonad :: (EqS phi, El phi a) => ZipperMonad phi I0 a (Any phi)
navigate :: (Fam phi, EqS phi, El phi a, Zipper phi (PF phi)) => phi a -> a -> ZipperMonad phi I0 a b -> Maybe a
saveMonad :: (EqS phi, El phi a) => ZipperMonad phi I0 a (Any phi)
loadMonad :: (EqS phi, El phi a) => ZipperMonad phi I0 a (Any phi)
topMonad :: (EqS phi, El phi a) => ZipperMonad phi I0 a (Any phi)
updateMonad :: (EqS phi, El phi a) => (forall xi. phi xi -> xi -> Maybe xi) -> ZipperMonad phi I0 a (Any phi)

module Generics.MultiRec.Transformations.Explicit

-- | Find a set of insertions to transform the first into the second tree
diff :: Transform phi => phi ix -> ix -> ix -> Transformation phi

-- | Apply the transformation to the given tree
apply :: Transform phi => phi ix -> ix -> Transformation phi -> Maybe ix
type Transformation phi = [AnyInsert phi]
data AnyInsert phi
AnyInsert :: phi ix -> Path -> HFix (WithRef phi) ix -> AnyInsert phi
data WithRef phi f a
InR :: (PF phi f a) -> WithRef phi f a
Ref :: Path -> WithRef phi f a
type Path = [Int]
class (Fam phi, Children phi (PF phi), CountI phi (PF phi), HFunctor phi (PF phi), SEq phi (PF phi), ExtractN phi (PF phi), MapN phi (PF phi), EqS phi, HEq phi (PF phi), HOrd phi (PF phi), OrdI phi) => Transform phi

-- | Comparing index of different types
class OrdI phi
compareI :: OrdI phi => phi ix -> phi ix' -> Ordering
instance Children phi f => Children phi ([] :.: f)
instance Children phi f => Children phi (f :>: ix)
instance Children phi f => Children phi (C c f)
instance (Children phi f, Children phi g) => Children phi (f :*: g)
instance (Children phi f, Children phi g) => Children phi (f :+: g)
instance Children phi U
instance Children phi (K a)
instance (Fam phi, El phi xi) => Children phi (I xi)
instance CountI phi f => CountI phi ([] :.: f)
instance CountI phi f => CountI phi (C c f)
instance CountI phi f => CountI phi (f :>: ix)
instance (CountI phi f, CountI phi g) => CountI phi (f :*: g)
instance (CountI phi f, CountI phi g) => CountI phi (f :+: g)
instance CountI phi U
instance CountI phi (K a)
instance El phi xi => CountI phi (I xi)
instance (CountI phi f, MapN phi f) => MapN phi ([] :.: f)
instance MapN phi f => MapN phi (C c f)
instance MapN phi f => MapN phi (f :>: ix)
instance (CountI phi f, MapN phi f, MapN phi g) => MapN phi (f :*: g)
instance (MapN phi f, MapN phi g) => MapN phi (f :+: g)
instance MapN phi U
instance MapN phi (K a)
instance El phi xi => MapN phi (I xi)
instance ExtractN phi f => ExtractN phi ([] :.: f)
instance ExtractN phi f => ExtractN phi (C c f)
instance ExtractN phi f => ExtractN phi (f :>: ix)
instance (CountI phi f, ExtractN phi f, ExtractN phi g) => ExtractN phi (f :*: g)
instance (ExtractN phi f, ExtractN phi g) => ExtractN phi (f :+: g)
instance ExtractN phi U
instance ExtractN phi (K a)
instance El phi xi => ExtractN phi (I xi)
instance SEq phi ([] :.: ix)
instance SEq phi f => SEq phi (C c f)
instance SEq phi f => SEq phi (f :>: ix)
instance (SEq phi f, SEq phi g) => SEq phi (f :*: g)
instance (SEq phi f, SEq phi g) => SEq phi (f :+: g)
instance Eq a => SEq phi (K a)
instance SEq phi U
instance El phi xi => SEq phi (I xi)
instance (EqS phi, Fam phi, OrdI phi, HEq phi (PF phi), HOrd phi (PF phi)) => Ord (MemoKey phi)
instance (EqS phi, Fam phi, HEq phi (PF phi)) => Eq (MemoKey phi)

module Generics.MultiRec.Rewriting.Machinery
class (Fam phi, EqS phi, HZip phi (PF phi), HFunctor phi (PF phi)) => Rewrite phi
rewriteM :: Rewrite phi => Rule phi a -> a -> Maybe a
match :: (Monad m, Rewrite phi) => phi ix -> Scheme phi ix -> ix -> m (Subst phi)
matchM :: (Monad m, Rewrite phi) => phi ix -> Scheme phi ix -> I0 ix -> StateT (Subst phi) m ()
checkEqual :: (Monad m, Rewrite phi) => phi ix -> ix -> Any phi -> m ()
inst :: Rewrite phi => Subst phi -> phi ix -> Scheme phi ix -> ix
type Subst phi = Map Metavar (Any phi)

module Generics.MultiRec.Rewriting

module Generics.MultiRec.Transformations.RewriteRules
type Transformation phi a = [AnyInsert phi a]
class (Zipper phi (PF phi), Rewrite phi) => Transform phi
apply :: Transform phi => Transformation phi a -> phi a -> a -> Maybe a
insert :: El phi ix => (Loc phi I0 a -> Maybe (Loc phi I0 a)) -> Rule phi ix -> AnyInsert phi a
data AnyInsert phi a
AnyInsert :: phi ix -> (Loc phi I0 a -> Maybe (Loc phi I0 a)) -> Rule phi ix -> AnyInsert phi a
instance Transform phi => Rewrite phi

module Generics.Regular.Functions.GOrd
class GOrd f
comparef :: GOrd f => (a -> a -> Ordering) -> f a -> f a -> Ordering
gcompare :: (Regular a, GOrd (PF a)) => a -> a -> Ordering
instance GOrd f => GOrd (S s f)
instance GOrd f => GOrd (C c f)
instance (GOrd f, GOrd g) => GOrd (f :*: g)
instance (GOrd f, GOrd g) => GOrd (f :+: g)
instance GOrd U
instance Ord a => GOrd (K a)
instance GOrd I

module Generics.Regular.Transformations.Explicit

-- | Find a set of edits to transform the first into the second tree
diff :: Transform a => a -> a -> Transformation a

-- | Apply the edits to the given tree
apply :: Transform a => Transformation a -> a -> Maybe a
type Transformation a = [(Path, Fix (WithRef a))]
data WithRef a b
InR :: (PF a b) -> WithRef a b
Ref :: Path -> WithRef a b
type Path = [Int]
class (Regular a, Children (PF a), CountI (PF a), Functor (PF a), SEq (PF a), ExtractN (PF a), MapN (PF a), GMap (PF a), GOrd (PF a), Eq (PF a)) => Transform a
instance Children f => Children (S s f)
instance Children f => Children (C c f)
instance (Children f, Children g) => Children (f :*: g)
instance (Children f, Children g) => Children (f :+: g)
instance Children U
instance Children (K a)
instance Children I
instance CountI f => CountI (S s f)
instance CountI f => CountI (C c f)
instance (CountI f, CountI g) => CountI (f :*: g)
instance (CountI f, CountI g) => CountI (f :+: g)
instance CountI U
instance CountI (K a)
instance CountI I
instance MapN f => MapN (S s f)
instance MapN f => MapN (C c f)
instance (CountI f, MapN f, MapN g) => MapN (f :*: g)
instance (MapN f, MapN g) => MapN (f :+: g)
instance MapN U
instance MapN (K a)
instance MapN I
instance ExtractN f => ExtractN (S s f)
instance ExtractN f => ExtractN (C c f)
instance (CountI f, ExtractN f, ExtractN g) => ExtractN (f :*: g)
instance (ExtractN f, ExtractN g) => ExtractN (f :+: g)
instance ExtractN U
instance ExtractN (K a)
instance ExtractN I
instance SEq f => SEq (S s f)
instance SEq f => SEq (C c f)
instance (SEq f, SEq g) => SEq (f :*: g)
instance (SEq f, SEq g) => SEq (f :+: g)
instance Eq a => SEq (K a)
instance SEq U
instance SEq I
instance (Regular a, Eq (PF a), GOrd (PF a)) => Ord (MemoKey a)
instance (Regular a, Eq (PF a)) => Eq (MemoKey a)

module Generics.Regular.Zipper

-- | Abstract type of locations. A location contains the current focus and
--   its context. A location is parameterized over the family of datatypes
--   and over the type of the complete value.
data Loc :: * -> *
Loc :: a -> [Ctx (PF a) a] -> Loc a

-- | Abstract type of context frames. Not required for the high-level
--   navigation functions.

-- | It is in general not necessary to use the generic navigation functions
--   directly. The functions listed in the `<tt>Interface'</tt> section
--   below are more user-friendly.
class Functor f => Zipper f
cmap :: Zipper f => (a -> b) -> Ctx f a -> Ctx f b
fill :: Zipper f => Ctx f a -> a -> f a
first, last :: Zipper f => f a -> Maybe (a, Ctx f a)
next, prev :: Zipper f => Ctx f a -> a -> Maybe (a, Ctx f a)

-- | Start navigating a datastructure. Returns a location that focuses the
--   entire value and has an empty context.
enter :: (Regular a, Zipper (PF a)) => a -> Loc a

-- | Move down to the leftmost child. Returns <a>Nothing</a> if the current
--   focus is a leaf.
down :: Loc a -> Maybe (Loc a)

-- | Move down to the rightmost child. Returns <a>Nothing</a> if the
--   current focus is a leaf.
down' :: Loc a -> Maybe (Loc a)

-- | Move up to the parent. Returns <a>Nothing</a> if the current focus is
--   the root.
up :: Loc a -> Maybe (Loc a)

-- | Move to the right sibling. Returns <a>Nothing</a> if the current focus
--   is the rightmost sibling.
right :: Loc a -> Maybe (Loc a)

-- | Move to the left sibling. Returns <a>Nothing</a> if the current focus
--   is the leftmost sibling.
left :: Loc a -> Maybe (Loc a)

-- | Return the entire value, independent of the current focus.
leave :: Loc a -> a

-- | Operate on the current focus. This function can be used to extract the
--   current point of focus.
on :: Loc a -> a

-- | Update the current focus without changing its type.
update :: (a -> a) -> Loc a -> Loc a

-- | Update the current focus without changing its type.
updateM :: Monad m => (a -> m a) -> Loc a -> m (Loc a)
instance Zipper f => Zipper (S s f)
instance Zipper f => Zipper (C c f)
instance (Zipper f, Zipper g) => Zipper (f :*: g)
instance (Zipper f, Zipper g) => Zipper (f :+: g)
instance Zipper U
instance Zipper (K a)
instance Zipper I
instance Zipper f => Functor (Ctx f)

module Generics.Regular.Transformations.RewriteRules
class (Regular a, Rewrite a, Zipper (PF a)) => Transform a
type Transformation a = [(Loc a -> Maybe (Loc a), Rule a)]
apply :: Transform a => Transformation a -> a -> Maybe a
instance Transform a => Rewrite a

module Generics.Regular.Transformations.ZipperState
type ZipperMonad a b = StateT (ZipperState a) Maybe b
type ZipperState a = ([a], Loc a)
upMonad :: ZipperMonad a a
downMonad :: ZipperMonad a a
leftMonad :: ZipperMonad a a
rightMonad :: ZipperMonad a a
navigate :: (Regular a, Zipper (PF a)) => a -> ZipperMonad a b -> Maybe a
saveMonad :: ZipperMonad a a
loadMonad :: ZipperMonad a a
topMonad :: ZipperMonad a a
updateMonad :: (a -> a) -> ZipperMonad a a