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

-- | Dependent sum type
--   
--   A dependent sum is a generalization of a particular way of thinking
--   about the Either type. Either a b can be thought of
--   as a 2-tuple (tag, value), where the value of the tag
--   determines the type of the value. In particular, either tag =
--   Left and value :: a or tag = Right and
--   value :: b.
--   
--   This package allows you to define your own dependent sum types by
--   using your own "tag" types.
@package dependent-sum
@version 0.7.2.0

module Data.Dependent.Sum

-- | A basic dependent sum type where the first component is a tag that
--   specifies the type of the second. For example, think of a GADT such
--   as:
--   
--   
--   data Tag a where
--      AString :: Tag String
--      AnInt   :: Tag Int
--      Rec     :: Tag (DSum Tag Identity)
--   
--   
--   Then we can write expressions where the RHS of
--   (:=>) has different types depending on the
--   Tag constructor used. Here are some expressions of type
--   DSum Tag Identity:
--   
--   
--   AString :=> Identity "hello!"
--   AnInt   :=> Identity 42
--   
--   
--   Often, the f we choose has an Applicative instance,
--   and we can use the helper function (==>). The
--   following expressions all have the type Applicative f => DSum
--   Tag f:
--   
--   
--   AString ==> "hello!"
--   AnInt   ==> 42
--   
--   
--   We can write functions that consume DSum Tag f values by
--   matching, such as:
--   
--   
--   toString :: DSum Tag Identity -> String
--   toString (AString :=> Identity str) = str
--   toString (AnInt   :=> Identity int) = show int
--   toString (Rec     :=> Identity sum) = toString sum
--   
--   
--   The (:=>) constructor and (==>)
--   helper are chosen to resemble the (key => value)
--   construction for dictionary entries in many dynamic languages. The
--   :=> and ==> operators have very low precedence
--   and bind to the right, making repeated use of these operators behave
--   as you'd expect:
--   
--   
--   -- Parses as: Rec ==> (AnInt ==> (3 + 4))
--   -- Has type: Applicative f => DSum Tag f
--   Rec ==> AnInt ==> 3 + 4
--   
--   
--   The precedence of these operators is just above that of $, so
--   foo bar $ AString ==> "eep" is equivalent to foo bar
--   (AString ==> "eep").
--   
--   To use the Eq, Ord, Read, and Show
--   instances for DSum tag f, you will need an
--   ArgDict instance for your tag type. Use deriveArgDict
--   from the constraints-extras package to generate this
--   instance.
data DSum (tag :: k -> Type) (f :: k -> Type)
(:=>) :: !tag a -> f a -> DSum (tag :: k -> Type) (f :: k -> Type)
infixr 1 :=>

-- | Convenience helper. Uses pure to lift a into f
--   a.
(==>) :: forall (f :: Type -> Type) tag a. Applicative f => tag a -> a -> DSum tag f
infixr 1 ==>

-- | Deprecated: Instead of 'ShowTag tag f', use '(GShow tag, Has' Show
--   tag f)'
type ShowTag (tag :: k' -> Type) (f :: k' -> Type) = (GShow tag, Has' Show tag f)
showTaggedPrec :: forall {k'} tag f (a :: k'). (GShow tag, Has' Show tag f) => tag a -> Int -> f a -> ShowS

-- | Deprecated: Instead of 'ReadTag tag f', use '(GRead tag, Has' Read
--   tag f)'
type ReadTag (tag :: k' -> Type) (f :: k' -> Type) = (GRead tag, Has' Read tag f)
readTaggedPrec :: forall {k'} tag f (a :: k'). (GRead tag, Has' Read tag f) => tag a -> Int -> ReadS (f a)

-- | Deprecated: Instead of 'EqTag tag f', use '(GEq tag, Has' Eq tag
--   f)'
type EqTag (tag :: k' -> Type) (f :: k' -> Type) = (GEq tag, Has' Eq tag f)
eqTaggedPrec :: forall {k'} tag f (a :: k'). (GEq tag, Has' Eq tag f) => tag a -> tag a -> f a -> f a -> Bool
eqTagged :: forall {k'} tag f (a :: k'). EqTag tag f => tag a -> tag a -> f a -> f a -> Bool

-- | Deprecated: Instead of 'OrdTag tag f', use '(GCompare tag, Has' Eq
--   tag f, Has' Ord tag f)'
type OrdTag (tag :: k' -> Type) (f :: k' -> Type) = (GCompare tag, Has' Eq tag f, Has' Ord tag f)
compareTaggedPrec :: forall {k'} tag f (a :: k'). (GCompare tag, Has' Eq tag f, Has' Ord tag f) => tag a -> tag a -> f a -> f a -> Ordering
compareTagged :: forall {k'} tag f (a :: k'). OrdTag tag f => tag a -> tag a -> f a -> f a -> Ordering
instance forall k (tag :: k -> *) (f :: k -> *). (Data.GADT.Internal.GEq tag, Data.Constraint.Extras.Has' GHC.Classes.Eq tag f) => GHC.Classes.Eq (Data.Dependent.Sum.DSum tag f)
instance forall k (tag :: k -> *) (f :: k -> *). (Data.GADT.Internal.GCompare tag, Data.Constraint.Extras.Has' GHC.Classes.Eq tag f, Data.Constraint.Extras.Has' GHC.Classes.Ord tag f) => GHC.Classes.Ord (Data.Dependent.Sum.DSum tag f)
instance forall k (tag :: k -> *) (f :: k -> *). (Data.GADT.Internal.GRead tag, Data.Constraint.Extras.Has' GHC.Internal.Read.Read tag f) => GHC.Internal.Read.Read (Data.Dependent.Sum.DSum tag f)
instance forall k (tag :: k -> *) (f :: k -> *). (Data.GADT.Internal.GShow tag, Data.Constraint.Extras.Has' GHC.Internal.Show.Show tag f) => GHC.Internal.Show.Show (Data.Dependent.Sum.DSum tag f)
