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


-- | A library for existential types
--   
--   The library defines the type Cell and Cell1 uses Constraint kinds to
--   so that it can stand for any existential type. Combinators and lenses
--   of various types are built on top of <a>Cell</a> and <a>Cell1</a>
@package existential
@version 0.1.0.0


-- | Conventions: * fooCell: a function that applies to <a>Cell</a>s
--   directly * fooCell': a function, very similar to fooCell but that
--   applies to a type which wraps a <a>Cell</a> using an instance of
--   <a>HasCell</a> * fooCell1: a function that applies to <a>Cell1</a> *
--   fooCell1': a function that a applies to a wrapped Cell1 (depends on
--   <a>HasCell</a>)
module Data.Existential

-- | <h1>The Cell Type</h1>
--   
--   A polymorphic cell. Type 'Cell MyClass' can take a value of any type
--   that conforms to <tt>MyClass</tt> and to <a>Typeable</a>. It is
--   defined in terms of <a>Cell1</a>.
type Cell = Cell1 Identity

-- | Generilization of <a>Cell</a>. 'Cell1 MyFunctor MyClass' takes values
--   ^ of type 'MyFunctor a' with '(MyClass a,Typeable a)'.
data Cell1 f (constr :: * -> Constraint)
Cell :: (f a) -> Cell1 f

-- | <a>HasCell</a> permits the overloading of <a>Iso</a> <a>cell</a> and
--   makes it easier | to wrap a <a>Cell</a> with a newtype without having
--   to mention <a>Cell</a> all | the time.
class HasCell a b | a -> b
cell :: HasCell a b => Iso' a b

-- | Similar to <a>makeCell</a>. Uses <a>Cell1</a> to allow the content ^
--   of a <a>Cell</a> to be wrapped with a generic type.
--   
--   <h1>Contructors</h1>
--   
--   We can use 'makeCell "hello" :: MyType' if there is an instance ^
--   'HasCell MyType (Cell Show)' (or any other class than show).
makeCell :: (HasCell a (Cell constr), constr b, Typeable b) => b -> a
makeCell1 :: (HasCell a (Cell1 f constr), constr b, Typeable b) => f b -> a

-- | <h1>Prisms</h1>
--   
--   Treats a <a>Cell</a> as an unbounded sum type: 'c^?_Cell :: Maybe a'
--   has the ^ value 'Just x' if x is of type <tt>a</tt> and <tt>c</tt>
--   contains value <tt>x</tt>. If cell <tt>c</tt> ^ has a value of any
--   other type then <tt>a</tt>, 'c^?_Cell == Nothing'.
_Cell :: (constr b, Typeable b, Typeable a) => Prism (Cell constr) (Cell constr) a b

-- | Similar to <a>_Cell</a> but operates on types that wrap a cell instead
--   of ^ on the cell itself.
_Cell' :: (constr a, Typeable a, HasCell c (Cell constr)) => Prism c c a a

-- | Similar to <a>_Cell</a> but values are wrapped in type <tt>f</tt>
--   inside the cell.
_Cell1 :: (constr b, Typeable b, Typeable a, Typeable f) => Prism (Cell1 f constr) (Cell1 f constr) (f a) (f b)

-- | Analogous to <a>_Cell'</a> and <a>_Cell1</a>.
_Cell1' :: (constr a, Typeable a, Typeable f, HasCell c (Cell1 f constr)) => Prism c c (f a) (f a)

-- | Like <a>_Cell</a> but disallows changing the type of the content of
--   the cell. ^ facilitates type checking when the prism is not used for
--   modification.
asCell :: (constr a, Typeable a) => Prism (Cell constr) (Cell constr) a a

-- | Like <a>_Cell1</a> and as <a>asCell</a>.
asCell1 :: (constr a, Typeable a, Typeable f) => Prism (Cell1 f constr) (Cell1 f constr) (f a) (f a)

-- | <h1>Traversals</h1>
traverseCell :: Functor f => (forall a. (constr a, Typeable a) => a -> f a) -> Cell constr -> f (Cell constr)
traverseCell' :: (Functor f, HasCell c (Cell constr)) => (forall a. (constr a, Typeable a) => a -> f a) -> c -> f c
traverseCell1 :: Functor f => (forall a. (constr a, Typeable a) => g a -> f (h a)) -> Cell1 g constr -> f (Cell1 h constr)
traverseCell1' :: (Functor f, HasCell c (Cell1 g constr)) => (forall a. (constr a, Typeable a) => g a -> f (g a)) -> c -> f c
mapCell :: (forall a. (constr a, Typeable a) => a -> a) -> Cell constr -> Cell constr
mapCell' :: HasCell c (Cell constr) => (forall a. (constr a, Typeable a) => a -> a) -> c -> c
readCell1 :: (forall a. (constr a, Typeable a) => f a -> r) -> Cell1 f constr -> r
readCell1' :: HasCell c (Cell1 f constr) => (forall a. (constr a, Typeable a) => f a -> r) -> c -> r
readCell :: (forall a. (constr a, Typeable a) => a -> r) -> Cell constr -> r
readCell' :: HasCell c (Cell constr) => (forall a. (constr a, Typeable a) => a -> r) -> c -> r

-- | <h1>Combinators =</h1>
apply2Cells :: Functor f => (forall a. (constr a, Typeable a) => a -> a -> f a) -> f (Cell constr) -> Cell constr -> Cell constr -> f (Cell constr)
apply2Cells' :: (Functor f, HasCell c (Cell constr)) => (forall a. (constr a, Typeable a) => a -> a -> f a) -> f c -> c -> c -> f c
apply2Cells1 :: (Functor f, Typeable g) => (forall a. (constr a, Typeable a) => g a -> g a -> f (g a)) -> f (Cell1 g constr) -> Cell1 g constr -> Cell1 g constr -> f (Cell1 g constr)
apply2Cells1' :: (Functor f, Typeable g, HasCell c (Cell1 g constr)) => (forall a. (constr a, Typeable a) => g a -> g a -> f (g a)) -> f c -> c -> c -> f c
map2Cells :: (forall a. (constr a, Typeable a) => a -> a -> a) -> Cell constr -> Cell constr -> Cell constr -> Cell constr
map2Cells' :: HasCell c (Cell constr) => (forall a. (constr a, Typeable a) => a -> a -> a) -> c -> c -> c -> c
map2Cells1 :: (forall a. (constr a, Typeable a) => a -> a -> a) -> Cell constr -> Cell constr -> Cell constr -> Cell constr
map2Cells1' :: HasCell c (Cell constr) => (forall a. (constr a, Typeable a) => a -> a -> a) -> c -> c -> c -> c
read2CellsWith :: (forall a. (constr a, Typeable a) => a -> a -> r) -> r -> Cell constr -> Cell constr -> r
read2CellsWith' :: HasCell c (Cell constr) => (forall a. (constr a, Typeable a) => a -> a -> r) -> r -> c -> c -> r
read2Cells1With :: Typeable f => (forall a. (constr a, Typeable a) => f a -> f a -> r) -> r -> Cell1 f constr -> Cell1 f constr -> r
read2Cells1With' :: (HasCell c (Cell1 f constr), Typeable f) => (forall a. (constr a, Typeable a) => f a -> f a -> r) -> r -> c -> c -> r

-- | <h1>Heterogenous Combinators</h1>
read2CellsH :: (forall a b. (constr a, Typeable a, constr b, Typeable b) => a -> b -> r) -> Cell constr -> Cell constr -> r
read2CellsH' :: HasCell c (Cell constr) => (forall a b. (constr a, Typeable a, constr b, Typeable b) => a -> b -> r) -> c -> c -> r
read2Cells1H :: (forall a b. (constr a, Typeable a, constr b, Typeable b) => f a -> f b -> r) -> Cell1 f constr -> Cell1 f constr -> r
read2Cells1H' :: (forall a b. (constr a, Typeable a, constr b, Typeable b) => f a -> f b -> r) -> Cell1 f constr -> Cell1 f constr -> r

-- | <h1>Comparing the content of cells</h1>
cell1Equal :: Typeable f => (forall a. constr a => f a -> f a -> Bool) -> Cell1 f constr -> Cell1 f constr -> Bool
cell1Equal' :: (HasCell c (Cell1 f constr), Typeable f) => (forall a. constr a => f a -> f a -> Bool) -> c -> c -> Bool
cellEqual :: (forall a. constr a => a -> a -> Bool) -> Cell constr -> Cell constr -> Bool
cellEqual' :: HasCell c (Cell constr) => (forall a. constr a => a -> a -> Bool) -> c -> c -> Bool
cellCompare :: (forall a. constr a => a -> a -> Ordering) -> Cell constr -> Cell constr -> Ordering
cellCompare' :: HasCell c (Cell constr) => (forall a. constr a => a -> a -> Ordering) -> c -> c -> Ordering
cell1Compare :: (Typeable f) => (forall a. constr a => f a -> f a -> Ordering) -> Cell1 f constr -> Cell1 f constr -> Ordering
cell1Compare' :: (HasCell c (Cell1 f constr), Typeable f) => (forall a. constr a => f a -> f a -> Ordering) -> c -> c -> Ordering

-- | <h1>Creating Lenses</h1>
cellLens :: Functor f => (forall a. constr a => LensLike' f a b) -> LensLike' f (Cell constr) b
cellLens' :: (HasCell c (Cell constr), Functor f) => (forall a. constr a => LensLike' f a b) -> LensLike' f c b
cell1Lens :: Functor f => (forall a. constr a => LensLike' f (g a) b) -> LensLike' f (Cell1 g constr) b
cell1Lens' :: (HasCell c (Cell1 g constr), Functor f) => (forall a. constr a => LensLike' f (g a) b) -> LensLike' f c b

-- | <h1>QuickCheck Helpers</h1>
arbitraryCell :: Name -> ExpQ
arbitraryCell' :: Name -> [TypeQ] -> ExpQ
arbitraryInstanceOf :: Name -> Name -> ExpQ
arbitraryInstanceOf' :: Name -> Name -> [TypeQ] -> ExpQ

-- | <h1>Utilities</h1>
--   
--   Utility function to facilitate the implementation of <a>Cell</a> |
--   functions in terms of <a>Cell1</a> functions.
onIdentity :: (a -> b -> c) -> Identity a -> Identity b -> c

-- | <h1>Properties</h1>
--   
--   Wrapping two values in cells does not change their equality
prop_consistent_equal :: (Eq a, Typeable a) => a -> a -> Property

-- | Wrapping two values in cells does not change their relative order
prop_consistent_compare :: (Ord a, Typeable a) => a -> a -> Property

-- | Check all the QuickCheck properties.
run_tests :: IO Bool
instance Data.Existential.HasCell (Data.Existential.Cell1 f constr) (Data.Existential.Cell1 f constr)