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


-- | Reify a recursive data structure into an explicit graph.
--   
--   This package is a (probably temporary) fork of Andy gill's data-reify
--   package.
--   
--   'data-reify' provided the ability to turn recursive structures into
--   explicit graphs. Many (implicitly or explicitly) recursive data
--   structure can be given this ability, via a type class instance. This
--   gives an alternative to using <a>Ref</a> for observable sharing.
--   
--   Observable sharing in general is unsafe, so we use the IO monad to
--   bound this effect, but can be used safely even with
--   <a>unsafePerformIO</a> if some simple conditions are met. Typically
--   this package will be used to tie the knot with DSL's that depend of
--   observable sharing, like Lava.
--   
--   Providing an instance for <a>MuRef</a> is the mechanism for allowing a
--   structure to be reified into a graph, and several examples of this are
--   provided.
--   
--   Version 0.2 of 'data-reify' uses <a>StableName</a>s, and is much
--   faster. Version 0.3 provided two versions of <a>MuRef</a>, the
--   mono-typed version, for trees of a single type, and the dynamic-typed
--   version, for trees of different types.
--   
--   © 2009 Andy Gill; BSD3 license.
@package data-treify
@version 0.3.1


-- | Custom Ty &amp; Typable
module CustomTy

-- | Typed type representation. Alternative to Data.Ty in the ty package
data Ty a
Bool :: Ty Bool
Integer :: Ty Integer
Float :: Ty Float
(:*:) :: Ty a -> Ty b -> Ty (a, b)
(:->:) :: Ty a -> Ty b -> Ty (a -> b)

-- | Replacement for Typeable and the ty package's ty.
class Typeable a
ty :: Typeable a => Ty a
instance (Typeable a, Typeable b) => Typeable (a -> b)
instance (Typeable a, Typeable b) => Typeable (a, b)
instance Typeable Float
instance Typeable Integer
instance Typeable Bool
instance IsTy Ty

module Data.Reify.TGraph
class ShowF f
showF :: ShowF f => f a -> String

-- | Identifiers
type Id = Int

-- | Typed variables
data V ty a
V :: Id -> (ty a) -> V ty a

-- | Typed binding pair, parameterized by variable and node type
--   constructors.
data Bind ty n
Bind :: (V ty a) -> (n (V ty) a) -> Bind ty n

-- | Graph, described by bindings and a root variable
data Graph ty n a
Graph :: [Bind ty n] -> (V ty a) -> Graph ty n a
instance (ShowF (n (V ty)), Show (V ty a)) => Show (Graph ty n a)
instance ShowF (n (V ty)) => Show (Bind ty n)
instance Show (V ty a)
instance ShowF (V ty)
instance Eq (V ty a)

module Data.TReify
class MuRef ty h where { type family DeRef h :: (* -> *) -> * -> *; }
mapDeRef :: (MuRef ty h, Applicative m) => (forall a. ty a -> h a -> m (v a)) -> (forall a. ty a -> h a -> m (DeRef h v a))

-- | <a>reifyGraph</a> takes a data structure that admits <a>MuRef</a>, and
--   returns a <a>Graph</a> that contains the dereferenced nodes, with
--   their children as <a>Integer</a> rather than recursive values.
reifyGraph :: (IsTy ty, MuRef ty h) => ty a -> h a -> IO (Graph ty (DeRef h) a)

module Exp
data Op :: * -> *
Add :: Op (a -> a -> a)
Mul :: Op (a -> a -> a)
Lit :: a -> Op a
data E :: (* -> *) -> * -> *
Op :: Op a -> E v a
(:^) :: E v (a -> b) -> E v a -> E v b
Let :: v a -> E v a -> E v b -> E v b
Var :: v a -> E v a
data N :: (* -> *) -> * -> *
ON :: Op a -> N v a
App :: v (a -> b) -> v a -> N v b
parens :: String -> String
notSupp :: String -> a
nodeE :: N v a -> E v a
unGraph :: Typeable a => Graph Ty N a -> E (V Ty) a
ssa :: Typeable a => E (V Ty) a -> IO (E (V Ty) a)
children :: N (V Ty) a -> [Id]
childrenB :: Bind Ty N -> [Id]
uses :: [Bind Ty N] -> (Id -> Int)
histogram :: [Int] -> IntMap Int
bindsF' :: [Bind Ty N] -> (V Ty a -> N (V Ty) a)
bindsF :: [Bind Ty n] -> (V Ty a -> n (V Ty) a)
unGraph2 :: Graph Ty N a -> E (V Ty) a

-- | Common subexpression elimination
cse :: Typeable a => E (V Ty) a -> IO (E (V Ty) a)
op2 :: (Typeable a, Typeable b, Typeable c) => Op (a -> b -> c) -> E v a -> E v b -> E v c
sqr :: Num a => a -> a
reify :: (MuRef Ty h, Typeable a) => h a -> IO (Graph Ty (DeRef h) a)
test :: Int -> E (V Ty) Integer
instance (Typeable a, Num a) => Num (E (V Ty) a)
instance Eq (E v a)
instance MuRef Ty (E v)
instance Show (E (V Ty) a)
instance ShowF v => ShowF (N v)
instance Show (Op a)
instance ShowF Op