{-# OPTIONS_GHC -fno-warn-orphans #-} -- for Out (NonEmpty a)

{- | Data types for representing Fortran code (for various versions of Fortran).

The same representation is used for all supported Fortran standards. Constructs
only available in certain versions are gated by the parsers (and the pretty
printer). In general, the definitions here are highly permissible, partly to
allow for all the oddities of older standards & extensions.

Useful Fortran standard references:

  * Fortran 2018 standard: WD 1539-1 J3/18-007r1
  * Fortran 2008 standard: WD 1539-1 J3/10-007r1
  * Fortran 90 standard: ANSI X3.198-1992 (also ISO/IEC 1539:1991)
  * Fortran 90 Handbook (J. Adams)
  * Fortran 77 standard: ANSI X3.9-1978
-}

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

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

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

  -- ** Other
  , Attribute(..)
  , Prefix(..)
  , Suffix(..)
  , ProcDecl(..)
  , ProcInterface(..)
  , Comment(..)
  , ForallHeader(..)
  , ForallHeaderPart(..)
  , 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(..)

  -- * 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

  -- * Re-exports
  , NonEmpty(..)

  ) where

import Prelude hiding ( init )

import Language.Fortran.AST.Common ( Name )
import Language.Fortran.AST.AList
import Language.Fortran.AST.Literal
import Language.Fortran.AST.Literal.Real
import Language.Fortran.AST.Literal.Boz ( Boz )
import Language.Fortran.AST.Literal.Complex
import Language.Fortran.Util.Position
import Language.Fortran.Util.FirstParameter
import Language.Fortran.Util.SecondParameter
import Language.Fortran.AST.Annotated
import Language.Fortran.Version

import Data.Data
import Data.Binary
import Control.DeepSeq
import Text.PrettyPrint.GenericPretty
import Data.List.NonEmpty ( NonEmpty(..) )

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

--------------------------------------------------------------------------------
-- 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 stock (Eq 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
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
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
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, 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)
  deriving anyclass (Get BaseType
[BaseType] -> Put
BaseType -> Put
forall t. (t -> Put) -> Get t -> ([t] -> Put) -> Binary t
putList :: [BaseType] -> Put
$cputList :: [BaseType] -> Put
get :: Get BaseType
$cget :: Get BaseType
put :: BaseType -> Put
$cput :: BaseType -> Put
Binary)

-- | 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
  { forall a. TypeSpec a -> a
typeSpecAnno :: a
  , forall a. TypeSpec a -> SrcSpan
typeSpecSpan :: SrcSpan
  , forall a. TypeSpec a -> BaseType
typeSpecBaseType :: BaseType
  , forall a. TypeSpec a -> Maybe (Selector a)
typeSpecSelector :: Maybe (Selector a)
  } deriving stock (TypeSpec a -> TypeSpec a -> Bool
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
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, TypeSpec a -> DataType
TypeSpec a -> Constr
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 (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))
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, 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 -> 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. Tightly bound to
--   'TypeSpec'.
--
-- 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.
--
-- Often used with the assumption that when a 'Selector' term is present, it
-- contains some information (i.e. one of length or kind is @'Just' _@), so that
-- the awkward "empty" possibility may be avoided.
data Selector a = Selector
  { forall a. Selector a -> a
selectorAnno :: a
  , forall a. Selector a -> SrcSpan
selectorSpan :: SrcSpan
  , forall a. Selector a -> Maybe (Expression a)
selectorLength :: Maybe (Expression a)
  , forall a. Selector a -> Maybe (Expression a)
selectorKind   :: Maybe (Expression a)
  } deriving stock (Selector a -> Selector a -> Bool
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
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, Selector a -> DataType
Selector a -> Constr
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 (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))
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, 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 -> 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)

data MetaInfo = MetaInfo { MetaInfo -> FortranVersion
miVersion :: FortranVersion, MetaInfo -> String
miFilename :: String }
  deriving stock (MetaInfo -> MetaInfo -> Bool
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
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
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, 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
  { forall a. ProgramFile a -> MetaInfo
programFileMeta :: MetaInfo
  , forall a. ProgramFile a -> [ProgramUnit a]
programFileProgramUnits :: [ ProgramUnit a ]
  } deriving stock (ProgramFile a -> ProgramFile a -> Bool
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
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, ProgramFile a -> DataType
ProgramFile a -> Constr
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 (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))
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, 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 -> 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) = 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

-- | A Fortran program unit. _(F2008 2.2)_
--
-- A Fortran program is made up of many program units.
--
-- Related points from the Fortran 2008 specification:
--
--   * There must be exactly one main program, and any number of other program
--     units.
--   * Note 2.3: There may be at most 1 unnamed block data program unit.
data ProgramUnit a =
    PUMain                          -- ^ Main program
      a SrcSpan
      (Maybe Name)                  -- ^ Program name
      [Block a]                     -- ^ Body
      (Maybe [ProgramUnit a])       -- ^ Subprograms

  | PUModule                        -- ^ Module
      a SrcSpan
      Name                          -- ^ Program name
      [Block a]                     -- ^ Body
      (Maybe [ProgramUnit a])       -- ^ Subprograms

  | PUSubroutine                    -- ^ Subroutine subprogram (procedure)
      a SrcSpan
      (PrefixSuffix a)              -- ^ Options (elemental, pure etc.)
      Name                          -- ^ Name
      (Maybe (AList Expression a))  -- ^ Arguments
      [Block a]                     -- ^ Body
      (Maybe [ProgramUnit a])       -- ^ Subprograms

  | PUFunction                      -- ^ Function subprogram (procedure)
      a SrcSpan
      (Maybe (TypeSpec a))          -- ^ Return type
      (PrefixSuffix a)              -- ^ Options (elemental, pure etc.)
      Name                          -- ^ Name
      (Maybe (AList Expression a))  -- ^ Arguments
      (Maybe (Expression a))        -- ^ Result
      [Block a]                     -- ^ Body
      (Maybe [ProgramUnit a])       -- ^ Subprograms

  | PUBlockData                     -- ^ Block data (named or unnamed).
      a SrcSpan
      (Maybe Name)                  -- ^ Optional block
      [Block a] -- Body

  | PUComment                       -- ^ Program unit-level comment
      a SrcSpan
      (Comment a)
  deriving stock (ProgramUnit a -> ProgramUnit a -> Bool
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
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, ProgramUnit a -> DataType
ProgramUnit a -> Constr
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 (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))
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, 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 -> 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 = forall a. Maybe a
Nothing

emptySuffixes :: Suffixes a
emptySuffixes :: forall a. Suffixes a
emptySuffixes = forall a. Maybe a
Nothing

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

data Prefix a = PfxRecursive a SrcSpan
              | PfxElemental a SrcSpan
              | PfxPure a SrcSpan
  deriving stock (Prefix a -> Prefix a -> Bool
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
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, Prefix a -> DataType
Prefix a -> Constr
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 (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))
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, 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 -> 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 (forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
any forall {a}. Prefix a -> Bool
isElem [Prefix a]
pfxs) Bool -> Bool -> Bool
|| (Bool -> Bool
not (forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
any forall {a}. Prefix a -> Bool
isRec [Prefix a]
pfxs) Bool -> Bool -> Bool
&& Bool -> Bool
not (forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
any 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 = forall (t :: * -> *) a. Maybe (AList t a) -> [t a]
aStrip' Prefixes a
mpfxs
    sfxs :: [Suffix a]
sfxs = forall (t :: * -> *) a. Maybe (AList t a) -> [t a]
aStrip' Suffixes a
msfxs

data Suffix a = SfxBind a SrcSpan (Maybe (Expression a))
  deriving stock (Suffix a -> Suffix a -> Bool
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
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, Suffix a -> DataType
Suffix a -> Constr
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 (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))
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, 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 -> 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' =
    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' =
    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' =
    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' =
    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' =
    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{}               = forall a. Maybe a
Nothing
programUnitSubprograms PUComment{}                 = forall a. Maybe a
Nothing

newtype Comment a = Comment String
  deriving stock (Comment a -> Comment a -> Bool
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
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, Comment a -> DataType
Comment a -> Constr
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 {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 (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)
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, 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 -> 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                              -- ^ Statement
                a SrcSpan
                (Maybe (Expression a))       -- ^ Label
                (Statement a)                -- ^ Wrapped statement

  | BlForall                                 -- ^ FORALL array assignment syntax
                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                                     -- ^ IF block construct
                a SrcSpan
                (Maybe (Expression a))       -- ^ Label
                (Maybe String)               -- ^ Construct name
                (NonEmpty (Expression a, [Block a])) -- ^ IF, ELSE IF clauses
                (Maybe [Block a])            -- ^ ELSE block
                (Maybe (Expression a))       -- ^ Label to END IF

  | BlCase                                   -- ^ SELECT CASE construct
                a SrcSpan
                (Maybe (Expression a))       -- ^ Label
                (Maybe String)               -- ^ Construct name
                (Expression a)               -- ^ Scrutinee
                [(AList Index a, [Block a])] -- ^ CASE clauses
                (Maybe [Block a])            -- ^ CASE default
                (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
  -- ^ The first 'Expression' in the abbreviation tuple is always an
  --   @ExpValue _ _ (ValVariable id)@. Also guaranteed nonempty. TODO
                a SrcSpan
                (Maybe (Expression a))       -- ^ Label
                (Maybe String)               -- ^ Construct name
                (AList (ATuple Expression Expression) a) -- ^ Expression abbreviations
                [ Block a ]                  -- ^ Body
                (Maybe (Expression a))       -- ^ Label

  | BlInterface a SrcSpan
                (Maybe (Expression a))       -- ^ Label
                Bool                         -- ^ Is this an abstract interface?
                [ ProgramUnit a ]            -- ^ Interface procedures
                [ Block a ]                  -- ^ Module procedures

  | BlComment                                -- ^ Block-level comment
                a SrcSpan
                (Comment a)
  deriving stock (Block a -> Block a -> Bool
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
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, Block a -> DataType
Block a -> Constr
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 (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))
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, 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 -> 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
    -- ^ Declare variable(s) at a given type.
        a SrcSpan
        (TypeSpec a)                -- ^ Type specification
        (Maybe (AList Attribute a)) -- ^ Attributes
        (AList Declarator a)        -- ^ Declarators

  | StStructure
    -- ^ A structure (pre-F90 extension) declaration.
        a SrcSpan
        (Maybe String)          -- ^ Structure name
        (AList StructureItem a) -- ^ Structure fields

  | 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
    -- ^ SAVE statement: variable retains its value between invocations
        a SrcSpan
        (Maybe (AList Expression a))
        -- ^ Save the given variables, or all saveable items in the program unit
        --   if 'Nothing'

  | StDimension           a SrcSpan (AList Declarator a)
    -- ^ DIMENSION attribute as statement.

  | StAllocatable         a SrcSpan (AList Declarator a)
    -- ^ ALLOCATABLE attribute statement.

  | StAsynchronous        a SrcSpan (AList Declarator a)
    -- ^ ASYNCHRONOUS attribute statement.

  | StPointer             a SrcSpan (AList Declarator a)
    -- ^ POINTER attribute statement.

  | StTarget              a SrcSpan (AList Declarator a)
    -- ^ TARGET attribute statement.

  | StValue               a SrcSpan (AList Declarator a)
    -- ^ VALUE attribute statement.

  | StVolatile            a SrcSpan (AList Declarator a)
    -- ^ VOLATILE attribute statement.

  | 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)
    -- ^ PARAMETER attribute as statement.

  | 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)               -- ^ name (guaranteed @ExpValue ValVariable@)
        (Maybe (AList Expression a)) -- ^ argument variables
        (Maybe (Expression a))       -- ^ optional result variable (guaranteed @ExpValue ValVariable@)

  | StInclude
        a SrcSpan
        (Expression a) -- ^ file name to include. guaranteed @ExpValue ValString@
        (Maybe [Block a]) -- ^ First parsed to 'Nothing', then potentially "expanded out" 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)) -- ^ guaranteed @ExpValue ValVariable@
  | StExit                a SrcSpan (Maybe (Expression a))
  | StIfLogical
        a SrcSpan
        (Expression a) -- ^ condition
        (Statement a)  -- ^ statement (should not further recurse)
  | StIfArithmetic        a SrcSpan (Expression a) (Expression a) (Expression a) (Expression a)

  | StSelectCase -- ^ CASE construct opener.
        a SrcSpan
        (Maybe String) -- ^ block name
        (Expression a)
        -- ^ CASE expression. Should be one of scalar CHARACTER, INTEGER or LOGICAL.

  | StCase -- ^ inner CASE clause
        a SrcSpan
        (Maybe String) -- ^ block name (must match a corresponding opener)
        (Maybe (AList Index a))
        -- ^ CASE indices (expressions). 'Nothing' means it's CASE DEFAULT.

  | StEndcase -- ^ END SELECT statement
        a SrcSpan
        (Maybe String) -- ^ block name (must match corresponding opener name)

  | 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) (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
    -- ^ Special TYPE "print" statement (~F77 syntactic sugar for PRINT/WRITE)
    --
    -- Not to be confused with the TYPE construct in later standards for
    -- defining derived data types.
        a SrcSpan
        (Expression a) -- ^ format identifier
        (Maybe (AList Expression a)) -- ^ variables etc. to print

  | 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 -- ^ ALLOCATE: associate pointers with targets
        a SrcSpan
        (Maybe (TypeSpec a))
        (AList Expression a) -- ^ pointers (variables/references)
        (Maybe (AList AllocOpt a))
  | StNullify -- ^ NULLIFY: disassociate pointers from targets
        a SrcSpan
        (AList Expression a) -- ^ pointers (variables/references)
  | StDeallocate -- ^ DEALLOCATE: disassociate pointers from targets
        a SrcSpan
        (AList Expression a) -- ^ pointers (variables/references)
        (Maybe (AList AllocOpt a))

  | StWhere
        a SrcSpan
        (Expression a) -- ^ must be LOGICAL
        (Statement a) -- ^ guaranteed to be 'StExpressionAssign'

  | StWhereConstruct -- ^ begin WHERE block
        a SrcSpan
        (Maybe String) -- ^ block name
        (Expression a) -- ^ must be LOGICAL
  | StElsewhere -- ^ WHERE clause. compare to IF, IF ELSE
        a SrcSpan
        (Maybe String) -- ^ block name
        (Maybe (Expression a)) -- ^ must be LOGICAL
  | StEndWhere -- ^ end WHERE block
        a SrcSpan
        (Maybe String) -- ^ block name

  | StUse
    -- ^ Import definitions (procedures, types) from a module. /(F2018 14.2.2)/
    --
    -- If a module nature isn't provided and there are both intrinsic and
    -- nonintrinsic modules with that name, the nonintrinsic module is selected.
        a SrcSpan
        (Expression a)
        -- ^ name of module to use, guaranteed to be @ExpValue ValVariable@
        (Maybe ModuleNature)  -- ^ optional explicit module nature
        Only
        (Maybe (AList Use a)) -- ^ definitions to import (including renames)

  | StModuleProcedure
        a SrcSpan
        (AList Expression a)
        -- ^ procedure names, guaranteed @ExpValue ValVariable@
  | StProcedure           a SrcSpan (Maybe (ProcInterface a)) (Maybe (AList Attribute a)) (AList ProcDecl a)

  | StType -- ^ TYPE ... = begin a DDT (derived data type) definition block
        a SrcSpan
        (Maybe (AList Attribute a)) -- ^ attributes (subset permitted)
        String                      -- ^ DDT name

  | StEndType
    -- ^ END TYPE [ type-name ] = end a DDT definition block
        a SrcSpan
        (Maybe String) -- ^ optional type name (must match corresponding opener)

  | StSequence            a SrcSpan

  | StForall -- ^ FORALL ... = begin a FORALL block
        a SrcSpan
        (Maybe String)   -- ^ block name
        (ForallHeader a) -- ^ FORALL header syntax
  | StEndForall
    -- ^ END FORALL [ construct-name ]
        a SrcSpan
        (Maybe String) -- ^ block name

  | StForallStatement -- ^ FORALL statement - essentially an inline FORALL block
        a SrcSpan
        (ForallHeader a) -- ^ FORALL header syntax
        (Statement a)    -- ^ guaranteed 'StExpressionAssign' or 'StPointerAssign'

  | StImport
        a SrcSpan
        (AList Expression a) -- ^ guaranteed @ExpValue ValVariable@

  | 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 stock (Statement a -> Statement a -> Bool
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
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, Statement a -> DataType
Statement a -> Constr
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 (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))
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, 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 -> 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
  { forall a. ProcDecl a -> a
procDeclAnno       :: a
  , forall a. ProcDecl a -> SrcSpan
procDeclSpan       :: SrcSpan
  , forall a. ProcDecl a -> Expression a
procDeclEntityName :: Expression a
  , forall a. ProcDecl a -> Maybe (Expression a)
procDeclInitName   :: Maybe (Expression a)
  } deriving stock (ProcDecl a -> ProcDecl a -> Bool
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
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, ProcDecl a -> DataType
ProcDecl a -> Constr
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 (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))
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, 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 -> 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 stock (ProcInterface a -> ProcInterface a -> Bool
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
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, ProcInterface a -> DataType
ProcInterface a -> Constr
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 (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))
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, 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 -> 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)

-- | Part of a FORALL statement. Introduced in Fortran 95.
data ForallHeader a = ForallHeader
  { forall a. ForallHeader a -> a
forallHeaderAnno    :: a
  , forall a. ForallHeader a -> SrcSpan
forallHeaderSpan    :: SrcSpan
  , forall a. ForallHeader a -> [ForallHeaderPart a]
forallHeaderHeaders :: [ForallHeaderPart a]
  , forall a. ForallHeader a -> Maybe (Expression a)
forallHeaderScaling :: Maybe (Expression a)
  } deriving stock (ForallHeader a -> ForallHeader a -> Bool
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
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, ForallHeader a -> DataType
ForallHeader a -> Constr
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 (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))
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, 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 -> 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 ForallHeaderPart a = ForallHeaderPart
  { forall a. ForallHeaderPart a -> a
forallHeaderPartAnno   :: a
  , forall a. ForallHeaderPart a -> SrcSpan
forallHeaderPartSpan   :: SrcSpan
  , forall a. ForallHeaderPart a -> String
forallHeaderPartName   :: Name
  , forall a. ForallHeaderPart a -> Expression a
forallHeaderPartStart  :: Expression a
  , forall a. ForallHeaderPart a -> Expression a
forallHeaderPartEnd    :: Expression a
  , forall a. ForallHeaderPart a -> Maybe (Expression a)
forallHeaderPartStride :: Maybe (Expression a)
  } deriving stock (ForallHeaderPart a -> ForallHeaderPart a -> Bool
forall a. Eq a => ForallHeaderPart a -> ForallHeaderPart a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ForallHeaderPart a -> ForallHeaderPart a -> Bool
$c/= :: forall a. Eq a => ForallHeaderPart a -> ForallHeaderPart a -> Bool
== :: ForallHeaderPart a -> ForallHeaderPart a -> Bool
$c== :: forall a. Eq a => ForallHeaderPart a -> ForallHeaderPart a -> Bool
Eq, Int -> ForallHeaderPart a -> ShowS
forall a. Show a => Int -> ForallHeaderPart a -> ShowS
forall a. Show a => [ForallHeaderPart a] -> ShowS
forall a. Show a => ForallHeaderPart a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ForallHeaderPart a] -> ShowS
$cshowList :: forall a. Show a => [ForallHeaderPart a] -> ShowS
show :: ForallHeaderPart a -> String
$cshow :: forall a. Show a => ForallHeaderPart a -> String
showsPrec :: Int -> ForallHeaderPart a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> ForallHeaderPart a -> ShowS
Show, ForallHeaderPart a -> DataType
ForallHeaderPart a -> Constr
forall {a}. Data a => Typeable (ForallHeaderPart a)
forall a. Data a => ForallHeaderPart a -> DataType
forall a. Data a => ForallHeaderPart a -> Constr
forall a.
Data a =>
(forall b. Data b => b -> b)
-> ForallHeaderPart a -> ForallHeaderPart a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> ForallHeaderPart a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> ForallHeaderPart a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ForallHeaderPart a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ForallHeaderPart a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d)
-> ForallHeaderPart a -> m (ForallHeaderPart a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> ForallHeaderPart a -> m (ForallHeaderPart a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ForallHeaderPart a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> ForallHeaderPart a
-> c (ForallHeaderPart a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (ForallHeaderPart a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ForallHeaderPart 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 (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ForallHeaderPart a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> ForallHeaderPart a
-> c (ForallHeaderPart a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (ForallHeaderPart a))
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ForallHeaderPart a -> m (ForallHeaderPart a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> ForallHeaderPart a -> m (ForallHeaderPart a)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ForallHeaderPart a -> m (ForallHeaderPart a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> ForallHeaderPart a -> m (ForallHeaderPart a)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> ForallHeaderPart a -> m (ForallHeaderPart a)
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d)
-> ForallHeaderPart a -> m (ForallHeaderPart a)
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> ForallHeaderPart a -> u
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> ForallHeaderPart a -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> ForallHeaderPart a -> [u]
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> ForallHeaderPart a -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ForallHeaderPart a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ForallHeaderPart a -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ForallHeaderPart a -> r
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ForallHeaderPart a -> r
gmapT :: (forall b. Data b => b -> b)
-> ForallHeaderPart a -> ForallHeaderPart a
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b)
-> ForallHeaderPart a -> ForallHeaderPart a
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ForallHeaderPart a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ForallHeaderPart a))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (ForallHeaderPart a))
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (ForallHeaderPart a))
dataTypeOf :: ForallHeaderPart a -> DataType
$cdataTypeOf :: forall a. Data a => ForallHeaderPart a -> DataType
toConstr :: ForallHeaderPart a -> Constr
$ctoConstr :: forall a. Data a => ForallHeaderPart a -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ForallHeaderPart a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ForallHeaderPart a)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> ForallHeaderPart a
-> c (ForallHeaderPart a)
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> ForallHeaderPart a
-> c (ForallHeaderPart a)
Data, forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (ForallHeaderPart a) x -> ForallHeaderPart a
forall a x. ForallHeaderPart a -> Rep (ForallHeaderPart a) x
$cto :: forall a x. Rep (ForallHeaderPart a) x -> ForallHeaderPart a
$cfrom :: forall a x. ForallHeaderPart a -> Rep (ForallHeaderPart a) x
Generic, forall a b. a -> ForallHeaderPart b -> ForallHeaderPart a
forall a b. (a -> b) -> ForallHeaderPart a -> ForallHeaderPart 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 -> ForallHeaderPart b -> ForallHeaderPart a
$c<$ :: forall a b. a -> ForallHeaderPart b -> ForallHeaderPart a
fmap :: forall a b. (a -> b) -> ForallHeaderPart a -> ForallHeaderPart b
$cfmap :: forall a b. (a -> b) -> ForallHeaderPart a -> ForallHeaderPart b
Functor)

data Only = Exclusive | Permissive
  deriving stock (Only -> Only -> Bool
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
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
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, 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 stock (ModuleNature -> ModuleNature -> Bool
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
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
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, 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)

-- | Part of USE statement. /(F2018 14.2.2)/
--
-- Expressions may be names or operators.
data Use a =
    UseRename
        a SrcSpan
        (Expression a) -- ^ local name
        (Expression a) -- ^ use name
  | UseID
        a SrcSpan
        (Expression a) -- ^ name
  deriving stock (Use a -> Use a -> Bool
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
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, Use a -> DataType
Use a -> Constr
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 (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))
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, 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 -> 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
  { forall a. Argument a -> a
argumentAnno :: a
  , forall a. Argument a -> SrcSpan
argumentSpan :: SrcSpan
  , forall a. Argument a -> Maybe String
argumentName :: Maybe String
  , forall a. Argument a -> ArgumentExpression a
argumentExpr :: ArgumentExpression a
  } deriving stock (Argument a -> Argument a -> Bool
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
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, Argument a -> DataType
Argument a -> Constr
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 (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))
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, 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 -> 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)

-- | Extra data type to disambiguate between plain variable arguments and
--   expression arguments (due to apparent behaviour of some Fortran compilers
--   to treat these differently).
--
-- Note the 'Annotated' and 'Spanned' instances pass to the inner 'Expression'
-- for 'ArgExpr'.
data ArgumentExpression a
  = ArgExpr              (Expression a)
  | ArgExprVar a SrcSpan Name
  deriving stock (ArgumentExpression a -> ArgumentExpression a -> Bool
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
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, ArgumentExpression a -> DataType
ArgumentExpression a -> Constr
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 (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))
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, 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 -> 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)

instance Annotated ArgumentExpression where
    getAnnotation :: forall a. ArgumentExpression a -> a
getAnnotation = \case
      ArgExpr    Expression a
e         -> forall (f :: * -> *) a. Annotated f => f a -> a
getAnnotation Expression a
e
      ArgExprVar a
a SrcSpan
_ss String
_nm -> a
a
    setAnnotation :: forall a. a -> ArgumentExpression a -> ArgumentExpression a
setAnnotation a
a = \case
      ArgExpr    Expression a
e         -> forall a. Expression a -> ArgumentExpression a
ArgExpr (forall (f :: * -> *) a. Annotated f => a -> f a -> f a
setAnnotation a
a Expression a
e)
      ArgExprVar a
_a SrcSpan
ss String
nm  -> forall a. a -> SrcSpan -> String -> ArgumentExpression a
ArgExprVar a
a SrcSpan
ss String
nm
    modifyAnnotation :: forall a. (a -> a) -> ArgumentExpression a -> ArgumentExpression a
modifyAnnotation a -> a
f = \case
      ArgExpr    Expression a
e        -> forall a. Expression a -> ArgumentExpression a
ArgExpr (forall (f :: * -> *) a. Annotated f => (a -> a) -> f a -> f a
modifyAnnotation a -> a
f Expression a
e)
      ArgExprVar a
a SrcSpan
ss String
nm  -> forall a. a -> SrcSpan -> String -> ArgumentExpression a
ArgExprVar (a -> a
f a
a) SrcSpan
ss String
nm

instance Spanned (ArgumentExpression a) where
    getSpan :: ArgumentExpression a -> SrcSpan
getSpan = \case
      ArgExpr    Expression a
e         -> forall a. Spanned a => a -> SrcSpan
getSpan Expression a
e
      ArgExprVar a
_a SrcSpan
ss String
_nm -> SrcSpan
ss
    setSpan :: SrcSpan -> ArgumentExpression a -> ArgumentExpression a
setSpan SrcSpan
ss = \case
      ArgExpr    Expression a
e        -> forall a. Expression a -> ArgumentExpression a
ArgExpr (forall a. Spanned a => SrcSpan -> a -> a
setSpan SrcSpan
ss Expression a
e)
      ArgExprVar a
a SrcSpan
_ss String
nm -> forall a. a -> SrcSpan -> String -> ArgumentExpression a
ArgExprVar a
a SrcSpan
ss String
nm

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 -> forall a. a -> SrcSpan -> Value a -> Expression a
ExpValue a
a SrcSpan
ss (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) = 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 stock (Attribute a -> Attribute a -> Bool
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
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, Attribute a -> DataType
Attribute a -> Constr
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 (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))
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, 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 -> 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 stock (Intent -> Intent -> Bool
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
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
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, 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
  { forall a. ControlPair a -> a
controlPairAnno :: a
  , forall a. ControlPair a -> SrcSpan
controlPairSpan :: SrcSpan
  , forall a. ControlPair a -> Maybe String
controlPairName :: Maybe String
  , forall a. ControlPair a -> Expression a
controlPairExpr :: Expression a
  } deriving stock (ControlPair a -> ControlPair a -> Bool
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
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, ControlPair a -> DataType
ControlPair a -> Constr
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 (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))
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, 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 -> 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)

-- | Part of ALLOCATE statement.
--
-- There are restrictions on how ALLOCATE options can be combined. See F2018
-- 9.7.1, or:
-- https://www.intel.com/content/www/us/en/develop/documentation/fortran-compiler-oneapi-dev-guide-and-reference/top/language-reference/a-to-z-reference/a-to-b/allocate-statement.html
data AllocOpt a =
    AOStat   -- ^ (output) status of allocation
        a SrcSpan
        (Expression a) -- ^ scalar integer variable
  | AOErrMsg -- ^ (output) error condition if present
        a SrcSpan
        (Expression a) -- ^ scalar character variable
  | AOSource a SrcSpan (Expression a)
  deriving stock (AllocOpt a -> AllocOpt a -> Bool
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
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, AllocOpt a -> DataType
AllocOpt a -> Constr
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 (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))
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, 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 -> 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)

-- | List of names for an IMPLICIT statement.
data ImpList a = ImpList
  { forall a. ImpList a -> a
impListAnno :: a
  , forall a. ImpList a -> SrcSpan
impListSpan :: SrcSpan
  , forall a. ImpList a -> TypeSpec a
impListType :: TypeSpec a
  , forall a. ImpList a -> AList ImpElement a
impListElements :: AList ImpElement a
  } deriving stock (ImpList a -> ImpList a -> Bool
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
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, ImpList a -> DataType
ImpList a -> Constr
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 (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))
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, 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 -> 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 = ImpElement
  { forall a. ImpElement a -> a
impElementAnno :: a
  , forall a. ImpElement a -> SrcSpan
impElementSpan :: SrcSpan
  , forall a. ImpElement a -> Char
impElementFrom :: Char
  , forall a. ImpElement a -> Maybe Char
impElementTo   :: Maybe Char
  } deriving stock (ImpElement a -> ImpElement a -> Bool
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
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, ImpElement a -> DataType
ImpElement a -> Constr
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 (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))
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, 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 -> 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)

-- | A single COMMON block definition.
--
-- The 'Declarator's here shall not contain initializing expressions.
data CommonGroup a = CommonGroup
  { forall a. CommonGroup a -> a
commonGroupAnno :: a
  , forall a. CommonGroup a -> SrcSpan
commonGroupSpan :: SrcSpan
  , forall a. CommonGroup a -> Maybe (Expression a)
commonGroupName :: Maybe (Expression a)
  , forall a. CommonGroup a -> AList Declarator a
commonGroupVars :: AList Declarator a
  } deriving stock (CommonGroup a -> CommonGroup a -> Bool
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
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, CommonGroup a -> DataType
CommonGroup a -> Constr
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 (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))
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, 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 -> 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
  { forall a. Namelist a -> a
namelistAnno :: a
  , forall a. Namelist a -> SrcSpan
namelistSpan :: SrcSpan
  , forall a. Namelist a -> Expression a
namelistName :: Expression a
  , forall a. Namelist a -> AList Expression a
namelistVars :: AList Expression a
  } deriving stock (Namelist a -> Namelist a -> Bool
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
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, Namelist a -> DataType
Namelist a -> Constr
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 (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))
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, 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 -> 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)

-- | The part of a DATA statement describing a single set of initializations.
--
-- The initializer list must be compatible with the name list. Generally, that
-- means either the lengths must be equal, or the name list is the singleton
-- list referring to an array, and the initializer list is compatible with that
-- array's shape.
data DataGroup a = DataGroup
  { forall a. DataGroup a -> a
dataGroupAnno         :: a
  , forall a. DataGroup a -> SrcSpan
dataGroupSpan         :: SrcSpan
  , forall a. DataGroup a -> AList Expression a
dataGroupNames        :: AList Expression a
  , forall a. DataGroup a -> AList Expression a
dataGroupInitializers :: AList Expression a
  } deriving stock (DataGroup a -> DataGroup a -> Bool
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
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, DataGroup a -> DataType
DataGroup a -> Constr
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 (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))
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, 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 -> 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)

-- | Field types in pre-Fortran 90 non-standard structure/record/union
--   extension.
--
-- Structures were obsoleted by derived types in later standards.
--
-- The outer structure is stored in 'StStructure'.
data StructureItem a =
    StructFields    -- ^ Regular field
        a SrcSpan
        (TypeSpec a)                -- ^ Type
        (Maybe (AList Attribute a)) -- ^ Attributes
        (AList Declarator a)        -- ^ Declarators
  | StructUnion     -- ^ Union field
        a SrcSpan
        (AList UnionMap a) -- ^ Union fields
  | StructStructure -- ^ Substructure (nested/inline record/structure)
        a SrcSpan
        (Maybe String)          -- ^ Substructure name
        String                  -- ^ Field name
        (AList StructureItem a) -- ^ Substructure fields
  deriving stock (StructureItem a -> StructureItem a -> Bool
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
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, StructureItem a -> DataType
StructureItem a -> Constr
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 (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))
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, 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 -> 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
  { forall a. UnionMap a -> a
unionMapAnno   :: a
  , forall a. UnionMap a -> SrcSpan
unionMapSpan   :: SrcSpan
  , forall a. UnionMap a -> AList StructureItem a
unionMapFields :: AList StructureItem a
  } deriving stock (UnionMap a -> UnionMap a -> Bool
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
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, UnionMap a -> DataType
UnionMap a -> Constr
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 (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))
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, 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 -> 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 stock (FormatItem a -> FormatItem a -> Bool
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
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, FormatItem a -> DataType
FormatItem a -> Constr
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 (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))
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, 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 -> 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)

-- | Part of the newer (Fortran 2003?) FLUSH statement.
--
-- See: https://www.ibm.com/docs/en/xl-fortran-aix/15.1.0?topic=attributes-flush-fortran-2003
data FlushSpec a
  = FSUnit
        a SrcSpan
        (Expression a) -- ^ scalar integer expression
  | FSIOStat
        a SrcSpan
        (Expression a) -- ^ scalar integer variable
  | FSIOMsg
        a SrcSpan
        (Expression a) -- ^ scalar character variable
  | FSErr
        a SrcSpan
        (Expression a) -- ^ statement label
    deriving stock (FlushSpec a -> FlushSpec a -> Bool
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
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, FlushSpec a -> DataType
FlushSpec a -> Constr
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 (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))
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, 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 -> 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
  { forall a. DoSpecification a -> a
doSpecAnno      :: a
  , forall a. DoSpecification a -> SrcSpan
doSpecSpan      :: SrcSpan
  , forall a. DoSpecification a -> Statement a
doSpecInitial   :: Statement a -- ^ Guaranteed to be 'StExpressionAssign'
  , forall a. DoSpecification a -> Expression a
doSpecLimit     :: Expression a
  , forall a. DoSpecification a -> Maybe (Expression a)
doSpecIncrement :: Maybe (Expression a)
  } deriving stock (DoSpecification a -> DoSpecification a -> Bool
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
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, DoSpecification a -> DataType
DoSpecification a -> Constr
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 (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))
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, 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 -> 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) (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 stock (Expression a -> Expression a -> Bool
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
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, Expression a -> DataType
Expression a -> Constr
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 (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))
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, 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 -> 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 stock (Index a -> Index a -> Bool
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
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, Index a -> DataType
Index a -> Constr
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 (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))
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, 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 -> 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)

-- | Values and literals.
--
-- Note that 'KindParam' kind parameters may only be available on certain
-- Fortran parsers. The fixed form parsers (F77, F66) may not parse them.
data Value a
  = ValInteger           String  (Maybe (KindParam a))
  -- ^ The string representation of an integer literal
  | ValReal         RealLit (Maybe (KindParam a))
  -- ^ The string representation of a real literal
  | ValComplex      (ComplexLit a)
  -- ^ The real and imaginary parts of a complex literal @(real, imag)@.
  | 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 (KindParam 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 stock    (Value a -> Value a -> Bool
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
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, Value a -> DataType
Value a -> Constr
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 (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))
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, 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 -> 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)
    deriving anyclass (forall a. NFData a => Value a -> ()
forall a. (a -> ()) -> NFData a
rnf :: Value a -> ()
$crnf :: forall a. NFData a => Value a -> ()
NFData, forall a. Out a => Int -> Value a -> Doc
forall a. Out a => [Value a] -> Doc
forall a. Out a => Value a -> Doc
forall a. (Int -> a -> Doc) -> (a -> Doc) -> ([a] -> Doc) -> Out a
docList :: [Value a] -> Doc
$cdocList :: forall a. Out a => [Value a] -> Doc
doc :: Value a -> Doc
$cdoc :: forall a. Out a => Value a -> Doc
docPrec :: Int -> Value a -> Doc
$cdocPrec :: forall a. Out a => Int -> Value a -> Doc
Out)

-- | 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
  { forall a. Declarator a -> a
declaratorAnno     :: a
  , forall a. Declarator a -> SrcSpan
declaratorSpan     :: SrcSpan
  , forall a. Declarator a -> Expression a
declaratorVariable :: Expression a
  , forall a. Declarator a -> DeclaratorType a
declaratorType     :: DeclaratorType a
  , forall a. Declarator a -> Maybe (Expression a)
declaratorLength   :: Maybe (Expression a)
  , forall a. Declarator a -> Maybe (Expression a)
declaratorInitial  :: Maybe (Expression a)
  } deriving stock (Declarator a -> Declarator a -> Bool
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
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, Declarator a -> DataType
Declarator a -> Constr
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 (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))
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, 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 -> 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 stock (DeclaratorType a -> DeclaratorType a -> Bool
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
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, DeclaratorType a -> DataType
DeclaratorType a -> Constr
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 (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))
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, 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 -> 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)

-- | 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 =
  forall a.
a
-> SrcSpan
-> Expression a
-> DeclaratorType a
-> Maybe (Expression a)
-> Maybe (Expression a)
-> Declarator a
Declarator a
a (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 (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
  { forall a. DimensionDeclarator a -> a
dimDeclAnno :: a
  , forall a. DimensionDeclarator a -> SrcSpan
dimDeclSpan :: SrcSpan
  , forall a. DimensionDeclarator a -> Maybe (Expression a)
dimDeclLower :: Maybe (Expression a)
  , forall a. DimensionDeclarator a -> Maybe (Expression a)
dimDeclUpper :: Maybe (Expression a)
  } deriving stock (DimensionDeclarator a -> DimensionDeclarator a -> Bool
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
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, DimensionDeclarator a -> DataType
DimensionDeclarator a -> Constr
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 (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))
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, 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 -> 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 stock (UnaryOp -> UnaryOp -> Bool
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
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
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
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, 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 stock (BinaryOp -> BinaryOp -> Bool
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
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
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
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, 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

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 FirstParameter (ForallHeader a) a
instance FirstParameter (ForallHeaderPart 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 SecondParameter (ForallHeader a) SrcSpan
instance SecondParameter (ForallHeaderPart a) SrcSpan

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 Annotated ForallHeader
instance Annotated ForallHeaderPart

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 (ForallHeader a)
instance Spanned (ForallHeaderPart 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' -> forall a. Spanned a => a -> SrcSpan
getSpan [ProgramUnit a]
pus'

  setSpan :: SrcSpan -> ProgramFile a -> ProgramFile a
setSpan SrcSpan
_ 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
_ NonEmpty (Expression a, [Block a])
_ Maybe [Block a]
_ Maybe (Expression a)
_) = Maybe (Expression a)
l
  getLabel (BlCase a
_ SrcSpan
_ Maybe (Expression a)
l Maybe String
_ Expression a
_ [(AList Index a, [Block a])]
_ Maybe [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
_ = forall a. Maybe a
Nothing

  getLastLabel :: forall a. Block a -> Maybe (Expression a)
getLastLabel b :: Block a
b@BlStatement{} = forall (f :: * -> *) a. Labeled f => f a -> Maybe (Expression a)
getLabel Block a
b
  getLastLabel (BlIf a
_ SrcSpan
_ Maybe (Expression a)
_ Maybe String
_ NonEmpty (Expression a, [Block a])
_ Maybe [Block a]
_ Maybe (Expression a)
l) = Maybe (Expression a)
l
  getLastLabel (BlCase a
_ SrcSpan
_ Maybe (Expression a)
_ Maybe String
_ Expression a
_ [(AList Index a, [Block a])]
_ Maybe [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
_ = 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 = forall a.
a -> SrcSpan -> Maybe (Expression a) -> Statement a -> Block a
BlStatement a
a SrcSpan
s (forall a. a -> Maybe a
Just Expression a
l) Statement a
st
  setLabel (BlIf a
a SrcSpan
s Maybe (Expression a)
_ Maybe String
mn NonEmpty (Expression a, [Block a])
clauses Maybe [Block a]
elseBlock Maybe (Expression a)
el) Expression a
l = forall a.
a
-> SrcSpan
-> Maybe (Expression a)
-> Maybe String
-> NonEmpty (Expression a, [Block a])
-> Maybe [Block a]
-> Maybe (Expression a)
-> Block a
BlIf a
a SrcSpan
s (forall a. a -> Maybe a
Just Expression a
l) Maybe String
mn NonEmpty (Expression a, [Block a])
clauses Maybe [Block a]
elseBlock 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 = 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 (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 = 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 (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 stock (Eq 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
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
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
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, 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) = forall a.
a
-> SrcSpan
-> Maybe String
-> [Block a]
-> Maybe [ProgramUnit a]
-> ProgramUnit a
PUMain a
a SrcSpan
s (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) = forall a.
a
-> SrcSpan
-> Maybe String
-> [Block a]
-> Maybe [ProgramUnit a]
-> ProgramUnit a
PUMain a
a SrcSpan
s 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) = 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) =
    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) =
    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) = forall a.
a -> SrcSpan -> Maybe String -> [Block a] -> ProgramUnit a
PUBlockData  a
a SrcSpan
s (forall a. a -> Maybe a
Just String
n) [Block a]
b
  setName ProgramUnitName
_         (PUBlockData  a
a SrcSpan
s Maybe String
_ [Block a]
b) = forall a.
a -> SrcSpan -> Maybe String -> [Block a] -> ProgramUnit a
PUBlockData  a
a SrcSpan
s 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 (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)
instance Out a => Out (ForallHeaderPart 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 forall a. Ord a => a -> a -> Bool
>= FortranVersion
Fortran90 = Bool
True
executableStatement FortranVersion
v StEntry{}  | FortranVersion
v forall a. Ord a => a -> a -> Bool
>= FortranVersion
Fortran90 = Bool
True
executableStatement FortranVersion
v StData{}   | FortranVersion
v forall a. Ord a => a -> a -> Bool
>= FortranVersion
Fortran90 = Bool
True
executableStatement FortranVersion
v Statement a
s = Bool -> Bool
not forall a b. (a -> b) -> a -> b
$ 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) = 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) = 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 (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 (ForallHeaderPart 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

instance Out a => Out (NonEmpty a)