{-# LANGUAGE DeriveAnyClass #-}

-- |
--
-- Module      : Aihc.Parser.Syntax
-- Description : Abstract Syntax Tree
-- License     : Unlicense
--
-- Abstract Syntax Tree (AST) covering Haskell2010 plus all language extensions.
module Aihc.Parser.Syntax
  ( ArithSeq (..),
    BangType (..),
    BinderName,
    CallConv (..),
    CaseAlt (..),
    ClassDecl (..),
    ClassDeclItem (..),
    CompStmt (..),
    Constraint (..),
    DataConDecl (..),
    DataDecl (..),
    Decl (..),
    DerivingClause (..),
    DerivingStrategy (..),
    DoStmt (..),
    Expr (..),
    Extension (..),
    ExtensionSetting (..),
    ExportSpec (..),
    FieldDecl (..),
    FixityAssoc (..),
    ForeignDecl (..),
    ForeignDirection (..),
    ForeignEntitySpec (..),
    ForeignSafety (..),
    GadtBody (..),
    GuardQualifier (..),
    GuardedRhs (..),
    ImportDecl (..),
    ImportLevel (..),
    ImportItem (..),
    ImportSpec (..),
    InstanceDecl (..),
    InstanceDeclItem (..),
    Literal (..),
    Match (..),
    Module (..),
    ModuleHead (..),
    WarningText (..),
    NewtypeDecl (..),
    OperatorName,
    Pattern (..),
    Rhs (..),
    HasSourceSpan (..),
    SourceSpan (..),
    StandaloneDerivingDecl (..),
    Type (..),
    TypeLiteral (..),
    TypePromotion (..),
    TyVarBinder (..),
    TypeSynDecl (..),
    ValueDecl (..),
    declValueBinderNames,
    allKnownExtensions,
    extensionName,
    extensionSettingName,
    gadtBodyResultType,
    mergeSourceSpans,
    noSourceSpan,
    parseExtensionName,
    parseExtensionSettingName,
    sourceSpanEnd,
    valueDeclBinderName,
    moduleName,
    moduleWarningText,
    moduleExports,
  )
where

import Control.Applicative ((<|>))
import Control.DeepSeq (NFData)
import Data.Data (Data)
import Data.Text (Text)
import Data.Text qualified as T
import GHC.Generics (Generic)
import Text.Read (readMaybe)

data Extension
  = AllowAmbiguousTypes
  | AlternativeLayoutRule
  | AlternativeLayoutRuleTransitional
  | ApplicativeDo
  | Arrows
  | AutoDeriveTypeable
  | BangPatterns
  | BinaryLiterals
  | BlockArguments
  | CApiFFI
  | ConstrainedClassMethods
  | ConstraintKinds
  | CPP
  | CUSKs
  | DataKinds
  | DatatypeContexts
  | DeepSubsumption
  | DefaultSignatures
  | DeriveAnyClass
  | DeriveDataTypeable
  | DeriveFoldable
  | DeriveFunctor
  | DeriveGeneric
  | DeriveLift
  | DeriveTraversable
  | DerivingStrategies
  | DerivingVia
  | DisambiguateRecordFields
  | DoAndIfThenElse
  | DoRec
  | DuplicateRecordFields
  | EmptyCase
  | EmptyDataDecls
  | EmptyDataDeriving
  | ExistentialQuantification
  | ExplicitForAll
  | ExplicitLevelImports
  | ExplicitNamespaces
  | ExtensibleRecords
  | ExtendedDefaultRules
  | ExtendedLiterals
  | FieldSelectors
  | FlexibleContexts
  | FlexibleInstances
  | ForeignFunctionInterface
  | FunctionalDependencies
  | GADTs
  | GADTSyntax
  | Generics
  | GeneralizedNewtypeDeriving
  | GHC2021
  | GHC2024
  | GHCForeignImportPrim
  | Haskell2010
  | Haskell98
  | HereDocuments
  | HexFloatLiterals
  | ImplicitParams
  | ImplicitPrelude
  | ImplicitStagePersistence
  | ImportQualifiedPost
  | ImpredicativeTypes
  | IncoherentInstances
  | InstanceSigs
  | InterruptibleFFI
  | JavaScriptFFI
  | KindSignatures
  | LambdaCase
  | LexicalNegation
  | LiberalTypeSynonyms
  | LinearTypes
  | ListTuplePuns
  | MagicHash
  | MonadComprehensions
  | MonadFailDesugaring
  | MonoLocalBinds
  | MonoPatBinds
  | MonomorphismRestriction
  | MultilineStrings
  | MultiParamTypeClasses
  | MultiWayIf
  | NamedDefaults
  | NamedFieldPuns
  | NamedWildCards
  | NewQualifiedOperators
  | NegativeLiterals
  | NondecreasingIndentation
  | NPlusKPatterns
  | NullaryTypeClasses
  | NumDecimals
  | NumericUnderscores
  | OrPatterns
  | OverlappingInstances
  | OverloadedLabels
  | OverloadedLists
  | OverloadedRecordDot
  | OverloadedRecordUpdate
  | OverloadedStrings
  | PackageImports
  | ParallelArrays
  | ParallelListComp
  | PartialTypeSignatures
  | PatternSignatures
  | PatternGuards
  | PatternSynonyms
  | PolymorphicComponents
  | PolyKinds
  | PostfixOperators
  | QualifiedDo
  | QualifiedStrings
  | QuantifiedConstraints
  | QuasiQuotes
  | Rank2Types
  | RankNTypes
  | RebindableSyntax
  | RecordPuns
  | RecordWildCards
  | RecursiveDo
  | RegularPatterns
  | RelaxedLayout
  | RelaxedPolyRec
  | RestrictedTypeSynonyms
  | RequiredTypeArguments
  | RoleAnnotations
  | SafeImports
  | SafeHaskell
  | ScopedTypeVariables
  | StandaloneDeriving
  | StandaloneKindSignatures
  | StarIsType
  | StaticPointers
  | Strict
  | StrictData
  | TemplateHaskell
  | TemplateHaskellQuotes
  | TraditionalRecordSyntax
  | TransformListComp
  | Trustworthy
  | TupleSections
  | TypeAbstractions
  | TypeApplications
  | TypeData
  | TypeFamilies
  | TypeFamilyDependencies
  | TypeInType
  | TypeOperators
  | TypeSynonymInstances
  | UnboxedSums
  | UnboxedTuples
  | UndecidableInstances
  | UndecidableSuperClasses
  | UnicodeSyntax
  | UnliftedDatatypes
  | UnliftedFFITypes
  | UnliftedNewtypes
  | UnsafeHaskell
  | ViewPatterns
  | XmlSyntax
  deriving (Extension -> Extension -> Bool
(Extension -> Extension -> Bool)
-> (Extension -> Extension -> Bool) -> Eq Extension
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Extension -> Extension -> Bool
== :: Extension -> Extension -> Bool
$c/= :: Extension -> Extension -> Bool
/= :: Extension -> Extension -> Bool
Eq, Eq Extension
Eq Extension =>
(Extension -> Extension -> Ordering)
-> (Extension -> Extension -> Bool)
-> (Extension -> Extension -> Bool)
-> (Extension -> Extension -> Bool)
-> (Extension -> Extension -> Bool)
-> (Extension -> Extension -> Extension)
-> (Extension -> Extension -> Extension)
-> Ord Extension
Extension -> Extension -> Bool
Extension -> Extension -> Ordering
Extension -> Extension -> Extension
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 :: Extension -> Extension -> Ordering
compare :: Extension -> Extension -> Ordering
$c< :: Extension -> Extension -> Bool
< :: Extension -> Extension -> Bool
$c<= :: Extension -> Extension -> Bool
<= :: Extension -> Extension -> Bool
$c> :: Extension -> Extension -> Bool
> :: Extension -> Extension -> Bool
$c>= :: Extension -> Extension -> Bool
>= :: Extension -> Extension -> Bool
$cmax :: Extension -> Extension -> Extension
max :: Extension -> Extension -> Extension
$cmin :: Extension -> Extension -> Extension
min :: Extension -> Extension -> Extension
Ord, Int -> Extension -> ShowS
[Extension] -> ShowS
Extension -> String
(Int -> Extension -> ShowS)
-> (Extension -> String)
-> ([Extension] -> ShowS)
-> Show Extension
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Extension -> ShowS
showsPrec :: Int -> Extension -> ShowS
$cshow :: Extension -> String
show :: Extension -> String
$cshowList :: [Extension] -> ShowS
showList :: [Extension] -> ShowS
Show, ReadPrec [Extension]
ReadPrec Extension
Int -> ReadS Extension
ReadS [Extension]
(Int -> ReadS Extension)
-> ReadS [Extension]
-> ReadPrec Extension
-> ReadPrec [Extension]
-> Read Extension
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Extension
readsPrec :: Int -> ReadS Extension
$creadList :: ReadS [Extension]
readList :: ReadS [Extension]
$creadPrec :: ReadPrec Extension
readPrec :: ReadPrec Extension
$creadListPrec :: ReadPrec [Extension]
readListPrec :: ReadPrec [Extension]
Read, Int -> Extension
Extension -> Int
Extension -> [Extension]
Extension -> Extension
Extension -> Extension -> [Extension]
Extension -> Extension -> Extension -> [Extension]
(Extension -> Extension)
-> (Extension -> Extension)
-> (Int -> Extension)
-> (Extension -> Int)
-> (Extension -> [Extension])
-> (Extension -> Extension -> [Extension])
-> (Extension -> Extension -> [Extension])
-> (Extension -> Extension -> Extension -> [Extension])
-> Enum Extension
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: Extension -> Extension
succ :: Extension -> Extension
$cpred :: Extension -> Extension
pred :: Extension -> Extension
$ctoEnum :: Int -> Extension
toEnum :: Int -> Extension
$cfromEnum :: Extension -> Int
fromEnum :: Extension -> Int
$cenumFrom :: Extension -> [Extension]
enumFrom :: Extension -> [Extension]
$cenumFromThen :: Extension -> Extension -> [Extension]
enumFromThen :: Extension -> Extension -> [Extension]
$cenumFromTo :: Extension -> Extension -> [Extension]
enumFromTo :: Extension -> Extension -> [Extension]
$cenumFromThenTo :: Extension -> Extension -> Extension -> [Extension]
enumFromThenTo :: Extension -> Extension -> Extension -> [Extension]
Enum, Extension
Extension -> Extension -> Bounded Extension
forall a. a -> a -> Bounded a
$cminBound :: Extension
minBound :: Extension
$cmaxBound :: Extension
maxBound :: Extension
Bounded, (forall x. Extension -> Rep Extension x)
-> (forall x. Rep Extension x -> Extension) -> Generic Extension
forall x. Rep Extension x -> Extension
forall x. Extension -> Rep Extension x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Extension -> Rep Extension x
from :: forall x. Extension -> Rep Extension x
$cto :: forall x. Rep Extension x -> Extension
to :: forall x. Rep Extension x -> Extension
Generic, Extension -> ()
(Extension -> ()) -> NFData Extension
forall a. (a -> ()) -> NFData a
$crnf :: Extension -> ()
rnf :: Extension -> ()
NFData)

data ExtensionSetting
  = EnableExtension Extension
  | DisableExtension Extension
  deriving (ExtensionSetting -> ExtensionSetting -> Bool
(ExtensionSetting -> ExtensionSetting -> Bool)
-> (ExtensionSetting -> ExtensionSetting -> Bool)
-> Eq ExtensionSetting
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ExtensionSetting -> ExtensionSetting -> Bool
== :: ExtensionSetting -> ExtensionSetting -> Bool
$c/= :: ExtensionSetting -> ExtensionSetting -> Bool
/= :: ExtensionSetting -> ExtensionSetting -> Bool
Eq, Eq ExtensionSetting
Eq ExtensionSetting =>
(ExtensionSetting -> ExtensionSetting -> Ordering)
-> (ExtensionSetting -> ExtensionSetting -> Bool)
-> (ExtensionSetting -> ExtensionSetting -> Bool)
-> (ExtensionSetting -> ExtensionSetting -> Bool)
-> (ExtensionSetting -> ExtensionSetting -> Bool)
-> (ExtensionSetting -> ExtensionSetting -> ExtensionSetting)
-> (ExtensionSetting -> ExtensionSetting -> ExtensionSetting)
-> Ord ExtensionSetting
ExtensionSetting -> ExtensionSetting -> Bool
ExtensionSetting -> ExtensionSetting -> Ordering
ExtensionSetting -> ExtensionSetting -> ExtensionSetting
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 :: ExtensionSetting -> ExtensionSetting -> Ordering
compare :: ExtensionSetting -> ExtensionSetting -> Ordering
$c< :: ExtensionSetting -> ExtensionSetting -> Bool
< :: ExtensionSetting -> ExtensionSetting -> Bool
$c<= :: ExtensionSetting -> ExtensionSetting -> Bool
<= :: ExtensionSetting -> ExtensionSetting -> Bool
$c> :: ExtensionSetting -> ExtensionSetting -> Bool
> :: ExtensionSetting -> ExtensionSetting -> Bool
$c>= :: ExtensionSetting -> ExtensionSetting -> Bool
>= :: ExtensionSetting -> ExtensionSetting -> Bool
$cmax :: ExtensionSetting -> ExtensionSetting -> ExtensionSetting
max :: ExtensionSetting -> ExtensionSetting -> ExtensionSetting
$cmin :: ExtensionSetting -> ExtensionSetting -> ExtensionSetting
min :: ExtensionSetting -> ExtensionSetting -> ExtensionSetting
Ord, Int -> ExtensionSetting -> ShowS
[ExtensionSetting] -> ShowS
ExtensionSetting -> String
(Int -> ExtensionSetting -> ShowS)
-> (ExtensionSetting -> String)
-> ([ExtensionSetting] -> ShowS)
-> Show ExtensionSetting
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ExtensionSetting -> ShowS
showsPrec :: Int -> ExtensionSetting -> ShowS
$cshow :: ExtensionSetting -> String
show :: ExtensionSetting -> String
$cshowList :: [ExtensionSetting] -> ShowS
showList :: [ExtensionSetting] -> ShowS
Show, ReadPrec [ExtensionSetting]
ReadPrec ExtensionSetting
Int -> ReadS ExtensionSetting
ReadS [ExtensionSetting]
(Int -> ReadS ExtensionSetting)
-> ReadS [ExtensionSetting]
-> ReadPrec ExtensionSetting
-> ReadPrec [ExtensionSetting]
-> Read ExtensionSetting
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS ExtensionSetting
readsPrec :: Int -> ReadS ExtensionSetting
$creadList :: ReadS [ExtensionSetting]
readList :: ReadS [ExtensionSetting]
$creadPrec :: ReadPrec ExtensionSetting
readPrec :: ReadPrec ExtensionSetting
$creadListPrec :: ReadPrec [ExtensionSetting]
readListPrec :: ReadPrec [ExtensionSetting]
Read, (forall x. ExtensionSetting -> Rep ExtensionSetting x)
-> (forall x. Rep ExtensionSetting x -> ExtensionSetting)
-> Generic ExtensionSetting
forall x. Rep ExtensionSetting x -> ExtensionSetting
forall x. ExtensionSetting -> Rep ExtensionSetting x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. ExtensionSetting -> Rep ExtensionSetting x
from :: forall x. ExtensionSetting -> Rep ExtensionSetting x
$cto :: forall x. Rep ExtensionSetting x -> ExtensionSetting
to :: forall x. Rep ExtensionSetting x -> ExtensionSetting
Generic, ExtensionSetting -> ()
(ExtensionSetting -> ()) -> NFData ExtensionSetting
forall a. (a -> ()) -> NFData a
$crnf :: ExtensionSetting -> ()
rnf :: ExtensionSetting -> ()
NFData)

allKnownExtensions :: [Extension]
allKnownExtensions :: [Extension]
allKnownExtensions = [Extension
forall a. Bounded a => a
minBound .. Extension
forall a. Bounded a => a
maxBound]

extensionName :: Extension -> Text
extensionName :: Extension -> Text
extensionName Extension
ext =
  case Extension
ext of
    Extension
SafeHaskell -> String -> Text
T.pack String
"Safe"
    Extension
UnsafeHaskell -> String -> Text
T.pack String
"Unsafe"
    Extension
_ -> String -> Text
T.pack (Extension -> String
forall a. Show a => a -> String
show Extension
ext)

extensionSettingName :: ExtensionSetting -> Text
extensionSettingName :: ExtensionSetting -> Text
extensionSettingName ExtensionSetting
setting =
  case ExtensionSetting
setting of
    EnableExtension Extension
ext -> Extension -> Text
extensionName Extension
ext
    DisableExtension Extension
ext -> String -> Text
T.pack String
"No" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Extension -> Text
extensionName Extension
ext

parseExtensionName :: Text -> Maybe Extension
parseExtensionName :: Text -> Maybe Extension
parseExtensionName Text
raw =
  String -> Maybe Extension
forall a. Read a => String -> Maybe a
readMaybe (Text -> String
T.unpack Text
trimmed) Maybe Extension -> Maybe Extension -> Maybe Extension
forall a. Maybe a -> Maybe a -> Maybe a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> String -> [(String, Extension)] -> Maybe Extension
forall a b. Eq a => a -> [(a, b)] -> Maybe b
lookup (Text -> String
T.unpack Text
trimmed) [(String, Extension)]
aliases
  where
    trimmed :: Text
trimmed = Text -> Text
T.strip Text
raw
    aliases :: [(String, Extension)]
aliases =
      [ (String
"Cpp", Extension
CPP),
        (String
"GeneralisedNewtypeDeriving", Extension
GeneralizedNewtypeDeriving),
        (String
"Safe", Extension
SafeHaskell),
        (String
"Unsafe", Extension
UnsafeHaskell)
      ]

parseExtensionSettingName :: Text -> Maybe ExtensionSetting
parseExtensionSettingName :: Text -> Maybe ExtensionSetting
parseExtensionSettingName Text
raw =
  case Text -> Text -> Maybe Text
T.stripPrefix (String -> Text
T.pack String
"No") Text
trimmed of
    Just Text
rest
      | Bool -> Bool
not (Text -> Bool
T.null Text
rest) ->
          case Text -> Maybe Extension
parseExtensionName Text
rest of
            Just Extension
ext -> ExtensionSetting -> Maybe ExtensionSetting
forall a. a -> Maybe a
Just (Extension -> ExtensionSetting
DisableExtension Extension
ext)
            Maybe Extension
Nothing -> Extension -> ExtensionSetting
EnableExtension (Extension -> ExtensionSetting)
-> Maybe Extension -> Maybe ExtensionSetting
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Text -> Maybe Extension
parseExtensionName Text
trimmed
    Maybe Text
_ -> Extension -> ExtensionSetting
EnableExtension (Extension -> ExtensionSetting)
-> Maybe Extension -> Maybe ExtensionSetting
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Text -> Maybe Extension
parseExtensionName Text
trimmed
  where
    trimmed :: Text
trimmed = Text -> Text
T.strip Text
raw

data SourceSpan
  = NoSourceSpan
  | SourceSpan
      { SourceSpan -> Int
sourceSpanStartLine :: !Int,
        SourceSpan -> Int
sourceSpanStartCol :: !Int,
        SourceSpan -> Int
sourceSpanEndLine :: !Int,
        SourceSpan -> Int
sourceSpanEndCol :: !Int
      }
  deriving (Typeable SourceSpan
Typeable SourceSpan =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> SourceSpan -> c SourceSpan)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c SourceSpan)
-> (SourceSpan -> Constr)
-> (SourceSpan -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c SourceSpan))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c SourceSpan))
-> ((forall b. Data b => b -> b) -> SourceSpan -> SourceSpan)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> SourceSpan -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> SourceSpan -> r)
-> (forall u. (forall d. Data d => d -> u) -> SourceSpan -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> SourceSpan -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> SourceSpan -> m SourceSpan)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> SourceSpan -> m SourceSpan)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> SourceSpan -> m SourceSpan)
-> Data SourceSpan
SourceSpan -> Constr
SourceSpan -> DataType
(forall b. Data b => b -> b) -> SourceSpan -> SourceSpan
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) -> SourceSpan -> u
forall u. (forall d. Data d => d -> u) -> SourceSpan -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SourceSpan -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SourceSpan -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SourceSpan -> m SourceSpan
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SourceSpan -> m SourceSpan
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SourceSpan
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SourceSpan -> c SourceSpan
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SourceSpan)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SourceSpan)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SourceSpan -> c SourceSpan
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SourceSpan -> c SourceSpan
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SourceSpan
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SourceSpan
$ctoConstr :: SourceSpan -> Constr
toConstr :: SourceSpan -> Constr
$cdataTypeOf :: SourceSpan -> DataType
dataTypeOf :: SourceSpan -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SourceSpan)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SourceSpan)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SourceSpan)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SourceSpan)
$cgmapT :: (forall b. Data b => b -> b) -> SourceSpan -> SourceSpan
gmapT :: (forall b. Data b => b -> b) -> SourceSpan -> SourceSpan
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SourceSpan -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SourceSpan -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SourceSpan -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SourceSpan -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> SourceSpan -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> SourceSpan -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> SourceSpan -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> SourceSpan -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SourceSpan -> m SourceSpan
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SourceSpan -> m SourceSpan
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SourceSpan -> m SourceSpan
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SourceSpan -> m SourceSpan
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SourceSpan -> m SourceSpan
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SourceSpan -> m SourceSpan
Data, SourceSpan -> SourceSpan -> Bool
(SourceSpan -> SourceSpan -> Bool)
-> (SourceSpan -> SourceSpan -> Bool) -> Eq SourceSpan
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SourceSpan -> SourceSpan -> Bool
== :: SourceSpan -> SourceSpan -> Bool
$c/= :: SourceSpan -> SourceSpan -> Bool
/= :: SourceSpan -> SourceSpan -> Bool
Eq, Eq SourceSpan
Eq SourceSpan =>
(SourceSpan -> SourceSpan -> Ordering)
-> (SourceSpan -> SourceSpan -> Bool)
-> (SourceSpan -> SourceSpan -> Bool)
-> (SourceSpan -> SourceSpan -> Bool)
-> (SourceSpan -> SourceSpan -> Bool)
-> (SourceSpan -> SourceSpan -> SourceSpan)
-> (SourceSpan -> SourceSpan -> SourceSpan)
-> Ord SourceSpan
SourceSpan -> SourceSpan -> Bool
SourceSpan -> SourceSpan -> Ordering
SourceSpan -> SourceSpan -> SourceSpan
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 :: SourceSpan -> SourceSpan -> Ordering
compare :: SourceSpan -> SourceSpan -> Ordering
$c< :: SourceSpan -> SourceSpan -> Bool
< :: SourceSpan -> SourceSpan -> Bool
$c<= :: SourceSpan -> SourceSpan -> Bool
<= :: SourceSpan -> SourceSpan -> Bool
$c> :: SourceSpan -> SourceSpan -> Bool
> :: SourceSpan -> SourceSpan -> Bool
$c>= :: SourceSpan -> SourceSpan -> Bool
>= :: SourceSpan -> SourceSpan -> Bool
$cmax :: SourceSpan -> SourceSpan -> SourceSpan
max :: SourceSpan -> SourceSpan -> SourceSpan
$cmin :: SourceSpan -> SourceSpan -> SourceSpan
min :: SourceSpan -> SourceSpan -> SourceSpan
Ord, Int -> SourceSpan -> ShowS
[SourceSpan] -> ShowS
SourceSpan -> String
(Int -> SourceSpan -> ShowS)
-> (SourceSpan -> String)
-> ([SourceSpan] -> ShowS)
-> Show SourceSpan
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SourceSpan -> ShowS
showsPrec :: Int -> SourceSpan -> ShowS
$cshow :: SourceSpan -> String
show :: SourceSpan -> String
$cshowList :: [SourceSpan] -> ShowS
showList :: [SourceSpan] -> ShowS
Show, (forall x. SourceSpan -> Rep SourceSpan x)
-> (forall x. Rep SourceSpan x -> SourceSpan) -> Generic SourceSpan
forall x. Rep SourceSpan x -> SourceSpan
forall x. SourceSpan -> Rep SourceSpan x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. SourceSpan -> Rep SourceSpan x
from :: forall x. SourceSpan -> Rep SourceSpan x
$cto :: forall x. Rep SourceSpan x -> SourceSpan
to :: forall x. Rep SourceSpan x -> SourceSpan
Generic, SourceSpan -> ()
(SourceSpan -> ()) -> NFData SourceSpan
forall a. (a -> ()) -> NFData a
$crnf :: SourceSpan -> ()
rnf :: SourceSpan -> ()
NFData)

noSourceSpan :: SourceSpan
noSourceSpan :: SourceSpan
noSourceSpan = SourceSpan
NoSourceSpan

class HasSourceSpan a where
  getSourceSpan :: a -> SourceSpan

mergeSourceSpans :: SourceSpan -> SourceSpan -> SourceSpan
mergeSourceSpans :: SourceSpan -> SourceSpan -> SourceSpan
mergeSourceSpans SourceSpan
left SourceSpan
right =
  case (SourceSpan
left, SourceSpan
right) of
    (SourceSpan Int
l1 Int
c1 Int
_ Int
_, SourceSpan Int
_ Int
_ Int
l2 Int
c2) -> Int -> Int -> Int -> Int -> SourceSpan
SourceSpan Int
l1 Int
c1 Int
l2 Int
c2
    (SourceSpan
NoSourceSpan, SourceSpan
span') -> SourceSpan
span'
    (SourceSpan
span', SourceSpan
NoSourceSpan) -> SourceSpan
span'

sourceSpanEnd :: (HasSourceSpan a) => [a] -> SourceSpan
sourceSpanEnd :: forall a. HasSourceSpan a => [a] -> SourceSpan
sourceSpanEnd [a]
xs =
  case [a] -> [a]
forall a. [a] -> [a]
reverse [a]
xs of
    [] -> SourceSpan
NoSourceSpan
    a
x : [a]
_ -> a -> SourceSpan
forall a. HasSourceSpan a => a -> SourceSpan
getSourceSpan a
x

type BinderName = Text

type OperatorName = Text

data WarningText
  = DeprText SourceSpan Text
  | WarnText SourceSpan Text
  deriving (WarningText -> WarningText -> Bool
(WarningText -> WarningText -> Bool)
-> (WarningText -> WarningText -> Bool) -> Eq WarningText
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: WarningText -> WarningText -> Bool
== :: WarningText -> WarningText -> Bool
$c/= :: WarningText -> WarningText -> Bool
/= :: WarningText -> WarningText -> Bool
Eq, Int -> WarningText -> ShowS
[WarningText] -> ShowS
WarningText -> String
(Int -> WarningText -> ShowS)
-> (WarningText -> String)
-> ([WarningText] -> ShowS)
-> Show WarningText
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> WarningText -> ShowS
showsPrec :: Int -> WarningText -> ShowS
$cshow :: WarningText -> String
show :: WarningText -> String
$cshowList :: [WarningText] -> ShowS
showList :: [WarningText] -> ShowS
Show, (forall x. WarningText -> Rep WarningText x)
-> (forall x. Rep WarningText x -> WarningText)
-> Generic WarningText
forall x. Rep WarningText x -> WarningText
forall x. WarningText -> Rep WarningText x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. WarningText -> Rep WarningText x
from :: forall x. WarningText -> Rep WarningText x
$cto :: forall x. Rep WarningText x -> WarningText
to :: forall x. Rep WarningText x -> WarningText
Generic, WarningText -> ()
(WarningText -> ()) -> NFData WarningText
forall a. (a -> ()) -> NFData a
$crnf :: WarningText -> ()
rnf :: WarningText -> ()
NFData)

instance HasSourceSpan WarningText where
  getSourceSpan :: WarningText -> SourceSpan
getSourceSpan WarningText
warningText =
    case WarningText
warningText of
      DeprText SourceSpan
span' Text
_ -> SourceSpan
span'
      WarnText SourceSpan
span' Text
_ -> SourceSpan
span'

data Module = Module
  { Module -> SourceSpan
moduleSpan :: SourceSpan,
    Module -> Maybe ModuleHead
moduleHead :: Maybe ModuleHead,
    Module -> [ExtensionSetting]
moduleLanguagePragmas :: [ExtensionSetting],
    Module -> [ImportDecl]
moduleImports :: [ImportDecl],
    Module -> [Decl]
moduleDecls :: [Decl]
  }
  deriving (Module -> Module -> Bool
(Module -> Module -> Bool)
-> (Module -> Module -> Bool) -> Eq Module
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Module -> Module -> Bool
== :: Module -> Module -> Bool
$c/= :: Module -> Module -> Bool
/= :: Module -> Module -> Bool
Eq, Int -> Module -> ShowS
[Module] -> ShowS
Module -> String
(Int -> Module -> ShowS)
-> (Module -> String) -> ([Module] -> ShowS) -> Show Module
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Module -> ShowS
showsPrec :: Int -> Module -> ShowS
$cshow :: Module -> String
show :: Module -> String
$cshowList :: [Module] -> ShowS
showList :: [Module] -> ShowS
Show, (forall x. Module -> Rep Module x)
-> (forall x. Rep Module x -> Module) -> Generic Module
forall x. Rep Module x -> Module
forall x. Module -> Rep Module x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Module -> Rep Module x
from :: forall x. Module -> Rep Module x
$cto :: forall x. Rep Module x -> Module
to :: forall x. Rep Module x -> Module
Generic, Module -> ()
(Module -> ()) -> NFData Module
forall a. (a -> ()) -> NFData a
$crnf :: Module -> ()
rnf :: Module -> ()
NFData)

instance HasSourceSpan Module where
  getSourceSpan :: Module -> SourceSpan
getSourceSpan = Module -> SourceSpan
moduleSpan

data ModuleHead = ModuleHead
  { ModuleHead -> SourceSpan
moduleHeadSpan :: SourceSpan,
    ModuleHead -> Text
moduleHeadName :: Text,
    ModuleHead -> Maybe WarningText
moduleHeadWarningText :: Maybe WarningText,
    ModuleHead -> Maybe [ExportSpec]
moduleHeadExports :: Maybe [ExportSpec]
  }
  deriving (ModuleHead -> ModuleHead -> Bool
(ModuleHead -> ModuleHead -> Bool)
-> (ModuleHead -> ModuleHead -> Bool) -> Eq ModuleHead
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ModuleHead -> ModuleHead -> Bool
== :: ModuleHead -> ModuleHead -> Bool
$c/= :: ModuleHead -> ModuleHead -> Bool
/= :: ModuleHead -> ModuleHead -> Bool
Eq, Int -> ModuleHead -> ShowS
[ModuleHead] -> ShowS
ModuleHead -> String
(Int -> ModuleHead -> ShowS)
-> (ModuleHead -> String)
-> ([ModuleHead] -> ShowS)
-> Show ModuleHead
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ModuleHead -> ShowS
showsPrec :: Int -> ModuleHead -> ShowS
$cshow :: ModuleHead -> String
show :: ModuleHead -> String
$cshowList :: [ModuleHead] -> ShowS
showList :: [ModuleHead] -> ShowS
Show, (forall x. ModuleHead -> Rep ModuleHead x)
-> (forall x. Rep ModuleHead x -> ModuleHead) -> Generic ModuleHead
forall x. Rep ModuleHead x -> ModuleHead
forall x. ModuleHead -> Rep ModuleHead x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. ModuleHead -> Rep ModuleHead x
from :: forall x. ModuleHead -> Rep ModuleHead x
$cto :: forall x. Rep ModuleHead x -> ModuleHead
to :: forall x. Rep ModuleHead x -> ModuleHead
Generic, ModuleHead -> ()
(ModuleHead -> ()) -> NFData ModuleHead
forall a. (a -> ()) -> NFData a
$crnf :: ModuleHead -> ()
rnf :: ModuleHead -> ()
NFData)

instance HasSourceSpan ModuleHead where
  getSourceSpan :: ModuleHead -> SourceSpan
getSourceSpan = ModuleHead -> SourceSpan
moduleHeadSpan

moduleName :: Module -> Maybe Text
moduleName :: Module -> Maybe Text
moduleName Module
modu = ModuleHead -> Text
moduleHeadName (ModuleHead -> Text) -> Maybe ModuleHead -> Maybe Text
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Module -> Maybe ModuleHead
moduleHead Module
modu

moduleWarningText :: Module -> Maybe WarningText
moduleWarningText :: Module -> Maybe WarningText
moduleWarningText Module
modu = ModuleHead -> Maybe WarningText
moduleHeadWarningText (ModuleHead -> Maybe WarningText)
-> Maybe ModuleHead -> Maybe WarningText
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Module -> Maybe ModuleHead
moduleHead Module
modu

moduleExports :: Module -> Maybe [ExportSpec]
moduleExports :: Module -> Maybe [ExportSpec]
moduleExports Module
modu = ModuleHead -> Maybe [ExportSpec]
moduleHeadExports (ModuleHead -> Maybe [ExportSpec])
-> Maybe ModuleHead -> Maybe [ExportSpec]
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Module -> Maybe ModuleHead
moduleHead Module
modu

data ExportSpec
  = ExportModule SourceSpan Text
  | ExportVar SourceSpan (Maybe Text) Text
  | ExportAbs SourceSpan (Maybe Text) Text
  | ExportAll SourceSpan (Maybe Text) Text
  | ExportWith SourceSpan (Maybe Text) Text [Text]
  deriving (ExportSpec -> ExportSpec -> Bool
(ExportSpec -> ExportSpec -> Bool)
-> (ExportSpec -> ExportSpec -> Bool) -> Eq ExportSpec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ExportSpec -> ExportSpec -> Bool
== :: ExportSpec -> ExportSpec -> Bool
$c/= :: ExportSpec -> ExportSpec -> Bool
/= :: ExportSpec -> ExportSpec -> Bool
Eq, Int -> ExportSpec -> ShowS
[ExportSpec] -> ShowS
ExportSpec -> String
(Int -> ExportSpec -> ShowS)
-> (ExportSpec -> String)
-> ([ExportSpec] -> ShowS)
-> Show ExportSpec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ExportSpec -> ShowS
showsPrec :: Int -> ExportSpec -> ShowS
$cshow :: ExportSpec -> String
show :: ExportSpec -> String
$cshowList :: [ExportSpec] -> ShowS
showList :: [ExportSpec] -> ShowS
Show, (forall x. ExportSpec -> Rep ExportSpec x)
-> (forall x. Rep ExportSpec x -> ExportSpec) -> Generic ExportSpec
forall x. Rep ExportSpec x -> ExportSpec
forall x. ExportSpec -> Rep ExportSpec x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. ExportSpec -> Rep ExportSpec x
from :: forall x. ExportSpec -> Rep ExportSpec x
$cto :: forall x. Rep ExportSpec x -> ExportSpec
to :: forall x. Rep ExportSpec x -> ExportSpec
Generic, ExportSpec -> ()
(ExportSpec -> ()) -> NFData ExportSpec
forall a. (a -> ()) -> NFData a
$crnf :: ExportSpec -> ()
rnf :: ExportSpec -> ()
NFData)

data ImportDecl = ImportDecl
  { ImportDecl -> SourceSpan
importDeclSpan :: SourceSpan,
    ImportDecl -> Maybe ImportLevel
importDeclLevel :: Maybe ImportLevel,
    ImportDecl -> Maybe Text
importDeclPackage :: Maybe Text,
    ImportDecl -> Bool
importDeclQualified :: Bool,
    ImportDecl -> Bool
importDeclQualifiedPost :: Bool,
    ImportDecl -> Text
importDeclModule :: Text,
    ImportDecl -> Maybe Text
importDeclAs :: Maybe Text,
    ImportDecl -> Maybe ImportSpec
importDeclSpec :: Maybe ImportSpec
  }
  deriving (ImportDecl -> ImportDecl -> Bool
(ImportDecl -> ImportDecl -> Bool)
-> (ImportDecl -> ImportDecl -> Bool) -> Eq ImportDecl
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ImportDecl -> ImportDecl -> Bool
== :: ImportDecl -> ImportDecl -> Bool
$c/= :: ImportDecl -> ImportDecl -> Bool
/= :: ImportDecl -> ImportDecl -> Bool
Eq, Int -> ImportDecl -> ShowS
[ImportDecl] -> ShowS
ImportDecl -> String
(Int -> ImportDecl -> ShowS)
-> (ImportDecl -> String)
-> ([ImportDecl] -> ShowS)
-> Show ImportDecl
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ImportDecl -> ShowS
showsPrec :: Int -> ImportDecl -> ShowS
$cshow :: ImportDecl -> String
show :: ImportDecl -> String
$cshowList :: [ImportDecl] -> ShowS
showList :: [ImportDecl] -> ShowS
Show, (forall x. ImportDecl -> Rep ImportDecl x)
-> (forall x. Rep ImportDecl x -> ImportDecl) -> Generic ImportDecl
forall x. Rep ImportDecl x -> ImportDecl
forall x. ImportDecl -> Rep ImportDecl x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. ImportDecl -> Rep ImportDecl x
from :: forall x. ImportDecl -> Rep ImportDecl x
$cto :: forall x. Rep ImportDecl x -> ImportDecl
to :: forall x. Rep ImportDecl x -> ImportDecl
Generic, ImportDecl -> ()
(ImportDecl -> ()) -> NFData ImportDecl
forall a. (a -> ()) -> NFData a
$crnf :: ImportDecl -> ()
rnf :: ImportDecl -> ()
NFData)

instance HasSourceSpan ImportDecl where
  getSourceSpan :: ImportDecl -> SourceSpan
getSourceSpan = ImportDecl -> SourceSpan
importDeclSpan

data ImportLevel
  = ImportLevelQuote
  | ImportLevelSplice
  deriving (ImportLevel -> ImportLevel -> Bool
(ImportLevel -> ImportLevel -> Bool)
-> (ImportLevel -> ImportLevel -> Bool) -> Eq ImportLevel
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ImportLevel -> ImportLevel -> Bool
== :: ImportLevel -> ImportLevel -> Bool
$c/= :: ImportLevel -> ImportLevel -> Bool
/= :: ImportLevel -> ImportLevel -> Bool
Eq, Int -> ImportLevel -> ShowS
[ImportLevel] -> ShowS
ImportLevel -> String
(Int -> ImportLevel -> ShowS)
-> (ImportLevel -> String)
-> ([ImportLevel] -> ShowS)
-> Show ImportLevel
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ImportLevel -> ShowS
showsPrec :: Int -> ImportLevel -> ShowS
$cshow :: ImportLevel -> String
show :: ImportLevel -> String
$cshowList :: [ImportLevel] -> ShowS
showList :: [ImportLevel] -> ShowS
Show, (forall x. ImportLevel -> Rep ImportLevel x)
-> (forall x. Rep ImportLevel x -> ImportLevel)
-> Generic ImportLevel
forall x. Rep ImportLevel x -> ImportLevel
forall x. ImportLevel -> Rep ImportLevel x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. ImportLevel -> Rep ImportLevel x
from :: forall x. ImportLevel -> Rep ImportLevel x
$cto :: forall x. Rep ImportLevel x -> ImportLevel
to :: forall x. Rep ImportLevel x -> ImportLevel
Generic, ImportLevel -> ()
(ImportLevel -> ()) -> NFData ImportLevel
forall a. (a -> ()) -> NFData a
$crnf :: ImportLevel -> ()
rnf :: ImportLevel -> ()
NFData)

data ImportSpec = ImportSpec
  { ImportSpec -> SourceSpan
importSpecSpan :: SourceSpan,
    ImportSpec -> Bool
importSpecHiding :: Bool,
    ImportSpec -> [ImportItem]
importSpecItems :: [ImportItem]
  }
  deriving (ImportSpec -> ImportSpec -> Bool
(ImportSpec -> ImportSpec -> Bool)
-> (ImportSpec -> ImportSpec -> Bool) -> Eq ImportSpec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ImportSpec -> ImportSpec -> Bool
== :: ImportSpec -> ImportSpec -> Bool
$c/= :: ImportSpec -> ImportSpec -> Bool
/= :: ImportSpec -> ImportSpec -> Bool
Eq, Int -> ImportSpec -> ShowS
[ImportSpec] -> ShowS
ImportSpec -> String
(Int -> ImportSpec -> ShowS)
-> (ImportSpec -> String)
-> ([ImportSpec] -> ShowS)
-> Show ImportSpec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ImportSpec -> ShowS
showsPrec :: Int -> ImportSpec -> ShowS
$cshow :: ImportSpec -> String
show :: ImportSpec -> String
$cshowList :: [ImportSpec] -> ShowS
showList :: [ImportSpec] -> ShowS
Show, (forall x. ImportSpec -> Rep ImportSpec x)
-> (forall x. Rep ImportSpec x -> ImportSpec) -> Generic ImportSpec
forall x. Rep ImportSpec x -> ImportSpec
forall x. ImportSpec -> Rep ImportSpec x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. ImportSpec -> Rep ImportSpec x
from :: forall x. ImportSpec -> Rep ImportSpec x
$cto :: forall x. Rep ImportSpec x -> ImportSpec
to :: forall x. Rep ImportSpec x -> ImportSpec
Generic, ImportSpec -> ()
(ImportSpec -> ()) -> NFData ImportSpec
forall a. (a -> ()) -> NFData a
$crnf :: ImportSpec -> ()
rnf :: ImportSpec -> ()
NFData)

instance HasSourceSpan ImportSpec where
  getSourceSpan :: ImportSpec -> SourceSpan
getSourceSpan = ImportSpec -> SourceSpan
importSpecSpan

data ImportItem
  = ImportItemVar SourceSpan (Maybe Text) Text
  | ImportItemAbs SourceSpan (Maybe Text) Text
  | ImportItemAll SourceSpan (Maybe Text) Text
  | ImportItemWith SourceSpan (Maybe Text) Text [Text]
  deriving (ImportItem -> ImportItem -> Bool
(ImportItem -> ImportItem -> Bool)
-> (ImportItem -> ImportItem -> Bool) -> Eq ImportItem
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ImportItem -> ImportItem -> Bool
== :: ImportItem -> ImportItem -> Bool
$c/= :: ImportItem -> ImportItem -> Bool
/= :: ImportItem -> ImportItem -> Bool
Eq, Int -> ImportItem -> ShowS
[ImportItem] -> ShowS
ImportItem -> String
(Int -> ImportItem -> ShowS)
-> (ImportItem -> String)
-> ([ImportItem] -> ShowS)
-> Show ImportItem
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ImportItem -> ShowS
showsPrec :: Int -> ImportItem -> ShowS
$cshow :: ImportItem -> String
show :: ImportItem -> String
$cshowList :: [ImportItem] -> ShowS
showList :: [ImportItem] -> ShowS
Show, (forall x. ImportItem -> Rep ImportItem x)
-> (forall x. Rep ImportItem x -> ImportItem) -> Generic ImportItem
forall x. Rep ImportItem x -> ImportItem
forall x. ImportItem -> Rep ImportItem x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. ImportItem -> Rep ImportItem x
from :: forall x. ImportItem -> Rep ImportItem x
$cto :: forall x. Rep ImportItem x -> ImportItem
to :: forall x. Rep ImportItem x -> ImportItem
Generic, ImportItem -> ()
(ImportItem -> ()) -> NFData ImportItem
forall a. (a -> ()) -> NFData a
$crnf :: ImportItem -> ()
rnf :: ImportItem -> ()
NFData)

data Decl
  = DeclValue SourceSpan ValueDecl
  | DeclTypeSig SourceSpan [BinderName] Type
  | DeclStandaloneKindSig SourceSpan BinderName Type
  | DeclFixity SourceSpan FixityAssoc (Maybe Int) [OperatorName]
  | DeclTypeSyn SourceSpan TypeSynDecl
  | DeclData SourceSpan DataDecl
  | DeclNewtype SourceSpan NewtypeDecl
  | DeclClass SourceSpan ClassDecl
  | DeclInstance SourceSpan InstanceDecl
  | DeclStandaloneDeriving SourceSpan StandaloneDerivingDecl
  | DeclDefault SourceSpan [Type]
  | DeclForeign SourceSpan ForeignDecl
  deriving (Typeable Decl
Typeable Decl =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Decl -> c Decl)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Decl)
-> (Decl -> Constr)
-> (Decl -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Decl))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Decl))
-> ((forall b. Data b => b -> b) -> Decl -> Decl)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Decl -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Decl -> r)
-> (forall u. (forall d. Data d => d -> u) -> Decl -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Decl -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Decl -> m Decl)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Decl -> m Decl)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Decl -> m Decl)
-> Data Decl
Decl -> Constr
Decl -> DataType
(forall b. Data b => b -> b) -> Decl -> Decl
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 -> u
forall u. (forall d. Data d => d -> u) -> Decl -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Decl -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Decl -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Decl -> m Decl
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Decl -> m Decl
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Decl
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Decl -> c Decl
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Decl)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Decl)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Decl -> c Decl
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Decl -> c Decl
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Decl
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Decl
$ctoConstr :: Decl -> Constr
toConstr :: Decl -> Constr
$cdataTypeOf :: Decl -> DataType
dataTypeOf :: Decl -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Decl)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Decl)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Decl)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Decl)
$cgmapT :: (forall b. Data b => b -> b) -> Decl -> Decl
gmapT :: (forall b. Data b => b -> b) -> Decl -> Decl
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Decl -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Decl -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Decl -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Decl -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Decl -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Decl -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Decl -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Decl -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Decl -> m Decl
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Decl -> m Decl
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Decl -> m Decl
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Decl -> m Decl
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Decl -> m Decl
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Decl -> m Decl
Data, Decl -> Decl -> Bool
(Decl -> Decl -> Bool) -> (Decl -> Decl -> Bool) -> Eq Decl
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Decl -> Decl -> Bool
== :: Decl -> Decl -> Bool
$c/= :: Decl -> Decl -> Bool
/= :: Decl -> Decl -> Bool
Eq, Int -> Decl -> ShowS
[Decl] -> ShowS
Decl -> String
(Int -> Decl -> ShowS)
-> (Decl -> String) -> ([Decl] -> ShowS) -> Show Decl
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Decl -> ShowS
showsPrec :: Int -> Decl -> ShowS
$cshow :: Decl -> String
show :: Decl -> String
$cshowList :: [Decl] -> ShowS
showList :: [Decl] -> ShowS
Show, (forall x. Decl -> Rep Decl x)
-> (forall x. Rep Decl x -> Decl) -> Generic Decl
forall x. Rep Decl x -> Decl
forall x. Decl -> Rep Decl x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Decl -> Rep Decl x
from :: forall x. Decl -> Rep Decl x
$cto :: forall x. Rep Decl x -> Decl
to :: forall x. Rep Decl x -> Decl
Generic, Decl -> ()
(Decl -> ()) -> NFData Decl
forall a. (a -> ()) -> NFData a
$crnf :: Decl -> ()
rnf :: Decl -> ()
NFData)

instance HasSourceSpan Decl where
  getSourceSpan :: Decl -> SourceSpan
getSourceSpan Decl
decl =
    case Decl
decl of
      DeclValue SourceSpan
span' ValueDecl
_ -> SourceSpan
span'
      DeclTypeSig SourceSpan
span' [Text]
_ Type
_ -> SourceSpan
span'
      DeclStandaloneKindSig SourceSpan
span' Text
_ Type
_ -> SourceSpan
span'
      DeclFixity SourceSpan
span' FixityAssoc
_ Maybe Int
_ [Text]
_ -> SourceSpan
span'
      DeclTypeSyn SourceSpan
span' TypeSynDecl
_ -> SourceSpan
span'
      DeclData SourceSpan
span' DataDecl
_ -> SourceSpan
span'
      DeclNewtype SourceSpan
span' NewtypeDecl
_ -> SourceSpan
span'
      DeclClass SourceSpan
span' ClassDecl
_ -> SourceSpan
span'
      DeclInstance SourceSpan
span' InstanceDecl
_ -> SourceSpan
span'
      DeclStandaloneDeriving SourceSpan
span' StandaloneDerivingDecl
_ -> SourceSpan
span'
      DeclDefault SourceSpan
span' [Type]
_ -> SourceSpan
span'
      DeclForeign SourceSpan
span' ForeignDecl
_ -> SourceSpan
span'

data ValueDecl
  = FunctionBind SourceSpan BinderName [Match]
  | PatternBind SourceSpan Pattern Rhs
  deriving (Typeable ValueDecl
Typeable ValueDecl =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> ValueDecl -> c ValueDecl)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ValueDecl)
-> (ValueDecl -> Constr)
-> (ValueDecl -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ValueDecl))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ValueDecl))
-> ((forall b. Data b => b -> b) -> ValueDecl -> ValueDecl)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ValueDecl -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ValueDecl -> r)
-> (forall u. (forall d. Data d => d -> u) -> ValueDecl -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> ValueDecl -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ValueDecl -> m ValueDecl)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ValueDecl -> m ValueDecl)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ValueDecl -> m ValueDecl)
-> Data ValueDecl
ValueDecl -> Constr
ValueDecl -> DataType
(forall b. Data b => b -> b) -> ValueDecl -> ValueDecl
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) -> ValueDecl -> u
forall u. (forall d. Data d => d -> u) -> ValueDecl -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ValueDecl -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ValueDecl -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ValueDecl -> m ValueDecl
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ValueDecl -> m ValueDecl
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ValueDecl
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ValueDecl -> c ValueDecl
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ValueDecl)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ValueDecl)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ValueDecl -> c ValueDecl
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ValueDecl -> c ValueDecl
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ValueDecl
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ValueDecl
$ctoConstr :: ValueDecl -> Constr
toConstr :: ValueDecl -> Constr
$cdataTypeOf :: ValueDecl -> DataType
dataTypeOf :: ValueDecl -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ValueDecl)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ValueDecl)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ValueDecl)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ValueDecl)
$cgmapT :: (forall b. Data b => b -> b) -> ValueDecl -> ValueDecl
gmapT :: (forall b. Data b => b -> b) -> ValueDecl -> ValueDecl
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ValueDecl -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ValueDecl -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ValueDecl -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ValueDecl -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> ValueDecl -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> ValueDecl -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ValueDecl -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ValueDecl -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ValueDecl -> m ValueDecl
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ValueDecl -> m ValueDecl
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ValueDecl -> m ValueDecl
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ValueDecl -> m ValueDecl
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ValueDecl -> m ValueDecl
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ValueDecl -> m ValueDecl
Data, ValueDecl -> ValueDecl -> Bool
(ValueDecl -> ValueDecl -> Bool)
-> (ValueDecl -> ValueDecl -> Bool) -> Eq ValueDecl
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ValueDecl -> ValueDecl -> Bool
== :: ValueDecl -> ValueDecl -> Bool
$c/= :: ValueDecl -> ValueDecl -> Bool
/= :: ValueDecl -> ValueDecl -> Bool
Eq, Int -> ValueDecl -> ShowS
[ValueDecl] -> ShowS
ValueDecl -> String
(Int -> ValueDecl -> ShowS)
-> (ValueDecl -> String)
-> ([ValueDecl] -> ShowS)
-> Show ValueDecl
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ValueDecl -> ShowS
showsPrec :: Int -> ValueDecl -> ShowS
$cshow :: ValueDecl -> String
show :: ValueDecl -> String
$cshowList :: [ValueDecl] -> ShowS
showList :: [ValueDecl] -> ShowS
Show, (forall x. ValueDecl -> Rep ValueDecl x)
-> (forall x. Rep ValueDecl x -> ValueDecl) -> Generic ValueDecl
forall x. Rep ValueDecl x -> ValueDecl
forall x. ValueDecl -> Rep ValueDecl x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. ValueDecl -> Rep ValueDecl x
from :: forall x. ValueDecl -> Rep ValueDecl x
$cto :: forall x. Rep ValueDecl x -> ValueDecl
to :: forall x. Rep ValueDecl x -> ValueDecl
Generic, ValueDecl -> ()
(ValueDecl -> ()) -> NFData ValueDecl
forall a. (a -> ()) -> NFData a
$crnf :: ValueDecl -> ()
rnf :: ValueDecl -> ()
NFData)

instance HasSourceSpan ValueDecl where
  getSourceSpan :: ValueDecl -> SourceSpan
getSourceSpan ValueDecl
valueDecl =
    case ValueDecl
valueDecl of
      FunctionBind SourceSpan
span' Text
_ [Match]
_ -> SourceSpan
span'
      PatternBind SourceSpan
span' Pattern
_ Rhs
_ -> SourceSpan
span'

data Match = Match
  { Match -> SourceSpan
matchSpan :: SourceSpan,
    Match -> [Pattern]
matchPats :: [Pattern],
    Match -> Rhs
matchRhs :: Rhs
  }
  deriving (Typeable Match
Typeable Match =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Match -> c Match)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Match)
-> (Match -> Constr)
-> (Match -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Match))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Match))
-> ((forall b. Data b => b -> b) -> Match -> Match)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Match -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Match -> r)
-> (forall u. (forall d. Data d => d -> u) -> Match -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Match -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Match -> m Match)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Match -> m Match)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Match -> m Match)
-> Data Match
Match -> Constr
Match -> DataType
(forall b. Data b => b -> b) -> Match -> Match
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 -> u
forall u. (forall d. Data d => d -> u) -> Match -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Match -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Match -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Match -> m Match
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Match -> m Match
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Match
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Match -> c Match
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Match)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Match)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Match -> c Match
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Match -> c Match
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Match
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Match
$ctoConstr :: Match -> Constr
toConstr :: Match -> Constr
$cdataTypeOf :: Match -> DataType
dataTypeOf :: Match -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Match)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Match)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Match)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Match)
$cgmapT :: (forall b. Data b => b -> b) -> Match -> Match
gmapT :: (forall b. Data b => b -> b) -> Match -> Match
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Match -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Match -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Match -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Match -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Match -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Match -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Match -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Match -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Match -> m Match
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Match -> m Match
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Match -> m Match
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Match -> m Match
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Match -> m Match
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Match -> m Match
Data, Match -> Match -> Bool
(Match -> Match -> Bool) -> (Match -> Match -> Bool) -> Eq Match
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Match -> Match -> Bool
== :: Match -> Match -> Bool
$c/= :: Match -> Match -> Bool
/= :: Match -> Match -> Bool
Eq, Int -> Match -> ShowS
[Match] -> ShowS
Match -> String
(Int -> Match -> ShowS)
-> (Match -> String) -> ([Match] -> ShowS) -> Show Match
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Match -> ShowS
showsPrec :: Int -> Match -> ShowS
$cshow :: Match -> String
show :: Match -> String
$cshowList :: [Match] -> ShowS
showList :: [Match] -> ShowS
Show, (forall x. Match -> Rep Match x)
-> (forall x. Rep Match x -> Match) -> Generic Match
forall x. Rep Match x -> Match
forall x. Match -> Rep Match x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Match -> Rep Match x
from :: forall x. Match -> Rep Match x
$cto :: forall x. Rep Match x -> Match
to :: forall x. Rep Match x -> Match
Generic, Match -> ()
(Match -> ()) -> NFData Match
forall a. (a -> ()) -> NFData a
$crnf :: Match -> ()
rnf :: Match -> ()
NFData)

instance HasSourceSpan Match where
  getSourceSpan :: Match -> SourceSpan
getSourceSpan = Match -> SourceSpan
matchSpan

data Rhs
  = UnguardedRhs SourceSpan Expr
  | GuardedRhss SourceSpan [GuardedRhs]
  deriving (Typeable Rhs
Typeable Rhs =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Rhs -> c Rhs)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Rhs)
-> (Rhs -> Constr)
-> (Rhs -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Rhs))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Rhs))
-> ((forall b. Data b => b -> b) -> Rhs -> Rhs)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Rhs -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Rhs -> r)
-> (forall u. (forall d. Data d => d -> u) -> Rhs -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Rhs -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Rhs -> m Rhs)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Rhs -> m Rhs)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Rhs -> m Rhs)
-> Data Rhs
Rhs -> Constr
Rhs -> DataType
(forall b. Data b => b -> b) -> Rhs -> Rhs
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 -> u
forall u. (forall d. Data d => d -> u) -> Rhs -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Rhs -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Rhs -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Rhs -> m Rhs
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Rhs -> m Rhs
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Rhs
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Rhs -> c Rhs
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Rhs)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Rhs)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Rhs -> c Rhs
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Rhs -> c Rhs
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Rhs
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Rhs
$ctoConstr :: Rhs -> Constr
toConstr :: Rhs -> Constr
$cdataTypeOf :: Rhs -> DataType
dataTypeOf :: Rhs -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Rhs)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Rhs)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Rhs)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Rhs)
$cgmapT :: (forall b. Data b => b -> b) -> Rhs -> Rhs
gmapT :: (forall b. Data b => b -> b) -> Rhs -> Rhs
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Rhs -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Rhs -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Rhs -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Rhs -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Rhs -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Rhs -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Rhs -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Rhs -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Rhs -> m Rhs
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Rhs -> m Rhs
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Rhs -> m Rhs
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Rhs -> m Rhs
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Rhs -> m Rhs
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Rhs -> m Rhs
Data, Rhs -> Rhs -> Bool
(Rhs -> Rhs -> Bool) -> (Rhs -> Rhs -> Bool) -> Eq Rhs
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Rhs -> Rhs -> Bool
== :: Rhs -> Rhs -> Bool
$c/= :: Rhs -> Rhs -> Bool
/= :: Rhs -> Rhs -> Bool
Eq, Int -> Rhs -> ShowS
[Rhs] -> ShowS
Rhs -> String
(Int -> Rhs -> ShowS)
-> (Rhs -> String) -> ([Rhs] -> ShowS) -> Show Rhs
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Rhs -> ShowS
showsPrec :: Int -> Rhs -> ShowS
$cshow :: Rhs -> String
show :: Rhs -> String
$cshowList :: [Rhs] -> ShowS
showList :: [Rhs] -> ShowS
Show, (forall x. Rhs -> Rep Rhs x)
-> (forall x. Rep Rhs x -> Rhs) -> Generic Rhs
forall x. Rep Rhs x -> Rhs
forall x. Rhs -> Rep Rhs x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Rhs -> Rep Rhs x
from :: forall x. Rhs -> Rep Rhs x
$cto :: forall x. Rep Rhs x -> Rhs
to :: forall x. Rep Rhs x -> Rhs
Generic, Rhs -> ()
(Rhs -> ()) -> NFData Rhs
forall a. (a -> ()) -> NFData a
$crnf :: Rhs -> ()
rnf :: Rhs -> ()
NFData)

instance HasSourceSpan Rhs where
  getSourceSpan :: Rhs -> SourceSpan
getSourceSpan Rhs
rhs =
    case Rhs
rhs of
      UnguardedRhs SourceSpan
span' Expr
_ -> SourceSpan
span'
      GuardedRhss SourceSpan
span' [GuardedRhs]
_ -> SourceSpan
span'

data GuardedRhs = GuardedRhs
  { GuardedRhs -> SourceSpan
guardedRhsSpan :: SourceSpan,
    GuardedRhs -> [GuardQualifier]
guardedRhsGuards :: [GuardQualifier],
    GuardedRhs -> Expr
guardedRhsBody :: Expr
  }
  deriving (Typeable GuardedRhs
Typeable GuardedRhs =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> GuardedRhs -> c GuardedRhs)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c GuardedRhs)
-> (GuardedRhs -> Constr)
-> (GuardedRhs -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c GuardedRhs))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c GuardedRhs))
-> ((forall b. Data b => b -> b) -> GuardedRhs -> GuardedRhs)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> GuardedRhs -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> GuardedRhs -> r)
-> (forall u. (forall d. Data d => d -> u) -> GuardedRhs -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> GuardedRhs -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> GuardedRhs -> m GuardedRhs)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> GuardedRhs -> m GuardedRhs)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> GuardedRhs -> m GuardedRhs)
-> Data GuardedRhs
GuardedRhs -> Constr
GuardedRhs -> DataType
(forall b. Data b => b -> b) -> GuardedRhs -> GuardedRhs
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 -> u
forall u. (forall d. Data d => d -> u) -> GuardedRhs -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> GuardedRhs -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> GuardedRhs -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> GuardedRhs -> m GuardedRhs
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> GuardedRhs -> m GuardedRhs
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c GuardedRhs
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> GuardedRhs -> c GuardedRhs
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c GuardedRhs)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c GuardedRhs)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> GuardedRhs -> c GuardedRhs
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> GuardedRhs -> c GuardedRhs
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c GuardedRhs
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c GuardedRhs
$ctoConstr :: GuardedRhs -> Constr
toConstr :: GuardedRhs -> Constr
$cdataTypeOf :: GuardedRhs -> DataType
dataTypeOf :: GuardedRhs -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c GuardedRhs)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c GuardedRhs)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c GuardedRhs)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c GuardedRhs)
$cgmapT :: (forall b. Data b => b -> b) -> GuardedRhs -> GuardedRhs
gmapT :: (forall b. Data b => b -> b) -> GuardedRhs -> GuardedRhs
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> GuardedRhs -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> GuardedRhs -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> GuardedRhs -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> GuardedRhs -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> GuardedRhs -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> GuardedRhs -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> GuardedRhs -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> GuardedRhs -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> GuardedRhs -> m GuardedRhs
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> GuardedRhs -> m GuardedRhs
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> GuardedRhs -> m GuardedRhs
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> GuardedRhs -> m GuardedRhs
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> GuardedRhs -> m GuardedRhs
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> GuardedRhs -> m GuardedRhs
Data, GuardedRhs -> GuardedRhs -> Bool
(GuardedRhs -> GuardedRhs -> Bool)
-> (GuardedRhs -> GuardedRhs -> Bool) -> Eq GuardedRhs
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: GuardedRhs -> GuardedRhs -> Bool
== :: GuardedRhs -> GuardedRhs -> Bool
$c/= :: GuardedRhs -> GuardedRhs -> Bool
/= :: GuardedRhs -> GuardedRhs -> Bool
Eq, Int -> GuardedRhs -> ShowS
[GuardedRhs] -> ShowS
GuardedRhs -> String
(Int -> GuardedRhs -> ShowS)
-> (GuardedRhs -> String)
-> ([GuardedRhs] -> ShowS)
-> Show GuardedRhs
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> GuardedRhs -> ShowS
showsPrec :: Int -> GuardedRhs -> ShowS
$cshow :: GuardedRhs -> String
show :: GuardedRhs -> String
$cshowList :: [GuardedRhs] -> ShowS
showList :: [GuardedRhs] -> ShowS
Show, (forall x. GuardedRhs -> Rep GuardedRhs x)
-> (forall x. Rep GuardedRhs x -> GuardedRhs) -> Generic GuardedRhs
forall x. Rep GuardedRhs x -> GuardedRhs
forall x. GuardedRhs -> Rep GuardedRhs x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. GuardedRhs -> Rep GuardedRhs x
from :: forall x. GuardedRhs -> Rep GuardedRhs x
$cto :: forall x. Rep GuardedRhs x -> GuardedRhs
to :: forall x. Rep GuardedRhs x -> GuardedRhs
Generic, GuardedRhs -> ()
(GuardedRhs -> ()) -> NFData GuardedRhs
forall a. (a -> ()) -> NFData a
$crnf :: GuardedRhs -> ()
rnf :: GuardedRhs -> ()
NFData)

instance HasSourceSpan GuardedRhs where
  getSourceSpan :: GuardedRhs -> SourceSpan
getSourceSpan = GuardedRhs -> SourceSpan
guardedRhsSpan

data GuardQualifier
  = GuardExpr SourceSpan Expr
  | GuardPat SourceSpan Pattern Expr
  | GuardLet SourceSpan [Decl]
  deriving (Typeable GuardQualifier
Typeable GuardQualifier =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> GuardQualifier -> c GuardQualifier)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c GuardQualifier)
-> (GuardQualifier -> Constr)
-> (GuardQualifier -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c GuardQualifier))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c GuardQualifier))
-> ((forall b. Data b => b -> b)
    -> GuardQualifier -> GuardQualifier)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> GuardQualifier -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> GuardQualifier -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> GuardQualifier -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> GuardQualifier -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> GuardQualifier -> m GuardQualifier)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> GuardQualifier -> m GuardQualifier)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> GuardQualifier -> m GuardQualifier)
-> Data GuardQualifier
GuardQualifier -> Constr
GuardQualifier -> DataType
(forall b. Data b => b -> b) -> GuardQualifier -> GuardQualifier
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) -> GuardQualifier -> u
forall u. (forall d. Data d => d -> u) -> GuardQualifier -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> GuardQualifier -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> GuardQualifier -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> GuardQualifier -> m GuardQualifier
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> GuardQualifier -> m GuardQualifier
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c GuardQualifier
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> GuardQualifier -> c GuardQualifier
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c GuardQualifier)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c GuardQualifier)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> GuardQualifier -> c GuardQualifier
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> GuardQualifier -> c GuardQualifier
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c GuardQualifier
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c GuardQualifier
$ctoConstr :: GuardQualifier -> Constr
toConstr :: GuardQualifier -> Constr
$cdataTypeOf :: GuardQualifier -> DataType
dataTypeOf :: GuardQualifier -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c GuardQualifier)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c GuardQualifier)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c GuardQualifier)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c GuardQualifier)
$cgmapT :: (forall b. Data b => b -> b) -> GuardQualifier -> GuardQualifier
gmapT :: (forall b. Data b => b -> b) -> GuardQualifier -> GuardQualifier
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> GuardQualifier -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> GuardQualifier -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> GuardQualifier -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> GuardQualifier -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> GuardQualifier -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> GuardQualifier -> [u]
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> GuardQualifier -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> GuardQualifier -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> GuardQualifier -> m GuardQualifier
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> GuardQualifier -> m GuardQualifier
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> GuardQualifier -> m GuardQualifier
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> GuardQualifier -> m GuardQualifier
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> GuardQualifier -> m GuardQualifier
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> GuardQualifier -> m GuardQualifier
Data, GuardQualifier -> GuardQualifier -> Bool
(GuardQualifier -> GuardQualifier -> Bool)
-> (GuardQualifier -> GuardQualifier -> Bool) -> Eq GuardQualifier
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: GuardQualifier -> GuardQualifier -> Bool
== :: GuardQualifier -> GuardQualifier -> Bool
$c/= :: GuardQualifier -> GuardQualifier -> Bool
/= :: GuardQualifier -> GuardQualifier -> Bool
Eq, Int -> GuardQualifier -> ShowS
[GuardQualifier] -> ShowS
GuardQualifier -> String
(Int -> GuardQualifier -> ShowS)
-> (GuardQualifier -> String)
-> ([GuardQualifier] -> ShowS)
-> Show GuardQualifier
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> GuardQualifier -> ShowS
showsPrec :: Int -> GuardQualifier -> ShowS
$cshow :: GuardQualifier -> String
show :: GuardQualifier -> String
$cshowList :: [GuardQualifier] -> ShowS
showList :: [GuardQualifier] -> ShowS
Show, (forall x. GuardQualifier -> Rep GuardQualifier x)
-> (forall x. Rep GuardQualifier x -> GuardQualifier)
-> Generic GuardQualifier
forall x. Rep GuardQualifier x -> GuardQualifier
forall x. GuardQualifier -> Rep GuardQualifier x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. GuardQualifier -> Rep GuardQualifier x
from :: forall x. GuardQualifier -> Rep GuardQualifier x
$cto :: forall x. Rep GuardQualifier x -> GuardQualifier
to :: forall x. Rep GuardQualifier x -> GuardQualifier
Generic, GuardQualifier -> ()
(GuardQualifier -> ()) -> NFData GuardQualifier
forall a. (a -> ()) -> NFData a
$crnf :: GuardQualifier -> ()
rnf :: GuardQualifier -> ()
NFData)

instance HasSourceSpan GuardQualifier where
  getSourceSpan :: GuardQualifier -> SourceSpan
getSourceSpan GuardQualifier
qualifier =
    case GuardQualifier
qualifier of
      GuardExpr SourceSpan
span' Expr
_ -> SourceSpan
span'
      GuardPat SourceSpan
span' Pattern
_ Expr
_ -> SourceSpan
span'
      GuardLet SourceSpan
span' [Decl]
_ -> SourceSpan
span'

data Literal
  = LitInt SourceSpan Integer Text
  | LitIntBase SourceSpan Integer Text
  | LitFloat SourceSpan Double Text
  | LitChar SourceSpan Char Text
  | LitString SourceSpan Text Text
  deriving (Typeable Literal
Typeable Literal =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Literal -> c Literal)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Literal)
-> (Literal -> Constr)
-> (Literal -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Literal))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Literal))
-> ((forall b. Data b => b -> b) -> Literal -> Literal)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Literal -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Literal -> r)
-> (forall u. (forall d. Data d => d -> u) -> Literal -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Literal -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Literal -> m Literal)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Literal -> m Literal)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Literal -> m Literal)
-> Data Literal
Literal -> Constr
Literal -> DataType
(forall b. Data b => b -> b) -> Literal -> Literal
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 -> u
forall u. (forall d. Data d => d -> u) -> Literal -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Literal -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Literal -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Literal -> m Literal
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Literal -> m Literal
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Literal
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Literal -> c Literal
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Literal)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Literal)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Literal -> c Literal
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Literal -> c Literal
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Literal
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Literal
$ctoConstr :: Literal -> Constr
toConstr :: Literal -> Constr
$cdataTypeOf :: Literal -> DataType
dataTypeOf :: Literal -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Literal)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Literal)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Literal)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Literal)
$cgmapT :: (forall b. Data b => b -> b) -> Literal -> Literal
gmapT :: (forall b. Data b => b -> b) -> Literal -> Literal
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Literal -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Literal -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Literal -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Literal -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Literal -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Literal -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Literal -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Literal -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Literal -> m Literal
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Literal -> m Literal
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Literal -> m Literal
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Literal -> m Literal
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Literal -> m Literal
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Literal -> m Literal
Data, Literal -> Literal -> Bool
(Literal -> Literal -> Bool)
-> (Literal -> Literal -> Bool) -> Eq Literal
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Literal -> Literal -> Bool
== :: Literal -> Literal -> Bool
$c/= :: Literal -> Literal -> Bool
/= :: Literal -> Literal -> Bool
Eq, Int -> Literal -> ShowS
[Literal] -> ShowS
Literal -> String
(Int -> Literal -> ShowS)
-> (Literal -> String) -> ([Literal] -> ShowS) -> Show Literal
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Literal -> ShowS
showsPrec :: Int -> Literal -> ShowS
$cshow :: Literal -> String
show :: Literal -> String
$cshowList :: [Literal] -> ShowS
showList :: [Literal] -> ShowS
Show, (forall x. Literal -> Rep Literal x)
-> (forall x. Rep Literal x -> Literal) -> Generic Literal
forall x. Rep Literal x -> Literal
forall x. Literal -> Rep Literal x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Literal -> Rep Literal x
from :: forall x. Literal -> Rep Literal x
$cto :: forall x. Rep Literal x -> Literal
to :: forall x. Rep Literal x -> Literal
Generic, Literal -> ()
(Literal -> ()) -> NFData Literal
forall a. (a -> ()) -> NFData a
$crnf :: Literal -> ()
rnf :: Literal -> ()
NFData)

instance HasSourceSpan Literal where
  getSourceSpan :: Literal -> SourceSpan
getSourceSpan Literal
literal =
    case Literal
literal of
      LitInt SourceSpan
span' Integer
_ Text
_ -> SourceSpan
span'
      LitIntBase SourceSpan
span' Integer
_ Text
_ -> SourceSpan
span'
      LitFloat SourceSpan
span' Double
_ Text
_ -> SourceSpan
span'
      LitChar SourceSpan
span' Char
_ Text
_ -> SourceSpan
span'
      LitString SourceSpan
span' Text
_ Text
_ -> SourceSpan
span'

data Pattern
  = PVar SourceSpan Text
  | PWildcard SourceSpan
  | PLit SourceSpan Literal
  | PQuasiQuote SourceSpan Text Text
  | PTuple SourceSpan [Pattern]
  | PList SourceSpan [Pattern]
  | PCon SourceSpan Text [Pattern]
  | PInfix SourceSpan Pattern Text Pattern
  | PView SourceSpan Expr Pattern
  | PAs SourceSpan Text Pattern
  | PStrict SourceSpan Pattern
  | PIrrefutable SourceSpan Pattern
  | PNegLit SourceSpan Literal
  | PParen SourceSpan Pattern
  | PRecord SourceSpan Text [(Text, Pattern)]
  deriving (Typeable Pattern
Typeable Pattern =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Pattern -> c Pattern)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Pattern)
-> (Pattern -> Constr)
-> (Pattern -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Pattern))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Pattern))
-> ((forall b. Data b => b -> b) -> Pattern -> Pattern)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Pattern -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Pattern -> r)
-> (forall u. (forall d. Data d => d -> u) -> Pattern -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Pattern -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Pattern -> m Pattern)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Pattern -> m Pattern)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Pattern -> m Pattern)
-> Data Pattern
Pattern -> Constr
Pattern -> DataType
(forall b. Data b => b -> b) -> Pattern -> Pattern
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) -> Pattern -> u
forall u. (forall d. Data d => d -> u) -> Pattern -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Pattern -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Pattern -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Pattern -> m Pattern
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Pattern -> m Pattern
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Pattern
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Pattern -> c Pattern
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Pattern)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Pattern)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Pattern -> c Pattern
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Pattern -> c Pattern
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Pattern
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Pattern
$ctoConstr :: Pattern -> Constr
toConstr :: Pattern -> Constr
$cdataTypeOf :: Pattern -> DataType
dataTypeOf :: Pattern -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Pattern)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Pattern)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Pattern)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Pattern)
$cgmapT :: (forall b. Data b => b -> b) -> Pattern -> Pattern
gmapT :: (forall b. Data b => b -> b) -> Pattern -> Pattern
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Pattern -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Pattern -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Pattern -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Pattern -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Pattern -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Pattern -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Pattern -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Pattern -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Pattern -> m Pattern
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Pattern -> m Pattern
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Pattern -> m Pattern
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Pattern -> m Pattern
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Pattern -> m Pattern
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Pattern -> m Pattern
Data, Pattern -> Pattern -> Bool
(Pattern -> Pattern -> Bool)
-> (Pattern -> Pattern -> Bool) -> Eq Pattern
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Pattern -> Pattern -> Bool
== :: Pattern -> Pattern -> Bool
$c/= :: Pattern -> Pattern -> Bool
/= :: Pattern -> Pattern -> Bool
Eq, Int -> Pattern -> ShowS
[Pattern] -> ShowS
Pattern -> String
(Int -> Pattern -> ShowS)
-> (Pattern -> String) -> ([Pattern] -> ShowS) -> Show Pattern
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Pattern -> ShowS
showsPrec :: Int -> Pattern -> ShowS
$cshow :: Pattern -> String
show :: Pattern -> String
$cshowList :: [Pattern] -> ShowS
showList :: [Pattern] -> ShowS
Show, (forall x. Pattern -> Rep Pattern x)
-> (forall x. Rep Pattern x -> Pattern) -> Generic Pattern
forall x. Rep Pattern x -> Pattern
forall x. Pattern -> Rep Pattern x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Pattern -> Rep Pattern x
from :: forall x. Pattern -> Rep Pattern x
$cto :: forall x. Rep Pattern x -> Pattern
to :: forall x. Rep Pattern x -> Pattern
Generic, Pattern -> ()
(Pattern -> ()) -> NFData Pattern
forall a. (a -> ()) -> NFData a
$crnf :: Pattern -> ()
rnf :: Pattern -> ()
NFData)

instance HasSourceSpan Pattern where
  getSourceSpan :: Pattern -> SourceSpan
getSourceSpan Pattern
pat =
    case Pattern
pat of
      PVar SourceSpan
span' Text
_ -> SourceSpan
span'
      PWildcard SourceSpan
span' -> SourceSpan
span'
      PLit SourceSpan
span' Literal
_ -> SourceSpan
span'
      PQuasiQuote SourceSpan
span' Text
_ Text
_ -> SourceSpan
span'
      PTuple SourceSpan
span' [Pattern]
_ -> SourceSpan
span'
      PList SourceSpan
span' [Pattern]
_ -> SourceSpan
span'
      PCon SourceSpan
span' Text
_ [Pattern]
_ -> SourceSpan
span'
      PInfix SourceSpan
span' Pattern
_ Text
_ Pattern
_ -> SourceSpan
span'
      PView SourceSpan
span' Expr
_ Pattern
_ -> SourceSpan
span'
      PAs SourceSpan
span' Text
_ Pattern
_ -> SourceSpan
span'
      PStrict SourceSpan
span' Pattern
_ -> SourceSpan
span'
      PIrrefutable SourceSpan
span' Pattern
_ -> SourceSpan
span'
      PNegLit SourceSpan
span' Literal
_ -> SourceSpan
span'
      PParen SourceSpan
span' Pattern
_ -> SourceSpan
span'
      PRecord SourceSpan
span' Text
_ [(Text, Pattern)]
_ -> SourceSpan
span'

data Type
  = TVar SourceSpan Text
  | TCon SourceSpan Text TypePromotion
  | TTypeLit SourceSpan TypeLiteral
  | TStar SourceSpan
  | TQuasiQuote SourceSpan Text Text
  | TForall SourceSpan [Text] Type
  | TApp SourceSpan Type Type
  | TFun SourceSpan Type Type
  | TTuple SourceSpan TypePromotion [Type]
  | TList SourceSpan TypePromotion Type
  | TParen SourceSpan Type
  | TContext SourceSpan [Constraint] Type
  deriving (Typeable Type
Typeable Type =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Type -> c Type)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Type)
-> (Type -> Constr)
-> (Type -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Type))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Type))
-> ((forall b. Data b => b -> b) -> Type -> Type)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Type -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Type -> r)
-> (forall u. (forall d. Data d => d -> u) -> Type -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Type -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Type -> m Type)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Type -> m Type)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Type -> m Type)
-> Data Type
Type -> Constr
Type -> DataType
(forall b. Data b => b -> b) -> Type -> Type
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 -> u
forall u. (forall d. Data d => d -> u) -> Type -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Type -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Type -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Type -> m Type
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Type -> m Type
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Type
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Type -> c Type
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Type)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Type)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Type -> c Type
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Type -> c Type
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Type
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Type
$ctoConstr :: Type -> Constr
toConstr :: Type -> Constr
$cdataTypeOf :: Type -> DataType
dataTypeOf :: Type -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Type)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Type)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Type)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Type)
$cgmapT :: (forall b. Data b => b -> b) -> Type -> Type
gmapT :: (forall b. Data b => b -> b) -> Type -> Type
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Type -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Type -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Type -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Type -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Type -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Type -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Type -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Type -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Type -> m Type
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Type -> m Type
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Type -> m Type
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Type -> m Type
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Type -> m Type
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Type -> m Type
Data, Type -> Type -> Bool
(Type -> Type -> Bool) -> (Type -> Type -> Bool) -> Eq Type
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Type -> Type -> Bool
== :: Type -> Type -> Bool
$c/= :: Type -> Type -> Bool
/= :: Type -> Type -> Bool
Eq, Int -> Type -> ShowS
[Type] -> ShowS
Type -> String
(Int -> Type -> ShowS)
-> (Type -> String) -> ([Type] -> ShowS) -> Show Type
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Type -> ShowS
showsPrec :: Int -> Type -> ShowS
$cshow :: Type -> String
show :: Type -> String
$cshowList :: [Type] -> ShowS
showList :: [Type] -> ShowS
Show, (forall x. Type -> Rep Type x)
-> (forall x. Rep Type x -> Type) -> Generic Type
forall x. Rep Type x -> Type
forall x. Type -> Rep Type x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Type -> Rep Type x
from :: forall x. Type -> Rep Type x
$cto :: forall x. Rep Type x -> Type
to :: forall x. Rep Type x -> Type
Generic, Type -> ()
(Type -> ()) -> NFData Type
forall a. (a -> ()) -> NFData a
$crnf :: Type -> ()
rnf :: Type -> ()
NFData)

instance HasSourceSpan Type where
  getSourceSpan :: Type -> SourceSpan
getSourceSpan Type
ty =
    case Type
ty of
      TVar SourceSpan
span' Text
_ -> SourceSpan
span'
      TCon SourceSpan
span' Text
_ TypePromotion
_ -> SourceSpan
span'
      TTypeLit SourceSpan
span' TypeLiteral
_ -> SourceSpan
span'
      TStar SourceSpan
span' -> SourceSpan
span'
      TQuasiQuote SourceSpan
span' Text
_ Text
_ -> SourceSpan
span'
      TForall SourceSpan
span' [Text]
_ Type
_ -> SourceSpan
span'
      TApp SourceSpan
span' Type
_ Type
_ -> SourceSpan
span'
      TFun SourceSpan
span' Type
_ Type
_ -> SourceSpan
span'
      TTuple SourceSpan
span' TypePromotion
_ [Type]
_ -> SourceSpan
span'
      TList SourceSpan
span' TypePromotion
_ Type
_ -> SourceSpan
span'
      TParen SourceSpan
span' Type
_ -> SourceSpan
span'
      TContext SourceSpan
span' [Constraint]
_ Type
_ -> SourceSpan
span'

data TypeLiteral
  = TypeLitInteger Integer Text
  | TypeLitSymbol Text Text
  | TypeLitChar Char Text
  deriving (Typeable TypeLiteral
Typeable TypeLiteral =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> TypeLiteral -> c TypeLiteral)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c TypeLiteral)
-> (TypeLiteral -> Constr)
-> (TypeLiteral -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c TypeLiteral))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c TypeLiteral))
-> ((forall b. Data b => b -> b) -> TypeLiteral -> TypeLiteral)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> TypeLiteral -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> TypeLiteral -> r)
-> (forall u. (forall d. Data d => d -> u) -> TypeLiteral -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> TypeLiteral -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> TypeLiteral -> m TypeLiteral)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TypeLiteral -> m TypeLiteral)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TypeLiteral -> m TypeLiteral)
-> Data TypeLiteral
TypeLiteral -> Constr
TypeLiteral -> DataType
(forall b. Data b => b -> b) -> TypeLiteral -> TypeLiteral
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) -> TypeLiteral -> u
forall u. (forall d. Data d => d -> u) -> TypeLiteral -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TypeLiteral -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TypeLiteral -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TypeLiteral -> m TypeLiteral
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TypeLiteral -> m TypeLiteral
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TypeLiteral
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TypeLiteral -> c TypeLiteral
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TypeLiteral)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c TypeLiteral)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TypeLiteral -> c TypeLiteral
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TypeLiteral -> c TypeLiteral
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TypeLiteral
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TypeLiteral
$ctoConstr :: TypeLiteral -> Constr
toConstr :: TypeLiteral -> Constr
$cdataTypeOf :: TypeLiteral -> DataType
dataTypeOf :: TypeLiteral -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TypeLiteral)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TypeLiteral)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c TypeLiteral)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c TypeLiteral)
$cgmapT :: (forall b. Data b => b -> b) -> TypeLiteral -> TypeLiteral
gmapT :: (forall b. Data b => b -> b) -> TypeLiteral -> TypeLiteral
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TypeLiteral -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TypeLiteral -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TypeLiteral -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TypeLiteral -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> TypeLiteral -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> TypeLiteral -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> TypeLiteral -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> TypeLiteral -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TypeLiteral -> m TypeLiteral
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TypeLiteral -> m TypeLiteral
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TypeLiteral -> m TypeLiteral
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TypeLiteral -> m TypeLiteral
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TypeLiteral -> m TypeLiteral
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TypeLiteral -> m TypeLiteral
Data, TypeLiteral -> TypeLiteral -> Bool
(TypeLiteral -> TypeLiteral -> Bool)
-> (TypeLiteral -> TypeLiteral -> Bool) -> Eq TypeLiteral
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TypeLiteral -> TypeLiteral -> Bool
== :: TypeLiteral -> TypeLiteral -> Bool
$c/= :: TypeLiteral -> TypeLiteral -> Bool
/= :: TypeLiteral -> TypeLiteral -> Bool
Eq, Int -> TypeLiteral -> ShowS
[TypeLiteral] -> ShowS
TypeLiteral -> String
(Int -> TypeLiteral -> ShowS)
-> (TypeLiteral -> String)
-> ([TypeLiteral] -> ShowS)
-> Show TypeLiteral
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> TypeLiteral -> ShowS
showsPrec :: Int -> TypeLiteral -> ShowS
$cshow :: TypeLiteral -> String
show :: TypeLiteral -> String
$cshowList :: [TypeLiteral] -> ShowS
showList :: [TypeLiteral] -> ShowS
Show, (forall x. TypeLiteral -> Rep TypeLiteral x)
-> (forall x. Rep TypeLiteral x -> TypeLiteral)
-> Generic TypeLiteral
forall x. Rep TypeLiteral x -> TypeLiteral
forall x. TypeLiteral -> Rep TypeLiteral x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. TypeLiteral -> Rep TypeLiteral x
from :: forall x. TypeLiteral -> Rep TypeLiteral x
$cto :: forall x. Rep TypeLiteral x -> TypeLiteral
to :: forall x. Rep TypeLiteral x -> TypeLiteral
Generic, TypeLiteral -> ()
(TypeLiteral -> ()) -> NFData TypeLiteral
forall a. (a -> ()) -> NFData a
$crnf :: TypeLiteral -> ()
rnf :: TypeLiteral -> ()
NFData)

data TypePromotion
  = Unpromoted
  | Promoted
  deriving (Typeable TypePromotion
Typeable TypePromotion =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> TypePromotion -> c TypePromotion)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c TypePromotion)
-> (TypePromotion -> Constr)
-> (TypePromotion -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c TypePromotion))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c TypePromotion))
-> ((forall b. Data b => b -> b) -> TypePromotion -> TypePromotion)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> TypePromotion -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> TypePromotion -> r)
-> (forall u. (forall d. Data d => d -> u) -> TypePromotion -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> TypePromotion -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> TypePromotion -> m TypePromotion)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TypePromotion -> m TypePromotion)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TypePromotion -> m TypePromotion)
-> Data TypePromotion
TypePromotion -> Constr
TypePromotion -> DataType
(forall b. Data b => b -> b) -> TypePromotion -> TypePromotion
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) -> TypePromotion -> u
forall u. (forall d. Data d => d -> u) -> TypePromotion -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TypePromotion -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TypePromotion -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TypePromotion -> m TypePromotion
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TypePromotion -> m TypePromotion
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TypePromotion
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TypePromotion -> c TypePromotion
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TypePromotion)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c TypePromotion)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TypePromotion -> c TypePromotion
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TypePromotion -> c TypePromotion
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TypePromotion
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TypePromotion
$ctoConstr :: TypePromotion -> Constr
toConstr :: TypePromotion -> Constr
$cdataTypeOf :: TypePromotion -> DataType
dataTypeOf :: TypePromotion -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TypePromotion)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TypePromotion)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c TypePromotion)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c TypePromotion)
$cgmapT :: (forall b. Data b => b -> b) -> TypePromotion -> TypePromotion
gmapT :: (forall b. Data b => b -> b) -> TypePromotion -> TypePromotion
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TypePromotion -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TypePromotion -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TypePromotion -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TypePromotion -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> TypePromotion -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> TypePromotion -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> TypePromotion -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> TypePromotion -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TypePromotion -> m TypePromotion
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TypePromotion -> m TypePromotion
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TypePromotion -> m TypePromotion
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TypePromotion -> m TypePromotion
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TypePromotion -> m TypePromotion
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TypePromotion -> m TypePromotion
Data, TypePromotion -> TypePromotion -> Bool
(TypePromotion -> TypePromotion -> Bool)
-> (TypePromotion -> TypePromotion -> Bool) -> Eq TypePromotion
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TypePromotion -> TypePromotion -> Bool
== :: TypePromotion -> TypePromotion -> Bool
$c/= :: TypePromotion -> TypePromotion -> Bool
/= :: TypePromotion -> TypePromotion -> Bool
Eq, Int -> TypePromotion -> ShowS
[TypePromotion] -> ShowS
TypePromotion -> String
(Int -> TypePromotion -> ShowS)
-> (TypePromotion -> String)
-> ([TypePromotion] -> ShowS)
-> Show TypePromotion
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> TypePromotion -> ShowS
showsPrec :: Int -> TypePromotion -> ShowS
$cshow :: TypePromotion -> String
show :: TypePromotion -> String
$cshowList :: [TypePromotion] -> ShowS
showList :: [TypePromotion] -> ShowS
Show, (forall x. TypePromotion -> Rep TypePromotion x)
-> (forall x. Rep TypePromotion x -> TypePromotion)
-> Generic TypePromotion
forall x. Rep TypePromotion x -> TypePromotion
forall x. TypePromotion -> Rep TypePromotion x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. TypePromotion -> Rep TypePromotion x
from :: forall x. TypePromotion -> Rep TypePromotion x
$cto :: forall x. Rep TypePromotion x -> TypePromotion
to :: forall x. Rep TypePromotion x -> TypePromotion
Generic, TypePromotion -> ()
(TypePromotion -> ()) -> NFData TypePromotion
forall a. (a -> ()) -> NFData a
$crnf :: TypePromotion -> ()
rnf :: TypePromotion -> ()
NFData)

data Constraint = Constraint
  { Constraint -> SourceSpan
constraintSpan :: SourceSpan,
    Constraint -> Text
constraintClass :: Text,
    Constraint -> [Type]
constraintArgs :: [Type],
    Constraint -> Bool
constraintParen :: Bool
  }
  deriving (Typeable Constraint
Typeable Constraint =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Constraint -> c Constraint)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Constraint)
-> (Constraint -> Constr)
-> (Constraint -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Constraint))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c Constraint))
-> ((forall b. Data b => b -> b) -> Constraint -> Constraint)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Constraint -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Constraint -> r)
-> (forall u. (forall d. Data d => d -> u) -> Constraint -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Constraint -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Constraint -> m Constraint)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Constraint -> m Constraint)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Constraint -> m Constraint)
-> Data Constraint
Constraint -> Constr
Constraint -> DataType
(forall b. Data b => b -> b) -> Constraint -> Constraint
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) -> Constraint -> u
forall u. (forall d. Data d => d -> u) -> Constraint -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Constraint -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Constraint -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Constraint -> m Constraint
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Constraint -> m Constraint
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Constraint
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Constraint -> c Constraint
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Constraint)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Constraint)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Constraint -> c Constraint
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Constraint -> c Constraint
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Constraint
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Constraint
$ctoConstr :: Constraint -> Constr
toConstr :: Constraint -> Constr
$cdataTypeOf :: Constraint -> DataType
dataTypeOf :: Constraint -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Constraint)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Constraint)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Constraint)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Constraint)
$cgmapT :: (forall b. Data b => b -> b) -> Constraint -> Constraint
gmapT :: (forall b. Data b => b -> b) -> Constraint -> Constraint
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Constraint -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Constraint -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Constraint -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Constraint -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Constraint -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Constraint -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Constraint -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Constraint -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Constraint -> m Constraint
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Constraint -> m Constraint
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Constraint -> m Constraint
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Constraint -> m Constraint
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Constraint -> m Constraint
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Constraint -> m Constraint
Data, Constraint -> Constraint -> Bool
(Constraint -> Constraint -> Bool)
-> (Constraint -> Constraint -> Bool) -> Eq Constraint
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Constraint -> Constraint -> Bool
== :: Constraint -> Constraint -> Bool
$c/= :: Constraint -> Constraint -> Bool
/= :: Constraint -> Constraint -> Bool
Eq, Int -> Constraint -> ShowS
[Constraint] -> ShowS
Constraint -> String
(Int -> Constraint -> ShowS)
-> (Constraint -> String)
-> ([Constraint] -> ShowS)
-> Show Constraint
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Constraint -> ShowS
showsPrec :: Int -> Constraint -> ShowS
$cshow :: Constraint -> String
show :: Constraint -> String
$cshowList :: [Constraint] -> ShowS
showList :: [Constraint] -> ShowS
Show, (forall x. Constraint -> Rep Constraint x)
-> (forall x. Rep Constraint x -> Constraint) -> Generic Constraint
forall x. Rep Constraint x -> Constraint
forall x. Constraint -> Rep Constraint x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Constraint -> Rep Constraint x
from :: forall x. Constraint -> Rep Constraint x
$cto :: forall x. Rep Constraint x -> Constraint
to :: forall x. Rep Constraint x -> Constraint
Generic, Constraint -> ()
(Constraint -> ()) -> NFData Constraint
forall a. (a -> ()) -> NFData a
$crnf :: Constraint -> ()
rnf :: Constraint -> ()
NFData)

instance HasSourceSpan Constraint where
  getSourceSpan :: Constraint -> SourceSpan
getSourceSpan = Constraint -> SourceSpan
constraintSpan

data TyVarBinder = TyVarBinder
  { TyVarBinder -> SourceSpan
tyVarBinderSpan :: SourceSpan,
    TyVarBinder -> Text
tyVarBinderName :: Text,
    TyVarBinder -> Maybe Type
tyVarBinderKind :: Maybe Type
  }
  deriving (Typeable TyVarBinder
Typeable TyVarBinder =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> TyVarBinder -> c TyVarBinder)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c TyVarBinder)
-> (TyVarBinder -> Constr)
-> (TyVarBinder -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c TyVarBinder))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c TyVarBinder))
-> ((forall b. Data b => b -> b) -> TyVarBinder -> TyVarBinder)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> TyVarBinder -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> TyVarBinder -> r)
-> (forall u. (forall d. Data d => d -> u) -> TyVarBinder -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> TyVarBinder -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> TyVarBinder -> m TyVarBinder)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TyVarBinder -> m TyVarBinder)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TyVarBinder -> m TyVarBinder)
-> Data TyVarBinder
TyVarBinder -> Constr
TyVarBinder -> DataType
(forall b. Data b => b -> b) -> TyVarBinder -> TyVarBinder
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) -> TyVarBinder -> u
forall u. (forall d. Data d => d -> u) -> TyVarBinder -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TyVarBinder -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TyVarBinder -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TyVarBinder -> m TyVarBinder
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TyVarBinder -> m TyVarBinder
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TyVarBinder
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TyVarBinder -> c TyVarBinder
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TyVarBinder)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c TyVarBinder)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TyVarBinder -> c TyVarBinder
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TyVarBinder -> c TyVarBinder
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TyVarBinder
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TyVarBinder
$ctoConstr :: TyVarBinder -> Constr
toConstr :: TyVarBinder -> Constr
$cdataTypeOf :: TyVarBinder -> DataType
dataTypeOf :: TyVarBinder -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TyVarBinder)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TyVarBinder)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c TyVarBinder)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c TyVarBinder)
$cgmapT :: (forall b. Data b => b -> b) -> TyVarBinder -> TyVarBinder
gmapT :: (forall b. Data b => b -> b) -> TyVarBinder -> TyVarBinder
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TyVarBinder -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TyVarBinder -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TyVarBinder -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TyVarBinder -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> TyVarBinder -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> TyVarBinder -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> TyVarBinder -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> TyVarBinder -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TyVarBinder -> m TyVarBinder
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TyVarBinder -> m TyVarBinder
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TyVarBinder -> m TyVarBinder
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TyVarBinder -> m TyVarBinder
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TyVarBinder -> m TyVarBinder
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TyVarBinder -> m TyVarBinder
Data, TyVarBinder -> TyVarBinder -> Bool
(TyVarBinder -> TyVarBinder -> Bool)
-> (TyVarBinder -> TyVarBinder -> Bool) -> Eq TyVarBinder
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TyVarBinder -> TyVarBinder -> Bool
== :: TyVarBinder -> TyVarBinder -> Bool
$c/= :: TyVarBinder -> TyVarBinder -> Bool
/= :: TyVarBinder -> TyVarBinder -> Bool
Eq, Int -> TyVarBinder -> ShowS
[TyVarBinder] -> ShowS
TyVarBinder -> String
(Int -> TyVarBinder -> ShowS)
-> (TyVarBinder -> String)
-> ([TyVarBinder] -> ShowS)
-> Show TyVarBinder
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> TyVarBinder -> ShowS
showsPrec :: Int -> TyVarBinder -> ShowS
$cshow :: TyVarBinder -> String
show :: TyVarBinder -> String
$cshowList :: [TyVarBinder] -> ShowS
showList :: [TyVarBinder] -> ShowS
Show, (forall x. TyVarBinder -> Rep TyVarBinder x)
-> (forall x. Rep TyVarBinder x -> TyVarBinder)
-> Generic TyVarBinder
forall x. Rep TyVarBinder x -> TyVarBinder
forall x. TyVarBinder -> Rep TyVarBinder x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. TyVarBinder -> Rep TyVarBinder x
from :: forall x. TyVarBinder -> Rep TyVarBinder x
$cto :: forall x. Rep TyVarBinder x -> TyVarBinder
to :: forall x. Rep TyVarBinder x -> TyVarBinder
Generic, TyVarBinder -> ()
(TyVarBinder -> ()) -> NFData TyVarBinder
forall a. (a -> ()) -> NFData a
$crnf :: TyVarBinder -> ()
rnf :: TyVarBinder -> ()
NFData)

instance HasSourceSpan TyVarBinder where
  getSourceSpan :: TyVarBinder -> SourceSpan
getSourceSpan = TyVarBinder -> SourceSpan
tyVarBinderSpan

data TypeSynDecl = TypeSynDecl
  { TypeSynDecl -> SourceSpan
typeSynSpan :: SourceSpan,
    TypeSynDecl -> Text
typeSynName :: Text,
    TypeSynDecl -> [TyVarBinder]
typeSynParams :: [TyVarBinder],
    TypeSynDecl -> Type
typeSynBody :: Type
  }
  deriving (Typeable TypeSynDecl
Typeable TypeSynDecl =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> TypeSynDecl -> c TypeSynDecl)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c TypeSynDecl)
-> (TypeSynDecl -> Constr)
-> (TypeSynDecl -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c TypeSynDecl))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c TypeSynDecl))
-> ((forall b. Data b => b -> b) -> TypeSynDecl -> TypeSynDecl)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> TypeSynDecl -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> TypeSynDecl -> r)
-> (forall u. (forall d. Data d => d -> u) -> TypeSynDecl -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> TypeSynDecl -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> TypeSynDecl -> m TypeSynDecl)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TypeSynDecl -> m TypeSynDecl)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TypeSynDecl -> m TypeSynDecl)
-> Data TypeSynDecl
TypeSynDecl -> Constr
TypeSynDecl -> DataType
(forall b. Data b => b -> b) -> TypeSynDecl -> TypeSynDecl
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) -> TypeSynDecl -> u
forall u. (forall d. Data d => d -> u) -> TypeSynDecl -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TypeSynDecl -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TypeSynDecl -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TypeSynDecl -> m TypeSynDecl
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TypeSynDecl -> m TypeSynDecl
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TypeSynDecl
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TypeSynDecl -> c TypeSynDecl
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TypeSynDecl)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c TypeSynDecl)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TypeSynDecl -> c TypeSynDecl
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TypeSynDecl -> c TypeSynDecl
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TypeSynDecl
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TypeSynDecl
$ctoConstr :: TypeSynDecl -> Constr
toConstr :: TypeSynDecl -> Constr
$cdataTypeOf :: TypeSynDecl -> DataType
dataTypeOf :: TypeSynDecl -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TypeSynDecl)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TypeSynDecl)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c TypeSynDecl)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c TypeSynDecl)
$cgmapT :: (forall b. Data b => b -> b) -> TypeSynDecl -> TypeSynDecl
gmapT :: (forall b. Data b => b -> b) -> TypeSynDecl -> TypeSynDecl
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TypeSynDecl -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TypeSynDecl -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TypeSynDecl -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TypeSynDecl -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> TypeSynDecl -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> TypeSynDecl -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> TypeSynDecl -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> TypeSynDecl -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TypeSynDecl -> m TypeSynDecl
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TypeSynDecl -> m TypeSynDecl
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TypeSynDecl -> m TypeSynDecl
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TypeSynDecl -> m TypeSynDecl
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TypeSynDecl -> m TypeSynDecl
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TypeSynDecl -> m TypeSynDecl
Data, TypeSynDecl -> TypeSynDecl -> Bool
(TypeSynDecl -> TypeSynDecl -> Bool)
-> (TypeSynDecl -> TypeSynDecl -> Bool) -> Eq TypeSynDecl
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TypeSynDecl -> TypeSynDecl -> Bool
== :: TypeSynDecl -> TypeSynDecl -> Bool
$c/= :: TypeSynDecl -> TypeSynDecl -> Bool
/= :: TypeSynDecl -> TypeSynDecl -> Bool
Eq, Int -> TypeSynDecl -> ShowS
[TypeSynDecl] -> ShowS
TypeSynDecl -> String
(Int -> TypeSynDecl -> ShowS)
-> (TypeSynDecl -> String)
-> ([TypeSynDecl] -> ShowS)
-> Show TypeSynDecl
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> TypeSynDecl -> ShowS
showsPrec :: Int -> TypeSynDecl -> ShowS
$cshow :: TypeSynDecl -> String
show :: TypeSynDecl -> String
$cshowList :: [TypeSynDecl] -> ShowS
showList :: [TypeSynDecl] -> ShowS
Show, (forall x. TypeSynDecl -> Rep TypeSynDecl x)
-> (forall x. Rep TypeSynDecl x -> TypeSynDecl)
-> Generic TypeSynDecl
forall x. Rep TypeSynDecl x -> TypeSynDecl
forall x. TypeSynDecl -> Rep TypeSynDecl x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. TypeSynDecl -> Rep TypeSynDecl x
from :: forall x. TypeSynDecl -> Rep TypeSynDecl x
$cto :: forall x. Rep TypeSynDecl x -> TypeSynDecl
to :: forall x. Rep TypeSynDecl x -> TypeSynDecl
Generic, TypeSynDecl -> ()
(TypeSynDecl -> ()) -> NFData TypeSynDecl
forall a. (a -> ()) -> NFData a
$crnf :: TypeSynDecl -> ()
rnf :: TypeSynDecl -> ()
NFData)

instance HasSourceSpan TypeSynDecl where
  getSourceSpan :: TypeSynDecl -> SourceSpan
getSourceSpan = TypeSynDecl -> SourceSpan
typeSynSpan

data DataDecl = DataDecl
  { DataDecl -> SourceSpan
dataDeclSpan :: SourceSpan,
    DataDecl -> [Constraint]
dataDeclContext :: [Constraint],
    DataDecl -> Text
dataDeclName :: Text,
    DataDecl -> [TyVarBinder]
dataDeclParams :: [TyVarBinder],
    DataDecl -> [DataConDecl]
dataDeclConstructors :: [DataConDecl],
    DataDecl -> [DerivingClause]
dataDeclDeriving :: [DerivingClause]
  }
  deriving (Typeable DataDecl
Typeable DataDecl =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> DataDecl -> c DataDecl)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DataDecl)
-> (DataDecl -> Constr)
-> (DataDecl -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DataDecl))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DataDecl))
-> ((forall b. Data b => b -> b) -> DataDecl -> DataDecl)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DataDecl -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DataDecl -> r)
-> (forall u. (forall d. Data d => d -> u) -> DataDecl -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> DataDecl -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DataDecl -> m DataDecl)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DataDecl -> m DataDecl)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DataDecl -> m DataDecl)
-> Data DataDecl
DataDecl -> Constr
DataDecl -> DataType
(forall b. Data b => b -> b) -> DataDecl -> DataDecl
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) -> DataDecl -> u
forall u. (forall d. Data d => d -> u) -> DataDecl -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DataDecl -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DataDecl -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DataDecl -> m DataDecl
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DataDecl -> m DataDecl
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DataDecl
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DataDecl -> c DataDecl
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DataDecl)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DataDecl)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DataDecl -> c DataDecl
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DataDecl -> c DataDecl
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DataDecl
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DataDecl
$ctoConstr :: DataDecl -> Constr
toConstr :: DataDecl -> Constr
$cdataTypeOf :: DataDecl -> DataType
dataTypeOf :: DataDecl -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DataDecl)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DataDecl)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DataDecl)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DataDecl)
$cgmapT :: (forall b. Data b => b -> b) -> DataDecl -> DataDecl
gmapT :: (forall b. Data b => b -> b) -> DataDecl -> DataDecl
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DataDecl -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DataDecl -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DataDecl -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DataDecl -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DataDecl -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> DataDecl -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DataDecl -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DataDecl -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DataDecl -> m DataDecl
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DataDecl -> m DataDecl
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DataDecl -> m DataDecl
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DataDecl -> m DataDecl
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DataDecl -> m DataDecl
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DataDecl -> m DataDecl
Data, DataDecl -> DataDecl -> Bool
(DataDecl -> DataDecl -> Bool)
-> (DataDecl -> DataDecl -> Bool) -> Eq DataDecl
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DataDecl -> DataDecl -> Bool
== :: DataDecl -> DataDecl -> Bool
$c/= :: DataDecl -> DataDecl -> Bool
/= :: DataDecl -> DataDecl -> Bool
Eq, Int -> DataDecl -> ShowS
[DataDecl] -> ShowS
DataDecl -> String
(Int -> DataDecl -> ShowS)
-> (DataDecl -> String) -> ([DataDecl] -> ShowS) -> Show DataDecl
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DataDecl -> ShowS
showsPrec :: Int -> DataDecl -> ShowS
$cshow :: DataDecl -> String
show :: DataDecl -> String
$cshowList :: [DataDecl] -> ShowS
showList :: [DataDecl] -> ShowS
Show, (forall x. DataDecl -> Rep DataDecl x)
-> (forall x. Rep DataDecl x -> DataDecl) -> Generic DataDecl
forall x. Rep DataDecl x -> DataDecl
forall x. DataDecl -> Rep DataDecl x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. DataDecl -> Rep DataDecl x
from :: forall x. DataDecl -> Rep DataDecl x
$cto :: forall x. Rep DataDecl x -> DataDecl
to :: forall x. Rep DataDecl x -> DataDecl
Generic, DataDecl -> ()
(DataDecl -> ()) -> NFData DataDecl
forall a. (a -> ()) -> NFData a
$crnf :: DataDecl -> ()
rnf :: DataDecl -> ()
NFData)

instance HasSourceSpan DataDecl where
  getSourceSpan :: DataDecl -> SourceSpan
getSourceSpan = DataDecl -> SourceSpan
dataDeclSpan

data NewtypeDecl = NewtypeDecl
  { NewtypeDecl -> SourceSpan
newtypeDeclSpan :: SourceSpan,
    NewtypeDecl -> [Constraint]
newtypeDeclContext :: [Constraint],
    NewtypeDecl -> Text
newtypeDeclName :: Text,
    NewtypeDecl -> [TyVarBinder]
newtypeDeclParams :: [TyVarBinder],
    NewtypeDecl -> Maybe DataConDecl
newtypeDeclConstructor :: Maybe DataConDecl,
    NewtypeDecl -> [DerivingClause]
newtypeDeclDeriving :: [DerivingClause]
  }
  deriving (Typeable NewtypeDecl
Typeable NewtypeDecl =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> NewtypeDecl -> c NewtypeDecl)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c NewtypeDecl)
-> (NewtypeDecl -> Constr)
-> (NewtypeDecl -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c NewtypeDecl))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c NewtypeDecl))
-> ((forall b. Data b => b -> b) -> NewtypeDecl -> NewtypeDecl)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> NewtypeDecl -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> NewtypeDecl -> r)
-> (forall u. (forall d. Data d => d -> u) -> NewtypeDecl -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> NewtypeDecl -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> NewtypeDecl -> m NewtypeDecl)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> NewtypeDecl -> m NewtypeDecl)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> NewtypeDecl -> m NewtypeDecl)
-> Data NewtypeDecl
NewtypeDecl -> Constr
NewtypeDecl -> DataType
(forall b. Data b => b -> b) -> NewtypeDecl -> NewtypeDecl
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) -> NewtypeDecl -> u
forall u. (forall d. Data d => d -> u) -> NewtypeDecl -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NewtypeDecl -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NewtypeDecl -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> NewtypeDecl -> m NewtypeDecl
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NewtypeDecl -> m NewtypeDecl
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c NewtypeDecl
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NewtypeDecl -> c NewtypeDecl
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c NewtypeDecl)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c NewtypeDecl)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NewtypeDecl -> c NewtypeDecl
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NewtypeDecl -> c NewtypeDecl
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c NewtypeDecl
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c NewtypeDecl
$ctoConstr :: NewtypeDecl -> Constr
toConstr :: NewtypeDecl -> Constr
$cdataTypeOf :: NewtypeDecl -> DataType
dataTypeOf :: NewtypeDecl -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c NewtypeDecl)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c NewtypeDecl)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c NewtypeDecl)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c NewtypeDecl)
$cgmapT :: (forall b. Data b => b -> b) -> NewtypeDecl -> NewtypeDecl
gmapT :: (forall b. Data b => b -> b) -> NewtypeDecl -> NewtypeDecl
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NewtypeDecl -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NewtypeDecl -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NewtypeDecl -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NewtypeDecl -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> NewtypeDecl -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> NewtypeDecl -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> NewtypeDecl -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> NewtypeDecl -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> NewtypeDecl -> m NewtypeDecl
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> NewtypeDecl -> m NewtypeDecl
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NewtypeDecl -> m NewtypeDecl
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NewtypeDecl -> m NewtypeDecl
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NewtypeDecl -> m NewtypeDecl
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NewtypeDecl -> m NewtypeDecl
Data, NewtypeDecl -> NewtypeDecl -> Bool
(NewtypeDecl -> NewtypeDecl -> Bool)
-> (NewtypeDecl -> NewtypeDecl -> Bool) -> Eq NewtypeDecl
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: NewtypeDecl -> NewtypeDecl -> Bool
== :: NewtypeDecl -> NewtypeDecl -> Bool
$c/= :: NewtypeDecl -> NewtypeDecl -> Bool
/= :: NewtypeDecl -> NewtypeDecl -> Bool
Eq, Int -> NewtypeDecl -> ShowS
[NewtypeDecl] -> ShowS
NewtypeDecl -> String
(Int -> NewtypeDecl -> ShowS)
-> (NewtypeDecl -> String)
-> ([NewtypeDecl] -> ShowS)
-> Show NewtypeDecl
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> NewtypeDecl -> ShowS
showsPrec :: Int -> NewtypeDecl -> ShowS
$cshow :: NewtypeDecl -> String
show :: NewtypeDecl -> String
$cshowList :: [NewtypeDecl] -> ShowS
showList :: [NewtypeDecl] -> ShowS
Show, (forall x. NewtypeDecl -> Rep NewtypeDecl x)
-> (forall x. Rep NewtypeDecl x -> NewtypeDecl)
-> Generic NewtypeDecl
forall x. Rep NewtypeDecl x -> NewtypeDecl
forall x. NewtypeDecl -> Rep NewtypeDecl x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. NewtypeDecl -> Rep NewtypeDecl x
from :: forall x. NewtypeDecl -> Rep NewtypeDecl x
$cto :: forall x. Rep NewtypeDecl x -> NewtypeDecl
to :: forall x. Rep NewtypeDecl x -> NewtypeDecl
Generic, NewtypeDecl -> ()
(NewtypeDecl -> ()) -> NFData NewtypeDecl
forall a. (a -> ()) -> NFData a
$crnf :: NewtypeDecl -> ()
rnf :: NewtypeDecl -> ()
NFData)

instance HasSourceSpan NewtypeDecl where
  getSourceSpan :: NewtypeDecl -> SourceSpan
getSourceSpan = NewtypeDecl -> SourceSpan
newtypeDeclSpan

data DataConDecl
  = PrefixCon SourceSpan [Text] [Constraint] Text [BangType]
  | InfixCon SourceSpan [Text] [Constraint] BangType Text BangType
  | RecordCon SourceSpan [Text] [Constraint] Text [FieldDecl]
  | -- | GADT-style constructor: @Con :: forall a. Ctx => Type@
    -- The list of names supports multiple constructors: @T1, T2 :: Type@
    GadtCon SourceSpan [TyVarBinder] [Constraint] [Text] GadtBody
  deriving (Typeable DataConDecl
Typeable DataConDecl =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> DataConDecl -> c DataConDecl)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DataConDecl)
-> (DataConDecl -> Constr)
-> (DataConDecl -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DataConDecl))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c DataConDecl))
-> ((forall b. Data b => b -> b) -> DataConDecl -> DataConDecl)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DataConDecl -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DataConDecl -> r)
-> (forall u. (forall d. Data d => d -> u) -> DataConDecl -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> DataConDecl -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DataConDecl -> m DataConDecl)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DataConDecl -> m DataConDecl)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DataConDecl -> m DataConDecl)
-> Data DataConDecl
DataConDecl -> Constr
DataConDecl -> DataType
(forall b. Data b => b -> b) -> DataConDecl -> DataConDecl
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) -> DataConDecl -> u
forall u. (forall d. Data d => d -> u) -> DataConDecl -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DataConDecl -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DataConDecl -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DataConDecl -> m DataConDecl
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DataConDecl -> m DataConDecl
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DataConDecl
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DataConDecl -> c DataConDecl
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DataConDecl)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DataConDecl)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DataConDecl -> c DataConDecl
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DataConDecl -> c DataConDecl
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DataConDecl
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DataConDecl
$ctoConstr :: DataConDecl -> Constr
toConstr :: DataConDecl -> Constr
$cdataTypeOf :: DataConDecl -> DataType
dataTypeOf :: DataConDecl -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DataConDecl)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DataConDecl)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DataConDecl)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DataConDecl)
$cgmapT :: (forall b. Data b => b -> b) -> DataConDecl -> DataConDecl
gmapT :: (forall b. Data b => b -> b) -> DataConDecl -> DataConDecl
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DataConDecl -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DataConDecl -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DataConDecl -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DataConDecl -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DataConDecl -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> DataConDecl -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DataConDecl -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DataConDecl -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DataConDecl -> m DataConDecl
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DataConDecl -> m DataConDecl
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DataConDecl -> m DataConDecl
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DataConDecl -> m DataConDecl
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DataConDecl -> m DataConDecl
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DataConDecl -> m DataConDecl
Data, DataConDecl -> DataConDecl -> Bool
(DataConDecl -> DataConDecl -> Bool)
-> (DataConDecl -> DataConDecl -> Bool) -> Eq DataConDecl
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DataConDecl -> DataConDecl -> Bool
== :: DataConDecl -> DataConDecl -> Bool
$c/= :: DataConDecl -> DataConDecl -> Bool
/= :: DataConDecl -> DataConDecl -> Bool
Eq, Int -> DataConDecl -> ShowS
[DataConDecl] -> ShowS
DataConDecl -> String
(Int -> DataConDecl -> ShowS)
-> (DataConDecl -> String)
-> ([DataConDecl] -> ShowS)
-> Show DataConDecl
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DataConDecl -> ShowS
showsPrec :: Int -> DataConDecl -> ShowS
$cshow :: DataConDecl -> String
show :: DataConDecl -> String
$cshowList :: [DataConDecl] -> ShowS
showList :: [DataConDecl] -> ShowS
Show, (forall x. DataConDecl -> Rep DataConDecl x)
-> (forall x. Rep DataConDecl x -> DataConDecl)
-> Generic DataConDecl
forall x. Rep DataConDecl x -> DataConDecl
forall x. DataConDecl -> Rep DataConDecl x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. DataConDecl -> Rep DataConDecl x
from :: forall x. DataConDecl -> Rep DataConDecl x
$cto :: forall x. Rep DataConDecl x -> DataConDecl
to :: forall x. Rep DataConDecl x -> DataConDecl
Generic, DataConDecl -> ()
(DataConDecl -> ()) -> NFData DataConDecl
forall a. (a -> ()) -> NFData a
$crnf :: DataConDecl -> ()
rnf :: DataConDecl -> ()
NFData)

-- | Body of a GADT constructor after the @::@ and optional forall/context
data GadtBody
  = -- | Prefix body: @a -> b -> T a@
    GadtPrefixBody [BangType] Type
  | -- | Record body: @{ field :: Type } -> T a@
    GadtRecordBody [FieldDecl] Type
  deriving (Typeable GadtBody
Typeable GadtBody =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> GadtBody -> c GadtBody)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c GadtBody)
-> (GadtBody -> Constr)
-> (GadtBody -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c GadtBody))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c GadtBody))
-> ((forall b. Data b => b -> b) -> GadtBody -> GadtBody)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> GadtBody -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> GadtBody -> r)
-> (forall u. (forall d. Data d => d -> u) -> GadtBody -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> GadtBody -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> GadtBody -> m GadtBody)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> GadtBody -> m GadtBody)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> GadtBody -> m GadtBody)
-> Data GadtBody
GadtBody -> Constr
GadtBody -> DataType
(forall b. Data b => b -> b) -> GadtBody -> GadtBody
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) -> GadtBody -> u
forall u. (forall d. Data d => d -> u) -> GadtBody -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> GadtBody -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> GadtBody -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> GadtBody -> m GadtBody
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> GadtBody -> m GadtBody
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c GadtBody
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> GadtBody -> c GadtBody
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c GadtBody)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c GadtBody)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> GadtBody -> c GadtBody
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> GadtBody -> c GadtBody
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c GadtBody
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c GadtBody
$ctoConstr :: GadtBody -> Constr
toConstr :: GadtBody -> Constr
$cdataTypeOf :: GadtBody -> DataType
dataTypeOf :: GadtBody -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c GadtBody)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c GadtBody)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c GadtBody)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c GadtBody)
$cgmapT :: (forall b. Data b => b -> b) -> GadtBody -> GadtBody
gmapT :: (forall b. Data b => b -> b) -> GadtBody -> GadtBody
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> GadtBody -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> GadtBody -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> GadtBody -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> GadtBody -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> GadtBody -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> GadtBody -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> GadtBody -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> GadtBody -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> GadtBody -> m GadtBody
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> GadtBody -> m GadtBody
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> GadtBody -> m GadtBody
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> GadtBody -> m GadtBody
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> GadtBody -> m GadtBody
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> GadtBody -> m GadtBody
Data, GadtBody -> GadtBody -> Bool
(GadtBody -> GadtBody -> Bool)
-> (GadtBody -> GadtBody -> Bool) -> Eq GadtBody
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: GadtBody -> GadtBody -> Bool
== :: GadtBody -> GadtBody -> Bool
$c/= :: GadtBody -> GadtBody -> Bool
/= :: GadtBody -> GadtBody -> Bool
Eq, Int -> GadtBody -> ShowS
[GadtBody] -> ShowS
GadtBody -> String
(Int -> GadtBody -> ShowS)
-> (GadtBody -> String) -> ([GadtBody] -> ShowS) -> Show GadtBody
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> GadtBody -> ShowS
showsPrec :: Int -> GadtBody -> ShowS
$cshow :: GadtBody -> String
show :: GadtBody -> String
$cshowList :: [GadtBody] -> ShowS
showList :: [GadtBody] -> ShowS
Show, (forall x. GadtBody -> Rep GadtBody x)
-> (forall x. Rep GadtBody x -> GadtBody) -> Generic GadtBody
forall x. Rep GadtBody x -> GadtBody
forall x. GadtBody -> Rep GadtBody x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. GadtBody -> Rep GadtBody x
from :: forall x. GadtBody -> Rep GadtBody x
$cto :: forall x. Rep GadtBody x -> GadtBody
to :: forall x. Rep GadtBody x -> GadtBody
Generic, GadtBody -> ()
(GadtBody -> ()) -> NFData GadtBody
forall a. (a -> ()) -> NFData a
$crnf :: GadtBody -> ()
rnf :: GadtBody -> ()
NFData)

-- | Get the result type from a GADT body
gadtBodyResultType :: GadtBody -> Type
gadtBodyResultType :: GadtBody -> Type
gadtBodyResultType GadtBody
body =
  case GadtBody
body of
    GadtPrefixBody [BangType]
_ Type
ty -> Type
ty
    GadtRecordBody [FieldDecl]
_ Type
ty -> Type
ty

instance HasSourceSpan DataConDecl where
  getSourceSpan :: DataConDecl -> SourceSpan
getSourceSpan DataConDecl
dataConDecl =
    case DataConDecl
dataConDecl of
      PrefixCon SourceSpan
span' [Text]
_ [Constraint]
_ Text
_ [BangType]
_ -> SourceSpan
span'
      InfixCon SourceSpan
span' [Text]
_ [Constraint]
_ BangType
_ Text
_ BangType
_ -> SourceSpan
span'
      RecordCon SourceSpan
span' [Text]
_ [Constraint]
_ Text
_ [FieldDecl]
_ -> SourceSpan
span'
      GadtCon SourceSpan
span' [TyVarBinder]
_ [Constraint]
_ [Text]
_ GadtBody
_ -> SourceSpan
span'

data BangType = BangType
  { BangType -> SourceSpan
bangSpan :: SourceSpan,
    BangType -> Bool
bangStrict :: Bool,
    BangType -> Type
bangType :: Type
  }
  deriving (Typeable BangType
Typeable BangType =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> BangType -> c BangType)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c BangType)
-> (BangType -> Constr)
-> (BangType -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c BangType))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c BangType))
-> ((forall b. Data b => b -> b) -> BangType -> BangType)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> BangType -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> BangType -> r)
-> (forall u. (forall d. Data d => d -> u) -> BangType -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> BangType -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> BangType -> m BangType)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> BangType -> m BangType)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> BangType -> m BangType)
-> Data BangType
BangType -> Constr
BangType -> DataType
(forall b. Data b => b -> b) -> BangType -> BangType
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 -> u
forall u. (forall d. Data d => d -> u) -> BangType -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> BangType -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> BangType -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> BangType -> m BangType
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> BangType -> m BangType
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c BangType
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BangType -> c BangType
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c BangType)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c BangType)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BangType -> c BangType
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BangType -> c BangType
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c BangType
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c BangType
$ctoConstr :: BangType -> Constr
toConstr :: BangType -> Constr
$cdataTypeOf :: BangType -> DataType
dataTypeOf :: BangType -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c BangType)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c BangType)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c BangType)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c BangType)
$cgmapT :: (forall b. Data b => b -> b) -> BangType -> BangType
gmapT :: (forall b. Data b => b -> b) -> BangType -> BangType
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> BangType -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> BangType -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> BangType -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> BangType -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> BangType -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> BangType -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> BangType -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> BangType -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> BangType -> m BangType
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> BangType -> m BangType
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> BangType -> m BangType
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> BangType -> m BangType
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> BangType -> m BangType
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> BangType -> m BangType
Data, BangType -> BangType -> Bool
(BangType -> BangType -> Bool)
-> (BangType -> BangType -> Bool) -> Eq BangType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: BangType -> BangType -> Bool
== :: BangType -> BangType -> Bool
$c/= :: BangType -> BangType -> Bool
/= :: BangType -> BangType -> Bool
Eq, Int -> BangType -> ShowS
[BangType] -> ShowS
BangType -> String
(Int -> BangType -> ShowS)
-> (BangType -> String) -> ([BangType] -> ShowS) -> Show BangType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> BangType -> ShowS
showsPrec :: Int -> BangType -> ShowS
$cshow :: BangType -> String
show :: BangType -> String
$cshowList :: [BangType] -> ShowS
showList :: [BangType] -> ShowS
Show, (forall x. BangType -> Rep BangType x)
-> (forall x. Rep BangType x -> BangType) -> Generic BangType
forall x. Rep BangType x -> BangType
forall x. BangType -> Rep BangType x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. BangType -> Rep BangType x
from :: forall x. BangType -> Rep BangType x
$cto :: forall x. Rep BangType x -> BangType
to :: forall x. Rep BangType x -> BangType
Generic, BangType -> ()
(BangType -> ()) -> NFData BangType
forall a. (a -> ()) -> NFData a
$crnf :: BangType -> ()
rnf :: BangType -> ()
NFData)

instance HasSourceSpan BangType where
  getSourceSpan :: BangType -> SourceSpan
getSourceSpan = BangType -> SourceSpan
bangSpan

data FieldDecl = FieldDecl
  { FieldDecl -> SourceSpan
fieldSpan :: SourceSpan,
    FieldDecl -> [Text]
fieldNames :: [Text],
    FieldDecl -> BangType
fieldType :: BangType
  }
  deriving (Typeable FieldDecl
Typeable FieldDecl =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> FieldDecl -> c FieldDecl)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c FieldDecl)
-> (FieldDecl -> Constr)
-> (FieldDecl -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c FieldDecl))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FieldDecl))
-> ((forall b. Data b => b -> b) -> FieldDecl -> FieldDecl)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> FieldDecl -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> FieldDecl -> r)
-> (forall u. (forall d. Data d => d -> u) -> FieldDecl -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> FieldDecl -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> FieldDecl -> m FieldDecl)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> FieldDecl -> m FieldDecl)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> FieldDecl -> m FieldDecl)
-> Data FieldDecl
FieldDecl -> Constr
FieldDecl -> DataType
(forall b. Data b => b -> b) -> FieldDecl -> FieldDecl
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 -> u
forall u. (forall d. Data d => d -> u) -> FieldDecl -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FieldDecl -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FieldDecl -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> FieldDecl -> m FieldDecl
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FieldDecl -> m FieldDecl
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FieldDecl
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FieldDecl -> c FieldDecl
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c FieldDecl)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FieldDecl)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FieldDecl -> c FieldDecl
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FieldDecl -> c FieldDecl
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FieldDecl
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FieldDecl
$ctoConstr :: FieldDecl -> Constr
toConstr :: FieldDecl -> Constr
$cdataTypeOf :: FieldDecl -> DataType
dataTypeOf :: FieldDecl -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c FieldDecl)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c FieldDecl)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FieldDecl)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FieldDecl)
$cgmapT :: (forall b. Data b => b -> b) -> FieldDecl -> FieldDecl
gmapT :: (forall b. Data b => b -> b) -> FieldDecl -> FieldDecl
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FieldDecl -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FieldDecl -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FieldDecl -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FieldDecl -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> FieldDecl -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> FieldDecl -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> FieldDecl -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> FieldDecl -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> FieldDecl -> m FieldDecl
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> FieldDecl -> m FieldDecl
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FieldDecl -> m FieldDecl
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FieldDecl -> m FieldDecl
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FieldDecl -> m FieldDecl
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FieldDecl -> m FieldDecl
Data, FieldDecl -> FieldDecl -> Bool
(FieldDecl -> FieldDecl -> Bool)
-> (FieldDecl -> FieldDecl -> Bool) -> Eq FieldDecl
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: FieldDecl -> FieldDecl -> Bool
== :: FieldDecl -> FieldDecl -> Bool
$c/= :: FieldDecl -> FieldDecl -> Bool
/= :: FieldDecl -> FieldDecl -> Bool
Eq, Int -> FieldDecl -> ShowS
[FieldDecl] -> ShowS
FieldDecl -> String
(Int -> FieldDecl -> ShowS)
-> (FieldDecl -> String)
-> ([FieldDecl] -> ShowS)
-> Show FieldDecl
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> FieldDecl -> ShowS
showsPrec :: Int -> FieldDecl -> ShowS
$cshow :: FieldDecl -> String
show :: FieldDecl -> String
$cshowList :: [FieldDecl] -> ShowS
showList :: [FieldDecl] -> ShowS
Show, (forall x. FieldDecl -> Rep FieldDecl x)
-> (forall x. Rep FieldDecl x -> FieldDecl) -> Generic FieldDecl
forall x. Rep FieldDecl x -> FieldDecl
forall x. FieldDecl -> Rep FieldDecl x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. FieldDecl -> Rep FieldDecl x
from :: forall x. FieldDecl -> Rep FieldDecl x
$cto :: forall x. Rep FieldDecl x -> FieldDecl
to :: forall x. Rep FieldDecl x -> FieldDecl
Generic, FieldDecl -> ()
(FieldDecl -> ()) -> NFData FieldDecl
forall a. (a -> ()) -> NFData a
$crnf :: FieldDecl -> ()
rnf :: FieldDecl -> ()
NFData)

instance HasSourceSpan FieldDecl where
  getSourceSpan :: FieldDecl -> SourceSpan
getSourceSpan = FieldDecl -> SourceSpan
fieldSpan

data DerivingClause = DerivingClause
  { DerivingClause -> Maybe DerivingStrategy
derivingStrategy :: Maybe DerivingStrategy,
    DerivingClause -> [Text]
derivingClasses :: [Text]
  }
  deriving (Typeable DerivingClause
Typeable DerivingClause =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> DerivingClause -> c DerivingClause)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DerivingClause)
-> (DerivingClause -> Constr)
-> (DerivingClause -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DerivingClause))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c DerivingClause))
-> ((forall b. Data b => b -> b)
    -> DerivingClause -> DerivingClause)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DerivingClause -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DerivingClause -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> DerivingClause -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> DerivingClause -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> DerivingClause -> m DerivingClause)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DerivingClause -> m DerivingClause)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DerivingClause -> m DerivingClause)
-> Data DerivingClause
DerivingClause -> Constr
DerivingClause -> DataType
(forall b. Data b => b -> b) -> DerivingClause -> DerivingClause
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) -> DerivingClause -> u
forall u. (forall d. Data d => d -> u) -> DerivingClause -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DerivingClause -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DerivingClause -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DerivingClause -> m DerivingClause
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DerivingClause -> m DerivingClause
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DerivingClause
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DerivingClause -> c DerivingClause
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DerivingClause)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DerivingClause)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DerivingClause -> c DerivingClause
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DerivingClause -> c DerivingClause
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DerivingClause
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DerivingClause
$ctoConstr :: DerivingClause -> Constr
toConstr :: DerivingClause -> Constr
$cdataTypeOf :: DerivingClause -> DataType
dataTypeOf :: DerivingClause -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DerivingClause)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DerivingClause)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DerivingClause)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DerivingClause)
$cgmapT :: (forall b. Data b => b -> b) -> DerivingClause -> DerivingClause
gmapT :: (forall b. Data b => b -> b) -> DerivingClause -> DerivingClause
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DerivingClause -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DerivingClause -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DerivingClause -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DerivingClause -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DerivingClause -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> DerivingClause -> [u]
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> DerivingClause -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> DerivingClause -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DerivingClause -> m DerivingClause
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DerivingClause -> m DerivingClause
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DerivingClause -> m DerivingClause
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DerivingClause -> m DerivingClause
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DerivingClause -> m DerivingClause
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DerivingClause -> m DerivingClause
Data, DerivingClause -> DerivingClause -> Bool
(DerivingClause -> DerivingClause -> Bool)
-> (DerivingClause -> DerivingClause -> Bool) -> Eq DerivingClause
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DerivingClause -> DerivingClause -> Bool
== :: DerivingClause -> DerivingClause -> Bool
$c/= :: DerivingClause -> DerivingClause -> Bool
/= :: DerivingClause -> DerivingClause -> Bool
Eq, Int -> DerivingClause -> ShowS
[DerivingClause] -> ShowS
DerivingClause -> String
(Int -> DerivingClause -> ShowS)
-> (DerivingClause -> String)
-> ([DerivingClause] -> ShowS)
-> Show DerivingClause
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DerivingClause -> ShowS
showsPrec :: Int -> DerivingClause -> ShowS
$cshow :: DerivingClause -> String
show :: DerivingClause -> String
$cshowList :: [DerivingClause] -> ShowS
showList :: [DerivingClause] -> ShowS
Show, (forall x. DerivingClause -> Rep DerivingClause x)
-> (forall x. Rep DerivingClause x -> DerivingClause)
-> Generic DerivingClause
forall x. Rep DerivingClause x -> DerivingClause
forall x. DerivingClause -> Rep DerivingClause x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. DerivingClause -> Rep DerivingClause x
from :: forall x. DerivingClause -> Rep DerivingClause x
$cto :: forall x. Rep DerivingClause x -> DerivingClause
to :: forall x. Rep DerivingClause x -> DerivingClause
Generic, DerivingClause -> ()
(DerivingClause -> ()) -> NFData DerivingClause
forall a. (a -> ()) -> NFData a
$crnf :: DerivingClause -> ()
rnf :: DerivingClause -> ()
NFData)

data DerivingStrategy
  = DerivingStock
  | DerivingNewtype
  | DerivingAnyclass
  deriving (Typeable DerivingStrategy
Typeable DerivingStrategy =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> DerivingStrategy -> c DerivingStrategy)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DerivingStrategy)
-> (DerivingStrategy -> Constr)
-> (DerivingStrategy -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DerivingStrategy))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c DerivingStrategy))
-> ((forall b. Data b => b -> b)
    -> DerivingStrategy -> DerivingStrategy)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DerivingStrategy -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DerivingStrategy -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> DerivingStrategy -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> DerivingStrategy -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> DerivingStrategy -> m DerivingStrategy)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DerivingStrategy -> m DerivingStrategy)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DerivingStrategy -> m DerivingStrategy)
-> Data DerivingStrategy
DerivingStrategy -> Constr
DerivingStrategy -> DataType
(forall b. Data b => b -> b)
-> DerivingStrategy -> DerivingStrategy
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) -> DerivingStrategy -> u
forall u. (forall d. Data d => d -> u) -> DerivingStrategy -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DerivingStrategy -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DerivingStrategy -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DerivingStrategy -> m DerivingStrategy
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DerivingStrategy -> m DerivingStrategy
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DerivingStrategy
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DerivingStrategy -> c DerivingStrategy
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DerivingStrategy)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DerivingStrategy)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DerivingStrategy -> c DerivingStrategy
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DerivingStrategy -> c DerivingStrategy
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DerivingStrategy
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DerivingStrategy
$ctoConstr :: DerivingStrategy -> Constr
toConstr :: DerivingStrategy -> Constr
$cdataTypeOf :: DerivingStrategy -> DataType
dataTypeOf :: DerivingStrategy -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DerivingStrategy)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DerivingStrategy)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DerivingStrategy)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DerivingStrategy)
$cgmapT :: (forall b. Data b => b -> b)
-> DerivingStrategy -> DerivingStrategy
gmapT :: (forall b. Data b => b -> b)
-> DerivingStrategy -> DerivingStrategy
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DerivingStrategy -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DerivingStrategy -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DerivingStrategy -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DerivingStrategy -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DerivingStrategy -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> DerivingStrategy -> [u]
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> DerivingStrategy -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> DerivingStrategy -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DerivingStrategy -> m DerivingStrategy
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DerivingStrategy -> m DerivingStrategy
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DerivingStrategy -> m DerivingStrategy
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DerivingStrategy -> m DerivingStrategy
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DerivingStrategy -> m DerivingStrategy
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DerivingStrategy -> m DerivingStrategy
Data, DerivingStrategy -> DerivingStrategy -> Bool
(DerivingStrategy -> DerivingStrategy -> Bool)
-> (DerivingStrategy -> DerivingStrategy -> Bool)
-> Eq DerivingStrategy
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DerivingStrategy -> DerivingStrategy -> Bool
== :: DerivingStrategy -> DerivingStrategy -> Bool
$c/= :: DerivingStrategy -> DerivingStrategy -> Bool
/= :: DerivingStrategy -> DerivingStrategy -> Bool
Eq, Int -> DerivingStrategy -> ShowS
[DerivingStrategy] -> ShowS
DerivingStrategy -> String
(Int -> DerivingStrategy -> ShowS)
-> (DerivingStrategy -> String)
-> ([DerivingStrategy] -> ShowS)
-> Show DerivingStrategy
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DerivingStrategy -> ShowS
showsPrec :: Int -> DerivingStrategy -> ShowS
$cshow :: DerivingStrategy -> String
show :: DerivingStrategy -> String
$cshowList :: [DerivingStrategy] -> ShowS
showList :: [DerivingStrategy] -> ShowS
Show, (forall x. DerivingStrategy -> Rep DerivingStrategy x)
-> (forall x. Rep DerivingStrategy x -> DerivingStrategy)
-> Generic DerivingStrategy
forall x. Rep DerivingStrategy x -> DerivingStrategy
forall x. DerivingStrategy -> Rep DerivingStrategy x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. DerivingStrategy -> Rep DerivingStrategy x
from :: forall x. DerivingStrategy -> Rep DerivingStrategy x
$cto :: forall x. Rep DerivingStrategy x -> DerivingStrategy
to :: forall x. Rep DerivingStrategy x -> DerivingStrategy
Generic, DerivingStrategy -> ()
(DerivingStrategy -> ()) -> NFData DerivingStrategy
forall a. (a -> ()) -> NFData a
$crnf :: DerivingStrategy -> ()
rnf :: DerivingStrategy -> ()
NFData)

data StandaloneDerivingDecl = StandaloneDerivingDecl
  { StandaloneDerivingDecl -> SourceSpan
standaloneDerivingSpan :: SourceSpan,
    StandaloneDerivingDecl -> Maybe DerivingStrategy
standaloneDerivingStrategy :: Maybe DerivingStrategy,
    StandaloneDerivingDecl -> [Constraint]
standaloneDerivingContext :: [Constraint],
    StandaloneDerivingDecl -> Text
standaloneDerivingClassName :: Text,
    StandaloneDerivingDecl -> [Type]
standaloneDerivingTypes :: [Type]
  }
  deriving (Typeable StandaloneDerivingDecl
Typeable StandaloneDerivingDecl =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g)
 -> StandaloneDerivingDecl
 -> c StandaloneDerivingDecl)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c StandaloneDerivingDecl)
-> (StandaloneDerivingDecl -> Constr)
-> (StandaloneDerivingDecl -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c StandaloneDerivingDecl))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c StandaloneDerivingDecl))
-> ((forall b. Data b => b -> b)
    -> StandaloneDerivingDecl -> StandaloneDerivingDecl)
-> (forall r r'.
    (r -> r' -> r)
    -> r
    -> (forall d. Data d => d -> r')
    -> StandaloneDerivingDecl
    -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r
    -> (forall d. Data d => d -> r')
    -> StandaloneDerivingDecl
    -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> StandaloneDerivingDecl -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> StandaloneDerivingDecl -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> StandaloneDerivingDecl -> m StandaloneDerivingDecl)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> StandaloneDerivingDecl -> m StandaloneDerivingDecl)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> StandaloneDerivingDecl -> m StandaloneDerivingDecl)
-> Data StandaloneDerivingDecl
StandaloneDerivingDecl -> Constr
StandaloneDerivingDecl -> DataType
(forall b. Data b => b -> b)
-> StandaloneDerivingDecl -> StandaloneDerivingDecl
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) -> StandaloneDerivingDecl -> u
forall u.
(forall d. Data d => d -> u) -> StandaloneDerivingDecl -> [u]
forall r r'.
(r -> r' -> r)
-> r
-> (forall d. Data d => d -> r')
-> StandaloneDerivingDecl
-> r
forall r r'.
(r' -> r -> r)
-> r
-> (forall d. Data d => d -> r')
-> StandaloneDerivingDecl
-> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> StandaloneDerivingDecl -> m StandaloneDerivingDecl
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> StandaloneDerivingDecl -> m StandaloneDerivingDecl
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c StandaloneDerivingDecl
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> StandaloneDerivingDecl
-> c StandaloneDerivingDecl
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c StandaloneDerivingDecl)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c StandaloneDerivingDecl)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> StandaloneDerivingDecl
-> c StandaloneDerivingDecl
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> StandaloneDerivingDecl
-> c StandaloneDerivingDecl
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c StandaloneDerivingDecl
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c StandaloneDerivingDecl
$ctoConstr :: StandaloneDerivingDecl -> Constr
toConstr :: StandaloneDerivingDecl -> Constr
$cdataTypeOf :: StandaloneDerivingDecl -> DataType
dataTypeOf :: StandaloneDerivingDecl -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c StandaloneDerivingDecl)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c StandaloneDerivingDecl)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c StandaloneDerivingDecl)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c StandaloneDerivingDecl)
$cgmapT :: (forall b. Data b => b -> b)
-> StandaloneDerivingDecl -> StandaloneDerivingDecl
gmapT :: (forall b. Data b => b -> b)
-> StandaloneDerivingDecl -> StandaloneDerivingDecl
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r
-> (forall d. Data d => d -> r')
-> StandaloneDerivingDecl
-> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r
-> (forall d. Data d => d -> r')
-> StandaloneDerivingDecl
-> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r
-> (forall d. Data d => d -> r')
-> StandaloneDerivingDecl
-> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r
-> (forall d. Data d => d -> r')
-> StandaloneDerivingDecl
-> r
$cgmapQ :: forall u.
(forall d. Data d => d -> u) -> StandaloneDerivingDecl -> [u]
gmapQ :: forall u.
(forall d. Data d => d -> u) -> StandaloneDerivingDecl -> [u]
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> StandaloneDerivingDecl -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> StandaloneDerivingDecl -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> StandaloneDerivingDecl -> m StandaloneDerivingDecl
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> StandaloneDerivingDecl -> m StandaloneDerivingDecl
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> StandaloneDerivingDecl -> m StandaloneDerivingDecl
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> StandaloneDerivingDecl -> m StandaloneDerivingDecl
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> StandaloneDerivingDecl -> m StandaloneDerivingDecl
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> StandaloneDerivingDecl -> m StandaloneDerivingDecl
Data, StandaloneDerivingDecl -> StandaloneDerivingDecl -> Bool
(StandaloneDerivingDecl -> StandaloneDerivingDecl -> Bool)
-> (StandaloneDerivingDecl -> StandaloneDerivingDecl -> Bool)
-> Eq StandaloneDerivingDecl
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: StandaloneDerivingDecl -> StandaloneDerivingDecl -> Bool
== :: StandaloneDerivingDecl -> StandaloneDerivingDecl -> Bool
$c/= :: StandaloneDerivingDecl -> StandaloneDerivingDecl -> Bool
/= :: StandaloneDerivingDecl -> StandaloneDerivingDecl -> Bool
Eq, Int -> StandaloneDerivingDecl -> ShowS
[StandaloneDerivingDecl] -> ShowS
StandaloneDerivingDecl -> String
(Int -> StandaloneDerivingDecl -> ShowS)
-> (StandaloneDerivingDecl -> String)
-> ([StandaloneDerivingDecl] -> ShowS)
-> Show StandaloneDerivingDecl
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> StandaloneDerivingDecl -> ShowS
showsPrec :: Int -> StandaloneDerivingDecl -> ShowS
$cshow :: StandaloneDerivingDecl -> String
show :: StandaloneDerivingDecl -> String
$cshowList :: [StandaloneDerivingDecl] -> ShowS
showList :: [StandaloneDerivingDecl] -> ShowS
Show, (forall x. StandaloneDerivingDecl -> Rep StandaloneDerivingDecl x)
-> (forall x.
    Rep StandaloneDerivingDecl x -> StandaloneDerivingDecl)
-> Generic StandaloneDerivingDecl
forall x. Rep StandaloneDerivingDecl x -> StandaloneDerivingDecl
forall x. StandaloneDerivingDecl -> Rep StandaloneDerivingDecl x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. StandaloneDerivingDecl -> Rep StandaloneDerivingDecl x
from :: forall x. StandaloneDerivingDecl -> Rep StandaloneDerivingDecl x
$cto :: forall x. Rep StandaloneDerivingDecl x -> StandaloneDerivingDecl
to :: forall x. Rep StandaloneDerivingDecl x -> StandaloneDerivingDecl
Generic, StandaloneDerivingDecl -> ()
(StandaloneDerivingDecl -> ()) -> NFData StandaloneDerivingDecl
forall a. (a -> ()) -> NFData a
$crnf :: StandaloneDerivingDecl -> ()
rnf :: StandaloneDerivingDecl -> ()
NFData)

instance HasSourceSpan StandaloneDerivingDecl where
  getSourceSpan :: StandaloneDerivingDecl -> SourceSpan
getSourceSpan = StandaloneDerivingDecl -> SourceSpan
standaloneDerivingSpan

data ClassDecl = ClassDecl
  { ClassDecl -> SourceSpan
classDeclSpan :: SourceSpan,
    ClassDecl -> Maybe [Constraint]
classDeclContext :: Maybe [Constraint],
    ClassDecl -> Text
classDeclName :: Text,
    ClassDecl -> [TyVarBinder]
classDeclParams :: [TyVarBinder],
    ClassDecl -> [ClassDeclItem]
classDeclItems :: [ClassDeclItem]
  }
  deriving (Typeable ClassDecl
Typeable ClassDecl =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> ClassDecl -> c ClassDecl)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ClassDecl)
-> (ClassDecl -> Constr)
-> (ClassDecl -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ClassDecl))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ClassDecl))
-> ((forall b. Data b => b -> b) -> ClassDecl -> ClassDecl)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ClassDecl -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ClassDecl -> r)
-> (forall u. (forall d. Data d => d -> u) -> ClassDecl -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> ClassDecl -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ClassDecl -> m ClassDecl)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ClassDecl -> m ClassDecl)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ClassDecl -> m ClassDecl)
-> Data ClassDecl
ClassDecl -> Constr
ClassDecl -> DataType
(forall b. Data b => b -> b) -> ClassDecl -> ClassDecl
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 -> u
forall u. (forall d. Data d => d -> u) -> ClassDecl -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ClassDecl -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ClassDecl -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ClassDecl -> m ClassDecl
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ClassDecl -> m ClassDecl
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ClassDecl
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ClassDecl -> c ClassDecl
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ClassDecl)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ClassDecl)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ClassDecl -> c ClassDecl
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ClassDecl -> c ClassDecl
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ClassDecl
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ClassDecl
$ctoConstr :: ClassDecl -> Constr
toConstr :: ClassDecl -> Constr
$cdataTypeOf :: ClassDecl -> DataType
dataTypeOf :: ClassDecl -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ClassDecl)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ClassDecl)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ClassDecl)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ClassDecl)
$cgmapT :: (forall b. Data b => b -> b) -> ClassDecl -> ClassDecl
gmapT :: (forall b. Data b => b -> b) -> ClassDecl -> ClassDecl
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ClassDecl -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ClassDecl -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ClassDecl -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ClassDecl -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> ClassDecl -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> ClassDecl -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ClassDecl -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ClassDecl -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ClassDecl -> m ClassDecl
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ClassDecl -> m ClassDecl
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ClassDecl -> m ClassDecl
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ClassDecl -> m ClassDecl
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ClassDecl -> m ClassDecl
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ClassDecl -> m ClassDecl
Data, ClassDecl -> ClassDecl -> Bool
(ClassDecl -> ClassDecl -> Bool)
-> (ClassDecl -> ClassDecl -> Bool) -> Eq ClassDecl
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ClassDecl -> ClassDecl -> Bool
== :: ClassDecl -> ClassDecl -> Bool
$c/= :: ClassDecl -> ClassDecl -> Bool
/= :: ClassDecl -> ClassDecl -> Bool
Eq, Int -> ClassDecl -> ShowS
[ClassDecl] -> ShowS
ClassDecl -> String
(Int -> ClassDecl -> ShowS)
-> (ClassDecl -> String)
-> ([ClassDecl] -> ShowS)
-> Show ClassDecl
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ClassDecl -> ShowS
showsPrec :: Int -> ClassDecl -> ShowS
$cshow :: ClassDecl -> String
show :: ClassDecl -> String
$cshowList :: [ClassDecl] -> ShowS
showList :: [ClassDecl] -> ShowS
Show, (forall x. ClassDecl -> Rep ClassDecl x)
-> (forall x. Rep ClassDecl x -> ClassDecl) -> Generic ClassDecl
forall x. Rep ClassDecl x -> ClassDecl
forall x. ClassDecl -> Rep ClassDecl x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. ClassDecl -> Rep ClassDecl x
from :: forall x. ClassDecl -> Rep ClassDecl x
$cto :: forall x. Rep ClassDecl x -> ClassDecl
to :: forall x. Rep ClassDecl x -> ClassDecl
Generic, ClassDecl -> ()
(ClassDecl -> ()) -> NFData ClassDecl
forall a. (a -> ()) -> NFData a
$crnf :: ClassDecl -> ()
rnf :: ClassDecl -> ()
NFData)

instance HasSourceSpan ClassDecl where
  getSourceSpan :: ClassDecl -> SourceSpan
getSourceSpan = ClassDecl -> SourceSpan
classDeclSpan

data ClassDeclItem
  = ClassItemTypeSig SourceSpan [BinderName] Type
  | ClassItemFixity SourceSpan FixityAssoc (Maybe Int) [OperatorName]
  | ClassItemDefault SourceSpan ValueDecl
  deriving (Typeable ClassDeclItem
Typeable ClassDeclItem =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> ClassDeclItem -> c ClassDeclItem)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ClassDeclItem)
-> (ClassDeclItem -> Constr)
-> (ClassDeclItem -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ClassDeclItem))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c ClassDeclItem))
-> ((forall b. Data b => b -> b) -> ClassDeclItem -> ClassDeclItem)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ClassDeclItem -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ClassDeclItem -> r)
-> (forall u. (forall d. Data d => d -> u) -> ClassDeclItem -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> ClassDeclItem -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ClassDeclItem -> m ClassDeclItem)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ClassDeclItem -> m ClassDeclItem)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ClassDeclItem -> m ClassDeclItem)
-> Data ClassDeclItem
ClassDeclItem -> Constr
ClassDeclItem -> DataType
(forall b. Data b => b -> b) -> ClassDeclItem -> ClassDeclItem
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) -> ClassDeclItem -> u
forall u. (forall d. Data d => d -> u) -> ClassDeclItem -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ClassDeclItem -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ClassDeclItem -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ClassDeclItem -> m ClassDeclItem
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ClassDeclItem -> m ClassDeclItem
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ClassDeclItem
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ClassDeclItem -> c ClassDeclItem
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ClassDeclItem)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ClassDeclItem)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ClassDeclItem -> c ClassDeclItem
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ClassDeclItem -> c ClassDeclItem
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ClassDeclItem
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ClassDeclItem
$ctoConstr :: ClassDeclItem -> Constr
toConstr :: ClassDeclItem -> Constr
$cdataTypeOf :: ClassDeclItem -> DataType
dataTypeOf :: ClassDeclItem -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ClassDeclItem)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ClassDeclItem)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ClassDeclItem)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ClassDeclItem)
$cgmapT :: (forall b. Data b => b -> b) -> ClassDeclItem -> ClassDeclItem
gmapT :: (forall b. Data b => b -> b) -> ClassDeclItem -> ClassDeclItem
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ClassDeclItem -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ClassDeclItem -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ClassDeclItem -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ClassDeclItem -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> ClassDeclItem -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> ClassDeclItem -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ClassDeclItem -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ClassDeclItem -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ClassDeclItem -> m ClassDeclItem
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ClassDeclItem -> m ClassDeclItem
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ClassDeclItem -> m ClassDeclItem
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ClassDeclItem -> m ClassDeclItem
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ClassDeclItem -> m ClassDeclItem
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ClassDeclItem -> m ClassDeclItem
Data, ClassDeclItem -> ClassDeclItem -> Bool
(ClassDeclItem -> ClassDeclItem -> Bool)
-> (ClassDeclItem -> ClassDeclItem -> Bool) -> Eq ClassDeclItem
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ClassDeclItem -> ClassDeclItem -> Bool
== :: ClassDeclItem -> ClassDeclItem -> Bool
$c/= :: ClassDeclItem -> ClassDeclItem -> Bool
/= :: ClassDeclItem -> ClassDeclItem -> Bool
Eq, Int -> ClassDeclItem -> ShowS
[ClassDeclItem] -> ShowS
ClassDeclItem -> String
(Int -> ClassDeclItem -> ShowS)
-> (ClassDeclItem -> String)
-> ([ClassDeclItem] -> ShowS)
-> Show ClassDeclItem
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ClassDeclItem -> ShowS
showsPrec :: Int -> ClassDeclItem -> ShowS
$cshow :: ClassDeclItem -> String
show :: ClassDeclItem -> String
$cshowList :: [ClassDeclItem] -> ShowS
showList :: [ClassDeclItem] -> ShowS
Show, (forall x. ClassDeclItem -> Rep ClassDeclItem x)
-> (forall x. Rep ClassDeclItem x -> ClassDeclItem)
-> Generic ClassDeclItem
forall x. Rep ClassDeclItem x -> ClassDeclItem
forall x. ClassDeclItem -> Rep ClassDeclItem x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. ClassDeclItem -> Rep ClassDeclItem x
from :: forall x. ClassDeclItem -> Rep ClassDeclItem x
$cto :: forall x. Rep ClassDeclItem x -> ClassDeclItem
to :: forall x. Rep ClassDeclItem x -> ClassDeclItem
Generic, ClassDeclItem -> ()
(ClassDeclItem -> ()) -> NFData ClassDeclItem
forall a. (a -> ()) -> NFData a
$crnf :: ClassDeclItem -> ()
rnf :: ClassDeclItem -> ()
NFData)

instance HasSourceSpan ClassDeclItem where
  getSourceSpan :: ClassDeclItem -> SourceSpan
getSourceSpan ClassDeclItem
classDeclItem =
    case ClassDeclItem
classDeclItem of
      ClassItemTypeSig SourceSpan
span' [Text]
_ Type
_ -> SourceSpan
span'
      ClassItemFixity SourceSpan
span' FixityAssoc
_ Maybe Int
_ [Text]
_ -> SourceSpan
span'
      ClassItemDefault SourceSpan
span' ValueDecl
_ -> SourceSpan
span'

data InstanceDecl = InstanceDecl
  { InstanceDecl -> SourceSpan
instanceDeclSpan :: SourceSpan,
    InstanceDecl -> [Constraint]
instanceDeclContext :: [Constraint],
    InstanceDecl -> Text
instanceDeclClassName :: Text,
    InstanceDecl -> [Type]
instanceDeclTypes :: [Type],
    InstanceDecl -> [InstanceDeclItem]
instanceDeclItems :: [InstanceDeclItem]
  }
  deriving (Typeable InstanceDecl
Typeable InstanceDecl =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> InstanceDecl -> c InstanceDecl)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c InstanceDecl)
-> (InstanceDecl -> Constr)
-> (InstanceDecl -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c InstanceDecl))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c InstanceDecl))
-> ((forall b. Data b => b -> b) -> InstanceDecl -> InstanceDecl)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> InstanceDecl -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> InstanceDecl -> r)
-> (forall u. (forall d. Data d => d -> u) -> InstanceDecl -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> InstanceDecl -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> InstanceDecl -> m InstanceDecl)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> InstanceDecl -> m InstanceDecl)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> InstanceDecl -> m InstanceDecl)
-> Data InstanceDecl
InstanceDecl -> Constr
InstanceDecl -> DataType
(forall b. Data b => b -> b) -> InstanceDecl -> InstanceDecl
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) -> InstanceDecl -> u
forall u. (forall d. Data d => d -> u) -> InstanceDecl -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> InstanceDecl -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> InstanceDecl -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> InstanceDecl -> m InstanceDecl
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> InstanceDecl -> m InstanceDecl
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c InstanceDecl
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> InstanceDecl -> c InstanceDecl
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c InstanceDecl)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c InstanceDecl)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> InstanceDecl -> c InstanceDecl
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> InstanceDecl -> c InstanceDecl
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c InstanceDecl
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c InstanceDecl
$ctoConstr :: InstanceDecl -> Constr
toConstr :: InstanceDecl -> Constr
$cdataTypeOf :: InstanceDecl -> DataType
dataTypeOf :: InstanceDecl -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c InstanceDecl)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c InstanceDecl)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c InstanceDecl)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c InstanceDecl)
$cgmapT :: (forall b. Data b => b -> b) -> InstanceDecl -> InstanceDecl
gmapT :: (forall b. Data b => b -> b) -> InstanceDecl -> InstanceDecl
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> InstanceDecl -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> InstanceDecl -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> InstanceDecl -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> InstanceDecl -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> InstanceDecl -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> InstanceDecl -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> InstanceDecl -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> InstanceDecl -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> InstanceDecl -> m InstanceDecl
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> InstanceDecl -> m InstanceDecl
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> InstanceDecl -> m InstanceDecl
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> InstanceDecl -> m InstanceDecl
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> InstanceDecl -> m InstanceDecl
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> InstanceDecl -> m InstanceDecl
Data, InstanceDecl -> InstanceDecl -> Bool
(InstanceDecl -> InstanceDecl -> Bool)
-> (InstanceDecl -> InstanceDecl -> Bool) -> Eq InstanceDecl
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: InstanceDecl -> InstanceDecl -> Bool
== :: InstanceDecl -> InstanceDecl -> Bool
$c/= :: InstanceDecl -> InstanceDecl -> Bool
/= :: InstanceDecl -> InstanceDecl -> Bool
Eq, Int -> InstanceDecl -> ShowS
[InstanceDecl] -> ShowS
InstanceDecl -> String
(Int -> InstanceDecl -> ShowS)
-> (InstanceDecl -> String)
-> ([InstanceDecl] -> ShowS)
-> Show InstanceDecl
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> InstanceDecl -> ShowS
showsPrec :: Int -> InstanceDecl -> ShowS
$cshow :: InstanceDecl -> String
show :: InstanceDecl -> String
$cshowList :: [InstanceDecl] -> ShowS
showList :: [InstanceDecl] -> ShowS
Show, (forall x. InstanceDecl -> Rep InstanceDecl x)
-> (forall x. Rep InstanceDecl x -> InstanceDecl)
-> Generic InstanceDecl
forall x. Rep InstanceDecl x -> InstanceDecl
forall x. InstanceDecl -> Rep InstanceDecl x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. InstanceDecl -> Rep InstanceDecl x
from :: forall x. InstanceDecl -> Rep InstanceDecl x
$cto :: forall x. Rep InstanceDecl x -> InstanceDecl
to :: forall x. Rep InstanceDecl x -> InstanceDecl
Generic, InstanceDecl -> ()
(InstanceDecl -> ()) -> NFData InstanceDecl
forall a. (a -> ()) -> NFData a
$crnf :: InstanceDecl -> ()
rnf :: InstanceDecl -> ()
NFData)

instance HasSourceSpan InstanceDecl where
  getSourceSpan :: InstanceDecl -> SourceSpan
getSourceSpan = InstanceDecl -> SourceSpan
instanceDeclSpan

data InstanceDeclItem
  = InstanceItemBind SourceSpan ValueDecl
  | InstanceItemTypeSig SourceSpan [BinderName] Type
  | InstanceItemFixity SourceSpan FixityAssoc (Maybe Int) [OperatorName]
  deriving (Typeable InstanceDeclItem
Typeable InstanceDeclItem =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> InstanceDeclItem -> c InstanceDeclItem)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c InstanceDeclItem)
-> (InstanceDeclItem -> Constr)
-> (InstanceDeclItem -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c InstanceDeclItem))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c InstanceDeclItem))
-> ((forall b. Data b => b -> b)
    -> InstanceDeclItem -> InstanceDeclItem)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> InstanceDeclItem -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> InstanceDeclItem -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> InstanceDeclItem -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> InstanceDeclItem -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> InstanceDeclItem -> m InstanceDeclItem)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> InstanceDeclItem -> m InstanceDeclItem)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> InstanceDeclItem -> m InstanceDeclItem)
-> Data InstanceDeclItem
InstanceDeclItem -> Constr
InstanceDeclItem -> DataType
(forall b. Data b => b -> b)
-> InstanceDeclItem -> InstanceDeclItem
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) -> InstanceDeclItem -> u
forall u. (forall d. Data d => d -> u) -> InstanceDeclItem -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> InstanceDeclItem -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> InstanceDeclItem -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> InstanceDeclItem -> m InstanceDeclItem
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> InstanceDeclItem -> m InstanceDeclItem
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c InstanceDeclItem
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> InstanceDeclItem -> c InstanceDeclItem
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c InstanceDeclItem)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c InstanceDeclItem)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> InstanceDeclItem -> c InstanceDeclItem
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> InstanceDeclItem -> c InstanceDeclItem
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c InstanceDeclItem
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c InstanceDeclItem
$ctoConstr :: InstanceDeclItem -> Constr
toConstr :: InstanceDeclItem -> Constr
$cdataTypeOf :: InstanceDeclItem -> DataType
dataTypeOf :: InstanceDeclItem -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c InstanceDeclItem)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c InstanceDeclItem)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c InstanceDeclItem)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c InstanceDeclItem)
$cgmapT :: (forall b. Data b => b -> b)
-> InstanceDeclItem -> InstanceDeclItem
gmapT :: (forall b. Data b => b -> b)
-> InstanceDeclItem -> InstanceDeclItem
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> InstanceDeclItem -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> InstanceDeclItem -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> InstanceDeclItem -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> InstanceDeclItem -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> InstanceDeclItem -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> InstanceDeclItem -> [u]
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> InstanceDeclItem -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> InstanceDeclItem -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> InstanceDeclItem -> m InstanceDeclItem
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> InstanceDeclItem -> m InstanceDeclItem
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> InstanceDeclItem -> m InstanceDeclItem
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> InstanceDeclItem -> m InstanceDeclItem
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> InstanceDeclItem -> m InstanceDeclItem
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> InstanceDeclItem -> m InstanceDeclItem
Data, InstanceDeclItem -> InstanceDeclItem -> Bool
(InstanceDeclItem -> InstanceDeclItem -> Bool)
-> (InstanceDeclItem -> InstanceDeclItem -> Bool)
-> Eq InstanceDeclItem
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: InstanceDeclItem -> InstanceDeclItem -> Bool
== :: InstanceDeclItem -> InstanceDeclItem -> Bool
$c/= :: InstanceDeclItem -> InstanceDeclItem -> Bool
/= :: InstanceDeclItem -> InstanceDeclItem -> Bool
Eq, Int -> InstanceDeclItem -> ShowS
[InstanceDeclItem] -> ShowS
InstanceDeclItem -> String
(Int -> InstanceDeclItem -> ShowS)
-> (InstanceDeclItem -> String)
-> ([InstanceDeclItem] -> ShowS)
-> Show InstanceDeclItem
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> InstanceDeclItem -> ShowS
showsPrec :: Int -> InstanceDeclItem -> ShowS
$cshow :: InstanceDeclItem -> String
show :: InstanceDeclItem -> String
$cshowList :: [InstanceDeclItem] -> ShowS
showList :: [InstanceDeclItem] -> ShowS
Show, (forall x. InstanceDeclItem -> Rep InstanceDeclItem x)
-> (forall x. Rep InstanceDeclItem x -> InstanceDeclItem)
-> Generic InstanceDeclItem
forall x. Rep InstanceDeclItem x -> InstanceDeclItem
forall x. InstanceDeclItem -> Rep InstanceDeclItem x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. InstanceDeclItem -> Rep InstanceDeclItem x
from :: forall x. InstanceDeclItem -> Rep InstanceDeclItem x
$cto :: forall x. Rep InstanceDeclItem x -> InstanceDeclItem
to :: forall x. Rep InstanceDeclItem x -> InstanceDeclItem
Generic, InstanceDeclItem -> ()
(InstanceDeclItem -> ()) -> NFData InstanceDeclItem
forall a. (a -> ()) -> NFData a
$crnf :: InstanceDeclItem -> ()
rnf :: InstanceDeclItem -> ()
NFData)

instance HasSourceSpan InstanceDeclItem where
  getSourceSpan :: InstanceDeclItem -> SourceSpan
getSourceSpan InstanceDeclItem
instanceDeclItem =
    case InstanceDeclItem
instanceDeclItem of
      InstanceItemBind SourceSpan
span' ValueDecl
_ -> SourceSpan
span'
      InstanceItemTypeSig SourceSpan
span' [Text]
_ Type
_ -> SourceSpan
span'
      InstanceItemFixity SourceSpan
span' FixityAssoc
_ Maybe Int
_ [Text]
_ -> SourceSpan
span'

data FixityAssoc
  = Infix
  | InfixL
  | InfixR
  deriving (Typeable FixityAssoc
Typeable FixityAssoc =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> FixityAssoc -> c FixityAssoc)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c FixityAssoc)
-> (FixityAssoc -> Constr)
-> (FixityAssoc -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c FixityAssoc))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c FixityAssoc))
-> ((forall b. Data b => b -> b) -> FixityAssoc -> FixityAssoc)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> FixityAssoc -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> FixityAssoc -> r)
-> (forall u. (forall d. Data d => d -> u) -> FixityAssoc -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> FixityAssoc -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> FixityAssoc -> m FixityAssoc)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> FixityAssoc -> m FixityAssoc)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> FixityAssoc -> m FixityAssoc)
-> Data FixityAssoc
FixityAssoc -> Constr
FixityAssoc -> DataType
(forall b. Data b => b -> b) -> FixityAssoc -> FixityAssoc
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) -> FixityAssoc -> u
forall u. (forall d. Data d => d -> u) -> FixityAssoc -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FixityAssoc -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FixityAssoc -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> FixityAssoc -> m FixityAssoc
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FixityAssoc -> m FixityAssoc
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FixityAssoc
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FixityAssoc -> c FixityAssoc
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c FixityAssoc)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c FixityAssoc)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FixityAssoc -> c FixityAssoc
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FixityAssoc -> c FixityAssoc
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FixityAssoc
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FixityAssoc
$ctoConstr :: FixityAssoc -> Constr
toConstr :: FixityAssoc -> Constr
$cdataTypeOf :: FixityAssoc -> DataType
dataTypeOf :: FixityAssoc -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c FixityAssoc)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c FixityAssoc)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c FixityAssoc)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c FixityAssoc)
$cgmapT :: (forall b. Data b => b -> b) -> FixityAssoc -> FixityAssoc
gmapT :: (forall b. Data b => b -> b) -> FixityAssoc -> FixityAssoc
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FixityAssoc -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FixityAssoc -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FixityAssoc -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FixityAssoc -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> FixityAssoc -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> FixityAssoc -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> FixityAssoc -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> FixityAssoc -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> FixityAssoc -> m FixityAssoc
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> FixityAssoc -> m FixityAssoc
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FixityAssoc -> m FixityAssoc
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FixityAssoc -> m FixityAssoc
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FixityAssoc -> m FixityAssoc
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FixityAssoc -> m FixityAssoc
Data, FixityAssoc -> FixityAssoc -> Bool
(FixityAssoc -> FixityAssoc -> Bool)
-> (FixityAssoc -> FixityAssoc -> Bool) -> Eq FixityAssoc
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: FixityAssoc -> FixityAssoc -> Bool
== :: FixityAssoc -> FixityAssoc -> Bool
$c/= :: FixityAssoc -> FixityAssoc -> Bool
/= :: FixityAssoc -> FixityAssoc -> Bool
Eq, Int -> FixityAssoc -> ShowS
[FixityAssoc] -> ShowS
FixityAssoc -> String
(Int -> FixityAssoc -> ShowS)
-> (FixityAssoc -> String)
-> ([FixityAssoc] -> ShowS)
-> Show FixityAssoc
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> FixityAssoc -> ShowS
showsPrec :: Int -> FixityAssoc -> ShowS
$cshow :: FixityAssoc -> String
show :: FixityAssoc -> String
$cshowList :: [FixityAssoc] -> ShowS
showList :: [FixityAssoc] -> ShowS
Show, (forall x. FixityAssoc -> Rep FixityAssoc x)
-> (forall x. Rep FixityAssoc x -> FixityAssoc)
-> Generic FixityAssoc
forall x. Rep FixityAssoc x -> FixityAssoc
forall x. FixityAssoc -> Rep FixityAssoc x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. FixityAssoc -> Rep FixityAssoc x
from :: forall x. FixityAssoc -> Rep FixityAssoc x
$cto :: forall x. Rep FixityAssoc x -> FixityAssoc
to :: forall x. Rep FixityAssoc x -> FixityAssoc
Generic, FixityAssoc -> ()
(FixityAssoc -> ()) -> NFData FixityAssoc
forall a. (a -> ()) -> NFData a
$crnf :: FixityAssoc -> ()
rnf :: FixityAssoc -> ()
NFData)

data ForeignDecl = ForeignDecl
  { ForeignDecl -> SourceSpan
foreignDeclSpan :: SourceSpan,
    ForeignDecl -> ForeignDirection
foreignDirection :: ForeignDirection,
    ForeignDecl -> CallConv
foreignCallConv :: CallConv,
    ForeignDecl -> Maybe ForeignSafety
foreignSafety :: Maybe ForeignSafety,
    ForeignDecl -> ForeignEntitySpec
foreignEntity :: ForeignEntitySpec,
    ForeignDecl -> Text
foreignName :: Text,
    ForeignDecl -> Type
foreignType :: Type
  }
  deriving (Typeable ForeignDecl
Typeable ForeignDecl =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> ForeignDecl -> c ForeignDecl)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ForeignDecl)
-> (ForeignDecl -> Constr)
-> (ForeignDecl -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ForeignDecl))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c ForeignDecl))
-> ((forall b. Data b => b -> b) -> ForeignDecl -> ForeignDecl)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ForeignDecl -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ForeignDecl -> r)
-> (forall u. (forall d. Data d => d -> u) -> ForeignDecl -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> ForeignDecl -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ForeignDecl -> m ForeignDecl)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ForeignDecl -> m ForeignDecl)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ForeignDecl -> m ForeignDecl)
-> Data ForeignDecl
ForeignDecl -> Constr
ForeignDecl -> DataType
(forall b. Data b => b -> b) -> ForeignDecl -> ForeignDecl
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) -> ForeignDecl -> u
forall u. (forall d. Data d => d -> u) -> ForeignDecl -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ForeignDecl -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ForeignDecl -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ForeignDecl -> m ForeignDecl
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ForeignDecl -> m ForeignDecl
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ForeignDecl
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ForeignDecl -> c ForeignDecl
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ForeignDecl)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ForeignDecl)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ForeignDecl -> c ForeignDecl
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ForeignDecl -> c ForeignDecl
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ForeignDecl
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ForeignDecl
$ctoConstr :: ForeignDecl -> Constr
toConstr :: ForeignDecl -> Constr
$cdataTypeOf :: ForeignDecl -> DataType
dataTypeOf :: ForeignDecl -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ForeignDecl)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ForeignDecl)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ForeignDecl)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ForeignDecl)
$cgmapT :: (forall b. Data b => b -> b) -> ForeignDecl -> ForeignDecl
gmapT :: (forall b. Data b => b -> b) -> ForeignDecl -> ForeignDecl
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ForeignDecl -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ForeignDecl -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ForeignDecl -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ForeignDecl -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> ForeignDecl -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> ForeignDecl -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ForeignDecl -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ForeignDecl -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ForeignDecl -> m ForeignDecl
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ForeignDecl -> m ForeignDecl
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ForeignDecl -> m ForeignDecl
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ForeignDecl -> m ForeignDecl
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ForeignDecl -> m ForeignDecl
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ForeignDecl -> m ForeignDecl
Data, ForeignDecl -> ForeignDecl -> Bool
(ForeignDecl -> ForeignDecl -> Bool)
-> (ForeignDecl -> ForeignDecl -> Bool) -> Eq ForeignDecl
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ForeignDecl -> ForeignDecl -> Bool
== :: ForeignDecl -> ForeignDecl -> Bool
$c/= :: ForeignDecl -> ForeignDecl -> Bool
/= :: ForeignDecl -> ForeignDecl -> Bool
Eq, Int -> ForeignDecl -> ShowS
[ForeignDecl] -> ShowS
ForeignDecl -> String
(Int -> ForeignDecl -> ShowS)
-> (ForeignDecl -> String)
-> ([ForeignDecl] -> ShowS)
-> Show ForeignDecl
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ForeignDecl -> ShowS
showsPrec :: Int -> ForeignDecl -> ShowS
$cshow :: ForeignDecl -> String
show :: ForeignDecl -> String
$cshowList :: [ForeignDecl] -> ShowS
showList :: [ForeignDecl] -> ShowS
Show, (forall x. ForeignDecl -> Rep ForeignDecl x)
-> (forall x. Rep ForeignDecl x -> ForeignDecl)
-> Generic ForeignDecl
forall x. Rep ForeignDecl x -> ForeignDecl
forall x. ForeignDecl -> Rep ForeignDecl x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. ForeignDecl -> Rep ForeignDecl x
from :: forall x. ForeignDecl -> Rep ForeignDecl x
$cto :: forall x. Rep ForeignDecl x -> ForeignDecl
to :: forall x. Rep ForeignDecl x -> ForeignDecl
Generic, ForeignDecl -> ()
(ForeignDecl -> ()) -> NFData ForeignDecl
forall a. (a -> ()) -> NFData a
$crnf :: ForeignDecl -> ()
rnf :: ForeignDecl -> ()
NFData)

instance HasSourceSpan ForeignDecl where
  getSourceSpan :: ForeignDecl -> SourceSpan
getSourceSpan = ForeignDecl -> SourceSpan
foreignDeclSpan

data ForeignEntitySpec
  = ForeignEntityDynamic
  | ForeignEntityWrapper
  | ForeignEntityStatic (Maybe Text)
  | ForeignEntityAddress (Maybe Text)
  | ForeignEntityNamed Text
  | ForeignEntityOmitted
  deriving (Typeable ForeignEntitySpec
Typeable ForeignEntitySpec =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g)
 -> ForeignEntitySpec
 -> c ForeignEntitySpec)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ForeignEntitySpec)
-> (ForeignEntitySpec -> Constr)
-> (ForeignEntitySpec -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ForeignEntitySpec))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c ForeignEntitySpec))
-> ((forall b. Data b => b -> b)
    -> ForeignEntitySpec -> ForeignEntitySpec)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ForeignEntitySpec -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ForeignEntitySpec -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> ForeignEntitySpec -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> ForeignEntitySpec -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> ForeignEntitySpec -> m ForeignEntitySpec)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> ForeignEntitySpec -> m ForeignEntitySpec)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> ForeignEntitySpec -> m ForeignEntitySpec)
-> Data ForeignEntitySpec
ForeignEntitySpec -> Constr
ForeignEntitySpec -> DataType
(forall b. Data b => b -> b)
-> ForeignEntitySpec -> ForeignEntitySpec
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) -> ForeignEntitySpec -> u
forall u. (forall d. Data d => d -> u) -> ForeignEntitySpec -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ForeignEntitySpec -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ForeignEntitySpec -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> ForeignEntitySpec -> m ForeignEntitySpec
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ForeignEntitySpec -> m ForeignEntitySpec
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ForeignEntitySpec
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ForeignEntitySpec -> c ForeignEntitySpec
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ForeignEntitySpec)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ForeignEntitySpec)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ForeignEntitySpec -> c ForeignEntitySpec
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ForeignEntitySpec -> c ForeignEntitySpec
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ForeignEntitySpec
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ForeignEntitySpec
$ctoConstr :: ForeignEntitySpec -> Constr
toConstr :: ForeignEntitySpec -> Constr
$cdataTypeOf :: ForeignEntitySpec -> DataType
dataTypeOf :: ForeignEntitySpec -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ForeignEntitySpec)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ForeignEntitySpec)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ForeignEntitySpec)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ForeignEntitySpec)
$cgmapT :: (forall b. Data b => b -> b)
-> ForeignEntitySpec -> ForeignEntitySpec
gmapT :: (forall b. Data b => b -> b)
-> ForeignEntitySpec -> ForeignEntitySpec
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ForeignEntitySpec -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ForeignEntitySpec -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ForeignEntitySpec -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ForeignEntitySpec -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> ForeignEntitySpec -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> ForeignEntitySpec -> [u]
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> ForeignEntitySpec -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> ForeignEntitySpec -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> ForeignEntitySpec -> m ForeignEntitySpec
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> ForeignEntitySpec -> m ForeignEntitySpec
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ForeignEntitySpec -> m ForeignEntitySpec
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ForeignEntitySpec -> m ForeignEntitySpec
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ForeignEntitySpec -> m ForeignEntitySpec
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ForeignEntitySpec -> m ForeignEntitySpec
Data, ForeignEntitySpec -> ForeignEntitySpec -> Bool
(ForeignEntitySpec -> ForeignEntitySpec -> Bool)
-> (ForeignEntitySpec -> ForeignEntitySpec -> Bool)
-> Eq ForeignEntitySpec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ForeignEntitySpec -> ForeignEntitySpec -> Bool
== :: ForeignEntitySpec -> ForeignEntitySpec -> Bool
$c/= :: ForeignEntitySpec -> ForeignEntitySpec -> Bool
/= :: ForeignEntitySpec -> ForeignEntitySpec -> Bool
Eq, Int -> ForeignEntitySpec -> ShowS
[ForeignEntitySpec] -> ShowS
ForeignEntitySpec -> String
(Int -> ForeignEntitySpec -> ShowS)
-> (ForeignEntitySpec -> String)
-> ([ForeignEntitySpec] -> ShowS)
-> Show ForeignEntitySpec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ForeignEntitySpec -> ShowS
showsPrec :: Int -> ForeignEntitySpec -> ShowS
$cshow :: ForeignEntitySpec -> String
show :: ForeignEntitySpec -> String
$cshowList :: [ForeignEntitySpec] -> ShowS
showList :: [ForeignEntitySpec] -> ShowS
Show, (forall x. ForeignEntitySpec -> Rep ForeignEntitySpec x)
-> (forall x. Rep ForeignEntitySpec x -> ForeignEntitySpec)
-> Generic ForeignEntitySpec
forall x. Rep ForeignEntitySpec x -> ForeignEntitySpec
forall x. ForeignEntitySpec -> Rep ForeignEntitySpec x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. ForeignEntitySpec -> Rep ForeignEntitySpec x
from :: forall x. ForeignEntitySpec -> Rep ForeignEntitySpec x
$cto :: forall x. Rep ForeignEntitySpec x -> ForeignEntitySpec
to :: forall x. Rep ForeignEntitySpec x -> ForeignEntitySpec
Generic, ForeignEntitySpec -> ()
(ForeignEntitySpec -> ()) -> NFData ForeignEntitySpec
forall a. (a -> ()) -> NFData a
$crnf :: ForeignEntitySpec -> ()
rnf :: ForeignEntitySpec -> ()
NFData)

data ForeignDirection
  = ForeignImport
  | ForeignExport
  deriving (Typeable ForeignDirection
Typeable ForeignDirection =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> ForeignDirection -> c ForeignDirection)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ForeignDirection)
-> (ForeignDirection -> Constr)
-> (ForeignDirection -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ForeignDirection))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c ForeignDirection))
-> ((forall b. Data b => b -> b)
    -> ForeignDirection -> ForeignDirection)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ForeignDirection -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ForeignDirection -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> ForeignDirection -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> ForeignDirection -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> ForeignDirection -> m ForeignDirection)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> ForeignDirection -> m ForeignDirection)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> ForeignDirection -> m ForeignDirection)
-> Data ForeignDirection
ForeignDirection -> Constr
ForeignDirection -> DataType
(forall b. Data b => b -> b)
-> ForeignDirection -> ForeignDirection
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) -> ForeignDirection -> u
forall u. (forall d. Data d => d -> u) -> ForeignDirection -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ForeignDirection -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ForeignDirection -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> ForeignDirection -> m ForeignDirection
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ForeignDirection -> m ForeignDirection
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ForeignDirection
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ForeignDirection -> c ForeignDirection
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ForeignDirection)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ForeignDirection)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ForeignDirection -> c ForeignDirection
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ForeignDirection -> c ForeignDirection
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ForeignDirection
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ForeignDirection
$ctoConstr :: ForeignDirection -> Constr
toConstr :: ForeignDirection -> Constr
$cdataTypeOf :: ForeignDirection -> DataType
dataTypeOf :: ForeignDirection -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ForeignDirection)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ForeignDirection)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ForeignDirection)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ForeignDirection)
$cgmapT :: (forall b. Data b => b -> b)
-> ForeignDirection -> ForeignDirection
gmapT :: (forall b. Data b => b -> b)
-> ForeignDirection -> ForeignDirection
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ForeignDirection -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ForeignDirection -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ForeignDirection -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ForeignDirection -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> ForeignDirection -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> ForeignDirection -> [u]
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> ForeignDirection -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> ForeignDirection -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> ForeignDirection -> m ForeignDirection
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> ForeignDirection -> m ForeignDirection
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ForeignDirection -> m ForeignDirection
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ForeignDirection -> m ForeignDirection
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ForeignDirection -> m ForeignDirection
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ForeignDirection -> m ForeignDirection
Data, ForeignDirection -> ForeignDirection -> Bool
(ForeignDirection -> ForeignDirection -> Bool)
-> (ForeignDirection -> ForeignDirection -> Bool)
-> Eq ForeignDirection
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ForeignDirection -> ForeignDirection -> Bool
== :: ForeignDirection -> ForeignDirection -> Bool
$c/= :: ForeignDirection -> ForeignDirection -> Bool
/= :: ForeignDirection -> ForeignDirection -> Bool
Eq, Int -> ForeignDirection -> ShowS
[ForeignDirection] -> ShowS
ForeignDirection -> String
(Int -> ForeignDirection -> ShowS)
-> (ForeignDirection -> String)
-> ([ForeignDirection] -> ShowS)
-> Show ForeignDirection
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ForeignDirection -> ShowS
showsPrec :: Int -> ForeignDirection -> ShowS
$cshow :: ForeignDirection -> String
show :: ForeignDirection -> String
$cshowList :: [ForeignDirection] -> ShowS
showList :: [ForeignDirection] -> ShowS
Show, (forall x. ForeignDirection -> Rep ForeignDirection x)
-> (forall x. Rep ForeignDirection x -> ForeignDirection)
-> Generic ForeignDirection
forall x. Rep ForeignDirection x -> ForeignDirection
forall x. ForeignDirection -> Rep ForeignDirection x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. ForeignDirection -> Rep ForeignDirection x
from :: forall x. ForeignDirection -> Rep ForeignDirection x
$cto :: forall x. Rep ForeignDirection x -> ForeignDirection
to :: forall x. Rep ForeignDirection x -> ForeignDirection
Generic, ForeignDirection -> ()
(ForeignDirection -> ()) -> NFData ForeignDirection
forall a. (a -> ()) -> NFData a
$crnf :: ForeignDirection -> ()
rnf :: ForeignDirection -> ()
NFData)

data CallConv
  = CCall
  | StdCall
  deriving (Typeable CallConv
Typeable CallConv =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> CallConv -> c CallConv)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c CallConv)
-> (CallConv -> Constr)
-> (CallConv -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c CallConv))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CallConv))
-> ((forall b. Data b => b -> b) -> CallConv -> CallConv)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> CallConv -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> CallConv -> r)
-> (forall u. (forall d. Data d => d -> u) -> CallConv -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> CallConv -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> CallConv -> m CallConv)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> CallConv -> m CallConv)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> CallConv -> m CallConv)
-> Data CallConv
CallConv -> Constr
CallConv -> DataType
(forall b. Data b => b -> b) -> CallConv -> CallConv
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 -> u
forall u. (forall d. Data d => d -> u) -> CallConv -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CallConv -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CallConv -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CallConv -> m CallConv
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CallConv -> m CallConv
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CallConv
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CallConv -> c CallConv
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CallConv)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CallConv)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CallConv -> c CallConv
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CallConv -> c CallConv
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CallConv
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CallConv
$ctoConstr :: CallConv -> Constr
toConstr :: CallConv -> Constr
$cdataTypeOf :: CallConv -> DataType
dataTypeOf :: CallConv -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CallConv)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CallConv)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CallConv)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CallConv)
$cgmapT :: (forall b. Data b => b -> b) -> CallConv -> CallConv
gmapT :: (forall b. Data b => b -> b) -> CallConv -> CallConv
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CallConv -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CallConv -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CallConv -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CallConv -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> CallConv -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> CallConv -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> CallConv -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> CallConv -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CallConv -> m CallConv
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CallConv -> m CallConv
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CallConv -> m CallConv
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CallConv -> m CallConv
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CallConv -> m CallConv
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CallConv -> m CallConv
Data, CallConv -> CallConv -> Bool
(CallConv -> CallConv -> Bool)
-> (CallConv -> CallConv -> Bool) -> Eq CallConv
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: CallConv -> CallConv -> Bool
== :: CallConv -> CallConv -> Bool
$c/= :: CallConv -> CallConv -> Bool
/= :: CallConv -> CallConv -> Bool
Eq, Int -> CallConv -> ShowS
[CallConv] -> ShowS
CallConv -> String
(Int -> CallConv -> ShowS)
-> (CallConv -> String) -> ([CallConv] -> ShowS) -> Show CallConv
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> CallConv -> ShowS
showsPrec :: Int -> CallConv -> ShowS
$cshow :: CallConv -> String
show :: CallConv -> String
$cshowList :: [CallConv] -> ShowS
showList :: [CallConv] -> ShowS
Show, (forall x. CallConv -> Rep CallConv x)
-> (forall x. Rep CallConv x -> CallConv) -> Generic CallConv
forall x. Rep CallConv x -> CallConv
forall x. CallConv -> Rep CallConv x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. CallConv -> Rep CallConv x
from :: forall x. CallConv -> Rep CallConv x
$cto :: forall x. Rep CallConv x -> CallConv
to :: forall x. Rep CallConv x -> CallConv
Generic, CallConv -> ()
(CallConv -> ()) -> NFData CallConv
forall a. (a -> ()) -> NFData a
$crnf :: CallConv -> ()
rnf :: CallConv -> ()
NFData)

data ForeignSafety
  = Safe
  | Unsafe
  deriving (Typeable ForeignSafety
Typeable ForeignSafety =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> ForeignSafety -> c ForeignSafety)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ForeignSafety)
-> (ForeignSafety -> Constr)
-> (ForeignSafety -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ForeignSafety))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c ForeignSafety))
-> ((forall b. Data b => b -> b) -> ForeignSafety -> ForeignSafety)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ForeignSafety -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ForeignSafety -> r)
-> (forall u. (forall d. Data d => d -> u) -> ForeignSafety -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> ForeignSafety -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ForeignSafety -> m ForeignSafety)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ForeignSafety -> m ForeignSafety)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ForeignSafety -> m ForeignSafety)
-> Data ForeignSafety
ForeignSafety -> Constr
ForeignSafety -> DataType
(forall b. Data b => b -> b) -> ForeignSafety -> ForeignSafety
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) -> ForeignSafety -> u
forall u. (forall d. Data d => d -> u) -> ForeignSafety -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ForeignSafety -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ForeignSafety -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ForeignSafety -> m ForeignSafety
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ForeignSafety -> m ForeignSafety
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ForeignSafety
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ForeignSafety -> c ForeignSafety
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ForeignSafety)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ForeignSafety)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ForeignSafety -> c ForeignSafety
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ForeignSafety -> c ForeignSafety
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ForeignSafety
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ForeignSafety
$ctoConstr :: ForeignSafety -> Constr
toConstr :: ForeignSafety -> Constr
$cdataTypeOf :: ForeignSafety -> DataType
dataTypeOf :: ForeignSafety -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ForeignSafety)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ForeignSafety)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ForeignSafety)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ForeignSafety)
$cgmapT :: (forall b. Data b => b -> b) -> ForeignSafety -> ForeignSafety
gmapT :: (forall b. Data b => b -> b) -> ForeignSafety -> ForeignSafety
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ForeignSafety -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ForeignSafety -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ForeignSafety -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ForeignSafety -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> ForeignSafety -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> ForeignSafety -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ForeignSafety -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ForeignSafety -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ForeignSafety -> m ForeignSafety
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ForeignSafety -> m ForeignSafety
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ForeignSafety -> m ForeignSafety
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ForeignSafety -> m ForeignSafety
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ForeignSafety -> m ForeignSafety
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ForeignSafety -> m ForeignSafety
Data, ForeignSafety -> ForeignSafety -> Bool
(ForeignSafety -> ForeignSafety -> Bool)
-> (ForeignSafety -> ForeignSafety -> Bool) -> Eq ForeignSafety
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ForeignSafety -> ForeignSafety -> Bool
== :: ForeignSafety -> ForeignSafety -> Bool
$c/= :: ForeignSafety -> ForeignSafety -> Bool
/= :: ForeignSafety -> ForeignSafety -> Bool
Eq, Int -> ForeignSafety -> ShowS
[ForeignSafety] -> ShowS
ForeignSafety -> String
(Int -> ForeignSafety -> ShowS)
-> (ForeignSafety -> String)
-> ([ForeignSafety] -> ShowS)
-> Show ForeignSafety
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ForeignSafety -> ShowS
showsPrec :: Int -> ForeignSafety -> ShowS
$cshow :: ForeignSafety -> String
show :: ForeignSafety -> String
$cshowList :: [ForeignSafety] -> ShowS
showList :: [ForeignSafety] -> ShowS
Show, (forall x. ForeignSafety -> Rep ForeignSafety x)
-> (forall x. Rep ForeignSafety x -> ForeignSafety)
-> Generic ForeignSafety
forall x. Rep ForeignSafety x -> ForeignSafety
forall x. ForeignSafety -> Rep ForeignSafety x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. ForeignSafety -> Rep ForeignSafety x
from :: forall x. ForeignSafety -> Rep ForeignSafety x
$cto :: forall x. Rep ForeignSafety x -> ForeignSafety
to :: forall x. Rep ForeignSafety x -> ForeignSafety
Generic, ForeignSafety -> ()
(ForeignSafety -> ()) -> NFData ForeignSafety
forall a. (a -> ()) -> NFData a
$crnf :: ForeignSafety -> ()
rnf :: ForeignSafety -> ()
NFData)

data Expr
  = EVar SourceSpan Text
  | EInt SourceSpan Integer Text
  | EIntBase SourceSpan Integer Text
  | EFloat SourceSpan Double Text
  | EChar SourceSpan Char Text
  | EString SourceSpan Text Text
  | EQuasiQuote SourceSpan Text Text
  | EIf SourceSpan Expr Expr Expr
  | ELambdaPats SourceSpan [Pattern] Expr
  | ELambdaCase SourceSpan [CaseAlt]
  | EInfix SourceSpan Expr Text Expr
  | ENegate SourceSpan Expr
  | ESectionL SourceSpan Expr Text
  | ESectionR SourceSpan Text Expr
  | ELetDecls SourceSpan [Decl] Expr
  | ECase SourceSpan Expr [CaseAlt]
  | EDo SourceSpan [DoStmt]
  | EListComp SourceSpan Expr [CompStmt]
  | EListCompParallel SourceSpan Expr [[CompStmt]]
  | EArithSeq SourceSpan ArithSeq
  | ERecordCon SourceSpan Text [(Text, Expr)]
  | ERecordUpd SourceSpan Expr [(Text, Expr)]
  | ETypeSig SourceSpan Expr Type
  | EParen SourceSpan Expr
  | EWhereDecls SourceSpan Expr [Decl]
  | EList SourceSpan [Expr]
  | ETuple SourceSpan [Expr]
  | ETupleSection SourceSpan [Maybe Expr]
  | ETupleCon SourceSpan Int
  | ETypeApp SourceSpan Expr Type
  | EApp SourceSpan Expr Expr
  deriving (Typeable Expr
Typeable Expr =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Expr -> c Expr)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Expr)
-> (Expr -> Constr)
-> (Expr -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Expr))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Expr))
-> ((forall b. Data b => b -> b) -> Expr -> Expr)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Expr -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Expr -> r)
-> (forall u. (forall d. Data d => d -> u) -> Expr -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Expr -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Expr -> m Expr)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Expr -> m Expr)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Expr -> m Expr)
-> Data Expr
Expr -> Constr
Expr -> DataType
(forall b. Data b => b -> b) -> Expr -> Expr
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) -> Expr -> u
forall u. (forall d. Data d => d -> u) -> Expr -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Expr -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Expr -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Expr -> m Expr
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Expr -> m Expr
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Expr
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Expr -> c Expr
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Expr)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Expr)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Expr -> c Expr
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Expr -> c Expr
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Expr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Expr
$ctoConstr :: Expr -> Constr
toConstr :: Expr -> Constr
$cdataTypeOf :: Expr -> DataType
dataTypeOf :: Expr -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Expr)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Expr)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Expr)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Expr)
$cgmapT :: (forall b. Data b => b -> b) -> Expr -> Expr
gmapT :: (forall b. Data b => b -> b) -> Expr -> Expr
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Expr -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Expr -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Expr -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Expr -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Expr -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Expr -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Expr -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Expr -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Expr -> m Expr
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Expr -> m Expr
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Expr -> m Expr
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Expr -> m Expr
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Expr -> m Expr
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Expr -> m Expr
Data, Expr -> Expr -> Bool
(Expr -> Expr -> Bool) -> (Expr -> Expr -> Bool) -> Eq Expr
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Expr -> Expr -> Bool
== :: Expr -> Expr -> Bool
$c/= :: Expr -> Expr -> Bool
/= :: Expr -> Expr -> Bool
Eq, Int -> Expr -> ShowS
[Expr] -> ShowS
Expr -> String
(Int -> Expr -> ShowS)
-> (Expr -> String) -> ([Expr] -> ShowS) -> Show Expr
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Expr -> ShowS
showsPrec :: Int -> Expr -> ShowS
$cshow :: Expr -> String
show :: Expr -> String
$cshowList :: [Expr] -> ShowS
showList :: [Expr] -> ShowS
Show, (forall x. Expr -> Rep Expr x)
-> (forall x. Rep Expr x -> Expr) -> Generic Expr
forall x. Rep Expr x -> Expr
forall x. Expr -> Rep Expr x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Expr -> Rep Expr x
from :: forall x. Expr -> Rep Expr x
$cto :: forall x. Rep Expr x -> Expr
to :: forall x. Rep Expr x -> Expr
Generic, Expr -> ()
(Expr -> ()) -> NFData Expr
forall a. (a -> ()) -> NFData a
$crnf :: Expr -> ()
rnf :: Expr -> ()
NFData)

instance HasSourceSpan Expr where
  getSourceSpan :: Expr -> SourceSpan
getSourceSpan Expr
expr =
    case Expr
expr of
      EVar SourceSpan
span' Text
_ -> SourceSpan
span'
      EInt SourceSpan
span' Integer
_ Text
_ -> SourceSpan
span'
      EIntBase SourceSpan
span' Integer
_ Text
_ -> SourceSpan
span'
      EFloat SourceSpan
span' Double
_ Text
_ -> SourceSpan
span'
      EChar SourceSpan
span' Char
_ Text
_ -> SourceSpan
span'
      EString SourceSpan
span' Text
_ Text
_ -> SourceSpan
span'
      EQuasiQuote SourceSpan
span' Text
_ Text
_ -> SourceSpan
span'
      EIf SourceSpan
span' Expr
_ Expr
_ Expr
_ -> SourceSpan
span'
      ELambdaPats SourceSpan
span' [Pattern]
_ Expr
_ -> SourceSpan
span'
      ELambdaCase SourceSpan
span' [CaseAlt]
_ -> SourceSpan
span'
      EInfix SourceSpan
span' Expr
_ Text
_ Expr
_ -> SourceSpan
span'
      ENegate SourceSpan
span' Expr
_ -> SourceSpan
span'
      ESectionL SourceSpan
span' Expr
_ Text
_ -> SourceSpan
span'
      ESectionR SourceSpan
span' Text
_ Expr
_ -> SourceSpan
span'
      ELetDecls SourceSpan
span' [Decl]
_ Expr
_ -> SourceSpan
span'
      ECase SourceSpan
span' Expr
_ [CaseAlt]
_ -> SourceSpan
span'
      EDo SourceSpan
span' [DoStmt]
_ -> SourceSpan
span'
      EListComp SourceSpan
span' Expr
_ [CompStmt]
_ -> SourceSpan
span'
      EListCompParallel SourceSpan
span' Expr
_ [[CompStmt]]
_ -> SourceSpan
span'
      EArithSeq SourceSpan
span' ArithSeq
_ -> SourceSpan
span'
      ERecordCon SourceSpan
span' Text
_ [(Text, Expr)]
_ -> SourceSpan
span'
      ERecordUpd SourceSpan
span' Expr
_ [(Text, Expr)]
_ -> SourceSpan
span'
      ETypeSig SourceSpan
span' Expr
_ Type
_ -> SourceSpan
span'
      EParen SourceSpan
span' Expr
_ -> SourceSpan
span'
      EWhereDecls SourceSpan
span' Expr
_ [Decl]
_ -> SourceSpan
span'
      EList SourceSpan
span' [Expr]
_ -> SourceSpan
span'
      ETuple SourceSpan
span' [Expr]
_ -> SourceSpan
span'
      ETupleSection SourceSpan
span' [Maybe Expr]
_ -> SourceSpan
span'
      ETupleCon SourceSpan
span' Int
_ -> SourceSpan
span'
      ETypeApp SourceSpan
span' Expr
_ Type
_ -> SourceSpan
span'
      EApp SourceSpan
span' Expr
_ Expr
_ -> SourceSpan
span'

data CaseAlt = CaseAlt
  { CaseAlt -> SourceSpan
caseAltSpan :: SourceSpan,
    CaseAlt -> Pattern
caseAltPattern :: Pattern,
    CaseAlt -> Rhs
caseAltRhs :: Rhs
  }
  deriving (Typeable CaseAlt
Typeable CaseAlt =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> CaseAlt -> c CaseAlt)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c CaseAlt)
-> (CaseAlt -> Constr)
-> (CaseAlt -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c CaseAlt))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CaseAlt))
-> ((forall b. Data b => b -> b) -> CaseAlt -> CaseAlt)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> CaseAlt -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> CaseAlt -> r)
-> (forall u. (forall d. Data d => d -> u) -> CaseAlt -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> CaseAlt -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> CaseAlt -> m CaseAlt)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> CaseAlt -> m CaseAlt)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> CaseAlt -> m CaseAlt)
-> Data CaseAlt
CaseAlt -> Constr
CaseAlt -> DataType
(forall b. Data b => b -> b) -> CaseAlt -> CaseAlt
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) -> CaseAlt -> u
forall u. (forall d. Data d => d -> u) -> CaseAlt -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CaseAlt -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CaseAlt -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CaseAlt -> m CaseAlt
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CaseAlt -> m CaseAlt
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CaseAlt
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CaseAlt -> c CaseAlt
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CaseAlt)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CaseAlt)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CaseAlt -> c CaseAlt
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CaseAlt -> c CaseAlt
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CaseAlt
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CaseAlt
$ctoConstr :: CaseAlt -> Constr
toConstr :: CaseAlt -> Constr
$cdataTypeOf :: CaseAlt -> DataType
dataTypeOf :: CaseAlt -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CaseAlt)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CaseAlt)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CaseAlt)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CaseAlt)
$cgmapT :: (forall b. Data b => b -> b) -> CaseAlt -> CaseAlt
gmapT :: (forall b. Data b => b -> b) -> CaseAlt -> CaseAlt
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CaseAlt -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CaseAlt -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CaseAlt -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CaseAlt -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> CaseAlt -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> CaseAlt -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> CaseAlt -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> CaseAlt -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CaseAlt -> m CaseAlt
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CaseAlt -> m CaseAlt
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CaseAlt -> m CaseAlt
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CaseAlt -> m CaseAlt
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CaseAlt -> m CaseAlt
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CaseAlt -> m CaseAlt
Data, CaseAlt -> CaseAlt -> Bool
(CaseAlt -> CaseAlt -> Bool)
-> (CaseAlt -> CaseAlt -> Bool) -> Eq CaseAlt
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: CaseAlt -> CaseAlt -> Bool
== :: CaseAlt -> CaseAlt -> Bool
$c/= :: CaseAlt -> CaseAlt -> Bool
/= :: CaseAlt -> CaseAlt -> Bool
Eq, Int -> CaseAlt -> ShowS
[CaseAlt] -> ShowS
CaseAlt -> String
(Int -> CaseAlt -> ShowS)
-> (CaseAlt -> String) -> ([CaseAlt] -> ShowS) -> Show CaseAlt
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> CaseAlt -> ShowS
showsPrec :: Int -> CaseAlt -> ShowS
$cshow :: CaseAlt -> String
show :: CaseAlt -> String
$cshowList :: [CaseAlt] -> ShowS
showList :: [CaseAlt] -> ShowS
Show, (forall x. CaseAlt -> Rep CaseAlt x)
-> (forall x. Rep CaseAlt x -> CaseAlt) -> Generic CaseAlt
forall x. Rep CaseAlt x -> CaseAlt
forall x. CaseAlt -> Rep CaseAlt x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. CaseAlt -> Rep CaseAlt x
from :: forall x. CaseAlt -> Rep CaseAlt x
$cto :: forall x. Rep CaseAlt x -> CaseAlt
to :: forall x. Rep CaseAlt x -> CaseAlt
Generic, CaseAlt -> ()
(CaseAlt -> ()) -> NFData CaseAlt
forall a. (a -> ()) -> NFData a
$crnf :: CaseAlt -> ()
rnf :: CaseAlt -> ()
NFData)

instance HasSourceSpan CaseAlt where
  getSourceSpan :: CaseAlt -> SourceSpan
getSourceSpan = CaseAlt -> SourceSpan
caseAltSpan

data DoStmt
  = DoBind SourceSpan Pattern Expr
  | DoLet SourceSpan [(Text, Expr)]
  | DoLetDecls SourceSpan [Decl]
  | DoExpr SourceSpan Expr
  deriving (Typeable DoStmt
Typeable DoStmt =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> DoStmt -> c DoStmt)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DoStmt)
-> (DoStmt -> Constr)
-> (DoStmt -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DoStmt))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DoStmt))
-> ((forall b. Data b => b -> b) -> DoStmt -> DoStmt)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DoStmt -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DoStmt -> r)
-> (forall u. (forall d. Data d => d -> u) -> DoStmt -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> DoStmt -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DoStmt -> m DoStmt)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DoStmt -> m DoStmt)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DoStmt -> m DoStmt)
-> Data DoStmt
DoStmt -> Constr
DoStmt -> DataType
(forall b. Data b => b -> b) -> DoStmt -> DoStmt
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) -> DoStmt -> u
forall u. (forall d. Data d => d -> u) -> DoStmt -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DoStmt -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DoStmt -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DoStmt -> m DoStmt
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DoStmt -> m DoStmt
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DoStmt
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DoStmt -> c DoStmt
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DoStmt)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DoStmt)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DoStmt -> c DoStmt
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DoStmt -> c DoStmt
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DoStmt
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DoStmt
$ctoConstr :: DoStmt -> Constr
toConstr :: DoStmt -> Constr
$cdataTypeOf :: DoStmt -> DataType
dataTypeOf :: DoStmt -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DoStmt)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DoStmt)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DoStmt)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DoStmt)
$cgmapT :: (forall b. Data b => b -> b) -> DoStmt -> DoStmt
gmapT :: (forall b. Data b => b -> b) -> DoStmt -> DoStmt
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DoStmt -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DoStmt -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DoStmt -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DoStmt -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DoStmt -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> DoStmt -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DoStmt -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DoStmt -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DoStmt -> m DoStmt
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DoStmt -> m DoStmt
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DoStmt -> m DoStmt
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DoStmt -> m DoStmt
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DoStmt -> m DoStmt
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DoStmt -> m DoStmt
Data, DoStmt -> DoStmt -> Bool
(DoStmt -> DoStmt -> Bool)
-> (DoStmt -> DoStmt -> Bool) -> Eq DoStmt
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DoStmt -> DoStmt -> Bool
== :: DoStmt -> DoStmt -> Bool
$c/= :: DoStmt -> DoStmt -> Bool
/= :: DoStmt -> DoStmt -> Bool
Eq, Int -> DoStmt -> ShowS
[DoStmt] -> ShowS
DoStmt -> String
(Int -> DoStmt -> ShowS)
-> (DoStmt -> String) -> ([DoStmt] -> ShowS) -> Show DoStmt
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DoStmt -> ShowS
showsPrec :: Int -> DoStmt -> ShowS
$cshow :: DoStmt -> String
show :: DoStmt -> String
$cshowList :: [DoStmt] -> ShowS
showList :: [DoStmt] -> ShowS
Show, (forall x. DoStmt -> Rep DoStmt x)
-> (forall x. Rep DoStmt x -> DoStmt) -> Generic DoStmt
forall x. Rep DoStmt x -> DoStmt
forall x. DoStmt -> Rep DoStmt x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. DoStmt -> Rep DoStmt x
from :: forall x. DoStmt -> Rep DoStmt x
$cto :: forall x. Rep DoStmt x -> DoStmt
to :: forall x. Rep DoStmt x -> DoStmt
Generic, DoStmt -> ()
(DoStmt -> ()) -> NFData DoStmt
forall a. (a -> ()) -> NFData a
$crnf :: DoStmt -> ()
rnf :: DoStmt -> ()
NFData)

instance HasSourceSpan DoStmt where
  getSourceSpan :: DoStmt -> SourceSpan
getSourceSpan DoStmt
doStmt =
    case DoStmt
doStmt of
      DoBind SourceSpan
span' Pattern
_ Expr
_ -> SourceSpan
span'
      DoLet SourceSpan
span' [(Text, Expr)]
_ -> SourceSpan
span'
      DoLetDecls SourceSpan
span' [Decl]
_ -> SourceSpan
span'
      DoExpr SourceSpan
span' Expr
_ -> SourceSpan
span'

data CompStmt
  = CompGen SourceSpan Pattern Expr
  | CompGuard SourceSpan Expr
  | CompLet SourceSpan [(Text, Expr)]
  | CompLetDecls SourceSpan [Decl]
  deriving (Typeable CompStmt
Typeable CompStmt =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> CompStmt -> c CompStmt)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c CompStmt)
-> (CompStmt -> Constr)
-> (CompStmt -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c CompStmt))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CompStmt))
-> ((forall b. Data b => b -> b) -> CompStmt -> CompStmt)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> CompStmt -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> CompStmt -> r)
-> (forall u. (forall d. Data d => d -> u) -> CompStmt -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> CompStmt -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> CompStmt -> m CompStmt)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> CompStmt -> m CompStmt)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> CompStmt -> m CompStmt)
-> Data CompStmt
CompStmt -> Constr
CompStmt -> DataType
(forall b. Data b => b -> b) -> CompStmt -> CompStmt
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) -> CompStmt -> u
forall u. (forall d. Data d => d -> u) -> CompStmt -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CompStmt -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CompStmt -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CompStmt -> m CompStmt
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CompStmt -> m CompStmt
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CompStmt
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CompStmt -> c CompStmt
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CompStmt)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CompStmt)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CompStmt -> c CompStmt
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CompStmt -> c CompStmt
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CompStmt
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CompStmt
$ctoConstr :: CompStmt -> Constr
toConstr :: CompStmt -> Constr
$cdataTypeOf :: CompStmt -> DataType
dataTypeOf :: CompStmt -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CompStmt)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CompStmt)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CompStmt)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CompStmt)
$cgmapT :: (forall b. Data b => b -> b) -> CompStmt -> CompStmt
gmapT :: (forall b. Data b => b -> b) -> CompStmt -> CompStmt
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CompStmt -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CompStmt -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CompStmt -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CompStmt -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> CompStmt -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> CompStmt -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> CompStmt -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> CompStmt -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CompStmt -> m CompStmt
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CompStmt -> m CompStmt
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CompStmt -> m CompStmt
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CompStmt -> m CompStmt
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CompStmt -> m CompStmt
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CompStmt -> m CompStmt
Data, CompStmt -> CompStmt -> Bool
(CompStmt -> CompStmt -> Bool)
-> (CompStmt -> CompStmt -> Bool) -> Eq CompStmt
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: CompStmt -> CompStmt -> Bool
== :: CompStmt -> CompStmt -> Bool
$c/= :: CompStmt -> CompStmt -> Bool
/= :: CompStmt -> CompStmt -> Bool
Eq, Int -> CompStmt -> ShowS
[CompStmt] -> ShowS
CompStmt -> String
(Int -> CompStmt -> ShowS)
-> (CompStmt -> String) -> ([CompStmt] -> ShowS) -> Show CompStmt
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> CompStmt -> ShowS
showsPrec :: Int -> CompStmt -> ShowS
$cshow :: CompStmt -> String
show :: CompStmt -> String
$cshowList :: [CompStmt] -> ShowS
showList :: [CompStmt] -> ShowS
Show, (forall x. CompStmt -> Rep CompStmt x)
-> (forall x. Rep CompStmt x -> CompStmt) -> Generic CompStmt
forall x. Rep CompStmt x -> CompStmt
forall x. CompStmt -> Rep CompStmt x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. CompStmt -> Rep CompStmt x
from :: forall x. CompStmt -> Rep CompStmt x
$cto :: forall x. Rep CompStmt x -> CompStmt
to :: forall x. Rep CompStmt x -> CompStmt
Generic, CompStmt -> ()
(CompStmt -> ()) -> NFData CompStmt
forall a. (a -> ()) -> NFData a
$crnf :: CompStmt -> ()
rnf :: CompStmt -> ()
NFData)

instance HasSourceSpan CompStmt where
  getSourceSpan :: CompStmt -> SourceSpan
getSourceSpan CompStmt
compStmt =
    case CompStmt
compStmt of
      CompGen SourceSpan
span' Pattern
_ Expr
_ -> SourceSpan
span'
      CompGuard SourceSpan
span' Expr
_ -> SourceSpan
span'
      CompLet SourceSpan
span' [(Text, Expr)]
_ -> SourceSpan
span'
      CompLetDecls SourceSpan
span' [Decl]
_ -> SourceSpan
span'

data ArithSeq
  = ArithSeqFrom SourceSpan Expr
  | ArithSeqFromThen SourceSpan Expr Expr
  | ArithSeqFromTo SourceSpan Expr Expr
  | ArithSeqFromThenTo SourceSpan Expr Expr Expr
  deriving (Typeable ArithSeq
Typeable ArithSeq =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> ArithSeq -> c ArithSeq)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ArithSeq)
-> (ArithSeq -> Constr)
-> (ArithSeq -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ArithSeq))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ArithSeq))
-> ((forall b. Data b => b -> b) -> ArithSeq -> ArithSeq)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ArithSeq -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ArithSeq -> r)
-> (forall u. (forall d. Data d => d -> u) -> ArithSeq -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> ArithSeq -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ArithSeq -> m ArithSeq)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ArithSeq -> m ArithSeq)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ArithSeq -> m ArithSeq)
-> Data ArithSeq
ArithSeq -> Constr
ArithSeq -> DataType
(forall b. Data b => b -> b) -> ArithSeq -> ArithSeq
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) -> ArithSeq -> u
forall u. (forall d. Data d => d -> u) -> ArithSeq -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ArithSeq -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ArithSeq -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ArithSeq -> m ArithSeq
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ArithSeq -> m ArithSeq
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ArithSeq
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ArithSeq -> c ArithSeq
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ArithSeq)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ArithSeq)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ArithSeq -> c ArithSeq
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ArithSeq -> c ArithSeq
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ArithSeq
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ArithSeq
$ctoConstr :: ArithSeq -> Constr
toConstr :: ArithSeq -> Constr
$cdataTypeOf :: ArithSeq -> DataType
dataTypeOf :: ArithSeq -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ArithSeq)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ArithSeq)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ArithSeq)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ArithSeq)
$cgmapT :: (forall b. Data b => b -> b) -> ArithSeq -> ArithSeq
gmapT :: (forall b. Data b => b -> b) -> ArithSeq -> ArithSeq
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ArithSeq -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ArithSeq -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ArithSeq -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ArithSeq -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> ArithSeq -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> ArithSeq -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ArithSeq -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ArithSeq -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ArithSeq -> m ArithSeq
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ArithSeq -> m ArithSeq
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ArithSeq -> m ArithSeq
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ArithSeq -> m ArithSeq
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ArithSeq -> m ArithSeq
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ArithSeq -> m ArithSeq
Data, ArithSeq -> ArithSeq -> Bool
(ArithSeq -> ArithSeq -> Bool)
-> (ArithSeq -> ArithSeq -> Bool) -> Eq ArithSeq
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ArithSeq -> ArithSeq -> Bool
== :: ArithSeq -> ArithSeq -> Bool
$c/= :: ArithSeq -> ArithSeq -> Bool
/= :: ArithSeq -> ArithSeq -> Bool
Eq, Int -> ArithSeq -> ShowS
[ArithSeq] -> ShowS
ArithSeq -> String
(Int -> ArithSeq -> ShowS)
-> (ArithSeq -> String) -> ([ArithSeq] -> ShowS) -> Show ArithSeq
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ArithSeq -> ShowS
showsPrec :: Int -> ArithSeq -> ShowS
$cshow :: ArithSeq -> String
show :: ArithSeq -> String
$cshowList :: [ArithSeq] -> ShowS
showList :: [ArithSeq] -> ShowS
Show, (forall x. ArithSeq -> Rep ArithSeq x)
-> (forall x. Rep ArithSeq x -> ArithSeq) -> Generic ArithSeq
forall x. Rep ArithSeq x -> ArithSeq
forall x. ArithSeq -> Rep ArithSeq x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. ArithSeq -> Rep ArithSeq x
from :: forall x. ArithSeq -> Rep ArithSeq x
$cto :: forall x. Rep ArithSeq x -> ArithSeq
to :: forall x. Rep ArithSeq x -> ArithSeq
Generic, ArithSeq -> ()
(ArithSeq -> ()) -> NFData ArithSeq
forall a. (a -> ()) -> NFData a
$crnf :: ArithSeq -> ()
rnf :: ArithSeq -> ()
NFData)

instance HasSourceSpan ArithSeq where
  getSourceSpan :: ArithSeq -> SourceSpan
getSourceSpan ArithSeq
arithSeq =
    case ArithSeq
arithSeq of
      ArithSeqFrom SourceSpan
span' Expr
_ -> SourceSpan
span'
      ArithSeqFromThen SourceSpan
span' Expr
_ Expr
_ -> SourceSpan
span'
      ArithSeqFromTo SourceSpan
span' Expr
_ Expr
_ -> SourceSpan
span'
      ArithSeqFromThenTo SourceSpan
span' Expr
_ Expr
_ Expr
_ -> SourceSpan
span'

valueDeclBinderName :: ValueDecl -> Maybe Text
valueDeclBinderName :: ValueDecl -> Maybe Text
valueDeclBinderName ValueDecl
vdecl =
  case ValueDecl
vdecl of
    FunctionBind SourceSpan
_ Text
name [Match]
_ -> Text -> Maybe Text
forall a. a -> Maybe a
Just Text
name
    PatternBind SourceSpan
_ Pattern
pat Rhs
_ ->
      case Pattern
pat of
        PVar SourceSpan
_ Text
name -> Text -> Maybe Text
forall a. a -> Maybe a
Just Text
name
        Pattern
_ -> Maybe Text
forall a. Maybe a
Nothing

declValueBinderNames :: Decl -> [Text]
declValueBinderNames :: Decl -> [Text]
declValueBinderNames Decl
decl =
  case Decl
decl of
    DeclValue SourceSpan
_ ValueDecl
vdecl ->
      case ValueDecl -> Maybe Text
valueDeclBinderName ValueDecl
vdecl of
        Just Text
name -> [Text
name]
        Maybe Text
Nothing -> []
    Decl
_ -> []