{-# LANGUAGE DeriveDataTypeable #-}
{-# LANGUAGE DeriveFoldable #-}
{-# LANGUAGE DeriveTraversable #-}
{-# LANGUAGE DeriveFunctor #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE CPP #-}

-----------------------------------------------------------------------------
-- |
-- Module      :  Language.Haskell.Exts.Syntax
-- Copyright   :  (c) Niklas Broberg 2004-2009,
--                (c) The GHC Team, 1997-2000
-- License     :  BSD-style (see the file LICENSE.txt)
--
-- Maintainer  :  Niklas Broberg, d00nibro@chalmers.se
-- Stability   :  stable
-- Portability :  portable
--
-- A suite of datatypes describing the (semi-concrete) abstract syntax of Haskell 98
-- <http://www.haskell.org/onlinereport/> plus registered extensions, including:
--
--   * multi-parameter type classes with functional dependencies (MultiParamTypeClasses, FunctionalDependencies)
--
--   * parameters of type class assertions are unrestricted (FlexibleContexts)
--
--   * 'forall' types as universal and existential quantification (RankNTypes, ExistentialQuantification, etc)
--
--   * pattern guards (PatternGuards)
--
--   * implicit parameters (ImplicitParameters)
--
--   * generalised algebraic data types (GADTs)
--
--   * template haskell (TemplateHaskell)
--
--   * empty data type declarations (EmptyDataDecls)
--
--   * unboxed tuples (UnboxedTuples)
--
--   * regular patterns (RegularPatterns)
--
--   * HSP-style XML expressions and patterns (XmlSyntax)
--
-- All nodes in the syntax tree are annotated with something of a user-definable data type.
-- When parsing, this annotation will contain information about the source location that the
-- particular node comes from.
--
-----------------------------------------------------------------------------

module Language.Haskell.Exts.Syntax (
    -- * Modules
    Module(..), ModuleHead(..), WarningText(..), ExportSpecList(..), ExportSpec(..),
    EWildcard(..),
    ImportDecl(..), ImportSpecList(..), ImportSpec(..), Assoc(..), Namespace(..),
    -- * Declarations
    Decl(..), DeclHead(..), InstRule(..), InstHead(..), Binds(..), IPBind(..), PatternSynDirection(..),
    InjectivityInfo(..), ResultSig(..),
    -- ** Type classes and instances
    ClassDecl(..), InstDecl(..), Deriving(..), DerivStrategy(..),
    -- ** Data type declarations
    DataOrNew(..), ConDecl(..), FieldDecl(..), QualConDecl(..), GadtDecl(..), BangType(..),
    Unpackedness(..),
    -- ** Function bindings
    Match(..), Rhs(..), GuardedRhs(..),
    -- * Class Assertions and Contexts
    Context(..), FunDep(..), Asst(..),
    -- * Types
    Type(..), Boxed(..), Kind, TyVarBind(..), Promoted(..),
    TypeEqn (..),
    -- * Expressions
    Exp(..), Stmt(..), QualStmt(..), FieldUpdate(..),
    Alt(..), XAttr(..),
    -- * Patterns
    Pat(..), PatField(..), PXAttr(..), RPat(..), RPatOp(..),
    -- * Literals
    Literal(..), Sign(..),
    -- * Variables, Constructors and Operators
    ModuleName(..), QName(..), Name(..), QOp(..), Op(..),
    SpecialCon(..), CName(..), IPName(..), XName(..), Role(..),
    MaybePromotedName(..),

    -- * Template Haskell
    Bracket(..), Splice(..),

    -- * FFI
    Safety(..), CallConv(..),

    -- * Pragmas
    ModulePragma(..), Tool(..), Overlap(..),
    Rule(..), RuleVar(..), Activation(..),
    Annotation(..), BooleanFormula(..),

    -- * Builtin names

    -- ** Modules
    prelude_mod, main_mod,
    -- ** Main function of a program
    main_name,
    -- ** Constructors
    unit_con_name, tuple_con_name, list_con_name, list_cons_name, unboxed_singleton_con_name,
    unit_con, tuple_con, unboxed_singleton_con,
    -- ** Special identifiers
    as_name, qualified_name, hiding_name, minus_name, bang_name, dot_name, star_name,
    export_name, safe_name, unsafe_name, interruptible_name, threadsafe_name,
    stdcall_name, ccall_name, cplusplus_name, dotnet_name, jvm_name, js_name,
    javascript_name, capi_name, forall_name, family_name, role_name, hole_name,
    stock_name, anyclass_name, via_name,
    -- ** Type constructors
    unit_tycon_name, fun_tycon_name, list_tycon_name, tuple_tycon_name, unboxed_singleton_tycon_name,
    unit_tycon, fun_tycon, list_tycon, tuple_tycon, unboxed_singleton_tycon,

    -- * Source coordinates
    -- SrcLoc(..),

    -- * Annotated trees
    Annotated(..), (=~=),
  ) where

import Prelude hiding (id)

import Data.Data
import GHC.Generics (Generic)
#if __GLASGOW_HASKELL__ < 710
import Data.Foldable (Foldable)
import Data.Traversable (Traversable)
#endif

-- | The name of a Haskell module.
data ModuleName l = ModuleName l String
  deriving (ModuleName l -> ModuleName l -> Bool
(ModuleName l -> ModuleName l -> Bool)
-> (ModuleName l -> ModuleName l -> Bool) -> Eq (ModuleName l)
forall l. Eq l => ModuleName l -> ModuleName l -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall l. Eq l => ModuleName l -> ModuleName l -> Bool
== :: ModuleName l -> ModuleName l -> Bool
$c/= :: forall l. Eq l => ModuleName l -> ModuleName l -> Bool
/= :: ModuleName l -> ModuleName l -> Bool
Eq,Eq (ModuleName l)
Eq (ModuleName l) =>
(ModuleName l -> ModuleName l -> Ordering)
-> (ModuleName l -> ModuleName l -> Bool)
-> (ModuleName l -> ModuleName l -> Bool)
-> (ModuleName l -> ModuleName l -> Bool)
-> (ModuleName l -> ModuleName l -> Bool)
-> (ModuleName l -> ModuleName l -> ModuleName l)
-> (ModuleName l -> ModuleName l -> ModuleName l)
-> Ord (ModuleName l)
ModuleName l -> ModuleName l -> Bool
ModuleName l -> ModuleName l -> Ordering
ModuleName l -> ModuleName l -> ModuleName l
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall l. Ord l => Eq (ModuleName l)
forall l. Ord l => ModuleName l -> ModuleName l -> Bool
forall l. Ord l => ModuleName l -> ModuleName l -> Ordering
forall l. Ord l => ModuleName l -> ModuleName l -> ModuleName l
$ccompare :: forall l. Ord l => ModuleName l -> ModuleName l -> Ordering
compare :: ModuleName l -> ModuleName l -> Ordering
$c< :: forall l. Ord l => ModuleName l -> ModuleName l -> Bool
< :: ModuleName l -> ModuleName l -> Bool
$c<= :: forall l. Ord l => ModuleName l -> ModuleName l -> Bool
<= :: ModuleName l -> ModuleName l -> Bool
$c> :: forall l. Ord l => ModuleName l -> ModuleName l -> Bool
> :: ModuleName l -> ModuleName l -> Bool
$c>= :: forall l. Ord l => ModuleName l -> ModuleName l -> Bool
>= :: ModuleName l -> ModuleName l -> Bool
$cmax :: forall l. Ord l => ModuleName l -> ModuleName l -> ModuleName l
max :: ModuleName l -> ModuleName l -> ModuleName l
$cmin :: forall l. Ord l => ModuleName l -> ModuleName l -> ModuleName l
min :: ModuleName l -> ModuleName l -> ModuleName l
Ord,Int -> ModuleName l -> ShowS
[ModuleName l] -> ShowS
ModuleName l -> String
(Int -> ModuleName l -> ShowS)
-> (ModuleName l -> String)
-> ([ModuleName l] -> ShowS)
-> Show (ModuleName l)
forall l. Show l => Int -> ModuleName l -> ShowS
forall l. Show l => [ModuleName l] -> ShowS
forall l. Show l => ModuleName l -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall l. Show l => Int -> ModuleName l -> ShowS
showsPrec :: Int -> ModuleName l -> ShowS
$cshow :: forall l. Show l => ModuleName l -> String
show :: ModuleName l -> String
$cshowList :: forall l. Show l => [ModuleName l] -> ShowS
showList :: [ModuleName l] -> ShowS
Show,Typeable,Typeable (ModuleName l)
Typeable (ModuleName l) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> ModuleName l -> c (ModuleName l))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (ModuleName l))
-> (ModuleName l -> Constr)
-> (ModuleName l -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (ModuleName l)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (ModuleName l)))
-> ((forall b. Data b => b -> b) -> ModuleName l -> ModuleName l)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ModuleName l -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ModuleName l -> r)
-> (forall u. (forall d. Data d => d -> u) -> ModuleName l -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> ModuleName l -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ModuleName l -> m (ModuleName l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ModuleName l -> m (ModuleName l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ModuleName l -> m (ModuleName l))
-> Data (ModuleName l)
ModuleName l -> Constr
ModuleName l -> DataType
(forall b. Data b => b -> b) -> ModuleName l -> ModuleName l
forall l. Data l => Typeable (ModuleName l)
forall l. Data l => ModuleName l -> Constr
forall l. Data l => ModuleName l -> DataType
forall l.
Data l =>
(forall b. Data b => b -> b) -> ModuleName l -> ModuleName l
forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> ModuleName l -> u
forall l u.
Data l =>
(forall d. Data d => d -> u) -> ModuleName l -> [u]
forall l r r'.
Data l =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ModuleName l -> r
forall l r r'.
Data l =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ModuleName l -> r
forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d) -> ModuleName l -> m (ModuleName l)
forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> ModuleName l -> m (ModuleName l)
forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ModuleName l)
forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ModuleName l -> c (ModuleName l)
forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (ModuleName l))
forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ModuleName l))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> ModuleName l -> u
forall u. (forall d. Data d => d -> u) -> ModuleName l -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ModuleName l -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ModuleName l -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ModuleName l -> m (ModuleName l)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ModuleName l -> m (ModuleName l)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ModuleName l)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ModuleName l -> c (ModuleName l)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (ModuleName l))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ModuleName l))
$cgfoldl :: forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ModuleName l -> c (ModuleName l)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ModuleName l -> c (ModuleName l)
$cgunfold :: forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ModuleName l)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ModuleName l)
$ctoConstr :: forall l. Data l => ModuleName l -> Constr
toConstr :: ModuleName l -> Constr
$cdataTypeOf :: forall l. Data l => ModuleName l -> DataType
dataTypeOf :: ModuleName l -> DataType
$cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (ModuleName l))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (ModuleName l))
$cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ModuleName l))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ModuleName l))
$cgmapT :: forall l.
Data l =>
(forall b. Data b => b -> b) -> ModuleName l -> ModuleName l
gmapT :: (forall b. Data b => b -> b) -> ModuleName l -> ModuleName l
$cgmapQl :: forall l r r'.
Data l =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ModuleName l -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ModuleName l -> r
$cgmapQr :: forall l r r'.
Data l =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ModuleName l -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ModuleName l -> r
$cgmapQ :: forall l u.
Data l =>
(forall d. Data d => d -> u) -> ModuleName l -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> ModuleName l -> [u]
$cgmapQi :: forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> ModuleName l -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ModuleName l -> u
$cgmapM :: forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d) -> ModuleName l -> m (ModuleName l)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ModuleName l -> m (ModuleName l)
$cgmapMp :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> ModuleName l -> m (ModuleName l)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ModuleName l -> m (ModuleName l)
$cgmapMo :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> ModuleName l -> m (ModuleName l)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ModuleName l -> m (ModuleName l)
Data,(forall m. Monoid m => ModuleName m -> m)
-> (forall m a. Monoid m => (a -> m) -> ModuleName a -> m)
-> (forall m a. Monoid m => (a -> m) -> ModuleName a -> m)
-> (forall a b. (a -> b -> b) -> b -> ModuleName a -> b)
-> (forall a b. (a -> b -> b) -> b -> ModuleName a -> b)
-> (forall b a. (b -> a -> b) -> b -> ModuleName a -> b)
-> (forall b a. (b -> a -> b) -> b -> ModuleName a -> b)
-> (forall a. (a -> a -> a) -> ModuleName a -> a)
-> (forall a. (a -> a -> a) -> ModuleName a -> a)
-> (forall a. ModuleName a -> [a])
-> (forall a. ModuleName a -> Bool)
-> (forall a. ModuleName a -> Int)
-> (forall a. Eq a => a -> ModuleName a -> Bool)
-> (forall a. Ord a => ModuleName a -> a)
-> (forall a. Ord a => ModuleName a -> a)
-> (forall a. Num a => ModuleName a -> a)
-> (forall a. Num a => ModuleName a -> a)
-> Foldable ModuleName
forall a. Eq a => a -> ModuleName a -> Bool
forall a. Num a => ModuleName a -> a
forall a. Ord a => ModuleName a -> a
forall m. Monoid m => ModuleName m -> m
forall a. ModuleName a -> Bool
forall a. ModuleName a -> Int
forall a. ModuleName a -> [a]
forall a. (a -> a -> a) -> ModuleName a -> a
forall m a. Monoid m => (a -> m) -> ModuleName a -> m
forall b a. (b -> a -> b) -> b -> ModuleName a -> b
forall a b. (a -> b -> b) -> b -> ModuleName a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall m. Monoid m => ModuleName m -> m
fold :: forall m. Monoid m => ModuleName m -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> ModuleName a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> ModuleName a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> ModuleName a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> ModuleName a -> m
$cfoldr :: forall a b. (a -> b -> b) -> b -> ModuleName a -> b
foldr :: forall a b. (a -> b -> b) -> b -> ModuleName a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> ModuleName a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> ModuleName a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> ModuleName a -> b
foldl :: forall b a. (b -> a -> b) -> b -> ModuleName a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> ModuleName a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> ModuleName a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> ModuleName a -> a
foldr1 :: forall a. (a -> a -> a) -> ModuleName a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> ModuleName a -> a
foldl1 :: forall a. (a -> a -> a) -> ModuleName a -> a
$ctoList :: forall a. ModuleName a -> [a]
toList :: forall a. ModuleName a -> [a]
$cnull :: forall a. ModuleName a -> Bool
null :: forall a. ModuleName a -> Bool
$clength :: forall a. ModuleName a -> Int
length :: forall a. ModuleName a -> Int
$celem :: forall a. Eq a => a -> ModuleName a -> Bool
elem :: forall a. Eq a => a -> ModuleName a -> Bool
$cmaximum :: forall a. Ord a => ModuleName a -> a
maximum :: forall a. Ord a => ModuleName a -> a
$cminimum :: forall a. Ord a => ModuleName a -> a
minimum :: forall a. Ord a => ModuleName a -> a
$csum :: forall a. Num a => ModuleName a -> a
sum :: forall a. Num a => ModuleName a -> a
$cproduct :: forall a. Num a => ModuleName a -> a
product :: forall a. Num a => ModuleName a -> a
Foldable,Functor ModuleName
Foldable ModuleName
(Functor ModuleName, Foldable ModuleName) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> ModuleName a -> f (ModuleName b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    ModuleName (f a) -> f (ModuleName a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> ModuleName a -> m (ModuleName b))
-> (forall (m :: * -> *) a.
    Monad m =>
    ModuleName (m a) -> m (ModuleName a))
-> Traversable ModuleName
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a.
Monad m =>
ModuleName (m a) -> m (ModuleName a)
forall (f :: * -> *) a.
Applicative f =>
ModuleName (f a) -> f (ModuleName a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> ModuleName a -> m (ModuleName b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> ModuleName a -> f (ModuleName b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> ModuleName a -> f (ModuleName b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> ModuleName a -> f (ModuleName b)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
ModuleName (f a) -> f (ModuleName a)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
ModuleName (f a) -> f (ModuleName a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> ModuleName a -> m (ModuleName b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> ModuleName a -> m (ModuleName b)
$csequence :: forall (m :: * -> *) a.
Monad m =>
ModuleName (m a) -> m (ModuleName a)
sequence :: forall (m :: * -> *) a.
Monad m =>
ModuleName (m a) -> m (ModuleName a)
Traversable,(forall a b. (a -> b) -> ModuleName a -> ModuleName b)
-> (forall a b. a -> ModuleName b -> ModuleName a)
-> Functor ModuleName
forall a b. a -> ModuleName b -> ModuleName a
forall a b. (a -> b) -> ModuleName a -> ModuleName b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> ModuleName a -> ModuleName b
fmap :: forall a b. (a -> b) -> ModuleName a -> ModuleName b
$c<$ :: forall a b. a -> ModuleName b -> ModuleName a
<$ :: forall a b. a -> ModuleName b -> ModuleName a
Functor,(forall x. ModuleName l -> Rep (ModuleName l) x)
-> (forall x. Rep (ModuleName l) x -> ModuleName l)
-> Generic (ModuleName l)
forall x. Rep (ModuleName l) x -> ModuleName l
forall x. ModuleName l -> Rep (ModuleName l) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall l x. Rep (ModuleName l) x -> ModuleName l
forall l x. ModuleName l -> Rep (ModuleName l) x
$cfrom :: forall l x. ModuleName l -> Rep (ModuleName l) x
from :: forall x. ModuleName l -> Rep (ModuleName l) x
$cto :: forall l x. Rep (ModuleName l) x -> ModuleName l
to :: forall x. Rep (ModuleName l) x -> ModuleName l
Generic)

-- | Constructors with special syntax.
-- These names are never qualified, and always refer to builtin type or
-- data constructors.
data SpecialCon l
    = UnitCon l             -- ^ unit type and data constructor @()@
    | ListCon l             -- ^ list type and data constructor @[]@
    | FunCon  l             -- ^ function type constructor @->@
    | TupleCon l Boxed Int  -- ^ /n/-ary tuple type and data
                            --   constructors @(,)@ etc, possibly boxed @(\#,\#)@
    | Cons l                -- ^ list data constructor @(:)@
    | UnboxedSingleCon l    -- ^ unboxed singleton tuple constructor @(\# \#)@
    | ExprHole l            -- ^ An expression hole _
  deriving (SpecialCon l -> SpecialCon l -> Bool
(SpecialCon l -> SpecialCon l -> Bool)
-> (SpecialCon l -> SpecialCon l -> Bool) -> Eq (SpecialCon l)
forall l. Eq l => SpecialCon l -> SpecialCon l -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall l. Eq l => SpecialCon l -> SpecialCon l -> Bool
== :: SpecialCon l -> SpecialCon l -> Bool
$c/= :: forall l. Eq l => SpecialCon l -> SpecialCon l -> Bool
/= :: SpecialCon l -> SpecialCon l -> Bool
Eq,Eq (SpecialCon l)
Eq (SpecialCon l) =>
(SpecialCon l -> SpecialCon l -> Ordering)
-> (SpecialCon l -> SpecialCon l -> Bool)
-> (SpecialCon l -> SpecialCon l -> Bool)
-> (SpecialCon l -> SpecialCon l -> Bool)
-> (SpecialCon l -> SpecialCon l -> Bool)
-> (SpecialCon l -> SpecialCon l -> SpecialCon l)
-> (SpecialCon l -> SpecialCon l -> SpecialCon l)
-> Ord (SpecialCon l)
SpecialCon l -> SpecialCon l -> Bool
SpecialCon l -> SpecialCon l -> Ordering
SpecialCon l -> SpecialCon l -> SpecialCon l
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall l. Ord l => Eq (SpecialCon l)
forall l. Ord l => SpecialCon l -> SpecialCon l -> Bool
forall l. Ord l => SpecialCon l -> SpecialCon l -> Ordering
forall l. Ord l => SpecialCon l -> SpecialCon l -> SpecialCon l
$ccompare :: forall l. Ord l => SpecialCon l -> SpecialCon l -> Ordering
compare :: SpecialCon l -> SpecialCon l -> Ordering
$c< :: forall l. Ord l => SpecialCon l -> SpecialCon l -> Bool
< :: SpecialCon l -> SpecialCon l -> Bool
$c<= :: forall l. Ord l => SpecialCon l -> SpecialCon l -> Bool
<= :: SpecialCon l -> SpecialCon l -> Bool
$c> :: forall l. Ord l => SpecialCon l -> SpecialCon l -> Bool
> :: SpecialCon l -> SpecialCon l -> Bool
$c>= :: forall l. Ord l => SpecialCon l -> SpecialCon l -> Bool
>= :: SpecialCon l -> SpecialCon l -> Bool
$cmax :: forall l. Ord l => SpecialCon l -> SpecialCon l -> SpecialCon l
max :: SpecialCon l -> SpecialCon l -> SpecialCon l
$cmin :: forall l. Ord l => SpecialCon l -> SpecialCon l -> SpecialCon l
min :: SpecialCon l -> SpecialCon l -> SpecialCon l
Ord,Int -> SpecialCon l -> ShowS
[SpecialCon l] -> ShowS
SpecialCon l -> String
(Int -> SpecialCon l -> ShowS)
-> (SpecialCon l -> String)
-> ([SpecialCon l] -> ShowS)
-> Show (SpecialCon l)
forall l. Show l => Int -> SpecialCon l -> ShowS
forall l. Show l => [SpecialCon l] -> ShowS
forall l. Show l => SpecialCon l -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall l. Show l => Int -> SpecialCon l -> ShowS
showsPrec :: Int -> SpecialCon l -> ShowS
$cshow :: forall l. Show l => SpecialCon l -> String
show :: SpecialCon l -> String
$cshowList :: forall l. Show l => [SpecialCon l] -> ShowS
showList :: [SpecialCon l] -> ShowS
Show,Typeable,Typeable (SpecialCon l)
Typeable (SpecialCon l) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> SpecialCon l -> c (SpecialCon l))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (SpecialCon l))
-> (SpecialCon l -> Constr)
-> (SpecialCon l -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (SpecialCon l)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (SpecialCon l)))
-> ((forall b. Data b => b -> b) -> SpecialCon l -> SpecialCon l)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> SpecialCon l -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> SpecialCon l -> r)
-> (forall u. (forall d. Data d => d -> u) -> SpecialCon l -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> SpecialCon l -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> SpecialCon l -> m (SpecialCon l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> SpecialCon l -> m (SpecialCon l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> SpecialCon l -> m (SpecialCon l))
-> Data (SpecialCon l)
SpecialCon l -> Constr
SpecialCon l -> DataType
(forall b. Data b => b -> b) -> SpecialCon l -> SpecialCon l
forall l. Data l => Typeable (SpecialCon l)
forall l. Data l => SpecialCon l -> Constr
forall l. Data l => SpecialCon l -> DataType
forall l.
Data l =>
(forall b. Data b => b -> b) -> SpecialCon l -> SpecialCon l
forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> SpecialCon l -> u
forall l u.
Data l =>
(forall d. Data d => d -> u) -> SpecialCon l -> [u]
forall l r r'.
Data l =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SpecialCon l -> r
forall l r r'.
Data l =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SpecialCon l -> r
forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d) -> SpecialCon l -> m (SpecialCon l)
forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> SpecialCon l -> m (SpecialCon l)
forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (SpecialCon l)
forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SpecialCon l -> c (SpecialCon l)
forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (SpecialCon l))
forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (SpecialCon l))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> SpecialCon l -> u
forall u. (forall d. Data d => d -> u) -> SpecialCon l -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SpecialCon l -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SpecialCon l -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SpecialCon l -> m (SpecialCon l)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SpecialCon l -> m (SpecialCon l)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (SpecialCon l)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SpecialCon l -> c (SpecialCon l)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (SpecialCon l))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (SpecialCon l))
$cgfoldl :: forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SpecialCon l -> c (SpecialCon l)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SpecialCon l -> c (SpecialCon l)
$cgunfold :: forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (SpecialCon l)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (SpecialCon l)
$ctoConstr :: forall l. Data l => SpecialCon l -> Constr
toConstr :: SpecialCon l -> Constr
$cdataTypeOf :: forall l. Data l => SpecialCon l -> DataType
dataTypeOf :: SpecialCon l -> DataType
$cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (SpecialCon l))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (SpecialCon l))
$cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (SpecialCon l))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (SpecialCon l))
$cgmapT :: forall l.
Data l =>
(forall b. Data b => b -> b) -> SpecialCon l -> SpecialCon l
gmapT :: (forall b. Data b => b -> b) -> SpecialCon l -> SpecialCon l
$cgmapQl :: forall l r r'.
Data l =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SpecialCon l -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SpecialCon l -> r
$cgmapQr :: forall l r r'.
Data l =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SpecialCon l -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SpecialCon l -> r
$cgmapQ :: forall l u.
Data l =>
(forall d. Data d => d -> u) -> SpecialCon l -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> SpecialCon l -> [u]
$cgmapQi :: forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> SpecialCon l -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> SpecialCon l -> u
$cgmapM :: forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d) -> SpecialCon l -> m (SpecialCon l)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SpecialCon l -> m (SpecialCon l)
$cgmapMp :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> SpecialCon l -> m (SpecialCon l)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SpecialCon l -> m (SpecialCon l)
$cgmapMo :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> SpecialCon l -> m (SpecialCon l)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SpecialCon l -> m (SpecialCon l)
Data,(forall m. Monoid m => SpecialCon m -> m)
-> (forall m a. Monoid m => (a -> m) -> SpecialCon a -> m)
-> (forall m a. Monoid m => (a -> m) -> SpecialCon a -> m)
-> (forall a b. (a -> b -> b) -> b -> SpecialCon a -> b)
-> (forall a b. (a -> b -> b) -> b -> SpecialCon a -> b)
-> (forall b a. (b -> a -> b) -> b -> SpecialCon a -> b)
-> (forall b a. (b -> a -> b) -> b -> SpecialCon a -> b)
-> (forall a. (a -> a -> a) -> SpecialCon a -> a)
-> (forall a. (a -> a -> a) -> SpecialCon a -> a)
-> (forall a. SpecialCon a -> [a])
-> (forall a. SpecialCon a -> Bool)
-> (forall a. SpecialCon a -> Int)
-> (forall a. Eq a => a -> SpecialCon a -> Bool)
-> (forall a. Ord a => SpecialCon a -> a)
-> (forall a. Ord a => SpecialCon a -> a)
-> (forall a. Num a => SpecialCon a -> a)
-> (forall a. Num a => SpecialCon a -> a)
-> Foldable SpecialCon
forall a. Eq a => a -> SpecialCon a -> Bool
forall a. Num a => SpecialCon a -> a
forall a. Ord a => SpecialCon a -> a
forall m. Monoid m => SpecialCon m -> m
forall a. SpecialCon a -> Bool
forall a. SpecialCon a -> Int
forall a. SpecialCon a -> [a]
forall a. (a -> a -> a) -> SpecialCon a -> a
forall m a. Monoid m => (a -> m) -> SpecialCon a -> m
forall b a. (b -> a -> b) -> b -> SpecialCon a -> b
forall a b. (a -> b -> b) -> b -> SpecialCon a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall m. Monoid m => SpecialCon m -> m
fold :: forall m. Monoid m => SpecialCon m -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> SpecialCon a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> SpecialCon a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> SpecialCon a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> SpecialCon a -> m
$cfoldr :: forall a b. (a -> b -> b) -> b -> SpecialCon a -> b
foldr :: forall a b. (a -> b -> b) -> b -> SpecialCon a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> SpecialCon a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> SpecialCon a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> SpecialCon a -> b
foldl :: forall b a. (b -> a -> b) -> b -> SpecialCon a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> SpecialCon a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> SpecialCon a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> SpecialCon a -> a
foldr1 :: forall a. (a -> a -> a) -> SpecialCon a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> SpecialCon a -> a
foldl1 :: forall a. (a -> a -> a) -> SpecialCon a -> a
$ctoList :: forall a. SpecialCon a -> [a]
toList :: forall a. SpecialCon a -> [a]
$cnull :: forall a. SpecialCon a -> Bool
null :: forall a. SpecialCon a -> Bool
$clength :: forall a. SpecialCon a -> Int
length :: forall a. SpecialCon a -> Int
$celem :: forall a. Eq a => a -> SpecialCon a -> Bool
elem :: forall a. Eq a => a -> SpecialCon a -> Bool
$cmaximum :: forall a. Ord a => SpecialCon a -> a
maximum :: forall a. Ord a => SpecialCon a -> a
$cminimum :: forall a. Ord a => SpecialCon a -> a
minimum :: forall a. Ord a => SpecialCon a -> a
$csum :: forall a. Num a => SpecialCon a -> a
sum :: forall a. Num a => SpecialCon a -> a
$cproduct :: forall a. Num a => SpecialCon a -> a
product :: forall a. Num a => SpecialCon a -> a
Foldable,Functor SpecialCon
Foldable SpecialCon
(Functor SpecialCon, Foldable SpecialCon) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> SpecialCon a -> f (SpecialCon b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    SpecialCon (f a) -> f (SpecialCon a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> SpecialCon a -> m (SpecialCon b))
-> (forall (m :: * -> *) a.
    Monad m =>
    SpecialCon (m a) -> m (SpecialCon a))
-> Traversable SpecialCon
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a.
Monad m =>
SpecialCon (m a) -> m (SpecialCon a)
forall (f :: * -> *) a.
Applicative f =>
SpecialCon (f a) -> f (SpecialCon a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> SpecialCon a -> m (SpecialCon b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> SpecialCon a -> f (SpecialCon b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> SpecialCon a -> f (SpecialCon b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> SpecialCon a -> f (SpecialCon b)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
SpecialCon (f a) -> f (SpecialCon a)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
SpecialCon (f a) -> f (SpecialCon a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> SpecialCon a -> m (SpecialCon b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> SpecialCon a -> m (SpecialCon b)
$csequence :: forall (m :: * -> *) a.
Monad m =>
SpecialCon (m a) -> m (SpecialCon a)
sequence :: forall (m :: * -> *) a.
Monad m =>
SpecialCon (m a) -> m (SpecialCon a)
Traversable,(forall a b. (a -> b) -> SpecialCon a -> SpecialCon b)
-> (forall a b. a -> SpecialCon b -> SpecialCon a)
-> Functor SpecialCon
forall a b. a -> SpecialCon b -> SpecialCon a
forall a b. (a -> b) -> SpecialCon a -> SpecialCon b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> SpecialCon a -> SpecialCon b
fmap :: forall a b. (a -> b) -> SpecialCon a -> SpecialCon b
$c<$ :: forall a b. a -> SpecialCon b -> SpecialCon a
<$ :: forall a b. a -> SpecialCon b -> SpecialCon a
Functor,(forall x. SpecialCon l -> Rep (SpecialCon l) x)
-> (forall x. Rep (SpecialCon l) x -> SpecialCon l)
-> Generic (SpecialCon l)
forall x. Rep (SpecialCon l) x -> SpecialCon l
forall x. SpecialCon l -> Rep (SpecialCon l) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall l x. Rep (SpecialCon l) x -> SpecialCon l
forall l x. SpecialCon l -> Rep (SpecialCon l) x
$cfrom :: forall l x. SpecialCon l -> Rep (SpecialCon l) x
from :: forall x. SpecialCon l -> Rep (SpecialCon l) x
$cto :: forall l x. Rep (SpecialCon l) x -> SpecialCon l
to :: forall x. Rep (SpecialCon l) x -> SpecialCon l
Generic)

-- | This type is used to represent qualified variables, and also
-- qualified constructors.
data QName l
    = Qual    l (ModuleName l) (Name l) -- ^ name qualified with a module name
    | UnQual  l                (Name l) -- ^ unqualified local name
    | Special l (SpecialCon l)          -- ^ built-in constructor with special syntax
  deriving (QName l -> QName l -> Bool
(QName l -> QName l -> Bool)
-> (QName l -> QName l -> Bool) -> Eq (QName l)
forall l. Eq l => QName l -> QName l -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall l. Eq l => QName l -> QName l -> Bool
== :: QName l -> QName l -> Bool
$c/= :: forall l. Eq l => QName l -> QName l -> Bool
/= :: QName l -> QName l -> Bool
Eq,Eq (QName l)
Eq (QName l) =>
(QName l -> QName l -> Ordering)
-> (QName l -> QName l -> Bool)
-> (QName l -> QName l -> Bool)
-> (QName l -> QName l -> Bool)
-> (QName l -> QName l -> Bool)
-> (QName l -> QName l -> QName l)
-> (QName l -> QName l -> QName l)
-> Ord (QName l)
QName l -> QName l -> Bool
QName l -> QName l -> Ordering
QName l -> QName l -> QName l
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall l. Ord l => Eq (QName l)
forall l. Ord l => QName l -> QName l -> Bool
forall l. Ord l => QName l -> QName l -> Ordering
forall l. Ord l => QName l -> QName l -> QName l
$ccompare :: forall l. Ord l => QName l -> QName l -> Ordering
compare :: QName l -> QName l -> Ordering
$c< :: forall l. Ord l => QName l -> QName l -> Bool
< :: QName l -> QName l -> Bool
$c<= :: forall l. Ord l => QName l -> QName l -> Bool
<= :: QName l -> QName l -> Bool
$c> :: forall l. Ord l => QName l -> QName l -> Bool
> :: QName l -> QName l -> Bool
$c>= :: forall l. Ord l => QName l -> QName l -> Bool
>= :: QName l -> QName l -> Bool
$cmax :: forall l. Ord l => QName l -> QName l -> QName l
max :: QName l -> QName l -> QName l
$cmin :: forall l. Ord l => QName l -> QName l -> QName l
min :: QName l -> QName l -> QName l
Ord,Int -> QName l -> ShowS
[QName l] -> ShowS
QName l -> String
(Int -> QName l -> ShowS)
-> (QName l -> String) -> ([QName l] -> ShowS) -> Show (QName l)
forall l. Show l => Int -> QName l -> ShowS
forall l. Show l => [QName l] -> ShowS
forall l. Show l => QName l -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall l. Show l => Int -> QName l -> ShowS
showsPrec :: Int -> QName l -> ShowS
$cshow :: forall l. Show l => QName l -> String
show :: QName l -> String
$cshowList :: forall l. Show l => [QName l] -> ShowS
showList :: [QName l] -> ShowS
Show,Typeable,Typeable (QName l)
Typeable (QName l) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> QName l -> c (QName l))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (QName l))
-> (QName l -> Constr)
-> (QName l -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (QName l)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (QName l)))
-> ((forall b. Data b => b -> b) -> QName l -> QName l)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> QName l -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> QName l -> r)
-> (forall u. (forall d. Data d => d -> u) -> QName l -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> QName l -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> QName l -> m (QName l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> QName l -> m (QName l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> QName l -> m (QName l))
-> Data (QName l)
QName l -> Constr
QName l -> DataType
(forall b. Data b => b -> b) -> QName l -> QName l
forall l. Data l => Typeable (QName l)
forall l. Data l => QName l -> Constr
forall l. Data l => QName l -> DataType
forall l.
Data l =>
(forall b. Data b => b -> b) -> QName l -> QName l
forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> QName l -> u
forall l u.
Data l =>
(forall d. Data d => d -> u) -> QName l -> [u]
forall l r r'.
Data l =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> QName l -> r
forall l r r'.
Data l =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> QName l -> r
forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d) -> QName l -> m (QName l)
forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> QName l -> m (QName l)
forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (QName l)
forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> QName l -> c (QName l)
forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (QName l))
forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (QName l))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> QName l -> u
forall u. (forall d. Data d => d -> u) -> QName l -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> QName l -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> QName l -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> QName l -> m (QName l)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> QName l -> m (QName l)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (QName l)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> QName l -> c (QName l)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (QName l))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (QName l))
$cgfoldl :: forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> QName l -> c (QName l)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> QName l -> c (QName l)
$cgunfold :: forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (QName l)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (QName l)
$ctoConstr :: forall l. Data l => QName l -> Constr
toConstr :: QName l -> Constr
$cdataTypeOf :: forall l. Data l => QName l -> DataType
dataTypeOf :: QName l -> DataType
$cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (QName l))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (QName l))
$cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (QName l))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (QName l))
$cgmapT :: forall l.
Data l =>
(forall b. Data b => b -> b) -> QName l -> QName l
gmapT :: (forall b. Data b => b -> b) -> QName l -> QName l
$cgmapQl :: forall l r r'.
Data l =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> QName l -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> QName l -> r
$cgmapQr :: forall l r r'.
Data l =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> QName l -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> QName l -> r
$cgmapQ :: forall l u.
Data l =>
(forall d. Data d => d -> u) -> QName l -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> QName l -> [u]
$cgmapQi :: forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> QName l -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> QName l -> u
$cgmapM :: forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d) -> QName l -> m (QName l)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> QName l -> m (QName l)
$cgmapMp :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> QName l -> m (QName l)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> QName l -> m (QName l)
$cgmapMo :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> QName l -> m (QName l)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> QName l -> m (QName l)
Data,(forall m. Monoid m => QName m -> m)
-> (forall m a. Monoid m => (a -> m) -> QName a -> m)
-> (forall m a. Monoid m => (a -> m) -> QName a -> m)
-> (forall a b. (a -> b -> b) -> b -> QName a -> b)
-> (forall a b. (a -> b -> b) -> b -> QName a -> b)
-> (forall b a. (b -> a -> b) -> b -> QName a -> b)
-> (forall b a. (b -> a -> b) -> b -> QName a -> b)
-> (forall a. (a -> a -> a) -> QName a -> a)
-> (forall a. (a -> a -> a) -> QName a -> a)
-> (forall a. QName a -> [a])
-> (forall a. QName a -> Bool)
-> (forall a. QName a -> Int)
-> (forall a. Eq a => a -> QName a -> Bool)
-> (forall a. Ord a => QName a -> a)
-> (forall a. Ord a => QName a -> a)
-> (forall a. Num a => QName a -> a)
-> (forall a. Num a => QName a -> a)
-> Foldable QName
forall a. Eq a => a -> QName a -> Bool
forall a. Num a => QName a -> a
forall a. Ord a => QName a -> a
forall m. Monoid m => QName m -> m
forall a. QName a -> Bool
forall a. QName a -> Int
forall a. QName a -> [a]
forall a. (a -> a -> a) -> QName a -> a
forall m a. Monoid m => (a -> m) -> QName a -> m
forall b a. (b -> a -> b) -> b -> QName a -> b
forall a b. (a -> b -> b) -> b -> QName a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall m. Monoid m => QName m -> m
fold :: forall m. Monoid m => QName m -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> QName a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> QName a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> QName a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> QName a -> m
$cfoldr :: forall a b. (a -> b -> b) -> b -> QName a -> b
foldr :: forall a b. (a -> b -> b) -> b -> QName a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> QName a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> QName a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> QName a -> b
foldl :: forall b a. (b -> a -> b) -> b -> QName a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> QName a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> QName a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> QName a -> a
foldr1 :: forall a. (a -> a -> a) -> QName a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> QName a -> a
foldl1 :: forall a. (a -> a -> a) -> QName a -> a
$ctoList :: forall a. QName a -> [a]
toList :: forall a. QName a -> [a]
$cnull :: forall a. QName a -> Bool
null :: forall a. QName a -> Bool
$clength :: forall a. QName a -> Int
length :: forall a. QName a -> Int
$celem :: forall a. Eq a => a -> QName a -> Bool
elem :: forall a. Eq a => a -> QName a -> Bool
$cmaximum :: forall a. Ord a => QName a -> a
maximum :: forall a. Ord a => QName a -> a
$cminimum :: forall a. Ord a => QName a -> a
minimum :: forall a. Ord a => QName a -> a
$csum :: forall a. Num a => QName a -> a
sum :: forall a. Num a => QName a -> a
$cproduct :: forall a. Num a => QName a -> a
product :: forall a. Num a => QName a -> a
Foldable,Functor QName
Foldable QName
(Functor QName, Foldable QName) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> QName a -> f (QName b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    QName (f a) -> f (QName a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> QName a -> m (QName b))
-> (forall (m :: * -> *) a. Monad m => QName (m a) -> m (QName a))
-> Traversable QName
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a. Monad m => QName (m a) -> m (QName a)
forall (f :: * -> *) a. Applicative f => QName (f a) -> f (QName a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> QName a -> m (QName b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> QName a -> f (QName b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> QName a -> f (QName b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> QName a -> f (QName b)
$csequenceA :: forall (f :: * -> *) a. Applicative f => QName (f a) -> f (QName a)
sequenceA :: forall (f :: * -> *) a. Applicative f => QName (f a) -> f (QName a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> QName a -> m (QName b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> QName a -> m (QName b)
$csequence :: forall (m :: * -> *) a. Monad m => QName (m a) -> m (QName a)
sequence :: forall (m :: * -> *) a. Monad m => QName (m a) -> m (QName a)
Traversable,(forall a b. (a -> b) -> QName a -> QName b)
-> (forall a b. a -> QName b -> QName a) -> Functor QName
forall a b. a -> QName b -> QName a
forall a b. (a -> b) -> QName a -> QName b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> QName a -> QName b
fmap :: forall a b. (a -> b) -> QName a -> QName b
$c<$ :: forall a b. a -> QName b -> QName a
<$ :: forall a b. a -> QName b -> QName a
Functor,(forall x. QName l -> Rep (QName l) x)
-> (forall x. Rep (QName l) x -> QName l) -> Generic (QName l)
forall x. Rep (QName l) x -> QName l
forall x. QName l -> Rep (QName l) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall l x. Rep (QName l) x -> QName l
forall l x. QName l -> Rep (QName l) x
$cfrom :: forall l x. QName l -> Rep (QName l) x
from :: forall x. QName l -> Rep (QName l) x
$cto :: forall l x. Rep (QName l) x -> QName l
to :: forall x. Rep (QName l) x -> QName l
Generic)

-- | This type is used to represent variables, and also constructors.
data Name l
    = Ident  l String   -- ^ /varid/ or /conid/.
    | Symbol l String   -- ^ /varsym/ or /consym/
  deriving (Name l -> Name l -> Bool
(Name l -> Name l -> Bool)
-> (Name l -> Name l -> Bool) -> Eq (Name l)
forall l. Eq l => Name l -> Name l -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall l. Eq l => Name l -> Name l -> Bool
== :: Name l -> Name l -> Bool
$c/= :: forall l. Eq l => Name l -> Name l -> Bool
/= :: Name l -> Name l -> Bool
Eq,Eq (Name l)
Eq (Name l) =>
(Name l -> Name l -> Ordering)
-> (Name l -> Name l -> Bool)
-> (Name l -> Name l -> Bool)
-> (Name l -> Name l -> Bool)
-> (Name l -> Name l -> Bool)
-> (Name l -> Name l -> Name l)
-> (Name l -> Name l -> Name l)
-> Ord (Name l)
Name l -> Name l -> Bool
Name l -> Name l -> Ordering
Name l -> Name l -> Name l
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall l. Ord l => Eq (Name l)
forall l. Ord l => Name l -> Name l -> Bool
forall l. Ord l => Name l -> Name l -> Ordering
forall l. Ord l => Name l -> Name l -> Name l
$ccompare :: forall l. Ord l => Name l -> Name l -> Ordering
compare :: Name l -> Name l -> Ordering
$c< :: forall l. Ord l => Name l -> Name l -> Bool
< :: Name l -> Name l -> Bool
$c<= :: forall l. Ord l => Name l -> Name l -> Bool
<= :: Name l -> Name l -> Bool
$c> :: forall l. Ord l => Name l -> Name l -> Bool
> :: Name l -> Name l -> Bool
$c>= :: forall l. Ord l => Name l -> Name l -> Bool
>= :: Name l -> Name l -> Bool
$cmax :: forall l. Ord l => Name l -> Name l -> Name l
max :: Name l -> Name l -> Name l
$cmin :: forall l. Ord l => Name l -> Name l -> Name l
min :: Name l -> Name l -> Name l
Ord,Int -> Name l -> ShowS
[Name l] -> ShowS
Name l -> String
(Int -> Name l -> ShowS)
-> (Name l -> String) -> ([Name l] -> ShowS) -> Show (Name l)
forall l. Show l => Int -> Name l -> ShowS
forall l. Show l => [Name l] -> ShowS
forall l. Show l => Name l -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall l. Show l => Int -> Name l -> ShowS
showsPrec :: Int -> Name l -> ShowS
$cshow :: forall l. Show l => Name l -> String
show :: Name l -> String
$cshowList :: forall l. Show l => [Name l] -> ShowS
showList :: [Name l] -> ShowS
Show,Typeable,Typeable (Name l)
Typeable (Name l) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Name l -> c (Name l))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Name l))
-> (Name l -> Constr)
-> (Name l -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Name l)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Name l)))
-> ((forall b. Data b => b -> b) -> Name l -> Name l)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Name l -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Name l -> r)
-> (forall u. (forall d. Data d => d -> u) -> Name l -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Name l -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Name l -> m (Name l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Name l -> m (Name l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Name l -> m (Name l))
-> Data (Name l)
Name l -> Constr
Name l -> DataType
(forall b. Data b => b -> b) -> Name l -> Name l
forall l. Data l => Typeable (Name l)
forall l. Data l => Name l -> Constr
forall l. Data l => Name l -> DataType
forall l.
Data l =>
(forall b. Data b => b -> b) -> Name l -> Name l
forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> Name l -> u
forall l u. Data l => (forall d. Data d => d -> u) -> Name l -> [u]
forall l r r'.
Data l =>
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Name l -> r
forall l r r'.
Data l =>
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Name l -> r
forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d) -> Name l -> m (Name l)
forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Name l -> m (Name l)
forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Name l)
forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Name l -> c (Name l)
forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Name l))
forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Name l))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Name l -> u
forall u. (forall d. Data d => d -> u) -> Name l -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Name l -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Name l -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Name l -> m (Name l)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Name l -> m (Name l)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Name l)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Name l -> c (Name l)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Name l))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Name l))
$cgfoldl :: forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Name l -> c (Name l)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Name l -> c (Name l)
$cgunfold :: forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Name l)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Name l)
$ctoConstr :: forall l. Data l => Name l -> Constr
toConstr :: Name l -> Constr
$cdataTypeOf :: forall l. Data l => Name l -> DataType
dataTypeOf :: Name l -> DataType
$cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Name l))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Name l))
$cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Name l))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Name l))
$cgmapT :: forall l.
Data l =>
(forall b. Data b => b -> b) -> Name l -> Name l
gmapT :: (forall b. Data b => b -> b) -> Name l -> Name l
$cgmapQl :: forall l r r'.
Data l =>
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Name l -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Name l -> r
$cgmapQr :: forall l r r'.
Data l =>
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Name l -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Name l -> r
$cgmapQ :: forall l u. Data l => (forall d. Data d => d -> u) -> Name l -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Name l -> [u]
$cgmapQi :: forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> Name l -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Name l -> u
$cgmapM :: forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d) -> Name l -> m (Name l)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Name l -> m (Name l)
$cgmapMp :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Name l -> m (Name l)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Name l -> m (Name l)
$cgmapMo :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Name l -> m (Name l)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Name l -> m (Name l)
Data,(forall m. Monoid m => Name m -> m)
-> (forall m a. Monoid m => (a -> m) -> Name a -> m)
-> (forall m a. Monoid m => (a -> m) -> Name a -> m)
-> (forall a b. (a -> b -> b) -> b -> Name a -> b)
-> (forall a b. (a -> b -> b) -> b -> Name a -> b)
-> (forall b a. (b -> a -> b) -> b -> Name a -> b)
-> (forall b a. (b -> a -> b) -> b -> Name a -> b)
-> (forall a. (a -> a -> a) -> Name a -> a)
-> (forall a. (a -> a -> a) -> Name a -> a)
-> (forall a. Name a -> [a])
-> (forall a. Name a -> Bool)
-> (forall a. Name a -> Int)
-> (forall a. Eq a => a -> Name a -> Bool)
-> (forall a. Ord a => Name a -> a)
-> (forall a. Ord a => Name a -> a)
-> (forall a. Num a => Name a -> a)
-> (forall a. Num a => Name a -> a)
-> Foldable Name
forall a. Eq a => a -> Name a -> Bool
forall a. Num a => Name a -> a
forall a. Ord a => Name a -> a
forall m. Monoid m => Name m -> m
forall a. Name a -> Bool
forall a. Name a -> Int
forall a. Name a -> [a]
forall a. (a -> a -> a) -> Name a -> a
forall m a. Monoid m => (a -> m) -> Name a -> m
forall b a. (b -> a -> b) -> b -> Name a -> b
forall a b. (a -> b -> b) -> b -> Name a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall m. Monoid m => Name m -> m
fold :: forall m. Monoid m => Name m -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> Name a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> Name a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> Name a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> Name a -> m
$cfoldr :: forall a b. (a -> b -> b) -> b -> Name a -> b
foldr :: forall a b. (a -> b -> b) -> b -> Name a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> Name a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> Name a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> Name a -> b
foldl :: forall b a. (b -> a -> b) -> b -> Name a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> Name a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> Name a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> Name a -> a
foldr1 :: forall a. (a -> a -> a) -> Name a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> Name a -> a
foldl1 :: forall a. (a -> a -> a) -> Name a -> a
$ctoList :: forall a. Name a -> [a]
toList :: forall a. Name a -> [a]
$cnull :: forall a. Name a -> Bool
null :: forall a. Name a -> Bool
$clength :: forall a. Name a -> Int
length :: forall a. Name a -> Int
$celem :: forall a. Eq a => a -> Name a -> Bool
elem :: forall a. Eq a => a -> Name a -> Bool
$cmaximum :: forall a. Ord a => Name a -> a
maximum :: forall a. Ord a => Name a -> a
$cminimum :: forall a. Ord a => Name a -> a
minimum :: forall a. Ord a => Name a -> a
$csum :: forall a. Num a => Name a -> a
sum :: forall a. Num a => Name a -> a
$cproduct :: forall a. Num a => Name a -> a
product :: forall a. Num a => Name a -> a
Foldable,Functor Name
Foldable Name
(Functor Name, Foldable Name) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> Name a -> f (Name b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    Name (f a) -> f (Name a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Name a -> m (Name b))
-> (forall (m :: * -> *) a. Monad m => Name (m a) -> m (Name a))
-> Traversable Name
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a. Monad m => Name (m a) -> m (Name a)
forall (f :: * -> *) a. Applicative f => Name (f a) -> f (Name a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Name a -> m (Name b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Name a -> f (Name b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Name a -> f (Name b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Name a -> f (Name b)
$csequenceA :: forall (f :: * -> *) a. Applicative f => Name (f a) -> f (Name a)
sequenceA :: forall (f :: * -> *) a. Applicative f => Name (f a) -> f (Name a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Name a -> m (Name b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Name a -> m (Name b)
$csequence :: forall (m :: * -> *) a. Monad m => Name (m a) -> m (Name a)
sequence :: forall (m :: * -> *) a. Monad m => Name (m a) -> m (Name a)
Traversable,(forall a b. (a -> b) -> Name a -> Name b)
-> (forall a b. a -> Name b -> Name a) -> Functor Name
forall a b. a -> Name b -> Name a
forall a b. (a -> b) -> Name a -> Name b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> Name a -> Name b
fmap :: forall a b. (a -> b) -> Name a -> Name b
$c<$ :: forall a b. a -> Name b -> Name a
<$ :: forall a b. a -> Name b -> Name a
Functor,(forall x. Name l -> Rep (Name l) x)
-> (forall x. Rep (Name l) x -> Name l) -> Generic (Name l)
forall x. Rep (Name l) x -> Name l
forall x. Name l -> Rep (Name l) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall l x. Rep (Name l) x -> Name l
forall l x. Name l -> Rep (Name l) x
$cfrom :: forall l x. Name l -> Rep (Name l) x
from :: forall x. Name l -> Rep (Name l) x
$cto :: forall l x. Rep (Name l) x -> Name l
to :: forall x. Rep (Name l) x -> Name l
Generic)

-- | An implicit parameter name.
data IPName l
    = IPDup l String -- ^ ?/ident/, non-linear implicit parameter
    | IPLin l String -- ^ %/ident/, linear implicit parameter
  deriving (IPName l -> IPName l -> Bool
(IPName l -> IPName l -> Bool)
-> (IPName l -> IPName l -> Bool) -> Eq (IPName l)
forall l. Eq l => IPName l -> IPName l -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall l. Eq l => IPName l -> IPName l -> Bool
== :: IPName l -> IPName l -> Bool
$c/= :: forall l. Eq l => IPName l -> IPName l -> Bool
/= :: IPName l -> IPName l -> Bool
Eq,Eq (IPName l)
Eq (IPName l) =>
(IPName l -> IPName l -> Ordering)
-> (IPName l -> IPName l -> Bool)
-> (IPName l -> IPName l -> Bool)
-> (IPName l -> IPName l -> Bool)
-> (IPName l -> IPName l -> Bool)
-> (IPName l -> IPName l -> IPName l)
-> (IPName l -> IPName l -> IPName l)
-> Ord (IPName l)
IPName l -> IPName l -> Bool
IPName l -> IPName l -> Ordering
IPName l -> IPName l -> IPName l
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall l. Ord l => Eq (IPName l)
forall l. Ord l => IPName l -> IPName l -> Bool
forall l. Ord l => IPName l -> IPName l -> Ordering
forall l. Ord l => IPName l -> IPName l -> IPName l
$ccompare :: forall l. Ord l => IPName l -> IPName l -> Ordering
compare :: IPName l -> IPName l -> Ordering
$c< :: forall l. Ord l => IPName l -> IPName l -> Bool
< :: IPName l -> IPName l -> Bool
$c<= :: forall l. Ord l => IPName l -> IPName l -> Bool
<= :: IPName l -> IPName l -> Bool
$c> :: forall l. Ord l => IPName l -> IPName l -> Bool
> :: IPName l -> IPName l -> Bool
$c>= :: forall l. Ord l => IPName l -> IPName l -> Bool
>= :: IPName l -> IPName l -> Bool
$cmax :: forall l. Ord l => IPName l -> IPName l -> IPName l
max :: IPName l -> IPName l -> IPName l
$cmin :: forall l. Ord l => IPName l -> IPName l -> IPName l
min :: IPName l -> IPName l -> IPName l
Ord,Int -> IPName l -> ShowS
[IPName l] -> ShowS
IPName l -> String
(Int -> IPName l -> ShowS)
-> (IPName l -> String) -> ([IPName l] -> ShowS) -> Show (IPName l)
forall l. Show l => Int -> IPName l -> ShowS
forall l. Show l => [IPName l] -> ShowS
forall l. Show l => IPName l -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall l. Show l => Int -> IPName l -> ShowS
showsPrec :: Int -> IPName l -> ShowS
$cshow :: forall l. Show l => IPName l -> String
show :: IPName l -> String
$cshowList :: forall l. Show l => [IPName l] -> ShowS
showList :: [IPName l] -> ShowS
Show,Typeable,Typeable (IPName l)
Typeable (IPName l) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> IPName l -> c (IPName l))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (IPName l))
-> (IPName l -> Constr)
-> (IPName l -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (IPName l)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (IPName l)))
-> ((forall b. Data b => b -> b) -> IPName l -> IPName l)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> IPName l -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> IPName l -> r)
-> (forall u. (forall d. Data d => d -> u) -> IPName l -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> IPName l -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> IPName l -> m (IPName l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> IPName l -> m (IPName l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> IPName l -> m (IPName l))
-> Data (IPName l)
IPName l -> Constr
IPName l -> DataType
(forall b. Data b => b -> b) -> IPName l -> IPName l
forall l. Data l => Typeable (IPName l)
forall l. Data l => IPName l -> Constr
forall l. Data l => IPName l -> DataType
forall l.
Data l =>
(forall b. Data b => b -> b) -> IPName l -> IPName l
forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> IPName l -> u
forall l u.
Data l =>
(forall d. Data d => d -> u) -> IPName l -> [u]
forall l r r'.
Data l =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> IPName l -> r
forall l r r'.
Data l =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> IPName l -> r
forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d) -> IPName l -> m (IPName l)
forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> IPName l -> m (IPName l)
forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (IPName l)
forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> IPName l -> c (IPName l)
forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (IPName l))
forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (IPName l))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> IPName l -> u
forall u. (forall d. Data d => d -> u) -> IPName l -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> IPName l -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> IPName l -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> IPName l -> m (IPName l)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> IPName l -> m (IPName l)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (IPName l)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> IPName l -> c (IPName l)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (IPName l))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (IPName l))
$cgfoldl :: forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> IPName l -> c (IPName l)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> IPName l -> c (IPName l)
$cgunfold :: forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (IPName l)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (IPName l)
$ctoConstr :: forall l. Data l => IPName l -> Constr
toConstr :: IPName l -> Constr
$cdataTypeOf :: forall l. Data l => IPName l -> DataType
dataTypeOf :: IPName l -> DataType
$cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (IPName l))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (IPName l))
$cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (IPName l))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (IPName l))
$cgmapT :: forall l.
Data l =>
(forall b. Data b => b -> b) -> IPName l -> IPName l
gmapT :: (forall b. Data b => b -> b) -> IPName l -> IPName l
$cgmapQl :: forall l r r'.
Data l =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> IPName l -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> IPName l -> r
$cgmapQr :: forall l r r'.
Data l =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> IPName l -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> IPName l -> r
$cgmapQ :: forall l u.
Data l =>
(forall d. Data d => d -> u) -> IPName l -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> IPName l -> [u]
$cgmapQi :: forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> IPName l -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> IPName l -> u
$cgmapM :: forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d) -> IPName l -> m (IPName l)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> IPName l -> m (IPName l)
$cgmapMp :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> IPName l -> m (IPName l)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> IPName l -> m (IPName l)
$cgmapMo :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> IPName l -> m (IPName l)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> IPName l -> m (IPName l)
Data,(forall m. Monoid m => IPName m -> m)
-> (forall m a. Monoid m => (a -> m) -> IPName a -> m)
-> (forall m a. Monoid m => (a -> m) -> IPName a -> m)
-> (forall a b. (a -> b -> b) -> b -> IPName a -> b)
-> (forall a b. (a -> b -> b) -> b -> IPName a -> b)
-> (forall b a. (b -> a -> b) -> b -> IPName a -> b)
-> (forall b a. (b -> a -> b) -> b -> IPName a -> b)
-> (forall a. (a -> a -> a) -> IPName a -> a)
-> (forall a. (a -> a -> a) -> IPName a -> a)
-> (forall a. IPName a -> [a])
-> (forall a. IPName a -> Bool)
-> (forall a. IPName a -> Int)
-> (forall a. Eq a => a -> IPName a -> Bool)
-> (forall a. Ord a => IPName a -> a)
-> (forall a. Ord a => IPName a -> a)
-> (forall a. Num a => IPName a -> a)
-> (forall a. Num a => IPName a -> a)
-> Foldable IPName
forall a. Eq a => a -> IPName a -> Bool
forall a. Num a => IPName a -> a
forall a. Ord a => IPName a -> a
forall m. Monoid m => IPName m -> m
forall a. IPName a -> Bool
forall a. IPName a -> Int
forall a. IPName a -> [a]
forall a. (a -> a -> a) -> IPName a -> a
forall m a. Monoid m => (a -> m) -> IPName a -> m
forall b a. (b -> a -> b) -> b -> IPName a -> b
forall a b. (a -> b -> b) -> b -> IPName a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall m. Monoid m => IPName m -> m
fold :: forall m. Monoid m => IPName m -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> IPName a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> IPName a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> IPName a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> IPName a -> m
$cfoldr :: forall a b. (a -> b -> b) -> b -> IPName a -> b
foldr :: forall a b. (a -> b -> b) -> b -> IPName a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> IPName a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> IPName a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> IPName a -> b
foldl :: forall b a. (b -> a -> b) -> b -> IPName a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> IPName a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> IPName a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> IPName a -> a
foldr1 :: forall a. (a -> a -> a) -> IPName a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> IPName a -> a
foldl1 :: forall a. (a -> a -> a) -> IPName a -> a
$ctoList :: forall a. IPName a -> [a]
toList :: forall a. IPName a -> [a]
$cnull :: forall a. IPName a -> Bool
null :: forall a. IPName a -> Bool
$clength :: forall a. IPName a -> Int
length :: forall a. IPName a -> Int
$celem :: forall a. Eq a => a -> IPName a -> Bool
elem :: forall a. Eq a => a -> IPName a -> Bool
$cmaximum :: forall a. Ord a => IPName a -> a
maximum :: forall a. Ord a => IPName a -> a
$cminimum :: forall a. Ord a => IPName a -> a
minimum :: forall a. Ord a => IPName a -> a
$csum :: forall a. Num a => IPName a -> a
sum :: forall a. Num a => IPName a -> a
$cproduct :: forall a. Num a => IPName a -> a
product :: forall a. Num a => IPName a -> a
Foldable,Functor IPName
Foldable IPName
(Functor IPName, Foldable IPName) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> IPName a -> f (IPName b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    IPName (f a) -> f (IPName a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> IPName a -> m (IPName b))
-> (forall (m :: * -> *) a.
    Monad m =>
    IPName (m a) -> m (IPName a))
-> Traversable IPName
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a. Monad m => IPName (m a) -> m (IPName a)
forall (f :: * -> *) a.
Applicative f =>
IPName (f a) -> f (IPName a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> IPName a -> m (IPName b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> IPName a -> f (IPName b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> IPName a -> f (IPName b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> IPName a -> f (IPName b)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
IPName (f a) -> f (IPName a)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
IPName (f a) -> f (IPName a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> IPName a -> m (IPName b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> IPName a -> m (IPName b)
$csequence :: forall (m :: * -> *) a. Monad m => IPName (m a) -> m (IPName a)
sequence :: forall (m :: * -> *) a. Monad m => IPName (m a) -> m (IPName a)
Traversable,(forall a b. (a -> b) -> IPName a -> IPName b)
-> (forall a b. a -> IPName b -> IPName a) -> Functor IPName
forall a b. a -> IPName b -> IPName a
forall a b. (a -> b) -> IPName a -> IPName b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> IPName a -> IPName b
fmap :: forall a b. (a -> b) -> IPName a -> IPName b
$c<$ :: forall a b. a -> IPName b -> IPName a
<$ :: forall a b. a -> IPName b -> IPName a
Functor,(forall x. IPName l -> Rep (IPName l) x)
-> (forall x. Rep (IPName l) x -> IPName l) -> Generic (IPName l)
forall x. Rep (IPName l) x -> IPName l
forall x. IPName l -> Rep (IPName l) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall l x. Rep (IPName l) x -> IPName l
forall l x. IPName l -> Rep (IPName l) x
$cfrom :: forall l x. IPName l -> Rep (IPName l) x
from :: forall x. IPName l -> Rep (IPName l) x
$cto :: forall l x. Rep (IPName l) x -> IPName l
to :: forall x. Rep (IPName l) x -> IPName l
Generic)

-- | Possibly qualified infix operators (/qop/), appearing in expressions.
data QOp l
    = QVarOp l (QName l) -- ^ variable operator (/qvarop/)
    | QConOp l (QName l) -- ^ constructor operator (/qconop/)
  deriving (QOp l -> QOp l -> Bool
(QOp l -> QOp l -> Bool) -> (QOp l -> QOp l -> Bool) -> Eq (QOp l)
forall l. Eq l => QOp l -> QOp l -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall l. Eq l => QOp l -> QOp l -> Bool
== :: QOp l -> QOp l -> Bool
$c/= :: forall l. Eq l => QOp l -> QOp l -> Bool
/= :: QOp l -> QOp l -> Bool
Eq,Eq (QOp l)
Eq (QOp l) =>
(QOp l -> QOp l -> Ordering)
-> (QOp l -> QOp l -> Bool)
-> (QOp l -> QOp l -> Bool)
-> (QOp l -> QOp l -> Bool)
-> (QOp l -> QOp l -> Bool)
-> (QOp l -> QOp l -> QOp l)
-> (QOp l -> QOp l -> QOp l)
-> Ord (QOp l)
QOp l -> QOp l -> Bool
QOp l -> QOp l -> Ordering
QOp l -> QOp l -> QOp l
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall l. Ord l => Eq (QOp l)
forall l. Ord l => QOp l -> QOp l -> Bool
forall l. Ord l => QOp l -> QOp l -> Ordering
forall l. Ord l => QOp l -> QOp l -> QOp l
$ccompare :: forall l. Ord l => QOp l -> QOp l -> Ordering
compare :: QOp l -> QOp l -> Ordering
$c< :: forall l. Ord l => QOp l -> QOp l -> Bool
< :: QOp l -> QOp l -> Bool
$c<= :: forall l. Ord l => QOp l -> QOp l -> Bool
<= :: QOp l -> QOp l -> Bool
$c> :: forall l. Ord l => QOp l -> QOp l -> Bool
> :: QOp l -> QOp l -> Bool
$c>= :: forall l. Ord l => QOp l -> QOp l -> Bool
>= :: QOp l -> QOp l -> Bool
$cmax :: forall l. Ord l => QOp l -> QOp l -> QOp l
max :: QOp l -> QOp l -> QOp l
$cmin :: forall l. Ord l => QOp l -> QOp l -> QOp l
min :: QOp l -> QOp l -> QOp l
Ord,Int -> QOp l -> ShowS
[QOp l] -> ShowS
QOp l -> String
(Int -> QOp l -> ShowS)
-> (QOp l -> String) -> ([QOp l] -> ShowS) -> Show (QOp l)
forall l. Show l => Int -> QOp l -> ShowS
forall l. Show l => [QOp l] -> ShowS
forall l. Show l => QOp l -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall l. Show l => Int -> QOp l -> ShowS
showsPrec :: Int -> QOp l -> ShowS
$cshow :: forall l. Show l => QOp l -> String
show :: QOp l -> String
$cshowList :: forall l. Show l => [QOp l] -> ShowS
showList :: [QOp l] -> ShowS
Show,Typeable,Typeable (QOp l)
Typeable (QOp l) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> QOp l -> c (QOp l))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (QOp l))
-> (QOp l -> Constr)
-> (QOp l -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (QOp l)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (QOp l)))
-> ((forall b. Data b => b -> b) -> QOp l -> QOp l)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> QOp l -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> QOp l -> r)
-> (forall u. (forall d. Data d => d -> u) -> QOp l -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> QOp l -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> QOp l -> m (QOp l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> QOp l -> m (QOp l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> QOp l -> m (QOp l))
-> Data (QOp l)
QOp l -> Constr
QOp l -> DataType
(forall b. Data b => b -> b) -> QOp l -> QOp l
forall l. Data l => Typeable (QOp l)
forall l. Data l => QOp l -> Constr
forall l. Data l => QOp l -> DataType
forall l. Data l => (forall b. Data b => b -> b) -> QOp l -> QOp l
forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> QOp l -> u
forall l u. Data l => (forall d. Data d => d -> u) -> QOp l -> [u]
forall l r r'.
Data l =>
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> QOp l -> r
forall l r r'.
Data l =>
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> QOp l -> r
forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d) -> QOp l -> m (QOp l)
forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> QOp l -> m (QOp l)
forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (QOp l)
forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> QOp l -> c (QOp l)
forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (QOp l))
forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (QOp l))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> QOp l -> u
forall u. (forall d. Data d => d -> u) -> QOp l -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> QOp l -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> QOp l -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> QOp l -> m (QOp l)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> QOp l -> m (QOp l)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (QOp l)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> QOp l -> c (QOp l)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (QOp l))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (QOp l))
$cgfoldl :: forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> QOp l -> c (QOp l)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> QOp l -> c (QOp l)
$cgunfold :: forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (QOp l)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (QOp l)
$ctoConstr :: forall l. Data l => QOp l -> Constr
toConstr :: QOp l -> Constr
$cdataTypeOf :: forall l. Data l => QOp l -> DataType
dataTypeOf :: QOp l -> DataType
$cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (QOp l))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (QOp l))
$cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (QOp l))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (QOp l))
$cgmapT :: forall l. Data l => (forall b. Data b => b -> b) -> QOp l -> QOp l
gmapT :: (forall b. Data b => b -> b) -> QOp l -> QOp l
$cgmapQl :: forall l r r'.
Data l =>
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> QOp l -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> QOp l -> r
$cgmapQr :: forall l r r'.
Data l =>
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> QOp l -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> QOp l -> r
$cgmapQ :: forall l u. Data l => (forall d. Data d => d -> u) -> QOp l -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> QOp l -> [u]
$cgmapQi :: forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> QOp l -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> QOp l -> u
$cgmapM :: forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d) -> QOp l -> m (QOp l)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> QOp l -> m (QOp l)
$cgmapMp :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> QOp l -> m (QOp l)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> QOp l -> m (QOp l)
$cgmapMo :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> QOp l -> m (QOp l)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> QOp l -> m (QOp l)
Data,(forall m. Monoid m => QOp m -> m)
-> (forall m a. Monoid m => (a -> m) -> QOp a -> m)
-> (forall m a. Monoid m => (a -> m) -> QOp a -> m)
-> (forall a b. (a -> b -> b) -> b -> QOp a -> b)
-> (forall a b. (a -> b -> b) -> b -> QOp a -> b)
-> (forall b a. (b -> a -> b) -> b -> QOp a -> b)
-> (forall b a. (b -> a -> b) -> b -> QOp a -> b)
-> (forall a. (a -> a -> a) -> QOp a -> a)
-> (forall a. (a -> a -> a) -> QOp a -> a)
-> (forall a. QOp a -> [a])
-> (forall a. QOp a -> Bool)
-> (forall a. QOp a -> Int)
-> (forall a. Eq a => a -> QOp a -> Bool)
-> (forall a. Ord a => QOp a -> a)
-> (forall a. Ord a => QOp a -> a)
-> (forall a. Num a => QOp a -> a)
-> (forall a. Num a => QOp a -> a)
-> Foldable QOp
forall a. Eq a => a -> QOp a -> Bool
forall a. Num a => QOp a -> a
forall a. Ord a => QOp a -> a
forall m. Monoid m => QOp m -> m
forall a. QOp a -> Bool
forall a. QOp a -> Int
forall a. QOp a -> [a]
forall a. (a -> a -> a) -> QOp a -> a
forall m a. Monoid m => (a -> m) -> QOp a -> m
forall b a. (b -> a -> b) -> b -> QOp a -> b
forall a b. (a -> b -> b) -> b -> QOp a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall m. Monoid m => QOp m -> m
fold :: forall m. Monoid m => QOp m -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> QOp a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> QOp a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> QOp a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> QOp a -> m
$cfoldr :: forall a b. (a -> b -> b) -> b -> QOp a -> b
foldr :: forall a b. (a -> b -> b) -> b -> QOp a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> QOp a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> QOp a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> QOp a -> b
foldl :: forall b a. (b -> a -> b) -> b -> QOp a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> QOp a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> QOp a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> QOp a -> a
foldr1 :: forall a. (a -> a -> a) -> QOp a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> QOp a -> a
foldl1 :: forall a. (a -> a -> a) -> QOp a -> a
$ctoList :: forall a. QOp a -> [a]
toList :: forall a. QOp a -> [a]
$cnull :: forall a. QOp a -> Bool
null :: forall a. QOp a -> Bool
$clength :: forall a. QOp a -> Int
length :: forall a. QOp a -> Int
$celem :: forall a. Eq a => a -> QOp a -> Bool
elem :: forall a. Eq a => a -> QOp a -> Bool
$cmaximum :: forall a. Ord a => QOp a -> a
maximum :: forall a. Ord a => QOp a -> a
$cminimum :: forall a. Ord a => QOp a -> a
minimum :: forall a. Ord a => QOp a -> a
$csum :: forall a. Num a => QOp a -> a
sum :: forall a. Num a => QOp a -> a
$cproduct :: forall a. Num a => QOp a -> a
product :: forall a. Num a => QOp a -> a
Foldable,Functor QOp
Foldable QOp
(Functor QOp, Foldable QOp) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> QOp a -> f (QOp b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    QOp (f a) -> f (QOp a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> QOp a -> m (QOp b))
-> (forall (m :: * -> *) a. Monad m => QOp (m a) -> m (QOp a))
-> Traversable QOp
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a. Monad m => QOp (m a) -> m (QOp a)
forall (f :: * -> *) a. Applicative f => QOp (f a) -> f (QOp a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> QOp a -> m (QOp b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> QOp a -> f (QOp b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> QOp a -> f (QOp b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> QOp a -> f (QOp b)
$csequenceA :: forall (f :: * -> *) a. Applicative f => QOp (f a) -> f (QOp a)
sequenceA :: forall (f :: * -> *) a. Applicative f => QOp (f a) -> f (QOp a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> QOp a -> m (QOp b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> QOp a -> m (QOp b)
$csequence :: forall (m :: * -> *) a. Monad m => QOp (m a) -> m (QOp a)
sequence :: forall (m :: * -> *) a. Monad m => QOp (m a) -> m (QOp a)
Traversable,(forall a b. (a -> b) -> QOp a -> QOp b)
-> (forall a b. a -> QOp b -> QOp a) -> Functor QOp
forall a b. a -> QOp b -> QOp a
forall a b. (a -> b) -> QOp a -> QOp b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> QOp a -> QOp b
fmap :: forall a b. (a -> b) -> QOp a -> QOp b
$c<$ :: forall a b. a -> QOp b -> QOp a
<$ :: forall a b. a -> QOp b -> QOp a
Functor,(forall x. QOp l -> Rep (QOp l) x)
-> (forall x. Rep (QOp l) x -> QOp l) -> Generic (QOp l)
forall x. Rep (QOp l) x -> QOp l
forall x. QOp l -> Rep (QOp l) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall l x. Rep (QOp l) x -> QOp l
forall l x. QOp l -> Rep (QOp l) x
$cfrom :: forall l x. QOp l -> Rep (QOp l) x
from :: forall x. QOp l -> Rep (QOp l) x
$cto :: forall l x. Rep (QOp l) x -> QOp l
to :: forall x. Rep (QOp l) x -> QOp l
Generic)

-- | Operators appearing in @infix@ declarations are never qualified.
data Op l
    = VarOp l (Name l)    -- ^ variable operator (/varop/)
    | ConOp l (Name l)    -- ^ constructor operator (/conop/)
  deriving (Op l -> Op l -> Bool
(Op l -> Op l -> Bool) -> (Op l -> Op l -> Bool) -> Eq (Op l)
forall l. Eq l => Op l -> Op l -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall l. Eq l => Op l -> Op l -> Bool
== :: Op l -> Op l -> Bool
$c/= :: forall l. Eq l => Op l -> Op l -> Bool
/= :: Op l -> Op l -> Bool
Eq,Eq (Op l)
Eq (Op l) =>
(Op l -> Op l -> Ordering)
-> (Op l -> Op l -> Bool)
-> (Op l -> Op l -> Bool)
-> (Op l -> Op l -> Bool)
-> (Op l -> Op l -> Bool)
-> (Op l -> Op l -> Op l)
-> (Op l -> Op l -> Op l)
-> Ord (Op l)
Op l -> Op l -> Bool
Op l -> Op l -> Ordering
Op l -> Op l -> Op l
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall l. Ord l => Eq (Op l)
forall l. Ord l => Op l -> Op l -> Bool
forall l. Ord l => Op l -> Op l -> Ordering
forall l. Ord l => Op l -> Op l -> Op l
$ccompare :: forall l. Ord l => Op l -> Op l -> Ordering
compare :: Op l -> Op l -> Ordering
$c< :: forall l. Ord l => Op l -> Op l -> Bool
< :: Op l -> Op l -> Bool
$c<= :: forall l. Ord l => Op l -> Op l -> Bool
<= :: Op l -> Op l -> Bool
$c> :: forall l. Ord l => Op l -> Op l -> Bool
> :: Op l -> Op l -> Bool
$c>= :: forall l. Ord l => Op l -> Op l -> Bool
>= :: Op l -> Op l -> Bool
$cmax :: forall l. Ord l => Op l -> Op l -> Op l
max :: Op l -> Op l -> Op l
$cmin :: forall l. Ord l => Op l -> Op l -> Op l
min :: Op l -> Op l -> Op l
Ord,Int -> Op l -> ShowS
[Op l] -> ShowS
Op l -> String
(Int -> Op l -> ShowS)
-> (Op l -> String) -> ([Op l] -> ShowS) -> Show (Op l)
forall l. Show l => Int -> Op l -> ShowS
forall l. Show l => [Op l] -> ShowS
forall l. Show l => Op l -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall l. Show l => Int -> Op l -> ShowS
showsPrec :: Int -> Op l -> ShowS
$cshow :: forall l. Show l => Op l -> String
show :: Op l -> String
$cshowList :: forall l. Show l => [Op l] -> ShowS
showList :: [Op l] -> ShowS
Show,Typeable,Typeable (Op l)
Typeable (Op l) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Op l -> c (Op l))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Op l))
-> (Op l -> Constr)
-> (Op l -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Op l)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Op l)))
-> ((forall b. Data b => b -> b) -> Op l -> Op l)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Op l -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Op l -> r)
-> (forall u. (forall d. Data d => d -> u) -> Op l -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Op l -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Op l -> m (Op l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Op l -> m (Op l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Op l -> m (Op l))
-> Data (Op l)
Op l -> Constr
Op l -> DataType
(forall b. Data b => b -> b) -> Op l -> Op l
forall l. Data l => Typeable (Op l)
forall l. Data l => Op l -> Constr
forall l. Data l => Op l -> DataType
forall l. Data l => (forall b. Data b => b -> b) -> Op l -> Op l
forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> Op l -> u
forall l u. Data l => (forall d. Data d => d -> u) -> Op l -> [u]
forall l r r'.
Data l =>
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Op l -> r
forall l r r'.
Data l =>
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Op l -> r
forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d) -> Op l -> m (Op l)
forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Op l -> m (Op l)
forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Op l)
forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Op l -> c (Op l)
forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Op l))
forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Op l))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Op l -> u
forall u. (forall d. Data d => d -> u) -> Op l -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Op l -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Op l -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Op l -> m (Op l)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Op l -> m (Op l)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Op l)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Op l -> c (Op l)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Op l))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Op l))
$cgfoldl :: forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Op l -> c (Op l)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Op l -> c (Op l)
$cgunfold :: forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Op l)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Op l)
$ctoConstr :: forall l. Data l => Op l -> Constr
toConstr :: Op l -> Constr
$cdataTypeOf :: forall l. Data l => Op l -> DataType
dataTypeOf :: Op l -> DataType
$cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Op l))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Op l))
$cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Op l))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Op l))
$cgmapT :: forall l. Data l => (forall b. Data b => b -> b) -> Op l -> Op l
gmapT :: (forall b. Data b => b -> b) -> Op l -> Op l
$cgmapQl :: forall l r r'.
Data l =>
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Op l -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Op l -> r
$cgmapQr :: forall l r r'.
Data l =>
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Op l -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Op l -> r
$cgmapQ :: forall l u. Data l => (forall d. Data d => d -> u) -> Op l -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Op l -> [u]
$cgmapQi :: forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> Op l -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Op l -> u
$cgmapM :: forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d) -> Op l -> m (Op l)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Op l -> m (Op l)
$cgmapMp :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Op l -> m (Op l)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Op l -> m (Op l)
$cgmapMo :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Op l -> m (Op l)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Op l -> m (Op l)
Data,(forall m. Monoid m => Op m -> m)
-> (forall m a. Monoid m => (a -> m) -> Op a -> m)
-> (forall m a. Monoid m => (a -> m) -> Op a -> m)
-> (forall a b. (a -> b -> b) -> b -> Op a -> b)
-> (forall a b. (a -> b -> b) -> b -> Op a -> b)
-> (forall b a. (b -> a -> b) -> b -> Op a -> b)
-> (forall b a. (b -> a -> b) -> b -> Op a -> b)
-> (forall a. (a -> a -> a) -> Op a -> a)
-> (forall a. (a -> a -> a) -> Op a -> a)
-> (forall a. Op a -> [a])
-> (forall a. Op a -> Bool)
-> (forall a. Op a -> Int)
-> (forall a. Eq a => a -> Op a -> Bool)
-> (forall a. Ord a => Op a -> a)
-> (forall a. Ord a => Op a -> a)
-> (forall a. Num a => Op a -> a)
-> (forall a. Num a => Op a -> a)
-> Foldable Op
forall a. Eq a => a -> Op a -> Bool
forall a. Num a => Op a -> a
forall a. Ord a => Op a -> a
forall m. Monoid m => Op m -> m
forall a. Op a -> Bool
forall a. Op a -> Int
forall a. Op a -> [a]
forall a. (a -> a -> a) -> Op a -> a
forall m a. Monoid m => (a -> m) -> Op a -> m
forall b a. (b -> a -> b) -> b -> Op a -> b
forall a b. (a -> b -> b) -> b -> Op a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall m. Monoid m => Op m -> m
fold :: forall m. Monoid m => Op m -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> Op a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> Op a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> Op a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> Op a -> m
$cfoldr :: forall a b. (a -> b -> b) -> b -> Op a -> b
foldr :: forall a b. (a -> b -> b) -> b -> Op a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> Op a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> Op a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> Op a -> b
foldl :: forall b a. (b -> a -> b) -> b -> Op a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> Op a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> Op a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> Op a -> a
foldr1 :: forall a. (a -> a -> a) -> Op a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> Op a -> a
foldl1 :: forall a. (a -> a -> a) -> Op a -> a
$ctoList :: forall a. Op a -> [a]
toList :: forall a. Op a -> [a]
$cnull :: forall a. Op a -> Bool
null :: forall a. Op a -> Bool
$clength :: forall a. Op a -> Int
length :: forall a. Op a -> Int
$celem :: forall a. Eq a => a -> Op a -> Bool
elem :: forall a. Eq a => a -> Op a -> Bool
$cmaximum :: forall a. Ord a => Op a -> a
maximum :: forall a. Ord a => Op a -> a
$cminimum :: forall a. Ord a => Op a -> a
minimum :: forall a. Ord a => Op a -> a
$csum :: forall a. Num a => Op a -> a
sum :: forall a. Num a => Op a -> a
$cproduct :: forall a. Num a => Op a -> a
product :: forall a. Num a => Op a -> a
Foldable,Functor Op
Foldable Op
(Functor Op, Foldable Op) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> Op a -> f (Op b))
-> (forall (f :: * -> *) a. Applicative f => Op (f a) -> f (Op a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Op a -> m (Op b))
-> (forall (m :: * -> *) a. Monad m => Op (m a) -> m (Op a))
-> Traversable Op
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a. Monad m => Op (m a) -> m (Op a)
forall (f :: * -> *) a. Applicative f => Op (f a) -> f (Op a)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> Op a -> m (Op b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Op a -> f (Op b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Op a -> f (Op b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Op a -> f (Op b)
$csequenceA :: forall (f :: * -> *) a. Applicative f => Op (f a) -> f (Op a)
sequenceA :: forall (f :: * -> *) a. Applicative f => Op (f a) -> f (Op a)
$cmapM :: forall (m :: * -> *) a b. Monad m => (a -> m b) -> Op a -> m (Op b)
mapM :: forall (m :: * -> *) a b. Monad m => (a -> m b) -> Op a -> m (Op b)
$csequence :: forall (m :: * -> *) a. Monad m => Op (m a) -> m (Op a)
sequence :: forall (m :: * -> *) a. Monad m => Op (m a) -> m (Op a)
Traversable,(forall a b. (a -> b) -> Op a -> Op b)
-> (forall a b. a -> Op b -> Op a) -> Functor Op
forall a b. a -> Op b -> Op a
forall a b. (a -> b) -> Op a -> Op b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> Op a -> Op b
fmap :: forall a b. (a -> b) -> Op a -> Op b
$c<$ :: forall a b. a -> Op b -> Op a
<$ :: forall a b. a -> Op b -> Op a
Functor,(forall x. Op l -> Rep (Op l) x)
-> (forall x. Rep (Op l) x -> Op l) -> Generic (Op l)
forall x. Rep (Op l) x -> Op l
forall x. Op l -> Rep (Op l) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall l x. Rep (Op l) x -> Op l
forall l x. Op l -> Rep (Op l) x
$cfrom :: forall l x. Op l -> Rep (Op l) x
from :: forall x. Op l -> Rep (Op l) x
$cto :: forall l x. Rep (Op l) x -> Op l
to :: forall x. Rep (Op l) x -> Op l
Generic)

-- | A name (/cname/) of a component of a class or data type in an @import@
-- or export specification.
data CName l
    = VarName l (Name l) -- ^ name of a method or field
    | ConName l (Name l) -- ^ name of a data constructor
  deriving (CName l -> CName l -> Bool
(CName l -> CName l -> Bool)
-> (CName l -> CName l -> Bool) -> Eq (CName l)
forall l. Eq l => CName l -> CName l -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall l. Eq l => CName l -> CName l -> Bool
== :: CName l -> CName l -> Bool
$c/= :: forall l. Eq l => CName l -> CName l -> Bool
/= :: CName l -> CName l -> Bool
Eq,Eq (CName l)
Eq (CName l) =>
(CName l -> CName l -> Ordering)
-> (CName l -> CName l -> Bool)
-> (CName l -> CName l -> Bool)
-> (CName l -> CName l -> Bool)
-> (CName l -> CName l -> Bool)
-> (CName l -> CName l -> CName l)
-> (CName l -> CName l -> CName l)
-> Ord (CName l)
CName l -> CName l -> Bool
CName l -> CName l -> Ordering
CName l -> CName l -> CName l
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall l. Ord l => Eq (CName l)
forall l. Ord l => CName l -> CName l -> Bool
forall l. Ord l => CName l -> CName l -> Ordering
forall l. Ord l => CName l -> CName l -> CName l
$ccompare :: forall l. Ord l => CName l -> CName l -> Ordering
compare :: CName l -> CName l -> Ordering
$c< :: forall l. Ord l => CName l -> CName l -> Bool
< :: CName l -> CName l -> Bool
$c<= :: forall l. Ord l => CName l -> CName l -> Bool
<= :: CName l -> CName l -> Bool
$c> :: forall l. Ord l => CName l -> CName l -> Bool
> :: CName l -> CName l -> Bool
$c>= :: forall l. Ord l => CName l -> CName l -> Bool
>= :: CName l -> CName l -> Bool
$cmax :: forall l. Ord l => CName l -> CName l -> CName l
max :: CName l -> CName l -> CName l
$cmin :: forall l. Ord l => CName l -> CName l -> CName l
min :: CName l -> CName l -> CName l
Ord,Int -> CName l -> ShowS
[CName l] -> ShowS
CName l -> String
(Int -> CName l -> ShowS)
-> (CName l -> String) -> ([CName l] -> ShowS) -> Show (CName l)
forall l. Show l => Int -> CName l -> ShowS
forall l. Show l => [CName l] -> ShowS
forall l. Show l => CName l -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall l. Show l => Int -> CName l -> ShowS
showsPrec :: Int -> CName l -> ShowS
$cshow :: forall l. Show l => CName l -> String
show :: CName l -> String
$cshowList :: forall l. Show l => [CName l] -> ShowS
showList :: [CName l] -> ShowS
Show,Typeable,Typeable (CName l)
Typeable (CName l) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> CName l -> c (CName l))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (CName l))
-> (CName l -> Constr)
-> (CName l -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (CName l)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (CName l)))
-> ((forall b. Data b => b -> b) -> CName l -> CName l)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> CName l -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> CName l -> r)
-> (forall u. (forall d. Data d => d -> u) -> CName l -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> CName l -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> CName l -> m (CName l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> CName l -> m (CName l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> CName l -> m (CName l))
-> Data (CName l)
CName l -> Constr
CName l -> DataType
(forall b. Data b => b -> b) -> CName l -> CName l
forall l. Data l => Typeable (CName l)
forall l. Data l => CName l -> Constr
forall l. Data l => CName l -> DataType
forall l.
Data l =>
(forall b. Data b => b -> b) -> CName l -> CName l
forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> CName l -> u
forall l u.
Data l =>
(forall d. Data d => d -> u) -> CName l -> [u]
forall l r r'.
Data l =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CName l -> r
forall l r r'.
Data l =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CName l -> r
forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d) -> CName l -> m (CName l)
forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> CName l -> m (CName l)
forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (CName l)
forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CName l -> c (CName l)
forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (CName l))
forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (CName l))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> CName l -> u
forall u. (forall d. Data d => d -> u) -> CName l -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CName l -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CName l -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CName l -> m (CName l)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CName l -> m (CName l)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (CName l)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CName l -> c (CName l)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (CName l))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (CName l))
$cgfoldl :: forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CName l -> c (CName l)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CName l -> c (CName l)
$cgunfold :: forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (CName l)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (CName l)
$ctoConstr :: forall l. Data l => CName l -> Constr
toConstr :: CName l -> Constr
$cdataTypeOf :: forall l. Data l => CName l -> DataType
dataTypeOf :: CName l -> DataType
$cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (CName l))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (CName l))
$cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (CName l))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (CName l))
$cgmapT :: forall l.
Data l =>
(forall b. Data b => b -> b) -> CName l -> CName l
gmapT :: (forall b. Data b => b -> b) -> CName l -> CName l
$cgmapQl :: forall l r r'.
Data l =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CName l -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CName l -> r
$cgmapQr :: forall l r r'.
Data l =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CName l -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CName l -> r
$cgmapQ :: forall l u.
Data l =>
(forall d. Data d => d -> u) -> CName l -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> CName l -> [u]
$cgmapQi :: forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> CName l -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> CName l -> u
$cgmapM :: forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d) -> CName l -> m (CName l)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CName l -> m (CName l)
$cgmapMp :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> CName l -> m (CName l)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CName l -> m (CName l)
$cgmapMo :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> CName l -> m (CName l)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CName l -> m (CName l)
Data,(forall m. Monoid m => CName m -> m)
-> (forall m a. Monoid m => (a -> m) -> CName a -> m)
-> (forall m a. Monoid m => (a -> m) -> CName a -> m)
-> (forall a b. (a -> b -> b) -> b -> CName a -> b)
-> (forall a b. (a -> b -> b) -> b -> CName a -> b)
-> (forall b a. (b -> a -> b) -> b -> CName a -> b)
-> (forall b a. (b -> a -> b) -> b -> CName a -> b)
-> (forall a. (a -> a -> a) -> CName a -> a)
-> (forall a. (a -> a -> a) -> CName a -> a)
-> (forall a. CName a -> [a])
-> (forall a. CName a -> Bool)
-> (forall a. CName a -> Int)
-> (forall a. Eq a => a -> CName a -> Bool)
-> (forall a. Ord a => CName a -> a)
-> (forall a. Ord a => CName a -> a)
-> (forall a. Num a => CName a -> a)
-> (forall a. Num a => CName a -> a)
-> Foldable CName
forall a. Eq a => a -> CName a -> Bool
forall a. Num a => CName a -> a
forall a. Ord a => CName a -> a
forall m. Monoid m => CName m -> m
forall a. CName a -> Bool
forall a. CName a -> Int
forall a. CName a -> [a]
forall a. (a -> a -> a) -> CName a -> a
forall m a. Monoid m => (a -> m) -> CName a -> m
forall b a. (b -> a -> b) -> b -> CName a -> b
forall a b. (a -> b -> b) -> b -> CName a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall m. Monoid m => CName m -> m
fold :: forall m. Monoid m => CName m -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> CName a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> CName a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> CName a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> CName a -> m
$cfoldr :: forall a b. (a -> b -> b) -> b -> CName a -> b
foldr :: forall a b. (a -> b -> b) -> b -> CName a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> CName a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> CName a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> CName a -> b
foldl :: forall b a. (b -> a -> b) -> b -> CName a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> CName a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> CName a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> CName a -> a
foldr1 :: forall a. (a -> a -> a) -> CName a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> CName a -> a
foldl1 :: forall a. (a -> a -> a) -> CName a -> a
$ctoList :: forall a. CName a -> [a]
toList :: forall a. CName a -> [a]
$cnull :: forall a. CName a -> Bool
null :: forall a. CName a -> Bool
$clength :: forall a. CName a -> Int
length :: forall a. CName a -> Int
$celem :: forall a. Eq a => a -> CName a -> Bool
elem :: forall a. Eq a => a -> CName a -> Bool
$cmaximum :: forall a. Ord a => CName a -> a
maximum :: forall a. Ord a => CName a -> a
$cminimum :: forall a. Ord a => CName a -> a
minimum :: forall a. Ord a => CName a -> a
$csum :: forall a. Num a => CName a -> a
sum :: forall a. Num a => CName a -> a
$cproduct :: forall a. Num a => CName a -> a
product :: forall a. Num a => CName a -> a
Foldable,Functor CName
Foldable CName
(Functor CName, Foldable CName) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> CName a -> f (CName b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    CName (f a) -> f (CName a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> CName a -> m (CName b))
-> (forall (m :: * -> *) a. Monad m => CName (m a) -> m (CName a))
-> Traversable CName
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a. Monad m => CName (m a) -> m (CName a)
forall (f :: * -> *) a. Applicative f => CName (f a) -> f (CName a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> CName a -> m (CName b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> CName a -> f (CName b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> CName a -> f (CName b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> CName a -> f (CName b)
$csequenceA :: forall (f :: * -> *) a. Applicative f => CName (f a) -> f (CName a)
sequenceA :: forall (f :: * -> *) a. Applicative f => CName (f a) -> f (CName a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> CName a -> m (CName b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> CName a -> m (CName b)
$csequence :: forall (m :: * -> *) a. Monad m => CName (m a) -> m (CName a)
sequence :: forall (m :: * -> *) a. Monad m => CName (m a) -> m (CName a)
Traversable,(forall a b. (a -> b) -> CName a -> CName b)
-> (forall a b. a -> CName b -> CName a) -> Functor CName
forall a b. a -> CName b -> CName a
forall a b. (a -> b) -> CName a -> CName b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> CName a -> CName b
fmap :: forall a b. (a -> b) -> CName a -> CName b
$c<$ :: forall a b. a -> CName b -> CName a
<$ :: forall a b. a -> CName b -> CName a
Functor,(forall x. CName l -> Rep (CName l) x)
-> (forall x. Rep (CName l) x -> CName l) -> Generic (CName l)
forall x. Rep (CName l) x -> CName l
forall x. CName l -> Rep (CName l) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall l x. Rep (CName l) x -> CName l
forall l x. CName l -> Rep (CName l) x
$cfrom :: forall l x. CName l -> Rep (CName l) x
from :: forall x. CName l -> Rep (CName l) x
$cto :: forall l x. Rep (CName l) x -> CName l
to :: forall x. Rep (CName l) x -> CName l
Generic)

-- | A complete Haskell source module.
data Module l
    = Module l (Maybe (ModuleHead l)) [ModulePragma l] [ImportDecl l] [Decl l]
    -- ^ an ordinary Haskell module
    | XmlPage l (ModuleName l) [ModulePragma l] (XName l) [XAttr l] (Maybe (Exp l)) [Exp l]
    -- ^ a module consisting of a single XML document. The ModuleName never appears in the source
    --   but is needed for semantic purposes, it will be the same as the file name.
    | XmlHybrid l (Maybe (ModuleHead l)) [ModulePragma l] [ImportDecl l] [Decl l]
                (XName l) [XAttr l] (Maybe (Exp l)) [Exp l]
    -- ^ a hybrid module combining an XML document with an ordinary module
  deriving (Module l -> Module l -> Bool
(Module l -> Module l -> Bool)
-> (Module l -> Module l -> Bool) -> Eq (Module l)
forall l. Eq l => Module l -> Module l -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall l. Eq l => Module l -> Module l -> Bool
== :: Module l -> Module l -> Bool
$c/= :: forall l. Eq l => Module l -> Module l -> Bool
/= :: Module l -> Module l -> Bool
Eq,Eq (Module l)
Eq (Module l) =>
(Module l -> Module l -> Ordering)
-> (Module l -> Module l -> Bool)
-> (Module l -> Module l -> Bool)
-> (Module l -> Module l -> Bool)
-> (Module l -> Module l -> Bool)
-> (Module l -> Module l -> Module l)
-> (Module l -> Module l -> Module l)
-> Ord (Module l)
Module l -> Module l -> Bool
Module l -> Module l -> Ordering
Module l -> Module l -> Module l
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall l. Ord l => Eq (Module l)
forall l. Ord l => Module l -> Module l -> Bool
forall l. Ord l => Module l -> Module l -> Ordering
forall l. Ord l => Module l -> Module l -> Module l
$ccompare :: forall l. Ord l => Module l -> Module l -> Ordering
compare :: Module l -> Module l -> Ordering
$c< :: forall l. Ord l => Module l -> Module l -> Bool
< :: Module l -> Module l -> Bool
$c<= :: forall l. Ord l => Module l -> Module l -> Bool
<= :: Module l -> Module l -> Bool
$c> :: forall l. Ord l => Module l -> Module l -> Bool
> :: Module l -> Module l -> Bool
$c>= :: forall l. Ord l => Module l -> Module l -> Bool
>= :: Module l -> Module l -> Bool
$cmax :: forall l. Ord l => Module l -> Module l -> Module l
max :: Module l -> Module l -> Module l
$cmin :: forall l. Ord l => Module l -> Module l -> Module l
min :: Module l -> Module l -> Module l
Ord,Int -> Module l -> ShowS
[Module l] -> ShowS
Module l -> String
(Int -> Module l -> ShowS)
-> (Module l -> String) -> ([Module l] -> ShowS) -> Show (Module l)
forall l. Show l => Int -> Module l -> ShowS
forall l. Show l => [Module l] -> ShowS
forall l. Show l => Module l -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall l. Show l => Int -> Module l -> ShowS
showsPrec :: Int -> Module l -> ShowS
$cshow :: forall l. Show l => Module l -> String
show :: Module l -> String
$cshowList :: forall l. Show l => [Module l] -> ShowS
showList :: [Module l] -> ShowS
Show,Typeable,Typeable (Module l)
Typeable (Module l) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Module l -> c (Module l))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Module l))
-> (Module l -> Constr)
-> (Module l -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Module l)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Module l)))
-> ((forall b. Data b => b -> b) -> Module l -> Module l)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Module l -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Module l -> r)
-> (forall u. (forall d. Data d => d -> u) -> Module l -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Module l -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Module l -> m (Module l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Module l -> m (Module l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Module l -> m (Module l))
-> Data (Module l)
Module l -> Constr
Module l -> DataType
(forall b. Data b => b -> b) -> Module l -> Module l
forall l. Data l => Typeable (Module l)
forall l. Data l => Module l -> Constr
forall l. Data l => Module l -> DataType
forall l.
Data l =>
(forall b. Data b => b -> b) -> Module l -> Module l
forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> Module l -> u
forall l u.
Data l =>
(forall d. Data d => d -> u) -> Module l -> [u]
forall l r r'.
Data l =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Module l -> r
forall l r r'.
Data l =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Module l -> r
forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d) -> Module l -> m (Module l)
forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Module l -> m (Module l)
forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Module l)
forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Module l -> c (Module l)
forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Module l))
forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Module l))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Module l -> u
forall u. (forall d. Data d => d -> u) -> Module l -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Module l -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Module l -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Module l -> m (Module l)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Module l -> m (Module l)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Module l)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Module l -> c (Module l)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Module l))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Module l))
$cgfoldl :: forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Module l -> c (Module l)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Module l -> c (Module l)
$cgunfold :: forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Module l)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Module l)
$ctoConstr :: forall l. Data l => Module l -> Constr
toConstr :: Module l -> Constr
$cdataTypeOf :: forall l. Data l => Module l -> DataType
dataTypeOf :: Module l -> DataType
$cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Module l))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Module l))
$cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Module l))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Module l))
$cgmapT :: forall l.
Data l =>
(forall b. Data b => b -> b) -> Module l -> Module l
gmapT :: (forall b. Data b => b -> b) -> Module l -> Module l
$cgmapQl :: forall l r r'.
Data l =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Module l -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Module l -> r
$cgmapQr :: forall l r r'.
Data l =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Module l -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Module l -> r
$cgmapQ :: forall l u.
Data l =>
(forall d. Data d => d -> u) -> Module l -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Module l -> [u]
$cgmapQi :: forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> Module l -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Module l -> u
$cgmapM :: forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d) -> Module l -> m (Module l)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Module l -> m (Module l)
$cgmapMp :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Module l -> m (Module l)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Module l -> m (Module l)
$cgmapMo :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Module l -> m (Module l)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Module l -> m (Module l)
Data,(forall m. Monoid m => Module m -> m)
-> (forall m a. Monoid m => (a -> m) -> Module a -> m)
-> (forall m a. Monoid m => (a -> m) -> Module a -> m)
-> (forall a b. (a -> b -> b) -> b -> Module a -> b)
-> (forall a b. (a -> b -> b) -> b -> Module a -> b)
-> (forall b a. (b -> a -> b) -> b -> Module a -> b)
-> (forall b a. (b -> a -> b) -> b -> Module a -> b)
-> (forall a. (a -> a -> a) -> Module a -> a)
-> (forall a. (a -> a -> a) -> Module a -> a)
-> (forall a. Module a -> [a])
-> (forall a. Module a -> Bool)
-> (forall a. Module a -> Int)
-> (forall a. Eq a => a -> Module a -> Bool)
-> (forall a. Ord a => Module a -> a)
-> (forall a. Ord a => Module a -> a)
-> (forall a. Num a => Module a -> a)
-> (forall a. Num a => Module a -> a)
-> Foldable Module
forall a. Eq a => a -> Module a -> Bool
forall a. Num a => Module a -> a
forall a. Ord a => Module a -> a
forall m. Monoid m => Module m -> m
forall a. Module a -> Bool
forall a. Module a -> Int
forall a. Module a -> [a]
forall a. (a -> a -> a) -> Module a -> a
forall m a. Monoid m => (a -> m) -> Module a -> m
forall b a. (b -> a -> b) -> b -> Module a -> b
forall a b. (a -> b -> b) -> b -> Module a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall m. Monoid m => Module m -> m
fold :: forall m. Monoid m => Module m -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> Module a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> Module a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> Module a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> Module a -> m
$cfoldr :: forall a b. (a -> b -> b) -> b -> Module a -> b
foldr :: forall a b. (a -> b -> b) -> b -> Module a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> Module a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> Module a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> Module a -> b
foldl :: forall b a. (b -> a -> b) -> b -> Module a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> Module a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> Module a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> Module a -> a
foldr1 :: forall a. (a -> a -> a) -> Module a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> Module a -> a
foldl1 :: forall a. (a -> a -> a) -> Module a -> a
$ctoList :: forall a. Module a -> [a]
toList :: forall a. Module a -> [a]
$cnull :: forall a. Module a -> Bool
null :: forall a. Module a -> Bool
$clength :: forall a. Module a -> Int
length :: forall a. Module a -> Int
$celem :: forall a. Eq a => a -> Module a -> Bool
elem :: forall a. Eq a => a -> Module a -> Bool
$cmaximum :: forall a. Ord a => Module a -> a
maximum :: forall a. Ord a => Module a -> a
$cminimum :: forall a. Ord a => Module a -> a
minimum :: forall a. Ord a => Module a -> a
$csum :: forall a. Num a => Module a -> a
sum :: forall a. Num a => Module a -> a
$cproduct :: forall a. Num a => Module a -> a
product :: forall a. Num a => Module a -> a
Foldable,Functor Module
Foldable Module
(Functor Module, Foldable Module) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> Module a -> f (Module b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    Module (f a) -> f (Module a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Module a -> m (Module b))
-> (forall (m :: * -> *) a.
    Monad m =>
    Module (m a) -> m (Module a))
-> Traversable Module
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a. Monad m => Module (m a) -> m (Module a)
forall (f :: * -> *) a.
Applicative f =>
Module (f a) -> f (Module a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Module a -> m (Module b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Module a -> f (Module b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Module a -> f (Module b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Module a -> f (Module b)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
Module (f a) -> f (Module a)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
Module (f a) -> f (Module a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Module a -> m (Module b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Module a -> m (Module b)
$csequence :: forall (m :: * -> *) a. Monad m => Module (m a) -> m (Module a)
sequence :: forall (m :: * -> *) a. Monad m => Module (m a) -> m (Module a)
Traversable,(forall a b. (a -> b) -> Module a -> Module b)
-> (forall a b. a -> Module b -> Module a) -> Functor Module
forall a b. a -> Module b -> Module a
forall a b. (a -> b) -> Module a -> Module b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> Module a -> Module b
fmap :: forall a b. (a -> b) -> Module a -> Module b
$c<$ :: forall a b. a -> Module b -> Module a
<$ :: forall a b. a -> Module b -> Module a
Functor,(forall x. Module l -> Rep (Module l) x)
-> (forall x. Rep (Module l) x -> Module l) -> Generic (Module l)
forall x. Rep (Module l) x -> Module l
forall x. Module l -> Rep (Module l) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall l x. Rep (Module l) x -> Module l
forall l x. Module l -> Rep (Module l) x
$cfrom :: forall l x. Module l -> Rep (Module l) x
from :: forall x. Module l -> Rep (Module l) x
$cto :: forall l x. Rep (Module l) x -> Module l
to :: forall x. Rep (Module l) x -> Module l
Generic)

-- | The head of a module, including the name and export specification.
data ModuleHead l = ModuleHead l (ModuleName l) (Maybe (WarningText l)) (Maybe (ExportSpecList l))
  deriving (ModuleHead l -> ModuleHead l -> Bool
(ModuleHead l -> ModuleHead l -> Bool)
-> (ModuleHead l -> ModuleHead l -> Bool) -> Eq (ModuleHead l)
forall l. Eq l => ModuleHead l -> ModuleHead l -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall l. Eq l => ModuleHead l -> ModuleHead l -> Bool
== :: ModuleHead l -> ModuleHead l -> Bool
$c/= :: forall l. Eq l => ModuleHead l -> ModuleHead l -> Bool
/= :: ModuleHead l -> ModuleHead l -> Bool
Eq,Eq (ModuleHead l)
Eq (ModuleHead l) =>
(ModuleHead l -> ModuleHead l -> Ordering)
-> (ModuleHead l -> ModuleHead l -> Bool)
-> (ModuleHead l -> ModuleHead l -> Bool)
-> (ModuleHead l -> ModuleHead l -> Bool)
-> (ModuleHead l -> ModuleHead l -> Bool)
-> (ModuleHead l -> ModuleHead l -> ModuleHead l)
-> (ModuleHead l -> ModuleHead l -> ModuleHead l)
-> Ord (ModuleHead l)
ModuleHead l -> ModuleHead l -> Bool
ModuleHead l -> ModuleHead l -> Ordering
ModuleHead l -> ModuleHead l -> ModuleHead l
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall l. Ord l => Eq (ModuleHead l)
forall l. Ord l => ModuleHead l -> ModuleHead l -> Bool
forall l. Ord l => ModuleHead l -> ModuleHead l -> Ordering
forall l. Ord l => ModuleHead l -> ModuleHead l -> ModuleHead l
$ccompare :: forall l. Ord l => ModuleHead l -> ModuleHead l -> Ordering
compare :: ModuleHead l -> ModuleHead l -> Ordering
$c< :: forall l. Ord l => ModuleHead l -> ModuleHead l -> Bool
< :: ModuleHead l -> ModuleHead l -> Bool
$c<= :: forall l. Ord l => ModuleHead l -> ModuleHead l -> Bool
<= :: ModuleHead l -> ModuleHead l -> Bool
$c> :: forall l. Ord l => ModuleHead l -> ModuleHead l -> Bool
> :: ModuleHead l -> ModuleHead l -> Bool
$c>= :: forall l. Ord l => ModuleHead l -> ModuleHead l -> Bool
>= :: ModuleHead l -> ModuleHead l -> Bool
$cmax :: forall l. Ord l => ModuleHead l -> ModuleHead l -> ModuleHead l
max :: ModuleHead l -> ModuleHead l -> ModuleHead l
$cmin :: forall l. Ord l => ModuleHead l -> ModuleHead l -> ModuleHead l
min :: ModuleHead l -> ModuleHead l -> ModuleHead l
Ord,Int -> ModuleHead l -> ShowS
[ModuleHead l] -> ShowS
ModuleHead l -> String
(Int -> ModuleHead l -> ShowS)
-> (ModuleHead l -> String)
-> ([ModuleHead l] -> ShowS)
-> Show (ModuleHead l)
forall l. Show l => Int -> ModuleHead l -> ShowS
forall l. Show l => [ModuleHead l] -> ShowS
forall l. Show l => ModuleHead l -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall l. Show l => Int -> ModuleHead l -> ShowS
showsPrec :: Int -> ModuleHead l -> ShowS
$cshow :: forall l. Show l => ModuleHead l -> String
show :: ModuleHead l -> String
$cshowList :: forall l. Show l => [ModuleHead l] -> ShowS
showList :: [ModuleHead l] -> ShowS
Show,Typeable,Typeable (ModuleHead l)
Typeable (ModuleHead l) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> ModuleHead l -> c (ModuleHead l))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (ModuleHead l))
-> (ModuleHead l -> Constr)
-> (ModuleHead l -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (ModuleHead l)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (ModuleHead l)))
-> ((forall b. Data b => b -> b) -> ModuleHead l -> ModuleHead l)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ModuleHead l -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ModuleHead l -> r)
-> (forall u. (forall d. Data d => d -> u) -> ModuleHead l -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> ModuleHead l -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ModuleHead l -> m (ModuleHead l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ModuleHead l -> m (ModuleHead l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ModuleHead l -> m (ModuleHead l))
-> Data (ModuleHead l)
ModuleHead l -> Constr
ModuleHead l -> DataType
(forall b. Data b => b -> b) -> ModuleHead l -> ModuleHead l
forall l. Data l => Typeable (ModuleHead l)
forall l. Data l => ModuleHead l -> Constr
forall l. Data l => ModuleHead l -> DataType
forall l.
Data l =>
(forall b. Data b => b -> b) -> ModuleHead l -> ModuleHead l
forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> ModuleHead l -> u
forall l u.
Data l =>
(forall d. Data d => d -> u) -> ModuleHead l -> [u]
forall l r r'.
Data l =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ModuleHead l -> r
forall l r r'.
Data l =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ModuleHead l -> r
forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d) -> ModuleHead l -> m (ModuleHead l)
forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> ModuleHead l -> m (ModuleHead l)
forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ModuleHead l)
forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ModuleHead l -> c (ModuleHead l)
forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (ModuleHead l))
forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ModuleHead l))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> ModuleHead l -> u
forall u. (forall d. Data d => d -> u) -> ModuleHead l -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ModuleHead l -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ModuleHead l -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ModuleHead l -> m (ModuleHead l)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ModuleHead l -> m (ModuleHead l)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ModuleHead l)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ModuleHead l -> c (ModuleHead l)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (ModuleHead l))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ModuleHead l))
$cgfoldl :: forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ModuleHead l -> c (ModuleHead l)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ModuleHead l -> c (ModuleHead l)
$cgunfold :: forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ModuleHead l)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ModuleHead l)
$ctoConstr :: forall l. Data l => ModuleHead l -> Constr
toConstr :: ModuleHead l -> Constr
$cdataTypeOf :: forall l. Data l => ModuleHead l -> DataType
dataTypeOf :: ModuleHead l -> DataType
$cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (ModuleHead l))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (ModuleHead l))
$cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ModuleHead l))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ModuleHead l))
$cgmapT :: forall l.
Data l =>
(forall b. Data b => b -> b) -> ModuleHead l -> ModuleHead l
gmapT :: (forall b. Data b => b -> b) -> ModuleHead l -> ModuleHead l
$cgmapQl :: forall l r r'.
Data l =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ModuleHead l -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ModuleHead l -> r
$cgmapQr :: forall l r r'.
Data l =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ModuleHead l -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ModuleHead l -> r
$cgmapQ :: forall l u.
Data l =>
(forall d. Data d => d -> u) -> ModuleHead l -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> ModuleHead l -> [u]
$cgmapQi :: forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> ModuleHead l -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ModuleHead l -> u
$cgmapM :: forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d) -> ModuleHead l -> m (ModuleHead l)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ModuleHead l -> m (ModuleHead l)
$cgmapMp :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> ModuleHead l -> m (ModuleHead l)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ModuleHead l -> m (ModuleHead l)
$cgmapMo :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> ModuleHead l -> m (ModuleHead l)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ModuleHead l -> m (ModuleHead l)
Data,(forall m. Monoid m => ModuleHead m -> m)
-> (forall m a. Monoid m => (a -> m) -> ModuleHead a -> m)
-> (forall m a. Monoid m => (a -> m) -> ModuleHead a -> m)
-> (forall a b. (a -> b -> b) -> b -> ModuleHead a -> b)
-> (forall a b. (a -> b -> b) -> b -> ModuleHead a -> b)
-> (forall b a. (b -> a -> b) -> b -> ModuleHead a -> b)
-> (forall b a. (b -> a -> b) -> b -> ModuleHead a -> b)
-> (forall a. (a -> a -> a) -> ModuleHead a -> a)
-> (forall a. (a -> a -> a) -> ModuleHead a -> a)
-> (forall a. ModuleHead a -> [a])
-> (forall a. ModuleHead a -> Bool)
-> (forall a. ModuleHead a -> Int)
-> (forall a. Eq a => a -> ModuleHead a -> Bool)
-> (forall a. Ord a => ModuleHead a -> a)
-> (forall a. Ord a => ModuleHead a -> a)
-> (forall a. Num a => ModuleHead a -> a)
-> (forall a. Num a => ModuleHead a -> a)
-> Foldable ModuleHead
forall a. Eq a => a -> ModuleHead a -> Bool
forall a. Num a => ModuleHead a -> a
forall a. Ord a => ModuleHead a -> a
forall m. Monoid m => ModuleHead m -> m
forall a. ModuleHead a -> Bool
forall a. ModuleHead a -> Int
forall a. ModuleHead a -> [a]
forall a. (a -> a -> a) -> ModuleHead a -> a
forall m a. Monoid m => (a -> m) -> ModuleHead a -> m
forall b a. (b -> a -> b) -> b -> ModuleHead a -> b
forall a b. (a -> b -> b) -> b -> ModuleHead a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall m. Monoid m => ModuleHead m -> m
fold :: forall m. Monoid m => ModuleHead m -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> ModuleHead a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> ModuleHead a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> ModuleHead a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> ModuleHead a -> m
$cfoldr :: forall a b. (a -> b -> b) -> b -> ModuleHead a -> b
foldr :: forall a b. (a -> b -> b) -> b -> ModuleHead a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> ModuleHead a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> ModuleHead a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> ModuleHead a -> b
foldl :: forall b a. (b -> a -> b) -> b -> ModuleHead a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> ModuleHead a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> ModuleHead a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> ModuleHead a -> a
foldr1 :: forall a. (a -> a -> a) -> ModuleHead a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> ModuleHead a -> a
foldl1 :: forall a. (a -> a -> a) -> ModuleHead a -> a
$ctoList :: forall a. ModuleHead a -> [a]
toList :: forall a. ModuleHead a -> [a]
$cnull :: forall a. ModuleHead a -> Bool
null :: forall a. ModuleHead a -> Bool
$clength :: forall a. ModuleHead a -> Int
length :: forall a. ModuleHead a -> Int
$celem :: forall a. Eq a => a -> ModuleHead a -> Bool
elem :: forall a. Eq a => a -> ModuleHead a -> Bool
$cmaximum :: forall a. Ord a => ModuleHead a -> a
maximum :: forall a. Ord a => ModuleHead a -> a
$cminimum :: forall a. Ord a => ModuleHead a -> a
minimum :: forall a. Ord a => ModuleHead a -> a
$csum :: forall a. Num a => ModuleHead a -> a
sum :: forall a. Num a => ModuleHead a -> a
$cproduct :: forall a. Num a => ModuleHead a -> a
product :: forall a. Num a => ModuleHead a -> a
Foldable,Functor ModuleHead
Foldable ModuleHead
(Functor ModuleHead, Foldable ModuleHead) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> ModuleHead a -> f (ModuleHead b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    ModuleHead (f a) -> f (ModuleHead a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> ModuleHead a -> m (ModuleHead b))
-> (forall (m :: * -> *) a.
    Monad m =>
    ModuleHead (m a) -> m (ModuleHead a))
-> Traversable ModuleHead
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a.
Monad m =>
ModuleHead (m a) -> m (ModuleHead a)
forall (f :: * -> *) a.
Applicative f =>
ModuleHead (f a) -> f (ModuleHead a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> ModuleHead a -> m (ModuleHead b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> ModuleHead a -> f (ModuleHead b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> ModuleHead a -> f (ModuleHead b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> ModuleHead a -> f (ModuleHead b)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
ModuleHead (f a) -> f (ModuleHead a)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
ModuleHead (f a) -> f (ModuleHead a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> ModuleHead a -> m (ModuleHead b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> ModuleHead a -> m (ModuleHead b)
$csequence :: forall (m :: * -> *) a.
Monad m =>
ModuleHead (m a) -> m (ModuleHead a)
sequence :: forall (m :: * -> *) a.
Monad m =>
ModuleHead (m a) -> m (ModuleHead a)
Traversable,(forall a b. (a -> b) -> ModuleHead a -> ModuleHead b)
-> (forall a b. a -> ModuleHead b -> ModuleHead a)
-> Functor ModuleHead
forall a b. a -> ModuleHead b -> ModuleHead a
forall a b. (a -> b) -> ModuleHead a -> ModuleHead b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> ModuleHead a -> ModuleHead b
fmap :: forall a b. (a -> b) -> ModuleHead a -> ModuleHead b
$c<$ :: forall a b. a -> ModuleHead b -> ModuleHead a
<$ :: forall a b. a -> ModuleHead b -> ModuleHead a
Functor,(forall x. ModuleHead l -> Rep (ModuleHead l) x)
-> (forall x. Rep (ModuleHead l) x -> ModuleHead l)
-> Generic (ModuleHead l)
forall x. Rep (ModuleHead l) x -> ModuleHead l
forall x. ModuleHead l -> Rep (ModuleHead l) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall l x. Rep (ModuleHead l) x -> ModuleHead l
forall l x. ModuleHead l -> Rep (ModuleHead l) x
$cfrom :: forall l x. ModuleHead l -> Rep (ModuleHead l) x
from :: forall x. ModuleHead l -> Rep (ModuleHead l) x
$cto :: forall l x. Rep (ModuleHead l) x -> ModuleHead l
to :: forall x. Rep (ModuleHead l) x -> ModuleHead l
Generic)

-- | An explicit export specification.
data ExportSpecList l
    = ExportSpecList l [ExportSpec l]
  deriving (ExportSpecList l -> ExportSpecList l -> Bool
(ExportSpecList l -> ExportSpecList l -> Bool)
-> (ExportSpecList l -> ExportSpecList l -> Bool)
-> Eq (ExportSpecList l)
forall l. Eq l => ExportSpecList l -> ExportSpecList l -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall l. Eq l => ExportSpecList l -> ExportSpecList l -> Bool
== :: ExportSpecList l -> ExportSpecList l -> Bool
$c/= :: forall l. Eq l => ExportSpecList l -> ExportSpecList l -> Bool
/= :: ExportSpecList l -> ExportSpecList l -> Bool
Eq,Eq (ExportSpecList l)
Eq (ExportSpecList l) =>
(ExportSpecList l -> ExportSpecList l -> Ordering)
-> (ExportSpecList l -> ExportSpecList l -> Bool)
-> (ExportSpecList l -> ExportSpecList l -> Bool)
-> (ExportSpecList l -> ExportSpecList l -> Bool)
-> (ExportSpecList l -> ExportSpecList l -> Bool)
-> (ExportSpecList l -> ExportSpecList l -> ExportSpecList l)
-> (ExportSpecList l -> ExportSpecList l -> ExportSpecList l)
-> Ord (ExportSpecList l)
ExportSpecList l -> ExportSpecList l -> Bool
ExportSpecList l -> ExportSpecList l -> Ordering
ExportSpecList l -> ExportSpecList l -> ExportSpecList l
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall l. Ord l => Eq (ExportSpecList l)
forall l. Ord l => ExportSpecList l -> ExportSpecList l -> Bool
forall l. Ord l => ExportSpecList l -> ExportSpecList l -> Ordering
forall l.
Ord l =>
ExportSpecList l -> ExportSpecList l -> ExportSpecList l
$ccompare :: forall l. Ord l => ExportSpecList l -> ExportSpecList l -> Ordering
compare :: ExportSpecList l -> ExportSpecList l -> Ordering
$c< :: forall l. Ord l => ExportSpecList l -> ExportSpecList l -> Bool
< :: ExportSpecList l -> ExportSpecList l -> Bool
$c<= :: forall l. Ord l => ExportSpecList l -> ExportSpecList l -> Bool
<= :: ExportSpecList l -> ExportSpecList l -> Bool
$c> :: forall l. Ord l => ExportSpecList l -> ExportSpecList l -> Bool
> :: ExportSpecList l -> ExportSpecList l -> Bool
$c>= :: forall l. Ord l => ExportSpecList l -> ExportSpecList l -> Bool
>= :: ExportSpecList l -> ExportSpecList l -> Bool
$cmax :: forall l.
Ord l =>
ExportSpecList l -> ExportSpecList l -> ExportSpecList l
max :: ExportSpecList l -> ExportSpecList l -> ExportSpecList l
$cmin :: forall l.
Ord l =>
ExportSpecList l -> ExportSpecList l -> ExportSpecList l
min :: ExportSpecList l -> ExportSpecList l -> ExportSpecList l
Ord,Int -> ExportSpecList l -> ShowS
[ExportSpecList l] -> ShowS
ExportSpecList l -> String
(Int -> ExportSpecList l -> ShowS)
-> (ExportSpecList l -> String)
-> ([ExportSpecList l] -> ShowS)
-> Show (ExportSpecList l)
forall l. Show l => Int -> ExportSpecList l -> ShowS
forall l. Show l => [ExportSpecList l] -> ShowS
forall l. Show l => ExportSpecList l -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall l. Show l => Int -> ExportSpecList l -> ShowS
showsPrec :: Int -> ExportSpecList l -> ShowS
$cshow :: forall l. Show l => ExportSpecList l -> String
show :: ExportSpecList l -> String
$cshowList :: forall l. Show l => [ExportSpecList l] -> ShowS
showList :: [ExportSpecList l] -> ShowS
Show,Typeable,Typeable (ExportSpecList l)
Typeable (ExportSpecList l) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g)
 -> ExportSpecList l
 -> c (ExportSpecList l))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (ExportSpecList l))
-> (ExportSpecList l -> Constr)
-> (ExportSpecList l -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (ExportSpecList l)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (ExportSpecList l)))
-> ((forall b. Data b => b -> b)
    -> ExportSpecList l -> ExportSpecList l)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ExportSpecList l -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ExportSpecList l -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> ExportSpecList l -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> ExportSpecList l -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> ExportSpecList l -> m (ExportSpecList l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> ExportSpecList l -> m (ExportSpecList l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> ExportSpecList l -> m (ExportSpecList l))
-> Data (ExportSpecList l)
ExportSpecList l -> Constr
ExportSpecList l -> DataType
(forall b. Data b => b -> b)
-> ExportSpecList l -> ExportSpecList l
forall l. Data l => Typeable (ExportSpecList l)
forall l. Data l => ExportSpecList l -> Constr
forall l. Data l => ExportSpecList l -> DataType
forall l.
Data l =>
(forall b. Data b => b -> b)
-> ExportSpecList l -> ExportSpecList l
forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> ExportSpecList l -> u
forall l u.
Data l =>
(forall d. Data d => d -> u) -> ExportSpecList l -> [u]
forall l r r'.
Data l =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ExportSpecList l -> r
forall l r r'.
Data l =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ExportSpecList l -> r
forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d)
-> ExportSpecList l -> m (ExportSpecList l)
forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> ExportSpecList l -> m (ExportSpecList l)
forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ExportSpecList l)
forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ExportSpecList l -> c (ExportSpecList l)
forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (ExportSpecList l))
forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ExportSpecList l))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> ExportSpecList l -> u
forall u. (forall d. Data d => d -> u) -> ExportSpecList l -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ExportSpecList l -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ExportSpecList l -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> ExportSpecList l -> m (ExportSpecList l)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ExportSpecList l -> m (ExportSpecList l)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ExportSpecList l)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ExportSpecList l -> c (ExportSpecList l)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (ExportSpecList l))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ExportSpecList l))
$cgfoldl :: forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ExportSpecList l -> c (ExportSpecList l)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ExportSpecList l -> c (ExportSpecList l)
$cgunfold :: forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ExportSpecList l)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ExportSpecList l)
$ctoConstr :: forall l. Data l => ExportSpecList l -> Constr
toConstr :: ExportSpecList l -> Constr
$cdataTypeOf :: forall l. Data l => ExportSpecList l -> DataType
dataTypeOf :: ExportSpecList l -> DataType
$cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (ExportSpecList l))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (ExportSpecList l))
$cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ExportSpecList l))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ExportSpecList l))
$cgmapT :: forall l.
Data l =>
(forall b. Data b => b -> b)
-> ExportSpecList l -> ExportSpecList l
gmapT :: (forall b. Data b => b -> b)
-> ExportSpecList l -> ExportSpecList l
$cgmapQl :: forall l r r'.
Data l =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ExportSpecList l -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ExportSpecList l -> r
$cgmapQr :: forall l r r'.
Data l =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ExportSpecList l -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ExportSpecList l -> r
$cgmapQ :: forall l u.
Data l =>
(forall d. Data d => d -> u) -> ExportSpecList l -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> ExportSpecList l -> [u]
$cgmapQi :: forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> ExportSpecList l -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> ExportSpecList l -> u
$cgmapM :: forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d)
-> ExportSpecList l -> m (ExportSpecList l)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> ExportSpecList l -> m (ExportSpecList l)
$cgmapMp :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> ExportSpecList l -> m (ExportSpecList l)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ExportSpecList l -> m (ExportSpecList l)
$cgmapMo :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> ExportSpecList l -> m (ExportSpecList l)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ExportSpecList l -> m (ExportSpecList l)
Data,(forall m. Monoid m => ExportSpecList m -> m)
-> (forall m a. Monoid m => (a -> m) -> ExportSpecList a -> m)
-> (forall m a. Monoid m => (a -> m) -> ExportSpecList a -> m)
-> (forall a b. (a -> b -> b) -> b -> ExportSpecList a -> b)
-> (forall a b. (a -> b -> b) -> b -> ExportSpecList a -> b)
-> (forall b a. (b -> a -> b) -> b -> ExportSpecList a -> b)
-> (forall b a. (b -> a -> b) -> b -> ExportSpecList a -> b)
-> (forall a. (a -> a -> a) -> ExportSpecList a -> a)
-> (forall a. (a -> a -> a) -> ExportSpecList a -> a)
-> (forall a. ExportSpecList a -> [a])
-> (forall a. ExportSpecList a -> Bool)
-> (forall a. ExportSpecList a -> Int)
-> (forall a. Eq a => a -> ExportSpecList a -> Bool)
-> (forall a. Ord a => ExportSpecList a -> a)
-> (forall a. Ord a => ExportSpecList a -> a)
-> (forall a. Num a => ExportSpecList a -> a)
-> (forall a. Num a => ExportSpecList a -> a)
-> Foldable ExportSpecList
forall a. Eq a => a -> ExportSpecList a -> Bool
forall a. Num a => ExportSpecList a -> a
forall a. Ord a => ExportSpecList a -> a
forall m. Monoid m => ExportSpecList m -> m
forall a. ExportSpecList a -> Bool
forall a. ExportSpecList a -> Int
forall a. ExportSpecList a -> [a]
forall a. (a -> a -> a) -> ExportSpecList a -> a
forall m a. Monoid m => (a -> m) -> ExportSpecList a -> m
forall b a. (b -> a -> b) -> b -> ExportSpecList a -> b
forall a b. (a -> b -> b) -> b -> ExportSpecList a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall m. Monoid m => ExportSpecList m -> m
fold :: forall m. Monoid m => ExportSpecList m -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> ExportSpecList a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> ExportSpecList a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> ExportSpecList a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> ExportSpecList a -> m
$cfoldr :: forall a b. (a -> b -> b) -> b -> ExportSpecList a -> b
foldr :: forall a b. (a -> b -> b) -> b -> ExportSpecList a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> ExportSpecList a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> ExportSpecList a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> ExportSpecList a -> b
foldl :: forall b a. (b -> a -> b) -> b -> ExportSpecList a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> ExportSpecList a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> ExportSpecList a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> ExportSpecList a -> a
foldr1 :: forall a. (a -> a -> a) -> ExportSpecList a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> ExportSpecList a -> a
foldl1 :: forall a. (a -> a -> a) -> ExportSpecList a -> a
$ctoList :: forall a. ExportSpecList a -> [a]
toList :: forall a. ExportSpecList a -> [a]
$cnull :: forall a. ExportSpecList a -> Bool
null :: forall a. ExportSpecList a -> Bool
$clength :: forall a. ExportSpecList a -> Int
length :: forall a. ExportSpecList a -> Int
$celem :: forall a. Eq a => a -> ExportSpecList a -> Bool
elem :: forall a. Eq a => a -> ExportSpecList a -> Bool
$cmaximum :: forall a. Ord a => ExportSpecList a -> a
maximum :: forall a. Ord a => ExportSpecList a -> a
$cminimum :: forall a. Ord a => ExportSpecList a -> a
minimum :: forall a. Ord a => ExportSpecList a -> a
$csum :: forall a. Num a => ExportSpecList a -> a
sum :: forall a. Num a => ExportSpecList a -> a
$cproduct :: forall a. Num a => ExportSpecList a -> a
product :: forall a. Num a => ExportSpecList a -> a
Foldable,Functor ExportSpecList
Foldable ExportSpecList
(Functor ExportSpecList, Foldable ExportSpecList) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> ExportSpecList a -> f (ExportSpecList b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    ExportSpecList (f a) -> f (ExportSpecList a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> ExportSpecList a -> m (ExportSpecList b))
-> (forall (m :: * -> *) a.
    Monad m =>
    ExportSpecList (m a) -> m (ExportSpecList a))
-> Traversable ExportSpecList
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a.
Monad m =>
ExportSpecList (m a) -> m (ExportSpecList a)
forall (f :: * -> *) a.
Applicative f =>
ExportSpecList (f a) -> f (ExportSpecList a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> ExportSpecList a -> m (ExportSpecList b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> ExportSpecList a -> f (ExportSpecList b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> ExportSpecList a -> f (ExportSpecList b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> ExportSpecList a -> f (ExportSpecList b)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
ExportSpecList (f a) -> f (ExportSpecList a)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
ExportSpecList (f a) -> f (ExportSpecList a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> ExportSpecList a -> m (ExportSpecList b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> ExportSpecList a -> m (ExportSpecList b)
$csequence :: forall (m :: * -> *) a.
Monad m =>
ExportSpecList (m a) -> m (ExportSpecList a)
sequence :: forall (m :: * -> *) a.
Monad m =>
ExportSpecList (m a) -> m (ExportSpecList a)
Traversable,(forall a b. (a -> b) -> ExportSpecList a -> ExportSpecList b)
-> (forall a b. a -> ExportSpecList b -> ExportSpecList a)
-> Functor ExportSpecList
forall a b. a -> ExportSpecList b -> ExportSpecList a
forall a b. (a -> b) -> ExportSpecList a -> ExportSpecList b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> ExportSpecList a -> ExportSpecList b
fmap :: forall a b. (a -> b) -> ExportSpecList a -> ExportSpecList b
$c<$ :: forall a b. a -> ExportSpecList b -> ExportSpecList a
<$ :: forall a b. a -> ExportSpecList b -> ExportSpecList a
Functor,(forall x. ExportSpecList l -> Rep (ExportSpecList l) x)
-> (forall x. Rep (ExportSpecList l) x -> ExportSpecList l)
-> Generic (ExportSpecList l)
forall x. Rep (ExportSpecList l) x -> ExportSpecList l
forall x. ExportSpecList l -> Rep (ExportSpecList l) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall l x. Rep (ExportSpecList l) x -> ExportSpecList l
forall l x. ExportSpecList l -> Rep (ExportSpecList l) x
$cfrom :: forall l x. ExportSpecList l -> Rep (ExportSpecList l) x
from :: forall x. ExportSpecList l -> Rep (ExportSpecList l) x
$cto :: forall l x. Rep (ExportSpecList l) x -> ExportSpecList l
to :: forall x. Rep (ExportSpecList l) x -> ExportSpecList l
Generic)

-- | An item in a module's export specification.
data ExportSpec l
     = EVar l (QName l)                 -- ^ variable.
     | EAbs l (Namespace l) (QName l)   -- ^ @T@:
                                        --   a class or datatype exported abstractly,
                                        --   or a type synonym.
     | EThingWith l (EWildcard l) (QName l) [CName l] -- ^ @T(C_1,...,C_n)@:
                                        --   a class exported with some of its methods, or
                                        --   a datatype exported with some of its constructors.
     | EModuleContents l (ModuleName l) -- ^ @module M@:
                                        --   re-export a module.
  deriving (ExportSpec l -> ExportSpec l -> Bool
(ExportSpec l -> ExportSpec l -> Bool)
-> (ExportSpec l -> ExportSpec l -> Bool) -> Eq (ExportSpec l)
forall l. Eq l => ExportSpec l -> ExportSpec l -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall l. Eq l => ExportSpec l -> ExportSpec l -> Bool
== :: ExportSpec l -> ExportSpec l -> Bool
$c/= :: forall l. Eq l => ExportSpec l -> ExportSpec l -> Bool
/= :: ExportSpec l -> ExportSpec l -> Bool
Eq,Eq (ExportSpec l)
Eq (ExportSpec l) =>
(ExportSpec l -> ExportSpec l -> Ordering)
-> (ExportSpec l -> ExportSpec l -> Bool)
-> (ExportSpec l -> ExportSpec l -> Bool)
-> (ExportSpec l -> ExportSpec l -> Bool)
-> (ExportSpec l -> ExportSpec l -> Bool)
-> (ExportSpec l -> ExportSpec l -> ExportSpec l)
-> (ExportSpec l -> ExportSpec l -> ExportSpec l)
-> Ord (ExportSpec l)
ExportSpec l -> ExportSpec l -> Bool
ExportSpec l -> ExportSpec l -> Ordering
ExportSpec l -> ExportSpec l -> ExportSpec l
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall l. Ord l => Eq (ExportSpec l)
forall l. Ord l => ExportSpec l -> ExportSpec l -> Bool
forall l. Ord l => ExportSpec l -> ExportSpec l -> Ordering
forall l. Ord l => ExportSpec l -> ExportSpec l -> ExportSpec l
$ccompare :: forall l. Ord l => ExportSpec l -> ExportSpec l -> Ordering
compare :: ExportSpec l -> ExportSpec l -> Ordering
$c< :: forall l. Ord l => ExportSpec l -> ExportSpec l -> Bool
< :: ExportSpec l -> ExportSpec l -> Bool
$c<= :: forall l. Ord l => ExportSpec l -> ExportSpec l -> Bool
<= :: ExportSpec l -> ExportSpec l -> Bool
$c> :: forall l. Ord l => ExportSpec l -> ExportSpec l -> Bool
> :: ExportSpec l -> ExportSpec l -> Bool
$c>= :: forall l. Ord l => ExportSpec l -> ExportSpec l -> Bool
>= :: ExportSpec l -> ExportSpec l -> Bool
$cmax :: forall l. Ord l => ExportSpec l -> ExportSpec l -> ExportSpec l
max :: ExportSpec l -> ExportSpec l -> ExportSpec l
$cmin :: forall l. Ord l => ExportSpec l -> ExportSpec l -> ExportSpec l
min :: ExportSpec l -> ExportSpec l -> ExportSpec l
Ord,Int -> ExportSpec l -> ShowS
[ExportSpec l] -> ShowS
ExportSpec l -> String
(Int -> ExportSpec l -> ShowS)
-> (ExportSpec l -> String)
-> ([ExportSpec l] -> ShowS)
-> Show (ExportSpec l)
forall l. Show l => Int -> ExportSpec l -> ShowS
forall l. Show l => [ExportSpec l] -> ShowS
forall l. Show l => ExportSpec l -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall l. Show l => Int -> ExportSpec l -> ShowS
showsPrec :: Int -> ExportSpec l -> ShowS
$cshow :: forall l. Show l => ExportSpec l -> String
show :: ExportSpec l -> String
$cshowList :: forall l. Show l => [ExportSpec l] -> ShowS
showList :: [ExportSpec l] -> ShowS
Show,Typeable,Typeable (ExportSpec l)
Typeable (ExportSpec l) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> ExportSpec l -> c (ExportSpec l))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (ExportSpec l))
-> (ExportSpec l -> Constr)
-> (ExportSpec l -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (ExportSpec l)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (ExportSpec l)))
-> ((forall b. Data b => b -> b) -> ExportSpec l -> ExportSpec l)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ExportSpec l -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ExportSpec l -> r)
-> (forall u. (forall d. Data d => d -> u) -> ExportSpec l -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> ExportSpec l -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ExportSpec l -> m (ExportSpec l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ExportSpec l -> m (ExportSpec l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ExportSpec l -> m (ExportSpec l))
-> Data (ExportSpec l)
ExportSpec l -> Constr
ExportSpec l -> DataType
(forall b. Data b => b -> b) -> ExportSpec l -> ExportSpec l
forall l. Data l => Typeable (ExportSpec l)
forall l. Data l => ExportSpec l -> Constr
forall l. Data l => ExportSpec l -> DataType
forall l.
Data l =>
(forall b. Data b => b -> b) -> ExportSpec l -> ExportSpec l
forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> ExportSpec l -> u
forall l u.
Data l =>
(forall d. Data d => d -> u) -> ExportSpec l -> [u]
forall l r r'.
Data l =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ExportSpec l -> r
forall l r r'.
Data l =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ExportSpec l -> r
forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d) -> ExportSpec l -> m (ExportSpec l)
forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> ExportSpec l -> m (ExportSpec l)
forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ExportSpec l)
forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ExportSpec l -> c (ExportSpec l)
forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (ExportSpec l))
forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ExportSpec l))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> ExportSpec l -> u
forall u. (forall d. Data d => d -> u) -> ExportSpec l -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ExportSpec l -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ExportSpec l -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ExportSpec l -> m (ExportSpec l)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ExportSpec l -> m (ExportSpec l)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ExportSpec l)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ExportSpec l -> c (ExportSpec l)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (ExportSpec l))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ExportSpec l))
$cgfoldl :: forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ExportSpec l -> c (ExportSpec l)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ExportSpec l -> c (ExportSpec l)
$cgunfold :: forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ExportSpec l)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ExportSpec l)
$ctoConstr :: forall l. Data l => ExportSpec l -> Constr
toConstr :: ExportSpec l -> Constr
$cdataTypeOf :: forall l. Data l => ExportSpec l -> DataType
dataTypeOf :: ExportSpec l -> DataType
$cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (ExportSpec l))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (ExportSpec l))
$cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ExportSpec l))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ExportSpec l))
$cgmapT :: forall l.
Data l =>
(forall b. Data b => b -> b) -> ExportSpec l -> ExportSpec l
gmapT :: (forall b. Data b => b -> b) -> ExportSpec l -> ExportSpec l
$cgmapQl :: forall l r r'.
Data l =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ExportSpec l -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ExportSpec l -> r
$cgmapQr :: forall l r r'.
Data l =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ExportSpec l -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ExportSpec l -> r
$cgmapQ :: forall l u.
Data l =>
(forall d. Data d => d -> u) -> ExportSpec l -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> ExportSpec l -> [u]
$cgmapQi :: forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> ExportSpec l -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ExportSpec l -> u
$cgmapM :: forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d) -> ExportSpec l -> m (ExportSpec l)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ExportSpec l -> m (ExportSpec l)
$cgmapMp :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> ExportSpec l -> m (ExportSpec l)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ExportSpec l -> m (ExportSpec l)
$cgmapMo :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> ExportSpec l -> m (ExportSpec l)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ExportSpec l -> m (ExportSpec l)
Data,(forall m. Monoid m => ExportSpec m -> m)
-> (forall m a. Monoid m => (a -> m) -> ExportSpec a -> m)
-> (forall m a. Monoid m => (a -> m) -> ExportSpec a -> m)
-> (forall a b. (a -> b -> b) -> b -> ExportSpec a -> b)
-> (forall a b. (a -> b -> b) -> b -> ExportSpec a -> b)
-> (forall b a. (b -> a -> b) -> b -> ExportSpec a -> b)
-> (forall b a. (b -> a -> b) -> b -> ExportSpec a -> b)
-> (forall a. (a -> a -> a) -> ExportSpec a -> a)
-> (forall a. (a -> a -> a) -> ExportSpec a -> a)
-> (forall a. ExportSpec a -> [a])
-> (forall a. ExportSpec a -> Bool)
-> (forall a. ExportSpec a -> Int)
-> (forall a. Eq a => a -> ExportSpec a -> Bool)
-> (forall a. Ord a => ExportSpec a -> a)
-> (forall a. Ord a => ExportSpec a -> a)
-> (forall a. Num a => ExportSpec a -> a)
-> (forall a. Num a => ExportSpec a -> a)
-> Foldable ExportSpec
forall a. Eq a => a -> ExportSpec a -> Bool
forall a. Num a => ExportSpec a -> a
forall a. Ord a => ExportSpec a -> a
forall m. Monoid m => ExportSpec m -> m
forall a. ExportSpec a -> Bool
forall a. ExportSpec a -> Int
forall a. ExportSpec a -> [a]
forall a. (a -> a -> a) -> ExportSpec a -> a
forall m a. Monoid m => (a -> m) -> ExportSpec a -> m
forall b a. (b -> a -> b) -> b -> ExportSpec a -> b
forall a b. (a -> b -> b) -> b -> ExportSpec a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall m. Monoid m => ExportSpec m -> m
fold :: forall m. Monoid m => ExportSpec m -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> ExportSpec a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> ExportSpec a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> ExportSpec a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> ExportSpec a -> m
$cfoldr :: forall a b. (a -> b -> b) -> b -> ExportSpec a -> b
foldr :: forall a b. (a -> b -> b) -> b -> ExportSpec a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> ExportSpec a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> ExportSpec a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> ExportSpec a -> b
foldl :: forall b a. (b -> a -> b) -> b -> ExportSpec a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> ExportSpec a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> ExportSpec a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> ExportSpec a -> a
foldr1 :: forall a. (a -> a -> a) -> ExportSpec a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> ExportSpec a -> a
foldl1 :: forall a. (a -> a -> a) -> ExportSpec a -> a
$ctoList :: forall a. ExportSpec a -> [a]
toList :: forall a. ExportSpec a -> [a]
$cnull :: forall a. ExportSpec a -> Bool
null :: forall a. ExportSpec a -> Bool
$clength :: forall a. ExportSpec a -> Int
length :: forall a. ExportSpec a -> Int
$celem :: forall a. Eq a => a -> ExportSpec a -> Bool
elem :: forall a. Eq a => a -> ExportSpec a -> Bool
$cmaximum :: forall a. Ord a => ExportSpec a -> a
maximum :: forall a. Ord a => ExportSpec a -> a
$cminimum :: forall a. Ord a => ExportSpec a -> a
minimum :: forall a. Ord a => ExportSpec a -> a
$csum :: forall a. Num a => ExportSpec a -> a
sum :: forall a. Num a => ExportSpec a -> a
$cproduct :: forall a. Num a => ExportSpec a -> a
product :: forall a. Num a => ExportSpec a -> a
Foldable,Functor ExportSpec
Foldable ExportSpec
(Functor ExportSpec, Foldable ExportSpec) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> ExportSpec a -> f (ExportSpec b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    ExportSpec (f a) -> f (ExportSpec a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> ExportSpec a -> m (ExportSpec b))
-> (forall (m :: * -> *) a.
    Monad m =>
    ExportSpec (m a) -> m (ExportSpec a))
-> Traversable ExportSpec
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a.
Monad m =>
ExportSpec (m a) -> m (ExportSpec a)
forall (f :: * -> *) a.
Applicative f =>
ExportSpec (f a) -> f (ExportSpec a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> ExportSpec a -> m (ExportSpec b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> ExportSpec a -> f (ExportSpec b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> ExportSpec a -> f (ExportSpec b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> ExportSpec a -> f (ExportSpec b)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
ExportSpec (f a) -> f (ExportSpec a)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
ExportSpec (f a) -> f (ExportSpec a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> ExportSpec a -> m (ExportSpec b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> ExportSpec a -> m (ExportSpec b)
$csequence :: forall (m :: * -> *) a.
Monad m =>
ExportSpec (m a) -> m (ExportSpec a)
sequence :: forall (m :: * -> *) a.
Monad m =>
ExportSpec (m a) -> m (ExportSpec a)
Traversable,(forall a b. (a -> b) -> ExportSpec a -> ExportSpec b)
-> (forall a b. a -> ExportSpec b -> ExportSpec a)
-> Functor ExportSpec
forall a b. a -> ExportSpec b -> ExportSpec a
forall a b. (a -> b) -> ExportSpec a -> ExportSpec b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> ExportSpec a -> ExportSpec b
fmap :: forall a b. (a -> b) -> ExportSpec a -> ExportSpec b
$c<$ :: forall a b. a -> ExportSpec b -> ExportSpec a
<$ :: forall a b. a -> ExportSpec b -> ExportSpec a
Functor,(forall x. ExportSpec l -> Rep (ExportSpec l) x)
-> (forall x. Rep (ExportSpec l) x -> ExportSpec l)
-> Generic (ExportSpec l)
forall x. Rep (ExportSpec l) x -> ExportSpec l
forall x. ExportSpec l -> Rep (ExportSpec l) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall l x. Rep (ExportSpec l) x -> ExportSpec l
forall l x. ExportSpec l -> Rep (ExportSpec l) x
$cfrom :: forall l x. ExportSpec l -> Rep (ExportSpec l) x
from :: forall x. ExportSpec l -> Rep (ExportSpec l) x
$cto :: forall l x. Rep (ExportSpec l) x -> ExportSpec l
to :: forall x. Rep (ExportSpec l) x -> ExportSpec l
Generic)

-- | Indicates the position of the wildcard in an export list
data EWildcard l = NoWildcard l | EWildcard l Int
  deriving (EWildcard l -> EWildcard l -> Bool
(EWildcard l -> EWildcard l -> Bool)
-> (EWildcard l -> EWildcard l -> Bool) -> Eq (EWildcard l)
forall l. Eq l => EWildcard l -> EWildcard l -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall l. Eq l => EWildcard l -> EWildcard l -> Bool
== :: EWildcard l -> EWildcard l -> Bool
$c/= :: forall l. Eq l => EWildcard l -> EWildcard l -> Bool
/= :: EWildcard l -> EWildcard l -> Bool
Eq,Eq (EWildcard l)
Eq (EWildcard l) =>
(EWildcard l -> EWildcard l -> Ordering)
-> (EWildcard l -> EWildcard l -> Bool)
-> (EWildcard l -> EWildcard l -> Bool)
-> (EWildcard l -> EWildcard l -> Bool)
-> (EWildcard l -> EWildcard l -> Bool)
-> (EWildcard l -> EWildcard l -> EWildcard l)
-> (EWildcard l -> EWildcard l -> EWildcard l)
-> Ord (EWildcard l)
EWildcard l -> EWildcard l -> Bool
EWildcard l -> EWildcard l -> Ordering
EWildcard l -> EWildcard l -> EWildcard l
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall l. Ord l => Eq (EWildcard l)
forall l. Ord l => EWildcard l -> EWildcard l -> Bool
forall l. Ord l => EWildcard l -> EWildcard l -> Ordering
forall l. Ord l => EWildcard l -> EWildcard l -> EWildcard l
$ccompare :: forall l. Ord l => EWildcard l -> EWildcard l -> Ordering
compare :: EWildcard l -> EWildcard l -> Ordering
$c< :: forall l. Ord l => EWildcard l -> EWildcard l -> Bool
< :: EWildcard l -> EWildcard l -> Bool
$c<= :: forall l. Ord l => EWildcard l -> EWildcard l -> Bool
<= :: EWildcard l -> EWildcard l -> Bool
$c> :: forall l. Ord l => EWildcard l -> EWildcard l -> Bool
> :: EWildcard l -> EWildcard l -> Bool
$c>= :: forall l. Ord l => EWildcard l -> EWildcard l -> Bool
>= :: EWildcard l -> EWildcard l -> Bool
$cmax :: forall l. Ord l => EWildcard l -> EWildcard l -> EWildcard l
max :: EWildcard l -> EWildcard l -> EWildcard l
$cmin :: forall l. Ord l => EWildcard l -> EWildcard l -> EWildcard l
min :: EWildcard l -> EWildcard l -> EWildcard l
Ord,Int -> EWildcard l -> ShowS
[EWildcard l] -> ShowS
EWildcard l -> String
(Int -> EWildcard l -> ShowS)
-> (EWildcard l -> String)
-> ([EWildcard l] -> ShowS)
-> Show (EWildcard l)
forall l. Show l => Int -> EWildcard l -> ShowS
forall l. Show l => [EWildcard l] -> ShowS
forall l. Show l => EWildcard l -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall l. Show l => Int -> EWildcard l -> ShowS
showsPrec :: Int -> EWildcard l -> ShowS
$cshow :: forall l. Show l => EWildcard l -> String
show :: EWildcard l -> String
$cshowList :: forall l. Show l => [EWildcard l] -> ShowS
showList :: [EWildcard l] -> ShowS
Show,Typeable,Typeable (EWildcard l)
Typeable (EWildcard l) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> EWildcard l -> c (EWildcard l))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (EWildcard l))
-> (EWildcard l -> Constr)
-> (EWildcard l -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (EWildcard l)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (EWildcard l)))
-> ((forall b. Data b => b -> b) -> EWildcard l -> EWildcard l)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> EWildcard l -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> EWildcard l -> r)
-> (forall u. (forall d. Data d => d -> u) -> EWildcard l -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> EWildcard l -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> EWildcard l -> m (EWildcard l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> EWildcard l -> m (EWildcard l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> EWildcard l -> m (EWildcard l))
-> Data (EWildcard l)
EWildcard l -> Constr
EWildcard l -> DataType
(forall b. Data b => b -> b) -> EWildcard l -> EWildcard l
forall l. Data l => Typeable (EWildcard l)
forall l. Data l => EWildcard l -> Constr
forall l. Data l => EWildcard l -> DataType
forall l.
Data l =>
(forall b. Data b => b -> b) -> EWildcard l -> EWildcard l
forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> EWildcard l -> u
forall l u.
Data l =>
(forall d. Data d => d -> u) -> EWildcard l -> [u]
forall l r r'.
Data l =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> EWildcard l -> r
forall l r r'.
Data l =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> EWildcard l -> r
forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d) -> EWildcard l -> m (EWildcard l)
forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> EWildcard l -> m (EWildcard l)
forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (EWildcard l)
forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> EWildcard l -> c (EWildcard l)
forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (EWildcard l))
forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (EWildcard l))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> EWildcard l -> u
forall u. (forall d. Data d => d -> u) -> EWildcard l -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> EWildcard l -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> EWildcard l -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> EWildcard l -> m (EWildcard l)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> EWildcard l -> m (EWildcard l)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (EWildcard l)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> EWildcard l -> c (EWildcard l)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (EWildcard l))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (EWildcard l))
$cgfoldl :: forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> EWildcard l -> c (EWildcard l)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> EWildcard l -> c (EWildcard l)
$cgunfold :: forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (EWildcard l)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (EWildcard l)
$ctoConstr :: forall l. Data l => EWildcard l -> Constr
toConstr :: EWildcard l -> Constr
$cdataTypeOf :: forall l. Data l => EWildcard l -> DataType
dataTypeOf :: EWildcard l -> DataType
$cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (EWildcard l))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (EWildcard l))
$cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (EWildcard l))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (EWildcard l))
$cgmapT :: forall l.
Data l =>
(forall b. Data b => b -> b) -> EWildcard l -> EWildcard l
gmapT :: (forall b. Data b => b -> b) -> EWildcard l -> EWildcard l
$cgmapQl :: forall l r r'.
Data l =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> EWildcard l -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> EWildcard l -> r
$cgmapQr :: forall l r r'.
Data l =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> EWildcard l -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> EWildcard l -> r
$cgmapQ :: forall l u.
Data l =>
(forall d. Data d => d -> u) -> EWildcard l -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> EWildcard l -> [u]
$cgmapQi :: forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> EWildcard l -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> EWildcard l -> u
$cgmapM :: forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d) -> EWildcard l -> m (EWildcard l)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> EWildcard l -> m (EWildcard l)
$cgmapMp :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> EWildcard l -> m (EWildcard l)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> EWildcard l -> m (EWildcard l)
$cgmapMo :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> EWildcard l -> m (EWildcard l)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> EWildcard l -> m (EWildcard l)
Data,(forall m. Monoid m => EWildcard m -> m)
-> (forall m a. Monoid m => (a -> m) -> EWildcard a -> m)
-> (forall m a. Monoid m => (a -> m) -> EWildcard a -> m)
-> (forall a b. (a -> b -> b) -> b -> EWildcard a -> b)
-> (forall a b. (a -> b -> b) -> b -> EWildcard a -> b)
-> (forall b a. (b -> a -> b) -> b -> EWildcard a -> b)
-> (forall b a. (b -> a -> b) -> b -> EWildcard a -> b)
-> (forall a. (a -> a -> a) -> EWildcard a -> a)
-> (forall a. (a -> a -> a) -> EWildcard a -> a)
-> (forall a. EWildcard a -> [a])
-> (forall a. EWildcard a -> Bool)
-> (forall a. EWildcard a -> Int)
-> (forall a. Eq a => a -> EWildcard a -> Bool)
-> (forall a. Ord a => EWildcard a -> a)
-> (forall a. Ord a => EWildcard a -> a)
-> (forall a. Num a => EWildcard a -> a)
-> (forall a. Num a => EWildcard a -> a)
-> Foldable EWildcard
forall a. Eq a => a -> EWildcard a -> Bool
forall a. Num a => EWildcard a -> a
forall a. Ord a => EWildcard a -> a
forall m. Monoid m => EWildcard m -> m
forall a. EWildcard a -> Bool
forall a. EWildcard a -> Int
forall a. EWildcard a -> [a]
forall a. (a -> a -> a) -> EWildcard a -> a
forall m a. Monoid m => (a -> m) -> EWildcard a -> m
forall b a. (b -> a -> b) -> b -> EWildcard a -> b
forall a b. (a -> b -> b) -> b -> EWildcard a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall m. Monoid m => EWildcard m -> m
fold :: forall m. Monoid m => EWildcard m -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> EWildcard a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> EWildcard a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> EWildcard a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> EWildcard a -> m
$cfoldr :: forall a b. (a -> b -> b) -> b -> EWildcard a -> b
foldr :: forall a b. (a -> b -> b) -> b -> EWildcard a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> EWildcard a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> EWildcard a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> EWildcard a -> b
foldl :: forall b a. (b -> a -> b) -> b -> EWildcard a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> EWildcard a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> EWildcard a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> EWildcard a -> a
foldr1 :: forall a. (a -> a -> a) -> EWildcard a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> EWildcard a -> a
foldl1 :: forall a. (a -> a -> a) -> EWildcard a -> a
$ctoList :: forall a. EWildcard a -> [a]
toList :: forall a. EWildcard a -> [a]
$cnull :: forall a. EWildcard a -> Bool
null :: forall a. EWildcard a -> Bool
$clength :: forall a. EWildcard a -> Int
length :: forall a. EWildcard a -> Int
$celem :: forall a. Eq a => a -> EWildcard a -> Bool
elem :: forall a. Eq a => a -> EWildcard a -> Bool
$cmaximum :: forall a. Ord a => EWildcard a -> a
maximum :: forall a. Ord a => EWildcard a -> a
$cminimum :: forall a. Ord a => EWildcard a -> a
minimum :: forall a. Ord a => EWildcard a -> a
$csum :: forall a. Num a => EWildcard a -> a
sum :: forall a. Num a => EWildcard a -> a
$cproduct :: forall a. Num a => EWildcard a -> a
product :: forall a. Num a => EWildcard a -> a
Foldable,Functor EWildcard
Foldable EWildcard
(Functor EWildcard, Foldable EWildcard) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> EWildcard a -> f (EWildcard b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    EWildcard (f a) -> f (EWildcard a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> EWildcard a -> m (EWildcard b))
-> (forall (m :: * -> *) a.
    Monad m =>
    EWildcard (m a) -> m (EWildcard a))
-> Traversable EWildcard
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a.
Monad m =>
EWildcard (m a) -> m (EWildcard a)
forall (f :: * -> *) a.
Applicative f =>
EWildcard (f a) -> f (EWildcard a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> EWildcard a -> m (EWildcard b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> EWildcard a -> f (EWildcard b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> EWildcard a -> f (EWildcard b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> EWildcard a -> f (EWildcard b)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
EWildcard (f a) -> f (EWildcard a)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
EWildcard (f a) -> f (EWildcard a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> EWildcard a -> m (EWildcard b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> EWildcard a -> m (EWildcard b)
$csequence :: forall (m :: * -> *) a.
Monad m =>
EWildcard (m a) -> m (EWildcard a)
sequence :: forall (m :: * -> *) a.
Monad m =>
EWildcard (m a) -> m (EWildcard a)
Traversable,(forall a b. (a -> b) -> EWildcard a -> EWildcard b)
-> (forall a b. a -> EWildcard b -> EWildcard a)
-> Functor EWildcard
forall a b. a -> EWildcard b -> EWildcard a
forall a b. (a -> b) -> EWildcard a -> EWildcard b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> EWildcard a -> EWildcard b
fmap :: forall a b. (a -> b) -> EWildcard a -> EWildcard b
$c<$ :: forall a b. a -> EWildcard b -> EWildcard a
<$ :: forall a b. a -> EWildcard b -> EWildcard a
Functor,(forall x. EWildcard l -> Rep (EWildcard l) x)
-> (forall x. Rep (EWildcard l) x -> EWildcard l)
-> Generic (EWildcard l)
forall x. Rep (EWildcard l) x -> EWildcard l
forall x. EWildcard l -> Rep (EWildcard l) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall l x. Rep (EWildcard l) x -> EWildcard l
forall l x. EWildcard l -> Rep (EWildcard l) x
$cfrom :: forall l x. EWildcard l -> Rep (EWildcard l) x
from :: forall x. EWildcard l -> Rep (EWildcard l) x
$cto :: forall l x. Rep (EWildcard l) x -> EWildcard l
to :: forall x. Rep (EWildcard l) x -> EWildcard l
Generic)

-- | Namespaces for imports/exports.
data Namespace l = NoNamespace l | TypeNamespace l | PatternNamespace l
  deriving (Namespace l -> Namespace l -> Bool
(Namespace l -> Namespace l -> Bool)
-> (Namespace l -> Namespace l -> Bool) -> Eq (Namespace l)
forall l. Eq l => Namespace l -> Namespace l -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall l. Eq l => Namespace l -> Namespace l -> Bool
== :: Namespace l -> Namespace l -> Bool
$c/= :: forall l. Eq l => Namespace l -> Namespace l -> Bool
/= :: Namespace l -> Namespace l -> Bool
Eq,Eq (Namespace l)
Eq (Namespace l) =>
(Namespace l -> Namespace l -> Ordering)
-> (Namespace l -> Namespace l -> Bool)
-> (Namespace l -> Namespace l -> Bool)
-> (Namespace l -> Namespace l -> Bool)
-> (Namespace l -> Namespace l -> Bool)
-> (Namespace l -> Namespace l -> Namespace l)
-> (Namespace l -> Namespace l -> Namespace l)
-> Ord (Namespace l)
Namespace l -> Namespace l -> Bool
Namespace l -> Namespace l -> Ordering
Namespace l -> Namespace l -> Namespace l
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall l. Ord l => Eq (Namespace l)
forall l. Ord l => Namespace l -> Namespace l -> Bool
forall l. Ord l => Namespace l -> Namespace l -> Ordering
forall l. Ord l => Namespace l -> Namespace l -> Namespace l
$ccompare :: forall l. Ord l => Namespace l -> Namespace l -> Ordering
compare :: Namespace l -> Namespace l -> Ordering
$c< :: forall l. Ord l => Namespace l -> Namespace l -> Bool
< :: Namespace l -> Namespace l -> Bool
$c<= :: forall l. Ord l => Namespace l -> Namespace l -> Bool
<= :: Namespace l -> Namespace l -> Bool
$c> :: forall l. Ord l => Namespace l -> Namespace l -> Bool
> :: Namespace l -> Namespace l -> Bool
$c>= :: forall l. Ord l => Namespace l -> Namespace l -> Bool
>= :: Namespace l -> Namespace l -> Bool
$cmax :: forall l. Ord l => Namespace l -> Namespace l -> Namespace l
max :: Namespace l -> Namespace l -> Namespace l
$cmin :: forall l. Ord l => Namespace l -> Namespace l -> Namespace l
min :: Namespace l -> Namespace l -> Namespace l
Ord,Int -> Namespace l -> ShowS
[Namespace l] -> ShowS
Namespace l -> String
(Int -> Namespace l -> ShowS)
-> (Namespace l -> String)
-> ([Namespace l] -> ShowS)
-> Show (Namespace l)
forall l. Show l => Int -> Namespace l -> ShowS
forall l. Show l => [Namespace l] -> ShowS
forall l. Show l => Namespace l -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall l. Show l => Int -> Namespace l -> ShowS
showsPrec :: Int -> Namespace l -> ShowS
$cshow :: forall l. Show l => Namespace l -> String
show :: Namespace l -> String
$cshowList :: forall l. Show l => [Namespace l] -> ShowS
showList :: [Namespace l] -> ShowS
Show,Typeable,Typeable (Namespace l)
Typeable (Namespace l) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Namespace l -> c (Namespace l))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Namespace l))
-> (Namespace l -> Constr)
-> (Namespace l -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Namespace l)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Namespace l)))
-> ((forall b. Data b => b -> b) -> Namespace l -> Namespace l)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Namespace l -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Namespace l -> r)
-> (forall u. (forall d. Data d => d -> u) -> Namespace l -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Namespace l -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Namespace l -> m (Namespace l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Namespace l -> m (Namespace l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Namespace l -> m (Namespace l))
-> Data (Namespace l)
Namespace l -> Constr
Namespace l -> DataType
(forall b. Data b => b -> b) -> Namespace l -> Namespace l
forall l. Data l => Typeable (Namespace l)
forall l. Data l => Namespace l -> Constr
forall l. Data l => Namespace l -> DataType
forall l.
Data l =>
(forall b. Data b => b -> b) -> Namespace l -> Namespace l
forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> Namespace l -> u
forall l u.
Data l =>
(forall d. Data d => d -> u) -> Namespace l -> [u]
forall l r r'.
Data l =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Namespace l -> r
forall l r r'.
Data l =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Namespace l -> r
forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d) -> Namespace l -> m (Namespace l)
forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Namespace l -> m (Namespace l)
forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Namespace l)
forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Namespace l -> c (Namespace l)
forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Namespace l))
forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Namespace l))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Namespace l -> u
forall u. (forall d. Data d => d -> u) -> Namespace l -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Namespace l -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Namespace l -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Namespace l -> m (Namespace l)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Namespace l -> m (Namespace l)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Namespace l)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Namespace l -> c (Namespace l)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Namespace l))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Namespace l))
$cgfoldl :: forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Namespace l -> c (Namespace l)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Namespace l -> c (Namespace l)
$cgunfold :: forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Namespace l)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Namespace l)
$ctoConstr :: forall l. Data l => Namespace l -> Constr
toConstr :: Namespace l -> Constr
$cdataTypeOf :: forall l. Data l => Namespace l -> DataType
dataTypeOf :: Namespace l -> DataType
$cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Namespace l))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Namespace l))
$cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Namespace l))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Namespace l))
$cgmapT :: forall l.
Data l =>
(forall b. Data b => b -> b) -> Namespace l -> Namespace l
gmapT :: (forall b. Data b => b -> b) -> Namespace l -> Namespace l
$cgmapQl :: forall l r r'.
Data l =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Namespace l -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Namespace l -> r
$cgmapQr :: forall l r r'.
Data l =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Namespace l -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Namespace l -> r
$cgmapQ :: forall l u.
Data l =>
(forall d. Data d => d -> u) -> Namespace l -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Namespace l -> [u]
$cgmapQi :: forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> Namespace l -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Namespace l -> u
$cgmapM :: forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d) -> Namespace l -> m (Namespace l)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Namespace l -> m (Namespace l)
$cgmapMp :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Namespace l -> m (Namespace l)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Namespace l -> m (Namespace l)
$cgmapMo :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Namespace l -> m (Namespace l)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Namespace l -> m (Namespace l)
Data,(forall m. Monoid m => Namespace m -> m)
-> (forall m a. Monoid m => (a -> m) -> Namespace a -> m)
-> (forall m a. Monoid m => (a -> m) -> Namespace a -> m)
-> (forall a b. (a -> b -> b) -> b -> Namespace a -> b)
-> (forall a b. (a -> b -> b) -> b -> Namespace a -> b)
-> (forall b a. (b -> a -> b) -> b -> Namespace a -> b)
-> (forall b a. (b -> a -> b) -> b -> Namespace a -> b)
-> (forall a. (a -> a -> a) -> Namespace a -> a)
-> (forall a. (a -> a -> a) -> Namespace a -> a)
-> (forall a. Namespace a -> [a])
-> (forall a. Namespace a -> Bool)
-> (forall a. Namespace a -> Int)
-> (forall a. Eq a => a -> Namespace a -> Bool)
-> (forall a. Ord a => Namespace a -> a)
-> (forall a. Ord a => Namespace a -> a)
-> (forall a. Num a => Namespace a -> a)
-> (forall a. Num a => Namespace a -> a)
-> Foldable Namespace
forall a. Eq a => a -> Namespace a -> Bool
forall a. Num a => Namespace a -> a
forall a. Ord a => Namespace a -> a
forall m. Monoid m => Namespace m -> m
forall a. Namespace a -> Bool
forall a. Namespace a -> Int
forall a. Namespace a -> [a]
forall a. (a -> a -> a) -> Namespace a -> a
forall m a. Monoid m => (a -> m) -> Namespace a -> m
forall b a. (b -> a -> b) -> b -> Namespace a -> b
forall a b. (a -> b -> b) -> b -> Namespace a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall m. Monoid m => Namespace m -> m
fold :: forall m. Monoid m => Namespace m -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> Namespace a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> Namespace a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> Namespace a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> Namespace a -> m
$cfoldr :: forall a b. (a -> b -> b) -> b -> Namespace a -> b
foldr :: forall a b. (a -> b -> b) -> b -> Namespace a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> Namespace a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> Namespace a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> Namespace a -> b
foldl :: forall b a. (b -> a -> b) -> b -> Namespace a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> Namespace a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> Namespace a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> Namespace a -> a
foldr1 :: forall a. (a -> a -> a) -> Namespace a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> Namespace a -> a
foldl1 :: forall a. (a -> a -> a) -> Namespace a -> a
$ctoList :: forall a. Namespace a -> [a]
toList :: forall a. Namespace a -> [a]
$cnull :: forall a. Namespace a -> Bool
null :: forall a. Namespace a -> Bool
$clength :: forall a. Namespace a -> Int
length :: forall a. Namespace a -> Int
$celem :: forall a. Eq a => a -> Namespace a -> Bool
elem :: forall a. Eq a => a -> Namespace a -> Bool
$cmaximum :: forall a. Ord a => Namespace a -> a
maximum :: forall a. Ord a => Namespace a -> a
$cminimum :: forall a. Ord a => Namespace a -> a
minimum :: forall a. Ord a => Namespace a -> a
$csum :: forall a. Num a => Namespace a -> a
sum :: forall a. Num a => Namespace a -> a
$cproduct :: forall a. Num a => Namespace a -> a
product :: forall a. Num a => Namespace a -> a
Foldable,Functor Namespace
Foldable Namespace
(Functor Namespace, Foldable Namespace) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> Namespace a -> f (Namespace b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    Namespace (f a) -> f (Namespace a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Namespace a -> m (Namespace b))
-> (forall (m :: * -> *) a.
    Monad m =>
    Namespace (m a) -> m (Namespace a))
-> Traversable Namespace
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a.
Monad m =>
Namespace (m a) -> m (Namespace a)
forall (f :: * -> *) a.
Applicative f =>
Namespace (f a) -> f (Namespace a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Namespace a -> m (Namespace b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Namespace a -> f (Namespace b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Namespace a -> f (Namespace b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Namespace a -> f (Namespace b)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
Namespace (f a) -> f (Namespace a)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
Namespace (f a) -> f (Namespace a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Namespace a -> m (Namespace b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Namespace a -> m (Namespace b)
$csequence :: forall (m :: * -> *) a.
Monad m =>
Namespace (m a) -> m (Namespace a)
sequence :: forall (m :: * -> *) a.
Monad m =>
Namespace (m a) -> m (Namespace a)
Traversable,(forall a b. (a -> b) -> Namespace a -> Namespace b)
-> (forall a b. a -> Namespace b -> Namespace a)
-> Functor Namespace
forall a b. a -> Namespace b -> Namespace a
forall a b. (a -> b) -> Namespace a -> Namespace b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> Namespace a -> Namespace b
fmap :: forall a b. (a -> b) -> Namespace a -> Namespace b
$c<$ :: forall a b. a -> Namespace b -> Namespace a
<$ :: forall a b. a -> Namespace b -> Namespace a
Functor,(forall x. Namespace l -> Rep (Namespace l) x)
-> (forall x. Rep (Namespace l) x -> Namespace l)
-> Generic (Namespace l)
forall x. Rep (Namespace l) x -> Namespace l
forall x. Namespace l -> Rep (Namespace l) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall l x. Rep (Namespace l) x -> Namespace l
forall l x. Namespace l -> Rep (Namespace l) x
$cfrom :: forall l x. Namespace l -> Rep (Namespace l) x
from :: forall x. Namespace l -> Rep (Namespace l) x
$cto :: forall l x. Rep (Namespace l) x -> Namespace l
to :: forall x. Rep (Namespace l) x -> Namespace l
Generic)

-- | An import declaration.
data ImportDecl l = ImportDecl
    { forall l. ImportDecl l -> l
importAnn :: l                   -- ^ annotation, used by parser for position of the @import@ keyword.
    , forall l. ImportDecl l -> ModuleName l
importModule :: ModuleName l     -- ^ name of the module imported.
    , forall l. ImportDecl l -> Bool
importQualified :: Bool          -- ^ imported @qualified@?
    , forall l. ImportDecl l -> Bool
importSrc :: Bool                -- ^ imported with @{-\# SOURCE \#-}@?
    , forall l. ImportDecl l -> Bool
importSafe :: Bool               -- ^ Import @safe@?
    , forall l. ImportDecl l -> Maybe String
importPkg :: Maybe String        -- ^ imported with explicit package name
    , forall l. ImportDecl l -> Maybe (ModuleName l)
importAs :: Maybe (ModuleName l) -- ^ optional alias name in an @as@ clause.
    , forall l. ImportDecl l -> Maybe (ImportSpecList l)
importSpecs :: Maybe (ImportSpecList l)
            -- ^ optional list of import specifications.
    }
  deriving (ImportDecl l -> ImportDecl l -> Bool
(ImportDecl l -> ImportDecl l -> Bool)
-> (ImportDecl l -> ImportDecl l -> Bool) -> Eq (ImportDecl l)
forall l. Eq l => ImportDecl l -> ImportDecl l -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall l. Eq l => ImportDecl l -> ImportDecl l -> Bool
== :: ImportDecl l -> ImportDecl l -> Bool
$c/= :: forall l. Eq l => ImportDecl l -> ImportDecl l -> Bool
/= :: ImportDecl l -> ImportDecl l -> Bool
Eq,Eq (ImportDecl l)
Eq (ImportDecl l) =>
(ImportDecl l -> ImportDecl l -> Ordering)
-> (ImportDecl l -> ImportDecl l -> Bool)
-> (ImportDecl l -> ImportDecl l -> Bool)
-> (ImportDecl l -> ImportDecl l -> Bool)
-> (ImportDecl l -> ImportDecl l -> Bool)
-> (ImportDecl l -> ImportDecl l -> ImportDecl l)
-> (ImportDecl l -> ImportDecl l -> ImportDecl l)
-> Ord (ImportDecl l)
ImportDecl l -> ImportDecl l -> Bool
ImportDecl l -> ImportDecl l -> Ordering
ImportDecl l -> ImportDecl l -> ImportDecl l
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall l. Ord l => Eq (ImportDecl l)
forall l. Ord l => ImportDecl l -> ImportDecl l -> Bool
forall l. Ord l => ImportDecl l -> ImportDecl l -> Ordering
forall l. Ord l => ImportDecl l -> ImportDecl l -> ImportDecl l
$ccompare :: forall l. Ord l => ImportDecl l -> ImportDecl l -> Ordering
compare :: ImportDecl l -> ImportDecl l -> Ordering
$c< :: forall l. Ord l => ImportDecl l -> ImportDecl l -> Bool
< :: ImportDecl l -> ImportDecl l -> Bool
$c<= :: forall l. Ord l => ImportDecl l -> ImportDecl l -> Bool
<= :: ImportDecl l -> ImportDecl l -> Bool
$c> :: forall l. Ord l => ImportDecl l -> ImportDecl l -> Bool
> :: ImportDecl l -> ImportDecl l -> Bool
$c>= :: forall l. Ord l => ImportDecl l -> ImportDecl l -> Bool
>= :: ImportDecl l -> ImportDecl l -> Bool
$cmax :: forall l. Ord l => ImportDecl l -> ImportDecl l -> ImportDecl l
max :: ImportDecl l -> ImportDecl l -> ImportDecl l
$cmin :: forall l. Ord l => ImportDecl l -> ImportDecl l -> ImportDecl l
min :: ImportDecl l -> ImportDecl l -> ImportDecl l
Ord,Int -> ImportDecl l -> ShowS
[ImportDecl l] -> ShowS
ImportDecl l -> String
(Int -> ImportDecl l -> ShowS)
-> (ImportDecl l -> String)
-> ([ImportDecl l] -> ShowS)
-> Show (ImportDecl l)
forall l. Show l => Int -> ImportDecl l -> ShowS
forall l. Show l => [ImportDecl l] -> ShowS
forall l. Show l => ImportDecl l -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall l. Show l => Int -> ImportDecl l -> ShowS
showsPrec :: Int -> ImportDecl l -> ShowS
$cshow :: forall l. Show l => ImportDecl l -> String
show :: ImportDecl l -> String
$cshowList :: forall l. Show l => [ImportDecl l] -> ShowS
showList :: [ImportDecl l] -> ShowS
Show,Typeable,Typeable (ImportDecl l)
Typeable (ImportDecl l) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> ImportDecl l -> c (ImportDecl l))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (ImportDecl l))
-> (ImportDecl l -> Constr)
-> (ImportDecl l -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (ImportDecl l)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (ImportDecl l)))
-> ((forall b. Data b => b -> b) -> ImportDecl l -> ImportDecl l)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ImportDecl l -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ImportDecl l -> r)
-> (forall u. (forall d. Data d => d -> u) -> ImportDecl l -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> ImportDecl l -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ImportDecl l -> m (ImportDecl l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ImportDecl l -> m (ImportDecl l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ImportDecl l -> m (ImportDecl l))
-> Data (ImportDecl l)
ImportDecl l -> Constr
ImportDecl l -> DataType
(forall b. Data b => b -> b) -> ImportDecl l -> ImportDecl l
forall l. Data l => Typeable (ImportDecl l)
forall l. Data l => ImportDecl l -> Constr
forall l. Data l => ImportDecl l -> DataType
forall l.
Data l =>
(forall b. Data b => b -> b) -> ImportDecl l -> ImportDecl l
forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> ImportDecl l -> u
forall l u.
Data l =>
(forall d. Data d => d -> u) -> ImportDecl l -> [u]
forall l r r'.
Data l =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ImportDecl l -> r
forall l r r'.
Data l =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ImportDecl l -> r
forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d) -> ImportDecl l -> m (ImportDecl l)
forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> ImportDecl l -> m (ImportDecl l)
forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ImportDecl l)
forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ImportDecl l -> c (ImportDecl l)
forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (ImportDecl l))
forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ImportDecl l))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> ImportDecl l -> u
forall u. (forall d. Data d => d -> u) -> ImportDecl l -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ImportDecl l -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ImportDecl l -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ImportDecl l -> m (ImportDecl l)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ImportDecl l -> m (ImportDecl l)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ImportDecl l)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ImportDecl l -> c (ImportDecl l)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (ImportDecl l))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ImportDecl l))
$cgfoldl :: forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ImportDecl l -> c (ImportDecl l)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ImportDecl l -> c (ImportDecl l)
$cgunfold :: forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ImportDecl l)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ImportDecl l)
$ctoConstr :: forall l. Data l => ImportDecl l -> Constr
toConstr :: ImportDecl l -> Constr
$cdataTypeOf :: forall l. Data l => ImportDecl l -> DataType
dataTypeOf :: ImportDecl l -> DataType
$cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (ImportDecl l))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (ImportDecl l))
$cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ImportDecl l))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ImportDecl l))
$cgmapT :: forall l.
Data l =>
(forall b. Data b => b -> b) -> ImportDecl l -> ImportDecl l
gmapT :: (forall b. Data b => b -> b) -> ImportDecl l -> ImportDecl l
$cgmapQl :: forall l r r'.
Data l =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ImportDecl l -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ImportDecl l -> r
$cgmapQr :: forall l r r'.
Data l =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ImportDecl l -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ImportDecl l -> r
$cgmapQ :: forall l u.
Data l =>
(forall d. Data d => d -> u) -> ImportDecl l -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> ImportDecl l -> [u]
$cgmapQi :: forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> ImportDecl l -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ImportDecl l -> u
$cgmapM :: forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d) -> ImportDecl l -> m (ImportDecl l)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ImportDecl l -> m (ImportDecl l)
$cgmapMp :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> ImportDecl l -> m (ImportDecl l)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ImportDecl l -> m (ImportDecl l)
$cgmapMo :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> ImportDecl l -> m (ImportDecl l)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ImportDecl l -> m (ImportDecl l)
Data,(forall m. Monoid m => ImportDecl m -> m)
-> (forall m a. Monoid m => (a -> m) -> ImportDecl a -> m)
-> (forall m a. Monoid m => (a -> m) -> ImportDecl a -> m)
-> (forall a b. (a -> b -> b) -> b -> ImportDecl a -> b)
-> (forall a b. (a -> b -> b) -> b -> ImportDecl a -> b)
-> (forall b a. (b -> a -> b) -> b -> ImportDecl a -> b)
-> (forall b a. (b -> a -> b) -> b -> ImportDecl a -> b)
-> (forall a. (a -> a -> a) -> ImportDecl a -> a)
-> (forall a. (a -> a -> a) -> ImportDecl a -> a)
-> (forall a. ImportDecl a -> [a])
-> (forall l. ImportDecl l -> Bool)
-> (forall a. ImportDecl a -> Int)
-> (forall a. Eq a => a -> ImportDecl a -> Bool)
-> (forall a. Ord a => ImportDecl a -> a)
-> (forall a. Ord a => ImportDecl a -> a)
-> (forall a. Num a => ImportDecl a -> a)
-> (forall a. Num a => ImportDecl a -> a)
-> Foldable ImportDecl
forall a. Eq a => a -> ImportDecl a -> Bool
forall a. Num a => ImportDecl a -> a
forall a. Ord a => ImportDecl a -> a
forall m. Monoid m => ImportDecl m -> m
forall l. ImportDecl l -> Bool
forall a. ImportDecl a -> Int
forall a. ImportDecl a -> [a]
forall a. (a -> a -> a) -> ImportDecl a -> a
forall m a. Monoid m => (a -> m) -> ImportDecl a -> m
forall b a. (b -> a -> b) -> b -> ImportDecl a -> b
forall a b. (a -> b -> b) -> b -> ImportDecl a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall m. Monoid m => ImportDecl m -> m
fold :: forall m. Monoid m => ImportDecl m -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> ImportDecl a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> ImportDecl a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> ImportDecl a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> ImportDecl a -> m
$cfoldr :: forall a b. (a -> b -> b) -> b -> ImportDecl a -> b
foldr :: forall a b. (a -> b -> b) -> b -> ImportDecl a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> ImportDecl a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> ImportDecl a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> ImportDecl a -> b
foldl :: forall b a. (b -> a -> b) -> b -> ImportDecl a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> ImportDecl a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> ImportDecl a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> ImportDecl a -> a
foldr1 :: forall a. (a -> a -> a) -> ImportDecl a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> ImportDecl a -> a
foldl1 :: forall a. (a -> a -> a) -> ImportDecl a -> a
$ctoList :: forall a. ImportDecl a -> [a]
toList :: forall a. ImportDecl a -> [a]
$cnull :: forall l. ImportDecl l -> Bool
null :: forall l. ImportDecl l -> Bool
$clength :: forall a. ImportDecl a -> Int
length :: forall a. ImportDecl a -> Int
$celem :: forall a. Eq a => a -> ImportDecl a -> Bool
elem :: forall a. Eq a => a -> ImportDecl a -> Bool
$cmaximum :: forall a. Ord a => ImportDecl a -> a
maximum :: forall a. Ord a => ImportDecl a -> a
$cminimum :: forall a. Ord a => ImportDecl a -> a
minimum :: forall a. Ord a => ImportDecl a -> a
$csum :: forall a. Num a => ImportDecl a -> a
sum :: forall a. Num a => ImportDecl a -> a
$cproduct :: forall a. Num a => ImportDecl a -> a
product :: forall a. Num a => ImportDecl a -> a
Foldable,Functor ImportDecl
Foldable ImportDecl
(Functor ImportDecl, Foldable ImportDecl) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> ImportDecl a -> f (ImportDecl b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    ImportDecl (f a) -> f (ImportDecl a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> ImportDecl a -> m (ImportDecl b))
-> (forall (m :: * -> *) a.
    Monad m =>
    ImportDecl (m a) -> m (ImportDecl a))
-> Traversable ImportDecl
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a.
Monad m =>
ImportDecl (m a) -> m (ImportDecl a)
forall (f :: * -> *) a.
Applicative f =>
ImportDecl (f a) -> f (ImportDecl a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> ImportDecl a -> m (ImportDecl b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> ImportDecl a -> f (ImportDecl b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> ImportDecl a -> f (ImportDecl b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> ImportDecl a -> f (ImportDecl b)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
ImportDecl (f a) -> f (ImportDecl a)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
ImportDecl (f a) -> f (ImportDecl a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> ImportDecl a -> m (ImportDecl b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> ImportDecl a -> m (ImportDecl b)
$csequence :: forall (m :: * -> *) a.
Monad m =>
ImportDecl (m a) -> m (ImportDecl a)
sequence :: forall (m :: * -> *) a.
Monad m =>
ImportDecl (m a) -> m (ImportDecl a)
Traversable,(forall a b. (a -> b) -> ImportDecl a -> ImportDecl b)
-> (forall a b. a -> ImportDecl b -> ImportDecl a)
-> Functor ImportDecl
forall a b. a -> ImportDecl b -> ImportDecl a
forall a b. (a -> b) -> ImportDecl a -> ImportDecl b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> ImportDecl a -> ImportDecl b
fmap :: forall a b. (a -> b) -> ImportDecl a -> ImportDecl b
$c<$ :: forall a b. a -> ImportDecl b -> ImportDecl a
<$ :: forall a b. a -> ImportDecl b -> ImportDecl a
Functor,(forall x. ImportDecl l -> Rep (ImportDecl l) x)
-> (forall x. Rep (ImportDecl l) x -> ImportDecl l)
-> Generic (ImportDecl l)
forall x. Rep (ImportDecl l) x -> ImportDecl l
forall x. ImportDecl l -> Rep (ImportDecl l) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall l x. Rep (ImportDecl l) x -> ImportDecl l
forall l x. ImportDecl l -> Rep (ImportDecl l) x
$cfrom :: forall l x. ImportDecl l -> Rep (ImportDecl l) x
from :: forall x. ImportDecl l -> Rep (ImportDecl l) x
$cto :: forall l x. Rep (ImportDecl l) x -> ImportDecl l
to :: forall x. Rep (ImportDecl l) x -> ImportDecl l
Generic)

-- | An explicit import specification list.
data ImportSpecList l
    = ImportSpecList l Bool [ImportSpec l]
            -- ^ A list of import specifications.
            -- The 'Bool' is 'True' if the names are excluded
            -- by @hiding@.
  deriving (ImportSpecList l -> ImportSpecList l -> Bool
(ImportSpecList l -> ImportSpecList l -> Bool)
-> (ImportSpecList l -> ImportSpecList l -> Bool)
-> Eq (ImportSpecList l)
forall l. Eq l => ImportSpecList l -> ImportSpecList l -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall l. Eq l => ImportSpecList l -> ImportSpecList l -> Bool
== :: ImportSpecList l -> ImportSpecList l -> Bool
$c/= :: forall l. Eq l => ImportSpecList l -> ImportSpecList l -> Bool
/= :: ImportSpecList l -> ImportSpecList l -> Bool
Eq,Eq (ImportSpecList l)
Eq (ImportSpecList l) =>
(ImportSpecList l -> ImportSpecList l -> Ordering)
-> (ImportSpecList l -> ImportSpecList l -> Bool)
-> (ImportSpecList l -> ImportSpecList l -> Bool)
-> (ImportSpecList l -> ImportSpecList l -> Bool)
-> (ImportSpecList l -> ImportSpecList l -> Bool)
-> (ImportSpecList l -> ImportSpecList l -> ImportSpecList l)
-> (ImportSpecList l -> ImportSpecList l -> ImportSpecList l)
-> Ord (ImportSpecList l)
ImportSpecList l -> ImportSpecList l -> Bool
ImportSpecList l -> ImportSpecList l -> Ordering
ImportSpecList l -> ImportSpecList l -> ImportSpecList l
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall l. Ord l => Eq (ImportSpecList l)
forall l. Ord l => ImportSpecList l -> ImportSpecList l -> Bool
forall l. Ord l => ImportSpecList l -> ImportSpecList l -> Ordering
forall l.
Ord l =>
ImportSpecList l -> ImportSpecList l -> ImportSpecList l
$ccompare :: forall l. Ord l => ImportSpecList l -> ImportSpecList l -> Ordering
compare :: ImportSpecList l -> ImportSpecList l -> Ordering
$c< :: forall l. Ord l => ImportSpecList l -> ImportSpecList l -> Bool
< :: ImportSpecList l -> ImportSpecList l -> Bool
$c<= :: forall l. Ord l => ImportSpecList l -> ImportSpecList l -> Bool
<= :: ImportSpecList l -> ImportSpecList l -> Bool
$c> :: forall l. Ord l => ImportSpecList l -> ImportSpecList l -> Bool
> :: ImportSpecList l -> ImportSpecList l -> Bool
$c>= :: forall l. Ord l => ImportSpecList l -> ImportSpecList l -> Bool
>= :: ImportSpecList l -> ImportSpecList l -> Bool
$cmax :: forall l.
Ord l =>
ImportSpecList l -> ImportSpecList l -> ImportSpecList l
max :: ImportSpecList l -> ImportSpecList l -> ImportSpecList l
$cmin :: forall l.
Ord l =>
ImportSpecList l -> ImportSpecList l -> ImportSpecList l
min :: ImportSpecList l -> ImportSpecList l -> ImportSpecList l
Ord,Int -> ImportSpecList l -> ShowS
[ImportSpecList l] -> ShowS
ImportSpecList l -> String
(Int -> ImportSpecList l -> ShowS)
-> (ImportSpecList l -> String)
-> ([ImportSpecList l] -> ShowS)
-> Show (ImportSpecList l)
forall l. Show l => Int -> ImportSpecList l -> ShowS
forall l. Show l => [ImportSpecList l] -> ShowS
forall l. Show l => ImportSpecList l -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall l. Show l => Int -> ImportSpecList l -> ShowS
showsPrec :: Int -> ImportSpecList l -> ShowS
$cshow :: forall l. Show l => ImportSpecList l -> String
show :: ImportSpecList l -> String
$cshowList :: forall l. Show l => [ImportSpecList l] -> ShowS
showList :: [ImportSpecList l] -> ShowS
Show,Typeable,Typeable (ImportSpecList l)
Typeable (ImportSpecList l) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g)
 -> ImportSpecList l
 -> c (ImportSpecList l))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (ImportSpecList l))
-> (ImportSpecList l -> Constr)
-> (ImportSpecList l -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (ImportSpecList l)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (ImportSpecList l)))
-> ((forall b. Data b => b -> b)
    -> ImportSpecList l -> ImportSpecList l)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ImportSpecList l -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ImportSpecList l -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> ImportSpecList l -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> ImportSpecList l -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> ImportSpecList l -> m (ImportSpecList l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> ImportSpecList l -> m (ImportSpecList l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> ImportSpecList l -> m (ImportSpecList l))
-> Data (ImportSpecList l)
ImportSpecList l -> Constr
ImportSpecList l -> DataType
(forall b. Data b => b -> b)
-> ImportSpecList l -> ImportSpecList l
forall l. Data l => Typeable (ImportSpecList l)
forall l. Data l => ImportSpecList l -> Constr
forall l. Data l => ImportSpecList l -> DataType
forall l.
Data l =>
(forall b. Data b => b -> b)
-> ImportSpecList l -> ImportSpecList l
forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> ImportSpecList l -> u
forall l u.
Data l =>
(forall d. Data d => d -> u) -> ImportSpecList l -> [u]
forall l r r'.
Data l =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ImportSpecList l -> r
forall l r r'.
Data l =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ImportSpecList l -> r
forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d)
-> ImportSpecList l -> m (ImportSpecList l)
forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> ImportSpecList l -> m (ImportSpecList l)
forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ImportSpecList l)
forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ImportSpecList l -> c (ImportSpecList l)
forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (ImportSpecList l))
forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ImportSpecList l))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> ImportSpecList l -> u
forall u. (forall d. Data d => d -> u) -> ImportSpecList l -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ImportSpecList l -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ImportSpecList l -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> ImportSpecList l -> m (ImportSpecList l)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ImportSpecList l -> m (ImportSpecList l)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ImportSpecList l)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ImportSpecList l -> c (ImportSpecList l)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (ImportSpecList l))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ImportSpecList l))
$cgfoldl :: forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ImportSpecList l -> c (ImportSpecList l)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ImportSpecList l -> c (ImportSpecList l)
$cgunfold :: forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ImportSpecList l)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ImportSpecList l)
$ctoConstr :: forall l. Data l => ImportSpecList l -> Constr
toConstr :: ImportSpecList l -> Constr
$cdataTypeOf :: forall l. Data l => ImportSpecList l -> DataType
dataTypeOf :: ImportSpecList l -> DataType
$cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (ImportSpecList l))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (ImportSpecList l))
$cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ImportSpecList l))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ImportSpecList l))
$cgmapT :: forall l.
Data l =>
(forall b. Data b => b -> b)
-> ImportSpecList l -> ImportSpecList l
gmapT :: (forall b. Data b => b -> b)
-> ImportSpecList l -> ImportSpecList l
$cgmapQl :: forall l r r'.
Data l =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ImportSpecList l -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ImportSpecList l -> r
$cgmapQr :: forall l r r'.
Data l =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ImportSpecList l -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ImportSpecList l -> r
$cgmapQ :: forall l u.
Data l =>
(forall d. Data d => d -> u) -> ImportSpecList l -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> ImportSpecList l -> [u]
$cgmapQi :: forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> ImportSpecList l -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> ImportSpecList l -> u
$cgmapM :: forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d)
-> ImportSpecList l -> m (ImportSpecList l)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> ImportSpecList l -> m (ImportSpecList l)
$cgmapMp :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> ImportSpecList l -> m (ImportSpecList l)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ImportSpecList l -> m (ImportSpecList l)
$cgmapMo :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> ImportSpecList l -> m (ImportSpecList l)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ImportSpecList l -> m (ImportSpecList l)
Data,(forall m. Monoid m => ImportSpecList m -> m)
-> (forall m a. Monoid m => (a -> m) -> ImportSpecList a -> m)
-> (forall m a. Monoid m => (a -> m) -> ImportSpecList a -> m)
-> (forall a b. (a -> b -> b) -> b -> ImportSpecList a -> b)
-> (forall a b. (a -> b -> b) -> b -> ImportSpecList a -> b)
-> (forall b a. (b -> a -> b) -> b -> ImportSpecList a -> b)
-> (forall b a. (b -> a -> b) -> b -> ImportSpecList a -> b)
-> (forall a. (a -> a -> a) -> ImportSpecList a -> a)
-> (forall a. (a -> a -> a) -> ImportSpecList a -> a)
-> (forall a. ImportSpecList a -> [a])
-> (forall a. ImportSpecList a -> Bool)
-> (forall a. ImportSpecList a -> Int)
-> (forall a. Eq a => a -> ImportSpecList a -> Bool)
-> (forall a. Ord a => ImportSpecList a -> a)
-> (forall a. Ord a => ImportSpecList a -> a)
-> (forall a. Num a => ImportSpecList a -> a)
-> (forall a. Num a => ImportSpecList a -> a)
-> Foldable ImportSpecList
forall a. Eq a => a -> ImportSpecList a -> Bool
forall a. Num a => ImportSpecList a -> a
forall a. Ord a => ImportSpecList a -> a
forall m. Monoid m => ImportSpecList m -> m
forall a. ImportSpecList a -> Bool
forall a. ImportSpecList a -> Int
forall a. ImportSpecList a -> [a]
forall a. (a -> a -> a) -> ImportSpecList a -> a
forall m a. Monoid m => (a -> m) -> ImportSpecList a -> m
forall b a. (b -> a -> b) -> b -> ImportSpecList a -> b
forall a b. (a -> b -> b) -> b -> ImportSpecList a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall m. Monoid m => ImportSpecList m -> m
fold :: forall m. Monoid m => ImportSpecList m -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> ImportSpecList a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> ImportSpecList a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> ImportSpecList a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> ImportSpecList a -> m
$cfoldr :: forall a b. (a -> b -> b) -> b -> ImportSpecList a -> b
foldr :: forall a b. (a -> b -> b) -> b -> ImportSpecList a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> ImportSpecList a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> ImportSpecList a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> ImportSpecList a -> b
foldl :: forall b a. (b -> a -> b) -> b -> ImportSpecList a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> ImportSpecList a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> ImportSpecList a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> ImportSpecList a -> a
foldr1 :: forall a. (a -> a -> a) -> ImportSpecList a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> ImportSpecList a -> a
foldl1 :: forall a. (a -> a -> a) -> ImportSpecList a -> a
$ctoList :: forall a. ImportSpecList a -> [a]
toList :: forall a. ImportSpecList a -> [a]
$cnull :: forall a. ImportSpecList a -> Bool
null :: forall a. ImportSpecList a -> Bool
$clength :: forall a. ImportSpecList a -> Int
length :: forall a. ImportSpecList a -> Int
$celem :: forall a. Eq a => a -> ImportSpecList a -> Bool
elem :: forall a. Eq a => a -> ImportSpecList a -> Bool
$cmaximum :: forall a. Ord a => ImportSpecList a -> a
maximum :: forall a. Ord a => ImportSpecList a -> a
$cminimum :: forall a. Ord a => ImportSpecList a -> a
minimum :: forall a. Ord a => ImportSpecList a -> a
$csum :: forall a. Num a => ImportSpecList a -> a
sum :: forall a. Num a => ImportSpecList a -> a
$cproduct :: forall a. Num a => ImportSpecList a -> a
product :: forall a. Num a => ImportSpecList a -> a
Foldable,Functor ImportSpecList
Foldable ImportSpecList
(Functor ImportSpecList, Foldable ImportSpecList) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> ImportSpecList a -> f (ImportSpecList b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    ImportSpecList (f a) -> f (ImportSpecList a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> ImportSpecList a -> m (ImportSpecList b))
-> (forall (m :: * -> *) a.
    Monad m =>
    ImportSpecList (m a) -> m (ImportSpecList a))
-> Traversable ImportSpecList
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a.
Monad m =>
ImportSpecList (m a) -> m (ImportSpecList a)
forall (f :: * -> *) a.
Applicative f =>
ImportSpecList (f a) -> f (ImportSpecList a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> ImportSpecList a -> m (ImportSpecList b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> ImportSpecList a -> f (ImportSpecList b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> ImportSpecList a -> f (ImportSpecList b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> ImportSpecList a -> f (ImportSpecList b)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
ImportSpecList (f a) -> f (ImportSpecList a)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
ImportSpecList (f a) -> f (ImportSpecList a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> ImportSpecList a -> m (ImportSpecList b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> ImportSpecList a -> m (ImportSpecList b)
$csequence :: forall (m :: * -> *) a.
Monad m =>
ImportSpecList (m a) -> m (ImportSpecList a)
sequence :: forall (m :: * -> *) a.
Monad m =>
ImportSpecList (m a) -> m (ImportSpecList a)
Traversable,(forall a b. (a -> b) -> ImportSpecList a -> ImportSpecList b)
-> (forall a b. a -> ImportSpecList b -> ImportSpecList a)
-> Functor ImportSpecList
forall a b. a -> ImportSpecList b -> ImportSpecList a
forall a b. (a -> b) -> ImportSpecList a -> ImportSpecList b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> ImportSpecList a -> ImportSpecList b
fmap :: forall a b. (a -> b) -> ImportSpecList a -> ImportSpecList b
$c<$ :: forall a b. a -> ImportSpecList b -> ImportSpecList a
<$ :: forall a b. a -> ImportSpecList b -> ImportSpecList a
Functor,(forall x. ImportSpecList l -> Rep (ImportSpecList l) x)
-> (forall x. Rep (ImportSpecList l) x -> ImportSpecList l)
-> Generic (ImportSpecList l)
forall x. Rep (ImportSpecList l) x -> ImportSpecList l
forall x. ImportSpecList l -> Rep (ImportSpecList l) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall l x. Rep (ImportSpecList l) x -> ImportSpecList l
forall l x. ImportSpecList l -> Rep (ImportSpecList l) x
$cfrom :: forall l x. ImportSpecList l -> Rep (ImportSpecList l) x
from :: forall x. ImportSpecList l -> Rep (ImportSpecList l) x
$cto :: forall l x. Rep (ImportSpecList l) x -> ImportSpecList l
to :: forall x. Rep (ImportSpecList l) x -> ImportSpecList l
Generic)

-- | An import specification, representing a single explicit item imported
--   (or hidden) from a module.
data ImportSpec l
     = IVar l (Name l)                  -- ^ variable
     | IAbs l (Namespace l) (Name l)    -- ^ @T@:
                                        --   the name of a class, datatype or type synonym.
     | IThingAll l (Name l)             -- ^ @T(..)@:
                                        --   a class imported with all of its methods, or
                                        --   a datatype imported with all of its constructors.
     | IThingWith l (Name l) [CName l]  -- ^ @T(C_1,...,C_n)@:
                                        --   a class imported with some of its methods, or
                                        --   a datatype imported with some of its constructors.
  deriving (ImportSpec l -> ImportSpec l -> Bool
(ImportSpec l -> ImportSpec l -> Bool)
-> (ImportSpec l -> ImportSpec l -> Bool) -> Eq (ImportSpec l)
forall l. Eq l => ImportSpec l -> ImportSpec l -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall l. Eq l => ImportSpec l -> ImportSpec l -> Bool
== :: ImportSpec l -> ImportSpec l -> Bool
$c/= :: forall l. Eq l => ImportSpec l -> ImportSpec l -> Bool
/= :: ImportSpec l -> ImportSpec l -> Bool
Eq,Eq (ImportSpec l)
Eq (ImportSpec l) =>
(ImportSpec l -> ImportSpec l -> Ordering)
-> (ImportSpec l -> ImportSpec l -> Bool)
-> (ImportSpec l -> ImportSpec l -> Bool)
-> (ImportSpec l -> ImportSpec l -> Bool)
-> (ImportSpec l -> ImportSpec l -> Bool)
-> (ImportSpec l -> ImportSpec l -> ImportSpec l)
-> (ImportSpec l -> ImportSpec l -> ImportSpec l)
-> Ord (ImportSpec l)
ImportSpec l -> ImportSpec l -> Bool
ImportSpec l -> ImportSpec l -> Ordering
ImportSpec l -> ImportSpec l -> ImportSpec l
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall l. Ord l => Eq (ImportSpec l)
forall l. Ord l => ImportSpec l -> ImportSpec l -> Bool
forall l. Ord l => ImportSpec l -> ImportSpec l -> Ordering
forall l. Ord l => ImportSpec l -> ImportSpec l -> ImportSpec l
$ccompare :: forall l. Ord l => ImportSpec l -> ImportSpec l -> Ordering
compare :: ImportSpec l -> ImportSpec l -> Ordering
$c< :: forall l. Ord l => ImportSpec l -> ImportSpec l -> Bool
< :: ImportSpec l -> ImportSpec l -> Bool
$c<= :: forall l. Ord l => ImportSpec l -> ImportSpec l -> Bool
<= :: ImportSpec l -> ImportSpec l -> Bool
$c> :: forall l. Ord l => ImportSpec l -> ImportSpec l -> Bool
> :: ImportSpec l -> ImportSpec l -> Bool
$c>= :: forall l. Ord l => ImportSpec l -> ImportSpec l -> Bool
>= :: ImportSpec l -> ImportSpec l -> Bool
$cmax :: forall l. Ord l => ImportSpec l -> ImportSpec l -> ImportSpec l
max :: ImportSpec l -> ImportSpec l -> ImportSpec l
$cmin :: forall l. Ord l => ImportSpec l -> ImportSpec l -> ImportSpec l
min :: ImportSpec l -> ImportSpec l -> ImportSpec l
Ord,Int -> ImportSpec l -> ShowS
[ImportSpec l] -> ShowS
ImportSpec l -> String
(Int -> ImportSpec l -> ShowS)
-> (ImportSpec l -> String)
-> ([ImportSpec l] -> ShowS)
-> Show (ImportSpec l)
forall l. Show l => Int -> ImportSpec l -> ShowS
forall l. Show l => [ImportSpec l] -> ShowS
forall l. Show l => ImportSpec l -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall l. Show l => Int -> ImportSpec l -> ShowS
showsPrec :: Int -> ImportSpec l -> ShowS
$cshow :: forall l. Show l => ImportSpec l -> String
show :: ImportSpec l -> String
$cshowList :: forall l. Show l => [ImportSpec l] -> ShowS
showList :: [ImportSpec l] -> ShowS
Show,Typeable,Typeable (ImportSpec l)
Typeable (ImportSpec l) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> ImportSpec l -> c (ImportSpec l))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (ImportSpec l))
-> (ImportSpec l -> Constr)
-> (ImportSpec l -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (ImportSpec l)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (ImportSpec l)))
-> ((forall b. Data b => b -> b) -> ImportSpec l -> ImportSpec l)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ImportSpec l -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ImportSpec l -> r)
-> (forall u. (forall d. Data d => d -> u) -> ImportSpec l -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> ImportSpec l -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ImportSpec l -> m (ImportSpec l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ImportSpec l -> m (ImportSpec l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ImportSpec l -> m (ImportSpec l))
-> Data (ImportSpec l)
ImportSpec l -> Constr
ImportSpec l -> DataType
(forall b. Data b => b -> b) -> ImportSpec l -> ImportSpec l
forall l. Data l => Typeable (ImportSpec l)
forall l. Data l => ImportSpec l -> Constr
forall l. Data l => ImportSpec l -> DataType
forall l.
Data l =>
(forall b. Data b => b -> b) -> ImportSpec l -> ImportSpec l
forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> ImportSpec l -> u
forall l u.
Data l =>
(forall d. Data d => d -> u) -> ImportSpec l -> [u]
forall l r r'.
Data l =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ImportSpec l -> r
forall l r r'.
Data l =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ImportSpec l -> r
forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d) -> ImportSpec l -> m (ImportSpec l)
forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> ImportSpec l -> m (ImportSpec l)
forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ImportSpec l)
forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ImportSpec l -> c (ImportSpec l)
forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (ImportSpec l))
forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ImportSpec l))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> ImportSpec l -> u
forall u. (forall d. Data d => d -> u) -> ImportSpec l -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ImportSpec l -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ImportSpec l -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ImportSpec l -> m (ImportSpec l)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ImportSpec l -> m (ImportSpec l)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ImportSpec l)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ImportSpec l -> c (ImportSpec l)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (ImportSpec l))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ImportSpec l))
$cgfoldl :: forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ImportSpec l -> c (ImportSpec l)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ImportSpec l -> c (ImportSpec l)
$cgunfold :: forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ImportSpec l)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ImportSpec l)
$ctoConstr :: forall l. Data l => ImportSpec l -> Constr
toConstr :: ImportSpec l -> Constr
$cdataTypeOf :: forall l. Data l => ImportSpec l -> DataType
dataTypeOf :: ImportSpec l -> DataType
$cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (ImportSpec l))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (ImportSpec l))
$cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ImportSpec l))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ImportSpec l))
$cgmapT :: forall l.
Data l =>
(forall b. Data b => b -> b) -> ImportSpec l -> ImportSpec l
gmapT :: (forall b. Data b => b -> b) -> ImportSpec l -> ImportSpec l
$cgmapQl :: forall l r r'.
Data l =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ImportSpec l -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ImportSpec l -> r
$cgmapQr :: forall l r r'.
Data l =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ImportSpec l -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ImportSpec l -> r
$cgmapQ :: forall l u.
Data l =>
(forall d. Data d => d -> u) -> ImportSpec l -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> ImportSpec l -> [u]
$cgmapQi :: forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> ImportSpec l -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ImportSpec l -> u
$cgmapM :: forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d) -> ImportSpec l -> m (ImportSpec l)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ImportSpec l -> m (ImportSpec l)
$cgmapMp :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> ImportSpec l -> m (ImportSpec l)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ImportSpec l -> m (ImportSpec l)
$cgmapMo :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> ImportSpec l -> m (ImportSpec l)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ImportSpec l -> m (ImportSpec l)
Data,(forall m. Monoid m => ImportSpec m -> m)
-> (forall m a. Monoid m => (a -> m) -> ImportSpec a -> m)
-> (forall m a. Monoid m => (a -> m) -> ImportSpec a -> m)
-> (forall a b. (a -> b -> b) -> b -> ImportSpec a -> b)
-> (forall a b. (a -> b -> b) -> b -> ImportSpec a -> b)
-> (forall b a. (b -> a -> b) -> b -> ImportSpec a -> b)
-> (forall b a. (b -> a -> b) -> b -> ImportSpec a -> b)
-> (forall a. (a -> a -> a) -> ImportSpec a -> a)
-> (forall a. (a -> a -> a) -> ImportSpec a -> a)
-> (forall a. ImportSpec a -> [a])
-> (forall a. ImportSpec a -> Bool)
-> (forall a. ImportSpec a -> Int)
-> (forall a. Eq a => a -> ImportSpec a -> Bool)
-> (forall a. Ord a => ImportSpec a -> a)
-> (forall a. Ord a => ImportSpec a -> a)
-> (forall a. Num a => ImportSpec a -> a)
-> (forall a. Num a => ImportSpec a -> a)
-> Foldable ImportSpec
forall a. Eq a => a -> ImportSpec a -> Bool
forall a. Num a => ImportSpec a -> a
forall a. Ord a => ImportSpec a -> a
forall m. Monoid m => ImportSpec m -> m
forall a. ImportSpec a -> Bool
forall a. ImportSpec a -> Int
forall a. ImportSpec a -> [a]
forall a. (a -> a -> a) -> ImportSpec a -> a
forall m a. Monoid m => (a -> m) -> ImportSpec a -> m
forall b a. (b -> a -> b) -> b -> ImportSpec a -> b
forall a b. (a -> b -> b) -> b -> ImportSpec a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall m. Monoid m => ImportSpec m -> m
fold :: forall m. Monoid m => ImportSpec m -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> ImportSpec a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> ImportSpec a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> ImportSpec a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> ImportSpec a -> m
$cfoldr :: forall a b. (a -> b -> b) -> b -> ImportSpec a -> b
foldr :: forall a b. (a -> b -> b) -> b -> ImportSpec a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> ImportSpec a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> ImportSpec a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> ImportSpec a -> b
foldl :: forall b a. (b -> a -> b) -> b -> ImportSpec a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> ImportSpec a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> ImportSpec a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> ImportSpec a -> a
foldr1 :: forall a. (a -> a -> a) -> ImportSpec a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> ImportSpec a -> a
foldl1 :: forall a. (a -> a -> a) -> ImportSpec a -> a
$ctoList :: forall a. ImportSpec a -> [a]
toList :: forall a. ImportSpec a -> [a]
$cnull :: forall a. ImportSpec a -> Bool
null :: forall a. ImportSpec a -> Bool
$clength :: forall a. ImportSpec a -> Int
length :: forall a. ImportSpec a -> Int
$celem :: forall a. Eq a => a -> ImportSpec a -> Bool
elem :: forall a. Eq a => a -> ImportSpec a -> Bool
$cmaximum :: forall a. Ord a => ImportSpec a -> a
maximum :: forall a. Ord a => ImportSpec a -> a
$cminimum :: forall a. Ord a => ImportSpec a -> a
minimum :: forall a. Ord a => ImportSpec a -> a
$csum :: forall a. Num a => ImportSpec a -> a
sum :: forall a. Num a => ImportSpec a -> a
$cproduct :: forall a. Num a => ImportSpec a -> a
product :: forall a. Num a => ImportSpec a -> a
Foldable,Functor ImportSpec
Foldable ImportSpec
(Functor ImportSpec, Foldable ImportSpec) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> ImportSpec a -> f (ImportSpec b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    ImportSpec (f a) -> f (ImportSpec a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> ImportSpec a -> m (ImportSpec b))
-> (forall (m :: * -> *) a.
    Monad m =>
    ImportSpec (m a) -> m (ImportSpec a))
-> Traversable ImportSpec
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a.
Monad m =>
ImportSpec (m a) -> m (ImportSpec a)
forall (f :: * -> *) a.
Applicative f =>
ImportSpec (f a) -> f (ImportSpec a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> ImportSpec a -> m (ImportSpec b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> ImportSpec a -> f (ImportSpec b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> ImportSpec a -> f (ImportSpec b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> ImportSpec a -> f (ImportSpec b)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
ImportSpec (f a) -> f (ImportSpec a)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
ImportSpec (f a) -> f (ImportSpec a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> ImportSpec a -> m (ImportSpec b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> ImportSpec a -> m (ImportSpec b)
$csequence :: forall (m :: * -> *) a.
Monad m =>
ImportSpec (m a) -> m (ImportSpec a)
sequence :: forall (m :: * -> *) a.
Monad m =>
ImportSpec (m a) -> m (ImportSpec a)
Traversable,(forall a b. (a -> b) -> ImportSpec a -> ImportSpec b)
-> (forall a b. a -> ImportSpec b -> ImportSpec a)
-> Functor ImportSpec
forall a b. a -> ImportSpec b -> ImportSpec a
forall a b. (a -> b) -> ImportSpec a -> ImportSpec b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> ImportSpec a -> ImportSpec b
fmap :: forall a b. (a -> b) -> ImportSpec a -> ImportSpec b
$c<$ :: forall a b. a -> ImportSpec b -> ImportSpec a
<$ :: forall a b. a -> ImportSpec b -> ImportSpec a
Functor,(forall x. ImportSpec l -> Rep (ImportSpec l) x)
-> (forall x. Rep (ImportSpec l) x -> ImportSpec l)
-> Generic (ImportSpec l)
forall x. Rep (ImportSpec l) x -> ImportSpec l
forall x. ImportSpec l -> Rep (ImportSpec l) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall l x. Rep (ImportSpec l) x -> ImportSpec l
forall l x. ImportSpec l -> Rep (ImportSpec l) x
$cfrom :: forall l x. ImportSpec l -> Rep (ImportSpec l) x
from :: forall x. ImportSpec l -> Rep (ImportSpec l) x
$cto :: forall l x. Rep (ImportSpec l) x -> ImportSpec l
to :: forall x. Rep (ImportSpec l) x -> ImportSpec l
Generic)

-- | Associativity of an operator.
data Assoc l
     = AssocNone  l -- ^ non-associative operator (declared with @infix@)
     | AssocLeft  l -- ^ left-associative operator (declared with @infixl@).
     | AssocRight l -- ^ right-associative operator (declared with @infixr@)
  deriving (Assoc l -> Assoc l -> Bool
(Assoc l -> Assoc l -> Bool)
-> (Assoc l -> Assoc l -> Bool) -> Eq (Assoc l)
forall l. Eq l => Assoc l -> Assoc l -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall l. Eq l => Assoc l -> Assoc l -> Bool
== :: Assoc l -> Assoc l -> Bool
$c/= :: forall l. Eq l => Assoc l -> Assoc l -> Bool
/= :: Assoc l -> Assoc l -> Bool
Eq,Eq (Assoc l)
Eq (Assoc l) =>
(Assoc l -> Assoc l -> Ordering)
-> (Assoc l -> Assoc l -> Bool)
-> (Assoc l -> Assoc l -> Bool)
-> (Assoc l -> Assoc l -> Bool)
-> (Assoc l -> Assoc l -> Bool)
-> (Assoc l -> Assoc l -> Assoc l)
-> (Assoc l -> Assoc l -> Assoc l)
-> Ord (Assoc l)
Assoc l -> Assoc l -> Bool
Assoc l -> Assoc l -> Ordering
Assoc l -> Assoc l -> Assoc l
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall l. Ord l => Eq (Assoc l)
forall l. Ord l => Assoc l -> Assoc l -> Bool
forall l. Ord l => Assoc l -> Assoc l -> Ordering
forall l. Ord l => Assoc l -> Assoc l -> Assoc l
$ccompare :: forall l. Ord l => Assoc l -> Assoc l -> Ordering
compare :: Assoc l -> Assoc l -> Ordering
$c< :: forall l. Ord l => Assoc l -> Assoc l -> Bool
< :: Assoc l -> Assoc l -> Bool
$c<= :: forall l. Ord l => Assoc l -> Assoc l -> Bool
<= :: Assoc l -> Assoc l -> Bool
$c> :: forall l. Ord l => Assoc l -> Assoc l -> Bool
> :: Assoc l -> Assoc l -> Bool
$c>= :: forall l. Ord l => Assoc l -> Assoc l -> Bool
>= :: Assoc l -> Assoc l -> Bool
$cmax :: forall l. Ord l => Assoc l -> Assoc l -> Assoc l
max :: Assoc l -> Assoc l -> Assoc l
$cmin :: forall l. Ord l => Assoc l -> Assoc l -> Assoc l
min :: Assoc l -> Assoc l -> Assoc l
Ord,Int -> Assoc l -> ShowS
[Assoc l] -> ShowS
Assoc l -> String
(Int -> Assoc l -> ShowS)
-> (Assoc l -> String) -> ([Assoc l] -> ShowS) -> Show (Assoc l)
forall l. Show l => Int -> Assoc l -> ShowS
forall l. Show l => [Assoc l] -> ShowS
forall l. Show l => Assoc l -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall l. Show l => Int -> Assoc l -> ShowS
showsPrec :: Int -> Assoc l -> ShowS
$cshow :: forall l. Show l => Assoc l -> String
show :: Assoc l -> String
$cshowList :: forall l. Show l => [Assoc l] -> ShowS
showList :: [Assoc l] -> ShowS
Show,Typeable,Typeable (Assoc l)
Typeable (Assoc l) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Assoc l -> c (Assoc l))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Assoc l))
-> (Assoc l -> Constr)
-> (Assoc l -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Assoc l)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Assoc l)))
-> ((forall b. Data b => b -> b) -> Assoc l -> Assoc l)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Assoc l -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Assoc l -> r)
-> (forall u. (forall d. Data d => d -> u) -> Assoc l -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Assoc l -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Assoc l -> m (Assoc l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Assoc l -> m (Assoc l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Assoc l -> m (Assoc l))
-> Data (Assoc l)
Assoc l -> Constr
Assoc l -> DataType
(forall b. Data b => b -> b) -> Assoc l -> Assoc l
forall l. Data l => Typeable (Assoc l)
forall l. Data l => Assoc l -> Constr
forall l. Data l => Assoc l -> DataType
forall l.
Data l =>
(forall b. Data b => b -> b) -> Assoc l -> Assoc l
forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> Assoc l -> u
forall l u.
Data l =>
(forall d. Data d => d -> u) -> Assoc l -> [u]
forall l r r'.
Data l =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Assoc l -> r
forall l r r'.
Data l =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Assoc l -> r
forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d) -> Assoc l -> m (Assoc l)
forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Assoc l -> m (Assoc l)
forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Assoc l)
forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Assoc l -> c (Assoc l)
forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Assoc l))
forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Assoc l))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Assoc l -> u
forall u. (forall d. Data d => d -> u) -> Assoc l -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Assoc l -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Assoc l -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Assoc l -> m (Assoc l)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Assoc l -> m (Assoc l)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Assoc l)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Assoc l -> c (Assoc l)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Assoc l))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Assoc l))
$cgfoldl :: forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Assoc l -> c (Assoc l)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Assoc l -> c (Assoc l)
$cgunfold :: forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Assoc l)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Assoc l)
$ctoConstr :: forall l. Data l => Assoc l -> Constr
toConstr :: Assoc l -> Constr
$cdataTypeOf :: forall l. Data l => Assoc l -> DataType
dataTypeOf :: Assoc l -> DataType
$cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Assoc l))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Assoc l))
$cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Assoc l))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Assoc l))
$cgmapT :: forall l.
Data l =>
(forall b. Data b => b -> b) -> Assoc l -> Assoc l
gmapT :: (forall b. Data b => b -> b) -> Assoc l -> Assoc l
$cgmapQl :: forall l r r'.
Data l =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Assoc l -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Assoc l -> r
$cgmapQr :: forall l r r'.
Data l =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Assoc l -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Assoc l -> r
$cgmapQ :: forall l u.
Data l =>
(forall d. Data d => d -> u) -> Assoc l -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Assoc l -> [u]
$cgmapQi :: forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> Assoc l -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Assoc l -> u
$cgmapM :: forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d) -> Assoc l -> m (Assoc l)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Assoc l -> m (Assoc l)
$cgmapMp :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Assoc l -> m (Assoc l)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Assoc l -> m (Assoc l)
$cgmapMo :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Assoc l -> m (Assoc l)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Assoc l -> m (Assoc l)
Data,(forall m. Monoid m => Assoc m -> m)
-> (forall m a. Monoid m => (a -> m) -> Assoc a -> m)
-> (forall m a. Monoid m => (a -> m) -> Assoc a -> m)
-> (forall a b. (a -> b -> b) -> b -> Assoc a -> b)
-> (forall a b. (a -> b -> b) -> b -> Assoc a -> b)
-> (forall b a. (b -> a -> b) -> b -> Assoc a -> b)
-> (forall b a. (b -> a -> b) -> b -> Assoc a -> b)
-> (forall a. (a -> a -> a) -> Assoc a -> a)
-> (forall a. (a -> a -> a) -> Assoc a -> a)
-> (forall a. Assoc a -> [a])
-> (forall a. Assoc a -> Bool)
-> (forall a. Assoc a -> Int)
-> (forall a. Eq a => a -> Assoc a -> Bool)
-> (forall a. Ord a => Assoc a -> a)
-> (forall a. Ord a => Assoc a -> a)
-> (forall a. Num a => Assoc a -> a)
-> (forall a. Num a => Assoc a -> a)
-> Foldable Assoc
forall a. Eq a => a -> Assoc a -> Bool
forall a. Num a => Assoc a -> a
forall a. Ord a => Assoc a -> a
forall m. Monoid m => Assoc m -> m
forall a. Assoc a -> Bool
forall a. Assoc a -> Int
forall a. Assoc a -> [a]
forall a. (a -> a -> a) -> Assoc a -> a
forall m a. Monoid m => (a -> m) -> Assoc a -> m
forall b a. (b -> a -> b) -> b -> Assoc a -> b
forall a b. (a -> b -> b) -> b -> Assoc a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall m. Monoid m => Assoc m -> m
fold :: forall m. Monoid m => Assoc m -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> Assoc a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> Assoc a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> Assoc a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> Assoc a -> m
$cfoldr :: forall a b. (a -> b -> b) -> b -> Assoc a -> b
foldr :: forall a b. (a -> b -> b) -> b -> Assoc a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> Assoc a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> Assoc a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> Assoc a -> b
foldl :: forall b a. (b -> a -> b) -> b -> Assoc a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> Assoc a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> Assoc a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> Assoc a -> a
foldr1 :: forall a. (a -> a -> a) -> Assoc a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> Assoc a -> a
foldl1 :: forall a. (a -> a -> a) -> Assoc a -> a
$ctoList :: forall a. Assoc a -> [a]
toList :: forall a. Assoc a -> [a]
$cnull :: forall a. Assoc a -> Bool
null :: forall a. Assoc a -> Bool
$clength :: forall a. Assoc a -> Int
length :: forall a. Assoc a -> Int
$celem :: forall a. Eq a => a -> Assoc a -> Bool
elem :: forall a. Eq a => a -> Assoc a -> Bool
$cmaximum :: forall a. Ord a => Assoc a -> a
maximum :: forall a. Ord a => Assoc a -> a
$cminimum :: forall a. Ord a => Assoc a -> a
minimum :: forall a. Ord a => Assoc a -> a
$csum :: forall a. Num a => Assoc a -> a
sum :: forall a. Num a => Assoc a -> a
$cproduct :: forall a. Num a => Assoc a -> a
product :: forall a. Num a => Assoc a -> a
Foldable,Functor Assoc
Foldable Assoc
(Functor Assoc, Foldable Assoc) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> Assoc a -> f (Assoc b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    Assoc (f a) -> f (Assoc a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Assoc a -> m (Assoc b))
-> (forall (m :: * -> *) a. Monad m => Assoc (m a) -> m (Assoc a))
-> Traversable Assoc
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a. Monad m => Assoc (m a) -> m (Assoc a)
forall (f :: * -> *) a. Applicative f => Assoc (f a) -> f (Assoc a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Assoc a -> m (Assoc b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Assoc a -> f (Assoc b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Assoc a -> f (Assoc b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Assoc a -> f (Assoc b)
$csequenceA :: forall (f :: * -> *) a. Applicative f => Assoc (f a) -> f (Assoc a)
sequenceA :: forall (f :: * -> *) a. Applicative f => Assoc (f a) -> f (Assoc a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Assoc a -> m (Assoc b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Assoc a -> m (Assoc b)
$csequence :: forall (m :: * -> *) a. Monad m => Assoc (m a) -> m (Assoc a)
sequence :: forall (m :: * -> *) a. Monad m => Assoc (m a) -> m (Assoc a)
Traversable,(forall a b. (a -> b) -> Assoc a -> Assoc b)
-> (forall a b. a -> Assoc b -> Assoc a) -> Functor Assoc
forall a b. a -> Assoc b -> Assoc a
forall a b. (a -> b) -> Assoc a -> Assoc b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> Assoc a -> Assoc b
fmap :: forall a b. (a -> b) -> Assoc a -> Assoc b
$c<$ :: forall a b. a -> Assoc b -> Assoc a
<$ :: forall a b. a -> Assoc b -> Assoc a
Functor,(forall x. Assoc l -> Rep (Assoc l) x)
-> (forall x. Rep (Assoc l) x -> Assoc l) -> Generic (Assoc l)
forall x. Rep (Assoc l) x -> Assoc l
forall x. Assoc l -> Rep (Assoc l) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall l x. Rep (Assoc l) x -> Assoc l
forall l x. Assoc l -> Rep (Assoc l) x
$cfrom :: forall l x. Assoc l -> Rep (Assoc l) x
from :: forall x. Assoc l -> Rep (Assoc l) x
$cto :: forall l x. Rep (Assoc l) x -> Assoc l
to :: forall x. Rep (Assoc l) x -> Assoc l
Generic)

-- | A top-level declaration.
data Decl l
     = TypeDecl     l (DeclHead l) (Type l)
     -- ^ A type declaration
     | TypeFamDecl  l (DeclHead l) (Maybe (ResultSig l)) (Maybe (InjectivityInfo l))
     -- ^ A type family declaration
     | ClosedTypeFamDecl  l (DeclHead l) (Maybe (ResultSig l)) (Maybe (InjectivityInfo l)) [TypeEqn l]
     -- ^ A closed type family declaration
     | DataDecl     l (DataOrNew l) (Maybe (Context l)) (DeclHead l)                  [QualConDecl l] [Deriving l]
     -- ^ A data OR newtype declaration
     | GDataDecl    l (DataOrNew l) (Maybe (Context l)) (DeclHead l) (Maybe (Kind l)) [GadtDecl l]    [Deriving l]
     -- ^ A data OR newtype declaration, GADT style
     | DataFamDecl  l {-data-}      (Maybe (Context l)) (DeclHead l) (Maybe (ResultSig l))
     -- ^ A data family declaration
     | TypeInsDecl  l (Type l) (Type l)
     -- ^ A type family instance declaration
     | DataInsDecl  l (DataOrNew l) (Type l)                  [QualConDecl l] [Deriving l]
     -- ^ A data family instance declaration
     | GDataInsDecl l (DataOrNew l) (Type l) (Maybe (Kind l)) [GadtDecl l]    [Deriving l]
     -- ^ A data family instance declaration, GADT style
     | ClassDecl    l (Maybe (Context l)) (DeclHead l) [FunDep l] (Maybe [ClassDecl l])
     -- ^ A declaration of a type class
     | InstDecl     l (Maybe (Overlap l)) (InstRule l) (Maybe [InstDecl l])
     -- ^ An declaration of a type class instance
     | DerivDecl    l (Maybe (DerivStrategy l)) (Maybe (Overlap l)) (InstRule l)
     -- ^ A standalone deriving declaration
     | InfixDecl    l (Assoc l) (Maybe Int) [Op l]
     -- ^ A declaration of operator fixity
     | DefaultDecl  l [Type l]
     -- ^ A declaration of default types
     | SpliceDecl   l (Exp l)
     -- ^ A Template Haskell splicing declaration
     | TSpliceDecl  l (Exp l)
     -- ^ A typed Template Haskell splicing declaration
     | TypeSig      l [Name l] (Type l)
     -- ^ A type signature declaration
     | PatSynSig    l [Name l] (Maybe [TyVarBind l]) (Maybe (Context l))
                               (Maybe [TyVarBind l]) (Maybe (Context l))
                                                     (Type l)
     -- ^ A pattern synonym signature declation
     | FunBind      l [Match l]
     -- ^ A set of function binding clauses
     | PatBind      l (Pat l) (Rhs l) {-where-} (Maybe (Binds l))
     -- ^ A pattern binding
     | PatSyn l (Pat l) (Pat l) (PatternSynDirection l)
     -- ^ A pattern synonym binding
     | ForImp       l (CallConv l) (Maybe (Safety l)) (Maybe String) (Name l) (Type l)
     -- ^ A foreign import declaration
     | ForExp       l (CallConv l)                    (Maybe String) (Name l) (Type l)
     -- ^ A foreign export declaration
     | RulePragmaDecl   l [Rule l]
     -- ^ A RULES pragma
     | DeprPragmaDecl   l [([Name l], String)]
     -- ^ A DEPRECATED pragma
     | WarnPragmaDecl   l [([Name l], String)]
     -- ^ A WARNING pragma
     | InlineSig        l Bool (Maybe (Activation l)) (QName l)
     -- ^ An INLINE pragma
     | InlineConlikeSig l      (Maybe (Activation l)) (QName l)
     -- ^ An INLINE CONLIKE pragma
     | SpecSig          l      (Maybe (Activation l)) (QName l) [Type l]
     -- ^ A SPECIALISE pragma
     | SpecInlineSig    l Bool (Maybe (Activation l)) (QName l) [Type l]
     -- ^ A SPECIALISE INLINE pragma
     | InstSig          l      (InstRule l)
     -- ^ A SPECIALISE instance pragma
     | AnnPragma        l (Annotation l)
     -- ^ An ANN pragma
     | MinimalPragma    l (Maybe (BooleanFormula l))
     -- ^ A MINIMAL pragma
     | RoleAnnotDecl    l (QName l) [Role l]
     -- ^ A role annotation
     | CompletePragma l [Name l] (Maybe (QName l))
     -- ^ A COMPLETE pragma
  deriving (Decl l -> Decl l -> Bool
(Decl l -> Decl l -> Bool)
-> (Decl l -> Decl l -> Bool) -> Eq (Decl l)
forall l. Eq l => Decl l -> Decl l -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall l. Eq l => Decl l -> Decl l -> Bool
== :: Decl l -> Decl l -> Bool
$c/= :: forall l. Eq l => Decl l -> Decl l -> Bool
/= :: Decl l -> Decl l -> Bool
Eq,Eq (Decl l)
Eq (Decl l) =>
(Decl l -> Decl l -> Ordering)
-> (Decl l -> Decl l -> Bool)
-> (Decl l -> Decl l -> Bool)
-> (Decl l -> Decl l -> Bool)
-> (Decl l -> Decl l -> Bool)
-> (Decl l -> Decl l -> Decl l)
-> (Decl l -> Decl l -> Decl l)
-> Ord (Decl l)
Decl l -> Decl l -> Bool
Decl l -> Decl l -> Ordering
Decl l -> Decl l -> Decl l
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall l. Ord l => Eq (Decl l)
forall l. Ord l => Decl l -> Decl l -> Bool
forall l. Ord l => Decl l -> Decl l -> Ordering
forall l. Ord l => Decl l -> Decl l -> Decl l
$ccompare :: forall l. Ord l => Decl l -> Decl l -> Ordering
compare :: Decl l -> Decl l -> Ordering
$c< :: forall l. Ord l => Decl l -> Decl l -> Bool
< :: Decl l -> Decl l -> Bool
$c<= :: forall l. Ord l => Decl l -> Decl l -> Bool
<= :: Decl l -> Decl l -> Bool
$c> :: forall l. Ord l => Decl l -> Decl l -> Bool
> :: Decl l -> Decl l -> Bool
$c>= :: forall l. Ord l => Decl l -> Decl l -> Bool
>= :: Decl l -> Decl l -> Bool
$cmax :: forall l. Ord l => Decl l -> Decl l -> Decl l
max :: Decl l -> Decl l -> Decl l
$cmin :: forall l. Ord l => Decl l -> Decl l -> Decl l
min :: Decl l -> Decl l -> Decl l
Ord,Int -> Decl l -> ShowS
[Decl l] -> ShowS
Decl l -> String
(Int -> Decl l -> ShowS)
-> (Decl l -> String) -> ([Decl l] -> ShowS) -> Show (Decl l)
forall l. Show l => Int -> Decl l -> ShowS
forall l. Show l => [Decl l] -> ShowS
forall l. Show l => Decl l -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall l. Show l => Int -> Decl l -> ShowS
showsPrec :: Int -> Decl l -> ShowS
$cshow :: forall l. Show l => Decl l -> String
show :: Decl l -> String
$cshowList :: forall l. Show l => [Decl l] -> ShowS
showList :: [Decl l] -> ShowS
Show,Typeable,Typeable (Decl l)
Typeable (Decl l) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Decl l -> c (Decl l))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Decl l))
-> (Decl l -> Constr)
-> (Decl l -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Decl l)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Decl l)))
-> ((forall b. Data b => b -> b) -> Decl l -> Decl l)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Decl l -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Decl l -> r)
-> (forall u. (forall d. Data d => d -> u) -> Decl l -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Decl l -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Decl l -> m (Decl l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Decl l -> m (Decl l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Decl l -> m (Decl l))
-> Data (Decl l)
Decl l -> Constr
Decl l -> DataType
(forall b. Data b => b -> b) -> Decl l -> Decl l
forall l. Data l => Typeable (Decl l)
forall l. Data l => Decl l -> Constr
forall l. Data l => Decl l -> DataType
forall l.
Data l =>
(forall b. Data b => b -> b) -> Decl l -> Decl l
forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> Decl l -> u
forall l u. Data l => (forall d. Data d => d -> u) -> Decl l -> [u]
forall l r r'.
Data l =>
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Decl l -> r
forall l r r'.
Data l =>
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Decl l -> r
forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d) -> Decl l -> m (Decl l)
forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Decl l -> m (Decl l)
forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Decl l)
forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Decl l -> c (Decl l)
forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Decl l))
forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Decl l))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Decl l -> u
forall u. (forall d. Data d => d -> u) -> Decl l -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Decl l -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Decl l -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Decl l -> m (Decl l)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Decl l -> m (Decl l)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Decl l)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Decl l -> c (Decl l)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Decl l))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Decl l))
$cgfoldl :: forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Decl l -> c (Decl l)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Decl l -> c (Decl l)
$cgunfold :: forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Decl l)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Decl l)
$ctoConstr :: forall l. Data l => Decl l -> Constr
toConstr :: Decl l -> Constr
$cdataTypeOf :: forall l. Data l => Decl l -> DataType
dataTypeOf :: Decl l -> DataType
$cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Decl l))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Decl l))
$cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Decl l))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Decl l))
$cgmapT :: forall l.
Data l =>
(forall b. Data b => b -> b) -> Decl l -> Decl l
gmapT :: (forall b. Data b => b -> b) -> Decl l -> Decl l
$cgmapQl :: forall l r r'.
Data l =>
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Decl l -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Decl l -> r
$cgmapQr :: forall l r r'.
Data l =>
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Decl l -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Decl l -> r
$cgmapQ :: forall l u. Data l => (forall d. Data d => d -> u) -> Decl l -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Decl l -> [u]
$cgmapQi :: forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> Decl l -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Decl l -> u
$cgmapM :: forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d) -> Decl l -> m (Decl l)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Decl l -> m (Decl l)
$cgmapMp :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Decl l -> m (Decl l)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Decl l -> m (Decl l)
$cgmapMo :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Decl l -> m (Decl l)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Decl l -> m (Decl l)
Data,(forall m. Monoid m => Decl m -> m)
-> (forall m a. Monoid m => (a -> m) -> Decl a -> m)
-> (forall m a. Monoid m => (a -> m) -> Decl a -> m)
-> (forall a b. (a -> b -> b) -> b -> Decl a -> b)
-> (forall a b. (a -> b -> b) -> b -> Decl a -> b)
-> (forall b a. (b -> a -> b) -> b -> Decl a -> b)
-> (forall b a. (b -> a -> b) -> b -> Decl a -> b)
-> (forall a. (a -> a -> a) -> Decl a -> a)
-> (forall a. (a -> a -> a) -> Decl a -> a)
-> (forall a. Decl a -> [a])
-> (forall a. Decl a -> Bool)
-> (forall a. Decl a -> Int)
-> (forall a. Eq a => a -> Decl a -> Bool)
-> (forall a. Ord a => Decl a -> a)
-> (forall a. Ord a => Decl a -> a)
-> (forall a. Num a => Decl a -> a)
-> (forall a. Num a => Decl a -> a)
-> Foldable Decl
forall a. Eq a => a -> Decl a -> Bool
forall a. Num a => Decl a -> a
forall a. Ord a => Decl a -> a
forall m. Monoid m => Decl m -> m
forall a. Decl a -> Bool
forall a. Decl a -> Int
forall a. Decl a -> [a]
forall a. (a -> a -> a) -> Decl a -> a
forall m a. Monoid m => (a -> m) -> Decl a -> m
forall b a. (b -> a -> b) -> b -> Decl a -> b
forall a b. (a -> b -> b) -> b -> Decl a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall m. Monoid m => Decl m -> m
fold :: forall m. Monoid m => Decl m -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> Decl a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> Decl a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> Decl a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> Decl a -> m
$cfoldr :: forall a b. (a -> b -> b) -> b -> Decl a -> b
foldr :: forall a b. (a -> b -> b) -> b -> Decl a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> Decl a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> Decl a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> Decl a -> b
foldl :: forall b a. (b -> a -> b) -> b -> Decl a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> Decl a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> Decl a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> Decl a -> a
foldr1 :: forall a. (a -> a -> a) -> Decl a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> Decl a -> a
foldl1 :: forall a. (a -> a -> a) -> Decl a -> a
$ctoList :: forall a. Decl a -> [a]
toList :: forall a. Decl a -> [a]
$cnull :: forall a. Decl a -> Bool
null :: forall a. Decl a -> Bool
$clength :: forall a. Decl a -> Int
length :: forall a. Decl a -> Int
$celem :: forall a. Eq a => a -> Decl a -> Bool
elem :: forall a. Eq a => a -> Decl a -> Bool
$cmaximum :: forall a. Ord a => Decl a -> a
maximum :: forall a. Ord a => Decl a -> a
$cminimum :: forall a. Ord a => Decl a -> a
minimum :: forall a. Ord a => Decl a -> a
$csum :: forall a. Num a => Decl a -> a
sum :: forall a. Num a => Decl a -> a
$cproduct :: forall a. Num a => Decl a -> a
product :: forall a. Num a => Decl a -> a
Foldable,Functor Decl
Foldable Decl
(Functor Decl, Foldable Decl) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> Decl a -> f (Decl b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    Decl (f a) -> f (Decl a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Decl a -> m (Decl b))
-> (forall (m :: * -> *) a. Monad m => Decl (m a) -> m (Decl a))
-> Traversable Decl
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a. Monad m => Decl (m a) -> m (Decl a)
forall (f :: * -> *) a. Applicative f => Decl (f a) -> f (Decl a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Decl a -> m (Decl b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Decl a -> f (Decl b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Decl a -> f (Decl b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Decl a -> f (Decl b)
$csequenceA :: forall (f :: * -> *) a. Applicative f => Decl (f a) -> f (Decl a)
sequenceA :: forall (f :: * -> *) a. Applicative f => Decl (f a) -> f (Decl a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Decl a -> m (Decl b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Decl a -> m (Decl b)
$csequence :: forall (m :: * -> *) a. Monad m => Decl (m a) -> m (Decl a)
sequence :: forall (m :: * -> *) a. Monad m => Decl (m a) -> m (Decl a)
Traversable,(forall a b. (a -> b) -> Decl a -> Decl b)
-> (forall a b. a -> Decl b -> Decl a) -> Functor Decl
forall a b. a -> Decl b -> Decl a
forall a b. (a -> b) -> Decl a -> Decl b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> Decl a -> Decl b
fmap :: forall a b. (a -> b) -> Decl a -> Decl b
$c<$ :: forall a b. a -> Decl b -> Decl a
<$ :: forall a b. a -> Decl b -> Decl a
Functor,(forall x. Decl l -> Rep (Decl l) x)
-> (forall x. Rep (Decl l) x -> Decl l) -> Generic (Decl l)
forall x. Rep (Decl l) x -> Decl l
forall x. Decl l -> Rep (Decl l) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall l x. Rep (Decl l) x -> Decl l
forall l x. Decl l -> Rep (Decl l) x
$cfrom :: forall l x. Decl l -> Rep (Decl l) x
from :: forall x. Decl l -> Rep (Decl l) x
$cto :: forall l x. Rep (Decl l) x -> Decl l
to :: forall x. Rep (Decl l) x -> Decl l
Generic)

data  PatternSynDirection l =
      Unidirectional -- ^ A unidirectional pattern synonym with "<-"
    | ImplicitBidirectional  -- ^ A bidirectional pattern synonym with "="
    | ExplicitBidirectional l [Decl l]  -- ^ A birectional pattern synonym with the construction specified.
    deriving (PatternSynDirection l -> PatternSynDirection l -> Bool
(PatternSynDirection l -> PatternSynDirection l -> Bool)
-> (PatternSynDirection l -> PatternSynDirection l -> Bool)
-> Eq (PatternSynDirection l)
forall l.
Eq l =>
PatternSynDirection l -> PatternSynDirection l -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall l.
Eq l =>
PatternSynDirection l -> PatternSynDirection l -> Bool
== :: PatternSynDirection l -> PatternSynDirection l -> Bool
$c/= :: forall l.
Eq l =>
PatternSynDirection l -> PatternSynDirection l -> Bool
/= :: PatternSynDirection l -> PatternSynDirection l -> Bool
Eq, Eq (PatternSynDirection l)
Eq (PatternSynDirection l) =>
(PatternSynDirection l -> PatternSynDirection l -> Ordering)
-> (PatternSynDirection l -> PatternSynDirection l -> Bool)
-> (PatternSynDirection l -> PatternSynDirection l -> Bool)
-> (PatternSynDirection l -> PatternSynDirection l -> Bool)
-> (PatternSynDirection l -> PatternSynDirection l -> Bool)
-> (PatternSynDirection l
    -> PatternSynDirection l -> PatternSynDirection l)
-> (PatternSynDirection l
    -> PatternSynDirection l -> PatternSynDirection l)
-> Ord (PatternSynDirection l)
PatternSynDirection l -> PatternSynDirection l -> Bool
PatternSynDirection l -> PatternSynDirection l -> Ordering
PatternSynDirection l
-> PatternSynDirection l -> PatternSynDirection l
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall l. Ord l => Eq (PatternSynDirection l)
forall l.
Ord l =>
PatternSynDirection l -> PatternSynDirection l -> Bool
forall l.
Ord l =>
PatternSynDirection l -> PatternSynDirection l -> Ordering
forall l.
Ord l =>
PatternSynDirection l
-> PatternSynDirection l -> PatternSynDirection l
$ccompare :: forall l.
Ord l =>
PatternSynDirection l -> PatternSynDirection l -> Ordering
compare :: PatternSynDirection l -> PatternSynDirection l -> Ordering
$c< :: forall l.
Ord l =>
PatternSynDirection l -> PatternSynDirection l -> Bool
< :: PatternSynDirection l -> PatternSynDirection l -> Bool
$c<= :: forall l.
Ord l =>
PatternSynDirection l -> PatternSynDirection l -> Bool
<= :: PatternSynDirection l -> PatternSynDirection l -> Bool
$c> :: forall l.
Ord l =>
PatternSynDirection l -> PatternSynDirection l -> Bool
> :: PatternSynDirection l -> PatternSynDirection l -> Bool
$c>= :: forall l.
Ord l =>
PatternSynDirection l -> PatternSynDirection l -> Bool
>= :: PatternSynDirection l -> PatternSynDirection l -> Bool
$cmax :: forall l.
Ord l =>
PatternSynDirection l
-> PatternSynDirection l -> PatternSynDirection l
max :: PatternSynDirection l
-> PatternSynDirection l -> PatternSynDirection l
$cmin :: forall l.
Ord l =>
PatternSynDirection l
-> PatternSynDirection l -> PatternSynDirection l
min :: PatternSynDirection l
-> PatternSynDirection l -> PatternSynDirection l
Ord, Int -> PatternSynDirection l -> ShowS
[PatternSynDirection l] -> ShowS
PatternSynDirection l -> String
(Int -> PatternSynDirection l -> ShowS)
-> (PatternSynDirection l -> String)
-> ([PatternSynDirection l] -> ShowS)
-> Show (PatternSynDirection l)
forall l. Show l => Int -> PatternSynDirection l -> ShowS
forall l. Show l => [PatternSynDirection l] -> ShowS
forall l. Show l => PatternSynDirection l -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall l. Show l => Int -> PatternSynDirection l -> ShowS
showsPrec :: Int -> PatternSynDirection l -> ShowS
$cshow :: forall l. Show l => PatternSynDirection l -> String
show :: PatternSynDirection l -> String
$cshowList :: forall l. Show l => [PatternSynDirection l] -> ShowS
showList :: [PatternSynDirection l] -> ShowS
Show, Typeable (PatternSynDirection l)
Typeable (PatternSynDirection l) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g)
 -> PatternSynDirection l
 -> c (PatternSynDirection l))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (PatternSynDirection l))
-> (PatternSynDirection l -> Constr)
-> (PatternSynDirection l -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (PatternSynDirection l)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (PatternSynDirection l)))
-> ((forall b. Data b => b -> b)
    -> PatternSynDirection l -> PatternSynDirection l)
-> (forall r r'.
    (r -> r' -> r)
    -> r
    -> (forall d. Data d => d -> r')
    -> PatternSynDirection l
    -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r
    -> (forall d. Data d => d -> r')
    -> PatternSynDirection l
    -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> PatternSynDirection l -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> PatternSynDirection l -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> PatternSynDirection l -> m (PatternSynDirection l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> PatternSynDirection l -> m (PatternSynDirection l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> PatternSynDirection l -> m (PatternSynDirection l))
-> Data (PatternSynDirection l)
PatternSynDirection l -> Constr
PatternSynDirection l -> DataType
(forall b. Data b => b -> b)
-> PatternSynDirection l -> PatternSynDirection l
forall l. Data l => Typeable (PatternSynDirection l)
forall l. Data l => PatternSynDirection l -> Constr
forall l. Data l => PatternSynDirection l -> DataType
forall l.
Data l =>
(forall b. Data b => b -> b)
-> PatternSynDirection l -> PatternSynDirection l
forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> PatternSynDirection l -> u
forall l u.
Data l =>
(forall d. Data d => d -> u) -> PatternSynDirection l -> [u]
forall l r r'.
Data l =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PatternSynDirection l -> r
forall l r r'.
Data l =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PatternSynDirection l -> r
forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d)
-> PatternSynDirection l -> m (PatternSynDirection l)
forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> PatternSynDirection l -> m (PatternSynDirection l)
forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (PatternSynDirection l)
forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> PatternSynDirection l
-> c (PatternSynDirection l)
forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (PatternSynDirection l))
forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (PatternSynDirection l))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> PatternSynDirection l -> u
forall u.
(forall d. Data d => d -> u) -> PatternSynDirection l -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PatternSynDirection l -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PatternSynDirection l -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> PatternSynDirection l -> m (PatternSynDirection l)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> PatternSynDirection l -> m (PatternSynDirection l)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (PatternSynDirection l)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> PatternSynDirection l
-> c (PatternSynDirection l)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (PatternSynDirection l))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (PatternSynDirection l))
$cgfoldl :: forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> PatternSynDirection l
-> c (PatternSynDirection l)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> PatternSynDirection l
-> c (PatternSynDirection l)
$cgunfold :: forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (PatternSynDirection l)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (PatternSynDirection l)
$ctoConstr :: forall l. Data l => PatternSynDirection l -> Constr
toConstr :: PatternSynDirection l -> Constr
$cdataTypeOf :: forall l. Data l => PatternSynDirection l -> DataType
dataTypeOf :: PatternSynDirection l -> DataType
$cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (PatternSynDirection l))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (PatternSynDirection l))
$cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (PatternSynDirection l))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (PatternSynDirection l))
$cgmapT :: forall l.
Data l =>
(forall b. Data b => b -> b)
-> PatternSynDirection l -> PatternSynDirection l
gmapT :: (forall b. Data b => b -> b)
-> PatternSynDirection l -> PatternSynDirection l
$cgmapQl :: forall l r r'.
Data l =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PatternSynDirection l -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PatternSynDirection l -> r
$cgmapQr :: forall l r r'.
Data l =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PatternSynDirection l -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PatternSynDirection l -> r
$cgmapQ :: forall l u.
Data l =>
(forall d. Data d => d -> u) -> PatternSynDirection l -> [u]
gmapQ :: forall u.
(forall d. Data d => d -> u) -> PatternSynDirection l -> [u]
$cgmapQi :: forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> PatternSynDirection l -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> PatternSynDirection l -> u
$cgmapM :: forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d)
-> PatternSynDirection l -> m (PatternSynDirection l)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> PatternSynDirection l -> m (PatternSynDirection l)
$cgmapMp :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> PatternSynDirection l -> m (PatternSynDirection l)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> PatternSynDirection l -> m (PatternSynDirection l)
$cgmapMo :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> PatternSynDirection l -> m (PatternSynDirection l)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> PatternSynDirection l -> m (PatternSynDirection l)
Data, Typeable, (forall m. Monoid m => PatternSynDirection m -> m)
-> (forall m a. Monoid m => (a -> m) -> PatternSynDirection a -> m)
-> (forall m a. Monoid m => (a -> m) -> PatternSynDirection a -> m)
-> (forall a b. (a -> b -> b) -> b -> PatternSynDirection a -> b)
-> (forall a b. (a -> b -> b) -> b -> PatternSynDirection a -> b)
-> (forall b a. (b -> a -> b) -> b -> PatternSynDirection a -> b)
-> (forall b a. (b -> a -> b) -> b -> PatternSynDirection a -> b)
-> (forall a. (a -> a -> a) -> PatternSynDirection a -> a)
-> (forall a. (a -> a -> a) -> PatternSynDirection a -> a)
-> (forall a. PatternSynDirection a -> [a])
-> (forall a. PatternSynDirection a -> Bool)
-> (forall a. PatternSynDirection a -> Int)
-> (forall a. Eq a => a -> PatternSynDirection a -> Bool)
-> (forall a. Ord a => PatternSynDirection a -> a)
-> (forall a. Ord a => PatternSynDirection a -> a)
-> (forall a. Num a => PatternSynDirection a -> a)
-> (forall a. Num a => PatternSynDirection a -> a)
-> Foldable PatternSynDirection
forall a. Eq a => a -> PatternSynDirection a -> Bool
forall a. Num a => PatternSynDirection a -> a
forall a. Ord a => PatternSynDirection a -> a
forall m. Monoid m => PatternSynDirection m -> m
forall a. PatternSynDirection a -> Bool
forall a. PatternSynDirection a -> Int
forall a. PatternSynDirection a -> [a]
forall a. (a -> a -> a) -> PatternSynDirection a -> a
forall m a. Monoid m => (a -> m) -> PatternSynDirection a -> m
forall b a. (b -> a -> b) -> b -> PatternSynDirection a -> b
forall a b. (a -> b -> b) -> b -> PatternSynDirection a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall m. Monoid m => PatternSynDirection m -> m
fold :: forall m. Monoid m => PatternSynDirection m -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> PatternSynDirection a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> PatternSynDirection a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> PatternSynDirection a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> PatternSynDirection a -> m
$cfoldr :: forall a b. (a -> b -> b) -> b -> PatternSynDirection a -> b
foldr :: forall a b. (a -> b -> b) -> b -> PatternSynDirection a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> PatternSynDirection a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> PatternSynDirection a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> PatternSynDirection a -> b
foldl :: forall b a. (b -> a -> b) -> b -> PatternSynDirection a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> PatternSynDirection a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> PatternSynDirection a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> PatternSynDirection a -> a
foldr1 :: forall a. (a -> a -> a) -> PatternSynDirection a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> PatternSynDirection a -> a
foldl1 :: forall a. (a -> a -> a) -> PatternSynDirection a -> a
$ctoList :: forall a. PatternSynDirection a -> [a]
toList :: forall a. PatternSynDirection a -> [a]
$cnull :: forall a. PatternSynDirection a -> Bool
null :: forall a. PatternSynDirection a -> Bool
$clength :: forall a. PatternSynDirection a -> Int
length :: forall a. PatternSynDirection a -> Int
$celem :: forall a. Eq a => a -> PatternSynDirection a -> Bool
elem :: forall a. Eq a => a -> PatternSynDirection a -> Bool
$cmaximum :: forall a. Ord a => PatternSynDirection a -> a
maximum :: forall a. Ord a => PatternSynDirection a -> a
$cminimum :: forall a. Ord a => PatternSynDirection a -> a
minimum :: forall a. Ord a => PatternSynDirection a -> a
$csum :: forall a. Num a => PatternSynDirection a -> a
sum :: forall a. Num a => PatternSynDirection a -> a
$cproduct :: forall a. Num a => PatternSynDirection a -> a
product :: forall a. Num a => PatternSynDirection a -> a
Foldable, Functor PatternSynDirection
Foldable PatternSynDirection
(Functor PatternSynDirection, Foldable PatternSynDirection) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> PatternSynDirection a -> f (PatternSynDirection b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    PatternSynDirection (f a) -> f (PatternSynDirection a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> PatternSynDirection a -> m (PatternSynDirection b))
-> (forall (m :: * -> *) a.
    Monad m =>
    PatternSynDirection (m a) -> m (PatternSynDirection a))
-> Traversable PatternSynDirection
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a.
Monad m =>
PatternSynDirection (m a) -> m (PatternSynDirection a)
forall (f :: * -> *) a.
Applicative f =>
PatternSynDirection (f a) -> f (PatternSynDirection a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> PatternSynDirection a -> m (PatternSynDirection b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> PatternSynDirection a -> f (PatternSynDirection b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> PatternSynDirection a -> f (PatternSynDirection b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> PatternSynDirection a -> f (PatternSynDirection b)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
PatternSynDirection (f a) -> f (PatternSynDirection a)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
PatternSynDirection (f a) -> f (PatternSynDirection a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> PatternSynDirection a -> m (PatternSynDirection b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> PatternSynDirection a -> m (PatternSynDirection b)
$csequence :: forall (m :: * -> *) a.
Monad m =>
PatternSynDirection (m a) -> m (PatternSynDirection a)
sequence :: forall (m :: * -> *) a.
Monad m =>
PatternSynDirection (m a) -> m (PatternSynDirection a)
Traversable, (forall a b.
 (a -> b) -> PatternSynDirection a -> PatternSynDirection b)
-> (forall a b.
    a -> PatternSynDirection b -> PatternSynDirection a)
-> Functor PatternSynDirection
forall a b. a -> PatternSynDirection b -> PatternSynDirection a
forall a b.
(a -> b) -> PatternSynDirection a -> PatternSynDirection b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b.
(a -> b) -> PatternSynDirection a -> PatternSynDirection b
fmap :: forall a b.
(a -> b) -> PatternSynDirection a -> PatternSynDirection b
$c<$ :: forall a b. a -> PatternSynDirection b -> PatternSynDirection a
<$ :: forall a b. a -> PatternSynDirection b -> PatternSynDirection a
Functor, (forall x. PatternSynDirection l -> Rep (PatternSynDirection l) x)
-> (forall x.
    Rep (PatternSynDirection l) x -> PatternSynDirection l)
-> Generic (PatternSynDirection l)
forall x. Rep (PatternSynDirection l) x -> PatternSynDirection l
forall x. PatternSynDirection l -> Rep (PatternSynDirection l) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall l x. Rep (PatternSynDirection l) x -> PatternSynDirection l
forall l x. PatternSynDirection l -> Rep (PatternSynDirection l) x
$cfrom :: forall l x. PatternSynDirection l -> Rep (PatternSynDirection l) x
from :: forall x. PatternSynDirection l -> Rep (PatternSynDirection l) x
$cto :: forall l x. Rep (PatternSynDirection l) x -> PatternSynDirection l
to :: forall x. Rep (PatternSynDirection l) x -> PatternSynDirection l
Generic)

-- | A type equation as found in closed type families.
data TypeEqn l = TypeEqn l (Type l) (Type l) deriving (TypeEqn l -> TypeEqn l -> Bool
(TypeEqn l -> TypeEqn l -> Bool)
-> (TypeEqn l -> TypeEqn l -> Bool) -> Eq (TypeEqn l)
forall l. Eq l => TypeEqn l -> TypeEqn l -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall l. Eq l => TypeEqn l -> TypeEqn l -> Bool
== :: TypeEqn l -> TypeEqn l -> Bool
$c/= :: forall l. Eq l => TypeEqn l -> TypeEqn l -> Bool
/= :: TypeEqn l -> TypeEqn l -> Bool
Eq,Eq (TypeEqn l)
Eq (TypeEqn l) =>
(TypeEqn l -> TypeEqn l -> Ordering)
-> (TypeEqn l -> TypeEqn l -> Bool)
-> (TypeEqn l -> TypeEqn l -> Bool)
-> (TypeEqn l -> TypeEqn l -> Bool)
-> (TypeEqn l -> TypeEqn l -> Bool)
-> (TypeEqn l -> TypeEqn l -> TypeEqn l)
-> (TypeEqn l -> TypeEqn l -> TypeEqn l)
-> Ord (TypeEqn l)
TypeEqn l -> TypeEqn l -> Bool
TypeEqn l -> TypeEqn l -> Ordering
TypeEqn l -> TypeEqn l -> TypeEqn l
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall l. Ord l => Eq (TypeEqn l)
forall l. Ord l => TypeEqn l -> TypeEqn l -> Bool
forall l. Ord l => TypeEqn l -> TypeEqn l -> Ordering
forall l. Ord l => TypeEqn l -> TypeEqn l -> TypeEqn l
$ccompare :: forall l. Ord l => TypeEqn l -> TypeEqn l -> Ordering
compare :: TypeEqn l -> TypeEqn l -> Ordering
$c< :: forall l. Ord l => TypeEqn l -> TypeEqn l -> Bool
< :: TypeEqn l -> TypeEqn l -> Bool
$c<= :: forall l. Ord l => TypeEqn l -> TypeEqn l -> Bool
<= :: TypeEqn l -> TypeEqn l -> Bool
$c> :: forall l. Ord l => TypeEqn l -> TypeEqn l -> Bool
> :: TypeEqn l -> TypeEqn l -> Bool
$c>= :: forall l. Ord l => TypeEqn l -> TypeEqn l -> Bool
>= :: TypeEqn l -> TypeEqn l -> Bool
$cmax :: forall l. Ord l => TypeEqn l -> TypeEqn l -> TypeEqn l
max :: TypeEqn l -> TypeEqn l -> TypeEqn l
$cmin :: forall l. Ord l => TypeEqn l -> TypeEqn l -> TypeEqn l
min :: TypeEqn l -> TypeEqn l -> TypeEqn l
Ord,Int -> TypeEqn l -> ShowS
[TypeEqn l] -> ShowS
TypeEqn l -> String
(Int -> TypeEqn l -> ShowS)
-> (TypeEqn l -> String)
-> ([TypeEqn l] -> ShowS)
-> Show (TypeEqn l)
forall l. Show l => Int -> TypeEqn l -> ShowS
forall l. Show l => [TypeEqn l] -> ShowS
forall l. Show l => TypeEqn l -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall l. Show l => Int -> TypeEqn l -> ShowS
showsPrec :: Int -> TypeEqn l -> ShowS
$cshow :: forall l. Show l => TypeEqn l -> String
show :: TypeEqn l -> String
$cshowList :: forall l. Show l => [TypeEqn l] -> ShowS
showList :: [TypeEqn l] -> ShowS
Show,Typeable,Typeable (TypeEqn l)
Typeable (TypeEqn l) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> TypeEqn l -> c (TypeEqn l))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (TypeEqn l))
-> (TypeEqn l -> Constr)
-> (TypeEqn l -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (TypeEqn l)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (TypeEqn l)))
-> ((forall b. Data b => b -> b) -> TypeEqn l -> TypeEqn l)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> TypeEqn l -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> TypeEqn l -> r)
-> (forall u. (forall d. Data d => d -> u) -> TypeEqn l -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> TypeEqn l -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> TypeEqn l -> m (TypeEqn l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TypeEqn l -> m (TypeEqn l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TypeEqn l -> m (TypeEqn l))
-> Data (TypeEqn l)
TypeEqn l -> Constr
TypeEqn l -> DataType
(forall b. Data b => b -> b) -> TypeEqn l -> TypeEqn l
forall l. Data l => Typeable (TypeEqn l)
forall l. Data l => TypeEqn l -> Constr
forall l. Data l => TypeEqn l -> DataType
forall l.
Data l =>
(forall b. Data b => b -> b) -> TypeEqn l -> TypeEqn l
forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> TypeEqn l -> u
forall l u.
Data l =>
(forall d. Data d => d -> u) -> TypeEqn l -> [u]
forall l r r'.
Data l =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TypeEqn l -> r
forall l r r'.
Data l =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TypeEqn l -> r
forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d) -> TypeEqn l -> m (TypeEqn l)
forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> TypeEqn l -> m (TypeEqn l)
forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (TypeEqn l)
forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TypeEqn l -> c (TypeEqn l)
forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (TypeEqn l))
forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (TypeEqn l))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> TypeEqn l -> u
forall u. (forall d. Data d => d -> u) -> TypeEqn l -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TypeEqn l -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TypeEqn l -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TypeEqn l -> m (TypeEqn l)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TypeEqn l -> m (TypeEqn l)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (TypeEqn l)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TypeEqn l -> c (TypeEqn l)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (TypeEqn l))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (TypeEqn l))
$cgfoldl :: forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TypeEqn l -> c (TypeEqn l)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TypeEqn l -> c (TypeEqn l)
$cgunfold :: forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (TypeEqn l)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (TypeEqn l)
$ctoConstr :: forall l. Data l => TypeEqn l -> Constr
toConstr :: TypeEqn l -> Constr
$cdataTypeOf :: forall l. Data l => TypeEqn l -> DataType
dataTypeOf :: TypeEqn l -> DataType
$cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (TypeEqn l))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (TypeEqn l))
$cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (TypeEqn l))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (TypeEqn l))
$cgmapT :: forall l.
Data l =>
(forall b. Data b => b -> b) -> TypeEqn l -> TypeEqn l
gmapT :: (forall b. Data b => b -> b) -> TypeEqn l -> TypeEqn l
$cgmapQl :: forall l r r'.
Data l =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TypeEqn l -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TypeEqn l -> r
$cgmapQr :: forall l r r'.
Data l =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TypeEqn l -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TypeEqn l -> r
$cgmapQ :: forall l u.
Data l =>
(forall d. Data d => d -> u) -> TypeEqn l -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> TypeEqn l -> [u]
$cgmapQi :: forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> TypeEqn l -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> TypeEqn l -> u
$cgmapM :: forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d) -> TypeEqn l -> m (TypeEqn l)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TypeEqn l -> m (TypeEqn l)
$cgmapMp :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> TypeEqn l -> m (TypeEqn l)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TypeEqn l -> m (TypeEqn l)
$cgmapMo :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> TypeEqn l -> m (TypeEqn l)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TypeEqn l -> m (TypeEqn l)
Data,(forall m. Monoid m => TypeEqn m -> m)
-> (forall m a. Monoid m => (a -> m) -> TypeEqn a -> m)
-> (forall m a. Monoid m => (a -> m) -> TypeEqn a -> m)
-> (forall a b. (a -> b -> b) -> b -> TypeEqn a -> b)
-> (forall a b. (a -> b -> b) -> b -> TypeEqn a -> b)
-> (forall b a. (b -> a -> b) -> b -> TypeEqn a -> b)
-> (forall b a. (b -> a -> b) -> b -> TypeEqn a -> b)
-> (forall a. (a -> a -> a) -> TypeEqn a -> a)
-> (forall a. (a -> a -> a) -> TypeEqn a -> a)
-> (forall a. TypeEqn a -> [a])
-> (forall a. TypeEqn a -> Bool)
-> (forall a. TypeEqn a -> Int)
-> (forall a. Eq a => a -> TypeEqn a -> Bool)
-> (forall a. Ord a => TypeEqn a -> a)
-> (forall a. Ord a => TypeEqn a -> a)
-> (forall a. Num a => TypeEqn a -> a)
-> (forall a. Num a => TypeEqn a -> a)
-> Foldable TypeEqn
forall a. Eq a => a -> TypeEqn a -> Bool
forall a. Num a => TypeEqn a -> a
forall a. Ord a => TypeEqn a -> a
forall m. Monoid m => TypeEqn m -> m
forall a. TypeEqn a -> Bool
forall a. TypeEqn a -> Int
forall a. TypeEqn a -> [a]
forall a. (a -> a -> a) -> TypeEqn a -> a
forall m a. Monoid m => (a -> m) -> TypeEqn a -> m
forall b a. (b -> a -> b) -> b -> TypeEqn a -> b
forall a b. (a -> b -> b) -> b -> TypeEqn a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall m. Monoid m => TypeEqn m -> m
fold :: forall m. Monoid m => TypeEqn m -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> TypeEqn a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> TypeEqn a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> TypeEqn a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> TypeEqn a -> m
$cfoldr :: forall a b. (a -> b -> b) -> b -> TypeEqn a -> b
foldr :: forall a b. (a -> b -> b) -> b -> TypeEqn a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> TypeEqn a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> TypeEqn a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> TypeEqn a -> b
foldl :: forall b a. (b -> a -> b) -> b -> TypeEqn a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> TypeEqn a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> TypeEqn a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> TypeEqn a -> a
foldr1 :: forall a. (a -> a -> a) -> TypeEqn a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> TypeEqn a -> a
foldl1 :: forall a. (a -> a -> a) -> TypeEqn a -> a
$ctoList :: forall a. TypeEqn a -> [a]
toList :: forall a. TypeEqn a -> [a]
$cnull :: forall a. TypeEqn a -> Bool
null :: forall a. TypeEqn a -> Bool
$clength :: forall a. TypeEqn a -> Int
length :: forall a. TypeEqn a -> Int
$celem :: forall a. Eq a => a -> TypeEqn a -> Bool
elem :: forall a. Eq a => a -> TypeEqn a -> Bool
$cmaximum :: forall a. Ord a => TypeEqn a -> a
maximum :: forall a. Ord a => TypeEqn a -> a
$cminimum :: forall a. Ord a => TypeEqn a -> a
minimum :: forall a. Ord a => TypeEqn a -> a
$csum :: forall a. Num a => TypeEqn a -> a
sum :: forall a. Num a => TypeEqn a -> a
$cproduct :: forall a. Num a => TypeEqn a -> a
product :: forall a. Num a => TypeEqn a -> a
Foldable,Functor TypeEqn
Foldable TypeEqn
(Functor TypeEqn, Foldable TypeEqn) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> TypeEqn a -> f (TypeEqn b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    TypeEqn (f a) -> f (TypeEqn a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> TypeEqn a -> m (TypeEqn b))
-> (forall (m :: * -> *) a.
    Monad m =>
    TypeEqn (m a) -> m (TypeEqn a))
-> Traversable TypeEqn
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a. Monad m => TypeEqn (m a) -> m (TypeEqn a)
forall (f :: * -> *) a.
Applicative f =>
TypeEqn (f a) -> f (TypeEqn a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> TypeEqn a -> m (TypeEqn b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> TypeEqn a -> f (TypeEqn b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> TypeEqn a -> f (TypeEqn b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> TypeEqn a -> f (TypeEqn b)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
TypeEqn (f a) -> f (TypeEqn a)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
TypeEqn (f a) -> f (TypeEqn a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> TypeEqn a -> m (TypeEqn b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> TypeEqn a -> m (TypeEqn b)
$csequence :: forall (m :: * -> *) a. Monad m => TypeEqn (m a) -> m (TypeEqn a)
sequence :: forall (m :: * -> *) a. Monad m => TypeEqn (m a) -> m (TypeEqn a)
Traversable,(forall a b. (a -> b) -> TypeEqn a -> TypeEqn b)
-> (forall a b. a -> TypeEqn b -> TypeEqn a) -> Functor TypeEqn
forall a b. a -> TypeEqn b -> TypeEqn a
forall a b. (a -> b) -> TypeEqn a -> TypeEqn b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> TypeEqn a -> TypeEqn b
fmap :: forall a b. (a -> b) -> TypeEqn a -> TypeEqn b
$c<$ :: forall a b. a -> TypeEqn b -> TypeEqn a
<$ :: forall a b. a -> TypeEqn b -> TypeEqn a
Functor,(forall x. TypeEqn l -> Rep (TypeEqn l) x)
-> (forall x. Rep (TypeEqn l) x -> TypeEqn l)
-> Generic (TypeEqn l)
forall x. Rep (TypeEqn l) x -> TypeEqn l
forall x. TypeEqn l -> Rep (TypeEqn l) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall l x. Rep (TypeEqn l) x -> TypeEqn l
forall l x. TypeEqn l -> Rep (TypeEqn l) x
$cfrom :: forall l x. TypeEqn l -> Rep (TypeEqn l) x
from :: forall x. TypeEqn l -> Rep (TypeEqn l) x
$cto :: forall l x. Rep (TypeEqn l) x -> TypeEqn l
to :: forall x. Rep (TypeEqn l) x -> TypeEqn l
Generic)

-- | An annotation through an ANN pragma.
data Annotation l
    = Ann       l (Name l)  (Exp l)
    -- ^ An annotation for a declared name.
    | TypeAnn   l (Name l)  (Exp l)
    -- ^ An annotation for a declared type.
    | ModuleAnn l           (Exp l)
    -- ^ An annotation for the defining module.
  deriving (Annotation l -> Annotation l -> Bool
(Annotation l -> Annotation l -> Bool)
-> (Annotation l -> Annotation l -> Bool) -> Eq (Annotation l)
forall l. Eq l => Annotation l -> Annotation l -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall l. Eq l => Annotation l -> Annotation l -> Bool
== :: Annotation l -> Annotation l -> Bool
$c/= :: forall l. Eq l => Annotation l -> Annotation l -> Bool
/= :: Annotation l -> Annotation l -> Bool
Eq,Eq (Annotation l)
Eq (Annotation l) =>
(Annotation l -> Annotation l -> Ordering)
-> (Annotation l -> Annotation l -> Bool)
-> (Annotation l -> Annotation l -> Bool)
-> (Annotation l -> Annotation l -> Bool)
-> (Annotation l -> Annotation l -> Bool)
-> (Annotation l -> Annotation l -> Annotation l)
-> (Annotation l -> Annotation l -> Annotation l)
-> Ord (Annotation l)
Annotation l -> Annotation l -> Bool
Annotation l -> Annotation l -> Ordering
Annotation l -> Annotation l -> Annotation l
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall l. Ord l => Eq (Annotation l)
forall l. Ord l => Annotation l -> Annotation l -> Bool
forall l. Ord l => Annotation l -> Annotation l -> Ordering
forall l. Ord l => Annotation l -> Annotation l -> Annotation l
$ccompare :: forall l. Ord l => Annotation l -> Annotation l -> Ordering
compare :: Annotation l -> Annotation l -> Ordering
$c< :: forall l. Ord l => Annotation l -> Annotation l -> Bool
< :: Annotation l -> Annotation l -> Bool
$c<= :: forall l. Ord l => Annotation l -> Annotation l -> Bool
<= :: Annotation l -> Annotation l -> Bool
$c> :: forall l. Ord l => Annotation l -> Annotation l -> Bool
> :: Annotation l -> Annotation l -> Bool
$c>= :: forall l. Ord l => Annotation l -> Annotation l -> Bool
>= :: Annotation l -> Annotation l -> Bool
$cmax :: forall l. Ord l => Annotation l -> Annotation l -> Annotation l
max :: Annotation l -> Annotation l -> Annotation l
$cmin :: forall l. Ord l => Annotation l -> Annotation l -> Annotation l
min :: Annotation l -> Annotation l -> Annotation l
Ord,Int -> Annotation l -> ShowS
[Annotation l] -> ShowS
Annotation l -> String
(Int -> Annotation l -> ShowS)
-> (Annotation l -> String)
-> ([Annotation l] -> ShowS)
-> Show (Annotation l)
forall l. Show l => Int -> Annotation l -> ShowS
forall l. Show l => [Annotation l] -> ShowS
forall l. Show l => Annotation l -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall l. Show l => Int -> Annotation l -> ShowS
showsPrec :: Int -> Annotation l -> ShowS
$cshow :: forall l. Show l => Annotation l -> String
show :: Annotation l -> String
$cshowList :: forall l. Show l => [Annotation l] -> ShowS
showList :: [Annotation l] -> ShowS
Show,Typeable,Typeable (Annotation l)
Typeable (Annotation l) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Annotation l -> c (Annotation l))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Annotation l))
-> (Annotation l -> Constr)
-> (Annotation l -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Annotation l)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Annotation l)))
-> ((forall b. Data b => b -> b) -> Annotation l -> Annotation l)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Annotation l -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Annotation l -> r)
-> (forall u. (forall d. Data d => d -> u) -> Annotation l -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Annotation l -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Annotation l -> m (Annotation l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Annotation l -> m (Annotation l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Annotation l -> m (Annotation l))
-> Data (Annotation l)
Annotation l -> Constr
Annotation l -> DataType
(forall b. Data b => b -> b) -> Annotation l -> Annotation l
forall l. Data l => Typeable (Annotation l)
forall l. Data l => Annotation l -> Constr
forall l. Data l => Annotation l -> DataType
forall l.
Data l =>
(forall b. Data b => b -> b) -> Annotation l -> Annotation l
forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> Annotation l -> u
forall l u.
Data l =>
(forall d. Data d => d -> u) -> Annotation l -> [u]
forall l r r'.
Data l =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Annotation l -> r
forall l r r'.
Data l =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Annotation l -> r
forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d) -> Annotation l -> m (Annotation l)
forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Annotation l -> m (Annotation l)
forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Annotation l)
forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Annotation l -> c (Annotation l)
forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Annotation l))
forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Annotation l))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Annotation l -> u
forall u. (forall d. Data d => d -> u) -> Annotation l -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Annotation l -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Annotation l -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Annotation l -> m (Annotation l)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Annotation l -> m (Annotation l)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Annotation l)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Annotation l -> c (Annotation l)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Annotation l))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Annotation l))
$cgfoldl :: forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Annotation l -> c (Annotation l)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Annotation l -> c (Annotation l)
$cgunfold :: forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Annotation l)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Annotation l)
$ctoConstr :: forall l. Data l => Annotation l -> Constr
toConstr :: Annotation l -> Constr
$cdataTypeOf :: forall l. Data l => Annotation l -> DataType
dataTypeOf :: Annotation l -> DataType
$cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Annotation l))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Annotation l))
$cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Annotation l))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Annotation l))
$cgmapT :: forall l.
Data l =>
(forall b. Data b => b -> b) -> Annotation l -> Annotation l
gmapT :: (forall b. Data b => b -> b) -> Annotation l -> Annotation l
$cgmapQl :: forall l r r'.
Data l =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Annotation l -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Annotation l -> r
$cgmapQr :: forall l r r'.
Data l =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Annotation l -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Annotation l -> r
$cgmapQ :: forall l u.
Data l =>
(forall d. Data d => d -> u) -> Annotation l -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Annotation l -> [u]
$cgmapQi :: forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> Annotation l -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Annotation l -> u
$cgmapM :: forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d) -> Annotation l -> m (Annotation l)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Annotation l -> m (Annotation l)
$cgmapMp :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Annotation l -> m (Annotation l)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Annotation l -> m (Annotation l)
$cgmapMo :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Annotation l -> m (Annotation l)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Annotation l -> m (Annotation l)
Data,(forall m. Monoid m => Annotation m -> m)
-> (forall m a. Monoid m => (a -> m) -> Annotation a -> m)
-> (forall m a. Monoid m => (a -> m) -> Annotation a -> m)
-> (forall a b. (a -> b -> b) -> b -> Annotation a -> b)
-> (forall a b. (a -> b -> b) -> b -> Annotation a -> b)
-> (forall b a. (b -> a -> b) -> b -> Annotation a -> b)
-> (forall b a. (b -> a -> b) -> b -> Annotation a -> b)
-> (forall a. (a -> a -> a) -> Annotation a -> a)
-> (forall a. (a -> a -> a) -> Annotation a -> a)
-> (forall a. Annotation a -> [a])
-> (forall a. Annotation a -> Bool)
-> (forall a. Annotation a -> Int)
-> (forall a. Eq a => a -> Annotation a -> Bool)
-> (forall a. Ord a => Annotation a -> a)
-> (forall a. Ord a => Annotation a -> a)
-> (forall a. Num a => Annotation a -> a)
-> (forall a. Num a => Annotation a -> a)
-> Foldable Annotation
forall a. Eq a => a -> Annotation a -> Bool
forall a. Num a => Annotation a -> a
forall a. Ord a => Annotation a -> a
forall m. Monoid m => Annotation m -> m
forall a. Annotation a -> Bool
forall a. Annotation a -> Int
forall a. Annotation a -> [a]
forall a. (a -> a -> a) -> Annotation a -> a
forall m a. Monoid m => (a -> m) -> Annotation a -> m
forall b a. (b -> a -> b) -> b -> Annotation a -> b
forall a b. (a -> b -> b) -> b -> Annotation a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall m. Monoid m => Annotation m -> m
fold :: forall m. Monoid m => Annotation m -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> Annotation a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> Annotation a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> Annotation a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> Annotation a -> m
$cfoldr :: forall a b. (a -> b -> b) -> b -> Annotation a -> b
foldr :: forall a b. (a -> b -> b) -> b -> Annotation a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> Annotation a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> Annotation a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> Annotation a -> b
foldl :: forall b a. (b -> a -> b) -> b -> Annotation a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> Annotation a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> Annotation a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> Annotation a -> a
foldr1 :: forall a. (a -> a -> a) -> Annotation a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> Annotation a -> a
foldl1 :: forall a. (a -> a -> a) -> Annotation a -> a
$ctoList :: forall a. Annotation a -> [a]
toList :: forall a. Annotation a -> [a]
$cnull :: forall a. Annotation a -> Bool
null :: forall a. Annotation a -> Bool
$clength :: forall a. Annotation a -> Int
length :: forall a. Annotation a -> Int
$celem :: forall a. Eq a => a -> Annotation a -> Bool
elem :: forall a. Eq a => a -> Annotation a -> Bool
$cmaximum :: forall a. Ord a => Annotation a -> a
maximum :: forall a. Ord a => Annotation a -> a
$cminimum :: forall a. Ord a => Annotation a -> a
minimum :: forall a. Ord a => Annotation a -> a
$csum :: forall a. Num a => Annotation a -> a
sum :: forall a. Num a => Annotation a -> a
$cproduct :: forall a. Num a => Annotation a -> a
product :: forall a. Num a => Annotation a -> a
Foldable,Functor Annotation
Foldable Annotation
(Functor Annotation, Foldable Annotation) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> Annotation a -> f (Annotation b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    Annotation (f a) -> f (Annotation a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Annotation a -> m (Annotation b))
-> (forall (m :: * -> *) a.
    Monad m =>
    Annotation (m a) -> m (Annotation a))
-> Traversable Annotation
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a.
Monad m =>
Annotation (m a) -> m (Annotation a)
forall (f :: * -> *) a.
Applicative f =>
Annotation (f a) -> f (Annotation a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Annotation a -> m (Annotation b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Annotation a -> f (Annotation b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Annotation a -> f (Annotation b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Annotation a -> f (Annotation b)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
Annotation (f a) -> f (Annotation a)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
Annotation (f a) -> f (Annotation a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Annotation a -> m (Annotation b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Annotation a -> m (Annotation b)
$csequence :: forall (m :: * -> *) a.
Monad m =>
Annotation (m a) -> m (Annotation a)
sequence :: forall (m :: * -> *) a.
Monad m =>
Annotation (m a) -> m (Annotation a)
Traversable,(forall a b. (a -> b) -> Annotation a -> Annotation b)
-> (forall a b. a -> Annotation b -> Annotation a)
-> Functor Annotation
forall a b. a -> Annotation b -> Annotation a
forall a b. (a -> b) -> Annotation a -> Annotation b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> Annotation a -> Annotation b
fmap :: forall a b. (a -> b) -> Annotation a -> Annotation b
$c<$ :: forall a b. a -> Annotation b -> Annotation a
<$ :: forall a b. a -> Annotation b -> Annotation a
Functor,(forall x. Annotation l -> Rep (Annotation l) x)
-> (forall x. Rep (Annotation l) x -> Annotation l)
-> Generic (Annotation l)
forall x. Rep (Annotation l) x -> Annotation l
forall x. Annotation l -> Rep (Annotation l) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall l x. Rep (Annotation l) x -> Annotation l
forall l x. Annotation l -> Rep (Annotation l) x
$cfrom :: forall l x. Annotation l -> Rep (Annotation l) x
from :: forall x. Annotation l -> Rep (Annotation l) x
$cto :: forall l x. Rep (Annotation l) x -> Annotation l
to :: forall x. Rep (Annotation l) x -> Annotation l
Generic)

-- | A boolean formula for MINIMAL pragmas.
data BooleanFormula l
    = VarFormula l (Name l)              -- ^ A variable.
    | AndFormula l [BooleanFormula l]    -- ^ And boolean formulas.
    | OrFormula l [BooleanFormula l]     -- ^ Or boolean formulas.
    | ParenFormula l (BooleanFormula l)  -- ^ Parenthesized boolean formulas.
  deriving (BooleanFormula l -> BooleanFormula l -> Bool
(BooleanFormula l -> BooleanFormula l -> Bool)
-> (BooleanFormula l -> BooleanFormula l -> Bool)
-> Eq (BooleanFormula l)
forall l. Eq l => BooleanFormula l -> BooleanFormula l -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall l. Eq l => BooleanFormula l -> BooleanFormula l -> Bool
== :: BooleanFormula l -> BooleanFormula l -> Bool
$c/= :: forall l. Eq l => BooleanFormula l -> BooleanFormula l -> Bool
/= :: BooleanFormula l -> BooleanFormula l -> Bool
Eq,Eq (BooleanFormula l)
Eq (BooleanFormula l) =>
(BooleanFormula l -> BooleanFormula l -> Ordering)
-> (BooleanFormula l -> BooleanFormula l -> Bool)
-> (BooleanFormula l -> BooleanFormula l -> Bool)
-> (BooleanFormula l -> BooleanFormula l -> Bool)
-> (BooleanFormula l -> BooleanFormula l -> Bool)
-> (BooleanFormula l -> BooleanFormula l -> BooleanFormula l)
-> (BooleanFormula l -> BooleanFormula l -> BooleanFormula l)
-> Ord (BooleanFormula l)
BooleanFormula l -> BooleanFormula l -> Bool
BooleanFormula l -> BooleanFormula l -> Ordering
BooleanFormula l -> BooleanFormula l -> BooleanFormula l
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall l. Ord l => Eq (BooleanFormula l)
forall l. Ord l => BooleanFormula l -> BooleanFormula l -> Bool
forall l. Ord l => BooleanFormula l -> BooleanFormula l -> Ordering
forall l.
Ord l =>
BooleanFormula l -> BooleanFormula l -> BooleanFormula l
$ccompare :: forall l. Ord l => BooleanFormula l -> BooleanFormula l -> Ordering
compare :: BooleanFormula l -> BooleanFormula l -> Ordering
$c< :: forall l. Ord l => BooleanFormula l -> BooleanFormula l -> Bool
< :: BooleanFormula l -> BooleanFormula l -> Bool
$c<= :: forall l. Ord l => BooleanFormula l -> BooleanFormula l -> Bool
<= :: BooleanFormula l -> BooleanFormula l -> Bool
$c> :: forall l. Ord l => BooleanFormula l -> BooleanFormula l -> Bool
> :: BooleanFormula l -> BooleanFormula l -> Bool
$c>= :: forall l. Ord l => BooleanFormula l -> BooleanFormula l -> Bool
>= :: BooleanFormula l -> BooleanFormula l -> Bool
$cmax :: forall l.
Ord l =>
BooleanFormula l -> BooleanFormula l -> BooleanFormula l
max :: BooleanFormula l -> BooleanFormula l -> BooleanFormula l
$cmin :: forall l.
Ord l =>
BooleanFormula l -> BooleanFormula l -> BooleanFormula l
min :: BooleanFormula l -> BooleanFormula l -> BooleanFormula l
Ord,Int -> BooleanFormula l -> ShowS
[BooleanFormula l] -> ShowS
BooleanFormula l -> String
(Int -> BooleanFormula l -> ShowS)
-> (BooleanFormula l -> String)
-> ([BooleanFormula l] -> ShowS)
-> Show (BooleanFormula l)
forall l. Show l => Int -> BooleanFormula l -> ShowS
forall l. Show l => [BooleanFormula l] -> ShowS
forall l. Show l => BooleanFormula l -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall l. Show l => Int -> BooleanFormula l -> ShowS
showsPrec :: Int -> BooleanFormula l -> ShowS
$cshow :: forall l. Show l => BooleanFormula l -> String
show :: BooleanFormula l -> String
$cshowList :: forall l. Show l => [BooleanFormula l] -> ShowS
showList :: [BooleanFormula l] -> ShowS
Show,Typeable,Typeable (BooleanFormula l)
Typeable (BooleanFormula l) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g)
 -> BooleanFormula l
 -> c (BooleanFormula l))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (BooleanFormula l))
-> (BooleanFormula l -> Constr)
-> (BooleanFormula l -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (BooleanFormula l)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (BooleanFormula l)))
-> ((forall b. Data b => b -> b)
    -> BooleanFormula l -> BooleanFormula l)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> BooleanFormula l -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> BooleanFormula l -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> BooleanFormula l -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> BooleanFormula l -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> BooleanFormula l -> m (BooleanFormula l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> BooleanFormula l -> m (BooleanFormula l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> BooleanFormula l -> m (BooleanFormula l))
-> Data (BooleanFormula l)
BooleanFormula l -> Constr
BooleanFormula l -> DataType
(forall b. Data b => b -> b)
-> BooleanFormula l -> BooleanFormula l
forall l. Data l => Typeable (BooleanFormula l)
forall l. Data l => BooleanFormula l -> Constr
forall l. Data l => BooleanFormula l -> DataType
forall l.
Data l =>
(forall b. Data b => b -> b)
-> BooleanFormula l -> BooleanFormula l
forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> BooleanFormula l -> u
forall l u.
Data l =>
(forall d. Data d => d -> u) -> BooleanFormula l -> [u]
forall l r r'.
Data l =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> BooleanFormula l -> r
forall l r r'.
Data l =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> BooleanFormula l -> r
forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d)
-> BooleanFormula l -> m (BooleanFormula l)
forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> BooleanFormula l -> m (BooleanFormula l)
forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (BooleanFormula l)
forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BooleanFormula l -> c (BooleanFormula l)
forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (BooleanFormula l))
forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (BooleanFormula l))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> BooleanFormula l -> u
forall u. (forall d. Data d => d -> u) -> BooleanFormula l -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> BooleanFormula l -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> BooleanFormula l -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> BooleanFormula l -> m (BooleanFormula l)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> BooleanFormula l -> m (BooleanFormula l)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (BooleanFormula l)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BooleanFormula l -> c (BooleanFormula l)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (BooleanFormula l))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (BooleanFormula l))
$cgfoldl :: forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BooleanFormula l -> c (BooleanFormula l)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BooleanFormula l -> c (BooleanFormula l)
$cgunfold :: forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (BooleanFormula l)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (BooleanFormula l)
$ctoConstr :: forall l. Data l => BooleanFormula l -> Constr
toConstr :: BooleanFormula l -> Constr
$cdataTypeOf :: forall l. Data l => BooleanFormula l -> DataType
dataTypeOf :: BooleanFormula l -> DataType
$cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (BooleanFormula l))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (BooleanFormula l))
$cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (BooleanFormula l))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (BooleanFormula l))
$cgmapT :: forall l.
Data l =>
(forall b. Data b => b -> b)
-> BooleanFormula l -> BooleanFormula l
gmapT :: (forall b. Data b => b -> b)
-> BooleanFormula l -> BooleanFormula l
$cgmapQl :: forall l r r'.
Data l =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> BooleanFormula l -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> BooleanFormula l -> r
$cgmapQr :: forall l r r'.
Data l =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> BooleanFormula l -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> BooleanFormula l -> r
$cgmapQ :: forall l u.
Data l =>
(forall d. Data d => d -> u) -> BooleanFormula l -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> BooleanFormula l -> [u]
$cgmapQi :: forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> BooleanFormula l -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> BooleanFormula l -> u
$cgmapM :: forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d)
-> BooleanFormula l -> m (BooleanFormula l)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> BooleanFormula l -> m (BooleanFormula l)
$cgmapMp :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> BooleanFormula l -> m (BooleanFormula l)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> BooleanFormula l -> m (BooleanFormula l)
$cgmapMo :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> BooleanFormula l -> m (BooleanFormula l)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> BooleanFormula l -> m (BooleanFormula l)
Data,(forall m. Monoid m => BooleanFormula m -> m)
-> (forall m a. Monoid m => (a -> m) -> BooleanFormula a -> m)
-> (forall m a. Monoid m => (a -> m) -> BooleanFormula a -> m)
-> (forall a b. (a -> b -> b) -> b -> BooleanFormula a -> b)
-> (forall a b. (a -> b -> b) -> b -> BooleanFormula a -> b)
-> (forall b a. (b -> a -> b) -> b -> BooleanFormula a -> b)
-> (forall b a. (b -> a -> b) -> b -> BooleanFormula a -> b)
-> (forall a. (a -> a -> a) -> BooleanFormula a -> a)
-> (forall a. (a -> a -> a) -> BooleanFormula a -> a)
-> (forall a. BooleanFormula a -> [a])
-> (forall a. BooleanFormula a -> Bool)
-> (forall a. BooleanFormula a -> Int)
-> (forall a. Eq a => a -> BooleanFormula a -> Bool)
-> (forall a. Ord a => BooleanFormula a -> a)
-> (forall a. Ord a => BooleanFormula a -> a)
-> (forall a. Num a => BooleanFormula a -> a)
-> (forall a. Num a => BooleanFormula a -> a)
-> Foldable BooleanFormula
forall a. Eq a => a -> BooleanFormula a -> Bool
forall a. Num a => BooleanFormula a -> a
forall a. Ord a => BooleanFormula a -> a
forall m. Monoid m => BooleanFormula m -> m
forall a. BooleanFormula a -> Bool
forall a. BooleanFormula a -> Int
forall a. BooleanFormula a -> [a]
forall a. (a -> a -> a) -> BooleanFormula a -> a
forall m a. Monoid m => (a -> m) -> BooleanFormula a -> m
forall b a. (b -> a -> b) -> b -> BooleanFormula a -> b
forall a b. (a -> b -> b) -> b -> BooleanFormula a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall m. Monoid m => BooleanFormula m -> m
fold :: forall m. Monoid m => BooleanFormula m -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> BooleanFormula a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> BooleanFormula a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> BooleanFormula a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> BooleanFormula a -> m
$cfoldr :: forall a b. (a -> b -> b) -> b -> BooleanFormula a -> b
foldr :: forall a b. (a -> b -> b) -> b -> BooleanFormula a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> BooleanFormula a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> BooleanFormula a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> BooleanFormula a -> b
foldl :: forall b a. (b -> a -> b) -> b -> BooleanFormula a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> BooleanFormula a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> BooleanFormula a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> BooleanFormula a -> a
foldr1 :: forall a. (a -> a -> a) -> BooleanFormula a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> BooleanFormula a -> a
foldl1 :: forall a. (a -> a -> a) -> BooleanFormula a -> a
$ctoList :: forall a. BooleanFormula a -> [a]
toList :: forall a. BooleanFormula a -> [a]
$cnull :: forall a. BooleanFormula a -> Bool
null :: forall a. BooleanFormula a -> Bool
$clength :: forall a. BooleanFormula a -> Int
length :: forall a. BooleanFormula a -> Int
$celem :: forall a. Eq a => a -> BooleanFormula a -> Bool
elem :: forall a. Eq a => a -> BooleanFormula a -> Bool
$cmaximum :: forall a. Ord a => BooleanFormula a -> a
maximum :: forall a. Ord a => BooleanFormula a -> a
$cminimum :: forall a. Ord a => BooleanFormula a -> a
minimum :: forall a. Ord a => BooleanFormula a -> a
$csum :: forall a. Num a => BooleanFormula a -> a
sum :: forall a. Num a => BooleanFormula a -> a
$cproduct :: forall a. Num a => BooleanFormula a -> a
product :: forall a. Num a => BooleanFormula a -> a
Foldable,Functor BooleanFormula
Foldable BooleanFormula
(Functor BooleanFormula, Foldable BooleanFormula) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> BooleanFormula a -> f (BooleanFormula b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    BooleanFormula (f a) -> f (BooleanFormula a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> BooleanFormula a -> m (BooleanFormula b))
-> (forall (m :: * -> *) a.
    Monad m =>
    BooleanFormula (m a) -> m (BooleanFormula a))
-> Traversable BooleanFormula
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a.
Monad m =>
BooleanFormula (m a) -> m (BooleanFormula a)
forall (f :: * -> *) a.
Applicative f =>
BooleanFormula (f a) -> f (BooleanFormula a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> BooleanFormula a -> m (BooleanFormula b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> BooleanFormula a -> f (BooleanFormula b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> BooleanFormula a -> f (BooleanFormula b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> BooleanFormula a -> f (BooleanFormula b)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
BooleanFormula (f a) -> f (BooleanFormula a)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
BooleanFormula (f a) -> f (BooleanFormula a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> BooleanFormula a -> m (BooleanFormula b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> BooleanFormula a -> m (BooleanFormula b)
$csequence :: forall (m :: * -> *) a.
Monad m =>
BooleanFormula (m a) -> m (BooleanFormula a)
sequence :: forall (m :: * -> *) a.
Monad m =>
BooleanFormula (m a) -> m (BooleanFormula a)
Traversable,(forall a b. (a -> b) -> BooleanFormula a -> BooleanFormula b)
-> (forall a b. a -> BooleanFormula b -> BooleanFormula a)
-> Functor BooleanFormula
forall a b. a -> BooleanFormula b -> BooleanFormula a
forall a b. (a -> b) -> BooleanFormula a -> BooleanFormula b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> BooleanFormula a -> BooleanFormula b
fmap :: forall a b. (a -> b) -> BooleanFormula a -> BooleanFormula b
$c<$ :: forall a b. a -> BooleanFormula b -> BooleanFormula a
<$ :: forall a b. a -> BooleanFormula b -> BooleanFormula a
Functor,(forall x. BooleanFormula l -> Rep (BooleanFormula l) x)
-> (forall x. Rep (BooleanFormula l) x -> BooleanFormula l)
-> Generic (BooleanFormula l)
forall x. Rep (BooleanFormula l) x -> BooleanFormula l
forall x. BooleanFormula l -> Rep (BooleanFormula l) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall l x. Rep (BooleanFormula l) x -> BooleanFormula l
forall l x. BooleanFormula l -> Rep (BooleanFormula l) x
$cfrom :: forall l x. BooleanFormula l -> Rep (BooleanFormula l) x
from :: forall x. BooleanFormula l -> Rep (BooleanFormula l) x
$cto :: forall l x. Rep (BooleanFormula l) x -> BooleanFormula l
to :: forall x. Rep (BooleanFormula l) x -> BooleanFormula l
Generic)

data Role l
  = Nominal l
  | Representational l
  | Phantom l
  | RoleWildcard l
  deriving (Role l -> Role l -> Bool
(Role l -> Role l -> Bool)
-> (Role l -> Role l -> Bool) -> Eq (Role l)
forall l. Eq l => Role l -> Role l -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall l. Eq l => Role l -> Role l -> Bool
== :: Role l -> Role l -> Bool
$c/= :: forall l. Eq l => Role l -> Role l -> Bool
/= :: Role l -> Role l -> Bool
Eq,Eq (Role l)
Eq (Role l) =>
(Role l -> Role l -> Ordering)
-> (Role l -> Role l -> Bool)
-> (Role l -> Role l -> Bool)
-> (Role l -> Role l -> Bool)
-> (Role l -> Role l -> Bool)
-> (Role l -> Role l -> Role l)
-> (Role l -> Role l -> Role l)
-> Ord (Role l)
Role l -> Role l -> Bool
Role l -> Role l -> Ordering
Role l -> Role l -> Role l
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall l. Ord l => Eq (Role l)
forall l. Ord l => Role l -> Role l -> Bool
forall l. Ord l => Role l -> Role l -> Ordering
forall l. Ord l => Role l -> Role l -> Role l
$ccompare :: forall l. Ord l => Role l -> Role l -> Ordering
compare :: Role l -> Role l -> Ordering
$c< :: forall l. Ord l => Role l -> Role l -> Bool
< :: Role l -> Role l -> Bool
$c<= :: forall l. Ord l => Role l -> Role l -> Bool
<= :: Role l -> Role l -> Bool
$c> :: forall l. Ord l => Role l -> Role l -> Bool
> :: Role l -> Role l -> Bool
$c>= :: forall l. Ord l => Role l -> Role l -> Bool
>= :: Role l -> Role l -> Bool
$cmax :: forall l. Ord l => Role l -> Role l -> Role l
max :: Role l -> Role l -> Role l
$cmin :: forall l. Ord l => Role l -> Role l -> Role l
min :: Role l -> Role l -> Role l
Ord,Int -> Role l -> ShowS
[Role l] -> ShowS
Role l -> String
(Int -> Role l -> ShowS)
-> (Role l -> String) -> ([Role l] -> ShowS) -> Show (Role l)
forall l. Show l => Int -> Role l -> ShowS
forall l. Show l => [Role l] -> ShowS
forall l. Show l => Role l -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall l. Show l => Int -> Role l -> ShowS
showsPrec :: Int -> Role l -> ShowS
$cshow :: forall l. Show l => Role l -> String
show :: Role l -> String
$cshowList :: forall l. Show l => [Role l] -> ShowS
showList :: [Role l] -> ShowS
Show,Typeable,Typeable (Role l)
Typeable (Role l) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Role l -> c (Role l))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Role l))
-> (Role l -> Constr)
-> (Role l -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Role l)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Role l)))
-> ((forall b. Data b => b -> b) -> Role l -> Role l)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Role l -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Role l -> r)
-> (forall u. (forall d. Data d => d -> u) -> Role l -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Role l -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Role l -> m (Role l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Role l -> m (Role l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Role l -> m (Role l))
-> Data (Role l)
Role l -> Constr
Role l -> DataType
(forall b. Data b => b -> b) -> Role l -> Role l
forall l. Data l => Typeable (Role l)
forall l. Data l => Role l -> Constr
forall l. Data l => Role l -> DataType
forall l.
Data l =>
(forall b. Data b => b -> b) -> Role l -> Role l
forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> Role l -> u
forall l u. Data l => (forall d. Data d => d -> u) -> Role l -> [u]
forall l r r'.
Data l =>
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Role l -> r
forall l r r'.
Data l =>
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Role l -> r
forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d) -> Role l -> m (Role l)
forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Role l -> m (Role l)
forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Role l)
forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Role l -> c (Role l)
forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Role l))
forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Role l))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Role l -> u
forall u. (forall d. Data d => d -> u) -> Role l -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Role l -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Role l -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Role l -> m (Role l)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Role l -> m (Role l)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Role l)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Role l -> c (Role l)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Role l))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Role l))
$cgfoldl :: forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Role l -> c (Role l)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Role l -> c (Role l)
$cgunfold :: forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Role l)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Role l)
$ctoConstr :: forall l. Data l => Role l -> Constr
toConstr :: Role l -> Constr
$cdataTypeOf :: forall l. Data l => Role l -> DataType
dataTypeOf :: Role l -> DataType
$cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Role l))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Role l))
$cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Role l))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Role l))
$cgmapT :: forall l.
Data l =>
(forall b. Data b => b -> b) -> Role l -> Role l
gmapT :: (forall b. Data b => b -> b) -> Role l -> Role l
$cgmapQl :: forall l r r'.
Data l =>
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Role l -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Role l -> r
$cgmapQr :: forall l r r'.
Data l =>
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Role l -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Role l -> r
$cgmapQ :: forall l u. Data l => (forall d. Data d => d -> u) -> Role l -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Role l -> [u]
$cgmapQi :: forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> Role l -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Role l -> u
$cgmapM :: forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d) -> Role l -> m (Role l)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Role l -> m (Role l)
$cgmapMp :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Role l -> m (Role l)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Role l -> m (Role l)
$cgmapMo :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Role l -> m (Role l)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Role l -> m (Role l)
Data,(forall m. Monoid m => Role m -> m)
-> (forall m a. Monoid m => (a -> m) -> Role a -> m)
-> (forall m a. Monoid m => (a -> m) -> Role a -> m)
-> (forall a b. (a -> b -> b) -> b -> Role a -> b)
-> (forall a b. (a -> b -> b) -> b -> Role a -> b)
-> (forall b a. (b -> a -> b) -> b -> Role a -> b)
-> (forall b a. (b -> a -> b) -> b -> Role a -> b)
-> (forall a. (a -> a -> a) -> Role a -> a)
-> (forall a. (a -> a -> a) -> Role a -> a)
-> (forall a. Role a -> [a])
-> (forall a. Role a -> Bool)
-> (forall a. Role a -> Int)
-> (forall a. Eq a => a -> Role a -> Bool)
-> (forall a. Ord a => Role a -> a)
-> (forall a. Ord a => Role a -> a)
-> (forall a. Num a => Role a -> a)
-> (forall a. Num a => Role a -> a)
-> Foldable Role
forall a. Eq a => a -> Role a -> Bool
forall a. Num a => Role a -> a
forall a. Ord a => Role a -> a
forall m. Monoid m => Role m -> m
forall a. Role a -> Bool
forall a. Role a -> Int
forall a. Role a -> [a]
forall a. (a -> a -> a) -> Role a -> a
forall m a. Monoid m => (a -> m) -> Role a -> m
forall b a. (b -> a -> b) -> b -> Role a -> b
forall a b. (a -> b -> b) -> b -> Role a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall m. Monoid m => Role m -> m
fold :: forall m. Monoid m => Role m -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> Role a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> Role a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> Role a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> Role a -> m
$cfoldr :: forall a b. (a -> b -> b) -> b -> Role a -> b
foldr :: forall a b. (a -> b -> b) -> b -> Role a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> Role a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> Role a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> Role a -> b
foldl :: forall b a. (b -> a -> b) -> b -> Role a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> Role a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> Role a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> Role a -> a
foldr1 :: forall a. (a -> a -> a) -> Role a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> Role a -> a
foldl1 :: forall a. (a -> a -> a) -> Role a -> a
$ctoList :: forall a. Role a -> [a]
toList :: forall a. Role a -> [a]
$cnull :: forall a. Role a -> Bool
null :: forall a. Role a -> Bool
$clength :: forall a. Role a -> Int
length :: forall a. Role a -> Int
$celem :: forall a. Eq a => a -> Role a -> Bool
elem :: forall a. Eq a => a -> Role a -> Bool
$cmaximum :: forall a. Ord a => Role a -> a
maximum :: forall a. Ord a => Role a -> a
$cminimum :: forall a. Ord a => Role a -> a
minimum :: forall a. Ord a => Role a -> a
$csum :: forall a. Num a => Role a -> a
sum :: forall a. Num a => Role a -> a
$cproduct :: forall a. Num a => Role a -> a
product :: forall a. Num a => Role a -> a
Foldable,Functor Role
Foldable Role
(Functor Role, Foldable Role) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> Role a -> f (Role b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    Role (f a) -> f (Role a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Role a -> m (Role b))
-> (forall (m :: * -> *) a. Monad m => Role (m a) -> m (Role a))
-> Traversable Role
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a. Monad m => Role (m a) -> m (Role a)
forall (f :: * -> *) a. Applicative f => Role (f a) -> f (Role a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Role a -> m (Role b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Role a -> f (Role b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Role a -> f (Role b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Role a -> f (Role b)
$csequenceA :: forall (f :: * -> *) a. Applicative f => Role (f a) -> f (Role a)
sequenceA :: forall (f :: * -> *) a. Applicative f => Role (f a) -> f (Role a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Role a -> m (Role b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Role a -> m (Role b)
$csequence :: forall (m :: * -> *) a. Monad m => Role (m a) -> m (Role a)
sequence :: forall (m :: * -> *) a. Monad m => Role (m a) -> m (Role a)
Traversable,(forall a b. (a -> b) -> Role a -> Role b)
-> (forall a b. a -> Role b -> Role a) -> Functor Role
forall a b. a -> Role b -> Role a
forall a b. (a -> b) -> Role a -> Role b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> Role a -> Role b
fmap :: forall a b. (a -> b) -> Role a -> Role b
$c<$ :: forall a b. a -> Role b -> Role a
<$ :: forall a b. a -> Role b -> Role a
Functor,(forall x. Role l -> Rep (Role l) x)
-> (forall x. Rep (Role l) x -> Role l) -> Generic (Role l)
forall x. Rep (Role l) x -> Role l
forall x. Role l -> Rep (Role l) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall l x. Rep (Role l) x -> Role l
forall l x. Role l -> Rep (Role l) x
$cfrom :: forall l x. Role l -> Rep (Role l) x
from :: forall x. Role l -> Rep (Role l) x
$cto :: forall l x. Rep (Role l) x -> Role l
to :: forall x. Rep (Role l) x -> Role l
Generic)

-- | A flag stating whether a declaration is a data or newtype declaration.
data DataOrNew l = DataType l | NewType l
  deriving (DataOrNew l -> DataOrNew l -> Bool
(DataOrNew l -> DataOrNew l -> Bool)
-> (DataOrNew l -> DataOrNew l -> Bool) -> Eq (DataOrNew l)
forall l. Eq l => DataOrNew l -> DataOrNew l -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall l. Eq l => DataOrNew l -> DataOrNew l -> Bool
== :: DataOrNew l -> DataOrNew l -> Bool
$c/= :: forall l. Eq l => DataOrNew l -> DataOrNew l -> Bool
/= :: DataOrNew l -> DataOrNew l -> Bool
Eq,Eq (DataOrNew l)
Eq (DataOrNew l) =>
(DataOrNew l -> DataOrNew l -> Ordering)
-> (DataOrNew l -> DataOrNew l -> Bool)
-> (DataOrNew l -> DataOrNew l -> Bool)
-> (DataOrNew l -> DataOrNew l -> Bool)
-> (DataOrNew l -> DataOrNew l -> Bool)
-> (DataOrNew l -> DataOrNew l -> DataOrNew l)
-> (DataOrNew l -> DataOrNew l -> DataOrNew l)
-> Ord (DataOrNew l)
DataOrNew l -> DataOrNew l -> Bool
DataOrNew l -> DataOrNew l -> Ordering
DataOrNew l -> DataOrNew l -> DataOrNew l
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall l. Ord l => Eq (DataOrNew l)
forall l. Ord l => DataOrNew l -> DataOrNew l -> Bool
forall l. Ord l => DataOrNew l -> DataOrNew l -> Ordering
forall l. Ord l => DataOrNew l -> DataOrNew l -> DataOrNew l
$ccompare :: forall l. Ord l => DataOrNew l -> DataOrNew l -> Ordering
compare :: DataOrNew l -> DataOrNew l -> Ordering
$c< :: forall l. Ord l => DataOrNew l -> DataOrNew l -> Bool
< :: DataOrNew l -> DataOrNew l -> Bool
$c<= :: forall l. Ord l => DataOrNew l -> DataOrNew l -> Bool
<= :: DataOrNew l -> DataOrNew l -> Bool
$c> :: forall l. Ord l => DataOrNew l -> DataOrNew l -> Bool
> :: DataOrNew l -> DataOrNew l -> Bool
$c>= :: forall l. Ord l => DataOrNew l -> DataOrNew l -> Bool
>= :: DataOrNew l -> DataOrNew l -> Bool
$cmax :: forall l. Ord l => DataOrNew l -> DataOrNew l -> DataOrNew l
max :: DataOrNew l -> DataOrNew l -> DataOrNew l
$cmin :: forall l. Ord l => DataOrNew l -> DataOrNew l -> DataOrNew l
min :: DataOrNew l -> DataOrNew l -> DataOrNew l
Ord,Int -> DataOrNew l -> ShowS
[DataOrNew l] -> ShowS
DataOrNew l -> String
(Int -> DataOrNew l -> ShowS)
-> (DataOrNew l -> String)
-> ([DataOrNew l] -> ShowS)
-> Show (DataOrNew l)
forall l. Show l => Int -> DataOrNew l -> ShowS
forall l. Show l => [DataOrNew l] -> ShowS
forall l. Show l => DataOrNew l -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall l. Show l => Int -> DataOrNew l -> ShowS
showsPrec :: Int -> DataOrNew l -> ShowS
$cshow :: forall l. Show l => DataOrNew l -> String
show :: DataOrNew l -> String
$cshowList :: forall l. Show l => [DataOrNew l] -> ShowS
showList :: [DataOrNew l] -> ShowS
Show,Typeable,Typeable (DataOrNew l)
Typeable (DataOrNew l) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> DataOrNew l -> c (DataOrNew l))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (DataOrNew l))
-> (DataOrNew l -> Constr)
-> (DataOrNew l -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (DataOrNew l)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (DataOrNew l)))
-> ((forall b. Data b => b -> b) -> DataOrNew l -> DataOrNew l)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DataOrNew l -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DataOrNew l -> r)
-> (forall u. (forall d. Data d => d -> u) -> DataOrNew l -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> DataOrNew l -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DataOrNew l -> m (DataOrNew l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DataOrNew l -> m (DataOrNew l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DataOrNew l -> m (DataOrNew l))
-> Data (DataOrNew l)
DataOrNew l -> Constr
DataOrNew l -> DataType
(forall b. Data b => b -> b) -> DataOrNew l -> DataOrNew l
forall l. Data l => Typeable (DataOrNew l)
forall l. Data l => DataOrNew l -> Constr
forall l. Data l => DataOrNew l -> DataType
forall l.
Data l =>
(forall b. Data b => b -> b) -> DataOrNew l -> DataOrNew l
forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> DataOrNew l -> u
forall l u.
Data l =>
(forall d. Data d => d -> u) -> DataOrNew l -> [u]
forall l r r'.
Data l =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DataOrNew l -> r
forall l r r'.
Data l =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DataOrNew l -> r
forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d) -> DataOrNew l -> m (DataOrNew l)
forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> DataOrNew l -> m (DataOrNew l)
forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (DataOrNew l)
forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DataOrNew l -> c (DataOrNew l)
forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (DataOrNew l))
forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (DataOrNew l))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> DataOrNew l -> u
forall u. (forall d. Data d => d -> u) -> DataOrNew l -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DataOrNew l -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DataOrNew l -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DataOrNew l -> m (DataOrNew l)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DataOrNew l -> m (DataOrNew l)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (DataOrNew l)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DataOrNew l -> c (DataOrNew l)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (DataOrNew l))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (DataOrNew l))
$cgfoldl :: forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DataOrNew l -> c (DataOrNew l)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DataOrNew l -> c (DataOrNew l)
$cgunfold :: forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (DataOrNew l)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (DataOrNew l)
$ctoConstr :: forall l. Data l => DataOrNew l -> Constr
toConstr :: DataOrNew l -> Constr
$cdataTypeOf :: forall l. Data l => DataOrNew l -> DataType
dataTypeOf :: DataOrNew l -> DataType
$cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (DataOrNew l))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (DataOrNew l))
$cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (DataOrNew l))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (DataOrNew l))
$cgmapT :: forall l.
Data l =>
(forall b. Data b => b -> b) -> DataOrNew l -> DataOrNew l
gmapT :: (forall b. Data b => b -> b) -> DataOrNew l -> DataOrNew l
$cgmapQl :: forall l r r'.
Data l =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DataOrNew l -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DataOrNew l -> r
$cgmapQr :: forall l r r'.
Data l =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DataOrNew l -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DataOrNew l -> r
$cgmapQ :: forall l u.
Data l =>
(forall d. Data d => d -> u) -> DataOrNew l -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> DataOrNew l -> [u]
$cgmapQi :: forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> DataOrNew l -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DataOrNew l -> u
$cgmapM :: forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d) -> DataOrNew l -> m (DataOrNew l)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DataOrNew l -> m (DataOrNew l)
$cgmapMp :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> DataOrNew l -> m (DataOrNew l)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DataOrNew l -> m (DataOrNew l)
$cgmapMo :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> DataOrNew l -> m (DataOrNew l)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DataOrNew l -> m (DataOrNew l)
Data,(forall m. Monoid m => DataOrNew m -> m)
-> (forall m a. Monoid m => (a -> m) -> DataOrNew a -> m)
-> (forall m a. Monoid m => (a -> m) -> DataOrNew a -> m)
-> (forall a b. (a -> b -> b) -> b -> DataOrNew a -> b)
-> (forall a b. (a -> b -> b) -> b -> DataOrNew a -> b)
-> (forall b a. (b -> a -> b) -> b -> DataOrNew a -> b)
-> (forall b a. (b -> a -> b) -> b -> DataOrNew a -> b)
-> (forall a. (a -> a -> a) -> DataOrNew a -> a)
-> (forall a. (a -> a -> a) -> DataOrNew a -> a)
-> (forall a. DataOrNew a -> [a])
-> (forall a. DataOrNew a -> Bool)
-> (forall a. DataOrNew a -> Int)
-> (forall a. Eq a => a -> DataOrNew a -> Bool)
-> (forall a. Ord a => DataOrNew a -> a)
-> (forall a. Ord a => DataOrNew a -> a)
-> (forall a. Num a => DataOrNew a -> a)
-> (forall a. Num a => DataOrNew a -> a)
-> Foldable DataOrNew
forall a. Eq a => a -> DataOrNew a -> Bool
forall a. Num a => DataOrNew a -> a
forall a. Ord a => DataOrNew a -> a
forall m. Monoid m => DataOrNew m -> m
forall a. DataOrNew a -> Bool
forall a. DataOrNew a -> Int
forall a. DataOrNew a -> [a]
forall a. (a -> a -> a) -> DataOrNew a -> a
forall m a. Monoid m => (a -> m) -> DataOrNew a -> m
forall b a. (b -> a -> b) -> b -> DataOrNew a -> b
forall a b. (a -> b -> b) -> b -> DataOrNew a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall m. Monoid m => DataOrNew m -> m
fold :: forall m. Monoid m => DataOrNew m -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> DataOrNew a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> DataOrNew a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> DataOrNew a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> DataOrNew a -> m
$cfoldr :: forall a b. (a -> b -> b) -> b -> DataOrNew a -> b
foldr :: forall a b. (a -> b -> b) -> b -> DataOrNew a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> DataOrNew a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> DataOrNew a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> DataOrNew a -> b
foldl :: forall b a. (b -> a -> b) -> b -> DataOrNew a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> DataOrNew a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> DataOrNew a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> DataOrNew a -> a
foldr1 :: forall a. (a -> a -> a) -> DataOrNew a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> DataOrNew a -> a
foldl1 :: forall a. (a -> a -> a) -> DataOrNew a -> a
$ctoList :: forall a. DataOrNew a -> [a]
toList :: forall a. DataOrNew a -> [a]
$cnull :: forall a. DataOrNew a -> Bool
null :: forall a. DataOrNew a -> Bool
$clength :: forall a. DataOrNew a -> Int
length :: forall a. DataOrNew a -> Int
$celem :: forall a. Eq a => a -> DataOrNew a -> Bool
elem :: forall a. Eq a => a -> DataOrNew a -> Bool
$cmaximum :: forall a. Ord a => DataOrNew a -> a
maximum :: forall a. Ord a => DataOrNew a -> a
$cminimum :: forall a. Ord a => DataOrNew a -> a
minimum :: forall a. Ord a => DataOrNew a -> a
$csum :: forall a. Num a => DataOrNew a -> a
sum :: forall a. Num a => DataOrNew a -> a
$cproduct :: forall a. Num a => DataOrNew a -> a
product :: forall a. Num a => DataOrNew a -> a
Foldable,Functor DataOrNew
Foldable DataOrNew
(Functor DataOrNew, Foldable DataOrNew) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> DataOrNew a -> f (DataOrNew b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    DataOrNew (f a) -> f (DataOrNew a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> DataOrNew a -> m (DataOrNew b))
-> (forall (m :: * -> *) a.
    Monad m =>
    DataOrNew (m a) -> m (DataOrNew a))
-> Traversable DataOrNew
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a.
Monad m =>
DataOrNew (m a) -> m (DataOrNew a)
forall (f :: * -> *) a.
Applicative f =>
DataOrNew (f a) -> f (DataOrNew a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> DataOrNew a -> m (DataOrNew b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> DataOrNew a -> f (DataOrNew b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> DataOrNew a -> f (DataOrNew b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> DataOrNew a -> f (DataOrNew b)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
DataOrNew (f a) -> f (DataOrNew a)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
DataOrNew (f a) -> f (DataOrNew a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> DataOrNew a -> m (DataOrNew b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> DataOrNew a -> m (DataOrNew b)
$csequence :: forall (m :: * -> *) a.
Monad m =>
DataOrNew (m a) -> m (DataOrNew a)
sequence :: forall (m :: * -> *) a.
Monad m =>
DataOrNew (m a) -> m (DataOrNew a)
Traversable,(forall a b. (a -> b) -> DataOrNew a -> DataOrNew b)
-> (forall a b. a -> DataOrNew b -> DataOrNew a)
-> Functor DataOrNew
forall a b. a -> DataOrNew b -> DataOrNew a
forall a b. (a -> b) -> DataOrNew a -> DataOrNew b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> DataOrNew a -> DataOrNew b
fmap :: forall a b. (a -> b) -> DataOrNew a -> DataOrNew b
$c<$ :: forall a b. a -> DataOrNew b -> DataOrNew a
<$ :: forall a b. a -> DataOrNew b -> DataOrNew a
Functor,(forall x. DataOrNew l -> Rep (DataOrNew l) x)
-> (forall x. Rep (DataOrNew l) x -> DataOrNew l)
-> Generic (DataOrNew l)
forall x. Rep (DataOrNew l) x -> DataOrNew l
forall x. DataOrNew l -> Rep (DataOrNew l) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall l x. Rep (DataOrNew l) x -> DataOrNew l
forall l x. DataOrNew l -> Rep (DataOrNew l) x
$cfrom :: forall l x. DataOrNew l -> Rep (DataOrNew l) x
from :: forall x. DataOrNew l -> Rep (DataOrNew l) x
$cto :: forall l x. Rep (DataOrNew l) x -> DataOrNew l
to :: forall x. Rep (DataOrNew l) x -> DataOrNew l
Generic)


-- | Injectivity info for injective type families
data InjectivityInfo l = InjectivityInfo l (Name l) [Name l]
  deriving (InjectivityInfo l -> InjectivityInfo l -> Bool
(InjectivityInfo l -> InjectivityInfo l -> Bool)
-> (InjectivityInfo l -> InjectivityInfo l -> Bool)
-> Eq (InjectivityInfo l)
forall l. Eq l => InjectivityInfo l -> InjectivityInfo l -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall l. Eq l => InjectivityInfo l -> InjectivityInfo l -> Bool
== :: InjectivityInfo l -> InjectivityInfo l -> Bool
$c/= :: forall l. Eq l => InjectivityInfo l -> InjectivityInfo l -> Bool
/= :: InjectivityInfo l -> InjectivityInfo l -> Bool
Eq, Eq (InjectivityInfo l)
Eq (InjectivityInfo l) =>
(InjectivityInfo l -> InjectivityInfo l -> Ordering)
-> (InjectivityInfo l -> InjectivityInfo l -> Bool)
-> (InjectivityInfo l -> InjectivityInfo l -> Bool)
-> (InjectivityInfo l -> InjectivityInfo l -> Bool)
-> (InjectivityInfo l -> InjectivityInfo l -> Bool)
-> (InjectivityInfo l -> InjectivityInfo l -> InjectivityInfo l)
-> (InjectivityInfo l -> InjectivityInfo l -> InjectivityInfo l)
-> Ord (InjectivityInfo l)
InjectivityInfo l -> InjectivityInfo l -> Bool
InjectivityInfo l -> InjectivityInfo l -> Ordering
InjectivityInfo l -> InjectivityInfo l -> InjectivityInfo l
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall l. Ord l => Eq (InjectivityInfo l)
forall l. Ord l => InjectivityInfo l -> InjectivityInfo l -> Bool
forall l.
Ord l =>
InjectivityInfo l -> InjectivityInfo l -> Ordering
forall l.
Ord l =>
InjectivityInfo l -> InjectivityInfo l -> InjectivityInfo l
$ccompare :: forall l.
Ord l =>
InjectivityInfo l -> InjectivityInfo l -> Ordering
compare :: InjectivityInfo l -> InjectivityInfo l -> Ordering
$c< :: forall l. Ord l => InjectivityInfo l -> InjectivityInfo l -> Bool
< :: InjectivityInfo l -> InjectivityInfo l -> Bool
$c<= :: forall l. Ord l => InjectivityInfo l -> InjectivityInfo l -> Bool
<= :: InjectivityInfo l -> InjectivityInfo l -> Bool
$c> :: forall l. Ord l => InjectivityInfo l -> InjectivityInfo l -> Bool
> :: InjectivityInfo l -> InjectivityInfo l -> Bool
$c>= :: forall l. Ord l => InjectivityInfo l -> InjectivityInfo l -> Bool
>= :: InjectivityInfo l -> InjectivityInfo l -> Bool
$cmax :: forall l.
Ord l =>
InjectivityInfo l -> InjectivityInfo l -> InjectivityInfo l
max :: InjectivityInfo l -> InjectivityInfo l -> InjectivityInfo l
$cmin :: forall l.
Ord l =>
InjectivityInfo l -> InjectivityInfo l -> InjectivityInfo l
min :: InjectivityInfo l -> InjectivityInfo l -> InjectivityInfo l
Ord, Int -> InjectivityInfo l -> ShowS
[InjectivityInfo l] -> ShowS
InjectivityInfo l -> String
(Int -> InjectivityInfo l -> ShowS)
-> (InjectivityInfo l -> String)
-> ([InjectivityInfo l] -> ShowS)
-> Show (InjectivityInfo l)
forall l. Show l => Int -> InjectivityInfo l -> ShowS
forall l. Show l => [InjectivityInfo l] -> ShowS
forall l. Show l => InjectivityInfo l -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall l. Show l => Int -> InjectivityInfo l -> ShowS
showsPrec :: Int -> InjectivityInfo l -> ShowS
$cshow :: forall l. Show l => InjectivityInfo l -> String
show :: InjectivityInfo l -> String
$cshowList :: forall l. Show l => [InjectivityInfo l] -> ShowS
showList :: [InjectivityInfo l] -> ShowS
Show, Typeable, Typeable (InjectivityInfo l)
Typeable (InjectivityInfo l) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g)
 -> InjectivityInfo l
 -> c (InjectivityInfo l))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (InjectivityInfo l))
-> (InjectivityInfo l -> Constr)
-> (InjectivityInfo l -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (InjectivityInfo l)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (InjectivityInfo l)))
-> ((forall b. Data b => b -> b)
    -> InjectivityInfo l -> InjectivityInfo l)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> InjectivityInfo l -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> InjectivityInfo l -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> InjectivityInfo l -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> InjectivityInfo l -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> InjectivityInfo l -> m (InjectivityInfo l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> InjectivityInfo l -> m (InjectivityInfo l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> InjectivityInfo l -> m (InjectivityInfo l))
-> Data (InjectivityInfo l)
InjectivityInfo l -> Constr
InjectivityInfo l -> DataType
(forall b. Data b => b -> b)
-> InjectivityInfo l -> InjectivityInfo l
forall l. Data l => Typeable (InjectivityInfo l)
forall l. Data l => InjectivityInfo l -> Constr
forall l. Data l => InjectivityInfo l -> DataType
forall l.
Data l =>
(forall b. Data b => b -> b)
-> InjectivityInfo l -> InjectivityInfo l
forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> InjectivityInfo l -> u
forall l u.
Data l =>
(forall d. Data d => d -> u) -> InjectivityInfo l -> [u]
forall l r r'.
Data l =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> InjectivityInfo l -> r
forall l r r'.
Data l =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> InjectivityInfo l -> r
forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d)
-> InjectivityInfo l -> m (InjectivityInfo l)
forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> InjectivityInfo l -> m (InjectivityInfo l)
forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (InjectivityInfo l)
forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> InjectivityInfo l
-> c (InjectivityInfo l)
forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (InjectivityInfo l))
forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (InjectivityInfo l))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> InjectivityInfo l -> u
forall u. (forall d. Data d => d -> u) -> InjectivityInfo l -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> InjectivityInfo l -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> InjectivityInfo l -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> InjectivityInfo l -> m (InjectivityInfo l)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> InjectivityInfo l -> m (InjectivityInfo l)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (InjectivityInfo l)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> InjectivityInfo l
-> c (InjectivityInfo l)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (InjectivityInfo l))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (InjectivityInfo l))
$cgfoldl :: forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> InjectivityInfo l
-> c (InjectivityInfo l)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> InjectivityInfo l
-> c (InjectivityInfo l)
$cgunfold :: forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (InjectivityInfo l)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (InjectivityInfo l)
$ctoConstr :: forall l. Data l => InjectivityInfo l -> Constr
toConstr :: InjectivityInfo l -> Constr
$cdataTypeOf :: forall l. Data l => InjectivityInfo l -> DataType
dataTypeOf :: InjectivityInfo l -> DataType
$cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (InjectivityInfo l))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (InjectivityInfo l))
$cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (InjectivityInfo l))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (InjectivityInfo l))
$cgmapT :: forall l.
Data l =>
(forall b. Data b => b -> b)
-> InjectivityInfo l -> InjectivityInfo l
gmapT :: (forall b. Data b => b -> b)
-> InjectivityInfo l -> InjectivityInfo l
$cgmapQl :: forall l r r'.
Data l =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> InjectivityInfo l -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> InjectivityInfo l -> r
$cgmapQr :: forall l r r'.
Data l =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> InjectivityInfo l -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> InjectivityInfo l -> r
$cgmapQ :: forall l u.
Data l =>
(forall d. Data d => d -> u) -> InjectivityInfo l -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> InjectivityInfo l -> [u]
$cgmapQi :: forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> InjectivityInfo l -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> InjectivityInfo l -> u
$cgmapM :: forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d)
-> InjectivityInfo l -> m (InjectivityInfo l)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> InjectivityInfo l -> m (InjectivityInfo l)
$cgmapMp :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> InjectivityInfo l -> m (InjectivityInfo l)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> InjectivityInfo l -> m (InjectivityInfo l)
$cgmapMo :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> InjectivityInfo l -> m (InjectivityInfo l)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> InjectivityInfo l -> m (InjectivityInfo l)
Data, (forall m. Monoid m => InjectivityInfo m -> m)
-> (forall m a. Monoid m => (a -> m) -> InjectivityInfo a -> m)
-> (forall m a. Monoid m => (a -> m) -> InjectivityInfo a -> m)
-> (forall a b. (a -> b -> b) -> b -> InjectivityInfo a -> b)
-> (forall a b. (a -> b -> b) -> b -> InjectivityInfo a -> b)
-> (forall b a. (b -> a -> b) -> b -> InjectivityInfo a -> b)
-> (forall b a. (b -> a -> b) -> b -> InjectivityInfo a -> b)
-> (forall a. (a -> a -> a) -> InjectivityInfo a -> a)
-> (forall a. (a -> a -> a) -> InjectivityInfo a -> a)
-> (forall a. InjectivityInfo a -> [a])
-> (forall a. InjectivityInfo a -> Bool)
-> (forall a. InjectivityInfo a -> Int)
-> (forall a. Eq a => a -> InjectivityInfo a -> Bool)
-> (forall a. Ord a => InjectivityInfo a -> a)
-> (forall a. Ord a => InjectivityInfo a -> a)
-> (forall a. Num a => InjectivityInfo a -> a)
-> (forall a. Num a => InjectivityInfo a -> a)
-> Foldable InjectivityInfo
forall a. Eq a => a -> InjectivityInfo a -> Bool
forall a. Num a => InjectivityInfo a -> a
forall a. Ord a => InjectivityInfo a -> a
forall m. Monoid m => InjectivityInfo m -> m
forall a. InjectivityInfo a -> Bool
forall a. InjectivityInfo a -> Int
forall a. InjectivityInfo a -> [a]
forall a. (a -> a -> a) -> InjectivityInfo a -> a
forall m a. Monoid m => (a -> m) -> InjectivityInfo a -> m
forall b a. (b -> a -> b) -> b -> InjectivityInfo a -> b
forall a b. (a -> b -> b) -> b -> InjectivityInfo a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall m. Monoid m => InjectivityInfo m -> m
fold :: forall m. Monoid m => InjectivityInfo m -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> InjectivityInfo a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> InjectivityInfo a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> InjectivityInfo a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> InjectivityInfo a -> m
$cfoldr :: forall a b. (a -> b -> b) -> b -> InjectivityInfo a -> b
foldr :: forall a b. (a -> b -> b) -> b -> InjectivityInfo a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> InjectivityInfo a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> InjectivityInfo a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> InjectivityInfo a -> b
foldl :: forall b a. (b -> a -> b) -> b -> InjectivityInfo a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> InjectivityInfo a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> InjectivityInfo a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> InjectivityInfo a -> a
foldr1 :: forall a. (a -> a -> a) -> InjectivityInfo a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> InjectivityInfo a -> a
foldl1 :: forall a. (a -> a -> a) -> InjectivityInfo a -> a
$ctoList :: forall a. InjectivityInfo a -> [a]
toList :: forall a. InjectivityInfo a -> [a]
$cnull :: forall a. InjectivityInfo a -> Bool
null :: forall a. InjectivityInfo a -> Bool
$clength :: forall a. InjectivityInfo a -> Int
length :: forall a. InjectivityInfo a -> Int
$celem :: forall a. Eq a => a -> InjectivityInfo a -> Bool
elem :: forall a. Eq a => a -> InjectivityInfo a -> Bool
$cmaximum :: forall a. Ord a => InjectivityInfo a -> a
maximum :: forall a. Ord a => InjectivityInfo a -> a
$cminimum :: forall a. Ord a => InjectivityInfo a -> a
minimum :: forall a. Ord a => InjectivityInfo a -> a
$csum :: forall a. Num a => InjectivityInfo a -> a
sum :: forall a. Num a => InjectivityInfo a -> a
$cproduct :: forall a. Num a => InjectivityInfo a -> a
product :: forall a. Num a => InjectivityInfo a -> a
Foldable, Functor InjectivityInfo
Foldable InjectivityInfo
(Functor InjectivityInfo, Foldable InjectivityInfo) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> InjectivityInfo a -> f (InjectivityInfo b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    InjectivityInfo (f a) -> f (InjectivityInfo a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> InjectivityInfo a -> m (InjectivityInfo b))
-> (forall (m :: * -> *) a.
    Monad m =>
    InjectivityInfo (m a) -> m (InjectivityInfo a))
-> Traversable InjectivityInfo
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a.
Monad m =>
InjectivityInfo (m a) -> m (InjectivityInfo a)
forall (f :: * -> *) a.
Applicative f =>
InjectivityInfo (f a) -> f (InjectivityInfo a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> InjectivityInfo a -> m (InjectivityInfo b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> InjectivityInfo a -> f (InjectivityInfo b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> InjectivityInfo a -> f (InjectivityInfo b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> InjectivityInfo a -> f (InjectivityInfo b)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
InjectivityInfo (f a) -> f (InjectivityInfo a)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
InjectivityInfo (f a) -> f (InjectivityInfo a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> InjectivityInfo a -> m (InjectivityInfo b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> InjectivityInfo a -> m (InjectivityInfo b)
$csequence :: forall (m :: * -> *) a.
Monad m =>
InjectivityInfo (m a) -> m (InjectivityInfo a)
sequence :: forall (m :: * -> *) a.
Monad m =>
InjectivityInfo (m a) -> m (InjectivityInfo a)
Traversable, (forall a b. (a -> b) -> InjectivityInfo a -> InjectivityInfo b)
-> (forall a b. a -> InjectivityInfo b -> InjectivityInfo a)
-> Functor InjectivityInfo
forall a b. a -> InjectivityInfo b -> InjectivityInfo a
forall a b. (a -> b) -> InjectivityInfo a -> InjectivityInfo b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> InjectivityInfo a -> InjectivityInfo b
fmap :: forall a b. (a -> b) -> InjectivityInfo a -> InjectivityInfo b
$c<$ :: forall a b. a -> InjectivityInfo b -> InjectivityInfo a
<$ :: forall a b. a -> InjectivityInfo b -> InjectivityInfo a
Functor, (forall x. InjectivityInfo l -> Rep (InjectivityInfo l) x)
-> (forall x. Rep (InjectivityInfo l) x -> InjectivityInfo l)
-> Generic (InjectivityInfo l)
forall x. Rep (InjectivityInfo l) x -> InjectivityInfo l
forall x. InjectivityInfo l -> Rep (InjectivityInfo l) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall l x. Rep (InjectivityInfo l) x -> InjectivityInfo l
forall l x. InjectivityInfo l -> Rep (InjectivityInfo l) x
$cfrom :: forall l x. InjectivityInfo l -> Rep (InjectivityInfo l) x
from :: forall x. InjectivityInfo l -> Rep (InjectivityInfo l) x
$cto :: forall l x. Rep (InjectivityInfo l) x -> InjectivityInfo l
to :: forall x. Rep (InjectivityInfo l) x -> InjectivityInfo l
Generic)

data ResultSig l = KindSig l (Kind l) | TyVarSig l (TyVarBind l)
  deriving (ResultSig l -> ResultSig l -> Bool
(ResultSig l -> ResultSig l -> Bool)
-> (ResultSig l -> ResultSig l -> Bool) -> Eq (ResultSig l)
forall l. Eq l => ResultSig l -> ResultSig l -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall l. Eq l => ResultSig l -> ResultSig l -> Bool
== :: ResultSig l -> ResultSig l -> Bool
$c/= :: forall l. Eq l => ResultSig l -> ResultSig l -> Bool
/= :: ResultSig l -> ResultSig l -> Bool
Eq, Eq (ResultSig l)
Eq (ResultSig l) =>
(ResultSig l -> ResultSig l -> Ordering)
-> (ResultSig l -> ResultSig l -> Bool)
-> (ResultSig l -> ResultSig l -> Bool)
-> (ResultSig l -> ResultSig l -> Bool)
-> (ResultSig l -> ResultSig l -> Bool)
-> (ResultSig l -> ResultSig l -> ResultSig l)
-> (ResultSig l -> ResultSig l -> ResultSig l)
-> Ord (ResultSig l)
ResultSig l -> ResultSig l -> Bool
ResultSig l -> ResultSig l -> Ordering
ResultSig l -> ResultSig l -> ResultSig l
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall l. Ord l => Eq (ResultSig l)
forall l. Ord l => ResultSig l -> ResultSig l -> Bool
forall l. Ord l => ResultSig l -> ResultSig l -> Ordering
forall l. Ord l => ResultSig l -> ResultSig l -> ResultSig l
$ccompare :: forall l. Ord l => ResultSig l -> ResultSig l -> Ordering
compare :: ResultSig l -> ResultSig l -> Ordering
$c< :: forall l. Ord l => ResultSig l -> ResultSig l -> Bool
< :: ResultSig l -> ResultSig l -> Bool
$c<= :: forall l. Ord l => ResultSig l -> ResultSig l -> Bool
<= :: ResultSig l -> ResultSig l -> Bool
$c> :: forall l. Ord l => ResultSig l -> ResultSig l -> Bool
> :: ResultSig l -> ResultSig l -> Bool
$c>= :: forall l. Ord l => ResultSig l -> ResultSig l -> Bool
>= :: ResultSig l -> ResultSig l -> Bool
$cmax :: forall l. Ord l => ResultSig l -> ResultSig l -> ResultSig l
max :: ResultSig l -> ResultSig l -> ResultSig l
$cmin :: forall l. Ord l => ResultSig l -> ResultSig l -> ResultSig l
min :: ResultSig l -> ResultSig l -> ResultSig l
Ord, Int -> ResultSig l -> ShowS
[ResultSig l] -> ShowS
ResultSig l -> String
(Int -> ResultSig l -> ShowS)
-> (ResultSig l -> String)
-> ([ResultSig l] -> ShowS)
-> Show (ResultSig l)
forall l. Show l => Int -> ResultSig l -> ShowS
forall l. Show l => [ResultSig l] -> ShowS
forall l. Show l => ResultSig l -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall l. Show l => Int -> ResultSig l -> ShowS
showsPrec :: Int -> ResultSig l -> ShowS
$cshow :: forall l. Show l => ResultSig l -> String
show :: ResultSig l -> String
$cshowList :: forall l. Show l => [ResultSig l] -> ShowS
showList :: [ResultSig l] -> ShowS
Show, Typeable, Typeable (ResultSig l)
Typeable (ResultSig l) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> ResultSig l -> c (ResultSig l))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (ResultSig l))
-> (ResultSig l -> Constr)
-> (ResultSig l -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (ResultSig l)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (ResultSig l)))
-> ((forall b. Data b => b -> b) -> ResultSig l -> ResultSig l)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ResultSig l -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ResultSig l -> r)
-> (forall u. (forall d. Data d => d -> u) -> ResultSig l -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> ResultSig l -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ResultSig l -> m (ResultSig l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ResultSig l -> m (ResultSig l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ResultSig l -> m (ResultSig l))
-> Data (ResultSig l)
ResultSig l -> Constr
ResultSig l -> DataType
(forall b. Data b => b -> b) -> ResultSig l -> ResultSig l
forall l. Data l => Typeable (ResultSig l)
forall l. Data l => ResultSig l -> Constr
forall l. Data l => ResultSig l -> DataType
forall l.
Data l =>
(forall b. Data b => b -> b) -> ResultSig l -> ResultSig l
forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> ResultSig l -> u
forall l u.
Data l =>
(forall d. Data d => d -> u) -> ResultSig l -> [u]
forall l r r'.
Data l =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ResultSig l -> r
forall l r r'.
Data l =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ResultSig l -> r
forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d) -> ResultSig l -> m (ResultSig l)
forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> ResultSig l -> m (ResultSig l)
forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ResultSig l)
forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ResultSig l -> c (ResultSig l)
forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (ResultSig l))
forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ResultSig l))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> ResultSig l -> u
forall u. (forall d. Data d => d -> u) -> ResultSig l -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ResultSig l -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ResultSig l -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ResultSig l -> m (ResultSig l)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ResultSig l -> m (ResultSig l)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ResultSig l)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ResultSig l -> c (ResultSig l)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (ResultSig l))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ResultSig l))
$cgfoldl :: forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ResultSig l -> c (ResultSig l)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ResultSig l -> c (ResultSig l)
$cgunfold :: forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ResultSig l)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ResultSig l)
$ctoConstr :: forall l. Data l => ResultSig l -> Constr
toConstr :: ResultSig l -> Constr
$cdataTypeOf :: forall l. Data l => ResultSig l -> DataType
dataTypeOf :: ResultSig l -> DataType
$cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (ResultSig l))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (ResultSig l))
$cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ResultSig l))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ResultSig l))
$cgmapT :: forall l.
Data l =>
(forall b. Data b => b -> b) -> ResultSig l -> ResultSig l
gmapT :: (forall b. Data b => b -> b) -> ResultSig l -> ResultSig l
$cgmapQl :: forall l r r'.
Data l =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ResultSig l -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ResultSig l -> r
$cgmapQr :: forall l r r'.
Data l =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ResultSig l -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ResultSig l -> r
$cgmapQ :: forall l u.
Data l =>
(forall d. Data d => d -> u) -> ResultSig l -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> ResultSig l -> [u]
$cgmapQi :: forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> ResultSig l -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ResultSig l -> u
$cgmapM :: forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d) -> ResultSig l -> m (ResultSig l)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ResultSig l -> m (ResultSig l)
$cgmapMp :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> ResultSig l -> m (ResultSig l)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ResultSig l -> m (ResultSig l)
$cgmapMo :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> ResultSig l -> m (ResultSig l)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ResultSig l -> m (ResultSig l)
Data, (forall m. Monoid m => ResultSig m -> m)
-> (forall m a. Monoid m => (a -> m) -> ResultSig a -> m)
-> (forall m a. Monoid m => (a -> m) -> ResultSig a -> m)
-> (forall a b. (a -> b -> b) -> b -> ResultSig a -> b)
-> (forall a b. (a -> b -> b) -> b -> ResultSig a -> b)
-> (forall b a. (b -> a -> b) -> b -> ResultSig a -> b)
-> (forall b a. (b -> a -> b) -> b -> ResultSig a -> b)
-> (forall a. (a -> a -> a) -> ResultSig a -> a)
-> (forall a. (a -> a -> a) -> ResultSig a -> a)
-> (forall a. ResultSig a -> [a])
-> (forall a. ResultSig a -> Bool)
-> (forall a. ResultSig a -> Int)
-> (forall a. Eq a => a -> ResultSig a -> Bool)
-> (forall a. Ord a => ResultSig a -> a)
-> (forall a. Ord a => ResultSig a -> a)
-> (forall a. Num a => ResultSig a -> a)
-> (forall a. Num a => ResultSig a -> a)
-> Foldable ResultSig
forall a. Eq a => a -> ResultSig a -> Bool
forall a. Num a => ResultSig a -> a
forall a. Ord a => ResultSig a -> a
forall m. Monoid m => ResultSig m -> m
forall a. ResultSig a -> Bool
forall a. ResultSig a -> Int
forall a. ResultSig a -> [a]
forall a. (a -> a -> a) -> ResultSig a -> a
forall m a. Monoid m => (a -> m) -> ResultSig a -> m
forall b a. (b -> a -> b) -> b -> ResultSig a -> b
forall a b. (a -> b -> b) -> b -> ResultSig a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall m. Monoid m => ResultSig m -> m
fold :: forall m. Monoid m => ResultSig m -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> ResultSig a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> ResultSig a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> ResultSig a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> ResultSig a -> m
$cfoldr :: forall a b. (a -> b -> b) -> b -> ResultSig a -> b
foldr :: forall a b. (a -> b -> b) -> b -> ResultSig a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> ResultSig a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> ResultSig a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> ResultSig a -> b
foldl :: forall b a. (b -> a -> b) -> b -> ResultSig a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> ResultSig a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> ResultSig a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> ResultSig a -> a
foldr1 :: forall a. (a -> a -> a) -> ResultSig a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> ResultSig a -> a
foldl1 :: forall a. (a -> a -> a) -> ResultSig a -> a
$ctoList :: forall a. ResultSig a -> [a]
toList :: forall a. ResultSig a -> [a]
$cnull :: forall a. ResultSig a -> Bool
null :: forall a. ResultSig a -> Bool
$clength :: forall a. ResultSig a -> Int
length :: forall a. ResultSig a -> Int
$celem :: forall a. Eq a => a -> ResultSig a -> Bool
elem :: forall a. Eq a => a -> ResultSig a -> Bool
$cmaximum :: forall a. Ord a => ResultSig a -> a
maximum :: forall a. Ord a => ResultSig a -> a
$cminimum :: forall a. Ord a => ResultSig a -> a
minimum :: forall a. Ord a => ResultSig a -> a
$csum :: forall a. Num a => ResultSig a -> a
sum :: forall a. Num a => ResultSig a -> a
$cproduct :: forall a. Num a => ResultSig a -> a
product :: forall a. Num a => ResultSig a -> a
Foldable, Functor ResultSig
Foldable ResultSig
(Functor ResultSig, Foldable ResultSig) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> ResultSig a -> f (ResultSig b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    ResultSig (f a) -> f (ResultSig a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> ResultSig a -> m (ResultSig b))
-> (forall (m :: * -> *) a.
    Monad m =>
    ResultSig (m a) -> m (ResultSig a))
-> Traversable ResultSig
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a.
Monad m =>
ResultSig (m a) -> m (ResultSig a)
forall (f :: * -> *) a.
Applicative f =>
ResultSig (f a) -> f (ResultSig a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> ResultSig a -> m (ResultSig b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> ResultSig a -> f (ResultSig b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> ResultSig a -> f (ResultSig b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> ResultSig a -> f (ResultSig b)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
ResultSig (f a) -> f (ResultSig a)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
ResultSig (f a) -> f (ResultSig a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> ResultSig a -> m (ResultSig b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> ResultSig a -> m (ResultSig b)
$csequence :: forall (m :: * -> *) a.
Monad m =>
ResultSig (m a) -> m (ResultSig a)
sequence :: forall (m :: * -> *) a.
Monad m =>
ResultSig (m a) -> m (ResultSig a)
Traversable, (forall a b. (a -> b) -> ResultSig a -> ResultSig b)
-> (forall a b. a -> ResultSig b -> ResultSig a)
-> Functor ResultSig
forall a b. a -> ResultSig b -> ResultSig a
forall a b. (a -> b) -> ResultSig a -> ResultSig b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> ResultSig a -> ResultSig b
fmap :: forall a b. (a -> b) -> ResultSig a -> ResultSig b
$c<$ :: forall a b. a -> ResultSig b -> ResultSig a
<$ :: forall a b. a -> ResultSig b -> ResultSig a
Functor, (forall x. ResultSig l -> Rep (ResultSig l) x)
-> (forall x. Rep (ResultSig l) x -> ResultSig l)
-> Generic (ResultSig l)
forall x. Rep (ResultSig l) x -> ResultSig l
forall x. ResultSig l -> Rep (ResultSig l) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall l x. Rep (ResultSig l) x -> ResultSig l
forall l x. ResultSig l -> Rep (ResultSig l) x
$cfrom :: forall l x. ResultSig l -> Rep (ResultSig l) x
from :: forall x. ResultSig l -> Rep (ResultSig l) x
$cto :: forall l x. Rep (ResultSig l) x -> ResultSig l
to :: forall x. Rep (ResultSig l) x -> ResultSig l
Generic)

-- | The head of a type or class declaration, which consists of the type
-- or class name applied to some type variables
--
-- @class C a b@ is represented as
--
-- >DHApp
-- >   ()
-- >   (DHApp
-- >      () (DHead () (Ident () "C")) (UnkindedVar () (Ident () "a")))
-- >   (UnkindedVar () (Ident () "b"))
--
-- (where the annotation type @l@ is instantiated with @()@)
--
-- @class (a :< b) c@ is represented as
--
-- >DHApp
-- >   ()
-- >   (DHParen
-- >      ()
-- >      (DHApp
-- >         ()
-- >         (DHInfix () (UnkindedVar () (Ident () "a")) (Symbol () ":<"))
-- >         (UnkindedVar () (Ident () "b"))))
-- >   (UnkindedVar () (Ident () "c"))
data DeclHead l
    = DHead l (Name l) -- ^ type or class name
    | DHInfix l (TyVarBind l) (Name l) -- ^ infix application of the type/class name to the left operand
    | DHParen l (DeclHead l) -- ^ parenthesized declaration head
    | DHApp   l (DeclHead l) (TyVarBind l) -- ^ application to one more type variable
  deriving (DeclHead l -> DeclHead l -> Bool
(DeclHead l -> DeclHead l -> Bool)
-> (DeclHead l -> DeclHead l -> Bool) -> Eq (DeclHead l)
forall l. Eq l => DeclHead l -> DeclHead l -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall l. Eq l => DeclHead l -> DeclHead l -> Bool
== :: DeclHead l -> DeclHead l -> Bool
$c/= :: forall l. Eq l => DeclHead l -> DeclHead l -> Bool
/= :: DeclHead l -> DeclHead l -> Bool
Eq,Eq (DeclHead l)
Eq (DeclHead l) =>
(DeclHead l -> DeclHead l -> Ordering)
-> (DeclHead l -> DeclHead l -> Bool)
-> (DeclHead l -> DeclHead l -> Bool)
-> (DeclHead l -> DeclHead l -> Bool)
-> (DeclHead l -> DeclHead l -> Bool)
-> (DeclHead l -> DeclHead l -> DeclHead l)
-> (DeclHead l -> DeclHead l -> DeclHead l)
-> Ord (DeclHead l)
DeclHead l -> DeclHead l -> Bool
DeclHead l -> DeclHead l -> Ordering
DeclHead l -> DeclHead l -> DeclHead l
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall l. Ord l => Eq (DeclHead l)
forall l. Ord l => DeclHead l -> DeclHead l -> Bool
forall l. Ord l => DeclHead l -> DeclHead l -> Ordering
forall l. Ord l => DeclHead l -> DeclHead l -> DeclHead l
$ccompare :: forall l. Ord l => DeclHead l -> DeclHead l -> Ordering
compare :: DeclHead l -> DeclHead l -> Ordering
$c< :: forall l. Ord l => DeclHead l -> DeclHead l -> Bool
< :: DeclHead l -> DeclHead l -> Bool
$c<= :: forall l. Ord l => DeclHead l -> DeclHead l -> Bool
<= :: DeclHead l -> DeclHead l -> Bool
$c> :: forall l. Ord l => DeclHead l -> DeclHead l -> Bool
> :: DeclHead l -> DeclHead l -> Bool
$c>= :: forall l. Ord l => DeclHead l -> DeclHead l -> Bool
>= :: DeclHead l -> DeclHead l -> Bool
$cmax :: forall l. Ord l => DeclHead l -> DeclHead l -> DeclHead l
max :: DeclHead l -> DeclHead l -> DeclHead l
$cmin :: forall l. Ord l => DeclHead l -> DeclHead l -> DeclHead l
min :: DeclHead l -> DeclHead l -> DeclHead l
Ord,Int -> DeclHead l -> ShowS
[DeclHead l] -> ShowS
DeclHead l -> String
(Int -> DeclHead l -> ShowS)
-> (DeclHead l -> String)
-> ([DeclHead l] -> ShowS)
-> Show (DeclHead l)
forall l. Show l => Int -> DeclHead l -> ShowS
forall l. Show l => [DeclHead l] -> ShowS
forall l. Show l => DeclHead l -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall l. Show l => Int -> DeclHead l -> ShowS
showsPrec :: Int -> DeclHead l -> ShowS
$cshow :: forall l. Show l => DeclHead l -> String
show :: DeclHead l -> String
$cshowList :: forall l. Show l => [DeclHead l] -> ShowS
showList :: [DeclHead l] -> ShowS
Show,Typeable,Typeable (DeclHead l)
Typeable (DeclHead l) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> DeclHead l -> c (DeclHead l))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (DeclHead l))
-> (DeclHead l -> Constr)
-> (DeclHead l -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (DeclHead l)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (DeclHead l)))
-> ((forall b. Data b => b -> b) -> DeclHead l -> DeclHead l)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DeclHead l -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DeclHead l -> r)
-> (forall u. (forall d. Data d => d -> u) -> DeclHead l -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> DeclHead l -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DeclHead l -> m (DeclHead l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DeclHead l -> m (DeclHead l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DeclHead l -> m (DeclHead l))
-> Data (DeclHead l)
DeclHead l -> Constr
DeclHead l -> DataType
(forall b. Data b => b -> b) -> DeclHead l -> DeclHead l
forall l. Data l => Typeable (DeclHead l)
forall l. Data l => DeclHead l -> Constr
forall l. Data l => DeclHead l -> DataType
forall l.
Data l =>
(forall b. Data b => b -> b) -> DeclHead l -> DeclHead l
forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> DeclHead l -> u
forall l u.
Data l =>
(forall d. Data d => d -> u) -> DeclHead l -> [u]
forall l r r'.
Data l =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DeclHead l -> r
forall l r r'.
Data l =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DeclHead l -> r
forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d) -> DeclHead l -> m (DeclHead l)
forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> DeclHead l -> m (DeclHead l)
forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (DeclHead l)
forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DeclHead l -> c (DeclHead l)
forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (DeclHead l))
forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (DeclHead l))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> DeclHead l -> u
forall u. (forall d. Data d => d -> u) -> DeclHead l -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DeclHead l -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DeclHead l -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DeclHead l -> m (DeclHead l)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DeclHead l -> m (DeclHead l)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (DeclHead l)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DeclHead l -> c (DeclHead l)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (DeclHead l))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (DeclHead l))
$cgfoldl :: forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DeclHead l -> c (DeclHead l)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DeclHead l -> c (DeclHead l)
$cgunfold :: forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (DeclHead l)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (DeclHead l)
$ctoConstr :: forall l. Data l => DeclHead l -> Constr
toConstr :: DeclHead l -> Constr
$cdataTypeOf :: forall l. Data l => DeclHead l -> DataType
dataTypeOf :: DeclHead l -> DataType
$cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (DeclHead l))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (DeclHead l))
$cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (DeclHead l))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (DeclHead l))
$cgmapT :: forall l.
Data l =>
(forall b. Data b => b -> b) -> DeclHead l -> DeclHead l
gmapT :: (forall b. Data b => b -> b) -> DeclHead l -> DeclHead l
$cgmapQl :: forall l r r'.
Data l =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DeclHead l -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DeclHead l -> r
$cgmapQr :: forall l r r'.
Data l =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DeclHead l -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DeclHead l -> r
$cgmapQ :: forall l u.
Data l =>
(forall d. Data d => d -> u) -> DeclHead l -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> DeclHead l -> [u]
$cgmapQi :: forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> DeclHead l -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DeclHead l -> u
$cgmapM :: forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d) -> DeclHead l -> m (DeclHead l)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DeclHead l -> m (DeclHead l)
$cgmapMp :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> DeclHead l -> m (DeclHead l)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DeclHead l -> m (DeclHead l)
$cgmapMo :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> DeclHead l -> m (DeclHead l)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DeclHead l -> m (DeclHead l)
Data,(forall m. Monoid m => DeclHead m -> m)
-> (forall m a. Monoid m => (a -> m) -> DeclHead a -> m)
-> (forall m a. Monoid m => (a -> m) -> DeclHead a -> m)
-> (forall a b. (a -> b -> b) -> b -> DeclHead a -> b)
-> (forall a b. (a -> b -> b) -> b -> DeclHead a -> b)
-> (forall b a. (b -> a -> b) -> b -> DeclHead a -> b)
-> (forall b a. (b -> a -> b) -> b -> DeclHead a -> b)
-> (forall a. (a -> a -> a) -> DeclHead a -> a)
-> (forall a. (a -> a -> a) -> DeclHead a -> a)
-> (forall a. DeclHead a -> [a])
-> (forall a. DeclHead a -> Bool)
-> (forall a. DeclHead a -> Int)
-> (forall a. Eq a => a -> DeclHead a -> Bool)
-> (forall a. Ord a => DeclHead a -> a)
-> (forall a. Ord a => DeclHead a -> a)
-> (forall a. Num a => DeclHead a -> a)
-> (forall a. Num a => DeclHead a -> a)
-> Foldable DeclHead
forall a. Eq a => a -> DeclHead a -> Bool
forall a. Num a => DeclHead a -> a
forall a. Ord a => DeclHead a -> a
forall m. Monoid m => DeclHead m -> m
forall a. DeclHead a -> Bool
forall a. DeclHead a -> Int
forall a. DeclHead a -> [a]
forall a. (a -> a -> a) -> DeclHead a -> a
forall m a. Monoid m => (a -> m) -> DeclHead a -> m
forall b a. (b -> a -> b) -> b -> DeclHead a -> b
forall a b. (a -> b -> b) -> b -> DeclHead a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall m. Monoid m => DeclHead m -> m
fold :: forall m. Monoid m => DeclHead m -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> DeclHead a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> DeclHead a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> DeclHead a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> DeclHead a -> m
$cfoldr :: forall a b. (a -> b -> b) -> b -> DeclHead a -> b
foldr :: forall a b. (a -> b -> b) -> b -> DeclHead a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> DeclHead a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> DeclHead a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> DeclHead a -> b
foldl :: forall b a. (b -> a -> b) -> b -> DeclHead a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> DeclHead a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> DeclHead a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> DeclHead a -> a
foldr1 :: forall a. (a -> a -> a) -> DeclHead a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> DeclHead a -> a
foldl1 :: forall a. (a -> a -> a) -> DeclHead a -> a
$ctoList :: forall a. DeclHead a -> [a]
toList :: forall a. DeclHead a -> [a]
$cnull :: forall a. DeclHead a -> Bool
null :: forall a. DeclHead a -> Bool
$clength :: forall a. DeclHead a -> Int
length :: forall a. DeclHead a -> Int
$celem :: forall a. Eq a => a -> DeclHead a -> Bool
elem :: forall a. Eq a => a -> DeclHead a -> Bool
$cmaximum :: forall a. Ord a => DeclHead a -> a
maximum :: forall a. Ord a => DeclHead a -> a
$cminimum :: forall a. Ord a => DeclHead a -> a
minimum :: forall a. Ord a => DeclHead a -> a
$csum :: forall a. Num a => DeclHead a -> a
sum :: forall a. Num a => DeclHead a -> a
$cproduct :: forall a. Num a => DeclHead a -> a
product :: forall a. Num a => DeclHead a -> a
Foldable,Functor DeclHead
Foldable DeclHead
(Functor DeclHead, Foldable DeclHead) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> DeclHead a -> f (DeclHead b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    DeclHead (f a) -> f (DeclHead a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> DeclHead a -> m (DeclHead b))
-> (forall (m :: * -> *) a.
    Monad m =>
    DeclHead (m a) -> m (DeclHead a))
-> Traversable DeclHead
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a. Monad m => DeclHead (m a) -> m (DeclHead a)
forall (f :: * -> *) a.
Applicative f =>
DeclHead (f a) -> f (DeclHead a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> DeclHead a -> m (DeclHead b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> DeclHead a -> f (DeclHead b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> DeclHead a -> f (DeclHead b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> DeclHead a -> f (DeclHead b)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
DeclHead (f a) -> f (DeclHead a)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
DeclHead (f a) -> f (DeclHead a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> DeclHead a -> m (DeclHead b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> DeclHead a -> m (DeclHead b)
$csequence :: forall (m :: * -> *) a. Monad m => DeclHead (m a) -> m (DeclHead a)
sequence :: forall (m :: * -> *) a. Monad m => DeclHead (m a) -> m (DeclHead a)
Traversable,(forall a b. (a -> b) -> DeclHead a -> DeclHead b)
-> (forall a b. a -> DeclHead b -> DeclHead a) -> Functor DeclHead
forall a b. a -> DeclHead b -> DeclHead a
forall a b. (a -> b) -> DeclHead a -> DeclHead b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> DeclHead a -> DeclHead b
fmap :: forall a b. (a -> b) -> DeclHead a -> DeclHead b
$c<$ :: forall a b. a -> DeclHead b -> DeclHead a
<$ :: forall a b. a -> DeclHead b -> DeclHead a
Functor,(forall x. DeclHead l -> Rep (DeclHead l) x)
-> (forall x. Rep (DeclHead l) x -> DeclHead l)
-> Generic (DeclHead l)
forall x. Rep (DeclHead l) x -> DeclHead l
forall x. DeclHead l -> Rep (DeclHead l) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall l x. Rep (DeclHead l) x -> DeclHead l
forall l x. DeclHead l -> Rep (DeclHead l) x
$cfrom :: forall l x. DeclHead l -> Rep (DeclHead l) x
from :: forall x. DeclHead l -> Rep (DeclHead l) x
$cto :: forall l x. Rep (DeclHead l) x -> DeclHead l
to :: forall x. Rep (DeclHead l) x -> DeclHead l
Generic)

-- | The instance declaration rule, which is, roughly, the part of the instance declaration before the @where@ keyword.
--
-- Example: @instance Ord a => Ord (Maybe a)@ is represented as
--
-- >IRule
-- >   ()
-- >   Nothing
-- >   (Just
-- >      (CxSingle
-- >         ()
-- >         (ClassA
-- >            () (UnQual () (Ident () "Ord")) [ TyVar () (Ident () "a") ])))
-- >   (IHApp
-- >      ()
-- >      (IHCon () (UnQual () (Ident () "Ord")))
-- >      (TyParen
-- >         ()
-- >         (TyApp
-- >            ()
-- >            (TyCon () (UnQual () (Ident () "Maybe")))
-- >            (TyVar () (Ident () "a")))))
--
-- An optional explicit forall after @instance@ is supported:
-- @instance forall a . Ord a => Ord (Maybe a) where@ becomes
--
-- >IRule
-- >   ()
-- >   (Just [ UnkindedVar () (Ident () "a") ])
-- >   ...
data InstRule l
    = IRule l (Maybe [TyVarBind l]) (Maybe (Context l)) (InstHead l)
    | IParen l (InstRule l)
  deriving (InstRule l -> InstRule l -> Bool
(InstRule l -> InstRule l -> Bool)
-> (InstRule l -> InstRule l -> Bool) -> Eq (InstRule l)
forall l. Eq l => InstRule l -> InstRule l -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall l. Eq l => InstRule l -> InstRule l -> Bool
== :: InstRule l -> InstRule l -> Bool
$c/= :: forall l. Eq l => InstRule l -> InstRule l -> Bool
/= :: InstRule l -> InstRule l -> Bool
Eq,Eq (InstRule l)
Eq (InstRule l) =>
(InstRule l -> InstRule l -> Ordering)
-> (InstRule l -> InstRule l -> Bool)
-> (InstRule l -> InstRule l -> Bool)
-> (InstRule l -> InstRule l -> Bool)
-> (InstRule l -> InstRule l -> Bool)
-> (InstRule l -> InstRule l -> InstRule l)
-> (InstRule l -> InstRule l -> InstRule l)
-> Ord (InstRule l)
InstRule l -> InstRule l -> Bool
InstRule l -> InstRule l -> Ordering
InstRule l -> InstRule l -> InstRule l
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall l. Ord l => Eq (InstRule l)
forall l. Ord l => InstRule l -> InstRule l -> Bool
forall l. Ord l => InstRule l -> InstRule l -> Ordering
forall l. Ord l => InstRule l -> InstRule l -> InstRule l
$ccompare :: forall l. Ord l => InstRule l -> InstRule l -> Ordering
compare :: InstRule l -> InstRule l -> Ordering
$c< :: forall l. Ord l => InstRule l -> InstRule l -> Bool
< :: InstRule l -> InstRule l -> Bool
$c<= :: forall l. Ord l => InstRule l -> InstRule l -> Bool
<= :: InstRule l -> InstRule l -> Bool
$c> :: forall l. Ord l => InstRule l -> InstRule l -> Bool
> :: InstRule l -> InstRule l -> Bool
$c>= :: forall l. Ord l => InstRule l -> InstRule l -> Bool
>= :: InstRule l -> InstRule l -> Bool
$cmax :: forall l. Ord l => InstRule l -> InstRule l -> InstRule l
max :: InstRule l -> InstRule l -> InstRule l
$cmin :: forall l. Ord l => InstRule l -> InstRule l -> InstRule l
min :: InstRule l -> InstRule l -> InstRule l
Ord,Int -> InstRule l -> ShowS
[InstRule l] -> ShowS
InstRule l -> String
(Int -> InstRule l -> ShowS)
-> (InstRule l -> String)
-> ([InstRule l] -> ShowS)
-> Show (InstRule l)
forall l. Show l => Int -> InstRule l -> ShowS
forall l. Show l => [InstRule l] -> ShowS
forall l. Show l => InstRule l -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall l. Show l => Int -> InstRule l -> ShowS
showsPrec :: Int -> InstRule l -> ShowS
$cshow :: forall l. Show l => InstRule l -> String
show :: InstRule l -> String
$cshowList :: forall l. Show l => [InstRule l] -> ShowS
showList :: [InstRule l] -> ShowS
Show,Typeable,Typeable (InstRule l)
Typeable (InstRule l) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> InstRule l -> c (InstRule l))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (InstRule l))
-> (InstRule l -> Constr)
-> (InstRule l -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (InstRule l)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (InstRule l)))
-> ((forall b. Data b => b -> b) -> InstRule l -> InstRule l)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> InstRule l -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> InstRule l -> r)
-> (forall u. (forall d. Data d => d -> u) -> InstRule l -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> InstRule l -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> InstRule l -> m (InstRule l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> InstRule l -> m (InstRule l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> InstRule l -> m (InstRule l))
-> Data (InstRule l)
InstRule l -> Constr
InstRule l -> DataType
(forall b. Data b => b -> b) -> InstRule l -> InstRule l
forall l. Data l => Typeable (InstRule l)
forall l. Data l => InstRule l -> Constr
forall l. Data l => InstRule l -> DataType
forall l.
Data l =>
(forall b. Data b => b -> b) -> InstRule l -> InstRule l
forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> InstRule l -> u
forall l u.
Data l =>
(forall d. Data d => d -> u) -> InstRule l -> [u]
forall l r r'.
Data l =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> InstRule l -> r
forall l r r'.
Data l =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> InstRule l -> r
forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d) -> InstRule l -> m (InstRule l)
forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> InstRule l -> m (InstRule l)
forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (InstRule l)
forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> InstRule l -> c (InstRule l)
forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (InstRule l))
forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (InstRule l))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> InstRule l -> u
forall u. (forall d. Data d => d -> u) -> InstRule l -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> InstRule l -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> InstRule l -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> InstRule l -> m (InstRule l)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> InstRule l -> m (InstRule l)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (InstRule l)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> InstRule l -> c (InstRule l)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (InstRule l))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (InstRule l))
$cgfoldl :: forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> InstRule l -> c (InstRule l)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> InstRule l -> c (InstRule l)
$cgunfold :: forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (InstRule l)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (InstRule l)
$ctoConstr :: forall l. Data l => InstRule l -> Constr
toConstr :: InstRule l -> Constr
$cdataTypeOf :: forall l. Data l => InstRule l -> DataType
dataTypeOf :: InstRule l -> DataType
$cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (InstRule l))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (InstRule l))
$cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (InstRule l))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (InstRule l))
$cgmapT :: forall l.
Data l =>
(forall b. Data b => b -> b) -> InstRule l -> InstRule l
gmapT :: (forall b. Data b => b -> b) -> InstRule l -> InstRule l
$cgmapQl :: forall l r r'.
Data l =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> InstRule l -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> InstRule l -> r
$cgmapQr :: forall l r r'.
Data l =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> InstRule l -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> InstRule l -> r
$cgmapQ :: forall l u.
Data l =>
(forall d. Data d => d -> u) -> InstRule l -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> InstRule l -> [u]
$cgmapQi :: forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> InstRule l -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> InstRule l -> u
$cgmapM :: forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d) -> InstRule l -> m (InstRule l)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> InstRule l -> m (InstRule l)
$cgmapMp :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> InstRule l -> m (InstRule l)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> InstRule l -> m (InstRule l)
$cgmapMo :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> InstRule l -> m (InstRule l)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> InstRule l -> m (InstRule l)
Data,(forall m. Monoid m => InstRule m -> m)
-> (forall m a. Monoid m => (a -> m) -> InstRule a -> m)
-> (forall m a. Monoid m => (a -> m) -> InstRule a -> m)
-> (forall a b. (a -> b -> b) -> b -> InstRule a -> b)
-> (forall a b. (a -> b -> b) -> b -> InstRule a -> b)
-> (forall b a. (b -> a -> b) -> b -> InstRule a -> b)
-> (forall b a. (b -> a -> b) -> b -> InstRule a -> b)
-> (forall a. (a -> a -> a) -> InstRule a -> a)
-> (forall a. (a -> a -> a) -> InstRule a -> a)
-> (forall a. InstRule a -> [a])
-> (forall a. InstRule a -> Bool)
-> (forall a. InstRule a -> Int)
-> (forall a. Eq a => a -> InstRule a -> Bool)
-> (forall a. Ord a => InstRule a -> a)
-> (forall a. Ord a => InstRule a -> a)
-> (forall a. Num a => InstRule a -> a)
-> (forall a. Num a => InstRule a -> a)
-> Foldable InstRule
forall a. Eq a => a -> InstRule a -> Bool
forall a. Num a => InstRule a -> a
forall a. Ord a => InstRule a -> a
forall m. Monoid m => InstRule m -> m
forall a. InstRule a -> Bool
forall a. InstRule a -> Int
forall a. InstRule a -> [a]
forall a. (a -> a -> a) -> InstRule a -> a
forall m a. Monoid m => (a -> m) -> InstRule a -> m
forall b a. (b -> a -> b) -> b -> InstRule a -> b
forall a b. (a -> b -> b) -> b -> InstRule a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall m. Monoid m => InstRule m -> m
fold :: forall m. Monoid m => InstRule m -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> InstRule a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> InstRule a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> InstRule a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> InstRule a -> m
$cfoldr :: forall a b. (a -> b -> b) -> b -> InstRule a -> b
foldr :: forall a b. (a -> b -> b) -> b -> InstRule a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> InstRule a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> InstRule a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> InstRule a -> b
foldl :: forall b a. (b -> a -> b) -> b -> InstRule a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> InstRule a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> InstRule a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> InstRule a -> a
foldr1 :: forall a. (a -> a -> a) -> InstRule a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> InstRule a -> a
foldl1 :: forall a. (a -> a -> a) -> InstRule a -> a
$ctoList :: forall a. InstRule a -> [a]
toList :: forall a. InstRule a -> [a]
$cnull :: forall a. InstRule a -> Bool
null :: forall a. InstRule a -> Bool
$clength :: forall a. InstRule a -> Int
length :: forall a. InstRule a -> Int
$celem :: forall a. Eq a => a -> InstRule a -> Bool
elem :: forall a. Eq a => a -> InstRule a -> Bool
$cmaximum :: forall a. Ord a => InstRule a -> a
maximum :: forall a. Ord a => InstRule a -> a
$cminimum :: forall a. Ord a => InstRule a -> a
minimum :: forall a. Ord a => InstRule a -> a
$csum :: forall a. Num a => InstRule a -> a
sum :: forall a. Num a => InstRule a -> a
$cproduct :: forall a. Num a => InstRule a -> a
product :: forall a. Num a => InstRule a -> a
Foldable,Functor InstRule
Foldable InstRule
(Functor InstRule, Foldable InstRule) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> InstRule a -> f (InstRule b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    InstRule (f a) -> f (InstRule a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> InstRule a -> m (InstRule b))
-> (forall (m :: * -> *) a.
    Monad m =>
    InstRule (m a) -> m (InstRule a))
-> Traversable InstRule
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a. Monad m => InstRule (m a) -> m (InstRule a)
forall (f :: * -> *) a.
Applicative f =>
InstRule (f a) -> f (InstRule a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> InstRule a -> m (InstRule b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> InstRule a -> f (InstRule b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> InstRule a -> f (InstRule b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> InstRule a -> f (InstRule b)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
InstRule (f a) -> f (InstRule a)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
InstRule (f a) -> f (InstRule a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> InstRule a -> m (InstRule b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> InstRule a -> m (InstRule b)
$csequence :: forall (m :: * -> *) a. Monad m => InstRule (m a) -> m (InstRule a)
sequence :: forall (m :: * -> *) a. Monad m => InstRule (m a) -> m (InstRule a)
Traversable,(forall a b. (a -> b) -> InstRule a -> InstRule b)
-> (forall a b. a -> InstRule b -> InstRule a) -> Functor InstRule
forall a b. a -> InstRule b -> InstRule a
forall a b. (a -> b) -> InstRule a -> InstRule b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> InstRule a -> InstRule b
fmap :: forall a b. (a -> b) -> InstRule a -> InstRule b
$c<$ :: forall a b. a -> InstRule b -> InstRule a
<$ :: forall a b. a -> InstRule b -> InstRule a
Functor,(forall x. InstRule l -> Rep (InstRule l) x)
-> (forall x. Rep (InstRule l) x -> InstRule l)
-> Generic (InstRule l)
forall x. Rep (InstRule l) x -> InstRule l
forall x. InstRule l -> Rep (InstRule l) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall l x. Rep (InstRule l) x -> InstRule l
forall l x. InstRule l -> Rep (InstRule l) x
$cfrom :: forall l x. InstRule l -> Rep (InstRule l) x
from :: forall x. InstRule l -> Rep (InstRule l) x
$cto :: forall l x. Rep (InstRule l) x -> InstRule l
to :: forall x. Rep (InstRule l) x -> InstRule l
Generic)

-- See bugs #7 and #31 for more details and use cases for the rationale
-- of the split. DeclOrInstHead should be used by DeclHead as the name implies.

-- | The instance head. The split between rule/head allow us to represent
-- @instance (Bounded a => Bounded [a]) where@ faithfully.
--
-- The structure of 'InstHead' follows one of 'DeclHead'.
--
-- For example, @instance C (Maybe a) Int where@ is represented as
--
-- >IHApp
-- >   ()
-- >   (IHApp
-- >      ()
-- >      (IHCon () (UnQual () (Ident () "C")))
-- >      (TyParen
-- >         ()
-- >         (TyApp
-- >            ()
-- >            (TyCon () (UnQual () (Ident () "Maybe")))
-- >            (TyVar () (Ident () "a")))))
-- >   (TyCon () (UnQual () (Ident () "Int")))))
data InstHead l
    = IHCon l (QName l) -- ^ type or class name
    | IHInfix l (Type l) (QName l) -- ^ infix application of the type/class name to the left operand
    | IHParen l (InstHead l) -- ^ parenthesized instance head
    | IHApp   l (InstHead l) (Type l) -- ^ application to one more type
  deriving (InstHead l -> InstHead l -> Bool
(InstHead l -> InstHead l -> Bool)
-> (InstHead l -> InstHead l -> Bool) -> Eq (InstHead l)
forall l. Eq l => InstHead l -> InstHead l -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall l. Eq l => InstHead l -> InstHead l -> Bool
== :: InstHead l -> InstHead l -> Bool
$c/= :: forall l. Eq l => InstHead l -> InstHead l -> Bool
/= :: InstHead l -> InstHead l -> Bool
Eq,Eq (InstHead l)
Eq (InstHead l) =>
(InstHead l -> InstHead l -> Ordering)
-> (InstHead l -> InstHead l -> Bool)
-> (InstHead l -> InstHead l -> Bool)
-> (InstHead l -> InstHead l -> Bool)
-> (InstHead l -> InstHead l -> Bool)
-> (InstHead l -> InstHead l -> InstHead l)
-> (InstHead l -> InstHead l -> InstHead l)
-> Ord (InstHead l)
InstHead l -> InstHead l -> Bool
InstHead l -> InstHead l -> Ordering
InstHead l -> InstHead l -> InstHead l
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall l. Ord l => Eq (InstHead l)
forall l. Ord l => InstHead l -> InstHead l -> Bool
forall l. Ord l => InstHead l -> InstHead l -> Ordering
forall l. Ord l => InstHead l -> InstHead l -> InstHead l
$ccompare :: forall l. Ord l => InstHead l -> InstHead l -> Ordering
compare :: InstHead l -> InstHead l -> Ordering
$c< :: forall l. Ord l => InstHead l -> InstHead l -> Bool
< :: InstHead l -> InstHead l -> Bool
$c<= :: forall l. Ord l => InstHead l -> InstHead l -> Bool
<= :: InstHead l -> InstHead l -> Bool
$c> :: forall l. Ord l => InstHead l -> InstHead l -> Bool
> :: InstHead l -> InstHead l -> Bool
$c>= :: forall l. Ord l => InstHead l -> InstHead l -> Bool
>= :: InstHead l -> InstHead l -> Bool
$cmax :: forall l. Ord l => InstHead l -> InstHead l -> InstHead l
max :: InstHead l -> InstHead l -> InstHead l
$cmin :: forall l. Ord l => InstHead l -> InstHead l -> InstHead l
min :: InstHead l -> InstHead l -> InstHead l
Ord,Int -> InstHead l -> ShowS
[InstHead l] -> ShowS
InstHead l -> String
(Int -> InstHead l -> ShowS)
-> (InstHead l -> String)
-> ([InstHead l] -> ShowS)
-> Show (InstHead l)
forall l. Show l => Int -> InstHead l -> ShowS
forall l. Show l => [InstHead l] -> ShowS
forall l. Show l => InstHead l -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall l. Show l => Int -> InstHead l -> ShowS
showsPrec :: Int -> InstHead l -> ShowS
$cshow :: forall l. Show l => InstHead l -> String
show :: InstHead l -> String
$cshowList :: forall l. Show l => [InstHead l] -> ShowS
showList :: [InstHead l] -> ShowS
Show,Typeable,Typeable (InstHead l)
Typeable (InstHead l) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> InstHead l -> c (InstHead l))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (InstHead l))
-> (InstHead l -> Constr)
-> (InstHead l -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (InstHead l)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (InstHead l)))
-> ((forall b. Data b => b -> b) -> InstHead l -> InstHead l)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> InstHead l -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> InstHead l -> r)
-> (forall u. (forall d. Data d => d -> u) -> InstHead l -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> InstHead l -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> InstHead l -> m (InstHead l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> InstHead l -> m (InstHead l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> InstHead l -> m (InstHead l))
-> Data (InstHead l)
InstHead l -> Constr
InstHead l -> DataType
(forall b. Data b => b -> b) -> InstHead l -> InstHead l
forall l. Data l => Typeable (InstHead l)
forall l. Data l => InstHead l -> Constr
forall l. Data l => InstHead l -> DataType
forall l.
Data l =>
(forall b. Data b => b -> b) -> InstHead l -> InstHead l
forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> InstHead l -> u
forall l u.
Data l =>
(forall d. Data d => d -> u) -> InstHead l -> [u]
forall l r r'.
Data l =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> InstHead l -> r
forall l r r'.
Data l =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> InstHead l -> r
forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d) -> InstHead l -> m (InstHead l)
forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> InstHead l -> m (InstHead l)
forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (InstHead l)
forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> InstHead l -> c (InstHead l)
forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (InstHead l))
forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (InstHead l))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> InstHead l -> u
forall u. (forall d. Data d => d -> u) -> InstHead l -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> InstHead l -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> InstHead l -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> InstHead l -> m (InstHead l)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> InstHead l -> m (InstHead l)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (InstHead l)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> InstHead l -> c (InstHead l)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (InstHead l))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (InstHead l))
$cgfoldl :: forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> InstHead l -> c (InstHead l)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> InstHead l -> c (InstHead l)
$cgunfold :: forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (InstHead l)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (InstHead l)
$ctoConstr :: forall l. Data l => InstHead l -> Constr
toConstr :: InstHead l -> Constr
$cdataTypeOf :: forall l. Data l => InstHead l -> DataType
dataTypeOf :: InstHead l -> DataType
$cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (InstHead l))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (InstHead l))
$cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (InstHead l))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (InstHead l))
$cgmapT :: forall l.
Data l =>
(forall b. Data b => b -> b) -> InstHead l -> InstHead l
gmapT :: (forall b. Data b => b -> b) -> InstHead l -> InstHead l
$cgmapQl :: forall l r r'.
Data l =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> InstHead l -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> InstHead l -> r
$cgmapQr :: forall l r r'.
Data l =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> InstHead l -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> InstHead l -> r
$cgmapQ :: forall l u.
Data l =>
(forall d. Data d => d -> u) -> InstHead l -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> InstHead l -> [u]
$cgmapQi :: forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> InstHead l -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> InstHead l -> u
$cgmapM :: forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d) -> InstHead l -> m (InstHead l)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> InstHead l -> m (InstHead l)
$cgmapMp :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> InstHead l -> m (InstHead l)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> InstHead l -> m (InstHead l)
$cgmapMo :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> InstHead l -> m (InstHead l)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> InstHead l -> m (InstHead l)
Data,(forall m. Monoid m => InstHead m -> m)
-> (forall m a. Monoid m => (a -> m) -> InstHead a -> m)
-> (forall m a. Monoid m => (a -> m) -> InstHead a -> m)
-> (forall a b. (a -> b -> b) -> b -> InstHead a -> b)
-> (forall a b. (a -> b -> b) -> b -> InstHead a -> b)
-> (forall b a. (b -> a -> b) -> b -> InstHead a -> b)
-> (forall b a. (b -> a -> b) -> b -> InstHead a -> b)
-> (forall a. (a -> a -> a) -> InstHead a -> a)
-> (forall a. (a -> a -> a) -> InstHead a -> a)
-> (forall a. InstHead a -> [a])
-> (forall a. InstHead a -> Bool)
-> (forall a. InstHead a -> Int)
-> (forall a. Eq a => a -> InstHead a -> Bool)
-> (forall a. Ord a => InstHead a -> a)
-> (forall a. Ord a => InstHead a -> a)
-> (forall a. Num a => InstHead a -> a)
-> (forall a. Num a => InstHead a -> a)
-> Foldable InstHead
forall a. Eq a => a -> InstHead a -> Bool
forall a. Num a => InstHead a -> a
forall a. Ord a => InstHead a -> a
forall m. Monoid m => InstHead m -> m
forall a. InstHead a -> Bool
forall a. InstHead a -> Int
forall a. InstHead a -> [a]
forall a. (a -> a -> a) -> InstHead a -> a
forall m a. Monoid m => (a -> m) -> InstHead a -> m
forall b a. (b -> a -> b) -> b -> InstHead a -> b
forall a b. (a -> b -> b) -> b -> InstHead a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall m. Monoid m => InstHead m -> m
fold :: forall m. Monoid m => InstHead m -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> InstHead a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> InstHead a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> InstHead a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> InstHead a -> m
$cfoldr :: forall a b. (a -> b -> b) -> b -> InstHead a -> b
foldr :: forall a b. (a -> b -> b) -> b -> InstHead a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> InstHead a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> InstHead a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> InstHead a -> b
foldl :: forall b a. (b -> a -> b) -> b -> InstHead a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> InstHead a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> InstHead a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> InstHead a -> a
foldr1 :: forall a. (a -> a -> a) -> InstHead a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> InstHead a -> a
foldl1 :: forall a. (a -> a -> a) -> InstHead a -> a
$ctoList :: forall a. InstHead a -> [a]
toList :: forall a. InstHead a -> [a]
$cnull :: forall a. InstHead a -> Bool
null :: forall a. InstHead a -> Bool
$clength :: forall a. InstHead a -> Int
length :: forall a. InstHead a -> Int
$celem :: forall a. Eq a => a -> InstHead a -> Bool
elem :: forall a. Eq a => a -> InstHead a -> Bool
$cmaximum :: forall a. Ord a => InstHead a -> a
maximum :: forall a. Ord a => InstHead a -> a
$cminimum :: forall a. Ord a => InstHead a -> a
minimum :: forall a. Ord a => InstHead a -> a
$csum :: forall a. Num a => InstHead a -> a
sum :: forall a. Num a => InstHead a -> a
$cproduct :: forall a. Num a => InstHead a -> a
product :: forall a. Num a => InstHead a -> a
Foldable,Functor InstHead
Foldable InstHead
(Functor InstHead, Foldable InstHead) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> InstHead a -> f (InstHead b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    InstHead (f a) -> f (InstHead a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> InstHead a -> m (InstHead b))
-> (forall (m :: * -> *) a.
    Monad m =>
    InstHead (m a) -> m (InstHead a))
-> Traversable InstHead
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a. Monad m => InstHead (m a) -> m (InstHead a)
forall (f :: * -> *) a.
Applicative f =>
InstHead (f a) -> f (InstHead a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> InstHead a -> m (InstHead b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> InstHead a -> f (InstHead b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> InstHead a -> f (InstHead b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> InstHead a -> f (InstHead b)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
InstHead (f a) -> f (InstHead a)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
InstHead (f a) -> f (InstHead a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> InstHead a -> m (InstHead b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> InstHead a -> m (InstHead b)
$csequence :: forall (m :: * -> *) a. Monad m => InstHead (m a) -> m (InstHead a)
sequence :: forall (m :: * -> *) a. Monad m => InstHead (m a) -> m (InstHead a)
Traversable,(forall a b. (a -> b) -> InstHead a -> InstHead b)
-> (forall a b. a -> InstHead b -> InstHead a) -> Functor InstHead
forall a b. a -> InstHead b -> InstHead a
forall a b. (a -> b) -> InstHead a -> InstHead b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> InstHead a -> InstHead b
fmap :: forall a b. (a -> b) -> InstHead a -> InstHead b
$c<$ :: forall a b. a -> InstHead b -> InstHead a
<$ :: forall a b. a -> InstHead b -> InstHead a
Functor,(forall x. InstHead l -> Rep (InstHead l) x)
-> (forall x. Rep (InstHead l) x -> InstHead l)
-> Generic (InstHead l)
forall x. Rep (InstHead l) x -> InstHead l
forall x. InstHead l -> Rep (InstHead l) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall l x. Rep (InstHead l) x -> InstHead l
forall l x. InstHead l -> Rep (InstHead l) x
$cfrom :: forall l x. InstHead l -> Rep (InstHead l) x
from :: forall x. InstHead l -> Rep (InstHead l) x
$cto :: forall l x. Rep (InstHead l) x -> InstHead l
to :: forall x. Rep (InstHead l) x -> InstHead l
Generic)

-- | A deriving clause following a data type declaration.
data Deriving l = Deriving l (Maybe (DerivStrategy l)) [InstRule l]
  deriving (Deriving l -> Deriving l -> Bool
(Deriving l -> Deriving l -> Bool)
-> (Deriving l -> Deriving l -> Bool) -> Eq (Deriving l)
forall l. Eq l => Deriving l -> Deriving l -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall l. Eq l => Deriving l -> Deriving l -> Bool
== :: Deriving l -> Deriving l -> Bool
$c/= :: forall l. Eq l => Deriving l -> Deriving l -> Bool
/= :: Deriving l -> Deriving l -> Bool
Eq,Eq (Deriving l)
Eq (Deriving l) =>
(Deriving l -> Deriving l -> Ordering)
-> (Deriving l -> Deriving l -> Bool)
-> (Deriving l -> Deriving l -> Bool)
-> (Deriving l -> Deriving l -> Bool)
-> (Deriving l -> Deriving l -> Bool)
-> (Deriving l -> Deriving l -> Deriving l)
-> (Deriving l -> Deriving l -> Deriving l)
-> Ord (Deriving l)
Deriving l -> Deriving l -> Bool
Deriving l -> Deriving l -> Ordering
Deriving l -> Deriving l -> Deriving l
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall l. Ord l => Eq (Deriving l)
forall l. Ord l => Deriving l -> Deriving l -> Bool
forall l. Ord l => Deriving l -> Deriving l -> Ordering
forall l. Ord l => Deriving l -> Deriving l -> Deriving l
$ccompare :: forall l. Ord l => Deriving l -> Deriving l -> Ordering
compare :: Deriving l -> Deriving l -> Ordering
$c< :: forall l. Ord l => Deriving l -> Deriving l -> Bool
< :: Deriving l -> Deriving l -> Bool
$c<= :: forall l. Ord l => Deriving l -> Deriving l -> Bool
<= :: Deriving l -> Deriving l -> Bool
$c> :: forall l. Ord l => Deriving l -> Deriving l -> Bool
> :: Deriving l -> Deriving l -> Bool
$c>= :: forall l. Ord l => Deriving l -> Deriving l -> Bool
>= :: Deriving l -> Deriving l -> Bool
$cmax :: forall l. Ord l => Deriving l -> Deriving l -> Deriving l
max :: Deriving l -> Deriving l -> Deriving l
$cmin :: forall l. Ord l => Deriving l -> Deriving l -> Deriving l
min :: Deriving l -> Deriving l -> Deriving l
Ord,Int -> Deriving l -> ShowS
[Deriving l] -> ShowS
Deriving l -> String
(Int -> Deriving l -> ShowS)
-> (Deriving l -> String)
-> ([Deriving l] -> ShowS)
-> Show (Deriving l)
forall l. Show l => Int -> Deriving l -> ShowS
forall l. Show l => [Deriving l] -> ShowS
forall l. Show l => Deriving l -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall l. Show l => Int -> Deriving l -> ShowS
showsPrec :: Int -> Deriving l -> ShowS
$cshow :: forall l. Show l => Deriving l -> String
show :: Deriving l -> String
$cshowList :: forall l. Show l => [Deriving l] -> ShowS
showList :: [Deriving l] -> ShowS
Show,Typeable,Typeable (Deriving l)
Typeable (Deriving l) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Deriving l -> c (Deriving l))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Deriving l))
-> (Deriving l -> Constr)
-> (Deriving l -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Deriving l)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Deriving l)))
-> ((forall b. Data b => b -> b) -> Deriving l -> Deriving l)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Deriving l -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Deriving l -> r)
-> (forall u. (forall d. Data d => d -> u) -> Deriving l -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Deriving l -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Deriving l -> m (Deriving l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Deriving l -> m (Deriving l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Deriving l -> m (Deriving l))
-> Data (Deriving l)
Deriving l -> Constr
Deriving l -> DataType
(forall b. Data b => b -> b) -> Deriving l -> Deriving l
forall l. Data l => Typeable (Deriving l)
forall l. Data l => Deriving l -> Constr
forall l. Data l => Deriving l -> DataType
forall l.
Data l =>
(forall b. Data b => b -> b) -> Deriving l -> Deriving l
forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> Deriving l -> u
forall l u.
Data l =>
(forall d. Data d => d -> u) -> Deriving l -> [u]
forall l r r'.
Data l =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Deriving l -> r
forall l r r'.
Data l =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Deriving l -> r
forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d) -> Deriving l -> m (Deriving l)
forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Deriving l -> m (Deriving l)
forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Deriving l)
forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Deriving l -> c (Deriving l)
forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Deriving l))
forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Deriving l))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Deriving l -> u
forall u. (forall d. Data d => d -> u) -> Deriving l -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Deriving l -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Deriving l -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Deriving l -> m (Deriving l)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Deriving l -> m (Deriving l)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Deriving l)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Deriving l -> c (Deriving l)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Deriving l))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Deriving l))
$cgfoldl :: forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Deriving l -> c (Deriving l)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Deriving l -> c (Deriving l)
$cgunfold :: forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Deriving l)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Deriving l)
$ctoConstr :: forall l. Data l => Deriving l -> Constr
toConstr :: Deriving l -> Constr
$cdataTypeOf :: forall l. Data l => Deriving l -> DataType
dataTypeOf :: Deriving l -> DataType
$cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Deriving l))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Deriving l))
$cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Deriving l))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Deriving l))
$cgmapT :: forall l.
Data l =>
(forall b. Data b => b -> b) -> Deriving l -> Deriving l
gmapT :: (forall b. Data b => b -> b) -> Deriving l -> Deriving l
$cgmapQl :: forall l r r'.
Data l =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Deriving l -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Deriving l -> r
$cgmapQr :: forall l r r'.
Data l =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Deriving l -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Deriving l -> r
$cgmapQ :: forall l u.
Data l =>
(forall d. Data d => d -> u) -> Deriving l -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Deriving l -> [u]
$cgmapQi :: forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> Deriving l -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Deriving l -> u
$cgmapM :: forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d) -> Deriving l -> m (Deriving l)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Deriving l -> m (Deriving l)
$cgmapMp :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Deriving l -> m (Deriving l)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Deriving l -> m (Deriving l)
$cgmapMo :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Deriving l -> m (Deriving l)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Deriving l -> m (Deriving l)
Data,(forall m. Monoid m => Deriving m -> m)
-> (forall m a. Monoid m => (a -> m) -> Deriving a -> m)
-> (forall m a. Monoid m => (a -> m) -> Deriving a -> m)
-> (forall a b. (a -> b -> b) -> b -> Deriving a -> b)
-> (forall a b. (a -> b -> b) -> b -> Deriving a -> b)
-> (forall b a. (b -> a -> b) -> b -> Deriving a -> b)
-> (forall b a. (b -> a -> b) -> b -> Deriving a -> b)
-> (forall a. (a -> a -> a) -> Deriving a -> a)
-> (forall a. (a -> a -> a) -> Deriving a -> a)
-> (forall a. Deriving a -> [a])
-> (forall a. Deriving a -> Bool)
-> (forall a. Deriving a -> Int)
-> (forall a. Eq a => a -> Deriving a -> Bool)
-> (forall a. Ord a => Deriving a -> a)
-> (forall a. Ord a => Deriving a -> a)
-> (forall a. Num a => Deriving a -> a)
-> (forall a. Num a => Deriving a -> a)
-> Foldable Deriving
forall a. Eq a => a -> Deriving a -> Bool
forall a. Num a => Deriving a -> a
forall a. Ord a => Deriving a -> a
forall m. Monoid m => Deriving m -> m
forall a. Deriving a -> Bool
forall a. Deriving a -> Int
forall a. Deriving a -> [a]
forall a. (a -> a -> a) -> Deriving a -> a
forall m a. Monoid m => (a -> m) -> Deriving a -> m
forall b a. (b -> a -> b) -> b -> Deriving a -> b
forall a b. (a -> b -> b) -> b -> Deriving a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall m. Monoid m => Deriving m -> m
fold :: forall m. Monoid m => Deriving m -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> Deriving a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> Deriving a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> Deriving a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> Deriving a -> m
$cfoldr :: forall a b. (a -> b -> b) -> b -> Deriving a -> b
foldr :: forall a b. (a -> b -> b) -> b -> Deriving a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> Deriving a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> Deriving a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> Deriving a -> b
foldl :: forall b a. (b -> a -> b) -> b -> Deriving a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> Deriving a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> Deriving a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> Deriving a -> a
foldr1 :: forall a. (a -> a -> a) -> Deriving a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> Deriving a -> a
foldl1 :: forall a. (a -> a -> a) -> Deriving a -> a
$ctoList :: forall a. Deriving a -> [a]
toList :: forall a. Deriving a -> [a]
$cnull :: forall a. Deriving a -> Bool
null :: forall a. Deriving a -> Bool
$clength :: forall a. Deriving a -> Int
length :: forall a. Deriving a -> Int
$celem :: forall a. Eq a => a -> Deriving a -> Bool
elem :: forall a. Eq a => a -> Deriving a -> Bool
$cmaximum :: forall a. Ord a => Deriving a -> a
maximum :: forall a. Ord a => Deriving a -> a
$cminimum :: forall a. Ord a => Deriving a -> a
minimum :: forall a. Ord a => Deriving a -> a
$csum :: forall a. Num a => Deriving a -> a
sum :: forall a. Num a => Deriving a -> a
$cproduct :: forall a. Num a => Deriving a -> a
product :: forall a. Num a => Deriving a -> a
Foldable,Functor Deriving
Foldable Deriving
(Functor Deriving, Foldable Deriving) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> Deriving a -> f (Deriving b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    Deriving (f a) -> f (Deriving a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Deriving a -> m (Deriving b))
-> (forall (m :: * -> *) a.
    Monad m =>
    Deriving (m a) -> m (Deriving a))
-> Traversable Deriving
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a. Monad m => Deriving (m a) -> m (Deriving a)
forall (f :: * -> *) a.
Applicative f =>
Deriving (f a) -> f (Deriving a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Deriving a -> m (Deriving b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Deriving a -> f (Deriving b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Deriving a -> f (Deriving b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Deriving a -> f (Deriving b)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
Deriving (f a) -> f (Deriving a)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
Deriving (f a) -> f (Deriving a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Deriving a -> m (Deriving b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Deriving a -> m (Deriving b)
$csequence :: forall (m :: * -> *) a. Monad m => Deriving (m a) -> m (Deriving a)
sequence :: forall (m :: * -> *) a. Monad m => Deriving (m a) -> m (Deriving a)
Traversable,(forall a b. (a -> b) -> Deriving a -> Deriving b)
-> (forall a b. a -> Deriving b -> Deriving a) -> Functor Deriving
forall a b. a -> Deriving b -> Deriving a
forall a b. (a -> b) -> Deriving a -> Deriving b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> Deriving a -> Deriving b
fmap :: forall a b. (a -> b) -> Deriving a -> Deriving b
$c<$ :: forall a b. a -> Deriving b -> Deriving a
<$ :: forall a b. a -> Deriving b -> Deriving a
Functor,(forall x. Deriving l -> Rep (Deriving l) x)
-> (forall x. Rep (Deriving l) x -> Deriving l)
-> Generic (Deriving l)
forall x. Rep (Deriving l) x -> Deriving l
forall x. Deriving l -> Rep (Deriving l) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall l x. Rep (Deriving l) x -> Deriving l
forall l x. Deriving l -> Rep (Deriving l) x
$cfrom :: forall l x. Deriving l -> Rep (Deriving l) x
from :: forall x. Deriving l -> Rep (Deriving l) x
$cto :: forall l x. Rep (Deriving l) x -> Deriving l
to :: forall x. Rep (Deriving l) x -> Deriving l
Generic)

-- | Which technique the user explicitly requested when deriving an instance.
data DerivStrategy l
  = DerivStock l        -- ^ GHC's \"standard\" strategy, which is to implement a
                        --   custom instance for the data type. This only works for
                        --   certain types that GHC knows about (e.g., 'Eq', 'Show',
                        --   'Functor' when @-XDeriveFunctor@ is enabled, etc.)
  | DerivAnyclass l     -- ^ @-XDeriveAnyClass@
  | DerivNewtype l      -- ^ @-XGeneralizedNewtypeDeriving@
  | DerivVia l (Type l) -- ^ @-XDerivingVia@
  deriving (DerivStrategy l -> DerivStrategy l -> Bool
(DerivStrategy l -> DerivStrategy l -> Bool)
-> (DerivStrategy l -> DerivStrategy l -> Bool)
-> Eq (DerivStrategy l)
forall l. Eq l => DerivStrategy l -> DerivStrategy l -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall l. Eq l => DerivStrategy l -> DerivStrategy l -> Bool
== :: DerivStrategy l -> DerivStrategy l -> Bool
$c/= :: forall l. Eq l => DerivStrategy l -> DerivStrategy l -> Bool
/= :: DerivStrategy l -> DerivStrategy l -> Bool
Eq,Eq (DerivStrategy l)
Eq (DerivStrategy l) =>
(DerivStrategy l -> DerivStrategy l -> Ordering)
-> (DerivStrategy l -> DerivStrategy l -> Bool)
-> (DerivStrategy l -> DerivStrategy l -> Bool)
-> (DerivStrategy l -> DerivStrategy l -> Bool)
-> (DerivStrategy l -> DerivStrategy l -> Bool)
-> (DerivStrategy l -> DerivStrategy l -> DerivStrategy l)
-> (DerivStrategy l -> DerivStrategy l -> DerivStrategy l)
-> Ord (DerivStrategy l)
DerivStrategy l -> DerivStrategy l -> Bool
DerivStrategy l -> DerivStrategy l -> Ordering
DerivStrategy l -> DerivStrategy l -> DerivStrategy l
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall l. Ord l => Eq (DerivStrategy l)
forall l. Ord l => DerivStrategy l -> DerivStrategy l -> Bool
forall l. Ord l => DerivStrategy l -> DerivStrategy l -> Ordering
forall l.
Ord l =>
DerivStrategy l -> DerivStrategy l -> DerivStrategy l
$ccompare :: forall l. Ord l => DerivStrategy l -> DerivStrategy l -> Ordering
compare :: DerivStrategy l -> DerivStrategy l -> Ordering
$c< :: forall l. Ord l => DerivStrategy l -> DerivStrategy l -> Bool
< :: DerivStrategy l -> DerivStrategy l -> Bool
$c<= :: forall l. Ord l => DerivStrategy l -> DerivStrategy l -> Bool
<= :: DerivStrategy l -> DerivStrategy l -> Bool
$c> :: forall l. Ord l => DerivStrategy l -> DerivStrategy l -> Bool
> :: DerivStrategy l -> DerivStrategy l -> Bool
$c>= :: forall l. Ord l => DerivStrategy l -> DerivStrategy l -> Bool
>= :: DerivStrategy l -> DerivStrategy l -> Bool
$cmax :: forall l.
Ord l =>
DerivStrategy l -> DerivStrategy l -> DerivStrategy l
max :: DerivStrategy l -> DerivStrategy l -> DerivStrategy l
$cmin :: forall l.
Ord l =>
DerivStrategy l -> DerivStrategy l -> DerivStrategy l
min :: DerivStrategy l -> DerivStrategy l -> DerivStrategy l
Ord,Int -> DerivStrategy l -> ShowS
[DerivStrategy l] -> ShowS
DerivStrategy l -> String
(Int -> DerivStrategy l -> ShowS)
-> (DerivStrategy l -> String)
-> ([DerivStrategy l] -> ShowS)
-> Show (DerivStrategy l)
forall l. Show l => Int -> DerivStrategy l -> ShowS
forall l. Show l => [DerivStrategy l] -> ShowS
forall l. Show l => DerivStrategy l -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall l. Show l => Int -> DerivStrategy l -> ShowS
showsPrec :: Int -> DerivStrategy l -> ShowS
$cshow :: forall l. Show l => DerivStrategy l -> String
show :: DerivStrategy l -> String
$cshowList :: forall l. Show l => [DerivStrategy l] -> ShowS
showList :: [DerivStrategy l] -> ShowS
Show,Typeable,Typeable (DerivStrategy l)
Typeable (DerivStrategy l) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> DerivStrategy l -> c (DerivStrategy l))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (DerivStrategy l))
-> (DerivStrategy l -> Constr)
-> (DerivStrategy l -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (DerivStrategy l)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (DerivStrategy l)))
-> ((forall b. Data b => b -> b)
    -> DerivStrategy l -> DerivStrategy l)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DerivStrategy l -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DerivStrategy l -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> DerivStrategy l -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> DerivStrategy l -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> DerivStrategy l -> m (DerivStrategy l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DerivStrategy l -> m (DerivStrategy l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DerivStrategy l -> m (DerivStrategy l))
-> Data (DerivStrategy l)
DerivStrategy l -> Constr
DerivStrategy l -> DataType
(forall b. Data b => b -> b) -> DerivStrategy l -> DerivStrategy l
forall l. Data l => Typeable (DerivStrategy l)
forall l. Data l => DerivStrategy l -> Constr
forall l. Data l => DerivStrategy l -> DataType
forall l.
Data l =>
(forall b. Data b => b -> b) -> DerivStrategy l -> DerivStrategy l
forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> DerivStrategy l -> u
forall l u.
Data l =>
(forall d. Data d => d -> u) -> DerivStrategy l -> [u]
forall l r r'.
Data l =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DerivStrategy l -> r
forall l r r'.
Data l =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DerivStrategy l -> r
forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d)
-> DerivStrategy l -> m (DerivStrategy l)
forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> DerivStrategy l -> m (DerivStrategy l)
forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (DerivStrategy l)
forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DerivStrategy l -> c (DerivStrategy l)
forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (DerivStrategy l))
forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (DerivStrategy l))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> DerivStrategy l -> u
forall u. (forall d. Data d => d -> u) -> DerivStrategy l -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DerivStrategy l -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DerivStrategy l -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DerivStrategy l -> m (DerivStrategy l)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DerivStrategy l -> m (DerivStrategy l)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (DerivStrategy l)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DerivStrategy l -> c (DerivStrategy l)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (DerivStrategy l))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (DerivStrategy l))
$cgfoldl :: forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DerivStrategy l -> c (DerivStrategy l)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DerivStrategy l -> c (DerivStrategy l)
$cgunfold :: forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (DerivStrategy l)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (DerivStrategy l)
$ctoConstr :: forall l. Data l => DerivStrategy l -> Constr
toConstr :: DerivStrategy l -> Constr
$cdataTypeOf :: forall l. Data l => DerivStrategy l -> DataType
dataTypeOf :: DerivStrategy l -> DataType
$cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (DerivStrategy l))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (DerivStrategy l))
$cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (DerivStrategy l))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (DerivStrategy l))
$cgmapT :: forall l.
Data l =>
(forall b. Data b => b -> b) -> DerivStrategy l -> DerivStrategy l
gmapT :: (forall b. Data b => b -> b) -> DerivStrategy l -> DerivStrategy l
$cgmapQl :: forall l r r'.
Data l =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DerivStrategy l -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DerivStrategy l -> r
$cgmapQr :: forall l r r'.
Data l =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DerivStrategy l -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DerivStrategy l -> r
$cgmapQ :: forall l u.
Data l =>
(forall d. Data d => d -> u) -> DerivStrategy l -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> DerivStrategy l -> [u]
$cgmapQi :: forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> DerivStrategy l -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> DerivStrategy l -> u
$cgmapM :: forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d)
-> DerivStrategy l -> m (DerivStrategy l)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DerivStrategy l -> m (DerivStrategy l)
$cgmapMp :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> DerivStrategy l -> m (DerivStrategy l)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DerivStrategy l -> m (DerivStrategy l)
$cgmapMo :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> DerivStrategy l -> m (DerivStrategy l)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DerivStrategy l -> m (DerivStrategy l)
Data,(forall m. Monoid m => DerivStrategy m -> m)
-> (forall m a. Monoid m => (a -> m) -> DerivStrategy a -> m)
-> (forall m a. Monoid m => (a -> m) -> DerivStrategy a -> m)
-> (forall a b. (a -> b -> b) -> b -> DerivStrategy a -> b)
-> (forall a b. (a -> b -> b) -> b -> DerivStrategy a -> b)
-> (forall b a. (b -> a -> b) -> b -> DerivStrategy a -> b)
-> (forall b a. (b -> a -> b) -> b -> DerivStrategy a -> b)
-> (forall a. (a -> a -> a) -> DerivStrategy a -> a)
-> (forall a. (a -> a -> a) -> DerivStrategy a -> a)
-> (forall a. DerivStrategy a -> [a])
-> (forall a. DerivStrategy a -> Bool)
-> (forall a. DerivStrategy a -> Int)
-> (forall a. Eq a => a -> DerivStrategy a -> Bool)
-> (forall a. Ord a => DerivStrategy a -> a)
-> (forall a. Ord a => DerivStrategy a -> a)
-> (forall a. Num a => DerivStrategy a -> a)
-> (forall a. Num a => DerivStrategy a -> a)
-> Foldable DerivStrategy
forall a. Eq a => a -> DerivStrategy a -> Bool
forall a. Num a => DerivStrategy a -> a
forall a. Ord a => DerivStrategy a -> a
forall m. Monoid m => DerivStrategy m -> m
forall a. DerivStrategy a -> Bool
forall a. DerivStrategy a -> Int
forall a. DerivStrategy a -> [a]
forall a. (a -> a -> a) -> DerivStrategy a -> a
forall m a. Monoid m => (a -> m) -> DerivStrategy a -> m
forall b a. (b -> a -> b) -> b -> DerivStrategy a -> b
forall a b. (a -> b -> b) -> b -> DerivStrategy a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall m. Monoid m => DerivStrategy m -> m
fold :: forall m. Monoid m => DerivStrategy m -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> DerivStrategy a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> DerivStrategy a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> DerivStrategy a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> DerivStrategy a -> m
$cfoldr :: forall a b. (a -> b -> b) -> b -> DerivStrategy a -> b
foldr :: forall a b. (a -> b -> b) -> b -> DerivStrategy a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> DerivStrategy a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> DerivStrategy a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> DerivStrategy a -> b
foldl :: forall b a. (b -> a -> b) -> b -> DerivStrategy a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> DerivStrategy a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> DerivStrategy a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> DerivStrategy a -> a
foldr1 :: forall a. (a -> a -> a) -> DerivStrategy a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> DerivStrategy a -> a
foldl1 :: forall a. (a -> a -> a) -> DerivStrategy a -> a
$ctoList :: forall a. DerivStrategy a -> [a]
toList :: forall a. DerivStrategy a -> [a]
$cnull :: forall a. DerivStrategy a -> Bool
null :: forall a. DerivStrategy a -> Bool
$clength :: forall a. DerivStrategy a -> Int
length :: forall a. DerivStrategy a -> Int
$celem :: forall a. Eq a => a -> DerivStrategy a -> Bool
elem :: forall a. Eq a => a -> DerivStrategy a -> Bool
$cmaximum :: forall a. Ord a => DerivStrategy a -> a
maximum :: forall a. Ord a => DerivStrategy a -> a
$cminimum :: forall a. Ord a => DerivStrategy a -> a
minimum :: forall a. Ord a => DerivStrategy a -> a
$csum :: forall a. Num a => DerivStrategy a -> a
sum :: forall a. Num a => DerivStrategy a -> a
$cproduct :: forall a. Num a => DerivStrategy a -> a
product :: forall a. Num a => DerivStrategy a -> a
Foldable,Functor DerivStrategy
Foldable DerivStrategy
(Functor DerivStrategy, Foldable DerivStrategy) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> DerivStrategy a -> f (DerivStrategy b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    DerivStrategy (f a) -> f (DerivStrategy a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> DerivStrategy a -> m (DerivStrategy b))
-> (forall (m :: * -> *) a.
    Monad m =>
    DerivStrategy (m a) -> m (DerivStrategy a))
-> Traversable DerivStrategy
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a.
Monad m =>
DerivStrategy (m a) -> m (DerivStrategy a)
forall (f :: * -> *) a.
Applicative f =>
DerivStrategy (f a) -> f (DerivStrategy a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> DerivStrategy a -> m (DerivStrategy b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> DerivStrategy a -> f (DerivStrategy b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> DerivStrategy a -> f (DerivStrategy b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> DerivStrategy a -> f (DerivStrategy b)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
DerivStrategy (f a) -> f (DerivStrategy a)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
DerivStrategy (f a) -> f (DerivStrategy a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> DerivStrategy a -> m (DerivStrategy b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> DerivStrategy a -> m (DerivStrategy b)
$csequence :: forall (m :: * -> *) a.
Monad m =>
DerivStrategy (m a) -> m (DerivStrategy a)
sequence :: forall (m :: * -> *) a.
Monad m =>
DerivStrategy (m a) -> m (DerivStrategy a)
Traversable,(forall a b. (a -> b) -> DerivStrategy a -> DerivStrategy b)
-> (forall a b. a -> DerivStrategy b -> DerivStrategy a)
-> Functor DerivStrategy
forall a b. a -> DerivStrategy b -> DerivStrategy a
forall a b. (a -> b) -> DerivStrategy a -> DerivStrategy b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> DerivStrategy a -> DerivStrategy b
fmap :: forall a b. (a -> b) -> DerivStrategy a -> DerivStrategy b
$c<$ :: forall a b. a -> DerivStrategy b -> DerivStrategy a
<$ :: forall a b. a -> DerivStrategy b -> DerivStrategy a
Functor,(forall x. DerivStrategy l -> Rep (DerivStrategy l) x)
-> (forall x. Rep (DerivStrategy l) x -> DerivStrategy l)
-> Generic (DerivStrategy l)
forall x. Rep (DerivStrategy l) x -> DerivStrategy l
forall x. DerivStrategy l -> Rep (DerivStrategy l) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall l x. Rep (DerivStrategy l) x -> DerivStrategy l
forall l x. DerivStrategy l -> Rep (DerivStrategy l) x
$cfrom :: forall l x. DerivStrategy l -> Rep (DerivStrategy l) x
from :: forall x. DerivStrategy l -> Rep (DerivStrategy l) x
$cto :: forall l x. Rep (DerivStrategy l) x -> DerivStrategy l
to :: forall x. Rep (DerivStrategy l) x -> DerivStrategy l
Generic)

-- | A binding group inside a @let@ or @where@ clause.
data Binds l
    = BDecls  l [Decl l]     -- ^ An ordinary binding group
    | IPBinds l [IPBind l]   -- ^ A binding group for implicit parameters
  deriving (Binds l -> Binds l -> Bool
(Binds l -> Binds l -> Bool)
-> (Binds l -> Binds l -> Bool) -> Eq (Binds l)
forall l. Eq l => Binds l -> Binds l -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall l. Eq l => Binds l -> Binds l -> Bool
== :: Binds l -> Binds l -> Bool
$c/= :: forall l. Eq l => Binds l -> Binds l -> Bool
/= :: Binds l -> Binds l -> Bool
Eq,Eq (Binds l)
Eq (Binds l) =>
(Binds l -> Binds l -> Ordering)
-> (Binds l -> Binds l -> Bool)
-> (Binds l -> Binds l -> Bool)
-> (Binds l -> Binds l -> Bool)
-> (Binds l -> Binds l -> Bool)
-> (Binds l -> Binds l -> Binds l)
-> (Binds l -> Binds l -> Binds l)
-> Ord (Binds l)
Binds l -> Binds l -> Bool
Binds l -> Binds l -> Ordering
Binds l -> Binds l -> Binds l
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall l. Ord l => Eq (Binds l)
forall l. Ord l => Binds l -> Binds l -> Bool
forall l. Ord l => Binds l -> Binds l -> Ordering
forall l. Ord l => Binds l -> Binds l -> Binds l
$ccompare :: forall l. Ord l => Binds l -> Binds l -> Ordering
compare :: Binds l -> Binds l -> Ordering
$c< :: forall l. Ord l => Binds l -> Binds l -> Bool
< :: Binds l -> Binds l -> Bool
$c<= :: forall l. Ord l => Binds l -> Binds l -> Bool
<= :: Binds l -> Binds l -> Bool
$c> :: forall l. Ord l => Binds l -> Binds l -> Bool
> :: Binds l -> Binds l -> Bool
$c>= :: forall l. Ord l => Binds l -> Binds l -> Bool
>= :: Binds l -> Binds l -> Bool
$cmax :: forall l. Ord l => Binds l -> Binds l -> Binds l
max :: Binds l -> Binds l -> Binds l
$cmin :: forall l. Ord l => Binds l -> Binds l -> Binds l
min :: Binds l -> Binds l -> Binds l
Ord,Int -> Binds l -> ShowS
[Binds l] -> ShowS
Binds l -> String
(Int -> Binds l -> ShowS)
-> (Binds l -> String) -> ([Binds l] -> ShowS) -> Show (Binds l)
forall l. Show l => Int -> Binds l -> ShowS
forall l. Show l => [Binds l] -> ShowS
forall l. Show l => Binds l -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall l. Show l => Int -> Binds l -> ShowS
showsPrec :: Int -> Binds l -> ShowS
$cshow :: forall l. Show l => Binds l -> String
show :: Binds l -> String
$cshowList :: forall l. Show l => [Binds l] -> ShowS
showList :: [Binds l] -> ShowS
Show,Typeable,Typeable (Binds l)
Typeable (Binds l) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Binds l -> c (Binds l))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Binds l))
-> (Binds l -> Constr)
-> (Binds l -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Binds l)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Binds l)))
-> ((forall b. Data b => b -> b) -> Binds l -> Binds l)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Binds l -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Binds l -> r)
-> (forall u. (forall d. Data d => d -> u) -> Binds l -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Binds l -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Binds l -> m (Binds l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Binds l -> m (Binds l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Binds l -> m (Binds l))
-> Data (Binds l)
Binds l -> Constr
Binds l -> DataType
(forall b. Data b => b -> b) -> Binds l -> Binds l
forall l. Data l => Typeable (Binds l)
forall l. Data l => Binds l -> Constr
forall l. Data l => Binds l -> DataType
forall l.
Data l =>
(forall b. Data b => b -> b) -> Binds l -> Binds l
forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> Binds l -> u
forall l u.
Data l =>
(forall d. Data d => d -> u) -> Binds l -> [u]
forall l r r'.
Data l =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Binds l -> r
forall l r r'.
Data l =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Binds l -> r
forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d) -> Binds l -> m (Binds l)
forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Binds l -> m (Binds l)
forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Binds l)
forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Binds l -> c (Binds l)
forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Binds l))
forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Binds l))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Binds l -> u
forall u. (forall d. Data d => d -> u) -> Binds l -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Binds l -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Binds l -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Binds l -> m (Binds l)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Binds l -> m (Binds l)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Binds l)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Binds l -> c (Binds l)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Binds l))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Binds l))
$cgfoldl :: forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Binds l -> c (Binds l)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Binds l -> c (Binds l)
$cgunfold :: forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Binds l)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Binds l)
$ctoConstr :: forall l. Data l => Binds l -> Constr
toConstr :: Binds l -> Constr
$cdataTypeOf :: forall l. Data l => Binds l -> DataType
dataTypeOf :: Binds l -> DataType
$cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Binds l))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Binds l))
$cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Binds l))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Binds l))
$cgmapT :: forall l.
Data l =>
(forall b. Data b => b -> b) -> Binds l -> Binds l
gmapT :: (forall b. Data b => b -> b) -> Binds l -> Binds l
$cgmapQl :: forall l r r'.
Data l =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Binds l -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Binds l -> r
$cgmapQr :: forall l r r'.
Data l =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Binds l -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Binds l -> r
$cgmapQ :: forall l u.
Data l =>
(forall d. Data d => d -> u) -> Binds l -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Binds l -> [u]
$cgmapQi :: forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> Binds l -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Binds l -> u
$cgmapM :: forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d) -> Binds l -> m (Binds l)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Binds l -> m (Binds l)
$cgmapMp :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Binds l -> m (Binds l)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Binds l -> m (Binds l)
$cgmapMo :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Binds l -> m (Binds l)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Binds l -> m (Binds l)
Data,(forall m. Monoid m => Binds m -> m)
-> (forall m a. Monoid m => (a -> m) -> Binds a -> m)
-> (forall m a. Monoid m => (a -> m) -> Binds a -> m)
-> (forall a b. (a -> b -> b) -> b -> Binds a -> b)
-> (forall a b. (a -> b -> b) -> b -> Binds a -> b)
-> (forall b a. (b -> a -> b) -> b -> Binds a -> b)
-> (forall b a. (b -> a -> b) -> b -> Binds a -> b)
-> (forall a. (a -> a -> a) -> Binds a -> a)
-> (forall a. (a -> a -> a) -> Binds a -> a)
-> (forall a. Binds a -> [a])
-> (forall a. Binds a -> Bool)
-> (forall a. Binds a -> Int)
-> (forall a. Eq a => a -> Binds a -> Bool)
-> (forall a. Ord a => Binds a -> a)
-> (forall a. Ord a => Binds a -> a)
-> (forall a. Num a => Binds a -> a)
-> (forall a. Num a => Binds a -> a)
-> Foldable Binds
forall a. Eq a => a -> Binds a -> Bool
forall a. Num a => Binds a -> a
forall a. Ord a => Binds a -> a
forall m. Monoid m => Binds m -> m
forall a. Binds a -> Bool
forall a. Binds a -> Int
forall a. Binds a -> [a]
forall a. (a -> a -> a) -> Binds a -> a
forall m a. Monoid m => (a -> m) -> Binds a -> m
forall b a. (b -> a -> b) -> b -> Binds a -> b
forall a b. (a -> b -> b) -> b -> Binds a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall m. Monoid m => Binds m -> m
fold :: forall m. Monoid m => Binds m -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> Binds a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> Binds a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> Binds a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> Binds a -> m
$cfoldr :: forall a b. (a -> b -> b) -> b -> Binds a -> b
foldr :: forall a b. (a -> b -> b) -> b -> Binds a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> Binds a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> Binds a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> Binds a -> b
foldl :: forall b a. (b -> a -> b) -> b -> Binds a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> Binds a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> Binds a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> Binds a -> a
foldr1 :: forall a. (a -> a -> a) -> Binds a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> Binds a -> a
foldl1 :: forall a. (a -> a -> a) -> Binds a -> a
$ctoList :: forall a. Binds a -> [a]
toList :: forall a. Binds a -> [a]
$cnull :: forall a. Binds a -> Bool
null :: forall a. Binds a -> Bool
$clength :: forall a. Binds a -> Int
length :: forall a. Binds a -> Int
$celem :: forall a. Eq a => a -> Binds a -> Bool
elem :: forall a. Eq a => a -> Binds a -> Bool
$cmaximum :: forall a. Ord a => Binds a -> a
maximum :: forall a. Ord a => Binds a -> a
$cminimum :: forall a. Ord a => Binds a -> a
minimum :: forall a. Ord a => Binds a -> a
$csum :: forall a. Num a => Binds a -> a
sum :: forall a. Num a => Binds a -> a
$cproduct :: forall a. Num a => Binds a -> a
product :: forall a. Num a => Binds a -> a
Foldable,Functor Binds
Foldable Binds
(Functor Binds, Foldable Binds) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> Binds a -> f (Binds b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    Binds (f a) -> f (Binds a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Binds a -> m (Binds b))
-> (forall (m :: * -> *) a. Monad m => Binds (m a) -> m (Binds a))
-> Traversable Binds
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a. Monad m => Binds (m a) -> m (Binds a)
forall (f :: * -> *) a. Applicative f => Binds (f a) -> f (Binds a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Binds a -> m (Binds b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Binds a -> f (Binds b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Binds a -> f (Binds b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Binds a -> f (Binds b)
$csequenceA :: forall (f :: * -> *) a. Applicative f => Binds (f a) -> f (Binds a)
sequenceA :: forall (f :: * -> *) a. Applicative f => Binds (f a) -> f (Binds a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Binds a -> m (Binds b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Binds a -> m (Binds b)
$csequence :: forall (m :: * -> *) a. Monad m => Binds (m a) -> m (Binds a)
sequence :: forall (m :: * -> *) a. Monad m => Binds (m a) -> m (Binds a)
Traversable,(forall a b. (a -> b) -> Binds a -> Binds b)
-> (forall a b. a -> Binds b -> Binds a) -> Functor Binds
forall a b. a -> Binds b -> Binds a
forall a b. (a -> b) -> Binds a -> Binds b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> Binds a -> Binds b
fmap :: forall a b. (a -> b) -> Binds a -> Binds b
$c<$ :: forall a b. a -> Binds b -> Binds a
<$ :: forall a b. a -> Binds b -> Binds a
Functor,(forall x. Binds l -> Rep (Binds l) x)
-> (forall x. Rep (Binds l) x -> Binds l) -> Generic (Binds l)
forall x. Rep (Binds l) x -> Binds l
forall x. Binds l -> Rep (Binds l) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall l x. Rep (Binds l) x -> Binds l
forall l x. Binds l -> Rep (Binds l) x
$cfrom :: forall l x. Binds l -> Rep (Binds l) x
from :: forall x. Binds l -> Rep (Binds l) x
$cto :: forall l x. Rep (Binds l) x -> Binds l
to :: forall x. Rep (Binds l) x -> Binds l
Generic)

-- | A binding of an implicit parameter.
data IPBind l = IPBind l (IPName l) (Exp l)
  deriving (IPBind l -> IPBind l -> Bool
(IPBind l -> IPBind l -> Bool)
-> (IPBind l -> IPBind l -> Bool) -> Eq (IPBind l)
forall l. Eq l => IPBind l -> IPBind l -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall l. Eq l => IPBind l -> IPBind l -> Bool
== :: IPBind l -> IPBind l -> Bool
$c/= :: forall l. Eq l => IPBind l -> IPBind l -> Bool
/= :: IPBind l -> IPBind l -> Bool
Eq,Eq (IPBind l)
Eq (IPBind l) =>
(IPBind l -> IPBind l -> Ordering)
-> (IPBind l -> IPBind l -> Bool)
-> (IPBind l -> IPBind l -> Bool)
-> (IPBind l -> IPBind l -> Bool)
-> (IPBind l -> IPBind l -> Bool)
-> (IPBind l -> IPBind l -> IPBind l)
-> (IPBind l -> IPBind l -> IPBind l)
-> Ord (IPBind l)
IPBind l -> IPBind l -> Bool
IPBind l -> IPBind l -> Ordering
IPBind l -> IPBind l -> IPBind l
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall l. Ord l => Eq (IPBind l)
forall l. Ord l => IPBind l -> IPBind l -> Bool
forall l. Ord l => IPBind l -> IPBind l -> Ordering
forall l. Ord l => IPBind l -> IPBind l -> IPBind l
$ccompare :: forall l. Ord l => IPBind l -> IPBind l -> Ordering
compare :: IPBind l -> IPBind l -> Ordering
$c< :: forall l. Ord l => IPBind l -> IPBind l -> Bool
< :: IPBind l -> IPBind l -> Bool
$c<= :: forall l. Ord l => IPBind l -> IPBind l -> Bool
<= :: IPBind l -> IPBind l -> Bool
$c> :: forall l. Ord l => IPBind l -> IPBind l -> Bool
> :: IPBind l -> IPBind l -> Bool
$c>= :: forall l. Ord l => IPBind l -> IPBind l -> Bool
>= :: IPBind l -> IPBind l -> Bool
$cmax :: forall l. Ord l => IPBind l -> IPBind l -> IPBind l
max :: IPBind l -> IPBind l -> IPBind l
$cmin :: forall l. Ord l => IPBind l -> IPBind l -> IPBind l
min :: IPBind l -> IPBind l -> IPBind l
Ord,Int -> IPBind l -> ShowS
[IPBind l] -> ShowS
IPBind l -> String
(Int -> IPBind l -> ShowS)
-> (IPBind l -> String) -> ([IPBind l] -> ShowS) -> Show (IPBind l)
forall l. Show l => Int -> IPBind l -> ShowS
forall l. Show l => [IPBind l] -> ShowS
forall l. Show l => IPBind l -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall l. Show l => Int -> IPBind l -> ShowS
showsPrec :: Int -> IPBind l -> ShowS
$cshow :: forall l. Show l => IPBind l -> String
show :: IPBind l -> String
$cshowList :: forall l. Show l => [IPBind l] -> ShowS
showList :: [IPBind l] -> ShowS
Show,Typeable,Typeable (IPBind l)
Typeable (IPBind l) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> IPBind l -> c (IPBind l))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (IPBind l))
-> (IPBind l -> Constr)
-> (IPBind l -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (IPBind l)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (IPBind l)))
-> ((forall b. Data b => b -> b) -> IPBind l -> IPBind l)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> IPBind l -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> IPBind l -> r)
-> (forall u. (forall d. Data d => d -> u) -> IPBind l -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> IPBind l -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> IPBind l -> m (IPBind l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> IPBind l -> m (IPBind l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> IPBind l -> m (IPBind l))
-> Data (IPBind l)
IPBind l -> Constr
IPBind l -> DataType
(forall b. Data b => b -> b) -> IPBind l -> IPBind l
forall l. Data l => Typeable (IPBind l)
forall l. Data l => IPBind l -> Constr
forall l. Data l => IPBind l -> DataType
forall l.
Data l =>
(forall b. Data b => b -> b) -> IPBind l -> IPBind l
forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> IPBind l -> u
forall l u.
Data l =>
(forall d. Data d => d -> u) -> IPBind l -> [u]
forall l r r'.
Data l =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> IPBind l -> r
forall l r r'.
Data l =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> IPBind l -> r
forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d) -> IPBind l -> m (IPBind l)
forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> IPBind l -> m (IPBind l)
forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (IPBind l)
forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> IPBind l -> c (IPBind l)
forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (IPBind l))
forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (IPBind l))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> IPBind l -> u
forall u. (forall d. Data d => d -> u) -> IPBind l -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> IPBind l -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> IPBind l -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> IPBind l -> m (IPBind l)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> IPBind l -> m (IPBind l)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (IPBind l)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> IPBind l -> c (IPBind l)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (IPBind l))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (IPBind l))
$cgfoldl :: forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> IPBind l -> c (IPBind l)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> IPBind l -> c (IPBind l)
$cgunfold :: forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (IPBind l)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (IPBind l)
$ctoConstr :: forall l. Data l => IPBind l -> Constr
toConstr :: IPBind l -> Constr
$cdataTypeOf :: forall l. Data l => IPBind l -> DataType
dataTypeOf :: IPBind l -> DataType
$cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (IPBind l))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (IPBind l))
$cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (IPBind l))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (IPBind l))
$cgmapT :: forall l.
Data l =>
(forall b. Data b => b -> b) -> IPBind l -> IPBind l
gmapT :: (forall b. Data b => b -> b) -> IPBind l -> IPBind l
$cgmapQl :: forall l r r'.
Data l =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> IPBind l -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> IPBind l -> r
$cgmapQr :: forall l r r'.
Data l =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> IPBind l -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> IPBind l -> r
$cgmapQ :: forall l u.
Data l =>
(forall d. Data d => d -> u) -> IPBind l -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> IPBind l -> [u]
$cgmapQi :: forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> IPBind l -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> IPBind l -> u
$cgmapM :: forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d) -> IPBind l -> m (IPBind l)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> IPBind l -> m (IPBind l)
$cgmapMp :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> IPBind l -> m (IPBind l)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> IPBind l -> m (IPBind l)
$cgmapMo :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> IPBind l -> m (IPBind l)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> IPBind l -> m (IPBind l)
Data,(forall m. Monoid m => IPBind m -> m)
-> (forall m a. Monoid m => (a -> m) -> IPBind a -> m)
-> (forall m a. Monoid m => (a -> m) -> IPBind a -> m)
-> (forall a b. (a -> b -> b) -> b -> IPBind a -> b)
-> (forall a b. (a -> b -> b) -> b -> IPBind a -> b)
-> (forall b a. (b -> a -> b) -> b -> IPBind a -> b)
-> (forall b a. (b -> a -> b) -> b -> IPBind a -> b)
-> (forall a. (a -> a -> a) -> IPBind a -> a)
-> (forall a. (a -> a -> a) -> IPBind a -> a)
-> (forall a. IPBind a -> [a])
-> (forall a. IPBind a -> Bool)
-> (forall a. IPBind a -> Int)
-> (forall a. Eq a => a -> IPBind a -> Bool)
-> (forall a. Ord a => IPBind a -> a)
-> (forall a. Ord a => IPBind a -> a)
-> (forall a. Num a => IPBind a -> a)
-> (forall a. Num a => IPBind a -> a)
-> Foldable IPBind
forall a. Eq a => a -> IPBind a -> Bool
forall a. Num a => IPBind a -> a
forall a. Ord a => IPBind a -> a
forall m. Monoid m => IPBind m -> m
forall a. IPBind a -> Bool
forall a. IPBind a -> Int
forall a. IPBind a -> [a]
forall a. (a -> a -> a) -> IPBind a -> a
forall m a. Monoid m => (a -> m) -> IPBind a -> m
forall b a. (b -> a -> b) -> b -> IPBind a -> b
forall a b. (a -> b -> b) -> b -> IPBind a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall m. Monoid m => IPBind m -> m
fold :: forall m. Monoid m => IPBind m -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> IPBind a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> IPBind a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> IPBind a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> IPBind a -> m
$cfoldr :: forall a b. (a -> b -> b) -> b -> IPBind a -> b
foldr :: forall a b. (a -> b -> b) -> b -> IPBind a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> IPBind a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> IPBind a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> IPBind a -> b
foldl :: forall b a. (b -> a -> b) -> b -> IPBind a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> IPBind a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> IPBind a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> IPBind a -> a
foldr1 :: forall a. (a -> a -> a) -> IPBind a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> IPBind a -> a
foldl1 :: forall a. (a -> a -> a) -> IPBind a -> a
$ctoList :: forall a. IPBind a -> [a]
toList :: forall a. IPBind a -> [a]
$cnull :: forall a. IPBind a -> Bool
null :: forall a. IPBind a -> Bool
$clength :: forall a. IPBind a -> Int
length :: forall a. IPBind a -> Int
$celem :: forall a. Eq a => a -> IPBind a -> Bool
elem :: forall a. Eq a => a -> IPBind a -> Bool
$cmaximum :: forall a. Ord a => IPBind a -> a
maximum :: forall a. Ord a => IPBind a -> a
$cminimum :: forall a. Ord a => IPBind a -> a
minimum :: forall a. Ord a => IPBind a -> a
$csum :: forall a. Num a => IPBind a -> a
sum :: forall a. Num a => IPBind a -> a
$cproduct :: forall a. Num a => IPBind a -> a
product :: forall a. Num a => IPBind a -> a
Foldable,Functor IPBind
Foldable IPBind
(Functor IPBind, Foldable IPBind) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> IPBind a -> f (IPBind b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    IPBind (f a) -> f (IPBind a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> IPBind a -> m (IPBind b))
-> (forall (m :: * -> *) a.
    Monad m =>
    IPBind (m a) -> m (IPBind a))
-> Traversable IPBind
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a. Monad m => IPBind (m a) -> m (IPBind a)
forall (f :: * -> *) a.
Applicative f =>
IPBind (f a) -> f (IPBind a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> IPBind a -> m (IPBind b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> IPBind a -> f (IPBind b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> IPBind a -> f (IPBind b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> IPBind a -> f (IPBind b)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
IPBind (f a) -> f (IPBind a)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
IPBind (f a) -> f (IPBind a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> IPBind a -> m (IPBind b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> IPBind a -> m (IPBind b)
$csequence :: forall (m :: * -> *) a. Monad m => IPBind (m a) -> m (IPBind a)
sequence :: forall (m :: * -> *) a. Monad m => IPBind (m a) -> m (IPBind a)
Traversable,(forall a b. (a -> b) -> IPBind a -> IPBind b)
-> (forall a b. a -> IPBind b -> IPBind a) -> Functor IPBind
forall a b. a -> IPBind b -> IPBind a
forall a b. (a -> b) -> IPBind a -> IPBind b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> IPBind a -> IPBind b
fmap :: forall a b. (a -> b) -> IPBind a -> IPBind b
$c<$ :: forall a b. a -> IPBind b -> IPBind a
<$ :: forall a b. a -> IPBind b -> IPBind a
Functor,(forall x. IPBind l -> Rep (IPBind l) x)
-> (forall x. Rep (IPBind l) x -> IPBind l) -> Generic (IPBind l)
forall x. Rep (IPBind l) x -> IPBind l
forall x. IPBind l -> Rep (IPBind l) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall l x. Rep (IPBind l) x -> IPBind l
forall l x. IPBind l -> Rep (IPBind l) x
$cfrom :: forall l x. IPBind l -> Rep (IPBind l) x
from :: forall x. IPBind l -> Rep (IPBind l) x
$cto :: forall l x. Rep (IPBind l) x -> IPBind l
to :: forall x. Rep (IPBind l) x -> IPBind l
Generic)

-- | Clauses of a function binding.
data Match l
     = Match l      (Name l) [Pat l]         (Rhs l) {-where-} (Maybe (Binds l))
        -- ^ A clause defined with prefix notation, i.e. the function name
        --  followed by its argument patterns, the right-hand side and an
        --  optional where clause.
     | InfixMatch l (Pat l) (Name l) [Pat l] (Rhs l) {-where-} (Maybe (Binds l))
        -- ^ A clause defined with infix notation, i.e. first its first argument
        --  pattern, then the function name, then its following argument(s),
        --  the right-hand side and an optional where clause.
        --  Note that there can be more than two arguments to a function declared
        --  infix, hence the list of pattern arguments.
  deriving (Match l -> Match l -> Bool
(Match l -> Match l -> Bool)
-> (Match l -> Match l -> Bool) -> Eq (Match l)
forall l. Eq l => Match l -> Match l -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall l. Eq l => Match l -> Match l -> Bool
== :: Match l -> Match l -> Bool
$c/= :: forall l. Eq l => Match l -> Match l -> Bool
/= :: Match l -> Match l -> Bool
Eq,Eq (Match l)
Eq (Match l) =>
(Match l -> Match l -> Ordering)
-> (Match l -> Match l -> Bool)
-> (Match l -> Match l -> Bool)
-> (Match l -> Match l -> Bool)
-> (Match l -> Match l -> Bool)
-> (Match l -> Match l -> Match l)
-> (Match l -> Match l -> Match l)
-> Ord (Match l)
Match l -> Match l -> Bool
Match l -> Match l -> Ordering
Match l -> Match l -> Match l
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall l. Ord l => Eq (Match l)
forall l. Ord l => Match l -> Match l -> Bool
forall l. Ord l => Match l -> Match l -> Ordering
forall l. Ord l => Match l -> Match l -> Match l
$ccompare :: forall l. Ord l => Match l -> Match l -> Ordering
compare :: Match l -> Match l -> Ordering
$c< :: forall l. Ord l => Match l -> Match l -> Bool
< :: Match l -> Match l -> Bool
$c<= :: forall l. Ord l => Match l -> Match l -> Bool
<= :: Match l -> Match l -> Bool
$c> :: forall l. Ord l => Match l -> Match l -> Bool
> :: Match l -> Match l -> Bool
$c>= :: forall l. Ord l => Match l -> Match l -> Bool
>= :: Match l -> Match l -> Bool
$cmax :: forall l. Ord l => Match l -> Match l -> Match l
max :: Match l -> Match l -> Match l
$cmin :: forall l. Ord l => Match l -> Match l -> Match l
min :: Match l -> Match l -> Match l
Ord,Int -> Match l -> ShowS
[Match l] -> ShowS
Match l -> String
(Int -> Match l -> ShowS)
-> (Match l -> String) -> ([Match l] -> ShowS) -> Show (Match l)
forall l. Show l => Int -> Match l -> ShowS
forall l. Show l => [Match l] -> ShowS
forall l. Show l => Match l -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall l. Show l => Int -> Match l -> ShowS
showsPrec :: Int -> Match l -> ShowS
$cshow :: forall l. Show l => Match l -> String
show :: Match l -> String
$cshowList :: forall l. Show l => [Match l] -> ShowS
showList :: [Match l] -> ShowS
Show,Typeable,Typeable (Match l)
Typeable (Match l) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Match l -> c (Match l))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Match l))
-> (Match l -> Constr)
-> (Match l -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Match l)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Match l)))
-> ((forall b. Data b => b -> b) -> Match l -> Match l)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Match l -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Match l -> r)
-> (forall u. (forall d. Data d => d -> u) -> Match l -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Match l -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Match l -> m (Match l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Match l -> m (Match l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Match l -> m (Match l))
-> Data (Match l)
Match l -> Constr
Match l -> DataType
(forall b. Data b => b -> b) -> Match l -> Match l
forall l. Data l => Typeable (Match l)
forall l. Data l => Match l -> Constr
forall l. Data l => Match l -> DataType
forall l.
Data l =>
(forall b. Data b => b -> b) -> Match l -> Match l
forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> Match l -> u
forall l u.
Data l =>
(forall d. Data d => d -> u) -> Match l -> [u]
forall l r r'.
Data l =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Match l -> r
forall l r r'.
Data l =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Match l -> r
forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d) -> Match l -> m (Match l)
forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Match l -> m (Match l)
forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Match l)
forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Match l -> c (Match l)
forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Match l))
forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Match l))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Match l -> u
forall u. (forall d. Data d => d -> u) -> Match l -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Match l -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Match l -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Match l -> m (Match l)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Match l -> m (Match l)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Match l)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Match l -> c (Match l)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Match l))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Match l))
$cgfoldl :: forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Match l -> c (Match l)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Match l -> c (Match l)
$cgunfold :: forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Match l)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Match l)
$ctoConstr :: forall l. Data l => Match l -> Constr
toConstr :: Match l -> Constr
$cdataTypeOf :: forall l. Data l => Match l -> DataType
dataTypeOf :: Match l -> DataType
$cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Match l))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Match l))
$cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Match l))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Match l))
$cgmapT :: forall l.
Data l =>
(forall b. Data b => b -> b) -> Match l -> Match l
gmapT :: (forall b. Data b => b -> b) -> Match l -> Match l
$cgmapQl :: forall l r r'.
Data l =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Match l -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Match l -> r
$cgmapQr :: forall l r r'.
Data l =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Match l -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Match l -> r
$cgmapQ :: forall l u.
Data l =>
(forall d. Data d => d -> u) -> Match l -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Match l -> [u]
$cgmapQi :: forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> Match l -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Match l -> u
$cgmapM :: forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d) -> Match l -> m (Match l)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Match l -> m (Match l)
$cgmapMp :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Match l -> m (Match l)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Match l -> m (Match l)
$cgmapMo :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Match l -> m (Match l)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Match l -> m (Match l)
Data,(forall m. Monoid m => Match m -> m)
-> (forall m a. Monoid m => (a -> m) -> Match a -> m)
-> (forall m a. Monoid m => (a -> m) -> Match a -> m)
-> (forall a b. (a -> b -> b) -> b -> Match a -> b)
-> (forall a b. (a -> b -> b) -> b -> Match a -> b)
-> (forall b a. (b -> a -> b) -> b -> Match a -> b)
-> (forall b a. (b -> a -> b) -> b -> Match a -> b)
-> (forall a. (a -> a -> a) -> Match a -> a)
-> (forall a. (a -> a -> a) -> Match a -> a)
-> (forall a. Match a -> [a])
-> (forall a. Match a -> Bool)
-> (forall a. Match a -> Int)
-> (forall a. Eq a => a -> Match a -> Bool)
-> (forall a. Ord a => Match a -> a)
-> (forall a. Ord a => Match a -> a)
-> (forall a. Num a => Match a -> a)
-> (forall a. Num a => Match a -> a)
-> Foldable Match
forall a. Eq a => a -> Match a -> Bool
forall a. Num a => Match a -> a
forall a. Ord a => Match a -> a
forall m. Monoid m => Match m -> m
forall a. Match a -> Bool
forall a. Match a -> Int
forall a. Match a -> [a]
forall a. (a -> a -> a) -> Match a -> a
forall m a. Monoid m => (a -> m) -> Match a -> m
forall b a. (b -> a -> b) -> b -> Match a -> b
forall a b. (a -> b -> b) -> b -> Match a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall m. Monoid m => Match m -> m
fold :: forall m. Monoid m => Match m -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> Match a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> Match a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> Match a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> Match a -> m
$cfoldr :: forall a b. (a -> b -> b) -> b -> Match a -> b
foldr :: forall a b. (a -> b -> b) -> b -> Match a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> Match a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> Match a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> Match a -> b
foldl :: forall b a. (b -> a -> b) -> b -> Match a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> Match a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> Match a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> Match a -> a
foldr1 :: forall a. (a -> a -> a) -> Match a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> Match a -> a
foldl1 :: forall a. (a -> a -> a) -> Match a -> a
$ctoList :: forall a. Match a -> [a]
toList :: forall a. Match a -> [a]
$cnull :: forall a. Match a -> Bool
null :: forall a. Match a -> Bool
$clength :: forall a. Match a -> Int
length :: forall a. Match a -> Int
$celem :: forall a. Eq a => a -> Match a -> Bool
elem :: forall a. Eq a => a -> Match a -> Bool
$cmaximum :: forall a. Ord a => Match a -> a
maximum :: forall a. Ord a => Match a -> a
$cminimum :: forall a. Ord a => Match a -> a
minimum :: forall a. Ord a => Match a -> a
$csum :: forall a. Num a => Match a -> a
sum :: forall a. Num a => Match a -> a
$cproduct :: forall a. Num a => Match a -> a
product :: forall a. Num a => Match a -> a
Foldable,Functor Match
Foldable Match
(Functor Match, Foldable Match) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> Match a -> f (Match b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    Match (f a) -> f (Match a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Match a -> m (Match b))
-> (forall (m :: * -> *) a. Monad m => Match (m a) -> m (Match a))
-> Traversable Match
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a. Monad m => Match (m a) -> m (Match a)
forall (f :: * -> *) a. Applicative f => Match (f a) -> f (Match a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Match a -> m (Match b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Match a -> f (Match b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Match a -> f (Match b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Match a -> f (Match b)
$csequenceA :: forall (f :: * -> *) a. Applicative f => Match (f a) -> f (Match a)
sequenceA :: forall (f :: * -> *) a. Applicative f => Match (f a) -> f (Match a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Match a -> m (Match b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Match a -> m (Match b)
$csequence :: forall (m :: * -> *) a. Monad m => Match (m a) -> m (Match a)
sequence :: forall (m :: * -> *) a. Monad m => Match (m a) -> m (Match a)
Traversable,(forall a b. (a -> b) -> Match a -> Match b)
-> (forall a b. a -> Match b -> Match a) -> Functor Match
forall a b. a -> Match b -> Match a
forall a b. (a -> b) -> Match a -> Match b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> Match a -> Match b
fmap :: forall a b. (a -> b) -> Match a -> Match b
$c<$ :: forall a b. a -> Match b -> Match a
<$ :: forall a b. a -> Match b -> Match a
Functor,(forall x. Match l -> Rep (Match l) x)
-> (forall x. Rep (Match l) x -> Match l) -> Generic (Match l)
forall x. Rep (Match l) x -> Match l
forall x. Match l -> Rep (Match l) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall l x. Rep (Match l) x -> Match l
forall l x. Match l -> Rep (Match l) x
$cfrom :: forall l x. Match l -> Rep (Match l) x
from :: forall x. Match l -> Rep (Match l) x
$cto :: forall l x. Rep (Match l) x -> Match l
to :: forall x. Rep (Match l) x -> Match l
Generic)

-- | A single constructor declaration within a data type declaration,
--   which may have an existential quantification binding.
data QualConDecl l
    = QualConDecl l
        {-forall-} (Maybe [TyVarBind l]) {- . -} (Maybe (Context l))
        {- => -} (ConDecl l)
  deriving (QualConDecl l -> QualConDecl l -> Bool
(QualConDecl l -> QualConDecl l -> Bool)
-> (QualConDecl l -> QualConDecl l -> Bool) -> Eq (QualConDecl l)
forall l. Eq l => QualConDecl l -> QualConDecl l -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall l. Eq l => QualConDecl l -> QualConDecl l -> Bool
== :: QualConDecl l -> QualConDecl l -> Bool
$c/= :: forall l. Eq l => QualConDecl l -> QualConDecl l -> Bool
/= :: QualConDecl l -> QualConDecl l -> Bool
Eq,Eq (QualConDecl l)
Eq (QualConDecl l) =>
(QualConDecl l -> QualConDecl l -> Ordering)
-> (QualConDecl l -> QualConDecl l -> Bool)
-> (QualConDecl l -> QualConDecl l -> Bool)
-> (QualConDecl l -> QualConDecl l -> Bool)
-> (QualConDecl l -> QualConDecl l -> Bool)
-> (QualConDecl l -> QualConDecl l -> QualConDecl l)
-> (QualConDecl l -> QualConDecl l -> QualConDecl l)
-> Ord (QualConDecl l)
QualConDecl l -> QualConDecl l -> Bool
QualConDecl l -> QualConDecl l -> Ordering
QualConDecl l -> QualConDecl l -> QualConDecl l
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall l. Ord l => Eq (QualConDecl l)
forall l. Ord l => QualConDecl l -> QualConDecl l -> Bool
forall l. Ord l => QualConDecl l -> QualConDecl l -> Ordering
forall l. Ord l => QualConDecl l -> QualConDecl l -> QualConDecl l
$ccompare :: forall l. Ord l => QualConDecl l -> QualConDecl l -> Ordering
compare :: QualConDecl l -> QualConDecl l -> Ordering
$c< :: forall l. Ord l => QualConDecl l -> QualConDecl l -> Bool
< :: QualConDecl l -> QualConDecl l -> Bool
$c<= :: forall l. Ord l => QualConDecl l -> QualConDecl l -> Bool
<= :: QualConDecl l -> QualConDecl l -> Bool
$c> :: forall l. Ord l => QualConDecl l -> QualConDecl l -> Bool
> :: QualConDecl l -> QualConDecl l -> Bool
$c>= :: forall l. Ord l => QualConDecl l -> QualConDecl l -> Bool
>= :: QualConDecl l -> QualConDecl l -> Bool
$cmax :: forall l. Ord l => QualConDecl l -> QualConDecl l -> QualConDecl l
max :: QualConDecl l -> QualConDecl l -> QualConDecl l
$cmin :: forall l. Ord l => QualConDecl l -> QualConDecl l -> QualConDecl l
min :: QualConDecl l -> QualConDecl l -> QualConDecl l
Ord,Int -> QualConDecl l -> ShowS
[QualConDecl l] -> ShowS
QualConDecl l -> String
(Int -> QualConDecl l -> ShowS)
-> (QualConDecl l -> String)
-> ([QualConDecl l] -> ShowS)
-> Show (QualConDecl l)
forall l. Show l => Int -> QualConDecl l -> ShowS
forall l. Show l => [QualConDecl l] -> ShowS
forall l. Show l => QualConDecl l -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall l. Show l => Int -> QualConDecl l -> ShowS
showsPrec :: Int -> QualConDecl l -> ShowS
$cshow :: forall l. Show l => QualConDecl l -> String
show :: QualConDecl l -> String
$cshowList :: forall l. Show l => [QualConDecl l] -> ShowS
showList :: [QualConDecl l] -> ShowS
Show,Typeable,Typeable (QualConDecl l)
Typeable (QualConDecl l) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> QualConDecl l -> c (QualConDecl l))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (QualConDecl l))
-> (QualConDecl l -> Constr)
-> (QualConDecl l -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (QualConDecl l)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (QualConDecl l)))
-> ((forall b. Data b => b -> b) -> QualConDecl l -> QualConDecl l)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> QualConDecl l -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> QualConDecl l -> r)
-> (forall u. (forall d. Data d => d -> u) -> QualConDecl l -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> QualConDecl l -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> QualConDecl l -> m (QualConDecl l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> QualConDecl l -> m (QualConDecl l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> QualConDecl l -> m (QualConDecl l))
-> Data (QualConDecl l)
QualConDecl l -> Constr
QualConDecl l -> DataType
(forall b. Data b => b -> b) -> QualConDecl l -> QualConDecl l
forall l. Data l => Typeable (QualConDecl l)
forall l. Data l => QualConDecl l -> Constr
forall l. Data l => QualConDecl l -> DataType
forall l.
Data l =>
(forall b. Data b => b -> b) -> QualConDecl l -> QualConDecl l
forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> QualConDecl l -> u
forall l u.
Data l =>
(forall d. Data d => d -> u) -> QualConDecl l -> [u]
forall l r r'.
Data l =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> QualConDecl l -> r
forall l r r'.
Data l =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> QualConDecl l -> r
forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d)
-> QualConDecl l -> m (QualConDecl l)
forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> QualConDecl l -> m (QualConDecl l)
forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (QualConDecl l)
forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> QualConDecl l -> c (QualConDecl l)
forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (QualConDecl l))
forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (QualConDecl l))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> QualConDecl l -> u
forall u. (forall d. Data d => d -> u) -> QualConDecl l -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> QualConDecl l -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> QualConDecl l -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> QualConDecl l -> m (QualConDecl l)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> QualConDecl l -> m (QualConDecl l)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (QualConDecl l)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> QualConDecl l -> c (QualConDecl l)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (QualConDecl l))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (QualConDecl l))
$cgfoldl :: forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> QualConDecl l -> c (QualConDecl l)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> QualConDecl l -> c (QualConDecl l)
$cgunfold :: forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (QualConDecl l)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (QualConDecl l)
$ctoConstr :: forall l. Data l => QualConDecl l -> Constr
toConstr :: QualConDecl l -> Constr
$cdataTypeOf :: forall l. Data l => QualConDecl l -> DataType
dataTypeOf :: QualConDecl l -> DataType
$cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (QualConDecl l))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (QualConDecl l))
$cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (QualConDecl l))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (QualConDecl l))
$cgmapT :: forall l.
Data l =>
(forall b. Data b => b -> b) -> QualConDecl l -> QualConDecl l
gmapT :: (forall b. Data b => b -> b) -> QualConDecl l -> QualConDecl l
$cgmapQl :: forall l r r'.
Data l =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> QualConDecl l -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> QualConDecl l -> r
$cgmapQr :: forall l r r'.
Data l =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> QualConDecl l -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> QualConDecl l -> r
$cgmapQ :: forall l u.
Data l =>
(forall d. Data d => d -> u) -> QualConDecl l -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> QualConDecl l -> [u]
$cgmapQi :: forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> QualConDecl l -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> QualConDecl l -> u
$cgmapM :: forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d)
-> QualConDecl l -> m (QualConDecl l)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> QualConDecl l -> m (QualConDecl l)
$cgmapMp :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> QualConDecl l -> m (QualConDecl l)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> QualConDecl l -> m (QualConDecl l)
$cgmapMo :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> QualConDecl l -> m (QualConDecl l)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> QualConDecl l -> m (QualConDecl l)
Data,(forall m. Monoid m => QualConDecl m -> m)
-> (forall m a. Monoid m => (a -> m) -> QualConDecl a -> m)
-> (forall m a. Monoid m => (a -> m) -> QualConDecl a -> m)
-> (forall a b. (a -> b -> b) -> b -> QualConDecl a -> b)
-> (forall a b. (a -> b -> b) -> b -> QualConDecl a -> b)
-> (forall b a. (b -> a -> b) -> b -> QualConDecl a -> b)
-> (forall b a. (b -> a -> b) -> b -> QualConDecl a -> b)
-> (forall a. (a -> a -> a) -> QualConDecl a -> a)
-> (forall a. (a -> a -> a) -> QualConDecl a -> a)
-> (forall a. QualConDecl a -> [a])
-> (forall a. QualConDecl a -> Bool)
-> (forall a. QualConDecl a -> Int)
-> (forall a. Eq a => a -> QualConDecl a -> Bool)
-> (forall a. Ord a => QualConDecl a -> a)
-> (forall a. Ord a => QualConDecl a -> a)
-> (forall a. Num a => QualConDecl a -> a)
-> (forall a. Num a => QualConDecl a -> a)
-> Foldable QualConDecl
forall a. Eq a => a -> QualConDecl a -> Bool
forall a. Num a => QualConDecl a -> a
forall a. Ord a => QualConDecl a -> a
forall m. Monoid m => QualConDecl m -> m
forall a. QualConDecl a -> Bool
forall a. QualConDecl a -> Int
forall a. QualConDecl a -> [a]
forall a. (a -> a -> a) -> QualConDecl a -> a
forall m a. Monoid m => (a -> m) -> QualConDecl a -> m
forall b a. (b -> a -> b) -> b -> QualConDecl a -> b
forall a b. (a -> b -> b) -> b -> QualConDecl a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall m. Monoid m => QualConDecl m -> m
fold :: forall m. Monoid m => QualConDecl m -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> QualConDecl a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> QualConDecl a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> QualConDecl a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> QualConDecl a -> m
$cfoldr :: forall a b. (a -> b -> b) -> b -> QualConDecl a -> b
foldr :: forall a b. (a -> b -> b) -> b -> QualConDecl a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> QualConDecl a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> QualConDecl a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> QualConDecl a -> b
foldl :: forall b a. (b -> a -> b) -> b -> QualConDecl a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> QualConDecl a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> QualConDecl a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> QualConDecl a -> a
foldr1 :: forall a. (a -> a -> a) -> QualConDecl a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> QualConDecl a -> a
foldl1 :: forall a. (a -> a -> a) -> QualConDecl a -> a
$ctoList :: forall a. QualConDecl a -> [a]
toList :: forall a. QualConDecl a -> [a]
$cnull :: forall a. QualConDecl a -> Bool
null :: forall a. QualConDecl a -> Bool
$clength :: forall a. QualConDecl a -> Int
length :: forall a. QualConDecl a -> Int
$celem :: forall a. Eq a => a -> QualConDecl a -> Bool
elem :: forall a. Eq a => a -> QualConDecl a -> Bool
$cmaximum :: forall a. Ord a => QualConDecl a -> a
maximum :: forall a. Ord a => QualConDecl a -> a
$cminimum :: forall a. Ord a => QualConDecl a -> a
minimum :: forall a. Ord a => QualConDecl a -> a
$csum :: forall a. Num a => QualConDecl a -> a
sum :: forall a. Num a => QualConDecl a -> a
$cproduct :: forall a. Num a => QualConDecl a -> a
product :: forall a. Num a => QualConDecl a -> a
Foldable,Functor QualConDecl
Foldable QualConDecl
(Functor QualConDecl, Foldable QualConDecl) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> QualConDecl a -> f (QualConDecl b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    QualConDecl (f a) -> f (QualConDecl a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> QualConDecl a -> m (QualConDecl b))
-> (forall (m :: * -> *) a.
    Monad m =>
    QualConDecl (m a) -> m (QualConDecl a))
-> Traversable QualConDecl
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a.
Monad m =>
QualConDecl (m a) -> m (QualConDecl a)
forall (f :: * -> *) a.
Applicative f =>
QualConDecl (f a) -> f (QualConDecl a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> QualConDecl a -> m (QualConDecl b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> QualConDecl a -> f (QualConDecl b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> QualConDecl a -> f (QualConDecl b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> QualConDecl a -> f (QualConDecl b)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
QualConDecl (f a) -> f (QualConDecl a)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
QualConDecl (f a) -> f (QualConDecl a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> QualConDecl a -> m (QualConDecl b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> QualConDecl a -> m (QualConDecl b)
$csequence :: forall (m :: * -> *) a.
Monad m =>
QualConDecl (m a) -> m (QualConDecl a)
sequence :: forall (m :: * -> *) a.
Monad m =>
QualConDecl (m a) -> m (QualConDecl a)
Traversable,(forall a b. (a -> b) -> QualConDecl a -> QualConDecl b)
-> (forall a b. a -> QualConDecl b -> QualConDecl a)
-> Functor QualConDecl
forall a b. a -> QualConDecl b -> QualConDecl a
forall a b. (a -> b) -> QualConDecl a -> QualConDecl b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> QualConDecl a -> QualConDecl b
fmap :: forall a b. (a -> b) -> QualConDecl a -> QualConDecl b
$c<$ :: forall a b. a -> QualConDecl b -> QualConDecl a
<$ :: forall a b. a -> QualConDecl b -> QualConDecl a
Functor,(forall x. QualConDecl l -> Rep (QualConDecl l) x)
-> (forall x. Rep (QualConDecl l) x -> QualConDecl l)
-> Generic (QualConDecl l)
forall x. Rep (QualConDecl l) x -> QualConDecl l
forall x. QualConDecl l -> Rep (QualConDecl l) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall l x. Rep (QualConDecl l) x -> QualConDecl l
forall l x. QualConDecl l -> Rep (QualConDecl l) x
$cfrom :: forall l x. QualConDecl l -> Rep (QualConDecl l) x
from :: forall x. QualConDecl l -> Rep (QualConDecl l) x
$cto :: forall l x. Rep (QualConDecl l) x -> QualConDecl l
to :: forall x. Rep (QualConDecl l) x -> QualConDecl l
Generic)

-- | Declaration of an ordinary data constructor.
data ConDecl l
     = ConDecl l (Name l) [Type l]
                -- ^ ordinary data constructor
     | InfixConDecl l (Type l) (Name l) (Type l)
                -- ^ infix data constructor
     | RecDecl l (Name l) [FieldDecl l]
                -- ^ record constructor
  deriving (ConDecl l -> ConDecl l -> Bool
(ConDecl l -> ConDecl l -> Bool)
-> (ConDecl l -> ConDecl l -> Bool) -> Eq (ConDecl l)
forall l. Eq l => ConDecl l -> ConDecl l -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall l. Eq l => ConDecl l -> ConDecl l -> Bool
== :: ConDecl l -> ConDecl l -> Bool
$c/= :: forall l. Eq l => ConDecl l -> ConDecl l -> Bool
/= :: ConDecl l -> ConDecl l -> Bool
Eq,Eq (ConDecl l)
Eq (ConDecl l) =>
(ConDecl l -> ConDecl l -> Ordering)
-> (ConDecl l -> ConDecl l -> Bool)
-> (ConDecl l -> ConDecl l -> Bool)
-> (ConDecl l -> ConDecl l -> Bool)
-> (ConDecl l -> ConDecl l -> Bool)
-> (ConDecl l -> ConDecl l -> ConDecl l)
-> (ConDecl l -> ConDecl l -> ConDecl l)
-> Ord (ConDecl l)
ConDecl l -> ConDecl l -> Bool
ConDecl l -> ConDecl l -> Ordering
ConDecl l -> ConDecl l -> ConDecl l
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall l. Ord l => Eq (ConDecl l)
forall l. Ord l => ConDecl l -> ConDecl l -> Bool
forall l. Ord l => ConDecl l -> ConDecl l -> Ordering
forall l. Ord l => ConDecl l -> ConDecl l -> ConDecl l
$ccompare :: forall l. Ord l => ConDecl l -> ConDecl l -> Ordering
compare :: ConDecl l -> ConDecl l -> Ordering
$c< :: forall l. Ord l => ConDecl l -> ConDecl l -> Bool
< :: ConDecl l -> ConDecl l -> Bool
$c<= :: forall l. Ord l => ConDecl l -> ConDecl l -> Bool
<= :: ConDecl l -> ConDecl l -> Bool
$c> :: forall l. Ord l => ConDecl l -> ConDecl l -> Bool
> :: ConDecl l -> ConDecl l -> Bool
$c>= :: forall l. Ord l => ConDecl l -> ConDecl l -> Bool
>= :: ConDecl l -> ConDecl l -> Bool
$cmax :: forall l. Ord l => ConDecl l -> ConDecl l -> ConDecl l
max :: ConDecl l -> ConDecl l -> ConDecl l
$cmin :: forall l. Ord l => ConDecl l -> ConDecl l -> ConDecl l
min :: ConDecl l -> ConDecl l -> ConDecl l
Ord,Int -> ConDecl l -> ShowS
[ConDecl l] -> ShowS
ConDecl l -> String
(Int -> ConDecl l -> ShowS)
-> (ConDecl l -> String)
-> ([ConDecl l] -> ShowS)
-> Show (ConDecl l)
forall l. Show l => Int -> ConDecl l -> ShowS
forall l. Show l => [ConDecl l] -> ShowS
forall l. Show l => ConDecl l -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall l. Show l => Int -> ConDecl l -> ShowS
showsPrec :: Int -> ConDecl l -> ShowS
$cshow :: forall l. Show l => ConDecl l -> String
show :: ConDecl l -> String
$cshowList :: forall l. Show l => [ConDecl l] -> ShowS
showList :: [ConDecl l] -> ShowS
Show,Typeable,Typeable (ConDecl l)
Typeable (ConDecl l) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> ConDecl l -> c (ConDecl l))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (ConDecl l))
-> (ConDecl l -> Constr)
-> (ConDecl l -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (ConDecl l)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (ConDecl l)))
-> ((forall b. Data b => b -> b) -> ConDecl l -> ConDecl l)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ConDecl l -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ConDecl l -> r)
-> (forall u. (forall d. Data d => d -> u) -> ConDecl l -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> ConDecl l -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ConDecl l -> m (ConDecl l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ConDecl l -> m (ConDecl l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ConDecl l -> m (ConDecl l))
-> Data (ConDecl l)
ConDecl l -> Constr
ConDecl l -> DataType
(forall b. Data b => b -> b) -> ConDecl l -> ConDecl l
forall l. Data l => Typeable (ConDecl l)
forall l. Data l => ConDecl l -> Constr
forall l. Data l => ConDecl l -> DataType
forall l.
Data l =>
(forall b. Data b => b -> b) -> ConDecl l -> ConDecl l
forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> ConDecl l -> u
forall l u.
Data l =>
(forall d. Data d => d -> u) -> ConDecl l -> [u]
forall l r r'.
Data l =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ConDecl l -> r
forall l r r'.
Data l =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ConDecl l -> r
forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d) -> ConDecl l -> m (ConDecl l)
forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> ConDecl l -> m (ConDecl l)
forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ConDecl l)
forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ConDecl l -> c (ConDecl l)
forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (ConDecl l))
forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ConDecl l))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> ConDecl l -> u
forall u. (forall d. Data d => d -> u) -> ConDecl l -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ConDecl l -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ConDecl l -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ConDecl l -> m (ConDecl l)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ConDecl l -> m (ConDecl l)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ConDecl l)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ConDecl l -> c (ConDecl l)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (ConDecl l))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ConDecl l))
$cgfoldl :: forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ConDecl l -> c (ConDecl l)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ConDecl l -> c (ConDecl l)
$cgunfold :: forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ConDecl l)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ConDecl l)
$ctoConstr :: forall l. Data l => ConDecl l -> Constr
toConstr :: ConDecl l -> Constr
$cdataTypeOf :: forall l. Data l => ConDecl l -> DataType
dataTypeOf :: ConDecl l -> DataType
$cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (ConDecl l))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (ConDecl l))
$cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ConDecl l))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ConDecl l))
$cgmapT :: forall l.
Data l =>
(forall b. Data b => b -> b) -> ConDecl l -> ConDecl l
gmapT :: (forall b. Data b => b -> b) -> ConDecl l -> ConDecl l
$cgmapQl :: forall l r r'.
Data l =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ConDecl l -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ConDecl l -> r
$cgmapQr :: forall l r r'.
Data l =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ConDecl l -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ConDecl l -> r
$cgmapQ :: forall l u.
Data l =>
(forall d. Data d => d -> u) -> ConDecl l -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> ConDecl l -> [u]
$cgmapQi :: forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> ConDecl l -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ConDecl l -> u
$cgmapM :: forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d) -> ConDecl l -> m (ConDecl l)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ConDecl l -> m (ConDecl l)
$cgmapMp :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> ConDecl l -> m (ConDecl l)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ConDecl l -> m (ConDecl l)
$cgmapMo :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> ConDecl l -> m (ConDecl l)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ConDecl l -> m (ConDecl l)
Data,(forall m. Monoid m => ConDecl m -> m)
-> (forall m a. Monoid m => (a -> m) -> ConDecl a -> m)
-> (forall m a. Monoid m => (a -> m) -> ConDecl a -> m)
-> (forall a b. (a -> b -> b) -> b -> ConDecl a -> b)
-> (forall a b. (a -> b -> b) -> b -> ConDecl a -> b)
-> (forall b a. (b -> a -> b) -> b -> ConDecl a -> b)
-> (forall b a. (b -> a -> b) -> b -> ConDecl a -> b)
-> (forall a. (a -> a -> a) -> ConDecl a -> a)
-> (forall a. (a -> a -> a) -> ConDecl a -> a)
-> (forall a. ConDecl a -> [a])
-> (forall a. ConDecl a -> Bool)
-> (forall a. ConDecl a -> Int)
-> (forall a. Eq a => a -> ConDecl a -> Bool)
-> (forall a. Ord a => ConDecl a -> a)
-> (forall a. Ord a => ConDecl a -> a)
-> (forall a. Num a => ConDecl a -> a)
-> (forall a. Num a => ConDecl a -> a)
-> Foldable ConDecl
forall a. Eq a => a -> ConDecl a -> Bool
forall a. Num a => ConDecl a -> a
forall a. Ord a => ConDecl a -> a
forall m. Monoid m => ConDecl m -> m
forall a. ConDecl a -> Bool
forall a. ConDecl a -> Int
forall a. ConDecl a -> [a]
forall a. (a -> a -> a) -> ConDecl a -> a
forall m a. Monoid m => (a -> m) -> ConDecl a -> m
forall b a. (b -> a -> b) -> b -> ConDecl a -> b
forall a b. (a -> b -> b) -> b -> ConDecl a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall m. Monoid m => ConDecl m -> m
fold :: forall m. Monoid m => ConDecl m -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> ConDecl a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> ConDecl a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> ConDecl a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> ConDecl a -> m
$cfoldr :: forall a b. (a -> b -> b) -> b -> ConDecl a -> b
foldr :: forall a b. (a -> b -> b) -> b -> ConDecl a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> ConDecl a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> ConDecl a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> ConDecl a -> b
foldl :: forall b a. (b -> a -> b) -> b -> ConDecl a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> ConDecl a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> ConDecl a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> ConDecl a -> a
foldr1 :: forall a. (a -> a -> a) -> ConDecl a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> ConDecl a -> a
foldl1 :: forall a. (a -> a -> a) -> ConDecl a -> a
$ctoList :: forall a. ConDecl a -> [a]
toList :: forall a. ConDecl a -> [a]
$cnull :: forall a. ConDecl a -> Bool
null :: forall a. ConDecl a -> Bool
$clength :: forall a. ConDecl a -> Int
length :: forall a. ConDecl a -> Int
$celem :: forall a. Eq a => a -> ConDecl a -> Bool
elem :: forall a. Eq a => a -> ConDecl a -> Bool
$cmaximum :: forall a. Ord a => ConDecl a -> a
maximum :: forall a. Ord a => ConDecl a -> a
$cminimum :: forall a. Ord a => ConDecl a -> a
minimum :: forall a. Ord a => ConDecl a -> a
$csum :: forall a. Num a => ConDecl a -> a
sum :: forall a. Num a => ConDecl a -> a
$cproduct :: forall a. Num a => ConDecl a -> a
product :: forall a. Num a => ConDecl a -> a
Foldable,Functor ConDecl
Foldable ConDecl
(Functor ConDecl, Foldable ConDecl) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> ConDecl a -> f (ConDecl b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    ConDecl (f a) -> f (ConDecl a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> ConDecl a -> m (ConDecl b))
-> (forall (m :: * -> *) a.
    Monad m =>
    ConDecl (m a) -> m (ConDecl a))
-> Traversable ConDecl
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a. Monad m => ConDecl (m a) -> m (ConDecl a)
forall (f :: * -> *) a.
Applicative f =>
ConDecl (f a) -> f (ConDecl a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> ConDecl a -> m (ConDecl b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> ConDecl a -> f (ConDecl b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> ConDecl a -> f (ConDecl b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> ConDecl a -> f (ConDecl b)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
ConDecl (f a) -> f (ConDecl a)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
ConDecl (f a) -> f (ConDecl a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> ConDecl a -> m (ConDecl b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> ConDecl a -> m (ConDecl b)
$csequence :: forall (m :: * -> *) a. Monad m => ConDecl (m a) -> m (ConDecl a)
sequence :: forall (m :: * -> *) a. Monad m => ConDecl (m a) -> m (ConDecl a)
Traversable,(forall a b. (a -> b) -> ConDecl a -> ConDecl b)
-> (forall a b. a -> ConDecl b -> ConDecl a) -> Functor ConDecl
forall a b. a -> ConDecl b -> ConDecl a
forall a b. (a -> b) -> ConDecl a -> ConDecl b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> ConDecl a -> ConDecl b
fmap :: forall a b. (a -> b) -> ConDecl a -> ConDecl b
$c<$ :: forall a b. a -> ConDecl b -> ConDecl a
<$ :: forall a b. a -> ConDecl b -> ConDecl a
Functor,(forall x. ConDecl l -> Rep (ConDecl l) x)
-> (forall x. Rep (ConDecl l) x -> ConDecl l)
-> Generic (ConDecl l)
forall x. Rep (ConDecl l) x -> ConDecl l
forall x. ConDecl l -> Rep (ConDecl l) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall l x. Rep (ConDecl l) x -> ConDecl l
forall l x. ConDecl l -> Rep (ConDecl l) x
$cfrom :: forall l x. ConDecl l -> Rep (ConDecl l) x
from :: forall x. ConDecl l -> Rep (ConDecl l) x
$cto :: forall l x. Rep (ConDecl l) x -> ConDecl l
to :: forall x. Rep (ConDecl l) x -> ConDecl l
Generic)

-- | Declaration of a (list of) named field(s).
data FieldDecl l = FieldDecl l [Name l] (Type l)
  deriving (FieldDecl l -> FieldDecl l -> Bool
(FieldDecl l -> FieldDecl l -> Bool)
-> (FieldDecl l -> FieldDecl l -> Bool) -> Eq (FieldDecl l)
forall l. Eq l => FieldDecl l -> FieldDecl l -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall l. Eq l => FieldDecl l -> FieldDecl l -> Bool
== :: FieldDecl l -> FieldDecl l -> Bool
$c/= :: forall l. Eq l => FieldDecl l -> FieldDecl l -> Bool
/= :: FieldDecl l -> FieldDecl l -> Bool
Eq,Eq (FieldDecl l)
Eq (FieldDecl l) =>
(FieldDecl l -> FieldDecl l -> Ordering)
-> (FieldDecl l -> FieldDecl l -> Bool)
-> (FieldDecl l -> FieldDecl l -> Bool)
-> (FieldDecl l -> FieldDecl l -> Bool)
-> (FieldDecl l -> FieldDecl l -> Bool)
-> (FieldDecl l -> FieldDecl l -> FieldDecl l)
-> (FieldDecl l -> FieldDecl l -> FieldDecl l)
-> Ord (FieldDecl l)
FieldDecl l -> FieldDecl l -> Bool
FieldDecl l -> FieldDecl l -> Ordering
FieldDecl l -> FieldDecl l -> FieldDecl l
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall l. Ord l => Eq (FieldDecl l)
forall l. Ord l => FieldDecl l -> FieldDecl l -> Bool
forall l. Ord l => FieldDecl l -> FieldDecl l -> Ordering
forall l. Ord l => FieldDecl l -> FieldDecl l -> FieldDecl l
$ccompare :: forall l. Ord l => FieldDecl l -> FieldDecl l -> Ordering
compare :: FieldDecl l -> FieldDecl l -> Ordering
$c< :: forall l. Ord l => FieldDecl l -> FieldDecl l -> Bool
< :: FieldDecl l -> FieldDecl l -> Bool
$c<= :: forall l. Ord l => FieldDecl l -> FieldDecl l -> Bool
<= :: FieldDecl l -> FieldDecl l -> Bool
$c> :: forall l. Ord l => FieldDecl l -> FieldDecl l -> Bool
> :: FieldDecl l -> FieldDecl l -> Bool
$c>= :: forall l. Ord l => FieldDecl l -> FieldDecl l -> Bool
>= :: FieldDecl l -> FieldDecl l -> Bool
$cmax :: forall l. Ord l => FieldDecl l -> FieldDecl l -> FieldDecl l
max :: FieldDecl l -> FieldDecl l -> FieldDecl l
$cmin :: forall l. Ord l => FieldDecl l -> FieldDecl l -> FieldDecl l
min :: FieldDecl l -> FieldDecl l -> FieldDecl l
Ord,Int -> FieldDecl l -> ShowS
[FieldDecl l] -> ShowS
FieldDecl l -> String
(Int -> FieldDecl l -> ShowS)
-> (FieldDecl l -> String)
-> ([FieldDecl l] -> ShowS)
-> Show (FieldDecl l)
forall l. Show l => Int -> FieldDecl l -> ShowS
forall l. Show l => [FieldDecl l] -> ShowS
forall l. Show l => FieldDecl l -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall l. Show l => Int -> FieldDecl l -> ShowS
showsPrec :: Int -> FieldDecl l -> ShowS
$cshow :: forall l. Show l => FieldDecl l -> String
show :: FieldDecl l -> String
$cshowList :: forall l. Show l => [FieldDecl l] -> ShowS
showList :: [FieldDecl l] -> ShowS
Show,Typeable,Typeable (FieldDecl l)
Typeable (FieldDecl l) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> FieldDecl l -> c (FieldDecl l))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (FieldDecl l))
-> (FieldDecl l -> Constr)
-> (FieldDecl l -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (FieldDecl l)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (FieldDecl l)))
-> ((forall b. Data b => b -> b) -> FieldDecl l -> FieldDecl l)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> FieldDecl l -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> FieldDecl l -> r)
-> (forall u. (forall d. Data d => d -> u) -> FieldDecl l -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> FieldDecl l -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> FieldDecl l -> m (FieldDecl l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> FieldDecl l -> m (FieldDecl l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> FieldDecl l -> m (FieldDecl l))
-> Data (FieldDecl l)
FieldDecl l -> Constr
FieldDecl l -> DataType
(forall b. Data b => b -> b) -> FieldDecl l -> FieldDecl l
forall l. Data l => Typeable (FieldDecl l)
forall l. Data l => FieldDecl l -> Constr
forall l. Data l => FieldDecl l -> DataType
forall l.
Data l =>
(forall b. Data b => b -> b) -> FieldDecl l -> FieldDecl l
forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> FieldDecl l -> u
forall l u.
Data l =>
(forall d. Data d => d -> u) -> FieldDecl l -> [u]
forall l r r'.
Data l =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FieldDecl l -> r
forall l r r'.
Data l =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FieldDecl l -> r
forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d) -> FieldDecl l -> m (FieldDecl l)
forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> FieldDecl l -> m (FieldDecl l)
forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (FieldDecl l)
forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FieldDecl l -> c (FieldDecl l)
forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (FieldDecl l))
forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (FieldDecl l))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> FieldDecl l -> u
forall u. (forall d. Data d => d -> u) -> FieldDecl l -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FieldDecl l -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FieldDecl l -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> FieldDecl l -> m (FieldDecl l)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FieldDecl l -> m (FieldDecl l)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (FieldDecl l)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FieldDecl l -> c (FieldDecl l)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (FieldDecl l))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (FieldDecl l))
$cgfoldl :: forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FieldDecl l -> c (FieldDecl l)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FieldDecl l -> c (FieldDecl l)
$cgunfold :: forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (FieldDecl l)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (FieldDecl l)
$ctoConstr :: forall l. Data l => FieldDecl l -> Constr
toConstr :: FieldDecl l -> Constr
$cdataTypeOf :: forall l. Data l => FieldDecl l -> DataType
dataTypeOf :: FieldDecl l -> DataType
$cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (FieldDecl l))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (FieldDecl l))
$cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (FieldDecl l))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (FieldDecl l))
$cgmapT :: forall l.
Data l =>
(forall b. Data b => b -> b) -> FieldDecl l -> FieldDecl l
gmapT :: (forall b. Data b => b -> b) -> FieldDecl l -> FieldDecl l
$cgmapQl :: forall l r r'.
Data l =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FieldDecl l -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FieldDecl l -> r
$cgmapQr :: forall l r r'.
Data l =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FieldDecl l -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FieldDecl l -> r
$cgmapQ :: forall l u.
Data l =>
(forall d. Data d => d -> u) -> FieldDecl l -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> FieldDecl l -> [u]
$cgmapQi :: forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> FieldDecl l -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> FieldDecl l -> u
$cgmapM :: forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d) -> FieldDecl l -> m (FieldDecl l)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> FieldDecl l -> m (FieldDecl l)
$cgmapMp :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> FieldDecl l -> m (FieldDecl l)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FieldDecl l -> m (FieldDecl l)
$cgmapMo :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> FieldDecl l -> m (FieldDecl l)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FieldDecl l -> m (FieldDecl l)
Data,(forall m. Monoid m => FieldDecl m -> m)
-> (forall m a. Monoid m => (a -> m) -> FieldDecl a -> m)
-> (forall m a. Monoid m => (a -> m) -> FieldDecl a -> m)
-> (forall a b. (a -> b -> b) -> b -> FieldDecl a -> b)
-> (forall a b. (a -> b -> b) -> b -> FieldDecl a -> b)
-> (forall b a. (b -> a -> b) -> b -> FieldDecl a -> b)
-> (forall b a. (b -> a -> b) -> b -> FieldDecl a -> b)
-> (forall a. (a -> a -> a) -> FieldDecl a -> a)
-> (forall a. (a -> a -> a) -> FieldDecl a -> a)
-> (forall a. FieldDecl a -> [a])
-> (forall a. FieldDecl a -> Bool)
-> (forall a. FieldDecl a -> Int)
-> (forall a. Eq a => a -> FieldDecl a -> Bool)
-> (forall a. Ord a => FieldDecl a -> a)
-> (forall a. Ord a => FieldDecl a -> a)
-> (forall a. Num a => FieldDecl a -> a)
-> (forall a. Num a => FieldDecl a -> a)
-> Foldable FieldDecl
forall a. Eq a => a -> FieldDecl a -> Bool
forall a. Num a => FieldDecl a -> a
forall a. Ord a => FieldDecl a -> a
forall m. Monoid m => FieldDecl m -> m
forall a. FieldDecl a -> Bool
forall a. FieldDecl a -> Int
forall a. FieldDecl a -> [a]
forall a. (a -> a -> a) -> FieldDecl a -> a
forall m a. Monoid m => (a -> m) -> FieldDecl a -> m
forall b a. (b -> a -> b) -> b -> FieldDecl a -> b
forall a b. (a -> b -> b) -> b -> FieldDecl a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall m. Monoid m => FieldDecl m -> m
fold :: forall m. Monoid m => FieldDecl m -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> FieldDecl a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> FieldDecl a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> FieldDecl a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> FieldDecl a -> m
$cfoldr :: forall a b. (a -> b -> b) -> b -> FieldDecl a -> b
foldr :: forall a b. (a -> b -> b) -> b -> FieldDecl a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> FieldDecl a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> FieldDecl a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> FieldDecl a -> b
foldl :: forall b a. (b -> a -> b) -> b -> FieldDecl a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> FieldDecl a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> FieldDecl a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> FieldDecl a -> a
foldr1 :: forall a. (a -> a -> a) -> FieldDecl a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> FieldDecl a -> a
foldl1 :: forall a. (a -> a -> a) -> FieldDecl a -> a
$ctoList :: forall a. FieldDecl a -> [a]
toList :: forall a. FieldDecl a -> [a]
$cnull :: forall a. FieldDecl a -> Bool
null :: forall a. FieldDecl a -> Bool
$clength :: forall a. FieldDecl a -> Int
length :: forall a. FieldDecl a -> Int
$celem :: forall a. Eq a => a -> FieldDecl a -> Bool
elem :: forall a. Eq a => a -> FieldDecl a -> Bool
$cmaximum :: forall a. Ord a => FieldDecl a -> a
maximum :: forall a. Ord a => FieldDecl a -> a
$cminimum :: forall a. Ord a => FieldDecl a -> a
minimum :: forall a. Ord a => FieldDecl a -> a
$csum :: forall a. Num a => FieldDecl a -> a
sum :: forall a. Num a => FieldDecl a -> a
$cproduct :: forall a. Num a => FieldDecl a -> a
product :: forall a. Num a => FieldDecl a -> a
Foldable,Functor FieldDecl
Foldable FieldDecl
(Functor FieldDecl, Foldable FieldDecl) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> FieldDecl a -> f (FieldDecl b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    FieldDecl (f a) -> f (FieldDecl a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> FieldDecl a -> m (FieldDecl b))
-> (forall (m :: * -> *) a.
    Monad m =>
    FieldDecl (m a) -> m (FieldDecl a))
-> Traversable FieldDecl
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a.
Monad m =>
FieldDecl (m a) -> m (FieldDecl a)
forall (f :: * -> *) a.
Applicative f =>
FieldDecl (f a) -> f (FieldDecl a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> FieldDecl a -> m (FieldDecl b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> FieldDecl a -> f (FieldDecl b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> FieldDecl a -> f (FieldDecl b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> FieldDecl a -> f (FieldDecl b)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
FieldDecl (f a) -> f (FieldDecl a)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
FieldDecl (f a) -> f (FieldDecl a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> FieldDecl a -> m (FieldDecl b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> FieldDecl a -> m (FieldDecl b)
$csequence :: forall (m :: * -> *) a.
Monad m =>
FieldDecl (m a) -> m (FieldDecl a)
sequence :: forall (m :: * -> *) a.
Monad m =>
FieldDecl (m a) -> m (FieldDecl a)
Traversable,(forall a b. (a -> b) -> FieldDecl a -> FieldDecl b)
-> (forall a b. a -> FieldDecl b -> FieldDecl a)
-> Functor FieldDecl
forall a b. a -> FieldDecl b -> FieldDecl a
forall a b. (a -> b) -> FieldDecl a -> FieldDecl b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> FieldDecl a -> FieldDecl b
fmap :: forall a b. (a -> b) -> FieldDecl a -> FieldDecl b
$c<$ :: forall a b. a -> FieldDecl b -> FieldDecl a
<$ :: forall a b. a -> FieldDecl b -> FieldDecl a
Functor,(forall x. FieldDecl l -> Rep (FieldDecl l) x)
-> (forall x. Rep (FieldDecl l) x -> FieldDecl l)
-> Generic (FieldDecl l)
forall x. Rep (FieldDecl l) x -> FieldDecl l
forall x. FieldDecl l -> Rep (FieldDecl l) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall l x. Rep (FieldDecl l) x -> FieldDecl l
forall l x. FieldDecl l -> Rep (FieldDecl l) x
$cfrom :: forall l x. FieldDecl l -> Rep (FieldDecl l) x
from :: forall x. FieldDecl l -> Rep (FieldDecl l) x
$cto :: forall l x. Rep (FieldDecl l) x -> FieldDecl l
to :: forall x. Rep (FieldDecl l) x -> FieldDecl l
Generic)


-- | A single constructor declaration in a GADT data type declaration.
--
-- If the GADT is declared using the record syntax, e.g.
--
-- >data Ty where
-- >  TCon :: { field1 :: Int, field2 :: Bool } -> Ty
--
-- then the fields are stored as a list of 'FieldDecl's, and the final type
-- (@Ty@ in the above example) is stored in the last 'Type' field.
--
-- If the GADT is declared using the ordinary syntax, e.g.
--
-- >data Ty where
-- >  TCon :: Int -> Bool -> Ty
--
-- then @'Maybe' ['FieldDecl' l]@ is 'Nothing', and the whole constructor's
-- type (such as @Int -> Bool -> Ty@) is stored in the last 'Type' field.
data GadtDecl l
    = GadtDecl l (Name l)
        {-forall-} (Maybe [TyVarBind l]) {- . -} (Maybe (Context l))
        {- => -} (Maybe [FieldDecl l]) (Type l)
  deriving (GadtDecl l -> GadtDecl l -> Bool
(GadtDecl l -> GadtDecl l -> Bool)
-> (GadtDecl l -> GadtDecl l -> Bool) -> Eq (GadtDecl l)
forall l. Eq l => GadtDecl l -> GadtDecl l -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall l. Eq l => GadtDecl l -> GadtDecl l -> Bool
== :: GadtDecl l -> GadtDecl l -> Bool
$c/= :: forall l. Eq l => GadtDecl l -> GadtDecl l -> Bool
/= :: GadtDecl l -> GadtDecl l -> Bool
Eq,Eq (GadtDecl l)
Eq (GadtDecl l) =>
(GadtDecl l -> GadtDecl l -> Ordering)
-> (GadtDecl l -> GadtDecl l -> Bool)
-> (GadtDecl l -> GadtDecl l -> Bool)
-> (GadtDecl l -> GadtDecl l -> Bool)
-> (GadtDecl l -> GadtDecl l -> Bool)
-> (GadtDecl l -> GadtDecl l -> GadtDecl l)
-> (GadtDecl l -> GadtDecl l -> GadtDecl l)
-> Ord (GadtDecl l)
GadtDecl l -> GadtDecl l -> Bool
GadtDecl l -> GadtDecl l -> Ordering
GadtDecl l -> GadtDecl l -> GadtDecl l
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall l. Ord l => Eq (GadtDecl l)
forall l. Ord l => GadtDecl l -> GadtDecl l -> Bool
forall l. Ord l => GadtDecl l -> GadtDecl l -> Ordering
forall l. Ord l => GadtDecl l -> GadtDecl l -> GadtDecl l
$ccompare :: forall l. Ord l => GadtDecl l -> GadtDecl l -> Ordering
compare :: GadtDecl l -> GadtDecl l -> Ordering
$c< :: forall l. Ord l => GadtDecl l -> GadtDecl l -> Bool
< :: GadtDecl l -> GadtDecl l -> Bool
$c<= :: forall l. Ord l => GadtDecl l -> GadtDecl l -> Bool
<= :: GadtDecl l -> GadtDecl l -> Bool
$c> :: forall l. Ord l => GadtDecl l -> GadtDecl l -> Bool
> :: GadtDecl l -> GadtDecl l -> Bool
$c>= :: forall l. Ord l => GadtDecl l -> GadtDecl l -> Bool
>= :: GadtDecl l -> GadtDecl l -> Bool
$cmax :: forall l. Ord l => GadtDecl l -> GadtDecl l -> GadtDecl l
max :: GadtDecl l -> GadtDecl l -> GadtDecl l
$cmin :: forall l. Ord l => GadtDecl l -> GadtDecl l -> GadtDecl l
min :: GadtDecl l -> GadtDecl l -> GadtDecl l
Ord,Int -> GadtDecl l -> ShowS
[GadtDecl l] -> ShowS
GadtDecl l -> String
(Int -> GadtDecl l -> ShowS)
-> (GadtDecl l -> String)
-> ([GadtDecl l] -> ShowS)
-> Show (GadtDecl l)
forall l. Show l => Int -> GadtDecl l -> ShowS
forall l. Show l => [GadtDecl l] -> ShowS
forall l. Show l => GadtDecl l -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall l. Show l => Int -> GadtDecl l -> ShowS
showsPrec :: Int -> GadtDecl l -> ShowS
$cshow :: forall l. Show l => GadtDecl l -> String
show :: GadtDecl l -> String
$cshowList :: forall l. Show l => [GadtDecl l] -> ShowS
showList :: [GadtDecl l] -> ShowS
Show,Typeable,Typeable (GadtDecl l)
Typeable (GadtDecl l) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> GadtDecl l -> c (GadtDecl l))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (GadtDecl l))
-> (GadtDecl l -> Constr)
-> (GadtDecl l -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (GadtDecl l)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (GadtDecl l)))
-> ((forall b. Data b => b -> b) -> GadtDecl l -> GadtDecl l)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> GadtDecl l -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> GadtDecl l -> r)
-> (forall u. (forall d. Data d => d -> u) -> GadtDecl l -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> GadtDecl l -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> GadtDecl l -> m (GadtDecl l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> GadtDecl l -> m (GadtDecl l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> GadtDecl l -> m (GadtDecl l))
-> Data (GadtDecl l)
GadtDecl l -> Constr
GadtDecl l -> DataType
(forall b. Data b => b -> b) -> GadtDecl l -> GadtDecl l
forall l. Data l => Typeable (GadtDecl l)
forall l. Data l => GadtDecl l -> Constr
forall l. Data l => GadtDecl l -> DataType
forall l.
Data l =>
(forall b. Data b => b -> b) -> GadtDecl l -> GadtDecl l
forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> GadtDecl l -> u
forall l u.
Data l =>
(forall d. Data d => d -> u) -> GadtDecl l -> [u]
forall l r r'.
Data l =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> GadtDecl l -> r
forall l r r'.
Data l =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> GadtDecl l -> r
forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d) -> GadtDecl l -> m (GadtDecl l)
forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> GadtDecl l -> m (GadtDecl l)
forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (GadtDecl l)
forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> GadtDecl l -> c (GadtDecl l)
forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (GadtDecl l))
forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (GadtDecl l))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> GadtDecl l -> u
forall u. (forall d. Data d => d -> u) -> GadtDecl l -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> GadtDecl l -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> GadtDecl l -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> GadtDecl l -> m (GadtDecl l)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> GadtDecl l -> m (GadtDecl l)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (GadtDecl l)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> GadtDecl l -> c (GadtDecl l)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (GadtDecl l))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (GadtDecl l))
$cgfoldl :: forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> GadtDecl l -> c (GadtDecl l)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> GadtDecl l -> c (GadtDecl l)
$cgunfold :: forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (GadtDecl l)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (GadtDecl l)
$ctoConstr :: forall l. Data l => GadtDecl l -> Constr
toConstr :: GadtDecl l -> Constr
$cdataTypeOf :: forall l. Data l => GadtDecl l -> DataType
dataTypeOf :: GadtDecl l -> DataType
$cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (GadtDecl l))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (GadtDecl l))
$cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (GadtDecl l))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (GadtDecl l))
$cgmapT :: forall l.
Data l =>
(forall b. Data b => b -> b) -> GadtDecl l -> GadtDecl l
gmapT :: (forall b. Data b => b -> b) -> GadtDecl l -> GadtDecl l
$cgmapQl :: forall l r r'.
Data l =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> GadtDecl l -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> GadtDecl l -> r
$cgmapQr :: forall l r r'.
Data l =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> GadtDecl l -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> GadtDecl l -> r
$cgmapQ :: forall l u.
Data l =>
(forall d. Data d => d -> u) -> GadtDecl l -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> GadtDecl l -> [u]
$cgmapQi :: forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> GadtDecl l -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> GadtDecl l -> u
$cgmapM :: forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d) -> GadtDecl l -> m (GadtDecl l)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> GadtDecl l -> m (GadtDecl l)
$cgmapMp :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> GadtDecl l -> m (GadtDecl l)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> GadtDecl l -> m (GadtDecl l)
$cgmapMo :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> GadtDecl l -> m (GadtDecl l)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> GadtDecl l -> m (GadtDecl l)
Data,(forall m. Monoid m => GadtDecl m -> m)
-> (forall m a. Monoid m => (a -> m) -> GadtDecl a -> m)
-> (forall m a. Monoid m => (a -> m) -> GadtDecl a -> m)
-> (forall a b. (a -> b -> b) -> b -> GadtDecl a -> b)
-> (forall a b. (a -> b -> b) -> b -> GadtDecl a -> b)
-> (forall b a. (b -> a -> b) -> b -> GadtDecl a -> b)
-> (forall b a. (b -> a -> b) -> b -> GadtDecl a -> b)
-> (forall a. (a -> a -> a) -> GadtDecl a -> a)
-> (forall a. (a -> a -> a) -> GadtDecl a -> a)
-> (forall a. GadtDecl a -> [a])
-> (forall a. GadtDecl a -> Bool)
-> (forall a. GadtDecl a -> Int)
-> (forall a. Eq a => a -> GadtDecl a -> Bool)
-> (forall a. Ord a => GadtDecl a -> a)
-> (forall a. Ord a => GadtDecl a -> a)
-> (forall a. Num a => GadtDecl a -> a)
-> (forall a. Num a => GadtDecl a -> a)
-> Foldable GadtDecl
forall a. Eq a => a -> GadtDecl a -> Bool
forall a. Num a => GadtDecl a -> a
forall a. Ord a => GadtDecl a -> a
forall m. Monoid m => GadtDecl m -> m
forall a. GadtDecl a -> Bool
forall a. GadtDecl a -> Int
forall a. GadtDecl a -> [a]
forall a. (a -> a -> a) -> GadtDecl a -> a
forall m a. Monoid m => (a -> m) -> GadtDecl a -> m
forall b a. (b -> a -> b) -> b -> GadtDecl a -> b
forall a b. (a -> b -> b) -> b -> GadtDecl a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall m. Monoid m => GadtDecl m -> m
fold :: forall m. Monoid m => GadtDecl m -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> GadtDecl a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> GadtDecl a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> GadtDecl a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> GadtDecl a -> m
$cfoldr :: forall a b. (a -> b -> b) -> b -> GadtDecl a -> b
foldr :: forall a b. (a -> b -> b) -> b -> GadtDecl a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> GadtDecl a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> GadtDecl a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> GadtDecl a -> b
foldl :: forall b a. (b -> a -> b) -> b -> GadtDecl a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> GadtDecl a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> GadtDecl a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> GadtDecl a -> a
foldr1 :: forall a. (a -> a -> a) -> GadtDecl a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> GadtDecl a -> a
foldl1 :: forall a. (a -> a -> a) -> GadtDecl a -> a
$ctoList :: forall a. GadtDecl a -> [a]
toList :: forall a. GadtDecl a -> [a]
$cnull :: forall a. GadtDecl a -> Bool
null :: forall a. GadtDecl a -> Bool
$clength :: forall a. GadtDecl a -> Int
length :: forall a. GadtDecl a -> Int
$celem :: forall a. Eq a => a -> GadtDecl a -> Bool
elem :: forall a. Eq a => a -> GadtDecl a -> Bool
$cmaximum :: forall a. Ord a => GadtDecl a -> a
maximum :: forall a. Ord a => GadtDecl a -> a
$cminimum :: forall a. Ord a => GadtDecl a -> a
minimum :: forall a. Ord a => GadtDecl a -> a
$csum :: forall a. Num a => GadtDecl a -> a
sum :: forall a. Num a => GadtDecl a -> a
$cproduct :: forall a. Num a => GadtDecl a -> a
product :: forall a. Num a => GadtDecl a -> a
Foldable,Functor GadtDecl
Foldable GadtDecl
(Functor GadtDecl, Foldable GadtDecl) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> GadtDecl a -> f (GadtDecl b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    GadtDecl (f a) -> f (GadtDecl a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> GadtDecl a -> m (GadtDecl b))
-> (forall (m :: * -> *) a.
    Monad m =>
    GadtDecl (m a) -> m (GadtDecl a))
-> Traversable GadtDecl
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a. Monad m => GadtDecl (m a) -> m (GadtDecl a)
forall (f :: * -> *) a.
Applicative f =>
GadtDecl (f a) -> f (GadtDecl a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> GadtDecl a -> m (GadtDecl b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> GadtDecl a -> f (GadtDecl b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> GadtDecl a -> f (GadtDecl b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> GadtDecl a -> f (GadtDecl b)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
GadtDecl (f a) -> f (GadtDecl a)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
GadtDecl (f a) -> f (GadtDecl a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> GadtDecl a -> m (GadtDecl b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> GadtDecl a -> m (GadtDecl b)
$csequence :: forall (m :: * -> *) a. Monad m => GadtDecl (m a) -> m (GadtDecl a)
sequence :: forall (m :: * -> *) a. Monad m => GadtDecl (m a) -> m (GadtDecl a)
Traversable,(forall a b. (a -> b) -> GadtDecl a -> GadtDecl b)
-> (forall a b. a -> GadtDecl b -> GadtDecl a) -> Functor GadtDecl
forall a b. a -> GadtDecl b -> GadtDecl a
forall a b. (a -> b) -> GadtDecl a -> GadtDecl b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> GadtDecl a -> GadtDecl b
fmap :: forall a b. (a -> b) -> GadtDecl a -> GadtDecl b
$c<$ :: forall a b. a -> GadtDecl b -> GadtDecl a
<$ :: forall a b. a -> GadtDecl b -> GadtDecl a
Functor,(forall x. GadtDecl l -> Rep (GadtDecl l) x)
-> (forall x. Rep (GadtDecl l) x -> GadtDecl l)
-> Generic (GadtDecl l)
forall x. Rep (GadtDecl l) x -> GadtDecl l
forall x. GadtDecl l -> Rep (GadtDecl l) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall l x. Rep (GadtDecl l) x -> GadtDecl l
forall l x. GadtDecl l -> Rep (GadtDecl l) x
$cfrom :: forall l x. GadtDecl l -> Rep (GadtDecl l) x
from :: forall x. GadtDecl l -> Rep (GadtDecl l) x
$cto :: forall l x. Rep (GadtDecl l) x -> GadtDecl l
to :: forall x. Rep (GadtDecl l) x -> GadtDecl l
Generic)

-- | Declarations inside a class declaration.
data ClassDecl l
    = ClsDecl    l (Decl l)
            -- ^ ordinary declaration
    | ClsDataFam l (Maybe (Context l)) (DeclHead l) (Maybe (ResultSig l))
            -- ^ declaration of an associated data type
    | ClsTyFam   l                     (DeclHead l) (Maybe (ResultSig l)) (Maybe (InjectivityInfo l))
            -- ^ declaration of an associated type synonym
    | ClsTyDef   l (TypeEqn l)
            -- ^ default choice for an associated type synonym
    | ClsDefSig  l (Name l) (Type l)
            -- ^ default signature
  deriving (ClassDecl l -> ClassDecl l -> Bool
(ClassDecl l -> ClassDecl l -> Bool)
-> (ClassDecl l -> ClassDecl l -> Bool) -> Eq (ClassDecl l)
forall l. Eq l => ClassDecl l -> ClassDecl l -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall l. Eq l => ClassDecl l -> ClassDecl l -> Bool
== :: ClassDecl l -> ClassDecl l -> Bool
$c/= :: forall l. Eq l => ClassDecl l -> ClassDecl l -> Bool
/= :: ClassDecl l -> ClassDecl l -> Bool
Eq,Eq (ClassDecl l)
Eq (ClassDecl l) =>
(ClassDecl l -> ClassDecl l -> Ordering)
-> (ClassDecl l -> ClassDecl l -> Bool)
-> (ClassDecl l -> ClassDecl l -> Bool)
-> (ClassDecl l -> ClassDecl l -> Bool)
-> (ClassDecl l -> ClassDecl l -> Bool)
-> (ClassDecl l -> ClassDecl l -> ClassDecl l)
-> (ClassDecl l -> ClassDecl l -> ClassDecl l)
-> Ord (ClassDecl l)
ClassDecl l -> ClassDecl l -> Bool
ClassDecl l -> ClassDecl l -> Ordering
ClassDecl l -> ClassDecl l -> ClassDecl l
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall l. Ord l => Eq (ClassDecl l)
forall l. Ord l => ClassDecl l -> ClassDecl l -> Bool
forall l. Ord l => ClassDecl l -> ClassDecl l -> Ordering
forall l. Ord l => ClassDecl l -> ClassDecl l -> ClassDecl l
$ccompare :: forall l. Ord l => ClassDecl l -> ClassDecl l -> Ordering
compare :: ClassDecl l -> ClassDecl l -> Ordering
$c< :: forall l. Ord l => ClassDecl l -> ClassDecl l -> Bool
< :: ClassDecl l -> ClassDecl l -> Bool
$c<= :: forall l. Ord l => ClassDecl l -> ClassDecl l -> Bool
<= :: ClassDecl l -> ClassDecl l -> Bool
$c> :: forall l. Ord l => ClassDecl l -> ClassDecl l -> Bool
> :: ClassDecl l -> ClassDecl l -> Bool
$c>= :: forall l. Ord l => ClassDecl l -> ClassDecl l -> Bool
>= :: ClassDecl l -> ClassDecl l -> Bool
$cmax :: forall l. Ord l => ClassDecl l -> ClassDecl l -> ClassDecl l
max :: ClassDecl l -> ClassDecl l -> ClassDecl l
$cmin :: forall l. Ord l => ClassDecl l -> ClassDecl l -> ClassDecl l
min :: ClassDecl l -> ClassDecl l -> ClassDecl l
Ord,Int -> ClassDecl l -> ShowS
[ClassDecl l] -> ShowS
ClassDecl l -> String
(Int -> ClassDecl l -> ShowS)
-> (ClassDecl l -> String)
-> ([ClassDecl l] -> ShowS)
-> Show (ClassDecl l)
forall l. Show l => Int -> ClassDecl l -> ShowS
forall l. Show l => [ClassDecl l] -> ShowS
forall l. Show l => ClassDecl l -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall l. Show l => Int -> ClassDecl l -> ShowS
showsPrec :: Int -> ClassDecl l -> ShowS
$cshow :: forall l. Show l => ClassDecl l -> String
show :: ClassDecl l -> String
$cshowList :: forall l. Show l => [ClassDecl l] -> ShowS
showList :: [ClassDecl l] -> ShowS
Show,Typeable,Typeable (ClassDecl l)
Typeable (ClassDecl l) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> ClassDecl l -> c (ClassDecl l))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (ClassDecl l))
-> (ClassDecl l -> Constr)
-> (ClassDecl l -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (ClassDecl l)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (ClassDecl l)))
-> ((forall b. Data b => b -> b) -> ClassDecl l -> ClassDecl l)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ClassDecl l -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ClassDecl l -> r)
-> (forall u. (forall d. Data d => d -> u) -> ClassDecl l -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> ClassDecl l -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ClassDecl l -> m (ClassDecl l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ClassDecl l -> m (ClassDecl l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ClassDecl l -> m (ClassDecl l))
-> Data (ClassDecl l)
ClassDecl l -> Constr
ClassDecl l -> DataType
(forall b. Data b => b -> b) -> ClassDecl l -> ClassDecl l
forall l. Data l => Typeable (ClassDecl l)
forall l. Data l => ClassDecl l -> Constr
forall l. Data l => ClassDecl l -> DataType
forall l.
Data l =>
(forall b. Data b => b -> b) -> ClassDecl l -> ClassDecl l
forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> ClassDecl l -> u
forall l u.
Data l =>
(forall d. Data d => d -> u) -> ClassDecl l -> [u]
forall l r r'.
Data l =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ClassDecl l -> r
forall l r r'.
Data l =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ClassDecl l -> r
forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d) -> ClassDecl l -> m (ClassDecl l)
forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> ClassDecl l -> m (ClassDecl l)
forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ClassDecl l)
forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ClassDecl l -> c (ClassDecl l)
forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (ClassDecl l))
forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ClassDecl l))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> ClassDecl l -> u
forall u. (forall d. Data d => d -> u) -> ClassDecl l -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ClassDecl l -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ClassDecl l -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ClassDecl l -> m (ClassDecl l)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ClassDecl l -> m (ClassDecl l)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ClassDecl l)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ClassDecl l -> c (ClassDecl l)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (ClassDecl l))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ClassDecl l))
$cgfoldl :: forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ClassDecl l -> c (ClassDecl l)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ClassDecl l -> c (ClassDecl l)
$cgunfold :: forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ClassDecl l)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ClassDecl l)
$ctoConstr :: forall l. Data l => ClassDecl l -> Constr
toConstr :: ClassDecl l -> Constr
$cdataTypeOf :: forall l. Data l => ClassDecl l -> DataType
dataTypeOf :: ClassDecl l -> DataType
$cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (ClassDecl l))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (ClassDecl l))
$cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ClassDecl l))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ClassDecl l))
$cgmapT :: forall l.
Data l =>
(forall b. Data b => b -> b) -> ClassDecl l -> ClassDecl l
gmapT :: (forall b. Data b => b -> b) -> ClassDecl l -> ClassDecl l
$cgmapQl :: forall l r r'.
Data l =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ClassDecl l -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ClassDecl l -> r
$cgmapQr :: forall l r r'.
Data l =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ClassDecl l -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ClassDecl l -> r
$cgmapQ :: forall l u.
Data l =>
(forall d. Data d => d -> u) -> ClassDecl l -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> ClassDecl l -> [u]
$cgmapQi :: forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> ClassDecl l -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ClassDecl l -> u
$cgmapM :: forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d) -> ClassDecl l -> m (ClassDecl l)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ClassDecl l -> m (ClassDecl l)
$cgmapMp :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> ClassDecl l -> m (ClassDecl l)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ClassDecl l -> m (ClassDecl l)
$cgmapMo :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> ClassDecl l -> m (ClassDecl l)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ClassDecl l -> m (ClassDecl l)
Data,(forall m. Monoid m => ClassDecl m -> m)
-> (forall m a. Monoid m => (a -> m) -> ClassDecl a -> m)
-> (forall m a. Monoid m => (a -> m) -> ClassDecl a -> m)
-> (forall a b. (a -> b -> b) -> b -> ClassDecl a -> b)
-> (forall a b. (a -> b -> b) -> b -> ClassDecl a -> b)
-> (forall b a. (b -> a -> b) -> b -> ClassDecl a -> b)
-> (forall b a. (b -> a -> b) -> b -> ClassDecl a -> b)
-> (forall a. (a -> a -> a) -> ClassDecl a -> a)
-> (forall a. (a -> a -> a) -> ClassDecl a -> a)
-> (forall a. ClassDecl a -> [a])
-> (forall a. ClassDecl a -> Bool)
-> (forall a. ClassDecl a -> Int)
-> (forall a. Eq a => a -> ClassDecl a -> Bool)
-> (forall a. Ord a => ClassDecl a -> a)
-> (forall a. Ord a => ClassDecl a -> a)
-> (forall a. Num a => ClassDecl a -> a)
-> (forall a. Num a => ClassDecl a -> a)
-> Foldable ClassDecl
forall a. Eq a => a -> ClassDecl a -> Bool
forall a. Num a => ClassDecl a -> a
forall a. Ord a => ClassDecl a -> a
forall m. Monoid m => ClassDecl m -> m
forall a. ClassDecl a -> Bool
forall a. ClassDecl a -> Int
forall a. ClassDecl a -> [a]
forall a. (a -> a -> a) -> ClassDecl a -> a
forall m a. Monoid m => (a -> m) -> ClassDecl a -> m
forall b a. (b -> a -> b) -> b -> ClassDecl a -> b
forall a b. (a -> b -> b) -> b -> ClassDecl a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall m. Monoid m => ClassDecl m -> m
fold :: forall m. Monoid m => ClassDecl m -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> ClassDecl a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> ClassDecl a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> ClassDecl a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> ClassDecl a -> m
$cfoldr :: forall a b. (a -> b -> b) -> b -> ClassDecl a -> b
foldr :: forall a b. (a -> b -> b) -> b -> ClassDecl a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> ClassDecl a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> ClassDecl a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> ClassDecl a -> b
foldl :: forall b a. (b -> a -> b) -> b -> ClassDecl a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> ClassDecl a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> ClassDecl a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> ClassDecl a -> a
foldr1 :: forall a. (a -> a -> a) -> ClassDecl a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> ClassDecl a -> a
foldl1 :: forall a. (a -> a -> a) -> ClassDecl a -> a
$ctoList :: forall a. ClassDecl a -> [a]
toList :: forall a. ClassDecl a -> [a]
$cnull :: forall a. ClassDecl a -> Bool
null :: forall a. ClassDecl a -> Bool
$clength :: forall a. ClassDecl a -> Int
length :: forall a. ClassDecl a -> Int
$celem :: forall a. Eq a => a -> ClassDecl a -> Bool
elem :: forall a. Eq a => a -> ClassDecl a -> Bool
$cmaximum :: forall a. Ord a => ClassDecl a -> a
maximum :: forall a. Ord a => ClassDecl a -> a
$cminimum :: forall a. Ord a => ClassDecl a -> a
minimum :: forall a. Ord a => ClassDecl a -> a
$csum :: forall a. Num a => ClassDecl a -> a
sum :: forall a. Num a => ClassDecl a -> a
$cproduct :: forall a. Num a => ClassDecl a -> a
product :: forall a. Num a => ClassDecl a -> a
Foldable,Functor ClassDecl
Foldable ClassDecl
(Functor ClassDecl, Foldable ClassDecl) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> ClassDecl a -> f (ClassDecl b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    ClassDecl (f a) -> f (ClassDecl a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> ClassDecl a -> m (ClassDecl b))
-> (forall (m :: * -> *) a.
    Monad m =>
    ClassDecl (m a) -> m (ClassDecl a))
-> Traversable ClassDecl
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a.
Monad m =>
ClassDecl (m a) -> m (ClassDecl a)
forall (f :: * -> *) a.
Applicative f =>
ClassDecl (f a) -> f (ClassDecl a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> ClassDecl a -> m (ClassDecl b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> ClassDecl a -> f (ClassDecl b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> ClassDecl a -> f (ClassDecl b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> ClassDecl a -> f (ClassDecl b)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
ClassDecl (f a) -> f (ClassDecl a)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
ClassDecl (f a) -> f (ClassDecl a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> ClassDecl a -> m (ClassDecl b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> ClassDecl a -> m (ClassDecl b)
$csequence :: forall (m :: * -> *) a.
Monad m =>
ClassDecl (m a) -> m (ClassDecl a)
sequence :: forall (m :: * -> *) a.
Monad m =>
ClassDecl (m a) -> m (ClassDecl a)
Traversable,(forall a b. (a -> b) -> ClassDecl a -> ClassDecl b)
-> (forall a b. a -> ClassDecl b -> ClassDecl a)
-> Functor ClassDecl
forall a b. a -> ClassDecl b -> ClassDecl a
forall a b. (a -> b) -> ClassDecl a -> ClassDecl b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> ClassDecl a -> ClassDecl b
fmap :: forall a b. (a -> b) -> ClassDecl a -> ClassDecl b
$c<$ :: forall a b. a -> ClassDecl b -> ClassDecl a
<$ :: forall a b. a -> ClassDecl b -> ClassDecl a
Functor,(forall x. ClassDecl l -> Rep (ClassDecl l) x)
-> (forall x. Rep (ClassDecl l) x -> ClassDecl l)
-> Generic (ClassDecl l)
forall x. Rep (ClassDecl l) x -> ClassDecl l
forall x. ClassDecl l -> Rep (ClassDecl l) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall l x. Rep (ClassDecl l) x -> ClassDecl l
forall l x. ClassDecl l -> Rep (ClassDecl l) x
$cfrom :: forall l x. ClassDecl l -> Rep (ClassDecl l) x
from :: forall x. ClassDecl l -> Rep (ClassDecl l) x
$cto :: forall l x. Rep (ClassDecl l) x -> ClassDecl l
to :: forall x. Rep (ClassDecl l) x -> ClassDecl l
Generic)

-- | Declarations inside an instance declaration.
data InstDecl l
    = InsDecl   l (Decl l)
            -- ^ ordinary declaration
    | InsType   l (Type l) (Type l)
            -- ^ an associated type definition
    | InsData   l (DataOrNew l) (Type l) [QualConDecl l] [Deriving l]
            -- ^ an associated data type implementation
    | InsGData  l (DataOrNew l) (Type l) (Maybe (Kind l)) [GadtDecl l] [Deriving l]
            -- ^ an associated data type implemented using GADT style
  deriving (InstDecl l -> InstDecl l -> Bool
(InstDecl l -> InstDecl l -> Bool)
-> (InstDecl l -> InstDecl l -> Bool) -> Eq (InstDecl l)
forall l. Eq l => InstDecl l -> InstDecl l -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall l. Eq l => InstDecl l -> InstDecl l -> Bool
== :: InstDecl l -> InstDecl l -> Bool
$c/= :: forall l. Eq l => InstDecl l -> InstDecl l -> Bool
/= :: InstDecl l -> InstDecl l -> Bool
Eq,Eq (InstDecl l)
Eq (InstDecl l) =>
(InstDecl l -> InstDecl l -> Ordering)
-> (InstDecl l -> InstDecl l -> Bool)
-> (InstDecl l -> InstDecl l -> Bool)
-> (InstDecl l -> InstDecl l -> Bool)
-> (InstDecl l -> InstDecl l -> Bool)
-> (InstDecl l -> InstDecl l -> InstDecl l)
-> (InstDecl l -> InstDecl l -> InstDecl l)
-> Ord (InstDecl l)
InstDecl l -> InstDecl l -> Bool
InstDecl l -> InstDecl l -> Ordering
InstDecl l -> InstDecl l -> InstDecl l
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall l. Ord l => Eq (InstDecl l)
forall l. Ord l => InstDecl l -> InstDecl l -> Bool
forall l. Ord l => InstDecl l -> InstDecl l -> Ordering
forall l. Ord l => InstDecl l -> InstDecl l -> InstDecl l
$ccompare :: forall l. Ord l => InstDecl l -> InstDecl l -> Ordering
compare :: InstDecl l -> InstDecl l -> Ordering
$c< :: forall l. Ord l => InstDecl l -> InstDecl l -> Bool
< :: InstDecl l -> InstDecl l -> Bool
$c<= :: forall l. Ord l => InstDecl l -> InstDecl l -> Bool
<= :: InstDecl l -> InstDecl l -> Bool
$c> :: forall l. Ord l => InstDecl l -> InstDecl l -> Bool
> :: InstDecl l -> InstDecl l -> Bool
$c>= :: forall l. Ord l => InstDecl l -> InstDecl l -> Bool
>= :: InstDecl l -> InstDecl l -> Bool
$cmax :: forall l. Ord l => InstDecl l -> InstDecl l -> InstDecl l
max :: InstDecl l -> InstDecl l -> InstDecl l
$cmin :: forall l. Ord l => InstDecl l -> InstDecl l -> InstDecl l
min :: InstDecl l -> InstDecl l -> InstDecl l
Ord,Int -> InstDecl l -> ShowS
[InstDecl l] -> ShowS
InstDecl l -> String
(Int -> InstDecl l -> ShowS)
-> (InstDecl l -> String)
-> ([InstDecl l] -> ShowS)
-> Show (InstDecl l)
forall l. Show l => Int -> InstDecl l -> ShowS
forall l. Show l => [InstDecl l] -> ShowS
forall l. Show l => InstDecl l -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall l. Show l => Int -> InstDecl l -> ShowS
showsPrec :: Int -> InstDecl l -> ShowS
$cshow :: forall l. Show l => InstDecl l -> String
show :: InstDecl l -> String
$cshowList :: forall l. Show l => [InstDecl l] -> ShowS
showList :: [InstDecl l] -> ShowS
Show,Typeable,Typeable (InstDecl l)
Typeable (InstDecl l) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> InstDecl l -> c (InstDecl l))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (InstDecl l))
-> (InstDecl l -> Constr)
-> (InstDecl l -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (InstDecl l)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (InstDecl l)))
-> ((forall b. Data b => b -> b) -> InstDecl l -> InstDecl l)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> InstDecl l -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> InstDecl l -> r)
-> (forall u. (forall d. Data d => d -> u) -> InstDecl l -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> InstDecl l -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> InstDecl l -> m (InstDecl l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> InstDecl l -> m (InstDecl l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> InstDecl l -> m (InstDecl l))
-> Data (InstDecl l)
InstDecl l -> Constr
InstDecl l -> DataType
(forall b. Data b => b -> b) -> InstDecl l -> InstDecl l
forall l. Data l => Typeable (InstDecl l)
forall l. Data l => InstDecl l -> Constr
forall l. Data l => InstDecl l -> DataType
forall l.
Data l =>
(forall b. Data b => b -> b) -> InstDecl l -> InstDecl l
forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> InstDecl l -> u
forall l u.
Data l =>
(forall d. Data d => d -> u) -> InstDecl l -> [u]
forall l r r'.
Data l =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> InstDecl l -> r
forall l r r'.
Data l =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> InstDecl l -> r
forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d) -> InstDecl l -> m (InstDecl l)
forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> InstDecl l -> m (InstDecl l)
forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (InstDecl l)
forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> InstDecl l -> c (InstDecl l)
forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (InstDecl l))
forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (InstDecl l))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> InstDecl l -> u
forall u. (forall d. Data d => d -> u) -> InstDecl l -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> InstDecl l -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> InstDecl l -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> InstDecl l -> m (InstDecl l)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> InstDecl l -> m (InstDecl l)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (InstDecl l)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> InstDecl l -> c (InstDecl l)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (InstDecl l))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (InstDecl l))
$cgfoldl :: forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> InstDecl l -> c (InstDecl l)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> InstDecl l -> c (InstDecl l)
$cgunfold :: forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (InstDecl l)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (InstDecl l)
$ctoConstr :: forall l. Data l => InstDecl l -> Constr
toConstr :: InstDecl l -> Constr
$cdataTypeOf :: forall l. Data l => InstDecl l -> DataType
dataTypeOf :: InstDecl l -> DataType
$cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (InstDecl l))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (InstDecl l))
$cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (InstDecl l))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (InstDecl l))
$cgmapT :: forall l.
Data l =>
(forall b. Data b => b -> b) -> InstDecl l -> InstDecl l
gmapT :: (forall b. Data b => b -> b) -> InstDecl l -> InstDecl l
$cgmapQl :: forall l r r'.
Data l =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> InstDecl l -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> InstDecl l -> r
$cgmapQr :: forall l r r'.
Data l =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> InstDecl l -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> InstDecl l -> r
$cgmapQ :: forall l u.
Data l =>
(forall d. Data d => d -> u) -> InstDecl l -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> InstDecl l -> [u]
$cgmapQi :: forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> InstDecl l -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> InstDecl l -> u
$cgmapM :: forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d) -> InstDecl l -> m (InstDecl l)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> InstDecl l -> m (InstDecl l)
$cgmapMp :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> InstDecl l -> m (InstDecl l)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> InstDecl l -> m (InstDecl l)
$cgmapMo :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> InstDecl l -> m (InstDecl l)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> InstDecl l -> m (InstDecl l)
Data,(forall m. Monoid m => InstDecl m -> m)
-> (forall m a. Monoid m => (a -> m) -> InstDecl a -> m)
-> (forall m a. Monoid m => (a -> m) -> InstDecl a -> m)
-> (forall a b. (a -> b -> b) -> b -> InstDecl a -> b)
-> (forall a b. (a -> b -> b) -> b -> InstDecl a -> b)
-> (forall b a. (b -> a -> b) -> b -> InstDecl a -> b)
-> (forall b a. (b -> a -> b) -> b -> InstDecl a -> b)
-> (forall a. (a -> a -> a) -> InstDecl a -> a)
-> (forall a. (a -> a -> a) -> InstDecl a -> a)
-> (forall a. InstDecl a -> [a])
-> (forall a. InstDecl a -> Bool)
-> (forall a. InstDecl a -> Int)
-> (forall a. Eq a => a -> InstDecl a -> Bool)
-> (forall a. Ord a => InstDecl a -> a)
-> (forall a. Ord a => InstDecl a -> a)
-> (forall a. Num a => InstDecl a -> a)
-> (forall a. Num a => InstDecl a -> a)
-> Foldable InstDecl
forall a. Eq a => a -> InstDecl a -> Bool
forall a. Num a => InstDecl a -> a
forall a. Ord a => InstDecl a -> a
forall m. Monoid m => InstDecl m -> m
forall a. InstDecl a -> Bool
forall a. InstDecl a -> Int
forall a. InstDecl a -> [a]
forall a. (a -> a -> a) -> InstDecl a -> a
forall m a. Monoid m => (a -> m) -> InstDecl a -> m
forall b a. (b -> a -> b) -> b -> InstDecl a -> b
forall a b. (a -> b -> b) -> b -> InstDecl a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall m. Monoid m => InstDecl m -> m
fold :: forall m. Monoid m => InstDecl m -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> InstDecl a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> InstDecl a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> InstDecl a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> InstDecl a -> m
$cfoldr :: forall a b. (a -> b -> b) -> b -> InstDecl a -> b
foldr :: forall a b. (a -> b -> b) -> b -> InstDecl a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> InstDecl a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> InstDecl a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> InstDecl a -> b
foldl :: forall b a. (b -> a -> b) -> b -> InstDecl a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> InstDecl a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> InstDecl a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> InstDecl a -> a
foldr1 :: forall a. (a -> a -> a) -> InstDecl a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> InstDecl a -> a
foldl1 :: forall a. (a -> a -> a) -> InstDecl a -> a
$ctoList :: forall a. InstDecl a -> [a]
toList :: forall a. InstDecl a -> [a]
$cnull :: forall a. InstDecl a -> Bool
null :: forall a. InstDecl a -> Bool
$clength :: forall a. InstDecl a -> Int
length :: forall a. InstDecl a -> Int
$celem :: forall a. Eq a => a -> InstDecl a -> Bool
elem :: forall a. Eq a => a -> InstDecl a -> Bool
$cmaximum :: forall a. Ord a => InstDecl a -> a
maximum :: forall a. Ord a => InstDecl a -> a
$cminimum :: forall a. Ord a => InstDecl a -> a
minimum :: forall a. Ord a => InstDecl a -> a
$csum :: forall a. Num a => InstDecl a -> a
sum :: forall a. Num a => InstDecl a -> a
$cproduct :: forall a. Num a => InstDecl a -> a
product :: forall a. Num a => InstDecl a -> a
Foldable,Functor InstDecl
Foldable InstDecl
(Functor InstDecl, Foldable InstDecl) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> InstDecl a -> f (InstDecl b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    InstDecl (f a) -> f (InstDecl a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> InstDecl a -> m (InstDecl b))
-> (forall (m :: * -> *) a.
    Monad m =>
    InstDecl (m a) -> m (InstDecl a))
-> Traversable InstDecl
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a. Monad m => InstDecl (m a) -> m (InstDecl a)
forall (f :: * -> *) a.
Applicative f =>
InstDecl (f a) -> f (InstDecl a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> InstDecl a -> m (InstDecl b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> InstDecl a -> f (InstDecl b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> InstDecl a -> f (InstDecl b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> InstDecl a -> f (InstDecl b)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
InstDecl (f a) -> f (InstDecl a)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
InstDecl (f a) -> f (InstDecl a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> InstDecl a -> m (InstDecl b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> InstDecl a -> m (InstDecl b)
$csequence :: forall (m :: * -> *) a. Monad m => InstDecl (m a) -> m (InstDecl a)
sequence :: forall (m :: * -> *) a. Monad m => InstDecl (m a) -> m (InstDecl a)
Traversable,(forall a b. (a -> b) -> InstDecl a -> InstDecl b)
-> (forall a b. a -> InstDecl b -> InstDecl a) -> Functor InstDecl
forall a b. a -> InstDecl b -> InstDecl a
forall a b. (a -> b) -> InstDecl a -> InstDecl b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> InstDecl a -> InstDecl b
fmap :: forall a b. (a -> b) -> InstDecl a -> InstDecl b
$c<$ :: forall a b. a -> InstDecl b -> InstDecl a
<$ :: forall a b. a -> InstDecl b -> InstDecl a
Functor,(forall x. InstDecl l -> Rep (InstDecl l) x)
-> (forall x. Rep (InstDecl l) x -> InstDecl l)
-> Generic (InstDecl l)
forall x. Rep (InstDecl l) x -> InstDecl l
forall x. InstDecl l -> Rep (InstDecl l) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall l x. Rep (InstDecl l) x -> InstDecl l
forall l x. InstDecl l -> Rep (InstDecl l) x
$cfrom :: forall l x. InstDecl l -> Rep (InstDecl l) x
from :: forall x. InstDecl l -> Rep (InstDecl l) x
$cto :: forall l x. Rep (InstDecl l) x -> InstDecl l
to :: forall x. Rep (InstDecl l) x -> InstDecl l
Generic)

-- | The type of a constructor argument or field, optionally including
--   a strictness annotation.
data BangType l
     = BangedTy   l -- ^ strict component, marked with \"@!@\"
     | LazyTy     l -- ^ lazy component, marked with \"@~@\"
     | NoStrictAnnot l -- ^ No strictness information
  deriving (BangType l -> BangType l -> Bool
(BangType l -> BangType l -> Bool)
-> (BangType l -> BangType l -> Bool) -> Eq (BangType l)
forall l. Eq l => BangType l -> BangType l -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall l. Eq l => BangType l -> BangType l -> Bool
== :: BangType l -> BangType l -> Bool
$c/= :: forall l. Eq l => BangType l -> BangType l -> Bool
/= :: BangType l -> BangType l -> Bool
Eq,Eq (BangType l)
Eq (BangType l) =>
(BangType l -> BangType l -> Ordering)
-> (BangType l -> BangType l -> Bool)
-> (BangType l -> BangType l -> Bool)
-> (BangType l -> BangType l -> Bool)
-> (BangType l -> BangType l -> Bool)
-> (BangType l -> BangType l -> BangType l)
-> (BangType l -> BangType l -> BangType l)
-> Ord (BangType l)
BangType l -> BangType l -> Bool
BangType l -> BangType l -> Ordering
BangType l -> BangType l -> BangType l
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall l. Ord l => Eq (BangType l)
forall l. Ord l => BangType l -> BangType l -> Bool
forall l. Ord l => BangType l -> BangType l -> Ordering
forall l. Ord l => BangType l -> BangType l -> BangType l
$ccompare :: forall l. Ord l => BangType l -> BangType l -> Ordering
compare :: BangType l -> BangType l -> Ordering
$c< :: forall l. Ord l => BangType l -> BangType l -> Bool
< :: BangType l -> BangType l -> Bool
$c<= :: forall l. Ord l => BangType l -> BangType l -> Bool
<= :: BangType l -> BangType l -> Bool
$c> :: forall l. Ord l => BangType l -> BangType l -> Bool
> :: BangType l -> BangType l -> Bool
$c>= :: forall l. Ord l => BangType l -> BangType l -> Bool
>= :: BangType l -> BangType l -> Bool
$cmax :: forall l. Ord l => BangType l -> BangType l -> BangType l
max :: BangType l -> BangType l -> BangType l
$cmin :: forall l. Ord l => BangType l -> BangType l -> BangType l
min :: BangType l -> BangType l -> BangType l
Ord,Int -> BangType l -> ShowS
[BangType l] -> ShowS
BangType l -> String
(Int -> BangType l -> ShowS)
-> (BangType l -> String)
-> ([BangType l] -> ShowS)
-> Show (BangType l)
forall l. Show l => Int -> BangType l -> ShowS
forall l. Show l => [BangType l] -> ShowS
forall l. Show l => BangType l -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall l. Show l => Int -> BangType l -> ShowS
showsPrec :: Int -> BangType l -> ShowS
$cshow :: forall l. Show l => BangType l -> String
show :: BangType l -> String
$cshowList :: forall l. Show l => [BangType l] -> ShowS
showList :: [BangType l] -> ShowS
Show,Typeable,Typeable (BangType l)
Typeable (BangType l) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> BangType l -> c (BangType l))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (BangType l))
-> (BangType l -> Constr)
-> (BangType l -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (BangType l)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (BangType l)))
-> ((forall b. Data b => b -> b) -> BangType l -> BangType l)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> BangType l -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> BangType l -> r)
-> (forall u. (forall d. Data d => d -> u) -> BangType l -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> BangType l -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> BangType l -> m (BangType l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> BangType l -> m (BangType l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> BangType l -> m (BangType l))
-> Data (BangType l)
BangType l -> Constr
BangType l -> DataType
(forall b. Data b => b -> b) -> BangType l -> BangType l
forall l. Data l => Typeable (BangType l)
forall l. Data l => BangType l -> Constr
forall l. Data l => BangType l -> DataType
forall l.
Data l =>
(forall b. Data b => b -> b) -> BangType l -> BangType l
forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> BangType l -> u
forall l u.
Data l =>
(forall d. Data d => d -> u) -> BangType l -> [u]
forall l r r'.
Data l =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> BangType l -> r
forall l r r'.
Data l =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> BangType l -> r
forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d) -> BangType l -> m (BangType l)
forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> BangType l -> m (BangType l)
forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (BangType l)
forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BangType l -> c (BangType l)
forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (BangType l))
forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (BangType l))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> BangType l -> u
forall u. (forall d. Data d => d -> u) -> BangType l -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> BangType l -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> BangType l -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> BangType l -> m (BangType l)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> BangType l -> m (BangType l)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (BangType l)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BangType l -> c (BangType l)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (BangType l))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (BangType l))
$cgfoldl :: forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BangType l -> c (BangType l)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BangType l -> c (BangType l)
$cgunfold :: forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (BangType l)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (BangType l)
$ctoConstr :: forall l. Data l => BangType l -> Constr
toConstr :: BangType l -> Constr
$cdataTypeOf :: forall l. Data l => BangType l -> DataType
dataTypeOf :: BangType l -> DataType
$cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (BangType l))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (BangType l))
$cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (BangType l))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (BangType l))
$cgmapT :: forall l.
Data l =>
(forall b. Data b => b -> b) -> BangType l -> BangType l
gmapT :: (forall b. Data b => b -> b) -> BangType l -> BangType l
$cgmapQl :: forall l r r'.
Data l =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> BangType l -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> BangType l -> r
$cgmapQr :: forall l r r'.
Data l =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> BangType l -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> BangType l -> r
$cgmapQ :: forall l u.
Data l =>
(forall d. Data d => d -> u) -> BangType l -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> BangType l -> [u]
$cgmapQi :: forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> BangType l -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> BangType l -> u
$cgmapM :: forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d) -> BangType l -> m (BangType l)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> BangType l -> m (BangType l)
$cgmapMp :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> BangType l -> m (BangType l)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> BangType l -> m (BangType l)
$cgmapMo :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> BangType l -> m (BangType l)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> BangType l -> m (BangType l)
Data,(forall m. Monoid m => BangType m -> m)
-> (forall m a. Monoid m => (a -> m) -> BangType a -> m)
-> (forall m a. Monoid m => (a -> m) -> BangType a -> m)
-> (forall a b. (a -> b -> b) -> b -> BangType a -> b)
-> (forall a b. (a -> b -> b) -> b -> BangType a -> b)
-> (forall b a. (b -> a -> b) -> b -> BangType a -> b)
-> (forall b a. (b -> a -> b) -> b -> BangType a -> b)
-> (forall a. (a -> a -> a) -> BangType a -> a)
-> (forall a. (a -> a -> a) -> BangType a -> a)
-> (forall a. BangType a -> [a])
-> (forall a. BangType a -> Bool)
-> (forall a. BangType a -> Int)
-> (forall a. Eq a => a -> BangType a -> Bool)
-> (forall a. Ord a => BangType a -> a)
-> (forall a. Ord a => BangType a -> a)
-> (forall a. Num a => BangType a -> a)
-> (forall a. Num a => BangType a -> a)
-> Foldable BangType
forall a. Eq a => a -> BangType a -> Bool
forall a. Num a => BangType a -> a
forall a. Ord a => BangType a -> a
forall m. Monoid m => BangType m -> m
forall a. BangType a -> Bool
forall a. BangType a -> Int
forall a. BangType a -> [a]
forall a. (a -> a -> a) -> BangType a -> a
forall m a. Monoid m => (a -> m) -> BangType a -> m
forall b a. (b -> a -> b) -> b -> BangType a -> b
forall a b. (a -> b -> b) -> b -> BangType a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall m. Monoid m => BangType m -> m
fold :: forall m. Monoid m => BangType m -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> BangType a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> BangType a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> BangType a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> BangType a -> m
$cfoldr :: forall a b. (a -> b -> b) -> b -> BangType a -> b
foldr :: forall a b. (a -> b -> b) -> b -> BangType a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> BangType a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> BangType a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> BangType a -> b
foldl :: forall b a. (b -> a -> b) -> b -> BangType a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> BangType a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> BangType a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> BangType a -> a
foldr1 :: forall a. (a -> a -> a) -> BangType a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> BangType a -> a
foldl1 :: forall a. (a -> a -> a) -> BangType a -> a
$ctoList :: forall a. BangType a -> [a]
toList :: forall a. BangType a -> [a]
$cnull :: forall a. BangType a -> Bool
null :: forall a. BangType a -> Bool
$clength :: forall a. BangType a -> Int
length :: forall a. BangType a -> Int
$celem :: forall a. Eq a => a -> BangType a -> Bool
elem :: forall a. Eq a => a -> BangType a -> Bool
$cmaximum :: forall a. Ord a => BangType a -> a
maximum :: forall a. Ord a => BangType a -> a
$cminimum :: forall a. Ord a => BangType a -> a
minimum :: forall a. Ord a => BangType a -> a
$csum :: forall a. Num a => BangType a -> a
sum :: forall a. Num a => BangType a -> a
$cproduct :: forall a. Num a => BangType a -> a
product :: forall a. Num a => BangType a -> a
Foldable,Functor BangType
Foldable BangType
(Functor BangType, Foldable BangType) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> BangType a -> f (BangType b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    BangType (f a) -> f (BangType a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> BangType a -> m (BangType b))
-> (forall (m :: * -> *) a.
    Monad m =>
    BangType (m a) -> m (BangType a))
-> Traversable BangType
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a. Monad m => BangType (m a) -> m (BangType a)
forall (f :: * -> *) a.
Applicative f =>
BangType (f a) -> f (BangType a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> BangType a -> m (BangType b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> BangType a -> f (BangType b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> BangType a -> f (BangType b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> BangType a -> f (BangType b)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
BangType (f a) -> f (BangType a)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
BangType (f a) -> f (BangType a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> BangType a -> m (BangType b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> BangType a -> m (BangType b)
$csequence :: forall (m :: * -> *) a. Monad m => BangType (m a) -> m (BangType a)
sequence :: forall (m :: * -> *) a. Monad m => BangType (m a) -> m (BangType a)
Traversable,(forall a b. (a -> b) -> BangType a -> BangType b)
-> (forall a b. a -> BangType b -> BangType a) -> Functor BangType
forall a b. a -> BangType b -> BangType a
forall a b. (a -> b) -> BangType a -> BangType b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> BangType a -> BangType b
fmap :: forall a b. (a -> b) -> BangType a -> BangType b
$c<$ :: forall a b. a -> BangType b -> BangType a
<$ :: forall a b. a -> BangType b -> BangType a
Functor,(forall x. BangType l -> Rep (BangType l) x)
-> (forall x. Rep (BangType l) x -> BangType l)
-> Generic (BangType l)
forall x. Rep (BangType l) x -> BangType l
forall x. BangType l -> Rep (BangType l) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall l x. Rep (BangType l) x -> BangType l
forall l x. BangType l -> Rep (BangType l) x
$cfrom :: forall l x. BangType l -> Rep (BangType l) x
from :: forall x. BangType l -> Rep (BangType l) x
$cto :: forall l x. Rep (BangType l) x -> BangType l
to :: forall x. Rep (BangType l) x -> BangType l
Generic)

data Unpackedness l
    = Unpack l -- ^ \"@{-\# UNPACK \#-}@\"
    | NoUnpack l -- ^ \"@{-\# NOUNPACK \#-}@\"
    | NoUnpackPragma l -- ^ No unpack pragma
  deriving (Unpackedness l -> Unpackedness l -> Bool
(Unpackedness l -> Unpackedness l -> Bool)
-> (Unpackedness l -> Unpackedness l -> Bool)
-> Eq (Unpackedness l)
forall l. Eq l => Unpackedness l -> Unpackedness l -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall l. Eq l => Unpackedness l -> Unpackedness l -> Bool
== :: Unpackedness l -> Unpackedness l -> Bool
$c/= :: forall l. Eq l => Unpackedness l -> Unpackedness l -> Bool
/= :: Unpackedness l -> Unpackedness l -> Bool
Eq,Eq (Unpackedness l)
Eq (Unpackedness l) =>
(Unpackedness l -> Unpackedness l -> Ordering)
-> (Unpackedness l -> Unpackedness l -> Bool)
-> (Unpackedness l -> Unpackedness l -> Bool)
-> (Unpackedness l -> Unpackedness l -> Bool)
-> (Unpackedness l -> Unpackedness l -> Bool)
-> (Unpackedness l -> Unpackedness l -> Unpackedness l)
-> (Unpackedness l -> Unpackedness l -> Unpackedness l)
-> Ord (Unpackedness l)
Unpackedness l -> Unpackedness l -> Bool
Unpackedness l -> Unpackedness l -> Ordering
Unpackedness l -> Unpackedness l -> Unpackedness l
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall l. Ord l => Eq (Unpackedness l)
forall l. Ord l => Unpackedness l -> Unpackedness l -> Bool
forall l. Ord l => Unpackedness l -> Unpackedness l -> Ordering
forall l.
Ord l =>
Unpackedness l -> Unpackedness l -> Unpackedness l
$ccompare :: forall l. Ord l => Unpackedness l -> Unpackedness l -> Ordering
compare :: Unpackedness l -> Unpackedness l -> Ordering
$c< :: forall l. Ord l => Unpackedness l -> Unpackedness l -> Bool
< :: Unpackedness l -> Unpackedness l -> Bool
$c<= :: forall l. Ord l => Unpackedness l -> Unpackedness l -> Bool
<= :: Unpackedness l -> Unpackedness l -> Bool
$c> :: forall l. Ord l => Unpackedness l -> Unpackedness l -> Bool
> :: Unpackedness l -> Unpackedness l -> Bool
$c>= :: forall l. Ord l => Unpackedness l -> Unpackedness l -> Bool
>= :: Unpackedness l -> Unpackedness l -> Bool
$cmax :: forall l.
Ord l =>
Unpackedness l -> Unpackedness l -> Unpackedness l
max :: Unpackedness l -> Unpackedness l -> Unpackedness l
$cmin :: forall l.
Ord l =>
Unpackedness l -> Unpackedness l -> Unpackedness l
min :: Unpackedness l -> Unpackedness l -> Unpackedness l
Ord,Int -> Unpackedness l -> ShowS
[Unpackedness l] -> ShowS
Unpackedness l -> String
(Int -> Unpackedness l -> ShowS)
-> (Unpackedness l -> String)
-> ([Unpackedness l] -> ShowS)
-> Show (Unpackedness l)
forall l. Show l => Int -> Unpackedness l -> ShowS
forall l. Show l => [Unpackedness l] -> ShowS
forall l. Show l => Unpackedness l -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall l. Show l => Int -> Unpackedness l -> ShowS
showsPrec :: Int -> Unpackedness l -> ShowS
$cshow :: forall l. Show l => Unpackedness l -> String
show :: Unpackedness l -> String
$cshowList :: forall l. Show l => [Unpackedness l] -> ShowS
showList :: [Unpackedness l] -> ShowS
Show,Typeable,Typeable (Unpackedness l)
Typeable (Unpackedness l) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Unpackedness l -> c (Unpackedness l))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Unpackedness l))
-> (Unpackedness l -> Constr)
-> (Unpackedness l -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Unpackedness l)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Unpackedness l)))
-> ((forall b. Data b => b -> b)
    -> Unpackedness l -> Unpackedness l)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Unpackedness l -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Unpackedness l -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> Unpackedness l -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Unpackedness l -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> Unpackedness l -> m (Unpackedness l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> Unpackedness l -> m (Unpackedness l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> Unpackedness l -> m (Unpackedness l))
-> Data (Unpackedness l)
Unpackedness l -> Constr
Unpackedness l -> DataType
(forall b. Data b => b -> b) -> Unpackedness l -> Unpackedness l
forall l. Data l => Typeable (Unpackedness l)
forall l. Data l => Unpackedness l -> Constr
forall l. Data l => Unpackedness l -> DataType
forall l.
Data l =>
(forall b. Data b => b -> b) -> Unpackedness l -> Unpackedness l
forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> Unpackedness l -> u
forall l u.
Data l =>
(forall d. Data d => d -> u) -> Unpackedness l -> [u]
forall l r r'.
Data l =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Unpackedness l -> r
forall l r r'.
Data l =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Unpackedness l -> r
forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d)
-> Unpackedness l -> m (Unpackedness l)
forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> Unpackedness l -> m (Unpackedness l)
forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Unpackedness l)
forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Unpackedness l -> c (Unpackedness l)
forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Unpackedness l))
forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Unpackedness l))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> Unpackedness l -> u
forall u. (forall d. Data d => d -> u) -> Unpackedness l -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Unpackedness l -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Unpackedness l -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> Unpackedness l -> m (Unpackedness l)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> Unpackedness l -> m (Unpackedness l)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Unpackedness l)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Unpackedness l -> c (Unpackedness l)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Unpackedness l))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Unpackedness l))
$cgfoldl :: forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Unpackedness l -> c (Unpackedness l)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Unpackedness l -> c (Unpackedness l)
$cgunfold :: forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Unpackedness l)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Unpackedness l)
$ctoConstr :: forall l. Data l => Unpackedness l -> Constr
toConstr :: Unpackedness l -> Constr
$cdataTypeOf :: forall l. Data l => Unpackedness l -> DataType
dataTypeOf :: Unpackedness l -> DataType
$cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Unpackedness l))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Unpackedness l))
$cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Unpackedness l))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Unpackedness l))
$cgmapT :: forall l.
Data l =>
(forall b. Data b => b -> b) -> Unpackedness l -> Unpackedness l
gmapT :: (forall b. Data b => b -> b) -> Unpackedness l -> Unpackedness l
$cgmapQl :: forall l r r'.
Data l =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Unpackedness l -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Unpackedness l -> r
$cgmapQr :: forall l r r'.
Data l =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Unpackedness l -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Unpackedness l -> r
$cgmapQ :: forall l u.
Data l =>
(forall d. Data d => d -> u) -> Unpackedness l -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Unpackedness l -> [u]
$cgmapQi :: forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> Unpackedness l -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> Unpackedness l -> u
$cgmapM :: forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d)
-> Unpackedness l -> m (Unpackedness l)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> Unpackedness l -> m (Unpackedness l)
$cgmapMp :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> Unpackedness l -> m (Unpackedness l)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> Unpackedness l -> m (Unpackedness l)
$cgmapMo :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> Unpackedness l -> m (Unpackedness l)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> Unpackedness l -> m (Unpackedness l)
Data,(forall m. Monoid m => Unpackedness m -> m)
-> (forall m a. Monoid m => (a -> m) -> Unpackedness a -> m)
-> (forall m a. Monoid m => (a -> m) -> Unpackedness a -> m)
-> (forall a b. (a -> b -> b) -> b -> Unpackedness a -> b)
-> (forall a b. (a -> b -> b) -> b -> Unpackedness a -> b)
-> (forall b a. (b -> a -> b) -> b -> Unpackedness a -> b)
-> (forall b a. (b -> a -> b) -> b -> Unpackedness a -> b)
-> (forall a. (a -> a -> a) -> Unpackedness a -> a)
-> (forall a. (a -> a -> a) -> Unpackedness a -> a)
-> (forall a. Unpackedness a -> [a])
-> (forall a. Unpackedness a -> Bool)
-> (forall a. Unpackedness a -> Int)
-> (forall a. Eq a => a -> Unpackedness a -> Bool)
-> (forall a. Ord a => Unpackedness a -> a)
-> (forall a. Ord a => Unpackedness a -> a)
-> (forall a. Num a => Unpackedness a -> a)
-> (forall a. Num a => Unpackedness a -> a)
-> Foldable Unpackedness
forall a. Eq a => a -> Unpackedness a -> Bool
forall a. Num a => Unpackedness a -> a
forall a. Ord a => Unpackedness a -> a
forall m. Monoid m => Unpackedness m -> m
forall a. Unpackedness a -> Bool
forall a. Unpackedness a -> Int
forall a. Unpackedness a -> [a]
forall a. (a -> a -> a) -> Unpackedness a -> a
forall m a. Monoid m => (a -> m) -> Unpackedness a -> m
forall b a. (b -> a -> b) -> b -> Unpackedness a -> b
forall a b. (a -> b -> b) -> b -> Unpackedness a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall m. Monoid m => Unpackedness m -> m
fold :: forall m. Monoid m => Unpackedness m -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> Unpackedness a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> Unpackedness a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> Unpackedness a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> Unpackedness a -> m
$cfoldr :: forall a b. (a -> b -> b) -> b -> Unpackedness a -> b
foldr :: forall a b. (a -> b -> b) -> b -> Unpackedness a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> Unpackedness a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> Unpackedness a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> Unpackedness a -> b
foldl :: forall b a. (b -> a -> b) -> b -> Unpackedness a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> Unpackedness a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> Unpackedness a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> Unpackedness a -> a
foldr1 :: forall a. (a -> a -> a) -> Unpackedness a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> Unpackedness a -> a
foldl1 :: forall a. (a -> a -> a) -> Unpackedness a -> a
$ctoList :: forall a. Unpackedness a -> [a]
toList :: forall a. Unpackedness a -> [a]
$cnull :: forall a. Unpackedness a -> Bool
null :: forall a. Unpackedness a -> Bool
$clength :: forall a. Unpackedness a -> Int
length :: forall a. Unpackedness a -> Int
$celem :: forall a. Eq a => a -> Unpackedness a -> Bool
elem :: forall a. Eq a => a -> Unpackedness a -> Bool
$cmaximum :: forall a. Ord a => Unpackedness a -> a
maximum :: forall a. Ord a => Unpackedness a -> a
$cminimum :: forall a. Ord a => Unpackedness a -> a
minimum :: forall a. Ord a => Unpackedness a -> a
$csum :: forall a. Num a => Unpackedness a -> a
sum :: forall a. Num a => Unpackedness a -> a
$cproduct :: forall a. Num a => Unpackedness a -> a
product :: forall a. Num a => Unpackedness a -> a
Foldable,Functor Unpackedness
Foldable Unpackedness
(Functor Unpackedness, Foldable Unpackedness) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> Unpackedness a -> f (Unpackedness b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    Unpackedness (f a) -> f (Unpackedness a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Unpackedness a -> m (Unpackedness b))
-> (forall (m :: * -> *) a.
    Monad m =>
    Unpackedness (m a) -> m (Unpackedness a))
-> Traversable Unpackedness
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a.
Monad m =>
Unpackedness (m a) -> m (Unpackedness a)
forall (f :: * -> *) a.
Applicative f =>
Unpackedness (f a) -> f (Unpackedness a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Unpackedness a -> m (Unpackedness b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Unpackedness a -> f (Unpackedness b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Unpackedness a -> f (Unpackedness b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Unpackedness a -> f (Unpackedness b)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
Unpackedness (f a) -> f (Unpackedness a)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
Unpackedness (f a) -> f (Unpackedness a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Unpackedness a -> m (Unpackedness b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Unpackedness a -> m (Unpackedness b)
$csequence :: forall (m :: * -> *) a.
Monad m =>
Unpackedness (m a) -> m (Unpackedness a)
sequence :: forall (m :: * -> *) a.
Monad m =>
Unpackedness (m a) -> m (Unpackedness a)
Traversable,(forall a b. (a -> b) -> Unpackedness a -> Unpackedness b)
-> (forall a b. a -> Unpackedness b -> Unpackedness a)
-> Functor Unpackedness
forall a b. a -> Unpackedness b -> Unpackedness a
forall a b. (a -> b) -> Unpackedness a -> Unpackedness b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> Unpackedness a -> Unpackedness b
fmap :: forall a b. (a -> b) -> Unpackedness a -> Unpackedness b
$c<$ :: forall a b. a -> Unpackedness b -> Unpackedness a
<$ :: forall a b. a -> Unpackedness b -> Unpackedness a
Functor,(forall x. Unpackedness l -> Rep (Unpackedness l) x)
-> (forall x. Rep (Unpackedness l) x -> Unpackedness l)
-> Generic (Unpackedness l)
forall x. Rep (Unpackedness l) x -> Unpackedness l
forall x. Unpackedness l -> Rep (Unpackedness l) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall l x. Rep (Unpackedness l) x -> Unpackedness l
forall l x. Unpackedness l -> Rep (Unpackedness l) x
$cfrom :: forall l x. Unpackedness l -> Rep (Unpackedness l) x
from :: forall x. Unpackedness l -> Rep (Unpackedness l) x
$cto :: forall l x. Rep (Unpackedness l) x -> Unpackedness l
to :: forall x. Rep (Unpackedness l) x -> Unpackedness l
Generic)

-- | The right hand side of a function binding, pattern binding, or a case
--   alternative.
data Rhs l
     = UnGuardedRhs l (Exp l) -- ^ unguarded right hand side (/exp/)
     | GuardedRhss  l [GuardedRhs l]
                -- ^ guarded right hand side (/gdrhs/)
  deriving (Rhs l -> Rhs l -> Bool
(Rhs l -> Rhs l -> Bool) -> (Rhs l -> Rhs l -> Bool) -> Eq (Rhs l)
forall l. Eq l => Rhs l -> Rhs l -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall l. Eq l => Rhs l -> Rhs l -> Bool
== :: Rhs l -> Rhs l -> Bool
$c/= :: forall l. Eq l => Rhs l -> Rhs l -> Bool
/= :: Rhs l -> Rhs l -> Bool
Eq,Eq (Rhs l)
Eq (Rhs l) =>
(Rhs l -> Rhs l -> Ordering)
-> (Rhs l -> Rhs l -> Bool)
-> (Rhs l -> Rhs l -> Bool)
-> (Rhs l -> Rhs l -> Bool)
-> (Rhs l -> Rhs l -> Bool)
-> (Rhs l -> Rhs l -> Rhs l)
-> (Rhs l -> Rhs l -> Rhs l)
-> Ord (Rhs l)
Rhs l -> Rhs l -> Bool
Rhs l -> Rhs l -> Ordering
Rhs l -> Rhs l -> Rhs l
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall l. Ord l => Eq (Rhs l)
forall l. Ord l => Rhs l -> Rhs l -> Bool
forall l. Ord l => Rhs l -> Rhs l -> Ordering
forall l. Ord l => Rhs l -> Rhs l -> Rhs l
$ccompare :: forall l. Ord l => Rhs l -> Rhs l -> Ordering
compare :: Rhs l -> Rhs l -> Ordering
$c< :: forall l. Ord l => Rhs l -> Rhs l -> Bool
< :: Rhs l -> Rhs l -> Bool
$c<= :: forall l. Ord l => Rhs l -> Rhs l -> Bool
<= :: Rhs l -> Rhs l -> Bool
$c> :: forall l. Ord l => Rhs l -> Rhs l -> Bool
> :: Rhs l -> Rhs l -> Bool
$c>= :: forall l. Ord l => Rhs l -> Rhs l -> Bool
>= :: Rhs l -> Rhs l -> Bool
$cmax :: forall l. Ord l => Rhs l -> Rhs l -> Rhs l
max :: Rhs l -> Rhs l -> Rhs l
$cmin :: forall l. Ord l => Rhs l -> Rhs l -> Rhs l
min :: Rhs l -> Rhs l -> Rhs l
Ord,Int -> Rhs l -> ShowS
[Rhs l] -> ShowS
Rhs l -> String
(Int -> Rhs l -> ShowS)
-> (Rhs l -> String) -> ([Rhs l] -> ShowS) -> Show (Rhs l)
forall l. Show l => Int -> Rhs l -> ShowS
forall l. Show l => [Rhs l] -> ShowS
forall l. Show l => Rhs l -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall l. Show l => Int -> Rhs l -> ShowS
showsPrec :: Int -> Rhs l -> ShowS
$cshow :: forall l. Show l => Rhs l -> String
show :: Rhs l -> String
$cshowList :: forall l. Show l => [Rhs l] -> ShowS
showList :: [Rhs l] -> ShowS
Show,Typeable,Typeable (Rhs l)
Typeable (Rhs l) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Rhs l -> c (Rhs l))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Rhs l))
-> (Rhs l -> Constr)
-> (Rhs l -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Rhs l)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Rhs l)))
-> ((forall b. Data b => b -> b) -> Rhs l -> Rhs l)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Rhs l -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Rhs l -> r)
-> (forall u. (forall d. Data d => d -> u) -> Rhs l -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Rhs l -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Rhs l -> m (Rhs l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Rhs l -> m (Rhs l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Rhs l -> m (Rhs l))
-> Data (Rhs l)
Rhs l -> Constr
Rhs l -> DataType
(forall b. Data b => b -> b) -> Rhs l -> Rhs l
forall l. Data l => Typeable (Rhs l)
forall l. Data l => Rhs l -> Constr
forall l. Data l => Rhs l -> DataType
forall l. Data l => (forall b. Data b => b -> b) -> Rhs l -> Rhs l
forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> Rhs l -> u
forall l u. Data l => (forall d. Data d => d -> u) -> Rhs l -> [u]
forall l r r'.
Data l =>
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Rhs l -> r
forall l r r'.
Data l =>
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Rhs l -> r
forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d) -> Rhs l -> m (Rhs l)
forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Rhs l -> m (Rhs l)
forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Rhs l)
forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Rhs l -> c (Rhs l)
forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Rhs l))
forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Rhs l))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Rhs l -> u
forall u. (forall d. Data d => d -> u) -> Rhs l -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Rhs l -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Rhs l -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Rhs l -> m (Rhs l)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Rhs l -> m (Rhs l)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Rhs l)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Rhs l -> c (Rhs l)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Rhs l))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Rhs l))
$cgfoldl :: forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Rhs l -> c (Rhs l)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Rhs l -> c (Rhs l)
$cgunfold :: forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Rhs l)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Rhs l)
$ctoConstr :: forall l. Data l => Rhs l -> Constr
toConstr :: Rhs l -> Constr
$cdataTypeOf :: forall l. Data l => Rhs l -> DataType
dataTypeOf :: Rhs l -> DataType
$cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Rhs l))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Rhs l))
$cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Rhs l))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Rhs l))
$cgmapT :: forall l. Data l => (forall b. Data b => b -> b) -> Rhs l -> Rhs l
gmapT :: (forall b. Data b => b -> b) -> Rhs l -> Rhs l
$cgmapQl :: forall l r r'.
Data l =>
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Rhs l -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Rhs l -> r
$cgmapQr :: forall l r r'.
Data l =>
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Rhs l -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Rhs l -> r
$cgmapQ :: forall l u. Data l => (forall d. Data d => d -> u) -> Rhs l -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Rhs l -> [u]
$cgmapQi :: forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> Rhs l -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Rhs l -> u
$cgmapM :: forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d) -> Rhs l -> m (Rhs l)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Rhs l -> m (Rhs l)
$cgmapMp :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Rhs l -> m (Rhs l)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Rhs l -> m (Rhs l)
$cgmapMo :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Rhs l -> m (Rhs l)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Rhs l -> m (Rhs l)
Data,(forall m. Monoid m => Rhs m -> m)
-> (forall m a. Monoid m => (a -> m) -> Rhs a -> m)
-> (forall m a. Monoid m => (a -> m) -> Rhs a -> m)
-> (forall a b. (a -> b -> b) -> b -> Rhs a -> b)
-> (forall a b. (a -> b -> b) -> b -> Rhs a -> b)
-> (forall b a. (b -> a -> b) -> b -> Rhs a -> b)
-> (forall b a. (b -> a -> b) -> b -> Rhs a -> b)
-> (forall a. (a -> a -> a) -> Rhs a -> a)
-> (forall a. (a -> a -> a) -> Rhs a -> a)
-> (forall a. Rhs a -> [a])
-> (forall a. Rhs a -> Bool)
-> (forall a. Rhs a -> Int)
-> (forall a. Eq a => a -> Rhs a -> Bool)
-> (forall a. Ord a => Rhs a -> a)
-> (forall a. Ord a => Rhs a -> a)
-> (forall a. Num a => Rhs a -> a)
-> (forall a. Num a => Rhs a -> a)
-> Foldable Rhs
forall a. Eq a => a -> Rhs a -> Bool
forall a. Num a => Rhs a -> a
forall a. Ord a => Rhs a -> a
forall m. Monoid m => Rhs m -> m
forall a. Rhs a -> Bool
forall a. Rhs a -> Int
forall a. Rhs a -> [a]
forall a. (a -> a -> a) -> Rhs a -> a
forall m a. Monoid m => (a -> m) -> Rhs a -> m
forall b a. (b -> a -> b) -> b -> Rhs a -> b
forall a b. (a -> b -> b) -> b -> Rhs a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall m. Monoid m => Rhs m -> m
fold :: forall m. Monoid m => Rhs m -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> Rhs a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> Rhs a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> Rhs a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> Rhs a -> m
$cfoldr :: forall a b. (a -> b -> b) -> b -> Rhs a -> b
foldr :: forall a b. (a -> b -> b) -> b -> Rhs a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> Rhs a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> Rhs a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> Rhs a -> b
foldl :: forall b a. (b -> a -> b) -> b -> Rhs a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> Rhs a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> Rhs a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> Rhs a -> a
foldr1 :: forall a. (a -> a -> a) -> Rhs a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> Rhs a -> a
foldl1 :: forall a. (a -> a -> a) -> Rhs a -> a
$ctoList :: forall a. Rhs a -> [a]
toList :: forall a. Rhs a -> [a]
$cnull :: forall a. Rhs a -> Bool
null :: forall a. Rhs a -> Bool
$clength :: forall a. Rhs a -> Int
length :: forall a. Rhs a -> Int
$celem :: forall a. Eq a => a -> Rhs a -> Bool
elem :: forall a. Eq a => a -> Rhs a -> Bool
$cmaximum :: forall a. Ord a => Rhs a -> a
maximum :: forall a. Ord a => Rhs a -> a
$cminimum :: forall a. Ord a => Rhs a -> a
minimum :: forall a. Ord a => Rhs a -> a
$csum :: forall a. Num a => Rhs a -> a
sum :: forall a. Num a => Rhs a -> a
$cproduct :: forall a. Num a => Rhs a -> a
product :: forall a. Num a => Rhs a -> a
Foldable,Functor Rhs
Foldable Rhs
(Functor Rhs, Foldable Rhs) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> Rhs a -> f (Rhs b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    Rhs (f a) -> f (Rhs a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Rhs a -> m (Rhs b))
-> (forall (m :: * -> *) a. Monad m => Rhs (m a) -> m (Rhs a))
-> Traversable Rhs
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a. Monad m => Rhs (m a) -> m (Rhs a)
forall (f :: * -> *) a. Applicative f => Rhs (f a) -> f (Rhs a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Rhs a -> m (Rhs b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Rhs a -> f (Rhs b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Rhs a -> f (Rhs b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Rhs a -> f (Rhs b)
$csequenceA :: forall (f :: * -> *) a. Applicative f => Rhs (f a) -> f (Rhs a)
sequenceA :: forall (f :: * -> *) a. Applicative f => Rhs (f a) -> f (Rhs a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Rhs a -> m (Rhs b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Rhs a -> m (Rhs b)
$csequence :: forall (m :: * -> *) a. Monad m => Rhs (m a) -> m (Rhs a)
sequence :: forall (m :: * -> *) a. Monad m => Rhs (m a) -> m (Rhs a)
Traversable,(forall a b. (a -> b) -> Rhs a -> Rhs b)
-> (forall a b. a -> Rhs b -> Rhs a) -> Functor Rhs
forall a b. a -> Rhs b -> Rhs a
forall a b. (a -> b) -> Rhs a -> Rhs b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> Rhs a -> Rhs b
fmap :: forall a b. (a -> b) -> Rhs a -> Rhs b
$c<$ :: forall a b. a -> Rhs b -> Rhs a
<$ :: forall a b. a -> Rhs b -> Rhs a
Functor,(forall x. Rhs l -> Rep (Rhs l) x)
-> (forall x. Rep (Rhs l) x -> Rhs l) -> Generic (Rhs l)
forall x. Rep (Rhs l) x -> Rhs l
forall x. Rhs l -> Rep (Rhs l) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall l x. Rep (Rhs l) x -> Rhs l
forall l x. Rhs l -> Rep (Rhs l) x
$cfrom :: forall l x. Rhs l -> Rep (Rhs l) x
from :: forall x. Rhs l -> Rep (Rhs l) x
$cto :: forall l x. Rep (Rhs l) x -> Rhs l
to :: forall x. Rep (Rhs l) x -> Rhs l
Generic)

-- | A guarded right hand side @|@ /stmts/ @=@ /exp/, or @|@ /stmts/ @->@ /exp/
--   for case alternatives.
--   The guard is a series of statements when using pattern guards,
--   otherwise it will be a single qualifier expression.
data GuardedRhs l
     = GuardedRhs l [Stmt l] (Exp l)
  deriving (GuardedRhs l -> GuardedRhs l -> Bool
(GuardedRhs l -> GuardedRhs l -> Bool)
-> (GuardedRhs l -> GuardedRhs l -> Bool) -> Eq (GuardedRhs l)
forall l. Eq l => GuardedRhs l -> GuardedRhs l -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall l. Eq l => GuardedRhs l -> GuardedRhs l -> Bool
== :: GuardedRhs l -> GuardedRhs l -> Bool
$c/= :: forall l. Eq l => GuardedRhs l -> GuardedRhs l -> Bool
/= :: GuardedRhs l -> GuardedRhs l -> Bool
Eq,Eq (GuardedRhs l)
Eq (GuardedRhs l) =>
(GuardedRhs l -> GuardedRhs l -> Ordering)
-> (GuardedRhs l -> GuardedRhs l -> Bool)
-> (GuardedRhs l -> GuardedRhs l -> Bool)
-> (GuardedRhs l -> GuardedRhs l -> Bool)
-> (GuardedRhs l -> GuardedRhs l -> Bool)
-> (GuardedRhs l -> GuardedRhs l -> GuardedRhs l)
-> (GuardedRhs l -> GuardedRhs l -> GuardedRhs l)
-> Ord (GuardedRhs l)
GuardedRhs l -> GuardedRhs l -> Bool
GuardedRhs l -> GuardedRhs l -> Ordering
GuardedRhs l -> GuardedRhs l -> GuardedRhs l
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall l. Ord l => Eq (GuardedRhs l)
forall l. Ord l => GuardedRhs l -> GuardedRhs l -> Bool
forall l. Ord l => GuardedRhs l -> GuardedRhs l -> Ordering
forall l. Ord l => GuardedRhs l -> GuardedRhs l -> GuardedRhs l
$ccompare :: forall l. Ord l => GuardedRhs l -> GuardedRhs l -> Ordering
compare :: GuardedRhs l -> GuardedRhs l -> Ordering
$c< :: forall l. Ord l => GuardedRhs l -> GuardedRhs l -> Bool
< :: GuardedRhs l -> GuardedRhs l -> Bool
$c<= :: forall l. Ord l => GuardedRhs l -> GuardedRhs l -> Bool
<= :: GuardedRhs l -> GuardedRhs l -> Bool
$c> :: forall l. Ord l => GuardedRhs l -> GuardedRhs l -> Bool
> :: GuardedRhs l -> GuardedRhs l -> Bool
$c>= :: forall l. Ord l => GuardedRhs l -> GuardedRhs l -> Bool
>= :: GuardedRhs l -> GuardedRhs l -> Bool
$cmax :: forall l. Ord l => GuardedRhs l -> GuardedRhs l -> GuardedRhs l
max :: GuardedRhs l -> GuardedRhs l -> GuardedRhs l
$cmin :: forall l. Ord l => GuardedRhs l -> GuardedRhs l -> GuardedRhs l
min :: GuardedRhs l -> GuardedRhs l -> GuardedRhs l
Ord,Int -> GuardedRhs l -> ShowS
[GuardedRhs l] -> ShowS
GuardedRhs l -> String
(Int -> GuardedRhs l -> ShowS)
-> (GuardedRhs l -> String)
-> ([GuardedRhs l] -> ShowS)
-> Show (GuardedRhs l)
forall l. Show l => Int -> GuardedRhs l -> ShowS
forall l. Show l => [GuardedRhs l] -> ShowS
forall l. Show l => GuardedRhs l -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall l. Show l => Int -> GuardedRhs l -> ShowS
showsPrec :: Int -> GuardedRhs l -> ShowS
$cshow :: forall l. Show l => GuardedRhs l -> String
show :: GuardedRhs l -> String
$cshowList :: forall l. Show l => [GuardedRhs l] -> ShowS
showList :: [GuardedRhs l] -> ShowS
Show,Typeable,Typeable (GuardedRhs l)
Typeable (GuardedRhs l) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> GuardedRhs l -> c (GuardedRhs l))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (GuardedRhs l))
-> (GuardedRhs l -> Constr)
-> (GuardedRhs l -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (GuardedRhs l)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (GuardedRhs l)))
-> ((forall b. Data b => b -> b) -> GuardedRhs l -> GuardedRhs l)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> GuardedRhs l -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> GuardedRhs l -> r)
-> (forall u. (forall d. Data d => d -> u) -> GuardedRhs l -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> GuardedRhs l -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> GuardedRhs l -> m (GuardedRhs l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> GuardedRhs l -> m (GuardedRhs l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> GuardedRhs l -> m (GuardedRhs l))
-> Data (GuardedRhs l)
GuardedRhs l -> Constr
GuardedRhs l -> DataType
(forall b. Data b => b -> b) -> GuardedRhs l -> GuardedRhs l
forall l. Data l => Typeable (GuardedRhs l)
forall l. Data l => GuardedRhs l -> Constr
forall l. Data l => GuardedRhs l -> DataType
forall l.
Data l =>
(forall b. Data b => b -> b) -> GuardedRhs l -> GuardedRhs l
forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> GuardedRhs l -> u
forall l u.
Data l =>
(forall d. Data d => d -> u) -> GuardedRhs l -> [u]
forall l r r'.
Data l =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> GuardedRhs l -> r
forall l r r'.
Data l =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> GuardedRhs l -> r
forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d) -> GuardedRhs l -> m (GuardedRhs l)
forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> GuardedRhs l -> m (GuardedRhs l)
forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (GuardedRhs l)
forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> GuardedRhs l -> c (GuardedRhs l)
forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (GuardedRhs l))
forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (GuardedRhs l))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> GuardedRhs l -> u
forall u. (forall d. Data d => d -> u) -> GuardedRhs l -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> GuardedRhs l -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> GuardedRhs l -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> GuardedRhs l -> m (GuardedRhs l)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> GuardedRhs l -> m (GuardedRhs l)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (GuardedRhs l)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> GuardedRhs l -> c (GuardedRhs l)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (GuardedRhs l))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (GuardedRhs l))
$cgfoldl :: forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> GuardedRhs l -> c (GuardedRhs l)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> GuardedRhs l -> c (GuardedRhs l)
$cgunfold :: forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (GuardedRhs l)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (GuardedRhs l)
$ctoConstr :: forall l. Data l => GuardedRhs l -> Constr
toConstr :: GuardedRhs l -> Constr
$cdataTypeOf :: forall l. Data l => GuardedRhs l -> DataType
dataTypeOf :: GuardedRhs l -> DataType
$cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (GuardedRhs l))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (GuardedRhs l))
$cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (GuardedRhs l))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (GuardedRhs l))
$cgmapT :: forall l.
Data l =>
(forall b. Data b => b -> b) -> GuardedRhs l -> GuardedRhs l
gmapT :: (forall b. Data b => b -> b) -> GuardedRhs l -> GuardedRhs l
$cgmapQl :: forall l r r'.
Data l =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> GuardedRhs l -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> GuardedRhs l -> r
$cgmapQr :: forall l r r'.
Data l =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> GuardedRhs l -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> GuardedRhs l -> r
$cgmapQ :: forall l u.
Data l =>
(forall d. Data d => d -> u) -> GuardedRhs l -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> GuardedRhs l -> [u]
$cgmapQi :: forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> GuardedRhs l -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> GuardedRhs l -> u
$cgmapM :: forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d) -> GuardedRhs l -> m (GuardedRhs l)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> GuardedRhs l -> m (GuardedRhs l)
$cgmapMp :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> GuardedRhs l -> m (GuardedRhs l)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> GuardedRhs l -> m (GuardedRhs l)
$cgmapMo :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> GuardedRhs l -> m (GuardedRhs l)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> GuardedRhs l -> m (GuardedRhs l)
Data,(forall m. Monoid m => GuardedRhs m -> m)
-> (forall m a. Monoid m => (a -> m) -> GuardedRhs a -> m)
-> (forall m a. Monoid m => (a -> m) -> GuardedRhs a -> m)
-> (forall a b. (a -> b -> b) -> b -> GuardedRhs a -> b)
-> (forall a b. (a -> b -> b) -> b -> GuardedRhs a -> b)
-> (forall b a. (b -> a -> b) -> b -> GuardedRhs a -> b)
-> (forall b a. (b -> a -> b) -> b -> GuardedRhs a -> b)
-> (forall a. (a -> a -> a) -> GuardedRhs a -> a)
-> (forall a. (a -> a -> a) -> GuardedRhs a -> a)
-> (forall a. GuardedRhs a -> [a])
-> (forall a. GuardedRhs a -> Bool)
-> (forall a. GuardedRhs a -> Int)
-> (forall a. Eq a => a -> GuardedRhs a -> Bool)
-> (forall a. Ord a => GuardedRhs a -> a)
-> (forall a. Ord a => GuardedRhs a -> a)
-> (forall a. Num a => GuardedRhs a -> a)
-> (forall a. Num a => GuardedRhs a -> a)
-> Foldable GuardedRhs
forall a. Eq a => a -> GuardedRhs a -> Bool
forall a. Num a => GuardedRhs a -> a
forall a. Ord a => GuardedRhs a -> a
forall m. Monoid m => GuardedRhs m -> m
forall a. GuardedRhs a -> Bool
forall a. GuardedRhs a -> Int
forall a. GuardedRhs a -> [a]
forall a. (a -> a -> a) -> GuardedRhs a -> a
forall m a. Monoid m => (a -> m) -> GuardedRhs a -> m
forall b a. (b -> a -> b) -> b -> GuardedRhs a -> b
forall a b. (a -> b -> b) -> b -> GuardedRhs a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall m. Monoid m => GuardedRhs m -> m
fold :: forall m. Monoid m => GuardedRhs m -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> GuardedRhs a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> GuardedRhs a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> GuardedRhs a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> GuardedRhs a -> m
$cfoldr :: forall a b. (a -> b -> b) -> b -> GuardedRhs a -> b
foldr :: forall a b. (a -> b -> b) -> b -> GuardedRhs a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> GuardedRhs a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> GuardedRhs a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> GuardedRhs a -> b
foldl :: forall b a. (b -> a -> b) -> b -> GuardedRhs a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> GuardedRhs a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> GuardedRhs a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> GuardedRhs a -> a
foldr1 :: forall a. (a -> a -> a) -> GuardedRhs a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> GuardedRhs a -> a
foldl1 :: forall a. (a -> a -> a) -> GuardedRhs a -> a
$ctoList :: forall a. GuardedRhs a -> [a]
toList :: forall a. GuardedRhs a -> [a]
$cnull :: forall a. GuardedRhs a -> Bool
null :: forall a. GuardedRhs a -> Bool
$clength :: forall a. GuardedRhs a -> Int
length :: forall a. GuardedRhs a -> Int
$celem :: forall a. Eq a => a -> GuardedRhs a -> Bool
elem :: forall a. Eq a => a -> GuardedRhs a -> Bool
$cmaximum :: forall a. Ord a => GuardedRhs a -> a
maximum :: forall a. Ord a => GuardedRhs a -> a
$cminimum :: forall a. Ord a => GuardedRhs a -> a
minimum :: forall a. Ord a => GuardedRhs a -> a
$csum :: forall a. Num a => GuardedRhs a -> a
sum :: forall a. Num a => GuardedRhs a -> a
$cproduct :: forall a. Num a => GuardedRhs a -> a
product :: forall a. Num a => GuardedRhs a -> a
Foldable,Functor GuardedRhs
Foldable GuardedRhs
(Functor GuardedRhs, Foldable GuardedRhs) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> GuardedRhs a -> f (GuardedRhs b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    GuardedRhs (f a) -> f (GuardedRhs a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> GuardedRhs a -> m (GuardedRhs b))
-> (forall (m :: * -> *) a.
    Monad m =>
    GuardedRhs (m a) -> m (GuardedRhs a))
-> Traversable GuardedRhs
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a.
Monad m =>
GuardedRhs (m a) -> m (GuardedRhs a)
forall (f :: * -> *) a.
Applicative f =>
GuardedRhs (f a) -> f (GuardedRhs a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> GuardedRhs a -> m (GuardedRhs b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> GuardedRhs a -> f (GuardedRhs b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> GuardedRhs a -> f (GuardedRhs b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> GuardedRhs a -> f (GuardedRhs b)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
GuardedRhs (f a) -> f (GuardedRhs a)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
GuardedRhs (f a) -> f (GuardedRhs a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> GuardedRhs a -> m (GuardedRhs b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> GuardedRhs a -> m (GuardedRhs b)
$csequence :: forall (m :: * -> *) a.
Monad m =>
GuardedRhs (m a) -> m (GuardedRhs a)
sequence :: forall (m :: * -> *) a.
Monad m =>
GuardedRhs (m a) -> m (GuardedRhs a)
Traversable,(forall a b. (a -> b) -> GuardedRhs a -> GuardedRhs b)
-> (forall a b. a -> GuardedRhs b -> GuardedRhs a)
-> Functor GuardedRhs
forall a b. a -> GuardedRhs b -> GuardedRhs a
forall a b. (a -> b) -> GuardedRhs a -> GuardedRhs b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> GuardedRhs a -> GuardedRhs b
fmap :: forall a b. (a -> b) -> GuardedRhs a -> GuardedRhs b
$c<$ :: forall a b. a -> GuardedRhs b -> GuardedRhs a
<$ :: forall a b. a -> GuardedRhs b -> GuardedRhs a
Functor,(forall x. GuardedRhs l -> Rep (GuardedRhs l) x)
-> (forall x. Rep (GuardedRhs l) x -> GuardedRhs l)
-> Generic (GuardedRhs l)
forall x. Rep (GuardedRhs l) x -> GuardedRhs l
forall x. GuardedRhs l -> Rep (GuardedRhs l) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall l x. Rep (GuardedRhs l) x -> GuardedRhs l
forall l x. GuardedRhs l -> Rep (GuardedRhs l) x
$cfrom :: forall l x. GuardedRhs l -> Rep (GuardedRhs l) x
from :: forall x. GuardedRhs l -> Rep (GuardedRhs l) x
$cto :: forall l x. Rep (GuardedRhs l) x -> GuardedRhs l
to :: forall x. Rep (GuardedRhs l) x -> GuardedRhs l
Generic)

-- | A type qualified with a context.
--   An unqualified type has an empty context.
data Type l
     = TyForall l
        (Maybe [TyVarBind l])
        (Maybe (Context l))
        (Type l)                                -- ^ qualified type
     | TyStar  l                                -- ^ @*@, the type of types
     | TyFun   l (Type l) (Type l)              -- ^ function type
     | TyTuple l Boxed [Type l]                 -- ^ tuple type, possibly boxed
     | TyUnboxedSum l [Type l]                  -- ^ unboxed tuple type
     | TyList  l (Type l)                       -- ^ list syntax, e.g. [a], as opposed to [] a
     | TyParArray  l (Type l)                   -- ^ parallel array syntax, e.g. [:a:]
     | TyApp   l (Type l) (Type l)              -- ^ application of a type constructor
     | TyVar   l (Name l)                       -- ^ type variable
     | TyCon   l (QName l)                      -- ^ named type or type constructor
     | TyParen l (Type l)                       -- ^ type surrounded by parentheses
     | TyInfix l (Type l) (MaybePromotedName l)
                          (Type l)              -- ^ infix type constructor
     | TyKind  l (Type l) (Kind l)              -- ^ type with explicit kind signature
     | TyPromoted l (Promoted l)                -- ^ @'K@, a promoted data type (-XDataKinds).
     | TyEquals l (Type l) (Type l)             -- ^ type equality predicate enabled by ConstraintKinds
     | TySplice l (Splice l)                    -- ^ template haskell splice type
     | TyBang l (BangType l) (Unpackedness l) (Type l)           -- ^ Strict type marked with \"@!@\" or type marked with UNPACK pragma.
     | TyWildCard l (Maybe (Name l))            -- ^ Either an anonymous of named type wildcard
     | TyQuasiQuote l String String             -- ^ @[$/name/| /string/ |]@
  deriving (Type l -> Type l -> Bool
(Type l -> Type l -> Bool)
-> (Type l -> Type l -> Bool) -> Eq (Type l)
forall l. Eq l => Type l -> Type l -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall l. Eq l => Type l -> Type l -> Bool
== :: Type l -> Type l -> Bool
$c/= :: forall l. Eq l => Type l -> Type l -> Bool
/= :: Type l -> Type l -> Bool
Eq,Eq (Type l)
Eq (Type l) =>
(Type l -> Type l -> Ordering)
-> (Type l -> Type l -> Bool)
-> (Type l -> Type l -> Bool)
-> (Type l -> Type l -> Bool)
-> (Type l -> Type l -> Bool)
-> (Type l -> Type l -> Type l)
-> (Type l -> Type l -> Type l)
-> Ord (Type l)
Type l -> Type l -> Bool
Type l -> Type l -> Ordering
Type l -> Type l -> Type l
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall l. Ord l => Eq (Type l)
forall l. Ord l => Type l -> Type l -> Bool
forall l. Ord l => Type l -> Type l -> Ordering
forall l. Ord l => Type l -> Type l -> Type l
$ccompare :: forall l. Ord l => Type l -> Type l -> Ordering
compare :: Type l -> Type l -> Ordering
$c< :: forall l. Ord l => Type l -> Type l -> Bool
< :: Type l -> Type l -> Bool
$c<= :: forall l. Ord l => Type l -> Type l -> Bool
<= :: Type l -> Type l -> Bool
$c> :: forall l. Ord l => Type l -> Type l -> Bool
> :: Type l -> Type l -> Bool
$c>= :: forall l. Ord l => Type l -> Type l -> Bool
>= :: Type l -> Type l -> Bool
$cmax :: forall l. Ord l => Type l -> Type l -> Type l
max :: Type l -> Type l -> Type l
$cmin :: forall l. Ord l => Type l -> Type l -> Type l
min :: Type l -> Type l -> Type l
Ord,Int -> Type l -> ShowS
[Type l] -> ShowS
Type l -> String
(Int -> Type l -> ShowS)
-> (Type l -> String) -> ([Type l] -> ShowS) -> Show (Type l)
forall l. Show l => Int -> Type l -> ShowS
forall l. Show l => [Type l] -> ShowS
forall l. Show l => Type l -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall l. Show l => Int -> Type l -> ShowS
showsPrec :: Int -> Type l -> ShowS
$cshow :: forall l. Show l => Type l -> String
show :: Type l -> String
$cshowList :: forall l. Show l => [Type l] -> ShowS
showList :: [Type l] -> ShowS
Show,Typeable,Typeable (Type l)
Typeable (Type l) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Type l -> c (Type l))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Type l))
-> (Type l -> Constr)
-> (Type l -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Type l)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Type l)))
-> ((forall b. Data b => b -> b) -> Type l -> Type l)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Type l -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Type l -> r)
-> (forall u. (forall d. Data d => d -> u) -> Type l -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Type l -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Type l -> m (Type l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Type l -> m (Type l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Type l -> m (Type l))
-> Data (Type l)
Type l -> Constr
Type l -> DataType
(forall b. Data b => b -> b) -> Type l -> Type l
forall l. Data l => Typeable (Type l)
forall l. Data l => Type l -> Constr
forall l. Data l => Type l -> DataType
forall l.
Data l =>
(forall b. Data b => b -> b) -> Type l -> Type l
forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> Type l -> u
forall l u. Data l => (forall d. Data d => d -> u) -> Type l -> [u]
forall l r r'.
Data l =>
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Type l -> r
forall l r r'.
Data l =>
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Type l -> r
forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d) -> Type l -> m (Type l)
forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Type l -> m (Type l)
forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Type l)
forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Type l -> c (Type l)
forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Type l))
forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Type l))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Type l -> u
forall u. (forall d. Data d => d -> u) -> Type l -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Type l -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Type l -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Type l -> m (Type l)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Type l -> m (Type l)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Type l)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Type l -> c (Type l)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Type l))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Type l))
$cgfoldl :: forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Type l -> c (Type l)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Type l -> c (Type l)
$cgunfold :: forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Type l)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Type l)
$ctoConstr :: forall l. Data l => Type l -> Constr
toConstr :: Type l -> Constr
$cdataTypeOf :: forall l. Data l => Type l -> DataType
dataTypeOf :: Type l -> DataType
$cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Type l))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Type l))
$cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Type l))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Type l))
$cgmapT :: forall l.
Data l =>
(forall b. Data b => b -> b) -> Type l -> Type l
gmapT :: (forall b. Data b => b -> b) -> Type l -> Type l
$cgmapQl :: forall l r r'.
Data l =>
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Type l -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Type l -> r
$cgmapQr :: forall l r r'.
Data l =>
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Type l -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Type l -> r
$cgmapQ :: forall l u. Data l => (forall d. Data d => d -> u) -> Type l -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Type l -> [u]
$cgmapQi :: forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> Type l -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Type l -> u
$cgmapM :: forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d) -> Type l -> m (Type l)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Type l -> m (Type l)
$cgmapMp :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Type l -> m (Type l)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Type l -> m (Type l)
$cgmapMo :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Type l -> m (Type l)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Type l -> m (Type l)
Data,(forall m. Monoid m => Type m -> m)
-> (forall m a. Monoid m => (a -> m) -> Type a -> m)
-> (forall m a. Monoid m => (a -> m) -> Type a -> m)
-> (forall a b. (a -> b -> b) -> b -> Type a -> b)
-> (forall a b. (a -> b -> b) -> b -> Type a -> b)
-> (forall b a. (b -> a -> b) -> b -> Type a -> b)
-> (forall b a. (b -> a -> b) -> b -> Type a -> b)
-> (forall a. (a -> a -> a) -> Type a -> a)
-> (forall a. (a -> a -> a) -> Type a -> a)
-> (forall a. Type a -> [a])
-> (forall a. Type a -> Bool)
-> (forall a. Type a -> Int)
-> (forall a. Eq a => a -> Type a -> Bool)
-> (forall a. Ord a => Type a -> a)
-> (forall a. Ord a => Type a -> a)
-> (forall a. Num a => Type a -> a)
-> (forall a. Num a => Type a -> a)
-> Foldable Type
forall a. Eq a => a -> Type a -> Bool
forall a. Num a => Type a -> a
forall a. Ord a => Type a -> a
forall m. Monoid m => Type m -> m
forall a. Type a -> Bool
forall a. Type a -> Int
forall a. Type a -> [a]
forall a. (a -> a -> a) -> Type a -> a
forall m a. Monoid m => (a -> m) -> Type a -> m
forall b a. (b -> a -> b) -> b -> Type a -> b
forall a b. (a -> b -> b) -> b -> Type a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall m. Monoid m => Type m -> m
fold :: forall m. Monoid m => Type m -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> Type a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> Type a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> Type a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> Type a -> m
$cfoldr :: forall a b. (a -> b -> b) -> b -> Type a -> b
foldr :: forall a b. (a -> b -> b) -> b -> Type a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> Type a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> Type a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> Type a -> b
foldl :: forall b a. (b -> a -> b) -> b -> Type a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> Type a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> Type a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> Type a -> a
foldr1 :: forall a. (a -> a -> a) -> Type a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> Type a -> a
foldl1 :: forall a. (a -> a -> a) -> Type a -> a
$ctoList :: forall a. Type a -> [a]
toList :: forall a. Type a -> [a]
$cnull :: forall a. Type a -> Bool
null :: forall a. Type a -> Bool
$clength :: forall a. Type a -> Int
length :: forall a. Type a -> Int
$celem :: forall a. Eq a => a -> Type a -> Bool
elem :: forall a. Eq a => a -> Type a -> Bool
$cmaximum :: forall a. Ord a => Type a -> a
maximum :: forall a. Ord a => Type a -> a
$cminimum :: forall a. Ord a => Type a -> a
minimum :: forall a. Ord a => Type a -> a
$csum :: forall a. Num a => Type a -> a
sum :: forall a. Num a => Type a -> a
$cproduct :: forall a. Num a => Type a -> a
product :: forall a. Num a => Type a -> a
Foldable,Functor Type
Foldable Type
(Functor Type, Foldable Type) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> Type a -> f (Type b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    Type (f a) -> f (Type a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Type a -> m (Type b))
-> (forall (m :: * -> *) a. Monad m => Type (m a) -> m (Type a))
-> Traversable Type
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a. Monad m => Type (m a) -> m (Type a)
forall (f :: * -> *) a. Applicative f => Type (f a) -> f (Type a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Type a -> m (Type b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Type a -> f (Type b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Type a -> f (Type b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Type a -> f (Type b)
$csequenceA :: forall (f :: * -> *) a. Applicative f => Type (f a) -> f (Type a)
sequenceA :: forall (f :: * -> *) a. Applicative f => Type (f a) -> f (Type a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Type a -> m (Type b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Type a -> m (Type b)
$csequence :: forall (m :: * -> *) a. Monad m => Type (m a) -> m (Type a)
sequence :: forall (m :: * -> *) a. Monad m => Type (m a) -> m (Type a)
Traversable,(forall a b. (a -> b) -> Type a -> Type b)
-> (forall a b. a -> Type b -> Type a) -> Functor Type
forall a b. a -> Type b -> Type a
forall a b. (a -> b) -> Type a -> Type b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> Type a -> Type b
fmap :: forall a b. (a -> b) -> Type a -> Type b
$c<$ :: forall a b. a -> Type b -> Type a
<$ :: forall a b. a -> Type b -> Type a
Functor,(forall x. Type l -> Rep (Type l) x)
-> (forall x. Rep (Type l) x -> Type l) -> Generic (Type l)
forall x. Rep (Type l) x -> Type l
forall x. Type l -> Rep (Type l) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall l x. Rep (Type l) x -> Type l
forall l x. Type l -> Rep (Type l) x
$cfrom :: forall l x. Type l -> Rep (Type l) x
from :: forall x. Type l -> Rep (Type l) x
$cto :: forall l x. Rep (Type l) x -> Type l
to :: forall x. Rep (Type l) x -> Type l
Generic)

data MaybePromotedName l = PromotedName l (QName l) | UnpromotedName l (QName l)
  deriving (MaybePromotedName l -> MaybePromotedName l -> Bool
(MaybePromotedName l -> MaybePromotedName l -> Bool)
-> (MaybePromotedName l -> MaybePromotedName l -> Bool)
-> Eq (MaybePromotedName l)
forall l.
Eq l =>
MaybePromotedName l -> MaybePromotedName l -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall l.
Eq l =>
MaybePromotedName l -> MaybePromotedName l -> Bool
== :: MaybePromotedName l -> MaybePromotedName l -> Bool
$c/= :: forall l.
Eq l =>
MaybePromotedName l -> MaybePromotedName l -> Bool
/= :: MaybePromotedName l -> MaybePromotedName l -> Bool
Eq,Eq (MaybePromotedName l)
Eq (MaybePromotedName l) =>
(MaybePromotedName l -> MaybePromotedName l -> Ordering)
-> (MaybePromotedName l -> MaybePromotedName l -> Bool)
-> (MaybePromotedName l -> MaybePromotedName l -> Bool)
-> (MaybePromotedName l -> MaybePromotedName l -> Bool)
-> (MaybePromotedName l -> MaybePromotedName l -> Bool)
-> (MaybePromotedName l
    -> MaybePromotedName l -> MaybePromotedName l)
-> (MaybePromotedName l
    -> MaybePromotedName l -> MaybePromotedName l)
-> Ord (MaybePromotedName l)
MaybePromotedName l -> MaybePromotedName l -> Bool
MaybePromotedName l -> MaybePromotedName l -> Ordering
MaybePromotedName l -> MaybePromotedName l -> MaybePromotedName l
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall l. Ord l => Eq (MaybePromotedName l)
forall l.
Ord l =>
MaybePromotedName l -> MaybePromotedName l -> Bool
forall l.
Ord l =>
MaybePromotedName l -> MaybePromotedName l -> Ordering
forall l.
Ord l =>
MaybePromotedName l -> MaybePromotedName l -> MaybePromotedName l
$ccompare :: forall l.
Ord l =>
MaybePromotedName l -> MaybePromotedName l -> Ordering
compare :: MaybePromotedName l -> MaybePromotedName l -> Ordering
$c< :: forall l.
Ord l =>
MaybePromotedName l -> MaybePromotedName l -> Bool
< :: MaybePromotedName l -> MaybePromotedName l -> Bool
$c<= :: forall l.
Ord l =>
MaybePromotedName l -> MaybePromotedName l -> Bool
<= :: MaybePromotedName l -> MaybePromotedName l -> Bool
$c> :: forall l.
Ord l =>
MaybePromotedName l -> MaybePromotedName l -> Bool
> :: MaybePromotedName l -> MaybePromotedName l -> Bool
$c>= :: forall l.
Ord l =>
MaybePromotedName l -> MaybePromotedName l -> Bool
>= :: MaybePromotedName l -> MaybePromotedName l -> Bool
$cmax :: forall l.
Ord l =>
MaybePromotedName l -> MaybePromotedName l -> MaybePromotedName l
max :: MaybePromotedName l -> MaybePromotedName l -> MaybePromotedName l
$cmin :: forall l.
Ord l =>
MaybePromotedName l -> MaybePromotedName l -> MaybePromotedName l
min :: MaybePromotedName l -> MaybePromotedName l -> MaybePromotedName l
Ord,Int -> MaybePromotedName l -> ShowS
[MaybePromotedName l] -> ShowS
MaybePromotedName l -> String
(Int -> MaybePromotedName l -> ShowS)
-> (MaybePromotedName l -> String)
-> ([MaybePromotedName l] -> ShowS)
-> Show (MaybePromotedName l)
forall l. Show l => Int -> MaybePromotedName l -> ShowS
forall l. Show l => [MaybePromotedName l] -> ShowS
forall l. Show l => MaybePromotedName l -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall l. Show l => Int -> MaybePromotedName l -> ShowS
showsPrec :: Int -> MaybePromotedName l -> ShowS
$cshow :: forall l. Show l => MaybePromotedName l -> String
show :: MaybePromotedName l -> String
$cshowList :: forall l. Show l => [MaybePromotedName l] -> ShowS
showList :: [MaybePromotedName l] -> ShowS
Show,Typeable,Typeable (MaybePromotedName l)
Typeable (MaybePromotedName l) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g)
 -> MaybePromotedName l
 -> c (MaybePromotedName l))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (MaybePromotedName l))
-> (MaybePromotedName l -> Constr)
-> (MaybePromotedName l -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (MaybePromotedName l)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (MaybePromotedName l)))
-> ((forall b. Data b => b -> b)
    -> MaybePromotedName l -> MaybePromotedName l)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> MaybePromotedName l -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> MaybePromotedName l -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> MaybePromotedName l -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> MaybePromotedName l -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> MaybePromotedName l -> m (MaybePromotedName l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> MaybePromotedName l -> m (MaybePromotedName l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> MaybePromotedName l -> m (MaybePromotedName l))
-> Data (MaybePromotedName l)
MaybePromotedName l -> Constr
MaybePromotedName l -> DataType
(forall b. Data b => b -> b)
-> MaybePromotedName l -> MaybePromotedName l
forall l. Data l => Typeable (MaybePromotedName l)
forall l. Data l => MaybePromotedName l -> Constr
forall l. Data l => MaybePromotedName l -> DataType
forall l.
Data l =>
(forall b. Data b => b -> b)
-> MaybePromotedName l -> MaybePromotedName l
forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> MaybePromotedName l -> u
forall l u.
Data l =>
(forall d. Data d => d -> u) -> MaybePromotedName l -> [u]
forall l r r'.
Data l =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> MaybePromotedName l -> r
forall l r r'.
Data l =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> MaybePromotedName l -> r
forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d)
-> MaybePromotedName l -> m (MaybePromotedName l)
forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> MaybePromotedName l -> m (MaybePromotedName l)
forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (MaybePromotedName l)
forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> MaybePromotedName l
-> c (MaybePromotedName l)
forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (MaybePromotedName l))
forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (MaybePromotedName l))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> MaybePromotedName l -> u
forall u.
(forall d. Data d => d -> u) -> MaybePromotedName l -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> MaybePromotedName l -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> MaybePromotedName l -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> MaybePromotedName l -> m (MaybePromotedName l)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> MaybePromotedName l -> m (MaybePromotedName l)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (MaybePromotedName l)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> MaybePromotedName l
-> c (MaybePromotedName l)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (MaybePromotedName l))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (MaybePromotedName l))
$cgfoldl :: forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> MaybePromotedName l
-> c (MaybePromotedName l)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> MaybePromotedName l
-> c (MaybePromotedName l)
$cgunfold :: forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (MaybePromotedName l)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (MaybePromotedName l)
$ctoConstr :: forall l. Data l => MaybePromotedName l -> Constr
toConstr :: MaybePromotedName l -> Constr
$cdataTypeOf :: forall l. Data l => MaybePromotedName l -> DataType
dataTypeOf :: MaybePromotedName l -> DataType
$cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (MaybePromotedName l))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (MaybePromotedName l))
$cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (MaybePromotedName l))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (MaybePromotedName l))
$cgmapT :: forall l.
Data l =>
(forall b. Data b => b -> b)
-> MaybePromotedName l -> MaybePromotedName l
gmapT :: (forall b. Data b => b -> b)
-> MaybePromotedName l -> MaybePromotedName l
$cgmapQl :: forall l r r'.
Data l =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> MaybePromotedName l -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> MaybePromotedName l -> r
$cgmapQr :: forall l r r'.
Data l =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> MaybePromotedName l -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> MaybePromotedName l -> r
$cgmapQ :: forall l u.
Data l =>
(forall d. Data d => d -> u) -> MaybePromotedName l -> [u]
gmapQ :: forall u.
(forall d. Data d => d -> u) -> MaybePromotedName l -> [u]
$cgmapQi :: forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> MaybePromotedName l -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> MaybePromotedName l -> u
$cgmapM :: forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d)
-> MaybePromotedName l -> m (MaybePromotedName l)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> MaybePromotedName l -> m (MaybePromotedName l)
$cgmapMp :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> MaybePromotedName l -> m (MaybePromotedName l)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> MaybePromotedName l -> m (MaybePromotedName l)
$cgmapMo :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> MaybePromotedName l -> m (MaybePromotedName l)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> MaybePromotedName l -> m (MaybePromotedName l)
Data,(forall m. Monoid m => MaybePromotedName m -> m)
-> (forall m a. Monoid m => (a -> m) -> MaybePromotedName a -> m)
-> (forall m a. Monoid m => (a -> m) -> MaybePromotedName a -> m)
-> (forall a b. (a -> b -> b) -> b -> MaybePromotedName a -> b)
-> (forall a b. (a -> b -> b) -> b -> MaybePromotedName a -> b)
-> (forall b a. (b -> a -> b) -> b -> MaybePromotedName a -> b)
-> (forall b a. (b -> a -> b) -> b -> MaybePromotedName a -> b)
-> (forall a. (a -> a -> a) -> MaybePromotedName a -> a)
-> (forall a. (a -> a -> a) -> MaybePromotedName a -> a)
-> (forall a. MaybePromotedName a -> [a])
-> (forall a. MaybePromotedName a -> Bool)
-> (forall a. MaybePromotedName a -> Int)
-> (forall a. Eq a => a -> MaybePromotedName a -> Bool)
-> (forall a. Ord a => MaybePromotedName a -> a)
-> (forall a. Ord a => MaybePromotedName a -> a)
-> (forall a. Num a => MaybePromotedName a -> a)
-> (forall a. Num a => MaybePromotedName a -> a)
-> Foldable MaybePromotedName
forall a. Eq a => a -> MaybePromotedName a -> Bool
forall a. Num a => MaybePromotedName a -> a
forall a. Ord a => MaybePromotedName a -> a
forall m. Monoid m => MaybePromotedName m -> m
forall a. MaybePromotedName a -> Bool
forall a. MaybePromotedName a -> Int
forall a. MaybePromotedName a -> [a]
forall a. (a -> a -> a) -> MaybePromotedName a -> a
forall m a. Monoid m => (a -> m) -> MaybePromotedName a -> m
forall b a. (b -> a -> b) -> b -> MaybePromotedName a -> b
forall a b. (a -> b -> b) -> b -> MaybePromotedName a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall m. Monoid m => MaybePromotedName m -> m
fold :: forall m. Monoid m => MaybePromotedName m -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> MaybePromotedName a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> MaybePromotedName a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> MaybePromotedName a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> MaybePromotedName a -> m
$cfoldr :: forall a b. (a -> b -> b) -> b -> MaybePromotedName a -> b
foldr :: forall a b. (a -> b -> b) -> b -> MaybePromotedName a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> MaybePromotedName a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> MaybePromotedName a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> MaybePromotedName a -> b
foldl :: forall b a. (b -> a -> b) -> b -> MaybePromotedName a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> MaybePromotedName a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> MaybePromotedName a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> MaybePromotedName a -> a
foldr1 :: forall a. (a -> a -> a) -> MaybePromotedName a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> MaybePromotedName a -> a
foldl1 :: forall a. (a -> a -> a) -> MaybePromotedName a -> a
$ctoList :: forall a. MaybePromotedName a -> [a]
toList :: forall a. MaybePromotedName a -> [a]
$cnull :: forall a. MaybePromotedName a -> Bool
null :: forall a. MaybePromotedName a -> Bool
$clength :: forall a. MaybePromotedName a -> Int
length :: forall a. MaybePromotedName a -> Int
$celem :: forall a. Eq a => a -> MaybePromotedName a -> Bool
elem :: forall a. Eq a => a -> MaybePromotedName a -> Bool
$cmaximum :: forall a. Ord a => MaybePromotedName a -> a
maximum :: forall a. Ord a => MaybePromotedName a -> a
$cminimum :: forall a. Ord a => MaybePromotedName a -> a
minimum :: forall a. Ord a => MaybePromotedName a -> a
$csum :: forall a. Num a => MaybePromotedName a -> a
sum :: forall a. Num a => MaybePromotedName a -> a
$cproduct :: forall a. Num a => MaybePromotedName a -> a
product :: forall a. Num a => MaybePromotedName a -> a
Foldable,Functor MaybePromotedName
Foldable MaybePromotedName
(Functor MaybePromotedName, Foldable MaybePromotedName) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> MaybePromotedName a -> f (MaybePromotedName b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    MaybePromotedName (f a) -> f (MaybePromotedName a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> MaybePromotedName a -> m (MaybePromotedName b))
-> (forall (m :: * -> *) a.
    Monad m =>
    MaybePromotedName (m a) -> m (MaybePromotedName a))
-> Traversable MaybePromotedName
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a.
Monad m =>
MaybePromotedName (m a) -> m (MaybePromotedName a)
forall (f :: * -> *) a.
Applicative f =>
MaybePromotedName (f a) -> f (MaybePromotedName a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> MaybePromotedName a -> m (MaybePromotedName b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> MaybePromotedName a -> f (MaybePromotedName b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> MaybePromotedName a -> f (MaybePromotedName b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> MaybePromotedName a -> f (MaybePromotedName b)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
MaybePromotedName (f a) -> f (MaybePromotedName a)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
MaybePromotedName (f a) -> f (MaybePromotedName a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> MaybePromotedName a -> m (MaybePromotedName b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> MaybePromotedName a -> m (MaybePromotedName b)
$csequence :: forall (m :: * -> *) a.
Monad m =>
MaybePromotedName (m a) -> m (MaybePromotedName a)
sequence :: forall (m :: * -> *) a.
Monad m =>
MaybePromotedName (m a) -> m (MaybePromotedName a)
Traversable,(forall a b.
 (a -> b) -> MaybePromotedName a -> MaybePromotedName b)
-> (forall a b. a -> MaybePromotedName b -> MaybePromotedName a)
-> Functor MaybePromotedName
forall a b. a -> MaybePromotedName b -> MaybePromotedName a
forall a b. (a -> b) -> MaybePromotedName a -> MaybePromotedName b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> MaybePromotedName a -> MaybePromotedName b
fmap :: forall a b. (a -> b) -> MaybePromotedName a -> MaybePromotedName b
$c<$ :: forall a b. a -> MaybePromotedName b -> MaybePromotedName a
<$ :: forall a b. a -> MaybePromotedName b -> MaybePromotedName a
Functor,(forall x. MaybePromotedName l -> Rep (MaybePromotedName l) x)
-> (forall x. Rep (MaybePromotedName l) x -> MaybePromotedName l)
-> Generic (MaybePromotedName l)
forall x. Rep (MaybePromotedName l) x -> MaybePromotedName l
forall x. MaybePromotedName l -> Rep (MaybePromotedName l) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall l x. Rep (MaybePromotedName l) x -> MaybePromotedName l
forall l x. MaybePromotedName l -> Rep (MaybePromotedName l) x
$cfrom :: forall l x. MaybePromotedName l -> Rep (MaybePromotedName l) x
from :: forall x. MaybePromotedName l -> Rep (MaybePromotedName l) x
$cto :: forall l x. Rep (MaybePromotedName l) x -> MaybePromotedName l
to :: forall x. Rep (MaybePromotedName l) x -> MaybePromotedName l
Generic)

-- | Bools here are True if there was a leading quote which may be
-- left out. For example @'[k1,k2]@ means the same thing as @[k1,k2]@.
data Promoted l
        = PromotedInteger l Integer String -- ^ parsed value and raw string
        | PromotedString l String String -- ^ parsed value and raw string
        | PromotedCon l Bool (QName l)
        | PromotedList l Bool [Type l]
        | PromotedTuple l [Type l]
        | PromotedUnit l
  deriving (Promoted l -> Promoted l -> Bool
(Promoted l -> Promoted l -> Bool)
-> (Promoted l -> Promoted l -> Bool) -> Eq (Promoted l)
forall l. Eq l => Promoted l -> Promoted l -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall l. Eq l => Promoted l -> Promoted l -> Bool
== :: Promoted l -> Promoted l -> Bool
$c/= :: forall l. Eq l => Promoted l -> Promoted l -> Bool
/= :: Promoted l -> Promoted l -> Bool
Eq,Eq (Promoted l)
Eq (Promoted l) =>
(Promoted l -> Promoted l -> Ordering)
-> (Promoted l -> Promoted l -> Bool)
-> (Promoted l -> Promoted l -> Bool)
-> (Promoted l -> Promoted l -> Bool)
-> (Promoted l -> Promoted l -> Bool)
-> (Promoted l -> Promoted l -> Promoted l)
-> (Promoted l -> Promoted l -> Promoted l)
-> Ord (Promoted l)
Promoted l -> Promoted l -> Bool
Promoted l -> Promoted l -> Ordering
Promoted l -> Promoted l -> Promoted l
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall l. Ord l => Eq (Promoted l)
forall l. Ord l => Promoted l -> Promoted l -> Bool
forall l. Ord l => Promoted l -> Promoted l -> Ordering
forall l. Ord l => Promoted l -> Promoted l -> Promoted l
$ccompare :: forall l. Ord l => Promoted l -> Promoted l -> Ordering
compare :: Promoted l -> Promoted l -> Ordering
$c< :: forall l. Ord l => Promoted l -> Promoted l -> Bool
< :: Promoted l -> Promoted l -> Bool
$c<= :: forall l. Ord l => Promoted l -> Promoted l -> Bool
<= :: Promoted l -> Promoted l -> Bool
$c> :: forall l. Ord l => Promoted l -> Promoted l -> Bool
> :: Promoted l -> Promoted l -> Bool
$c>= :: forall l. Ord l => Promoted l -> Promoted l -> Bool
>= :: Promoted l -> Promoted l -> Bool
$cmax :: forall l. Ord l => Promoted l -> Promoted l -> Promoted l
max :: Promoted l -> Promoted l -> Promoted l
$cmin :: forall l. Ord l => Promoted l -> Promoted l -> Promoted l
min :: Promoted l -> Promoted l -> Promoted l
Ord,Int -> Promoted l -> ShowS
[Promoted l] -> ShowS
Promoted l -> String
(Int -> Promoted l -> ShowS)
-> (Promoted l -> String)
-> ([Promoted l] -> ShowS)
-> Show (Promoted l)
forall l. Show l => Int -> Promoted l -> ShowS
forall l. Show l => [Promoted l] -> ShowS
forall l. Show l => Promoted l -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall l. Show l => Int -> Promoted l -> ShowS
showsPrec :: Int -> Promoted l -> ShowS
$cshow :: forall l. Show l => Promoted l -> String
show :: Promoted l -> String
$cshowList :: forall l. Show l => [Promoted l] -> ShowS
showList :: [Promoted l] -> ShowS
Show,Typeable,Typeable (Promoted l)
Typeable (Promoted l) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Promoted l -> c (Promoted l))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Promoted l))
-> (Promoted l -> Constr)
-> (Promoted l -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Promoted l)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Promoted l)))
-> ((forall b. Data b => b -> b) -> Promoted l -> Promoted l)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Promoted l -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Promoted l -> r)
-> (forall u. (forall d. Data d => d -> u) -> Promoted l -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Promoted l -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Promoted l -> m (Promoted l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Promoted l -> m (Promoted l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Promoted l -> m (Promoted l))
-> Data (Promoted l)
Promoted l -> Constr
Promoted l -> DataType
(forall b. Data b => b -> b) -> Promoted l -> Promoted l
forall l. Data l => Typeable (Promoted l)
forall l. Data l => Promoted l -> Constr
forall l. Data l => Promoted l -> DataType
forall l.
Data l =>
(forall b. Data b => b -> b) -> Promoted l -> Promoted l
forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> Promoted l -> u
forall l u.
Data l =>
(forall d. Data d => d -> u) -> Promoted l -> [u]
forall l r r'.
Data l =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Promoted l -> r
forall l r r'.
Data l =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Promoted l -> r
forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d) -> Promoted l -> m (Promoted l)
forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Promoted l -> m (Promoted l)
forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Promoted l)
forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Promoted l -> c (Promoted l)
forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Promoted l))
forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Promoted l))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Promoted l -> u
forall u. (forall d. Data d => d -> u) -> Promoted l -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Promoted l -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Promoted l -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Promoted l -> m (Promoted l)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Promoted l -> m (Promoted l)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Promoted l)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Promoted l -> c (Promoted l)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Promoted l))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Promoted l))
$cgfoldl :: forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Promoted l -> c (Promoted l)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Promoted l -> c (Promoted l)
$cgunfold :: forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Promoted l)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Promoted l)
$ctoConstr :: forall l. Data l => Promoted l -> Constr
toConstr :: Promoted l -> Constr
$cdataTypeOf :: forall l. Data l => Promoted l -> DataType
dataTypeOf :: Promoted l -> DataType
$cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Promoted l))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Promoted l))
$cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Promoted l))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Promoted l))
$cgmapT :: forall l.
Data l =>
(forall b. Data b => b -> b) -> Promoted l -> Promoted l
gmapT :: (forall b. Data b => b -> b) -> Promoted l -> Promoted l
$cgmapQl :: forall l r r'.
Data l =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Promoted l -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Promoted l -> r
$cgmapQr :: forall l r r'.
Data l =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Promoted l -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Promoted l -> r
$cgmapQ :: forall l u.
Data l =>
(forall d. Data d => d -> u) -> Promoted l -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Promoted l -> [u]
$cgmapQi :: forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> Promoted l -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Promoted l -> u
$cgmapM :: forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d) -> Promoted l -> m (Promoted l)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Promoted l -> m (Promoted l)
$cgmapMp :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Promoted l -> m (Promoted l)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Promoted l -> m (Promoted l)
$cgmapMo :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Promoted l -> m (Promoted l)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Promoted l -> m (Promoted l)
Data,(forall m. Monoid m => Promoted m -> m)
-> (forall m a. Monoid m => (a -> m) -> Promoted a -> m)
-> (forall m a. Monoid m => (a -> m) -> Promoted a -> m)
-> (forall a b. (a -> b -> b) -> b -> Promoted a -> b)
-> (forall a b. (a -> b -> b) -> b -> Promoted a -> b)
-> (forall b a. (b -> a -> b) -> b -> Promoted a -> b)
-> (forall b a. (b -> a -> b) -> b -> Promoted a -> b)
-> (forall a. (a -> a -> a) -> Promoted a -> a)
-> (forall a. (a -> a -> a) -> Promoted a -> a)
-> (forall a. Promoted a -> [a])
-> (forall a. Promoted a -> Bool)
-> (forall a. Promoted a -> Int)
-> (forall a. Eq a => a -> Promoted a -> Bool)
-> (forall a. Ord a => Promoted a -> a)
-> (forall a. Ord a => Promoted a -> a)
-> (forall a. Num a => Promoted a -> a)
-> (forall a. Num a => Promoted a -> a)
-> Foldable Promoted
forall a. Eq a => a -> Promoted a -> Bool
forall a. Num a => Promoted a -> a
forall a. Ord a => Promoted a -> a
forall m. Monoid m => Promoted m -> m
forall a. Promoted a -> Bool
forall a. Promoted a -> Int
forall a. Promoted a -> [a]
forall a. (a -> a -> a) -> Promoted a -> a
forall m a. Monoid m => (a -> m) -> Promoted a -> m
forall b a. (b -> a -> b) -> b -> Promoted a -> b
forall a b. (a -> b -> b) -> b -> Promoted a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall m. Monoid m => Promoted m -> m
fold :: forall m. Monoid m => Promoted m -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> Promoted a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> Promoted a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> Promoted a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> Promoted a -> m
$cfoldr :: forall a b. (a -> b -> b) -> b -> Promoted a -> b
foldr :: forall a b. (a -> b -> b) -> b -> Promoted a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> Promoted a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> Promoted a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> Promoted a -> b
foldl :: forall b a. (b -> a -> b) -> b -> Promoted a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> Promoted a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> Promoted a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> Promoted a -> a
foldr1 :: forall a. (a -> a -> a) -> Promoted a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> Promoted a -> a
foldl1 :: forall a. (a -> a -> a) -> Promoted a -> a
$ctoList :: forall a. Promoted a -> [a]
toList :: forall a. Promoted a -> [a]
$cnull :: forall a. Promoted a -> Bool
null :: forall a. Promoted a -> Bool
$clength :: forall a. Promoted a -> Int
length :: forall a. Promoted a -> Int
$celem :: forall a. Eq a => a -> Promoted a -> Bool
elem :: forall a. Eq a => a -> Promoted a -> Bool
$cmaximum :: forall a. Ord a => Promoted a -> a
maximum :: forall a. Ord a => Promoted a -> a
$cminimum :: forall a. Ord a => Promoted a -> a
minimum :: forall a. Ord a => Promoted a -> a
$csum :: forall a. Num a => Promoted a -> a
sum :: forall a. Num a => Promoted a -> a
$cproduct :: forall a. Num a => Promoted a -> a
product :: forall a. Num a => Promoted a -> a
Foldable,Functor Promoted
Foldable Promoted
(Functor Promoted, Foldable Promoted) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> Promoted a -> f (Promoted b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    Promoted (f a) -> f (Promoted a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Promoted a -> m (Promoted b))
-> (forall (m :: * -> *) a.
    Monad m =>
    Promoted (m a) -> m (Promoted a))
-> Traversable Promoted
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a. Monad m => Promoted (m a) -> m (Promoted a)
forall (f :: * -> *) a.
Applicative f =>
Promoted (f a) -> f (Promoted a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Promoted a -> m (Promoted b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Promoted a -> f (Promoted b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Promoted a -> f (Promoted b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Promoted a -> f (Promoted b)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
Promoted (f a) -> f (Promoted a)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
Promoted (f a) -> f (Promoted a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Promoted a -> m (Promoted b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Promoted a -> m (Promoted b)
$csequence :: forall (m :: * -> *) a. Monad m => Promoted (m a) -> m (Promoted a)
sequence :: forall (m :: * -> *) a. Monad m => Promoted (m a) -> m (Promoted a)
Traversable,(forall a b. (a -> b) -> Promoted a -> Promoted b)
-> (forall a b. a -> Promoted b -> Promoted a) -> Functor Promoted
forall a b. a -> Promoted b -> Promoted a
forall a b. (a -> b) -> Promoted a -> Promoted b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> Promoted a -> Promoted b
fmap :: forall a b. (a -> b) -> Promoted a -> Promoted b
$c<$ :: forall a b. a -> Promoted b -> Promoted a
<$ :: forall a b. a -> Promoted b -> Promoted a
Functor,(forall x. Promoted l -> Rep (Promoted l) x)
-> (forall x. Rep (Promoted l) x -> Promoted l)
-> Generic (Promoted l)
forall x. Rep (Promoted l) x -> Promoted l
forall x. Promoted l -> Rep (Promoted l) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall l x. Rep (Promoted l) x -> Promoted l
forall l x. Promoted l -> Rep (Promoted l) x
$cfrom :: forall l x. Promoted l -> Rep (Promoted l) x
from :: forall x. Promoted l -> Rep (Promoted l) x
$cto :: forall l x. Rep (Promoted l) x -> Promoted l
to :: forall x. Rep (Promoted l) x -> Promoted l
Generic)

-- | Flag denoting whether a tuple is boxed or unboxed.
data Boxed = Boxed | Unboxed
  deriving (Boxed -> Boxed -> Bool
(Boxed -> Boxed -> Bool) -> (Boxed -> Boxed -> Bool) -> Eq Boxed
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Boxed -> Boxed -> Bool
== :: Boxed -> Boxed -> Bool
$c/= :: Boxed -> Boxed -> Bool
/= :: Boxed -> Boxed -> Bool
Eq,Eq Boxed
Eq Boxed =>
(Boxed -> Boxed -> Ordering)
-> (Boxed -> Boxed -> Bool)
-> (Boxed -> Boxed -> Bool)
-> (Boxed -> Boxed -> Bool)
-> (Boxed -> Boxed -> Bool)
-> (Boxed -> Boxed -> Boxed)
-> (Boxed -> Boxed -> Boxed)
-> Ord Boxed
Boxed -> Boxed -> Bool
Boxed -> Boxed -> Ordering
Boxed -> Boxed -> Boxed
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Boxed -> Boxed -> Ordering
compare :: Boxed -> Boxed -> Ordering
$c< :: Boxed -> Boxed -> Bool
< :: Boxed -> Boxed -> Bool
$c<= :: Boxed -> Boxed -> Bool
<= :: Boxed -> Boxed -> Bool
$c> :: Boxed -> Boxed -> Bool
> :: Boxed -> Boxed -> Bool
$c>= :: Boxed -> Boxed -> Bool
>= :: Boxed -> Boxed -> Bool
$cmax :: Boxed -> Boxed -> Boxed
max :: Boxed -> Boxed -> Boxed
$cmin :: Boxed -> Boxed -> Boxed
min :: Boxed -> Boxed -> Boxed
Ord,Int -> Boxed -> ShowS
[Boxed] -> ShowS
Boxed -> String
(Int -> Boxed -> ShowS)
-> (Boxed -> String) -> ([Boxed] -> ShowS) -> Show Boxed
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Boxed -> ShowS
showsPrec :: Int -> Boxed -> ShowS
$cshow :: Boxed -> String
show :: Boxed -> String
$cshowList :: [Boxed] -> ShowS
showList :: [Boxed] -> ShowS
Show,Typeable,Typeable Boxed
Typeable Boxed =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Boxed -> c Boxed)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Boxed)
-> (Boxed -> Constr)
-> (Boxed -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Boxed))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Boxed))
-> ((forall b. Data b => b -> b) -> Boxed -> Boxed)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Boxed -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Boxed -> r)
-> (forall u. (forall d. Data d => d -> u) -> Boxed -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Boxed -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Boxed -> m Boxed)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Boxed -> m Boxed)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Boxed -> m Boxed)
-> Data Boxed
Boxed -> Constr
Boxed -> DataType
(forall b. Data b => b -> b) -> Boxed -> Boxed
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Boxed -> u
forall u. (forall d. Data d => d -> u) -> Boxed -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Boxed -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Boxed -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Boxed -> m Boxed
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Boxed -> m Boxed
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Boxed
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Boxed -> c Boxed
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Boxed)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Boxed)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Boxed -> c Boxed
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Boxed -> c Boxed
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Boxed
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Boxed
$ctoConstr :: Boxed -> Constr
toConstr :: Boxed -> Constr
$cdataTypeOf :: Boxed -> DataType
dataTypeOf :: Boxed -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Boxed)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Boxed)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Boxed)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Boxed)
$cgmapT :: (forall b. Data b => b -> b) -> Boxed -> Boxed
gmapT :: (forall b. Data b => b -> b) -> Boxed -> Boxed
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Boxed -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Boxed -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Boxed -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Boxed -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Boxed -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Boxed -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Boxed -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Boxed -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Boxed -> m Boxed
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Boxed -> m Boxed
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Boxed -> m Boxed
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Boxed -> m Boxed
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Boxed -> m Boxed
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Boxed -> m Boxed
Data,(forall x. Boxed -> Rep Boxed x)
-> (forall x. Rep Boxed x -> Boxed) -> Generic Boxed
forall x. Rep Boxed x -> Boxed
forall x. Boxed -> Rep Boxed x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Boxed -> Rep Boxed x
from :: forall x. Boxed -> Rep Boxed x
$cto :: forall x. Rep Boxed x -> Boxed
to :: forall x. Rep Boxed x -> Boxed
Generic)

-- | A type variable declaration, optionally with an explicit kind annotation.
data TyVarBind l
    = KindedVar   l (Name l) (Kind l)  -- ^ variable binding with kind annotation
    | UnkindedVar l (Name l)           -- ^ ordinary variable binding
  deriving (TyVarBind l -> TyVarBind l -> Bool
(TyVarBind l -> TyVarBind l -> Bool)
-> (TyVarBind l -> TyVarBind l -> Bool) -> Eq (TyVarBind l)
forall l. Eq l => TyVarBind l -> TyVarBind l -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall l. Eq l => TyVarBind l -> TyVarBind l -> Bool
== :: TyVarBind l -> TyVarBind l -> Bool
$c/= :: forall l. Eq l => TyVarBind l -> TyVarBind l -> Bool
/= :: TyVarBind l -> TyVarBind l -> Bool
Eq,Eq (TyVarBind l)
Eq (TyVarBind l) =>
(TyVarBind l -> TyVarBind l -> Ordering)
-> (TyVarBind l -> TyVarBind l -> Bool)
-> (TyVarBind l -> TyVarBind l -> Bool)
-> (TyVarBind l -> TyVarBind l -> Bool)
-> (TyVarBind l -> TyVarBind l -> Bool)
-> (TyVarBind l -> TyVarBind l -> TyVarBind l)
-> (TyVarBind l -> TyVarBind l -> TyVarBind l)
-> Ord (TyVarBind l)
TyVarBind l -> TyVarBind l -> Bool
TyVarBind l -> TyVarBind l -> Ordering
TyVarBind l -> TyVarBind l -> TyVarBind l
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall l. Ord l => Eq (TyVarBind l)
forall l. Ord l => TyVarBind l -> TyVarBind l -> Bool
forall l. Ord l => TyVarBind l -> TyVarBind l -> Ordering
forall l. Ord l => TyVarBind l -> TyVarBind l -> TyVarBind l
$ccompare :: forall l. Ord l => TyVarBind l -> TyVarBind l -> Ordering
compare :: TyVarBind l -> TyVarBind l -> Ordering
$c< :: forall l. Ord l => TyVarBind l -> TyVarBind l -> Bool
< :: TyVarBind l -> TyVarBind l -> Bool
$c<= :: forall l. Ord l => TyVarBind l -> TyVarBind l -> Bool
<= :: TyVarBind l -> TyVarBind l -> Bool
$c> :: forall l. Ord l => TyVarBind l -> TyVarBind l -> Bool
> :: TyVarBind l -> TyVarBind l -> Bool
$c>= :: forall l. Ord l => TyVarBind l -> TyVarBind l -> Bool
>= :: TyVarBind l -> TyVarBind l -> Bool
$cmax :: forall l. Ord l => TyVarBind l -> TyVarBind l -> TyVarBind l
max :: TyVarBind l -> TyVarBind l -> TyVarBind l
$cmin :: forall l. Ord l => TyVarBind l -> TyVarBind l -> TyVarBind l
min :: TyVarBind l -> TyVarBind l -> TyVarBind l
Ord,Int -> TyVarBind l -> ShowS
[TyVarBind l] -> ShowS
TyVarBind l -> String
(Int -> TyVarBind l -> ShowS)
-> (TyVarBind l -> String)
-> ([TyVarBind l] -> ShowS)
-> Show (TyVarBind l)
forall l. Show l => Int -> TyVarBind l -> ShowS
forall l. Show l => [TyVarBind l] -> ShowS
forall l. Show l => TyVarBind l -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall l. Show l => Int -> TyVarBind l -> ShowS
showsPrec :: Int -> TyVarBind l -> ShowS
$cshow :: forall l. Show l => TyVarBind l -> String
show :: TyVarBind l -> String
$cshowList :: forall l. Show l => [TyVarBind l] -> ShowS
showList :: [TyVarBind l] -> ShowS
Show,Typeable,Typeable (TyVarBind l)
Typeable (TyVarBind l) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> TyVarBind l -> c (TyVarBind l))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (TyVarBind l))
-> (TyVarBind l -> Constr)
-> (TyVarBind l -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (TyVarBind l)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (TyVarBind l)))
-> ((forall b. Data b => b -> b) -> TyVarBind l -> TyVarBind l)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> TyVarBind l -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> TyVarBind l -> r)
-> (forall u. (forall d. Data d => d -> u) -> TyVarBind l -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> TyVarBind l -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> TyVarBind l -> m (TyVarBind l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TyVarBind l -> m (TyVarBind l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TyVarBind l -> m (TyVarBind l))
-> Data (TyVarBind l)
TyVarBind l -> Constr
TyVarBind l -> DataType
(forall b. Data b => b -> b) -> TyVarBind l -> TyVarBind l
forall l. Data l => Typeable (TyVarBind l)
forall l. Data l => TyVarBind l -> Constr
forall l. Data l => TyVarBind l -> DataType
forall l.
Data l =>
(forall b. Data b => b -> b) -> TyVarBind l -> TyVarBind l
forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> TyVarBind l -> u
forall l u.
Data l =>
(forall d. Data d => d -> u) -> TyVarBind l -> [u]
forall l r r'.
Data l =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TyVarBind l -> r
forall l r r'.
Data l =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TyVarBind l -> r
forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d) -> TyVarBind l -> m (TyVarBind l)
forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> TyVarBind l -> m (TyVarBind l)
forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (TyVarBind l)
forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TyVarBind l -> c (TyVarBind l)
forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (TyVarBind l))
forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (TyVarBind l))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> TyVarBind l -> u
forall u. (forall d. Data d => d -> u) -> TyVarBind l -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TyVarBind l -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TyVarBind l -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TyVarBind l -> m (TyVarBind l)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TyVarBind l -> m (TyVarBind l)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (TyVarBind l)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TyVarBind l -> c (TyVarBind l)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (TyVarBind l))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (TyVarBind l))
$cgfoldl :: forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TyVarBind l -> c (TyVarBind l)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TyVarBind l -> c (TyVarBind l)
$cgunfold :: forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (TyVarBind l)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (TyVarBind l)
$ctoConstr :: forall l. Data l => TyVarBind l -> Constr
toConstr :: TyVarBind l -> Constr
$cdataTypeOf :: forall l. Data l => TyVarBind l -> DataType
dataTypeOf :: TyVarBind l -> DataType
$cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (TyVarBind l))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (TyVarBind l))
$cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (TyVarBind l))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (TyVarBind l))
$cgmapT :: forall l.
Data l =>
(forall b. Data b => b -> b) -> TyVarBind l -> TyVarBind l
gmapT :: (forall b. Data b => b -> b) -> TyVarBind l -> TyVarBind l
$cgmapQl :: forall l r r'.
Data l =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TyVarBind l -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TyVarBind l -> r
$cgmapQr :: forall l r r'.
Data l =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TyVarBind l -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TyVarBind l -> r
$cgmapQ :: forall l u.
Data l =>
(forall d. Data d => d -> u) -> TyVarBind l -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> TyVarBind l -> [u]
$cgmapQi :: forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> TyVarBind l -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> TyVarBind l -> u
$cgmapM :: forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d) -> TyVarBind l -> m (TyVarBind l)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TyVarBind l -> m (TyVarBind l)
$cgmapMp :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> TyVarBind l -> m (TyVarBind l)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TyVarBind l -> m (TyVarBind l)
$cgmapMo :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> TyVarBind l -> m (TyVarBind l)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TyVarBind l -> m (TyVarBind l)
Data,(forall m. Monoid m => TyVarBind m -> m)
-> (forall m a. Monoid m => (a -> m) -> TyVarBind a -> m)
-> (forall m a. Monoid m => (a -> m) -> TyVarBind a -> m)
-> (forall a b. (a -> b -> b) -> b -> TyVarBind a -> b)
-> (forall a b. (a -> b -> b) -> b -> TyVarBind a -> b)
-> (forall b a. (b -> a -> b) -> b -> TyVarBind a -> b)
-> (forall b a. (b -> a -> b) -> b -> TyVarBind a -> b)
-> (forall a. (a -> a -> a) -> TyVarBind a -> a)
-> (forall a. (a -> a -> a) -> TyVarBind a -> a)
-> (forall a. TyVarBind a -> [a])
-> (forall a. TyVarBind a -> Bool)
-> (forall a. TyVarBind a -> Int)
-> (forall a. Eq a => a -> TyVarBind a -> Bool)
-> (forall a. Ord a => TyVarBind a -> a)
-> (forall a. Ord a => TyVarBind a -> a)
-> (forall a. Num a => TyVarBind a -> a)
-> (forall a. Num a => TyVarBind a -> a)
-> Foldable TyVarBind
forall a. Eq a => a -> TyVarBind a -> Bool
forall a. Num a => TyVarBind a -> a
forall a. Ord a => TyVarBind a -> a
forall m. Monoid m => TyVarBind m -> m
forall a. TyVarBind a -> Bool
forall a. TyVarBind a -> Int
forall a. TyVarBind a -> [a]
forall a. (a -> a -> a) -> TyVarBind a -> a
forall m a. Monoid m => (a -> m) -> TyVarBind a -> m
forall b a. (b -> a -> b) -> b -> TyVarBind a -> b
forall a b. (a -> b -> b) -> b -> TyVarBind a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall m. Monoid m => TyVarBind m -> m
fold :: forall m. Monoid m => TyVarBind m -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> TyVarBind a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> TyVarBind a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> TyVarBind a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> TyVarBind a -> m
$cfoldr :: forall a b. (a -> b -> b) -> b -> TyVarBind a -> b
foldr :: forall a b. (a -> b -> b) -> b -> TyVarBind a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> TyVarBind a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> TyVarBind a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> TyVarBind a -> b
foldl :: forall b a. (b -> a -> b) -> b -> TyVarBind a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> TyVarBind a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> TyVarBind a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> TyVarBind a -> a
foldr1 :: forall a. (a -> a -> a) -> TyVarBind a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> TyVarBind a -> a
foldl1 :: forall a. (a -> a -> a) -> TyVarBind a -> a
$ctoList :: forall a. TyVarBind a -> [a]
toList :: forall a. TyVarBind a -> [a]
$cnull :: forall a. TyVarBind a -> Bool
null :: forall a. TyVarBind a -> Bool
$clength :: forall a. TyVarBind a -> Int
length :: forall a. TyVarBind a -> Int
$celem :: forall a. Eq a => a -> TyVarBind a -> Bool
elem :: forall a. Eq a => a -> TyVarBind a -> Bool
$cmaximum :: forall a. Ord a => TyVarBind a -> a
maximum :: forall a. Ord a => TyVarBind a -> a
$cminimum :: forall a. Ord a => TyVarBind a -> a
minimum :: forall a. Ord a => TyVarBind a -> a
$csum :: forall a. Num a => TyVarBind a -> a
sum :: forall a. Num a => TyVarBind a -> a
$cproduct :: forall a. Num a => TyVarBind a -> a
product :: forall a. Num a => TyVarBind a -> a
Foldable,Functor TyVarBind
Foldable TyVarBind
(Functor TyVarBind, Foldable TyVarBind) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> TyVarBind a -> f (TyVarBind b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    TyVarBind (f a) -> f (TyVarBind a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> TyVarBind a -> m (TyVarBind b))
-> (forall (m :: * -> *) a.
    Monad m =>
    TyVarBind (m a) -> m (TyVarBind a))
-> Traversable TyVarBind
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a.
Monad m =>
TyVarBind (m a) -> m (TyVarBind a)
forall (f :: * -> *) a.
Applicative f =>
TyVarBind (f a) -> f (TyVarBind a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> TyVarBind a -> m (TyVarBind b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> TyVarBind a -> f (TyVarBind b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> TyVarBind a -> f (TyVarBind b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> TyVarBind a -> f (TyVarBind b)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
TyVarBind (f a) -> f (TyVarBind a)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
TyVarBind (f a) -> f (TyVarBind a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> TyVarBind a -> m (TyVarBind b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> TyVarBind a -> m (TyVarBind b)
$csequence :: forall (m :: * -> *) a.
Monad m =>
TyVarBind (m a) -> m (TyVarBind a)
sequence :: forall (m :: * -> *) a.
Monad m =>
TyVarBind (m a) -> m (TyVarBind a)
Traversable,(forall a b. (a -> b) -> TyVarBind a -> TyVarBind b)
-> (forall a b. a -> TyVarBind b -> TyVarBind a)
-> Functor TyVarBind
forall a b. a -> TyVarBind b -> TyVarBind a
forall a b. (a -> b) -> TyVarBind a -> TyVarBind b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> TyVarBind a -> TyVarBind b
fmap :: forall a b. (a -> b) -> TyVarBind a -> TyVarBind b
$c<$ :: forall a b. a -> TyVarBind b -> TyVarBind a
<$ :: forall a b. a -> TyVarBind b -> TyVarBind a
Functor,(forall x. TyVarBind l -> Rep (TyVarBind l) x)
-> (forall x. Rep (TyVarBind l) x -> TyVarBind l)
-> Generic (TyVarBind l)
forall x. Rep (TyVarBind l) x -> TyVarBind l
forall x. TyVarBind l -> Rep (TyVarBind l) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall l x. Rep (TyVarBind l) x -> TyVarBind l
forall l x. TyVarBind l -> Rep (TyVarBind l) x
$cfrom :: forall l x. TyVarBind l -> Rep (TyVarBind l) x
from :: forall x. TyVarBind l -> Rep (TyVarBind l) x
$cto :: forall l x. Rep (TyVarBind l) x -> TyVarBind l
to :: forall x. Rep (TyVarBind l) x -> TyVarBind l
Generic)

-- | An explicit kind annotation.
type Kind = Type


-- | A functional dependency, given on the form
--   l1 l2 ... ln -> r2 r3 .. rn
data FunDep l
    = FunDep l [Name l] [Name l]
  deriving (FunDep l -> FunDep l -> Bool
(FunDep l -> FunDep l -> Bool)
-> (FunDep l -> FunDep l -> Bool) -> Eq (FunDep l)
forall l. Eq l => FunDep l -> FunDep l -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall l. Eq l => FunDep l -> FunDep l -> Bool
== :: FunDep l -> FunDep l -> Bool
$c/= :: forall l. Eq l => FunDep l -> FunDep l -> Bool
/= :: FunDep l -> FunDep l -> Bool
Eq,Eq (FunDep l)
Eq (FunDep l) =>
(FunDep l -> FunDep l -> Ordering)
-> (FunDep l -> FunDep l -> Bool)
-> (FunDep l -> FunDep l -> Bool)
-> (FunDep l -> FunDep l -> Bool)
-> (FunDep l -> FunDep l -> Bool)
-> (FunDep l -> FunDep l -> FunDep l)
-> (FunDep l -> FunDep l -> FunDep l)
-> Ord (FunDep l)
FunDep l -> FunDep l -> Bool
FunDep l -> FunDep l -> Ordering
FunDep l -> FunDep l -> FunDep l
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall l. Ord l => Eq (FunDep l)
forall l. Ord l => FunDep l -> FunDep l -> Bool
forall l. Ord l => FunDep l -> FunDep l -> Ordering
forall l. Ord l => FunDep l -> FunDep l -> FunDep l
$ccompare :: forall l. Ord l => FunDep l -> FunDep l -> Ordering
compare :: FunDep l -> FunDep l -> Ordering
$c< :: forall l. Ord l => FunDep l -> FunDep l -> Bool
< :: FunDep l -> FunDep l -> Bool
$c<= :: forall l. Ord l => FunDep l -> FunDep l -> Bool
<= :: FunDep l -> FunDep l -> Bool
$c> :: forall l. Ord l => FunDep l -> FunDep l -> Bool
> :: FunDep l -> FunDep l -> Bool
$c>= :: forall l. Ord l => FunDep l -> FunDep l -> Bool
>= :: FunDep l -> FunDep l -> Bool
$cmax :: forall l. Ord l => FunDep l -> FunDep l -> FunDep l
max :: FunDep l -> FunDep l -> FunDep l
$cmin :: forall l. Ord l => FunDep l -> FunDep l -> FunDep l
min :: FunDep l -> FunDep l -> FunDep l
Ord,Int -> FunDep l -> ShowS
[FunDep l] -> ShowS
FunDep l -> String
(Int -> FunDep l -> ShowS)
-> (FunDep l -> String) -> ([FunDep l] -> ShowS) -> Show (FunDep l)
forall l. Show l => Int -> FunDep l -> ShowS
forall l. Show l => [FunDep l] -> ShowS
forall l. Show l => FunDep l -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall l. Show l => Int -> FunDep l -> ShowS
showsPrec :: Int -> FunDep l -> ShowS
$cshow :: forall l. Show l => FunDep l -> String
show :: FunDep l -> String
$cshowList :: forall l. Show l => [FunDep l] -> ShowS
showList :: [FunDep l] -> ShowS
Show,Typeable,Typeable (FunDep l)
Typeable (FunDep l) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> FunDep l -> c (FunDep l))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (FunDep l))
-> (FunDep l -> Constr)
-> (FunDep l -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (FunDep l)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (FunDep l)))
-> ((forall b. Data b => b -> b) -> FunDep l -> FunDep l)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> FunDep l -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> FunDep l -> r)
-> (forall u. (forall d. Data d => d -> u) -> FunDep l -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> FunDep l -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> FunDep l -> m (FunDep l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> FunDep l -> m (FunDep l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> FunDep l -> m (FunDep l))
-> Data (FunDep l)
FunDep l -> Constr
FunDep l -> DataType
(forall b. Data b => b -> b) -> FunDep l -> FunDep l
forall l. Data l => Typeable (FunDep l)
forall l. Data l => FunDep l -> Constr
forall l. Data l => FunDep l -> DataType
forall l.
Data l =>
(forall b. Data b => b -> b) -> FunDep l -> FunDep l
forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> FunDep l -> u
forall l u.
Data l =>
(forall d. Data d => d -> u) -> FunDep l -> [u]
forall l r r'.
Data l =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FunDep l -> r
forall l r r'.
Data l =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FunDep l -> r
forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d) -> FunDep l -> m (FunDep l)
forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> FunDep l -> m (FunDep l)
forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (FunDep l)
forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FunDep l -> c (FunDep l)
forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (FunDep l))
forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (FunDep l))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> FunDep l -> u
forall u. (forall d. Data d => d -> u) -> FunDep l -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FunDep l -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FunDep l -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> FunDep l -> m (FunDep l)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FunDep l -> m (FunDep l)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (FunDep l)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FunDep l -> c (FunDep l)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (FunDep l))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (FunDep l))
$cgfoldl :: forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FunDep l -> c (FunDep l)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FunDep l -> c (FunDep l)
$cgunfold :: forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (FunDep l)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (FunDep l)
$ctoConstr :: forall l. Data l => FunDep l -> Constr
toConstr :: FunDep l -> Constr
$cdataTypeOf :: forall l. Data l => FunDep l -> DataType
dataTypeOf :: FunDep l -> DataType
$cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (FunDep l))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (FunDep l))
$cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (FunDep l))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (FunDep l))
$cgmapT :: forall l.
Data l =>
(forall b. Data b => b -> b) -> FunDep l -> FunDep l
gmapT :: (forall b. Data b => b -> b) -> FunDep l -> FunDep l
$cgmapQl :: forall l r r'.
Data l =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FunDep l -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FunDep l -> r
$cgmapQr :: forall l r r'.
Data l =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FunDep l -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FunDep l -> r
$cgmapQ :: forall l u.
Data l =>
(forall d. Data d => d -> u) -> FunDep l -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> FunDep l -> [u]
$cgmapQi :: forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> FunDep l -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> FunDep l -> u
$cgmapM :: forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d) -> FunDep l -> m (FunDep l)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> FunDep l -> m (FunDep l)
$cgmapMp :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> FunDep l -> m (FunDep l)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FunDep l -> m (FunDep l)
$cgmapMo :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> FunDep l -> m (FunDep l)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FunDep l -> m (FunDep l)
Data,(forall m. Monoid m => FunDep m -> m)
-> (forall m a. Monoid m => (a -> m) -> FunDep a -> m)
-> (forall m a. Monoid m => (a -> m) -> FunDep a -> m)
-> (forall a b. (a -> b -> b) -> b -> FunDep a -> b)
-> (forall a b. (a -> b -> b) -> b -> FunDep a -> b)
-> (forall b a. (b -> a -> b) -> b -> FunDep a -> b)
-> (forall b a. (b -> a -> b) -> b -> FunDep a -> b)
-> (forall a. (a -> a -> a) -> FunDep a -> a)
-> (forall a. (a -> a -> a) -> FunDep a -> a)
-> (forall a. FunDep a -> [a])
-> (forall a. FunDep a -> Bool)
-> (forall a. FunDep a -> Int)
-> (forall a. Eq a => a -> FunDep a -> Bool)
-> (forall a. Ord a => FunDep a -> a)
-> (forall a. Ord a => FunDep a -> a)
-> (forall a. Num a => FunDep a -> a)
-> (forall a. Num a => FunDep a -> a)
-> Foldable FunDep
forall a. Eq a => a -> FunDep a -> Bool
forall a. Num a => FunDep a -> a
forall a. Ord a => FunDep a -> a
forall m. Monoid m => FunDep m -> m
forall a. FunDep a -> Bool
forall a. FunDep a -> Int
forall a. FunDep a -> [a]
forall a. (a -> a -> a) -> FunDep a -> a
forall m a. Monoid m => (a -> m) -> FunDep a -> m
forall b a. (b -> a -> b) -> b -> FunDep a -> b
forall a b. (a -> b -> b) -> b -> FunDep a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall m. Monoid m => FunDep m -> m
fold :: forall m. Monoid m => FunDep m -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> FunDep a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> FunDep a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> FunDep a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> FunDep a -> m
$cfoldr :: forall a b. (a -> b -> b) -> b -> FunDep a -> b
foldr :: forall a b. (a -> b -> b) -> b -> FunDep a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> FunDep a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> FunDep a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> FunDep a -> b
foldl :: forall b a. (b -> a -> b) -> b -> FunDep a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> FunDep a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> FunDep a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> FunDep a -> a
foldr1 :: forall a. (a -> a -> a) -> FunDep a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> FunDep a -> a
foldl1 :: forall a. (a -> a -> a) -> FunDep a -> a
$ctoList :: forall a. FunDep a -> [a]
toList :: forall a. FunDep a -> [a]
$cnull :: forall a. FunDep a -> Bool
null :: forall a. FunDep a -> Bool
$clength :: forall a. FunDep a -> Int
length :: forall a. FunDep a -> Int
$celem :: forall a. Eq a => a -> FunDep a -> Bool
elem :: forall a. Eq a => a -> FunDep a -> Bool
$cmaximum :: forall a. Ord a => FunDep a -> a
maximum :: forall a. Ord a => FunDep a -> a
$cminimum :: forall a. Ord a => FunDep a -> a
minimum :: forall a. Ord a => FunDep a -> a
$csum :: forall a. Num a => FunDep a -> a
sum :: forall a. Num a => FunDep a -> a
$cproduct :: forall a. Num a => FunDep a -> a
product :: forall a. Num a => FunDep a -> a
Foldable,Functor FunDep
Foldable FunDep
(Functor FunDep, Foldable FunDep) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> FunDep a -> f (FunDep b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    FunDep (f a) -> f (FunDep a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> FunDep a -> m (FunDep b))
-> (forall (m :: * -> *) a.
    Monad m =>
    FunDep (m a) -> m (FunDep a))
-> Traversable FunDep
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a. Monad m => FunDep (m a) -> m (FunDep a)
forall (f :: * -> *) a.
Applicative f =>
FunDep (f a) -> f (FunDep a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> FunDep a -> m (FunDep b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> FunDep a -> f (FunDep b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> FunDep a -> f (FunDep b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> FunDep a -> f (FunDep b)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
FunDep (f a) -> f (FunDep a)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
FunDep (f a) -> f (FunDep a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> FunDep a -> m (FunDep b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> FunDep a -> m (FunDep b)
$csequence :: forall (m :: * -> *) a. Monad m => FunDep (m a) -> m (FunDep a)
sequence :: forall (m :: * -> *) a. Monad m => FunDep (m a) -> m (FunDep a)
Traversable,(forall a b. (a -> b) -> FunDep a -> FunDep b)
-> (forall a b. a -> FunDep b -> FunDep a) -> Functor FunDep
forall a b. a -> FunDep b -> FunDep a
forall a b. (a -> b) -> FunDep a -> FunDep b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> FunDep a -> FunDep b
fmap :: forall a b. (a -> b) -> FunDep a -> FunDep b
$c<$ :: forall a b. a -> FunDep b -> FunDep a
<$ :: forall a b. a -> FunDep b -> FunDep a
Functor,(forall x. FunDep l -> Rep (FunDep l) x)
-> (forall x. Rep (FunDep l) x -> FunDep l) -> Generic (FunDep l)
forall x. Rep (FunDep l) x -> FunDep l
forall x. FunDep l -> Rep (FunDep l) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall l x. Rep (FunDep l) x -> FunDep l
forall l x. FunDep l -> Rep (FunDep l) x
$cfrom :: forall l x. FunDep l -> Rep (FunDep l) x
from :: forall x. FunDep l -> Rep (FunDep l) x
$cto :: forall l x. Rep (FunDep l) x -> FunDep l
to :: forall x. Rep (FunDep l) x -> FunDep l
Generic)

-- | A context is a set of assertions
data Context l
    = CxSingle l (Asst l)
    | CxTuple  l [Asst l]
    | CxEmpty  l
  deriving (Context l -> Context l -> Bool
(Context l -> Context l -> Bool)
-> (Context l -> Context l -> Bool) -> Eq (Context l)
forall l. Eq l => Context l -> Context l -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall l. Eq l => Context l -> Context l -> Bool
== :: Context l -> Context l -> Bool
$c/= :: forall l. Eq l => Context l -> Context l -> Bool
/= :: Context l -> Context l -> Bool
Eq,Eq (Context l)
Eq (Context l) =>
(Context l -> Context l -> Ordering)
-> (Context l -> Context l -> Bool)
-> (Context l -> Context l -> Bool)
-> (Context l -> Context l -> Bool)
-> (Context l -> Context l -> Bool)
-> (Context l -> Context l -> Context l)
-> (Context l -> Context l -> Context l)
-> Ord (Context l)
Context l -> Context l -> Bool
Context l -> Context l -> Ordering
Context l -> Context l -> Context l
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall l. Ord l => Eq (Context l)
forall l. Ord l => Context l -> Context l -> Bool
forall l. Ord l => Context l -> Context l -> Ordering
forall l. Ord l => Context l -> Context l -> Context l
$ccompare :: forall l. Ord l => Context l -> Context l -> Ordering
compare :: Context l -> Context l -> Ordering
$c< :: forall l. Ord l => Context l -> Context l -> Bool
< :: Context l -> Context l -> Bool
$c<= :: forall l. Ord l => Context l -> Context l -> Bool
<= :: Context l -> Context l -> Bool
$c> :: forall l. Ord l => Context l -> Context l -> Bool
> :: Context l -> Context l -> Bool
$c>= :: forall l. Ord l => Context l -> Context l -> Bool
>= :: Context l -> Context l -> Bool
$cmax :: forall l. Ord l => Context l -> Context l -> Context l
max :: Context l -> Context l -> Context l
$cmin :: forall l. Ord l => Context l -> Context l -> Context l
min :: Context l -> Context l -> Context l
Ord,Int -> Context l -> ShowS
[Context l] -> ShowS
Context l -> String
(Int -> Context l -> ShowS)
-> (Context l -> String)
-> ([Context l] -> ShowS)
-> Show (Context l)
forall l. Show l => Int -> Context l -> ShowS
forall l. Show l => [Context l] -> ShowS
forall l. Show l => Context l -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall l. Show l => Int -> Context l -> ShowS
showsPrec :: Int -> Context l -> ShowS
$cshow :: forall l. Show l => Context l -> String
show :: Context l -> String
$cshowList :: forall l. Show l => [Context l] -> ShowS
showList :: [Context l] -> ShowS
Show,Typeable,Typeable (Context l)
Typeable (Context l) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Context l -> c (Context l))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Context l))
-> (Context l -> Constr)
-> (Context l -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Context l)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Context l)))
-> ((forall b. Data b => b -> b) -> Context l -> Context l)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Context l -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Context l -> r)
-> (forall u. (forall d. Data d => d -> u) -> Context l -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Context l -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Context l -> m (Context l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Context l -> m (Context l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Context l -> m (Context l))
-> Data (Context l)
Context l -> Constr
Context l -> DataType
(forall b. Data b => b -> b) -> Context l -> Context l
forall l. Data l => Typeable (Context l)
forall l. Data l => Context l -> Constr
forall l. Data l => Context l -> DataType
forall l.
Data l =>
(forall b. Data b => b -> b) -> Context l -> Context l
forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> Context l -> u
forall l u.
Data l =>
(forall d. Data d => d -> u) -> Context l -> [u]
forall l r r'.
Data l =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Context l -> r
forall l r r'.
Data l =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Context l -> r
forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d) -> Context l -> m (Context l)
forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Context l -> m (Context l)
forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Context l)
forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Context l -> c (Context l)
forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Context l))
forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Context l))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Context l -> u
forall u. (forall d. Data d => d -> u) -> Context l -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Context l -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Context l -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Context l -> m (Context l)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Context l -> m (Context l)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Context l)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Context l -> c (Context l)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Context l))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Context l))
$cgfoldl :: forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Context l -> c (Context l)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Context l -> c (Context l)
$cgunfold :: forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Context l)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Context l)
$ctoConstr :: forall l. Data l => Context l -> Constr
toConstr :: Context l -> Constr
$cdataTypeOf :: forall l. Data l => Context l -> DataType
dataTypeOf :: Context l -> DataType
$cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Context l))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Context l))
$cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Context l))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Context l))
$cgmapT :: forall l.
Data l =>
(forall b. Data b => b -> b) -> Context l -> Context l
gmapT :: (forall b. Data b => b -> b) -> Context l -> Context l
$cgmapQl :: forall l r r'.
Data l =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Context l -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Context l -> r
$cgmapQr :: forall l r r'.
Data l =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Context l -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Context l -> r
$cgmapQ :: forall l u.
Data l =>
(forall d. Data d => d -> u) -> Context l -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Context l -> [u]
$cgmapQi :: forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> Context l -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Context l -> u
$cgmapM :: forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d) -> Context l -> m (Context l)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Context l -> m (Context l)
$cgmapMp :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Context l -> m (Context l)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Context l -> m (Context l)
$cgmapMo :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Context l -> m (Context l)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Context l -> m (Context l)
Data,(forall m. Monoid m => Context m -> m)
-> (forall m a. Monoid m => (a -> m) -> Context a -> m)
-> (forall m a. Monoid m => (a -> m) -> Context a -> m)
-> (forall a b. (a -> b -> b) -> b -> Context a -> b)
-> (forall a b. (a -> b -> b) -> b -> Context a -> b)
-> (forall b a. (b -> a -> b) -> b -> Context a -> b)
-> (forall b a. (b -> a -> b) -> b -> Context a -> b)
-> (forall a. (a -> a -> a) -> Context a -> a)
-> (forall a. (a -> a -> a) -> Context a -> a)
-> (forall a. Context a -> [a])
-> (forall a. Context a -> Bool)
-> (forall a. Context a -> Int)
-> (forall a. Eq a => a -> Context a -> Bool)
-> (forall a. Ord a => Context a -> a)
-> (forall a. Ord a => Context a -> a)
-> (forall a. Num a => Context a -> a)
-> (forall a. Num a => Context a -> a)
-> Foldable Context
forall a. Eq a => a -> Context a -> Bool
forall a. Num a => Context a -> a
forall a. Ord a => Context a -> a
forall m. Monoid m => Context m -> m
forall a. Context a -> Bool
forall a. Context a -> Int
forall a. Context a -> [a]
forall a. (a -> a -> a) -> Context a -> a
forall m a. Monoid m => (a -> m) -> Context a -> m
forall b a. (b -> a -> b) -> b -> Context a -> b
forall a b. (a -> b -> b) -> b -> Context a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall m. Monoid m => Context m -> m
fold :: forall m. Monoid m => Context m -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> Context a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> Context a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> Context a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> Context a -> m
$cfoldr :: forall a b. (a -> b -> b) -> b -> Context a -> b
foldr :: forall a b. (a -> b -> b) -> b -> Context a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> Context a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> Context a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> Context a -> b
foldl :: forall b a. (b -> a -> b) -> b -> Context a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> Context a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> Context a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> Context a -> a
foldr1 :: forall a. (a -> a -> a) -> Context a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> Context a -> a
foldl1 :: forall a. (a -> a -> a) -> Context a -> a
$ctoList :: forall a. Context a -> [a]
toList :: forall a. Context a -> [a]
$cnull :: forall a. Context a -> Bool
null :: forall a. Context a -> Bool
$clength :: forall a. Context a -> Int
length :: forall a. Context a -> Int
$celem :: forall a. Eq a => a -> Context a -> Bool
elem :: forall a. Eq a => a -> Context a -> Bool
$cmaximum :: forall a. Ord a => Context a -> a
maximum :: forall a. Ord a => Context a -> a
$cminimum :: forall a. Ord a => Context a -> a
minimum :: forall a. Ord a => Context a -> a
$csum :: forall a. Num a => Context a -> a
sum :: forall a. Num a => Context a -> a
$cproduct :: forall a. Num a => Context a -> a
product :: forall a. Num a => Context a -> a
Foldable,Functor Context
Foldable Context
(Functor Context, Foldable Context) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> Context a -> f (Context b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    Context (f a) -> f (Context a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Context a -> m (Context b))
-> (forall (m :: * -> *) a.
    Monad m =>
    Context (m a) -> m (Context a))
-> Traversable Context
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a. Monad m => Context (m a) -> m (Context a)
forall (f :: * -> *) a.
Applicative f =>
Context (f a) -> f (Context a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Context a -> m (Context b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Context a -> f (Context b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Context a -> f (Context b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Context a -> f (Context b)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
Context (f a) -> f (Context a)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
Context (f a) -> f (Context a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Context a -> m (Context b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Context a -> m (Context b)
$csequence :: forall (m :: * -> *) a. Monad m => Context (m a) -> m (Context a)
sequence :: forall (m :: * -> *) a. Monad m => Context (m a) -> m (Context a)
Traversable,(forall a b. (a -> b) -> Context a -> Context b)
-> (forall a b. a -> Context b -> Context a) -> Functor Context
forall a b. a -> Context b -> Context a
forall a b. (a -> b) -> Context a -> Context b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> Context a -> Context b
fmap :: forall a b. (a -> b) -> Context a -> Context b
$c<$ :: forall a b. a -> Context b -> Context a
<$ :: forall a b. a -> Context b -> Context a
Functor,(forall x. Context l -> Rep (Context l) x)
-> (forall x. Rep (Context l) x -> Context l)
-> Generic (Context l)
forall x. Rep (Context l) x -> Context l
forall x. Context l -> Rep (Context l) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall l x. Rep (Context l) x -> Context l
forall l x. Context l -> Rep (Context l) x
$cfrom :: forall l x. Context l -> Rep (Context l) x
from :: forall x. Context l -> Rep (Context l) x
$cto :: forall l x. Rep (Context l) x -> Context l
to :: forall x. Rep (Context l) x -> Context l
Generic)

-- | Class assertions.
data Asst l
        = TypeA l (Type l)                      -- ^ type assertion
        | IParam l (IPName l) (Type l)          -- ^ implicit parameter assertion
        | ParenA l (Asst l)                     -- ^ parenthesised class assertion
  deriving (Asst l -> Asst l -> Bool
(Asst l -> Asst l -> Bool)
-> (Asst l -> Asst l -> Bool) -> Eq (Asst l)
forall l. Eq l => Asst l -> Asst l -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall l. Eq l => Asst l -> Asst l -> Bool
== :: Asst l -> Asst l -> Bool
$c/= :: forall l. Eq l => Asst l -> Asst l -> Bool
/= :: Asst l -> Asst l -> Bool
Eq,Eq (Asst l)
Eq (Asst l) =>
(Asst l -> Asst l -> Ordering)
-> (Asst l -> Asst l -> Bool)
-> (Asst l -> Asst l -> Bool)
-> (Asst l -> Asst l -> Bool)
-> (Asst l -> Asst l -> Bool)
-> (Asst l -> Asst l -> Asst l)
-> (Asst l -> Asst l -> Asst l)
-> Ord (Asst l)
Asst l -> Asst l -> Bool
Asst l -> Asst l -> Ordering
Asst l -> Asst l -> Asst l
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall l. Ord l => Eq (Asst l)
forall l. Ord l => Asst l -> Asst l -> Bool
forall l. Ord l => Asst l -> Asst l -> Ordering
forall l. Ord l => Asst l -> Asst l -> Asst l
$ccompare :: forall l. Ord l => Asst l -> Asst l -> Ordering
compare :: Asst l -> Asst l -> Ordering
$c< :: forall l. Ord l => Asst l -> Asst l -> Bool
< :: Asst l -> Asst l -> Bool
$c<= :: forall l. Ord l => Asst l -> Asst l -> Bool
<= :: Asst l -> Asst l -> Bool
$c> :: forall l. Ord l => Asst l -> Asst l -> Bool
> :: Asst l -> Asst l -> Bool
$c>= :: forall l. Ord l => Asst l -> Asst l -> Bool
>= :: Asst l -> Asst l -> Bool
$cmax :: forall l. Ord l => Asst l -> Asst l -> Asst l
max :: Asst l -> Asst l -> Asst l
$cmin :: forall l. Ord l => Asst l -> Asst l -> Asst l
min :: Asst l -> Asst l -> Asst l
Ord,Int -> Asst l -> ShowS
[Asst l] -> ShowS
Asst l -> String
(Int -> Asst l -> ShowS)
-> (Asst l -> String) -> ([Asst l] -> ShowS) -> Show (Asst l)
forall l. Show l => Int -> Asst l -> ShowS
forall l. Show l => [Asst l] -> ShowS
forall l. Show l => Asst l -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall l. Show l => Int -> Asst l -> ShowS
showsPrec :: Int -> Asst l -> ShowS
$cshow :: forall l. Show l => Asst l -> String
show :: Asst l -> String
$cshowList :: forall l. Show l => [Asst l] -> ShowS
showList :: [Asst l] -> ShowS
Show,Typeable,Typeable (Asst l)
Typeable (Asst l) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Asst l -> c (Asst l))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Asst l))
-> (Asst l -> Constr)
-> (Asst l -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Asst l)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Asst l)))
-> ((forall b. Data b => b -> b) -> Asst l -> Asst l)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Asst l -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Asst l -> r)
-> (forall u. (forall d. Data d => d -> u) -> Asst l -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Asst l -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Asst l -> m (Asst l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Asst l -> m (Asst l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Asst l -> m (Asst l))
-> Data (Asst l)
Asst l -> Constr
Asst l -> DataType
(forall b. Data b => b -> b) -> Asst l -> Asst l
forall l. Data l => Typeable (Asst l)
forall l. Data l => Asst l -> Constr
forall l. Data l => Asst l -> DataType
forall l.
Data l =>
(forall b. Data b => b -> b) -> Asst l -> Asst l
forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> Asst l -> u
forall l u. Data l => (forall d. Data d => d -> u) -> Asst l -> [u]
forall l r r'.
Data l =>
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Asst l -> r
forall l r r'.
Data l =>
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Asst l -> r
forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d) -> Asst l -> m (Asst l)
forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Asst l -> m (Asst l)
forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Asst l)
forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Asst l -> c (Asst l)
forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Asst l))
forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Asst l))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Asst l -> u
forall u. (forall d. Data d => d -> u) -> Asst l -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Asst l -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Asst l -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Asst l -> m (Asst l)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Asst l -> m (Asst l)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Asst l)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Asst l -> c (Asst l)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Asst l))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Asst l))
$cgfoldl :: forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Asst l -> c (Asst l)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Asst l -> c (Asst l)
$cgunfold :: forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Asst l)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Asst l)
$ctoConstr :: forall l. Data l => Asst l -> Constr
toConstr :: Asst l -> Constr
$cdataTypeOf :: forall l. Data l => Asst l -> DataType
dataTypeOf :: Asst l -> DataType
$cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Asst l))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Asst l))
$cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Asst l))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Asst l))
$cgmapT :: forall l.
Data l =>
(forall b. Data b => b -> b) -> Asst l -> Asst l
gmapT :: (forall b. Data b => b -> b) -> Asst l -> Asst l
$cgmapQl :: forall l r r'.
Data l =>
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Asst l -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Asst l -> r
$cgmapQr :: forall l r r'.
Data l =>
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Asst l -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Asst l -> r
$cgmapQ :: forall l u. Data l => (forall d. Data d => d -> u) -> Asst l -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Asst l -> [u]
$cgmapQi :: forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> Asst l -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Asst l -> u
$cgmapM :: forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d) -> Asst l -> m (Asst l)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Asst l -> m (Asst l)
$cgmapMp :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Asst l -> m (Asst l)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Asst l -> m (Asst l)
$cgmapMo :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Asst l -> m (Asst l)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Asst l -> m (Asst l)
Data,(forall m. Monoid m => Asst m -> m)
-> (forall m a. Monoid m => (a -> m) -> Asst a -> m)
-> (forall m a. Monoid m => (a -> m) -> Asst a -> m)
-> (forall a b. (a -> b -> b) -> b -> Asst a -> b)
-> (forall a b. (a -> b -> b) -> b -> Asst a -> b)
-> (forall b a. (b -> a -> b) -> b -> Asst a -> b)
-> (forall b a. (b -> a -> b) -> b -> Asst a -> b)
-> (forall a. (a -> a -> a) -> Asst a -> a)
-> (forall a. (a -> a -> a) -> Asst a -> a)
-> (forall a. Asst a -> [a])
-> (forall a. Asst a -> Bool)
-> (forall a. Asst a -> Int)
-> (forall a. Eq a => a -> Asst a -> Bool)
-> (forall a. Ord a => Asst a -> a)
-> (forall a. Ord a => Asst a -> a)
-> (forall a. Num a => Asst a -> a)
-> (forall a. Num a => Asst a -> a)
-> Foldable Asst
forall a. Eq a => a -> Asst a -> Bool
forall a. Num a => Asst a -> a
forall a. Ord a => Asst a -> a
forall m. Monoid m => Asst m -> m
forall a. Asst a -> Bool
forall a. Asst a -> Int
forall a. Asst a -> [a]
forall a. (a -> a -> a) -> Asst a -> a
forall m a. Monoid m => (a -> m) -> Asst a -> m
forall b a. (b -> a -> b) -> b -> Asst a -> b
forall a b. (a -> b -> b) -> b -> Asst a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall m. Monoid m => Asst m -> m
fold :: forall m. Monoid m => Asst m -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> Asst a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> Asst a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> Asst a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> Asst a -> m
$cfoldr :: forall a b. (a -> b -> b) -> b -> Asst a -> b
foldr :: forall a b. (a -> b -> b) -> b -> Asst a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> Asst a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> Asst a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> Asst a -> b
foldl :: forall b a. (b -> a -> b) -> b -> Asst a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> Asst a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> Asst a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> Asst a -> a
foldr1 :: forall a. (a -> a -> a) -> Asst a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> Asst a -> a
foldl1 :: forall a. (a -> a -> a) -> Asst a -> a
$ctoList :: forall a. Asst a -> [a]
toList :: forall a. Asst a -> [a]
$cnull :: forall a. Asst a -> Bool
null :: forall a. Asst a -> Bool
$clength :: forall a. Asst a -> Int
length :: forall a. Asst a -> Int
$celem :: forall a. Eq a => a -> Asst a -> Bool
elem :: forall a. Eq a => a -> Asst a -> Bool
$cmaximum :: forall a. Ord a => Asst a -> a
maximum :: forall a. Ord a => Asst a -> a
$cminimum :: forall a. Ord a => Asst a -> a
minimum :: forall a. Ord a => Asst a -> a
$csum :: forall a. Num a => Asst a -> a
sum :: forall a. Num a => Asst a -> a
$cproduct :: forall a. Num a => Asst a -> a
product :: forall a. Num a => Asst a -> a
Foldable,Functor Asst
Foldable Asst
(Functor Asst, Foldable Asst) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> Asst a -> f (Asst b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    Asst (f a) -> f (Asst a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Asst a -> m (Asst b))
-> (forall (m :: * -> *) a. Monad m => Asst (m a) -> m (Asst a))
-> Traversable Asst
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a. Monad m => Asst (m a) -> m (Asst a)
forall (f :: * -> *) a. Applicative f => Asst (f a) -> f (Asst a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Asst a -> m (Asst b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Asst a -> f (Asst b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Asst a -> f (Asst b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Asst a -> f (Asst b)
$csequenceA :: forall (f :: * -> *) a. Applicative f => Asst (f a) -> f (Asst a)
sequenceA :: forall (f :: * -> *) a. Applicative f => Asst (f a) -> f (Asst a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Asst a -> m (Asst b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Asst a -> m (Asst b)
$csequence :: forall (m :: * -> *) a. Monad m => Asst (m a) -> m (Asst a)
sequence :: forall (m :: * -> *) a. Monad m => Asst (m a) -> m (Asst a)
Traversable,(forall a b. (a -> b) -> Asst a -> Asst b)
-> (forall a b. a -> Asst b -> Asst a) -> Functor Asst
forall a b. a -> Asst b -> Asst a
forall a b. (a -> b) -> Asst a -> Asst b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> Asst a -> Asst b
fmap :: forall a b. (a -> b) -> Asst a -> Asst b
$c<$ :: forall a b. a -> Asst b -> Asst a
<$ :: forall a b. a -> Asst b -> Asst a
Functor,(forall x. Asst l -> Rep (Asst l) x)
-> (forall x. Rep (Asst l) x -> Asst l) -> Generic (Asst l)
forall x. Rep (Asst l) x -> Asst l
forall x. Asst l -> Rep (Asst l) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall l x. Rep (Asst l) x -> Asst l
forall l x. Asst l -> Rep (Asst l) x
$cfrom :: forall l x. Asst l -> Rep (Asst l) x
from :: forall x. Asst l -> Rep (Asst l) x
$cto :: forall l x. Rep (Asst l) x -> Asst l
to :: forall x. Rep (Asst l) x -> Asst l
Generic)

-- | /literal/
-- Values of this type hold the abstract value of the literal, along with the
-- precise string representation used.  For example, @10@, @0o12@ and @0xa@
-- have the same value representation, but each carry a different string representation.
data Literal l
    = Char       l Char     String     -- ^ character literal
    | String     l String   String     -- ^ string literal
    | Int        l Integer  String     -- ^ integer literal
    | Frac       l Rational String     -- ^ floating point literal
    | PrimInt    l Integer  String     -- ^ unboxed integer literal
    | PrimWord   l Integer  String     -- ^ unboxed word literal
    | PrimFloat  l Rational String     -- ^ unboxed float literal
    | PrimDouble l Rational String     -- ^ unboxed double literal
    | PrimChar   l Char     String     -- ^ unboxed character literal
    | PrimString l String   String     -- ^ unboxed string literal
  deriving (Literal l -> Literal l -> Bool
(Literal l -> Literal l -> Bool)
-> (Literal l -> Literal l -> Bool) -> Eq (Literal l)
forall l. Eq l => Literal l -> Literal l -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall l. Eq l => Literal l -> Literal l -> Bool
== :: Literal l -> Literal l -> Bool
$c/= :: forall l. Eq l => Literal l -> Literal l -> Bool
/= :: Literal l -> Literal l -> Bool
Eq,Eq (Literal l)
Eq (Literal l) =>
(Literal l -> Literal l -> Ordering)
-> (Literal l -> Literal l -> Bool)
-> (Literal l -> Literal l -> Bool)
-> (Literal l -> Literal l -> Bool)
-> (Literal l -> Literal l -> Bool)
-> (Literal l -> Literal l -> Literal l)
-> (Literal l -> Literal l -> Literal l)
-> Ord (Literal l)
Literal l -> Literal l -> Bool
Literal l -> Literal l -> Ordering
Literal l -> Literal l -> Literal l
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall l. Ord l => Eq (Literal l)
forall l. Ord l => Literal l -> Literal l -> Bool
forall l. Ord l => Literal l -> Literal l -> Ordering
forall l. Ord l => Literal l -> Literal l -> Literal l
$ccompare :: forall l. Ord l => Literal l -> Literal l -> Ordering
compare :: Literal l -> Literal l -> Ordering
$c< :: forall l. Ord l => Literal l -> Literal l -> Bool
< :: Literal l -> Literal l -> Bool
$c<= :: forall l. Ord l => Literal l -> Literal l -> Bool
<= :: Literal l -> Literal l -> Bool
$c> :: forall l. Ord l => Literal l -> Literal l -> Bool
> :: Literal l -> Literal l -> Bool
$c>= :: forall l. Ord l => Literal l -> Literal l -> Bool
>= :: Literal l -> Literal l -> Bool
$cmax :: forall l. Ord l => Literal l -> Literal l -> Literal l
max :: Literal l -> Literal l -> Literal l
$cmin :: forall l. Ord l => Literal l -> Literal l -> Literal l
min :: Literal l -> Literal l -> Literal l
Ord,Int -> Literal l -> ShowS
[Literal l] -> ShowS
Literal l -> String
(Int -> Literal l -> ShowS)
-> (Literal l -> String)
-> ([Literal l] -> ShowS)
-> Show (Literal l)
forall l. Show l => Int -> Literal l -> ShowS
forall l. Show l => [Literal l] -> ShowS
forall l. Show l => Literal l -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall l. Show l => Int -> Literal l -> ShowS
showsPrec :: Int -> Literal l -> ShowS
$cshow :: forall l. Show l => Literal l -> String
show :: Literal l -> String
$cshowList :: forall l. Show l => [Literal l] -> ShowS
showList :: [Literal l] -> ShowS
Show,Typeable,Typeable (Literal l)
Typeable (Literal l) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Literal l -> c (Literal l))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Literal l))
-> (Literal l -> Constr)
-> (Literal l -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Literal l)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Literal l)))
-> ((forall b. Data b => b -> b) -> Literal l -> Literal l)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Literal l -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Literal l -> r)
-> (forall u. (forall d. Data d => d -> u) -> Literal l -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Literal l -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Literal l -> m (Literal l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Literal l -> m (Literal l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Literal l -> m (Literal l))
-> Data (Literal l)
Literal l -> Constr
Literal l -> DataType
(forall b. Data b => b -> b) -> Literal l -> Literal l
forall l. Data l => Typeable (Literal l)
forall l. Data l => Literal l -> Constr
forall l. Data l => Literal l -> DataType
forall l.
Data l =>
(forall b. Data b => b -> b) -> Literal l -> Literal l
forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> Literal l -> u
forall l u.
Data l =>
(forall d. Data d => d -> u) -> Literal l -> [u]
forall l r r'.
Data l =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Literal l -> r
forall l r r'.
Data l =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Literal l -> r
forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d) -> Literal l -> m (Literal l)
forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Literal l -> m (Literal l)
forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Literal l)
forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Literal l -> c (Literal l)
forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Literal l))
forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Literal l))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Literal l -> u
forall u. (forall d. Data d => d -> u) -> Literal l -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Literal l -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Literal l -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Literal l -> m (Literal l)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Literal l -> m (Literal l)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Literal l)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Literal l -> c (Literal l)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Literal l))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Literal l))
$cgfoldl :: forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Literal l -> c (Literal l)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Literal l -> c (Literal l)
$cgunfold :: forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Literal l)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Literal l)
$ctoConstr :: forall l. Data l => Literal l -> Constr
toConstr :: Literal l -> Constr
$cdataTypeOf :: forall l. Data l => Literal l -> DataType
dataTypeOf :: Literal l -> DataType
$cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Literal l))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Literal l))
$cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Literal l))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Literal l))
$cgmapT :: forall l.
Data l =>
(forall b. Data b => b -> b) -> Literal l -> Literal l
gmapT :: (forall b. Data b => b -> b) -> Literal l -> Literal l
$cgmapQl :: forall l r r'.
Data l =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Literal l -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Literal l -> r
$cgmapQr :: forall l r r'.
Data l =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Literal l -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Literal l -> r
$cgmapQ :: forall l u.
Data l =>
(forall d. Data d => d -> u) -> Literal l -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Literal l -> [u]
$cgmapQi :: forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> Literal l -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Literal l -> u
$cgmapM :: forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d) -> Literal l -> m (Literal l)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Literal l -> m (Literal l)
$cgmapMp :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Literal l -> m (Literal l)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Literal l -> m (Literal l)
$cgmapMo :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Literal l -> m (Literal l)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Literal l -> m (Literal l)
Data,(forall m. Monoid m => Literal m -> m)
-> (forall m a. Monoid m => (a -> m) -> Literal a -> m)
-> (forall m a. Monoid m => (a -> m) -> Literal a -> m)
-> (forall a b. (a -> b -> b) -> b -> Literal a -> b)
-> (forall a b. (a -> b -> b) -> b -> Literal a -> b)
-> (forall b a. (b -> a -> b) -> b -> Literal a -> b)
-> (forall b a. (b -> a -> b) -> b -> Literal a -> b)
-> (forall a. (a -> a -> a) -> Literal a -> a)
-> (forall a. (a -> a -> a) -> Literal a -> a)
-> (forall a. Literal a -> [a])
-> (forall a. Literal a -> Bool)
-> (forall a. Literal a -> Int)
-> (forall a. Eq a => a -> Literal a -> Bool)
-> (forall a. Ord a => Literal a -> a)
-> (forall a. Ord a => Literal a -> a)
-> (forall a. Num a => Literal a -> a)
-> (forall a. Num a => Literal a -> a)
-> Foldable Literal
forall a. Eq a => a -> Literal a -> Bool
forall a. Num a => Literal a -> a
forall a. Ord a => Literal a -> a
forall m. Monoid m => Literal m -> m
forall a. Literal a -> Bool
forall a. Literal a -> Int
forall a. Literal a -> [a]
forall a. (a -> a -> a) -> Literal a -> a
forall m a. Monoid m => (a -> m) -> Literal a -> m
forall b a. (b -> a -> b) -> b -> Literal a -> b
forall a b. (a -> b -> b) -> b -> Literal a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall m. Monoid m => Literal m -> m
fold :: forall m. Monoid m => Literal m -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> Literal a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> Literal a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> Literal a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> Literal a -> m
$cfoldr :: forall a b. (a -> b -> b) -> b -> Literal a -> b
foldr :: forall a b. (a -> b -> b) -> b -> Literal a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> Literal a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> Literal a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> Literal a -> b
foldl :: forall b a. (b -> a -> b) -> b -> Literal a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> Literal a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> Literal a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> Literal a -> a
foldr1 :: forall a. (a -> a -> a) -> Literal a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> Literal a -> a
foldl1 :: forall a. (a -> a -> a) -> Literal a -> a
$ctoList :: forall a. Literal a -> [a]
toList :: forall a. Literal a -> [a]
$cnull :: forall a. Literal a -> Bool
null :: forall a. Literal a -> Bool
$clength :: forall a. Literal a -> Int
length :: forall a. Literal a -> Int
$celem :: forall a. Eq a => a -> Literal a -> Bool
elem :: forall a. Eq a => a -> Literal a -> Bool
$cmaximum :: forall a. Ord a => Literal a -> a
maximum :: forall a. Ord a => Literal a -> a
$cminimum :: forall a. Ord a => Literal a -> a
minimum :: forall a. Ord a => Literal a -> a
$csum :: forall a. Num a => Literal a -> a
sum :: forall a. Num a => Literal a -> a
$cproduct :: forall a. Num a => Literal a -> a
product :: forall a. Num a => Literal a -> a
Foldable,Functor Literal
Foldable Literal
(Functor Literal, Foldable Literal) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> Literal a -> f (Literal b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    Literal (f a) -> f (Literal a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Literal a -> m (Literal b))
-> (forall (m :: * -> *) a.
    Monad m =>
    Literal (m a) -> m (Literal a))
-> Traversable Literal
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a. Monad m => Literal (m a) -> m (Literal a)
forall (f :: * -> *) a.
Applicative f =>
Literal (f a) -> f (Literal a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Literal a -> m (Literal b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Literal a -> f (Literal b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Literal a -> f (Literal b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Literal a -> f (Literal b)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
Literal (f a) -> f (Literal a)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
Literal (f a) -> f (Literal a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Literal a -> m (Literal b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Literal a -> m (Literal b)
$csequence :: forall (m :: * -> *) a. Monad m => Literal (m a) -> m (Literal a)
sequence :: forall (m :: * -> *) a. Monad m => Literal (m a) -> m (Literal a)
Traversable,(forall a b. (a -> b) -> Literal a -> Literal b)
-> (forall a b. a -> Literal b -> Literal a) -> Functor Literal
forall a b. a -> Literal b -> Literal a
forall a b. (a -> b) -> Literal a -> Literal b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> Literal a -> Literal b
fmap :: forall a b. (a -> b) -> Literal a -> Literal b
$c<$ :: forall a b. a -> Literal b -> Literal a
<$ :: forall a b. a -> Literal b -> Literal a
Functor,(forall x. Literal l -> Rep (Literal l) x)
-> (forall x. Rep (Literal l) x -> Literal l)
-> Generic (Literal l)
forall x. Rep (Literal l) x -> Literal l
forall x. Literal l -> Rep (Literal l) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall l x. Rep (Literal l) x -> Literal l
forall l x. Literal l -> Rep (Literal l) x
$cfrom :: forall l x. Literal l -> Rep (Literal l) x
from :: forall x. Literal l -> Rep (Literal l) x
$cto :: forall l x. Rep (Literal l) x -> Literal l
to :: forall x. Rep (Literal l) x -> Literal l
Generic)

-- | An indication whether a literal pattern has been negated or not.
data Sign l
    = Signless l
    | Negative l
  deriving (Sign l -> Sign l -> Bool
(Sign l -> Sign l -> Bool)
-> (Sign l -> Sign l -> Bool) -> Eq (Sign l)
forall l. Eq l => Sign l -> Sign l -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall l. Eq l => Sign l -> Sign l -> Bool
== :: Sign l -> Sign l -> Bool
$c/= :: forall l. Eq l => Sign l -> Sign l -> Bool
/= :: Sign l -> Sign l -> Bool
Eq,Eq (Sign l)
Eq (Sign l) =>
(Sign l -> Sign l -> Ordering)
-> (Sign l -> Sign l -> Bool)
-> (Sign l -> Sign l -> Bool)
-> (Sign l -> Sign l -> Bool)
-> (Sign l -> Sign l -> Bool)
-> (Sign l -> Sign l -> Sign l)
-> (Sign l -> Sign l -> Sign l)
-> Ord (Sign l)
Sign l -> Sign l -> Bool
Sign l -> Sign l -> Ordering
Sign l -> Sign l -> Sign l
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall l. Ord l => Eq (Sign l)
forall l. Ord l => Sign l -> Sign l -> Bool
forall l. Ord l => Sign l -> Sign l -> Ordering
forall l. Ord l => Sign l -> Sign l -> Sign l
$ccompare :: forall l. Ord l => Sign l -> Sign l -> Ordering
compare :: Sign l -> Sign l -> Ordering
$c< :: forall l. Ord l => Sign l -> Sign l -> Bool
< :: Sign l -> Sign l -> Bool
$c<= :: forall l. Ord l => Sign l -> Sign l -> Bool
<= :: Sign l -> Sign l -> Bool
$c> :: forall l. Ord l => Sign l -> Sign l -> Bool
> :: Sign l -> Sign l -> Bool
$c>= :: forall l. Ord l => Sign l -> Sign l -> Bool
>= :: Sign l -> Sign l -> Bool
$cmax :: forall l. Ord l => Sign l -> Sign l -> Sign l
max :: Sign l -> Sign l -> Sign l
$cmin :: forall l. Ord l => Sign l -> Sign l -> Sign l
min :: Sign l -> Sign l -> Sign l
Ord,Int -> Sign l -> ShowS
[Sign l] -> ShowS
Sign l -> String
(Int -> Sign l -> ShowS)
-> (Sign l -> String) -> ([Sign l] -> ShowS) -> Show (Sign l)
forall l. Show l => Int -> Sign l -> ShowS
forall l. Show l => [Sign l] -> ShowS
forall l. Show l => Sign l -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall l. Show l => Int -> Sign l -> ShowS
showsPrec :: Int -> Sign l -> ShowS
$cshow :: forall l. Show l => Sign l -> String
show :: Sign l -> String
$cshowList :: forall l. Show l => [Sign l] -> ShowS
showList :: [Sign l] -> ShowS
Show,Typeable,Typeable (Sign l)
Typeable (Sign l) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Sign l -> c (Sign l))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Sign l))
-> (Sign l -> Constr)
-> (Sign l -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Sign l)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Sign l)))
-> ((forall b. Data b => b -> b) -> Sign l -> Sign l)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Sign l -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Sign l -> r)
-> (forall u. (forall d. Data d => d -> u) -> Sign l -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Sign l -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Sign l -> m (Sign l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Sign l -> m (Sign l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Sign l -> m (Sign l))
-> Data (Sign l)
Sign l -> Constr
Sign l -> DataType
(forall b. Data b => b -> b) -> Sign l -> Sign l
forall l. Data l => Typeable (Sign l)
forall l. Data l => Sign l -> Constr
forall l. Data l => Sign l -> DataType
forall l.
Data l =>
(forall b. Data b => b -> b) -> Sign l -> Sign l
forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> Sign l -> u
forall l u. Data l => (forall d. Data d => d -> u) -> Sign l -> [u]
forall l r r'.
Data l =>
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Sign l -> r
forall l r r'.
Data l =>
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Sign l -> r
forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d) -> Sign l -> m (Sign l)
forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Sign l -> m (Sign l)
forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Sign l)
forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Sign l -> c (Sign l)
forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Sign l))
forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Sign l))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Sign l -> u
forall u. (forall d. Data d => d -> u) -> Sign l -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Sign l -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Sign l -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Sign l -> m (Sign l)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Sign l -> m (Sign l)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Sign l)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Sign l -> c (Sign l)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Sign l))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Sign l))
$cgfoldl :: forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Sign l -> c (Sign l)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Sign l -> c (Sign l)
$cgunfold :: forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Sign l)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Sign l)
$ctoConstr :: forall l. Data l => Sign l -> Constr
toConstr :: Sign l -> Constr
$cdataTypeOf :: forall l. Data l => Sign l -> DataType
dataTypeOf :: Sign l -> DataType
$cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Sign l))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Sign l))
$cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Sign l))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Sign l))
$cgmapT :: forall l.
Data l =>
(forall b. Data b => b -> b) -> Sign l -> Sign l
gmapT :: (forall b. Data b => b -> b) -> Sign l -> Sign l
$cgmapQl :: forall l r r'.
Data l =>
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Sign l -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Sign l -> r
$cgmapQr :: forall l r r'.
Data l =>
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Sign l -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Sign l -> r
$cgmapQ :: forall l u. Data l => (forall d. Data d => d -> u) -> Sign l -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Sign l -> [u]
$cgmapQi :: forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> Sign l -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Sign l -> u
$cgmapM :: forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d) -> Sign l -> m (Sign l)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Sign l -> m (Sign l)
$cgmapMp :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Sign l -> m (Sign l)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Sign l -> m (Sign l)
$cgmapMo :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Sign l -> m (Sign l)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Sign l -> m (Sign l)
Data,(forall m. Monoid m => Sign m -> m)
-> (forall m a. Monoid m => (a -> m) -> Sign a -> m)
-> (forall m a. Monoid m => (a -> m) -> Sign a -> m)
-> (forall a b. (a -> b -> b) -> b -> Sign a -> b)
-> (forall a b. (a -> b -> b) -> b -> Sign a -> b)
-> (forall b a. (b -> a -> b) -> b -> Sign a -> b)
-> (forall b a. (b -> a -> b) -> b -> Sign a -> b)
-> (forall a. (a -> a -> a) -> Sign a -> a)
-> (forall a. (a -> a -> a) -> Sign a -> a)
-> (forall a. Sign a -> [a])
-> (forall a. Sign a -> Bool)
-> (forall a. Sign a -> Int)
-> (forall a. Eq a => a -> Sign a -> Bool)
-> (forall a. Ord a => Sign a -> a)
-> (forall a. Ord a => Sign a -> a)
-> (forall a. Num a => Sign a -> a)
-> (forall a. Num a => Sign a -> a)
-> Foldable Sign
forall a. Eq a => a -> Sign a -> Bool
forall a. Num a => Sign a -> a
forall a. Ord a => Sign a -> a
forall m. Monoid m => Sign m -> m
forall a. Sign a -> Bool
forall a. Sign a -> Int
forall a. Sign a -> [a]
forall a. (a -> a -> a) -> Sign a -> a
forall m a. Monoid m => (a -> m) -> Sign a -> m
forall b a. (b -> a -> b) -> b -> Sign a -> b
forall a b. (a -> b -> b) -> b -> Sign a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall m. Monoid m => Sign m -> m
fold :: forall m. Monoid m => Sign m -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> Sign a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> Sign a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> Sign a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> Sign a -> m
$cfoldr :: forall a b. (a -> b -> b) -> b -> Sign a -> b
foldr :: forall a b. (a -> b -> b) -> b -> Sign a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> Sign a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> Sign a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> Sign a -> b
foldl :: forall b a. (b -> a -> b) -> b -> Sign a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> Sign a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> Sign a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> Sign a -> a
foldr1 :: forall a. (a -> a -> a) -> Sign a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> Sign a -> a
foldl1 :: forall a. (a -> a -> a) -> Sign a -> a
$ctoList :: forall a. Sign a -> [a]
toList :: forall a. Sign a -> [a]
$cnull :: forall a. Sign a -> Bool
null :: forall a. Sign a -> Bool
$clength :: forall a. Sign a -> Int
length :: forall a. Sign a -> Int
$celem :: forall a. Eq a => a -> Sign a -> Bool
elem :: forall a. Eq a => a -> Sign a -> Bool
$cmaximum :: forall a. Ord a => Sign a -> a
maximum :: forall a. Ord a => Sign a -> a
$cminimum :: forall a. Ord a => Sign a -> a
minimum :: forall a. Ord a => Sign a -> a
$csum :: forall a. Num a => Sign a -> a
sum :: forall a. Num a => Sign a -> a
$cproduct :: forall a. Num a => Sign a -> a
product :: forall a. Num a => Sign a -> a
Foldable,Functor Sign
Foldable Sign
(Functor Sign, Foldable Sign) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> Sign a -> f (Sign b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    Sign (f a) -> f (Sign a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Sign a -> m (Sign b))
-> (forall (m :: * -> *) a. Monad m => Sign (m a) -> m (Sign a))
-> Traversable Sign
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a. Monad m => Sign (m a) -> m (Sign a)
forall (f :: * -> *) a. Applicative f => Sign (f a) -> f (Sign a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Sign a -> m (Sign b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Sign a -> f (Sign b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Sign a -> f (Sign b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Sign a -> f (Sign b)
$csequenceA :: forall (f :: * -> *) a. Applicative f => Sign (f a) -> f (Sign a)
sequenceA :: forall (f :: * -> *) a. Applicative f => Sign (f a) -> f (Sign a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Sign a -> m (Sign b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Sign a -> m (Sign b)
$csequence :: forall (m :: * -> *) a. Monad m => Sign (m a) -> m (Sign a)
sequence :: forall (m :: * -> *) a. Monad m => Sign (m a) -> m (Sign a)
Traversable,(forall a b. (a -> b) -> Sign a -> Sign b)
-> (forall a b. a -> Sign b -> Sign a) -> Functor Sign
forall a b. a -> Sign b -> Sign a
forall a b. (a -> b) -> Sign a -> Sign b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> Sign a -> Sign b
fmap :: forall a b. (a -> b) -> Sign a -> Sign b
$c<$ :: forall a b. a -> Sign b -> Sign a
<$ :: forall a b. a -> Sign b -> Sign a
Functor,(forall x. Sign l -> Rep (Sign l) x)
-> (forall x. Rep (Sign l) x -> Sign l) -> Generic (Sign l)
forall x. Rep (Sign l) x -> Sign l
forall x. Sign l -> Rep (Sign l) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall l x. Rep (Sign l) x -> Sign l
forall l x. Sign l -> Rep (Sign l) x
$cfrom :: forall l x. Sign l -> Rep (Sign l) x
from :: forall x. Sign l -> Rep (Sign l) x
$cto :: forall l x. Rep (Sign l) x -> Sign l
to :: forall x. Rep (Sign l) x -> Sign l
Generic)

-- | Haskell expressions.
data Exp l
    = Var l (QName l)                       -- ^ variable
    | OverloadedLabel l String              -- ^ Overloaded label #foo
    | IPVar l (IPName l)                    -- ^ implicit parameter variable
    | Con l (QName l)                       -- ^ data constructor
    | Lit l (Literal l)                     -- ^ literal constant
    | InfixApp l (Exp l) (QOp l) (Exp l)    -- ^ infix application
    | App l (Exp l) (Exp l)                 -- ^ ordinary application
    | NegApp l (Exp l)                      -- ^ negation expression @-/exp/@ (unary minus)
    | Lambda l [Pat l] (Exp l)              -- ^ lambda expression
    | Let l (Binds l) (Exp l)               -- ^ local declarations with @let@ ... @in@ ...
    | If l (Exp l) (Exp l) (Exp l)          -- ^ @if@ /exp/ @then@ /exp/ @else@ /exp/
    | MultiIf l [GuardedRhs l]              -- ^ @if@ @|@ /stmts/ @->@ /exp/ ...
    | Case l (Exp l) [Alt l]                -- ^ @case@ /exp/ @of@ /alts/
    | Do l [Stmt l]                         -- ^ @do@-expression:
                                            --   the last statement in the list
                                            --   should be an expression.
    | MDo l [Stmt l]                        -- ^ @mdo@-expression
    | Tuple l Boxed [Exp l]                 -- ^ tuple expression
    | UnboxedSum l Int Int (Exp l)          -- ^ unboxed sum
    | TupleSection l Boxed [Maybe (Exp l)]  -- ^ tuple section expression, e.g. @(,,3)@
    | List l [Exp l]                        -- ^ list expression
    | ParArray l [Exp l]                    -- ^ parallel array expression
    | Paren l (Exp l)                       -- ^ parenthesised expression
    | LeftSection l (Exp l) (QOp l)         -- ^ left section @(@/exp/ /qop/@)@
    | RightSection l (QOp l) (Exp l)        -- ^ right section @(@/qop/ /exp/@)@
    | RecConstr l (QName l) [FieldUpdate l] -- ^ record construction expression
    | RecUpdate l (Exp l)   [FieldUpdate l] -- ^ record update expression
    | EnumFrom l (Exp l)                    -- ^ unbounded arithmetic sequence,
                                            --   incrementing by 1: @[from ..]@
    | EnumFromTo l (Exp l) (Exp l)          -- ^ bounded arithmetic sequence,
                                            --   incrementing by 1 @[from .. to]@
    | EnumFromThen l (Exp l) (Exp l)        -- ^ unbounded arithmetic sequence,
                                            --   with first two elements given @[from, then ..]@
    | EnumFromThenTo l (Exp l) (Exp l) (Exp l)
                                            -- ^ bounded arithmetic sequence,
                                            --   with first two elements given @[from, then .. to]@
    | ParArrayFromTo l (Exp l) (Exp l)      -- ^ Parallel array bounded arithmetic sequence,
                                            --   incrementing by 1 @[:from .. to:]@
    | ParArrayFromThenTo l (Exp l) (Exp l) (Exp l)
                                            -- ^ bounded arithmetic sequence,
                                            --   with first two elements given @[:from, then .. to:]@
    | ListComp l (Exp l) [QualStmt l]       -- ^ ordinary list comprehension
    | ParComp  l (Exp l) [[QualStmt l]]     -- ^ parallel list comprehension
    | ParArrayComp  l (Exp l) [[QualStmt l]] -- ^ parallel array comprehension
    | ExpTypeSig l (Exp l) (Type l)         -- ^ expression with explicit type signature

    | VarQuote l (QName l)                  -- ^ @'x@ for template haskell reifying of expressions
    | TypQuote l (QName l)                  -- ^ @''T@ for template haskell reifying of types
    | BracketExp l (Bracket l)              -- ^ template haskell bracket expression
    | SpliceExp l (Splice l)                -- ^ template haskell splice expression
    | QuasiQuote l String String            -- ^ quasi-quotaion: @[$/name/| /string/ |]@
    | TypeApp l (Type l)                    -- ^ Visible type application

-- Hsx
    | XTag l (XName l) [XAttr l] (Maybe (Exp l)) [Exp l]
                                            -- ^ xml element, with attributes and children
    | XETag l (XName l) [XAttr l] (Maybe (Exp l))
                                            -- ^ empty xml element, with attributes
    | XPcdata l String                      -- ^ PCDATA child element
    | XExpTag l (Exp l)                     -- ^ escaped haskell expression inside xml
    | XChildTag l [Exp l]                   -- ^ children of an xml element


-- Pragmas
    | CorePragma l      String (Exp l)      -- ^ CORE pragma
    | SCCPragma  l      String (Exp l)      -- ^ SCC pragma
    | GenPragma  l      String (Int, Int) (Int, Int) (Exp l)
                                            -- ^ GENERATED pragma

-- Arrows
    | Proc            l (Pat l) (Exp l)     -- ^ arrows proc: @proc@ /pat/ @->@ /exp/
    | LeftArrApp      l (Exp l) (Exp l)     -- ^ arrow application (from left): /exp/ @-<@ /exp/
    | RightArrApp     l (Exp l) (Exp l)     -- ^ arrow application (from right): /exp/ @>-@ /exp/
    | LeftArrHighApp  l (Exp l) (Exp l)     -- ^ higher-order arrow application (from left): /exp/ @-<<@ /exp/
    | RightArrHighApp l (Exp l) (Exp l)     -- ^ higher-order arrow application (from right): /exp/ @>>-@ /exp/
    | ArrOp           l (Exp l)             -- ^ arrow control operators: @(| /exp/ |)@

-- LambdaCase
    | LCase l [Alt l]                       -- ^ @\case@ /alts/

  deriving (Exp l -> Exp l -> Bool
(Exp l -> Exp l -> Bool) -> (Exp l -> Exp l -> Bool) -> Eq (Exp l)
forall l. Eq l => Exp l -> Exp l -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall l. Eq l => Exp l -> Exp l -> Bool
== :: Exp l -> Exp l -> Bool
$c/= :: forall l. Eq l => Exp l -> Exp l -> Bool
/= :: Exp l -> Exp l -> Bool
Eq,Eq (Exp l)
Eq (Exp l) =>
(Exp l -> Exp l -> Ordering)
-> (Exp l -> Exp l -> Bool)
-> (Exp l -> Exp l -> Bool)
-> (Exp l -> Exp l -> Bool)
-> (Exp l -> Exp l -> Bool)
-> (Exp l -> Exp l -> Exp l)
-> (Exp l -> Exp l -> Exp l)
-> Ord (Exp l)
Exp l -> Exp l -> Bool
Exp l -> Exp l -> Ordering
Exp l -> Exp l -> Exp l
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall l. Ord l => Eq (Exp l)
forall l. Ord l => Exp l -> Exp l -> Bool
forall l. Ord l => Exp l -> Exp l -> Ordering
forall l. Ord l => Exp l -> Exp l -> Exp l
$ccompare :: forall l. Ord l => Exp l -> Exp l -> Ordering
compare :: Exp l -> Exp l -> Ordering
$c< :: forall l. Ord l => Exp l -> Exp l -> Bool
< :: Exp l -> Exp l -> Bool
$c<= :: forall l. Ord l => Exp l -> Exp l -> Bool
<= :: Exp l -> Exp l -> Bool
$c> :: forall l. Ord l => Exp l -> Exp l -> Bool
> :: Exp l -> Exp l -> Bool
$c>= :: forall l. Ord l => Exp l -> Exp l -> Bool
>= :: Exp l -> Exp l -> Bool
$cmax :: forall l. Ord l => Exp l -> Exp l -> Exp l
max :: Exp l -> Exp l -> Exp l
$cmin :: forall l. Ord l => Exp l -> Exp l -> Exp l
min :: Exp l -> Exp l -> Exp l
Ord,Int -> Exp l -> ShowS
[Exp l] -> ShowS
Exp l -> String
(Int -> Exp l -> ShowS)
-> (Exp l -> String) -> ([Exp l] -> ShowS) -> Show (Exp l)
forall l. Show l => Int -> Exp l -> ShowS
forall l. Show l => [Exp l] -> ShowS
forall l. Show l => Exp l -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall l. Show l => Int -> Exp l -> ShowS
showsPrec :: Int -> Exp l -> ShowS
$cshow :: forall l. Show l => Exp l -> String
show :: Exp l -> String
$cshowList :: forall l. Show l => [Exp l] -> ShowS
showList :: [Exp l] -> ShowS
Show,Typeable,Typeable (Exp l)
Typeable (Exp l) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Exp l -> c (Exp l))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Exp l))
-> (Exp l -> Constr)
-> (Exp l -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Exp l)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Exp l)))
-> ((forall b. Data b => b -> b) -> Exp l -> Exp l)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Exp l -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Exp l -> r)
-> (forall u. (forall d. Data d => d -> u) -> Exp l -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Exp l -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Exp l -> m (Exp l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Exp l -> m (Exp l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Exp l -> m (Exp l))
-> Data (Exp l)
Exp l -> Constr
Exp l -> DataType
(forall b. Data b => b -> b) -> Exp l -> Exp l
forall l. Data l => Typeable (Exp l)
forall l. Data l => Exp l -> Constr
forall l. Data l => Exp l -> DataType
forall l. Data l => (forall b. Data b => b -> b) -> Exp l -> Exp l
forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> Exp l -> u
forall l u. Data l => (forall d. Data d => d -> u) -> Exp l -> [u]
forall l r r'.
Data l =>
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Exp l -> r
forall l r r'.
Data l =>
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Exp l -> r
forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d) -> Exp l -> m (Exp l)
forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Exp l -> m (Exp l)
forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Exp l)
forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Exp l -> c (Exp l)
forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Exp l))
forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Exp l))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Exp l -> u
forall u. (forall d. Data d => d -> u) -> Exp l -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Exp l -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Exp l -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Exp l -> m (Exp l)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Exp l -> m (Exp l)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Exp l)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Exp l -> c (Exp l)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Exp l))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Exp l))
$cgfoldl :: forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Exp l -> c (Exp l)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Exp l -> c (Exp l)
$cgunfold :: forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Exp l)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Exp l)
$ctoConstr :: forall l. Data l => Exp l -> Constr
toConstr :: Exp l -> Constr
$cdataTypeOf :: forall l. Data l => Exp l -> DataType
dataTypeOf :: Exp l -> DataType
$cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Exp l))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Exp l))
$cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Exp l))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Exp l))
$cgmapT :: forall l. Data l => (forall b. Data b => b -> b) -> Exp l -> Exp l
gmapT :: (forall b. Data b => b -> b) -> Exp l -> Exp l
$cgmapQl :: forall l r r'.
Data l =>
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Exp l -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Exp l -> r
$cgmapQr :: forall l r r'.
Data l =>
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Exp l -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Exp l -> r
$cgmapQ :: forall l u. Data l => (forall d. Data d => d -> u) -> Exp l -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Exp l -> [u]
$cgmapQi :: forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> Exp l -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Exp l -> u
$cgmapM :: forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d) -> Exp l -> m (Exp l)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Exp l -> m (Exp l)
$cgmapMp :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Exp l -> m (Exp l)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Exp l -> m (Exp l)
$cgmapMo :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Exp l -> m (Exp l)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Exp l -> m (Exp l)
Data,(forall m. Monoid m => Exp m -> m)
-> (forall m a. Monoid m => (a -> m) -> Exp a -> m)
-> (forall m a. Monoid m => (a -> m) -> Exp a -> m)
-> (forall a b. (a -> b -> b) -> b -> Exp a -> b)
-> (forall a b. (a -> b -> b) -> b -> Exp a -> b)
-> (forall b a. (b -> a -> b) -> b -> Exp a -> b)
-> (forall b a. (b -> a -> b) -> b -> Exp a -> b)
-> (forall a. (a -> a -> a) -> Exp a -> a)
-> (forall a. (a -> a -> a) -> Exp a -> a)
-> (forall a. Exp a -> [a])
-> (forall a. Exp a -> Bool)
-> (forall a. Exp a -> Int)
-> (forall a. Eq a => a -> Exp a -> Bool)
-> (forall a. Ord a => Exp a -> a)
-> (forall a. Ord a => Exp a -> a)
-> (forall a. Num a => Exp a -> a)
-> (forall a. Num a => Exp a -> a)
-> Foldable Exp
forall a. Eq a => a -> Exp a -> Bool
forall a. Num a => Exp a -> a
forall a. Ord a => Exp a -> a
forall m. Monoid m => Exp m -> m
forall a. Exp a -> Bool
forall a. Exp a -> Int
forall a. Exp a -> [a]
forall a. (a -> a -> a) -> Exp a -> a
forall m a. Monoid m => (a -> m) -> Exp a -> m
forall b a. (b -> a -> b) -> b -> Exp a -> b
forall a b. (a -> b -> b) -> b -> Exp a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall m. Monoid m => Exp m -> m
fold :: forall m. Monoid m => Exp m -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> Exp a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> Exp a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> Exp a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> Exp a -> m
$cfoldr :: forall a b. (a -> b -> b) -> b -> Exp a -> b
foldr :: forall a b. (a -> b -> b) -> b -> Exp a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> Exp a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> Exp a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> Exp a -> b
foldl :: forall b a. (b -> a -> b) -> b -> Exp a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> Exp a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> Exp a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> Exp a -> a
foldr1 :: forall a. (a -> a -> a) -> Exp a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> Exp a -> a
foldl1 :: forall a. (a -> a -> a) -> Exp a -> a
$ctoList :: forall a. Exp a -> [a]
toList :: forall a. Exp a -> [a]
$cnull :: forall a. Exp a -> Bool
null :: forall a. Exp a -> Bool
$clength :: forall a. Exp a -> Int
length :: forall a. Exp a -> Int
$celem :: forall a. Eq a => a -> Exp a -> Bool
elem :: forall a. Eq a => a -> Exp a -> Bool
$cmaximum :: forall a. Ord a => Exp a -> a
maximum :: forall a. Ord a => Exp a -> a
$cminimum :: forall a. Ord a => Exp a -> a
minimum :: forall a. Ord a => Exp a -> a
$csum :: forall a. Num a => Exp a -> a
sum :: forall a. Num a => Exp a -> a
$cproduct :: forall a. Num a => Exp a -> a
product :: forall a. Num a => Exp a -> a
Foldable,Functor Exp
Foldable Exp
(Functor Exp, Foldable Exp) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> Exp a -> f (Exp b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    Exp (f a) -> f (Exp a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Exp a -> m (Exp b))
-> (forall (m :: * -> *) a. Monad m => Exp (m a) -> m (Exp a))
-> Traversable Exp
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a. Monad m => Exp (m a) -> m (Exp a)
forall (f :: * -> *) a. Applicative f => Exp (f a) -> f (Exp a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Exp a -> m (Exp b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Exp a -> f (Exp b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Exp a -> f (Exp b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Exp a -> f (Exp b)
$csequenceA :: forall (f :: * -> *) a. Applicative f => Exp (f a) -> f (Exp a)
sequenceA :: forall (f :: * -> *) a. Applicative f => Exp (f a) -> f (Exp a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Exp a -> m (Exp b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Exp a -> m (Exp b)
$csequence :: forall (m :: * -> *) a. Monad m => Exp (m a) -> m (Exp a)
sequence :: forall (m :: * -> *) a. Monad m => Exp (m a) -> m (Exp a)
Traversable,(forall a b. (a -> b) -> Exp a -> Exp b)
-> (forall a b. a -> Exp b -> Exp a) -> Functor Exp
forall a b. a -> Exp b -> Exp a
forall a b. (a -> b) -> Exp a -> Exp b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> Exp a -> Exp b
fmap :: forall a b. (a -> b) -> Exp a -> Exp b
$c<$ :: forall a b. a -> Exp b -> Exp a
<$ :: forall a b. a -> Exp b -> Exp a
Functor,(forall x. Exp l -> Rep (Exp l) x)
-> (forall x. Rep (Exp l) x -> Exp l) -> Generic (Exp l)
forall x. Rep (Exp l) x -> Exp l
forall x. Exp l -> Rep (Exp l) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall l x. Rep (Exp l) x -> Exp l
forall l x. Exp l -> Rep (Exp l) x
$cfrom :: forall l x. Exp l -> Rep (Exp l) x
from :: forall x. Exp l -> Rep (Exp l) x
$cto :: forall l x. Rep (Exp l) x -> Exp l
to :: forall x. Rep (Exp l) x -> Exp l
Generic)

-- | The name of an xml element or attribute,
--   possibly qualified with a namespace.
data XName l
    = XName l String              -- <name ...
    | XDomName l String String    -- <dom:name ...
  deriving (XName l -> XName l -> Bool
(XName l -> XName l -> Bool)
-> (XName l -> XName l -> Bool) -> Eq (XName l)
forall l. Eq l => XName l -> XName l -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall l. Eq l => XName l -> XName l -> Bool
== :: XName l -> XName l -> Bool
$c/= :: forall l. Eq l => XName l -> XName l -> Bool
/= :: XName l -> XName l -> Bool
Eq,Eq (XName l)
Eq (XName l) =>
(XName l -> XName l -> Ordering)
-> (XName l -> XName l -> Bool)
-> (XName l -> XName l -> Bool)
-> (XName l -> XName l -> Bool)
-> (XName l -> XName l -> Bool)
-> (XName l -> XName l -> XName l)
-> (XName l -> XName l -> XName l)
-> Ord (XName l)
XName l -> XName l -> Bool
XName l -> XName l -> Ordering
XName l -> XName l -> XName l
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall l. Ord l => Eq (XName l)
forall l. Ord l => XName l -> XName l -> Bool
forall l. Ord l => XName l -> XName l -> Ordering
forall l. Ord l => XName l -> XName l -> XName l
$ccompare :: forall l. Ord l => XName l -> XName l -> Ordering
compare :: XName l -> XName l -> Ordering
$c< :: forall l. Ord l => XName l -> XName l -> Bool
< :: XName l -> XName l -> Bool
$c<= :: forall l. Ord l => XName l -> XName l -> Bool
<= :: XName l -> XName l -> Bool
$c> :: forall l. Ord l => XName l -> XName l -> Bool
> :: XName l -> XName l -> Bool
$c>= :: forall l. Ord l => XName l -> XName l -> Bool
>= :: XName l -> XName l -> Bool
$cmax :: forall l. Ord l => XName l -> XName l -> XName l
max :: XName l -> XName l -> XName l
$cmin :: forall l. Ord l => XName l -> XName l -> XName l
min :: XName l -> XName l -> XName l
Ord,Int -> XName l -> ShowS
[XName l] -> ShowS
XName l -> String
(Int -> XName l -> ShowS)
-> (XName l -> String) -> ([XName l] -> ShowS) -> Show (XName l)
forall l. Show l => Int -> XName l -> ShowS
forall l. Show l => [XName l] -> ShowS
forall l. Show l => XName l -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall l. Show l => Int -> XName l -> ShowS
showsPrec :: Int -> XName l -> ShowS
$cshow :: forall l. Show l => XName l -> String
show :: XName l -> String
$cshowList :: forall l. Show l => [XName l] -> ShowS
showList :: [XName l] -> ShowS
Show,Typeable,Typeable (XName l)
Typeable (XName l) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> XName l -> c (XName l))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (XName l))
-> (XName l -> Constr)
-> (XName l -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (XName l)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (XName l)))
-> ((forall b. Data b => b -> b) -> XName l -> XName l)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> XName l -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> XName l -> r)
-> (forall u. (forall d. Data d => d -> u) -> XName l -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> XName l -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> XName l -> m (XName l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> XName l -> m (XName l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> XName l -> m (XName l))
-> Data (XName l)
XName l -> Constr
XName l -> DataType
(forall b. Data b => b -> b) -> XName l -> XName l
forall l. Data l => Typeable (XName l)
forall l. Data l => XName l -> Constr
forall l. Data l => XName l -> DataType
forall l.
Data l =>
(forall b. Data b => b -> b) -> XName l -> XName l
forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> XName l -> u
forall l u.
Data l =>
(forall d. Data d => d -> u) -> XName l -> [u]
forall l r r'.
Data l =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> XName l -> r
forall l r r'.
Data l =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> XName l -> r
forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d) -> XName l -> m (XName l)
forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> XName l -> m (XName l)
forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (XName l)
forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> XName l -> c (XName l)
forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (XName l))
forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (XName l))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> XName l -> u
forall u. (forall d. Data d => d -> u) -> XName l -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> XName l -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> XName l -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> XName l -> m (XName l)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> XName l -> m (XName l)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (XName l)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> XName l -> c (XName l)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (XName l))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (XName l))
$cgfoldl :: forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> XName l -> c (XName l)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> XName l -> c (XName l)
$cgunfold :: forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (XName l)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (XName l)
$ctoConstr :: forall l. Data l => XName l -> Constr
toConstr :: XName l -> Constr
$cdataTypeOf :: forall l. Data l => XName l -> DataType
dataTypeOf :: XName l -> DataType
$cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (XName l))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (XName l))
$cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (XName l))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (XName l))
$cgmapT :: forall l.
Data l =>
(forall b. Data b => b -> b) -> XName l -> XName l
gmapT :: (forall b. Data b => b -> b) -> XName l -> XName l
$cgmapQl :: forall l r r'.
Data l =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> XName l -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> XName l -> r
$cgmapQr :: forall l r r'.
Data l =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> XName l -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> XName l -> r
$cgmapQ :: forall l u.
Data l =>
(forall d. Data d => d -> u) -> XName l -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> XName l -> [u]
$cgmapQi :: forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> XName l -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> XName l -> u
$cgmapM :: forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d) -> XName l -> m (XName l)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> XName l -> m (XName l)
$cgmapMp :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> XName l -> m (XName l)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> XName l -> m (XName l)
$cgmapMo :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> XName l -> m (XName l)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> XName l -> m (XName l)
Data,(forall m. Monoid m => XName m -> m)
-> (forall m a. Monoid m => (a -> m) -> XName a -> m)
-> (forall m a. Monoid m => (a -> m) -> XName a -> m)
-> (forall a b. (a -> b -> b) -> b -> XName a -> b)
-> (forall a b. (a -> b -> b) -> b -> XName a -> b)
-> (forall b a. (b -> a -> b) -> b -> XName a -> b)
-> (forall b a. (b -> a -> b) -> b -> XName a -> b)
-> (forall a. (a -> a -> a) -> XName a -> a)
-> (forall a. (a -> a -> a) -> XName a -> a)
-> (forall a. XName a -> [a])
-> (forall a. XName a -> Bool)
-> (forall a. XName a -> Int)
-> (forall a. Eq a => a -> XName a -> Bool)
-> (forall a. Ord a => XName a -> a)
-> (forall a. Ord a => XName a -> a)
-> (forall a. Num a => XName a -> a)
-> (forall a. Num a => XName a -> a)
-> Foldable XName
forall a. Eq a => a -> XName a -> Bool
forall a. Num a => XName a -> a
forall a. Ord a => XName a -> a
forall m. Monoid m => XName m -> m
forall a. XName a -> Bool
forall a. XName a -> Int
forall a. XName a -> [a]
forall a. (a -> a -> a) -> XName a -> a
forall m a. Monoid m => (a -> m) -> XName a -> m
forall b a. (b -> a -> b) -> b -> XName a -> b
forall a b. (a -> b -> b) -> b -> XName a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall m. Monoid m => XName m -> m
fold :: forall m. Monoid m => XName m -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> XName a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> XName a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> XName a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> XName a -> m
$cfoldr :: forall a b. (a -> b -> b) -> b -> XName a -> b
foldr :: forall a b. (a -> b -> b) -> b -> XName a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> XName a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> XName a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> XName a -> b
foldl :: forall b a. (b -> a -> b) -> b -> XName a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> XName a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> XName a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> XName a -> a
foldr1 :: forall a. (a -> a -> a) -> XName a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> XName a -> a
foldl1 :: forall a. (a -> a -> a) -> XName a -> a
$ctoList :: forall a. XName a -> [a]
toList :: forall a. XName a -> [a]
$cnull :: forall a. XName a -> Bool
null :: forall a. XName a -> Bool
$clength :: forall a. XName a -> Int
length :: forall a. XName a -> Int
$celem :: forall a. Eq a => a -> XName a -> Bool
elem :: forall a. Eq a => a -> XName a -> Bool
$cmaximum :: forall a. Ord a => XName a -> a
maximum :: forall a. Ord a => XName a -> a
$cminimum :: forall a. Ord a => XName a -> a
minimum :: forall a. Ord a => XName a -> a
$csum :: forall a. Num a => XName a -> a
sum :: forall a. Num a => XName a -> a
$cproduct :: forall a. Num a => XName a -> a
product :: forall a. Num a => XName a -> a
Foldable,Functor XName
Foldable XName
(Functor XName, Foldable XName) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> XName a -> f (XName b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    XName (f a) -> f (XName a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> XName a -> m (XName b))
-> (forall (m :: * -> *) a. Monad m => XName (m a) -> m (XName a))
-> Traversable XName
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a. Monad m => XName (m a) -> m (XName a)
forall (f :: * -> *) a. Applicative f => XName (f a) -> f (XName a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> XName a -> m (XName b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> XName a -> f (XName b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> XName a -> f (XName b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> XName a -> f (XName b)
$csequenceA :: forall (f :: * -> *) a. Applicative f => XName (f a) -> f (XName a)
sequenceA :: forall (f :: * -> *) a. Applicative f => XName (f a) -> f (XName a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> XName a -> m (XName b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> XName a -> m (XName b)
$csequence :: forall (m :: * -> *) a. Monad m => XName (m a) -> m (XName a)
sequence :: forall (m :: * -> *) a. Monad m => XName (m a) -> m (XName a)
Traversable,(forall a b. (a -> b) -> XName a -> XName b)
-> (forall a b. a -> XName b -> XName a) -> Functor XName
forall a b. a -> XName b -> XName a
forall a b. (a -> b) -> XName a -> XName b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> XName a -> XName b
fmap :: forall a b. (a -> b) -> XName a -> XName b
$c<$ :: forall a b. a -> XName b -> XName a
<$ :: forall a b. a -> XName b -> XName a
Functor,(forall x. XName l -> Rep (XName l) x)
-> (forall x. Rep (XName l) x -> XName l) -> Generic (XName l)
forall x. Rep (XName l) x -> XName l
forall x. XName l -> Rep (XName l) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall l x. Rep (XName l) x -> XName l
forall l x. XName l -> Rep (XName l) x
$cfrom :: forall l x. XName l -> Rep (XName l) x
from :: forall x. XName l -> Rep (XName l) x
$cto :: forall l x. Rep (XName l) x -> XName l
to :: forall x. Rep (XName l) x -> XName l
Generic)

-- | An xml attribute, which is a name-expression pair.
data XAttr l = XAttr l (XName l) (Exp l)
  deriving (XAttr l -> XAttr l -> Bool
(XAttr l -> XAttr l -> Bool)
-> (XAttr l -> XAttr l -> Bool) -> Eq (XAttr l)
forall l. Eq l => XAttr l -> XAttr l -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall l. Eq l => XAttr l -> XAttr l -> Bool
== :: XAttr l -> XAttr l -> Bool
$c/= :: forall l. Eq l => XAttr l -> XAttr l -> Bool
/= :: XAttr l -> XAttr l -> Bool
Eq,Eq (XAttr l)
Eq (XAttr l) =>
(XAttr l -> XAttr l -> Ordering)
-> (XAttr l -> XAttr l -> Bool)
-> (XAttr l -> XAttr l -> Bool)
-> (XAttr l -> XAttr l -> Bool)
-> (XAttr l -> XAttr l -> Bool)
-> (XAttr l -> XAttr l -> XAttr l)
-> (XAttr l -> XAttr l -> XAttr l)
-> Ord (XAttr l)
XAttr l -> XAttr l -> Bool
XAttr l -> XAttr l -> Ordering
XAttr l -> XAttr l -> XAttr l
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall l. Ord l => Eq (XAttr l)
forall l. Ord l => XAttr l -> XAttr l -> Bool
forall l. Ord l => XAttr l -> XAttr l -> Ordering
forall l. Ord l => XAttr l -> XAttr l -> XAttr l
$ccompare :: forall l. Ord l => XAttr l -> XAttr l -> Ordering
compare :: XAttr l -> XAttr l -> Ordering
$c< :: forall l. Ord l => XAttr l -> XAttr l -> Bool
< :: XAttr l -> XAttr l -> Bool
$c<= :: forall l. Ord l => XAttr l -> XAttr l -> Bool
<= :: XAttr l -> XAttr l -> Bool
$c> :: forall l. Ord l => XAttr l -> XAttr l -> Bool
> :: XAttr l -> XAttr l -> Bool
$c>= :: forall l. Ord l => XAttr l -> XAttr l -> Bool
>= :: XAttr l -> XAttr l -> Bool
$cmax :: forall l. Ord l => XAttr l -> XAttr l -> XAttr l
max :: XAttr l -> XAttr l -> XAttr l
$cmin :: forall l. Ord l => XAttr l -> XAttr l -> XAttr l
min :: XAttr l -> XAttr l -> XAttr l
Ord,Int -> XAttr l -> ShowS
[XAttr l] -> ShowS
XAttr l -> String
(Int -> XAttr l -> ShowS)
-> (XAttr l -> String) -> ([XAttr l] -> ShowS) -> Show (XAttr l)
forall l. Show l => Int -> XAttr l -> ShowS
forall l. Show l => [XAttr l] -> ShowS
forall l. Show l => XAttr l -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall l. Show l => Int -> XAttr l -> ShowS
showsPrec :: Int -> XAttr l -> ShowS
$cshow :: forall l. Show l => XAttr l -> String
show :: XAttr l -> String
$cshowList :: forall l. Show l => [XAttr l] -> ShowS
showList :: [XAttr l] -> ShowS
Show,Typeable,Typeable (XAttr l)
Typeable (XAttr l) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> XAttr l -> c (XAttr l))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (XAttr l))
-> (XAttr l -> Constr)
-> (XAttr l -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (XAttr l)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (XAttr l)))
-> ((forall b. Data b => b -> b) -> XAttr l -> XAttr l)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> XAttr l -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> XAttr l -> r)
-> (forall u. (forall d. Data d => d -> u) -> XAttr l -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> XAttr l -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> XAttr l -> m (XAttr l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> XAttr l -> m (XAttr l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> XAttr l -> m (XAttr l))
-> Data (XAttr l)
XAttr l -> Constr
XAttr l -> DataType
(forall b. Data b => b -> b) -> XAttr l -> XAttr l
forall l. Data l => Typeable (XAttr l)
forall l. Data l => XAttr l -> Constr
forall l. Data l => XAttr l -> DataType
forall l.
Data l =>
(forall b. Data b => b -> b) -> XAttr l -> XAttr l
forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> XAttr l -> u
forall l u.
Data l =>
(forall d. Data d => d -> u) -> XAttr l -> [u]
forall l r r'.
Data l =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> XAttr l -> r
forall l r r'.
Data l =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> XAttr l -> r
forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d) -> XAttr l -> m (XAttr l)
forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> XAttr l -> m (XAttr l)
forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (XAttr l)
forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> XAttr l -> c (XAttr l)
forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (XAttr l))
forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (XAttr l))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> XAttr l -> u
forall u. (forall d. Data d => d -> u) -> XAttr l -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> XAttr l -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> XAttr l -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> XAttr l -> m (XAttr l)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> XAttr l -> m (XAttr l)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (XAttr l)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> XAttr l -> c (XAttr l)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (XAttr l))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (XAttr l))
$cgfoldl :: forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> XAttr l -> c (XAttr l)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> XAttr l -> c (XAttr l)
$cgunfold :: forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (XAttr l)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (XAttr l)
$ctoConstr :: forall l. Data l => XAttr l -> Constr
toConstr :: XAttr l -> Constr
$cdataTypeOf :: forall l. Data l => XAttr l -> DataType
dataTypeOf :: XAttr l -> DataType
$cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (XAttr l))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (XAttr l))
$cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (XAttr l))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (XAttr l))
$cgmapT :: forall l.
Data l =>
(forall b. Data b => b -> b) -> XAttr l -> XAttr l
gmapT :: (forall b. Data b => b -> b) -> XAttr l -> XAttr l
$cgmapQl :: forall l r r'.
Data l =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> XAttr l -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> XAttr l -> r
$cgmapQr :: forall l r r'.
Data l =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> XAttr l -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> XAttr l -> r
$cgmapQ :: forall l u.
Data l =>
(forall d. Data d => d -> u) -> XAttr l -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> XAttr l -> [u]
$cgmapQi :: forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> XAttr l -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> XAttr l -> u
$cgmapM :: forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d) -> XAttr l -> m (XAttr l)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> XAttr l -> m (XAttr l)
$cgmapMp :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> XAttr l -> m (XAttr l)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> XAttr l -> m (XAttr l)
$cgmapMo :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> XAttr l -> m (XAttr l)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> XAttr l -> m (XAttr l)
Data,(forall m. Monoid m => XAttr m -> m)
-> (forall m a. Monoid m => (a -> m) -> XAttr a -> m)
-> (forall m a. Monoid m => (a -> m) -> XAttr a -> m)
-> (forall a b. (a -> b -> b) -> b -> XAttr a -> b)
-> (forall a b. (a -> b -> b) -> b -> XAttr a -> b)
-> (forall b a. (b -> a -> b) -> b -> XAttr a -> b)
-> (forall b a. (b -> a -> b) -> b -> XAttr a -> b)
-> (forall a. (a -> a -> a) -> XAttr a -> a)
-> (forall a. (a -> a -> a) -> XAttr a -> a)
-> (forall a. XAttr a -> [a])
-> (forall a. XAttr a -> Bool)
-> (forall a. XAttr a -> Int)
-> (forall a. Eq a => a -> XAttr a -> Bool)
-> (forall a. Ord a => XAttr a -> a)
-> (forall a. Ord a => XAttr a -> a)
-> (forall a. Num a => XAttr a -> a)
-> (forall a. Num a => XAttr a -> a)
-> Foldable XAttr
forall a. Eq a => a -> XAttr a -> Bool
forall a. Num a => XAttr a -> a
forall a. Ord a => XAttr a -> a
forall m. Monoid m => XAttr m -> m
forall a. XAttr a -> Bool
forall a. XAttr a -> Int
forall a. XAttr a -> [a]
forall a. (a -> a -> a) -> XAttr a -> a
forall m a. Monoid m => (a -> m) -> XAttr a -> m
forall b a. (b -> a -> b) -> b -> XAttr a -> b
forall a b. (a -> b -> b) -> b -> XAttr a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall m. Monoid m => XAttr m -> m
fold :: forall m. Monoid m => XAttr m -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> XAttr a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> XAttr a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> XAttr a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> XAttr a -> m
$cfoldr :: forall a b. (a -> b -> b) -> b -> XAttr a -> b
foldr :: forall a b. (a -> b -> b) -> b -> XAttr a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> XAttr a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> XAttr a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> XAttr a -> b
foldl :: forall b a. (b -> a -> b) -> b -> XAttr a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> XAttr a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> XAttr a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> XAttr a -> a
foldr1 :: forall a. (a -> a -> a) -> XAttr a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> XAttr a -> a
foldl1 :: forall a. (a -> a -> a) -> XAttr a -> a
$ctoList :: forall a. XAttr a -> [a]
toList :: forall a. XAttr a -> [a]
$cnull :: forall a. XAttr a -> Bool
null :: forall a. XAttr a -> Bool
$clength :: forall a. XAttr a -> Int
length :: forall a. XAttr a -> Int
$celem :: forall a. Eq a => a -> XAttr a -> Bool
elem :: forall a. Eq a => a -> XAttr a -> Bool
$cmaximum :: forall a. Ord a => XAttr a -> a
maximum :: forall a. Ord a => XAttr a -> a
$cminimum :: forall a. Ord a => XAttr a -> a
minimum :: forall a. Ord a => XAttr a -> a
$csum :: forall a. Num a => XAttr a -> a
sum :: forall a. Num a => XAttr a -> a
$cproduct :: forall a. Num a => XAttr a -> a
product :: forall a. Num a => XAttr a -> a
Foldable,Functor XAttr
Foldable XAttr
(Functor XAttr, Foldable XAttr) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> XAttr a -> f (XAttr b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    XAttr (f a) -> f (XAttr a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> XAttr a -> m (XAttr b))
-> (forall (m :: * -> *) a. Monad m => XAttr (m a) -> m (XAttr a))
-> Traversable XAttr
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a. Monad m => XAttr (m a) -> m (XAttr a)
forall (f :: * -> *) a. Applicative f => XAttr (f a) -> f (XAttr a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> XAttr a -> m (XAttr b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> XAttr a -> f (XAttr b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> XAttr a -> f (XAttr b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> XAttr a -> f (XAttr b)
$csequenceA :: forall (f :: * -> *) a. Applicative f => XAttr (f a) -> f (XAttr a)
sequenceA :: forall (f :: * -> *) a. Applicative f => XAttr (f a) -> f (XAttr a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> XAttr a -> m (XAttr b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> XAttr a -> m (XAttr b)
$csequence :: forall (m :: * -> *) a. Monad m => XAttr (m a) -> m (XAttr a)
sequence :: forall (m :: * -> *) a. Monad m => XAttr (m a) -> m (XAttr a)
Traversable,(forall a b. (a -> b) -> XAttr a -> XAttr b)
-> (forall a b. a -> XAttr b -> XAttr a) -> Functor XAttr
forall a b. a -> XAttr b -> XAttr a
forall a b. (a -> b) -> XAttr a -> XAttr b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> XAttr a -> XAttr b
fmap :: forall a b. (a -> b) -> XAttr a -> XAttr b
$c<$ :: forall a b. a -> XAttr b -> XAttr a
<$ :: forall a b. a -> XAttr b -> XAttr a
Functor,(forall x. XAttr l -> Rep (XAttr l) x)
-> (forall x. Rep (XAttr l) x -> XAttr l) -> Generic (XAttr l)
forall x. Rep (XAttr l) x -> XAttr l
forall x. XAttr l -> Rep (XAttr l) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall l x. Rep (XAttr l) x -> XAttr l
forall l x. XAttr l -> Rep (XAttr l) x
$cfrom :: forall l x. XAttr l -> Rep (XAttr l) x
from :: forall x. XAttr l -> Rep (XAttr l) x
$cto :: forall l x. Rep (XAttr l) x -> XAttr l
to :: forall x. Rep (XAttr l) x -> XAttr l
Generic)

-- | A template haskell bracket expression.
data Bracket l
    = ExpBracket l (Exp l)        -- ^ expression bracket: @[| ... |]@
    | TExpBracket l (Exp l)       -- ^ typed expression bracket: @[|| ... ||]@
    | PatBracket l (Pat l)        -- ^ pattern bracket: @[p| ... |]@
    | TypeBracket l (Type l)      -- ^ type bracket: @[t| ... |]@
    | DeclBracket l [Decl l]      -- ^ declaration bracket: @[d| ... |]@
  deriving (Bracket l -> Bracket l -> Bool
(Bracket l -> Bracket l -> Bool)
-> (Bracket l -> Bracket l -> Bool) -> Eq (Bracket l)
forall l. Eq l => Bracket l -> Bracket l -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall l. Eq l => Bracket l -> Bracket l -> Bool
== :: Bracket l -> Bracket l -> Bool
$c/= :: forall l. Eq l => Bracket l -> Bracket l -> Bool
/= :: Bracket l -> Bracket l -> Bool
Eq,Eq (Bracket l)
Eq (Bracket l) =>
(Bracket l -> Bracket l -> Ordering)
-> (Bracket l -> Bracket l -> Bool)
-> (Bracket l -> Bracket l -> Bool)
-> (Bracket l -> Bracket l -> Bool)
-> (Bracket l -> Bracket l -> Bool)
-> (Bracket l -> Bracket l -> Bracket l)
-> (Bracket l -> Bracket l -> Bracket l)
-> Ord (Bracket l)
Bracket l -> Bracket l -> Bool
Bracket l -> Bracket l -> Ordering
Bracket l -> Bracket l -> Bracket l
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall l. Ord l => Eq (Bracket l)
forall l. Ord l => Bracket l -> Bracket l -> Bool
forall l. Ord l => Bracket l -> Bracket l -> Ordering
forall l. Ord l => Bracket l -> Bracket l -> Bracket l
$ccompare :: forall l. Ord l => Bracket l -> Bracket l -> Ordering
compare :: Bracket l -> Bracket l -> Ordering
$c< :: forall l. Ord l => Bracket l -> Bracket l -> Bool
< :: Bracket l -> Bracket l -> Bool
$c<= :: forall l. Ord l => Bracket l -> Bracket l -> Bool
<= :: Bracket l -> Bracket l -> Bool
$c> :: forall l. Ord l => Bracket l -> Bracket l -> Bool
> :: Bracket l -> Bracket l -> Bool
$c>= :: forall l. Ord l => Bracket l -> Bracket l -> Bool
>= :: Bracket l -> Bracket l -> Bool
$cmax :: forall l. Ord l => Bracket l -> Bracket l -> Bracket l
max :: Bracket l -> Bracket l -> Bracket l
$cmin :: forall l. Ord l => Bracket l -> Bracket l -> Bracket l
min :: Bracket l -> Bracket l -> Bracket l
Ord,Int -> Bracket l -> ShowS
[Bracket l] -> ShowS
Bracket l -> String
(Int -> Bracket l -> ShowS)
-> (Bracket l -> String)
-> ([Bracket l] -> ShowS)
-> Show (Bracket l)
forall l. Show l => Int -> Bracket l -> ShowS
forall l. Show l => [Bracket l] -> ShowS
forall l. Show l => Bracket l -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall l. Show l => Int -> Bracket l -> ShowS
showsPrec :: Int -> Bracket l -> ShowS
$cshow :: forall l. Show l => Bracket l -> String
show :: Bracket l -> String
$cshowList :: forall l. Show l => [Bracket l] -> ShowS
showList :: [Bracket l] -> ShowS
Show,Typeable,Typeable (Bracket l)
Typeable (Bracket l) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Bracket l -> c (Bracket l))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Bracket l))
-> (Bracket l -> Constr)
-> (Bracket l -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Bracket l)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Bracket l)))
-> ((forall b. Data b => b -> b) -> Bracket l -> Bracket l)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Bracket l -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Bracket l -> r)
-> (forall u. (forall d. Data d => d -> u) -> Bracket l -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Bracket l -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Bracket l -> m (Bracket l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Bracket l -> m (Bracket l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Bracket l -> m (Bracket l))
-> Data (Bracket l)
Bracket l -> Constr
Bracket l -> DataType
(forall b. Data b => b -> b) -> Bracket l -> Bracket l
forall l. Data l => Typeable (Bracket l)
forall l. Data l => Bracket l -> Constr
forall l. Data l => Bracket l -> DataType
forall l.
Data l =>
(forall b. Data b => b -> b) -> Bracket l -> Bracket l
forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> Bracket l -> u
forall l u.
Data l =>
(forall d. Data d => d -> u) -> Bracket l -> [u]
forall l r r'.
Data l =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Bracket l -> r
forall l r r'.
Data l =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Bracket l -> r
forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d) -> Bracket l -> m (Bracket l)
forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Bracket l -> m (Bracket l)
forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Bracket l)
forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Bracket l -> c (Bracket l)
forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Bracket l))
forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Bracket l))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Bracket l -> u
forall u. (forall d. Data d => d -> u) -> Bracket l -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Bracket l -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Bracket l -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Bracket l -> m (Bracket l)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Bracket l -> m (Bracket l)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Bracket l)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Bracket l -> c (Bracket l)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Bracket l))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Bracket l))
$cgfoldl :: forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Bracket l -> c (Bracket l)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Bracket l -> c (Bracket l)
$cgunfold :: forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Bracket l)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Bracket l)
$ctoConstr :: forall l. Data l => Bracket l -> Constr
toConstr :: Bracket l -> Constr
$cdataTypeOf :: forall l. Data l => Bracket l -> DataType
dataTypeOf :: Bracket l -> DataType
$cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Bracket l))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Bracket l))
$cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Bracket l))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Bracket l))
$cgmapT :: forall l.
Data l =>
(forall b. Data b => b -> b) -> Bracket l -> Bracket l
gmapT :: (forall b. Data b => b -> b) -> Bracket l -> Bracket l
$cgmapQl :: forall l r r'.
Data l =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Bracket l -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Bracket l -> r
$cgmapQr :: forall l r r'.
Data l =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Bracket l -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Bracket l -> r
$cgmapQ :: forall l u.
Data l =>
(forall d. Data d => d -> u) -> Bracket l -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Bracket l -> [u]
$cgmapQi :: forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> Bracket l -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Bracket l -> u
$cgmapM :: forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d) -> Bracket l -> m (Bracket l)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Bracket l -> m (Bracket l)
$cgmapMp :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Bracket l -> m (Bracket l)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Bracket l -> m (Bracket l)
$cgmapMo :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Bracket l -> m (Bracket l)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Bracket l -> m (Bracket l)
Data,(forall m. Monoid m => Bracket m -> m)
-> (forall m a. Monoid m => (a -> m) -> Bracket a -> m)
-> (forall m a. Monoid m => (a -> m) -> Bracket a -> m)
-> (forall a b. (a -> b -> b) -> b -> Bracket a -> b)
-> (forall a b. (a -> b -> b) -> b -> Bracket a -> b)
-> (forall b a. (b -> a -> b) -> b -> Bracket a -> b)
-> (forall b a. (b -> a -> b) -> b -> Bracket a -> b)
-> (forall a. (a -> a -> a) -> Bracket a -> a)
-> (forall a. (a -> a -> a) -> Bracket a -> a)
-> (forall a. Bracket a -> [a])
-> (forall a. Bracket a -> Bool)
-> (forall a. Bracket a -> Int)
-> (forall a. Eq a => a -> Bracket a -> Bool)
-> (forall a. Ord a => Bracket a -> a)
-> (forall a. Ord a => Bracket a -> a)
-> (forall a. Num a => Bracket a -> a)
-> (forall a. Num a => Bracket a -> a)
-> Foldable Bracket
forall a. Eq a => a -> Bracket a -> Bool
forall a. Num a => Bracket a -> a
forall a. Ord a => Bracket a -> a
forall m. Monoid m => Bracket m -> m
forall a. Bracket a -> Bool
forall a. Bracket a -> Int
forall a. Bracket a -> [a]
forall a. (a -> a -> a) -> Bracket a -> a
forall m a. Monoid m => (a -> m) -> Bracket a -> m
forall b a. (b -> a -> b) -> b -> Bracket a -> b
forall a b. (a -> b -> b) -> b -> Bracket a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall m. Monoid m => Bracket m -> m
fold :: forall m. Monoid m => Bracket m -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> Bracket a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> Bracket a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> Bracket a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> Bracket a -> m
$cfoldr :: forall a b. (a -> b -> b) -> b -> Bracket a -> b
foldr :: forall a b. (a -> b -> b) -> b -> Bracket a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> Bracket a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> Bracket a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> Bracket a -> b
foldl :: forall b a. (b -> a -> b) -> b -> Bracket a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> Bracket a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> Bracket a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> Bracket a -> a
foldr1 :: forall a. (a -> a -> a) -> Bracket a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> Bracket a -> a
foldl1 :: forall a. (a -> a -> a) -> Bracket a -> a
$ctoList :: forall a. Bracket a -> [a]
toList :: forall a. Bracket a -> [a]
$cnull :: forall a. Bracket a -> Bool
null :: forall a. Bracket a -> Bool
$clength :: forall a. Bracket a -> Int
length :: forall a. Bracket a -> Int
$celem :: forall a. Eq a => a -> Bracket a -> Bool
elem :: forall a. Eq a => a -> Bracket a -> Bool
$cmaximum :: forall a. Ord a => Bracket a -> a
maximum :: forall a. Ord a => Bracket a -> a
$cminimum :: forall a. Ord a => Bracket a -> a
minimum :: forall a. Ord a => Bracket a -> a
$csum :: forall a. Num a => Bracket a -> a
sum :: forall a. Num a => Bracket a -> a
$cproduct :: forall a. Num a => Bracket a -> a
product :: forall a. Num a => Bracket a -> a
Foldable,Functor Bracket
Foldable Bracket
(Functor Bracket, Foldable Bracket) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> Bracket a -> f (Bracket b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    Bracket (f a) -> f (Bracket a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Bracket a -> m (Bracket b))
-> (forall (m :: * -> *) a.
    Monad m =>
    Bracket (m a) -> m (Bracket a))
-> Traversable Bracket
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a. Monad m => Bracket (m a) -> m (Bracket a)
forall (f :: * -> *) a.
Applicative f =>
Bracket (f a) -> f (Bracket a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Bracket a -> m (Bracket b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Bracket a -> f (Bracket b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Bracket a -> f (Bracket b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Bracket a -> f (Bracket b)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
Bracket (f a) -> f (Bracket a)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
Bracket (f a) -> f (Bracket a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Bracket a -> m (Bracket b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Bracket a -> m (Bracket b)
$csequence :: forall (m :: * -> *) a. Monad m => Bracket (m a) -> m (Bracket a)
sequence :: forall (m :: * -> *) a. Monad m => Bracket (m a) -> m (Bracket a)
Traversable,(forall a b. (a -> b) -> Bracket a -> Bracket b)
-> (forall a b. a -> Bracket b -> Bracket a) -> Functor Bracket
forall a b. a -> Bracket b -> Bracket a
forall a b. (a -> b) -> Bracket a -> Bracket b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> Bracket a -> Bracket b
fmap :: forall a b. (a -> b) -> Bracket a -> Bracket b
$c<$ :: forall a b. a -> Bracket b -> Bracket a
<$ :: forall a b. a -> Bracket b -> Bracket a
Functor,(forall x. Bracket l -> Rep (Bracket l) x)
-> (forall x. Rep (Bracket l) x -> Bracket l)
-> Generic (Bracket l)
forall x. Rep (Bracket l) x -> Bracket l
forall x. Bracket l -> Rep (Bracket l) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall l x. Rep (Bracket l) x -> Bracket l
forall l x. Bracket l -> Rep (Bracket l) x
$cfrom :: forall l x. Bracket l -> Rep (Bracket l) x
from :: forall x. Bracket l -> Rep (Bracket l) x
$cto :: forall l x. Rep (Bracket l) x -> Bracket l
to :: forall x. Rep (Bracket l) x -> Bracket l
Generic)

-- | A template haskell splice expression
data Splice l
    = IdSplice l String           -- ^ variable splice: @$var@
    | TIdSplice l String          -- ^ typed variable splice: @$$var@
    | ParenSplice l (Exp l)       -- ^ parenthesised expression splice: @$(/exp/)@
    | TParenSplice l (Exp l)      -- ^ parenthesised typed expression splice: @$$(/exp/)@
  deriving (Splice l -> Splice l -> Bool
(Splice l -> Splice l -> Bool)
-> (Splice l -> Splice l -> Bool) -> Eq (Splice l)
forall l. Eq l => Splice l -> Splice l -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall l. Eq l => Splice l -> Splice l -> Bool
== :: Splice l -> Splice l -> Bool
$c/= :: forall l. Eq l => Splice l -> Splice l -> Bool
/= :: Splice l -> Splice l -> Bool
Eq,Eq (Splice l)
Eq (Splice l) =>
(Splice l -> Splice l -> Ordering)
-> (Splice l -> Splice l -> Bool)
-> (Splice l -> Splice l -> Bool)
-> (Splice l -> Splice l -> Bool)
-> (Splice l -> Splice l -> Bool)
-> (Splice l -> Splice l -> Splice l)
-> (Splice l -> Splice l -> Splice l)
-> Ord (Splice l)
Splice l -> Splice l -> Bool
Splice l -> Splice l -> Ordering
Splice l -> Splice l -> Splice l
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall l. Ord l => Eq (Splice l)
forall l. Ord l => Splice l -> Splice l -> Bool
forall l. Ord l => Splice l -> Splice l -> Ordering
forall l. Ord l => Splice l -> Splice l -> Splice l
$ccompare :: forall l. Ord l => Splice l -> Splice l -> Ordering
compare :: Splice l -> Splice l -> Ordering
$c< :: forall l. Ord l => Splice l -> Splice l -> Bool
< :: Splice l -> Splice l -> Bool
$c<= :: forall l. Ord l => Splice l -> Splice l -> Bool
<= :: Splice l -> Splice l -> Bool
$c> :: forall l. Ord l => Splice l -> Splice l -> Bool
> :: Splice l -> Splice l -> Bool
$c>= :: forall l. Ord l => Splice l -> Splice l -> Bool
>= :: Splice l -> Splice l -> Bool
$cmax :: forall l. Ord l => Splice l -> Splice l -> Splice l
max :: Splice l -> Splice l -> Splice l
$cmin :: forall l. Ord l => Splice l -> Splice l -> Splice l
min :: Splice l -> Splice l -> Splice l
Ord,Int -> Splice l -> ShowS
[Splice l] -> ShowS
Splice l -> String
(Int -> Splice l -> ShowS)
-> (Splice l -> String) -> ([Splice l] -> ShowS) -> Show (Splice l)
forall l. Show l => Int -> Splice l -> ShowS
forall l. Show l => [Splice l] -> ShowS
forall l. Show l => Splice l -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall l. Show l => Int -> Splice l -> ShowS
showsPrec :: Int -> Splice l -> ShowS
$cshow :: forall l. Show l => Splice l -> String
show :: Splice l -> String
$cshowList :: forall l. Show l => [Splice l] -> ShowS
showList :: [Splice l] -> ShowS
Show,Typeable,Typeable (Splice l)
Typeable (Splice l) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Splice l -> c (Splice l))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Splice l))
-> (Splice l -> Constr)
-> (Splice l -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Splice l)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Splice l)))
-> ((forall b. Data b => b -> b) -> Splice l -> Splice l)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Splice l -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Splice l -> r)
-> (forall u. (forall d. Data d => d -> u) -> Splice l -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Splice l -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Splice l -> m (Splice l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Splice l -> m (Splice l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Splice l -> m (Splice l))
-> Data (Splice l)
Splice l -> Constr
Splice l -> DataType
(forall b. Data b => b -> b) -> Splice l -> Splice l
forall l. Data l => Typeable (Splice l)
forall l. Data l => Splice l -> Constr
forall l. Data l => Splice l -> DataType
forall l.
Data l =>
(forall b. Data b => b -> b) -> Splice l -> Splice l
forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> Splice l -> u
forall l u.
Data l =>
(forall d. Data d => d -> u) -> Splice l -> [u]
forall l r r'.
Data l =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Splice l -> r
forall l r r'.
Data l =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Splice l -> r
forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d) -> Splice l -> m (Splice l)
forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Splice l -> m (Splice l)
forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Splice l)
forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Splice l -> c (Splice l)
forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Splice l))
forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Splice l))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Splice l -> u
forall u. (forall d. Data d => d -> u) -> Splice l -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Splice l -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Splice l -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Splice l -> m (Splice l)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Splice l -> m (Splice l)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Splice l)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Splice l -> c (Splice l)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Splice l))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Splice l))
$cgfoldl :: forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Splice l -> c (Splice l)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Splice l -> c (Splice l)
$cgunfold :: forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Splice l)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Splice l)
$ctoConstr :: forall l. Data l => Splice l -> Constr
toConstr :: Splice l -> Constr
$cdataTypeOf :: forall l. Data l => Splice l -> DataType
dataTypeOf :: Splice l -> DataType
$cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Splice l))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Splice l))
$cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Splice l))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Splice l))
$cgmapT :: forall l.
Data l =>
(forall b. Data b => b -> b) -> Splice l -> Splice l
gmapT :: (forall b. Data b => b -> b) -> Splice l -> Splice l
$cgmapQl :: forall l r r'.
Data l =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Splice l -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Splice l -> r
$cgmapQr :: forall l r r'.
Data l =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Splice l -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Splice l -> r
$cgmapQ :: forall l u.
Data l =>
(forall d. Data d => d -> u) -> Splice l -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Splice l -> [u]
$cgmapQi :: forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> Splice l -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Splice l -> u
$cgmapM :: forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d) -> Splice l -> m (Splice l)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Splice l -> m (Splice l)
$cgmapMp :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Splice l -> m (Splice l)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Splice l -> m (Splice l)
$cgmapMo :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Splice l -> m (Splice l)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Splice l -> m (Splice l)
Data,(forall m. Monoid m => Splice m -> m)
-> (forall m a. Monoid m => (a -> m) -> Splice a -> m)
-> (forall m a. Monoid m => (a -> m) -> Splice a -> m)
-> (forall a b. (a -> b -> b) -> b -> Splice a -> b)
-> (forall a b. (a -> b -> b) -> b -> Splice a -> b)
-> (forall b a. (b -> a -> b) -> b -> Splice a -> b)
-> (forall b a. (b -> a -> b) -> b -> Splice a -> b)
-> (forall a. (a -> a -> a) -> Splice a -> a)
-> (forall a. (a -> a -> a) -> Splice a -> a)
-> (forall a. Splice a -> [a])
-> (forall a. Splice a -> Bool)
-> (forall a. Splice a -> Int)
-> (forall a. Eq a => a -> Splice a -> Bool)
-> (forall a. Ord a => Splice a -> a)
-> (forall a. Ord a => Splice a -> a)
-> (forall a. Num a => Splice a -> a)
-> (forall a. Num a => Splice a -> a)
-> Foldable Splice
forall a. Eq a => a -> Splice a -> Bool
forall a. Num a => Splice a -> a
forall a. Ord a => Splice a -> a
forall m. Monoid m => Splice m -> m
forall a. Splice a -> Bool
forall a. Splice a -> Int
forall a. Splice a -> [a]
forall a. (a -> a -> a) -> Splice a -> a
forall m a. Monoid m => (a -> m) -> Splice a -> m
forall b a. (b -> a -> b) -> b -> Splice a -> b
forall a b. (a -> b -> b) -> b -> Splice a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall m. Monoid m => Splice m -> m
fold :: forall m. Monoid m => Splice m -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> Splice a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> Splice a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> Splice a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> Splice a -> m
$cfoldr :: forall a b. (a -> b -> b) -> b -> Splice a -> b
foldr :: forall a b. (a -> b -> b) -> b -> Splice a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> Splice a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> Splice a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> Splice a -> b
foldl :: forall b a. (b -> a -> b) -> b -> Splice a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> Splice a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> Splice a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> Splice a -> a
foldr1 :: forall a. (a -> a -> a) -> Splice a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> Splice a -> a
foldl1 :: forall a. (a -> a -> a) -> Splice a -> a
$ctoList :: forall a. Splice a -> [a]
toList :: forall a. Splice a -> [a]
$cnull :: forall a. Splice a -> Bool
null :: forall a. Splice a -> Bool
$clength :: forall a. Splice a -> Int
length :: forall a. Splice a -> Int
$celem :: forall a. Eq a => a -> Splice a -> Bool
elem :: forall a. Eq a => a -> Splice a -> Bool
$cmaximum :: forall a. Ord a => Splice a -> a
maximum :: forall a. Ord a => Splice a -> a
$cminimum :: forall a. Ord a => Splice a -> a
minimum :: forall a. Ord a => Splice a -> a
$csum :: forall a. Num a => Splice a -> a
sum :: forall a. Num a => Splice a -> a
$cproduct :: forall a. Num a => Splice a -> a
product :: forall a. Num a => Splice a -> a
Foldable,Functor Splice
Foldable Splice
(Functor Splice, Foldable Splice) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> Splice a -> f (Splice b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    Splice (f a) -> f (Splice a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Splice a -> m (Splice b))
-> (forall (m :: * -> *) a.
    Monad m =>
    Splice (m a) -> m (Splice a))
-> Traversable Splice
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a. Monad m => Splice (m a) -> m (Splice a)
forall (f :: * -> *) a.
Applicative f =>
Splice (f a) -> f (Splice a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Splice a -> m (Splice b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Splice a -> f (Splice b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Splice a -> f (Splice b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Splice a -> f (Splice b)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
Splice (f a) -> f (Splice a)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
Splice (f a) -> f (Splice a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Splice a -> m (Splice b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Splice a -> m (Splice b)
$csequence :: forall (m :: * -> *) a. Monad m => Splice (m a) -> m (Splice a)
sequence :: forall (m :: * -> *) a. Monad m => Splice (m a) -> m (Splice a)
Traversable,(forall a b. (a -> b) -> Splice a -> Splice b)
-> (forall a b. a -> Splice b -> Splice a) -> Functor Splice
forall a b. a -> Splice b -> Splice a
forall a b. (a -> b) -> Splice a -> Splice b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> Splice a -> Splice b
fmap :: forall a b. (a -> b) -> Splice a -> Splice b
$c<$ :: forall a b. a -> Splice b -> Splice a
<$ :: forall a b. a -> Splice b -> Splice a
Functor,(forall x. Splice l -> Rep (Splice l) x)
-> (forall x. Rep (Splice l) x -> Splice l) -> Generic (Splice l)
forall x. Rep (Splice l) x -> Splice l
forall x. Splice l -> Rep (Splice l) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall l x. Rep (Splice l) x -> Splice l
forall l x. Splice l -> Rep (Splice l) x
$cfrom :: forall l x. Splice l -> Rep (Splice l) x
from :: forall x. Splice l -> Rep (Splice l) x
$cto :: forall l x. Rep (Splice l) x -> Splice l
to :: forall x. Rep (Splice l) x -> Splice l
Generic)

-- | The safety of a foreign function call.
data Safety l
    = PlayRisky l         -- ^ unsafe
    | PlaySafe l Bool     -- ^ safe ('False') or threadsafe ('True')
    | PlayInterruptible l -- ^ interruptible
  deriving (Safety l -> Safety l -> Bool
(Safety l -> Safety l -> Bool)
-> (Safety l -> Safety l -> Bool) -> Eq (Safety l)
forall l. Eq l => Safety l -> Safety l -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall l. Eq l => Safety l -> Safety l -> Bool
== :: Safety l -> Safety l -> Bool
$c/= :: forall l. Eq l => Safety l -> Safety l -> Bool
/= :: Safety l -> Safety l -> Bool
Eq,Eq (Safety l)
Eq (Safety l) =>
(Safety l -> Safety l -> Ordering)
-> (Safety l -> Safety l -> Bool)
-> (Safety l -> Safety l -> Bool)
-> (Safety l -> Safety l -> Bool)
-> (Safety l -> Safety l -> Bool)
-> (Safety l -> Safety l -> Safety l)
-> (Safety l -> Safety l -> Safety l)
-> Ord (Safety l)
Safety l -> Safety l -> Bool
Safety l -> Safety l -> Ordering
Safety l -> Safety l -> Safety l
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall l. Ord l => Eq (Safety l)
forall l. Ord l => Safety l -> Safety l -> Bool
forall l. Ord l => Safety l -> Safety l -> Ordering
forall l. Ord l => Safety l -> Safety l -> Safety l
$ccompare :: forall l. Ord l => Safety l -> Safety l -> Ordering
compare :: Safety l -> Safety l -> Ordering
$c< :: forall l. Ord l => Safety l -> Safety l -> Bool
< :: Safety l -> Safety l -> Bool
$c<= :: forall l. Ord l => Safety l -> Safety l -> Bool
<= :: Safety l -> Safety l -> Bool
$c> :: forall l. Ord l => Safety l -> Safety l -> Bool
> :: Safety l -> Safety l -> Bool
$c>= :: forall l. Ord l => Safety l -> Safety l -> Bool
>= :: Safety l -> Safety l -> Bool
$cmax :: forall l. Ord l => Safety l -> Safety l -> Safety l
max :: Safety l -> Safety l -> Safety l
$cmin :: forall l. Ord l => Safety l -> Safety l -> Safety l
min :: Safety l -> Safety l -> Safety l
Ord,Int -> Safety l -> ShowS
[Safety l] -> ShowS
Safety l -> String
(Int -> Safety l -> ShowS)
-> (Safety l -> String) -> ([Safety l] -> ShowS) -> Show (Safety l)
forall l. Show l => Int -> Safety l -> ShowS
forall l. Show l => [Safety l] -> ShowS
forall l. Show l => Safety l -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall l. Show l => Int -> Safety l -> ShowS
showsPrec :: Int -> Safety l -> ShowS
$cshow :: forall l. Show l => Safety l -> String
show :: Safety l -> String
$cshowList :: forall l. Show l => [Safety l] -> ShowS
showList :: [Safety l] -> ShowS
Show,Typeable,Typeable (Safety l)
Typeable (Safety l) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Safety l -> c (Safety l))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Safety l))
-> (Safety l -> Constr)
-> (Safety l -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Safety l)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Safety l)))
-> ((forall b. Data b => b -> b) -> Safety l -> Safety l)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Safety l -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Safety l -> r)
-> (forall u. (forall d. Data d => d -> u) -> Safety l -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Safety l -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Safety l -> m (Safety l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Safety l -> m (Safety l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Safety l -> m (Safety l))
-> Data (Safety l)
Safety l -> Constr
Safety l -> DataType
(forall b. Data b => b -> b) -> Safety l -> Safety l
forall l. Data l => Typeable (Safety l)
forall l. Data l => Safety l -> Constr
forall l. Data l => Safety l -> DataType
forall l.
Data l =>
(forall b. Data b => b -> b) -> Safety l -> Safety l
forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> Safety l -> u
forall l u.
Data l =>
(forall d. Data d => d -> u) -> Safety l -> [u]
forall l r r'.
Data l =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Safety l -> r
forall l r r'.
Data l =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Safety l -> r
forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d) -> Safety l -> m (Safety l)
forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Safety l -> m (Safety l)
forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Safety l)
forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Safety l -> c (Safety l)
forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Safety l))
forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Safety l))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Safety l -> u
forall u. (forall d. Data d => d -> u) -> Safety l -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Safety l -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Safety l -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Safety l -> m (Safety l)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Safety l -> m (Safety l)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Safety l)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Safety l -> c (Safety l)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Safety l))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Safety l))
$cgfoldl :: forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Safety l -> c (Safety l)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Safety l -> c (Safety l)
$cgunfold :: forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Safety l)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Safety l)
$ctoConstr :: forall l. Data l => Safety l -> Constr
toConstr :: Safety l -> Constr
$cdataTypeOf :: forall l. Data l => Safety l -> DataType
dataTypeOf :: Safety l -> DataType
$cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Safety l))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Safety l))
$cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Safety l))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Safety l))
$cgmapT :: forall l.
Data l =>
(forall b. Data b => b -> b) -> Safety l -> Safety l
gmapT :: (forall b. Data b => b -> b) -> Safety l -> Safety l
$cgmapQl :: forall l r r'.
Data l =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Safety l -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Safety l -> r
$cgmapQr :: forall l r r'.
Data l =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Safety l -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Safety l -> r
$cgmapQ :: forall l u.
Data l =>
(forall d. Data d => d -> u) -> Safety l -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Safety l -> [u]
$cgmapQi :: forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> Safety l -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Safety l -> u
$cgmapM :: forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d) -> Safety l -> m (Safety l)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Safety l -> m (Safety l)
$cgmapMp :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Safety l -> m (Safety l)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Safety l -> m (Safety l)
$cgmapMo :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Safety l -> m (Safety l)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Safety l -> m (Safety l)
Data,(forall m. Monoid m => Safety m -> m)
-> (forall m a. Monoid m => (a -> m) -> Safety a -> m)
-> (forall m a. Monoid m => (a -> m) -> Safety a -> m)
-> (forall a b. (a -> b -> b) -> b -> Safety a -> b)
-> (forall a b. (a -> b -> b) -> b -> Safety a -> b)
-> (forall b a. (b -> a -> b) -> b -> Safety a -> b)
-> (forall b a. (b -> a -> b) -> b -> Safety a -> b)
-> (forall a. (a -> a -> a) -> Safety a -> a)
-> (forall a. (a -> a -> a) -> Safety a -> a)
-> (forall a. Safety a -> [a])
-> (forall a. Safety a -> Bool)
-> (forall a. Safety a -> Int)
-> (forall a. Eq a => a -> Safety a -> Bool)
-> (forall a. Ord a => Safety a -> a)
-> (forall a. Ord a => Safety a -> a)
-> (forall a. Num a => Safety a -> a)
-> (forall a. Num a => Safety a -> a)
-> Foldable Safety
forall a. Eq a => a -> Safety a -> Bool
forall a. Num a => Safety a -> a
forall a. Ord a => Safety a -> a
forall m. Monoid m => Safety m -> m
forall a. Safety a -> Bool
forall a. Safety a -> Int
forall a. Safety a -> [a]
forall a. (a -> a -> a) -> Safety a -> a
forall m a. Monoid m => (a -> m) -> Safety a -> m
forall b a. (b -> a -> b) -> b -> Safety a -> b
forall a b. (a -> b -> b) -> b -> Safety a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall m. Monoid m => Safety m -> m
fold :: forall m. Monoid m => Safety m -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> Safety a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> Safety a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> Safety a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> Safety a -> m
$cfoldr :: forall a b. (a -> b -> b) -> b -> Safety a -> b
foldr :: forall a b. (a -> b -> b) -> b -> Safety a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> Safety a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> Safety a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> Safety a -> b
foldl :: forall b a. (b -> a -> b) -> b -> Safety a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> Safety a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> Safety a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> Safety a -> a
foldr1 :: forall a. (a -> a -> a) -> Safety a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> Safety a -> a
foldl1 :: forall a. (a -> a -> a) -> Safety a -> a
$ctoList :: forall a. Safety a -> [a]
toList :: forall a. Safety a -> [a]
$cnull :: forall a. Safety a -> Bool
null :: forall a. Safety a -> Bool
$clength :: forall a. Safety a -> Int
length :: forall a. Safety a -> Int
$celem :: forall a. Eq a => a -> Safety a -> Bool
elem :: forall a. Eq a => a -> Safety a -> Bool
$cmaximum :: forall a. Ord a => Safety a -> a
maximum :: forall a. Ord a => Safety a -> a
$cminimum :: forall a. Ord a => Safety a -> a
minimum :: forall a. Ord a => Safety a -> a
$csum :: forall a. Num a => Safety a -> a
sum :: forall a. Num a => Safety a -> a
$cproduct :: forall a. Num a => Safety a -> a
product :: forall a. Num a => Safety a -> a
Foldable,Functor Safety
Foldable Safety
(Functor Safety, Foldable Safety) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> Safety a -> f (Safety b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    Safety (f a) -> f (Safety a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Safety a -> m (Safety b))
-> (forall (m :: * -> *) a.
    Monad m =>
    Safety (m a) -> m (Safety a))
-> Traversable Safety
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a. Monad m => Safety (m a) -> m (Safety a)
forall (f :: * -> *) a.
Applicative f =>
Safety (f a) -> f (Safety a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Safety a -> m (Safety b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Safety a -> f (Safety b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Safety a -> f (Safety b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Safety a -> f (Safety b)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
Safety (f a) -> f (Safety a)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
Safety (f a) -> f (Safety a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Safety a -> m (Safety b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Safety a -> m (Safety b)
$csequence :: forall (m :: * -> *) a. Monad m => Safety (m a) -> m (Safety a)
sequence :: forall (m :: * -> *) a. Monad m => Safety (m a) -> m (Safety a)
Traversable,(forall a b. (a -> b) -> Safety a -> Safety b)
-> (forall a b. a -> Safety b -> Safety a) -> Functor Safety
forall a b. a -> Safety b -> Safety a
forall a b. (a -> b) -> Safety a -> Safety b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> Safety a -> Safety b
fmap :: forall a b. (a -> b) -> Safety a -> Safety b
$c<$ :: forall a b. a -> Safety b -> Safety a
<$ :: forall a b. a -> Safety b -> Safety a
Functor,(forall x. Safety l -> Rep (Safety l) x)
-> (forall x. Rep (Safety l) x -> Safety l) -> Generic (Safety l)
forall x. Rep (Safety l) x -> Safety l
forall x. Safety l -> Rep (Safety l) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall l x. Rep (Safety l) x -> Safety l
forall l x. Safety l -> Rep (Safety l) x
$cfrom :: forall l x. Safety l -> Rep (Safety l) x
from :: forall x. Safety l -> Rep (Safety l) x
$cto :: forall l x. Rep (Safety l) x -> Safety l
to :: forall x. Rep (Safety l) x -> Safety l
Generic)

-- | The calling convention of a foreign function call.
data CallConv l
    = StdCall l
    | CCall l
    | CPlusPlus l
    | DotNet l
    | Jvm l
    | Js l
    | JavaScript l
    | CApi l
  deriving (CallConv l -> CallConv l -> Bool
(CallConv l -> CallConv l -> Bool)
-> (CallConv l -> CallConv l -> Bool) -> Eq (CallConv l)
forall l. Eq l => CallConv l -> CallConv l -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall l. Eq l => CallConv l -> CallConv l -> Bool
== :: CallConv l -> CallConv l -> Bool
$c/= :: forall l. Eq l => CallConv l -> CallConv l -> Bool
/= :: CallConv l -> CallConv l -> Bool
Eq,Eq (CallConv l)
Eq (CallConv l) =>
(CallConv l -> CallConv l -> Ordering)
-> (CallConv l -> CallConv l -> Bool)
-> (CallConv l -> CallConv l -> Bool)
-> (CallConv l -> CallConv l -> Bool)
-> (CallConv l -> CallConv l -> Bool)
-> (CallConv l -> CallConv l -> CallConv l)
-> (CallConv l -> CallConv l -> CallConv l)
-> Ord (CallConv l)
CallConv l -> CallConv l -> Bool
CallConv l -> CallConv l -> Ordering
CallConv l -> CallConv l -> CallConv l
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall l. Ord l => Eq (CallConv l)
forall l. Ord l => CallConv l -> CallConv l -> Bool
forall l. Ord l => CallConv l -> CallConv l -> Ordering
forall l. Ord l => CallConv l -> CallConv l -> CallConv l
$ccompare :: forall l. Ord l => CallConv l -> CallConv l -> Ordering
compare :: CallConv l -> CallConv l -> Ordering
$c< :: forall l. Ord l => CallConv l -> CallConv l -> Bool
< :: CallConv l -> CallConv l -> Bool
$c<= :: forall l. Ord l => CallConv l -> CallConv l -> Bool
<= :: CallConv l -> CallConv l -> Bool
$c> :: forall l. Ord l => CallConv l -> CallConv l -> Bool
> :: CallConv l -> CallConv l -> Bool
$c>= :: forall l. Ord l => CallConv l -> CallConv l -> Bool
>= :: CallConv l -> CallConv l -> Bool
$cmax :: forall l. Ord l => CallConv l -> CallConv l -> CallConv l
max :: CallConv l -> CallConv l -> CallConv l
$cmin :: forall l. Ord l => CallConv l -> CallConv l -> CallConv l
min :: CallConv l -> CallConv l -> CallConv l
Ord,Int -> CallConv l -> ShowS
[CallConv l] -> ShowS
CallConv l -> String
(Int -> CallConv l -> ShowS)
-> (CallConv l -> String)
-> ([CallConv l] -> ShowS)
-> Show (CallConv l)
forall l. Show l => Int -> CallConv l -> ShowS
forall l. Show l => [CallConv l] -> ShowS
forall l. Show l => CallConv l -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall l. Show l => Int -> CallConv l -> ShowS
showsPrec :: Int -> CallConv l -> ShowS
$cshow :: forall l. Show l => CallConv l -> String
show :: CallConv l -> String
$cshowList :: forall l. Show l => [CallConv l] -> ShowS
showList :: [CallConv l] -> ShowS
Show,Typeable,Typeable (CallConv l)
Typeable (CallConv l) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> CallConv l -> c (CallConv l))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (CallConv l))
-> (CallConv l -> Constr)
-> (CallConv l -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (CallConv l)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (CallConv l)))
-> ((forall b. Data b => b -> b) -> CallConv l -> CallConv l)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> CallConv l -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> CallConv l -> r)
-> (forall u. (forall d. Data d => d -> u) -> CallConv l -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> CallConv l -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> CallConv l -> m (CallConv l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> CallConv l -> m (CallConv l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> CallConv l -> m (CallConv l))
-> Data (CallConv l)
CallConv l -> Constr
CallConv l -> DataType
(forall b. Data b => b -> b) -> CallConv l -> CallConv l
forall l. Data l => Typeable (CallConv l)
forall l. Data l => CallConv l -> Constr
forall l. Data l => CallConv l -> DataType
forall l.
Data l =>
(forall b. Data b => b -> b) -> CallConv l -> CallConv l
forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> CallConv l -> u
forall l u.
Data l =>
(forall d. Data d => d -> u) -> CallConv l -> [u]
forall l r r'.
Data l =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CallConv l -> r
forall l r r'.
Data l =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CallConv l -> r
forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d) -> CallConv l -> m (CallConv l)
forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> CallConv l -> m (CallConv l)
forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (CallConv l)
forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CallConv l -> c (CallConv l)
forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (CallConv l))
forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (CallConv l))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> CallConv l -> u
forall u. (forall d. Data d => d -> u) -> CallConv l -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CallConv l -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CallConv l -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CallConv l -> m (CallConv l)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CallConv l -> m (CallConv l)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (CallConv l)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CallConv l -> c (CallConv l)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (CallConv l))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (CallConv l))
$cgfoldl :: forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CallConv l -> c (CallConv l)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CallConv l -> c (CallConv l)
$cgunfold :: forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (CallConv l)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (CallConv l)
$ctoConstr :: forall l. Data l => CallConv l -> Constr
toConstr :: CallConv l -> Constr
$cdataTypeOf :: forall l. Data l => CallConv l -> DataType
dataTypeOf :: CallConv l -> DataType
$cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (CallConv l))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (CallConv l))
$cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (CallConv l))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (CallConv l))
$cgmapT :: forall l.
Data l =>
(forall b. Data b => b -> b) -> CallConv l -> CallConv l
gmapT :: (forall b. Data b => b -> b) -> CallConv l -> CallConv l
$cgmapQl :: forall l r r'.
Data l =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CallConv l -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CallConv l -> r
$cgmapQr :: forall l r r'.
Data l =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CallConv l -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CallConv l -> r
$cgmapQ :: forall l u.
Data l =>
(forall d. Data d => d -> u) -> CallConv l -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> CallConv l -> [u]
$cgmapQi :: forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> CallConv l -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> CallConv l -> u
$cgmapM :: forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d) -> CallConv l -> m (CallConv l)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CallConv l -> m (CallConv l)
$cgmapMp :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> CallConv l -> m (CallConv l)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CallConv l -> m (CallConv l)
$cgmapMo :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> CallConv l -> m (CallConv l)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CallConv l -> m (CallConv l)
Data,(forall m. Monoid m => CallConv m -> m)
-> (forall m a. Monoid m => (a -> m) -> CallConv a -> m)
-> (forall m a. Monoid m => (a -> m) -> CallConv a -> m)
-> (forall a b. (a -> b -> b) -> b -> CallConv a -> b)
-> (forall a b. (a -> b -> b) -> b -> CallConv a -> b)
-> (forall b a. (b -> a -> b) -> b -> CallConv a -> b)
-> (forall b a. (b -> a -> b) -> b -> CallConv a -> b)
-> (forall a. (a -> a -> a) -> CallConv a -> a)
-> (forall a. (a -> a -> a) -> CallConv a -> a)
-> (forall a. CallConv a -> [a])
-> (forall a. CallConv a -> Bool)
-> (forall a. CallConv a -> Int)
-> (forall a. Eq a => a -> CallConv a -> Bool)
-> (forall a. Ord a => CallConv a -> a)
-> (forall a. Ord a => CallConv a -> a)
-> (forall a. Num a => CallConv a -> a)
-> (forall a. Num a => CallConv a -> a)
-> Foldable CallConv
forall a. Eq a => a -> CallConv a -> Bool
forall a. Num a => CallConv a -> a
forall a. Ord a => CallConv a -> a
forall m. Monoid m => CallConv m -> m
forall a. CallConv a -> Bool
forall a. CallConv a -> Int
forall a. CallConv a -> [a]
forall a. (a -> a -> a) -> CallConv a -> a
forall m a. Monoid m => (a -> m) -> CallConv a -> m
forall b a. (b -> a -> b) -> b -> CallConv a -> b
forall a b. (a -> b -> b) -> b -> CallConv a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall m. Monoid m => CallConv m -> m
fold :: forall m. Monoid m => CallConv m -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> CallConv a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> CallConv a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> CallConv a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> CallConv a -> m
$cfoldr :: forall a b. (a -> b -> b) -> b -> CallConv a -> b
foldr :: forall a b. (a -> b -> b) -> b -> CallConv a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> CallConv a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> CallConv a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> CallConv a -> b
foldl :: forall b a. (b -> a -> b) -> b -> CallConv a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> CallConv a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> CallConv a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> CallConv a -> a
foldr1 :: forall a. (a -> a -> a) -> CallConv a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> CallConv a -> a
foldl1 :: forall a. (a -> a -> a) -> CallConv a -> a
$ctoList :: forall a. CallConv a -> [a]
toList :: forall a. CallConv a -> [a]
$cnull :: forall a. CallConv a -> Bool
null :: forall a. CallConv a -> Bool
$clength :: forall a. CallConv a -> Int
length :: forall a. CallConv a -> Int
$celem :: forall a. Eq a => a -> CallConv a -> Bool
elem :: forall a. Eq a => a -> CallConv a -> Bool
$cmaximum :: forall a. Ord a => CallConv a -> a
maximum :: forall a. Ord a => CallConv a -> a
$cminimum :: forall a. Ord a => CallConv a -> a
minimum :: forall a. Ord a => CallConv a -> a
$csum :: forall a. Num a => CallConv a -> a
sum :: forall a. Num a => CallConv a -> a
$cproduct :: forall a. Num a => CallConv a -> a
product :: forall a. Num a => CallConv a -> a
Foldable,Functor CallConv
Foldable CallConv
(Functor CallConv, Foldable CallConv) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> CallConv a -> f (CallConv b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    CallConv (f a) -> f (CallConv a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> CallConv a -> m (CallConv b))
-> (forall (m :: * -> *) a.
    Monad m =>
    CallConv (m a) -> m (CallConv a))
-> Traversable CallConv
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a. Monad m => CallConv (m a) -> m (CallConv a)
forall (f :: * -> *) a.
Applicative f =>
CallConv (f a) -> f (CallConv a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> CallConv a -> m (CallConv b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> CallConv a -> f (CallConv b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> CallConv a -> f (CallConv b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> CallConv a -> f (CallConv b)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
CallConv (f a) -> f (CallConv a)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
CallConv (f a) -> f (CallConv a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> CallConv a -> m (CallConv b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> CallConv a -> m (CallConv b)
$csequence :: forall (m :: * -> *) a. Monad m => CallConv (m a) -> m (CallConv a)
sequence :: forall (m :: * -> *) a. Monad m => CallConv (m a) -> m (CallConv a)
Traversable,(forall a b. (a -> b) -> CallConv a -> CallConv b)
-> (forall a b. a -> CallConv b -> CallConv a) -> Functor CallConv
forall a b. a -> CallConv b -> CallConv a
forall a b. (a -> b) -> CallConv a -> CallConv b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> CallConv a -> CallConv b
fmap :: forall a b. (a -> b) -> CallConv a -> CallConv b
$c<$ :: forall a b. a -> CallConv b -> CallConv a
<$ :: forall a b. a -> CallConv b -> CallConv a
Functor,(forall x. CallConv l -> Rep (CallConv l) x)
-> (forall x. Rep (CallConv l) x -> CallConv l)
-> Generic (CallConv l)
forall x. Rep (CallConv l) x -> CallConv l
forall x. CallConv l -> Rep (CallConv l) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall l x. Rep (CallConv l) x -> CallConv l
forall l x. CallConv l -> Rep (CallConv l) x
$cfrom :: forall l x. CallConv l -> Rep (CallConv l) x
from :: forall x. CallConv l -> Rep (CallConv l) x
$cto :: forall l x. Rep (CallConv l) x -> CallConv l
to :: forall x. Rep (CallConv l) x -> CallConv l
Generic)

-- | A top level options pragma, preceding the module header.
data ModulePragma l
    = LanguagePragma   l [Name l]  -- ^ LANGUAGE pragma
    | OptionsPragma    l (Maybe Tool) String
                        -- ^ OPTIONS pragma, possibly qualified with a tool, e.g. OPTIONS_GHC
    | AnnModulePragma  l (Annotation l)
                        -- ^ ANN pragma with module scope
  deriving (ModulePragma l -> ModulePragma l -> Bool
(ModulePragma l -> ModulePragma l -> Bool)
-> (ModulePragma l -> ModulePragma l -> Bool)
-> Eq (ModulePragma l)
forall l. Eq l => ModulePragma l -> ModulePragma l -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall l. Eq l => ModulePragma l -> ModulePragma l -> Bool
== :: ModulePragma l -> ModulePragma l -> Bool
$c/= :: forall l. Eq l => ModulePragma l -> ModulePragma l -> Bool
/= :: ModulePragma l -> ModulePragma l -> Bool
Eq,Eq (ModulePragma l)
Eq (ModulePragma l) =>
(ModulePragma l -> ModulePragma l -> Ordering)
-> (ModulePragma l -> ModulePragma l -> Bool)
-> (ModulePragma l -> ModulePragma l -> Bool)
-> (ModulePragma l -> ModulePragma l -> Bool)
-> (ModulePragma l -> ModulePragma l -> Bool)
-> (ModulePragma l -> ModulePragma l -> ModulePragma l)
-> (ModulePragma l -> ModulePragma l -> ModulePragma l)
-> Ord (ModulePragma l)
ModulePragma l -> ModulePragma l -> Bool
ModulePragma l -> ModulePragma l -> Ordering
ModulePragma l -> ModulePragma l -> ModulePragma l
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall l. Ord l => Eq (ModulePragma l)
forall l. Ord l => ModulePragma l -> ModulePragma l -> Bool
forall l. Ord l => ModulePragma l -> ModulePragma l -> Ordering
forall l.
Ord l =>
ModulePragma l -> ModulePragma l -> ModulePragma l
$ccompare :: forall l. Ord l => ModulePragma l -> ModulePragma l -> Ordering
compare :: ModulePragma l -> ModulePragma l -> Ordering
$c< :: forall l. Ord l => ModulePragma l -> ModulePragma l -> Bool
< :: ModulePragma l -> ModulePragma l -> Bool
$c<= :: forall l. Ord l => ModulePragma l -> ModulePragma l -> Bool
<= :: ModulePragma l -> ModulePragma l -> Bool
$c> :: forall l. Ord l => ModulePragma l -> ModulePragma l -> Bool
> :: ModulePragma l -> ModulePragma l -> Bool
$c>= :: forall l. Ord l => ModulePragma l -> ModulePragma l -> Bool
>= :: ModulePragma l -> ModulePragma l -> Bool
$cmax :: forall l.
Ord l =>
ModulePragma l -> ModulePragma l -> ModulePragma l
max :: ModulePragma l -> ModulePragma l -> ModulePragma l
$cmin :: forall l.
Ord l =>
ModulePragma l -> ModulePragma l -> ModulePragma l
min :: ModulePragma l -> ModulePragma l -> ModulePragma l
Ord,Int -> ModulePragma l -> ShowS
[ModulePragma l] -> ShowS
ModulePragma l -> String
(Int -> ModulePragma l -> ShowS)
-> (ModulePragma l -> String)
-> ([ModulePragma l] -> ShowS)
-> Show (ModulePragma l)
forall l. Show l => Int -> ModulePragma l -> ShowS
forall l. Show l => [ModulePragma l] -> ShowS
forall l. Show l => ModulePragma l -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall l. Show l => Int -> ModulePragma l -> ShowS
showsPrec :: Int -> ModulePragma l -> ShowS
$cshow :: forall l. Show l => ModulePragma l -> String
show :: ModulePragma l -> String
$cshowList :: forall l. Show l => [ModulePragma l] -> ShowS
showList :: [ModulePragma l] -> ShowS
Show,Typeable,Typeable (ModulePragma l)
Typeable (ModulePragma l) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> ModulePragma l -> c (ModulePragma l))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (ModulePragma l))
-> (ModulePragma l -> Constr)
-> (ModulePragma l -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (ModulePragma l)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (ModulePragma l)))
-> ((forall b. Data b => b -> b)
    -> ModulePragma l -> ModulePragma l)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ModulePragma l -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ModulePragma l -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> ModulePragma l -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> ModulePragma l -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> ModulePragma l -> m (ModulePragma l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> ModulePragma l -> m (ModulePragma l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> ModulePragma l -> m (ModulePragma l))
-> Data (ModulePragma l)
ModulePragma l -> Constr
ModulePragma l -> DataType
(forall b. Data b => b -> b) -> ModulePragma l -> ModulePragma l
forall l. Data l => Typeable (ModulePragma l)
forall l. Data l => ModulePragma l -> Constr
forall l. Data l => ModulePragma l -> DataType
forall l.
Data l =>
(forall b. Data b => b -> b) -> ModulePragma l -> ModulePragma l
forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> ModulePragma l -> u
forall l u.
Data l =>
(forall d. Data d => d -> u) -> ModulePragma l -> [u]
forall l r r'.
Data l =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ModulePragma l -> r
forall l r r'.
Data l =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ModulePragma l -> r
forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d)
-> ModulePragma l -> m (ModulePragma l)
forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> ModulePragma l -> m (ModulePragma l)
forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ModulePragma l)
forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ModulePragma l -> c (ModulePragma l)
forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (ModulePragma l))
forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ModulePragma l))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> ModulePragma l -> u
forall u. (forall d. Data d => d -> u) -> ModulePragma l -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ModulePragma l -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ModulePragma l -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> ModulePragma l -> m (ModulePragma l)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ModulePragma l -> m (ModulePragma l)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ModulePragma l)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ModulePragma l -> c (ModulePragma l)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (ModulePragma l))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ModulePragma l))
$cgfoldl :: forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ModulePragma l -> c (ModulePragma l)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ModulePragma l -> c (ModulePragma l)
$cgunfold :: forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ModulePragma l)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ModulePragma l)
$ctoConstr :: forall l. Data l => ModulePragma l -> Constr
toConstr :: ModulePragma l -> Constr
$cdataTypeOf :: forall l. Data l => ModulePragma l -> DataType
dataTypeOf :: ModulePragma l -> DataType
$cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (ModulePragma l))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (ModulePragma l))
$cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ModulePragma l))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ModulePragma l))
$cgmapT :: forall l.
Data l =>
(forall b. Data b => b -> b) -> ModulePragma l -> ModulePragma l
gmapT :: (forall b. Data b => b -> b) -> ModulePragma l -> ModulePragma l
$cgmapQl :: forall l r r'.
Data l =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ModulePragma l -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ModulePragma l -> r
$cgmapQr :: forall l r r'.
Data l =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ModulePragma l -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ModulePragma l -> r
$cgmapQ :: forall l u.
Data l =>
(forall d. Data d => d -> u) -> ModulePragma l -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> ModulePragma l -> [u]
$cgmapQi :: forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> ModulePragma l -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> ModulePragma l -> u
$cgmapM :: forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d)
-> ModulePragma l -> m (ModulePragma l)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> ModulePragma l -> m (ModulePragma l)
$cgmapMp :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> ModulePragma l -> m (ModulePragma l)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ModulePragma l -> m (ModulePragma l)
$cgmapMo :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> ModulePragma l -> m (ModulePragma l)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ModulePragma l -> m (ModulePragma l)
Data,(forall m. Monoid m => ModulePragma m -> m)
-> (forall m a. Monoid m => (a -> m) -> ModulePragma a -> m)
-> (forall m a. Monoid m => (a -> m) -> ModulePragma a -> m)
-> (forall a b. (a -> b -> b) -> b -> ModulePragma a -> b)
-> (forall a b. (a -> b -> b) -> b -> ModulePragma a -> b)
-> (forall b a. (b -> a -> b) -> b -> ModulePragma a -> b)
-> (forall b a. (b -> a -> b) -> b -> ModulePragma a -> b)
-> (forall a. (a -> a -> a) -> ModulePragma a -> a)
-> (forall a. (a -> a -> a) -> ModulePragma a -> a)
-> (forall a. ModulePragma a -> [a])
-> (forall a. ModulePragma a -> Bool)
-> (forall a. ModulePragma a -> Int)
-> (forall a. Eq a => a -> ModulePragma a -> Bool)
-> (forall a. Ord a => ModulePragma a -> a)
-> (forall a. Ord a => ModulePragma a -> a)
-> (forall a. Num a => ModulePragma a -> a)
-> (forall a. Num a => ModulePragma a -> a)
-> Foldable ModulePragma
forall a. Eq a => a -> ModulePragma a -> Bool
forall a. Num a => ModulePragma a -> a
forall a. Ord a => ModulePragma a -> a
forall m. Monoid m => ModulePragma m -> m
forall a. ModulePragma a -> Bool
forall a. ModulePragma a -> Int
forall a. ModulePragma a -> [a]
forall a. (a -> a -> a) -> ModulePragma a -> a
forall m a. Monoid m => (a -> m) -> ModulePragma a -> m
forall b a. (b -> a -> b) -> b -> ModulePragma a -> b
forall a b. (a -> b -> b) -> b -> ModulePragma a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall m. Monoid m => ModulePragma m -> m
fold :: forall m. Monoid m => ModulePragma m -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> ModulePragma a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> ModulePragma a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> ModulePragma a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> ModulePragma a -> m
$cfoldr :: forall a b. (a -> b -> b) -> b -> ModulePragma a -> b
foldr :: forall a b. (a -> b -> b) -> b -> ModulePragma a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> ModulePragma a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> ModulePragma a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> ModulePragma a -> b
foldl :: forall b a. (b -> a -> b) -> b -> ModulePragma a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> ModulePragma a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> ModulePragma a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> ModulePragma a -> a
foldr1 :: forall a. (a -> a -> a) -> ModulePragma a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> ModulePragma a -> a
foldl1 :: forall a. (a -> a -> a) -> ModulePragma a -> a
$ctoList :: forall a. ModulePragma a -> [a]
toList :: forall a. ModulePragma a -> [a]
$cnull :: forall a. ModulePragma a -> Bool
null :: forall a. ModulePragma a -> Bool
$clength :: forall a. ModulePragma a -> Int
length :: forall a. ModulePragma a -> Int
$celem :: forall a. Eq a => a -> ModulePragma a -> Bool
elem :: forall a. Eq a => a -> ModulePragma a -> Bool
$cmaximum :: forall a. Ord a => ModulePragma a -> a
maximum :: forall a. Ord a => ModulePragma a -> a
$cminimum :: forall a. Ord a => ModulePragma a -> a
minimum :: forall a. Ord a => ModulePragma a -> a
$csum :: forall a. Num a => ModulePragma a -> a
sum :: forall a. Num a => ModulePragma a -> a
$cproduct :: forall a. Num a => ModulePragma a -> a
product :: forall a. Num a => ModulePragma a -> a
Foldable,Functor ModulePragma
Foldable ModulePragma
(Functor ModulePragma, Foldable ModulePragma) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> ModulePragma a -> f (ModulePragma b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    ModulePragma (f a) -> f (ModulePragma a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> ModulePragma a -> m (ModulePragma b))
-> (forall (m :: * -> *) a.
    Monad m =>
    ModulePragma (m a) -> m (ModulePragma a))
-> Traversable ModulePragma
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a.
Monad m =>
ModulePragma (m a) -> m (ModulePragma a)
forall (f :: * -> *) a.
Applicative f =>
ModulePragma (f a) -> f (ModulePragma a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> ModulePragma a -> m (ModulePragma b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> ModulePragma a -> f (ModulePragma b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> ModulePragma a -> f (ModulePragma b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> ModulePragma a -> f (ModulePragma b)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
ModulePragma (f a) -> f (ModulePragma a)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
ModulePragma (f a) -> f (ModulePragma a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> ModulePragma a -> m (ModulePragma b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> ModulePragma a -> m (ModulePragma b)
$csequence :: forall (m :: * -> *) a.
Monad m =>
ModulePragma (m a) -> m (ModulePragma a)
sequence :: forall (m :: * -> *) a.
Monad m =>
ModulePragma (m a) -> m (ModulePragma a)
Traversable,(forall a b. (a -> b) -> ModulePragma a -> ModulePragma b)
-> (forall a b. a -> ModulePragma b -> ModulePragma a)
-> Functor ModulePragma
forall a b. a -> ModulePragma b -> ModulePragma a
forall a b. (a -> b) -> ModulePragma a -> ModulePragma b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> ModulePragma a -> ModulePragma b
fmap :: forall a b. (a -> b) -> ModulePragma a -> ModulePragma b
$c<$ :: forall a b. a -> ModulePragma b -> ModulePragma a
<$ :: forall a b. a -> ModulePragma b -> ModulePragma a
Functor,(forall x. ModulePragma l -> Rep (ModulePragma l) x)
-> (forall x. Rep (ModulePragma l) x -> ModulePragma l)
-> Generic (ModulePragma l)
forall x. Rep (ModulePragma l) x -> ModulePragma l
forall x. ModulePragma l -> Rep (ModulePragma l) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall l x. Rep (ModulePragma l) x -> ModulePragma l
forall l x. ModulePragma l -> Rep (ModulePragma l) x
$cfrom :: forall l x. ModulePragma l -> Rep (ModulePragma l) x
from :: forall x. ModulePragma l -> Rep (ModulePragma l) x
$cto :: forall l x. Rep (ModulePragma l) x -> ModulePragma l
to :: forall x. Rep (ModulePragma l) x -> ModulePragma l
Generic)

-- | Recognised tools for OPTIONS pragmas.
data Tool = GHC | HUGS | NHC98 | YHC | HADDOCK | UnknownTool String
  deriving (Tool -> Tool -> Bool
(Tool -> Tool -> Bool) -> (Tool -> Tool -> Bool) -> Eq Tool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Tool -> Tool -> Bool
== :: Tool -> Tool -> Bool
$c/= :: Tool -> Tool -> Bool
/= :: Tool -> Tool -> Bool
Eq,Eq Tool
Eq Tool =>
(Tool -> Tool -> Ordering)
-> (Tool -> Tool -> Bool)
-> (Tool -> Tool -> Bool)
-> (Tool -> Tool -> Bool)
-> (Tool -> Tool -> Bool)
-> (Tool -> Tool -> Tool)
-> (Tool -> Tool -> Tool)
-> Ord Tool
Tool -> Tool -> Bool
Tool -> Tool -> Ordering
Tool -> Tool -> Tool
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Tool -> Tool -> Ordering
compare :: Tool -> Tool -> Ordering
$c< :: Tool -> Tool -> Bool
< :: Tool -> Tool -> Bool
$c<= :: Tool -> Tool -> Bool
<= :: Tool -> Tool -> Bool
$c> :: Tool -> Tool -> Bool
> :: Tool -> Tool -> Bool
$c>= :: Tool -> Tool -> Bool
>= :: Tool -> Tool -> Bool
$cmax :: Tool -> Tool -> Tool
max :: Tool -> Tool -> Tool
$cmin :: Tool -> Tool -> Tool
min :: Tool -> Tool -> Tool
Ord,Int -> Tool -> ShowS
[Tool] -> ShowS
Tool -> String
(Int -> Tool -> ShowS)
-> (Tool -> String) -> ([Tool] -> ShowS) -> Show Tool
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Tool -> ShowS
showsPrec :: Int -> Tool -> ShowS
$cshow :: Tool -> String
show :: Tool -> String
$cshowList :: [Tool] -> ShowS
showList :: [Tool] -> ShowS
Show,Typeable,Typeable Tool
Typeable Tool =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Tool -> c Tool)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Tool)
-> (Tool -> Constr)
-> (Tool -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Tool))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Tool))
-> ((forall b. Data b => b -> b) -> Tool -> Tool)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Tool -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Tool -> r)
-> (forall u. (forall d. Data d => d -> u) -> Tool -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Tool -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Tool -> m Tool)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Tool -> m Tool)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Tool -> m Tool)
-> Data Tool
Tool -> Constr
Tool -> DataType
(forall b. Data b => b -> b) -> Tool -> Tool
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Tool -> u
forall u. (forall d. Data d => d -> u) -> Tool -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Tool -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Tool -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Tool -> m Tool
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Tool -> m Tool
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Tool
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Tool -> c Tool
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Tool)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Tool)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Tool -> c Tool
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Tool -> c Tool
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Tool
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Tool
$ctoConstr :: Tool -> Constr
toConstr :: Tool -> Constr
$cdataTypeOf :: Tool -> DataType
dataTypeOf :: Tool -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Tool)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Tool)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Tool)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Tool)
$cgmapT :: (forall b. Data b => b -> b) -> Tool -> Tool
gmapT :: (forall b. Data b => b -> b) -> Tool -> Tool
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Tool -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Tool -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Tool -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Tool -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Tool -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Tool -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Tool -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Tool -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Tool -> m Tool
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Tool -> m Tool
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Tool -> m Tool
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Tool -> m Tool
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Tool -> m Tool
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Tool -> m Tool
Data,(forall x. Tool -> Rep Tool x)
-> (forall x. Rep Tool x -> Tool) -> Generic Tool
forall x. Rep Tool x -> Tool
forall x. Tool -> Rep Tool x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Tool -> Rep Tool x
from :: forall x. Tool -> Rep Tool x
$cto :: forall x. Rep Tool x -> Tool
to :: forall x. Rep Tool x -> Tool
Generic)

-- | Recognised overlaps for overlap pragmas.
data Overlap l
    = NoOverlap l   -- ^ NO_OVERLAP pragma
    | Overlap l     -- ^ OVERLAP pragma
    | Overlapping l
    | Overlaps l
    | Overlappable l
    | Incoherent l  -- ^ INCOHERENT pragma
  deriving (Overlap l -> Overlap l -> Bool
(Overlap l -> Overlap l -> Bool)
-> (Overlap l -> Overlap l -> Bool) -> Eq (Overlap l)
forall l. Eq l => Overlap l -> Overlap l -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall l. Eq l => Overlap l -> Overlap l -> Bool
== :: Overlap l -> Overlap l -> Bool
$c/= :: forall l. Eq l => Overlap l -> Overlap l -> Bool
/= :: Overlap l -> Overlap l -> Bool
Eq,Eq (Overlap l)
Eq (Overlap l) =>
(Overlap l -> Overlap l -> Ordering)
-> (Overlap l -> Overlap l -> Bool)
-> (Overlap l -> Overlap l -> Bool)
-> (Overlap l -> Overlap l -> Bool)
-> (Overlap l -> Overlap l -> Bool)
-> (Overlap l -> Overlap l -> Overlap l)
-> (Overlap l -> Overlap l -> Overlap l)
-> Ord (Overlap l)
Overlap l -> Overlap l -> Bool
Overlap l -> Overlap l -> Ordering
Overlap l -> Overlap l -> Overlap l
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall l. Ord l => Eq (Overlap l)
forall l. Ord l => Overlap l -> Overlap l -> Bool
forall l. Ord l => Overlap l -> Overlap l -> Ordering
forall l. Ord l => Overlap l -> Overlap l -> Overlap l
$ccompare :: forall l. Ord l => Overlap l -> Overlap l -> Ordering
compare :: Overlap l -> Overlap l -> Ordering
$c< :: forall l. Ord l => Overlap l -> Overlap l -> Bool
< :: Overlap l -> Overlap l -> Bool
$c<= :: forall l. Ord l => Overlap l -> Overlap l -> Bool
<= :: Overlap l -> Overlap l -> Bool
$c> :: forall l. Ord l => Overlap l -> Overlap l -> Bool
> :: Overlap l -> Overlap l -> Bool
$c>= :: forall l. Ord l => Overlap l -> Overlap l -> Bool
>= :: Overlap l -> Overlap l -> Bool
$cmax :: forall l. Ord l => Overlap l -> Overlap l -> Overlap l
max :: Overlap l -> Overlap l -> Overlap l
$cmin :: forall l. Ord l => Overlap l -> Overlap l -> Overlap l
min :: Overlap l -> Overlap l -> Overlap l
Ord,Int -> Overlap l -> ShowS
[Overlap l] -> ShowS
Overlap l -> String
(Int -> Overlap l -> ShowS)
-> (Overlap l -> String)
-> ([Overlap l] -> ShowS)
-> Show (Overlap l)
forall l. Show l => Int -> Overlap l -> ShowS
forall l. Show l => [Overlap l] -> ShowS
forall l. Show l => Overlap l -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall l. Show l => Int -> Overlap l -> ShowS
showsPrec :: Int -> Overlap l -> ShowS
$cshow :: forall l. Show l => Overlap l -> String
show :: Overlap l -> String
$cshowList :: forall l. Show l => [Overlap l] -> ShowS
showList :: [Overlap l] -> ShowS
Show,Typeable,Typeable (Overlap l)
Typeable (Overlap l) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Overlap l -> c (Overlap l))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Overlap l))
-> (Overlap l -> Constr)
-> (Overlap l -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Overlap l)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Overlap l)))
-> ((forall b. Data b => b -> b) -> Overlap l -> Overlap l)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Overlap l -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Overlap l -> r)
-> (forall u. (forall d. Data d => d -> u) -> Overlap l -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Overlap l -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Overlap l -> m (Overlap l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Overlap l -> m (Overlap l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Overlap l -> m (Overlap l))
-> Data (Overlap l)
Overlap l -> Constr
Overlap l -> DataType
(forall b. Data b => b -> b) -> Overlap l -> Overlap l
forall l. Data l => Typeable (Overlap l)
forall l. Data l => Overlap l -> Constr
forall l. Data l => Overlap l -> DataType
forall l.
Data l =>
(forall b. Data b => b -> b) -> Overlap l -> Overlap l
forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> Overlap l -> u
forall l u.
Data l =>
(forall d. Data d => d -> u) -> Overlap l -> [u]
forall l r r'.
Data l =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Overlap l -> r
forall l r r'.
Data l =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Overlap l -> r
forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d) -> Overlap l -> m (Overlap l)
forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Overlap l -> m (Overlap l)
forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Overlap l)
forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Overlap l -> c (Overlap l)
forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Overlap l))
forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Overlap l))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Overlap l -> u
forall u. (forall d. Data d => d -> u) -> Overlap l -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Overlap l -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Overlap l -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Overlap l -> m (Overlap l)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Overlap l -> m (Overlap l)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Overlap l)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Overlap l -> c (Overlap l)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Overlap l))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Overlap l))
$cgfoldl :: forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Overlap l -> c (Overlap l)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Overlap l -> c (Overlap l)
$cgunfold :: forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Overlap l)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Overlap l)
$ctoConstr :: forall l. Data l => Overlap l -> Constr
toConstr :: Overlap l -> Constr
$cdataTypeOf :: forall l. Data l => Overlap l -> DataType
dataTypeOf :: Overlap l -> DataType
$cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Overlap l))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Overlap l))
$cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Overlap l))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Overlap l))
$cgmapT :: forall l.
Data l =>
(forall b. Data b => b -> b) -> Overlap l -> Overlap l
gmapT :: (forall b. Data b => b -> b) -> Overlap l -> Overlap l
$cgmapQl :: forall l r r'.
Data l =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Overlap l -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Overlap l -> r
$cgmapQr :: forall l r r'.
Data l =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Overlap l -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Overlap l -> r
$cgmapQ :: forall l u.
Data l =>
(forall d. Data d => d -> u) -> Overlap l -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Overlap l -> [u]
$cgmapQi :: forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> Overlap l -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Overlap l -> u
$cgmapM :: forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d) -> Overlap l -> m (Overlap l)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Overlap l -> m (Overlap l)
$cgmapMp :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Overlap l -> m (Overlap l)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Overlap l -> m (Overlap l)
$cgmapMo :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Overlap l -> m (Overlap l)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Overlap l -> m (Overlap l)
Data,(forall m. Monoid m => Overlap m -> m)
-> (forall m a. Monoid m => (a -> m) -> Overlap a -> m)
-> (forall m a. Monoid m => (a -> m) -> Overlap a -> m)
-> (forall a b. (a -> b -> b) -> b -> Overlap a -> b)
-> (forall a b. (a -> b -> b) -> b -> Overlap a -> b)
-> (forall b a. (b -> a -> b) -> b -> Overlap a -> b)
-> (forall b a. (b -> a -> b) -> b -> Overlap a -> b)
-> (forall a. (a -> a -> a) -> Overlap a -> a)
-> (forall a. (a -> a -> a) -> Overlap a -> a)
-> (forall a. Overlap a -> [a])
-> (forall a. Overlap a -> Bool)
-> (forall a. Overlap a -> Int)
-> (forall a. Eq a => a -> Overlap a -> Bool)
-> (forall a. Ord a => Overlap a -> a)
-> (forall a. Ord a => Overlap a -> a)
-> (forall a. Num a => Overlap a -> a)
-> (forall a. Num a => Overlap a -> a)
-> Foldable Overlap
forall a. Eq a => a -> Overlap a -> Bool
forall a. Num a => Overlap a -> a
forall a. Ord a => Overlap a -> a
forall m. Monoid m => Overlap m -> m
forall a. Overlap a -> Bool
forall a. Overlap a -> Int
forall a. Overlap a -> [a]
forall a. (a -> a -> a) -> Overlap a -> a
forall m a. Monoid m => (a -> m) -> Overlap a -> m
forall b a. (b -> a -> b) -> b -> Overlap a -> b
forall a b. (a -> b -> b) -> b -> Overlap a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall m. Monoid m => Overlap m -> m
fold :: forall m. Monoid m => Overlap m -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> Overlap a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> Overlap a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> Overlap a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> Overlap a -> m
$cfoldr :: forall a b. (a -> b -> b) -> b -> Overlap a -> b
foldr :: forall a b. (a -> b -> b) -> b -> Overlap a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> Overlap a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> Overlap a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> Overlap a -> b
foldl :: forall b a. (b -> a -> b) -> b -> Overlap a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> Overlap a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> Overlap a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> Overlap a -> a
foldr1 :: forall a. (a -> a -> a) -> Overlap a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> Overlap a -> a
foldl1 :: forall a. (a -> a -> a) -> Overlap a -> a
$ctoList :: forall a. Overlap a -> [a]
toList :: forall a. Overlap a -> [a]
$cnull :: forall a. Overlap a -> Bool
null :: forall a. Overlap a -> Bool
$clength :: forall a. Overlap a -> Int
length :: forall a. Overlap a -> Int
$celem :: forall a. Eq a => a -> Overlap a -> Bool
elem :: forall a. Eq a => a -> Overlap a -> Bool
$cmaximum :: forall a. Ord a => Overlap a -> a
maximum :: forall a. Ord a => Overlap a -> a
$cminimum :: forall a. Ord a => Overlap a -> a
minimum :: forall a. Ord a => Overlap a -> a
$csum :: forall a. Num a => Overlap a -> a
sum :: forall a. Num a => Overlap a -> a
$cproduct :: forall a. Num a => Overlap a -> a
product :: forall a. Num a => Overlap a -> a
Foldable,Functor Overlap
Foldable Overlap
(Functor Overlap, Foldable Overlap) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> Overlap a -> f (Overlap b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    Overlap (f a) -> f (Overlap a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Overlap a -> m (Overlap b))
-> (forall (m :: * -> *) a.
    Monad m =>
    Overlap (m a) -> m (Overlap a))
-> Traversable Overlap
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a. Monad m => Overlap (m a) -> m (Overlap a)
forall (f :: * -> *) a.
Applicative f =>
Overlap (f a) -> f (Overlap a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Overlap a -> m (Overlap b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Overlap a -> f (Overlap b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Overlap a -> f (Overlap b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Overlap a -> f (Overlap b)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
Overlap (f a) -> f (Overlap a)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
Overlap (f a) -> f (Overlap a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Overlap a -> m (Overlap b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Overlap a -> m (Overlap b)
$csequence :: forall (m :: * -> *) a. Monad m => Overlap (m a) -> m (Overlap a)
sequence :: forall (m :: * -> *) a. Monad m => Overlap (m a) -> m (Overlap a)
Traversable,(forall a b. (a -> b) -> Overlap a -> Overlap b)
-> (forall a b. a -> Overlap b -> Overlap a) -> Functor Overlap
forall a b. a -> Overlap b -> Overlap a
forall a b. (a -> b) -> Overlap a -> Overlap b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> Overlap a -> Overlap b
fmap :: forall a b. (a -> b) -> Overlap a -> Overlap b
$c<$ :: forall a b. a -> Overlap b -> Overlap a
<$ :: forall a b. a -> Overlap b -> Overlap a
Functor,(forall x. Overlap l -> Rep (Overlap l) x)
-> (forall x. Rep (Overlap l) x -> Overlap l)
-> Generic (Overlap l)
forall x. Rep (Overlap l) x -> Overlap l
forall x. Overlap l -> Rep (Overlap l) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall l x. Rep (Overlap l) x -> Overlap l
forall l x. Overlap l -> Rep (Overlap l) x
$cfrom :: forall l x. Overlap l -> Rep (Overlap l) x
from :: forall x. Overlap l -> Rep (Overlap l) x
$cto :: forall l x. Rep (Overlap l) x -> Overlap l
to :: forall x. Rep (Overlap l) x -> Overlap l
Generic)

-- | Activation clause of a RULES pragma.
data Activation l
    = ActiveFrom   l Int
    | ActiveUntil  l Int
  deriving (Activation l -> Activation l -> Bool
(Activation l -> Activation l -> Bool)
-> (Activation l -> Activation l -> Bool) -> Eq (Activation l)
forall l. Eq l => Activation l -> Activation l -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall l. Eq l => Activation l -> Activation l -> Bool
== :: Activation l -> Activation l -> Bool
$c/= :: forall l. Eq l => Activation l -> Activation l -> Bool
/= :: Activation l -> Activation l -> Bool
Eq,Eq (Activation l)
Eq (Activation l) =>
(Activation l -> Activation l -> Ordering)
-> (Activation l -> Activation l -> Bool)
-> (Activation l -> Activation l -> Bool)
-> (Activation l -> Activation l -> Bool)
-> (Activation l -> Activation l -> Bool)
-> (Activation l -> Activation l -> Activation l)
-> (Activation l -> Activation l -> Activation l)
-> Ord (Activation l)
Activation l -> Activation l -> Bool
Activation l -> Activation l -> Ordering
Activation l -> Activation l -> Activation l
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall l. Ord l => Eq (Activation l)
forall l. Ord l => Activation l -> Activation l -> Bool
forall l. Ord l => Activation l -> Activation l -> Ordering
forall l. Ord l => Activation l -> Activation l -> Activation l
$ccompare :: forall l. Ord l => Activation l -> Activation l -> Ordering
compare :: Activation l -> Activation l -> Ordering
$c< :: forall l. Ord l => Activation l -> Activation l -> Bool
< :: Activation l -> Activation l -> Bool
$c<= :: forall l. Ord l => Activation l -> Activation l -> Bool
<= :: Activation l -> Activation l -> Bool
$c> :: forall l. Ord l => Activation l -> Activation l -> Bool
> :: Activation l -> Activation l -> Bool
$c>= :: forall l. Ord l => Activation l -> Activation l -> Bool
>= :: Activation l -> Activation l -> Bool
$cmax :: forall l. Ord l => Activation l -> Activation l -> Activation l
max :: Activation l -> Activation l -> Activation l
$cmin :: forall l. Ord l => Activation l -> Activation l -> Activation l
min :: Activation l -> Activation l -> Activation l
Ord,Int -> Activation l -> ShowS
[Activation l] -> ShowS
Activation l -> String
(Int -> Activation l -> ShowS)
-> (Activation l -> String)
-> ([Activation l] -> ShowS)
-> Show (Activation l)
forall l. Show l => Int -> Activation l -> ShowS
forall l. Show l => [Activation l] -> ShowS
forall l. Show l => Activation l -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall l. Show l => Int -> Activation l -> ShowS
showsPrec :: Int -> Activation l -> ShowS
$cshow :: forall l. Show l => Activation l -> String
show :: Activation l -> String
$cshowList :: forall l. Show l => [Activation l] -> ShowS
showList :: [Activation l] -> ShowS
Show,Typeable,Typeable (Activation l)
Typeable (Activation l) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Activation l -> c (Activation l))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Activation l))
-> (Activation l -> Constr)
-> (Activation l -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Activation l)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Activation l)))
-> ((forall b. Data b => b -> b) -> Activation l -> Activation l)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Activation l -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Activation l -> r)
-> (forall u. (forall d. Data d => d -> u) -> Activation l -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Activation l -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Activation l -> m (Activation l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Activation l -> m (Activation l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Activation l -> m (Activation l))
-> Data (Activation l)
Activation l -> Constr
Activation l -> DataType
(forall b. Data b => b -> b) -> Activation l -> Activation l
forall l. Data l => Typeable (Activation l)
forall l. Data l => Activation l -> Constr
forall l. Data l => Activation l -> DataType
forall l.
Data l =>
(forall b. Data b => b -> b) -> Activation l -> Activation l
forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> Activation l -> u
forall l u.
Data l =>
(forall d. Data d => d -> u) -> Activation l -> [u]
forall l r r'.
Data l =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Activation l -> r
forall l r r'.
Data l =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Activation l -> r
forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d) -> Activation l -> m (Activation l)
forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Activation l -> m (Activation l)
forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Activation l)
forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Activation l -> c (Activation l)
forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Activation l))
forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Activation l))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Activation l -> u
forall u. (forall d. Data d => d -> u) -> Activation l -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Activation l -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Activation l -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Activation l -> m (Activation l)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Activation l -> m (Activation l)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Activation l)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Activation l -> c (Activation l)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Activation l))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Activation l))
$cgfoldl :: forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Activation l -> c (Activation l)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Activation l -> c (Activation l)
$cgunfold :: forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Activation l)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Activation l)
$ctoConstr :: forall l. Data l => Activation l -> Constr
toConstr :: Activation l -> Constr
$cdataTypeOf :: forall l. Data l => Activation l -> DataType
dataTypeOf :: Activation l -> DataType
$cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Activation l))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Activation l))
$cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Activation l))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Activation l))
$cgmapT :: forall l.
Data l =>
(forall b. Data b => b -> b) -> Activation l -> Activation l
gmapT :: (forall b. Data b => b -> b) -> Activation l -> Activation l
$cgmapQl :: forall l r r'.
Data l =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Activation l -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Activation l -> r
$cgmapQr :: forall l r r'.
Data l =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Activation l -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Activation l -> r
$cgmapQ :: forall l u.
Data l =>
(forall d. Data d => d -> u) -> Activation l -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Activation l -> [u]
$cgmapQi :: forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> Activation l -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Activation l -> u
$cgmapM :: forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d) -> Activation l -> m (Activation l)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Activation l -> m (Activation l)
$cgmapMp :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Activation l -> m (Activation l)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Activation l -> m (Activation l)
$cgmapMo :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Activation l -> m (Activation l)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Activation l -> m (Activation l)
Data,(forall m. Monoid m => Activation m -> m)
-> (forall m a. Monoid m => (a -> m) -> Activation a -> m)
-> (forall m a. Monoid m => (a -> m) -> Activation a -> m)
-> (forall a b. (a -> b -> b) -> b -> Activation a -> b)
-> (forall a b. (a -> b -> b) -> b -> Activation a -> b)
-> (forall b a. (b -> a -> b) -> b -> Activation a -> b)
-> (forall b a. (b -> a -> b) -> b -> Activation a -> b)
-> (forall a. (a -> a -> a) -> Activation a -> a)
-> (forall a. (a -> a -> a) -> Activation a -> a)
-> (forall a. Activation a -> [a])
-> (forall a. Activation a -> Bool)
-> (forall a. Activation a -> Int)
-> (forall a. Eq a => a -> Activation a -> Bool)
-> (forall a. Ord a => Activation a -> a)
-> (forall a. Ord a => Activation a -> a)
-> (forall a. Num a => Activation a -> a)
-> (forall a. Num a => Activation a -> a)
-> Foldable Activation
forall a. Eq a => a -> Activation a -> Bool
forall a. Num a => Activation a -> a
forall a. Ord a => Activation a -> a
forall m. Monoid m => Activation m -> m
forall a. Activation a -> Bool
forall a. Activation a -> Int
forall a. Activation a -> [a]
forall a. (a -> a -> a) -> Activation a -> a
forall m a. Monoid m => (a -> m) -> Activation a -> m
forall b a. (b -> a -> b) -> b -> Activation a -> b
forall a b. (a -> b -> b) -> b -> Activation a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall m. Monoid m => Activation m -> m
fold :: forall m. Monoid m => Activation m -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> Activation a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> Activation a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> Activation a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> Activation a -> m
$cfoldr :: forall a b. (a -> b -> b) -> b -> Activation a -> b
foldr :: forall a b. (a -> b -> b) -> b -> Activation a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> Activation a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> Activation a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> Activation a -> b
foldl :: forall b a. (b -> a -> b) -> b -> Activation a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> Activation a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> Activation a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> Activation a -> a
foldr1 :: forall a. (a -> a -> a) -> Activation a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> Activation a -> a
foldl1 :: forall a. (a -> a -> a) -> Activation a -> a
$ctoList :: forall a. Activation a -> [a]
toList :: forall a. Activation a -> [a]
$cnull :: forall a. Activation a -> Bool
null :: forall a. Activation a -> Bool
$clength :: forall a. Activation a -> Int
length :: forall a. Activation a -> Int
$celem :: forall a. Eq a => a -> Activation a -> Bool
elem :: forall a. Eq a => a -> Activation a -> Bool
$cmaximum :: forall a. Ord a => Activation a -> a
maximum :: forall a. Ord a => Activation a -> a
$cminimum :: forall a. Ord a => Activation a -> a
minimum :: forall a. Ord a => Activation a -> a
$csum :: forall a. Num a => Activation a -> a
sum :: forall a. Num a => Activation a -> a
$cproduct :: forall a. Num a => Activation a -> a
product :: forall a. Num a => Activation a -> a
Foldable,Functor Activation
Foldable Activation
(Functor Activation, Foldable Activation) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> Activation a -> f (Activation b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    Activation (f a) -> f (Activation a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Activation a -> m (Activation b))
-> (forall (m :: * -> *) a.
    Monad m =>
    Activation (m a) -> m (Activation a))
-> Traversable Activation
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a.
Monad m =>
Activation (m a) -> m (Activation a)
forall (f :: * -> *) a.
Applicative f =>
Activation (f a) -> f (Activation a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Activation a -> m (Activation b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Activation a -> f (Activation b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Activation a -> f (Activation b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Activation a -> f (Activation b)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
Activation (f a) -> f (Activation a)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
Activation (f a) -> f (Activation a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Activation a -> m (Activation b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Activation a -> m (Activation b)
$csequence :: forall (m :: * -> *) a.
Monad m =>
Activation (m a) -> m (Activation a)
sequence :: forall (m :: * -> *) a.
Monad m =>
Activation (m a) -> m (Activation a)
Traversable,(forall a b. (a -> b) -> Activation a -> Activation b)
-> (forall a b. a -> Activation b -> Activation a)
-> Functor Activation
forall a b. a -> Activation b -> Activation a
forall a b. (a -> b) -> Activation a -> Activation b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> Activation a -> Activation b
fmap :: forall a b. (a -> b) -> Activation a -> Activation b
$c<$ :: forall a b. a -> Activation b -> Activation a
<$ :: forall a b. a -> Activation b -> Activation a
Functor,(forall x. Activation l -> Rep (Activation l) x)
-> (forall x. Rep (Activation l) x -> Activation l)
-> Generic (Activation l)
forall x. Rep (Activation l) x -> Activation l
forall x. Activation l -> Rep (Activation l) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall l x. Rep (Activation l) x -> Activation l
forall l x. Activation l -> Rep (Activation l) x
$cfrom :: forall l x. Activation l -> Rep (Activation l) x
from :: forall x. Activation l -> Rep (Activation l) x
$cto :: forall l x. Rep (Activation l) x -> Activation l
to :: forall x. Rep (Activation l) x -> Activation l
Generic)

-- | The body of a RULES pragma.
data Rule l
    = Rule l String (Maybe (Activation l)) (Maybe [RuleVar l]) (Exp l) (Exp l)
  deriving (Rule l -> Rule l -> Bool
(Rule l -> Rule l -> Bool)
-> (Rule l -> Rule l -> Bool) -> Eq (Rule l)
forall l. Eq l => Rule l -> Rule l -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall l. Eq l => Rule l -> Rule l -> Bool
== :: Rule l -> Rule l -> Bool
$c/= :: forall l. Eq l => Rule l -> Rule l -> Bool
/= :: Rule l -> Rule l -> Bool
Eq,Eq (Rule l)
Eq (Rule l) =>
(Rule l -> Rule l -> Ordering)
-> (Rule l -> Rule l -> Bool)
-> (Rule l -> Rule l -> Bool)
-> (Rule l -> Rule l -> Bool)
-> (Rule l -> Rule l -> Bool)
-> (Rule l -> Rule l -> Rule l)
-> (Rule l -> Rule l -> Rule l)
-> Ord (Rule l)
Rule l -> Rule l -> Bool
Rule l -> Rule l -> Ordering
Rule l -> Rule l -> Rule l
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall l. Ord l => Eq (Rule l)
forall l. Ord l => Rule l -> Rule l -> Bool
forall l. Ord l => Rule l -> Rule l -> Ordering
forall l. Ord l => Rule l -> Rule l -> Rule l
$ccompare :: forall l. Ord l => Rule l -> Rule l -> Ordering
compare :: Rule l -> Rule l -> Ordering
$c< :: forall l. Ord l => Rule l -> Rule l -> Bool
< :: Rule l -> Rule l -> Bool
$c<= :: forall l. Ord l => Rule l -> Rule l -> Bool
<= :: Rule l -> Rule l -> Bool
$c> :: forall l. Ord l => Rule l -> Rule l -> Bool
> :: Rule l -> Rule l -> Bool
$c>= :: forall l. Ord l => Rule l -> Rule l -> Bool
>= :: Rule l -> Rule l -> Bool
$cmax :: forall l. Ord l => Rule l -> Rule l -> Rule l
max :: Rule l -> Rule l -> Rule l
$cmin :: forall l. Ord l => Rule l -> Rule l -> Rule l
min :: Rule l -> Rule l -> Rule l
Ord,Int -> Rule l -> ShowS
[Rule l] -> ShowS
Rule l -> String
(Int -> Rule l -> ShowS)
-> (Rule l -> String) -> ([Rule l] -> ShowS) -> Show (Rule l)
forall l. Show l => Int -> Rule l -> ShowS
forall l. Show l => [Rule l] -> ShowS
forall l. Show l => Rule l -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall l. Show l => Int -> Rule l -> ShowS
showsPrec :: Int -> Rule l -> ShowS
$cshow :: forall l. Show l => Rule l -> String
show :: Rule l -> String
$cshowList :: forall l. Show l => [Rule l] -> ShowS
showList :: [Rule l] -> ShowS
Show,Typeable,Typeable (Rule l)
Typeable (Rule l) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Rule l -> c (Rule l))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Rule l))
-> (Rule l -> Constr)
-> (Rule l -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Rule l)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Rule l)))
-> ((forall b. Data b => b -> b) -> Rule l -> Rule l)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Rule l -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Rule l -> r)
-> (forall u. (forall d. Data d => d -> u) -> Rule l -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Rule l -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Rule l -> m (Rule l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Rule l -> m (Rule l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Rule l -> m (Rule l))
-> Data (Rule l)
Rule l -> Constr
Rule l -> DataType
(forall b. Data b => b -> b) -> Rule l -> Rule l
forall l. Data l => Typeable (Rule l)
forall l. Data l => Rule l -> Constr
forall l. Data l => Rule l -> DataType
forall l.
Data l =>
(forall b. Data b => b -> b) -> Rule l -> Rule l
forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> Rule l -> u
forall l u. Data l => (forall d. Data d => d -> u) -> Rule l -> [u]
forall l r r'.
Data l =>
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Rule l -> r
forall l r r'.
Data l =>
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Rule l -> r
forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d) -> Rule l -> m (Rule l)
forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Rule l -> m (Rule l)
forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Rule l)
forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Rule l -> c (Rule l)
forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Rule l))
forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Rule l))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Rule l -> u
forall u. (forall d. Data d => d -> u) -> Rule l -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Rule l -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Rule l -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Rule l -> m (Rule l)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Rule l -> m (Rule l)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Rule l)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Rule l -> c (Rule l)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Rule l))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Rule l))
$cgfoldl :: forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Rule l -> c (Rule l)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Rule l -> c (Rule l)
$cgunfold :: forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Rule l)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Rule l)
$ctoConstr :: forall l. Data l => Rule l -> Constr
toConstr :: Rule l -> Constr
$cdataTypeOf :: forall l. Data l => Rule l -> DataType
dataTypeOf :: Rule l -> DataType
$cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Rule l))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Rule l))
$cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Rule l))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Rule l))
$cgmapT :: forall l.
Data l =>
(forall b. Data b => b -> b) -> Rule l -> Rule l
gmapT :: (forall b. Data b => b -> b) -> Rule l -> Rule l
$cgmapQl :: forall l r r'.
Data l =>
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Rule l -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Rule l -> r
$cgmapQr :: forall l r r'.
Data l =>
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Rule l -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Rule l -> r
$cgmapQ :: forall l u. Data l => (forall d. Data d => d -> u) -> Rule l -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Rule l -> [u]
$cgmapQi :: forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> Rule l -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Rule l -> u
$cgmapM :: forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d) -> Rule l -> m (Rule l)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Rule l -> m (Rule l)
$cgmapMp :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Rule l -> m (Rule l)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Rule l -> m (Rule l)
$cgmapMo :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Rule l -> m (Rule l)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Rule l -> m (Rule l)
Data,(forall m. Monoid m => Rule m -> m)
-> (forall m a. Monoid m => (a -> m) -> Rule a -> m)
-> (forall m a. Monoid m => (a -> m) -> Rule a -> m)
-> (forall a b. (a -> b -> b) -> b -> Rule a -> b)
-> (forall a b. (a -> b -> b) -> b -> Rule a -> b)
-> (forall b a. (b -> a -> b) -> b -> Rule a -> b)
-> (forall b a. (b -> a -> b) -> b -> Rule a -> b)
-> (forall a. (a -> a -> a) -> Rule a -> a)
-> (forall a. (a -> a -> a) -> Rule a -> a)
-> (forall a. Rule a -> [a])
-> (forall a. Rule a -> Bool)
-> (forall a. Rule a -> Int)
-> (forall a. Eq a => a -> Rule a -> Bool)
-> (forall a. Ord a => Rule a -> a)
-> (forall a. Ord a => Rule a -> a)
-> (forall a. Num a => Rule a -> a)
-> (forall a. Num a => Rule a -> a)
-> Foldable Rule
forall a. Eq a => a -> Rule a -> Bool
forall a. Num a => Rule a -> a
forall a. Ord a => Rule a -> a
forall m. Monoid m => Rule m -> m
forall a. Rule a -> Bool
forall a. Rule a -> Int
forall a. Rule a -> [a]
forall a. (a -> a -> a) -> Rule a -> a
forall m a. Monoid m => (a -> m) -> Rule a -> m
forall b a. (b -> a -> b) -> b -> Rule a -> b
forall a b. (a -> b -> b) -> b -> Rule a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall m. Monoid m => Rule m -> m
fold :: forall m. Monoid m => Rule m -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> Rule a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> Rule a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> Rule a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> Rule a -> m
$cfoldr :: forall a b. (a -> b -> b) -> b -> Rule a -> b
foldr :: forall a b. (a -> b -> b) -> b -> Rule a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> Rule a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> Rule a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> Rule a -> b
foldl :: forall b a. (b -> a -> b) -> b -> Rule a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> Rule a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> Rule a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> Rule a -> a
foldr1 :: forall a. (a -> a -> a) -> Rule a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> Rule a -> a
foldl1 :: forall a. (a -> a -> a) -> Rule a -> a
$ctoList :: forall a. Rule a -> [a]
toList :: forall a. Rule a -> [a]
$cnull :: forall a. Rule a -> Bool
null :: forall a. Rule a -> Bool
$clength :: forall a. Rule a -> Int
length :: forall a. Rule a -> Int
$celem :: forall a. Eq a => a -> Rule a -> Bool
elem :: forall a. Eq a => a -> Rule a -> Bool
$cmaximum :: forall a. Ord a => Rule a -> a
maximum :: forall a. Ord a => Rule a -> a
$cminimum :: forall a. Ord a => Rule a -> a
minimum :: forall a. Ord a => Rule a -> a
$csum :: forall a. Num a => Rule a -> a
sum :: forall a. Num a => Rule a -> a
$cproduct :: forall a. Num a => Rule a -> a
product :: forall a. Num a => Rule a -> a
Foldable,Functor Rule
Foldable Rule
(Functor Rule, Foldable Rule) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> Rule a -> f (Rule b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    Rule (f a) -> f (Rule a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Rule a -> m (Rule b))
-> (forall (m :: * -> *) a. Monad m => Rule (m a) -> m (Rule a))
-> Traversable Rule
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a. Monad m => Rule (m a) -> m (Rule a)
forall (f :: * -> *) a. Applicative f => Rule (f a) -> f (Rule a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Rule a -> m (Rule b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Rule a -> f (Rule b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Rule a -> f (Rule b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Rule a -> f (Rule b)
$csequenceA :: forall (f :: * -> *) a. Applicative f => Rule (f a) -> f (Rule a)
sequenceA :: forall (f :: * -> *) a. Applicative f => Rule (f a) -> f (Rule a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Rule a -> m (Rule b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Rule a -> m (Rule b)
$csequence :: forall (m :: * -> *) a. Monad m => Rule (m a) -> m (Rule a)
sequence :: forall (m :: * -> *) a. Monad m => Rule (m a) -> m (Rule a)
Traversable,(forall a b. (a -> b) -> Rule a -> Rule b)
-> (forall a b. a -> Rule b -> Rule a) -> Functor Rule
forall a b. a -> Rule b -> Rule a
forall a b. (a -> b) -> Rule a -> Rule b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> Rule a -> Rule b
fmap :: forall a b. (a -> b) -> Rule a -> Rule b
$c<$ :: forall a b. a -> Rule b -> Rule a
<$ :: forall a b. a -> Rule b -> Rule a
Functor,(forall x. Rule l -> Rep (Rule l) x)
-> (forall x. Rep (Rule l) x -> Rule l) -> Generic (Rule l)
forall x. Rep (Rule l) x -> Rule l
forall x. Rule l -> Rep (Rule l) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall l x. Rep (Rule l) x -> Rule l
forall l x. Rule l -> Rep (Rule l) x
$cfrom :: forall l x. Rule l -> Rep (Rule l) x
from :: forall x. Rule l -> Rep (Rule l) x
$cto :: forall l x. Rep (Rule l) x -> Rule l
to :: forall x. Rep (Rule l) x -> Rule l
Generic)

-- | Variables used in a RULES pragma, optionally annotated with types
data RuleVar l
    = RuleVar l (Name l)
    | TypedRuleVar l (Name l) (Type l)
  deriving (RuleVar l -> RuleVar l -> Bool
(RuleVar l -> RuleVar l -> Bool)
-> (RuleVar l -> RuleVar l -> Bool) -> Eq (RuleVar l)
forall l. Eq l => RuleVar l -> RuleVar l -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall l. Eq l => RuleVar l -> RuleVar l -> Bool
== :: RuleVar l -> RuleVar l -> Bool
$c/= :: forall l. Eq l => RuleVar l -> RuleVar l -> Bool
/= :: RuleVar l -> RuleVar l -> Bool
Eq,Eq (RuleVar l)
Eq (RuleVar l) =>
(RuleVar l -> RuleVar l -> Ordering)
-> (RuleVar l -> RuleVar l -> Bool)
-> (RuleVar l -> RuleVar l -> Bool)
-> (RuleVar l -> RuleVar l -> Bool)
-> (RuleVar l -> RuleVar l -> Bool)
-> (RuleVar l -> RuleVar l -> RuleVar l)
-> (RuleVar l -> RuleVar l -> RuleVar l)
-> Ord (RuleVar l)
RuleVar l -> RuleVar l -> Bool
RuleVar l -> RuleVar l -> Ordering
RuleVar l -> RuleVar l -> RuleVar l
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall l. Ord l => Eq (RuleVar l)
forall l. Ord l => RuleVar l -> RuleVar l -> Bool
forall l. Ord l => RuleVar l -> RuleVar l -> Ordering
forall l. Ord l => RuleVar l -> RuleVar l -> RuleVar l
$ccompare :: forall l. Ord l => RuleVar l -> RuleVar l -> Ordering
compare :: RuleVar l -> RuleVar l -> Ordering
$c< :: forall l. Ord l => RuleVar l -> RuleVar l -> Bool
< :: RuleVar l -> RuleVar l -> Bool
$c<= :: forall l. Ord l => RuleVar l -> RuleVar l -> Bool
<= :: RuleVar l -> RuleVar l -> Bool
$c> :: forall l. Ord l => RuleVar l -> RuleVar l -> Bool
> :: RuleVar l -> RuleVar l -> Bool
$c>= :: forall l. Ord l => RuleVar l -> RuleVar l -> Bool
>= :: RuleVar l -> RuleVar l -> Bool
$cmax :: forall l. Ord l => RuleVar l -> RuleVar l -> RuleVar l
max :: RuleVar l -> RuleVar l -> RuleVar l
$cmin :: forall l. Ord l => RuleVar l -> RuleVar l -> RuleVar l
min :: RuleVar l -> RuleVar l -> RuleVar l
Ord,Int -> RuleVar l -> ShowS
[RuleVar l] -> ShowS
RuleVar l -> String
(Int -> RuleVar l -> ShowS)
-> (RuleVar l -> String)
-> ([RuleVar l] -> ShowS)
-> Show (RuleVar l)
forall l. Show l => Int -> RuleVar l -> ShowS
forall l. Show l => [RuleVar l] -> ShowS
forall l. Show l => RuleVar l -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall l. Show l => Int -> RuleVar l -> ShowS
showsPrec :: Int -> RuleVar l -> ShowS
$cshow :: forall l. Show l => RuleVar l -> String
show :: RuleVar l -> String
$cshowList :: forall l. Show l => [RuleVar l] -> ShowS
showList :: [RuleVar l] -> ShowS
Show,Typeable,Typeable (RuleVar l)
Typeable (RuleVar l) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> RuleVar l -> c (RuleVar l))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (RuleVar l))
-> (RuleVar l -> Constr)
-> (RuleVar l -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (RuleVar l)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (RuleVar l)))
-> ((forall b. Data b => b -> b) -> RuleVar l -> RuleVar l)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> RuleVar l -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> RuleVar l -> r)
-> (forall u. (forall d. Data d => d -> u) -> RuleVar l -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> RuleVar l -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> RuleVar l -> m (RuleVar l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> RuleVar l -> m (RuleVar l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> RuleVar l -> m (RuleVar l))
-> Data (RuleVar l)
RuleVar l -> Constr
RuleVar l -> DataType
(forall b. Data b => b -> b) -> RuleVar l -> RuleVar l
forall l. Data l => Typeable (RuleVar l)
forall l. Data l => RuleVar l -> Constr
forall l. Data l => RuleVar l -> DataType
forall l.
Data l =>
(forall b. Data b => b -> b) -> RuleVar l -> RuleVar l
forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> RuleVar l -> u
forall l u.
Data l =>
(forall d. Data d => d -> u) -> RuleVar l -> [u]
forall l r r'.
Data l =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> RuleVar l -> r
forall l r r'.
Data l =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> RuleVar l -> r
forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d) -> RuleVar l -> m (RuleVar l)
forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> RuleVar l -> m (RuleVar l)
forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (RuleVar l)
forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RuleVar l -> c (RuleVar l)
forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (RuleVar l))
forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (RuleVar l))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> RuleVar l -> u
forall u. (forall d. Data d => d -> u) -> RuleVar l -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> RuleVar l -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> RuleVar l -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> RuleVar l -> m (RuleVar l)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RuleVar l -> m (RuleVar l)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (RuleVar l)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RuleVar l -> c (RuleVar l)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (RuleVar l))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (RuleVar l))
$cgfoldl :: forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RuleVar l -> c (RuleVar l)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RuleVar l -> c (RuleVar l)
$cgunfold :: forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (RuleVar l)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (RuleVar l)
$ctoConstr :: forall l. Data l => RuleVar l -> Constr
toConstr :: RuleVar l -> Constr
$cdataTypeOf :: forall l. Data l => RuleVar l -> DataType
dataTypeOf :: RuleVar l -> DataType
$cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (RuleVar l))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (RuleVar l))
$cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (RuleVar l))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (RuleVar l))
$cgmapT :: forall l.
Data l =>
(forall b. Data b => b -> b) -> RuleVar l -> RuleVar l
gmapT :: (forall b. Data b => b -> b) -> RuleVar l -> RuleVar l
$cgmapQl :: forall l r r'.
Data l =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> RuleVar l -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> RuleVar l -> r
$cgmapQr :: forall l r r'.
Data l =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> RuleVar l -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> RuleVar l -> r
$cgmapQ :: forall l u.
Data l =>
(forall d. Data d => d -> u) -> RuleVar l -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> RuleVar l -> [u]
$cgmapQi :: forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> RuleVar l -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> RuleVar l -> u
$cgmapM :: forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d) -> RuleVar l -> m (RuleVar l)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> RuleVar l -> m (RuleVar l)
$cgmapMp :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> RuleVar l -> m (RuleVar l)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RuleVar l -> m (RuleVar l)
$cgmapMo :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> RuleVar l -> m (RuleVar l)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RuleVar l -> m (RuleVar l)
Data,(forall m. Monoid m => RuleVar m -> m)
-> (forall m a. Monoid m => (a -> m) -> RuleVar a -> m)
-> (forall m a. Monoid m => (a -> m) -> RuleVar a -> m)
-> (forall a b. (a -> b -> b) -> b -> RuleVar a -> b)
-> (forall a b. (a -> b -> b) -> b -> RuleVar a -> b)
-> (forall b a. (b -> a -> b) -> b -> RuleVar a -> b)
-> (forall b a. (b -> a -> b) -> b -> RuleVar a -> b)
-> (forall a. (a -> a -> a) -> RuleVar a -> a)
-> (forall a. (a -> a -> a) -> RuleVar a -> a)
-> (forall a. RuleVar a -> [a])
-> (forall a. RuleVar a -> Bool)
-> (forall a. RuleVar a -> Int)
-> (forall a. Eq a => a -> RuleVar a -> Bool)
-> (forall a. Ord a => RuleVar a -> a)
-> (forall a. Ord a => RuleVar a -> a)
-> (forall a. Num a => RuleVar a -> a)
-> (forall a. Num a => RuleVar a -> a)
-> Foldable RuleVar
forall a. Eq a => a -> RuleVar a -> Bool
forall a. Num a => RuleVar a -> a
forall a. Ord a => RuleVar a -> a
forall m. Monoid m => RuleVar m -> m
forall a. RuleVar a -> Bool
forall a. RuleVar a -> Int
forall a. RuleVar a -> [a]
forall a. (a -> a -> a) -> RuleVar a -> a
forall m a. Monoid m => (a -> m) -> RuleVar a -> m
forall b a. (b -> a -> b) -> b -> RuleVar a -> b
forall a b. (a -> b -> b) -> b -> RuleVar a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall m. Monoid m => RuleVar m -> m
fold :: forall m. Monoid m => RuleVar m -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> RuleVar a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> RuleVar a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> RuleVar a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> RuleVar a -> m
$cfoldr :: forall a b. (a -> b -> b) -> b -> RuleVar a -> b
foldr :: forall a b. (a -> b -> b) -> b -> RuleVar a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> RuleVar a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> RuleVar a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> RuleVar a -> b
foldl :: forall b a. (b -> a -> b) -> b -> RuleVar a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> RuleVar a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> RuleVar a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> RuleVar a -> a
foldr1 :: forall a. (a -> a -> a) -> RuleVar a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> RuleVar a -> a
foldl1 :: forall a. (a -> a -> a) -> RuleVar a -> a
$ctoList :: forall a. RuleVar a -> [a]
toList :: forall a. RuleVar a -> [a]
$cnull :: forall a. RuleVar a -> Bool
null :: forall a. RuleVar a -> Bool
$clength :: forall a. RuleVar a -> Int
length :: forall a. RuleVar a -> Int
$celem :: forall a. Eq a => a -> RuleVar a -> Bool
elem :: forall a. Eq a => a -> RuleVar a -> Bool
$cmaximum :: forall a. Ord a => RuleVar a -> a
maximum :: forall a. Ord a => RuleVar a -> a
$cminimum :: forall a. Ord a => RuleVar a -> a
minimum :: forall a. Ord a => RuleVar a -> a
$csum :: forall a. Num a => RuleVar a -> a
sum :: forall a. Num a => RuleVar a -> a
$cproduct :: forall a. Num a => RuleVar a -> a
product :: forall a. Num a => RuleVar a -> a
Foldable,Functor RuleVar
Foldable RuleVar
(Functor RuleVar, Foldable RuleVar) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> RuleVar a -> f (RuleVar b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    RuleVar (f a) -> f (RuleVar a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> RuleVar a -> m (RuleVar b))
-> (forall (m :: * -> *) a.
    Monad m =>
    RuleVar (m a) -> m (RuleVar a))
-> Traversable RuleVar
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a. Monad m => RuleVar (m a) -> m (RuleVar a)
forall (f :: * -> *) a.
Applicative f =>
RuleVar (f a) -> f (RuleVar a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> RuleVar a -> m (RuleVar b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> RuleVar a -> f (RuleVar b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> RuleVar a -> f (RuleVar b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> RuleVar a -> f (RuleVar b)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
RuleVar (f a) -> f (RuleVar a)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
RuleVar (f a) -> f (RuleVar a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> RuleVar a -> m (RuleVar b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> RuleVar a -> m (RuleVar b)
$csequence :: forall (m :: * -> *) a. Monad m => RuleVar (m a) -> m (RuleVar a)
sequence :: forall (m :: * -> *) a. Monad m => RuleVar (m a) -> m (RuleVar a)
Traversable,(forall a b. (a -> b) -> RuleVar a -> RuleVar b)
-> (forall a b. a -> RuleVar b -> RuleVar a) -> Functor RuleVar
forall a b. a -> RuleVar b -> RuleVar a
forall a b. (a -> b) -> RuleVar a -> RuleVar b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> RuleVar a -> RuleVar b
fmap :: forall a b. (a -> b) -> RuleVar a -> RuleVar b
$c<$ :: forall a b. a -> RuleVar b -> RuleVar a
<$ :: forall a b. a -> RuleVar b -> RuleVar a
Functor,(forall x. RuleVar l -> Rep (RuleVar l) x)
-> (forall x. Rep (RuleVar l) x -> RuleVar l)
-> Generic (RuleVar l)
forall x. Rep (RuleVar l) x -> RuleVar l
forall x. RuleVar l -> Rep (RuleVar l) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall l x. Rep (RuleVar l) x -> RuleVar l
forall l x. RuleVar l -> Rep (RuleVar l) x
$cfrom :: forall l x. RuleVar l -> Rep (RuleVar l) x
from :: forall x. RuleVar l -> Rep (RuleVar l) x
$cto :: forall l x. Rep (RuleVar l) x -> RuleVar l
to :: forall x. Rep (RuleVar l) x -> RuleVar l
Generic)

-- | Warning text to optionally use in the module header of e.g.
--   a deprecated module.
data WarningText l
    = DeprText l String
    | WarnText l String
  deriving (WarningText l -> WarningText l -> Bool
(WarningText l -> WarningText l -> Bool)
-> (WarningText l -> WarningText l -> Bool) -> Eq (WarningText l)
forall l. Eq l => WarningText l -> WarningText l -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall l. Eq l => WarningText l -> WarningText l -> Bool
== :: WarningText l -> WarningText l -> Bool
$c/= :: forall l. Eq l => WarningText l -> WarningText l -> Bool
/= :: WarningText l -> WarningText l -> Bool
Eq,Eq (WarningText l)
Eq (WarningText l) =>
(WarningText l -> WarningText l -> Ordering)
-> (WarningText l -> WarningText l -> Bool)
-> (WarningText l -> WarningText l -> Bool)
-> (WarningText l -> WarningText l -> Bool)
-> (WarningText l -> WarningText l -> Bool)
-> (WarningText l -> WarningText l -> WarningText l)
-> (WarningText l -> WarningText l -> WarningText l)
-> Ord (WarningText l)
WarningText l -> WarningText l -> Bool
WarningText l -> WarningText l -> Ordering
WarningText l -> WarningText l -> WarningText l
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall l. Ord l => Eq (WarningText l)
forall l. Ord l => WarningText l -> WarningText l -> Bool
forall l. Ord l => WarningText l -> WarningText l -> Ordering
forall l. Ord l => WarningText l -> WarningText l -> WarningText l
$ccompare :: forall l. Ord l => WarningText l -> WarningText l -> Ordering
compare :: WarningText l -> WarningText l -> Ordering
$c< :: forall l. Ord l => WarningText l -> WarningText l -> Bool
< :: WarningText l -> WarningText l -> Bool
$c<= :: forall l. Ord l => WarningText l -> WarningText l -> Bool
<= :: WarningText l -> WarningText l -> Bool
$c> :: forall l. Ord l => WarningText l -> WarningText l -> Bool
> :: WarningText l -> WarningText l -> Bool
$c>= :: forall l. Ord l => WarningText l -> WarningText l -> Bool
>= :: WarningText l -> WarningText l -> Bool
$cmax :: forall l. Ord l => WarningText l -> WarningText l -> WarningText l
max :: WarningText l -> WarningText l -> WarningText l
$cmin :: forall l. Ord l => WarningText l -> WarningText l -> WarningText l
min :: WarningText l -> WarningText l -> WarningText l
Ord,Int -> WarningText l -> ShowS
[WarningText l] -> ShowS
WarningText l -> String
(Int -> WarningText l -> ShowS)
-> (WarningText l -> String)
-> ([WarningText l] -> ShowS)
-> Show (WarningText l)
forall l. Show l => Int -> WarningText l -> ShowS
forall l. Show l => [WarningText l] -> ShowS
forall l. Show l => WarningText l -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall l. Show l => Int -> WarningText l -> ShowS
showsPrec :: Int -> WarningText l -> ShowS
$cshow :: forall l. Show l => WarningText l -> String
show :: WarningText l -> String
$cshowList :: forall l. Show l => [WarningText l] -> ShowS
showList :: [WarningText l] -> ShowS
Show,Typeable,Typeable (WarningText l)
Typeable (WarningText l) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> WarningText l -> c (WarningText l))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (WarningText l))
-> (WarningText l -> Constr)
-> (WarningText l -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (WarningText l)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (WarningText l)))
-> ((forall b. Data b => b -> b) -> WarningText l -> WarningText l)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> WarningText l -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> WarningText l -> r)
-> (forall u. (forall d. Data d => d -> u) -> WarningText l -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> WarningText l -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> WarningText l -> m (WarningText l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> WarningText l -> m (WarningText l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> WarningText l -> m (WarningText l))
-> Data (WarningText l)
WarningText l -> Constr
WarningText l -> DataType
(forall b. Data b => b -> b) -> WarningText l -> WarningText l
forall l. Data l => Typeable (WarningText l)
forall l. Data l => WarningText l -> Constr
forall l. Data l => WarningText l -> DataType
forall l.
Data l =>
(forall b. Data b => b -> b) -> WarningText l -> WarningText l
forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> WarningText l -> u
forall l u.
Data l =>
(forall d. Data d => d -> u) -> WarningText l -> [u]
forall l r r'.
Data l =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> WarningText l -> r
forall l r r'.
Data l =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> WarningText l -> r
forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d)
-> WarningText l -> m (WarningText l)
forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> WarningText l -> m (WarningText l)
forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (WarningText l)
forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> WarningText l -> c (WarningText l)
forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (WarningText l))
forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (WarningText l))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> WarningText l -> u
forall u. (forall d. Data d => d -> u) -> WarningText l -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> WarningText l -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> WarningText l -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> WarningText l -> m (WarningText l)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> WarningText l -> m (WarningText l)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (WarningText l)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> WarningText l -> c (WarningText l)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (WarningText l))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (WarningText l))
$cgfoldl :: forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> WarningText l -> c (WarningText l)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> WarningText l -> c (WarningText l)
$cgunfold :: forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (WarningText l)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (WarningText l)
$ctoConstr :: forall l. Data l => WarningText l -> Constr
toConstr :: WarningText l -> Constr
$cdataTypeOf :: forall l. Data l => WarningText l -> DataType
dataTypeOf :: WarningText l -> DataType
$cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (WarningText l))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (WarningText l))
$cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (WarningText l))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (WarningText l))
$cgmapT :: forall l.
Data l =>
(forall b. Data b => b -> b) -> WarningText l -> WarningText l
gmapT :: (forall b. Data b => b -> b) -> WarningText l -> WarningText l
$cgmapQl :: forall l r r'.
Data l =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> WarningText l -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> WarningText l -> r
$cgmapQr :: forall l r r'.
Data l =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> WarningText l -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> WarningText l -> r
$cgmapQ :: forall l u.
Data l =>
(forall d. Data d => d -> u) -> WarningText l -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> WarningText l -> [u]
$cgmapQi :: forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> WarningText l -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> WarningText l -> u
$cgmapM :: forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d)
-> WarningText l -> m (WarningText l)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> WarningText l -> m (WarningText l)
$cgmapMp :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> WarningText l -> m (WarningText l)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> WarningText l -> m (WarningText l)
$cgmapMo :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> WarningText l -> m (WarningText l)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> WarningText l -> m (WarningText l)
Data,(forall m. Monoid m => WarningText m -> m)
-> (forall m a. Monoid m => (a -> m) -> WarningText a -> m)
-> (forall m a. Monoid m => (a -> m) -> WarningText a -> m)
-> (forall a b. (a -> b -> b) -> b -> WarningText a -> b)
-> (forall a b. (a -> b -> b) -> b -> WarningText a -> b)
-> (forall b a. (b -> a -> b) -> b -> WarningText a -> b)
-> (forall b a. (b -> a -> b) -> b -> WarningText a -> b)
-> (forall a. (a -> a -> a) -> WarningText a -> a)
-> (forall a. (a -> a -> a) -> WarningText a -> a)
-> (forall a. WarningText a -> [a])
-> (forall a. WarningText a -> Bool)
-> (forall a. WarningText a -> Int)
-> (forall a. Eq a => a -> WarningText a -> Bool)
-> (forall a. Ord a => WarningText a -> a)
-> (forall a. Ord a => WarningText a -> a)
-> (forall a. Num a => WarningText a -> a)
-> (forall a. Num a => WarningText a -> a)
-> Foldable WarningText
forall a. Eq a => a -> WarningText a -> Bool
forall a. Num a => WarningText a -> a
forall a. Ord a => WarningText a -> a
forall m. Monoid m => WarningText m -> m
forall a. WarningText a -> Bool
forall a. WarningText a -> Int
forall a. WarningText a -> [a]
forall a. (a -> a -> a) -> WarningText a -> a
forall m a. Monoid m => (a -> m) -> WarningText a -> m
forall b a. (b -> a -> b) -> b -> WarningText a -> b
forall a b. (a -> b -> b) -> b -> WarningText a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall m. Monoid m => WarningText m -> m
fold :: forall m. Monoid m => WarningText m -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> WarningText a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> WarningText a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> WarningText a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> WarningText a -> m
$cfoldr :: forall a b. (a -> b -> b) -> b -> WarningText a -> b
foldr :: forall a b. (a -> b -> b) -> b -> WarningText a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> WarningText a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> WarningText a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> WarningText a -> b
foldl :: forall b a. (b -> a -> b) -> b -> WarningText a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> WarningText a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> WarningText a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> WarningText a -> a
foldr1 :: forall a. (a -> a -> a) -> WarningText a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> WarningText a -> a
foldl1 :: forall a. (a -> a -> a) -> WarningText a -> a
$ctoList :: forall a. WarningText a -> [a]
toList :: forall a. WarningText a -> [a]
$cnull :: forall a. WarningText a -> Bool
null :: forall a. WarningText a -> Bool
$clength :: forall a. WarningText a -> Int
length :: forall a. WarningText a -> Int
$celem :: forall a. Eq a => a -> WarningText a -> Bool
elem :: forall a. Eq a => a -> WarningText a -> Bool
$cmaximum :: forall a. Ord a => WarningText a -> a
maximum :: forall a. Ord a => WarningText a -> a
$cminimum :: forall a. Ord a => WarningText a -> a
minimum :: forall a. Ord a => WarningText a -> a
$csum :: forall a. Num a => WarningText a -> a
sum :: forall a. Num a => WarningText a -> a
$cproduct :: forall a. Num a => WarningText a -> a
product :: forall a. Num a => WarningText a -> a
Foldable,Functor WarningText
Foldable WarningText
(Functor WarningText, Foldable WarningText) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> WarningText a -> f (WarningText b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    WarningText (f a) -> f (WarningText a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> WarningText a -> m (WarningText b))
-> (forall (m :: * -> *) a.
    Monad m =>
    WarningText (m a) -> m (WarningText a))
-> Traversable WarningText
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a.
Monad m =>
WarningText (m a) -> m (WarningText a)
forall (f :: * -> *) a.
Applicative f =>
WarningText (f a) -> f (WarningText a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> WarningText a -> m (WarningText b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> WarningText a -> f (WarningText b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> WarningText a -> f (WarningText b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> WarningText a -> f (WarningText b)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
WarningText (f a) -> f (WarningText a)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
WarningText (f a) -> f (WarningText a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> WarningText a -> m (WarningText b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> WarningText a -> m (WarningText b)
$csequence :: forall (m :: * -> *) a.
Monad m =>
WarningText (m a) -> m (WarningText a)
sequence :: forall (m :: * -> *) a.
Monad m =>
WarningText (m a) -> m (WarningText a)
Traversable,(forall a b. (a -> b) -> WarningText a -> WarningText b)
-> (forall a b. a -> WarningText b -> WarningText a)
-> Functor WarningText
forall a b. a -> WarningText b -> WarningText a
forall a b. (a -> b) -> WarningText a -> WarningText b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> WarningText a -> WarningText b
fmap :: forall a b. (a -> b) -> WarningText a -> WarningText b
$c<$ :: forall a b. a -> WarningText b -> WarningText a
<$ :: forall a b. a -> WarningText b -> WarningText a
Functor,(forall x. WarningText l -> Rep (WarningText l) x)
-> (forall x. Rep (WarningText l) x -> WarningText l)
-> Generic (WarningText l)
forall x. Rep (WarningText l) x -> WarningText l
forall x. WarningText l -> Rep (WarningText l) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall l x. Rep (WarningText l) x -> WarningText l
forall l x. WarningText l -> Rep (WarningText l) x
$cfrom :: forall l x. WarningText l -> Rep (WarningText l) x
from :: forall x. WarningText l -> Rep (WarningText l) x
$cto :: forall l x. Rep (WarningText l) x -> WarningText l
to :: forall x. Rep (WarningText l) x -> WarningText l
Generic)


-- | A pattern, to be matched against a value.
data Pat l
    = PVar l (Name l)                       -- ^ variable
    | PLit l (Sign l) (Literal l)           -- ^ literal constant
    | PNPlusK l (Name l) Integer            -- ^ n+k pattern
    | PInfixApp l (Pat l) (QName l) (Pat l) -- ^ pattern with an infix data constructor
    | PApp l (QName l) [Pat l]              -- ^ data constructor and argument patterns
    | PTuple l Boxed [Pat l]                -- ^ tuple pattern
    | PUnboxedSum l Int Int (Pat l)         -- ^ unboxed sum
    | PList l [Pat l]                       -- ^ list pattern
    | PParen l (Pat l)                      -- ^ parenthesized pattern
    | PRec l (QName l) [PatField l]         -- ^ labelled pattern, record style
    | PAsPat l (Name l) (Pat l)             -- ^ @\@@-pattern
    | PWildCard l                           -- ^ wildcard pattern: @_@
    | PIrrPat l (Pat l)                     -- ^ irrefutable pattern: @~/pat/@
    | PatTypeSig l (Pat l) (Type l)         -- ^ pattern with type signature
    | PViewPat l (Exp l) (Pat l)            -- ^ view patterns of the form @(/exp/ -> /pat/)@
    | PRPat l [RPat l]                      -- ^ regular list pattern
    | PXTag l (XName l) [PXAttr l] (Maybe (Pat l)) [Pat l]
                                            -- ^ XML element pattern
    | PXETag l (XName l) [PXAttr l] (Maybe (Pat l))
                                            -- ^ XML singleton element pattern
    | PXPcdata l String                     -- ^ XML PCDATA pattern
    | PXPatTag l (Pat l)                    -- ^ XML embedded pattern
    | PXRPats  l [RPat l]                   -- ^ XML regular list pattern
    | PSplice l (Splice l)                  -- ^ template haskell splice pattern
    | PQuasiQuote l String String           -- ^ quasi quote pattern: @[$/name/| /string/ |]@
    | PBangPat l (Pat l)                    -- ^ strict (bang) pattern: @f !x = ...@
  deriving (Pat l -> Pat l -> Bool
(Pat l -> Pat l -> Bool) -> (Pat l -> Pat l -> Bool) -> Eq (Pat l)
forall l. Eq l => Pat l -> Pat l -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall l. Eq l => Pat l -> Pat l -> Bool
== :: Pat l -> Pat l -> Bool
$c/= :: forall l. Eq l => Pat l -> Pat l -> Bool
/= :: Pat l -> Pat l -> Bool
Eq,Eq (Pat l)
Eq (Pat l) =>
(Pat l -> Pat l -> Ordering)
-> (Pat l -> Pat l -> Bool)
-> (Pat l -> Pat l -> Bool)
-> (Pat l -> Pat l -> Bool)
-> (Pat l -> Pat l -> Bool)
-> (Pat l -> Pat l -> Pat l)
-> (Pat l -> Pat l -> Pat l)
-> Ord (Pat l)
Pat l -> Pat l -> Bool
Pat l -> Pat l -> Ordering
Pat l -> Pat l -> Pat l
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall l. Ord l => Eq (Pat l)
forall l. Ord l => Pat l -> Pat l -> Bool
forall l. Ord l => Pat l -> Pat l -> Ordering
forall l. Ord l => Pat l -> Pat l -> Pat l
$ccompare :: forall l. Ord l => Pat l -> Pat l -> Ordering
compare :: Pat l -> Pat l -> Ordering
$c< :: forall l. Ord l => Pat l -> Pat l -> Bool
< :: Pat l -> Pat l -> Bool
$c<= :: forall l. Ord l => Pat l -> Pat l -> Bool
<= :: Pat l -> Pat l -> Bool
$c> :: forall l. Ord l => Pat l -> Pat l -> Bool
> :: Pat l -> Pat l -> Bool
$c>= :: forall l. Ord l => Pat l -> Pat l -> Bool
>= :: Pat l -> Pat l -> Bool
$cmax :: forall l. Ord l => Pat l -> Pat l -> Pat l
max :: Pat l -> Pat l -> Pat l
$cmin :: forall l. Ord l => Pat l -> Pat l -> Pat l
min :: Pat l -> Pat l -> Pat l
Ord,Int -> Pat l -> ShowS
[Pat l] -> ShowS
Pat l -> String
(Int -> Pat l -> ShowS)
-> (Pat l -> String) -> ([Pat l] -> ShowS) -> Show (Pat l)
forall l. Show l => Int -> Pat l -> ShowS
forall l. Show l => [Pat l] -> ShowS
forall l. Show l => Pat l -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall l. Show l => Int -> Pat l -> ShowS
showsPrec :: Int -> Pat l -> ShowS
$cshow :: forall l. Show l => Pat l -> String
show :: Pat l -> String
$cshowList :: forall l. Show l => [Pat l] -> ShowS
showList :: [Pat l] -> ShowS
Show,Typeable,Typeable (Pat l)
Typeable (Pat l) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Pat l -> c (Pat l))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Pat l))
-> (Pat l -> Constr)
-> (Pat l -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Pat l)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Pat l)))
-> ((forall b. Data b => b -> b) -> Pat l -> Pat l)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Pat l -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Pat l -> r)
-> (forall u. (forall d. Data d => d -> u) -> Pat l -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Pat l -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Pat l -> m (Pat l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Pat l -> m (Pat l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Pat l -> m (Pat l))
-> Data (Pat l)
Pat l -> Constr
Pat l -> DataType
(forall b. Data b => b -> b) -> Pat l -> Pat l
forall l. Data l => Typeable (Pat l)
forall l. Data l => Pat l -> Constr
forall l. Data l => Pat l -> DataType
forall l. Data l => (forall b. Data b => b -> b) -> Pat l -> Pat l
forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> Pat l -> u
forall l u. Data l => (forall d. Data d => d -> u) -> Pat l -> [u]
forall l r r'.
Data l =>
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Pat l -> r
forall l r r'.
Data l =>
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Pat l -> r
forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d) -> Pat l -> m (Pat l)
forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Pat l -> m (Pat l)
forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Pat l)
forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Pat l -> c (Pat l)
forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Pat l))
forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Pat l))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Pat l -> u
forall u. (forall d. Data d => d -> u) -> Pat l -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Pat l -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Pat l -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Pat l -> m (Pat l)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Pat l -> m (Pat l)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Pat l)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Pat l -> c (Pat l)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Pat l))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Pat l))
$cgfoldl :: forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Pat l -> c (Pat l)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Pat l -> c (Pat l)
$cgunfold :: forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Pat l)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Pat l)
$ctoConstr :: forall l. Data l => Pat l -> Constr
toConstr :: Pat l -> Constr
$cdataTypeOf :: forall l. Data l => Pat l -> DataType
dataTypeOf :: Pat l -> DataType
$cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Pat l))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Pat l))
$cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Pat l))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Pat l))
$cgmapT :: forall l. Data l => (forall b. Data b => b -> b) -> Pat l -> Pat l
gmapT :: (forall b. Data b => b -> b) -> Pat l -> Pat l
$cgmapQl :: forall l r r'.
Data l =>
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Pat l -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Pat l -> r
$cgmapQr :: forall l r r'.
Data l =>
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Pat l -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Pat l -> r
$cgmapQ :: forall l u. Data l => (forall d. Data d => d -> u) -> Pat l -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Pat l -> [u]
$cgmapQi :: forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> Pat l -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Pat l -> u
$cgmapM :: forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d) -> Pat l -> m (Pat l)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Pat l -> m (Pat l)
$cgmapMp :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Pat l -> m (Pat l)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Pat l -> m (Pat l)
$cgmapMo :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Pat l -> m (Pat l)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Pat l -> m (Pat l)
Data,(forall m. Monoid m => Pat m -> m)
-> (forall m a. Monoid m => (a -> m) -> Pat a -> m)
-> (forall m a. Monoid m => (a -> m) -> Pat a -> m)
-> (forall a b. (a -> b -> b) -> b -> Pat a -> b)
-> (forall a b. (a -> b -> b) -> b -> Pat a -> b)
-> (forall b a. (b -> a -> b) -> b -> Pat a -> b)
-> (forall b a. (b -> a -> b) -> b -> Pat a -> b)
-> (forall a. (a -> a -> a) -> Pat a -> a)
-> (forall a. (a -> a -> a) -> Pat a -> a)
-> (forall a. Pat a -> [a])
-> (forall a. Pat a -> Bool)
-> (forall a. Pat a -> Int)
-> (forall a. Eq a => a -> Pat a -> Bool)
-> (forall a. Ord a => Pat a -> a)
-> (forall a. Ord a => Pat a -> a)
-> (forall a. Num a => Pat a -> a)
-> (forall a. Num a => Pat a -> a)
-> Foldable Pat
forall a. Eq a => a -> Pat a -> Bool
forall a. Num a => Pat a -> a
forall a. Ord a => Pat a -> a
forall m. Monoid m => Pat m -> m
forall a. Pat a -> Bool
forall a. Pat a -> Int
forall a. Pat a -> [a]
forall a. (a -> a -> a) -> Pat a -> a
forall m a. Monoid m => (a -> m) -> Pat a -> m
forall b a. (b -> a -> b) -> b -> Pat a -> b
forall a b. (a -> b -> b) -> b -> Pat a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall m. Monoid m => Pat m -> m
fold :: forall m. Monoid m => Pat m -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> Pat a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> Pat a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> Pat a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> Pat a -> m
$cfoldr :: forall a b. (a -> b -> b) -> b -> Pat a -> b
foldr :: forall a b. (a -> b -> b) -> b -> Pat a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> Pat a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> Pat a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> Pat a -> b
foldl :: forall b a. (b -> a -> b) -> b -> Pat a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> Pat a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> Pat a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> Pat a -> a
foldr1 :: forall a. (a -> a -> a) -> Pat a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> Pat a -> a
foldl1 :: forall a. (a -> a -> a) -> Pat a -> a
$ctoList :: forall a. Pat a -> [a]
toList :: forall a. Pat a -> [a]
$cnull :: forall a. Pat a -> Bool
null :: forall a. Pat a -> Bool
$clength :: forall a. Pat a -> Int
length :: forall a. Pat a -> Int
$celem :: forall a. Eq a => a -> Pat a -> Bool
elem :: forall a. Eq a => a -> Pat a -> Bool
$cmaximum :: forall a. Ord a => Pat a -> a
maximum :: forall a. Ord a => Pat a -> a
$cminimum :: forall a. Ord a => Pat a -> a
minimum :: forall a. Ord a => Pat a -> a
$csum :: forall a. Num a => Pat a -> a
sum :: forall a. Num a => Pat a -> a
$cproduct :: forall a. Num a => Pat a -> a
product :: forall a. Num a => Pat a -> a
Foldable,Functor Pat
Foldable Pat
(Functor Pat, Foldable Pat) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> Pat a -> f (Pat b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    Pat (f a) -> f (Pat a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Pat a -> m (Pat b))
-> (forall (m :: * -> *) a. Monad m => Pat (m a) -> m (Pat a))
-> Traversable Pat
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a. Monad m => Pat (m a) -> m (Pat a)
forall (f :: * -> *) a. Applicative f => Pat (f a) -> f (Pat a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Pat a -> m (Pat b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Pat a -> f (Pat b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Pat a -> f (Pat b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Pat a -> f (Pat b)
$csequenceA :: forall (f :: * -> *) a. Applicative f => Pat (f a) -> f (Pat a)
sequenceA :: forall (f :: * -> *) a. Applicative f => Pat (f a) -> f (Pat a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Pat a -> m (Pat b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Pat a -> m (Pat b)
$csequence :: forall (m :: * -> *) a. Monad m => Pat (m a) -> m (Pat a)
sequence :: forall (m :: * -> *) a. Monad m => Pat (m a) -> m (Pat a)
Traversable,(forall a b. (a -> b) -> Pat a -> Pat b)
-> (forall a b. a -> Pat b -> Pat a) -> Functor Pat
forall a b. a -> Pat b -> Pat a
forall a b. (a -> b) -> Pat a -> Pat b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> Pat a -> Pat b
fmap :: forall a b. (a -> b) -> Pat a -> Pat b
$c<$ :: forall a b. a -> Pat b -> Pat a
<$ :: forall a b. a -> Pat b -> Pat a
Functor,(forall x. Pat l -> Rep (Pat l) x)
-> (forall x. Rep (Pat l) x -> Pat l) -> Generic (Pat l)
forall x. Rep (Pat l) x -> Pat l
forall x. Pat l -> Rep (Pat l) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall l x. Rep (Pat l) x -> Pat l
forall l x. Pat l -> Rep (Pat l) x
$cfrom :: forall l x. Pat l -> Rep (Pat l) x
from :: forall x. Pat l -> Rep (Pat l) x
$cto :: forall l x. Rep (Pat l) x -> Pat l
to :: forall x. Rep (Pat l) x -> Pat l
Generic)

-- | An XML attribute in a pattern.
data PXAttr l = PXAttr l (XName l) (Pat l)
  deriving (PXAttr l -> PXAttr l -> Bool
(PXAttr l -> PXAttr l -> Bool)
-> (PXAttr l -> PXAttr l -> Bool) -> Eq (PXAttr l)
forall l. Eq l => PXAttr l -> PXAttr l -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall l. Eq l => PXAttr l -> PXAttr l -> Bool
== :: PXAttr l -> PXAttr l -> Bool
$c/= :: forall l. Eq l => PXAttr l -> PXAttr l -> Bool
/= :: PXAttr l -> PXAttr l -> Bool
Eq,Eq (PXAttr l)
Eq (PXAttr l) =>
(PXAttr l -> PXAttr l -> Ordering)
-> (PXAttr l -> PXAttr l -> Bool)
-> (PXAttr l -> PXAttr l -> Bool)
-> (PXAttr l -> PXAttr l -> Bool)
-> (PXAttr l -> PXAttr l -> Bool)
-> (PXAttr l -> PXAttr l -> PXAttr l)
-> (PXAttr l -> PXAttr l -> PXAttr l)
-> Ord (PXAttr l)
PXAttr l -> PXAttr l -> Bool
PXAttr l -> PXAttr l -> Ordering
PXAttr l -> PXAttr l -> PXAttr l
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall l. Ord l => Eq (PXAttr l)
forall l. Ord l => PXAttr l -> PXAttr l -> Bool
forall l. Ord l => PXAttr l -> PXAttr l -> Ordering
forall l. Ord l => PXAttr l -> PXAttr l -> PXAttr l
$ccompare :: forall l. Ord l => PXAttr l -> PXAttr l -> Ordering
compare :: PXAttr l -> PXAttr l -> Ordering
$c< :: forall l. Ord l => PXAttr l -> PXAttr l -> Bool
< :: PXAttr l -> PXAttr l -> Bool
$c<= :: forall l. Ord l => PXAttr l -> PXAttr l -> Bool
<= :: PXAttr l -> PXAttr l -> Bool
$c> :: forall l. Ord l => PXAttr l -> PXAttr l -> Bool
> :: PXAttr l -> PXAttr l -> Bool
$c>= :: forall l. Ord l => PXAttr l -> PXAttr l -> Bool
>= :: PXAttr l -> PXAttr l -> Bool
$cmax :: forall l. Ord l => PXAttr l -> PXAttr l -> PXAttr l
max :: PXAttr l -> PXAttr l -> PXAttr l
$cmin :: forall l. Ord l => PXAttr l -> PXAttr l -> PXAttr l
min :: PXAttr l -> PXAttr l -> PXAttr l
Ord,Int -> PXAttr l -> ShowS
[PXAttr l] -> ShowS
PXAttr l -> String
(Int -> PXAttr l -> ShowS)
-> (PXAttr l -> String) -> ([PXAttr l] -> ShowS) -> Show (PXAttr l)
forall l. Show l => Int -> PXAttr l -> ShowS
forall l. Show l => [PXAttr l] -> ShowS
forall l. Show l => PXAttr l -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall l. Show l => Int -> PXAttr l -> ShowS
showsPrec :: Int -> PXAttr l -> ShowS
$cshow :: forall l. Show l => PXAttr l -> String
show :: PXAttr l -> String
$cshowList :: forall l. Show l => [PXAttr l] -> ShowS
showList :: [PXAttr l] -> ShowS
Show,Typeable,Typeable (PXAttr l)
Typeable (PXAttr l) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> PXAttr l -> c (PXAttr l))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (PXAttr l))
-> (PXAttr l -> Constr)
-> (PXAttr l -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (PXAttr l)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (PXAttr l)))
-> ((forall b. Data b => b -> b) -> PXAttr l -> PXAttr l)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> PXAttr l -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> PXAttr l -> r)
-> (forall u. (forall d. Data d => d -> u) -> PXAttr l -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> PXAttr l -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> PXAttr l -> m (PXAttr l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> PXAttr l -> m (PXAttr l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> PXAttr l -> m (PXAttr l))
-> Data (PXAttr l)
PXAttr l -> Constr
PXAttr l -> DataType
(forall b. Data b => b -> b) -> PXAttr l -> PXAttr l
forall l. Data l => Typeable (PXAttr l)
forall l. Data l => PXAttr l -> Constr
forall l. Data l => PXAttr l -> DataType
forall l.
Data l =>
(forall b. Data b => b -> b) -> PXAttr l -> PXAttr l
forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> PXAttr l -> u
forall l u.
Data l =>
(forall d. Data d => d -> u) -> PXAttr l -> [u]
forall l r r'.
Data l =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PXAttr l -> r
forall l r r'.
Data l =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PXAttr l -> r
forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d) -> PXAttr l -> m (PXAttr l)
forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> PXAttr l -> m (PXAttr l)
forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (PXAttr l)
forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PXAttr l -> c (PXAttr l)
forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (PXAttr l))
forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (PXAttr l))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> PXAttr l -> u
forall u. (forall d. Data d => d -> u) -> PXAttr l -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PXAttr l -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PXAttr l -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> PXAttr l -> m (PXAttr l)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> PXAttr l -> m (PXAttr l)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (PXAttr l)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PXAttr l -> c (PXAttr l)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (PXAttr l))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (PXAttr l))
$cgfoldl :: forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PXAttr l -> c (PXAttr l)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PXAttr l -> c (PXAttr l)
$cgunfold :: forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (PXAttr l)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (PXAttr l)
$ctoConstr :: forall l. Data l => PXAttr l -> Constr
toConstr :: PXAttr l -> Constr
$cdataTypeOf :: forall l. Data l => PXAttr l -> DataType
dataTypeOf :: PXAttr l -> DataType
$cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (PXAttr l))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (PXAttr l))
$cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (PXAttr l))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (PXAttr l))
$cgmapT :: forall l.
Data l =>
(forall b. Data b => b -> b) -> PXAttr l -> PXAttr l
gmapT :: (forall b. Data b => b -> b) -> PXAttr l -> PXAttr l
$cgmapQl :: forall l r r'.
Data l =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PXAttr l -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PXAttr l -> r
$cgmapQr :: forall l r r'.
Data l =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PXAttr l -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PXAttr l -> r
$cgmapQ :: forall l u.
Data l =>
(forall d. Data d => d -> u) -> PXAttr l -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> PXAttr l -> [u]
$cgmapQi :: forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> PXAttr l -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> PXAttr l -> u
$cgmapM :: forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d) -> PXAttr l -> m (PXAttr l)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> PXAttr l -> m (PXAttr l)
$cgmapMp :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> PXAttr l -> m (PXAttr l)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> PXAttr l -> m (PXAttr l)
$cgmapMo :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> PXAttr l -> m (PXAttr l)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> PXAttr l -> m (PXAttr l)
Data,(forall m. Monoid m => PXAttr m -> m)
-> (forall m a. Monoid m => (a -> m) -> PXAttr a -> m)
-> (forall m a. Monoid m => (a -> m) -> PXAttr a -> m)
-> (forall a b. (a -> b -> b) -> b -> PXAttr a -> b)
-> (forall a b. (a -> b -> b) -> b -> PXAttr a -> b)
-> (forall b a. (b -> a -> b) -> b -> PXAttr a -> b)
-> (forall b a. (b -> a -> b) -> b -> PXAttr a -> b)
-> (forall a. (a -> a -> a) -> PXAttr a -> a)
-> (forall a. (a -> a -> a) -> PXAttr a -> a)
-> (forall a. PXAttr a -> [a])
-> (forall a. PXAttr a -> Bool)
-> (forall a. PXAttr a -> Int)
-> (forall a. Eq a => a -> PXAttr a -> Bool)
-> (forall a. Ord a => PXAttr a -> a)
-> (forall a. Ord a => PXAttr a -> a)
-> (forall a. Num a => PXAttr a -> a)
-> (forall a. Num a => PXAttr a -> a)
-> Foldable PXAttr
forall a. Eq a => a -> PXAttr a -> Bool
forall a. Num a => PXAttr a -> a
forall a. Ord a => PXAttr a -> a
forall m. Monoid m => PXAttr m -> m
forall a. PXAttr a -> Bool
forall a. PXAttr a -> Int
forall a. PXAttr a -> [a]
forall a. (a -> a -> a) -> PXAttr a -> a
forall m a. Monoid m => (a -> m) -> PXAttr a -> m
forall b a. (b -> a -> b) -> b -> PXAttr a -> b
forall a b. (a -> b -> b) -> b -> PXAttr a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall m. Monoid m => PXAttr m -> m
fold :: forall m. Monoid m => PXAttr m -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> PXAttr a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> PXAttr a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> PXAttr a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> PXAttr a -> m
$cfoldr :: forall a b. (a -> b -> b) -> b -> PXAttr a -> b
foldr :: forall a b. (a -> b -> b) -> b -> PXAttr a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> PXAttr a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> PXAttr a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> PXAttr a -> b
foldl :: forall b a. (b -> a -> b) -> b -> PXAttr a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> PXAttr a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> PXAttr a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> PXAttr a -> a
foldr1 :: forall a. (a -> a -> a) -> PXAttr a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> PXAttr a -> a
foldl1 :: forall a. (a -> a -> a) -> PXAttr a -> a
$ctoList :: forall a. PXAttr a -> [a]
toList :: forall a. PXAttr a -> [a]
$cnull :: forall a. PXAttr a -> Bool
null :: forall a. PXAttr a -> Bool
$clength :: forall a. PXAttr a -> Int
length :: forall a. PXAttr a -> Int
$celem :: forall a. Eq a => a -> PXAttr a -> Bool
elem :: forall a. Eq a => a -> PXAttr a -> Bool
$cmaximum :: forall a. Ord a => PXAttr a -> a
maximum :: forall a. Ord a => PXAttr a -> a
$cminimum :: forall a. Ord a => PXAttr a -> a
minimum :: forall a. Ord a => PXAttr a -> a
$csum :: forall a. Num a => PXAttr a -> a
sum :: forall a. Num a => PXAttr a -> a
$cproduct :: forall a. Num a => PXAttr a -> a
product :: forall a. Num a => PXAttr a -> a
Foldable,Functor PXAttr
Foldable PXAttr
(Functor PXAttr, Foldable PXAttr) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> PXAttr a -> f (PXAttr b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    PXAttr (f a) -> f (PXAttr a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> PXAttr a -> m (PXAttr b))
-> (forall (m :: * -> *) a.
    Monad m =>
    PXAttr (m a) -> m (PXAttr a))
-> Traversable PXAttr
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a. Monad m => PXAttr (m a) -> m (PXAttr a)
forall (f :: * -> *) a.
Applicative f =>
PXAttr (f a) -> f (PXAttr a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> PXAttr a -> m (PXAttr b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> PXAttr a -> f (PXAttr b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> PXAttr a -> f (PXAttr b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> PXAttr a -> f (PXAttr b)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
PXAttr (f a) -> f (PXAttr a)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
PXAttr (f a) -> f (PXAttr a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> PXAttr a -> m (PXAttr b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> PXAttr a -> m (PXAttr b)
$csequence :: forall (m :: * -> *) a. Monad m => PXAttr (m a) -> m (PXAttr a)
sequence :: forall (m :: * -> *) a. Monad m => PXAttr (m a) -> m (PXAttr a)
Traversable,(forall a b. (a -> b) -> PXAttr a -> PXAttr b)
-> (forall a b. a -> PXAttr b -> PXAttr a) -> Functor PXAttr
forall a b. a -> PXAttr b -> PXAttr a
forall a b. (a -> b) -> PXAttr a -> PXAttr b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> PXAttr a -> PXAttr b
fmap :: forall a b. (a -> b) -> PXAttr a -> PXAttr b
$c<$ :: forall a b. a -> PXAttr b -> PXAttr a
<$ :: forall a b. a -> PXAttr b -> PXAttr a
Functor,(forall x. PXAttr l -> Rep (PXAttr l) x)
-> (forall x. Rep (PXAttr l) x -> PXAttr l) -> Generic (PXAttr l)
forall x. Rep (PXAttr l) x -> PXAttr l
forall x. PXAttr l -> Rep (PXAttr l) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall l x. Rep (PXAttr l) x -> PXAttr l
forall l x. PXAttr l -> Rep (PXAttr l) x
$cfrom :: forall l x. PXAttr l -> Rep (PXAttr l) x
from :: forall x. PXAttr l -> Rep (PXAttr l) x
$cto :: forall l x. Rep (PXAttr l) x -> PXAttr l
to :: forall x. Rep (PXAttr l) x -> PXAttr l
Generic)

-- | A regular pattern operator.
data RPatOp l
    = RPStar  l  -- ^ @*@ = 0 or more
    | RPStarG l  -- ^ @*!@ = 0 or more, greedy
    | RPPlus  l  -- ^ @+@ = 1 or more
    | RPPlusG l  -- ^ @+!@ = 1 or more, greedy
    | RPOpt   l  -- ^ @?@ = 0 or 1
    | RPOptG  l  -- ^ @?!@ = 0 or 1, greedy
  deriving (RPatOp l -> RPatOp l -> Bool
(RPatOp l -> RPatOp l -> Bool)
-> (RPatOp l -> RPatOp l -> Bool) -> Eq (RPatOp l)
forall l. Eq l => RPatOp l -> RPatOp l -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall l. Eq l => RPatOp l -> RPatOp l -> Bool
== :: RPatOp l -> RPatOp l -> Bool
$c/= :: forall l. Eq l => RPatOp l -> RPatOp l -> Bool
/= :: RPatOp l -> RPatOp l -> Bool
Eq,Eq (RPatOp l)
Eq (RPatOp l) =>
(RPatOp l -> RPatOp l -> Ordering)
-> (RPatOp l -> RPatOp l -> Bool)
-> (RPatOp l -> RPatOp l -> Bool)
-> (RPatOp l -> RPatOp l -> Bool)
-> (RPatOp l -> RPatOp l -> Bool)
-> (RPatOp l -> RPatOp l -> RPatOp l)
-> (RPatOp l -> RPatOp l -> RPatOp l)
-> Ord (RPatOp l)
RPatOp l -> RPatOp l -> Bool
RPatOp l -> RPatOp l -> Ordering
RPatOp l -> RPatOp l -> RPatOp l
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall l. Ord l => Eq (RPatOp l)
forall l. Ord l => RPatOp l -> RPatOp l -> Bool
forall l. Ord l => RPatOp l -> RPatOp l -> Ordering
forall l. Ord l => RPatOp l -> RPatOp l -> RPatOp l
$ccompare :: forall l. Ord l => RPatOp l -> RPatOp l -> Ordering
compare :: RPatOp l -> RPatOp l -> Ordering
$c< :: forall l. Ord l => RPatOp l -> RPatOp l -> Bool
< :: RPatOp l -> RPatOp l -> Bool
$c<= :: forall l. Ord l => RPatOp l -> RPatOp l -> Bool
<= :: RPatOp l -> RPatOp l -> Bool
$c> :: forall l. Ord l => RPatOp l -> RPatOp l -> Bool
> :: RPatOp l -> RPatOp l -> Bool
$c>= :: forall l. Ord l => RPatOp l -> RPatOp l -> Bool
>= :: RPatOp l -> RPatOp l -> Bool
$cmax :: forall l. Ord l => RPatOp l -> RPatOp l -> RPatOp l
max :: RPatOp l -> RPatOp l -> RPatOp l
$cmin :: forall l. Ord l => RPatOp l -> RPatOp l -> RPatOp l
min :: RPatOp l -> RPatOp l -> RPatOp l
Ord,Int -> RPatOp l -> ShowS
[RPatOp l] -> ShowS
RPatOp l -> String
(Int -> RPatOp l -> ShowS)
-> (RPatOp l -> String) -> ([RPatOp l] -> ShowS) -> Show (RPatOp l)
forall l. Show l => Int -> RPatOp l -> ShowS
forall l. Show l => [RPatOp l] -> ShowS
forall l. Show l => RPatOp l -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall l. Show l => Int -> RPatOp l -> ShowS
showsPrec :: Int -> RPatOp l -> ShowS
$cshow :: forall l. Show l => RPatOp l -> String
show :: RPatOp l -> String
$cshowList :: forall l. Show l => [RPatOp l] -> ShowS
showList :: [RPatOp l] -> ShowS
Show,Typeable,Typeable (RPatOp l)
Typeable (RPatOp l) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> RPatOp l -> c (RPatOp l))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (RPatOp l))
-> (RPatOp l -> Constr)
-> (RPatOp l -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (RPatOp l)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (RPatOp l)))
-> ((forall b. Data b => b -> b) -> RPatOp l -> RPatOp l)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> RPatOp l -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> RPatOp l -> r)
-> (forall u. (forall d. Data d => d -> u) -> RPatOp l -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> RPatOp l -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> RPatOp l -> m (RPatOp l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> RPatOp l -> m (RPatOp l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> RPatOp l -> m (RPatOp l))
-> Data (RPatOp l)
RPatOp l -> Constr
RPatOp l -> DataType
(forall b. Data b => b -> b) -> RPatOp l -> RPatOp l
forall l. Data l => Typeable (RPatOp l)
forall l. Data l => RPatOp l -> Constr
forall l. Data l => RPatOp l -> DataType
forall l.
Data l =>
(forall b. Data b => b -> b) -> RPatOp l -> RPatOp l
forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> RPatOp l -> u
forall l u.
Data l =>
(forall d. Data d => d -> u) -> RPatOp l -> [u]
forall l r r'.
Data l =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> RPatOp l -> r
forall l r r'.
Data l =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> RPatOp l -> r
forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d) -> RPatOp l -> m (RPatOp l)
forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> RPatOp l -> m (RPatOp l)
forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (RPatOp l)
forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RPatOp l -> c (RPatOp l)
forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (RPatOp l))
forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (RPatOp l))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> RPatOp l -> u
forall u. (forall d. Data d => d -> u) -> RPatOp l -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> RPatOp l -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> RPatOp l -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> RPatOp l -> m (RPatOp l)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RPatOp l -> m (RPatOp l)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (RPatOp l)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RPatOp l -> c (RPatOp l)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (RPatOp l))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (RPatOp l))
$cgfoldl :: forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RPatOp l -> c (RPatOp l)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RPatOp l -> c (RPatOp l)
$cgunfold :: forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (RPatOp l)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (RPatOp l)
$ctoConstr :: forall l. Data l => RPatOp l -> Constr
toConstr :: RPatOp l -> Constr
$cdataTypeOf :: forall l. Data l => RPatOp l -> DataType
dataTypeOf :: RPatOp l -> DataType
$cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (RPatOp l))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (RPatOp l))
$cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (RPatOp l))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (RPatOp l))
$cgmapT :: forall l.
Data l =>
(forall b. Data b => b -> b) -> RPatOp l -> RPatOp l
gmapT :: (forall b. Data b => b -> b) -> RPatOp l -> RPatOp l
$cgmapQl :: forall l r r'.
Data l =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> RPatOp l -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> RPatOp l -> r
$cgmapQr :: forall l r r'.
Data l =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> RPatOp l -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> RPatOp l -> r
$cgmapQ :: forall l u.
Data l =>
(forall d. Data d => d -> u) -> RPatOp l -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> RPatOp l -> [u]
$cgmapQi :: forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> RPatOp l -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> RPatOp l -> u
$cgmapM :: forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d) -> RPatOp l -> m (RPatOp l)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> RPatOp l -> m (RPatOp l)
$cgmapMp :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> RPatOp l -> m (RPatOp l)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RPatOp l -> m (RPatOp l)
$cgmapMo :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> RPatOp l -> m (RPatOp l)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RPatOp l -> m (RPatOp l)
Data,(forall m. Monoid m => RPatOp m -> m)
-> (forall m a. Monoid m => (a -> m) -> RPatOp a -> m)
-> (forall m a. Monoid m => (a -> m) -> RPatOp a -> m)
-> (forall a b. (a -> b -> b) -> b -> RPatOp a -> b)
-> (forall a b. (a -> b -> b) -> b -> RPatOp a -> b)
-> (forall b a. (b -> a -> b) -> b -> RPatOp a -> b)
-> (forall b a. (b -> a -> b) -> b -> RPatOp a -> b)
-> (forall a. (a -> a -> a) -> RPatOp a -> a)
-> (forall a. (a -> a -> a) -> RPatOp a -> a)
-> (forall a. RPatOp a -> [a])
-> (forall a. RPatOp a -> Bool)
-> (forall a. RPatOp a -> Int)
-> (forall a. Eq a => a -> RPatOp a -> Bool)
-> (forall a. Ord a => RPatOp a -> a)
-> (forall a. Ord a => RPatOp a -> a)
-> (forall a. Num a => RPatOp a -> a)
-> (forall a. Num a => RPatOp a -> a)
-> Foldable RPatOp
forall a. Eq a => a -> RPatOp a -> Bool
forall a. Num a => RPatOp a -> a
forall a. Ord a => RPatOp a -> a
forall m. Monoid m => RPatOp m -> m
forall a. RPatOp a -> Bool
forall a. RPatOp a -> Int
forall a. RPatOp a -> [a]
forall a. (a -> a -> a) -> RPatOp a -> a
forall m a. Monoid m => (a -> m) -> RPatOp a -> m
forall b a. (b -> a -> b) -> b -> RPatOp a -> b
forall a b. (a -> b -> b) -> b -> RPatOp a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall m. Monoid m => RPatOp m -> m
fold :: forall m. Monoid m => RPatOp m -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> RPatOp a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> RPatOp a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> RPatOp a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> RPatOp a -> m
$cfoldr :: forall a b. (a -> b -> b) -> b -> RPatOp a -> b
foldr :: forall a b. (a -> b -> b) -> b -> RPatOp a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> RPatOp a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> RPatOp a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> RPatOp a -> b
foldl :: forall b a. (b -> a -> b) -> b -> RPatOp a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> RPatOp a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> RPatOp a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> RPatOp a -> a
foldr1 :: forall a. (a -> a -> a) -> RPatOp a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> RPatOp a -> a
foldl1 :: forall a. (a -> a -> a) -> RPatOp a -> a
$ctoList :: forall a. RPatOp a -> [a]
toList :: forall a. RPatOp a -> [a]
$cnull :: forall a. RPatOp a -> Bool
null :: forall a. RPatOp a -> Bool
$clength :: forall a. RPatOp a -> Int
length :: forall a. RPatOp a -> Int
$celem :: forall a. Eq a => a -> RPatOp a -> Bool
elem :: forall a. Eq a => a -> RPatOp a -> Bool
$cmaximum :: forall a. Ord a => RPatOp a -> a
maximum :: forall a. Ord a => RPatOp a -> a
$cminimum :: forall a. Ord a => RPatOp a -> a
minimum :: forall a. Ord a => RPatOp a -> a
$csum :: forall a. Num a => RPatOp a -> a
sum :: forall a. Num a => RPatOp a -> a
$cproduct :: forall a. Num a => RPatOp a -> a
product :: forall a. Num a => RPatOp a -> a
Foldable,Functor RPatOp
Foldable RPatOp
(Functor RPatOp, Foldable RPatOp) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> RPatOp a -> f (RPatOp b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    RPatOp (f a) -> f (RPatOp a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> RPatOp a -> m (RPatOp b))
-> (forall (m :: * -> *) a.
    Monad m =>
    RPatOp (m a) -> m (RPatOp a))
-> Traversable RPatOp
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a. Monad m => RPatOp (m a) -> m (RPatOp a)
forall (f :: * -> *) a.
Applicative f =>
RPatOp (f a) -> f (RPatOp a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> RPatOp a -> m (RPatOp b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> RPatOp a -> f (RPatOp b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> RPatOp a -> f (RPatOp b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> RPatOp a -> f (RPatOp b)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
RPatOp (f a) -> f (RPatOp a)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
RPatOp (f a) -> f (RPatOp a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> RPatOp a -> m (RPatOp b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> RPatOp a -> m (RPatOp b)
$csequence :: forall (m :: * -> *) a. Monad m => RPatOp (m a) -> m (RPatOp a)
sequence :: forall (m :: * -> *) a. Monad m => RPatOp (m a) -> m (RPatOp a)
Traversable,(forall a b. (a -> b) -> RPatOp a -> RPatOp b)
-> (forall a b. a -> RPatOp b -> RPatOp a) -> Functor RPatOp
forall a b. a -> RPatOp b -> RPatOp a
forall a b. (a -> b) -> RPatOp a -> RPatOp b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> RPatOp a -> RPatOp b
fmap :: forall a b. (a -> b) -> RPatOp a -> RPatOp b
$c<$ :: forall a b. a -> RPatOp b -> RPatOp a
<$ :: forall a b. a -> RPatOp b -> RPatOp a
Functor,(forall x. RPatOp l -> Rep (RPatOp l) x)
-> (forall x. Rep (RPatOp l) x -> RPatOp l) -> Generic (RPatOp l)
forall x. Rep (RPatOp l) x -> RPatOp l
forall x. RPatOp l -> Rep (RPatOp l) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall l x. Rep (RPatOp l) x -> RPatOp l
forall l x. RPatOp l -> Rep (RPatOp l) x
$cfrom :: forall l x. RPatOp l -> Rep (RPatOp l) x
from :: forall x. RPatOp l -> Rep (RPatOp l) x
$cto :: forall l x. Rep (RPatOp l) x -> RPatOp l
to :: forall x. Rep (RPatOp l) x -> RPatOp l
Generic)

-- | An entity in a regular pattern.
data RPat l
    = RPOp l (RPat l) (RPatOp l)   -- ^ operator pattern, e.g. pat*
    | RPEither l (RPat l) (RPat l) -- ^ choice pattern, e.g. (1 | 2)
    | RPSeq l [RPat l]             -- ^ sequence pattern, e.g. (| 1, 2, 3 |)
    | RPGuard l (Pat l) [Stmt l]   -- ^ guarded pattern, e.g. (| p | p < 3 |)
    | RPCAs l (Name l) (RPat l)    -- ^ non-linear variable binding, e.g. (foo\@:(1 | 2))*
    | RPAs l (Name l) (RPat l)     -- ^ linear variable binding, e.g. foo\@(1 | 2)
    | RPParen l (RPat l)           -- ^ parenthesised pattern, e.g. (2*)
    | RPPat l (Pat l)              -- ^ an ordinary pattern
  deriving (RPat l -> RPat l -> Bool
(RPat l -> RPat l -> Bool)
-> (RPat l -> RPat l -> Bool) -> Eq (RPat l)
forall l. Eq l => RPat l -> RPat l -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall l. Eq l => RPat l -> RPat l -> Bool
== :: RPat l -> RPat l -> Bool
$c/= :: forall l. Eq l => RPat l -> RPat l -> Bool
/= :: RPat l -> RPat l -> Bool
Eq,Eq (RPat l)
Eq (RPat l) =>
(RPat l -> RPat l -> Ordering)
-> (RPat l -> RPat l -> Bool)
-> (RPat l -> RPat l -> Bool)
-> (RPat l -> RPat l -> Bool)
-> (RPat l -> RPat l -> Bool)
-> (RPat l -> RPat l -> RPat l)
-> (RPat l -> RPat l -> RPat l)
-> Ord (RPat l)
RPat l -> RPat l -> Bool
RPat l -> RPat l -> Ordering
RPat l -> RPat l -> RPat l
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall l. Ord l => Eq (RPat l)
forall l. Ord l => RPat l -> RPat l -> Bool
forall l. Ord l => RPat l -> RPat l -> Ordering
forall l. Ord l => RPat l -> RPat l -> RPat l
$ccompare :: forall l. Ord l => RPat l -> RPat l -> Ordering
compare :: RPat l -> RPat l -> Ordering
$c< :: forall l. Ord l => RPat l -> RPat l -> Bool
< :: RPat l -> RPat l -> Bool
$c<= :: forall l. Ord l => RPat l -> RPat l -> Bool
<= :: RPat l -> RPat l -> Bool
$c> :: forall l. Ord l => RPat l -> RPat l -> Bool
> :: RPat l -> RPat l -> Bool
$c>= :: forall l. Ord l => RPat l -> RPat l -> Bool
>= :: RPat l -> RPat l -> Bool
$cmax :: forall l. Ord l => RPat l -> RPat l -> RPat l
max :: RPat l -> RPat l -> RPat l
$cmin :: forall l. Ord l => RPat l -> RPat l -> RPat l
min :: RPat l -> RPat l -> RPat l
Ord,Int -> RPat l -> ShowS
[RPat l] -> ShowS
RPat l -> String
(Int -> RPat l -> ShowS)
-> (RPat l -> String) -> ([RPat l] -> ShowS) -> Show (RPat l)
forall l. Show l => Int -> RPat l -> ShowS
forall l. Show l => [RPat l] -> ShowS
forall l. Show l => RPat l -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall l. Show l => Int -> RPat l -> ShowS
showsPrec :: Int -> RPat l -> ShowS
$cshow :: forall l. Show l => RPat l -> String
show :: RPat l -> String
$cshowList :: forall l. Show l => [RPat l] -> ShowS
showList :: [RPat l] -> ShowS
Show,Typeable,Typeable (RPat l)
Typeable (RPat l) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> RPat l -> c (RPat l))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (RPat l))
-> (RPat l -> Constr)
-> (RPat l -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (RPat l)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (RPat l)))
-> ((forall b. Data b => b -> b) -> RPat l -> RPat l)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> RPat l -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> RPat l -> r)
-> (forall u. (forall d. Data d => d -> u) -> RPat l -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> RPat l -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> RPat l -> m (RPat l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> RPat l -> m (RPat l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> RPat l -> m (RPat l))
-> Data (RPat l)
RPat l -> Constr
RPat l -> DataType
(forall b. Data b => b -> b) -> RPat l -> RPat l
forall l. Data l => Typeable (RPat l)
forall l. Data l => RPat l -> Constr
forall l. Data l => RPat l -> DataType
forall l.
Data l =>
(forall b. Data b => b -> b) -> RPat l -> RPat l
forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> RPat l -> u
forall l u. Data l => (forall d. Data d => d -> u) -> RPat l -> [u]
forall l r r'.
Data l =>
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RPat l -> r
forall l r r'.
Data l =>
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RPat l -> r
forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d) -> RPat l -> m (RPat l)
forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> RPat l -> m (RPat l)
forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (RPat l)
forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RPat l -> c (RPat l)
forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (RPat l))
forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (RPat l))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> RPat l -> u
forall u. (forall d. Data d => d -> u) -> RPat l -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RPat l -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RPat l -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> RPat l -> m (RPat l)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RPat l -> m (RPat l)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (RPat l)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RPat l -> c (RPat l)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (RPat l))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (RPat l))
$cgfoldl :: forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RPat l -> c (RPat l)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RPat l -> c (RPat l)
$cgunfold :: forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (RPat l)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (RPat l)
$ctoConstr :: forall l. Data l => RPat l -> Constr
toConstr :: RPat l -> Constr
$cdataTypeOf :: forall l. Data l => RPat l -> DataType
dataTypeOf :: RPat l -> DataType
$cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (RPat l))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (RPat l))
$cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (RPat l))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (RPat l))
$cgmapT :: forall l.
Data l =>
(forall b. Data b => b -> b) -> RPat l -> RPat l
gmapT :: (forall b. Data b => b -> b) -> RPat l -> RPat l
$cgmapQl :: forall l r r'.
Data l =>
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RPat l -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RPat l -> r
$cgmapQr :: forall l r r'.
Data l =>
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RPat l -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RPat l -> r
$cgmapQ :: forall l u. Data l => (forall d. Data d => d -> u) -> RPat l -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> RPat l -> [u]
$cgmapQi :: forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> RPat l -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> RPat l -> u
$cgmapM :: forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d) -> RPat l -> m (RPat l)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> RPat l -> m (RPat l)
$cgmapMp :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> RPat l -> m (RPat l)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RPat l -> m (RPat l)
$cgmapMo :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> RPat l -> m (RPat l)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RPat l -> m (RPat l)
Data,(forall m. Monoid m => RPat m -> m)
-> (forall m a. Monoid m => (a -> m) -> RPat a -> m)
-> (forall m a. Monoid m => (a -> m) -> RPat a -> m)
-> (forall a b. (a -> b -> b) -> b -> RPat a -> b)
-> (forall a b. (a -> b -> b) -> b -> RPat a -> b)
-> (forall b a. (b -> a -> b) -> b -> RPat a -> b)
-> (forall b a. (b -> a -> b) -> b -> RPat a -> b)
-> (forall a. (a -> a -> a) -> RPat a -> a)
-> (forall a. (a -> a -> a) -> RPat a -> a)
-> (forall a. RPat a -> [a])
-> (forall a. RPat a -> Bool)
-> (forall a. RPat a -> Int)
-> (forall a. Eq a => a -> RPat a -> Bool)
-> (forall a. Ord a => RPat a -> a)
-> (forall a. Ord a => RPat a -> a)
-> (forall a. Num a => RPat a -> a)
-> (forall a. Num a => RPat a -> a)
-> Foldable RPat
forall a. Eq a => a -> RPat a -> Bool
forall a. Num a => RPat a -> a
forall a. Ord a => RPat a -> a
forall m. Monoid m => RPat m -> m
forall a. RPat a -> Bool
forall a. RPat a -> Int
forall a. RPat a -> [a]
forall a. (a -> a -> a) -> RPat a -> a
forall m a. Monoid m => (a -> m) -> RPat a -> m
forall b a. (b -> a -> b) -> b -> RPat a -> b
forall a b. (a -> b -> b) -> b -> RPat a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall m. Monoid m => RPat m -> m
fold :: forall m. Monoid m => RPat m -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> RPat a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> RPat a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> RPat a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> RPat a -> m
$cfoldr :: forall a b. (a -> b -> b) -> b -> RPat a -> b
foldr :: forall a b. (a -> b -> b) -> b -> RPat a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> RPat a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> RPat a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> RPat a -> b
foldl :: forall b a. (b -> a -> b) -> b -> RPat a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> RPat a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> RPat a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> RPat a -> a
foldr1 :: forall a. (a -> a -> a) -> RPat a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> RPat a -> a
foldl1 :: forall a. (a -> a -> a) -> RPat a -> a
$ctoList :: forall a. RPat a -> [a]
toList :: forall a. RPat a -> [a]
$cnull :: forall a. RPat a -> Bool
null :: forall a. RPat a -> Bool
$clength :: forall a. RPat a -> Int
length :: forall a. RPat a -> Int
$celem :: forall a. Eq a => a -> RPat a -> Bool
elem :: forall a. Eq a => a -> RPat a -> Bool
$cmaximum :: forall a. Ord a => RPat a -> a
maximum :: forall a. Ord a => RPat a -> a
$cminimum :: forall a. Ord a => RPat a -> a
minimum :: forall a. Ord a => RPat a -> a
$csum :: forall a. Num a => RPat a -> a
sum :: forall a. Num a => RPat a -> a
$cproduct :: forall a. Num a => RPat a -> a
product :: forall a. Num a => RPat a -> a
Foldable,Functor RPat
Foldable RPat
(Functor RPat, Foldable RPat) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> RPat a -> f (RPat b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    RPat (f a) -> f (RPat a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> RPat a -> m (RPat b))
-> (forall (m :: * -> *) a. Monad m => RPat (m a) -> m (RPat a))
-> Traversable RPat
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a. Monad m => RPat (m a) -> m (RPat a)
forall (f :: * -> *) a. Applicative f => RPat (f a) -> f (RPat a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> RPat a -> m (RPat b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> RPat a -> f (RPat b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> RPat a -> f (RPat b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> RPat a -> f (RPat b)
$csequenceA :: forall (f :: * -> *) a. Applicative f => RPat (f a) -> f (RPat a)
sequenceA :: forall (f :: * -> *) a. Applicative f => RPat (f a) -> f (RPat a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> RPat a -> m (RPat b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> RPat a -> m (RPat b)
$csequence :: forall (m :: * -> *) a. Monad m => RPat (m a) -> m (RPat a)
sequence :: forall (m :: * -> *) a. Monad m => RPat (m a) -> m (RPat a)
Traversable,(forall a b. (a -> b) -> RPat a -> RPat b)
-> (forall a b. a -> RPat b -> RPat a) -> Functor RPat
forall a b. a -> RPat b -> RPat a
forall a b. (a -> b) -> RPat a -> RPat b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> RPat a -> RPat b
fmap :: forall a b. (a -> b) -> RPat a -> RPat b
$c<$ :: forall a b. a -> RPat b -> RPat a
<$ :: forall a b. a -> RPat b -> RPat a
Functor,(forall x. RPat l -> Rep (RPat l) x)
-> (forall x. Rep (RPat l) x -> RPat l) -> Generic (RPat l)
forall x. Rep (RPat l) x -> RPat l
forall x. RPat l -> Rep (RPat l) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall l x. Rep (RPat l) x -> RPat l
forall l x. RPat l -> Rep (RPat l) x
$cfrom :: forall l x. RPat l -> Rep (RPat l) x
from :: forall x. RPat l -> Rep (RPat l) x
$cto :: forall l x. Rep (RPat l) x -> RPat l
to :: forall x. Rep (RPat l) x -> RPat l
Generic)

-- | An /fpat/ in a labeled record pattern.
data PatField l
    = PFieldPat l (QName l) (Pat l)     -- ^ ordinary label-pattern pair
    | PFieldPun l (QName l)             -- ^ record field pun
    | PFieldWildcard l                  -- ^ record field wildcard
  deriving (PatField l -> PatField l -> Bool
(PatField l -> PatField l -> Bool)
-> (PatField l -> PatField l -> Bool) -> Eq (PatField l)
forall l. Eq l => PatField l -> PatField l -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall l. Eq l => PatField l -> PatField l -> Bool
== :: PatField l -> PatField l -> Bool
$c/= :: forall l. Eq l => PatField l -> PatField l -> Bool
/= :: PatField l -> PatField l -> Bool
Eq,Eq (PatField l)
Eq (PatField l) =>
(PatField l -> PatField l -> Ordering)
-> (PatField l -> PatField l -> Bool)
-> (PatField l -> PatField l -> Bool)
-> (PatField l -> PatField l -> Bool)
-> (PatField l -> PatField l -> Bool)
-> (PatField l -> PatField l -> PatField l)
-> (PatField l -> PatField l -> PatField l)
-> Ord (PatField l)
PatField l -> PatField l -> Bool
PatField l -> PatField l -> Ordering
PatField l -> PatField l -> PatField l
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall l. Ord l => Eq (PatField l)
forall l. Ord l => PatField l -> PatField l -> Bool
forall l. Ord l => PatField l -> PatField l -> Ordering
forall l. Ord l => PatField l -> PatField l -> PatField l
$ccompare :: forall l. Ord l => PatField l -> PatField l -> Ordering
compare :: PatField l -> PatField l -> Ordering
$c< :: forall l. Ord l => PatField l -> PatField l -> Bool
< :: PatField l -> PatField l -> Bool
$c<= :: forall l. Ord l => PatField l -> PatField l -> Bool
<= :: PatField l -> PatField l -> Bool
$c> :: forall l. Ord l => PatField l -> PatField l -> Bool
> :: PatField l -> PatField l -> Bool
$c>= :: forall l. Ord l => PatField l -> PatField l -> Bool
>= :: PatField l -> PatField l -> Bool
$cmax :: forall l. Ord l => PatField l -> PatField l -> PatField l
max :: PatField l -> PatField l -> PatField l
$cmin :: forall l. Ord l => PatField l -> PatField l -> PatField l
min :: PatField l -> PatField l -> PatField l
Ord,Int -> PatField l -> ShowS
[PatField l] -> ShowS
PatField l -> String
(Int -> PatField l -> ShowS)
-> (PatField l -> String)
-> ([PatField l] -> ShowS)
-> Show (PatField l)
forall l. Show l => Int -> PatField l -> ShowS
forall l. Show l => [PatField l] -> ShowS
forall l. Show l => PatField l -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall l. Show l => Int -> PatField l -> ShowS
showsPrec :: Int -> PatField l -> ShowS
$cshow :: forall l. Show l => PatField l -> String
show :: PatField l -> String
$cshowList :: forall l. Show l => [PatField l] -> ShowS
showList :: [PatField l] -> ShowS
Show,Typeable,Typeable (PatField l)
Typeable (PatField l) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> PatField l -> c (PatField l))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (PatField l))
-> (PatField l -> Constr)
-> (PatField l -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (PatField l)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (PatField l)))
-> ((forall b. Data b => b -> b) -> PatField l -> PatField l)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> PatField l -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> PatField l -> r)
-> (forall u. (forall d. Data d => d -> u) -> PatField l -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> PatField l -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> PatField l -> m (PatField l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> PatField l -> m (PatField l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> PatField l -> m (PatField l))
-> Data (PatField l)
PatField l -> Constr
PatField l -> DataType
(forall b. Data b => b -> b) -> PatField l -> PatField l
forall l. Data l => Typeable (PatField l)
forall l. Data l => PatField l -> Constr
forall l. Data l => PatField l -> DataType
forall l.
Data l =>
(forall b. Data b => b -> b) -> PatField l -> PatField l
forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> PatField l -> u
forall l u.
Data l =>
(forall d. Data d => d -> u) -> PatField l -> [u]
forall l r r'.
Data l =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PatField l -> r
forall l r r'.
Data l =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PatField l -> r
forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d) -> PatField l -> m (PatField l)
forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> PatField l -> m (PatField l)
forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (PatField l)
forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PatField l -> c (PatField l)
forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (PatField l))
forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (PatField l))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> PatField l -> u
forall u. (forall d. Data d => d -> u) -> PatField l -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PatField l -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PatField l -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> PatField l -> m (PatField l)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> PatField l -> m (PatField l)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (PatField l)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PatField l -> c (PatField l)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (PatField l))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (PatField l))
$cgfoldl :: forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PatField l -> c (PatField l)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PatField l -> c (PatField l)
$cgunfold :: forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (PatField l)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (PatField l)
$ctoConstr :: forall l. Data l => PatField l -> Constr
toConstr :: PatField l -> Constr
$cdataTypeOf :: forall l. Data l => PatField l -> DataType
dataTypeOf :: PatField l -> DataType
$cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (PatField l))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (PatField l))
$cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (PatField l))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (PatField l))
$cgmapT :: forall l.
Data l =>
(forall b. Data b => b -> b) -> PatField l -> PatField l
gmapT :: (forall b. Data b => b -> b) -> PatField l -> PatField l
$cgmapQl :: forall l r r'.
Data l =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PatField l -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PatField l -> r
$cgmapQr :: forall l r r'.
Data l =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PatField l -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PatField l -> r
$cgmapQ :: forall l u.
Data l =>
(forall d. Data d => d -> u) -> PatField l -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> PatField l -> [u]
$cgmapQi :: forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> PatField l -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> PatField l -> u
$cgmapM :: forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d) -> PatField l -> m (PatField l)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> PatField l -> m (PatField l)
$cgmapMp :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> PatField l -> m (PatField l)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> PatField l -> m (PatField l)
$cgmapMo :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> PatField l -> m (PatField l)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> PatField l -> m (PatField l)
Data,(forall m. Monoid m => PatField m -> m)
-> (forall m a. Monoid m => (a -> m) -> PatField a -> m)
-> (forall m a. Monoid m => (a -> m) -> PatField a -> m)
-> (forall a b. (a -> b -> b) -> b -> PatField a -> b)
-> (forall a b. (a -> b -> b) -> b -> PatField a -> b)
-> (forall b a. (b -> a -> b) -> b -> PatField a -> b)
-> (forall b a. (b -> a -> b) -> b -> PatField a -> b)
-> (forall a. (a -> a -> a) -> PatField a -> a)
-> (forall a. (a -> a -> a) -> PatField a -> a)
-> (forall a. PatField a -> [a])
-> (forall a. PatField a -> Bool)
-> (forall a. PatField a -> Int)
-> (forall a. Eq a => a -> PatField a -> Bool)
-> (forall a. Ord a => PatField a -> a)
-> (forall a. Ord a => PatField a -> a)
-> (forall a. Num a => PatField a -> a)
-> (forall a. Num a => PatField a -> a)
-> Foldable PatField
forall a. Eq a => a -> PatField a -> Bool
forall a. Num a => PatField a -> a
forall a. Ord a => PatField a -> a
forall m. Monoid m => PatField m -> m
forall a. PatField a -> Bool
forall a. PatField a -> Int
forall a. PatField a -> [a]
forall a. (a -> a -> a) -> PatField a -> a
forall m a. Monoid m => (a -> m) -> PatField a -> m
forall b a. (b -> a -> b) -> b -> PatField a -> b
forall a b. (a -> b -> b) -> b -> PatField a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall m. Monoid m => PatField m -> m
fold :: forall m. Monoid m => PatField m -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> PatField a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> PatField a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> PatField a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> PatField a -> m
$cfoldr :: forall a b. (a -> b -> b) -> b -> PatField a -> b
foldr :: forall a b. (a -> b -> b) -> b -> PatField a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> PatField a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> PatField a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> PatField a -> b
foldl :: forall b a. (b -> a -> b) -> b -> PatField a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> PatField a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> PatField a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> PatField a -> a
foldr1 :: forall a. (a -> a -> a) -> PatField a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> PatField a -> a
foldl1 :: forall a. (a -> a -> a) -> PatField a -> a
$ctoList :: forall a. PatField a -> [a]
toList :: forall a. PatField a -> [a]
$cnull :: forall a. PatField a -> Bool
null :: forall a. PatField a -> Bool
$clength :: forall a. PatField a -> Int
length :: forall a. PatField a -> Int
$celem :: forall a. Eq a => a -> PatField a -> Bool
elem :: forall a. Eq a => a -> PatField a -> Bool
$cmaximum :: forall a. Ord a => PatField a -> a
maximum :: forall a. Ord a => PatField a -> a
$cminimum :: forall a. Ord a => PatField a -> a
minimum :: forall a. Ord a => PatField a -> a
$csum :: forall a. Num a => PatField a -> a
sum :: forall a. Num a => PatField a -> a
$cproduct :: forall a. Num a => PatField a -> a
product :: forall a. Num a => PatField a -> a
Foldable,Functor PatField
Foldable PatField
(Functor PatField, Foldable PatField) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> PatField a -> f (PatField b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    PatField (f a) -> f (PatField a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> PatField a -> m (PatField b))
-> (forall (m :: * -> *) a.
    Monad m =>
    PatField (m a) -> m (PatField a))
-> Traversable PatField
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a. Monad m => PatField (m a) -> m (PatField a)
forall (f :: * -> *) a.
Applicative f =>
PatField (f a) -> f (PatField a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> PatField a -> m (PatField b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> PatField a -> f (PatField b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> PatField a -> f (PatField b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> PatField a -> f (PatField b)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
PatField (f a) -> f (PatField a)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
PatField (f a) -> f (PatField a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> PatField a -> m (PatField b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> PatField a -> m (PatField b)
$csequence :: forall (m :: * -> *) a. Monad m => PatField (m a) -> m (PatField a)
sequence :: forall (m :: * -> *) a. Monad m => PatField (m a) -> m (PatField a)
Traversable,(forall a b. (a -> b) -> PatField a -> PatField b)
-> (forall a b. a -> PatField b -> PatField a) -> Functor PatField
forall a b. a -> PatField b -> PatField a
forall a b. (a -> b) -> PatField a -> PatField b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> PatField a -> PatField b
fmap :: forall a b. (a -> b) -> PatField a -> PatField b
$c<$ :: forall a b. a -> PatField b -> PatField a
<$ :: forall a b. a -> PatField b -> PatField a
Functor,(forall x. PatField l -> Rep (PatField l) x)
-> (forall x. Rep (PatField l) x -> PatField l)
-> Generic (PatField l)
forall x. Rep (PatField l) x -> PatField l
forall x. PatField l -> Rep (PatField l) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall l x. Rep (PatField l) x -> PatField l
forall l x. PatField l -> Rep (PatField l) x
$cfrom :: forall l x. PatField l -> Rep (PatField l) x
from :: forall x. PatField l -> Rep (PatField l) x
$cto :: forall l x. Rep (PatField l) x -> PatField l
to :: forall x. Rep (PatField l) x -> PatField l
Generic)

-- | A statement, representing both a /stmt/ in a @do@-expression,
--   an ordinary /qual/ in a list comprehension, as well as a /stmt/
--   in a pattern guard.
data Stmt l
    = Generator l (Pat l) (Exp l)
                            -- ^ a generator: /pat/ @<-@ /exp/
    | Qualifier l (Exp l)   -- ^ an /exp/ by itself: in a @do@-expression,
                            --   an action whose result is discarded;
                            --   in a list comprehension and pattern guard,
                            --   a guard expression
    | LetStmt l (Binds l)   -- ^ local bindings
    | RecStmt l [Stmt l]    -- ^ a recursive binding group for arrows
  deriving (Stmt l -> Stmt l -> Bool
(Stmt l -> Stmt l -> Bool)
-> (Stmt l -> Stmt l -> Bool) -> Eq (Stmt l)
forall l. Eq l => Stmt l -> Stmt l -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall l. Eq l => Stmt l -> Stmt l -> Bool
== :: Stmt l -> Stmt l -> Bool
$c/= :: forall l. Eq l => Stmt l -> Stmt l -> Bool
/= :: Stmt l -> Stmt l -> Bool
Eq,Eq (Stmt l)
Eq (Stmt l) =>
(Stmt l -> Stmt l -> Ordering)
-> (Stmt l -> Stmt l -> Bool)
-> (Stmt l -> Stmt l -> Bool)
-> (Stmt l -> Stmt l -> Bool)
-> (Stmt l -> Stmt l -> Bool)
-> (Stmt l -> Stmt l -> Stmt l)
-> (Stmt l -> Stmt l -> Stmt l)
-> Ord (Stmt l)
Stmt l -> Stmt l -> Bool
Stmt l -> Stmt l -> Ordering
Stmt l -> Stmt l -> Stmt l
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall l. Ord l => Eq (Stmt l)
forall l. Ord l => Stmt l -> Stmt l -> Bool
forall l. Ord l => Stmt l -> Stmt l -> Ordering
forall l. Ord l => Stmt l -> Stmt l -> Stmt l
$ccompare :: forall l. Ord l => Stmt l -> Stmt l -> Ordering
compare :: Stmt l -> Stmt l -> Ordering
$c< :: forall l. Ord l => Stmt l -> Stmt l -> Bool
< :: Stmt l -> Stmt l -> Bool
$c<= :: forall l. Ord l => Stmt l -> Stmt l -> Bool
<= :: Stmt l -> Stmt l -> Bool
$c> :: forall l. Ord l => Stmt l -> Stmt l -> Bool
> :: Stmt l -> Stmt l -> Bool
$c>= :: forall l. Ord l => Stmt l -> Stmt l -> Bool
>= :: Stmt l -> Stmt l -> Bool
$cmax :: forall l. Ord l => Stmt l -> Stmt l -> Stmt l
max :: Stmt l -> Stmt l -> Stmt l
$cmin :: forall l. Ord l => Stmt l -> Stmt l -> Stmt l
min :: Stmt l -> Stmt l -> Stmt l
Ord,Int -> Stmt l -> ShowS
[Stmt l] -> ShowS
Stmt l -> String
(Int -> Stmt l -> ShowS)
-> (Stmt l -> String) -> ([Stmt l] -> ShowS) -> Show (Stmt l)
forall l. Show l => Int -> Stmt l -> ShowS
forall l. Show l => [Stmt l] -> ShowS
forall l. Show l => Stmt l -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall l. Show l => Int -> Stmt l -> ShowS
showsPrec :: Int -> Stmt l -> ShowS
$cshow :: forall l. Show l => Stmt l -> String
show :: Stmt l -> String
$cshowList :: forall l. Show l => [Stmt l] -> ShowS
showList :: [Stmt l] -> ShowS
Show,Typeable,Typeable (Stmt l)
Typeable (Stmt l) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Stmt l -> c (Stmt l))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Stmt l))
-> (Stmt l -> Constr)
-> (Stmt l -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Stmt l)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Stmt l)))
-> ((forall b. Data b => b -> b) -> Stmt l -> Stmt l)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Stmt l -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Stmt l -> r)
-> (forall u. (forall d. Data d => d -> u) -> Stmt l -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Stmt l -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Stmt l -> m (Stmt l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Stmt l -> m (Stmt l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Stmt l -> m (Stmt l))
-> Data (Stmt l)
Stmt l -> Constr
Stmt l -> DataType
(forall b. Data b => b -> b) -> Stmt l -> Stmt l
forall l. Data l => Typeable (Stmt l)
forall l. Data l => Stmt l -> Constr
forall l. Data l => Stmt l -> DataType
forall l.
Data l =>
(forall b. Data b => b -> b) -> Stmt l -> Stmt l
forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> Stmt l -> u
forall l u. Data l => (forall d. Data d => d -> u) -> Stmt l -> [u]
forall l r r'.
Data l =>
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Stmt l -> r
forall l r r'.
Data l =>
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Stmt l -> r
forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d) -> Stmt l -> m (Stmt l)
forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Stmt l -> m (Stmt l)
forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Stmt l)
forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Stmt l -> c (Stmt l)
forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Stmt l))
forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Stmt l))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Stmt l -> u
forall u. (forall d. Data d => d -> u) -> Stmt l -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Stmt l -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Stmt l -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Stmt l -> m (Stmt l)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Stmt l -> m (Stmt l)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Stmt l)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Stmt l -> c (Stmt l)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Stmt l))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Stmt l))
$cgfoldl :: forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Stmt l -> c (Stmt l)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Stmt l -> c (Stmt l)
$cgunfold :: forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Stmt l)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Stmt l)
$ctoConstr :: forall l. Data l => Stmt l -> Constr
toConstr :: Stmt l -> Constr
$cdataTypeOf :: forall l. Data l => Stmt l -> DataType
dataTypeOf :: Stmt l -> DataType
$cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Stmt l))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Stmt l))
$cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Stmt l))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Stmt l))
$cgmapT :: forall l.
Data l =>
(forall b. Data b => b -> b) -> Stmt l -> Stmt l
gmapT :: (forall b. Data b => b -> b) -> Stmt l -> Stmt l
$cgmapQl :: forall l r r'.
Data l =>
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Stmt l -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Stmt l -> r
$cgmapQr :: forall l r r'.
Data l =>
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Stmt l -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Stmt l -> r
$cgmapQ :: forall l u. Data l => (forall d. Data d => d -> u) -> Stmt l -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Stmt l -> [u]
$cgmapQi :: forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> Stmt l -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Stmt l -> u
$cgmapM :: forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d) -> Stmt l -> m (Stmt l)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Stmt l -> m (Stmt l)
$cgmapMp :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Stmt l -> m (Stmt l)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Stmt l -> m (Stmt l)
$cgmapMo :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Stmt l -> m (Stmt l)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Stmt l -> m (Stmt l)
Data,(forall m. Monoid m => Stmt m -> m)
-> (forall m a. Monoid m => (a -> m) -> Stmt a -> m)
-> (forall m a. Monoid m => (a -> m) -> Stmt a -> m)
-> (forall a b. (a -> b -> b) -> b -> Stmt a -> b)
-> (forall a b. (a -> b -> b) -> b -> Stmt a -> b)
-> (forall b a. (b -> a -> b) -> b -> Stmt a -> b)
-> (forall b a. (b -> a -> b) -> b -> Stmt a -> b)
-> (forall a. (a -> a -> a) -> Stmt a -> a)
-> (forall a. (a -> a -> a) -> Stmt a -> a)
-> (forall a. Stmt a -> [a])
-> (forall a. Stmt a -> Bool)
-> (forall a. Stmt a -> Int)
-> (forall a. Eq a => a -> Stmt a -> Bool)
-> (forall a. Ord a => Stmt a -> a)
-> (forall a. Ord a => Stmt a -> a)
-> (forall a. Num a => Stmt a -> a)
-> (forall a. Num a => Stmt a -> a)
-> Foldable Stmt
forall a. Eq a => a -> Stmt a -> Bool
forall a. Num a => Stmt a -> a
forall a. Ord a => Stmt a -> a
forall m. Monoid m => Stmt m -> m
forall a. Stmt a -> Bool
forall a. Stmt a -> Int
forall a. Stmt a -> [a]
forall a. (a -> a -> a) -> Stmt a -> a
forall m a. Monoid m => (a -> m) -> Stmt a -> m
forall b a. (b -> a -> b) -> b -> Stmt a -> b
forall a b. (a -> b -> b) -> b -> Stmt a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall m. Monoid m => Stmt m -> m
fold :: forall m. Monoid m => Stmt m -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> Stmt a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> Stmt a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> Stmt a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> Stmt a -> m
$cfoldr :: forall a b. (a -> b -> b) -> b -> Stmt a -> b
foldr :: forall a b. (a -> b -> b) -> b -> Stmt a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> Stmt a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> Stmt a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> Stmt a -> b
foldl :: forall b a. (b -> a -> b) -> b -> Stmt a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> Stmt a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> Stmt a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> Stmt a -> a
foldr1 :: forall a. (a -> a -> a) -> Stmt a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> Stmt a -> a
foldl1 :: forall a. (a -> a -> a) -> Stmt a -> a
$ctoList :: forall a. Stmt a -> [a]
toList :: forall a. Stmt a -> [a]
$cnull :: forall a. Stmt a -> Bool
null :: forall a. Stmt a -> Bool
$clength :: forall a. Stmt a -> Int
length :: forall a. Stmt a -> Int
$celem :: forall a. Eq a => a -> Stmt a -> Bool
elem :: forall a. Eq a => a -> Stmt a -> Bool
$cmaximum :: forall a. Ord a => Stmt a -> a
maximum :: forall a. Ord a => Stmt a -> a
$cminimum :: forall a. Ord a => Stmt a -> a
minimum :: forall a. Ord a => Stmt a -> a
$csum :: forall a. Num a => Stmt a -> a
sum :: forall a. Num a => Stmt a -> a
$cproduct :: forall a. Num a => Stmt a -> a
product :: forall a. Num a => Stmt a -> a
Foldable,Functor Stmt
Foldable Stmt
(Functor Stmt, Foldable Stmt) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> Stmt a -> f (Stmt b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    Stmt (f a) -> f (Stmt a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Stmt a -> m (Stmt b))
-> (forall (m :: * -> *) a. Monad m => Stmt (m a) -> m (Stmt a))
-> Traversable Stmt
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a. Monad m => Stmt (m a) -> m (Stmt a)
forall (f :: * -> *) a. Applicative f => Stmt (f a) -> f (Stmt a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Stmt a -> m (Stmt b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Stmt a -> f (Stmt b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Stmt a -> f (Stmt b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Stmt a -> f (Stmt b)
$csequenceA :: forall (f :: * -> *) a. Applicative f => Stmt (f a) -> f (Stmt a)
sequenceA :: forall (f :: * -> *) a. Applicative f => Stmt (f a) -> f (Stmt a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Stmt a -> m (Stmt b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Stmt a -> m (Stmt b)
$csequence :: forall (m :: * -> *) a. Monad m => Stmt (m a) -> m (Stmt a)
sequence :: forall (m :: * -> *) a. Monad m => Stmt (m a) -> m (Stmt a)
Traversable,(forall a b. (a -> b) -> Stmt a -> Stmt b)
-> (forall a b. a -> Stmt b -> Stmt a) -> Functor Stmt
forall a b. a -> Stmt b -> Stmt a
forall a b. (a -> b) -> Stmt a -> Stmt b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> Stmt a -> Stmt b
fmap :: forall a b. (a -> b) -> Stmt a -> Stmt b
$c<$ :: forall a b. a -> Stmt b -> Stmt a
<$ :: forall a b. a -> Stmt b -> Stmt a
Functor,(forall x. Stmt l -> Rep (Stmt l) x)
-> (forall x. Rep (Stmt l) x -> Stmt l) -> Generic (Stmt l)
forall x. Rep (Stmt l) x -> Stmt l
forall x. Stmt l -> Rep (Stmt l) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall l x. Rep (Stmt l) x -> Stmt l
forall l x. Stmt l -> Rep (Stmt l) x
$cfrom :: forall l x. Stmt l -> Rep (Stmt l) x
from :: forall x. Stmt l -> Rep (Stmt l) x
$cto :: forall l x. Rep (Stmt l) x -> Stmt l
to :: forall x. Rep (Stmt l) x -> Stmt l
Generic)

-- | A general /transqual/ in a list comprehension,
--   which could potentially be a transform of the kind
--   enabled by TransformListComp.
data QualStmt l
    = QualStmt     l (Stmt l)         -- ^ an ordinary statement
    | ThenTrans    l (Exp l)          -- ^ @then@ /exp/
    | ThenBy       l (Exp l) (Exp l)  -- ^ @then@ /exp/ @by@ /exp/
    | GroupBy      l (Exp l)          -- ^ @then@ @group@ @by@ /exp/
    | GroupUsing   l (Exp l)          -- ^ @then@ @group@ @using@ /exp/
    | GroupByUsing l (Exp l) (Exp l)  -- ^ @then@ @group@ @by@ /exp/ @using@ /exp/
  deriving (QualStmt l -> QualStmt l -> Bool
(QualStmt l -> QualStmt l -> Bool)
-> (QualStmt l -> QualStmt l -> Bool) -> Eq (QualStmt l)
forall l. Eq l => QualStmt l -> QualStmt l -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall l. Eq l => QualStmt l -> QualStmt l -> Bool
== :: QualStmt l -> QualStmt l -> Bool
$c/= :: forall l. Eq l => QualStmt l -> QualStmt l -> Bool
/= :: QualStmt l -> QualStmt l -> Bool
Eq,Eq (QualStmt l)
Eq (QualStmt l) =>
(QualStmt l -> QualStmt l -> Ordering)
-> (QualStmt l -> QualStmt l -> Bool)
-> (QualStmt l -> QualStmt l -> Bool)
-> (QualStmt l -> QualStmt l -> Bool)
-> (QualStmt l -> QualStmt l -> Bool)
-> (QualStmt l -> QualStmt l -> QualStmt l)
-> (QualStmt l -> QualStmt l -> QualStmt l)
-> Ord (QualStmt l)
QualStmt l -> QualStmt l -> Bool
QualStmt l -> QualStmt l -> Ordering
QualStmt l -> QualStmt l -> QualStmt l
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall l. Ord l => Eq (QualStmt l)
forall l. Ord l => QualStmt l -> QualStmt l -> Bool
forall l. Ord l => QualStmt l -> QualStmt l -> Ordering
forall l. Ord l => QualStmt l -> QualStmt l -> QualStmt l
$ccompare :: forall l. Ord l => QualStmt l -> QualStmt l -> Ordering
compare :: QualStmt l -> QualStmt l -> Ordering
$c< :: forall l. Ord l => QualStmt l -> QualStmt l -> Bool
< :: QualStmt l -> QualStmt l -> Bool
$c<= :: forall l. Ord l => QualStmt l -> QualStmt l -> Bool
<= :: QualStmt l -> QualStmt l -> Bool
$c> :: forall l. Ord l => QualStmt l -> QualStmt l -> Bool
> :: QualStmt l -> QualStmt l -> Bool
$c>= :: forall l. Ord l => QualStmt l -> QualStmt l -> Bool
>= :: QualStmt l -> QualStmt l -> Bool
$cmax :: forall l. Ord l => QualStmt l -> QualStmt l -> QualStmt l
max :: QualStmt l -> QualStmt l -> QualStmt l
$cmin :: forall l. Ord l => QualStmt l -> QualStmt l -> QualStmt l
min :: QualStmt l -> QualStmt l -> QualStmt l
Ord,Int -> QualStmt l -> ShowS
[QualStmt l] -> ShowS
QualStmt l -> String
(Int -> QualStmt l -> ShowS)
-> (QualStmt l -> String)
-> ([QualStmt l] -> ShowS)
-> Show (QualStmt l)
forall l. Show l => Int -> QualStmt l -> ShowS
forall l. Show l => [QualStmt l] -> ShowS
forall l. Show l => QualStmt l -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall l. Show l => Int -> QualStmt l -> ShowS
showsPrec :: Int -> QualStmt l -> ShowS
$cshow :: forall l. Show l => QualStmt l -> String
show :: QualStmt l -> String
$cshowList :: forall l. Show l => [QualStmt l] -> ShowS
showList :: [QualStmt l] -> ShowS
Show,Typeable,Typeable (QualStmt l)
Typeable (QualStmt l) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> QualStmt l -> c (QualStmt l))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (QualStmt l))
-> (QualStmt l -> Constr)
-> (QualStmt l -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (QualStmt l)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (QualStmt l)))
-> ((forall b. Data b => b -> b) -> QualStmt l -> QualStmt l)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> QualStmt l -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> QualStmt l -> r)
-> (forall u. (forall d. Data d => d -> u) -> QualStmt l -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> QualStmt l -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> QualStmt l -> m (QualStmt l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> QualStmt l -> m (QualStmt l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> QualStmt l -> m (QualStmt l))
-> Data (QualStmt l)
QualStmt l -> Constr
QualStmt l -> DataType
(forall b. Data b => b -> b) -> QualStmt l -> QualStmt l
forall l. Data l => Typeable (QualStmt l)
forall l. Data l => QualStmt l -> Constr
forall l. Data l => QualStmt l -> DataType
forall l.
Data l =>
(forall b. Data b => b -> b) -> QualStmt l -> QualStmt l
forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> QualStmt l -> u
forall l u.
Data l =>
(forall d. Data d => d -> u) -> QualStmt l -> [u]
forall l r r'.
Data l =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> QualStmt l -> r
forall l r r'.
Data l =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> QualStmt l -> r
forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d) -> QualStmt l -> m (QualStmt l)
forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> QualStmt l -> m (QualStmt l)
forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (QualStmt l)
forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> QualStmt l -> c (QualStmt l)
forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (QualStmt l))
forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (QualStmt l))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> QualStmt l -> u
forall u. (forall d. Data d => d -> u) -> QualStmt l -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> QualStmt l -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> QualStmt l -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> QualStmt l -> m (QualStmt l)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> QualStmt l -> m (QualStmt l)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (QualStmt l)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> QualStmt l -> c (QualStmt l)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (QualStmt l))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (QualStmt l))
$cgfoldl :: forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> QualStmt l -> c (QualStmt l)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> QualStmt l -> c (QualStmt l)
$cgunfold :: forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (QualStmt l)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (QualStmt l)
$ctoConstr :: forall l. Data l => QualStmt l -> Constr
toConstr :: QualStmt l -> Constr
$cdataTypeOf :: forall l. Data l => QualStmt l -> DataType
dataTypeOf :: QualStmt l -> DataType
$cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (QualStmt l))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (QualStmt l))
$cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (QualStmt l))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (QualStmt l))
$cgmapT :: forall l.
Data l =>
(forall b. Data b => b -> b) -> QualStmt l -> QualStmt l
gmapT :: (forall b. Data b => b -> b) -> QualStmt l -> QualStmt l
$cgmapQl :: forall l r r'.
Data l =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> QualStmt l -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> QualStmt l -> r
$cgmapQr :: forall l r r'.
Data l =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> QualStmt l -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> QualStmt l -> r
$cgmapQ :: forall l u.
Data l =>
(forall d. Data d => d -> u) -> QualStmt l -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> QualStmt l -> [u]
$cgmapQi :: forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> QualStmt l -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> QualStmt l -> u
$cgmapM :: forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d) -> QualStmt l -> m (QualStmt l)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> QualStmt l -> m (QualStmt l)
$cgmapMp :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> QualStmt l -> m (QualStmt l)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> QualStmt l -> m (QualStmt l)
$cgmapMo :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> QualStmt l -> m (QualStmt l)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> QualStmt l -> m (QualStmt l)
Data,(forall m. Monoid m => QualStmt m -> m)
-> (forall m a. Monoid m => (a -> m) -> QualStmt a -> m)
-> (forall m a. Monoid m => (a -> m) -> QualStmt a -> m)
-> (forall a b. (a -> b -> b) -> b -> QualStmt a -> b)
-> (forall a b. (a -> b -> b) -> b -> QualStmt a -> b)
-> (forall b a. (b -> a -> b) -> b -> QualStmt a -> b)
-> (forall b a. (b -> a -> b) -> b -> QualStmt a -> b)
-> (forall a. (a -> a -> a) -> QualStmt a -> a)
-> (forall a. (a -> a -> a) -> QualStmt a -> a)
-> (forall a. QualStmt a -> [a])
-> (forall a. QualStmt a -> Bool)
-> (forall a. QualStmt a -> Int)
-> (forall a. Eq a => a -> QualStmt a -> Bool)
-> (forall a. Ord a => QualStmt a -> a)
-> (forall a. Ord a => QualStmt a -> a)
-> (forall a. Num a => QualStmt a -> a)
-> (forall a. Num a => QualStmt a -> a)
-> Foldable QualStmt
forall a. Eq a => a -> QualStmt a -> Bool
forall a. Num a => QualStmt a -> a
forall a. Ord a => QualStmt a -> a
forall m. Monoid m => QualStmt m -> m
forall a. QualStmt a -> Bool
forall a. QualStmt a -> Int
forall a. QualStmt a -> [a]
forall a. (a -> a -> a) -> QualStmt a -> a
forall m a. Monoid m => (a -> m) -> QualStmt a -> m
forall b a. (b -> a -> b) -> b -> QualStmt a -> b
forall a b. (a -> b -> b) -> b -> QualStmt a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall m. Monoid m => QualStmt m -> m
fold :: forall m. Monoid m => QualStmt m -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> QualStmt a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> QualStmt a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> QualStmt a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> QualStmt a -> m
$cfoldr :: forall a b. (a -> b -> b) -> b -> QualStmt a -> b
foldr :: forall a b. (a -> b -> b) -> b -> QualStmt a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> QualStmt a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> QualStmt a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> QualStmt a -> b
foldl :: forall b a. (b -> a -> b) -> b -> QualStmt a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> QualStmt a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> QualStmt a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> QualStmt a -> a
foldr1 :: forall a. (a -> a -> a) -> QualStmt a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> QualStmt a -> a
foldl1 :: forall a. (a -> a -> a) -> QualStmt a -> a
$ctoList :: forall a. QualStmt a -> [a]
toList :: forall a. QualStmt a -> [a]
$cnull :: forall a. QualStmt a -> Bool
null :: forall a. QualStmt a -> Bool
$clength :: forall a. QualStmt a -> Int
length :: forall a. QualStmt a -> Int
$celem :: forall a. Eq a => a -> QualStmt a -> Bool
elem :: forall a. Eq a => a -> QualStmt a -> Bool
$cmaximum :: forall a. Ord a => QualStmt a -> a
maximum :: forall a. Ord a => QualStmt a -> a
$cminimum :: forall a. Ord a => QualStmt a -> a
minimum :: forall a. Ord a => QualStmt a -> a
$csum :: forall a. Num a => QualStmt a -> a
sum :: forall a. Num a => QualStmt a -> a
$cproduct :: forall a. Num a => QualStmt a -> a
product :: forall a. Num a => QualStmt a -> a
Foldable,Functor QualStmt
Foldable QualStmt
(Functor QualStmt, Foldable QualStmt) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> QualStmt a -> f (QualStmt b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    QualStmt (f a) -> f (QualStmt a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> QualStmt a -> m (QualStmt b))
-> (forall (m :: * -> *) a.
    Monad m =>
    QualStmt (m a) -> m (QualStmt a))
-> Traversable QualStmt
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a. Monad m => QualStmt (m a) -> m (QualStmt a)
forall (f :: * -> *) a.
Applicative f =>
QualStmt (f a) -> f (QualStmt a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> QualStmt a -> m (QualStmt b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> QualStmt a -> f (QualStmt b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> QualStmt a -> f (QualStmt b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> QualStmt a -> f (QualStmt b)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
QualStmt (f a) -> f (QualStmt a)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
QualStmt (f a) -> f (QualStmt a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> QualStmt a -> m (QualStmt b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> QualStmt a -> m (QualStmt b)
$csequence :: forall (m :: * -> *) a. Monad m => QualStmt (m a) -> m (QualStmt a)
sequence :: forall (m :: * -> *) a. Monad m => QualStmt (m a) -> m (QualStmt a)
Traversable,(forall a b. (a -> b) -> QualStmt a -> QualStmt b)
-> (forall a b. a -> QualStmt b -> QualStmt a) -> Functor QualStmt
forall a b. a -> QualStmt b -> QualStmt a
forall a b. (a -> b) -> QualStmt a -> QualStmt b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> QualStmt a -> QualStmt b
fmap :: forall a b. (a -> b) -> QualStmt a -> QualStmt b
$c<$ :: forall a b. a -> QualStmt b -> QualStmt a
<$ :: forall a b. a -> QualStmt b -> QualStmt a
Functor,(forall x. QualStmt l -> Rep (QualStmt l) x)
-> (forall x. Rep (QualStmt l) x -> QualStmt l)
-> Generic (QualStmt l)
forall x. Rep (QualStmt l) x -> QualStmt l
forall x. QualStmt l -> Rep (QualStmt l) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall l x. Rep (QualStmt l) x -> QualStmt l
forall l x. QualStmt l -> Rep (QualStmt l) x
$cfrom :: forall l x. QualStmt l -> Rep (QualStmt l) x
from :: forall x. QualStmt l -> Rep (QualStmt l) x
$cto :: forall l x. Rep (QualStmt l) x -> QualStmt l
to :: forall x. Rep (QualStmt l) x -> QualStmt l
Generic)

-- | An /fbind/ in a labeled construction or update expression.
data FieldUpdate l
    = FieldUpdate l (QName l) (Exp l)    -- ^ ordinary label-expresion pair
    | FieldPun l (QName l)               -- ^ record field pun
    | FieldWildcard l                    -- ^ record field wildcard
  deriving (FieldUpdate l -> FieldUpdate l -> Bool
(FieldUpdate l -> FieldUpdate l -> Bool)
-> (FieldUpdate l -> FieldUpdate l -> Bool) -> Eq (FieldUpdate l)
forall l. Eq l => FieldUpdate l -> FieldUpdate l -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall l. Eq l => FieldUpdate l -> FieldUpdate l -> Bool
== :: FieldUpdate l -> FieldUpdate l -> Bool
$c/= :: forall l. Eq l => FieldUpdate l -> FieldUpdate l -> Bool
/= :: FieldUpdate l -> FieldUpdate l -> Bool
Eq,Eq (FieldUpdate l)
Eq (FieldUpdate l) =>
(FieldUpdate l -> FieldUpdate l -> Ordering)
-> (FieldUpdate l -> FieldUpdate l -> Bool)
-> (FieldUpdate l -> FieldUpdate l -> Bool)
-> (FieldUpdate l -> FieldUpdate l -> Bool)
-> (FieldUpdate l -> FieldUpdate l -> Bool)
-> (FieldUpdate l -> FieldUpdate l -> FieldUpdate l)
-> (FieldUpdate l -> FieldUpdate l -> FieldUpdate l)
-> Ord (FieldUpdate l)
FieldUpdate l -> FieldUpdate l -> Bool
FieldUpdate l -> FieldUpdate l -> Ordering
FieldUpdate l -> FieldUpdate l -> FieldUpdate l
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall l. Ord l => Eq (FieldUpdate l)
forall l. Ord l => FieldUpdate l -> FieldUpdate l -> Bool
forall l. Ord l => FieldUpdate l -> FieldUpdate l -> Ordering
forall l. Ord l => FieldUpdate l -> FieldUpdate l -> FieldUpdate l
$ccompare :: forall l. Ord l => FieldUpdate l -> FieldUpdate l -> Ordering
compare :: FieldUpdate l -> FieldUpdate l -> Ordering
$c< :: forall l. Ord l => FieldUpdate l -> FieldUpdate l -> Bool
< :: FieldUpdate l -> FieldUpdate l -> Bool
$c<= :: forall l. Ord l => FieldUpdate l -> FieldUpdate l -> Bool
<= :: FieldUpdate l -> FieldUpdate l -> Bool
$c> :: forall l. Ord l => FieldUpdate l -> FieldUpdate l -> Bool
> :: FieldUpdate l -> FieldUpdate l -> Bool
$c>= :: forall l. Ord l => FieldUpdate l -> FieldUpdate l -> Bool
>= :: FieldUpdate l -> FieldUpdate l -> Bool
$cmax :: forall l. Ord l => FieldUpdate l -> FieldUpdate l -> FieldUpdate l
max :: FieldUpdate l -> FieldUpdate l -> FieldUpdate l
$cmin :: forall l. Ord l => FieldUpdate l -> FieldUpdate l -> FieldUpdate l
min :: FieldUpdate l -> FieldUpdate l -> FieldUpdate l
Ord,Int -> FieldUpdate l -> ShowS
[FieldUpdate l] -> ShowS
FieldUpdate l -> String
(Int -> FieldUpdate l -> ShowS)
-> (FieldUpdate l -> String)
-> ([FieldUpdate l] -> ShowS)
-> Show (FieldUpdate l)
forall l. Show l => Int -> FieldUpdate l -> ShowS
forall l. Show l => [FieldUpdate l] -> ShowS
forall l. Show l => FieldUpdate l -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall l. Show l => Int -> FieldUpdate l -> ShowS
showsPrec :: Int -> FieldUpdate l -> ShowS
$cshow :: forall l. Show l => FieldUpdate l -> String
show :: FieldUpdate l -> String
$cshowList :: forall l. Show l => [FieldUpdate l] -> ShowS
showList :: [FieldUpdate l] -> ShowS
Show,Typeable,Typeable (FieldUpdate l)
Typeable (FieldUpdate l) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> FieldUpdate l -> c (FieldUpdate l))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (FieldUpdate l))
-> (FieldUpdate l -> Constr)
-> (FieldUpdate l -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (FieldUpdate l)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (FieldUpdate l)))
-> ((forall b. Data b => b -> b) -> FieldUpdate l -> FieldUpdate l)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> FieldUpdate l -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> FieldUpdate l -> r)
-> (forall u. (forall d. Data d => d -> u) -> FieldUpdate l -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> FieldUpdate l -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> FieldUpdate l -> m (FieldUpdate l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> FieldUpdate l -> m (FieldUpdate l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> FieldUpdate l -> m (FieldUpdate l))
-> Data (FieldUpdate l)
FieldUpdate l -> Constr
FieldUpdate l -> DataType
(forall b. Data b => b -> b) -> FieldUpdate l -> FieldUpdate l
forall l. Data l => Typeable (FieldUpdate l)
forall l. Data l => FieldUpdate l -> Constr
forall l. Data l => FieldUpdate l -> DataType
forall l.
Data l =>
(forall b. Data b => b -> b) -> FieldUpdate l -> FieldUpdate l
forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> FieldUpdate l -> u
forall l u.
Data l =>
(forall d. Data d => d -> u) -> FieldUpdate l -> [u]
forall l r r'.
Data l =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FieldUpdate l -> r
forall l r r'.
Data l =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FieldUpdate l -> r
forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d)
-> FieldUpdate l -> m (FieldUpdate l)
forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> FieldUpdate l -> m (FieldUpdate l)
forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (FieldUpdate l)
forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FieldUpdate l -> c (FieldUpdate l)
forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (FieldUpdate l))
forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (FieldUpdate l))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> FieldUpdate l -> u
forall u. (forall d. Data d => d -> u) -> FieldUpdate l -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FieldUpdate l -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FieldUpdate l -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> FieldUpdate l -> m (FieldUpdate l)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> FieldUpdate l -> m (FieldUpdate l)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (FieldUpdate l)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FieldUpdate l -> c (FieldUpdate l)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (FieldUpdate l))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (FieldUpdate l))
$cgfoldl :: forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FieldUpdate l -> c (FieldUpdate l)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FieldUpdate l -> c (FieldUpdate l)
$cgunfold :: forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (FieldUpdate l)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (FieldUpdate l)
$ctoConstr :: forall l. Data l => FieldUpdate l -> Constr
toConstr :: FieldUpdate l -> Constr
$cdataTypeOf :: forall l. Data l => FieldUpdate l -> DataType
dataTypeOf :: FieldUpdate l -> DataType
$cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (FieldUpdate l))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (FieldUpdate l))
$cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (FieldUpdate l))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (FieldUpdate l))
$cgmapT :: forall l.
Data l =>
(forall b. Data b => b -> b) -> FieldUpdate l -> FieldUpdate l
gmapT :: (forall b. Data b => b -> b) -> FieldUpdate l -> FieldUpdate l
$cgmapQl :: forall l r r'.
Data l =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FieldUpdate l -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FieldUpdate l -> r
$cgmapQr :: forall l r r'.
Data l =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FieldUpdate l -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FieldUpdate l -> r
$cgmapQ :: forall l u.
Data l =>
(forall d. Data d => d -> u) -> FieldUpdate l -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> FieldUpdate l -> [u]
$cgmapQi :: forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> FieldUpdate l -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> FieldUpdate l -> u
$cgmapM :: forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d)
-> FieldUpdate l -> m (FieldUpdate l)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> FieldUpdate l -> m (FieldUpdate l)
$cgmapMp :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> FieldUpdate l -> m (FieldUpdate l)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> FieldUpdate l -> m (FieldUpdate l)
$cgmapMo :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> FieldUpdate l -> m (FieldUpdate l)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> FieldUpdate l -> m (FieldUpdate l)
Data,(forall m. Monoid m => FieldUpdate m -> m)
-> (forall m a. Monoid m => (a -> m) -> FieldUpdate a -> m)
-> (forall m a. Monoid m => (a -> m) -> FieldUpdate a -> m)
-> (forall a b. (a -> b -> b) -> b -> FieldUpdate a -> b)
-> (forall a b. (a -> b -> b) -> b -> FieldUpdate a -> b)
-> (forall b a. (b -> a -> b) -> b -> FieldUpdate a -> b)
-> (forall b a. (b -> a -> b) -> b -> FieldUpdate a -> b)
-> (forall a. (a -> a -> a) -> FieldUpdate a -> a)
-> (forall a. (a -> a -> a) -> FieldUpdate a -> a)
-> (forall a. FieldUpdate a -> [a])
-> (forall a. FieldUpdate a -> Bool)
-> (forall a. FieldUpdate a -> Int)
-> (forall a. Eq a => a -> FieldUpdate a -> Bool)
-> (forall a. Ord a => FieldUpdate a -> a)
-> (forall a. Ord a => FieldUpdate a -> a)
-> (forall a. Num a => FieldUpdate a -> a)
-> (forall a. Num a => FieldUpdate a -> a)
-> Foldable FieldUpdate
forall a. Eq a => a -> FieldUpdate a -> Bool
forall a. Num a => FieldUpdate a -> a
forall a. Ord a => FieldUpdate a -> a
forall m. Monoid m => FieldUpdate m -> m
forall a. FieldUpdate a -> Bool
forall a. FieldUpdate a -> Int
forall a. FieldUpdate a -> [a]
forall a. (a -> a -> a) -> FieldUpdate a -> a
forall m a. Monoid m => (a -> m) -> FieldUpdate a -> m
forall b a. (b -> a -> b) -> b -> FieldUpdate a -> b
forall a b. (a -> b -> b) -> b -> FieldUpdate a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall m. Monoid m => FieldUpdate m -> m
fold :: forall m. Monoid m => FieldUpdate m -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> FieldUpdate a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> FieldUpdate a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> FieldUpdate a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> FieldUpdate a -> m
$cfoldr :: forall a b. (a -> b -> b) -> b -> FieldUpdate a -> b
foldr :: forall a b. (a -> b -> b) -> b -> FieldUpdate a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> FieldUpdate a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> FieldUpdate a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> FieldUpdate a -> b
foldl :: forall b a. (b -> a -> b) -> b -> FieldUpdate a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> FieldUpdate a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> FieldUpdate a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> FieldUpdate a -> a
foldr1 :: forall a. (a -> a -> a) -> FieldUpdate a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> FieldUpdate a -> a
foldl1 :: forall a. (a -> a -> a) -> FieldUpdate a -> a
$ctoList :: forall a. FieldUpdate a -> [a]
toList :: forall a. FieldUpdate a -> [a]
$cnull :: forall a. FieldUpdate a -> Bool
null :: forall a. FieldUpdate a -> Bool
$clength :: forall a. FieldUpdate a -> Int
length :: forall a. FieldUpdate a -> Int
$celem :: forall a. Eq a => a -> FieldUpdate a -> Bool
elem :: forall a. Eq a => a -> FieldUpdate a -> Bool
$cmaximum :: forall a. Ord a => FieldUpdate a -> a
maximum :: forall a. Ord a => FieldUpdate a -> a
$cminimum :: forall a. Ord a => FieldUpdate a -> a
minimum :: forall a. Ord a => FieldUpdate a -> a
$csum :: forall a. Num a => FieldUpdate a -> a
sum :: forall a. Num a => FieldUpdate a -> a
$cproduct :: forall a. Num a => FieldUpdate a -> a
product :: forall a. Num a => FieldUpdate a -> a
Foldable,Functor FieldUpdate
Foldable FieldUpdate
(Functor FieldUpdate, Foldable FieldUpdate) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> FieldUpdate a -> f (FieldUpdate b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    FieldUpdate (f a) -> f (FieldUpdate a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> FieldUpdate a -> m (FieldUpdate b))
-> (forall (m :: * -> *) a.
    Monad m =>
    FieldUpdate (m a) -> m (FieldUpdate a))
-> Traversable FieldUpdate
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a.
Monad m =>
FieldUpdate (m a) -> m (FieldUpdate a)
forall (f :: * -> *) a.
Applicative f =>
FieldUpdate (f a) -> f (FieldUpdate a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> FieldUpdate a -> m (FieldUpdate b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> FieldUpdate a -> f (FieldUpdate b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> FieldUpdate a -> f (FieldUpdate b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> FieldUpdate a -> f (FieldUpdate b)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
FieldUpdate (f a) -> f (FieldUpdate a)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
FieldUpdate (f a) -> f (FieldUpdate a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> FieldUpdate a -> m (FieldUpdate b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> FieldUpdate a -> m (FieldUpdate b)
$csequence :: forall (m :: * -> *) a.
Monad m =>
FieldUpdate (m a) -> m (FieldUpdate a)
sequence :: forall (m :: * -> *) a.
Monad m =>
FieldUpdate (m a) -> m (FieldUpdate a)
Traversable,(forall a b. (a -> b) -> FieldUpdate a -> FieldUpdate b)
-> (forall a b. a -> FieldUpdate b -> FieldUpdate a)
-> Functor FieldUpdate
forall a b. a -> FieldUpdate b -> FieldUpdate a
forall a b. (a -> b) -> FieldUpdate a -> FieldUpdate b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> FieldUpdate a -> FieldUpdate b
fmap :: forall a b. (a -> b) -> FieldUpdate a -> FieldUpdate b
$c<$ :: forall a b. a -> FieldUpdate b -> FieldUpdate a
<$ :: forall a b. a -> FieldUpdate b -> FieldUpdate a
Functor,(forall x. FieldUpdate l -> Rep (FieldUpdate l) x)
-> (forall x. Rep (FieldUpdate l) x -> FieldUpdate l)
-> Generic (FieldUpdate l)
forall x. Rep (FieldUpdate l) x -> FieldUpdate l
forall x. FieldUpdate l -> Rep (FieldUpdate l) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall l x. Rep (FieldUpdate l) x -> FieldUpdate l
forall l x. FieldUpdate l -> Rep (FieldUpdate l) x
$cfrom :: forall l x. FieldUpdate l -> Rep (FieldUpdate l) x
from :: forall x. FieldUpdate l -> Rep (FieldUpdate l) x
$cto :: forall l x. Rep (FieldUpdate l) x -> FieldUpdate l
to :: forall x. Rep (FieldUpdate l) x -> FieldUpdate l
Generic)

-- | An /alt/ alternative in a @case@ expression.
data Alt l
    = Alt l (Pat l) (Rhs l) (Maybe (Binds l))
  deriving (Alt l -> Alt l -> Bool
(Alt l -> Alt l -> Bool) -> (Alt l -> Alt l -> Bool) -> Eq (Alt l)
forall l. Eq l => Alt l -> Alt l -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall l. Eq l => Alt l -> Alt l -> Bool
== :: Alt l -> Alt l -> Bool
$c/= :: forall l. Eq l => Alt l -> Alt l -> Bool
/= :: Alt l -> Alt l -> Bool
Eq,Eq (Alt l)
Eq (Alt l) =>
(Alt l -> Alt l -> Ordering)
-> (Alt l -> Alt l -> Bool)
-> (Alt l -> Alt l -> Bool)
-> (Alt l -> Alt l -> Bool)
-> (Alt l -> Alt l -> Bool)
-> (Alt l -> Alt l -> Alt l)
-> (Alt l -> Alt l -> Alt l)
-> Ord (Alt l)
Alt l -> Alt l -> Bool
Alt l -> Alt l -> Ordering
Alt l -> Alt l -> Alt l
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall l. Ord l => Eq (Alt l)
forall l. Ord l => Alt l -> Alt l -> Bool
forall l. Ord l => Alt l -> Alt l -> Ordering
forall l. Ord l => Alt l -> Alt l -> Alt l
$ccompare :: forall l. Ord l => Alt l -> Alt l -> Ordering
compare :: Alt l -> Alt l -> Ordering
$c< :: forall l. Ord l => Alt l -> Alt l -> Bool
< :: Alt l -> Alt l -> Bool
$c<= :: forall l. Ord l => Alt l -> Alt l -> Bool
<= :: Alt l -> Alt l -> Bool
$c> :: forall l. Ord l => Alt l -> Alt l -> Bool
> :: Alt l -> Alt l -> Bool
$c>= :: forall l. Ord l => Alt l -> Alt l -> Bool
>= :: Alt l -> Alt l -> Bool
$cmax :: forall l. Ord l => Alt l -> Alt l -> Alt l
max :: Alt l -> Alt l -> Alt l
$cmin :: forall l. Ord l => Alt l -> Alt l -> Alt l
min :: Alt l -> Alt l -> Alt l
Ord,Int -> Alt l -> ShowS
[Alt l] -> ShowS
Alt l -> String
(Int -> Alt l -> ShowS)
-> (Alt l -> String) -> ([Alt l] -> ShowS) -> Show (Alt l)
forall l. Show l => Int -> Alt l -> ShowS
forall l. Show l => [Alt l] -> ShowS
forall l. Show l => Alt l -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall l. Show l => Int -> Alt l -> ShowS
showsPrec :: Int -> Alt l -> ShowS
$cshow :: forall l. Show l => Alt l -> String
show :: Alt l -> String
$cshowList :: forall l. Show l => [Alt l] -> ShowS
showList :: [Alt l] -> ShowS
Show,Typeable,Typeable (Alt l)
Typeable (Alt l) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Alt l -> c (Alt l))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Alt l))
-> (Alt l -> Constr)
-> (Alt l -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Alt l)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Alt l)))
-> ((forall b. Data b => b -> b) -> Alt l -> Alt l)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Alt l -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Alt l -> r)
-> (forall u. (forall d. Data d => d -> u) -> Alt l -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Alt l -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Alt l -> m (Alt l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Alt l -> m (Alt l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Alt l -> m (Alt l))
-> Data (Alt l)
Alt l -> Constr
Alt l -> DataType
(forall b. Data b => b -> b) -> Alt l -> Alt l
forall l. Data l => Typeable (Alt l)
forall l. Data l => Alt l -> Constr
forall l. Data l => Alt l -> DataType
forall l. Data l => (forall b. Data b => b -> b) -> Alt l -> Alt l
forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> Alt l -> u
forall l u. Data l => (forall d. Data d => d -> u) -> Alt l -> [u]
forall l r r'.
Data l =>
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Alt l -> r
forall l r r'.
Data l =>
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Alt l -> r
forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d) -> Alt l -> m (Alt l)
forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Alt l -> m (Alt l)
forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Alt l)
forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Alt l -> c (Alt l)
forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Alt l))
forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Alt l))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Alt l -> u
forall u. (forall d. Data d => d -> u) -> Alt l -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Alt l -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Alt l -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Alt l -> m (Alt l)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Alt l -> m (Alt l)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Alt l)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Alt l -> c (Alt l)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Alt l))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Alt l))
$cgfoldl :: forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Alt l -> c (Alt l)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Alt l -> c (Alt l)
$cgunfold :: forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Alt l)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Alt l)
$ctoConstr :: forall l. Data l => Alt l -> Constr
toConstr :: Alt l -> Constr
$cdataTypeOf :: forall l. Data l => Alt l -> DataType
dataTypeOf :: Alt l -> DataType
$cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Alt l))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Alt l))
$cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Alt l))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Alt l))
$cgmapT :: forall l. Data l => (forall b. Data b => b -> b) -> Alt l -> Alt l
gmapT :: (forall b. Data b => b -> b) -> Alt l -> Alt l
$cgmapQl :: forall l r r'.
Data l =>
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Alt l -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Alt l -> r
$cgmapQr :: forall l r r'.
Data l =>
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Alt l -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Alt l -> r
$cgmapQ :: forall l u. Data l => (forall d. Data d => d -> u) -> Alt l -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Alt l -> [u]
$cgmapQi :: forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> Alt l -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Alt l -> u
$cgmapM :: forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d) -> Alt l -> m (Alt l)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Alt l -> m (Alt l)
$cgmapMp :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Alt l -> m (Alt l)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Alt l -> m (Alt l)
$cgmapMo :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Alt l -> m (Alt l)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Alt l -> m (Alt l)
Data,(forall m. Monoid m => Alt m -> m)
-> (forall m a. Monoid m => (a -> m) -> Alt a -> m)
-> (forall m a. Monoid m => (a -> m) -> Alt a -> m)
-> (forall a b. (a -> b -> b) -> b -> Alt a -> b)
-> (forall a b. (a -> b -> b) -> b -> Alt a -> b)
-> (forall b a. (b -> a -> b) -> b -> Alt a -> b)
-> (forall b a. (b -> a -> b) -> b -> Alt a -> b)
-> (forall a. (a -> a -> a) -> Alt a -> a)
-> (forall a. (a -> a -> a) -> Alt a -> a)
-> (forall a. Alt a -> [a])
-> (forall a. Alt a -> Bool)
-> (forall a. Alt a -> Int)
-> (forall a. Eq a => a -> Alt a -> Bool)
-> (forall a. Ord a => Alt a -> a)
-> (forall a. Ord a => Alt a -> a)
-> (forall a. Num a => Alt a -> a)
-> (forall a. Num a => Alt a -> a)
-> Foldable Alt
forall a. Eq a => a -> Alt a -> Bool
forall a. Num a => Alt a -> a
forall a. Ord a => Alt a -> a
forall m. Monoid m => Alt m -> m
forall a. Alt a -> Bool
forall a. Alt a -> Int
forall a. Alt a -> [a]
forall a. (a -> a -> a) -> Alt a -> a
forall m a. Monoid m => (a -> m) -> Alt a -> m
forall b a. (b -> a -> b) -> b -> Alt a -> b
forall a b. (a -> b -> b) -> b -> Alt a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall m. Monoid m => Alt m -> m
fold :: forall m. Monoid m => Alt m -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> Alt a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> Alt a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> Alt a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> Alt a -> m
$cfoldr :: forall a b. (a -> b -> b) -> b -> Alt a -> b
foldr :: forall a b. (a -> b -> b) -> b -> Alt a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> Alt a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> Alt a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> Alt a -> b
foldl :: forall b a. (b -> a -> b) -> b -> Alt a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> Alt a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> Alt a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> Alt a -> a
foldr1 :: forall a. (a -> a -> a) -> Alt a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> Alt a -> a
foldl1 :: forall a. (a -> a -> a) -> Alt a -> a
$ctoList :: forall a. Alt a -> [a]
toList :: forall a. Alt a -> [a]
$cnull :: forall a. Alt a -> Bool
null :: forall a. Alt a -> Bool
$clength :: forall a. Alt a -> Int
length :: forall a. Alt a -> Int
$celem :: forall a. Eq a => a -> Alt a -> Bool
elem :: forall a. Eq a => a -> Alt a -> Bool
$cmaximum :: forall a. Ord a => Alt a -> a
maximum :: forall a. Ord a => Alt a -> a
$cminimum :: forall a. Ord a => Alt a -> a
minimum :: forall a. Ord a => Alt a -> a
$csum :: forall a. Num a => Alt a -> a
sum :: forall a. Num a => Alt a -> a
$cproduct :: forall a. Num a => Alt a -> a
product :: forall a. Num a => Alt a -> a
Foldable,Functor Alt
Foldable Alt
(Functor Alt, Foldable Alt) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> Alt a -> f (Alt b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    Alt (f a) -> f (Alt a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Alt a -> m (Alt b))
-> (forall (m :: * -> *) a. Monad m => Alt (m a) -> m (Alt a))
-> Traversable Alt
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a. Monad m => Alt (m a) -> m (Alt a)
forall (f :: * -> *) a. Applicative f => Alt (f a) -> f (Alt a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Alt a -> m (Alt b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Alt a -> f (Alt b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Alt a -> f (Alt b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Alt a -> f (Alt b)
$csequenceA :: forall (f :: * -> *) a. Applicative f => Alt (f a) -> f (Alt a)
sequenceA :: forall (f :: * -> *) a. Applicative f => Alt (f a) -> f (Alt a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Alt a -> m (Alt b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Alt a -> m (Alt b)
$csequence :: forall (m :: * -> *) a. Monad m => Alt (m a) -> m (Alt a)
sequence :: forall (m :: * -> *) a. Monad m => Alt (m a) -> m (Alt a)
Traversable,(forall a b. (a -> b) -> Alt a -> Alt b)
-> (forall a b. a -> Alt b -> Alt a) -> Functor Alt
forall a b. a -> Alt b -> Alt a
forall a b. (a -> b) -> Alt a -> Alt b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> Alt a -> Alt b
fmap :: forall a b. (a -> b) -> Alt a -> Alt b
$c<$ :: forall a b. a -> Alt b -> Alt a
<$ :: forall a b. a -> Alt b -> Alt a
Functor,(forall x. Alt l -> Rep (Alt l) x)
-> (forall x. Rep (Alt l) x -> Alt l) -> Generic (Alt l)
forall x. Rep (Alt l) x -> Alt l
forall x. Alt l -> Rep (Alt l) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall l x. Rep (Alt l) x -> Alt l
forall l x. Alt l -> Rep (Alt l) x
$cfrom :: forall l x. Alt l -> Rep (Alt l) x
from :: forall x. Alt l -> Rep (Alt l) x
$cto :: forall l x. Rep (Alt l) x -> Alt l
to :: forall x. Rep (Alt l) x -> Alt l
Generic)

-----------------------------------------------------------------------------
-- Builtin names.

prelude_mod, main_mod :: l -> ModuleName l
prelude_mod :: forall l. l -> ModuleName l
prelude_mod l
l = l -> String -> ModuleName l
forall l. l -> String -> ModuleName l
ModuleName l
l String
"Prelude"
main_mod :: forall l. l -> ModuleName l
main_mod    l
l = l -> String -> ModuleName l
forall l. l -> String -> ModuleName l
ModuleName l
l String
"Main"

main_name :: l -> Name l
main_name :: forall l. l -> Name l
main_name l
l = l -> String -> Name l
forall l. l -> String -> Name l
Ident l
l String
"main"

unit_con_name :: l -> QName l
unit_con_name :: forall l. l -> QName l
unit_con_name l
l = l -> SpecialCon l -> QName l
forall l. l -> SpecialCon l -> QName l
Special l
l (l -> SpecialCon l
forall l. l -> SpecialCon l
UnitCon l
l)

tuple_con_name :: l -> Boxed -> Int -> QName l
tuple_con_name :: forall l. l -> Boxed -> Int -> QName l
tuple_con_name l
l Boxed
b Int
i = l -> SpecialCon l -> QName l
forall l. l -> SpecialCon l -> QName l
Special l
l (l -> Boxed -> Int -> SpecialCon l
forall l. l -> Boxed -> Int -> SpecialCon l
TupleCon l
l Boxed
b (Int
iInt -> Int -> Int
forall a. Num a => a -> a -> a
+Int
1))

list_con_name :: l -> QName l
list_con_name :: forall l. l -> QName l
list_con_name l
l = l -> SpecialCon l -> QName l
forall l. l -> SpecialCon l -> QName l
Special l
l (l -> SpecialCon l
forall l. l -> SpecialCon l
ListCon l
l)

list_cons_name :: l -> QName l
list_cons_name :: forall l. l -> QName l
list_cons_name l
l = l -> SpecialCon l -> QName l
forall l. l -> SpecialCon l -> QName l
Special l
l (l -> SpecialCon l
forall l. l -> SpecialCon l
Cons l
l)

unboxed_singleton_con_name :: l -> QName l
unboxed_singleton_con_name :: forall l. l -> QName l
unboxed_singleton_con_name l
l = l -> SpecialCon l -> QName l
forall l. l -> SpecialCon l -> QName l
Special l
l (l -> SpecialCon l
forall l. l -> SpecialCon l
UnboxedSingleCon l
l)

unit_con :: l -> Exp l
unit_con :: forall l. l -> Exp l
unit_con l
l = l -> QName l -> Exp l
forall l. l -> QName l -> Exp l
Con l
l (QName l -> Exp l) -> QName l -> Exp l
forall a b. (a -> b) -> a -> b
$ l -> QName l
forall l. l -> QName l
unit_con_name l
l

tuple_con :: l -> Boxed -> Int -> Exp l
tuple_con :: forall l. l -> Boxed -> Int -> Exp l
tuple_con l
l Boxed
b Int
i = l -> QName l -> Exp l
forall l. l -> QName l -> Exp l
Con l
l (l -> Boxed -> Int -> QName l
forall l. l -> Boxed -> Int -> QName l
tuple_con_name l
l Boxed
b Int
i)

unboxed_singleton_con :: l -> Exp l
unboxed_singleton_con :: forall l. l -> Exp l
unboxed_singleton_con l
l = l -> QName l -> Exp l
forall l. l -> QName l -> Exp l
Con l
l (l -> QName l
forall l. l -> QName l
unboxed_singleton_con_name l
l)

as_name, qualified_name, hiding_name, minus_name, bang_name, dot_name, star_name :: l -> Name l
as_name :: forall l. l -> Name l
as_name        l
l = l -> String -> Name l
forall l. l -> String -> Name l
Ident  l
l String
"as"
qualified_name :: forall l. l -> Name l
qualified_name l
l = l -> String -> Name l
forall l. l -> String -> Name l
Ident  l
l String
"qualified"
hiding_name :: forall l. l -> Name l
hiding_name    l
l = l -> String -> Name l
forall l. l -> String -> Name l
Ident  l
l String
"hiding"
minus_name :: forall l. l -> Name l
minus_name     l
l = l -> String -> Name l
forall l. l -> String -> Name l
Symbol l
l String
"-"
bang_name :: forall l. l -> Name l
bang_name      l
l = l -> String -> Name l
forall l. l -> String -> Name l
Symbol l
l String
"!"
dot_name :: forall l. l -> Name l
dot_name       l
l = l -> String -> Name l
forall l. l -> String -> Name l
Symbol l
l String
"."
star_name :: forall l. l -> Name l
star_name      l
l = l -> String -> Name l
forall l. l -> String -> Name l
Symbol l
l String
"*"

hole_name :: l -> QName l
hole_name :: forall l. l -> QName l
hole_name      l
l = l -> SpecialCon l -> QName l
forall l. l -> SpecialCon l -> QName l
Special l
l (l -> SpecialCon l
forall l. l -> SpecialCon l
ExprHole l
l)

export_name, safe_name, unsafe_name, interruptible_name, threadsafe_name,
  stdcall_name, ccall_name, cplusplus_name, dotnet_name,
  jvm_name, js_name, javascript_name, capi_name, forall_name,
  family_name, role_name, stock_name, anyclass_name, via_name :: l -> Name l
export_name :: forall l. l -> Name l
export_name     l
l = l -> String -> Name l
forall l. l -> String -> Name l
Ident l
l String
"export"
safe_name :: forall l. l -> Name l
safe_name       l
l = l -> String -> Name l
forall l. l -> String -> Name l
Ident l
l String
"safe"
unsafe_name :: forall l. l -> Name l
unsafe_name     l
l = l -> String -> Name l
forall l. l -> String -> Name l
Ident l
l String
"unsafe"
interruptible_name :: forall l. l -> Name l
interruptible_name l
l = l -> String -> Name l
forall l. l -> String -> Name l
Ident l
l String
"interruptible"
threadsafe_name :: forall l. l -> Name l
threadsafe_name l
l = l -> String -> Name l
forall l. l -> String -> Name l
Ident l
l String
"threadsafe"
stdcall_name :: forall l. l -> Name l
stdcall_name    l
l = l -> String -> Name l
forall l. l -> String -> Name l
Ident l
l String
"stdcall"
ccall_name :: forall l. l -> Name l
ccall_name      l
l = l -> String -> Name l
forall l. l -> String -> Name l
Ident l
l String
"ccall"
cplusplus_name :: forall l. l -> Name l
cplusplus_name  l
l = l -> String -> Name l
forall l. l -> String -> Name l
Ident l
l String
"cplusplus"
dotnet_name :: forall l. l -> Name l
dotnet_name     l
l = l -> String -> Name l
forall l. l -> String -> Name l
Ident l
l String
"dotnet"
jvm_name :: forall l. l -> Name l
jvm_name        l
l = l -> String -> Name l
forall l. l -> String -> Name l
Ident l
l String
"jvm"
js_name :: forall l. l -> Name l
js_name         l
l = l -> String -> Name l
forall l. l -> String -> Name l
Ident l
l String
"js"
javascript_name :: forall l. l -> Name l
javascript_name l
l = l -> String -> Name l
forall l. l -> String -> Name l
Ident l
l String
"javascript"
capi_name :: forall l. l -> Name l
capi_name       l
l = l -> String -> Name l
forall l. l -> String -> Name l
Ident l
l String
"capi"
forall_name :: forall l. l -> Name l
forall_name     l
l = l -> String -> Name l
forall l. l -> String -> Name l
Ident l
l String
"forall"
family_name :: forall l. l -> Name l
family_name     l
l = l -> String -> Name l
forall l. l -> String -> Name l
Ident l
l String
"family"
role_name :: forall l. l -> Name l
role_name       l
l = l -> String -> Name l
forall l. l -> String -> Name l
Ident l
l String
"role"
stock_name :: forall l. l -> Name l
stock_name      l
l = l -> String -> Name l
forall l. l -> String -> Name l
Ident l
l String
"stock"
anyclass_name :: forall l. l -> Name l
anyclass_name   l
l = l -> String -> Name l
forall l. l -> String -> Name l
Ident l
l String
"anyclass"
via_name :: forall l. l -> Name l
via_name        l
l = l -> String -> Name l
forall l. l -> String -> Name l
Ident l
l String
"via"

unit_tycon_name, fun_tycon_name, list_tycon_name, unboxed_singleton_tycon_name :: l -> QName l
unit_tycon_name :: forall l. l -> QName l
unit_tycon_name l
l = l -> QName l
forall l. l -> QName l
unit_con_name l
l
fun_tycon_name :: forall l. l -> QName l
fun_tycon_name  l
l = l -> SpecialCon l -> QName l
forall l. l -> SpecialCon l -> QName l
Special l
l (l -> SpecialCon l
forall l. l -> SpecialCon l
FunCon l
l)
list_tycon_name :: forall l. l -> QName l
list_tycon_name l
l = l -> SpecialCon l -> QName l
forall l. l -> SpecialCon l -> QName l
Special l
l (l -> SpecialCon l
forall l. l -> SpecialCon l
ListCon l
l)
unboxed_singleton_tycon_name :: forall l. l -> QName l
unboxed_singleton_tycon_name l
l = l -> SpecialCon l -> QName l
forall l. l -> SpecialCon l -> QName l
Special l
l (l -> SpecialCon l
forall l. l -> SpecialCon l
UnboxedSingleCon l
l)

tuple_tycon_name :: l -> Boxed -> Int -> QName l
tuple_tycon_name :: forall l. l -> Boxed -> Int -> QName l
tuple_tycon_name l
l Boxed
b Int
i = l -> Boxed -> Int -> QName l
forall l. l -> Boxed -> Int -> QName l
tuple_con_name l
l Boxed
b Int
i

unit_tycon, fun_tycon, list_tycon, unboxed_singleton_tycon :: l -> Type l
unit_tycon :: forall l. l -> Type l
unit_tycon l
l = l -> QName l -> Type l
forall l. l -> QName l -> Type l
TyCon l
l (QName l -> Type l) -> QName l -> Type l
forall a b. (a -> b) -> a -> b
$ l -> QName l
forall l. l -> QName l
unit_tycon_name l
l
fun_tycon :: forall l. l -> Type l
fun_tycon  l
l = l -> QName l -> Type l
forall l. l -> QName l -> Type l
TyCon l
l (QName l -> Type l) -> QName l -> Type l
forall a b. (a -> b) -> a -> b
$ l -> QName l
forall l. l -> QName l
fun_tycon_name  l
l
list_tycon :: forall l. l -> Type l
list_tycon l
l = l -> QName l -> Type l
forall l. l -> QName l -> Type l
TyCon l
l (QName l -> Type l) -> QName l -> Type l
forall a b. (a -> b) -> a -> b
$ l -> QName l
forall l. l -> QName l
list_tycon_name l
l
unboxed_singleton_tycon :: forall l. l -> Type l
unboxed_singleton_tycon l
l = l -> QName l -> Type l
forall l. l -> QName l -> Type l
TyCon l
l (QName l -> Type l) -> QName l -> Type l
forall a b. (a -> b) -> a -> b
$ l -> QName l
forall l. l -> QName l
unboxed_singleton_tycon_name l
l

tuple_tycon :: l -> Boxed -> Int -> Type l
tuple_tycon :: forall l. l -> Boxed -> Int -> Type l
tuple_tycon l
l Boxed
b Int
i = l -> QName l -> Type l
forall l. l -> QName l -> Type l
TyCon l
l (l -> Boxed -> Int -> QName l
forall l. l -> Boxed -> Int -> QName l
tuple_tycon_name l
l Boxed
b Int
i)

-----------------------------------------------------------------------------
-- AST traversal, boiler-plate style

-- | Test if two AST elements are equal modulo annotations.
(=~=) :: (Annotated a, Eq (a ())) => a l1 -> a l2 -> Bool
a l1
a =~= :: forall (a :: * -> *) l1 l2.
(Annotated a, Eq (a ())) =>
a l1 -> a l2 -> Bool
=~= a l2
b = (l1 -> ()) -> a l1 -> a ()
forall a b. (a -> b) -> a a -> a b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (() -> l1 -> ()
forall a b. a -> b -> a
const ()) a l1
a a () -> a () -> Bool
forall a. Eq a => a -> a -> Bool
== (l2 -> ()) -> a l2 -> a ()
forall a b. (a -> b) -> a a -> a b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (() -> l2 -> ()
forall a b. a -> b -> a
const ()) a l2
b

-----------------------------------------------------------------------------
-- Reading annotations

-- | AST nodes are annotated, and this class allows manipulation of the annotations.
class Functor ast => Annotated ast where
    -- | Retrieve the annotation of an AST node.
    ann :: ast l -> l
    -- | Change the annotation of an AST node. Note that only the annotation of
    --   the node itself is affected, and not the annotations of any child nodes.
    --   if all nodes in the AST tree are to be affected, use 'fmap'.
    amap :: (l -> l) -> ast l -> ast l

instance Annotated ModuleName where
    ann :: forall l. ModuleName l -> l
ann (ModuleName l
l String
_) = l
l
    amap :: forall l. (l -> l) -> ModuleName l -> ModuleName l
amap l -> l
f (ModuleName l
l String
n) = l -> String -> ModuleName l
forall l. l -> String -> ModuleName l
ModuleName (l -> l
f l
l) String
n

instance Annotated SpecialCon where
    ann :: forall l. SpecialCon l -> l
ann SpecialCon l
sc = case SpecialCon l
sc of
        UnitCon l
l   -> l
l
        ListCon l
l   -> l
l
        FunCon  l
l   -> l
l
        TupleCon l
l Boxed
_ Int
_  -> l
l
        Cons l
l      -> l
l
        UnboxedSingleCon l
l  -> l
l
        ExprHole l
l  -> l
l
    amap :: forall l. (l -> l) -> SpecialCon l -> SpecialCon l
amap = (l -> l) -> SpecialCon l -> SpecialCon l
forall a b. (a -> b) -> SpecialCon a -> SpecialCon b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap

instance Annotated QName where
    ann :: forall l. QName l -> l
ann QName l
qn = case QName l
qn of
        Qual    l
l ModuleName l
_ Name l
_  -> l
l
        UnQual  l
l   Name l
_  -> l
l
        Special l
l SpecialCon l
_    -> l
l
    amap :: forall l. (l -> l) -> QName l -> QName l
amap l -> l
f QName l
qn = case QName l
qn of
        Qual    l
l ModuleName l
mn Name l
n  -> l -> ModuleName l -> Name l -> QName l
forall l. l -> ModuleName l -> Name l -> QName l
Qual    (l -> l
f l
l) ModuleName l
mn Name l
n
        UnQual  l
l    Name l
n  -> l -> Name l -> QName l
forall l. l -> Name l -> QName l
UnQual  (l -> l
f l
l)    Name l
n
        Special l
l SpecialCon l
sc    -> l -> SpecialCon l -> QName l
forall l. l -> SpecialCon l -> QName l
Special (l -> l
f l
l) SpecialCon l
sc

instance Annotated Name where
    ann :: forall l. Name l -> l
ann (Ident  l
l String
_) = l
l
    ann (Symbol l
l String
_) = l
l
    amap :: forall l. (l -> l) -> Name l -> Name l
amap = (l -> l) -> Name l -> Name l
forall a b. (a -> b) -> Name a -> Name b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap

instance Annotated IPName where
    ann :: forall l. IPName l -> l
ann (IPDup l
l String
_) = l
l
    ann (IPLin l
l String
_) = l
l
    amap :: forall l. (l -> l) -> IPName l -> IPName l
amap = (l -> l) -> IPName l -> IPName l
forall a b. (a -> b) -> IPName a -> IPName b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap

instance Annotated QOp where
    ann :: forall l. QOp l -> l
ann (QVarOp l
l QName l
_) = l
l
    ann (QConOp l
l QName l
_) = l
l
    amap :: forall l. (l -> l) -> QOp l -> QOp l
amap l -> l
f (QVarOp l
l QName l
qn) = l -> QName l -> QOp l
forall l. l -> QName l -> QOp l
QVarOp (l -> l
f l
l) QName l
qn
    amap l -> l
f (QConOp l
l QName l
qn) = l -> QName l -> QOp l
forall l. l -> QName l -> QOp l
QConOp (l -> l
f l
l) QName l
qn

instance Annotated Op where
    ann :: forall l. Op l -> l
ann (VarOp l
l Name l
_) = l
l
    ann (ConOp l
l Name l
_) = l
l
    amap :: forall l. (l -> l) -> Op l -> Op l
amap l -> l
f (VarOp l
l Name l
n) = l -> Name l -> Op l
forall l. l -> Name l -> Op l
VarOp (l -> l
f l
l) Name l
n
    amap l -> l
f (ConOp l
l Name l
n) = l -> Name l -> Op l
forall l. l -> Name l -> Op l
ConOp (l -> l
f l
l) Name l
n

instance Annotated CName where
    ann :: forall l. CName l -> l
ann (VarName l
l Name l
_) = l
l
    ann (ConName l
l Name l
_) = l
l
    amap :: forall l. (l -> l) -> CName l -> CName l
amap l -> l
f (VarName l
l Name l
n) = l -> Name l -> CName l
forall l. l -> Name l -> CName l
VarName (l -> l
f l
l) Name l
n
    amap l -> l
f (ConName l
l Name l
n) = l -> Name l -> CName l
forall l. l -> Name l -> CName l
ConName (l -> l
f l
l) Name l
n

instance Annotated Module where
    ann :: forall l. Module l -> l
ann (Module l
l Maybe (ModuleHead l)
_ [ModulePragma l]
_ [ImportDecl l]
_ [Decl l]
_)            = l
l
    ann (XmlPage l
l ModuleName l
_ [ModulePragma l]
_ XName l
_ [XAttr l]
_ Maybe (Exp l)
_ [Exp l]
_)       = l
l
    ann (XmlHybrid l
l Maybe (ModuleHead l)
_ [ModulePragma l]
_ [ImportDecl l]
_ [Decl l]
_ XName l
_ [XAttr l]
_ Maybe (Exp l)
_ [Exp l]
_) = l
l

    amap :: forall l. (l -> l) -> Module l -> Module l
amap l -> l
f (Module l
l Maybe (ModuleHead l)
mmh [ModulePragma l]
ops [ImportDecl l]
iss [Decl l]
dcls) =
        l
-> Maybe (ModuleHead l)
-> [ModulePragma l]
-> [ImportDecl l]
-> [Decl l]
-> Module l
forall l.
l
-> Maybe (ModuleHead l)
-> [ModulePragma l]
-> [ImportDecl l]
-> [Decl l]
-> Module l
Module (l -> l
f l
l) Maybe (ModuleHead l)
mmh [ModulePragma l]
ops [ImportDecl l]
iss [Decl l]
dcls
    amap l -> l
f (XmlPage l
l ModuleName l
mn [ModulePragma l]
os XName l
xn [XAttr l]
xas Maybe (Exp l)
me [Exp l]
es) =
        l
-> ModuleName l
-> [ModulePragma l]
-> XName l
-> [XAttr l]
-> Maybe (Exp l)
-> [Exp l]
-> Module l
forall l.
l
-> ModuleName l
-> [ModulePragma l]
-> XName l
-> [XAttr l]
-> Maybe (Exp l)
-> [Exp l]
-> Module l
XmlPage (l -> l
f l
l) ModuleName l
mn [ModulePragma l]
os XName l
xn [XAttr l]
xas Maybe (Exp l)
me [Exp l]
es
    amap l -> l
f (XmlHybrid l
l Maybe (ModuleHead l)
mmh [ModulePragma l]
ops [ImportDecl l]
iss [Decl l]
dcls XName l
xn [XAttr l]
xas Maybe (Exp l)
me [Exp l]
es) =
        l
-> Maybe (ModuleHead l)
-> [ModulePragma l]
-> [ImportDecl l]
-> [Decl l]
-> XName l
-> [XAttr l]
-> Maybe (Exp l)
-> [Exp l]
-> Module l
forall l.
l
-> Maybe (ModuleHead l)
-> [ModulePragma l]
-> [ImportDecl l]
-> [Decl l]
-> XName l
-> [XAttr l]
-> Maybe (Exp l)
-> [Exp l]
-> Module l
XmlHybrid (l -> l
f l
l) Maybe (ModuleHead l)
mmh [ModulePragma l]
ops [ImportDecl l]
iss [Decl l]
dcls XName l
xn [XAttr l]
xas Maybe (Exp l)
me [Exp l]
es

instance Annotated ModuleHead where
    ann :: forall l. ModuleHead l -> l
ann (ModuleHead l
l ModuleName l
_ Maybe (WarningText l)
_ Maybe (ExportSpecList l)
_)         = l
l
    amap :: forall l. (l -> l) -> ModuleHead l -> ModuleHead l
amap l -> l
f (ModuleHead l
l ModuleName l
n Maybe (WarningText l)
mwt Maybe (ExportSpecList l)
mesl) = l
-> ModuleName l
-> Maybe (WarningText l)
-> Maybe (ExportSpecList l)
-> ModuleHead l
forall l.
l
-> ModuleName l
-> Maybe (WarningText l)
-> Maybe (ExportSpecList l)
-> ModuleHead l
ModuleHead (l -> l
f l
l) ModuleName l
n Maybe (WarningText l)
mwt Maybe (ExportSpecList l)
mesl

instance Annotated ExportSpecList where
    ann :: forall l. ExportSpecList l -> l
ann (ExportSpecList l
l [ExportSpec l]
_)      = l
l
    amap :: forall l. (l -> l) -> ExportSpecList l -> ExportSpecList l
amap l -> l
f (ExportSpecList l
l [ExportSpec l]
ess) = l -> [ExportSpec l] -> ExportSpecList l
forall l. l -> [ExportSpec l] -> ExportSpecList l
ExportSpecList (l -> l
f l
l) [ExportSpec l]
ess

instance Annotated ExportSpec where
    ann :: forall l. ExportSpec l -> l
ann ExportSpec l
es = case ExportSpec l
es of
        EVar l
l QName l
_            -> l
l
        EAbs l
l Namespace l
_ QName l
_          -> l
l
        EThingWith l
l EWildcard l
_ QName l
_ [CName l]
_    -> l
l
        EModuleContents l
l ModuleName l
_ -> l
l
    amap :: forall l. (l -> l) -> ExportSpec l -> ExportSpec l
amap l -> l
f ExportSpec l
es = case ExportSpec l
es of
        EVar l
l QName l
qn     -> l -> QName l -> ExportSpec l
forall l. l -> QName l -> ExportSpec l
EVar (l -> l
f l
l) QName l
qn
        EAbs l
l Namespace l
n QName l
qn       -> l -> Namespace l -> QName l -> ExportSpec l
forall l. l -> Namespace l -> QName l -> ExportSpec l
EAbs (l -> l
f l
l) Namespace l
n QName l
qn
        EThingWith l
l EWildcard l
wc QName l
qn [CName l]
cns -> l -> EWildcard l -> QName l -> [CName l] -> ExportSpec l
forall l. l -> EWildcard l -> QName l -> [CName l] -> ExportSpec l
EThingWith (l -> l
f l
l) EWildcard l
wc QName l
qn [CName l]
cns
        EModuleContents l
l ModuleName l
mn    -> l -> ModuleName l -> ExportSpec l
forall l. l -> ModuleName l -> ExportSpec l
EModuleContents (l -> l
f l
l) ModuleName l
mn

instance Annotated EWildcard where
  ann :: forall l. EWildcard l -> l
ann EWildcard l
ewc = case EWildcard l
ewc of
      NoWildcard l
l  -> l
l
      EWildcard l
l Int
_ -> l
l
  amap :: forall l. (l -> l) -> EWildcard l -> EWildcard l
amap l -> l
f EWildcard l
ewc = case EWildcard l
ewc of
      NoWildcard l
l  -> l -> EWildcard l
forall l. l -> EWildcard l
NoWildcard (l -> l
f l
l)
      EWildcard l
l Int
n -> l -> Int -> EWildcard l
forall l. l -> Int -> EWildcard l
EWildcard (l -> l
f l
l) Int
n



instance Annotated Namespace where
    ann :: forall l. Namespace l -> l
ann Namespace l
es = case Namespace l
es of
        NoNamespace l
l   -> l
l
        TypeNamespace l
l -> l
l
        PatternNamespace l
l -> l
l
    amap :: forall l. (l -> l) -> Namespace l -> Namespace l
amap l -> l
f Namespace l
es = case Namespace l
es of
        NoNamespace l
l   -> l -> Namespace l
forall l. l -> Namespace l
NoNamespace (l -> l
f l
l)
        TypeNamespace l
l -> l -> Namespace l
forall l. l -> Namespace l
TypeNamespace (l -> l
f l
l)
        PatternNamespace l
l -> l -> Namespace l
forall l. l -> Namespace l
PatternNamespace (l -> l
f l
l)

instance Annotated ImportDecl where
    ann :: forall l. ImportDecl l -> l
ann (ImportDecl l
l ModuleName l
_ Bool
_ Bool
_ Bool
_ Maybe String
_ Maybe (ModuleName l)
_ Maybe (ImportSpecList l)
_) = l
l
    amap :: forall l. (l -> l) -> ImportDecl l -> ImportDecl l
amap l -> l
f (ImportDecl l
l ModuleName l
mn Bool
qual Bool
src Bool
safe Maybe String
pkg Maybe (ModuleName l)
mmn Maybe (ImportSpecList l)
mis) =
        l
-> ModuleName l
-> Bool
-> Bool
-> Bool
-> Maybe String
-> Maybe (ModuleName l)
-> Maybe (ImportSpecList l)
-> ImportDecl l
forall l.
l
-> ModuleName l
-> Bool
-> Bool
-> Bool
-> Maybe String
-> Maybe (ModuleName l)
-> Maybe (ImportSpecList l)
-> ImportDecl l
ImportDecl (l -> l
f l
l) ModuleName l
mn Bool
qual Bool
src Bool
safe Maybe String
pkg Maybe (ModuleName l)
mmn Maybe (ImportSpecList l)
mis

instance Annotated ImportSpecList where
    ann :: forall l. ImportSpecList l -> l
ann (ImportSpecList l
l Bool
_ [ImportSpec l]
_)      = l
l
    amap :: forall l. (l -> l) -> ImportSpecList l -> ImportSpecList l
amap l -> l
f (ImportSpecList l
l Bool
b [ImportSpec l]
iss) = l -> Bool -> [ImportSpec l] -> ImportSpecList l
forall l. l -> Bool -> [ImportSpec l] -> ImportSpecList l
ImportSpecList (l -> l
f l
l) Bool
b [ImportSpec l]
iss

instance Annotated ImportSpec where
    ann :: forall l. ImportSpec l -> l
ann ImportSpec l
is = case ImportSpec l
is of
        IVar l
l Name l
_         -> l
l
        IAbs l
l Namespace l
_ Name l
_       -> l
l
        IThingAll l
l Name l
_    -> l
l
        IThingWith l
l Name l
_ [CName l]
_ -> l
l
    amap :: forall l. (l -> l) -> ImportSpec l -> ImportSpec l
amap l -> l
f ImportSpec l
is = case ImportSpec l
is of
        IVar l
l Name l
n        -> l -> Name l -> ImportSpec l
forall l. l -> Name l -> ImportSpec l
IVar (l -> l
f l
l) Name l
n
        IAbs l
l Namespace l
ns Name l
n     -> l -> Namespace l -> Name l -> ImportSpec l
forall l. l -> Namespace l -> Name l -> ImportSpec l
IAbs (l -> l
f l
l) Namespace l
ns Name l
n
        IThingAll l
l Name l
n   -> l -> Name l -> ImportSpec l
forall l. l -> Name l -> ImportSpec l
IThingAll (l -> l
f l
l) Name l
n
        IThingWith l
l Name l
n [CName l]
cns  -> l -> Name l -> [CName l] -> ImportSpec l
forall l. l -> Name l -> [CName l] -> ImportSpec l
IThingWith (l -> l
f l
l) Name l
n [CName l]
cns

instance Annotated Assoc where
    ann :: forall l. Assoc l -> l
ann (AssocNone  l
l) = l
l
    ann (AssocLeft  l
l) = l
l
    ann (AssocRight l
l) = l
l
    amap :: forall l. (l -> l) -> Assoc l -> Assoc l
amap = (l -> l) -> Assoc l -> Assoc l
forall a b. (a -> b) -> Assoc a -> Assoc b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap

instance Annotated Deriving where
    ann :: forall l. Deriving l -> l
ann (Deriving l
l Maybe (DerivStrategy l)
_ [InstRule l]
_)        = l
l
    amap :: forall l. (l -> l) -> Deriving l -> Deriving l
amap l -> l
f (Deriving l
l Maybe (DerivStrategy l)
mds [InstRule l]
ihs) = l -> Maybe (DerivStrategy l) -> [InstRule l] -> Deriving l
forall l.
l -> Maybe (DerivStrategy l) -> [InstRule l] -> Deriving l
Deriving (l -> l
f l
l) Maybe (DerivStrategy l)
mds [InstRule l]
ihs

instance Annotated DerivStrategy where
    ann :: forall l. DerivStrategy l -> l
ann (DerivStock l
l)    = l
l
    ann (DerivAnyclass l
l) = l
l
    ann (DerivNewtype l
l)  = l
l
    ann (DerivVia l
l Type l
_)    = l
l

    amap :: forall l. (l -> l) -> DerivStrategy l -> DerivStrategy l
amap l -> l
f (DerivStock l
l)    = l -> DerivStrategy l
forall l. l -> DerivStrategy l
DerivStock (l -> l
f l
l)
    amap l -> l
f (DerivAnyclass l
l) = l -> DerivStrategy l
forall l. l -> DerivStrategy l
DerivAnyclass (l -> l
f l
l)
    amap l -> l
f (DerivNewtype l
l)  = l -> DerivStrategy l
forall l. l -> DerivStrategy l
DerivNewtype (l -> l
f l
l)
    amap l -> l
f (DerivVia l
l Type l
t)    = l -> Type l -> DerivStrategy l
forall l. l -> Type l -> DerivStrategy l
DerivVia (l -> l
f l
l) Type l
t

instance Annotated TypeEqn where
    ann :: forall l. TypeEqn l -> l
ann (TypeEqn l
l Type l
_ Type l
_) = l
l
    amap :: forall l. (l -> l) -> TypeEqn l -> TypeEqn l
amap l -> l
f (TypeEqn l
l Type l
a Type l
b) = l -> Type l -> Type l -> TypeEqn l
forall l. l -> Type l -> Type l -> TypeEqn l
TypeEqn (l -> l
f l
l) Type l
a Type l
b

instance Annotated InjectivityInfo where
  ann :: forall l. InjectivityInfo l -> l
ann (InjectivityInfo l
l Name l
_ [Name l]
_) = l
l
  amap :: forall l. (l -> l) -> InjectivityInfo l -> InjectivityInfo l
amap l -> l
f (InjectivityInfo l
l Name l
to [Name l]
from) = l -> Name l -> [Name l] -> InjectivityInfo l
forall l. l -> Name l -> [Name l] -> InjectivityInfo l
InjectivityInfo (l -> l
f l
l) Name l
to [Name l]
from

instance Annotated ResultSig where
  ann :: forall l. ResultSig l -> l
ann (KindSig l
l Kind l
_) = l
l
  ann (TyVarSig l
l TyVarBind l
_) = l
l

  amap :: forall l. (l -> l) -> ResultSig l -> ResultSig l
amap l -> l
f (KindSig l
l Kind l
k) = l -> Kind l -> ResultSig l
forall l. l -> Kind l -> ResultSig l
KindSig (l -> l
f l
l) Kind l
k
  amap l -> l
f (TyVarSig l
l TyVarBind l
tv) = l -> TyVarBind l -> ResultSig l
forall l. l -> TyVarBind l -> ResultSig l
TyVarSig (l -> l
f l
l) TyVarBind l
tv

instance Annotated Decl where
    ann :: forall l. Decl l -> l
ann Decl l
decl = case Decl l
decl of
        TypeDecl     l
l DeclHead l
_ Type l
_              -> l
l
        TypeFamDecl  l
l DeclHead l
_ Maybe (ResultSig l)
_ Maybe (InjectivityInfo l)
_            -> l
l
        ClosedTypeFamDecl  l
l DeclHead l
_ Maybe (ResultSig l)
_ Maybe (InjectivityInfo l)
_ [TypeEqn l]
_    -> l
l
        DataDecl     l
l DataOrNew l
_ Maybe (Context l)
_ DeclHead l
_ [QualConDecl l]
_ [Deriving l]
_        -> l
l
        GDataDecl    l
l DataOrNew l
_ Maybe (Context l)
_ DeclHead l
_ Maybe (Type l)
_ [GadtDecl l]
_ [Deriving l]
_      -> l
l
        DataFamDecl  l
l    Maybe (Context l)
_ DeclHead l
_ Maybe (ResultSig l)
_         -> l
l
        TypeInsDecl  l
l Type l
_  Type l
_             -> l
l
        DataInsDecl  l
l DataOrNew l
_ Type l
_ [QualConDecl l]
_ [Deriving l]
_          -> l
l
        GDataInsDecl l
l DataOrNew l
_ Type l
_ Maybe (Type l)
_ [GadtDecl l]
_ [Deriving l]
_        -> l
l
        ClassDecl    l
l Maybe (Context l)
_ DeclHead l
_ [FunDep l]
_ Maybe [ClassDecl l]
_          -> l
l
        InstDecl     l
l Maybe (Overlap l)
_ InstRule l
_ Maybe [InstDecl l]
_            -> l
l
        DerivDecl    l
l Maybe (DerivStrategy l)
_ Maybe (Overlap l)
_ InstRule l
_            -> l
l
        InfixDecl    l
l Assoc l
_ Maybe Int
_ [Op l]
_            -> l
l
        DefaultDecl  l
l [Type l]
_                -> l
l
        SpliceDecl   l
l Exp l
_                -> l
l
        TSpliceDecl  l
l Exp l
_                -> l
l
        TypeSig      l
l [Name l]
_ Type l
_              -> l
l
        PatSynSig    l
l [Name l]
_ Maybe [TyVarBind l]
_ Maybe (Context l)
_ Maybe [TyVarBind l]
_ Maybe (Context l)
_ Type l
_      -> l
l
        FunBind      l
l [Match l]
_                -> l
l
        PatBind      l
l Pat l
_ Rhs l
_ Maybe (Binds l)
_            -> l
l
        ForImp       l
l CallConv l
_ Maybe (Safety l)
_ Maybe String
_ Name l
_ Type l
_        -> l
l
        ForExp       l
l CallConv l
_ Maybe String
_ Name l
_ Type l
_          -> l
l
        RulePragmaDecl   l
l [Rule l]
_            -> l
l
        DeprPragmaDecl   l
l [([Name l], String)]
_            -> l
l
        WarnPragmaDecl   l
l [([Name l], String)]
_            -> l
l
        InlineSig        l
l Bool
_ Maybe (Activation l)
_ QName l
_        -> l
l
        InlineConlikeSig l
l   Maybe (Activation l)
_ QName l
_        -> l
l
        SpecSig          l
l   Maybe (Activation l)
_ QName l
_ [Type l]
_      -> l
l
        SpecInlineSig    l
l Bool
_ Maybe (Activation l)
_ QName l
_ [Type l]
_      -> l
l
        InstSig          l
l InstRule l
_            -> l
l
        AnnPragma        l
l Annotation l
_            -> l
l
        MinimalPragma    l
l Maybe (BooleanFormula l)
_            -> l
l
        RoleAnnotDecl    l
l QName l
_ [Role l]
_          -> l
l
        PatSyn           l
l Pat l
_ Pat l
_ PatternSynDirection l
_        -> l
l
        CompletePragma l
l [Name l]
_ Maybe (QName l)
_            -> l
l
    amap :: forall l. (l -> l) -> Decl l -> Decl l
amap l -> l
f Decl l
decl = case Decl l
decl of
        TypeDecl     l
l DeclHead l
dh Type l
t      -> l -> DeclHead l -> Type l -> Decl l
forall l. l -> DeclHead l -> Type l -> Decl l
TypeDecl    (l -> l
f l
l) DeclHead l
dh Type l
t
        TypeFamDecl  l
l DeclHead l
dh Maybe (ResultSig l)
mk Maybe (InjectivityInfo l)
mi  -> l
-> DeclHead l
-> Maybe (ResultSig l)
-> Maybe (InjectivityInfo l)
-> Decl l
forall l.
l
-> DeclHead l
-> Maybe (ResultSig l)
-> Maybe (InjectivityInfo l)
-> Decl l
TypeFamDecl (l -> l
f l
l) DeclHead l
dh Maybe (ResultSig l)
mk Maybe (InjectivityInfo l)
mi
        ClosedTypeFamDecl  l
l DeclHead l
dh Maybe (ResultSig l)
mk Maybe (InjectivityInfo l)
mi [TypeEqn l]
eqns  -> l
-> DeclHead l
-> Maybe (ResultSig l)
-> Maybe (InjectivityInfo l)
-> [TypeEqn l]
-> Decl l
forall l.
l
-> DeclHead l
-> Maybe (ResultSig l)
-> Maybe (InjectivityInfo l)
-> [TypeEqn l]
-> Decl l
ClosedTypeFamDecl (l -> l
f l
l) DeclHead l
dh Maybe (ResultSig l)
mk Maybe (InjectivityInfo l)
mi [TypeEqn l]
eqns
        DataDecl     l
l DataOrNew l
dn Maybe (Context l)
mcx DeclHead l
dh [QualConDecl l]
cds [Deriving l]
ders ->
            l
-> DataOrNew l
-> Maybe (Context l)
-> DeclHead l
-> [QualConDecl l]
-> [Deriving l]
-> Decl l
forall l.
l
-> DataOrNew l
-> Maybe (Context l)
-> DeclHead l
-> [QualConDecl l]
-> [Deriving l]
-> Decl l
DataDecl (l -> l
f l
l) DataOrNew l
dn Maybe (Context l)
mcx DeclHead l
dh [QualConDecl l]
cds [Deriving l]
ders
        GDataDecl    l
l DataOrNew l
dn Maybe (Context l)
mcx DeclHead l
dh Maybe (Type l)
mk [GadtDecl l]
gds [Deriving l]
ders ->
            l
-> DataOrNew l
-> Maybe (Context l)
-> DeclHead l
-> Maybe (Type l)
-> [GadtDecl l]
-> [Deriving l]
-> Decl l
forall l.
l
-> DataOrNew l
-> Maybe (Context l)
-> DeclHead l
-> Maybe (Type l)
-> [GadtDecl l]
-> [Deriving l]
-> Decl l
GDataDecl (l -> l
f l
l) DataOrNew l
dn Maybe (Context l)
mcx DeclHead l
dh Maybe (Type l)
mk [GadtDecl l]
gds [Deriving l]
ders
        DataFamDecl  l
l Maybe (Context l)
mcx DeclHead l
dh Maybe (ResultSig l)
mk         -> l
-> Maybe (Context l) -> DeclHead l -> Maybe (ResultSig l) -> Decl l
forall l.
l
-> Maybe (Context l) -> DeclHead l -> Maybe (ResultSig l) -> Decl l
DataFamDecl (l -> l
f l
l) Maybe (Context l)
mcx DeclHead l
dh Maybe (ResultSig l)
mk
        TypeInsDecl  l
l Type l
t1 Type l
t2             -> l -> Type l -> Type l -> Decl l
forall l. l -> Type l -> Type l -> Decl l
TypeInsDecl (l -> l
f l
l) Type l
t1 Type l
t2
        DataInsDecl  l
l DataOrNew l
dn Type l
t [QualConDecl l]
cds [Deriving l]
ders     -> l
-> DataOrNew l
-> Type l
-> [QualConDecl l]
-> [Deriving l]
-> Decl l
forall l.
l
-> DataOrNew l
-> Type l
-> [QualConDecl l]
-> [Deriving l]
-> Decl l
DataInsDecl (l -> l
f l
l) DataOrNew l
dn Type l
t [QualConDecl l]
cds [Deriving l]
ders
        GDataInsDecl l
l DataOrNew l
dn Type l
t Maybe (Type l)
mk [GadtDecl l]
gds [Deriving l]
ders  -> l
-> DataOrNew l
-> Type l
-> Maybe (Type l)
-> [GadtDecl l]
-> [Deriving l]
-> Decl l
forall l.
l
-> DataOrNew l
-> Type l
-> Maybe (Type l)
-> [GadtDecl l]
-> [Deriving l]
-> Decl l
GDataInsDecl (l -> l
f l
l) DataOrNew l
dn Type l
t Maybe (Type l)
mk [GadtDecl l]
gds [Deriving l]
ders
        ClassDecl    l
l Maybe (Context l)
mcx DeclHead l
dh [FunDep l]
fds Maybe [ClassDecl l]
cds    -> l
-> Maybe (Context l)
-> DeclHead l
-> [FunDep l]
-> Maybe [ClassDecl l]
-> Decl l
forall l.
l
-> Maybe (Context l)
-> DeclHead l
-> [FunDep l]
-> Maybe [ClassDecl l]
-> Decl l
ClassDecl (l -> l
f l
l) Maybe (Context l)
mcx DeclHead l
dh [FunDep l]
fds Maybe [ClassDecl l]
cds
        InstDecl     l
l Maybe (Overlap l)
mo InstRule l
ih Maybe [InstDecl l]
ids         -> l
-> Maybe (Overlap l) -> InstRule l -> Maybe [InstDecl l] -> Decl l
forall l.
l
-> Maybe (Overlap l) -> InstRule l -> Maybe [InstDecl l] -> Decl l
InstDecl (l -> l
f l
l) Maybe (Overlap l)
mo InstRule l
ih Maybe [InstDecl l]
ids
        DerivDecl    l
l Maybe (DerivStrategy l)
mds Maybe (Overlap l)
mo InstRule l
ih         -> l
-> Maybe (DerivStrategy l)
-> Maybe (Overlap l)
-> InstRule l
-> Decl l
forall l.
l
-> Maybe (DerivStrategy l)
-> Maybe (Overlap l)
-> InstRule l
-> Decl l
DerivDecl (l -> l
f l
l) Maybe (DerivStrategy l)
mds Maybe (Overlap l)
mo InstRule l
ih
        InfixDecl    l
l Assoc l
a Maybe Int
k [Op l]
ops           -> l -> Assoc l -> Maybe Int -> [Op l] -> Decl l
forall l. l -> Assoc l -> Maybe Int -> [Op l] -> Decl l
InfixDecl (l -> l
f l
l) Assoc l
a Maybe Int
k [Op l]
ops
        DefaultDecl  l
l [Type l]
ts                -> l -> [Type l] -> Decl l
forall l. l -> [Type l] -> Decl l
DefaultDecl (l -> l
f l
l) [Type l]
ts
        SpliceDecl   l
l Exp l
sp                -> l -> Exp l -> Decl l
forall l. l -> Exp l -> Decl l
SpliceDecl (l -> l
f l
l) Exp l
sp
        TSpliceDecl  l
l Exp l
sp                -> l -> Exp l -> Decl l
forall l. l -> Exp l -> Decl l
TSpliceDecl (l -> l
f l
l) Exp l
sp
        TypeSig      l
l [Name l]
ns Type l
t              -> l -> [Name l] -> Type l -> Decl l
forall l. l -> [Name l] -> Type l -> Decl l
TypeSig (l -> l
f l
l) [Name l]
ns Type l
t
        PatSynSig    l
l [Name l]
n Maybe [TyVarBind l]
dh Maybe (Context l)
c1 Maybe [TyVarBind l]
dh2 Maybe (Context l)
c2 Type l
t      -> l
-> [Name l]
-> Maybe [TyVarBind l]
-> Maybe (Context l)
-> Maybe [TyVarBind l]
-> Maybe (Context l)
-> Type l
-> Decl l
forall l.
l
-> [Name l]
-> Maybe [TyVarBind l]
-> Maybe (Context l)
-> Maybe [TyVarBind l]
-> Maybe (Context l)
-> Type l
-> Decl l
PatSynSig (l -> l
f l
l) [Name l]
n Maybe [TyVarBind l]
dh Maybe (Context l)
c1 Maybe [TyVarBind l]
dh2 Maybe (Context l)
c2 Type l
t
        FunBind      l
l [Match l]
ms                -> l -> [Match l] -> Decl l
forall l. l -> [Match l] -> Decl l
FunBind (l -> l
f l
l) [Match l]
ms
        PatBind      l
l Pat l
p Rhs l
rhs Maybe (Binds l)
bs          -> l -> Pat l -> Rhs l -> Maybe (Binds l) -> Decl l
forall l. l -> Pat l -> Rhs l -> Maybe (Binds l) -> Decl l
PatBind (l -> l
f l
l) Pat l
p Rhs l
rhs Maybe (Binds l)
bs
        ForImp       l
l CallConv l
cc Maybe (Safety l)
msf Maybe String
s Name l
n Type l
t      -> l
-> CallConv l
-> Maybe (Safety l)
-> Maybe String
-> Name l
-> Type l
-> Decl l
forall l.
l
-> CallConv l
-> Maybe (Safety l)
-> Maybe String
-> Name l
-> Type l
-> Decl l
ForImp (l -> l
f l
l) CallConv l
cc Maybe (Safety l)
msf Maybe String
s Name l
n Type l
t
        ForExp       l
l CallConv l
cc     Maybe String
s Name l
n Type l
t      -> l -> CallConv l -> Maybe String -> Name l -> Type l -> Decl l
forall l.
l -> CallConv l -> Maybe String -> Name l -> Type l -> Decl l
ForExp (l -> l
f l
l) CallConv l
cc     Maybe String
s Name l
n Type l
t
        RulePragmaDecl   l
l [Rule l]
rs            -> l -> [Rule l] -> Decl l
forall l. l -> [Rule l] -> Decl l
RulePragmaDecl (l -> l
f l
l) [Rule l]
rs
        DeprPragmaDecl   l
l [([Name l], String)]
nss           -> l -> [([Name l], String)] -> Decl l
forall l. l -> [([Name l], String)] -> Decl l
DeprPragmaDecl (l -> l
f l
l) [([Name l], String)]
nss
        WarnPragmaDecl   l
l [([Name l], String)]
nss           -> l -> [([Name l], String)] -> Decl l
forall l. l -> [([Name l], String)] -> Decl l
WarnPragmaDecl (l -> l
f l
l) [([Name l], String)]
nss
        InlineSig        l
l Bool
b Maybe (Activation l)
act QName l
qn      -> l -> Bool -> Maybe (Activation l) -> QName l -> Decl l
forall l. l -> Bool -> Maybe (Activation l) -> QName l -> Decl l
InlineSig (l -> l
f l
l) Bool
b Maybe (Activation l)
act QName l
qn
        InlineConlikeSig l
l   Maybe (Activation l)
act QName l
qn      -> l -> Maybe (Activation l) -> QName l -> Decl l
forall l. l -> Maybe (Activation l) -> QName l -> Decl l
InlineConlikeSig (l -> l
f l
l) Maybe (Activation l)
act QName l
qn
        SpecSig          l
l   Maybe (Activation l)
act QName l
qn [Type l]
ts   -> l -> Maybe (Activation l) -> QName l -> [Type l] -> Decl l
forall l.
l -> Maybe (Activation l) -> QName l -> [Type l] -> Decl l
SpecSig       (l -> l
f l
l)   Maybe (Activation l)
act QName l
qn [Type l]
ts
        SpecInlineSig    l
l Bool
b Maybe (Activation l)
act QName l
qn [Type l]
ts   -> l -> Bool -> Maybe (Activation l) -> QName l -> [Type l] -> Decl l
forall l.
l -> Bool -> Maybe (Activation l) -> QName l -> [Type l] -> Decl l
SpecInlineSig (l -> l
f l
l) Bool
b Maybe (Activation l)
act QName l
qn [Type l]
ts
        InstSig          l
l InstRule l
ih            -> l -> InstRule l -> Decl l
forall l. l -> InstRule l -> Decl l
InstSig (l -> l
f l
l) InstRule l
ih
        AnnPragma        l
l Annotation l
ann'          -> l -> Annotation l -> Decl l
forall l. l -> Annotation l -> Decl l
AnnPragma (l -> l
f l
l) Annotation l
ann'
        MinimalPragma    l
l Maybe (BooleanFormula l)
b             -> l -> Maybe (BooleanFormula l) -> Decl l
forall l. l -> Maybe (BooleanFormula l) -> Decl l
MinimalPragma (l -> l
f l
l) Maybe (BooleanFormula l)
b
        RoleAnnotDecl    l
l QName l
t [Role l]
rs          -> l -> QName l -> [Role l] -> Decl l
forall l. l -> QName l -> [Role l] -> Decl l
RoleAnnotDecl (l -> l
f l
l) QName l
t [Role l]
rs
        PatSyn           l
l Pat l
p Pat l
r PatternSynDirection l
d         -> l -> Pat l -> Pat l -> PatternSynDirection l -> Decl l
forall l. l -> Pat l -> Pat l -> PatternSynDirection l -> Decl l
PatSyn (l -> l
f l
l) Pat l
p Pat l
r PatternSynDirection l
d
        CompletePragma   l
l [Name l]
cs Maybe (QName l)
ty         -> l -> [Name l] -> Maybe (QName l) -> Decl l
forall l. l -> [Name l] -> Maybe (QName l) -> Decl l
CompletePragma (l -> l
f l
l) [Name l]
cs Maybe (QName l)
ty

instance Annotated Role where
    ann :: forall l. Role l -> l
ann Role l
r = case Role l
r of
      RoleWildcard l
l -> l
l
      Representational l
l -> l
l
      Phantom l
l -> l
l
      Nominal l
l -> l
l
    amap :: forall l. (l -> l) -> Role l -> Role l
amap l -> l
f Role l
r = case Role l
r of
      RoleWildcard l
l -> l -> Role l
forall l. l -> Role l
RoleWildcard (l -> l
f l
l)
      Representational l
l -> l -> Role l
forall l. l -> Role l
Representational (l -> l
f l
l)
      Phantom l
l -> l -> Role l
forall l. l -> Role l
Phantom (l -> l
f l
l)
      Nominal l
l -> l -> Role l
forall l. l -> Role l
Nominal (l -> l
f l
l)

instance Annotated Annotation where
    ann :: forall l. Annotation l -> l
ann (Ann     l
l Name l
_ Exp l
_) = l
l
    ann (TypeAnn l
l Name l
_ Exp l
_) = l
l
    ann (ModuleAnn l
l Exp l
_) = l
l
    amap :: forall l. (l -> l) -> Annotation l -> Annotation l
amap l -> l
f (Ann     l
l Name l
n Exp l
e) = l -> Name l -> Exp l -> Annotation l
forall l. l -> Name l -> Exp l -> Annotation l
Ann     (l -> l
f l
l) Name l
n Exp l
e
    amap l -> l
f (TypeAnn l
l Name l
n Exp l
e) = l -> Name l -> Exp l -> Annotation l
forall l. l -> Name l -> Exp l -> Annotation l
TypeAnn (l -> l
f l
l) Name l
n Exp l
e
    amap l -> l
f (ModuleAnn l
l Exp l
e) = l -> Exp l -> Annotation l
forall l. l -> Exp l -> Annotation l
ModuleAnn (l -> l
f l
l) Exp l
e

instance Annotated BooleanFormula where
    ann :: forall l. BooleanFormula l -> l
ann (VarFormula l
l Name l
_)   = l
l
    ann (AndFormula l
l [BooleanFormula l]
_)   = l
l
    ann (OrFormula l
l [BooleanFormula l]
_)    = l
l
    ann (ParenFormula l
l BooleanFormula l
_) = l
l
    amap :: forall l. (l -> l) -> BooleanFormula l -> BooleanFormula l
amap l -> l
f (VarFormula l
l Name l
n)   = l -> Name l -> BooleanFormula l
forall l. l -> Name l -> BooleanFormula l
VarFormula (l -> l
f l
l) Name l
n
    amap l -> l
f (AndFormula l
l [BooleanFormula l]
bs)  = l -> [BooleanFormula l] -> BooleanFormula l
forall l. l -> [BooleanFormula l] -> BooleanFormula l
AndFormula (l -> l
f l
l) [BooleanFormula l]
bs
    amap l -> l
f (OrFormula l
l [BooleanFormula l]
bs)   = l -> [BooleanFormula l] -> BooleanFormula l
forall l. l -> [BooleanFormula l] -> BooleanFormula l
OrFormula (l -> l
f l
l) [BooleanFormula l]
bs
    amap l -> l
f (ParenFormula l
l BooleanFormula l
b) = l -> BooleanFormula l -> BooleanFormula l
forall l. l -> BooleanFormula l -> BooleanFormula l
ParenFormula (l -> l
f l
l) BooleanFormula l
b

instance Annotated DataOrNew where
    ann :: forall l. DataOrNew l -> l
ann (DataType l
l) = l
l
    ann (NewType  l
l) = l
l
    amap :: forall l. (l -> l) -> DataOrNew l -> DataOrNew l
amap = (l -> l) -> DataOrNew l -> DataOrNew l
forall a b. (a -> b) -> DataOrNew a -> DataOrNew b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap

instance Annotated DeclHead where
    ann :: forall l. DeclHead l -> l
ann (DHead l
l Name l
_)              = l
l
    ann (DHInfix l
l TyVarBind l
_ Name l
_)          = l
l
    ann (DHParen l
l DeclHead l
_)            = l
l
    ann (DHApp l
l DeclHead l
_ TyVarBind l
_)            = l
l
    amap :: forall l. (l -> l) -> DeclHead l -> DeclHead l
amap l -> l
f (DHead l
l Name l
n)           = l -> Name l -> DeclHead l
forall l. l -> Name l -> DeclHead l
DHead (l -> l
f l
l) Name l
n
    amap l -> l
f (DHInfix l
l TyVarBind l
tva Name l
n)     = l -> TyVarBind l -> Name l -> DeclHead l
forall l. l -> TyVarBind l -> Name l -> DeclHead l
DHInfix (l -> l
f l
l) TyVarBind l
tva Name l
n
    amap l -> l
f (DHParen l
l DeclHead l
dh)        = l -> DeclHead l -> DeclHead l
forall l. l -> DeclHead l -> DeclHead l
DHParen (l -> l
f l
l) DeclHead l
dh
    amap l -> l
f (DHApp l
l DeclHead l
dh TyVarBind l
t)        = l -> DeclHead l -> TyVarBind l -> DeclHead l
forall l. l -> DeclHead l -> TyVarBind l -> DeclHead l
DHApp (l -> l
f l
l) DeclHead l
dh TyVarBind l
t

instance Annotated InstRule where
    ann :: forall l. InstRule l -> l
ann (IRule l
l Maybe [TyVarBind l]
_ Maybe (Context l)
_ InstHead l
_)         = l
l
    ann (IParen l
l InstRule l
_)            = l
l
    amap :: forall l. (l -> l) -> InstRule l -> InstRule l
amap l -> l
f (IRule l
l Maybe [TyVarBind l]
mtv Maybe (Context l)
cxt InstHead l
qn) = l
-> Maybe [TyVarBind l]
-> Maybe (Context l)
-> InstHead l
-> InstRule l
forall l.
l
-> Maybe [TyVarBind l]
-> Maybe (Context l)
-> InstHead l
-> InstRule l
IRule (l -> l
f l
l) Maybe [TyVarBind l]
mtv Maybe (Context l)
cxt InstHead l
qn
    amap l -> l
f (IParen l
l InstRule l
ih)        = l -> InstRule l -> InstRule l
forall l. l -> InstRule l -> InstRule l
IParen (l -> l
f l
l) InstRule l
ih

instance Annotated InstHead where
    ann :: forall l. InstHead l -> l
ann (IHCon l
l QName l
_)              = l
l
    ann (IHInfix l
l Type l
_ QName l
_)          = l
l
    ann (IHParen l
l InstHead l
_)            = l
l
    ann (IHApp l
l InstHead l
_ Type l
_)            = l
l
    amap :: forall l. (l -> l) -> InstHead l -> InstHead l
amap l -> l
f (IHCon l
l QName l
n)           = l -> QName l -> InstHead l
forall l. l -> QName l -> InstHead l
IHCon (l -> l
f l
l) QName l
n
    amap l -> l
f (IHInfix l
l Type l
tva QName l
n)     = l -> Type l -> QName l -> InstHead l
forall l. l -> Type l -> QName l -> InstHead l
IHInfix (l -> l
f l
l) Type l
tva QName l
n
    amap l -> l
f (IHParen l
l InstHead l
dh)        = l -> InstHead l -> InstHead l
forall l. l -> InstHead l -> InstHead l
IHParen (l -> l
f l
l) InstHead l
dh
    amap l -> l
f (IHApp l
l InstHead l
dh Type l
t)        = l -> InstHead l -> Type l -> InstHead l
forall l. l -> InstHead l -> Type l -> InstHead l
IHApp (l -> l
f l
l) InstHead l
dh Type l
t

instance Annotated Binds where
    ann :: forall l. Binds l -> l
ann (BDecls  l
l [Decl l]
_) = l
l
    ann (IPBinds l
l [IPBind l]
_) = l
l
    amap :: forall l. (l -> l) -> Binds l -> Binds l
amap l -> l
f (BDecls  l
l [Decl l]
decls) = l -> [Decl l] -> Binds l
forall l. l -> [Decl l] -> Binds l
BDecls (l -> l
f l
l) [Decl l]
decls
    amap l -> l
f (IPBinds l
l [IPBind l]
ibs)   = l -> [IPBind l] -> Binds l
forall l. l -> [IPBind l] -> Binds l
IPBinds (l -> l
f l
l) [IPBind l]
ibs

instance Annotated IPBind where
    ann :: forall l. IPBind l -> l
ann (IPBind l
l IPName l
_ Exp l
_) = l
l
    amap :: forall l. (l -> l) -> IPBind l -> IPBind l
amap l -> l
f (IPBind l
l IPName l
ipn Exp l
e) = l -> IPName l -> Exp l -> IPBind l
forall l. l -> IPName l -> Exp l -> IPBind l
IPBind (l -> l
f l
l) IPName l
ipn Exp l
e

instance Annotated Match where
    ann :: forall l. Match l -> l
ann (Match l
l Name l
_ [Pat l]
_ Rhs l
_ Maybe (Binds l)
_)        = l
l
    ann (InfixMatch l
l Pat l
_ Name l
_ [Pat l]
_ Rhs l
_ Maybe (Binds l)
_) = l
l
    amap :: forall l. (l -> l) -> Match l -> Match l
amap l -> l
f (Match l
l Name l
n [Pat l]
ps Rhs l
rhs Maybe (Binds l)
bs) = l -> Name l -> [Pat l] -> Rhs l -> Maybe (Binds l) -> Match l
forall l.
l -> Name l -> [Pat l] -> Rhs l -> Maybe (Binds l) -> Match l
Match (l -> l
f l
l) Name l
n [Pat l]
ps Rhs l
rhs Maybe (Binds l)
bs
    amap l -> l
f (InfixMatch l
l Pat l
a Name l
n [Pat l]
b Rhs l
rhs Maybe (Binds l)
bs) = l
-> Pat l
-> Name l
-> [Pat l]
-> Rhs l
-> Maybe (Binds l)
-> Match l
forall l.
l
-> Pat l
-> Name l
-> [Pat l]
-> Rhs l
-> Maybe (Binds l)
-> Match l
InfixMatch (l -> l
f l
l) Pat l
a Name l
n [Pat l]
b Rhs l
rhs Maybe (Binds l)
bs

instance Annotated QualConDecl where
    ann :: forall l. QualConDecl l -> l
ann (QualConDecl l
l Maybe [TyVarBind l]
_ Maybe (Context l)
_ ConDecl l
_) = l
l
    amap :: forall l. (l -> l) -> QualConDecl l -> QualConDecl l
amap l -> l
f (QualConDecl l
l Maybe [TyVarBind l]
tvs Maybe (Context l)
cx ConDecl l
cd) = l
-> Maybe [TyVarBind l]
-> Maybe (Context l)
-> ConDecl l
-> QualConDecl l
forall l.
l
-> Maybe [TyVarBind l]
-> Maybe (Context l)
-> ConDecl l
-> QualConDecl l
QualConDecl (l -> l
f l
l) Maybe [TyVarBind l]
tvs Maybe (Context l)
cx ConDecl l
cd

instance Annotated ConDecl where
    ann :: forall l. ConDecl l -> l
ann (ConDecl l
l Name l
_ [Type l]
_)        = l
l
    ann (InfixConDecl l
l Type l
_ Name l
_ Type l
_) = l
l
    ann (RecDecl l
l Name l
_ [FieldDecl l]
_)        = l
l
    amap :: forall l. (l -> l) -> ConDecl l -> ConDecl l
amap l -> l
f (ConDecl l
l Name l
n [Type l]
bts) = l -> Name l -> [Type l] -> ConDecl l
forall l. l -> Name l -> [Type l] -> ConDecl l
ConDecl (l -> l
f l
l) Name l
n [Type l]
bts
    amap l -> l
f (InfixConDecl l
l Type l
ta Name l
n Type l
tb) = l -> Type l -> Name l -> Type l -> ConDecl l
forall l. l -> Type l -> Name l -> Type l -> ConDecl l
InfixConDecl (l -> l
f l
l) Type l
ta Name l
n Type l
tb
    amap l -> l
f (RecDecl l
l Name l
n [FieldDecl l]
fds) = l -> Name l -> [FieldDecl l] -> ConDecl l
forall l. l -> Name l -> [FieldDecl l] -> ConDecl l
RecDecl (l -> l
f l
l) Name l
n [FieldDecl l]
fds

instance Annotated FieldDecl where
    ann :: forall l. FieldDecl l -> l
ann (FieldDecl l
l [Name l]
_ Type l
_) = l
l
    amap :: forall l. (l -> l) -> FieldDecl l -> FieldDecl l
amap l -> l
f (FieldDecl l
l [Name l]
ns Type l
t) = l -> [Name l] -> Type l -> FieldDecl l
forall l. l -> [Name l] -> Type l -> FieldDecl l
FieldDecl (l -> l
f l
l) [Name l]
ns Type l
t

instance Annotated GadtDecl where
    ann :: forall l. GadtDecl l -> l
ann (GadtDecl l
l Name l
_ Maybe [TyVarBind l]
_ Maybe (Context l)
_ Maybe [FieldDecl l]
_ Type l
_) = l
l
    amap :: forall l. (l -> l) -> GadtDecl l -> GadtDecl l
amap l -> l
f (GadtDecl l
l Name l
n Maybe [TyVarBind l]
t1 Maybe (Context l)
t2 Maybe [FieldDecl l]
t3 Type l
t4) = l
-> Name l
-> Maybe [TyVarBind l]
-> Maybe (Context l)
-> Maybe [FieldDecl l]
-> Type l
-> GadtDecl l
forall l.
l
-> Name l
-> Maybe [TyVarBind l]
-> Maybe (Context l)
-> Maybe [FieldDecl l]
-> Type l
-> GadtDecl l
GadtDecl (l -> l
f l
l) Name l
n Maybe [TyVarBind l]
t1 Maybe (Context l)
t2 Maybe [FieldDecl l]
t3 Type l
t4

instance Annotated ClassDecl where
    ann :: forall l. ClassDecl l -> l
ann (ClsDecl    l
l Decl l
_)      = l
l
    ann (ClsDataFam l
l Maybe (Context l)
_ DeclHead l
_ Maybe (ResultSig l)
_)  = l
l
    ann (ClsTyFam   l
l DeclHead l
_ Maybe (ResultSig l)
_ Maybe (InjectivityInfo l)
_) = l
l
    ann (ClsTyDef   l
l TypeEqn l
_)    = l
l
    ann (ClsDefSig  l
l Name l
_ Type l
_)    = l
l
    amap :: forall l. (l -> l) -> ClassDecl l -> ClassDecl l
amap l -> l
f (ClsDecl    l
l Decl l
d) = l -> Decl l -> ClassDecl l
forall l. l -> Decl l -> ClassDecl l
ClsDecl (l -> l
f l
l) Decl l
d
    amap l -> l
f (ClsDataFam l
l Maybe (Context l)
mcx DeclHead l
dh Maybe (ResultSig l)
mk) = l
-> Maybe (Context l)
-> DeclHead l
-> Maybe (ResultSig l)
-> ClassDecl l
forall l.
l
-> Maybe (Context l)
-> DeclHead l
-> Maybe (ResultSig l)
-> ClassDecl l
ClsDataFam (l -> l
f l
l) Maybe (Context l)
mcx DeclHead l
dh Maybe (ResultSig l)
mk
    amap l -> l
f (ClsTyFam   l
l DeclHead l
dh Maybe (ResultSig l)
mk Maybe (InjectivityInfo l)
mi) = l
-> DeclHead l
-> Maybe (ResultSig l)
-> Maybe (InjectivityInfo l)
-> ClassDecl l
forall l.
l
-> DeclHead l
-> Maybe (ResultSig l)
-> Maybe (InjectivityInfo l)
-> ClassDecl l
ClsTyFam (l -> l
f l
l) DeclHead l
dh Maybe (ResultSig l)
mk Maybe (InjectivityInfo l)
mi
    amap l -> l
f (ClsTyDef   l
l TypeEqn l
t ) = l -> TypeEqn l -> ClassDecl l
forall l. l -> TypeEqn l -> ClassDecl l
ClsTyDef (l -> l
f l
l) TypeEqn l
t
    amap l -> l
f (ClsDefSig  l
l Name l
n Type l
t) = l -> Name l -> Type l -> ClassDecl l
forall l. l -> Name l -> Type l -> ClassDecl l
ClsDefSig (l -> l
f l
l) Name l
n Type l
t

instance Annotated InstDecl where
    ann :: forall l. InstDecl l -> l
ann InstDecl l
id = case InstDecl l
id of
        InsDecl   l
l Decl l
_            -> l
l
        InsType   l
l Type l
_ Type l
_          -> l
l
        InsData   l
l DataOrNew l
_ Type l
_  [QualConDecl l]
_ [Deriving l]
_     -> l
l
        InsGData  l
l DataOrNew l
_ Type l
_ Maybe (Type l)
_ [GadtDecl l]
_ [Deriving l]
_    -> l
l
--        InsInline l _ _ _    -> l
    amap :: forall l. (l -> l) -> InstDecl l -> InstDecl l
amap l -> l
f InstDecl l
id = case InstDecl l
id of
        InsDecl   l
l Decl l
d           -> l -> Decl l -> InstDecl l
forall l. l -> Decl l -> InstDecl l
InsDecl (l -> l
f l
l) Decl l
d
        InsType   l
l Type l
t1 Type l
t2       -> l -> Type l -> Type l -> InstDecl l
forall l. l -> Type l -> Type l -> InstDecl l
InsType (l -> l
f l
l) Type l
t1 Type l
t2
        InsData   l
l DataOrNew l
dn Type l
t    [QualConDecl l]
cds [Deriving l]
ders -> l
-> DataOrNew l
-> Type l
-> [QualConDecl l]
-> [Deriving l]
-> InstDecl l
forall l.
l
-> DataOrNew l
-> Type l
-> [QualConDecl l]
-> [Deriving l]
-> InstDecl l
InsData  (l -> l
f l
l) DataOrNew l
dn Type l
t    [QualConDecl l]
cds [Deriving l]
ders
        InsGData  l
l DataOrNew l
dn Type l
t Maybe (Type l)
mk [GadtDecl l]
gds [Deriving l]
ders -> l
-> DataOrNew l
-> Type l
-> Maybe (Type l)
-> [GadtDecl l]
-> [Deriving l]
-> InstDecl l
forall l.
l
-> DataOrNew l
-> Type l
-> Maybe (Type l)
-> [GadtDecl l]
-> [Deriving l]
-> InstDecl l
InsGData (l -> l
f l
l) DataOrNew l
dn Type l
t Maybe (Type l)
mk [GadtDecl l]
gds [Deriving l]
ders
--        InsInline l b act qn    -> InsInline (f l) b act qn

instance Annotated BangType where
     ann :: forall l. BangType l -> l
ann (BangedTy   l
l)       = l
l
     ann (LazyTy   l
l)         = l
l
     ann (NoStrictAnnot l
l)    = l
l

     amap :: forall l. (l -> l) -> BangType l -> BangType l
amap l -> l
f (BangedTy   l
l) = l -> BangType l
forall l. l -> BangType l
BangedTy (l -> l
f l
l)
     amap l -> l
f (LazyTy   l
l)   = l -> BangType l
forall l. l -> BangType l
LazyTy (l -> l
f l
l)
     amap l -> l
f (NoStrictAnnot l
l) = l -> BangType l
forall l. l -> BangType l
NoStrictAnnot (l -> l
f l
l)

instance Annotated Unpackedness where
    ann :: forall l. Unpackedness l -> l
ann (Unpack l
l) = l
l
    ann (NoUnpack l
l) = l
l
    ann (NoUnpackPragma l
l) = l
l

    amap :: forall l. (l -> l) -> Unpackedness l -> Unpackedness l
amap l -> l
f (Unpack l
l) = l -> Unpackedness l
forall l. l -> Unpackedness l
Unpack (l -> l
f l
l)
    amap l -> l
f (NoUnpack l
l) = l -> Unpackedness l
forall l. l -> Unpackedness l
Unpack (l -> l
f l
l)
    amap l -> l
f (NoUnpackPragma l
l) = l -> Unpackedness l
forall l. l -> Unpackedness l
Unpack (l -> l
f l
l)

instance Annotated Rhs where
     ann :: forall l. Rhs l -> l
ann (UnGuardedRhs l
l Exp l
_) = l
l
     ann (GuardedRhss  l
l [GuardedRhs l]
_) = l
l
     amap :: forall l. (l -> l) -> Rhs l -> Rhs l
amap l -> l
f (UnGuardedRhs l
l Exp l
e)     = l -> Exp l -> Rhs l
forall l. l -> Exp l -> Rhs l
UnGuardedRhs (l -> l
f l
l) Exp l
e
     amap l -> l
f (GuardedRhss  l
l [GuardedRhs l]
grhss) = l -> [GuardedRhs l] -> Rhs l
forall l. l -> [GuardedRhs l] -> Rhs l
GuardedRhss  (l -> l
f l
l) [GuardedRhs l]
grhss

instance Annotated GuardedRhs where
     ann :: forall l. GuardedRhs l -> l
ann (GuardedRhs l
l [Stmt l]
_ Exp l
_) = l
l
     amap :: forall l. (l -> l) -> GuardedRhs l -> GuardedRhs l
amap l -> l
f (GuardedRhs l
l [Stmt l]
ss Exp l
e) = l -> [Stmt l] -> Exp l -> GuardedRhs l
forall l. l -> [Stmt l] -> Exp l -> GuardedRhs l
GuardedRhs (l -> l
f l
l) [Stmt l]
ss Exp l
e

instance Annotated Type where
    ann :: forall l. Type l -> l
ann Type l
t = case Type l
t of
      TyForall l
l Maybe [TyVarBind l]
_ Maybe (Context l)
_ Type l
_              -> l
l
      TyStar  l
l                     -> l
l
      TyFun   l
l Type l
_ Type l
_                 -> l
l
      TyTuple l
l Boxed
_ [Type l]
_                 -> l
l
      TyUnboxedSum l
l [Type l]
_              -> l
l
      TyList  l
l Type l
_                   -> l
l
      TyParArray  l
l Type l
_               -> l
l
      TyApp   l
l Type l
_ Type l
_                 -> l
l
      TyVar   l
l Name l
_                   -> l
l
      TyCon   l
l QName l
_                   -> l
l
      TyParen l
l Type l
_                   -> l
l
      TyInfix l
l Type l
_ MaybePromotedName l
_ Type l
_               -> l
l
      TyKind  l
l Type l
_ Type l
_                 -> l
l
      TyPromoted l
l   Promoted l
_              -> l
l
      TyEquals l
l Type l
_ Type l
_                -> l
l
      TySplice l
l Splice l
_                  -> l
l
      TyBang l
l BangType l
_ Unpackedness l
_ Type l
_                  -> l
l
      TyWildCard l
l Maybe (Name l)
_                -> l
l
      TyQuasiQuote l
l String
_ String
_            -> l
l
    amap :: forall l. (l -> l) -> Type l -> Type l
amap l -> l
f Type l
t1 = case Type l
t1 of
      TyForall l
l Maybe [TyVarBind l]
mtvs Maybe (Context l)
mcx Type l
t         -> l -> Maybe [TyVarBind l] -> Maybe (Context l) -> Type l -> Type l
forall l.
l -> Maybe [TyVarBind l] -> Maybe (Context l) -> Type l -> Type l
TyForall (l -> l
f l
l) Maybe [TyVarBind l]
mtvs Maybe (Context l)
mcx Type l
t
      TyStar  l
l                     -> l -> Type l
forall l. l -> Type l
TyStar (l -> l
f l
l)
      TyFun   l
l Type l
t1' Type l
t2              -> l -> Type l -> Type l -> Type l
forall l. l -> Type l -> Type l -> Type l
TyFun (l -> l
f l
l) Type l
t1' Type l
t2
      TyTuple l
l Boxed
b [Type l]
ts                -> l -> Boxed -> [Type l] -> Type l
forall l. l -> Boxed -> [Type l] -> Type l
TyTuple (l -> l
f l
l) Boxed
b [Type l]
ts
      TyUnboxedSum l
l [Type l]
s              -> l -> [Type l] -> Type l
forall l. l -> [Type l] -> Type l
TyUnboxedSum (l -> l
f l
l) [Type l]
s
      TyList  l
l Type l
t                   -> l -> Type l -> Type l
forall l. l -> Type l -> Type l
TyList (l -> l
f l
l) Type l
t
      TyParArray  l
l Type l
t               -> l -> Type l -> Type l
forall l. l -> Type l -> Type l
TyParArray (l -> l
f l
l) Type l
t
      TyApp   l
l Type l
t1' Type l
t2              -> l -> Type l -> Type l -> Type l
forall l. l -> Type l -> Type l -> Type l
TyApp (l -> l
f l
l) Type l
t1' Type l
t2
      TyVar   l
l Name l
n                   -> l -> Name l -> Type l
forall l. l -> Name l -> Type l
TyVar (l -> l
f l
l) Name l
n
      TyCon   l
l QName l
qn                  -> l -> QName l -> Type l
forall l. l -> QName l -> Type l
TyCon (l -> l
f l
l) QName l
qn
      TyParen l
l Type l
t                   -> l -> Type l -> Type l
forall l. l -> Type l -> Type l
TyParen (l -> l
f l
l) Type l
t
      TyInfix l
l Type l
ta MaybePromotedName l
qn Type l
tb            -> l -> Type l -> MaybePromotedName l -> Type l -> Type l
forall l. l -> Type l -> MaybePromotedName l -> Type l -> Type l
TyInfix (l -> l
f l
l) Type l
ta MaybePromotedName l
qn Type l
tb
      TyKind  l
l Type l
t Type l
k                 -> l -> Type l -> Type l -> Type l
forall l. l -> Type l -> Type l -> Type l
TyKind (l -> l
f l
l) Type l
t Type l
k
      TyPromoted l
l   Promoted l
p              -> l -> Promoted l -> Type l
forall l. l -> Promoted l -> Type l
TyPromoted (l -> l
f l
l)   Promoted l
p
      TyEquals l
l Type l
a Type l
b                -> l -> Type l -> Type l -> Type l
forall l. l -> Type l -> Type l -> Type l
TyEquals (l -> l
f l
l) Type l
a Type l
b
      TySplice l
l Splice l
s                  -> l -> Splice l -> Type l
forall l. l -> Splice l -> Type l
TySplice (l -> l
f l
l) Splice l
s
      TyBang l
l BangType l
b Unpackedness l
u Type l
t                  -> l -> BangType l -> Unpackedness l -> Type l -> Type l
forall l. l -> BangType l -> Unpackedness l -> Type l -> Type l
TyBang (l -> l
f l
l) BangType l
b Unpackedness l
u Type l
t
      TyWildCard l
l Maybe (Name l)
n                -> l -> Maybe (Name l) -> Type l
forall l. l -> Maybe (Name l) -> Type l
TyWildCard (l -> l
f l
l) Maybe (Name l)
n
      TyQuasiQuote l
l String
n String
s            -> l -> String -> String -> Type l
forall l. l -> String -> String -> Type l
TyQuasiQuote (l -> l
f l
l) String
n String
s

instance Annotated MaybePromotedName where
  ann :: forall l. MaybePromotedName l -> l
ann MaybePromotedName l
t = case MaybePromotedName l
t of
    PromotedName l
l QName l
_ -> l
l
    UnpromotedName l
l QName l
_ -> l
l
  amap :: forall l. (l -> l) -> MaybePromotedName l -> MaybePromotedName l
amap l -> l
f MaybePromotedName l
tl =  case MaybePromotedName l
tl of
    PromotedName l
l QName l
q -> l -> QName l -> MaybePromotedName l
forall l. l -> QName l -> MaybePromotedName l
PromotedName (l -> l
f l
l)     QName l
q
    UnpromotedName l
l QName l
q -> l -> QName l -> MaybePromotedName l
forall l. l -> QName l -> MaybePromotedName l
UnpromotedName (l -> l
f l
l) QName l
q

instance Annotated TyVarBind where
    ann :: forall l. TyVarBind l -> l
ann (KindedVar   l
l Name l
_ Kind l
_) = l
l
    ann (UnkindedVar l
l Name l
_)   = l
l
    amap :: forall l. (l -> l) -> TyVarBind l -> TyVarBind l
amap l -> l
f (KindedVar   l
l Name l
n Kind l
k) = l -> Name l -> Kind l -> TyVarBind l
forall l. l -> Name l -> Kind l -> TyVarBind l
KindedVar   (l -> l
f l
l) Name l
n Kind l
k
    amap l -> l
f (UnkindedVar l
l Name l
n)   = l -> Name l -> TyVarBind l
forall l. l -> Name l -> TyVarBind l
UnkindedVar (l -> l
f l
l) Name l
n

instance Annotated FunDep where
    ann :: forall l. FunDep l -> l
ann (FunDep l
l [Name l]
_ [Name l]
_) = l
l
    amap :: forall l. (l -> l) -> FunDep l -> FunDep l
amap l -> l
f (FunDep l
l [Name l]
ns1 [Name l]
ns2) = l -> [Name l] -> [Name l] -> FunDep l
forall l. l -> [Name l] -> [Name l] -> FunDep l
FunDep (l -> l
f l
l) [Name l]
ns1 [Name l]
ns2

instance Annotated Context where
    ann :: forall l. Context l -> l
ann (CxSingle l
l Asst l
_) = l
l
    ann (CxTuple  l
l [Asst l]
_) = l
l
    ann (CxEmpty  l
l)   = l
l
    amap :: forall l. (l -> l) -> Context l -> Context l
amap l -> l
f (CxSingle l
l Asst l
asst ) = l -> Asst l -> Context l
forall l. l -> Asst l -> Context l
CxSingle (l -> l
f l
l) Asst l
asst
    amap l -> l
f (CxTuple  l
l [Asst l]
assts) = l -> [Asst l] -> Context l
forall l. l -> [Asst l] -> Context l
CxTuple  (l -> l
f l
l) [Asst l]
assts
    amap l -> l
f (CxEmpty l
l) = l -> Context l
forall l. l -> Context l
CxEmpty (l -> l
f l
l)

instance Annotated Asst where
    ann :: forall l. Asst l -> l
ann Asst l
asst = case Asst l
asst of
        TypeA l
l Type l
_        -> l
l
        IParam l
l IPName l
_ Type l
_     -> l
l
        ParenA l
l Asst l
_       -> l
l
    amap :: forall l. (l -> l) -> Asst l -> Asst l
amap l -> l
f Asst l
asst = case Asst l
asst of
        TypeA l
l Type l
t           -> l -> Type l -> Asst l
forall l. l -> Type l -> Asst l
TypeA (l -> l
f l
l) Type l
t
        IParam l
l IPName l
ipn Type l
t      -> l -> IPName l -> Type l -> Asst l
forall l. l -> IPName l -> Type l -> Asst l
IParam (l -> l
f l
l) IPName l
ipn Type l
t
        ParenA l
l Asst l
a          -> l -> Asst l -> Asst l
forall l. l -> Asst l -> Asst l
ParenA (l -> l
f l
l) Asst l
a

instance Annotated Literal where
    ann :: forall l. Literal l -> l
ann Literal l
lit = case Literal l
lit of
        Char    l
l Char
_    String
_  -> l
l
        String  l
l String
_    String
_  -> l
l
        Int     l
l Integer
_    String
_  -> l
l
        Frac    l
l Rational
_    String
_  -> l
l
        PrimInt    l
l Integer
_ String
_  -> l
l
        PrimWord   l
l Integer
_ String
_  -> l
l
        PrimFloat  l
l Rational
_ String
_  -> l
l
        PrimDouble l
l Rational
_ String
_  -> l
l
        PrimChar   l
l Char
_ String
_  -> l
l
        PrimString l
l String
_ String
_  -> l
l
    amap :: forall l. (l -> l) -> Literal l -> Literal l
amap = (l -> l) -> Literal l -> Literal l
forall a b. (a -> b) -> Literal a -> Literal b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap

instance Annotated Sign where
    ann :: forall l. Sign l -> l
ann Sign l
sg = case Sign l
sg of
        Signless l
l -> l
l
        Negative l
l -> l
l
    amap :: forall l. (l -> l) -> Sign l -> Sign l
amap = (l -> l) -> Sign l -> Sign l
forall a b. (a -> b) -> Sign a -> Sign b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap

instance Annotated Exp where
    ann :: forall l. Exp l -> l
ann Exp l
e = case Exp l
e of
        Var l
l QName l
_                -> l
l
        OverloadedLabel l
l String
_    -> l
l
        IPVar l
l IPName l
_              -> l
l
        Con l
l QName l
_                -> l
l
        Lit l
l Literal l
_                -> l
l
        InfixApp l
l Exp l
_ QOp l
_ Exp l
_       -> l
l
        App l
l Exp l
_ Exp l
_              -> l
l
        NegApp l
l Exp l
_             -> l
l
        Lambda l
l [Pat l]
_ Exp l
_           -> l
l
        Let l
l Binds l
_ Exp l
_              -> l
l
        If l
l Exp l
_ Exp l
_ Exp l
_             -> l
l
        MultiIf l
l [GuardedRhs l]
_            -> l
l
        Case l
l Exp l
_ [Alt l]
_             -> l
l
        Do l
l [Stmt l]
_                 -> l
l
        MDo l
l [Stmt l]
_                -> l
l
        Tuple l
l Boxed
_ [Exp l]
_            -> l
l
        UnboxedSum l
l Int
_ Int
_ Exp l
_     -> l
l
        TupleSection l
l Boxed
_ [Maybe (Exp l)]
_     -> l
l
        List l
l [Exp l]
_               -> l
l
        ParArray l
l [Exp l]
_           -> l
l
        Paren l
l Exp l
_              -> l
l
        LeftSection l
l Exp l
_ QOp l
_      -> l
l
        RightSection l
l QOp l
_ Exp l
_     -> l
l
        RecConstr l
l QName l
_ [FieldUpdate l]
_        -> l
l
        RecUpdate l
l Exp l
_ [FieldUpdate l]
_        -> l
l
        EnumFrom l
l Exp l
_           -> l
l
        EnumFromTo l
l Exp l
_ Exp l
_       -> l
l
        EnumFromThen l
l Exp l
_ Exp l
_     -> l
l
        EnumFromThenTo l
l Exp l
_ Exp l
_ Exp l
_ -> l
l
        ParArrayFromTo l
l Exp l
_ Exp l
_   -> l
l
        ParArrayFromThenTo l
l Exp l
_ Exp l
_ Exp l
_ -> l
l
        ListComp l
l Exp l
_ [QualStmt l]
_         -> l
l
        ParComp  l
l Exp l
_ [[QualStmt l]]
_         -> l
l
        ParArrayComp  l
l Exp l
_ [[QualStmt l]]
_    -> l
l
        ExpTypeSig l
l Exp l
_ Type l
_       -> l
l
        VarQuote l
l QName l
_           -> l
l
        TypQuote l
l QName l
_           -> l
l
        BracketExp l
l Bracket l
_         -> l
l
        SpliceExp l
l Splice l
_          -> l
l
        QuasiQuote l
l String
_ String
_       -> l
l
        TypeApp l
l Type l
_            -> l
l

        XTag  l
l XName l
_ [XAttr l]
_ Maybe (Exp l)
_ [Exp l]
_        -> l
l
        XETag l
l XName l
_ [XAttr l]
_ Maybe (Exp l)
_          -> l
l
        XPcdata l
l String
_            -> l
l
        XExpTag l
l Exp l
_            -> l
l
        XChildTag l
l [Exp l]
_          -> l
l

        CorePragma l
l String
_ Exp l
_       -> l
l
        SCCPragma  l
l String
_ Exp l
_       -> l
l
        GenPragma  l
l String
_ (Int, Int)
_ (Int, Int)
_ Exp l
_   -> l
l

        Proc            l
l Pat l
_ Exp l
_  -> l
l
        LeftArrApp      l
l Exp l
_ Exp l
_  -> l
l
        RightArrApp     l
l Exp l
_ Exp l
_  -> l
l
        LeftArrHighApp  l
l Exp l
_ Exp l
_  -> l
l
        RightArrHighApp l
l Exp l
_ Exp l
_  -> l
l
        ArrOp           l
l Exp l
_    -> l
l

        LCase l
l [Alt l]
_              -> l
l

    amap :: forall l. (l -> l) -> Exp l -> Exp l
amap l -> l
f Exp l
e1 = case Exp l
e1 of
        Var l
l QName l
qn        -> l -> QName l -> Exp l
forall l. l -> QName l -> Exp l
Var (l -> l
f l
l) QName l
qn
        OverloadedLabel l
l String
qn -> l -> String -> Exp l
forall l. l -> String -> Exp l
OverloadedLabel (l -> l
f l
l) String
qn
        IPVar l
l IPName l
ipn     -> l -> IPName l -> Exp l
forall l. l -> IPName l -> Exp l
IPVar (l -> l
f l
l) IPName l
ipn
        Con l
l QName l
qn        -> l -> QName l -> Exp l
forall l. l -> QName l -> Exp l
Con (l -> l
f l
l) QName l
qn
        Lit l
l Literal l
lit       -> l -> Literal l -> Exp l
forall l. l -> Literal l -> Exp l
Lit (l -> l
f l
l) Literal l
lit
        InfixApp l
l Exp l
e1' QOp l
qop Exp l
e2    -> l -> Exp l -> QOp l -> Exp l -> Exp l
forall l. l -> Exp l -> QOp l -> Exp l -> Exp l
InfixApp (l -> l
f l
l) Exp l
e1' QOp l
qop Exp l
e2
        App l
l Exp l
e1' Exp l
e2    -> l -> Exp l -> Exp l -> Exp l
forall l. l -> Exp l -> Exp l -> Exp l
App (l -> l
f l
l) Exp l
e1' Exp l
e2
        NegApp l
l Exp l
e      -> l -> Exp l -> Exp l
forall l. l -> Exp l -> Exp l
NegApp (l -> l
f l
l) Exp l
e
        Lambda l
l [Pat l]
ps Exp l
e   -> l -> [Pat l] -> Exp l -> Exp l
forall l. l -> [Pat l] -> Exp l -> Exp l
Lambda (l -> l
f l
l) [Pat l]
ps Exp l
e
        Let l
l Binds l
bs Exp l
e      -> l -> Binds l -> Exp l -> Exp l
forall l. l -> Binds l -> Exp l -> Exp l
Let (l -> l
f l
l) Binds l
bs Exp l
e
        If l
l Exp l
ec Exp l
et Exp l
ee   -> l -> Exp l -> Exp l -> Exp l -> Exp l
forall l. l -> Exp l -> Exp l -> Exp l -> Exp l
If (l -> l
f l
l) Exp l
ec Exp l
et Exp l
ee
        Case l
l Exp l
e [Alt l]
alts   -> l -> Exp l -> [Alt l] -> Exp l
forall l. l -> Exp l -> [Alt l] -> Exp l
Case (l -> l
f l
l) Exp l
e [Alt l]
alts
        Do l
l [Stmt l]
ss         -> l -> [Stmt l] -> Exp l
forall l. l -> [Stmt l] -> Exp l
Do (l -> l
f l
l) [Stmt l]
ss
        MDo l
l [Stmt l]
ss        -> l -> [Stmt l] -> Exp l
forall l. l -> [Stmt l] -> Exp l
MDo (l -> l
f l
l) [Stmt l]
ss
        Tuple l
l Boxed
bx [Exp l]
es   -> l -> Boxed -> [Exp l] -> Exp l
forall l. l -> Boxed -> [Exp l] -> Exp l
Tuple (l -> l
f l
l) Boxed
bx [Exp l]
es
        UnboxedSum l
l Int
b Int
a Exp l
es -> l -> Int -> Int -> Exp l -> Exp l
forall l. l -> Int -> Int -> Exp l -> Exp l
UnboxedSum (l -> l
f l
l) Int
b Int
a Exp l
es
        TupleSection l
l Boxed
bx [Maybe (Exp l)]
mes -> l -> Boxed -> [Maybe (Exp l)] -> Exp l
forall l. l -> Boxed -> [Maybe (Exp l)] -> Exp l
TupleSection (l -> l
f l
l) Boxed
bx [Maybe (Exp l)]
mes
        List l
l [Exp l]
es       -> l -> [Exp l] -> Exp l
forall l. l -> [Exp l] -> Exp l
List (l -> l
f l
l) [Exp l]
es
        ParArray l
l [Exp l]
es   -> l -> [Exp l] -> Exp l
forall l. l -> [Exp l] -> Exp l
ParArray (l -> l
f l
l) [Exp l]
es
        Paren l
l Exp l
e       -> l -> Exp l -> Exp l
forall l. l -> Exp l -> Exp l
Paren (l -> l
f l
l) Exp l
e
        LeftSection l
l Exp l
e QOp l
qop     -> l -> Exp l -> QOp l -> Exp l
forall l. l -> Exp l -> QOp l -> Exp l
LeftSection (l -> l
f l
l) Exp l
e QOp l
qop
        RightSection l
l QOp l
qop Exp l
e    -> l -> QOp l -> Exp l -> Exp l
forall l. l -> QOp l -> Exp l -> Exp l
RightSection (l -> l
f l
l) QOp l
qop Exp l
e
        RecConstr l
l QName l
qn [FieldUpdate l]
fups     -> l -> QName l -> [FieldUpdate l] -> Exp l
forall l. l -> QName l -> [FieldUpdate l] -> Exp l
RecConstr (l -> l
f l
l) QName l
qn [FieldUpdate l]
fups
        RecUpdate l
l Exp l
e  [FieldUpdate l]
fups     -> l -> Exp l -> [FieldUpdate l] -> Exp l
forall l. l -> Exp l -> [FieldUpdate l] -> Exp l
RecUpdate (l -> l
f l
l) Exp l
e  [FieldUpdate l]
fups
        EnumFrom l
l Exp l
e            -> l -> Exp l -> Exp l
forall l. l -> Exp l -> Exp l
EnumFrom (l -> l
f l
l) Exp l
e
        EnumFromTo l
l Exp l
ef Exp l
et      -> l -> Exp l -> Exp l -> Exp l
forall l. l -> Exp l -> Exp l -> Exp l
EnumFromTo (l -> l
f l
l) Exp l
ef Exp l
et
        EnumFromThen l
l Exp l
ef Exp l
et    -> l -> Exp l -> Exp l -> Exp l
forall l. l -> Exp l -> Exp l -> Exp l
EnumFromThen (l -> l
f l
l) Exp l
ef Exp l
et
        EnumFromThenTo l
l Exp l
ef Exp l
eth Exp l
eto -> l -> Exp l -> Exp l -> Exp l -> Exp l
forall l. l -> Exp l -> Exp l -> Exp l -> Exp l
EnumFromThenTo (l -> l
f l
l) Exp l
ef Exp l
eth Exp l
eto
        ParArrayFromTo l
l Exp l
ef Exp l
et  -> l -> Exp l -> Exp l -> Exp l
forall l. l -> Exp l -> Exp l -> Exp l
ParArrayFromTo (l -> l
f l
l) Exp l
ef Exp l
et
        ParArrayFromThenTo l
l Exp l
ef Exp l
eth Exp l
eto -> l -> Exp l -> Exp l -> Exp l -> Exp l
forall l. l -> Exp l -> Exp l -> Exp l -> Exp l
ParArrayFromThenTo (l -> l
f l
l) Exp l
ef Exp l
eth Exp l
eto
        ListComp l
l Exp l
e [QualStmt l]
qss        -> l -> Exp l -> [QualStmt l] -> Exp l
forall l. l -> Exp l -> [QualStmt l] -> Exp l
ListComp (l -> l
f l
l) Exp l
e [QualStmt l]
qss
        ParComp  l
l Exp l
e [[QualStmt l]]
qsss       -> l -> Exp l -> [[QualStmt l]] -> Exp l
forall l. l -> Exp l -> [[QualStmt l]] -> Exp l
ParComp  (l -> l
f l
l) Exp l
e [[QualStmt l]]
qsss
        ParArrayComp  l
l Exp l
e [[QualStmt l]]
qsss  -> l -> Exp l -> [[QualStmt l]] -> Exp l
forall l. l -> Exp l -> [[QualStmt l]] -> Exp l
ParArrayComp  (l -> l
f l
l) Exp l
e [[QualStmt l]]
qsss
        ExpTypeSig l
l Exp l
e Type l
t        -> l -> Exp l -> Type l -> Exp l
forall l. l -> Exp l -> Type l -> Exp l
ExpTypeSig (l -> l
f l
l) Exp l
e Type l
t
        VarQuote l
l QName l
qn           -> l -> QName l -> Exp l
forall l. l -> QName l -> Exp l
VarQuote (l -> l
f l
l) QName l
qn
        TypQuote l
l QName l
qn           -> l -> QName l -> Exp l
forall l. l -> QName l -> Exp l
TypQuote (l -> l
f l
l) QName l
qn
        BracketExp l
l Bracket l
br         -> l -> Bracket l -> Exp l
forall l. l -> Bracket l -> Exp l
BracketExp (l -> l
f l
l) Bracket l
br
        SpliceExp l
l Splice l
sp          -> l -> Splice l -> Exp l
forall l. l -> Splice l -> Exp l
SpliceExp (l -> l
f l
l) Splice l
sp
        QuasiQuote l
l String
sn String
se      -> l -> String -> String -> Exp l
forall l. l -> String -> String -> Exp l
QuasiQuote (l -> l
f l
l) String
sn String
se
        TypeApp l
l Type l
t             -> l -> Type l -> Exp l
forall l. l -> Type l -> Exp l
TypeApp (l -> l
f l
l) Type l
t

        XTag  l
l XName l
xn [XAttr l]
xas Maybe (Exp l)
me [Exp l]
es     -> l -> XName l -> [XAttr l] -> Maybe (Exp l) -> [Exp l] -> Exp l
forall l.
l -> XName l -> [XAttr l] -> Maybe (Exp l) -> [Exp l] -> Exp l
XTag  (l -> l
f l
l) XName l
xn [XAttr l]
xas Maybe (Exp l)
me [Exp l]
es
        XETag l
l XName l
xn [XAttr l]
xas Maybe (Exp l)
me        -> l -> XName l -> [XAttr l] -> Maybe (Exp l) -> Exp l
forall l. l -> XName l -> [XAttr l] -> Maybe (Exp l) -> Exp l
XETag (l -> l
f l
l) XName l
xn [XAttr l]
xas Maybe (Exp l)
me
        XPcdata l
l String
s              -> l -> String -> Exp l
forall l. l -> String -> Exp l
XPcdata (l -> l
f l
l) String
s
        XExpTag l
l Exp l
e              -> l -> Exp l -> Exp l
forall l. l -> Exp l -> Exp l
XExpTag (l -> l
f l
l) Exp l
e
        XChildTag l
l [Exp l]
es           -> l -> [Exp l] -> Exp l
forall l. l -> [Exp l] -> Exp l
XChildTag (l -> l
f l
l) [Exp l]
es

        CorePragma l
l String
s Exp l
e   -> l -> String -> Exp l -> Exp l
forall l. l -> String -> Exp l -> Exp l
CorePragma (l -> l
f l
l) String
s Exp l
e
        SCCPragma  l
l String
s Exp l
e   -> l -> String -> Exp l -> Exp l
forall l. l -> String -> Exp l -> Exp l
SCCPragma (l -> l
f l
l) String
s Exp l
e
        GenPragma  l
l String
s (Int, Int)
n12 (Int, Int)
n34 Exp l
e -> l -> String -> (Int, Int) -> (Int, Int) -> Exp l -> Exp l
forall l. l -> String -> (Int, Int) -> (Int, Int) -> Exp l -> Exp l
GenPragma (l -> l
f l
l) String
s (Int, Int)
n12 (Int, Int)
n34 Exp l
e

        Proc            l
l Pat l
p Exp l
e  -> l -> Pat l -> Exp l -> Exp l
forall l. l -> Pat l -> Exp l -> Exp l
Proc (l -> l
f l
l) Pat l
p Exp l
e
        LeftArrApp      l
l Exp l
e1' Exp l
e2 -> l -> Exp l -> Exp l -> Exp l
forall l. l -> Exp l -> Exp l -> Exp l
LeftArrApp      (l -> l
f l
l) Exp l
e1' Exp l
e2
        RightArrApp     l
l Exp l
e1' Exp l
e2 -> l -> Exp l -> Exp l -> Exp l
forall l. l -> Exp l -> Exp l -> Exp l
RightArrApp     (l -> l
f l
l) Exp l
e1' Exp l
e2
        LeftArrHighApp  l
l Exp l
e1' Exp l
e2 -> l -> Exp l -> Exp l -> Exp l
forall l. l -> Exp l -> Exp l -> Exp l
LeftArrHighApp  (l -> l
f l
l) Exp l
e1' Exp l
e2
        RightArrHighApp l
l Exp l
e1' Exp l
e2 -> l -> Exp l -> Exp l -> Exp l
forall l. l -> Exp l -> Exp l -> Exp l
RightArrHighApp (l -> l
f l
l) Exp l
e1' Exp l
e2
        ArrOp           l
l Exp l
e      -> l -> Exp l -> Exp l
forall l. l -> Exp l -> Exp l
ArrOp           (l -> l
f l
l) Exp l
e

        LCase l
l [Alt l]
alts -> l -> [Alt l] -> Exp l
forall l. l -> [Alt l] -> Exp l
LCase (l -> l
f l
l) [Alt l]
alts
        MultiIf l
l [GuardedRhs l]
alts -> l -> [GuardedRhs l] -> Exp l
forall l. l -> [GuardedRhs l] -> Exp l
MultiIf (l -> l
f l
l) [GuardedRhs l]
alts


instance Annotated XName where
    ann :: forall l. XName l -> l
ann (XName l
l String
_)      = l
l
    ann (XDomName l
l String
_ String
_) = l
l
    amap :: forall l. (l -> l) -> XName l -> XName l
amap = (l -> l) -> XName l -> XName l
forall a b. (a -> b) -> XName a -> XName b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap

instance Annotated XAttr where
    ann :: forall l. XAttr l -> l
ann (XAttr l
l XName l
_ Exp l
_) = l
l
    amap :: forall l. (l -> l) -> XAttr l -> XAttr l
amap l -> l
f (XAttr l
l XName l
xn Exp l
e) = l -> XName l -> Exp l -> XAttr l
forall l. l -> XName l -> Exp l -> XAttr l
XAttr (l -> l
f l
l) XName l
xn Exp l
e

instance Annotated Bracket where
    ann :: forall l. Bracket l -> l
ann (ExpBracket l
l Exp l
_)  = l
l
    ann (TExpBracket l
l Exp l
_) = l
l
    ann (PatBracket l
l Pat l
_)  = l
l
    ann (TypeBracket l
l Type l
_) = l
l
    ann (DeclBracket l
l [Decl l]
_) = l
l
    amap :: forall l. (l -> l) -> Bracket l -> Bracket l
amap l -> l
f (ExpBracket l
l Exp l
e) = l -> Exp l -> Bracket l
forall l. l -> Exp l -> Bracket l
ExpBracket (l -> l
f l
l) Exp l
e
    amap l -> l
f (TExpBracket l
l Exp l
e) = l -> Exp l -> Bracket l
forall l. l -> Exp l -> Bracket l
TExpBracket (l -> l
f l
l) Exp l
e
    amap l -> l
f (PatBracket l
l Pat l
p) = l -> Pat l -> Bracket l
forall l. l -> Pat l -> Bracket l
PatBracket (l -> l
f l
l) Pat l
p
    amap l -> l
f (TypeBracket l
l Type l
t) = l -> Type l -> Bracket l
forall l. l -> Type l -> Bracket l
TypeBracket (l -> l
f l
l) Type l
t
    amap l -> l
f (DeclBracket l
l [Decl l]
ds) = l -> [Decl l] -> Bracket l
forall l. l -> [Decl l] -> Bracket l
DeclBracket (l -> l
f l
l) [Decl l]
ds

instance Annotated Splice where
    ann :: forall l. Splice l -> l
ann (IdSplice l
l String
_)    = l
l
    ann (TIdSplice l
l String
_)   = l
l
    ann (ParenSplice l
l Exp l
_) = l
l
    ann (TParenSplice l
l Exp l
_) = l
l
    amap :: forall l. (l -> l) -> Splice l -> Splice l
amap l -> l
f (IdSplice l
l String
s) = l -> String -> Splice l
forall l. l -> String -> Splice l
IdSplice (l -> l
f l
l) String
s
    amap l -> l
f (TIdSplice l
l String
s) = l -> String -> Splice l
forall l. l -> String -> Splice l
TIdSplice (l -> l
f l
l) String
s
    amap l -> l
f (ParenSplice l
l Exp l
e) = l -> Exp l -> Splice l
forall l. l -> Exp l -> Splice l
ParenSplice (l -> l
f l
l) Exp l
e
    amap l -> l
f (TParenSplice l
l Exp l
e) = l -> Exp l -> Splice l
forall l. l -> Exp l -> Splice l
TParenSplice (l -> l
f l
l) Exp l
e

instance Annotated Safety where
    ann :: forall l. Safety l -> l
ann (PlayRisky l
l) = l
l
    ann (PlaySafe l
l Bool
_) = l
l
    ann (PlayInterruptible l
l) = l
l
    amap :: forall l. (l -> l) -> Safety l -> Safety l
amap = (l -> l) -> Safety l -> Safety l
forall a b. (a -> b) -> Safety a -> Safety b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap

instance Annotated CallConv where
    ann :: forall l. CallConv l -> l
ann (StdCall l
l) = l
l
    ann (CCall l
l) = l
l
    ann (CPlusPlus l
l) = l
l
    ann (DotNet l
l) = l
l
    ann (Jvm l
l) = l
l
    ann (Js l
l) = l
l
    ann (JavaScript l
l) = l
l
    ann (CApi l
l) = l
l
    amap :: forall l. (l -> l) -> CallConv l -> CallConv l
amap = (l -> l) -> CallConv l -> CallConv l
forall a b. (a -> b) -> CallConv a -> CallConv b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap

instance Annotated ModulePragma where
    ann :: forall l. ModulePragma l -> l
ann (LanguagePragma   l
l [Name l]
_)   = l
l
    ann (OptionsPragma    l
l Maybe Tool
_ String
_) = l
l
    ann (AnnModulePragma  l
l Annotation l
_)   = l
l
    amap :: forall l. (l -> l) -> ModulePragma l -> ModulePragma l
amap l -> l
f (LanguagePragma   l
l [Name l]
ns) = l -> [Name l] -> ModulePragma l
forall l. l -> [Name l] -> ModulePragma l
LanguagePragma (l -> l
f l
l) [Name l]
ns
    amap l -> l
f (AnnModulePragma  l
l Annotation l
a) = l -> Annotation l -> ModulePragma l
forall l. l -> Annotation l -> ModulePragma l
AnnModulePragma (l -> l
f l
l) Annotation l
a
    amap l -> l
f ModulePragma l
p = (l -> l) -> ModulePragma l -> ModulePragma l
forall a b. (a -> b) -> ModulePragma a -> ModulePragma b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap l -> l
f ModulePragma l
p

instance Annotated Overlap where
    ann :: forall l. Overlap l -> l
ann (NoOverlap l
l)  = l
l
    ann (Overlap l
l)    = l
l
    ann (Overlaps l
l)   = l
l
    ann (Overlappable l
l) = l
l
    ann (Overlapping l
l)  = l
l
    ann (Incoherent l
l) = l
l
    amap :: forall l. (l -> l) -> Overlap l -> Overlap l
amap = (l -> l) -> Overlap l -> Overlap l
forall a b. (a -> b) -> Overlap a -> Overlap b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap

instance Annotated Activation where
    ann :: forall l. Activation l -> l
ann (ActiveFrom   l
l Int
_) = l
l
    ann (ActiveUntil  l
l Int
_) = l
l
    amap :: forall l. (l -> l) -> Activation l -> Activation l
amap = (l -> l) -> Activation l -> Activation l
forall a b. (a -> b) -> Activation a -> Activation b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap

instance Annotated Rule where
    ann :: forall l. Rule l -> l
ann (Rule l
l String
_ Maybe (Activation l)
_ Maybe [RuleVar l]
_ Exp l
_ Exp l
_) = l
l
    amap :: forall l. (l -> l) -> Rule l -> Rule l
amap l -> l
f (Rule l
l String
s Maybe (Activation l)
act Maybe [RuleVar l]
mrvs Exp l
e1 Exp l
e2) = l
-> String
-> Maybe (Activation l)
-> Maybe [RuleVar l]
-> Exp l
-> Exp l
-> Rule l
forall l.
l
-> String
-> Maybe (Activation l)
-> Maybe [RuleVar l]
-> Exp l
-> Exp l
-> Rule l
Rule (l -> l
f l
l) String
s Maybe (Activation l)
act Maybe [RuleVar l]
mrvs Exp l
e1 Exp l
e2

instance Annotated RuleVar where
    ann :: forall l. RuleVar l -> l
ann (RuleVar l
l Name l
_)        = l
l
    ann (TypedRuleVar l
l Name l
_ Type l
_) = l
l
    amap :: forall l. (l -> l) -> RuleVar l -> RuleVar l
amap l -> l
f (RuleVar l
l Name l
n) = l -> Name l -> RuleVar l
forall l. l -> Name l -> RuleVar l
RuleVar (l -> l
f l
l) Name l
n
    amap l -> l
f (TypedRuleVar l
l Name l
n Type l
t) = l -> Name l -> Type l -> RuleVar l
forall l. l -> Name l -> Type l -> RuleVar l
TypedRuleVar (l -> l
f l
l) Name l
n Type l
t

instance Annotated WarningText where
    ann :: forall l. WarningText l -> l
ann (DeprText l
l String
_) = l
l
    ann (WarnText l
l String
_) = l
l
    amap :: forall l. (l -> l) -> WarningText l -> WarningText l
amap = (l -> l) -> WarningText l -> WarningText l
forall a b. (a -> b) -> WarningText a -> WarningText b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap

instance Annotated Pat where
    ann :: forall l. Pat l -> l
ann Pat l
p = case Pat l
p of
      PVar l
l Name l
_          -> l
l
      PLit l
l Sign l
_ Literal l
_        -> l
l
      PNPlusK l
l Name l
_ Integer
_     -> l
l
      PInfixApp l
l Pat l
_ QName l
_ Pat l
_ -> l
l
      PApp l
l QName l
_ [Pat l]
_        -> l
l
      PTuple l
l Boxed
_ [Pat l]
_      -> l
l
      PUnboxedSum l
l Int
_ Int
_ Pat l
_ -> l
l
      PList l
l [Pat l]
_         -> l
l
      PParen l
l Pat l
_        -> l
l
      PRec l
l QName l
_ [PatField l]
_        -> l
l
      PAsPat l
l Name l
_ Pat l
_      -> l
l
      PWildCard l
l       -> l
l
      PIrrPat l
l Pat l
_       -> l
l
      PatTypeSig l
l Pat l
_ Type l
_  -> l
l
      PViewPat l
l Exp l
_ Pat l
_    -> l
l
      PRPat l
l [RPat l]
_         -> l
l
      PXTag l
l XName l
_ [PXAttr l]
_ Maybe (Pat l)
_ [Pat l]
_   -> l
l
      PXETag l
l XName l
_ [PXAttr l]
_ Maybe (Pat l)
_    -> l
l
      PXPcdata l
l String
_      -> l
l
      PXPatTag l
l Pat l
_      -> l
l
      PXRPats  l
l [RPat l]
_      -> l
l
      PSplice l
l Splice l
_       -> l
l
      PQuasiQuote l
l String
_ String
_ -> l
l
      PBangPat l
l Pat l
_      -> l
l
    amap :: forall l. (l -> l) -> Pat l -> Pat l
amap l -> l
f Pat l
p1 = case Pat l
p1 of
      PVar l
l Name l
n          -> l -> Name l -> Pat l
forall l. l -> Name l -> Pat l
PVar (l -> l
f l
l) Name l
n
      PLit l
l Sign l
sg Literal l
lit     -> l -> Sign l -> Literal l -> Pat l
forall l. l -> Sign l -> Literal l -> Pat l
PLit (l -> l
f l
l) Sign l
sg Literal l
lit
      PNPlusK l
l Name l
n Integer
k     -> l -> Name l -> Integer -> Pat l
forall l. l -> Name l -> Integer -> Pat l
PNPlusK (l -> l
f l
l) Name l
n Integer
k
      PInfixApp l
l Pat l
pa QName l
qn Pat l
pb  -> l -> Pat l -> QName l -> Pat l -> Pat l
forall l. l -> Pat l -> QName l -> Pat l -> Pat l
PInfixApp (l -> l
f l
l) Pat l
pa QName l
qn Pat l
pb
      PApp l
l QName l
qn [Pat l]
ps      -> l -> QName l -> [Pat l] -> Pat l
forall l. l -> QName l -> [Pat l] -> Pat l
PApp (l -> l
f l
l) QName l
qn [Pat l]
ps
      PTuple l
l Boxed
bx [Pat l]
ps    -> l -> Boxed -> [Pat l] -> Pat l
forall l. l -> Boxed -> [Pat l] -> Pat l
PTuple (l -> l
f l
l) Boxed
bx [Pat l]
ps
      PUnboxedSum l
l Int
b Int
a Pat l
ps -> l -> Int -> Int -> Pat l -> Pat l
forall l. l -> Int -> Int -> Pat l -> Pat l
PUnboxedSum (l -> l
f l
l) Int
b Int
a Pat l
ps
      PList l
l [Pat l]
ps        -> l -> [Pat l] -> Pat l
forall l. l -> [Pat l] -> Pat l
PList (l -> l
f l
l) [Pat l]
ps
      PParen l
l Pat l
p        -> l -> Pat l -> Pat l
forall l. l -> Pat l -> Pat l
PParen (l -> l
f l
l) Pat l
p
      PRec l
l QName l
qn [PatField l]
pfs     -> l -> QName l -> [PatField l] -> Pat l
forall l. l -> QName l -> [PatField l] -> Pat l
PRec (l -> l
f l
l) QName l
qn [PatField l]
pfs
      PAsPat l
l Name l
n Pat l
p      -> l -> Name l -> Pat l -> Pat l
forall l. l -> Name l -> Pat l -> Pat l
PAsPat (l -> l
f l
l) Name l
n Pat l
p
      PWildCard l
l       -> l -> Pat l
forall l. l -> Pat l
PWildCard (l -> l
f l
l)
      PIrrPat l
l Pat l
p       -> l -> Pat l -> Pat l
forall l. l -> Pat l -> Pat l
PIrrPat (l -> l
f l
l) Pat l
p
      PatTypeSig l
l Pat l
p Type l
t  -> l -> Pat l -> Type l -> Pat l
forall l. l -> Pat l -> Type l -> Pat l
PatTypeSig (l -> l
f l
l) Pat l
p Type l
t
      PViewPat l
l Exp l
e Pat l
p    -> l -> Exp l -> Pat l -> Pat l
forall l. l -> Exp l -> Pat l -> Pat l
PViewPat (l -> l
f l
l) Exp l
e Pat l
p
      PRPat l
l [RPat l]
rps       -> l -> [RPat l] -> Pat l
forall l. l -> [RPat l] -> Pat l
PRPat (l -> l
f l
l) [RPat l]
rps
      PXTag l
l XName l
xn [PXAttr l]
pxas Maybe (Pat l)
mp [Pat l]
ps -> l -> XName l -> [PXAttr l] -> Maybe (Pat l) -> [Pat l] -> Pat l
forall l.
l -> XName l -> [PXAttr l] -> Maybe (Pat l) -> [Pat l] -> Pat l
PXTag  (l -> l
f l
l) XName l
xn [PXAttr l]
pxas Maybe (Pat l)
mp [Pat l]
ps
      PXETag l
l XName l
xn [PXAttr l]
pxas Maybe (Pat l)
mp   -> l -> XName l -> [PXAttr l] -> Maybe (Pat l) -> Pat l
forall l. l -> XName l -> [PXAttr l] -> Maybe (Pat l) -> Pat l
PXETag (l -> l
f l
l) XName l
xn [PXAttr l]
pxas Maybe (Pat l)
mp
      PXPcdata l
l String
s      -> l -> String -> Pat l
forall l. l -> String -> Pat l
PXPcdata (l -> l
f l
l) String
s
      PXPatTag l
l Pat l
p      -> l -> Pat l -> Pat l
forall l. l -> Pat l -> Pat l
PXPatTag (l -> l
f l
l) Pat l
p
      PXRPats  l
l [RPat l]
rps    -> l -> [RPat l] -> Pat l
forall l. l -> [RPat l] -> Pat l
PXRPats  (l -> l
f l
l) [RPat l]
rps
      PSplice l
l Splice l
sp      -> l -> Splice l -> Pat l
forall l. l -> Splice l -> Pat l
PSplice (l -> l
f l
l) Splice l
sp
      PQuasiQuote l
l String
sn String
st   -> l -> String -> String -> Pat l
forall l. l -> String -> String -> Pat l
PQuasiQuote (l -> l
f l
l) String
sn String
st
      PBangPat l
l Pat l
p          -> l -> Pat l -> Pat l
forall l. l -> Pat l -> Pat l
PBangPat (l -> l
f l
l) Pat l
p

instance Annotated PXAttr where
    ann :: forall l. PXAttr l -> l
ann (PXAttr l
l XName l
_ Pat l
_) = l
l
    amap :: forall l. (l -> l) -> PXAttr l -> PXAttr l
amap l -> l
f (PXAttr l
l XName l
xn Pat l
p) = l -> XName l -> Pat l -> PXAttr l
forall l. l -> XName l -> Pat l -> PXAttr l
PXAttr (l -> l
f l
l) XName l
xn Pat l
p

instance Annotated RPatOp where
    ann :: forall l. RPatOp l -> l
ann (RPStar  l
l) = l
l
    ann (RPStarG l
l) = l
l
    ann (RPPlus  l
l) = l
l
    ann (RPPlusG l
l) = l
l
    ann (RPOpt   l
l) = l
l
    ann (RPOptG  l
l) = l
l
    amap :: forall l. (l -> l) -> RPatOp l -> RPatOp l
amap = (l -> l) -> RPatOp l -> RPatOp l
forall a b. (a -> b) -> RPatOp a -> RPatOp b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap

instance Annotated RPat where
    ann :: forall l. RPat l -> l
ann RPat l
rp = case RPat l
rp of
      RPOp l
l RPat l
_ RPatOp l
_            -> l
l
      RPEither l
l RPat l
_ RPat l
_        -> l
l
      RPSeq l
l [RPat l]
_             -> l
l
      RPGuard l
l Pat l
_ [Stmt l]
_         -> l
l
      RPCAs l
l Name l
_ RPat l
_           -> l
l
      RPAs l
l Name l
_ RPat l
_            -> l
l
      RPParen l
l RPat l
_           -> l
l
      RPPat l
l Pat l
_             -> l
l
    amap :: forall l. (l -> l) -> RPat l -> RPat l
amap l -> l
f RPat l
rp1 = case RPat l
rp1 of
      RPOp l
l RPat l
rp RPatOp l
rop         -> l -> RPat l -> RPatOp l -> RPat l
forall l. l -> RPat l -> RPatOp l -> RPat l
RPOp (l -> l
f l
l) RPat l
rp RPatOp l
rop
      RPEither l
l RPat l
rp1' RPat l
rp2   -> l -> RPat l -> RPat l -> RPat l
forall l. l -> RPat l -> RPat l -> RPat l
RPEither (l -> l
f l
l) RPat l
rp1' RPat l
rp2
      RPSeq l
l [RPat l]
rps           -> l -> [RPat l] -> RPat l
forall l. l -> [RPat l] -> RPat l
RPSeq (l -> l
f l
l) [RPat l]
rps
      RPGuard l
l Pat l
p [Stmt l]
ss        -> l -> Pat l -> [Stmt l] -> RPat l
forall l. l -> Pat l -> [Stmt l] -> RPat l
RPGuard (l -> l
f l
l) Pat l
p [Stmt l]
ss
      RPCAs l
l Name l
n RPat l
rp          -> l -> Name l -> RPat l -> RPat l
forall l. l -> Name l -> RPat l -> RPat l
RPCAs (l -> l
f l
l) Name l
n RPat l
rp
      RPAs l
l Name l
n RPat l
rp           -> l -> Name l -> RPat l -> RPat l
forall l. l -> Name l -> RPat l -> RPat l
RPAs (l -> l
f l
l) Name l
n RPat l
rp
      RPParen l
l RPat l
rp          -> l -> RPat l -> RPat l
forall l. l -> RPat l -> RPat l
RPParen (l -> l
f l
l) RPat l
rp
      RPPat l
l Pat l
p             -> l -> Pat l -> RPat l
forall l. l -> Pat l -> RPat l
RPPat (l -> l
f l
l) Pat l
p

instance Annotated PatField where
    ann :: forall l. PatField l -> l
ann (PFieldPat l
l QName l
_ Pat l
_)  = l
l
    ann (PFieldPun l
l QName l
_)    = l
l
    ann (PFieldWildcard l
l) = l
l
    amap :: forall l. (l -> l) -> PatField l -> PatField l
amap l -> l
f (PFieldPat l
l QName l
qn Pat l
p) = l -> QName l -> Pat l -> PatField l
forall l. l -> QName l -> Pat l -> PatField l
PFieldPat (l -> l
f l
l) QName l
qn Pat l
p
    amap l -> l
f (PFieldPun l
l QName l
n) = l -> QName l -> PatField l
forall l. l -> QName l -> PatField l
PFieldPun (l -> l
f l
l) QName l
n
    amap l -> l
f (PFieldWildcard l
l) = l -> PatField l
forall l. l -> PatField l
PFieldWildcard (l -> l
f l
l)

instance Annotated Stmt where
    ann :: forall l. Stmt l -> l
ann (Generator l
l Pat l
_ Exp l
_) = l
l
    ann (Qualifier l
l Exp l
_)   = l
l
    ann (LetStmt l
l Binds l
_)     = l
l
    ann (RecStmt l
l [Stmt l]
_)     = l
l
    amap :: forall l. (l -> l) -> Stmt l -> Stmt l
amap l -> l
f (Generator l
l Pat l
p Exp l
e) = l -> Pat l -> Exp l -> Stmt l
forall l. l -> Pat l -> Exp l -> Stmt l
Generator (l -> l
f l
l) Pat l
p Exp l
e
    amap l -> l
f (Qualifier l
l Exp l
e)   = l -> Exp l -> Stmt l
forall l. l -> Exp l -> Stmt l
Qualifier (l -> l
f l
l) Exp l
e
    amap l -> l
f (LetStmt l
l Binds l
bs)    = l -> Binds l -> Stmt l
forall l. l -> Binds l -> Stmt l
LetStmt (l -> l
f l
l) Binds l
bs
    amap l -> l
f (RecStmt l
l [Stmt l]
ss)    = l -> [Stmt l] -> Stmt l
forall l. l -> [Stmt l] -> Stmt l
RecStmt (l -> l
f l
l) [Stmt l]
ss

instance Annotated QualStmt where
    ann :: forall l. QualStmt l -> l
ann (QualStmt     l
l Stmt l
_)   = l
l
    ann (ThenTrans    l
l Exp l
_)   = l
l
    ann (ThenBy       l
l Exp l
_ Exp l
_) = l
l
    ann (GroupBy      l
l Exp l
_)   = l
l
    ann (GroupUsing   l
l Exp l
_)   = l
l
    ann (GroupByUsing l
l Exp l
_ Exp l
_) = l
l
    amap :: forall l. (l -> l) -> QualStmt l -> QualStmt l
amap l -> l
f (QualStmt     l
l Stmt l
s) = l -> Stmt l -> QualStmt l
forall l. l -> Stmt l -> QualStmt l
QualStmt (l -> l
f l
l) Stmt l
s
    amap l -> l
f (ThenTrans    l
l Exp l
e) = l -> Exp l -> QualStmt l
forall l. l -> Exp l -> QualStmt l
ThenTrans (l -> l
f l
l) Exp l
e
    amap l -> l
f (ThenBy       l
l Exp l
e1 Exp l
e2) = l -> Exp l -> Exp l -> QualStmt l
forall l. l -> Exp l -> Exp l -> QualStmt l
ThenBy (l -> l
f l
l) Exp l
e1 Exp l
e2
    amap l -> l
f (GroupBy      l
l Exp l
e) = l -> Exp l -> QualStmt l
forall l. l -> Exp l -> QualStmt l
GroupBy (l -> l
f l
l) Exp l
e
    amap l -> l
f (GroupUsing   l
l Exp l
e) = l -> Exp l -> QualStmt l
forall l. l -> Exp l -> QualStmt l
GroupUsing (l -> l
f l
l) Exp l
e
    amap l -> l
f (GroupByUsing l
l Exp l
e1 Exp l
e2) = l -> Exp l -> Exp l -> QualStmt l
forall l. l -> Exp l -> Exp l -> QualStmt l
GroupByUsing (l -> l
f l
l) Exp l
e1 Exp l
e2

instance Annotated FieldUpdate where
    ann :: forall l. FieldUpdate l -> l
ann (FieldUpdate l
l QName l
_ Exp l
_)  = l
l
    ann (FieldPun l
l QName l
_)       = l
l
    ann (FieldWildcard l
l)    = l
l
    amap :: forall l. (l -> l) -> FieldUpdate l -> FieldUpdate l
amap l -> l
f (FieldUpdate l
l QName l
qn Exp l
e) = l -> QName l -> Exp l -> FieldUpdate l
forall l. l -> QName l -> Exp l -> FieldUpdate l
FieldUpdate (l -> l
f l
l) QName l
qn Exp l
e
    amap l -> l
f (FieldPun l
l QName l
n)       = l -> QName l -> FieldUpdate l
forall l. l -> QName l -> FieldUpdate l
FieldPun (l -> l
f l
l) QName l
n
    amap l -> l
f (FieldWildcard l
l)    = l -> FieldUpdate l
forall l. l -> FieldUpdate l
FieldWildcard (l -> l
f l
l)

instance Annotated Alt where
    ann :: forall l. Alt l -> l
ann (Alt l
l Pat l
_ Rhs l
_ Maybe (Binds l)
_) = l
l
    amap :: forall l. (l -> l) -> Alt l -> Alt l
amap l -> l
f (Alt l
l Pat l
p Rhs l
gs Maybe (Binds l)
bs) = l -> Pat l -> Rhs l -> Maybe (Binds l) -> Alt l
forall l. l -> Pat l -> Rhs l -> Maybe (Binds l) -> Alt l
Alt (l -> l
f l
l) Pat l
p Rhs l
gs Maybe (Binds l)
bs

instance Annotated Promoted where
    ann :: forall l. Promoted l -> l
ann (PromotedInteger l
l Integer
_ String
_) = l
l
    ann (PromotedString l
l String
_ String
_)  = l
l
    ann (PromotedCon l
l Bool
_ QName l
_)     = l
l
    ann (PromotedList l
l Bool
_ [Type l]
_)    = l
l
    ann (PromotedTuple l
l [Type l]
_)     = l
l
    ann (PromotedUnit l
l)        = l
l
    amap :: forall l. (l -> l) -> Promoted l -> Promoted l
amap l -> l
f (PromotedInteger l
l Integer
int String
raw) = l -> Integer -> String -> Promoted l
forall l. l -> Integer -> String -> Promoted l
PromotedInteger (l -> l
f l
l) Integer
int String
raw
    amap l -> l
f (PromotedString l
l String
str String
raw) = l -> String -> String -> Promoted l
forall l. l -> String -> String -> Promoted l
PromotedString (l -> l
f l
l) String
str String
raw
    amap l -> l
f (PromotedCon l
l Bool
b QName l
qn)   = l -> Bool -> QName l -> Promoted l
forall l. l -> Bool -> QName l -> Promoted l
PromotedCon (l -> l
f l
l) Bool
b QName l
qn
    amap l -> l
f (PromotedList l
l Bool
b [Type l]
ps)  = l -> Bool -> [Type l] -> Promoted l
forall l. l -> Bool -> [Type l] -> Promoted l
PromotedList  (l -> l
f l
l) Bool
b [Type l]
ps
    amap l -> l
f (PromotedTuple l
l [Type l]
ps) = l -> [Type l] -> Promoted l
forall l. l -> [Type l] -> Promoted l
PromotedTuple (l -> l
f l
l) [Type l]
ps
    amap l -> l
f (PromotedUnit l
l)     = l -> Promoted l
forall l. l -> Promoted l
PromotedUnit (l -> l
f l
l)