{-# LANGUAGE DefaultSignatures #-}

-- |
--
-- This module holds the data types used to represent Fortran code of various
-- versions.
--
-- fortran-src supports Fortran 66 through to Fortran 2003, and uses the same
-- types to represent them. The Fortran standard was largely refined as it grew,
-- often assimilating popular compiler extensions for the previous standard. We
-- try to be as permissible as reasonable when parsing; similarly, this AST
-- keeps close to the syntax, and includes statements, expressions, types etc.
-- only applicable to certain (newer) versions of Fortran.
--
-- Useful Fortran standard references:
--
--   * Fortran 77 ANSI standard: ANSI X3.9-1978
--   * Fortran 90 ANSI standard: ANSI X3.198-1992 (also ISO/IEC 1539:1991)
--   * Fortran 90 Handbook (J. Adams)
--
-- (The Fortran 66 ANSI standard lacks detail, and isn't as useful as the later
-- standards for implementing the language.)
--
-- /Note:/ some comments aren't reflected in the Haddock documentation, so you
-- may also wish to view this file's source.

module Language.Fortran.AST
  (
  -- * AST nodes and types
  -- ** Statements and expressions
    ProgramFile(..)
  , ProgramUnit(..)
  , Block(..)
  , Statement(..)
  , Expression(..)
  , Index(..)
  , Value(..)
  , UnaryOp(..)
  , BinaryOp(..)

  -- ** Types and declarations
  , Name
  , BaseType(..)
  , TypeSpec(..)
  , Selector(..)
  , Declarator(..)
  , DeclaratorType(..)
  , declaratorType
  , DimensionDeclarator(..)

  -- ** Annotated node list (re-export)
  , module Language.Fortran.AST.AList

  -- ** Other
  , Attribute(..)
  , Prefix(..)
  , Suffix(..)
  , ProcDecl(..)
  , ProcInterface(..)
  , Comment(..)
  , ForallHeader(..)
  , Only(..)
  , MetaInfo(..)
  , Prefixes
  , Suffixes
  , PrefixSuffix
  , ModuleNature(..)
  , Use(..)
  , Argument(..)
  , ArgumentExpression(..)
  , argExprNormalize
  , argExtractExpr
  , Intent(..)
  , ControlPair(..)
  , AllocOpt(..)
  , ImpList(..)
  , ImpElement(..)
  , CommonGroup(..)
  , Namelist(..)
  , DataGroup(..)
  , StructureItem(..)
  , UnionMap(..)
  , FormatItem(..)
  , FlushSpec(..)
  , DoSpecification(..)
  , ProgramUnitName(..)
  , Kind

  -- * Node annotations & related typeclasses
  , A0
  , Annotated(..)
  , Labeled(..)
  , Named(..)

  -- * Helpers
  , validPrefixSuffix
  , emptyPrefixes
  , emptySuffixes
  , emptyPrefixSuffix
  , nonExecutableStatement
  , nonExecutableStatementBlock
  , executableStatement
  , executableStatementBlock
  , setInitialisation

  -- ** Assorted getters & setters
  , pfSetFilename
  , pfGetFilename
  , programUnitBody
  , updateProgramUnitBody
  , programUnitSubprograms

  ) where

import Prelude hiding ( init )

import Language.Fortran.AST.AList
import Language.Fortran.AST.RealLit
import Language.Fortran.AST.Boz ( Boz )
import Language.Fortran.Util.Position
import Language.Fortran.Util.FirstParameter
import Language.Fortran.Util.SecondParameter
import Language.Fortran.Version

import Data.Data
import Data.Binary
import Control.DeepSeq
import Text.PrettyPrint.GenericPretty

-- | The empty annotation.
type A0 = ()

type Name = String

--------------------------------------------------------------------------------
-- Basic AST nodes
--------------------------------------------------------------------------------

-- | Type name referenced in syntax.
--
-- In many Fortran specs and compilers, certain types are actually "synonyms"
-- for other types with specified kinds. The primary example is DOUBLE PRECISION
-- being equivalent to REAL(8). Type kinds were introduced in Fortran 90, and it
-- should be safe to replace all instances of DOUBLE PRECISION with REAL(8) in
-- Fortran 90 code. However, type kinds weren't present in (standard) Fortran
-- 77, so this equivalence was detached from the user.
--
-- In any case, it's unclear how strong the equivalence is and whether it can
-- be retroactively applied to previous standards. We choose to parse types
-- directly, and handle those transformations during type analysis, where we
-- assign most scalars a kind (see 'Analysis.SemType').
data BaseType =
    TypeInteger
  | TypeReal
  | TypeDoublePrecision
  | TypeComplex
  | TypeDoubleComplex
  | TypeLogical
  | TypeCharacter
  | TypeCustom String
  | ClassStar
  | ClassCustom String
  | TypeByte
  deriving (Eq BaseType
Eq BaseType
-> (BaseType -> BaseType -> Ordering)
-> (BaseType -> BaseType -> Bool)
-> (BaseType -> BaseType -> Bool)
-> (BaseType -> BaseType -> Bool)
-> (BaseType -> BaseType -> Bool)
-> (BaseType -> BaseType -> BaseType)
-> (BaseType -> BaseType -> BaseType)
-> Ord BaseType
BaseType -> BaseType -> Bool
BaseType -> BaseType -> Ordering
BaseType -> BaseType -> BaseType
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
min :: BaseType -> BaseType -> BaseType
$cmin :: BaseType -> BaseType -> BaseType
max :: BaseType -> BaseType -> BaseType
$cmax :: BaseType -> BaseType -> BaseType
>= :: BaseType -> BaseType -> Bool
$c>= :: BaseType -> BaseType -> Bool
> :: BaseType -> BaseType -> Bool
$c> :: BaseType -> BaseType -> Bool
<= :: BaseType -> BaseType -> Bool
$c<= :: BaseType -> BaseType -> Bool
< :: BaseType -> BaseType -> Bool
$c< :: BaseType -> BaseType -> Bool
compare :: BaseType -> BaseType -> Ordering
$ccompare :: BaseType -> BaseType -> Ordering
Ord, BaseType -> BaseType -> Bool
(BaseType -> BaseType -> Bool)
-> (BaseType -> BaseType -> Bool) -> Eq BaseType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: BaseType -> BaseType -> Bool
$c/= :: BaseType -> BaseType -> Bool
== :: BaseType -> BaseType -> Bool
$c== :: BaseType -> BaseType -> Bool
Eq, Int -> BaseType -> ShowS
[BaseType] -> ShowS
BaseType -> String
(Int -> BaseType -> ShowS)
-> (BaseType -> String) -> ([BaseType] -> ShowS) -> Show BaseType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [BaseType] -> ShowS
$cshowList :: [BaseType] -> ShowS
show :: BaseType -> String
$cshow :: BaseType -> String
showsPrec :: Int -> BaseType -> ShowS
$cshowsPrec :: Int -> BaseType -> ShowS
Show, Typeable BaseType
Typeable BaseType
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> BaseType -> c BaseType)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c BaseType)
-> (BaseType -> Constr)
-> (BaseType -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c BaseType))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c BaseType))
-> ((forall b. Data b => b -> b) -> BaseType -> BaseType)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> BaseType -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> BaseType -> r)
-> (forall u. (forall d. Data d => d -> u) -> BaseType -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> BaseType -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> BaseType -> m BaseType)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> BaseType -> m BaseType)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> BaseType -> m BaseType)
-> Data BaseType
BaseType -> DataType
BaseType -> Constr
(forall b. Data b => b -> b) -> BaseType -> BaseType
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) -> BaseType -> u
forall u. (forall d. Data d => d -> u) -> BaseType -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> BaseType -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> BaseType -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> BaseType -> m BaseType
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> BaseType -> m BaseType
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c BaseType
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BaseType -> c BaseType
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c BaseType)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c BaseType)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> BaseType -> m BaseType
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> BaseType -> m BaseType
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> BaseType -> m BaseType
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> BaseType -> m BaseType
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> BaseType -> m BaseType
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> BaseType -> m BaseType
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> BaseType -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> BaseType -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> BaseType -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> BaseType -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> BaseType -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> BaseType -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> BaseType -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> BaseType -> r
gmapT :: (forall b. Data b => b -> b) -> BaseType -> BaseType
$cgmapT :: (forall b. Data b => b -> b) -> BaseType -> BaseType
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c BaseType)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c BaseType)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c BaseType)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c BaseType)
dataTypeOf :: BaseType -> DataType
$cdataTypeOf :: BaseType -> DataType
toConstr :: BaseType -> Constr
$ctoConstr :: BaseType -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c BaseType
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c BaseType
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BaseType -> c BaseType
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BaseType -> c BaseType
Data, Typeable, (forall x. BaseType -> Rep BaseType x)
-> (forall x. Rep BaseType x -> BaseType) -> Generic BaseType
forall x. Rep BaseType x -> BaseType
forall x. BaseType -> Rep BaseType x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep BaseType x -> BaseType
$cfrom :: forall x. BaseType -> Rep BaseType x
Generic)

instance Binary BaseType

-- | The type specification of a declaration statement, containing the syntactic
--   type name and kind selector.
--
-- See HP's F90 spec pg.24.
data TypeSpec a = TypeSpec a SrcSpan BaseType (Maybe (Selector a))
  deriving (TypeSpec a -> TypeSpec a -> Bool
(TypeSpec a -> TypeSpec a -> Bool)
-> (TypeSpec a -> TypeSpec a -> Bool) -> Eq (TypeSpec a)
forall a. Eq a => TypeSpec a -> TypeSpec a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TypeSpec a -> TypeSpec a -> Bool
$c/= :: forall a. Eq a => TypeSpec a -> TypeSpec a -> Bool
== :: TypeSpec a -> TypeSpec a -> Bool
$c== :: forall a. Eq a => TypeSpec a -> TypeSpec a -> Bool
Eq, Int -> TypeSpec a -> ShowS
[TypeSpec a] -> ShowS
TypeSpec a -> String
(Int -> TypeSpec a -> ShowS)
-> (TypeSpec a -> String)
-> ([TypeSpec a] -> ShowS)
-> Show (TypeSpec a)
forall a. Show a => Int -> TypeSpec a -> ShowS
forall a. Show a => [TypeSpec a] -> ShowS
forall a. Show a => TypeSpec a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TypeSpec a] -> ShowS
$cshowList :: forall a. Show a => [TypeSpec a] -> ShowS
show :: TypeSpec a -> String
$cshow :: forall a. Show a => TypeSpec a -> String
showsPrec :: Int -> TypeSpec a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> TypeSpec a -> ShowS
Show, Typeable (TypeSpec a)
Typeable (TypeSpec a)
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> TypeSpec a -> c (TypeSpec a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (TypeSpec a))
-> (TypeSpec a -> Constr)
-> (TypeSpec a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (TypeSpec a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (TypeSpec a)))
-> ((forall b. Data b => b -> b) -> TypeSpec a -> TypeSpec a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> TypeSpec a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> TypeSpec a -> r)
-> (forall u. (forall d. Data d => d -> u) -> TypeSpec a -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> TypeSpec a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> TypeSpec a -> m (TypeSpec a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TypeSpec a -> m (TypeSpec a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TypeSpec a -> m (TypeSpec a))
-> Data (TypeSpec a)
TypeSpec a -> DataType
TypeSpec a -> Constr
(forall b. Data b => b -> b) -> TypeSpec a -> TypeSpec a
forall {a}. Data a => Typeable (TypeSpec a)
forall a. Data a => TypeSpec a -> DataType
forall a. Data a => TypeSpec a -> Constr
forall a.
Data a =>
(forall b. Data b => b -> b) -> TypeSpec a -> TypeSpec a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> TypeSpec a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> TypeSpec a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TypeSpec a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TypeSpec a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> TypeSpec a -> m (TypeSpec a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> TypeSpec a -> m (TypeSpec a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (TypeSpec a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TypeSpec a -> c (TypeSpec a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (TypeSpec a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (TypeSpec a))
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) -> TypeSpec a -> u
forall u. (forall d. Data d => d -> u) -> TypeSpec a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TypeSpec a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TypeSpec a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TypeSpec a -> m (TypeSpec a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TypeSpec a -> m (TypeSpec a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (TypeSpec a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TypeSpec a -> c (TypeSpec a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (TypeSpec a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (TypeSpec a))
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TypeSpec a -> m (TypeSpec a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> TypeSpec a -> m (TypeSpec a)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TypeSpec a -> m (TypeSpec a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> TypeSpec a -> m (TypeSpec a)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TypeSpec a -> m (TypeSpec a)
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> TypeSpec a -> m (TypeSpec a)
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> TypeSpec a -> u
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> TypeSpec a -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> TypeSpec a -> [u]
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> TypeSpec a -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TypeSpec a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TypeSpec a -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TypeSpec a -> r
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TypeSpec a -> r
gmapT :: (forall b. Data b => b -> b) -> TypeSpec a -> TypeSpec a
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b) -> TypeSpec a -> TypeSpec a
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (TypeSpec a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (TypeSpec a))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (TypeSpec a))
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (TypeSpec a))
dataTypeOf :: TypeSpec a -> DataType
$cdataTypeOf :: forall a. Data a => TypeSpec a -> DataType
toConstr :: TypeSpec a -> Constr
$ctoConstr :: forall a. Data a => TypeSpec a -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (TypeSpec a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (TypeSpec a)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TypeSpec a -> c (TypeSpec a)
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TypeSpec a -> c (TypeSpec a)
Data, Typeable, (forall x. TypeSpec a -> Rep (TypeSpec a) x)
-> (forall x. Rep (TypeSpec a) x -> TypeSpec a)
-> Generic (TypeSpec a)
forall x. Rep (TypeSpec a) x -> TypeSpec a
forall x. TypeSpec a -> Rep (TypeSpec a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (TypeSpec a) x -> TypeSpec a
forall a x. TypeSpec a -> Rep (TypeSpec a) x
$cto :: forall a x. Rep (TypeSpec a) x -> TypeSpec a
$cfrom :: forall a x. TypeSpec a -> Rep (TypeSpec a) x
Generic, (forall a b. (a -> b) -> TypeSpec a -> TypeSpec b)
-> (forall a b. a -> TypeSpec b -> TypeSpec a) -> Functor TypeSpec
forall a b. a -> TypeSpec b -> TypeSpec a
forall a b. (a -> b) -> TypeSpec a -> TypeSpec b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: forall a b. a -> TypeSpec b -> TypeSpec a
$c<$ :: forall a b. a -> TypeSpec b -> TypeSpec a
fmap :: forall a b. (a -> b) -> TypeSpec a -> TypeSpec b
$cfmap :: forall a b. (a -> b) -> TypeSpec a -> TypeSpec b
Functor)

-- | The "kind selector" of a declaration statement.
--
-- HP's F90 spec (pg.24) actually differentiates between "kind selectors" and
-- "char selectors", where char selectors can specify a length (alongside kind),
-- and the default meaning of an unlabelled kind parameter (the 8 in INTEGER(8))
-- is length instead of kind. We handle this correctly in the parsers, but place
-- both into this 'Selector' type.
--
-- The upshot is, length is invalid for non-CHARACTER types, and the parser
-- guarantees that it will be Nothing. For CHARACTER types, both maybe or may
-- not be present.
data Selector a =
  Selector a SrcSpan
    (Maybe (Expression a)) -- ^ length (if present)
    (Maybe (Expression a)) -- ^ kind (if present)
  deriving (Selector a -> Selector a -> Bool
(Selector a -> Selector a -> Bool)
-> (Selector a -> Selector a -> Bool) -> Eq (Selector a)
forall a. Eq a => Selector a -> Selector a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Selector a -> Selector a -> Bool
$c/= :: forall a. Eq a => Selector a -> Selector a -> Bool
== :: Selector a -> Selector a -> Bool
$c== :: forall a. Eq a => Selector a -> Selector a -> Bool
Eq, Int -> Selector a -> ShowS
[Selector a] -> ShowS
Selector a -> String
(Int -> Selector a -> ShowS)
-> (Selector a -> String)
-> ([Selector a] -> ShowS)
-> Show (Selector a)
forall a. Show a => Int -> Selector a -> ShowS
forall a. Show a => [Selector a] -> ShowS
forall a. Show a => Selector a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Selector a] -> ShowS
$cshowList :: forall a. Show a => [Selector a] -> ShowS
show :: Selector a -> String
$cshow :: forall a. Show a => Selector a -> String
showsPrec :: Int -> Selector a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> Selector a -> ShowS
Show, Typeable (Selector a)
Typeable (Selector a)
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Selector a -> c (Selector a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Selector a))
-> (Selector a -> Constr)
-> (Selector a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Selector a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Selector a)))
-> ((forall b. Data b => b -> b) -> Selector a -> Selector a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Selector a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Selector a -> r)
-> (forall u. (forall d. Data d => d -> u) -> Selector a -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Selector a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Selector a -> m (Selector a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Selector a -> m (Selector a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Selector a -> m (Selector a))
-> Data (Selector a)
Selector a -> DataType
Selector a -> Constr
(forall b. Data b => b -> b) -> Selector a -> Selector a
forall {a}. Data a => Typeable (Selector a)
forall a. Data a => Selector a -> DataType
forall a. Data a => Selector a -> Constr
forall a.
Data a =>
(forall b. Data b => b -> b) -> Selector a -> Selector a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Selector a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> Selector a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Selector a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Selector a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Selector a -> m (Selector a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Selector a -> m (Selector a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Selector a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Selector a -> c (Selector a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Selector a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Selector a))
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) -> Selector a -> u
forall u. (forall d. Data d => d -> u) -> Selector a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Selector a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Selector a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Selector a -> m (Selector a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Selector a -> m (Selector a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Selector a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Selector a -> c (Selector a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Selector a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Selector a))
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Selector a -> m (Selector a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Selector a -> m (Selector a)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Selector a -> m (Selector a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Selector a -> m (Selector a)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Selector a -> m (Selector a)
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Selector a -> m (Selector a)
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Selector a -> u
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Selector a -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> Selector a -> [u]
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> Selector a -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Selector a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Selector a -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Selector a -> r
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Selector a -> r
gmapT :: (forall b. Data b => b -> b) -> Selector a -> Selector a
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b) -> Selector a -> Selector a
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Selector a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Selector a))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Selector a))
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Selector a))
dataTypeOf :: Selector a -> DataType
$cdataTypeOf :: forall a. Data a => Selector a -> DataType
toConstr :: Selector a -> Constr
$ctoConstr :: forall a. Data a => Selector a -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Selector a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Selector a)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Selector a -> c (Selector a)
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Selector a -> c (Selector a)
Data, Typeable, (forall x. Selector a -> Rep (Selector a) x)
-> (forall x. Rep (Selector a) x -> Selector a)
-> Generic (Selector a)
forall x. Rep (Selector a) x -> Selector a
forall x. Selector a -> Rep (Selector a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (Selector a) x -> Selector a
forall a x. Selector a -> Rep (Selector a) x
$cto :: forall a x. Rep (Selector a) x -> Selector a
$cfrom :: forall a x. Selector a -> Rep (Selector a) x
Generic, (forall a b. (a -> b) -> Selector a -> Selector b)
-> (forall a b. a -> Selector b -> Selector a) -> Functor Selector
forall a b. a -> Selector b -> Selector a
forall a b. (a -> b) -> Selector a -> Selector b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: forall a b. a -> Selector b -> Selector a
$c<$ :: forall a b. a -> Selector b -> Selector a
fmap :: forall a b. (a -> b) -> Selector a -> Selector b
$cfmap :: forall a b. (a -> b) -> Selector a -> Selector b
Functor)

type Kind = Int

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

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

pfSetFilename :: String -> ProgramFile a -> ProgramFile a
pfSetFilename :: forall a. String -> ProgramFile a -> ProgramFile a
pfSetFilename String
fn (ProgramFile MetaInfo
mi [ProgramUnit a]
pus) = MetaInfo -> [ProgramUnit a] -> ProgramFile a
forall a. MetaInfo -> [ProgramUnit a] -> ProgramFile a
ProgramFile (MetaInfo
mi { miFilename :: String
miFilename = String
fn }) [ProgramUnit a]
pus
pfGetFilename :: ProgramFile a -> String
pfGetFilename :: forall a. ProgramFile a -> String
pfGetFilename (ProgramFile MetaInfo
mi [ProgramUnit a]
_) = MetaInfo -> String
miFilename MetaInfo
mi

data ProgramUnit a =
    PUMain
      a SrcSpan
      (Maybe Name) -- Program name
      [Block a] -- Body
      (Maybe [ProgramUnit a]) -- Subprograms
  | PUModule
      a SrcSpan
      Name -- Program name
      [Block a] -- Body
      (Maybe [ProgramUnit a]) -- Subprograms
  | PUSubroutine
      a SrcSpan
      (PrefixSuffix a) -- Subroutine options
      Name
      (Maybe (AList Expression a)) -- Arguments
      [Block a] -- Body
      (Maybe [ProgramUnit a]) -- Subprograms
  | PUFunction
      a SrcSpan
      (Maybe (TypeSpec a)) -- Return type
      (PrefixSuffix a) -- Function Options
      Name
      (Maybe (AList Expression a)) -- Arguments
      (Maybe (Expression a)) -- Result
      [Block a] -- Body
      (Maybe [ProgramUnit a]) -- Subprograms
  | PUBlockData
      a SrcSpan
      (Maybe Name)
      [Block a] -- Body
  | PUComment a SrcSpan (Comment a)
  deriving (ProgramUnit a -> ProgramUnit a -> Bool
(ProgramUnit a -> ProgramUnit a -> Bool)
-> (ProgramUnit a -> ProgramUnit a -> Bool) -> Eq (ProgramUnit a)
forall a. Eq a => ProgramUnit a -> ProgramUnit a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ProgramUnit a -> ProgramUnit a -> Bool
$c/= :: forall a. Eq a => ProgramUnit a -> ProgramUnit a -> Bool
== :: ProgramUnit a -> ProgramUnit a -> Bool
$c== :: forall a. Eq a => ProgramUnit a -> ProgramUnit a -> Bool
Eq, Int -> ProgramUnit a -> ShowS
[ProgramUnit a] -> ShowS
ProgramUnit a -> String
(Int -> ProgramUnit a -> ShowS)
-> (ProgramUnit a -> String)
-> ([ProgramUnit a] -> ShowS)
-> Show (ProgramUnit a)
forall a. Show a => Int -> ProgramUnit a -> ShowS
forall a. Show a => [ProgramUnit a] -> ShowS
forall a. Show a => ProgramUnit a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ProgramUnit a] -> ShowS
$cshowList :: forall a. Show a => [ProgramUnit a] -> ShowS
show :: ProgramUnit a -> String
$cshow :: forall a. Show a => ProgramUnit a -> String
showsPrec :: Int -> ProgramUnit a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> ProgramUnit a -> ShowS
Show, Typeable (ProgramUnit a)
Typeable (ProgramUnit a)
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ProgramUnit a -> c (ProgramUnit a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (ProgramUnit a))
-> (ProgramUnit a -> Constr)
-> (ProgramUnit a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (ProgramUnit a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (ProgramUnit a)))
-> ((forall b. Data b => b -> b) -> ProgramUnit a -> ProgramUnit a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ProgramUnit a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ProgramUnit a -> r)
-> (forall u. (forall d. Data d => d -> u) -> ProgramUnit a -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> ProgramUnit a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> ProgramUnit a -> m (ProgramUnit a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> ProgramUnit a -> m (ProgramUnit a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> ProgramUnit a -> m (ProgramUnit a))
-> Data (ProgramUnit a)
ProgramUnit a -> DataType
ProgramUnit a -> Constr
(forall b. Data b => b -> b) -> ProgramUnit a -> ProgramUnit a
forall {a}. Data a => Typeable (ProgramUnit a)
forall a. Data a => ProgramUnit a -> DataType
forall a. Data a => ProgramUnit a -> Constr
forall a.
Data a =>
(forall b. Data b => b -> b) -> ProgramUnit a -> ProgramUnit a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> ProgramUnit a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> ProgramUnit a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ProgramUnit a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ProgramUnit a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d)
-> ProgramUnit a -> m (ProgramUnit a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> ProgramUnit a -> m (ProgramUnit a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ProgramUnit a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ProgramUnit a -> c (ProgramUnit a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (ProgramUnit a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ProgramUnit a))
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) -> ProgramUnit a -> u
forall u. (forall d. Data d => d -> u) -> ProgramUnit a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ProgramUnit a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ProgramUnit a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> ProgramUnit a -> m (ProgramUnit a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ProgramUnit a -> m (ProgramUnit a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ProgramUnit a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ProgramUnit a -> c (ProgramUnit a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (ProgramUnit a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ProgramUnit a))
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ProgramUnit a -> m (ProgramUnit a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> ProgramUnit a -> m (ProgramUnit a)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ProgramUnit a -> m (ProgramUnit a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> ProgramUnit a -> m (ProgramUnit a)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> ProgramUnit a -> m (ProgramUnit a)
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d)
-> ProgramUnit a -> m (ProgramUnit a)
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ProgramUnit a -> u
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> ProgramUnit a -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> ProgramUnit a -> [u]
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> ProgramUnit a -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ProgramUnit a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ProgramUnit a -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ProgramUnit a -> r
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ProgramUnit a -> r
gmapT :: (forall b. Data b => b -> b) -> ProgramUnit a -> ProgramUnit a
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b) -> ProgramUnit a -> ProgramUnit a
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ProgramUnit a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ProgramUnit a))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (ProgramUnit a))
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (ProgramUnit a))
dataTypeOf :: ProgramUnit a -> DataType
$cdataTypeOf :: forall a. Data a => ProgramUnit a -> DataType
toConstr :: ProgramUnit a -> Constr
$ctoConstr :: forall a. Data a => ProgramUnit a -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ProgramUnit a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ProgramUnit a)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ProgramUnit a -> c (ProgramUnit a)
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ProgramUnit a -> c (ProgramUnit a)
Data, Typeable, (forall x. ProgramUnit a -> Rep (ProgramUnit a) x)
-> (forall x. Rep (ProgramUnit a) x -> ProgramUnit a)
-> Generic (ProgramUnit a)
forall x. Rep (ProgramUnit a) x -> ProgramUnit a
forall x. ProgramUnit a -> Rep (ProgramUnit a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (ProgramUnit a) x -> ProgramUnit a
forall a x. ProgramUnit a -> Rep (ProgramUnit a) x
$cto :: forall a x. Rep (ProgramUnit a) x -> ProgramUnit a
$cfrom :: forall a x. ProgramUnit a -> Rep (ProgramUnit a) x
Generic, (forall a b. (a -> b) -> ProgramUnit a -> ProgramUnit b)
-> (forall a b. a -> ProgramUnit b -> ProgramUnit a)
-> Functor ProgramUnit
forall a b. a -> ProgramUnit b -> ProgramUnit a
forall a b. (a -> b) -> ProgramUnit a -> ProgramUnit b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: forall a b. a -> ProgramUnit b -> ProgramUnit a
$c<$ :: forall a b. a -> ProgramUnit b -> ProgramUnit a
fmap :: forall a b. (a -> b) -> ProgramUnit a -> ProgramUnit b
$cfmap :: forall a b. (a -> b) -> ProgramUnit a -> ProgramUnit b
Functor)

type Prefixes a = Maybe (AList Prefix a)
type Suffixes a = Maybe (AList Suffix a)
type PrefixSuffix a = (Prefixes a, Suffixes a)

emptyPrefixes :: Prefixes a
emptyPrefixes :: forall a. Prefixes a
emptyPrefixes = Maybe (AList Prefix a)
forall a. Maybe a
Nothing

emptySuffixes :: Suffixes a
emptySuffixes :: forall a. Suffixes a
emptySuffixes = Maybe (AList Suffix a)
forall a. Maybe a
Nothing

emptyPrefixSuffix :: PrefixSuffix a
emptyPrefixSuffix :: forall a. PrefixSuffix a
emptyPrefixSuffix = (Prefixes a
forall a. Prefixes a
emptyPrefixes, Suffixes a
forall a. Suffixes a
emptySuffixes)

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

-- see C1241 & C1242 (Fortran2003)
validPrefixSuffix :: PrefixSuffix a -> Bool
validPrefixSuffix :: forall a. PrefixSuffix a -> Bool
validPrefixSuffix (Prefixes a
mpfxs, Suffixes a
msfxs) =
  Bool -> Bool
not ((Prefix a -> Bool) -> [Prefix a] -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
any Prefix a -> Bool
forall {a}. Prefix a -> Bool
isElem [Prefix a]
pfxs) Bool -> Bool -> Bool
|| (Bool -> Bool
not ((Prefix a -> Bool) -> [Prefix a] -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
any Prefix a -> Bool
forall {a}. Prefix a -> Bool
isRec [Prefix a]
pfxs) Bool -> Bool -> Bool
&& Bool -> Bool
not ((Suffix a -> Bool) -> [Suffix a] -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
any Suffix a -> Bool
forall {a}. Suffix a -> Bool
isBind [Suffix a]
sfxs))
  where
    isElem :: Prefix a -> Bool
isElem (PfxElemental {}) = Bool
True; isElem Prefix a
_ = Bool
False
    isRec :: Prefix a -> Bool
isRec  (PfxRecursive {}) = Bool
True; isRec Prefix a
_  = Bool
False
    isBind :: Suffix a -> Bool
isBind (SfxBind {})      = Bool
True
    pfxs :: [Prefix a]
pfxs = Prefixes a -> [Prefix a]
forall (t :: * -> *) a. Maybe (AList t a) -> [t a]
aStrip' Prefixes a
mpfxs
    sfxs :: [Suffix a]
sfxs = Suffixes a -> [Suffix a]
forall (t :: * -> *) a. Maybe (AList t a) -> [t a]
aStrip' Suffixes a
msfxs

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

programUnitBody :: ProgramUnit a -> [Block a]
programUnitBody :: forall a. ProgramUnit a -> [Block a]
programUnitBody (PUMain a
_ SrcSpan
_ Maybe String
_ [Block a]
bs Maybe [ProgramUnit a]
_)              = [Block a]
bs
programUnitBody (PUModule a
_ SrcSpan
_ String
_ [Block a]
bs Maybe [ProgramUnit a]
_)            = [Block a]
bs
programUnitBody (PUSubroutine a
_ SrcSpan
_ PrefixSuffix a
_ String
_ Maybe (AList Expression a)
_ [Block a]
bs Maybe [ProgramUnit a]
_)    = [Block a]
bs
programUnitBody (PUFunction a
_ SrcSpan
_ Maybe (TypeSpec a)
_ PrefixSuffix a
_ String
_ Maybe (AList Expression a)
_ Maybe (Expression a)
_ [Block a]
bs Maybe [ProgramUnit a]
_)  = [Block a]
bs
programUnitBody (PUBlockData a
_ SrcSpan
_ Maybe String
_ [Block a]
bs)           = [Block a]
bs
programUnitBody PUComment{}                   = []

updateProgramUnitBody :: ProgramUnit a -> [Block a] -> ProgramUnit a
updateProgramUnitBody :: forall a. ProgramUnit a -> [Block a] -> ProgramUnit a
updateProgramUnitBody (PUMain a
a SrcSpan
s Maybe String
n [Block a]
_ Maybe [ProgramUnit a]
pu)   [Block a]
bs' =
    a
-> SrcSpan
-> Maybe String
-> [Block a]
-> Maybe [ProgramUnit a]
-> ProgramUnit a
forall a.
a
-> SrcSpan
-> Maybe String
-> [Block a]
-> Maybe [ProgramUnit a]
-> ProgramUnit a
PUMain a
a SrcSpan
s Maybe String
n [Block a]
bs' Maybe [ProgramUnit a]
pu
updateProgramUnitBody (PUModule a
a SrcSpan
s String
n [Block a]
_ Maybe [ProgramUnit a]
pu) [Block a]
bs' =
    a
-> SrcSpan
-> String
-> [Block a]
-> Maybe [ProgramUnit a]
-> ProgramUnit a
forall a.
a
-> SrcSpan
-> String
-> [Block a]
-> Maybe [ProgramUnit a]
-> ProgramUnit a
PUModule a
a SrcSpan
s String
n [Block a]
bs' Maybe [ProgramUnit a]
pu
updateProgramUnitBody (PUSubroutine a
a SrcSpan
s PrefixSuffix a
f String
n Maybe (AList Expression a)
args [Block a]
_ Maybe [ProgramUnit a]
pu) [Block a]
bs' =
    a
-> SrcSpan
-> PrefixSuffix a
-> String
-> Maybe (AList Expression a)
-> [Block a]
-> Maybe [ProgramUnit a]
-> ProgramUnit a
forall a.
a
-> SrcSpan
-> PrefixSuffix a
-> String
-> Maybe (AList Expression a)
-> [Block a]
-> Maybe [ProgramUnit a]
-> ProgramUnit a
PUSubroutine a
a SrcSpan
s PrefixSuffix a
f String
n Maybe (AList Expression a)
args [Block a]
bs' Maybe [ProgramUnit a]
pu
updateProgramUnitBody (PUFunction a
a SrcSpan
s Maybe (TypeSpec a)
t PrefixSuffix a
f String
n Maybe (AList Expression a)
args Maybe (Expression a)
res [Block a]
_ Maybe [ProgramUnit a]
pu) [Block a]
bs' =
    a
-> SrcSpan
-> Maybe (TypeSpec a)
-> PrefixSuffix a
-> String
-> Maybe (AList Expression a)
-> Maybe (Expression a)
-> [Block a]
-> Maybe [ProgramUnit a]
-> ProgramUnit a
forall a.
a
-> SrcSpan
-> Maybe (TypeSpec a)
-> PrefixSuffix a
-> String
-> Maybe (AList Expression a)
-> Maybe (Expression a)
-> [Block a]
-> Maybe [ProgramUnit a]
-> ProgramUnit a
PUFunction a
a SrcSpan
s Maybe (TypeSpec a)
t PrefixSuffix a
f String
n Maybe (AList Expression a)
args Maybe (Expression a)
res [Block a]
bs' Maybe [ProgramUnit a]
pu
updateProgramUnitBody (PUBlockData a
a SrcSpan
s Maybe String
n [Block a]
_) [Block a]
bs' =
    a -> SrcSpan -> Maybe String -> [Block a] -> ProgramUnit a
forall a.
a -> SrcSpan -> Maybe String -> [Block a] -> ProgramUnit a
PUBlockData a
a SrcSpan
s Maybe String
n [Block a]
bs'
updateProgramUnitBody p :: ProgramUnit a
p@PUComment{} [Block a]
_ = ProgramUnit a
p

programUnitSubprograms :: ProgramUnit a -> Maybe [ProgramUnit a]
programUnitSubprograms :: forall a. ProgramUnit a -> Maybe [ProgramUnit a]
programUnitSubprograms (PUMain a
_ SrcSpan
_ Maybe String
_ [Block a]
_ Maybe [ProgramUnit a]
s)             = Maybe [ProgramUnit a]
s
programUnitSubprograms (PUModule a
_ SrcSpan
_ String
_ [Block a]
_ Maybe [ProgramUnit a]
s)           = Maybe [ProgramUnit a]
s
programUnitSubprograms (PUSubroutine a
_ SrcSpan
_ PrefixSuffix a
_ String
_ Maybe (AList Expression a)
_ [Block a]
_ Maybe [ProgramUnit a]
s)   = Maybe [ProgramUnit a]
s
programUnitSubprograms (PUFunction a
_ SrcSpan
_ Maybe (TypeSpec a)
_ PrefixSuffix a
_ String
_ Maybe (AList Expression a)
_ Maybe (Expression a)
_ [Block a]
_ Maybe [ProgramUnit a]
s) = Maybe [ProgramUnit a]
s
programUnitSubprograms PUBlockData{}               = Maybe [ProgramUnit a]
forall a. Maybe a
Nothing
programUnitSubprograms PUComment{}                 = Maybe [ProgramUnit a]
forall a. Maybe a
Nothing

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

data Block a =
    BlStatement a SrcSpan
                (Maybe (Expression a))       -- ^ Label
                (Statement a)                -- ^ Statement

  | BlForall    a SrcSpan
                (Maybe (Expression a))       -- ^ Label
                (Maybe String)               -- ^ Construct name
                (ForallHeader a)             -- ^ Header information
                [ Block a ]                  -- ^ Body
                (Maybe (Expression a))       -- ^ Label to END DO

  | BlIf        a SrcSpan
                (Maybe (Expression a))       -- ^ Label
                (Maybe String)               -- ^ Construct name
                [ Maybe (Expression a) ]     -- ^ Conditions
                [ [ Block a ] ]              -- ^ Bodies
                (Maybe (Expression a))       -- ^ Label to END IF

  | BlCase      a SrcSpan
                (Maybe (Expression a))       -- ^ Label
                (Maybe String)               -- ^ Construct name
                (Expression a)               -- ^ Scrutinee
                [ Maybe (AList Index a) ]    -- ^ Case ranges
                [ [ Block a ] ]              -- ^ Bodies
                (Maybe (Expression a))       -- ^ Label to END SELECT

  | BlDo        a SrcSpan
                (Maybe (Expression a))       -- ^ Label
                (Maybe String)               -- ^ Construct name
                (Maybe (Expression a))       -- ^ Target label
                (Maybe (DoSpecification a))  -- ^ Do Specification
                [ Block a ]                  -- ^ Body
                (Maybe (Expression a))       -- ^ Label to END DO

  | BlDoWhile   a SrcSpan
                (Maybe (Expression a))       -- ^ Label
                (Maybe String)               -- ^ Construct name
                (Maybe (Expression a))       -- ^ Target label
                (Expression a)               -- ^ Condition
                [ Block a ]                  -- ^ Body
                (Maybe (Expression a))       -- ^ Label to END DO

  | BlAssociate a SrcSpan
                (Maybe (Expression a))       -- Label
                (Maybe String)               -- Construct name
                (AList (ATuple Expression Expression) a) -- Expression abbreviations
                [ Block a ]                  -- Body
                (Maybe (Expression a))       -- Label to END IF
  -- ^ The first 'Expression' in the abbreviation tuple is always an
  --   @ExpValue _ _ (ValVariable id)@. Also guaranteed nonempty.

  | BlInterface a SrcSpan
                (Maybe (Expression a))       -- ^ label
                Bool                         -- ^ abstract?
                [ ProgramUnit a ]            -- ^ Routine decls. in the interface
                [ Block a ]                  -- ^ Module procedures

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

data Statement a  =
    StDeclaration         a SrcSpan (TypeSpec a) (Maybe (AList Attribute a)) (AList Declarator a)
  | StStructure           a SrcSpan (Maybe String) (AList StructureItem a)
  | StIntent              a SrcSpan Intent (AList Expression a)
  | StOptional            a SrcSpan (AList Expression a)
  | StPublic              a SrcSpan (Maybe (AList Expression a))
  | StPrivate             a SrcSpan (Maybe (AList Expression a))
  | StProtected           a SrcSpan (Maybe (AList Expression a))
  | StSave                a SrcSpan (Maybe (AList Expression a))
  | StDimension           a SrcSpan (AList Declarator a)
  | StAllocatable         a SrcSpan (AList Declarator a)
  | StAsynchronous        a SrcSpan (AList Declarator a)
  | StPointer             a SrcSpan (AList Declarator a)
  | StTarget              a SrcSpan (AList Declarator a)
  | StValue               a SrcSpan (AList Declarator a)
  | StVolatile            a SrcSpan (AList Declarator a)
  | StData                a SrcSpan (AList DataGroup a)
  | StAutomatic           a SrcSpan (AList Declarator a)
  | StStatic              a SrcSpan (AList Declarator a)
  | StNamelist            a SrcSpan (AList Namelist a)
  | StParameter           a SrcSpan (AList Declarator a)
  | StExternal            a SrcSpan (AList Expression a)
  | StIntrinsic           a SrcSpan (AList Expression a)
  | StCommon              a SrcSpan (AList CommonGroup a)
  -- ^ A COMMON statement, defining a list of common blocks.
  | StEquivalence         a SrcSpan (AList (AList Expression) a)
  | StFormat              a SrcSpan (AList FormatItem a)
  | StImplicit            a SrcSpan (Maybe (AList ImpList a))
  | StEntry               a SrcSpan (Expression a) (Maybe (AList Expression a)) (Maybe (Expression a))

  | StInclude             a SrcSpan (Expression a) (Maybe [Block a])
  -- ^ Nothing indicates an yet-to-be processed include. (The F77 parser parses
  -- Nothing, then fills out each include statement in a post-parse step.)

  | StDo                  a SrcSpan (Maybe String) (Maybe (Expression a)) (Maybe (DoSpecification a))
  | StDoWhile             a SrcSpan (Maybe String) (Maybe (Expression a)) (Expression a)
  | StEnddo               a SrcSpan (Maybe String)
  | StCycle               a SrcSpan (Maybe (Expression a))
  | StExit                a SrcSpan (Maybe (Expression a))
  | StIfLogical           a SrcSpan (Expression a) (Statement a) -- Statement should not further recurse
  | StIfArithmetic        a SrcSpan (Expression a) (Expression a) (Expression a) (Expression a)
  | StSelectCase          a SrcSpan (Maybe String) (Expression a)
  | StCase                a SrcSpan (Maybe String) (Maybe (AList Index a))
  | StEndcase             a SrcSpan (Maybe String)
  | StFunction            a SrcSpan (Expression a) (AList Expression a) (Expression a)
  | StExpressionAssign    a SrcSpan (Expression a) (Expression a)
  | StPointerAssign       a SrcSpan (Expression a) (Expression a)
  | StLabelAssign         a SrcSpan (Expression a) (Expression a)
  | StGotoUnconditional   a SrcSpan (Expression a)
  | StGotoAssigned        a SrcSpan (Expression a) (Maybe (AList Expression a))
  | StGotoComputed        a SrcSpan (AList Expression a) (Expression a)
  | StCall                a SrcSpan (Expression a) (Maybe (AList Argument a))
  | StReturn              a SrcSpan (Maybe (Expression a))
  | StContinue            a SrcSpan
  | StStop                a SrcSpan (Maybe (Expression a))
  | StPause               a SrcSpan (Maybe (Expression a))
  | StRead                a SrcSpan (AList ControlPair a) (Maybe (AList Expression a))
  | StRead2               a SrcSpan (Expression a) (Maybe (AList Expression a))
  | StWrite               a SrcSpan (AList ControlPair a) (Maybe (AList Expression a))
  | StPrint               a SrcSpan (Expression a) (Maybe (AList Expression a))
  | StTypePrint           a SrcSpan (Expression a) (Maybe (AList Expression a))
  | StOpen                a SrcSpan (AList ControlPair a)
  | StClose               a SrcSpan (AList ControlPair a)
  | StFlush               a SrcSpan (AList FlushSpec a)
  | StInquire             a SrcSpan (AList ControlPair a)
  | StRewind              a SrcSpan (AList ControlPair a)
  | StRewind2             a SrcSpan (Expression a)
  | StBackspace           a SrcSpan (AList ControlPair a)
  | StBackspace2          a SrcSpan (Expression a)
  | StEndfile             a SrcSpan (AList ControlPair a)
  | StEndfile2            a SrcSpan (Expression a)
  | StAllocate            a SrcSpan (Maybe (TypeSpec a)) (AList Expression a) (Maybe (AList AllocOpt a))
  | StNullify             a SrcSpan (AList Expression a)
  | StDeallocate          a SrcSpan (AList Expression a) (Maybe (AList AllocOpt a))
  | StWhere               a SrcSpan (Expression a) (Statement a)
  | StWhereConstruct      a SrcSpan (Maybe String) (Expression a)
  | StElsewhere           a SrcSpan (Maybe String) (Maybe (Expression a))
  | StEndWhere            a SrcSpan (Maybe String)
  | StUse                 a SrcSpan (Expression a) (Maybe ModuleNature) Only (Maybe (AList Use a))
  | StModuleProcedure     a SrcSpan (AList Expression a)
  | StProcedure           a SrcSpan (Maybe (ProcInterface a)) (Maybe (Attribute a)) (AList ProcDecl a)
  | StType                a SrcSpan (Maybe (AList Attribute a)) String
  | StEndType             a SrcSpan (Maybe String)
  | StSequence            a SrcSpan
  | StForall              a SrcSpan (Maybe String) (ForallHeader a)
  | StForallStatement     a SrcSpan (ForallHeader a) (Statement a)
  | StEndForall           a SrcSpan (Maybe String)
  | StImport              a SrcSpan (AList Expression a)
  | StEnum                a SrcSpan
  | StEnumerator          a SrcSpan (AList Declarator a)
  | StEndEnum             a SrcSpan
  -- Following is a temporary solution to a complicated FORMAT statement
  -- parsing problem.
  | StFormatBogus         a SrcSpan String
  deriving (Statement a -> Statement a -> Bool
(Statement a -> Statement a -> Bool)
-> (Statement a -> Statement a -> Bool) -> Eq (Statement a)
forall a. Eq a => Statement a -> Statement a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Statement a -> Statement a -> Bool
$c/= :: forall a. Eq a => Statement a -> Statement a -> Bool
== :: Statement a -> Statement a -> Bool
$c== :: forall a. Eq a => Statement a -> Statement a -> Bool
Eq, Int -> Statement a -> ShowS
[Statement a] -> ShowS
Statement a -> String
(Int -> Statement a -> ShowS)
-> (Statement a -> String)
-> ([Statement a] -> ShowS)
-> Show (Statement a)
forall a. Show a => Int -> Statement a -> ShowS
forall a. Show a => [Statement a] -> ShowS
forall a. Show a => Statement a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Statement a] -> ShowS
$cshowList :: forall a. Show a => [Statement a] -> ShowS
show :: Statement a -> String
$cshow :: forall a. Show a => Statement a -> String
showsPrec :: Int -> Statement a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> Statement a -> ShowS
Show, Typeable (Statement a)
Typeable (Statement a)
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Statement a -> c (Statement a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Statement a))
-> (Statement a -> Constr)
-> (Statement a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Statement a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Statement a)))
-> ((forall b. Data b => b -> b) -> Statement a -> Statement a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Statement a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Statement a -> r)
-> (forall u. (forall d. Data d => d -> u) -> Statement a -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Statement a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Statement a -> m (Statement a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Statement a -> m (Statement a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Statement a -> m (Statement a))
-> Data (Statement a)
Statement a -> DataType
Statement a -> Constr
(forall b. Data b => b -> b) -> Statement a -> Statement a
forall {a}. Data a => Typeable (Statement a)
forall a. Data a => Statement a -> DataType
forall a. Data a => Statement a -> Constr
forall a.
Data a =>
(forall b. Data b => b -> b) -> Statement a -> Statement a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Statement a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> Statement a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Statement a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Statement a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Statement a -> m (Statement a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Statement a -> m (Statement a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Statement a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Statement a -> c (Statement a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Statement a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Statement a))
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) -> Statement a -> u
forall u. (forall d. Data d => d -> u) -> Statement a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Statement a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Statement a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Statement a -> m (Statement a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Statement a -> m (Statement a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Statement a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Statement a -> c (Statement a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Statement a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Statement a))
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Statement a -> m (Statement a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Statement a -> m (Statement a)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Statement a -> m (Statement a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Statement a -> m (Statement a)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Statement a -> m (Statement a)
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Statement a -> m (Statement a)
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Statement a -> u
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Statement a -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> Statement a -> [u]
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> Statement a -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Statement a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Statement a -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Statement a -> r
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Statement a -> r
gmapT :: (forall b. Data b => b -> b) -> Statement a -> Statement a
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b) -> Statement a -> Statement a
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Statement a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Statement a))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Statement a))
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Statement a))
dataTypeOf :: Statement a -> DataType
$cdataTypeOf :: forall a. Data a => Statement a -> DataType
toConstr :: Statement a -> Constr
$ctoConstr :: forall a. Data a => Statement a -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Statement a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Statement a)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Statement a -> c (Statement a)
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Statement a -> c (Statement a)
Data, Typeable, (forall x. Statement a -> Rep (Statement a) x)
-> (forall x. Rep (Statement a) x -> Statement a)
-> Generic (Statement a)
forall x. Rep (Statement a) x -> Statement a
forall x. Statement a -> Rep (Statement a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (Statement a) x -> Statement a
forall a x. Statement a -> Rep (Statement a) x
$cto :: forall a x. Rep (Statement a) x -> Statement a
$cfrom :: forall a x. Statement a -> Rep (Statement a) x
Generic, (forall a b. (a -> b) -> Statement a -> Statement b)
-> (forall a b. a -> Statement b -> Statement a)
-> Functor Statement
forall a b. a -> Statement b -> Statement a
forall a b. (a -> b) -> Statement a -> Statement b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: forall a b. a -> Statement b -> Statement a
$c<$ :: forall a b. a -> Statement b -> Statement a
fmap :: forall a b. (a -> b) -> Statement a -> Statement b
$cfmap :: forall a b. (a -> b) -> Statement a -> Statement b
Functor)

-- R1214 proc-decl is procedure-entity-name [=> null-init]
data ProcDecl a = ProcDecl a SrcSpan (Expression a) (Maybe (Expression a))
  deriving (ProcDecl a -> ProcDecl a -> Bool
(ProcDecl a -> ProcDecl a -> Bool)
-> (ProcDecl a -> ProcDecl a -> Bool) -> Eq (ProcDecl a)
forall a. Eq a => ProcDecl a -> ProcDecl a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ProcDecl a -> ProcDecl a -> Bool
$c/= :: forall a. Eq a => ProcDecl a -> ProcDecl a -> Bool
== :: ProcDecl a -> ProcDecl a -> Bool
$c== :: forall a. Eq a => ProcDecl a -> ProcDecl a -> Bool
Eq, Int -> ProcDecl a -> ShowS
[ProcDecl a] -> ShowS
ProcDecl a -> String
(Int -> ProcDecl a -> ShowS)
-> (ProcDecl a -> String)
-> ([ProcDecl a] -> ShowS)
-> Show (ProcDecl a)
forall a. Show a => Int -> ProcDecl a -> ShowS
forall a. Show a => [ProcDecl a] -> ShowS
forall a. Show a => ProcDecl a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ProcDecl a] -> ShowS
$cshowList :: forall a. Show a => [ProcDecl a] -> ShowS
show :: ProcDecl a -> String
$cshow :: forall a. Show a => ProcDecl a -> String
showsPrec :: Int -> ProcDecl a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> ProcDecl a -> ShowS
Show, Typeable (ProcDecl a)
Typeable (ProcDecl a)
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ProcDecl a -> c (ProcDecl a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (ProcDecl a))
-> (ProcDecl a -> Constr)
-> (ProcDecl a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (ProcDecl a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (ProcDecl a)))
-> ((forall b. Data b => b -> b) -> ProcDecl a -> ProcDecl a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ProcDecl a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ProcDecl a -> r)
-> (forall u. (forall d. Data d => d -> u) -> ProcDecl a -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> ProcDecl a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ProcDecl a -> m (ProcDecl a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ProcDecl a -> m (ProcDecl a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ProcDecl a -> m (ProcDecl a))
-> Data (ProcDecl a)
ProcDecl a -> DataType
ProcDecl a -> Constr
(forall b. Data b => b -> b) -> ProcDecl a -> ProcDecl a
forall {a}. Data a => Typeable (ProcDecl a)
forall a. Data a => ProcDecl a -> DataType
forall a. Data a => ProcDecl a -> Constr
forall a.
Data a =>
(forall b. Data b => b -> b) -> ProcDecl a -> ProcDecl a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> ProcDecl a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> ProcDecl a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ProcDecl a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ProcDecl a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> ProcDecl a -> m (ProcDecl a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> ProcDecl a -> m (ProcDecl a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ProcDecl a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ProcDecl a -> c (ProcDecl a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (ProcDecl a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ProcDecl a))
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) -> ProcDecl a -> u
forall u. (forall d. Data d => d -> u) -> ProcDecl a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ProcDecl a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ProcDecl a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ProcDecl a -> m (ProcDecl a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ProcDecl a -> m (ProcDecl a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ProcDecl a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ProcDecl a -> c (ProcDecl a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (ProcDecl a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ProcDecl a))
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ProcDecl a -> m (ProcDecl a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> ProcDecl a -> m (ProcDecl a)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ProcDecl a -> m (ProcDecl a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> ProcDecl a -> m (ProcDecl a)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ProcDecl a -> m (ProcDecl a)
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> ProcDecl a -> m (ProcDecl a)
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ProcDecl a -> u
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> ProcDecl a -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> ProcDecl a -> [u]
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> ProcDecl a -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ProcDecl a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ProcDecl a -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ProcDecl a -> r
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ProcDecl a -> r
gmapT :: (forall b. Data b => b -> b) -> ProcDecl a -> ProcDecl a
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b) -> ProcDecl a -> ProcDecl a
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ProcDecl a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ProcDecl a))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (ProcDecl a))
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (ProcDecl a))
dataTypeOf :: ProcDecl a -> DataType
$cdataTypeOf :: forall a. Data a => ProcDecl a -> DataType
toConstr :: ProcDecl a -> Constr
$ctoConstr :: forall a. Data a => ProcDecl a -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ProcDecl a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ProcDecl a)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ProcDecl a -> c (ProcDecl a)
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ProcDecl a -> c (ProcDecl a)
Data, Typeable, (forall x. ProcDecl a -> Rep (ProcDecl a) x)
-> (forall x. Rep (ProcDecl a) x -> ProcDecl a)
-> Generic (ProcDecl a)
forall x. Rep (ProcDecl a) x -> ProcDecl a
forall x. ProcDecl a -> Rep (ProcDecl a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (ProcDecl a) x -> ProcDecl a
forall a x. ProcDecl a -> Rep (ProcDecl a) x
$cto :: forall a x. Rep (ProcDecl a) x -> ProcDecl a
$cfrom :: forall a x. ProcDecl a -> Rep (ProcDecl a) x
Generic, (forall a b. (a -> b) -> ProcDecl a -> ProcDecl b)
-> (forall a b. a -> ProcDecl b -> ProcDecl a) -> Functor ProcDecl
forall a b. a -> ProcDecl b -> ProcDecl a
forall a b. (a -> b) -> ProcDecl a -> ProcDecl b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: forall a b. a -> ProcDecl b -> ProcDecl a
$c<$ :: forall a b. a -> ProcDecl b -> ProcDecl a
fmap :: forall a b. (a -> b) -> ProcDecl a -> ProcDecl b
$cfmap :: forall a b. (a -> b) -> ProcDecl a -> ProcDecl b
Functor)

-- R1212 proc-interface is interface-name or declaration-type-spec
data ProcInterface a = ProcInterfaceName a SrcSpan (Expression a)
                     | ProcInterfaceType a SrcSpan (TypeSpec a)
  deriving (ProcInterface a -> ProcInterface a -> Bool
(ProcInterface a -> ProcInterface a -> Bool)
-> (ProcInterface a -> ProcInterface a -> Bool)
-> Eq (ProcInterface a)
forall a. Eq a => ProcInterface a -> ProcInterface a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ProcInterface a -> ProcInterface a -> Bool
$c/= :: forall a. Eq a => ProcInterface a -> ProcInterface a -> Bool
== :: ProcInterface a -> ProcInterface a -> Bool
$c== :: forall a. Eq a => ProcInterface a -> ProcInterface a -> Bool
Eq, Int -> ProcInterface a -> ShowS
[ProcInterface a] -> ShowS
ProcInterface a -> String
(Int -> ProcInterface a -> ShowS)
-> (ProcInterface a -> String)
-> ([ProcInterface a] -> ShowS)
-> Show (ProcInterface a)
forall a. Show a => Int -> ProcInterface a -> ShowS
forall a. Show a => [ProcInterface a] -> ShowS
forall a. Show a => ProcInterface a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ProcInterface a] -> ShowS
$cshowList :: forall a. Show a => [ProcInterface a] -> ShowS
show :: ProcInterface a -> String
$cshow :: forall a. Show a => ProcInterface a -> String
showsPrec :: Int -> ProcInterface a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> ProcInterface a -> ShowS
Show, Typeable (ProcInterface a)
Typeable (ProcInterface a)
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ProcInterface a -> c (ProcInterface a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (ProcInterface a))
-> (ProcInterface a -> Constr)
-> (ProcInterface a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (ProcInterface a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (ProcInterface a)))
-> ((forall b. Data b => b -> b)
    -> ProcInterface a -> ProcInterface a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ProcInterface a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ProcInterface a -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> ProcInterface a -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> ProcInterface a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> ProcInterface a -> m (ProcInterface a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> ProcInterface a -> m (ProcInterface a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> ProcInterface a -> m (ProcInterface a))
-> Data (ProcInterface a)
ProcInterface a -> DataType
ProcInterface a -> Constr
(forall b. Data b => b -> b) -> ProcInterface a -> ProcInterface a
forall {a}. Data a => Typeable (ProcInterface a)
forall a. Data a => ProcInterface a -> DataType
forall a. Data a => ProcInterface a -> Constr
forall a.
Data a =>
(forall b. Data b => b -> b) -> ProcInterface a -> ProcInterface a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> ProcInterface a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> ProcInterface a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ProcInterface a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ProcInterface a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d)
-> ProcInterface a -> m (ProcInterface a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> ProcInterface a -> m (ProcInterface a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ProcInterface a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ProcInterface a -> c (ProcInterface a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (ProcInterface a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ProcInterface a))
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) -> ProcInterface a -> u
forall u. (forall d. Data d => d -> u) -> ProcInterface a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ProcInterface a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ProcInterface a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> ProcInterface a -> m (ProcInterface a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ProcInterface a -> m (ProcInterface a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ProcInterface a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ProcInterface a -> c (ProcInterface a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (ProcInterface a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ProcInterface a))
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ProcInterface a -> m (ProcInterface a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> ProcInterface a -> m (ProcInterface a)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ProcInterface a -> m (ProcInterface a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> ProcInterface a -> m (ProcInterface a)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> ProcInterface a -> m (ProcInterface a)
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d)
-> ProcInterface a -> m (ProcInterface a)
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> ProcInterface a -> u
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> ProcInterface a -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> ProcInterface a -> [u]
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> ProcInterface a -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ProcInterface a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ProcInterface a -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ProcInterface a -> r
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ProcInterface a -> r
gmapT :: (forall b. Data b => b -> b) -> ProcInterface a -> ProcInterface a
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b) -> ProcInterface a -> ProcInterface a
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ProcInterface a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ProcInterface a))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (ProcInterface a))
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (ProcInterface a))
dataTypeOf :: ProcInterface a -> DataType
$cdataTypeOf :: forall a. Data a => ProcInterface a -> DataType
toConstr :: ProcInterface a -> Constr
$ctoConstr :: forall a. Data a => ProcInterface a -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ProcInterface a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ProcInterface a)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ProcInterface a -> c (ProcInterface a)
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ProcInterface a -> c (ProcInterface a)
Data, Typeable, (forall x. ProcInterface a -> Rep (ProcInterface a) x)
-> (forall x. Rep (ProcInterface a) x -> ProcInterface a)
-> Generic (ProcInterface a)
forall x. Rep (ProcInterface a) x -> ProcInterface a
forall x. ProcInterface a -> Rep (ProcInterface a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (ProcInterface a) x -> ProcInterface a
forall a x. ProcInterface a -> Rep (ProcInterface a) x
$cto :: forall a x. Rep (ProcInterface a) x -> ProcInterface a
$cfrom :: forall a x. ProcInterface a -> Rep (ProcInterface a) x
Generic, (forall a b. (a -> b) -> ProcInterface a -> ProcInterface b)
-> (forall a b. a -> ProcInterface b -> ProcInterface a)
-> Functor ProcInterface
forall a b. a -> ProcInterface b -> ProcInterface a
forall a b. (a -> b) -> ProcInterface a -> ProcInterface b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: forall a b. a -> ProcInterface b -> ProcInterface a
$c<$ :: forall a b. a -> ProcInterface b -> ProcInterface a
fmap :: forall a b. (a -> b) -> ProcInterface a -> ProcInterface b
$cfmap :: forall a b. (a -> b) -> ProcInterface a -> ProcInterface b
Functor)

data ForallHeader a = ForallHeader
    -- List of tuples: index-name, start subscript, end subscript, optional stride
    [(Name, Expression a, Expression a, Maybe (Expression a))]
    -- An optional expression for scaling
    (Maybe (Expression a))
  deriving (ForallHeader a -> ForallHeader a -> Bool
(ForallHeader a -> ForallHeader a -> Bool)
-> (ForallHeader a -> ForallHeader a -> Bool)
-> Eq (ForallHeader a)
forall a. Eq a => ForallHeader a -> ForallHeader a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ForallHeader a -> ForallHeader a -> Bool
$c/= :: forall a. Eq a => ForallHeader a -> ForallHeader a -> Bool
== :: ForallHeader a -> ForallHeader a -> Bool
$c== :: forall a. Eq a => ForallHeader a -> ForallHeader a -> Bool
Eq, Int -> ForallHeader a -> ShowS
[ForallHeader a] -> ShowS
ForallHeader a -> String
(Int -> ForallHeader a -> ShowS)
-> (ForallHeader a -> String)
-> ([ForallHeader a] -> ShowS)
-> Show (ForallHeader a)
forall a. Show a => Int -> ForallHeader a -> ShowS
forall a. Show a => [ForallHeader a] -> ShowS
forall a. Show a => ForallHeader a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ForallHeader a] -> ShowS
$cshowList :: forall a. Show a => [ForallHeader a] -> ShowS
show :: ForallHeader a -> String
$cshow :: forall a. Show a => ForallHeader a -> String
showsPrec :: Int -> ForallHeader a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> ForallHeader a -> ShowS
Show, Typeable (ForallHeader a)
Typeable (ForallHeader a)
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ForallHeader a -> c (ForallHeader a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (ForallHeader a))
-> (ForallHeader a -> Constr)
-> (ForallHeader a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (ForallHeader a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (ForallHeader a)))
-> ((forall b. Data b => b -> b)
    -> ForallHeader a -> ForallHeader a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ForallHeader a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ForallHeader a -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> ForallHeader a -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> ForallHeader a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> ForallHeader a -> m (ForallHeader a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> ForallHeader a -> m (ForallHeader a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> ForallHeader a -> m (ForallHeader a))
-> Data (ForallHeader a)
ForallHeader a -> DataType
ForallHeader a -> Constr
(forall b. Data b => b -> b) -> ForallHeader a -> ForallHeader a
forall {a}. Data a => Typeable (ForallHeader a)
forall a. Data a => ForallHeader a -> DataType
forall a. Data a => ForallHeader a -> Constr
forall a.
Data a =>
(forall b. Data b => b -> b) -> ForallHeader a -> ForallHeader a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> ForallHeader a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> ForallHeader a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ForallHeader a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ForallHeader a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d)
-> ForallHeader a -> m (ForallHeader a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> ForallHeader a -> m (ForallHeader a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ForallHeader a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ForallHeader a -> c (ForallHeader a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (ForallHeader a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ForallHeader a))
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) -> ForallHeader a -> u
forall u. (forall d. Data d => d -> u) -> ForallHeader a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ForallHeader a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ForallHeader a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> ForallHeader a -> m (ForallHeader a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ForallHeader a -> m (ForallHeader a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ForallHeader a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ForallHeader a -> c (ForallHeader a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (ForallHeader a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ForallHeader a))
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ForallHeader a -> m (ForallHeader a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> ForallHeader a -> m (ForallHeader a)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ForallHeader a -> m (ForallHeader a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> ForallHeader a -> m (ForallHeader a)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> ForallHeader a -> m (ForallHeader a)
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d)
-> ForallHeader a -> m (ForallHeader a)
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> ForallHeader a -> u
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> ForallHeader a -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> ForallHeader a -> [u]
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> ForallHeader a -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ForallHeader a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ForallHeader a -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ForallHeader a -> r
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ForallHeader a -> r
gmapT :: (forall b. Data b => b -> b) -> ForallHeader a -> ForallHeader a
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b) -> ForallHeader a -> ForallHeader a
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ForallHeader a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ForallHeader a))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (ForallHeader a))
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (ForallHeader a))
dataTypeOf :: ForallHeader a -> DataType
$cdataTypeOf :: forall a. Data a => ForallHeader a -> DataType
toConstr :: ForallHeader a -> Constr
$ctoConstr :: forall a. Data a => ForallHeader a -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ForallHeader a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ForallHeader a)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ForallHeader a -> c (ForallHeader a)
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ForallHeader a -> c (ForallHeader a)
Data, Typeable, (forall x. ForallHeader a -> Rep (ForallHeader a) x)
-> (forall x. Rep (ForallHeader a) x -> ForallHeader a)
-> Generic (ForallHeader a)
forall x. Rep (ForallHeader a) x -> ForallHeader a
forall x. ForallHeader a -> Rep (ForallHeader a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (ForallHeader a) x -> ForallHeader a
forall a x. ForallHeader a -> Rep (ForallHeader a) x
$cto :: forall a x. Rep (ForallHeader a) x -> ForallHeader a
$cfrom :: forall a x. ForallHeader a -> Rep (ForallHeader a) x
Generic, (forall a b. (a -> b) -> ForallHeader a -> ForallHeader b)
-> (forall a b. a -> ForallHeader b -> ForallHeader a)
-> Functor ForallHeader
forall a b. a -> ForallHeader b -> ForallHeader a
forall a b. (a -> b) -> ForallHeader a -> ForallHeader b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: forall a b. a -> ForallHeader b -> ForallHeader a
$c<$ :: forall a b. a -> ForallHeader b -> ForallHeader a
fmap :: forall a b. (a -> b) -> ForallHeader a -> ForallHeader b
$cfmap :: forall a b. (a -> b) -> ForallHeader a -> ForallHeader b
Functor)

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

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

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

-- TODO potentially should throw Maybe String into ArgumentExpression too?
data Argument a = Argument a SrcSpan (Maybe String) (ArgumentExpression a)
  deriving (Argument a -> Argument a -> Bool
(Argument a -> Argument a -> Bool)
-> (Argument a -> Argument a -> Bool) -> Eq (Argument a)
forall a. Eq a => Argument a -> Argument a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Argument a -> Argument a -> Bool
$c/= :: forall a. Eq a => Argument a -> Argument a -> Bool
== :: Argument a -> Argument a -> Bool
$c== :: forall a. Eq a => Argument a -> Argument a -> Bool
Eq, Int -> Argument a -> ShowS
[Argument a] -> ShowS
Argument a -> String
(Int -> Argument a -> ShowS)
-> (Argument a -> String)
-> ([Argument a] -> ShowS)
-> Show (Argument a)
forall a. Show a => Int -> Argument a -> ShowS
forall a. Show a => [Argument a] -> ShowS
forall a. Show a => Argument a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Argument a] -> ShowS
$cshowList :: forall a. Show a => [Argument a] -> ShowS
show :: Argument a -> String
$cshow :: forall a. Show a => Argument a -> String
showsPrec :: Int -> Argument a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> Argument a -> ShowS
Show, Typeable (Argument a)
Typeable (Argument a)
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Argument a -> c (Argument a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Argument a))
-> (Argument a -> Constr)
-> (Argument a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Argument a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Argument a)))
-> ((forall b. Data b => b -> b) -> Argument a -> Argument a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Argument a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Argument a -> r)
-> (forall u. (forall d. Data d => d -> u) -> Argument a -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Argument a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Argument a -> m (Argument a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Argument a -> m (Argument a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Argument a -> m (Argument a))
-> Data (Argument a)
Argument a -> DataType
Argument a -> Constr
(forall b. Data b => b -> b) -> Argument a -> Argument a
forall {a}. Data a => Typeable (Argument a)
forall a. Data a => Argument a -> DataType
forall a. Data a => Argument a -> Constr
forall a.
Data a =>
(forall b. Data b => b -> b) -> Argument a -> Argument a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Argument a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> Argument a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Argument a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Argument a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Argument a -> m (Argument a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Argument a -> m (Argument a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Argument a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Argument a -> c (Argument a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Argument a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Argument a))
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) -> Argument a -> u
forall u. (forall d. Data d => d -> u) -> Argument a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Argument a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Argument a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Argument a -> m (Argument a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Argument a -> m (Argument a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Argument a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Argument a -> c (Argument a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Argument a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Argument a))
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Argument a -> m (Argument a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Argument a -> m (Argument a)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Argument a -> m (Argument a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Argument a -> m (Argument a)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Argument a -> m (Argument a)
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Argument a -> m (Argument a)
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Argument a -> u
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Argument a -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> Argument a -> [u]
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> Argument a -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Argument a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Argument a -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Argument a -> r
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Argument a -> r
gmapT :: (forall b. Data b => b -> b) -> Argument a -> Argument a
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b) -> Argument a -> Argument a
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Argument a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Argument a))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Argument a))
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Argument a))
dataTypeOf :: Argument a -> DataType
$cdataTypeOf :: forall a. Data a => Argument a -> DataType
toConstr :: Argument a -> Constr
$ctoConstr :: forall a. Data a => Argument a -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Argument a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Argument a)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Argument a -> c (Argument a)
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Argument a -> c (Argument a)
Data, Typeable, (forall x. Argument a -> Rep (Argument a) x)
-> (forall x. Rep (Argument a) x -> Argument a)
-> Generic (Argument a)
forall x. Rep (Argument a) x -> Argument a
forall x. Argument a -> Rep (Argument a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (Argument a) x -> Argument a
forall a x. Argument a -> Rep (Argument a) x
$cto :: forall a x. Rep (Argument a) x -> Argument a
$cfrom :: forall a x. Argument a -> Rep (Argument a) x
Generic, (forall a b. (a -> b) -> Argument a -> Argument b)
-> (forall a b. a -> Argument b -> Argument a) -> Functor Argument
forall a b. a -> Argument b -> Argument a
forall a b. (a -> b) -> Argument a -> Argument b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: forall a b. a -> Argument b -> Argument a
$c<$ :: forall a b. a -> Argument b -> Argument a
fmap :: forall a b. (a -> b) -> Argument a -> Argument b
$cfmap :: forall a b. (a -> b) -> Argument a -> Argument b
Functor)

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

argExprNormalize :: ArgumentExpression a -> Expression a
argExprNormalize :: forall a. ArgumentExpression a -> Expression a
argExprNormalize = \case ArgExpr         Expression a
e -> Expression a
e
                         ArgExprVar a
a SrcSpan
ss String
v -> a -> SrcSpan -> Value a -> Expression a
forall a. a -> SrcSpan -> Value a -> Expression a
ExpValue a
a SrcSpan
ss (String -> Value a
forall a. String -> Value a
ValVariable String
v)

argExtractExpr :: Argument a -> Expression a
argExtractExpr :: forall a. Argument a -> Expression a
argExtractExpr (Argument a
_ SrcSpan
_ Maybe String
_ ArgumentExpression a
ae) = ArgumentExpression a -> Expression a
forall a. ArgumentExpression a -> Expression a
argExprNormalize ArgumentExpression a
ae

data Attribute a =
    AttrAllocatable a SrcSpan
  | AttrAsynchronous a SrcSpan
  | AttrDimension a SrcSpan (AList DimensionDeclarator a)
  | AttrExternal a SrcSpan
  | AttrIntent a SrcSpan Intent
  | AttrIntrinsic a SrcSpan
  | AttrOptional a SrcSpan
  | AttrParameter a SrcSpan
  | AttrPointer a SrcSpan
  | AttrPrivate a SrcSpan
  | AttrProtected a SrcSpan
  | AttrPublic a SrcSpan
  | AttrSave a SrcSpan
  | AttrSuffix a SrcSpan (Suffix a)  -- for language-binding-spec
  | AttrTarget a SrcSpan
  | AttrValue a SrcSpan
  | AttrVolatile a SrcSpan
  deriving (Attribute a -> Attribute a -> Bool
(Attribute a -> Attribute a -> Bool)
-> (Attribute a -> Attribute a -> Bool) -> Eq (Attribute a)
forall a. Eq a => Attribute a -> Attribute a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Attribute a -> Attribute a -> Bool
$c/= :: forall a. Eq a => Attribute a -> Attribute a -> Bool
== :: Attribute a -> Attribute a -> Bool
$c== :: forall a. Eq a => Attribute a -> Attribute a -> Bool
Eq, Int -> Attribute a -> ShowS
[Attribute a] -> ShowS
Attribute a -> String
(Int -> Attribute a -> ShowS)
-> (Attribute a -> String)
-> ([Attribute a] -> ShowS)
-> Show (Attribute a)
forall a. Show a => Int -> Attribute a -> ShowS
forall a. Show a => [Attribute a] -> ShowS
forall a. Show a => Attribute a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Attribute a] -> ShowS
$cshowList :: forall a. Show a => [Attribute a] -> ShowS
show :: Attribute a -> String
$cshow :: forall a. Show a => Attribute a -> String
showsPrec :: Int -> Attribute a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> Attribute a -> ShowS
Show, Typeable (Attribute a)
Typeable (Attribute a)
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Attribute a -> c (Attribute a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Attribute a))
-> (Attribute a -> Constr)
-> (Attribute a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Attribute a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Attribute a)))
-> ((forall b. Data b => b -> b) -> Attribute a -> Attribute a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Attribute a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Attribute a -> r)
-> (forall u. (forall d. Data d => d -> u) -> Attribute a -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Attribute a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Attribute a -> m (Attribute a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Attribute a -> m (Attribute a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Attribute a -> m (Attribute a))
-> Data (Attribute a)
Attribute a -> DataType
Attribute a -> Constr
(forall b. Data b => b -> b) -> Attribute a -> Attribute a
forall {a}. Data a => Typeable (Attribute a)
forall a. Data a => Attribute a -> DataType
forall a. Data a => Attribute a -> Constr
forall a.
Data a =>
(forall b. Data b => b -> b) -> Attribute a -> Attribute a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Attribute a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> Attribute a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Attribute a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Attribute a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Attribute a -> m (Attribute a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Attribute a -> m (Attribute a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Attribute a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Attribute a -> c (Attribute a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Attribute a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Attribute a))
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) -> Attribute a -> u
forall u. (forall d. Data d => d -> u) -> Attribute a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Attribute a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Attribute a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Attribute a -> m (Attribute a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Attribute a -> m (Attribute a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Attribute a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Attribute a -> c (Attribute a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Attribute a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Attribute a))
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Attribute a -> m (Attribute a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Attribute a -> m (Attribute a)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Attribute a -> m (Attribute a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Attribute a -> m (Attribute a)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Attribute a -> m (Attribute a)
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Attribute a -> m (Attribute a)
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Attribute a -> u
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Attribute a -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> Attribute a -> [u]
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> Attribute a -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Attribute a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Attribute a -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Attribute a -> r
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Attribute a -> r
gmapT :: (forall b. Data b => b -> b) -> Attribute a -> Attribute a
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b) -> Attribute a -> Attribute a
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Attribute a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Attribute a))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Attribute a))
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Attribute a))
dataTypeOf :: Attribute a -> DataType
$cdataTypeOf :: forall a. Data a => Attribute a -> DataType
toConstr :: Attribute a -> Constr
$ctoConstr :: forall a. Data a => Attribute a -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Attribute a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Attribute a)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Attribute a -> c (Attribute a)
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Attribute a -> c (Attribute a)
Data, Typeable, (forall x. Attribute a -> Rep (Attribute a) x)
-> (forall x. Rep (Attribute a) x -> Attribute a)
-> Generic (Attribute a)
forall x. Rep (Attribute a) x -> Attribute a
forall x. Attribute a -> Rep (Attribute a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (Attribute a) x -> Attribute a
forall a x. Attribute a -> Rep (Attribute a) x
$cto :: forall a x. Rep (Attribute a) x -> Attribute a
$cfrom :: forall a x. Attribute a -> Rep (Attribute a) x
Generic, (forall a b. (a -> b) -> Attribute a -> Attribute b)
-> (forall a b. a -> Attribute b -> Attribute a)
-> Functor Attribute
forall a b. a -> Attribute b -> Attribute a
forall a b. (a -> b) -> Attribute a -> Attribute b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: forall a b. a -> Attribute b -> Attribute a
$c<$ :: forall a b. a -> Attribute b -> Attribute a
fmap :: forall a b. (a -> b) -> Attribute a -> Attribute b
$cfmap :: forall a b. (a -> b) -> Attribute a -> Attribute b
Functor)

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

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

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

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

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

-- | Note that the 'Declarator's in common group definitions do not contain
--   initializing expressions.
data CommonGroup a =
  CommonGroup a SrcSpan (Maybe (Expression a)) (AList Declarator a)
  deriving (CommonGroup a -> CommonGroup a -> Bool
(CommonGroup a -> CommonGroup a -> Bool)
-> (CommonGroup a -> CommonGroup a -> Bool) -> Eq (CommonGroup a)
forall a. Eq a => CommonGroup a -> CommonGroup a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CommonGroup a -> CommonGroup a -> Bool
$c/= :: forall a. Eq a => CommonGroup a -> CommonGroup a -> Bool
== :: CommonGroup a -> CommonGroup a -> Bool
$c== :: forall a. Eq a => CommonGroup a -> CommonGroup a -> Bool
Eq, Int -> CommonGroup a -> ShowS
[CommonGroup a] -> ShowS
CommonGroup a -> String
(Int -> CommonGroup a -> ShowS)
-> (CommonGroup a -> String)
-> ([CommonGroup a] -> ShowS)
-> Show (CommonGroup a)
forall a. Show a => Int -> CommonGroup a -> ShowS
forall a. Show a => [CommonGroup a] -> ShowS
forall a. Show a => CommonGroup a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CommonGroup a] -> ShowS
$cshowList :: forall a. Show a => [CommonGroup a] -> ShowS
show :: CommonGroup a -> String
$cshow :: forall a. Show a => CommonGroup a -> String
showsPrec :: Int -> CommonGroup a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> CommonGroup a -> ShowS
Show, Typeable (CommonGroup a)
Typeable (CommonGroup a)
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> CommonGroup a -> c (CommonGroup a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (CommonGroup a))
-> (CommonGroup a -> Constr)
-> (CommonGroup a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (CommonGroup a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (CommonGroup a)))
-> ((forall b. Data b => b -> b) -> CommonGroup a -> CommonGroup a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> CommonGroup a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> CommonGroup a -> r)
-> (forall u. (forall d. Data d => d -> u) -> CommonGroup a -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> CommonGroup a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> CommonGroup a -> m (CommonGroup a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> CommonGroup a -> m (CommonGroup a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> CommonGroup a -> m (CommonGroup a))
-> Data (CommonGroup a)
CommonGroup a -> DataType
CommonGroup a -> Constr
(forall b. Data b => b -> b) -> CommonGroup a -> CommonGroup a
forall {a}. Data a => Typeable (CommonGroup a)
forall a. Data a => CommonGroup a -> DataType
forall a. Data a => CommonGroup a -> Constr
forall a.
Data a =>
(forall b. Data b => b -> b) -> CommonGroup a -> CommonGroup a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> CommonGroup a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> CommonGroup a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CommonGroup a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CommonGroup a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d)
-> CommonGroup a -> m (CommonGroup a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> CommonGroup a -> m (CommonGroup a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (CommonGroup a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CommonGroup a -> c (CommonGroup a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (CommonGroup a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (CommonGroup a))
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) -> CommonGroup a -> u
forall u. (forall d. Data d => d -> u) -> CommonGroup a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CommonGroup a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CommonGroup a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> CommonGroup a -> m (CommonGroup a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> CommonGroup a -> m (CommonGroup a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (CommonGroup a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CommonGroup a -> c (CommonGroup a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (CommonGroup a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (CommonGroup a))
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> CommonGroup a -> m (CommonGroup a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> CommonGroup a -> m (CommonGroup a)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> CommonGroup a -> m (CommonGroup a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> CommonGroup a -> m (CommonGroup a)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> CommonGroup a -> m (CommonGroup a)
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d)
-> CommonGroup a -> m (CommonGroup a)
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> CommonGroup a -> u
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> CommonGroup a -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> CommonGroup a -> [u]
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> CommonGroup a -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CommonGroup a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CommonGroup a -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CommonGroup a -> r
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CommonGroup a -> r
gmapT :: (forall b. Data b => b -> b) -> CommonGroup a -> CommonGroup a
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b) -> CommonGroup a -> CommonGroup a
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (CommonGroup a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (CommonGroup a))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (CommonGroup a))
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (CommonGroup a))
dataTypeOf :: CommonGroup a -> DataType
$cdataTypeOf :: forall a. Data a => CommonGroup a -> DataType
toConstr :: CommonGroup a -> Constr
$ctoConstr :: forall a. Data a => CommonGroup a -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (CommonGroup a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (CommonGroup a)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CommonGroup a -> c (CommonGroup a)
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CommonGroup a -> c (CommonGroup a)
Data, Typeable, (forall x. CommonGroup a -> Rep (CommonGroup a) x)
-> (forall x. Rep (CommonGroup a) x -> CommonGroup a)
-> Generic (CommonGroup a)
forall x. Rep (CommonGroup a) x -> CommonGroup a
forall x. CommonGroup a -> Rep (CommonGroup a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (CommonGroup a) x -> CommonGroup a
forall a x. CommonGroup a -> Rep (CommonGroup a) x
$cto :: forall a x. Rep (CommonGroup a) x -> CommonGroup a
$cfrom :: forall a x. CommonGroup a -> Rep (CommonGroup a) x
Generic, (forall a b. (a -> b) -> CommonGroup a -> CommonGroup b)
-> (forall a b. a -> CommonGroup b -> CommonGroup a)
-> Functor CommonGroup
forall a b. a -> CommonGroup b -> CommonGroup a
forall a b. (a -> b) -> CommonGroup a -> CommonGroup b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: forall a b. a -> CommonGroup b -> CommonGroup a
$c<$ :: forall a b. a -> CommonGroup b -> CommonGroup a
fmap :: forall a b. (a -> b) -> CommonGroup a -> CommonGroup b
$cfmap :: forall a b. (a -> b) -> CommonGroup a -> CommonGroup b
Functor)

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

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

data StructureItem a =
    StructFields a SrcSpan (TypeSpec a) (Maybe (AList Attribute a)) (AList Declarator a)
  | StructUnion a SrcSpan (AList UnionMap a)
  | StructStructure a SrcSpan (Maybe String) String (AList StructureItem a)
  deriving (StructureItem a -> StructureItem a -> Bool
(StructureItem a -> StructureItem a -> Bool)
-> (StructureItem a -> StructureItem a -> Bool)
-> Eq (StructureItem a)
forall a. Eq a => StructureItem a -> StructureItem a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: StructureItem a -> StructureItem a -> Bool
$c/= :: forall a. Eq a => StructureItem a -> StructureItem a -> Bool
== :: StructureItem a -> StructureItem a -> Bool
$c== :: forall a. Eq a => StructureItem a -> StructureItem a -> Bool
Eq, Int -> StructureItem a -> ShowS
[StructureItem a] -> ShowS
StructureItem a -> String
(Int -> StructureItem a -> ShowS)
-> (StructureItem a -> String)
-> ([StructureItem a] -> ShowS)
-> Show (StructureItem a)
forall a. Show a => Int -> StructureItem a -> ShowS
forall a. Show a => [StructureItem a] -> ShowS
forall a. Show a => StructureItem a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [StructureItem a] -> ShowS
$cshowList :: forall a. Show a => [StructureItem a] -> ShowS
show :: StructureItem a -> String
$cshow :: forall a. Show a => StructureItem a -> String
showsPrec :: Int -> StructureItem a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> StructureItem a -> ShowS
Show, Typeable (StructureItem a)
Typeable (StructureItem a)
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> StructureItem a -> c (StructureItem a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (StructureItem a))
-> (StructureItem a -> Constr)
-> (StructureItem a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (StructureItem a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (StructureItem a)))
-> ((forall b. Data b => b -> b)
    -> StructureItem a -> StructureItem a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> StructureItem a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> StructureItem a -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> StructureItem a -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> StructureItem a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> StructureItem a -> m (StructureItem a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> StructureItem a -> m (StructureItem a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> StructureItem a -> m (StructureItem a))
-> Data (StructureItem a)
StructureItem a -> DataType
StructureItem a -> Constr
(forall b. Data b => b -> b) -> StructureItem a -> StructureItem a
forall {a}. Data a => Typeable (StructureItem a)
forall a. Data a => StructureItem a -> DataType
forall a. Data a => StructureItem a -> Constr
forall a.
Data a =>
(forall b. Data b => b -> b) -> StructureItem a -> StructureItem a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> StructureItem a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> StructureItem a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> StructureItem a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> StructureItem a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d)
-> StructureItem a -> m (StructureItem a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> StructureItem a -> m (StructureItem a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (StructureItem a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> StructureItem a -> c (StructureItem a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (StructureItem a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (StructureItem a))
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) -> StructureItem a -> u
forall u. (forall d. Data d => d -> u) -> StructureItem a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> StructureItem a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> StructureItem a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> StructureItem a -> m (StructureItem a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> StructureItem a -> m (StructureItem a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (StructureItem a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> StructureItem a -> c (StructureItem a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (StructureItem a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (StructureItem a))
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> StructureItem a -> m (StructureItem a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> StructureItem a -> m (StructureItem a)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> StructureItem a -> m (StructureItem a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> StructureItem a -> m (StructureItem a)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> StructureItem a -> m (StructureItem a)
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d)
-> StructureItem a -> m (StructureItem a)
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> StructureItem a -> u
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> StructureItem a -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> StructureItem a -> [u]
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> StructureItem a -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> StructureItem a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> StructureItem a -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> StructureItem a -> r
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> StructureItem a -> r
gmapT :: (forall b. Data b => b -> b) -> StructureItem a -> StructureItem a
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b) -> StructureItem a -> StructureItem a
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (StructureItem a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (StructureItem a))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (StructureItem a))
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (StructureItem a))
dataTypeOf :: StructureItem a -> DataType
$cdataTypeOf :: forall a. Data a => StructureItem a -> DataType
toConstr :: StructureItem a -> Constr
$ctoConstr :: forall a. Data a => StructureItem a -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (StructureItem a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (StructureItem a)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> StructureItem a -> c (StructureItem a)
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> StructureItem a -> c (StructureItem a)
Data, Typeable, (forall x. StructureItem a -> Rep (StructureItem a) x)
-> (forall x. Rep (StructureItem a) x -> StructureItem a)
-> Generic (StructureItem a)
forall x. Rep (StructureItem a) x -> StructureItem a
forall x. StructureItem a -> Rep (StructureItem a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (StructureItem a) x -> StructureItem a
forall a x. StructureItem a -> Rep (StructureItem a) x
$cto :: forall a x. Rep (StructureItem a) x -> StructureItem a
$cfrom :: forall a x. StructureItem a -> Rep (StructureItem a) x
Generic, (forall a b. (a -> b) -> StructureItem a -> StructureItem b)
-> (forall a b. a -> StructureItem b -> StructureItem a)
-> Functor StructureItem
forall a b. a -> StructureItem b -> StructureItem a
forall a b. (a -> b) -> StructureItem a -> StructureItem b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: forall a b. a -> StructureItem b -> StructureItem a
$c<$ :: forall a b. a -> StructureItem b -> StructureItem a
fmap :: forall a b. (a -> b) -> StructureItem a -> StructureItem b
$cfmap :: forall a b. (a -> b) -> StructureItem a -> StructureItem b
Functor)

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

data FormatItem a =
    FIFormatList            a             SrcSpan   (Maybe String) (AList FormatItem a)
  | FIHollerith             a             SrcSpan   (Value a)
  | FIDelimiter             a             SrcSpan
--  descriptor type       | annotation  | span    | repeat          | descriptor  | width   | integer
  | FIFieldDescriptorDEFG   a             SrcSpan   (Maybe Integer)   Char          Integer   Integer
  | FIFieldDescriptorAIL    a             SrcSpan   (Maybe Integer)   Char          Integer
  | FIBlankDescriptor       a             SrcSpan   Integer
  | FIScaleFactor           a             SrcSpan   Integer
  deriving (FormatItem a -> FormatItem a -> Bool
(FormatItem a -> FormatItem a -> Bool)
-> (FormatItem a -> FormatItem a -> Bool) -> Eq (FormatItem a)
forall a. Eq a => FormatItem a -> FormatItem a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: FormatItem a -> FormatItem a -> Bool
$c/= :: forall a. Eq a => FormatItem a -> FormatItem a -> Bool
== :: FormatItem a -> FormatItem a -> Bool
$c== :: forall a. Eq a => FormatItem a -> FormatItem a -> Bool
Eq, Int -> FormatItem a -> ShowS
[FormatItem a] -> ShowS
FormatItem a -> String
(Int -> FormatItem a -> ShowS)
-> (FormatItem a -> String)
-> ([FormatItem a] -> ShowS)
-> Show (FormatItem a)
forall a. Show a => Int -> FormatItem a -> ShowS
forall a. Show a => [FormatItem a] -> ShowS
forall a. Show a => FormatItem a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [FormatItem a] -> ShowS
$cshowList :: forall a. Show a => [FormatItem a] -> ShowS
show :: FormatItem a -> String
$cshow :: forall a. Show a => FormatItem a -> String
showsPrec :: Int -> FormatItem a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> FormatItem a -> ShowS
Show, Typeable (FormatItem a)
Typeable (FormatItem a)
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> FormatItem a -> c (FormatItem a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (FormatItem a))
-> (FormatItem a -> Constr)
-> (FormatItem a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (FormatItem a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (FormatItem a)))
-> ((forall b. Data b => b -> b) -> FormatItem a -> FormatItem a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> FormatItem a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> FormatItem a -> r)
-> (forall u. (forall d. Data d => d -> u) -> FormatItem a -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> FormatItem a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> FormatItem a -> m (FormatItem a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> FormatItem a -> m (FormatItem a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> FormatItem a -> m (FormatItem a))
-> Data (FormatItem a)
FormatItem a -> DataType
FormatItem a -> Constr
(forall b. Data b => b -> b) -> FormatItem a -> FormatItem a
forall {a}. Data a => Typeable (FormatItem a)
forall a. Data a => FormatItem a -> DataType
forall a. Data a => FormatItem a -> Constr
forall a.
Data a =>
(forall b. Data b => b -> b) -> FormatItem a -> FormatItem a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> FormatItem a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> FormatItem a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FormatItem a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FormatItem a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> FormatItem a -> m (FormatItem a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> FormatItem a -> m (FormatItem a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (FormatItem a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FormatItem a -> c (FormatItem a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (FormatItem a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (FormatItem a))
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) -> FormatItem a -> u
forall u. (forall d. Data d => d -> u) -> FormatItem a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FormatItem a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FormatItem a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> FormatItem a -> m (FormatItem a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FormatItem a -> m (FormatItem a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (FormatItem a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FormatItem a -> c (FormatItem a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (FormatItem a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (FormatItem a))
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FormatItem a -> m (FormatItem a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> FormatItem a -> m (FormatItem a)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FormatItem a -> m (FormatItem a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> FormatItem a -> m (FormatItem a)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> FormatItem a -> m (FormatItem a)
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> FormatItem a -> m (FormatItem a)
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> FormatItem a -> u
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> FormatItem a -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> FormatItem a -> [u]
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> FormatItem a -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FormatItem a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FormatItem a -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FormatItem a -> r
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FormatItem a -> r
gmapT :: (forall b. Data b => b -> b) -> FormatItem a -> FormatItem a
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b) -> FormatItem a -> FormatItem a
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (FormatItem a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (FormatItem a))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (FormatItem a))
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (FormatItem a))
dataTypeOf :: FormatItem a -> DataType
$cdataTypeOf :: forall a. Data a => FormatItem a -> DataType
toConstr :: FormatItem a -> Constr
$ctoConstr :: forall a. Data a => FormatItem a -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (FormatItem a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (FormatItem a)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FormatItem a -> c (FormatItem a)
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FormatItem a -> c (FormatItem a)
Data, Typeable, (forall x. FormatItem a -> Rep (FormatItem a) x)
-> (forall x. Rep (FormatItem a) x -> FormatItem a)
-> Generic (FormatItem a)
forall x. Rep (FormatItem a) x -> FormatItem a
forall x. FormatItem a -> Rep (FormatItem a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (FormatItem a) x -> FormatItem a
forall a x. FormatItem a -> Rep (FormatItem a) x
$cto :: forall a x. Rep (FormatItem a) x -> FormatItem a
$cfrom :: forall a x. FormatItem a -> Rep (FormatItem a) x
Generic, (forall a b. (a -> b) -> FormatItem a -> FormatItem b)
-> (forall a b. a -> FormatItem b -> FormatItem a)
-> Functor FormatItem
forall a b. a -> FormatItem b -> FormatItem a
forall a b. (a -> b) -> FormatItem a -> FormatItem b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: forall a b. a -> FormatItem b -> FormatItem a
$c<$ :: forall a b. a -> FormatItem b -> FormatItem a
fmap :: forall a b. (a -> b) -> FormatItem a -> FormatItem b
$cfmap :: forall a b. (a -> b) -> FormatItem a -> FormatItem b
Functor)

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

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

data Expression a =
    ExpValue         a SrcSpan (Value a)
  -- ^ Use a value as an expression.
  | ExpBinary        a SrcSpan BinaryOp (Expression a) (Expression a)
  -- ^ A binary operator applied to two expressions.
  | ExpUnary         a SrcSpan UnaryOp (Expression a)
  -- ^ A unary operator applied to one expression.
  | ExpSubscript     a SrcSpan (Expression a) (AList Index a)
  -- ^ Array indexing
  | ExpDataRef       a SrcSpan (Expression a) (Expression a)
  -- ^ @%@ notation for variables inside data types
  | ExpFunctionCall  a SrcSpan (Expression a) (Maybe (AList Argument a))
  -- ^ A function expression applied to a list of arguments.
  | ExpImpliedDo     a SrcSpan (AList Expression a) (DoSpecification a)
  -- ^ Implied do (i.e. one-liner do loops)
  | ExpInitialisation  a SrcSpan (AList Expression a)
  -- ^ Array initialisation
  | ExpReturnSpec    a SrcSpan (Expression a)
  -- ^ Function return value specification
  deriving (Expression a -> Expression a -> Bool
(Expression a -> Expression a -> Bool)
-> (Expression a -> Expression a -> Bool) -> Eq (Expression a)
forall a. Eq a => Expression a -> Expression a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Expression a -> Expression a -> Bool
$c/= :: forall a. Eq a => Expression a -> Expression a -> Bool
== :: Expression a -> Expression a -> Bool
$c== :: forall a. Eq a => Expression a -> Expression a -> Bool
Eq, Int -> Expression a -> ShowS
[Expression a] -> ShowS
Expression a -> String
(Int -> Expression a -> ShowS)
-> (Expression a -> String)
-> ([Expression a] -> ShowS)
-> Show (Expression a)
forall a. Show a => Int -> Expression a -> ShowS
forall a. Show a => [Expression a] -> ShowS
forall a. Show a => Expression a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Expression a] -> ShowS
$cshowList :: forall a. Show a => [Expression a] -> ShowS
show :: Expression a -> String
$cshow :: forall a. Show a => Expression a -> String
showsPrec :: Int -> Expression a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> Expression a -> ShowS
Show, Typeable (Expression a)
Typeable (Expression a)
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Expression a -> c (Expression a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Expression a))
-> (Expression a -> Constr)
-> (Expression a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Expression a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Expression a)))
-> ((forall b. Data b => b -> b) -> Expression a -> Expression a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Expression a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Expression a -> r)
-> (forall u. (forall d. Data d => d -> u) -> Expression a -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Expression a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Expression a -> m (Expression a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Expression a -> m (Expression a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Expression a -> m (Expression a))
-> Data (Expression a)
Expression a -> DataType
Expression a -> Constr
(forall b. Data b => b -> b) -> Expression a -> Expression a
forall {a}. Data a => Typeable (Expression a)
forall a. Data a => Expression a -> DataType
forall a. Data a => Expression a -> Constr
forall a.
Data a =>
(forall b. Data b => b -> b) -> Expression a -> Expression a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Expression a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> Expression a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Expression a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Expression a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Expression a -> m (Expression a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Expression a -> m (Expression a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Expression a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Expression a -> c (Expression a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Expression a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Expression a))
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) -> Expression a -> u
forall u. (forall d. Data d => d -> u) -> Expression a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Expression a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Expression a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Expression a -> m (Expression a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Expression a -> m (Expression a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Expression a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Expression a -> c (Expression a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Expression a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Expression a))
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Expression a -> m (Expression a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Expression a -> m (Expression a)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Expression a -> m (Expression a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Expression a -> m (Expression a)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Expression a -> m (Expression a)
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Expression a -> m (Expression a)
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Expression a -> u
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Expression a -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> Expression a -> [u]
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> Expression a -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Expression a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Expression a -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Expression a -> r
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Expression a -> r
gmapT :: (forall b. Data b => b -> b) -> Expression a -> Expression a
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b) -> Expression a -> Expression a
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Expression a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Expression a))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Expression a))
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Expression a))
dataTypeOf :: Expression a -> DataType
$cdataTypeOf :: forall a. Data a => Expression a -> DataType
toConstr :: Expression a -> Constr
$ctoConstr :: forall a. Data a => Expression a -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Expression a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Expression a)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Expression a -> c (Expression a)
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Expression a -> c (Expression a)
Data, Typeable, (forall x. Expression a -> Rep (Expression a) x)
-> (forall x. Rep (Expression a) x -> Expression a)
-> Generic (Expression a)
forall x. Rep (Expression a) x -> Expression a
forall x. Expression a -> Rep (Expression a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (Expression a) x -> Expression a
forall a x. Expression a -> Rep (Expression a) x
$cto :: forall a x. Rep (Expression a) x -> Expression a
$cfrom :: forall a x. Expression a -> Rep (Expression a) x
Generic, (forall a b. (a -> b) -> Expression a -> Expression b)
-> (forall a b. a -> Expression b -> Expression a)
-> Functor Expression
forall a b. a -> Expression b -> Expression a
forall a b. (a -> b) -> Expression a -> Expression b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: forall a b. a -> Expression b -> Expression a
$c<$ :: forall a b. a -> Expression b -> Expression a
fmap :: forall a b. (a -> b) -> Expression a -> Expression b
$cfmap :: forall a b. (a -> b) -> Expression a -> Expression b
Functor)

data Index a =
    IxSingle a SrcSpan (Maybe String) (Expression a)
  | IxRange a SrcSpan
            (Maybe (Expression a)) -- ^ Lower index
            (Maybe (Expression a)) -- ^ Upper index
            (Maybe (Expression a)) -- ^ Stride
  deriving (Index a -> Index a -> Bool
(Index a -> Index a -> Bool)
-> (Index a -> Index a -> Bool) -> Eq (Index a)
forall a. Eq a => Index a -> Index a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Index a -> Index a -> Bool
$c/= :: forall a. Eq a => Index a -> Index a -> Bool
== :: Index a -> Index a -> Bool
$c== :: forall a. Eq a => Index a -> Index a -> Bool
Eq, Int -> Index a -> ShowS
[Index a] -> ShowS
Index a -> String
(Int -> Index a -> ShowS)
-> (Index a -> String) -> ([Index a] -> ShowS) -> Show (Index a)
forall a. Show a => Int -> Index a -> ShowS
forall a. Show a => [Index a] -> ShowS
forall a. Show a => Index a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Index a] -> ShowS
$cshowList :: forall a. Show a => [Index a] -> ShowS
show :: Index a -> String
$cshow :: forall a. Show a => Index a -> String
showsPrec :: Int -> Index a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> Index a -> ShowS
Show, Typeable (Index a)
Typeable (Index a)
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Index a -> c (Index a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Index a))
-> (Index a -> Constr)
-> (Index a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Index a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Index a)))
-> ((forall b. Data b => b -> b) -> Index a -> Index a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Index a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Index a -> r)
-> (forall u. (forall d. Data d => d -> u) -> Index a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Index a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Index a -> m (Index a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Index a -> m (Index a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Index a -> m (Index a))
-> Data (Index a)
Index a -> DataType
Index a -> Constr
(forall b. Data b => b -> b) -> Index a -> Index a
forall {a}. Data a => Typeable (Index a)
forall a. Data a => Index a -> DataType
forall a. Data a => Index a -> Constr
forall a.
Data a =>
(forall b. Data b => b -> b) -> Index a -> Index a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Index a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> Index a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Index a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Index a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Index a -> m (Index a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Index a -> m (Index a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Index a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Index a -> c (Index a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Index a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Index a))
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) -> Index a -> u
forall u. (forall d. Data d => d -> u) -> Index a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Index a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Index a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Index a -> m (Index a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Index a -> m (Index a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Index a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Index a -> c (Index a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Index a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Index a))
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Index a -> m (Index a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Index a -> m (Index a)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Index a -> m (Index a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Index a -> m (Index a)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Index a -> m (Index a)
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Index a -> m (Index a)
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Index a -> u
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Index a -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> Index a -> [u]
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> Index a -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Index a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Index a -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Index a -> r
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Index a -> r
gmapT :: (forall b. Data b => b -> b) -> Index a -> Index a
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b) -> Index a -> Index a
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Index a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Index a))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Index a))
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Index a))
dataTypeOf :: Index a -> DataType
$cdataTypeOf :: forall a. Data a => Index a -> DataType
toConstr :: Index a -> Constr
$ctoConstr :: forall a. Data a => Index a -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Index a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Index a)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Index a -> c (Index a)
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Index a -> c (Index a)
Data, Typeable, (forall x. Index a -> Rep (Index a) x)
-> (forall x. Rep (Index a) x -> Index a) -> Generic (Index a)
forall x. Rep (Index a) x -> Index a
forall x. Index a -> Rep (Index a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (Index a) x -> Index a
forall a x. Index a -> Rep (Index a) x
$cto :: forall a x. Rep (Index a) x -> Index a
$cfrom :: forall a x. Index a -> Rep (Index a) x
Generic, (forall a b. (a -> b) -> Index a -> Index b)
-> (forall a b. a -> Index b -> Index a) -> Functor Index
forall a b. a -> Index b -> Index a
forall a b. (a -> b) -> Index a -> Index b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: forall a b. a -> Index b -> Index a
$c<$ :: forall a b. a -> Index b -> Index a
fmap :: forall a b. (a -> b) -> Index a -> Index b
$cfmap :: forall a b. (a -> b) -> Index a -> Index b
Functor)

-- All recursive Values
data Value a
  = ValInteger           String (Maybe (Expression a))
  -- ^ The string representation of an integer literal
  | ValReal              RealLit (Maybe (Expression a))
  -- ^ The string representation of a real literal
  | ValComplex           (Expression a) (Expression a)
  -- ^ The real and imaginary parts of a complex value
  | ValString            String
  -- ^ A string literal
  | ValBoz               Boz
  -- ^ A BOZ literal constant
  | ValHollerith         String
  -- ^ A Hollerith literal
  | ValVariable          Name
  -- ^ The name of a variable
  | ValIntrinsic         Name
  -- ^ The name of a built-in function
  | ValLogical           Bool (Maybe (Expression a))
  -- ^ A boolean value
  | ValOperator          String
  -- ^ User-defined operators in interfaces
  | ValAssignment
  -- ^ Overloaded assignment in interfaces
  | ValType              String
  | ValStar
  | ValColon                   -- see R402 / C403 in Fortran2003 spec.
  deriving (Value a -> Value a -> Bool
(Value a -> Value a -> Bool)
-> (Value a -> Value a -> Bool) -> Eq (Value a)
forall a. Eq a => Value a -> Value a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Value a -> Value a -> Bool
$c/= :: forall a. Eq a => Value a -> Value a -> Bool
== :: Value a -> Value a -> Bool
$c== :: forall a. Eq a => Value a -> Value a -> Bool
Eq, Int -> Value a -> ShowS
[Value a] -> ShowS
Value a -> String
(Int -> Value a -> ShowS)
-> (Value a -> String) -> ([Value a] -> ShowS) -> Show (Value a)
forall a. Show a => Int -> Value a -> ShowS
forall a. Show a => [Value a] -> ShowS
forall a. Show a => Value a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Value a] -> ShowS
$cshowList :: forall a. Show a => [Value a] -> ShowS
show :: Value a -> String
$cshow :: forall a. Show a => Value a -> String
showsPrec :: Int -> Value a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> Value a -> ShowS
Show, Typeable (Value a)
Typeable (Value a)
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Value a -> c (Value a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Value a))
-> (Value a -> Constr)
-> (Value a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Value a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Value a)))
-> ((forall b. Data b => b -> b) -> Value a -> Value a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Value a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Value a -> r)
-> (forall u. (forall d. Data d => d -> u) -> Value a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Value a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Value a -> m (Value a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Value a -> m (Value a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Value a -> m (Value a))
-> Data (Value a)
Value a -> DataType
Value a -> Constr
(forall b. Data b => b -> b) -> Value a -> Value a
forall {a}. Data a => Typeable (Value a)
forall a. Data a => Value a -> DataType
forall a. Data a => Value a -> Constr
forall a.
Data a =>
(forall b. Data b => b -> b) -> Value a -> Value a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Value a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> Value a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Value a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Value a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Value a -> m (Value a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Value a -> m (Value a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Value a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Value a -> c (Value a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Value a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Value a))
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) -> Value a -> u
forall u. (forall d. Data d => d -> u) -> Value a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Value a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Value a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Value a -> m (Value a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Value a -> m (Value a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Value a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Value a -> c (Value a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Value a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Value a))
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Value a -> m (Value a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Value a -> m (Value a)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Value a -> m (Value a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Value a -> m (Value a)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Value a -> m (Value a)
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Value a -> m (Value a)
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Value a -> u
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Value a -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> Value a -> [u]
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> Value a -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Value a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Value a -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Value a -> r
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Value a -> r
gmapT :: (forall b. Data b => b -> b) -> Value a -> Value a
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b) -> Value a -> Value a
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Value a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Value a))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Value a))
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Value a))
dataTypeOf :: Value a -> DataType
$cdataTypeOf :: forall a. Data a => Value a -> DataType
toConstr :: Value a -> Constr
$ctoConstr :: forall a. Data a => Value a -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Value a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Value a)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Value a -> c (Value a)
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Value a -> c (Value a)
Data, Typeable, (forall x. Value a -> Rep (Value a) x)
-> (forall x. Rep (Value a) x -> Value a) -> Generic (Value a)
forall x. Rep (Value a) x -> Value a
forall x. Value a -> Rep (Value a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (Value a) x -> Value a
forall a x. Value a -> Rep (Value a) x
$cto :: forall a x. Rep (Value a) x -> Value a
$cfrom :: forall a x. Value a -> Rep (Value a) x
Generic, (forall a b. (a -> b) -> Value a -> Value b)
-> (forall a b. a -> Value b -> Value a) -> Functor Value
forall a b. a -> Value b -> Value a
forall a b. (a -> b) -> Value a -> Value b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: forall a b. a -> Value b -> Value a
$c<$ :: forall a b. a -> Value b -> Value a
fmap :: forall a b. (a -> b) -> Value a -> Value b
$cfmap :: forall a b. (a -> b) -> Value a -> Value b
Functor)

-- | Declarators. R505 entity-decl from F90 ISO spec.
--
-- Declaration statements can have multiple variables on the right of the double
-- colon, separated by commas. A 'Declarator' identifies a single one of these.
-- In F90, they look like this:
--
--     VAR_NAME ( OPT_ARRAY_DIMS ) * CHAR_LENGTH_EXPR = INIT_EXPR
--
-- F77 doesn't standardize so nicely -- in particular, I'm not confident in
-- initializing expression syntax. So no example.
--
-- Only CHARACTERs may specify a length. However, a nonstandard syntax feature
-- uses non-CHARACTER lengths as a kind parameter. We parse regardless of type
-- and warn during analysis.
data Declarator a
  = Declarator a SrcSpan
               (Expression a)         -- ^ Variable
               (DeclaratorType a)     -- ^ Declarator type (dimensions if array)
               (Maybe (Expression a)) -- ^ Length (character)
               (Maybe (Expression a)) -- ^ Initial value
  deriving (Declarator a -> Declarator a -> Bool
(Declarator a -> Declarator a -> Bool)
-> (Declarator a -> Declarator a -> Bool) -> Eq (Declarator a)
forall a. Eq a => Declarator a -> Declarator a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Declarator a -> Declarator a -> Bool
$c/= :: forall a. Eq a => Declarator a -> Declarator a -> Bool
== :: Declarator a -> Declarator a -> Bool
$c== :: forall a. Eq a => Declarator a -> Declarator a -> Bool
Eq, Int -> Declarator a -> ShowS
[Declarator a] -> ShowS
Declarator a -> String
(Int -> Declarator a -> ShowS)
-> (Declarator a -> String)
-> ([Declarator a] -> ShowS)
-> Show (Declarator a)
forall a. Show a => Int -> Declarator a -> ShowS
forall a. Show a => [Declarator a] -> ShowS
forall a. Show a => Declarator a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Declarator a] -> ShowS
$cshowList :: forall a. Show a => [Declarator a] -> ShowS
show :: Declarator a -> String
$cshow :: forall a. Show a => Declarator a -> String
showsPrec :: Int -> Declarator a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> Declarator a -> ShowS
Show, Typeable (Declarator a)
Typeable (Declarator a)
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Declarator a -> c (Declarator a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Declarator a))
-> (Declarator a -> Constr)
-> (Declarator a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Declarator a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Declarator a)))
-> ((forall b. Data b => b -> b) -> Declarator a -> Declarator a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Declarator a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Declarator a -> r)
-> (forall u. (forall d. Data d => d -> u) -> Declarator a -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Declarator a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Declarator a -> m (Declarator a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Declarator a -> m (Declarator a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Declarator a -> m (Declarator a))
-> Data (Declarator a)
Declarator a -> DataType
Declarator a -> Constr
(forall b. Data b => b -> b) -> Declarator a -> Declarator a
forall {a}. Data a => Typeable (Declarator a)
forall a. Data a => Declarator a -> DataType
forall a. Data a => Declarator a -> Constr
forall a.
Data a =>
(forall b. Data b => b -> b) -> Declarator a -> Declarator a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Declarator a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> Declarator a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Declarator a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Declarator a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Declarator a -> m (Declarator a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Declarator a -> m (Declarator a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Declarator a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Declarator a -> c (Declarator a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Declarator a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Declarator a))
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) -> Declarator a -> u
forall u. (forall d. Data d => d -> u) -> Declarator a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Declarator a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Declarator a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Declarator a -> m (Declarator a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Declarator a -> m (Declarator a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Declarator a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Declarator a -> c (Declarator a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Declarator a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Declarator a))
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Declarator a -> m (Declarator a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Declarator a -> m (Declarator a)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Declarator a -> m (Declarator a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Declarator a -> m (Declarator a)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Declarator a -> m (Declarator a)
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Declarator a -> m (Declarator a)
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Declarator a -> u
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Declarator a -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> Declarator a -> [u]
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> Declarator a -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Declarator a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Declarator a -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Declarator a -> r
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Declarator a -> r
gmapT :: (forall b. Data b => b -> b) -> Declarator a -> Declarator a
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b) -> Declarator a -> Declarator a
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Declarator a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Declarator a))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Declarator a))
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Declarator a))
dataTypeOf :: Declarator a -> DataType
$cdataTypeOf :: forall a. Data a => Declarator a -> DataType
toConstr :: Declarator a -> Constr
$ctoConstr :: forall a. Data a => Declarator a -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Declarator a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Declarator a)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Declarator a -> c (Declarator a)
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Declarator a -> c (Declarator a)
Data, Typeable, (forall x. Declarator a -> Rep (Declarator a) x)
-> (forall x. Rep (Declarator a) x -> Declarator a)
-> Generic (Declarator a)
forall x. Rep (Declarator a) x -> Declarator a
forall x. Declarator a -> Rep (Declarator a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (Declarator a) x -> Declarator a
forall a x. Declarator a -> Rep (Declarator a) x
$cto :: forall a x. Rep (Declarator a) x -> Declarator a
$cfrom :: forall a x. Declarator a -> Rep (Declarator a) x
Generic, (forall a b. (a -> b) -> Declarator a -> Declarator b)
-> (forall a b. a -> Declarator b -> Declarator a)
-> Functor Declarator
forall a b. a -> Declarator b -> Declarator a
forall a b. (a -> b) -> Declarator a -> Declarator b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: forall a b. a -> Declarator b -> Declarator a
$c<$ :: forall a b. a -> Declarator b -> Declarator a
fmap :: forall a b. (a -> b) -> Declarator a -> Declarator b
$cfmap :: forall a b. (a -> b) -> Declarator a -> Declarator b
Functor)

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

declaratorType :: Declarator a -> DeclaratorType a
declaratorType :: forall a. Declarator a -> DeclaratorType a
declaratorType (Declarator a
_ SrcSpan
_ Expression a
_ DeclaratorType a
dt Maybe (Expression a)
_ Maybe (Expression a)
_) = DeclaratorType a
dt

-- | Set a 'Declarator''s initializing expression only if it has none already.
setInitialisation :: Declarator a -> Expression a -> Declarator a
setInitialisation :: forall a. Declarator a -> Expression a -> Declarator a
setInitialisation (Declarator a
a SrcSpan
s Expression a
v DeclaratorType a
dt Maybe (Expression a)
l Maybe (Expression a)
Nothing) Expression a
init =
  a
-> SrcSpan
-> Expression a
-> DeclaratorType a
-> Maybe (Expression a)
-> Maybe (Expression a)
-> Declarator a
forall a.
a
-> SrcSpan
-> Expression a
-> DeclaratorType a
-> Maybe (Expression a)
-> Maybe (Expression a)
-> Declarator a
Declarator a
a (SrcSpan -> Expression a -> SrcSpan
forall a b. SpannedPair a b => a -> b -> SrcSpan
getTransSpan SrcSpan
s Expression a
init) Expression a
v DeclaratorType a
dt Maybe (Expression a)
l (Expression a -> Maybe (Expression a)
forall a. a -> Maybe a
Just Expression a
init)
setInitialisation Declarator a
d Expression a
_ = Declarator a
d

-- | Dimension declarator stored in @dimension@ attributes and 'Declarator's.
data DimensionDeclarator a =
  DimensionDeclarator a SrcSpan (Maybe (Expression a)) (Maybe (Expression a))
  deriving (DimensionDeclarator a -> DimensionDeclarator a -> Bool
(DimensionDeclarator a -> DimensionDeclarator a -> Bool)
-> (DimensionDeclarator a -> DimensionDeclarator a -> Bool)
-> Eq (DimensionDeclarator a)
forall a.
Eq a =>
DimensionDeclarator a -> DimensionDeclarator a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DimensionDeclarator a -> DimensionDeclarator a -> Bool
$c/= :: forall a.
Eq a =>
DimensionDeclarator a -> DimensionDeclarator a -> Bool
== :: DimensionDeclarator a -> DimensionDeclarator a -> Bool
$c== :: forall a.
Eq a =>
DimensionDeclarator a -> DimensionDeclarator a -> Bool
Eq, Int -> DimensionDeclarator a -> ShowS
[DimensionDeclarator a] -> ShowS
DimensionDeclarator a -> String
(Int -> DimensionDeclarator a -> ShowS)
-> (DimensionDeclarator a -> String)
-> ([DimensionDeclarator a] -> ShowS)
-> Show (DimensionDeclarator a)
forall a. Show a => Int -> DimensionDeclarator a -> ShowS
forall a. Show a => [DimensionDeclarator a] -> ShowS
forall a. Show a => DimensionDeclarator a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DimensionDeclarator a] -> ShowS
$cshowList :: forall a. Show a => [DimensionDeclarator a] -> ShowS
show :: DimensionDeclarator a -> String
$cshow :: forall a. Show a => DimensionDeclarator a -> String
showsPrec :: Int -> DimensionDeclarator a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> DimensionDeclarator a -> ShowS
Show, Typeable (DimensionDeclarator a)
Typeable (DimensionDeclarator a)
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g)
    -> DimensionDeclarator a
    -> c (DimensionDeclarator a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (DimensionDeclarator a))
-> (DimensionDeclarator a -> Constr)
-> (DimensionDeclarator a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (DimensionDeclarator a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (DimensionDeclarator a)))
-> ((forall b. Data b => b -> b)
    -> DimensionDeclarator a -> DimensionDeclarator a)
-> (forall r r'.
    (r -> r' -> r)
    -> r
    -> (forall d. Data d => d -> r')
    -> DimensionDeclarator a
    -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r
    -> (forall d. Data d => d -> r')
    -> DimensionDeclarator a
    -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> DimensionDeclarator a -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> DimensionDeclarator a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> DimensionDeclarator a -> m (DimensionDeclarator a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DimensionDeclarator a -> m (DimensionDeclarator a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DimensionDeclarator a -> m (DimensionDeclarator a))
-> Data (DimensionDeclarator a)
DimensionDeclarator a -> DataType
DimensionDeclarator a -> Constr
(forall b. Data b => b -> b)
-> DimensionDeclarator a -> DimensionDeclarator a
forall {a}. Data a => Typeable (DimensionDeclarator a)
forall a. Data a => DimensionDeclarator a -> DataType
forall a. Data a => DimensionDeclarator a -> Constr
forall a.
Data a =>
(forall b. Data b => b -> b)
-> DimensionDeclarator a -> DimensionDeclarator a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> DimensionDeclarator a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> DimensionDeclarator a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DimensionDeclarator a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DimensionDeclarator a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d)
-> DimensionDeclarator a -> m (DimensionDeclarator a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> DimensionDeclarator a -> m (DimensionDeclarator a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (DimensionDeclarator a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> DimensionDeclarator a
-> c (DimensionDeclarator a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (DimensionDeclarator a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (DimensionDeclarator a))
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) -> DimensionDeclarator a -> u
forall u.
(forall d. Data d => d -> u) -> DimensionDeclarator a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DimensionDeclarator a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DimensionDeclarator a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DimensionDeclarator a -> m (DimensionDeclarator a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DimensionDeclarator a -> m (DimensionDeclarator a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (DimensionDeclarator a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> DimensionDeclarator a
-> c (DimensionDeclarator a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (DimensionDeclarator a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (DimensionDeclarator a))
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DimensionDeclarator a -> m (DimensionDeclarator a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> DimensionDeclarator a -> m (DimensionDeclarator a)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DimensionDeclarator a -> m (DimensionDeclarator a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> DimensionDeclarator a -> m (DimensionDeclarator a)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DimensionDeclarator a -> m (DimensionDeclarator a)
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d)
-> DimensionDeclarator a -> m (DimensionDeclarator a)
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> DimensionDeclarator a -> u
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> DimensionDeclarator a -> u
gmapQ :: forall u.
(forall d. Data d => d -> u) -> DimensionDeclarator a -> [u]
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> DimensionDeclarator a -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DimensionDeclarator a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DimensionDeclarator a -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DimensionDeclarator a -> r
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DimensionDeclarator a -> r
gmapT :: (forall b. Data b => b -> b)
-> DimensionDeclarator a -> DimensionDeclarator a
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b)
-> DimensionDeclarator a -> DimensionDeclarator a
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (DimensionDeclarator a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (DimensionDeclarator a))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (DimensionDeclarator a))
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (DimensionDeclarator a))
dataTypeOf :: DimensionDeclarator a -> DataType
$cdataTypeOf :: forall a. Data a => DimensionDeclarator a -> DataType
toConstr :: DimensionDeclarator a -> Constr
$ctoConstr :: forall a. Data a => DimensionDeclarator a -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (DimensionDeclarator a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (DimensionDeclarator a)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> DimensionDeclarator a
-> c (DimensionDeclarator a)
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> DimensionDeclarator a
-> c (DimensionDeclarator a)
Data, Typeable, (forall x. DimensionDeclarator a -> Rep (DimensionDeclarator a) x)
-> (forall x.
    Rep (DimensionDeclarator a) x -> DimensionDeclarator a)
-> Generic (DimensionDeclarator a)
forall x. Rep (DimensionDeclarator a) x -> DimensionDeclarator a
forall x. DimensionDeclarator a -> Rep (DimensionDeclarator a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (DimensionDeclarator a) x -> DimensionDeclarator a
forall a x. DimensionDeclarator a -> Rep (DimensionDeclarator a) x
$cto :: forall a x. Rep (DimensionDeclarator a) x -> DimensionDeclarator a
$cfrom :: forall a x. DimensionDeclarator a -> Rep (DimensionDeclarator a) x
Generic, (forall a b.
 (a -> b) -> DimensionDeclarator a -> DimensionDeclarator b)
-> (forall a b.
    a -> DimensionDeclarator b -> DimensionDeclarator a)
-> Functor DimensionDeclarator
forall a b. a -> DimensionDeclarator b -> DimensionDeclarator a
forall a b.
(a -> b) -> DimensionDeclarator a -> DimensionDeclarator b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: forall a b. a -> DimensionDeclarator b -> DimensionDeclarator a
$c<$ :: forall a b. a -> DimensionDeclarator b -> DimensionDeclarator a
fmap :: forall a b.
(a -> b) -> DimensionDeclarator a -> DimensionDeclarator b
$cfmap :: forall a b.
(a -> b) -> DimensionDeclarator a -> DimensionDeclarator b
Functor)

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

instance Binary UnaryOp

data BinaryOp =
    Addition
  | Subtraction
  | Multiplication
  | Division
  | Exponentiation
  | Concatenation
  | GT
  | GTE
  | LT
  | LTE
  | EQ
  | NE
  | Or
  | XOr
  | And
  | Equivalent
  | NotEquivalent
  | BinCustom String
  deriving (BinaryOp -> BinaryOp -> Bool
(BinaryOp -> BinaryOp -> Bool)
-> (BinaryOp -> BinaryOp -> Bool) -> Eq BinaryOp
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: BinaryOp -> BinaryOp -> Bool
$c/= :: BinaryOp -> BinaryOp -> Bool
== :: BinaryOp -> BinaryOp -> Bool
$c== :: BinaryOp -> BinaryOp -> Bool
Eq, Eq BinaryOp
Eq BinaryOp
-> (BinaryOp -> BinaryOp -> Ordering)
-> (BinaryOp -> BinaryOp -> Bool)
-> (BinaryOp -> BinaryOp -> Bool)
-> (BinaryOp -> BinaryOp -> Bool)
-> (BinaryOp -> BinaryOp -> Bool)
-> (BinaryOp -> BinaryOp -> BinaryOp)
-> (BinaryOp -> BinaryOp -> BinaryOp)
-> Ord BinaryOp
BinaryOp -> BinaryOp -> Bool
BinaryOp -> BinaryOp -> Ordering
BinaryOp -> BinaryOp -> BinaryOp
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
min :: BinaryOp -> BinaryOp -> BinaryOp
$cmin :: BinaryOp -> BinaryOp -> BinaryOp
max :: BinaryOp -> BinaryOp -> BinaryOp
$cmax :: BinaryOp -> BinaryOp -> BinaryOp
>= :: BinaryOp -> BinaryOp -> Bool
$c>= :: BinaryOp -> BinaryOp -> Bool
> :: BinaryOp -> BinaryOp -> Bool
$c> :: BinaryOp -> BinaryOp -> Bool
<= :: BinaryOp -> BinaryOp -> Bool
$c<= :: BinaryOp -> BinaryOp -> Bool
< :: BinaryOp -> BinaryOp -> Bool
$c< :: BinaryOp -> BinaryOp -> Bool
compare :: BinaryOp -> BinaryOp -> Ordering
$ccompare :: BinaryOp -> BinaryOp -> Ordering
Ord, Int -> BinaryOp -> ShowS
[BinaryOp] -> ShowS
BinaryOp -> String
(Int -> BinaryOp -> ShowS)
-> (BinaryOp -> String) -> ([BinaryOp] -> ShowS) -> Show BinaryOp
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [BinaryOp] -> ShowS
$cshowList :: [BinaryOp] -> ShowS
show :: BinaryOp -> String
$cshow :: BinaryOp -> String
showsPrec :: Int -> BinaryOp -> ShowS
$cshowsPrec :: Int -> BinaryOp -> ShowS
Show, Typeable BinaryOp
Typeable BinaryOp
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> BinaryOp -> c BinaryOp)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c BinaryOp)
-> (BinaryOp -> Constr)
-> (BinaryOp -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c BinaryOp))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c BinaryOp))
-> ((forall b. Data b => b -> b) -> BinaryOp -> BinaryOp)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> BinaryOp -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> BinaryOp -> r)
-> (forall u. (forall d. Data d => d -> u) -> BinaryOp -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> BinaryOp -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> BinaryOp -> m BinaryOp)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> BinaryOp -> m BinaryOp)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> BinaryOp -> m BinaryOp)
-> Data BinaryOp
BinaryOp -> DataType
BinaryOp -> Constr
(forall b. Data b => b -> b) -> BinaryOp -> BinaryOp
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) -> BinaryOp -> u
forall u. (forall d. Data d => d -> u) -> BinaryOp -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> BinaryOp -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> BinaryOp -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> BinaryOp -> m BinaryOp
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> BinaryOp -> m BinaryOp
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c BinaryOp
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BinaryOp -> c BinaryOp
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c BinaryOp)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c BinaryOp)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> BinaryOp -> m BinaryOp
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> BinaryOp -> m BinaryOp
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> BinaryOp -> m BinaryOp
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> BinaryOp -> m BinaryOp
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> BinaryOp -> m BinaryOp
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> BinaryOp -> m BinaryOp
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> BinaryOp -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> BinaryOp -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> BinaryOp -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> BinaryOp -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> BinaryOp -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> BinaryOp -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> BinaryOp -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> BinaryOp -> r
gmapT :: (forall b. Data b => b -> b) -> BinaryOp -> BinaryOp
$cgmapT :: (forall b. Data b => b -> b) -> BinaryOp -> BinaryOp
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c BinaryOp)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c BinaryOp)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c BinaryOp)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c BinaryOp)
dataTypeOf :: BinaryOp -> DataType
$cdataTypeOf :: BinaryOp -> DataType
toConstr :: BinaryOp -> Constr
$ctoConstr :: BinaryOp -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c BinaryOp
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c BinaryOp
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BinaryOp -> c BinaryOp
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BinaryOp -> c BinaryOp
Data, Typeable, (forall x. BinaryOp -> Rep BinaryOp x)
-> (forall x. Rep BinaryOp x -> BinaryOp) -> Generic BinaryOp
forall x. Rep BinaryOp x -> BinaryOp
forall x. BinaryOp -> Rep BinaryOp x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep BinaryOp x -> BinaryOp
$cfrom :: forall x. BinaryOp -> Rep BinaryOp x
Generic)

instance Binary BinaryOp

-- Retrieving SrcSpan and Annotation from nodes
class Annotated f where
  getAnnotation :: f a -> a
  setAnnotation :: a -> f a -> f a
  modifyAnnotation :: (a -> a) -> f a -> f a
  default getAnnotation :: (FirstParameter (f a) a) => f a -> a
  getAnnotation = f a -> a
forall a e. FirstParameter a e => a -> e
getFirstParameter

  default setAnnotation :: (FirstParameter (f a) a) => a -> f a -> f a
  setAnnotation = a -> f a -> f a
forall a e. FirstParameter a e => e -> a -> a
setFirstParameter

  modifyAnnotation a -> a
f f a
x = a -> f a -> f a
forall (f :: * -> *) a. Annotated f => a -> f a -> f a
setAnnotation (a -> a
f (f a -> a
forall (f :: * -> *) a. Annotated f => f a -> a
getAnnotation f a
x)) f a
x

instance FirstParameter (ProgramUnit a) a
instance FirstParameter (Prefix a) a
instance FirstParameter (Suffix a) a
instance FirstParameter (Block a) a
instance FirstParameter (Statement a) a
instance FirstParameter (Argument a) a
instance FirstParameter (Use a) a
instance FirstParameter (TypeSpec a) a
instance FirstParameter (ProcDecl a) a
instance FirstParameter (ProcInterface a) a
instance FirstParameter (Selector a) a
instance FirstParameter (Attribute a) a
instance FirstParameter (ImpList a) a
instance FirstParameter (ImpElement a) a
instance FirstParameter (CommonGroup a) a
instance FirstParameter (DataGroup a) a
instance FirstParameter (StructureItem a) a
instance FirstParameter (UnionMap a) a
instance FirstParameter (Namelist a) a
instance FirstParameter (FormatItem a) a
instance FirstParameter (Expression a) a
instance FirstParameter (Index a) a
instance FirstParameter (DoSpecification a) a
instance FirstParameter (FlushSpec a) a
instance FirstParameter (Declarator a) a
instance FirstParameter (DimensionDeclarator a) a
instance FirstParameter (ControlPair a) a
instance FirstParameter (AllocOpt a) a

instance SecondParameter (ProgramUnit a) SrcSpan
instance SecondParameter (Prefix a) SrcSpan
instance SecondParameter (Suffix a) SrcSpan
instance SecondParameter (Block a) SrcSpan
instance SecondParameter (Statement a) SrcSpan
instance SecondParameter (Argument a) SrcSpan
instance SecondParameter (Use a) SrcSpan
instance SecondParameter (TypeSpec a) SrcSpan
instance SecondParameter (ProcDecl a) SrcSpan
instance SecondParameter (ProcInterface a) SrcSpan
instance SecondParameter (Selector a) SrcSpan
instance SecondParameter (Attribute a) SrcSpan
instance SecondParameter (ImpList a) SrcSpan
instance SecondParameter (ImpElement a) SrcSpan
instance SecondParameter (CommonGroup a) SrcSpan
instance SecondParameter (DataGroup a) SrcSpan
instance SecondParameter (StructureItem a) SrcSpan
instance SecondParameter (UnionMap a) SrcSpan
instance SecondParameter (Namelist a) SrcSpan
instance SecondParameter (FormatItem a) SrcSpan
instance SecondParameter (Expression a) SrcSpan
instance SecondParameter (Index a) SrcSpan
instance SecondParameter (DoSpecification a) SrcSpan
instance SecondParameter (FlushSpec a) SrcSpan
instance SecondParameter (Declarator a) SrcSpan
instance SecondParameter (DimensionDeclarator a) SrcSpan
instance SecondParameter (ControlPair a) SrcSpan
instance SecondParameter (AllocOpt a) SrcSpan

instance Annotated (AList t)
instance Annotated ProgramUnit
instance Annotated Block
instance Annotated Statement
instance Annotated Argument
instance Annotated Use
instance Annotated TypeSpec
instance Annotated ProcDecl
instance Annotated ProcInterface
instance Annotated Selector
instance Annotated Attribute
instance Annotated ImpList
instance Annotated ImpElement
instance Annotated CommonGroup
instance Annotated DataGroup
instance Annotated StructureItem
instance Annotated UnionMap
instance Annotated Namelist
instance Annotated FormatItem
instance Annotated Expression
instance Annotated Index
instance Annotated DoSpecification
instance Annotated FlushSpec
instance Annotated Declarator
instance Annotated DimensionDeclarator
instance Annotated ControlPair
instance Annotated AllocOpt

instance Spanned (ProgramUnit a)
instance Spanned (Prefix a)
instance Spanned (Suffix a)
instance Spanned (Statement a)
instance Spanned (Argument a)
instance Spanned (Use a)
instance Spanned (Attribute a)
instance Spanned (TypeSpec a)
instance Spanned (ProcDecl a)
instance Spanned (ProcInterface a)
instance Spanned (Selector a)
instance Spanned (ImpList a)
instance Spanned (ImpElement a)
instance Spanned (Block a)
instance Spanned (CommonGroup a)
instance Spanned (DataGroup a)
instance Spanned (StructureItem a)
instance Spanned (UnionMap a)
instance Spanned (Namelist a)
instance Spanned (FormatItem a)
instance Spanned (Expression a)
instance Spanned (Index a)
instance Spanned (DoSpecification a)
instance Spanned (FlushSpec a)
instance Spanned (Declarator a)
instance Spanned (DimensionDeclarator a)
instance Spanned (ControlPair a)
instance Spanned (AllocOpt a)

instance Spanned (ProgramFile a) where
  getSpan :: ProgramFile a -> SrcSpan
getSpan (ProgramFile MetaInfo
_ [ProgramUnit a]
pus) =
    case [ProgramUnit a]
pus of
      [] -> Position -> Position -> SrcSpan
SrcSpan Position
initPosition Position
initPosition
      [ProgramUnit a]
pus' -> [ProgramUnit a] -> SrcSpan
forall a. Spanned a => a -> SrcSpan
getSpan [ProgramUnit a]
pus'

  setSpan :: SrcSpan -> ProgramFile a -> ProgramFile a
setSpan SrcSpan
_ ProgramFile a
_ = String -> ProgramFile a
forall a. HasCallStack => String -> a
error String
"Cannot set span to a program unit"

class Labeled f where
  getLabel :: f a -> Maybe (Expression a)
  getLastLabel :: f a -> Maybe (Expression a)
  setLabel :: f a -> Expression a -> f a

instance Labeled Block where
  getLabel :: forall a. Block a -> Maybe (Expression a)
getLabel (BlStatement a
_ SrcSpan
_ Maybe (Expression a)
l Statement a
_) = Maybe (Expression a)
l
  getLabel (BlIf a
_ SrcSpan
_ Maybe (Expression a)
l Maybe String
_ [Maybe (Expression a)]
_ [[Block a]]
_ Maybe (Expression a)
_) = Maybe (Expression a)
l
  getLabel (BlCase a
_ SrcSpan
_ Maybe (Expression a)
l Maybe String
_ Expression a
_ [Maybe (AList Index a)]
_ [[Block a]]
_ Maybe (Expression a)
_) = Maybe (Expression a)
l
  getLabel (BlDo a
_ SrcSpan
_ Maybe (Expression a)
l Maybe String
_ Maybe (Expression a)
_ Maybe (DoSpecification a)
_ [Block a]
_ Maybe (Expression a)
_) = Maybe (Expression a)
l
  getLabel (BlDoWhile a
_ SrcSpan
_ Maybe (Expression a)
l Maybe String
_ Maybe (Expression a)
_ Expression a
_ [Block a]
_ Maybe (Expression a)
_) = Maybe (Expression a)
l
  getLabel Block a
_ = Maybe (Expression a)
forall a. Maybe a
Nothing

  getLastLabel :: forall a. Block a -> Maybe (Expression a)
getLastLabel b :: Block a
b@BlStatement{} = Block a -> Maybe (Expression a)
forall (f :: * -> *) a. Labeled f => f a -> Maybe (Expression a)
getLabel Block a
b
  getLastLabel (BlIf a
_ SrcSpan
_ Maybe (Expression a)
_ Maybe String
_ [Maybe (Expression a)]
_ [[Block a]]
_ Maybe (Expression a)
l) = Maybe (Expression a)
l
  getLastLabel (BlCase a
_ SrcSpan
_ Maybe (Expression a)
_ Maybe String
_ Expression a
_ [Maybe (AList Index a)]
_ [[Block a]]
_ Maybe (Expression a)
l) = Maybe (Expression a)
l
  getLastLabel (BlDo a
_ SrcSpan
_ Maybe (Expression a)
_ Maybe String
_ Maybe (Expression a)
_ Maybe (DoSpecification a)
_ [Block a]
_ Maybe (Expression a)
l) = Maybe (Expression a)
l
  getLastLabel (BlDoWhile a
_ SrcSpan
_ Maybe (Expression a)
_ Maybe String
_ Maybe (Expression a)
_ Expression a
_ [Block a]
_ Maybe (Expression a)
l) = Maybe (Expression a)
l
  getLastLabel Block a
_ = Maybe (Expression a)
forall a. Maybe a
Nothing

  setLabel :: forall a. Block a -> Expression a -> Block a
setLabel (BlStatement a
a SrcSpan
s Maybe (Expression a)
_ Statement a
st) Expression a
l = a -> SrcSpan -> Maybe (Expression a) -> Statement a -> Block a
forall a.
a -> SrcSpan -> Maybe (Expression a) -> Statement a -> Block a
BlStatement a
a SrcSpan
s (Expression a -> Maybe (Expression a)
forall a. a -> Maybe a
Just Expression a
l) Statement a
st
  setLabel (BlIf a
a SrcSpan
s Maybe (Expression a)
_ Maybe String
mn [Maybe (Expression a)]
conds [[Block a]]
bs Maybe (Expression a)
el) Expression a
l = a
-> SrcSpan
-> Maybe (Expression a)
-> Maybe String
-> [Maybe (Expression a)]
-> [[Block a]]
-> Maybe (Expression a)
-> Block a
forall a.
a
-> SrcSpan
-> Maybe (Expression a)
-> Maybe String
-> [Maybe (Expression a)]
-> [[Block a]]
-> Maybe (Expression a)
-> Block a
BlIf a
a SrcSpan
s (Expression a -> Maybe (Expression a)
forall a. a -> Maybe a
Just Expression a
l) Maybe String
mn [Maybe (Expression a)]
conds [[Block a]]
bs Maybe (Expression a)
el
  setLabel (BlDo a
a SrcSpan
s Maybe (Expression a)
_ Maybe String
mn Maybe (Expression a)
tl Maybe (DoSpecification a)
spec [Block a]
bs Maybe (Expression a)
el) Expression a
l = a
-> SrcSpan
-> Maybe (Expression a)
-> Maybe String
-> Maybe (Expression a)
-> Maybe (DoSpecification a)
-> [Block a]
-> Maybe (Expression a)
-> Block a
forall a.
a
-> SrcSpan
-> Maybe (Expression a)
-> Maybe String
-> Maybe (Expression a)
-> Maybe (DoSpecification a)
-> [Block a]
-> Maybe (Expression a)
-> Block a
BlDo a
a SrcSpan
s (Expression a -> Maybe (Expression a)
forall a. a -> Maybe a
Just Expression a
l) Maybe String
mn Maybe (Expression a)
tl Maybe (DoSpecification a)
spec [Block a]
bs Maybe (Expression a)
el
  setLabel (BlDoWhile a
a SrcSpan
s Maybe (Expression a)
_ Maybe String
n Maybe (Expression a)
tl Expression a
spec [Block a]
bs Maybe (Expression a)
el) Expression a
l = a
-> SrcSpan
-> Maybe (Expression a)
-> Maybe String
-> Maybe (Expression a)
-> Expression a
-> [Block a]
-> Maybe (Expression a)
-> Block a
forall a.
a
-> SrcSpan
-> Maybe (Expression a)
-> Maybe String
-> Maybe (Expression a)
-> Expression a
-> [Block a]
-> Maybe (Expression a)
-> Block a
BlDoWhile a
a SrcSpan
s (Expression a -> Maybe (Expression a)
forall a. a -> Maybe a
Just Expression a
l) Maybe String
n Maybe (Expression a)
tl Expression a
spec [Block a]
bs Maybe (Expression a)
el
  setLabel Block a
b Expression a
_ = Block a
b

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

instance Binary ProgramUnitName
instance NFData ProgramUnitName

class Named a where
  getName :: a -> ProgramUnitName
  setName :: ProgramUnitName -> a -> a

instance Named (ProgramUnit a) where
  getName :: ProgramUnit a -> ProgramUnitName
getName (PUMain a
_ SrcSpan
_ Maybe String
Nothing [Block a]
_ Maybe [ProgramUnit a]
_) = ProgramUnitName
NamelessMain
  getName (PUMain a
_ SrcSpan
_ (Just String
n) [Block a]
_ Maybe [ProgramUnit a]
_) = String -> ProgramUnitName
Named String
n
  getName (PUModule a
_ SrcSpan
_ String
n [Block a]
_ Maybe [ProgramUnit a]
_) = String -> ProgramUnitName
Named String
n
  getName (PUSubroutine a
_ SrcSpan
_ PrefixSuffix a
_ String
n Maybe (AList Expression a)
_ [Block a]
_ Maybe [ProgramUnit a]
_) = String -> ProgramUnitName
Named String
n
  getName (PUFunction a
_ SrcSpan
_ Maybe (TypeSpec a)
_ PrefixSuffix a
_ String
n Maybe (AList Expression a)
_ Maybe (Expression a)
_ [Block a]
_ Maybe [ProgramUnit a]
_) = String -> ProgramUnitName
Named String
n
  getName (PUBlockData a
_ SrcSpan
_ Maybe String
Nothing [Block a]
_)  = ProgramUnitName
NamelessBlockData
  getName (PUBlockData a
_ SrcSpan
_ (Just String
n) [Block a]
_) = String -> ProgramUnitName
Named String
n
  getName PUComment{} = ProgramUnitName
NamelessComment
  setName :: ProgramUnitName -> ProgramUnit a -> ProgramUnit a
setName (Named String
n) (PUMain a
a SrcSpan
s Maybe String
_ [Block a]
b Maybe [ProgramUnit a]
pus) = a
-> SrcSpan
-> Maybe String
-> [Block a]
-> Maybe [ProgramUnit a]
-> ProgramUnit a
forall a.
a
-> SrcSpan
-> Maybe String
-> [Block a]
-> Maybe [ProgramUnit a]
-> ProgramUnit a
PUMain a
a SrcSpan
s (String -> Maybe String
forall a. a -> Maybe a
Just String
n) [Block a]
b Maybe [ProgramUnit a]
pus
  setName ProgramUnitName
_         (PUMain a
a SrcSpan
s Maybe String
_ [Block a]
b Maybe [ProgramUnit a]
pus) = a
-> SrcSpan
-> Maybe String
-> [Block a]
-> Maybe [ProgramUnit a]
-> ProgramUnit a
forall a.
a
-> SrcSpan
-> Maybe String
-> [Block a]
-> Maybe [ProgramUnit a]
-> ProgramUnit a
PUMain a
a SrcSpan
s Maybe String
forall a. Maybe a
Nothing [Block a]
b Maybe [ProgramUnit a]
pus
  setName (Named String
n) (PUModule a
a SrcSpan
s String
_ [Block a]
b Maybe [ProgramUnit a]
pus) = a
-> SrcSpan
-> String
-> [Block a]
-> Maybe [ProgramUnit a]
-> ProgramUnit a
forall a.
a
-> SrcSpan
-> String
-> [Block a]
-> Maybe [ProgramUnit a]
-> ProgramUnit a
PUModule a
a SrcSpan
s String
n [Block a]
b Maybe [ProgramUnit a]
pus
  setName (Named String
n) (PUSubroutine a
a SrcSpan
s PrefixSuffix a
r String
_ Maybe (AList Expression a)
p [Block a]
b Maybe [ProgramUnit a]
subs) =
    a
-> SrcSpan
-> PrefixSuffix a
-> String
-> Maybe (AList Expression a)
-> [Block a]
-> Maybe [ProgramUnit a]
-> ProgramUnit a
forall a.
a
-> SrcSpan
-> PrefixSuffix a
-> String
-> Maybe (AList Expression a)
-> [Block a]
-> Maybe [ProgramUnit a]
-> ProgramUnit a
PUSubroutine a
a SrcSpan
s PrefixSuffix a
r String
n Maybe (AList Expression a)
p [Block a]
b Maybe [ProgramUnit a]
subs
  setName (Named String
n) (PUFunction   a
a SrcSpan
s Maybe (TypeSpec a)
r PrefixSuffix a
rec String
_ Maybe (AList Expression a)
p Maybe (Expression a)
res [Block a]
b Maybe [ProgramUnit a]
subs) =
    a
-> SrcSpan
-> Maybe (TypeSpec a)
-> PrefixSuffix a
-> String
-> Maybe (AList Expression a)
-> Maybe (Expression a)
-> [Block a]
-> Maybe [ProgramUnit a]
-> ProgramUnit a
forall a.
a
-> SrcSpan
-> Maybe (TypeSpec a)
-> PrefixSuffix a
-> String
-> Maybe (AList Expression a)
-> Maybe (Expression a)
-> [Block a]
-> Maybe [ProgramUnit a]
-> ProgramUnit a
PUFunction a
a SrcSpan
s Maybe (TypeSpec a)
r PrefixSuffix a
rec String
n Maybe (AList Expression a)
p Maybe (Expression a)
res [Block a]
b Maybe [ProgramUnit a]
subs
  setName (Named String
n) (PUBlockData  a
a SrcSpan
s Maybe String
_ [Block a]
b) = a -> SrcSpan -> Maybe String -> [Block a] -> ProgramUnit a
forall a.
a -> SrcSpan -> Maybe String -> [Block a] -> ProgramUnit a
PUBlockData  a
a SrcSpan
s (String -> Maybe String
forall a. a -> Maybe a
Just String
n) [Block a]
b
  setName ProgramUnitName
_         (PUBlockData  a
a SrcSpan
s Maybe String
_ [Block a]
b) = a -> SrcSpan -> Maybe String -> [Block a] -> ProgramUnit a
forall a.
a -> SrcSpan -> Maybe String -> [Block a] -> ProgramUnit a
PUBlockData  a
a SrcSpan
s Maybe String
forall a. Maybe a
Nothing [Block a]
b
  -- Identity function if first arg is nameless or second arg is comment.
  setName ProgramUnitName
_ ProgramUnit a
a = ProgramUnit a
a

instance Out MetaInfo
instance Out a => Out (ProgramFile a)
instance Out a => Out (ProgramUnit a)
instance Out a => Out (Prefix a)
instance Out a => Out (Suffix a)
instance Out a => Out (Statement a)
instance Out a => Out (ProcDecl a)
instance Out a => Out (ProcInterface a)
instance Out Only
instance Out ModuleNature
instance Out a => Out (Argument a)
instance Out a => Out (ArgumentExpression a)
instance Out a => Out (Use a)
instance Out a => Out (Attribute a)
instance Out Intent
instance Out a => Out (ImpList a)
instance Out a => Out (ImpElement a)
instance Out a => Out (Comment a)
instance Out a => Out (Block a)
instance Out a => Out (CommonGroup a)
instance Out a => Out (DataGroup a)
instance Out a => Out (StructureItem a)
instance Out a => Out (UnionMap a)
instance Out a => Out (Namelist a)
instance Out a => Out (FormatItem a)
instance Out a => Out (Expression a)
instance Out a => Out (Index a)
instance Out a => Out (DoSpecification a)
instance Out a => Out (FlushSpec a)
instance Out a => Out (Value a)
instance Out a => Out (TypeSpec a)
instance Out a => Out (Selector a)
instance Out BaseType
instance Out a => Out (Declarator a)
instance Out a => Out (DimensionDeclarator a)
instance Out a => Out (DeclaratorType a)
instance Out a => Out (ControlPair a)
instance Out a => Out (AllocOpt a)
instance Out UnaryOp
instance Out BinaryOp
instance Out a => Out (ForallHeader a)

-- Classifiers on statement and blocks ASTs

nonExecutableStatement :: FortranVersion -> Statement a -> Bool
nonExecutableStatement :: forall a. FortranVersion -> Statement a -> Bool
nonExecutableStatement FortranVersion
_ Statement a
s = case Statement a
s of
    StIntent {}       -> Bool
True
    StOptional {}     -> Bool
True
    StPublic {}       -> Bool
True
    StPrivate {}      -> Bool
True
    StProtected {}    -> Bool
True
    StSave {}         -> Bool
True
    StDimension {}    -> Bool
True
    StAllocatable {}  -> Bool
True
    StAsynchronous {} -> Bool
True
    StPointer {}      -> Bool
True
    StTarget {}       -> Bool
True
    StValue {}        -> Bool
True
    StVolatile {}     -> Bool
True
    StData {}         -> Bool
True
    StParameter {}    -> Bool
True
    StImplicit {}     -> Bool
True
    StNamelist {}     -> Bool
True
    StEquivalence {}  -> Bool
True
    StCommon {}       -> Bool
True
    StExternal {}     -> Bool
True
    StIntrinsic {}    -> Bool
True
    StUse {}          -> Bool
True
    StEntry {}        -> Bool
True
    StSequence {}     -> Bool
True
    StType {}         -> Bool
True
    StEndType {}      -> Bool
True
    StFormat {}       -> Bool
True
    StFormatBogus {}  -> Bool
True
    StInclude {}      -> Bool
True
    StDeclaration {}  -> Bool
True
    StStructure {}    -> Bool
True
    Statement a
_                 -> Bool
False

executableStatement :: FortranVersion -> Statement a -> Bool
-- Some statements are both executable and non-executable in Fortran 90 upwards
executableStatement :: forall a. FortranVersion -> Statement a -> Bool
executableStatement FortranVersion
v StFormat{} | FortranVersion
v FortranVersion -> FortranVersion -> Bool
forall a. Ord a => a -> a -> Bool
>= FortranVersion
Fortran90 = Bool
True
executableStatement FortranVersion
v StEntry{}  | FortranVersion
v FortranVersion -> FortranVersion -> Bool
forall a. Ord a => a -> a -> Bool
>= FortranVersion
Fortran90 = Bool
True
executableStatement FortranVersion
v StData{}   | FortranVersion
v FortranVersion -> FortranVersion -> Bool
forall a. Ord a => a -> a -> Bool
>= FortranVersion
Fortran90 = Bool
True
executableStatement FortranVersion
v Statement a
s = Bool -> Bool
not (Bool -> Bool) -> Bool -> Bool
forall a b. (a -> b) -> a -> b
$ FortranVersion -> Statement a -> Bool
forall a. FortranVersion -> Statement a -> Bool
nonExecutableStatement FortranVersion
v Statement a
s

executableStatementBlock :: FortranVersion -> Block a -> Bool
executableStatementBlock :: forall a. FortranVersion -> Block a -> Bool
executableStatementBlock FortranVersion
v (BlStatement a
_ SrcSpan
_ Maybe (Expression a)
_ Statement a
s) = FortranVersion -> Statement a -> Bool
forall a. FortranVersion -> Statement a -> Bool
executableStatement FortranVersion
v Statement a
s
executableStatementBlock FortranVersion
_ Block a
_ = Bool
False

nonExecutableStatementBlock :: FortranVersion -> Block a -> Bool
nonExecutableStatementBlock :: forall a. FortranVersion -> Block a -> Bool
nonExecutableStatementBlock FortranVersion
v (BlStatement a
_ SrcSpan
_ Maybe (Expression a)
_ Statement a
s) = FortranVersion -> Statement a -> Bool
forall a. FortranVersion -> Statement a -> Bool
nonExecutableStatement FortranVersion
v Statement a
s
nonExecutableStatementBlock FortranVersion
_ BlInterface{} = Bool
True
nonExecutableStatementBlock FortranVersion
_ Block a
_ = Bool
False

instance NFData a => NFData (ProgramFile a)
instance NFData a => NFData (ProgramUnit a)
instance NFData a => NFData (Block a)
instance NFData a => NFData (Expression a)
instance NFData a => NFData (TypeSpec a)
instance NFData a => NFData (Index a)
instance NFData a => NFData (Value a)
instance NFData a => NFData (Comment a)
instance NFData a => NFData (Statement a)
instance NFData a => NFData (ProcDecl a)
instance NFData a => NFData (ProcInterface a)
instance NFData a => NFData (DoSpecification a)
instance NFData a => NFData (Selector a)
instance NFData a => NFData (ForallHeader a)
instance NFData a => NFData (Argument a)
instance NFData a => NFData (ArgumentExpression a)
instance NFData a => NFData (Use a)
instance NFData a => NFData (Attribute a)
instance NFData a => NFData (CommonGroup a)
instance NFData a => NFData (ControlPair a)
instance NFData a => NFData (AllocOpt a)
instance NFData a => NFData (DataGroup a)
instance NFData a => NFData (DimensionDeclarator a)
instance NFData a => NFData (Declarator a)
instance NFData a => NFData (DeclaratorType a)
instance NFData a => NFData (FormatItem a)
instance NFData a => NFData (FlushSpec a)
instance NFData a => NFData (ImpElement a)
instance NFData a => NFData (ImpList a)
instance NFData a => NFData (Namelist a)
instance NFData a => NFData (Prefix a)
instance NFData a => NFData (Suffix a)
instance NFData a => NFData (StructureItem a)
instance NFData a => NFData (UnionMap a)
instance NFData MetaInfo
instance NFData BaseType
instance NFData UnaryOp
instance NFData BinaryOp
instance NFData Only
instance NFData ModuleNature
instance NFData Intent