{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE DeriveDataTypeable #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE DeriveFunctor #-}
{-# LANGUAGE DefaultSignatures #-}
{-# LANGUAGE FlexibleContexts #-}
-- orphans are instances of package-natives
{-# OPTIONS_GHC -Wno-orphans #-}

module Language.Fortran.AST where

import Prelude hiding (init)
import Data.Data
import Data.Generics.Uniplate.Data ()
import Data.Typeable ()
import Data.Binary
import Control.DeepSeq
import Text.PrettyPrint.GenericPretty
import Language.Fortran.ParserMonad (FortranVersion(..))

import Language.Fortran.Util.Position
import Language.Fortran.Util.FirstParameter
import Language.Fortran.Util.SecondParameter


type A0 = ()

type Name = String

-- AST is polymorphic on some type a as that type is used for arbitrary
-- annotations

-- Many AST nodes such as executable statements, declerations, etc. may
-- appear in lists, hence a dedicated annotated list type is defined
data AList t a = AList a SrcSpan [t a] deriving (AList t a -> AList t a -> Bool
(AList t a -> AList t a -> Bool)
-> (AList t a -> AList t a -> Bool) -> Eq (AList t a)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall (t :: * -> *) a.
(Eq a, Eq (t a)) =>
AList t a -> AList t a -> Bool
/= :: AList t a -> AList t a -> Bool
$c/= :: forall (t :: * -> *) a.
(Eq a, Eq (t a)) =>
AList t a -> AList t a -> Bool
== :: AList t a -> AList t a -> Bool
$c== :: forall (t :: * -> *) a.
(Eq a, Eq (t a)) =>
AList t a -> AList t a -> Bool
Eq, Int -> AList t a -> ShowS
[AList t a] -> ShowS
AList t a -> String
(Int -> AList t a -> ShowS)
-> (AList t a -> String)
-> ([AList t a] -> ShowS)
-> Show (AList t a)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall (t :: * -> *) a.
(Show a, Show (t a)) =>
Int -> AList t a -> ShowS
forall (t :: * -> *) a.
(Show a, Show (t a)) =>
[AList t a] -> ShowS
forall (t :: * -> *) a. (Show a, Show (t a)) => AList t a -> String
showList :: [AList t a] -> ShowS
$cshowList :: forall (t :: * -> *) a.
(Show a, Show (t a)) =>
[AList t a] -> ShowS
show :: AList t a -> String
$cshow :: forall (t :: * -> *) a. (Show a, Show (t a)) => AList t a -> String
showsPrec :: Int -> AList t a -> ShowS
$cshowsPrec :: forall (t :: * -> *) a.
(Show a, Show (t a)) =>
Int -> AList t a -> ShowS
Show, Typeable (AList t a)
DataType
Constr
Typeable (AList t a)
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> AList t a -> c (AList t a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (AList t a))
-> (AList t a -> Constr)
-> (AList t a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (AList t a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (AList t a)))
-> ((forall b. Data b => b -> b) -> AList t a -> AList t a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> AList t a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> AList t a -> r)
-> (forall u. (forall d. Data d => d -> u) -> AList t a -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> AList t a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> AList t a -> m (AList t a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> AList t a -> m (AList t a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> AList t a -> m (AList t a))
-> Data (AList t a)
AList t a -> DataType
AList t a -> Constr
(forall b. Data b => b -> b) -> AList t a -> AList t a
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> AList t a -> c (AList t a)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (AList t a)
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> AList t a -> u
forall u. (forall d. Data d => d -> u) -> AList t a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> AList t a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> AList t a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> AList t a -> m (AList t a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> AList t a -> m (AList t a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (AList t a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> AList t a -> c (AList t a)
forall (t :: * -> *) a.
(Typeable t, Data a, Data (t a)) =>
Typeable (AList t a)
forall (t :: * -> *) a.
(Typeable t, Data a, Data (t a)) =>
AList t a -> DataType
forall (t :: * -> *) a.
(Typeable t, Data a, Data (t a)) =>
AList t a -> Constr
forall (t :: * -> *) a.
(Typeable t, Data a, Data (t a)) =>
(forall b. Data b => b -> b) -> AList t a -> AList t a
forall (t :: * -> *) a u.
(Typeable t, Data a, Data (t a)) =>
Int -> (forall d. Data d => d -> u) -> AList t a -> u
forall (t :: * -> *) a u.
(Typeable t, Data a, Data (t a)) =>
(forall d. Data d => d -> u) -> AList t a -> [u]
forall (t :: * -> *) a r r'.
(Typeable t, Data a, Data (t a)) =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> AList t a -> r
forall (t :: * -> *) a r r'.
(Typeable t, Data a, Data (t a)) =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> AList t a -> r
forall (t :: * -> *) a (m :: * -> *).
(Typeable t, Data a, Data (t a), Monad m) =>
(forall d. Data d => d -> m d) -> AList t a -> m (AList t a)
forall (t :: * -> *) a (m :: * -> *).
(Typeable t, Data a, Data (t a), MonadPlus m) =>
(forall d. Data d => d -> m d) -> AList t a -> m (AList t a)
forall (t :: * -> *) a (c :: * -> *).
(Typeable t, Data a, Data (t a)) =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (AList t a)
forall (t :: * -> *) a (c :: * -> *).
(Typeable t, Data a, Data (t a)) =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> AList t a -> c (AList t a)
forall (t :: * -> *) a (t :: * -> *) (c :: * -> *).
(Typeable t, Data a, Data (t a), Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (AList t a))
forall (t :: * -> *) a (t :: * -> * -> *) (c :: * -> *).
(Typeable t, Data a, Data (t a), Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (AList t a))
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (AList t a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (AList t a))
$cAList :: Constr
$tAList :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> AList t a -> m (AList t a)
$cgmapMo :: forall (t :: * -> *) a (m :: * -> *).
(Typeable t, Data a, Data (t a), MonadPlus m) =>
(forall d. Data d => d -> m d) -> AList t a -> m (AList t a)
gmapMp :: (forall d. Data d => d -> m d) -> AList t a -> m (AList t a)
$cgmapMp :: forall (t :: * -> *) a (m :: * -> *).
(Typeable t, Data a, Data (t a), MonadPlus m) =>
(forall d. Data d => d -> m d) -> AList t a -> m (AList t a)
gmapM :: (forall d. Data d => d -> m d) -> AList t a -> m (AList t a)
$cgmapM :: forall (t :: * -> *) a (m :: * -> *).
(Typeable t, Data a, Data (t a), Monad m) =>
(forall d. Data d => d -> m d) -> AList t a -> m (AList t a)
gmapQi :: Int -> (forall d. Data d => d -> u) -> AList t a -> u
$cgmapQi :: forall (t :: * -> *) a u.
(Typeable t, Data a, Data (t a)) =>
Int -> (forall d. Data d => d -> u) -> AList t a -> u
gmapQ :: (forall d. Data d => d -> u) -> AList t a -> [u]
$cgmapQ :: forall (t :: * -> *) a u.
(Typeable t, Data a, Data (t a)) =>
(forall d. Data d => d -> u) -> AList t a -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> AList t a -> r
$cgmapQr :: forall (t :: * -> *) a r r'.
(Typeable t, Data a, Data (t a)) =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> AList t a -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> AList t a -> r
$cgmapQl :: forall (t :: * -> *) a r r'.
(Typeable t, Data a, Data (t a)) =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> AList t a -> r
gmapT :: (forall b. Data b => b -> b) -> AList t a -> AList t a
$cgmapT :: forall (t :: * -> *) a.
(Typeable t, Data a, Data (t a)) =>
(forall b. Data b => b -> b) -> AList t a -> AList t a
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (AList t a))
$cdataCast2 :: forall (t :: * -> *) a (t :: * -> * -> *) (c :: * -> *).
(Typeable t, Data a, Data (t a), Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (AList t a))
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c (AList t a))
$cdataCast1 :: forall (t :: * -> *) a (t :: * -> *) (c :: * -> *).
(Typeable t, Data a, Data (t a), Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (AList t a))
dataTypeOf :: AList t a -> DataType
$cdataTypeOf :: forall (t :: * -> *) a.
(Typeable t, Data a, Data (t a)) =>
AList t a -> DataType
toConstr :: AList t a -> Constr
$ctoConstr :: forall (t :: * -> *) a.
(Typeable t, Data a, Data (t a)) =>
AList t a -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (AList t a)
$cgunfold :: forall (t :: * -> *) a (c :: * -> *).
(Typeable t, Data a, Data (t a)) =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (AList t a)
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> AList t a -> c (AList t a)
$cgfoldl :: forall (t :: * -> *) a (c :: * -> *).
(Typeable t, Data a, Data (t a)) =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> AList t a -> c (AList t a)
$cp1Data :: forall (t :: * -> *) a.
(Typeable t, Data a, Data (t a)) =>
Typeable (AList t a)
Data, Typeable, (forall x. AList t a -> Rep (AList t a) x)
-> (forall x. Rep (AList t a) x -> AList t a)
-> Generic (AList t a)
forall x. Rep (AList t a) x -> AList t a
forall x. AList t a -> Rep (AList t a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall (t :: * -> *) a x. Rep (AList t a) x -> AList t a
forall (t :: * -> *) a x. AList t a -> Rep (AList t a) x
$cto :: forall (t :: * -> *) a x. Rep (AList t a) x -> AList t a
$cfrom :: forall (t :: * -> *) a x. AList t a -> Rep (AList t a) x
Generic)
instance Functor t => Functor (AList t) where
  fmap :: (a -> b) -> AList t a -> AList t b
fmap a -> b
f (AList a
a SrcSpan
s [t a]
xs) = b -> SrcSpan -> [t b] -> AList t b
forall (t :: * -> *) a. a -> SrcSpan -> [t a] -> AList t a
AList (a -> b
f a
a) SrcSpan
s ((t a -> t b) -> [t a] -> [t b]
forall a b. (a -> b) -> [a] -> [b]
map ((a -> b) -> t a -> t b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> b
f) [t a]
xs)


-- Convert non-empty list to AList.
fromList :: Spanned (t a) => a -> [ t a ] -> AList t a
fromList :: a -> [t a] -> AList t a
fromList a
a [t a]
xs = a -> SrcSpan -> [t a] -> AList t a
forall (t :: * -> *) a. a -> SrcSpan -> [t a] -> AList t a
AList a
a ([t a] -> SrcSpan
forall a. Spanned a => a -> SrcSpan
getSpan [t a]
xs) [t a]
xs

-- Nothing iff list is empty
fromList' :: Spanned (t a) => a -> [ t a ] -> Maybe (AList t a)
fromList' :: a -> [t a] -> Maybe (AList t a)
fromList' a
_ [] = Maybe (AList t a)
forall a. Maybe a
Nothing
fromList' a
a [t a]
xs = AList t a -> Maybe (AList t a)
forall a. a -> Maybe a
Just (AList t a -> Maybe (AList t a)) -> AList t a -> Maybe (AList t a)
forall a b. (a -> b) -> a -> b
$ a -> [t a] -> AList t a
forall (t :: * -> *) a. Spanned (t a) => a -> [t a] -> AList t a
fromList a
a [t a]
xs

fromReverseList :: Spanned (t ()) => [ t () ] -> AList t ()
fromReverseList :: [t ()] -> AList t ()
fromReverseList = () -> [t ()] -> AList t ()
forall (t :: * -> *) a. Spanned (t a) => a -> [t a] -> AList t a
fromList () ([t ()] -> AList t ())
-> ([t ()] -> [t ()]) -> [t ()] -> AList t ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [t ()] -> [t ()]
forall a. [a] -> [a]
reverse

fromReverseList' :: Spanned (t ()) => [ t () ] -> Maybe (AList t ())
fromReverseList' :: [t ()] -> Maybe (AList t ())
fromReverseList' = () -> [t ()] -> Maybe (AList t ())
forall (t :: * -> *) a.
Spanned (t a) =>
a -> [t a] -> Maybe (AList t a)
fromList' () ([t ()] -> Maybe (AList t ()))
-> ([t ()] -> [t ()]) -> [t ()] -> Maybe (AList t ())
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [t ()] -> [t ()]
forall a. [a] -> [a]
reverse

aCons :: t a -> AList t a -> AList t a
aCons :: t a -> AList t a -> AList t a
aCons t a
x (AList a
a SrcSpan
s [t a]
xs) = a -> SrcSpan -> [t a] -> AList t a
forall (t :: * -> *) a. a -> SrcSpan -> [t a] -> AList t a
AList a
a SrcSpan
s ([t a] -> AList t a) -> [t a] -> AList t a
forall a b. (a -> b) -> a -> b
$ t a
xt a -> [t a] -> [t a]
forall a. a -> [a] -> [a]
:[t a]
xs

infixr 5 `aCons`

aReverse :: AList t a -> AList t a
aReverse :: AList t a -> AList t a
aReverse (AList a
a SrcSpan
s [t a]
xs) = a -> SrcSpan -> [t a] -> AList t a
forall (t :: * -> *) a. a -> SrcSpan -> [t a] -> AList t a
AList a
a SrcSpan
s ([t a] -> AList t a) -> [t a] -> AList t a
forall a b. (a -> b) -> a -> b
$ [t a] -> [t a]
forall a. [a] -> [a]
reverse [t a]
xs

aStrip :: AList t a -> [t a]
aStrip :: AList t a -> [t a]
aStrip (AList a
_ SrcSpan
_ [t a]
l) = [t a]
l

aStrip' :: Maybe (AList t a) -> [t a]
aStrip' :: Maybe (AList t a) -> [t a]
aStrip' Maybe (AList t a)
Nothing = []
aStrip' (Just AList t a
a) = AList t a -> [t a]
forall (t :: * -> *) a. AList t a -> [t a]
aStrip AList t a
a

aMap :: (t a -> r a) -> AList t a -> AList r a
aMap :: (t a -> r a) -> AList t a -> AList r a
aMap t a -> r a
f (AList a
a SrcSpan
s [t a]
xs) = a -> SrcSpan -> [r a] -> AList r a
forall (t :: * -> *) a. a -> SrcSpan -> [t a] -> AList t a
AList a
a SrcSpan
s ((t a -> r a) -> [t a] -> [r a]
forall a b. (a -> b) -> [a] -> [b]
map t a -> r a
f [t a]
xs)

-- Basic AST nodes
data BaseType =
    TypeInteger
  | TypeReal
  | TypeDoublePrecision
  | TypeComplex
  | TypeDoubleComplex
  | TypeLogical
  | TypeCharacter (Maybe CharacterLen) (Maybe String) -- ^ len and kind, if specified
  | TypeCustom String
  | ClassStar
  | ClassCustom String
  | TypeByte
  deriving (Eq BaseType
Eq BaseType
-> (BaseType -> BaseType -> Ordering)
-> (BaseType -> BaseType -> Bool)
-> (BaseType -> BaseType -> Bool)
-> (BaseType -> BaseType -> Bool)
-> (BaseType -> BaseType -> Bool)
-> (BaseType -> BaseType -> BaseType)
-> (BaseType -> BaseType -> BaseType)
-> Ord BaseType
BaseType -> BaseType -> Bool
BaseType -> BaseType -> Ordering
BaseType -> BaseType -> BaseType
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: BaseType -> BaseType -> BaseType
$cmin :: BaseType -> BaseType -> BaseType
max :: BaseType -> BaseType -> BaseType
$cmax :: BaseType -> BaseType -> BaseType
>= :: BaseType -> BaseType -> Bool
$c>= :: BaseType -> BaseType -> Bool
> :: BaseType -> BaseType -> Bool
$c> :: BaseType -> BaseType -> Bool
<= :: BaseType -> BaseType -> Bool
$c<= :: BaseType -> BaseType -> Bool
< :: BaseType -> BaseType -> Bool
$c< :: BaseType -> BaseType -> Bool
compare :: BaseType -> BaseType -> Ordering
$ccompare :: BaseType -> BaseType -> Ordering
$cp1Ord :: Eq BaseType
Ord, BaseType -> BaseType -> Bool
(BaseType -> BaseType -> Bool)
-> (BaseType -> BaseType -> Bool) -> Eq BaseType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: BaseType -> BaseType -> Bool
$c/= :: BaseType -> BaseType -> Bool
== :: BaseType -> BaseType -> Bool
$c== :: BaseType -> BaseType -> Bool
Eq, Int -> BaseType -> ShowS
[BaseType] -> ShowS
BaseType -> String
(Int -> BaseType -> ShowS)
-> (BaseType -> String) -> ([BaseType] -> ShowS) -> Show BaseType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [BaseType] -> ShowS
$cshowList :: [BaseType] -> ShowS
show :: BaseType -> String
$cshow :: BaseType -> String
showsPrec :: Int -> BaseType -> ShowS
$cshowsPrec :: Int -> BaseType -> ShowS
Show, Typeable BaseType
DataType
Constr
Typeable BaseType
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> BaseType -> c BaseType)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c BaseType)
-> (BaseType -> Constr)
-> (BaseType -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c BaseType))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c BaseType))
-> ((forall b. Data b => b -> b) -> BaseType -> BaseType)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> BaseType -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> BaseType -> r)
-> (forall u. (forall d. Data d => d -> u) -> BaseType -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> BaseType -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> BaseType -> m BaseType)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> BaseType -> m BaseType)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> BaseType -> m BaseType)
-> Data BaseType
BaseType -> DataType
BaseType -> Constr
(forall b. Data b => b -> b) -> BaseType -> BaseType
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BaseType -> c BaseType
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c 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)
$cTypeByte :: Constr
$cClassCustom :: Constr
$cClassStar :: Constr
$cTypeCustom :: Constr
$cTypeCharacter :: Constr
$cTypeLogical :: Constr
$cTypeDoubleComplex :: Constr
$cTypeComplex :: Constr
$cTypeDoublePrecision :: Constr
$cTypeReal :: Constr
$cTypeInteger :: Constr
$tBaseType :: DataType
gmapMo :: (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 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 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 :: Int -> (forall d. Data d => d -> u) -> BaseType -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> BaseType -> u
gmapQ :: (forall d. Data d => d -> u) -> BaseType -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> BaseType -> [u]
gmapQr :: (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 :: (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 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 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 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 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
$cp1Data :: Typeable BaseType
Data, Typeable, (forall x. BaseType -> Rep BaseType x)
-> (forall x. Rep BaseType x -> BaseType) -> Generic BaseType
forall x. Rep BaseType x -> BaseType
forall x. BaseType -> Rep BaseType x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep BaseType x -> BaseType
$cfrom :: forall x. BaseType -> Rep BaseType x
Generic)

instance Binary BaseType

data CharacterLen = CharLenStar    -- ^ specified with a *
                  | CharLenColon   -- ^ specified with a : (Fortran2003)
                    -- FIXME, possibly, with a more robust const-exp:
                  | CharLenExp     -- ^ specified with a non-trivial expression
                  | CharLenInt Int -- ^ specified with a constant integer
  deriving (Eq CharacterLen
Eq CharacterLen
-> (CharacterLen -> CharacterLen -> Ordering)
-> (CharacterLen -> CharacterLen -> Bool)
-> (CharacterLen -> CharacterLen -> Bool)
-> (CharacterLen -> CharacterLen -> Bool)
-> (CharacterLen -> CharacterLen -> Bool)
-> (CharacterLen -> CharacterLen -> CharacterLen)
-> (CharacterLen -> CharacterLen -> CharacterLen)
-> Ord CharacterLen
CharacterLen -> CharacterLen -> Bool
CharacterLen -> CharacterLen -> Ordering
CharacterLen -> CharacterLen -> CharacterLen
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 :: CharacterLen -> CharacterLen -> CharacterLen
$cmin :: CharacterLen -> CharacterLen -> CharacterLen
max :: CharacterLen -> CharacterLen -> CharacterLen
$cmax :: CharacterLen -> CharacterLen -> CharacterLen
>= :: CharacterLen -> CharacterLen -> Bool
$c>= :: CharacterLen -> CharacterLen -> Bool
> :: CharacterLen -> CharacterLen -> Bool
$c> :: CharacterLen -> CharacterLen -> Bool
<= :: CharacterLen -> CharacterLen -> Bool
$c<= :: CharacterLen -> CharacterLen -> Bool
< :: CharacterLen -> CharacterLen -> Bool
$c< :: CharacterLen -> CharacterLen -> Bool
compare :: CharacterLen -> CharacterLen -> Ordering
$ccompare :: CharacterLen -> CharacterLen -> Ordering
$cp1Ord :: Eq CharacterLen
Ord, CharacterLen -> CharacterLen -> Bool
(CharacterLen -> CharacterLen -> Bool)
-> (CharacterLen -> CharacterLen -> Bool) -> Eq CharacterLen
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CharacterLen -> CharacterLen -> Bool
$c/= :: CharacterLen -> CharacterLen -> Bool
== :: CharacterLen -> CharacterLen -> Bool
$c== :: CharacterLen -> CharacterLen -> Bool
Eq, Int -> CharacterLen -> ShowS
[CharacterLen] -> ShowS
CharacterLen -> String
(Int -> CharacterLen -> ShowS)
-> (CharacterLen -> String)
-> ([CharacterLen] -> ShowS)
-> Show CharacterLen
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CharacterLen] -> ShowS
$cshowList :: [CharacterLen] -> ShowS
show :: CharacterLen -> String
$cshow :: CharacterLen -> String
showsPrec :: Int -> CharacterLen -> ShowS
$cshowsPrec :: Int -> CharacterLen -> ShowS
Show, Typeable CharacterLen
DataType
Constr
Typeable CharacterLen
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> CharacterLen -> c CharacterLen)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c CharacterLen)
-> (CharacterLen -> Constr)
-> (CharacterLen -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c CharacterLen))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c CharacterLen))
-> ((forall b. Data b => b -> b) -> CharacterLen -> CharacterLen)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> CharacterLen -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> CharacterLen -> r)
-> (forall u. (forall d. Data d => d -> u) -> CharacterLen -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> CharacterLen -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> CharacterLen -> m CharacterLen)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> CharacterLen -> m CharacterLen)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> CharacterLen -> m CharacterLen)
-> Data CharacterLen
CharacterLen -> DataType
CharacterLen -> Constr
(forall b. Data b => b -> b) -> CharacterLen -> CharacterLen
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CharacterLen -> c CharacterLen
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CharacterLen
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) -> CharacterLen -> u
forall u. (forall d. Data d => d -> u) -> CharacterLen -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CharacterLen -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CharacterLen -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CharacterLen -> m CharacterLen
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CharacterLen -> m CharacterLen
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CharacterLen
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CharacterLen -> c CharacterLen
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CharacterLen)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c CharacterLen)
$cCharLenInt :: Constr
$cCharLenExp :: Constr
$cCharLenColon :: Constr
$cCharLenStar :: Constr
$tCharacterLen :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> CharacterLen -> m CharacterLen
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CharacterLen -> m CharacterLen
gmapMp :: (forall d. Data d => d -> m d) -> CharacterLen -> m CharacterLen
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CharacterLen -> m CharacterLen
gmapM :: (forall d. Data d => d -> m d) -> CharacterLen -> m CharacterLen
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CharacterLen -> m CharacterLen
gmapQi :: Int -> (forall d. Data d => d -> u) -> CharacterLen -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> CharacterLen -> u
gmapQ :: (forall d. Data d => d -> u) -> CharacterLen -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> CharacterLen -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CharacterLen -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CharacterLen -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CharacterLen -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CharacterLen -> r
gmapT :: (forall b. Data b => b -> b) -> CharacterLen -> CharacterLen
$cgmapT :: (forall b. Data b => b -> b) -> CharacterLen -> CharacterLen
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c CharacterLen)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c CharacterLen)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c CharacterLen)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CharacterLen)
dataTypeOf :: CharacterLen -> DataType
$cdataTypeOf :: CharacterLen -> DataType
toConstr :: CharacterLen -> Constr
$ctoConstr :: CharacterLen -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CharacterLen
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CharacterLen
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CharacterLen -> c CharacterLen
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CharacterLen -> c CharacterLen
$cp1Data :: Typeable CharacterLen
Data, Typeable, (forall x. CharacterLen -> Rep CharacterLen x)
-> (forall x. Rep CharacterLen x -> CharacterLen)
-> Generic CharacterLen
forall x. Rep CharacterLen x -> CharacterLen
forall x. CharacterLen -> Rep CharacterLen x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep CharacterLen x -> CharacterLen
$cfrom :: forall x. CharacterLen -> Rep CharacterLen x
Generic)

instance Binary CharacterLen

charLenSelector :: Maybe (Selector a) -> (Maybe CharacterLen, Maybe String)
charLenSelector :: Maybe (Selector a) -> (Maybe CharacterLen, Maybe String)
charLenSelector Maybe (Selector a)
Nothing                          = (Maybe CharacterLen
forall a. Maybe a
Nothing, Maybe String
forall a. Maybe a
Nothing)
charLenSelector (Just (Selector a
_ SrcSpan
_ Maybe (Expression a)
mlen Maybe (Expression a)
mkind)) = (Maybe CharacterLen
l, Maybe String
k)
  where
    l :: Maybe CharacterLen
l | Just (ExpValue a
_ SrcSpan
_ Value a
ValStar) <- Maybe (Expression a)
mlen        = CharacterLen -> Maybe CharacterLen
forall a. a -> Maybe a
Just CharacterLen
CharLenStar
      | Just (ExpValue a
_ SrcSpan
_ Value a
ValColon) <- Maybe (Expression a)
mlen       = CharacterLen -> Maybe CharacterLen
forall a. a -> Maybe a
Just CharacterLen
CharLenColon
      | Just (ExpValue a
_ SrcSpan
_ (ValInteger String
i)) <- Maybe (Expression a)
mlen = CharacterLen -> Maybe CharacterLen
forall a. a -> Maybe a
Just (CharacterLen -> Maybe CharacterLen)
-> CharacterLen -> Maybe CharacterLen
forall a b. (a -> b) -> a -> b
$ Int -> CharacterLen
CharLenInt (String -> Int
forall a. Read a => String -> a
read String
i)
      | Maybe (Expression a)
Nothing <- Maybe (Expression a)
mlen                            = Maybe CharacterLen
forall a. Maybe a
Nothing
      | Bool
otherwise                                  = CharacterLen -> Maybe CharacterLen
forall a. a -> Maybe a
Just CharacterLen
CharLenExp
    k :: Maybe String
k | Just (ExpValue a
_ SrcSpan
_ (ValInteger String
i)) <- Maybe (Expression a)
mkind  = String -> Maybe String
forall a. a -> Maybe a
Just String
i
      | Just (ExpValue a
_ SrcSpan
_ (ValVariable String
s)) <- Maybe (Expression a)
mkind = String -> Maybe String
forall a. a -> Maybe a
Just String
s
      -- FIXME: some references refer to things like kind=kanji but I can't find any spec for it
      | Bool
otherwise                                    = Maybe String
forall a. Maybe a
Nothing

data TypeSpec a = TypeSpec a SrcSpan BaseType (Maybe (Selector a))
  deriving (TypeSpec a -> TypeSpec a -> Bool
(TypeSpec a -> TypeSpec a -> Bool)
-> (TypeSpec a -> TypeSpec a -> Bool) -> Eq (TypeSpec a)
forall a. Eq a => TypeSpec a -> TypeSpec a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TypeSpec a -> TypeSpec a -> Bool
$c/= :: forall a. Eq a => TypeSpec a -> TypeSpec a -> Bool
== :: TypeSpec a -> TypeSpec a -> Bool
$c== :: forall a. Eq a => TypeSpec a -> TypeSpec a -> Bool
Eq, Int -> TypeSpec a -> ShowS
[TypeSpec a] -> ShowS
TypeSpec a -> String
(Int -> TypeSpec a -> ShowS)
-> (TypeSpec a -> String)
-> ([TypeSpec a] -> ShowS)
-> Show (TypeSpec a)
forall a. Show a => Int -> TypeSpec a -> ShowS
forall a. Show a => [TypeSpec a] -> ShowS
forall a. Show a => TypeSpec a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TypeSpec a] -> ShowS
$cshowList :: forall a. Show a => [TypeSpec a] -> ShowS
show :: TypeSpec a -> String
$cshow :: forall a. Show a => TypeSpec a -> String
showsPrec :: Int -> TypeSpec a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> TypeSpec a -> ShowS
Show, Typeable (TypeSpec a)
DataType
Constr
Typeable (TypeSpec a)
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> TypeSpec a -> c (TypeSpec a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (TypeSpec a))
-> (TypeSpec a -> Constr)
-> (TypeSpec a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (TypeSpec a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (TypeSpec a)))
-> ((forall b. Data b => b -> b) -> TypeSpec a -> TypeSpec a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> TypeSpec a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> TypeSpec a -> r)
-> (forall u. (forall d. Data d => d -> u) -> TypeSpec a -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> TypeSpec a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> TypeSpec a -> m (TypeSpec a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TypeSpec a -> m (TypeSpec a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TypeSpec a -> m (TypeSpec a))
-> Data (TypeSpec a)
TypeSpec a -> DataType
TypeSpec a -> Constr
(forall d. Data d => c (t d)) -> Maybe (c (TypeSpec a))
(forall b. Data b => b -> b) -> TypeSpec a -> TypeSpec a
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TypeSpec a -> c (TypeSpec a)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (TypeSpec a)
forall a. Data a => Typeable (TypeSpec a)
forall a. Data a => TypeSpec a -> DataType
forall a. Data a => TypeSpec a -> Constr
forall a.
Data a =>
(forall b. Data b => b -> b) -> TypeSpec a -> TypeSpec a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> TypeSpec a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> TypeSpec a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TypeSpec a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TypeSpec a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> TypeSpec a -> m (TypeSpec a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> TypeSpec a -> m (TypeSpec a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (TypeSpec a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TypeSpec a -> c (TypeSpec a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (TypeSpec a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (TypeSpec a))
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> TypeSpec a -> u
forall u. (forall d. Data d => d -> u) -> TypeSpec a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TypeSpec a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TypeSpec a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TypeSpec a -> m (TypeSpec a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TypeSpec a -> m (TypeSpec a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (TypeSpec a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TypeSpec a -> c (TypeSpec a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (TypeSpec a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (TypeSpec a))
$cTypeSpec :: Constr
$tTypeSpec :: DataType
gmapMo :: (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 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 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 :: 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 d. Data d => d -> u) -> TypeSpec a -> [u]
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> TypeSpec a -> [u]
gmapQr :: (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 :: (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 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 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 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 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)
$cp1Data :: forall a. Data a => Typeable (TypeSpec a)
Data, Typeable, (forall x. TypeSpec a -> Rep (TypeSpec a) x)
-> (forall x. Rep (TypeSpec a) x -> TypeSpec a)
-> Generic (TypeSpec a)
forall x. Rep (TypeSpec a) x -> TypeSpec a
forall x. TypeSpec a -> Rep (TypeSpec a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (TypeSpec a) x -> TypeSpec a
forall a x. TypeSpec a -> Rep (TypeSpec a) x
$cto :: forall a x. Rep (TypeSpec a) x -> TypeSpec a
$cfrom :: forall a x. TypeSpec a -> Rep (TypeSpec a) x
Generic, a -> TypeSpec b -> TypeSpec a
(a -> b) -> TypeSpec a -> TypeSpec b
(forall a b. (a -> b) -> TypeSpec a -> TypeSpec b)
-> (forall a b. a -> TypeSpec b -> TypeSpec a) -> Functor TypeSpec
forall a b. a -> TypeSpec b -> TypeSpec a
forall a b. (a -> b) -> TypeSpec a -> TypeSpec b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> TypeSpec b -> TypeSpec a
$c<$ :: forall a b. a -> TypeSpec b -> TypeSpec a
fmap :: (a -> b) -> TypeSpec a -> TypeSpec b
$cfmap :: forall a b. (a -> b) -> TypeSpec a -> TypeSpec b
Functor)

data Selector a =
--                   Maybe length         | Maybe kind
  Selector a SrcSpan (Maybe (Expression a)) (Maybe (Expression a))
  deriving (Selector a -> Selector a -> Bool
(Selector a -> Selector a -> Bool)
-> (Selector a -> Selector a -> Bool) -> Eq (Selector a)
forall a. Eq a => Selector a -> Selector a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Selector a -> Selector a -> Bool
$c/= :: forall a. Eq a => Selector a -> Selector a -> Bool
== :: Selector a -> Selector a -> Bool
$c== :: forall a. Eq a => Selector a -> Selector a -> Bool
Eq, Int -> Selector a -> ShowS
[Selector a] -> ShowS
Selector a -> String
(Int -> Selector a -> ShowS)
-> (Selector a -> String)
-> ([Selector a] -> ShowS)
-> Show (Selector a)
forall a. Show a => Int -> Selector a -> ShowS
forall a. Show a => [Selector a] -> ShowS
forall a. Show a => Selector a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Selector a] -> ShowS
$cshowList :: forall a. Show a => [Selector a] -> ShowS
show :: Selector a -> String
$cshow :: forall a. Show a => Selector a -> String
showsPrec :: Int -> Selector a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> Selector a -> ShowS
Show, Typeable (Selector a)
DataType
Constr
Typeable (Selector a)
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Selector a -> c (Selector a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Selector a))
-> (Selector a -> Constr)
-> (Selector a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Selector a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Selector a)))
-> ((forall b. Data b => b -> b) -> Selector a -> Selector a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Selector a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Selector a -> r)
-> (forall u. (forall d. Data d => d -> u) -> Selector a -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Selector a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Selector a -> m (Selector a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Selector a -> m (Selector a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Selector a -> m (Selector a))
-> Data (Selector a)
Selector a -> DataType
Selector a -> Constr
(forall d. Data d => c (t d)) -> Maybe (c (Selector a))
(forall b. Data b => b -> b) -> Selector a -> Selector a
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Selector a -> c (Selector a)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Selector a)
forall a. Data a => Typeable (Selector a)
forall a. Data a => Selector a -> DataType
forall a. Data a => Selector a -> Constr
forall a.
Data a =>
(forall b. Data b => b -> b) -> Selector a -> Selector a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Selector a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> Selector a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Selector a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Selector a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Selector a -> m (Selector a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Selector a -> m (Selector a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Selector a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Selector a -> c (Selector a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Selector a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Selector a))
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Selector a -> u
forall u. (forall d. Data d => d -> u) -> Selector a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Selector a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Selector a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Selector a -> m (Selector a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Selector a -> m (Selector a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Selector a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Selector a -> c (Selector a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Selector a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Selector a))
$cSelector :: Constr
$tSelector :: DataType
gmapMo :: (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 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 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 :: 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 d. Data d => d -> u) -> Selector a -> [u]
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> Selector a -> [u]
gmapQr :: (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 :: (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 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 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 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 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)
$cp1Data :: forall a. Data a => Typeable (Selector a)
Data, Typeable, (forall x. Selector a -> Rep (Selector a) x)
-> (forall x. Rep (Selector a) x -> Selector a)
-> Generic (Selector a)
forall x. Rep (Selector a) x -> Selector a
forall x. Selector a -> Rep (Selector a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (Selector a) x -> Selector a
forall a x. Selector a -> Rep (Selector a) x
$cto :: forall a x. Rep (Selector a) x -> Selector a
$cfrom :: forall a x. Selector a -> Rep (Selector a) x
Generic, a -> Selector b -> Selector a
(a -> b) -> Selector a -> Selector b
(forall a b. (a -> b) -> Selector a -> Selector b)
-> (forall a b. a -> Selector b -> Selector a) -> Functor Selector
forall a b. a -> Selector b -> Selector a
forall a b. (a -> b) -> Selector a -> Selector b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> Selector b -> Selector a
$c<$ :: forall a b. a -> Selector b -> Selector a
fmap :: (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 (MetaInfo -> MetaInfo -> Bool
(MetaInfo -> MetaInfo -> Bool)
-> (MetaInfo -> MetaInfo -> Bool) -> Eq MetaInfo
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: MetaInfo -> MetaInfo -> Bool
$c/= :: MetaInfo -> MetaInfo -> Bool
== :: MetaInfo -> MetaInfo -> Bool
$c== :: MetaInfo -> MetaInfo -> Bool
Eq, Int -> MetaInfo -> ShowS
[MetaInfo] -> ShowS
MetaInfo -> String
(Int -> MetaInfo -> ShowS)
-> (MetaInfo -> String) -> ([MetaInfo] -> ShowS) -> Show MetaInfo
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [MetaInfo] -> ShowS
$cshowList :: [MetaInfo] -> ShowS
show :: MetaInfo -> String
$cshow :: MetaInfo -> String
showsPrec :: Int -> MetaInfo -> ShowS
$cshowsPrec :: Int -> MetaInfo -> ShowS
Show, Typeable MetaInfo
DataType
Constr
Typeable MetaInfo
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> MetaInfo -> c MetaInfo)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c MetaInfo)
-> (MetaInfo -> Constr)
-> (MetaInfo -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c MetaInfo))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c MetaInfo))
-> ((forall b. Data b => b -> b) -> MetaInfo -> MetaInfo)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> MetaInfo -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> MetaInfo -> r)
-> (forall u. (forall d. Data d => d -> u) -> MetaInfo -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> MetaInfo -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> MetaInfo -> m MetaInfo)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> MetaInfo -> m MetaInfo)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> MetaInfo -> m MetaInfo)
-> Data MetaInfo
MetaInfo -> DataType
MetaInfo -> Constr
(forall b. Data b => b -> b) -> MetaInfo -> MetaInfo
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MetaInfo -> c MetaInfo
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c 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)
$cMetaInfo :: Constr
$tMetaInfo :: DataType
gmapMo :: (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 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 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 :: Int -> (forall d. Data d => d -> u) -> MetaInfo -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> MetaInfo -> u
gmapQ :: (forall d. Data d => d -> u) -> MetaInfo -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> MetaInfo -> [u]
gmapQr :: (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 :: (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 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 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 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 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
$cp1Data :: Typeable MetaInfo
Data, Typeable, (forall x. MetaInfo -> Rep MetaInfo x)
-> (forall x. Rep MetaInfo x -> MetaInfo) -> Generic MetaInfo
forall x. Rep MetaInfo x -> MetaInfo
forall x. MetaInfo -> Rep MetaInfo x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep MetaInfo x -> MetaInfo
$cfrom :: forall x. MetaInfo -> Rep MetaInfo x
Generic)

-- Program structure definition
data ProgramFile a = ProgramFile MetaInfo [ ProgramUnit a ]
  deriving (ProgramFile a -> ProgramFile a -> Bool
(ProgramFile a -> ProgramFile a -> Bool)
-> (ProgramFile a -> ProgramFile a -> Bool) -> Eq (ProgramFile a)
forall a. Eq a => ProgramFile a -> ProgramFile a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ProgramFile a -> ProgramFile a -> Bool
$c/= :: forall a. Eq a => ProgramFile a -> ProgramFile a -> Bool
== :: ProgramFile a -> ProgramFile a -> Bool
$c== :: forall a. Eq a => ProgramFile a -> ProgramFile a -> Bool
Eq, Int -> ProgramFile a -> ShowS
[ProgramFile a] -> ShowS
ProgramFile a -> String
(Int -> ProgramFile a -> ShowS)
-> (ProgramFile a -> String)
-> ([ProgramFile a] -> ShowS)
-> Show (ProgramFile a)
forall a. Show a => Int -> ProgramFile a -> ShowS
forall a. Show a => [ProgramFile a] -> ShowS
forall a. Show a => ProgramFile a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ProgramFile a] -> ShowS
$cshowList :: forall a. Show a => [ProgramFile a] -> ShowS
show :: ProgramFile a -> String
$cshow :: forall a. Show a => ProgramFile a -> String
showsPrec :: Int -> ProgramFile a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> ProgramFile a -> ShowS
Show, Typeable (ProgramFile a)
DataType
Constr
Typeable (ProgramFile a)
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ProgramFile a -> c (ProgramFile a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (ProgramFile a))
-> (ProgramFile a -> Constr)
-> (ProgramFile a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (ProgramFile a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (ProgramFile a)))
-> ((forall b. Data b => b -> b) -> ProgramFile a -> ProgramFile a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ProgramFile a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ProgramFile a -> r)
-> (forall u. (forall d. Data d => d -> u) -> ProgramFile a -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> ProgramFile a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> ProgramFile a -> m (ProgramFile a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> ProgramFile a -> m (ProgramFile a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> ProgramFile a -> m (ProgramFile a))
-> Data (ProgramFile a)
ProgramFile a -> DataType
ProgramFile a -> Constr
(forall d. Data d => c (t d)) -> Maybe (c (ProgramFile a))
(forall b. Data b => b -> b) -> ProgramFile a -> ProgramFile a
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ProgramFile a -> c (ProgramFile a)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ProgramFile a)
forall a. Data a => Typeable (ProgramFile a)
forall a. Data a => ProgramFile a -> DataType
forall a. Data a => ProgramFile a -> Constr
forall a.
Data a =>
(forall b. Data b => b -> b) -> ProgramFile a -> ProgramFile a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> ProgramFile a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> ProgramFile a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ProgramFile a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ProgramFile a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d)
-> ProgramFile a -> m (ProgramFile a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> ProgramFile a -> m (ProgramFile a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ProgramFile a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ProgramFile a -> c (ProgramFile a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (ProgramFile a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ProgramFile a))
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> ProgramFile a -> u
forall u. (forall d. Data d => d -> u) -> ProgramFile a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ProgramFile a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ProgramFile a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> ProgramFile a -> m (ProgramFile a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ProgramFile a -> m (ProgramFile a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ProgramFile a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ProgramFile a -> c (ProgramFile a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (ProgramFile a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ProgramFile a))
$cProgramFile :: Constr
$tProgramFile :: DataType
gmapMo :: (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 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 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 :: 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 d. Data d => d -> u) -> ProgramFile a -> [u]
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> ProgramFile a -> [u]
gmapQr :: (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 :: (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 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 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 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 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)
$cp1Data :: forall a. Data a => Typeable (ProgramFile a)
Data, Typeable, (forall x. ProgramFile a -> Rep (ProgramFile a) x)
-> (forall x. Rep (ProgramFile a) x -> ProgramFile a)
-> Generic (ProgramFile a)
forall x. Rep (ProgramFile a) x -> ProgramFile a
forall x. ProgramFile a -> Rep (ProgramFile a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (ProgramFile a) x -> ProgramFile a
forall a x. ProgramFile a -> Rep (ProgramFile a) x
$cto :: forall a x. Rep (ProgramFile a) x -> ProgramFile a
$cfrom :: forall a x. ProgramFile a -> Rep (ProgramFile a) x
Generic, a -> ProgramFile b -> ProgramFile a
(a -> b) -> ProgramFile a -> ProgramFile b
(forall a b. (a -> b) -> ProgramFile a -> ProgramFile b)
-> (forall a b. a -> ProgramFile b -> ProgramFile a)
-> Functor ProgramFile
forall a b. a -> ProgramFile b -> ProgramFile a
forall a b. (a -> b) -> ProgramFile a -> ProgramFile b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> ProgramFile b -> ProgramFile a
$c<$ :: forall a b. a -> ProgramFile b -> ProgramFile a
fmap :: (a -> b) -> ProgramFile a -> ProgramFile b
$cfmap :: forall a b. (a -> b) -> ProgramFile a -> ProgramFile b
Functor)

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

data ProgramUnit a =
    PUMain
      a SrcSpan
      (Maybe Name) -- Program name
      [Block a] -- Body
      (Maybe [ProgramUnit a]) -- Subprograms
  | PUModule
      a SrcSpan
      Name -- Program name
      [Block a] -- Body
      (Maybe [ProgramUnit a]) -- Subprograms
  | PUSubroutine
      a SrcSpan
      (PrefixSuffix a) -- Subroutine options
      Name
      (Maybe (AList Expression a)) -- Arguments
      [Block a] -- Body
      (Maybe [ProgramUnit a]) -- Subprograms
  | PUFunction
      a SrcSpan
      (Maybe (TypeSpec a)) -- Return type
      (PrefixSuffix a) -- Function Options
      Name
      (Maybe (AList Expression a)) -- Arguments
      (Maybe (Expression a)) -- Result
      [Block a] -- Body
      (Maybe [ProgramUnit a]) -- Subprograms
  | PUBlockData
      a SrcSpan
      (Maybe Name)
      [Block a] -- Body
  | PUComment a SrcSpan (Comment a)
  deriving (ProgramUnit a -> ProgramUnit a -> Bool
(ProgramUnit a -> ProgramUnit a -> Bool)
-> (ProgramUnit a -> ProgramUnit a -> Bool) -> Eq (ProgramUnit a)
forall a. Eq a => ProgramUnit a -> ProgramUnit a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ProgramUnit a -> ProgramUnit a -> Bool
$c/= :: forall a. Eq a => ProgramUnit a -> ProgramUnit a -> Bool
== :: ProgramUnit a -> ProgramUnit a -> Bool
$c== :: forall a. Eq a => ProgramUnit a -> ProgramUnit a -> Bool
Eq, Int -> ProgramUnit a -> ShowS
[ProgramUnit a] -> ShowS
ProgramUnit a -> String
(Int -> ProgramUnit a -> ShowS)
-> (ProgramUnit a -> String)
-> ([ProgramUnit a] -> ShowS)
-> Show (ProgramUnit a)
forall a. Show a => Int -> ProgramUnit a -> ShowS
forall a. Show a => [ProgramUnit a] -> ShowS
forall a. Show a => ProgramUnit a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ProgramUnit a] -> ShowS
$cshowList :: forall a. Show a => [ProgramUnit a] -> ShowS
show :: ProgramUnit a -> String
$cshow :: forall a. Show a => ProgramUnit a -> String
showsPrec :: Int -> ProgramUnit a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> ProgramUnit a -> ShowS
Show, Typeable (ProgramUnit a)
DataType
Constr
Typeable (ProgramUnit a)
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ProgramUnit a -> c (ProgramUnit a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (ProgramUnit a))
-> (ProgramUnit a -> Constr)
-> (ProgramUnit a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (ProgramUnit a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (ProgramUnit a)))
-> ((forall b. Data b => b -> b) -> ProgramUnit a -> ProgramUnit a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ProgramUnit a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ProgramUnit a -> r)
-> (forall u. (forall d. Data d => d -> u) -> ProgramUnit a -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> ProgramUnit a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> ProgramUnit a -> m (ProgramUnit a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> ProgramUnit a -> m (ProgramUnit a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> ProgramUnit a -> m (ProgramUnit a))
-> Data (ProgramUnit a)
ProgramUnit a -> DataType
ProgramUnit a -> Constr
(forall d. Data d => c (t d)) -> Maybe (c (ProgramUnit a))
(forall b. Data b => b -> b) -> ProgramUnit a -> ProgramUnit a
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ProgramUnit a -> c (ProgramUnit a)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ProgramUnit a)
forall a. Data a => Typeable (ProgramUnit a)
forall a. Data a => ProgramUnit a -> DataType
forall a. Data a => ProgramUnit a -> Constr
forall a.
Data a =>
(forall b. Data b => b -> b) -> ProgramUnit a -> ProgramUnit a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> ProgramUnit a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> ProgramUnit a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ProgramUnit a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ProgramUnit a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d)
-> ProgramUnit a -> m (ProgramUnit a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> ProgramUnit a -> m (ProgramUnit a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ProgramUnit a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ProgramUnit a -> c (ProgramUnit a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (ProgramUnit a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ProgramUnit a))
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> ProgramUnit a -> u
forall u. (forall d. Data d => d -> u) -> ProgramUnit a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ProgramUnit a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ProgramUnit a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> ProgramUnit a -> m (ProgramUnit a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ProgramUnit a -> m (ProgramUnit a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ProgramUnit a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ProgramUnit a -> c (ProgramUnit a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (ProgramUnit a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ProgramUnit a))
$cPUComment :: Constr
$cPUBlockData :: Constr
$cPUFunction :: Constr
$cPUSubroutine :: Constr
$cPUModule :: Constr
$cPUMain :: Constr
$tProgramUnit :: DataType
gmapMo :: (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 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 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 :: 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 d. Data d => d -> u) -> ProgramUnit a -> [u]
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> ProgramUnit a -> [u]
gmapQr :: (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 :: (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 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 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 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 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)
$cp1Data :: forall a. Data a => Typeable (ProgramUnit a)
Data, Typeable, (forall x. ProgramUnit a -> Rep (ProgramUnit a) x)
-> (forall x. Rep (ProgramUnit a) x -> ProgramUnit a)
-> Generic (ProgramUnit a)
forall x. Rep (ProgramUnit a) x -> ProgramUnit a
forall x. ProgramUnit a -> Rep (ProgramUnit a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (ProgramUnit a) x -> ProgramUnit a
forall a x. ProgramUnit a -> Rep (ProgramUnit a) x
$cto :: forall a x. Rep (ProgramUnit a) x -> ProgramUnit a
$cfrom :: forall a x. ProgramUnit a -> Rep (ProgramUnit a) x
Generic, a -> ProgramUnit b -> ProgramUnit a
(a -> b) -> ProgramUnit a -> ProgramUnit b
(forall a b. (a -> b) -> ProgramUnit a -> ProgramUnit b)
-> (forall a b. a -> ProgramUnit b -> ProgramUnit a)
-> Functor ProgramUnit
forall a b. a -> ProgramUnit b -> ProgramUnit a
forall a b. (a -> b) -> ProgramUnit a -> ProgramUnit b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> ProgramUnit b -> ProgramUnit a
$c<$ :: forall a b. a -> ProgramUnit b -> ProgramUnit a
fmap :: (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 :: Prefixes a
emptyPrefixes = Prefixes a
forall a. Maybe a
Nothing

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

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

data Prefix a = PfxRecursive a SrcSpan
              | PfxElemental a SrcSpan
              | PfxPure a SrcSpan
  deriving (Prefix a -> Prefix a -> Bool
(Prefix a -> Prefix a -> Bool)
-> (Prefix a -> Prefix a -> Bool) -> Eq (Prefix a)
forall a. Eq a => Prefix a -> Prefix a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Prefix a -> Prefix a -> Bool
$c/= :: forall a. Eq a => Prefix a -> Prefix a -> Bool
== :: Prefix a -> Prefix a -> Bool
$c== :: forall a. Eq a => Prefix a -> Prefix a -> Bool
Eq, Int -> Prefix a -> ShowS
[Prefix a] -> ShowS
Prefix a -> String
(Int -> Prefix a -> ShowS)
-> (Prefix a -> String) -> ([Prefix a] -> ShowS) -> Show (Prefix a)
forall a. Show a => Int -> Prefix a -> ShowS
forall a. Show a => [Prefix a] -> ShowS
forall a. Show a => Prefix a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Prefix a] -> ShowS
$cshowList :: forall a. Show a => [Prefix a] -> ShowS
show :: Prefix a -> String
$cshow :: forall a. Show a => Prefix a -> String
showsPrec :: Int -> Prefix a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> Prefix a -> ShowS
Show, Typeable (Prefix a)
DataType
Constr
Typeable (Prefix a)
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Prefix a -> c (Prefix a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Prefix a))
-> (Prefix a -> Constr)
-> (Prefix a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Prefix a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Prefix a)))
-> ((forall b. Data b => b -> b) -> Prefix a -> Prefix a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Prefix a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Prefix a -> r)
-> (forall u. (forall d. Data d => d -> u) -> Prefix a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Prefix a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Prefix a -> m (Prefix a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Prefix a -> m (Prefix a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Prefix a -> m (Prefix a))
-> Data (Prefix a)
Prefix a -> DataType
Prefix a -> Constr
(forall d. Data d => c (t d)) -> Maybe (c (Prefix a))
(forall b. Data b => b -> b) -> Prefix a -> Prefix a
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Prefix a -> c (Prefix a)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Prefix a)
forall a. Data a => Typeable (Prefix a)
forall a. Data a => Prefix a -> DataType
forall a. Data a => Prefix a -> Constr
forall a.
Data a =>
(forall b. Data b => b -> b) -> Prefix a -> Prefix a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Prefix a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> Prefix a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Prefix a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Prefix a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Prefix a -> m (Prefix a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Prefix a -> m (Prefix a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Prefix a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Prefix a -> c (Prefix a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Prefix a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Prefix a))
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Prefix a -> u
forall u. (forall d. Data d => d -> u) -> Prefix a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Prefix a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Prefix a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Prefix a -> m (Prefix a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Prefix a -> m (Prefix a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Prefix a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Prefix a -> c (Prefix a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Prefix a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Prefix a))
$cPfxPure :: Constr
$cPfxElemental :: Constr
$cPfxRecursive :: Constr
$tPrefix :: DataType
gmapMo :: (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 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 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 :: 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 d. Data d => d -> u) -> Prefix a -> [u]
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> Prefix a -> [u]
gmapQr :: (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 :: (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 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 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 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 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)
$cp1Data :: forall a. Data a => Typeable (Prefix a)
Data, Typeable, (forall x. Prefix a -> Rep (Prefix a) x)
-> (forall x. Rep (Prefix a) x -> Prefix a) -> Generic (Prefix a)
forall x. Rep (Prefix a) x -> Prefix a
forall x. Prefix a -> Rep (Prefix a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (Prefix a) x -> Prefix a
forall a x. Prefix a -> Rep (Prefix a) x
$cto :: forall a x. Rep (Prefix a) x -> Prefix a
$cfrom :: forall a x. Prefix a -> Rep (Prefix a) x
Generic, a -> Prefix b -> Prefix a
(a -> b) -> Prefix a -> Prefix b
(forall a b. (a -> b) -> Prefix a -> Prefix b)
-> (forall a b. a -> Prefix b -> Prefix a) -> Functor Prefix
forall a b. a -> Prefix b -> Prefix a
forall a b. (a -> b) -> Prefix a -> Prefix b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> Prefix b -> Prefix a
$c<$ :: forall a b. a -> Prefix b -> Prefix a
fmap :: (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 :: PrefixSuffix a -> Bool
validPrefixSuffix (Prefixes a
mpfxs, Suffixes a
msfxs) =
  Bool -> Bool
not ((Prefix a -> Bool) -> [Prefix a] -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
any Prefix a -> Bool
forall a. Prefix a -> Bool
isElem [Prefix a]
pfxs) Bool -> Bool -> Bool
|| (Bool -> Bool
not ((Prefix a -> Bool) -> [Prefix a] -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
any Prefix a -> Bool
forall a. Prefix a -> Bool
isRec [Prefix a]
pfxs) Bool -> Bool -> Bool
&& Bool -> Bool
not ((Suffix a -> Bool) -> [Suffix a] -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
any Suffix a -> Bool
forall a. Suffix a -> Bool
isBind [Suffix a]
sfxs))
  where
    isElem :: Prefix a -> Bool
isElem (PfxElemental {}) = Bool
True; isElem Prefix a
_ = Bool
False
    isRec :: Prefix a -> Bool
isRec  (PfxRecursive {}) = Bool
True; isRec Prefix a
_  = Bool
False
    isBind :: Suffix a -> Bool
isBind (SfxBind {})      = Bool
True
    pfxs :: [Prefix a]
pfxs = Prefixes a -> [Prefix a]
forall (t :: * -> *) a. Maybe (AList t a) -> [t a]
aStrip' Prefixes a
mpfxs
    sfxs :: [Suffix a]
sfxs = Suffixes a -> [Suffix a]
forall (t :: * -> *) a. Maybe (AList t a) -> [t a]
aStrip' Suffixes a
msfxs

data Suffix a = SfxBind a SrcSpan (Maybe (Expression a))
  deriving (Suffix a -> Suffix a -> Bool
(Suffix a -> Suffix a -> Bool)
-> (Suffix a -> Suffix a -> Bool) -> Eq (Suffix a)
forall a. Eq a => Suffix a -> Suffix a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Suffix a -> Suffix a -> Bool
$c/= :: forall a. Eq a => Suffix a -> Suffix a -> Bool
== :: Suffix a -> Suffix a -> Bool
$c== :: forall a. Eq a => Suffix a -> Suffix a -> Bool
Eq, Int -> Suffix a -> ShowS
[Suffix a] -> ShowS
Suffix a -> String
(Int -> Suffix a -> ShowS)
-> (Suffix a -> String) -> ([Suffix a] -> ShowS) -> Show (Suffix a)
forall a. Show a => Int -> Suffix a -> ShowS
forall a. Show a => [Suffix a] -> ShowS
forall a. Show a => Suffix a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Suffix a] -> ShowS
$cshowList :: forall a. Show a => [Suffix a] -> ShowS
show :: Suffix a -> String
$cshow :: forall a. Show a => Suffix a -> String
showsPrec :: Int -> Suffix a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> Suffix a -> ShowS
Show, Typeable (Suffix a)
DataType
Constr
Typeable (Suffix a)
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Suffix a -> c (Suffix a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Suffix a))
-> (Suffix a -> Constr)
-> (Suffix a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Suffix a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Suffix a)))
-> ((forall b. Data b => b -> b) -> Suffix a -> Suffix a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Suffix a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Suffix a -> r)
-> (forall u. (forall d. Data d => d -> u) -> Suffix a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Suffix a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Suffix a -> m (Suffix a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Suffix a -> m (Suffix a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Suffix a -> m (Suffix a))
-> Data (Suffix a)
Suffix a -> DataType
Suffix a -> Constr
(forall d. Data d => c (t d)) -> Maybe (c (Suffix a))
(forall b. Data b => b -> b) -> Suffix a -> Suffix a
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Suffix a -> c (Suffix a)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Suffix a)
forall a. Data a => Typeable (Suffix a)
forall a. Data a => Suffix a -> DataType
forall a. Data a => Suffix a -> Constr
forall a.
Data a =>
(forall b. Data b => b -> b) -> Suffix a -> Suffix a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Suffix a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> Suffix a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Suffix a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Suffix a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Suffix a -> m (Suffix a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Suffix a -> m (Suffix a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Suffix a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Suffix a -> c (Suffix a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Suffix a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Suffix a))
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Suffix a -> u
forall u. (forall d. Data d => d -> u) -> Suffix a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Suffix a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Suffix a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Suffix a -> m (Suffix a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Suffix a -> m (Suffix a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Suffix a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Suffix a -> c (Suffix a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Suffix a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Suffix a))
$cSfxBind :: Constr
$tSuffix :: DataType
gmapMo :: (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 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 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 :: 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 d. Data d => d -> u) -> Suffix a -> [u]
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> Suffix a -> [u]
gmapQr :: (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 :: (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 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 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 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 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)
$cp1Data :: forall a. Data a => Typeable (Suffix a)
Data, Typeable, (forall x. Suffix a -> Rep (Suffix a) x)
-> (forall x. Rep (Suffix a) x -> Suffix a) -> Generic (Suffix a)
forall x. Rep (Suffix a) x -> Suffix a
forall x. Suffix a -> Rep (Suffix a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (Suffix a) x -> Suffix a
forall a x. Suffix a -> Rep (Suffix a) x
$cto :: forall a x. Rep (Suffix a) x -> Suffix a
$cfrom :: forall a x. Suffix a -> Rep (Suffix a) x
Generic, a -> Suffix b -> Suffix a
(a -> b) -> Suffix a -> Suffix b
(forall a b. (a -> b) -> Suffix a -> Suffix b)
-> (forall a b. a -> Suffix b -> Suffix a) -> Functor Suffix
forall a b. a -> Suffix b -> Suffix a
forall a b. (a -> b) -> Suffix a -> Suffix b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> Suffix b -> Suffix a
$c<$ :: forall a b. a -> Suffix b -> Suffix a
fmap :: (a -> b) -> Suffix a -> Suffix b
$cfmap :: forall a b. (a -> b) -> Suffix a -> Suffix b
Functor)

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

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

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

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

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

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

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

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

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

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

  | BlComment a SrcSpan (Comment a)
  deriving (Block a -> Block a -> Bool
(Block a -> Block a -> Bool)
-> (Block a -> Block a -> Bool) -> Eq (Block a)
forall a. Eq a => Block a -> Block a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Block a -> Block a -> Bool
$c/= :: forall a. Eq a => Block a -> Block a -> Bool
== :: Block a -> Block a -> Bool
$c== :: forall a. Eq a => Block a -> Block a -> Bool
Eq, Int -> Block a -> ShowS
[Block a] -> ShowS
Block a -> String
(Int -> Block a -> ShowS)
-> (Block a -> String) -> ([Block a] -> ShowS) -> Show (Block a)
forall a. Show a => Int -> Block a -> ShowS
forall a. Show a => [Block a] -> ShowS
forall a. Show a => Block a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Block a] -> ShowS
$cshowList :: forall a. Show a => [Block a] -> ShowS
show :: Block a -> String
$cshow :: forall a. Show a => Block a -> String
showsPrec :: Int -> Block a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> Block a -> ShowS
Show, Typeable (Block a)
DataType
Constr
Typeable (Block a)
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Block a -> c (Block a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Block a))
-> (Block a -> Constr)
-> (Block a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Block a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Block a)))
-> ((forall b. Data b => b -> b) -> Block a -> Block a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Block a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Block a -> r)
-> (forall u. (forall d. Data d => d -> u) -> Block a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Block a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Block a -> m (Block a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Block a -> m (Block a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Block a -> m (Block a))
-> Data (Block a)
Block a -> DataType
Block a -> Constr
(forall d. Data d => c (t d)) -> Maybe (c (Block a))
(forall b. Data b => b -> b) -> Block a -> Block a
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Block a -> c (Block a)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Block a)
forall a. Data a => Typeable (Block a)
forall a. Data a => Block a -> DataType
forall a. Data a => Block a -> Constr
forall a.
Data a =>
(forall b. Data b => b -> b) -> Block a -> Block a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Block a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> Block a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Block a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Block a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Block a -> m (Block a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Block a -> m (Block a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Block a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Block a -> c (Block a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Block a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Block a))
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Block a -> u
forall u. (forall d. Data d => d -> u) -> Block a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Block a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Block a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Block a -> m (Block a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Block a -> m (Block a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Block a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Block a -> c (Block a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Block a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Block a))
$cBlComment :: Constr
$cBlInterface :: Constr
$cBlDoWhile :: Constr
$cBlDo :: Constr
$cBlCase :: Constr
$cBlIf :: Constr
$cBlForall :: Constr
$cBlStatement :: Constr
$tBlock :: DataType
gmapMo :: (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 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 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 :: 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 d. Data d => d -> u) -> Block a -> [u]
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> Block a -> [u]
gmapQr :: (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 :: (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 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 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 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 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)
$cp1Data :: forall a. Data a => Typeable (Block a)
Data, Typeable, (forall x. Block a -> Rep (Block a) x)
-> (forall x. Rep (Block a) x -> Block a) -> Generic (Block a)
forall x. Rep (Block a) x -> Block a
forall x. Block a -> Rep (Block a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (Block a) x -> Block a
forall a x. Block a -> Rep (Block a) x
$cto :: forall a x. Rep (Block a) x -> Block a
$cfrom :: forall a x. Block a -> Rep (Block a) x
Generic, a -> Block b -> Block a
(a -> b) -> Block a -> Block b
(forall a b. (a -> b) -> Block a -> Block b)
-> (forall a b. a -> Block b -> Block a) -> Functor Block
forall a b. a -> Block b -> Block a
forall a b. (a -> b) -> Block a -> Block b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> Block b -> Block a
$c<$ :: forall a b. a -> Block b -> Block a
fmap :: (a -> b) -> Block a -> Block b
$cfmap :: forall a b. (a -> b) -> Block a -> Block b
Functor)

data Statement a  =
    StDeclaration         a SrcSpan (TypeSpec a) (Maybe (AList Attribute a)) (AList Declarator a)
  | StStructure           a SrcSpan (Maybe String) (AList StructureItem a)
  | StIntent              a SrcSpan Intent (AList Expression a)
  | StOptional            a SrcSpan (AList Expression a)
  | StPublic              a SrcSpan (Maybe (AList Expression a))
  | StPrivate             a SrcSpan (Maybe (AList Expression a))
  | StProtected           a SrcSpan (Maybe (AList Expression a))
  | StSave                a SrcSpan (Maybe (AList Expression a))
  | StDimension           a SrcSpan (AList Declarator a)
  | StAllocatable         a SrcSpan (AList Declarator a)
  | StAsynchronous        a SrcSpan (AList Declarator a)
  | StPointer             a SrcSpan (AList Declarator a)
  | StTarget              a SrcSpan (AList Declarator a)
  | StValue               a SrcSpan (AList Declarator a)
  | StVolatile            a SrcSpan (AList Declarator a)
  | StData                a SrcSpan (AList DataGroup a)
  | StAutomatic           a SrcSpan (AList Declarator a)
  | StNamelist            a SrcSpan (AList Namelist a)
  | StParameter           a SrcSpan (AList Declarator a)
  | StExternal            a SrcSpan (AList Expression a)
  | StIntrinsic           a SrcSpan (AList Expression a)
  | StCommon              a SrcSpan (AList CommonGroup a)
  | StEquivalence         a SrcSpan (AList (AList Expression) a)
  | StFormat              a SrcSpan (AList FormatItem a)
  | StImplicit            a SrcSpan (Maybe (AList ImpList a))
  | StEntry               a SrcSpan (Expression a) (Maybe (AList Expression a)) (Maybe (Expression a))
  | StInclude             a SrcSpan (Expression a) (Maybe [Block a])
  | StDo                  a SrcSpan (Maybe String) (Maybe (Expression a)) (Maybe (DoSpecification a))
  | StDoWhile             a SrcSpan (Maybe String) (Maybe (Expression a)) (Expression a)
  | StEnddo               a SrcSpan (Maybe String)
  | StCycle               a SrcSpan (Maybe (Expression a))
  | StExit                a SrcSpan (Maybe (Expression a))
  | StIfLogical           a SrcSpan (Expression a) (Statement a) -- Statement should not further recurse
  | StIfArithmetic        a SrcSpan (Expression a) (Expression a) (Expression a) (Expression a)
  | StIfThen              a SrcSpan (Maybe String) (Expression a)
  | StElse                a SrcSpan (Maybe String)
  | StElsif               a SrcSpan (Maybe String) (Expression a)
  | StEndif               a SrcSpan (Maybe String)
  | StSelectCase          a SrcSpan (Maybe String) (Expression a)
  | StCase                a SrcSpan (Maybe String) (Maybe (AList Index a))
  | StEndcase             a SrcSpan (Maybe String)
  | StFunction            a SrcSpan (Expression a) (AList Expression a) (Expression a)
  | StExpressionAssign    a SrcSpan (Expression a) (Expression a)
  | StPointerAssign       a SrcSpan (Expression a) (Expression a)
  | StLabelAssign         a SrcSpan (Expression a) (Expression a)
  | StGotoUnconditional   a SrcSpan (Expression a)
  | StGotoAssigned        a SrcSpan (Expression a) (Maybe (AList Expression a))
  | StGotoComputed        a SrcSpan (AList Expression a) (Expression a)
  | StCall                a SrcSpan (Expression a) (Maybe (AList Argument a))
  | StReturn              a SrcSpan (Maybe (Expression a))
  | StContinue            a SrcSpan
  | StStop                a SrcSpan (Maybe (Expression a))
  | StPause               a SrcSpan (Maybe (Expression a))
  | StRead                a SrcSpan (AList ControlPair a) (Maybe (AList Expression a))
  | StRead2               a SrcSpan (Expression a) (Maybe (AList Expression a))
  | StWrite               a SrcSpan (AList ControlPair a) (Maybe (AList Expression a))
  | StPrint               a SrcSpan (Expression a) (Maybe (AList Expression a))
  | StTypePrint           a SrcSpan (Expression a) (Maybe (AList Expression a))
  | StOpen                a SrcSpan (AList ControlPair a)
  | StClose               a SrcSpan (AList ControlPair a)
  | StFlush               a SrcSpan (AList FlushSpec a)
  | StInquire             a SrcSpan (AList ControlPair a)
  | StRewind              a SrcSpan (AList ControlPair a)
  | StRewind2             a SrcSpan (Expression a)
  | StBackspace           a SrcSpan (AList ControlPair a)
  | StBackspace2          a SrcSpan (Expression a)
  | StEndfile             a SrcSpan (AList ControlPair a)
  | StEndfile2            a SrcSpan (Expression a)
  | StAllocate            a SrcSpan (Maybe (TypeSpec a)) (AList Expression a) (Maybe (AList AllocOpt a))
  | StNullify             a SrcSpan (AList Expression a)
  | StDeallocate          a SrcSpan (AList Expression a) (Maybe (AList AllocOpt a))
  | StWhere               a SrcSpan (Expression a) (Statement a)
  | StWhereConstruct      a SrcSpan (Maybe String) (Expression a)
  | StElsewhere           a SrcSpan (Maybe String) (Maybe (Expression a))
  | StEndWhere            a SrcSpan (Maybe String)
  | StUse                 a SrcSpan (Expression a) (Maybe ModuleNature) Only (Maybe (AList Use a))
  | StModuleProcedure     a SrcSpan (AList Expression a)
  | StProcedure           a SrcSpan (Maybe (ProcInterface a)) (Maybe (Attribute a)) (AList ProcDecl a)
  | StType                a SrcSpan (Maybe (AList Attribute a)) String
  | StEndType             a SrcSpan (Maybe String)
  | StSequence            a SrcSpan
  | StForall              a SrcSpan (Maybe String) (ForallHeader a)
  | StForallStatement     a SrcSpan (ForallHeader a) (Statement a)
  | StEndForall           a SrcSpan (Maybe String)
  | StImport              a SrcSpan (AList Expression a)
  | StEnum                a SrcSpan
  | StEnumerator          a SrcSpan (AList Declarator a)
  | StEndEnum             a SrcSpan
  -- Following is a temporary solution to a complicated FORMAT statement
  -- parsing problem.
  | StFormatBogus         a SrcSpan String
  deriving (Statement a -> Statement a -> Bool
(Statement a -> Statement a -> Bool)
-> (Statement a -> Statement a -> Bool) -> Eq (Statement a)
forall a. Eq a => Statement a -> Statement a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Statement a -> Statement a -> Bool
$c/= :: forall a. Eq a => Statement a -> Statement a -> Bool
== :: Statement a -> Statement a -> Bool
$c== :: forall a. Eq a => Statement a -> Statement a -> Bool
Eq, Int -> Statement a -> ShowS
[Statement a] -> ShowS
Statement a -> String
(Int -> Statement a -> ShowS)
-> (Statement a -> String)
-> ([Statement a] -> ShowS)
-> Show (Statement a)
forall a. Show a => Int -> Statement a -> ShowS
forall a. Show a => [Statement a] -> ShowS
forall a. Show a => Statement a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Statement a] -> ShowS
$cshowList :: forall a. Show a => [Statement a] -> ShowS
show :: Statement a -> String
$cshow :: forall a. Show a => Statement a -> String
showsPrec :: Int -> Statement a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> Statement a -> ShowS
Show, Typeable (Statement a)
DataType
Constr
Typeable (Statement a)
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Statement a -> c (Statement a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Statement a))
-> (Statement a -> Constr)
-> (Statement a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Statement a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Statement a)))
-> ((forall b. Data b => b -> b) -> Statement a -> Statement a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Statement a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Statement a -> r)
-> (forall u. (forall d. Data d => d -> u) -> Statement a -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Statement a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Statement a -> m (Statement a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Statement a -> m (Statement a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Statement a -> m (Statement a))
-> Data (Statement a)
Statement a -> DataType
Statement a -> Constr
(forall d. Data d => c (t d)) -> Maybe (c (Statement a))
(forall b. Data b => b -> b) -> Statement a -> Statement a
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Statement a -> c (Statement a)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Statement a)
forall a. Data a => Typeable (Statement a)
forall a. Data a => Statement a -> DataType
forall a. Data a => Statement a -> Constr
forall a.
Data a =>
(forall b. Data b => b -> b) -> Statement a -> Statement a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Statement a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> Statement a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Statement a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Statement a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Statement a -> m (Statement a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Statement a -> m (Statement a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Statement a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Statement a -> c (Statement a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Statement a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Statement a))
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Statement a -> u
forall u. (forall d. Data d => d -> u) -> Statement a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Statement a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Statement a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Statement a -> m (Statement a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Statement a -> m (Statement a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Statement a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Statement a -> c (Statement a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Statement a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Statement a))
$cStFormatBogus :: Constr
$cStEndEnum :: Constr
$cStEnumerator :: Constr
$cStEnum :: Constr
$cStImport :: Constr
$cStEndForall :: Constr
$cStForallStatement :: Constr
$cStForall :: Constr
$cStSequence :: Constr
$cStEndType :: Constr
$cStType :: Constr
$cStProcedure :: Constr
$cStModuleProcedure :: Constr
$cStUse :: Constr
$cStEndWhere :: Constr
$cStElsewhere :: Constr
$cStWhereConstruct :: Constr
$cStWhere :: Constr
$cStDeallocate :: Constr
$cStNullify :: Constr
$cStAllocate :: Constr
$cStEndfile2 :: Constr
$cStEndfile :: Constr
$cStBackspace2 :: Constr
$cStBackspace :: Constr
$cStRewind2 :: Constr
$cStRewind :: Constr
$cStInquire :: Constr
$cStFlush :: Constr
$cStClose :: Constr
$cStOpen :: Constr
$cStTypePrint :: Constr
$cStPrint :: Constr
$cStWrite :: Constr
$cStRead2 :: Constr
$cStRead :: Constr
$cStPause :: Constr
$cStStop :: Constr
$cStContinue :: Constr
$cStReturn :: Constr
$cStCall :: Constr
$cStGotoComputed :: Constr
$cStGotoAssigned :: Constr
$cStGotoUnconditional :: Constr
$cStLabelAssign :: Constr
$cStPointerAssign :: Constr
$cStExpressionAssign :: Constr
$cStFunction :: Constr
$cStEndcase :: Constr
$cStCase :: Constr
$cStSelectCase :: Constr
$cStEndif :: Constr
$cStElsif :: Constr
$cStElse :: Constr
$cStIfThen :: Constr
$cStIfArithmetic :: Constr
$cStIfLogical :: Constr
$cStExit :: Constr
$cStCycle :: Constr
$cStEnddo :: Constr
$cStDoWhile :: Constr
$cStDo :: Constr
$cStInclude :: Constr
$cStEntry :: Constr
$cStImplicit :: Constr
$cStFormat :: Constr
$cStEquivalence :: Constr
$cStCommon :: Constr
$cStIntrinsic :: Constr
$cStExternal :: Constr
$cStParameter :: Constr
$cStNamelist :: Constr
$cStAutomatic :: Constr
$cStData :: Constr
$cStVolatile :: Constr
$cStValue :: Constr
$cStTarget :: Constr
$cStPointer :: Constr
$cStAsynchronous :: Constr
$cStAllocatable :: Constr
$cStDimension :: Constr
$cStSave :: Constr
$cStProtected :: Constr
$cStPrivate :: Constr
$cStPublic :: Constr
$cStOptional :: Constr
$cStIntent :: Constr
$cStStructure :: Constr
$cStDeclaration :: Constr
$tStatement :: DataType
gmapMo :: (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 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 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 :: 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 d. Data d => d -> u) -> Statement a -> [u]
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> Statement a -> [u]
gmapQr :: (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 :: (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 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 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 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 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)
$cp1Data :: forall a. Data a => Typeable (Statement a)
Data, Typeable, (forall x. Statement a -> Rep (Statement a) x)
-> (forall x. Rep (Statement a) x -> Statement a)
-> Generic (Statement a)
forall x. Rep (Statement a) x -> Statement a
forall x. Statement a -> Rep (Statement a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (Statement a) x -> Statement a
forall a x. Statement a -> Rep (Statement a) x
$cto :: forall a x. Rep (Statement a) x -> Statement a
$cfrom :: forall a x. Statement a -> Rep (Statement a) x
Generic, a -> Statement b -> Statement a
(a -> b) -> Statement a -> Statement b
(forall a b. (a -> b) -> Statement a -> Statement b)
-> (forall a b. a -> Statement b -> Statement a)
-> Functor Statement
forall a b. a -> Statement b -> Statement a
forall a b. (a -> b) -> Statement a -> Statement b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> Statement b -> Statement a
$c<$ :: forall a b. a -> Statement b -> Statement a
fmap :: (a -> b) -> Statement a -> Statement b
$cfmap :: forall a b. (a -> b) -> Statement a -> Statement b
Functor)

-- R1214 proc-decl is procedure-entity-name [=> null-init]
data ProcDecl a = ProcDecl a SrcSpan (Expression a) (Maybe (Expression a))
  deriving (ProcDecl a -> ProcDecl a -> Bool
(ProcDecl a -> ProcDecl a -> Bool)
-> (ProcDecl a -> ProcDecl a -> Bool) -> Eq (ProcDecl a)
forall a. Eq a => ProcDecl a -> ProcDecl a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ProcDecl a -> ProcDecl a -> Bool
$c/= :: forall a. Eq a => ProcDecl a -> ProcDecl a -> Bool
== :: ProcDecl a -> ProcDecl a -> Bool
$c== :: forall a. Eq a => ProcDecl a -> ProcDecl a -> Bool
Eq, Int -> ProcDecl a -> ShowS
[ProcDecl a] -> ShowS
ProcDecl a -> String
(Int -> ProcDecl a -> ShowS)
-> (ProcDecl a -> String)
-> ([ProcDecl a] -> ShowS)
-> Show (ProcDecl a)
forall a. Show a => Int -> ProcDecl a -> ShowS
forall a. Show a => [ProcDecl a] -> ShowS
forall a. Show a => ProcDecl a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ProcDecl a] -> ShowS
$cshowList :: forall a. Show a => [ProcDecl a] -> ShowS
show :: ProcDecl a -> String
$cshow :: forall a. Show a => ProcDecl a -> String
showsPrec :: Int -> ProcDecl a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> ProcDecl a -> ShowS
Show, Typeable (ProcDecl a)
DataType
Constr
Typeable (ProcDecl a)
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ProcDecl a -> c (ProcDecl a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (ProcDecl a))
-> (ProcDecl a -> Constr)
-> (ProcDecl a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (ProcDecl a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (ProcDecl a)))
-> ((forall b. Data b => b -> b) -> ProcDecl a -> ProcDecl a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ProcDecl a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ProcDecl a -> r)
-> (forall u. (forall d. Data d => d -> u) -> ProcDecl a -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> ProcDecl a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ProcDecl a -> m (ProcDecl a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ProcDecl a -> m (ProcDecl a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ProcDecl a -> m (ProcDecl a))
-> Data (ProcDecl a)
ProcDecl a -> DataType
ProcDecl a -> Constr
(forall d. Data d => c (t d)) -> Maybe (c (ProcDecl a))
(forall b. Data b => b -> b) -> ProcDecl a -> ProcDecl a
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ProcDecl a -> c (ProcDecl a)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ProcDecl a)
forall a. Data a => Typeable (ProcDecl a)
forall a. Data a => ProcDecl a -> DataType
forall a. Data a => ProcDecl a -> Constr
forall a.
Data a =>
(forall b. Data b => b -> b) -> ProcDecl a -> ProcDecl a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> ProcDecl a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> ProcDecl a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ProcDecl a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ProcDecl a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> ProcDecl a -> m (ProcDecl a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> ProcDecl a -> m (ProcDecl a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ProcDecl a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ProcDecl a -> c (ProcDecl a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (ProcDecl a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ProcDecl a))
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> ProcDecl a -> u
forall u. (forall d. Data d => d -> u) -> ProcDecl a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ProcDecl a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ProcDecl a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ProcDecl a -> m (ProcDecl a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ProcDecl a -> m (ProcDecl a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ProcDecl a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ProcDecl a -> c (ProcDecl a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (ProcDecl a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ProcDecl a))
$cProcDecl :: Constr
$tProcDecl :: DataType
gmapMo :: (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 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 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 :: 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 d. Data d => d -> u) -> ProcDecl a -> [u]
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> ProcDecl a -> [u]
gmapQr :: (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 :: (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 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 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 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 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)
$cp1Data :: forall a. Data a => Typeable (ProcDecl a)
Data, Typeable, (forall x. ProcDecl a -> Rep (ProcDecl a) x)
-> (forall x. Rep (ProcDecl a) x -> ProcDecl a)
-> Generic (ProcDecl a)
forall x. Rep (ProcDecl a) x -> ProcDecl a
forall x. ProcDecl a -> Rep (ProcDecl a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (ProcDecl a) x -> ProcDecl a
forall a x. ProcDecl a -> Rep (ProcDecl a) x
$cto :: forall a x. Rep (ProcDecl a) x -> ProcDecl a
$cfrom :: forall a x. ProcDecl a -> Rep (ProcDecl a) x
Generic, a -> ProcDecl b -> ProcDecl a
(a -> b) -> ProcDecl a -> ProcDecl b
(forall a b. (a -> b) -> ProcDecl a -> ProcDecl b)
-> (forall a b. a -> ProcDecl b -> ProcDecl a) -> Functor ProcDecl
forall a b. a -> ProcDecl b -> ProcDecl a
forall a b. (a -> b) -> ProcDecl a -> ProcDecl b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> ProcDecl b -> ProcDecl a
$c<$ :: forall a b. a -> ProcDecl b -> ProcDecl a
fmap :: (a -> b) -> ProcDecl a -> ProcDecl b
$cfmap :: forall a b. (a -> b) -> ProcDecl a -> ProcDecl b
Functor)

-- R1212 proc-interface is interface-name or declaration-type-spec
data ProcInterface a = ProcInterfaceName a SrcSpan (Expression a)
                     | ProcInterfaceType a SrcSpan (TypeSpec a)
  deriving (ProcInterface a -> ProcInterface a -> Bool
(ProcInterface a -> ProcInterface a -> Bool)
-> (ProcInterface a -> ProcInterface a -> Bool)
-> Eq (ProcInterface a)
forall a. Eq a => ProcInterface a -> ProcInterface a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ProcInterface a -> ProcInterface a -> Bool
$c/= :: forall a. Eq a => ProcInterface a -> ProcInterface a -> Bool
== :: ProcInterface a -> ProcInterface a -> Bool
$c== :: forall a. Eq a => ProcInterface a -> ProcInterface a -> Bool
Eq, Int -> ProcInterface a -> ShowS
[ProcInterface a] -> ShowS
ProcInterface a -> String
(Int -> ProcInterface a -> ShowS)
-> (ProcInterface a -> String)
-> ([ProcInterface a] -> ShowS)
-> Show (ProcInterface a)
forall a. Show a => Int -> ProcInterface a -> ShowS
forall a. Show a => [ProcInterface a] -> ShowS
forall a. Show a => ProcInterface a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ProcInterface a] -> ShowS
$cshowList :: forall a. Show a => [ProcInterface a] -> ShowS
show :: ProcInterface a -> String
$cshow :: forall a. Show a => ProcInterface a -> String
showsPrec :: Int -> ProcInterface a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> ProcInterface a -> ShowS
Show, Typeable (ProcInterface a)
DataType
Constr
Typeable (ProcInterface a)
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ProcInterface a -> c (ProcInterface a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (ProcInterface a))
-> (ProcInterface a -> Constr)
-> (ProcInterface a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (ProcInterface a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (ProcInterface a)))
-> ((forall b. Data b => b -> b)
    -> ProcInterface a -> ProcInterface a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ProcInterface a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ProcInterface a -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> ProcInterface a -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> ProcInterface a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> ProcInterface a -> m (ProcInterface a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> ProcInterface a -> m (ProcInterface a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> ProcInterface a -> m (ProcInterface a))
-> Data (ProcInterface a)
ProcInterface a -> DataType
ProcInterface a -> Constr
(forall d. Data d => c (t d)) -> Maybe (c (ProcInterface a))
(forall b. Data b => b -> b) -> ProcInterface a -> ProcInterface a
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ProcInterface a -> c (ProcInterface a)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ProcInterface a)
forall a. Data a => Typeable (ProcInterface a)
forall a. Data a => ProcInterface a -> DataType
forall a. Data a => ProcInterface a -> Constr
forall a.
Data a =>
(forall b. Data b => b -> b) -> ProcInterface a -> ProcInterface a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> ProcInterface a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> ProcInterface a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ProcInterface a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ProcInterface a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d)
-> ProcInterface a -> m (ProcInterface a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> ProcInterface a -> m (ProcInterface a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ProcInterface a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ProcInterface a -> c (ProcInterface a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (ProcInterface a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ProcInterface a))
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> ProcInterface a -> u
forall u. (forall d. Data d => d -> u) -> ProcInterface a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ProcInterface a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ProcInterface a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> ProcInterface a -> m (ProcInterface a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ProcInterface a -> m (ProcInterface a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ProcInterface a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ProcInterface a -> c (ProcInterface a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (ProcInterface a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ProcInterface a))
$cProcInterfaceType :: Constr
$cProcInterfaceName :: Constr
$tProcInterface :: DataType
gmapMo :: (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 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 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 :: 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 d. Data d => d -> u) -> ProcInterface a -> [u]
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> ProcInterface a -> [u]
gmapQr :: (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 :: (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 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 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 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 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)
$cp1Data :: forall a. Data a => Typeable (ProcInterface a)
Data, Typeable, (forall x. ProcInterface a -> Rep (ProcInterface a) x)
-> (forall x. Rep (ProcInterface a) x -> ProcInterface a)
-> Generic (ProcInterface a)
forall x. Rep (ProcInterface a) x -> ProcInterface a
forall x. ProcInterface a -> Rep (ProcInterface a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (ProcInterface a) x -> ProcInterface a
forall a x. ProcInterface a -> Rep (ProcInterface a) x
$cto :: forall a x. Rep (ProcInterface a) x -> ProcInterface a
$cfrom :: forall a x. ProcInterface a -> Rep (ProcInterface a) x
Generic, a -> ProcInterface b -> ProcInterface a
(a -> b) -> ProcInterface a -> ProcInterface b
(forall a b. (a -> b) -> ProcInterface a -> ProcInterface b)
-> (forall a b. a -> ProcInterface b -> ProcInterface a)
-> Functor ProcInterface
forall a b. a -> ProcInterface b -> ProcInterface a
forall a b. (a -> b) -> ProcInterface a -> ProcInterface b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> ProcInterface b -> ProcInterface a
$c<$ :: forall a b. a -> ProcInterface b -> ProcInterface a
fmap :: (a -> b) -> ProcInterface a -> ProcInterface b
$cfmap :: forall a b. (a -> b) -> ProcInterface a -> ProcInterface b
Functor)

data ForallHeader a = ForallHeader
    -- List of tuples: index-name, start subscript, end subscript, optional stride
    [(Name, Expression a, Expression a, Maybe (Expression a))]
    -- An optional expression for scaling
    (Maybe (Expression a))
  deriving (ForallHeader a -> ForallHeader a -> Bool
(ForallHeader a -> ForallHeader a -> Bool)
-> (ForallHeader a -> ForallHeader a -> Bool)
-> Eq (ForallHeader a)
forall a. Eq a => ForallHeader a -> ForallHeader a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ForallHeader a -> ForallHeader a -> Bool
$c/= :: forall a. Eq a => ForallHeader a -> ForallHeader a -> Bool
== :: ForallHeader a -> ForallHeader a -> Bool
$c== :: forall a. Eq a => ForallHeader a -> ForallHeader a -> Bool
Eq, Int -> ForallHeader a -> ShowS
[ForallHeader a] -> ShowS
ForallHeader a -> String
(Int -> ForallHeader a -> ShowS)
-> (ForallHeader a -> String)
-> ([ForallHeader a] -> ShowS)
-> Show (ForallHeader a)
forall a. Show a => Int -> ForallHeader a -> ShowS
forall a. Show a => [ForallHeader a] -> ShowS
forall a. Show a => ForallHeader a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ForallHeader a] -> ShowS
$cshowList :: forall a. Show a => [ForallHeader a] -> ShowS
show :: ForallHeader a -> String
$cshow :: forall a. Show a => ForallHeader a -> String
showsPrec :: Int -> ForallHeader a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> ForallHeader a -> ShowS
Show, Typeable (ForallHeader a)
DataType
Constr
Typeable (ForallHeader a)
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ForallHeader a -> c (ForallHeader a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (ForallHeader a))
-> (ForallHeader a -> Constr)
-> (ForallHeader a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (ForallHeader a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (ForallHeader a)))
-> ((forall b. Data b => b -> b)
    -> ForallHeader a -> ForallHeader a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ForallHeader a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ForallHeader a -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> ForallHeader a -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> ForallHeader a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> ForallHeader a -> m (ForallHeader a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> ForallHeader a -> m (ForallHeader a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> ForallHeader a -> m (ForallHeader a))
-> Data (ForallHeader a)
ForallHeader a -> DataType
ForallHeader a -> Constr
(forall d. Data d => c (t d)) -> Maybe (c (ForallHeader a))
(forall b. Data b => b -> b) -> ForallHeader a -> ForallHeader a
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ForallHeader a -> c (ForallHeader a)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ForallHeader a)
forall a. Data a => Typeable (ForallHeader a)
forall a. Data a => ForallHeader a -> DataType
forall a. Data a => ForallHeader a -> Constr
forall a.
Data a =>
(forall b. Data b => b -> b) -> ForallHeader a -> ForallHeader a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> ForallHeader a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> ForallHeader a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ForallHeader a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ForallHeader a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d)
-> ForallHeader a -> m (ForallHeader a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> ForallHeader a -> m (ForallHeader a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ForallHeader a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ForallHeader a -> c (ForallHeader a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (ForallHeader a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ForallHeader a))
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> ForallHeader a -> u
forall u. (forall d. Data d => d -> u) -> ForallHeader a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ForallHeader a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ForallHeader a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> ForallHeader a -> m (ForallHeader a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ForallHeader a -> m (ForallHeader a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ForallHeader a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ForallHeader a -> c (ForallHeader a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (ForallHeader a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ForallHeader a))
$cForallHeader :: Constr
$tForallHeader :: DataType
gmapMo :: (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 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 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 :: 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 d. Data d => d -> u) -> ForallHeader a -> [u]
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> ForallHeader a -> [u]
gmapQr :: (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 :: (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 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 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 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 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)
$cp1Data :: forall a. Data a => Typeable (ForallHeader a)
Data, Typeable, (forall x. ForallHeader a -> Rep (ForallHeader a) x)
-> (forall x. Rep (ForallHeader a) x -> ForallHeader a)
-> Generic (ForallHeader a)
forall x. Rep (ForallHeader a) x -> ForallHeader a
forall x. ForallHeader a -> Rep (ForallHeader a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (ForallHeader a) x -> ForallHeader a
forall a x. ForallHeader a -> Rep (ForallHeader a) x
$cto :: forall a x. Rep (ForallHeader a) x -> ForallHeader a
$cfrom :: forall a x. ForallHeader a -> Rep (ForallHeader a) x
Generic, a -> ForallHeader b -> ForallHeader a
(a -> b) -> ForallHeader a -> ForallHeader b
(forall a b. (a -> b) -> ForallHeader a -> ForallHeader b)
-> (forall a b. a -> ForallHeader b -> ForallHeader a)
-> Functor ForallHeader
forall a b. a -> ForallHeader b -> ForallHeader a
forall a b. (a -> b) -> ForallHeader a -> ForallHeader b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> ForallHeader b -> ForallHeader a
$c<$ :: forall a b. a -> ForallHeader b -> ForallHeader a
fmap :: (a -> b) -> ForallHeader a -> ForallHeader b
$cfmap :: forall a b. (a -> b) -> ForallHeader a -> ForallHeader b
Functor)

data Only = Exclusive | Permissive
  deriving (Only -> Only -> Bool
(Only -> Only -> Bool) -> (Only -> Only -> Bool) -> Eq Only
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Only -> Only -> Bool
$c/= :: Only -> Only -> Bool
== :: Only -> Only -> Bool
$c== :: Only -> Only -> Bool
Eq, Int -> Only -> ShowS
[Only] -> ShowS
Only -> String
(Int -> Only -> ShowS)
-> (Only -> String) -> ([Only] -> ShowS) -> Show Only
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Only] -> ShowS
$cshowList :: [Only] -> ShowS
show :: Only -> String
$cshow :: Only -> String
showsPrec :: Int -> Only -> ShowS
$cshowsPrec :: Int -> Only -> ShowS
Show, Typeable Only
DataType
Constr
Typeable Only
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Only -> c Only)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Only)
-> (Only -> Constr)
-> (Only -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Only))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Only))
-> ((forall b. Data b => b -> b) -> Only -> Only)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Only -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Only -> r)
-> (forall u. (forall d. Data d => d -> u) -> Only -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Only -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Only -> m Only)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Only -> m Only)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Only -> m Only)
-> Data Only
Only -> DataType
Only -> Constr
(forall b. Data b => b -> b) -> Only -> Only
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Only -> c Only
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c 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)
$cPermissive :: Constr
$cExclusive :: Constr
$tOnly :: DataType
gmapMo :: (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 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 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 :: Int -> (forall d. Data d => d -> u) -> Only -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Only -> u
gmapQ :: (forall d. Data d => d -> u) -> Only -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Only -> [u]
gmapQr :: (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 :: (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 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 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 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 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
$cp1Data :: Typeable Only
Data, Typeable, (forall x. Only -> Rep Only x)
-> (forall x. Rep Only x -> Only) -> Generic Only
forall x. Rep Only x -> Only
forall x. Only -> Rep Only x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Only x -> Only
$cfrom :: forall x. Only -> Rep Only x
Generic)

data ModuleNature = ModIntrinsic | ModNonIntrinsic
  deriving (ModuleNature -> ModuleNature -> Bool
(ModuleNature -> ModuleNature -> Bool)
-> (ModuleNature -> ModuleNature -> Bool) -> Eq ModuleNature
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ModuleNature -> ModuleNature -> Bool
$c/= :: ModuleNature -> ModuleNature -> Bool
== :: ModuleNature -> ModuleNature -> Bool
$c== :: ModuleNature -> ModuleNature -> Bool
Eq, Int -> ModuleNature -> ShowS
[ModuleNature] -> ShowS
ModuleNature -> String
(Int -> ModuleNature -> ShowS)
-> (ModuleNature -> String)
-> ([ModuleNature] -> ShowS)
-> Show ModuleNature
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ModuleNature] -> ShowS
$cshowList :: [ModuleNature] -> ShowS
show :: ModuleNature -> String
$cshow :: ModuleNature -> String
showsPrec :: Int -> ModuleNature -> ShowS
$cshowsPrec :: Int -> ModuleNature -> ShowS
Show, Typeable ModuleNature
DataType
Constr
Typeable ModuleNature
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ModuleNature -> c ModuleNature)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ModuleNature)
-> (ModuleNature -> Constr)
-> (ModuleNature -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ModuleNature))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c ModuleNature))
-> ((forall b. Data b => b -> b) -> ModuleNature -> ModuleNature)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ModuleNature -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ModuleNature -> r)
-> (forall u. (forall d. Data d => d -> u) -> ModuleNature -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> ModuleNature -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ModuleNature -> m ModuleNature)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ModuleNature -> m ModuleNature)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ModuleNature -> m ModuleNature)
-> Data ModuleNature
ModuleNature -> DataType
ModuleNature -> Constr
(forall b. Data b => b -> b) -> ModuleNature -> ModuleNature
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ModuleNature -> c ModuleNature
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c 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)
$cModNonIntrinsic :: Constr
$cModIntrinsic :: Constr
$tModuleNature :: DataType
gmapMo :: (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 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 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 :: Int -> (forall d. Data d => d -> u) -> ModuleNature -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ModuleNature -> u
gmapQ :: (forall d. Data d => d -> u) -> ModuleNature -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> ModuleNature -> [u]
gmapQr :: (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 :: (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 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 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 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 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
$cp1Data :: Typeable ModuleNature
Data, Typeable, (forall x. ModuleNature -> Rep ModuleNature x)
-> (forall x. Rep ModuleNature x -> ModuleNature)
-> Generic ModuleNature
forall x. Rep ModuleNature x -> ModuleNature
forall x. ModuleNature -> Rep ModuleNature x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ModuleNature x -> ModuleNature
$cfrom :: forall x. ModuleNature -> Rep ModuleNature x
Generic)

data Use a =
    UseRename a SrcSpan (Expression a) (Expression a)
  | UseID a SrcSpan (Expression a)
  deriving (Use a -> Use a -> Bool
(Use a -> Use a -> Bool) -> (Use a -> Use a -> Bool) -> Eq (Use a)
forall a. Eq a => Use a -> Use a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Use a -> Use a -> Bool
$c/= :: forall a. Eq a => Use a -> Use a -> Bool
== :: Use a -> Use a -> Bool
$c== :: forall a. Eq a => Use a -> Use a -> Bool
Eq, Int -> Use a -> ShowS
[Use a] -> ShowS
Use a -> String
(Int -> Use a -> ShowS)
-> (Use a -> String) -> ([Use a] -> ShowS) -> Show (Use a)
forall a. Show a => Int -> Use a -> ShowS
forall a. Show a => [Use a] -> ShowS
forall a. Show a => Use a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Use a] -> ShowS
$cshowList :: forall a. Show a => [Use a] -> ShowS
show :: Use a -> String
$cshow :: forall a. Show a => Use a -> String
showsPrec :: Int -> Use a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> Use a -> ShowS
Show, Typeable (Use a)
DataType
Constr
Typeable (Use a)
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Use a -> c (Use a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Use a))
-> (Use a -> Constr)
-> (Use a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Use a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Use a)))
-> ((forall b. Data b => b -> b) -> Use a -> Use a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Use a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Use a -> r)
-> (forall u. (forall d. Data d => d -> u) -> Use a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Use a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Use a -> m (Use a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Use a -> m (Use a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Use a -> m (Use a))
-> Data (Use a)
Use a -> DataType
Use a -> Constr
(forall d. Data d => c (t d)) -> Maybe (c (Use a))
(forall b. Data b => b -> b) -> Use a -> Use a
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Use a -> c (Use a)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Use a)
forall a. Data a => Typeable (Use a)
forall a. Data a => Use a -> DataType
forall a. Data a => Use a -> Constr
forall a. Data a => (forall b. Data b => b -> b) -> Use a -> Use a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Use a -> u
forall a u. Data a => (forall d. Data d => d -> u) -> Use a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Use a -> r
forall a r r'.
Data a =>
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Use a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Use a -> m (Use a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Use a -> m (Use a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Use a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Use a -> c (Use a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Use a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Use a))
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Use a -> u
forall u. (forall d. Data d => d -> u) -> Use a -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Use a -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Use a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Use a -> m (Use a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Use a -> m (Use a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Use a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Use a -> c (Use a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Use a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Use a))
$cUseID :: Constr
$cUseRename :: Constr
$tUse :: DataType
gmapMo :: (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 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 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 :: 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 d. Data d => d -> u) -> Use a -> [u]
$cgmapQ :: forall a u. Data a => (forall d. Data d => d -> u) -> Use a -> [u]
gmapQr :: (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 :: (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 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 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 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 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)
$cp1Data :: forall a. Data a => Typeable (Use a)
Data, Typeable, (forall x. Use a -> Rep (Use a) x)
-> (forall x. Rep (Use a) x -> Use a) -> Generic (Use a)
forall x. Rep (Use a) x -> Use a
forall x. Use a -> Rep (Use a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (Use a) x -> Use a
forall a x. Use a -> Rep (Use a) x
$cto :: forall a x. Rep (Use a) x -> Use a
$cfrom :: forall a x. Use a -> Rep (Use a) x
Generic, a -> Use b -> Use a
(a -> b) -> Use a -> Use b
(forall a b. (a -> b) -> Use a -> Use b)
-> (forall a b. a -> Use b -> Use a) -> Functor Use
forall a b. a -> Use b -> Use a
forall a b. (a -> b) -> Use a -> Use b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> Use b -> Use a
$c<$ :: forall a b. a -> Use b -> Use a
fmap :: (a -> b) -> Use a -> Use b
$cfmap :: forall a b. (a -> b) -> Use a -> Use b
Functor)

data Argument a = Argument a SrcSpan (Maybe String) (Expression a)
  deriving (Argument a -> Argument a -> Bool
(Argument a -> Argument a -> Bool)
-> (Argument a -> Argument a -> Bool) -> Eq (Argument a)
forall a. Eq a => Argument a -> Argument a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Argument a -> Argument a -> Bool
$c/= :: forall a. Eq a => Argument a -> Argument a -> Bool
== :: Argument a -> Argument a -> Bool
$c== :: forall a. Eq a => Argument a -> Argument a -> Bool
Eq, Int -> Argument a -> ShowS
[Argument a] -> ShowS
Argument a -> String
(Int -> Argument a -> ShowS)
-> (Argument a -> String)
-> ([Argument a] -> ShowS)
-> Show (Argument a)
forall a. Show a => Int -> Argument a -> ShowS
forall a. Show a => [Argument a] -> ShowS
forall a. Show a => Argument a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Argument a] -> ShowS
$cshowList :: forall a. Show a => [Argument a] -> ShowS
show :: Argument a -> String
$cshow :: forall a. Show a => Argument a -> String
showsPrec :: Int -> Argument a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> Argument a -> ShowS
Show, Typeable (Argument a)
DataType
Constr
Typeable (Argument a)
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Argument a -> c (Argument a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Argument a))
-> (Argument a -> Constr)
-> (Argument a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Argument a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Argument a)))
-> ((forall b. Data b => b -> b) -> Argument a -> Argument a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Argument a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Argument a -> r)
-> (forall u. (forall d. Data d => d -> u) -> Argument a -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Argument a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Argument a -> m (Argument a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Argument a -> m (Argument a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Argument a -> m (Argument a))
-> Data (Argument a)
Argument a -> DataType
Argument a -> Constr
(forall d. Data d => c (t d)) -> Maybe (c (Argument a))
(forall b. Data b => b -> b) -> Argument a -> Argument a
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Argument a -> c (Argument a)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Argument a)
forall a. Data a => Typeable (Argument a)
forall a. Data a => Argument a -> DataType
forall a. Data a => Argument a -> Constr
forall a.
Data a =>
(forall b. Data b => b -> b) -> Argument a -> Argument a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Argument a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> Argument a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Argument a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Argument a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Argument a -> m (Argument a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Argument a -> m (Argument a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Argument a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Argument a -> c (Argument a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Argument a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Argument a))
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Argument a -> u
forall u. (forall d. Data d => d -> u) -> Argument a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Argument a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Argument a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Argument a -> m (Argument a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Argument a -> m (Argument a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Argument a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Argument a -> c (Argument a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Argument a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Argument a))
$cArgument :: Constr
$tArgument :: DataType
gmapMo :: (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 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 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 :: 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 d. Data d => d -> u) -> Argument a -> [u]
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> Argument a -> [u]
gmapQr :: (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 :: (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 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 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 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 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)
$cp1Data :: forall a. Data a => Typeable (Argument a)
Data, Typeable, (forall x. Argument a -> Rep (Argument a) x)
-> (forall x. Rep (Argument a) x -> Argument a)
-> Generic (Argument a)
forall x. Rep (Argument a) x -> Argument a
forall x. Argument a -> Rep (Argument a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (Argument a) x -> Argument a
forall a x. Argument a -> Rep (Argument a) x
$cto :: forall a x. Rep (Argument a) x -> Argument a
$cfrom :: forall a x. Argument a -> Rep (Argument a) x
Generic, a -> Argument b -> Argument a
(a -> b) -> Argument a -> Argument b
(forall a b. (a -> b) -> Argument a -> Argument b)
-> (forall a b. a -> Argument b -> Argument a) -> Functor Argument
forall a b. a -> Argument b -> Argument a
forall a b. (a -> b) -> Argument a -> Argument b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> Argument b -> Argument a
$c<$ :: forall a b. a -> Argument b -> Argument a
fmap :: (a -> b) -> Argument a -> Argument b
$cfmap :: forall a b. (a -> b) -> Argument a -> Argument b
Functor)

data Attribute a =
    AttrAllocatable a SrcSpan
  | AttrAsynchronous a SrcSpan
  | AttrDimension a SrcSpan (AList DimensionDeclarator a)
  | AttrExternal a SrcSpan
  | AttrIntent a SrcSpan Intent
  | AttrIntrinsic a SrcSpan
  | AttrOptional a SrcSpan
  | AttrParameter a SrcSpan
  | AttrPointer a SrcSpan
  | AttrPrivate a SrcSpan
  | AttrProtected a SrcSpan
  | AttrPublic a SrcSpan
  | AttrSave a SrcSpan
  | AttrSuffix a SrcSpan (Suffix a)  -- for language-binding-spec
  | AttrTarget a SrcSpan
  | AttrValue a SrcSpan
  | AttrVolatile a SrcSpan
  deriving (Attribute a -> Attribute a -> Bool
(Attribute a -> Attribute a -> Bool)
-> (Attribute a -> Attribute a -> Bool) -> Eq (Attribute a)
forall a. Eq a => Attribute a -> Attribute a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Attribute a -> Attribute a -> Bool
$c/= :: forall a. Eq a => Attribute a -> Attribute a -> Bool
== :: Attribute a -> Attribute a -> Bool
$c== :: forall a. Eq a => Attribute a -> Attribute a -> Bool
Eq, Int -> Attribute a -> ShowS
[Attribute a] -> ShowS
Attribute a -> String
(Int -> Attribute a -> ShowS)
-> (Attribute a -> String)
-> ([Attribute a] -> ShowS)
-> Show (Attribute a)
forall a. Show a => Int -> Attribute a -> ShowS
forall a. Show a => [Attribute a] -> ShowS
forall a. Show a => Attribute a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Attribute a] -> ShowS
$cshowList :: forall a. Show a => [Attribute a] -> ShowS
show :: Attribute a -> String
$cshow :: forall a. Show a => Attribute a -> String
showsPrec :: Int -> Attribute a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> Attribute a -> ShowS
Show, Typeable (Attribute a)
DataType
Constr
Typeable (Attribute a)
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Attribute a -> c (Attribute a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Attribute a))
-> (Attribute a -> Constr)
-> (Attribute a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Attribute a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Attribute a)))
-> ((forall b. Data b => b -> b) -> Attribute a -> Attribute a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Attribute a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Attribute a -> r)
-> (forall u. (forall d. Data d => d -> u) -> Attribute a -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Attribute a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Attribute a -> m (Attribute a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Attribute a -> m (Attribute a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Attribute a -> m (Attribute a))
-> Data (Attribute a)
Attribute a -> DataType
Attribute a -> Constr
(forall d. Data d => c (t d)) -> Maybe (c (Attribute a))
(forall b. Data b => b -> b) -> Attribute a -> Attribute a
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Attribute a -> c (Attribute a)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Attribute a)
forall a. Data a => Typeable (Attribute a)
forall a. Data a => Attribute a -> DataType
forall a. Data a => Attribute a -> Constr
forall a.
Data a =>
(forall b. Data b => b -> b) -> Attribute a -> Attribute a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Attribute a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> Attribute a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Attribute a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Attribute a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Attribute a -> m (Attribute a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Attribute a -> m (Attribute a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Attribute a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Attribute a -> c (Attribute a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Attribute a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Attribute a))
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Attribute a -> u
forall u. (forall d. Data d => d -> u) -> Attribute a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Attribute a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Attribute a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Attribute a -> m (Attribute a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Attribute a -> m (Attribute a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Attribute a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Attribute a -> c (Attribute a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Attribute a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Attribute a))
$cAttrVolatile :: Constr
$cAttrValue :: Constr
$cAttrTarget :: Constr
$cAttrSuffix :: Constr
$cAttrSave :: Constr
$cAttrPublic :: Constr
$cAttrProtected :: Constr
$cAttrPrivate :: Constr
$cAttrPointer :: Constr
$cAttrParameter :: Constr
$cAttrOptional :: Constr
$cAttrIntrinsic :: Constr
$cAttrIntent :: Constr
$cAttrExternal :: Constr
$cAttrDimension :: Constr
$cAttrAsynchronous :: Constr
$cAttrAllocatable :: Constr
$tAttribute :: DataType
gmapMo :: (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 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 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 :: 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 d. Data d => d -> u) -> Attribute a -> [u]
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> Attribute a -> [u]
gmapQr :: (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 :: (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 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 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 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 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)
$cp1Data :: forall a. Data a => Typeable (Attribute a)
Data, Typeable, (forall x. Attribute a -> Rep (Attribute a) x)
-> (forall x. Rep (Attribute a) x -> Attribute a)
-> Generic (Attribute a)
forall x. Rep (Attribute a) x -> Attribute a
forall x. Attribute a -> Rep (Attribute a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (Attribute a) x -> Attribute a
forall a x. Attribute a -> Rep (Attribute a) x
$cto :: forall a x. Rep (Attribute a) x -> Attribute a
$cfrom :: forall a x. Attribute a -> Rep (Attribute a) x
Generic, a -> Attribute b -> Attribute a
(a -> b) -> Attribute a -> Attribute b
(forall a b. (a -> b) -> Attribute a -> Attribute b)
-> (forall a b. a -> Attribute b -> Attribute a)
-> Functor Attribute
forall a b. a -> Attribute b -> Attribute a
forall a b. (a -> b) -> Attribute a -> Attribute b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> Attribute b -> Attribute a
$c<$ :: forall a b. a -> Attribute b -> Attribute a
fmap :: (a -> b) -> Attribute a -> Attribute b
$cfmap :: forall a b. (a -> b) -> Attribute a -> Attribute b
Functor)

data Intent = In | Out | InOut
  deriving (Intent -> Intent -> Bool
(Intent -> Intent -> Bool)
-> (Intent -> Intent -> Bool) -> Eq Intent
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Intent -> Intent -> Bool
$c/= :: Intent -> Intent -> Bool
== :: Intent -> Intent -> Bool
$c== :: Intent -> Intent -> Bool
Eq, Int -> Intent -> ShowS
[Intent] -> ShowS
Intent -> String
(Int -> Intent -> ShowS)
-> (Intent -> String) -> ([Intent] -> ShowS) -> Show Intent
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Intent] -> ShowS
$cshowList :: [Intent] -> ShowS
show :: Intent -> String
$cshow :: Intent -> String
showsPrec :: Int -> Intent -> ShowS
$cshowsPrec :: Int -> Intent -> ShowS
Show, Typeable Intent
DataType
Constr
Typeable Intent
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Intent -> c Intent)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Intent)
-> (Intent -> Constr)
-> (Intent -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Intent))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Intent))
-> ((forall b. Data b => b -> b) -> Intent -> Intent)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Intent -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Intent -> r)
-> (forall u. (forall d. Data d => d -> u) -> Intent -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Intent -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Intent -> m Intent)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Intent -> m Intent)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Intent -> m Intent)
-> Data Intent
Intent -> DataType
Intent -> Constr
(forall b. Data b => b -> b) -> Intent -> Intent
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Intent -> c Intent
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c 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)
$cInOut :: Constr
$cOut :: Constr
$cIn :: Constr
$tIntent :: DataType
gmapMo :: (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 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 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 :: Int -> (forall d. Data d => d -> u) -> Intent -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Intent -> u
gmapQ :: (forall d. Data d => d -> u) -> Intent -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Intent -> [u]
gmapQr :: (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 :: (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 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 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 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 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
$cp1Data :: Typeable Intent
Data, Typeable, (forall x. Intent -> Rep Intent x)
-> (forall x. Rep Intent x -> Intent) -> Generic Intent
forall x. Rep Intent x -> Intent
forall x. Intent -> Rep Intent x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Intent x -> Intent
$cfrom :: forall x. Intent -> Rep Intent x
Generic)

data ControlPair a = ControlPair a SrcSpan (Maybe String) (Expression a)
  deriving (ControlPair a -> ControlPair a -> Bool
(ControlPair a -> ControlPair a -> Bool)
-> (ControlPair a -> ControlPair a -> Bool) -> Eq (ControlPair a)
forall a. Eq a => ControlPair a -> ControlPair a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ControlPair a -> ControlPair a -> Bool
$c/= :: forall a. Eq a => ControlPair a -> ControlPair a -> Bool
== :: ControlPair a -> ControlPair a -> Bool
$c== :: forall a. Eq a => ControlPair a -> ControlPair a -> Bool
Eq, Int -> ControlPair a -> ShowS
[ControlPair a] -> ShowS
ControlPair a -> String
(Int -> ControlPair a -> ShowS)
-> (ControlPair a -> String)
-> ([ControlPair a] -> ShowS)
-> Show (ControlPair a)
forall a. Show a => Int -> ControlPair a -> ShowS
forall a. Show a => [ControlPair a] -> ShowS
forall a. Show a => ControlPair a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ControlPair a] -> ShowS
$cshowList :: forall a. Show a => [ControlPair a] -> ShowS
show :: ControlPair a -> String
$cshow :: forall a. Show a => ControlPair a -> String
showsPrec :: Int -> ControlPair a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> ControlPair a -> ShowS
Show, Typeable (ControlPair a)
DataType
Constr
Typeable (ControlPair a)
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ControlPair a -> c (ControlPair a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (ControlPair a))
-> (ControlPair a -> Constr)
-> (ControlPair a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (ControlPair a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (ControlPair a)))
-> ((forall b. Data b => b -> b) -> ControlPair a -> ControlPair a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ControlPair a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ControlPair a -> r)
-> (forall u. (forall d. Data d => d -> u) -> ControlPair a -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> ControlPair a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> ControlPair a -> m (ControlPair a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> ControlPair a -> m (ControlPair a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> ControlPair a -> m (ControlPair a))
-> Data (ControlPair a)
ControlPair a -> DataType
ControlPair a -> Constr
(forall d. Data d => c (t d)) -> Maybe (c (ControlPair a))
(forall b. Data b => b -> b) -> ControlPair a -> ControlPair a
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ControlPair a -> c (ControlPair a)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ControlPair a)
forall a. Data a => Typeable (ControlPair a)
forall a. Data a => ControlPair a -> DataType
forall a. Data a => ControlPair a -> Constr
forall a.
Data a =>
(forall b. Data b => b -> b) -> ControlPair a -> ControlPair a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> ControlPair a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> ControlPair a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ControlPair a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ControlPair a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d)
-> ControlPair a -> m (ControlPair a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> ControlPair a -> m (ControlPair a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ControlPair a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ControlPair a -> c (ControlPair a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (ControlPair a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ControlPair a))
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> ControlPair a -> u
forall u. (forall d. Data d => d -> u) -> ControlPair a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ControlPair a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ControlPair a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> ControlPair a -> m (ControlPair a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ControlPair a -> m (ControlPair a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ControlPair a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ControlPair a -> c (ControlPair a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (ControlPair a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ControlPair a))
$cControlPair :: Constr
$tControlPair :: DataType
gmapMo :: (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 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 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 :: 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 d. Data d => d -> u) -> ControlPair a -> [u]
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> ControlPair a -> [u]
gmapQr :: (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 :: (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 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 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 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 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)
$cp1Data :: forall a. Data a => Typeable (ControlPair a)
Data, Typeable, (forall x. ControlPair a -> Rep (ControlPair a) x)
-> (forall x. Rep (ControlPair a) x -> ControlPair a)
-> Generic (ControlPair a)
forall x. Rep (ControlPair a) x -> ControlPair a
forall x. ControlPair a -> Rep (ControlPair a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (ControlPair a) x -> ControlPair a
forall a x. ControlPair a -> Rep (ControlPair a) x
$cto :: forall a x. Rep (ControlPair a) x -> ControlPair a
$cfrom :: forall a x. ControlPair a -> Rep (ControlPair a) x
Generic, a -> ControlPair b -> ControlPair a
(a -> b) -> ControlPair a -> ControlPair b
(forall a b. (a -> b) -> ControlPair a -> ControlPair b)
-> (forall a b. a -> ControlPair b -> ControlPair a)
-> Functor ControlPair
forall a b. a -> ControlPair b -> ControlPair a
forall a b. (a -> b) -> ControlPair a -> ControlPair b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> ControlPair b -> ControlPair a
$c<$ :: forall a b. a -> ControlPair b -> ControlPair a
fmap :: (a -> b) -> ControlPair a -> ControlPair b
$cfmap :: forall a b. (a -> b) -> ControlPair a -> ControlPair b
Functor)

data AllocOpt a =
    AOStat a SrcSpan (Expression a)
  | AOErrMsg a SrcSpan (Expression a)
  | AOSource a SrcSpan (Expression a)
  deriving (AllocOpt a -> AllocOpt a -> Bool
(AllocOpt a -> AllocOpt a -> Bool)
-> (AllocOpt a -> AllocOpt a -> Bool) -> Eq (AllocOpt a)
forall a. Eq a => AllocOpt a -> AllocOpt a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: AllocOpt a -> AllocOpt a -> Bool
$c/= :: forall a. Eq a => AllocOpt a -> AllocOpt a -> Bool
== :: AllocOpt a -> AllocOpt a -> Bool
$c== :: forall a. Eq a => AllocOpt a -> AllocOpt a -> Bool
Eq, Int -> AllocOpt a -> ShowS
[AllocOpt a] -> ShowS
AllocOpt a -> String
(Int -> AllocOpt a -> ShowS)
-> (AllocOpt a -> String)
-> ([AllocOpt a] -> ShowS)
-> Show (AllocOpt a)
forall a. Show a => Int -> AllocOpt a -> ShowS
forall a. Show a => [AllocOpt a] -> ShowS
forall a. Show a => AllocOpt a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [AllocOpt a] -> ShowS
$cshowList :: forall a. Show a => [AllocOpt a] -> ShowS
show :: AllocOpt a -> String
$cshow :: forall a. Show a => AllocOpt a -> String
showsPrec :: Int -> AllocOpt a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> AllocOpt a -> ShowS
Show, Typeable (AllocOpt a)
DataType
Constr
Typeable (AllocOpt a)
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> AllocOpt a -> c (AllocOpt a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (AllocOpt a))
-> (AllocOpt a -> Constr)
-> (AllocOpt a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (AllocOpt a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (AllocOpt a)))
-> ((forall b. Data b => b -> b) -> AllocOpt a -> AllocOpt a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> AllocOpt a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> AllocOpt a -> r)
-> (forall u. (forall d. Data d => d -> u) -> AllocOpt a -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> AllocOpt a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> AllocOpt a -> m (AllocOpt a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> AllocOpt a -> m (AllocOpt a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> AllocOpt a -> m (AllocOpt a))
-> Data (AllocOpt a)
AllocOpt a -> DataType
AllocOpt a -> Constr
(forall d. Data d => c (t d)) -> Maybe (c (AllocOpt a))
(forall b. Data b => b -> b) -> AllocOpt a -> AllocOpt a
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> AllocOpt a -> c (AllocOpt a)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (AllocOpt a)
forall a. Data a => Typeable (AllocOpt a)
forall a. Data a => AllocOpt a -> DataType
forall a. Data a => AllocOpt a -> Constr
forall a.
Data a =>
(forall b. Data b => b -> b) -> AllocOpt a -> AllocOpt a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> AllocOpt a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> AllocOpt a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> AllocOpt a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> AllocOpt a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> AllocOpt a -> m (AllocOpt a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> AllocOpt a -> m (AllocOpt a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (AllocOpt a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> AllocOpt a -> c (AllocOpt a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (AllocOpt a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (AllocOpt a))
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> AllocOpt a -> u
forall u. (forall d. Data d => d -> u) -> AllocOpt a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> AllocOpt a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> AllocOpt a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> AllocOpt a -> m (AllocOpt a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> AllocOpt a -> m (AllocOpt a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (AllocOpt a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> AllocOpt a -> c (AllocOpt a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (AllocOpt a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (AllocOpt a))
$cAOSource :: Constr
$cAOErrMsg :: Constr
$cAOStat :: Constr
$tAllocOpt :: DataType
gmapMo :: (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 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 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 :: 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 d. Data d => d -> u) -> AllocOpt a -> [u]
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> AllocOpt a -> [u]
gmapQr :: (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 :: (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 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 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 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 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)
$cp1Data :: forall a. Data a => Typeable (AllocOpt a)
Data, Typeable, (forall x. AllocOpt a -> Rep (AllocOpt a) x)
-> (forall x. Rep (AllocOpt a) x -> AllocOpt a)
-> Generic (AllocOpt a)
forall x. Rep (AllocOpt a) x -> AllocOpt a
forall x. AllocOpt a -> Rep (AllocOpt a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (AllocOpt a) x -> AllocOpt a
forall a x. AllocOpt a -> Rep (AllocOpt a) x
$cto :: forall a x. Rep (AllocOpt a) x -> AllocOpt a
$cfrom :: forall a x. AllocOpt a -> Rep (AllocOpt a) x
Generic, a -> AllocOpt b -> AllocOpt a
(a -> b) -> AllocOpt a -> AllocOpt b
(forall a b. (a -> b) -> AllocOpt a -> AllocOpt b)
-> (forall a b. a -> AllocOpt b -> AllocOpt a) -> Functor AllocOpt
forall a b. a -> AllocOpt b -> AllocOpt a
forall a b. (a -> b) -> AllocOpt a -> AllocOpt b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> AllocOpt b -> AllocOpt a
$c<$ :: forall a b. a -> AllocOpt b -> AllocOpt a
fmap :: (a -> b) -> AllocOpt a -> AllocOpt b
$cfmap :: forall a b. (a -> b) -> AllocOpt a -> AllocOpt b
Functor)

data ImpList a = ImpList a SrcSpan (TypeSpec a) (AList ImpElement a)
  deriving (ImpList a -> ImpList a -> Bool
(ImpList a -> ImpList a -> Bool)
-> (ImpList a -> ImpList a -> Bool) -> Eq (ImpList a)
forall a. Eq a => ImpList a -> ImpList a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ImpList a -> ImpList a -> Bool
$c/= :: forall a. Eq a => ImpList a -> ImpList a -> Bool
== :: ImpList a -> ImpList a -> Bool
$c== :: forall a. Eq a => ImpList a -> ImpList a -> Bool
Eq, Int -> ImpList a -> ShowS
[ImpList a] -> ShowS
ImpList a -> String
(Int -> ImpList a -> ShowS)
-> (ImpList a -> String)
-> ([ImpList a] -> ShowS)
-> Show (ImpList a)
forall a. Show a => Int -> ImpList a -> ShowS
forall a. Show a => [ImpList a] -> ShowS
forall a. Show a => ImpList a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ImpList a] -> ShowS
$cshowList :: forall a. Show a => [ImpList a] -> ShowS
show :: ImpList a -> String
$cshow :: forall a. Show a => ImpList a -> String
showsPrec :: Int -> ImpList a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> ImpList a -> ShowS
Show, Typeable (ImpList a)
DataType
Constr
Typeable (ImpList a)
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ImpList a -> c (ImpList a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (ImpList a))
-> (ImpList a -> Constr)
-> (ImpList a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (ImpList a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (ImpList a)))
-> ((forall b. Data b => b -> b) -> ImpList a -> ImpList a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ImpList a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ImpList a -> r)
-> (forall u. (forall d. Data d => d -> u) -> ImpList a -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> ImpList a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ImpList a -> m (ImpList a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ImpList a -> m (ImpList a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ImpList a -> m (ImpList a))
-> Data (ImpList a)
ImpList a -> DataType
ImpList a -> Constr
(forall d. Data d => c (t d)) -> Maybe (c (ImpList a))
(forall b. Data b => b -> b) -> ImpList a -> ImpList a
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ImpList a -> c (ImpList a)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ImpList a)
forall a. Data a => Typeable (ImpList a)
forall a. Data a => ImpList a -> DataType
forall a. Data a => ImpList a -> Constr
forall a.
Data a =>
(forall b. Data b => b -> b) -> ImpList a -> ImpList a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> ImpList a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> ImpList a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ImpList a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ImpList a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> ImpList a -> m (ImpList a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> ImpList a -> m (ImpList a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ImpList a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ImpList a -> c (ImpList a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (ImpList a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ImpList a))
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> ImpList a -> u
forall u. (forall d. Data d => d -> u) -> ImpList a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ImpList a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ImpList a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ImpList a -> m (ImpList a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ImpList a -> m (ImpList a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ImpList a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ImpList a -> c (ImpList a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (ImpList a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ImpList a))
$cImpList :: Constr
$tImpList :: DataType
gmapMo :: (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 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 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 :: 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 d. Data d => d -> u) -> ImpList a -> [u]
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> ImpList a -> [u]
gmapQr :: (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 :: (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 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 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 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 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)
$cp1Data :: forall a. Data a => Typeable (ImpList a)
Data, Typeable, (forall x. ImpList a -> Rep (ImpList a) x)
-> (forall x. Rep (ImpList a) x -> ImpList a)
-> Generic (ImpList a)
forall x. Rep (ImpList a) x -> ImpList a
forall x. ImpList a -> Rep (ImpList a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (ImpList a) x -> ImpList a
forall a x. ImpList a -> Rep (ImpList a) x
$cto :: forall a x. Rep (ImpList a) x -> ImpList a
$cfrom :: forall a x. ImpList a -> Rep (ImpList a) x
Generic, a -> ImpList b -> ImpList a
(a -> b) -> ImpList a -> ImpList b
(forall a b. (a -> b) -> ImpList a -> ImpList b)
-> (forall a b. a -> ImpList b -> ImpList a) -> Functor ImpList
forall a b. a -> ImpList b -> ImpList a
forall a b. (a -> b) -> ImpList a -> ImpList b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> ImpList b -> ImpList a
$c<$ :: forall a b. a -> ImpList b -> ImpList a
fmap :: (a -> b) -> ImpList a -> ImpList b
$cfmap :: forall a b. (a -> b) -> ImpList a -> ImpList b
Functor)

data ImpElement a =
    ImpCharacter    a SrcSpan String
  | ImpRange        a SrcSpan String String
  deriving (ImpElement a -> ImpElement a -> Bool
(ImpElement a -> ImpElement a -> Bool)
-> (ImpElement a -> ImpElement a -> Bool) -> Eq (ImpElement a)
forall a. Eq a => ImpElement a -> ImpElement a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ImpElement a -> ImpElement a -> Bool
$c/= :: forall a. Eq a => ImpElement a -> ImpElement a -> Bool
== :: ImpElement a -> ImpElement a -> Bool
$c== :: forall a. Eq a => ImpElement a -> ImpElement a -> Bool
Eq, Int -> ImpElement a -> ShowS
[ImpElement a] -> ShowS
ImpElement a -> String
(Int -> ImpElement a -> ShowS)
-> (ImpElement a -> String)
-> ([ImpElement a] -> ShowS)
-> Show (ImpElement a)
forall a. Show a => Int -> ImpElement a -> ShowS
forall a. Show a => [ImpElement a] -> ShowS
forall a. Show a => ImpElement a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ImpElement a] -> ShowS
$cshowList :: forall a. Show a => [ImpElement a] -> ShowS
show :: ImpElement a -> String
$cshow :: forall a. Show a => ImpElement a -> String
showsPrec :: Int -> ImpElement a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> ImpElement a -> ShowS
Show, Typeable (ImpElement a)
DataType
Constr
Typeable (ImpElement a)
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ImpElement a -> c (ImpElement a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (ImpElement a))
-> (ImpElement a -> Constr)
-> (ImpElement a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (ImpElement a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (ImpElement a)))
-> ((forall b. Data b => b -> b) -> ImpElement a -> ImpElement a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ImpElement a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ImpElement a -> r)
-> (forall u. (forall d. Data d => d -> u) -> ImpElement a -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> ImpElement a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ImpElement a -> m (ImpElement a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ImpElement a -> m (ImpElement a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ImpElement a -> m (ImpElement a))
-> Data (ImpElement a)
ImpElement a -> DataType
ImpElement a -> Constr
(forall d. Data d => c (t d)) -> Maybe (c (ImpElement a))
(forall b. Data b => b -> b) -> ImpElement a -> ImpElement a
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ImpElement a -> c (ImpElement a)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ImpElement a)
forall a. Data a => Typeable (ImpElement a)
forall a. Data a => ImpElement a -> DataType
forall a. Data a => ImpElement a -> Constr
forall a.
Data a =>
(forall b. Data b => b -> b) -> ImpElement a -> ImpElement a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> ImpElement a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> ImpElement a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ImpElement a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ImpElement a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> ImpElement a -> m (ImpElement a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> ImpElement a -> m (ImpElement a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ImpElement a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ImpElement a -> c (ImpElement a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (ImpElement a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ImpElement a))
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> ImpElement a -> u
forall u. (forall d. Data d => d -> u) -> ImpElement a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ImpElement a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ImpElement a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ImpElement a -> m (ImpElement a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ImpElement a -> m (ImpElement a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ImpElement a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ImpElement a -> c (ImpElement a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (ImpElement a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ImpElement a))
$cImpRange :: Constr
$cImpCharacter :: Constr
$tImpElement :: DataType
gmapMo :: (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 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 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 :: 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 d. Data d => d -> u) -> ImpElement a -> [u]
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> ImpElement a -> [u]
gmapQr :: (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 :: (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 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 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 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 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)
$cp1Data :: forall a. Data a => Typeable (ImpElement a)
Data, Typeable, (forall x. ImpElement a -> Rep (ImpElement a) x)
-> (forall x. Rep (ImpElement a) x -> ImpElement a)
-> Generic (ImpElement a)
forall x. Rep (ImpElement a) x -> ImpElement a
forall x. ImpElement a -> Rep (ImpElement a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (ImpElement a) x -> ImpElement a
forall a x. ImpElement a -> Rep (ImpElement a) x
$cto :: forall a x. Rep (ImpElement a) x -> ImpElement a
$cfrom :: forall a x. ImpElement a -> Rep (ImpElement a) x
Generic, a -> ImpElement b -> ImpElement a
(a -> b) -> ImpElement a -> ImpElement b
(forall a b. (a -> b) -> ImpElement a -> ImpElement b)
-> (forall a b. a -> ImpElement b -> ImpElement a)
-> Functor ImpElement
forall a b. a -> ImpElement b -> ImpElement a
forall a b. (a -> b) -> ImpElement a -> ImpElement b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> ImpElement b -> ImpElement a
$c<$ :: forall a b. a -> ImpElement b -> ImpElement a
fmap :: (a -> b) -> ImpElement a -> ImpElement b
$cfmap :: forall a b. (a -> b) -> ImpElement a -> ImpElement b
Functor)

data CommonGroup a =
  CommonGroup a SrcSpan (Maybe (Expression a)) (AList Expression a)
  deriving (CommonGroup a -> CommonGroup a -> Bool
(CommonGroup a -> CommonGroup a -> Bool)
-> (CommonGroup a -> CommonGroup a -> Bool) -> Eq (CommonGroup a)
forall a. Eq a => CommonGroup a -> CommonGroup a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CommonGroup a -> CommonGroup a -> Bool
$c/= :: forall a. Eq a => CommonGroup a -> CommonGroup a -> Bool
== :: CommonGroup a -> CommonGroup a -> Bool
$c== :: forall a. Eq a => CommonGroup a -> CommonGroup a -> Bool
Eq, Int -> CommonGroup a -> ShowS
[CommonGroup a] -> ShowS
CommonGroup a -> String
(Int -> CommonGroup a -> ShowS)
-> (CommonGroup a -> String)
-> ([CommonGroup a] -> ShowS)
-> Show (CommonGroup a)
forall a. Show a => Int -> CommonGroup a -> ShowS
forall a. Show a => [CommonGroup a] -> ShowS
forall a. Show a => CommonGroup a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CommonGroup a] -> ShowS
$cshowList :: forall a. Show a => [CommonGroup a] -> ShowS
show :: CommonGroup a -> String
$cshow :: forall a. Show a => CommonGroup a -> String
showsPrec :: Int -> CommonGroup a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> CommonGroup a -> ShowS
Show, Typeable (CommonGroup a)
DataType
Constr
Typeable (CommonGroup a)
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> CommonGroup a -> c (CommonGroup a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (CommonGroup a))
-> (CommonGroup a -> Constr)
-> (CommonGroup a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (CommonGroup a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (CommonGroup a)))
-> ((forall b. Data b => b -> b) -> CommonGroup a -> CommonGroup a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> CommonGroup a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> CommonGroup a -> r)
-> (forall u. (forall d. Data d => d -> u) -> CommonGroup a -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> CommonGroup a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> CommonGroup a -> m (CommonGroup a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> CommonGroup a -> m (CommonGroup a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> CommonGroup a -> m (CommonGroup a))
-> Data (CommonGroup a)
CommonGroup a -> DataType
CommonGroup a -> Constr
(forall d. Data d => c (t d)) -> Maybe (c (CommonGroup a))
(forall b. Data b => b -> b) -> CommonGroup a -> CommonGroup a
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CommonGroup a -> c (CommonGroup a)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (CommonGroup a)
forall a. Data a => Typeable (CommonGroup a)
forall a. Data a => CommonGroup a -> DataType
forall a. Data a => CommonGroup a -> Constr
forall a.
Data a =>
(forall b. Data b => b -> b) -> CommonGroup a -> CommonGroup a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> CommonGroup a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> CommonGroup a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CommonGroup a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CommonGroup a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d)
-> CommonGroup a -> m (CommonGroup a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> CommonGroup a -> m (CommonGroup a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (CommonGroup a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CommonGroup a -> c (CommonGroup a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (CommonGroup a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (CommonGroup a))
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> CommonGroup a -> u
forall u. (forall d. Data d => d -> u) -> CommonGroup a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CommonGroup a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CommonGroup a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> CommonGroup a -> m (CommonGroup a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> CommonGroup a -> m (CommonGroup a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (CommonGroup a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CommonGroup a -> c (CommonGroup a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (CommonGroup a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (CommonGroup a))
$cCommonGroup :: Constr
$tCommonGroup :: DataType
gmapMo :: (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 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 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 :: 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 d. Data d => d -> u) -> CommonGroup a -> [u]
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> CommonGroup a -> [u]
gmapQr :: (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 :: (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 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 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 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 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)
$cp1Data :: forall a. Data a => Typeable (CommonGroup a)
Data, Typeable, (forall x. CommonGroup a -> Rep (CommonGroup a) x)
-> (forall x. Rep (CommonGroup a) x -> CommonGroup a)
-> Generic (CommonGroup a)
forall x. Rep (CommonGroup a) x -> CommonGroup a
forall x. CommonGroup a -> Rep (CommonGroup a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (CommonGroup a) x -> CommonGroup a
forall a x. CommonGroup a -> Rep (CommonGroup a) x
$cto :: forall a x. Rep (CommonGroup a) x -> CommonGroup a
$cfrom :: forall a x. CommonGroup a -> Rep (CommonGroup a) x
Generic, a -> CommonGroup b -> CommonGroup a
(a -> b) -> CommonGroup a -> CommonGroup b
(forall a b. (a -> b) -> CommonGroup a -> CommonGroup b)
-> (forall a b. a -> CommonGroup b -> CommonGroup a)
-> Functor CommonGroup
forall a b. a -> CommonGroup b -> CommonGroup a
forall a b. (a -> b) -> CommonGroup a -> CommonGroup b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> CommonGroup b -> CommonGroup a
$c<$ :: forall a b. a -> CommonGroup b -> CommonGroup a
fmap :: (a -> b) -> CommonGroup a -> CommonGroup b
$cfmap :: forall a b. (a -> b) -> CommonGroup a -> CommonGroup b
Functor)

data Namelist a =
  Namelist a SrcSpan (Expression a) (AList Expression a)
  deriving (Namelist a -> Namelist a -> Bool
(Namelist a -> Namelist a -> Bool)
-> (Namelist a -> Namelist a -> Bool) -> Eq (Namelist a)
forall a. Eq a => Namelist a -> Namelist a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Namelist a -> Namelist a -> Bool
$c/= :: forall a. Eq a => Namelist a -> Namelist a -> Bool
== :: Namelist a -> Namelist a -> Bool
$c== :: forall a. Eq a => Namelist a -> Namelist a -> Bool
Eq, Int -> Namelist a -> ShowS
[Namelist a] -> ShowS
Namelist a -> String
(Int -> Namelist a -> ShowS)
-> (Namelist a -> String)
-> ([Namelist a] -> ShowS)
-> Show (Namelist a)
forall a. Show a => Int -> Namelist a -> ShowS
forall a. Show a => [Namelist a] -> ShowS
forall a. Show a => Namelist a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Namelist a] -> ShowS
$cshowList :: forall a. Show a => [Namelist a] -> ShowS
show :: Namelist a -> String
$cshow :: forall a. Show a => Namelist a -> String
showsPrec :: Int -> Namelist a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> Namelist a -> ShowS
Show, Typeable (Namelist a)
DataType
Constr
Typeable (Namelist a)
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Namelist a -> c (Namelist a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Namelist a))
-> (Namelist a -> Constr)
-> (Namelist a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Namelist a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Namelist a)))
-> ((forall b. Data b => b -> b) -> Namelist a -> Namelist a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Namelist a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Namelist a -> r)
-> (forall u. (forall d. Data d => d -> u) -> Namelist a -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Namelist a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Namelist a -> m (Namelist a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Namelist a -> m (Namelist a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Namelist a -> m (Namelist a))
-> Data (Namelist a)
Namelist a -> DataType
Namelist a -> Constr
(forall d. Data d => c (t d)) -> Maybe (c (Namelist a))
(forall b. Data b => b -> b) -> Namelist a -> Namelist a
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Namelist a -> c (Namelist a)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Namelist a)
forall a. Data a => Typeable (Namelist a)
forall a. Data a => Namelist a -> DataType
forall a. Data a => Namelist a -> Constr
forall a.
Data a =>
(forall b. Data b => b -> b) -> Namelist a -> Namelist a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Namelist a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> Namelist a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Namelist a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Namelist a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Namelist a -> m (Namelist a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Namelist a -> m (Namelist a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Namelist a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Namelist a -> c (Namelist a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Namelist a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Namelist a))
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Namelist a -> u
forall u. (forall d. Data d => d -> u) -> Namelist a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Namelist a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Namelist a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Namelist a -> m (Namelist a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Namelist a -> m (Namelist a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Namelist a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Namelist a -> c (Namelist a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Namelist a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Namelist a))
$cNamelist :: Constr
$tNamelist :: DataType
gmapMo :: (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 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 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 :: 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 d. Data d => d -> u) -> Namelist a -> [u]
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> Namelist a -> [u]
gmapQr :: (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 :: (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 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 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 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 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)
$cp1Data :: forall a. Data a => Typeable (Namelist a)
Data, Typeable, (forall x. Namelist a -> Rep (Namelist a) x)
-> (forall x. Rep (Namelist a) x -> Namelist a)
-> Generic (Namelist a)
forall x. Rep (Namelist a) x -> Namelist a
forall x. Namelist a -> Rep (Namelist a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (Namelist a) x -> Namelist a
forall a x. Namelist a -> Rep (Namelist a) x
$cto :: forall a x. Rep (Namelist a) x -> Namelist a
$cfrom :: forall a x. Namelist a -> Rep (Namelist a) x
Generic, a -> Namelist b -> Namelist a
(a -> b) -> Namelist a -> Namelist b
(forall a b. (a -> b) -> Namelist a -> Namelist b)
-> (forall a b. a -> Namelist b -> Namelist a) -> Functor Namelist
forall a b. a -> Namelist b -> Namelist a
forall a b. (a -> b) -> Namelist a -> Namelist b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> Namelist b -> Namelist a
$c<$ :: forall a b. a -> Namelist b -> Namelist a
fmap :: (a -> b) -> Namelist a -> Namelist b
$cfmap :: forall a b. (a -> b) -> Namelist a -> Namelist b
Functor)

data DataGroup a =
  DataGroup a SrcSpan (AList Expression a) (AList Expression a)
  deriving (DataGroup a -> DataGroup a -> Bool
(DataGroup a -> DataGroup a -> Bool)
-> (DataGroup a -> DataGroup a -> Bool) -> Eq (DataGroup a)
forall a. Eq a => DataGroup a -> DataGroup a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DataGroup a -> DataGroup a -> Bool
$c/= :: forall a. Eq a => DataGroup a -> DataGroup a -> Bool
== :: DataGroup a -> DataGroup a -> Bool
$c== :: forall a. Eq a => DataGroup a -> DataGroup a -> Bool
Eq, Int -> DataGroup a -> ShowS
[DataGroup a] -> ShowS
DataGroup a -> String
(Int -> DataGroup a -> ShowS)
-> (DataGroup a -> String)
-> ([DataGroup a] -> ShowS)
-> Show (DataGroup a)
forall a. Show a => Int -> DataGroup a -> ShowS
forall a. Show a => [DataGroup a] -> ShowS
forall a. Show a => DataGroup a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DataGroup a] -> ShowS
$cshowList :: forall a. Show a => [DataGroup a] -> ShowS
show :: DataGroup a -> String
$cshow :: forall a. Show a => DataGroup a -> String
showsPrec :: Int -> DataGroup a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> DataGroup a -> ShowS
Show, Typeable (DataGroup a)
DataType
Constr
Typeable (DataGroup a)
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DataGroup a -> c (DataGroup a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (DataGroup a))
-> (DataGroup a -> Constr)
-> (DataGroup a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (DataGroup a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (DataGroup a)))
-> ((forall b. Data b => b -> b) -> DataGroup a -> DataGroup a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DataGroup a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DataGroup a -> r)
-> (forall u. (forall d. Data d => d -> u) -> DataGroup a -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> DataGroup a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DataGroup a -> m (DataGroup a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DataGroup a -> m (DataGroup a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DataGroup a -> m (DataGroup a))
-> Data (DataGroup a)
DataGroup a -> DataType
DataGroup a -> Constr
(forall d. Data d => c (t d)) -> Maybe (c (DataGroup a))
(forall b. Data b => b -> b) -> DataGroup a -> DataGroup a
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DataGroup a -> c (DataGroup a)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (DataGroup a)
forall a. Data a => Typeable (DataGroup a)
forall a. Data a => DataGroup a -> DataType
forall a. Data a => DataGroup a -> Constr
forall a.
Data a =>
(forall b. Data b => b -> b) -> DataGroup a -> DataGroup a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> DataGroup a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> DataGroup a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DataGroup a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DataGroup a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> DataGroup a -> m (DataGroup a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> DataGroup a -> m (DataGroup a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (DataGroup a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DataGroup a -> c (DataGroup a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (DataGroup a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (DataGroup a))
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> DataGroup a -> u
forall u. (forall d. Data d => d -> u) -> DataGroup a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DataGroup a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DataGroup a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DataGroup a -> m (DataGroup a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DataGroup a -> m (DataGroup a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (DataGroup a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DataGroup a -> c (DataGroup a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (DataGroup a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (DataGroup a))
$cDataGroup :: Constr
$tDataGroup :: DataType
gmapMo :: (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 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 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 :: 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 d. Data d => d -> u) -> DataGroup a -> [u]
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> DataGroup a -> [u]
gmapQr :: (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 :: (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 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 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 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 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)
$cp1Data :: forall a. Data a => Typeable (DataGroup a)
Data, Typeable, (forall x. DataGroup a -> Rep (DataGroup a) x)
-> (forall x. Rep (DataGroup a) x -> DataGroup a)
-> Generic (DataGroup a)
forall x. Rep (DataGroup a) x -> DataGroup a
forall x. DataGroup a -> Rep (DataGroup a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (DataGroup a) x -> DataGroup a
forall a x. DataGroup a -> Rep (DataGroup a) x
$cto :: forall a x. Rep (DataGroup a) x -> DataGroup a
$cfrom :: forall a x. DataGroup a -> Rep (DataGroup a) x
Generic, a -> DataGroup b -> DataGroup a
(a -> b) -> DataGroup a -> DataGroup b
(forall a b. (a -> b) -> DataGroup a -> DataGroup b)
-> (forall a b. a -> DataGroup b -> DataGroup a)
-> Functor DataGroup
forall a b. a -> DataGroup b -> DataGroup a
forall a b. (a -> b) -> DataGroup a -> DataGroup b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> DataGroup b -> DataGroup a
$c<$ :: forall a b. a -> DataGroup b -> DataGroup a
fmap :: (a -> b) -> DataGroup a -> DataGroup b
$cfmap :: forall a b. (a -> b) -> DataGroup a -> DataGroup b
Functor)

data StructureItem a =
    StructFields a SrcSpan (TypeSpec a) (Maybe (AList Attribute a)) (AList Declarator a)
  | StructUnion a SrcSpan (AList UnionMap a)
  | StructStructure a SrcSpan (Maybe String) String (AList StructureItem a)
  deriving (StructureItem a -> StructureItem a -> Bool
(StructureItem a -> StructureItem a -> Bool)
-> (StructureItem a -> StructureItem a -> Bool)
-> Eq (StructureItem a)
forall a. Eq a => StructureItem a -> StructureItem a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: StructureItem a -> StructureItem a -> Bool
$c/= :: forall a. Eq a => StructureItem a -> StructureItem a -> Bool
== :: StructureItem a -> StructureItem a -> Bool
$c== :: forall a. Eq a => StructureItem a -> StructureItem a -> Bool
Eq, Int -> StructureItem a -> ShowS
[StructureItem a] -> ShowS
StructureItem a -> String
(Int -> StructureItem a -> ShowS)
-> (StructureItem a -> String)
-> ([StructureItem a] -> ShowS)
-> Show (StructureItem a)
forall a. Show a => Int -> StructureItem a -> ShowS
forall a. Show a => [StructureItem a] -> ShowS
forall a. Show a => StructureItem a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [StructureItem a] -> ShowS
$cshowList :: forall a. Show a => [StructureItem a] -> ShowS
show :: StructureItem a -> String
$cshow :: forall a. Show a => StructureItem a -> String
showsPrec :: Int -> StructureItem a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> StructureItem a -> ShowS
Show, Typeable (StructureItem a)
DataType
Constr
Typeable (StructureItem a)
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> StructureItem a -> c (StructureItem a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (StructureItem a))
-> (StructureItem a -> Constr)
-> (StructureItem a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (StructureItem a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (StructureItem a)))
-> ((forall b. Data b => b -> b)
    -> StructureItem a -> StructureItem a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> StructureItem a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> StructureItem a -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> StructureItem a -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> StructureItem a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> StructureItem a -> m (StructureItem a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> StructureItem a -> m (StructureItem a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> StructureItem a -> m (StructureItem a))
-> Data (StructureItem a)
StructureItem a -> DataType
StructureItem a -> Constr
(forall d. Data d => c (t d)) -> Maybe (c (StructureItem a))
(forall b. Data b => b -> b) -> StructureItem a -> StructureItem a
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> StructureItem a -> c (StructureItem a)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (StructureItem a)
forall a. Data a => Typeable (StructureItem a)
forall a. Data a => StructureItem a -> DataType
forall a. Data a => StructureItem a -> Constr
forall a.
Data a =>
(forall b. Data b => b -> b) -> StructureItem a -> StructureItem a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> StructureItem a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> StructureItem a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> StructureItem a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> StructureItem a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d)
-> StructureItem a -> m (StructureItem a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> StructureItem a -> m (StructureItem a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (StructureItem a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> StructureItem a -> c (StructureItem a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (StructureItem a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (StructureItem a))
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> StructureItem a -> u
forall u. (forall d. Data d => d -> u) -> StructureItem a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> StructureItem a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> StructureItem a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> StructureItem a -> m (StructureItem a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> StructureItem a -> m (StructureItem a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (StructureItem a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> StructureItem a -> c (StructureItem a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (StructureItem a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (StructureItem a))
$cStructStructure :: Constr
$cStructUnion :: Constr
$cStructFields :: Constr
$tStructureItem :: DataType
gmapMo :: (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 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 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 :: 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 d. Data d => d -> u) -> StructureItem a -> [u]
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> StructureItem a -> [u]
gmapQr :: (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 :: (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 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 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 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 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)
$cp1Data :: forall a. Data a => Typeable (StructureItem a)
Data, Typeable, (forall x. StructureItem a -> Rep (StructureItem a) x)
-> (forall x. Rep (StructureItem a) x -> StructureItem a)
-> Generic (StructureItem a)
forall x. Rep (StructureItem a) x -> StructureItem a
forall x. StructureItem a -> Rep (StructureItem a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (StructureItem a) x -> StructureItem a
forall a x. StructureItem a -> Rep (StructureItem a) x
$cto :: forall a x. Rep (StructureItem a) x -> StructureItem a
$cfrom :: forall a x. StructureItem a -> Rep (StructureItem a) x
Generic, a -> StructureItem b -> StructureItem a
(a -> b) -> StructureItem a -> StructureItem b
(forall a b. (a -> b) -> StructureItem a -> StructureItem b)
-> (forall a b. a -> StructureItem b -> StructureItem a)
-> Functor StructureItem
forall a b. a -> StructureItem b -> StructureItem a
forall a b. (a -> b) -> StructureItem a -> StructureItem b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> StructureItem b -> StructureItem a
$c<$ :: forall a b. a -> StructureItem b -> StructureItem a
fmap :: (a -> b) -> StructureItem a -> StructureItem b
$cfmap :: forall a b. (a -> b) -> StructureItem a -> StructureItem b
Functor)

data UnionMap a =
  UnionMap a SrcSpan (AList StructureItem a)
  deriving (UnionMap a -> UnionMap a -> Bool
(UnionMap a -> UnionMap a -> Bool)
-> (UnionMap a -> UnionMap a -> Bool) -> Eq (UnionMap a)
forall a. Eq a => UnionMap a -> UnionMap a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: UnionMap a -> UnionMap a -> Bool
$c/= :: forall a. Eq a => UnionMap a -> UnionMap a -> Bool
== :: UnionMap a -> UnionMap a -> Bool
$c== :: forall a. Eq a => UnionMap a -> UnionMap a -> Bool
Eq, Int -> UnionMap a -> ShowS
[UnionMap a] -> ShowS
UnionMap a -> String
(Int -> UnionMap a -> ShowS)
-> (UnionMap a -> String)
-> ([UnionMap a] -> ShowS)
-> Show (UnionMap a)
forall a. Show a => Int -> UnionMap a -> ShowS
forall a. Show a => [UnionMap a] -> ShowS
forall a. Show a => UnionMap a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [UnionMap a] -> ShowS
$cshowList :: forall a. Show a => [UnionMap a] -> ShowS
show :: UnionMap a -> String
$cshow :: forall a. Show a => UnionMap a -> String
showsPrec :: Int -> UnionMap a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> UnionMap a -> ShowS
Show, Typeable (UnionMap a)
DataType
Constr
Typeable (UnionMap a)
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> UnionMap a -> c (UnionMap a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (UnionMap a))
-> (UnionMap a -> Constr)
-> (UnionMap a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (UnionMap a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (UnionMap a)))
-> ((forall b. Data b => b -> b) -> UnionMap a -> UnionMap a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> UnionMap a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> UnionMap a -> r)
-> (forall u. (forall d. Data d => d -> u) -> UnionMap a -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> UnionMap a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> UnionMap a -> m (UnionMap a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> UnionMap a -> m (UnionMap a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> UnionMap a -> m (UnionMap a))
-> Data (UnionMap a)
UnionMap a -> DataType
UnionMap a -> Constr
(forall d. Data d => c (t d)) -> Maybe (c (UnionMap a))
(forall b. Data b => b -> b) -> UnionMap a -> UnionMap a
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> UnionMap a -> c (UnionMap a)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (UnionMap a)
forall a. Data a => Typeable (UnionMap a)
forall a. Data a => UnionMap a -> DataType
forall a. Data a => UnionMap a -> Constr
forall a.
Data a =>
(forall b. Data b => b -> b) -> UnionMap a -> UnionMap a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> UnionMap a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> UnionMap a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> UnionMap a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> UnionMap a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> UnionMap a -> m (UnionMap a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> UnionMap a -> m (UnionMap a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (UnionMap a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> UnionMap a -> c (UnionMap a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (UnionMap a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (UnionMap a))
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> UnionMap a -> u
forall u. (forall d. Data d => d -> u) -> UnionMap a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> UnionMap a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> UnionMap a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> UnionMap a -> m (UnionMap a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> UnionMap a -> m (UnionMap a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (UnionMap a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> UnionMap a -> c (UnionMap a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (UnionMap a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (UnionMap a))
$cUnionMap :: Constr
$tUnionMap :: DataType
gmapMo :: (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 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 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 :: 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 d. Data d => d -> u) -> UnionMap a -> [u]
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> UnionMap a -> [u]
gmapQr :: (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 :: (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 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 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 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 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)
$cp1Data :: forall a. Data a => Typeable (UnionMap a)
Data, Typeable, (forall x. UnionMap a -> Rep (UnionMap a) x)
-> (forall x. Rep (UnionMap a) x -> UnionMap a)
-> Generic (UnionMap a)
forall x. Rep (UnionMap a) x -> UnionMap a
forall x. UnionMap a -> Rep (UnionMap a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (UnionMap a) x -> UnionMap a
forall a x. UnionMap a -> Rep (UnionMap a) x
$cto :: forall a x. Rep (UnionMap a) x -> UnionMap a
$cfrom :: forall a x. UnionMap a -> Rep (UnionMap a) x
Generic, a -> UnionMap b -> UnionMap a
(a -> b) -> UnionMap a -> UnionMap b
(forall a b. (a -> b) -> UnionMap a -> UnionMap b)
-> (forall a b. a -> UnionMap b -> UnionMap a) -> Functor UnionMap
forall a b. a -> UnionMap b -> UnionMap a
forall a b. (a -> b) -> UnionMap a -> UnionMap b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> UnionMap b -> UnionMap a
$c<$ :: forall a b. a -> UnionMap b -> UnionMap a
fmap :: (a -> b) -> UnionMap a -> UnionMap b
$cfmap :: forall a b. (a -> b) -> UnionMap a -> UnionMap b
Functor)

data FormatItem a =
    FIFormatList            a             SrcSpan   (Maybe String) (AList FormatItem a)
  | FIHollerith             a             SrcSpan   (Value a)
  | FIDelimiter             a             SrcSpan
--  descriptor type       | annotation  | span    | repeat          | descriptor  | width   | integer
  | FIFieldDescriptorDEFG   a             SrcSpan   (Maybe Integer)   Char          Integer   Integer
  | FIFieldDescriptorAIL    a             SrcSpan   (Maybe Integer)   Char          Integer
  | FIBlankDescriptor       a             SrcSpan   Integer
  | FIScaleFactor           a             SrcSpan   Integer
  deriving (FormatItem a -> FormatItem a -> Bool
(FormatItem a -> FormatItem a -> Bool)
-> (FormatItem a -> FormatItem a -> Bool) -> Eq (FormatItem a)
forall a. Eq a => FormatItem a -> FormatItem a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: FormatItem a -> FormatItem a -> Bool
$c/= :: forall a. Eq a => FormatItem a -> FormatItem a -> Bool
== :: FormatItem a -> FormatItem a -> Bool
$c== :: forall a. Eq a => FormatItem a -> FormatItem a -> Bool
Eq, Int -> FormatItem a -> ShowS
[FormatItem a] -> ShowS
FormatItem a -> String
(Int -> FormatItem a -> ShowS)
-> (FormatItem a -> String)
-> ([FormatItem a] -> ShowS)
-> Show (FormatItem a)
forall a. Show a => Int -> FormatItem a -> ShowS
forall a. Show a => [FormatItem a] -> ShowS
forall a. Show a => FormatItem a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [FormatItem a] -> ShowS
$cshowList :: forall a. Show a => [FormatItem a] -> ShowS
show :: FormatItem a -> String
$cshow :: forall a. Show a => FormatItem a -> String
showsPrec :: Int -> FormatItem a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> FormatItem a -> ShowS
Show, Typeable (FormatItem a)
DataType
Constr
Typeable (FormatItem a)
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> FormatItem a -> c (FormatItem a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (FormatItem a))
-> (FormatItem a -> Constr)
-> (FormatItem a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (FormatItem a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (FormatItem a)))
-> ((forall b. Data b => b -> b) -> FormatItem a -> FormatItem a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> FormatItem a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> FormatItem a -> r)
-> (forall u. (forall d. Data d => d -> u) -> FormatItem a -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> FormatItem a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> FormatItem a -> m (FormatItem a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> FormatItem a -> m (FormatItem a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> FormatItem a -> m (FormatItem a))
-> Data (FormatItem a)
FormatItem a -> DataType
FormatItem a -> Constr
(forall d. Data d => c (t d)) -> Maybe (c (FormatItem a))
(forall b. Data b => b -> b) -> FormatItem a -> FormatItem a
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FormatItem a -> c (FormatItem a)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (FormatItem a)
forall a. Data a => Typeable (FormatItem a)
forall a. Data a => FormatItem a -> DataType
forall a. Data a => FormatItem a -> Constr
forall a.
Data a =>
(forall b. Data b => b -> b) -> FormatItem a -> FormatItem a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> FormatItem a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> FormatItem a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FormatItem a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FormatItem a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> FormatItem a -> m (FormatItem a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> FormatItem a -> m (FormatItem a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (FormatItem a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FormatItem a -> c (FormatItem a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (FormatItem a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (FormatItem a))
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> FormatItem a -> u
forall u. (forall d. Data d => d -> u) -> FormatItem a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FormatItem a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FormatItem a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> FormatItem a -> m (FormatItem a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FormatItem a -> m (FormatItem a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (FormatItem a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FormatItem a -> c (FormatItem a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (FormatItem a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (FormatItem a))
$cFIScaleFactor :: Constr
$cFIBlankDescriptor :: Constr
$cFIFieldDescriptorAIL :: Constr
$cFIFieldDescriptorDEFG :: Constr
$cFIDelimiter :: Constr
$cFIHollerith :: Constr
$cFIFormatList :: Constr
$tFormatItem :: DataType
gmapMo :: (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 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 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 :: 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 d. Data d => d -> u) -> FormatItem a -> [u]
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> FormatItem a -> [u]
gmapQr :: (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 :: (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 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 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 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 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)
$cp1Data :: forall a. Data a => Typeable (FormatItem a)
Data, Typeable, (forall x. FormatItem a -> Rep (FormatItem a) x)
-> (forall x. Rep (FormatItem a) x -> FormatItem a)
-> Generic (FormatItem a)
forall x. Rep (FormatItem a) x -> FormatItem a
forall x. FormatItem a -> Rep (FormatItem a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (FormatItem a) x -> FormatItem a
forall a x. FormatItem a -> Rep (FormatItem a) x
$cto :: forall a x. Rep (FormatItem a) x -> FormatItem a
$cfrom :: forall a x. FormatItem a -> Rep (FormatItem a) x
Generic, a -> FormatItem b -> FormatItem a
(a -> b) -> FormatItem a -> FormatItem b
(forall a b. (a -> b) -> FormatItem a -> FormatItem b)
-> (forall a b. a -> FormatItem b -> FormatItem a)
-> Functor FormatItem
forall a b. a -> FormatItem b -> FormatItem a
forall a b. (a -> b) -> FormatItem a -> FormatItem b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> FormatItem b -> FormatItem a
$c<$ :: forall a b. a -> FormatItem b -> FormatItem a
fmap :: (a -> b) -> FormatItem a -> FormatItem b
$cfmap :: forall a b. (a -> b) -> FormatItem a -> FormatItem b
Functor)

data FlushSpec a =
    FSUnit a SrcSpan (Expression a)
  | FSIOStat a SrcSpan (Expression a)
  | FSIOMsg a SrcSpan (Expression a)
  | FSErr a SrcSpan (Expression a)
  deriving (FlushSpec a -> FlushSpec a -> Bool
(FlushSpec a -> FlushSpec a -> Bool)
-> (FlushSpec a -> FlushSpec a -> Bool) -> Eq (FlushSpec a)
forall a. Eq a => FlushSpec a -> FlushSpec a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: FlushSpec a -> FlushSpec a -> Bool
$c/= :: forall a. Eq a => FlushSpec a -> FlushSpec a -> Bool
== :: FlushSpec a -> FlushSpec a -> Bool
$c== :: forall a. Eq a => FlushSpec a -> FlushSpec a -> Bool
Eq, Int -> FlushSpec a -> ShowS
[FlushSpec a] -> ShowS
FlushSpec a -> String
(Int -> FlushSpec a -> ShowS)
-> (FlushSpec a -> String)
-> ([FlushSpec a] -> ShowS)
-> Show (FlushSpec a)
forall a. Show a => Int -> FlushSpec a -> ShowS
forall a. Show a => [FlushSpec a] -> ShowS
forall a. Show a => FlushSpec a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [FlushSpec a] -> ShowS
$cshowList :: forall a. Show a => [FlushSpec a] -> ShowS
show :: FlushSpec a -> String
$cshow :: forall a. Show a => FlushSpec a -> String
showsPrec :: Int -> FlushSpec a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> FlushSpec a -> ShowS
Show, Typeable (FlushSpec a)
DataType
Constr
Typeable (FlushSpec a)
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> FlushSpec a -> c (FlushSpec a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (FlushSpec a))
-> (FlushSpec a -> Constr)
-> (FlushSpec a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (FlushSpec a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (FlushSpec a)))
-> ((forall b. Data b => b -> b) -> FlushSpec a -> FlushSpec a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> FlushSpec a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> FlushSpec a -> r)
-> (forall u. (forall d. Data d => d -> u) -> FlushSpec a -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> FlushSpec a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> FlushSpec a -> m (FlushSpec a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> FlushSpec a -> m (FlushSpec a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> FlushSpec a -> m (FlushSpec a))
-> Data (FlushSpec a)
FlushSpec a -> DataType
FlushSpec a -> Constr
(forall d. Data d => c (t d)) -> Maybe (c (FlushSpec a))
(forall b. Data b => b -> b) -> FlushSpec a -> FlushSpec a
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FlushSpec a -> c (FlushSpec a)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (FlushSpec a)
forall a. Data a => Typeable (FlushSpec a)
forall a. Data a => FlushSpec a -> DataType
forall a. Data a => FlushSpec a -> Constr
forall a.
Data a =>
(forall b. Data b => b -> b) -> FlushSpec a -> FlushSpec a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> FlushSpec a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> FlushSpec a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FlushSpec a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FlushSpec a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> FlushSpec a -> m (FlushSpec a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> FlushSpec a -> m (FlushSpec a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (FlushSpec a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FlushSpec a -> c (FlushSpec a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (FlushSpec a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (FlushSpec a))
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> FlushSpec a -> u
forall u. (forall d. Data d => d -> u) -> FlushSpec a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FlushSpec a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FlushSpec a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> FlushSpec a -> m (FlushSpec a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FlushSpec a -> m (FlushSpec a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (FlushSpec a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FlushSpec a -> c (FlushSpec a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (FlushSpec a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (FlushSpec a))
$cFSErr :: Constr
$cFSIOMsg :: Constr
$cFSIOStat :: Constr
$cFSUnit :: Constr
$tFlushSpec :: DataType
gmapMo :: (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 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 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 :: 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 d. Data d => d -> u) -> FlushSpec a -> [u]
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> FlushSpec a -> [u]
gmapQr :: (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 :: (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 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 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 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 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)
$cp1Data :: forall a. Data a => Typeable (FlushSpec a)
Data, Typeable, (forall x. FlushSpec a -> Rep (FlushSpec a) x)
-> (forall x. Rep (FlushSpec a) x -> FlushSpec a)
-> Generic (FlushSpec a)
forall x. Rep (FlushSpec a) x -> FlushSpec a
forall x. FlushSpec a -> Rep (FlushSpec a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (FlushSpec a) x -> FlushSpec a
forall a x. FlushSpec a -> Rep (FlushSpec a) x
$cto :: forall a x. Rep (FlushSpec a) x -> FlushSpec a
$cfrom :: forall a x. FlushSpec a -> Rep (FlushSpec a) x
Generic, a -> FlushSpec b -> FlushSpec a
(a -> b) -> FlushSpec a -> FlushSpec b
(forall a b. (a -> b) -> FlushSpec a -> FlushSpec b)
-> (forall a b. a -> FlushSpec b -> FlushSpec a)
-> Functor FlushSpec
forall a b. a -> FlushSpec b -> FlushSpec a
forall a b. (a -> b) -> FlushSpec a -> FlushSpec b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> FlushSpec b -> FlushSpec a
$c<$ :: forall a b. a -> FlushSpec b -> FlushSpec a
fmap :: (a -> b) -> FlushSpec a -> FlushSpec b
$cfmap :: forall a b. (a -> b) -> FlushSpec a -> FlushSpec b
Functor)

data DoSpecification a =
  DoSpecification a SrcSpan (Statement a) (Expression a) (Maybe (Expression a))
  deriving (DoSpecification a -> DoSpecification a -> Bool
(DoSpecification a -> DoSpecification a -> Bool)
-> (DoSpecification a -> DoSpecification a -> Bool)
-> Eq (DoSpecification a)
forall a. Eq a => DoSpecification a -> DoSpecification a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DoSpecification a -> DoSpecification a -> Bool
$c/= :: forall a. Eq a => DoSpecification a -> DoSpecification a -> Bool
== :: DoSpecification a -> DoSpecification a -> Bool
$c== :: forall a. Eq a => DoSpecification a -> DoSpecification a -> Bool
Eq, Int -> DoSpecification a -> ShowS
[DoSpecification a] -> ShowS
DoSpecification a -> String
(Int -> DoSpecification a -> ShowS)
-> (DoSpecification a -> String)
-> ([DoSpecification a] -> ShowS)
-> Show (DoSpecification a)
forall a. Show a => Int -> DoSpecification a -> ShowS
forall a. Show a => [DoSpecification a] -> ShowS
forall a. Show a => DoSpecification a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DoSpecification a] -> ShowS
$cshowList :: forall a. Show a => [DoSpecification a] -> ShowS
show :: DoSpecification a -> String
$cshow :: forall a. Show a => DoSpecification a -> String
showsPrec :: Int -> DoSpecification a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> DoSpecification a -> ShowS
Show, Typeable (DoSpecification a)
DataType
Constr
Typeable (DoSpecification a)
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g)
    -> DoSpecification a
    -> c (DoSpecification a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (DoSpecification a))
-> (DoSpecification a -> Constr)
-> (DoSpecification a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (DoSpecification a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (DoSpecification a)))
-> ((forall b. Data b => b -> b)
    -> DoSpecification a -> DoSpecification a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DoSpecification a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DoSpecification a -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> DoSpecification a -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> DoSpecification a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> DoSpecification a -> m (DoSpecification a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DoSpecification a -> m (DoSpecification a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DoSpecification a -> m (DoSpecification a))
-> Data (DoSpecification a)
DoSpecification a -> DataType
DoSpecification a -> Constr
(forall d. Data d => c (t d)) -> Maybe (c (DoSpecification a))
(forall b. Data b => b -> b)
-> DoSpecification a -> DoSpecification a
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> DoSpecification a
-> c (DoSpecification a)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (DoSpecification a)
forall a. Data a => Typeable (DoSpecification a)
forall a. Data a => DoSpecification a -> DataType
forall a. Data a => DoSpecification a -> Constr
forall a.
Data a =>
(forall b. Data b => b -> b)
-> DoSpecification a -> DoSpecification a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> DoSpecification a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> DoSpecification a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DoSpecification a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DoSpecification a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d)
-> DoSpecification a -> m (DoSpecification a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> DoSpecification a -> m (DoSpecification a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (DoSpecification a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> DoSpecification a
-> c (DoSpecification a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (DoSpecification a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (DoSpecification a))
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> DoSpecification a -> u
forall u. (forall d. Data d => d -> u) -> DoSpecification a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DoSpecification a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DoSpecification a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DoSpecification a -> m (DoSpecification a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DoSpecification a -> m (DoSpecification a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (DoSpecification a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> DoSpecification a
-> c (DoSpecification a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (DoSpecification a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (DoSpecification a))
$cDoSpecification :: Constr
$tDoSpecification :: DataType
gmapMo :: (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 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 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 :: 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 d. Data d => d -> u) -> DoSpecification a -> [u]
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> DoSpecification a -> [u]
gmapQr :: (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 :: (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 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 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 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 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)
$cp1Data :: forall a. Data a => Typeable (DoSpecification a)
Data, Typeable, (forall x. DoSpecification a -> Rep (DoSpecification a) x)
-> (forall x. Rep (DoSpecification a) x -> DoSpecification a)
-> Generic (DoSpecification a)
forall x. Rep (DoSpecification a) x -> DoSpecification a
forall x. DoSpecification a -> Rep (DoSpecification a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (DoSpecification a) x -> DoSpecification a
forall a x. DoSpecification a -> Rep (DoSpecification a) x
$cto :: forall a x. Rep (DoSpecification a) x -> DoSpecification a
$cfrom :: forall a x. DoSpecification a -> Rep (DoSpecification a) x
Generic, a -> DoSpecification b -> DoSpecification a
(a -> b) -> DoSpecification a -> DoSpecification b
(forall a b. (a -> b) -> DoSpecification a -> DoSpecification b)
-> (forall a b. a -> DoSpecification b -> DoSpecification a)
-> Functor DoSpecification
forall a b. a -> DoSpecification b -> DoSpecification a
forall a b. (a -> b) -> DoSpecification a -> DoSpecification b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> DoSpecification b -> DoSpecification a
$c<$ :: forall a b. a -> DoSpecification b -> DoSpecification a
fmap :: (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 two expressions.
  | ExpSubscript     a SrcSpan (Expression a) (AList Index a)
  -- ^ Array indexing
  | ExpDataRef       a SrcSpan (Expression a) (Expression a)
  -- ^ @%@ notation for variables inside data types
  | ExpFunctionCall  a SrcSpan (Expression a) (Maybe (AList Argument a))
  -- ^ A function expression applied to a list of arguments.
  | ExpImpliedDo     a SrcSpan (AList Expression a) (DoSpecification a)
  -- ^ Implied do (i.e. one-liner do loops)
  | ExpInitialisation  a SrcSpan (AList Expression a)
  -- ^ Array initialisation
  | ExpReturnSpec    a SrcSpan (Expression a)
  -- ^ Function return value specification
  deriving (Expression a -> Expression a -> Bool
(Expression a -> Expression a -> Bool)
-> (Expression a -> Expression a -> Bool) -> Eq (Expression a)
forall a. Eq a => Expression a -> Expression a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Expression a -> Expression a -> Bool
$c/= :: forall a. Eq a => Expression a -> Expression a -> Bool
== :: Expression a -> Expression a -> Bool
$c== :: forall a. Eq a => Expression a -> Expression a -> Bool
Eq, Int -> Expression a -> ShowS
[Expression a] -> ShowS
Expression a -> String
(Int -> Expression a -> ShowS)
-> (Expression a -> String)
-> ([Expression a] -> ShowS)
-> Show (Expression a)
forall a. Show a => Int -> Expression a -> ShowS
forall a. Show a => [Expression a] -> ShowS
forall a. Show a => Expression a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Expression a] -> ShowS
$cshowList :: forall a. Show a => [Expression a] -> ShowS
show :: Expression a -> String
$cshow :: forall a. Show a => Expression a -> String
showsPrec :: Int -> Expression a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> Expression a -> ShowS
Show, Typeable (Expression a)
DataType
Constr
Typeable (Expression a)
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Expression a -> c (Expression a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Expression a))
-> (Expression a -> Constr)
-> (Expression a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Expression a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Expression a)))
-> ((forall b. Data b => b -> b) -> Expression a -> Expression a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Expression a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Expression a -> r)
-> (forall u. (forall d. Data d => d -> u) -> Expression a -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Expression a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Expression a -> m (Expression a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Expression a -> m (Expression a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Expression a -> m (Expression a))
-> Data (Expression a)
Expression a -> DataType
Expression a -> Constr
(forall d. Data d => c (t d)) -> Maybe (c (Expression a))
(forall b. Data b => b -> b) -> Expression a -> Expression a
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Expression a -> c (Expression a)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Expression a)
forall a. Data a => Typeable (Expression a)
forall a. Data a => Expression a -> DataType
forall a. Data a => Expression a -> Constr
forall a.
Data a =>
(forall b. Data b => b -> b) -> Expression a -> Expression a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Expression a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> Expression a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Expression a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Expression a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Expression a -> m (Expression a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Expression a -> m (Expression a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Expression a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Expression a -> c (Expression a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Expression a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Expression a))
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Expression a -> u
forall u. (forall d. Data d => d -> u) -> Expression a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Expression a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Expression a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Expression a -> m (Expression a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Expression a -> m (Expression a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Expression a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Expression a -> c (Expression a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Expression a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Expression a))
$cExpReturnSpec :: Constr
$cExpInitialisation :: Constr
$cExpImpliedDo :: Constr
$cExpFunctionCall :: Constr
$cExpDataRef :: Constr
$cExpSubscript :: Constr
$cExpUnary :: Constr
$cExpBinary :: Constr
$cExpValue :: Constr
$tExpression :: DataType
gmapMo :: (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 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 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 :: 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 d. Data d => d -> u) -> Expression a -> [u]
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> Expression a -> [u]
gmapQr :: (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 :: (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 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 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 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 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)
$cp1Data :: forall a. Data a => Typeable (Expression a)
Data, Typeable, (forall x. Expression a -> Rep (Expression a) x)
-> (forall x. Rep (Expression a) x -> Expression a)
-> Generic (Expression a)
forall x. Rep (Expression a) x -> Expression a
forall x. Expression a -> Rep (Expression a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (Expression a) x -> Expression a
forall a x. Expression a -> Rep (Expression a) x
$cto :: forall a x. Rep (Expression a) x -> Expression a
$cfrom :: forall a x. Expression a -> Rep (Expression a) x
Generic, a -> Expression b -> Expression a
(a -> b) -> Expression a -> Expression b
(forall a b. (a -> b) -> Expression a -> Expression b)
-> (forall a b. a -> Expression b -> Expression a)
-> Functor Expression
forall a b. a -> Expression b -> Expression a
forall a b. (a -> b) -> Expression a -> Expression b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> Expression b -> Expression a
$c<$ :: forall a b. a -> Expression b -> Expression a
fmap :: (a -> b) -> Expression a -> Expression b
$cfmap :: forall a b. (a -> b) -> Expression a -> Expression b
Functor)

data Index a =
    IxSingle a SrcSpan (Maybe String) (Expression a)
  | IxRange a SrcSpan
            (Maybe (Expression a)) -- Lower index
            (Maybe (Expression a)) -- Upper index
            (Maybe (Expression a)) -- Stride
  deriving (Index a -> Index a -> Bool
(Index a -> Index a -> Bool)
-> (Index a -> Index a -> Bool) -> Eq (Index a)
forall a. Eq a => Index a -> Index a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Index a -> Index a -> Bool
$c/= :: forall a. Eq a => Index a -> Index a -> Bool
== :: Index a -> Index a -> Bool
$c== :: forall a. Eq a => Index a -> Index a -> Bool
Eq, Int -> Index a -> ShowS
[Index a] -> ShowS
Index a -> String
(Int -> Index a -> ShowS)
-> (Index a -> String) -> ([Index a] -> ShowS) -> Show (Index a)
forall a. Show a => Int -> Index a -> ShowS
forall a. Show a => [Index a] -> ShowS
forall a. Show a => Index a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Index a] -> ShowS
$cshowList :: forall a. Show a => [Index a] -> ShowS
show :: Index a -> String
$cshow :: forall a. Show a => Index a -> String
showsPrec :: Int -> Index a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> Index a -> ShowS
Show, Typeable (Index a)
DataType
Constr
Typeable (Index a)
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Index a -> c (Index a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Index a))
-> (Index a -> Constr)
-> (Index a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Index a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Index a)))
-> ((forall b. Data b => b -> b) -> Index a -> Index a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Index a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Index a -> r)
-> (forall u. (forall d. Data d => d -> u) -> Index a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Index a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Index a -> m (Index a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Index a -> m (Index a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Index a -> m (Index a))
-> Data (Index a)
Index a -> DataType
Index a -> Constr
(forall d. Data d => c (t d)) -> Maybe (c (Index a))
(forall b. Data b => b -> b) -> Index a -> Index a
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Index a -> c (Index a)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Index a)
forall a. Data a => Typeable (Index a)
forall a. Data a => Index a -> DataType
forall a. Data a => Index a -> Constr
forall a.
Data a =>
(forall b. Data b => b -> b) -> Index a -> Index a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Index a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> Index a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Index a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Index a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Index a -> m (Index a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Index a -> m (Index a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Index a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Index a -> c (Index a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Index a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Index a))
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Index a -> u
forall u. (forall d. Data d => d -> u) -> Index a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Index a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Index a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Index a -> m (Index a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Index a -> m (Index a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Index a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Index a -> c (Index a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Index a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Index a))
$cIxRange :: Constr
$cIxSingle :: Constr
$tIndex :: DataType
gmapMo :: (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 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 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 :: 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 d. Data d => d -> u) -> Index a -> [u]
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> Index a -> [u]
gmapQr :: (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 :: (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 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 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 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 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)
$cp1Data :: forall a. Data a => Typeable (Index a)
Data, Typeable, (forall x. Index a -> Rep (Index a) x)
-> (forall x. Rep (Index a) x -> Index a) -> Generic (Index a)
forall x. Rep (Index a) x -> Index a
forall x. Index a -> Rep (Index a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (Index a) x -> Index a
forall a x. Index a -> Rep (Index a) x
$cto :: forall a x. Rep (Index a) x -> Index a
$cfrom :: forall a x. Index a -> Rep (Index a) x
Generic, a -> Index b -> Index a
(a -> b) -> Index a -> Index b
(forall a b. (a -> b) -> Index a -> Index b)
-> (forall a b. a -> Index b -> Index a) -> Functor Index
forall a b. a -> Index b -> Index a
forall a b. (a -> b) -> Index a -> Index b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> Index b -> Index a
$c<$ :: forall a b. a -> Index b -> Index a
fmap :: (a -> b) -> Index a -> Index b
$cfmap :: forall a b. (a -> b) -> Index a -> Index b
Functor)

-- All recursive Values
data Value a =
    ValInteger           String
  -- ^ The string representation of an integer literal
  | ValReal              String
  -- ^ The string representation of a real literal
  | ValComplex           (Expression a) (Expression a)
  -- ^ The real and imaginary parts of a complex value
  | ValString            String
  -- ^ A string literal
  | ValHollerith         String
  -- ^ A Hollerith literal
  | ValVariable          Name
  -- ^ The name of a variable
  | ValIntrinsic         Name
  -- ^ The name of a built-in function
  | ValLogical           String
  -- ^ A boolean value
  | ValOperator          String
  -- ^ User-defined operators in interfaces
  | ValAssignment
  -- ^ Overloaded assignment in interfaces
  | ValType              String
  | ValStar
  | ValColon                   -- see R402 / C403 in Fortran2003 spec.
  deriving (Value a -> Value a -> Bool
(Value a -> Value a -> Bool)
-> (Value a -> Value a -> Bool) -> Eq (Value a)
forall a. Eq a => Value a -> Value a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Value a -> Value a -> Bool
$c/= :: forall a. Eq a => Value a -> Value a -> Bool
== :: Value a -> Value a -> Bool
$c== :: forall a. Eq a => Value a -> Value a -> Bool
Eq, Int -> Value a -> ShowS
[Value a] -> ShowS
Value a -> String
(Int -> Value a -> ShowS)
-> (Value a -> String) -> ([Value a] -> ShowS) -> Show (Value a)
forall a. Show a => Int -> Value a -> ShowS
forall a. Show a => [Value a] -> ShowS
forall a. Show a => Value a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Value a] -> ShowS
$cshowList :: forall a. Show a => [Value a] -> ShowS
show :: Value a -> String
$cshow :: forall a. Show a => Value a -> String
showsPrec :: Int -> Value a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> Value a -> ShowS
Show, Typeable (Value a)
DataType
Constr
Typeable (Value a)
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Value a -> c (Value a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Value a))
-> (Value a -> Constr)
-> (Value a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Value a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Value a)))
-> ((forall b. Data b => b -> b) -> Value a -> Value a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Value a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Value a -> r)
-> (forall u. (forall d. Data d => d -> u) -> Value a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Value a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Value a -> m (Value a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Value a -> m (Value a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Value a -> m (Value a))
-> Data (Value a)
Value a -> DataType
Value a -> Constr
(forall d. Data d => c (t d)) -> Maybe (c (Value a))
(forall b. Data b => b -> b) -> Value a -> Value a
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Value a -> c (Value a)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Value a)
forall a. Data a => Typeable (Value a)
forall a. Data a => Value a -> DataType
forall a. Data a => Value a -> Constr
forall a.
Data a =>
(forall b. Data b => b -> b) -> Value a -> Value a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Value a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> Value a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Value a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Value a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Value a -> m (Value a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Value a -> m (Value a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Value a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Value a -> c (Value a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Value a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Value a))
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Value a -> u
forall u. (forall d. Data d => d -> u) -> Value a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Value a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Value a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Value a -> m (Value a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Value a -> m (Value a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Value a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Value a -> c (Value a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Value a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Value a))
$cValColon :: Constr
$cValStar :: Constr
$cValType :: Constr
$cValAssignment :: Constr
$cValOperator :: Constr
$cValLogical :: Constr
$cValIntrinsic :: Constr
$cValVariable :: Constr
$cValHollerith :: Constr
$cValString :: Constr
$cValComplex :: Constr
$cValReal :: Constr
$cValInteger :: Constr
$tValue :: DataType
gmapMo :: (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 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 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 :: 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 d. Data d => d -> u) -> Value a -> [u]
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> Value a -> [u]
gmapQr :: (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 :: (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 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 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 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 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)
$cp1Data :: forall a. Data a => Typeable (Value a)
Data, Typeable, (forall x. Value a -> Rep (Value a) x)
-> (forall x. Rep (Value a) x -> Value a) -> Generic (Value a)
forall x. Rep (Value a) x -> Value a
forall x. Value a -> Rep (Value a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (Value a) x -> Value a
forall a x. Value a -> Rep (Value a) x
$cto :: forall a x. Rep (Value a) x -> Value a
$cfrom :: forall a x. Value a -> Rep (Value a) x
Generic, a -> Value b -> Value a
(a -> b) -> Value a -> Value b
(forall a b. (a -> b) -> Value a -> Value b)
-> (forall a b. a -> Value b -> Value a) -> Functor Value
forall a b. a -> Value b -> Value a
forall a b. (a -> b) -> Value a -> Value b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> Value b -> Value a
$c<$ :: forall a b. a -> Value b -> Value a
fmap :: (a -> b) -> Value a -> Value b
$cfmap :: forall a b. (a -> b) -> Value a -> Value b
Functor)

data Declarator a =
    DeclVariable a SrcSpan
                 (Expression a) -- Variable
                 (Maybe (Expression a)) -- Length (character)
                 (Maybe (Expression a)) -- Initial value
  | DeclArray a SrcSpan
              (Expression a) -- Array
              (AList DimensionDeclarator a) -- Dimensions
              (Maybe (Expression a)) -- Length (character)
              (Maybe (Expression a)) -- Initial value
  deriving (Declarator a -> Declarator a -> Bool
(Declarator a -> Declarator a -> Bool)
-> (Declarator a -> Declarator a -> Bool) -> Eq (Declarator a)
forall a. Eq a => Declarator a -> Declarator a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Declarator a -> Declarator a -> Bool
$c/= :: forall a. Eq a => Declarator a -> Declarator a -> Bool
== :: Declarator a -> Declarator a -> Bool
$c== :: forall a. Eq a => Declarator a -> Declarator a -> Bool
Eq, Int -> Declarator a -> ShowS
[Declarator a] -> ShowS
Declarator a -> String
(Int -> Declarator a -> ShowS)
-> (Declarator a -> String)
-> ([Declarator a] -> ShowS)
-> Show (Declarator a)
forall a. Show a => Int -> Declarator a -> ShowS
forall a. Show a => [Declarator a] -> ShowS
forall a. Show a => Declarator a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Declarator a] -> ShowS
$cshowList :: forall a. Show a => [Declarator a] -> ShowS
show :: Declarator a -> String
$cshow :: forall a. Show a => Declarator a -> String
showsPrec :: Int -> Declarator a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> Declarator a -> ShowS
Show, Typeable (Declarator a)
DataType
Constr
Typeable (Declarator a)
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Declarator a -> c (Declarator a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Declarator a))
-> (Declarator a -> Constr)
-> (Declarator a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Declarator a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Declarator a)))
-> ((forall b. Data b => b -> b) -> Declarator a -> Declarator a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Declarator a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Declarator a -> r)
-> (forall u. (forall d. Data d => d -> u) -> Declarator a -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Declarator a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Declarator a -> m (Declarator a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Declarator a -> m (Declarator a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Declarator a -> m (Declarator a))
-> Data (Declarator a)
Declarator a -> DataType
Declarator a -> Constr
(forall d. Data d => c (t d)) -> Maybe (c (Declarator a))
(forall b. Data b => b -> b) -> Declarator a -> Declarator a
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Declarator a -> c (Declarator a)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Declarator a)
forall a. Data a => Typeable (Declarator a)
forall a. Data a => Declarator a -> DataType
forall a. Data a => Declarator a -> Constr
forall a.
Data a =>
(forall b. Data b => b -> b) -> Declarator a -> Declarator a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Declarator a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> Declarator a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Declarator a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Declarator a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Declarator a -> m (Declarator a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Declarator a -> m (Declarator a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Declarator a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Declarator a -> c (Declarator a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Declarator a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Declarator a))
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Declarator a -> u
forall u. (forall d. Data d => d -> u) -> Declarator a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Declarator a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Declarator a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Declarator a -> m (Declarator a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Declarator a -> m (Declarator a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Declarator a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Declarator a -> c (Declarator a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Declarator a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Declarator a))
$cDeclArray :: Constr
$cDeclVariable :: Constr
$tDeclarator :: DataType
gmapMo :: (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 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 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 :: 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 d. Data d => d -> u) -> Declarator a -> [u]
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> Declarator a -> [u]
gmapQr :: (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 :: (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 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 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 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 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)
$cp1Data :: forall a. Data a => Typeable (Declarator a)
Data, Typeable, (forall x. Declarator a -> Rep (Declarator a) x)
-> (forall x. Rep (Declarator a) x -> Declarator a)
-> Generic (Declarator a)
forall x. Rep (Declarator a) x -> Declarator a
forall x. Declarator a -> Rep (Declarator a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (Declarator a) x -> Declarator a
forall a x. Declarator a -> Rep (Declarator a) x
$cto :: forall a x. Rep (Declarator a) x -> Declarator a
$cfrom :: forall a x. Declarator a -> Rep (Declarator a) x
Generic, a -> Declarator b -> Declarator a
(a -> b) -> Declarator a -> Declarator b
(forall a b. (a -> b) -> Declarator a -> Declarator b)
-> (forall a b. a -> Declarator b -> Declarator a)
-> Functor Declarator
forall a b. a -> Declarator b -> Declarator a
forall a b. (a -> b) -> Declarator a -> Declarator b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> Declarator b -> Declarator a
$c<$ :: forall a b. a -> Declarator b -> Declarator a
fmap :: (a -> b) -> Declarator a -> Declarator b
$cfmap :: forall a b. (a -> b) -> Declarator a -> Declarator b
Functor)

setInitialisation :: Declarator a -> Expression a -> Declarator a
setInitialisation :: Declarator a -> Expression a -> Declarator a
setInitialisation (DeclVariable a
a SrcSpan
s Expression a
v Maybe (Expression a)
l Maybe (Expression a)
Nothing) Expression a
init =
  a
-> SrcSpan
-> Expression a
-> Maybe (Expression a)
-> Maybe (Expression a)
-> Declarator a
forall a.
a
-> SrcSpan
-> Expression a
-> Maybe (Expression a)
-> Maybe (Expression a)
-> Declarator a
DeclVariable a
a (SrcSpan -> Expression a -> SrcSpan
forall a b. SpannedPair a b => a -> b -> SrcSpan
getTransSpan SrcSpan
s Expression a
init) Expression a
v Maybe (Expression a)
l (Expression a -> Maybe (Expression a)
forall a. a -> Maybe a
Just Expression a
init)
setInitialisation (DeclArray a
a SrcSpan
s Expression a
v AList DimensionDeclarator a
ds Maybe (Expression a)
l Maybe (Expression a)
Nothing) Expression a
init =
  a
-> SrcSpan
-> Expression a
-> AList DimensionDeclarator a
-> Maybe (Expression a)
-> Maybe (Expression a)
-> Declarator a
forall a.
a
-> SrcSpan
-> Expression a
-> AList DimensionDeclarator a
-> Maybe (Expression a)
-> Maybe (Expression a)
-> Declarator a
DeclArray a
a (SrcSpan -> Expression a -> SrcSpan
forall a b. SpannedPair a b => a -> b -> SrcSpan
getTransSpan SrcSpan
s Expression a
init) Expression a
v AList DimensionDeclarator a
ds Maybe (Expression a)
l (Expression a -> Maybe (Expression a)
forall a. a -> Maybe a
Just Expression a
init)
-- do nothing when there is already a value
setInitialisation Declarator a
d Expression a
_ = Declarator a
d

data DimensionDeclarator a =
  DimensionDeclarator a SrcSpan (Maybe (Expression a)) (Maybe (Expression a))
  deriving (DimensionDeclarator a -> DimensionDeclarator a -> Bool
(DimensionDeclarator a -> DimensionDeclarator a -> Bool)
-> (DimensionDeclarator a -> DimensionDeclarator a -> Bool)
-> Eq (DimensionDeclarator a)
forall a.
Eq a =>
DimensionDeclarator a -> DimensionDeclarator a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DimensionDeclarator a -> DimensionDeclarator a -> Bool
$c/= :: forall a.
Eq a =>
DimensionDeclarator a -> DimensionDeclarator a -> Bool
== :: DimensionDeclarator a -> DimensionDeclarator a -> Bool
$c== :: forall a.
Eq a =>
DimensionDeclarator a -> DimensionDeclarator a -> Bool
Eq, Int -> DimensionDeclarator a -> ShowS
[DimensionDeclarator a] -> ShowS
DimensionDeclarator a -> String
(Int -> DimensionDeclarator a -> ShowS)
-> (DimensionDeclarator a -> String)
-> ([DimensionDeclarator a] -> ShowS)
-> Show (DimensionDeclarator a)
forall a. Show a => Int -> DimensionDeclarator a -> ShowS
forall a. Show a => [DimensionDeclarator a] -> ShowS
forall a. Show a => DimensionDeclarator a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DimensionDeclarator a] -> ShowS
$cshowList :: forall a. Show a => [DimensionDeclarator a] -> ShowS
show :: DimensionDeclarator a -> String
$cshow :: forall a. Show a => DimensionDeclarator a -> String
showsPrec :: Int -> DimensionDeclarator a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> DimensionDeclarator a -> ShowS
Show, Typeable (DimensionDeclarator a)
DataType
Constr
Typeable (DimensionDeclarator a)
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g)
    -> DimensionDeclarator a
    -> c (DimensionDeclarator a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (DimensionDeclarator a))
-> (DimensionDeclarator a -> Constr)
-> (DimensionDeclarator a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (DimensionDeclarator a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (DimensionDeclarator a)))
-> ((forall b. Data b => b -> b)
    -> DimensionDeclarator a -> DimensionDeclarator a)
-> (forall r r'.
    (r -> r' -> r)
    -> r
    -> (forall d. Data d => d -> r')
    -> DimensionDeclarator a
    -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r
    -> (forall d. Data d => d -> r')
    -> DimensionDeclarator a
    -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> DimensionDeclarator a -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> DimensionDeclarator a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> DimensionDeclarator a -> m (DimensionDeclarator a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DimensionDeclarator a -> m (DimensionDeclarator a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DimensionDeclarator a -> m (DimensionDeclarator a))
-> Data (DimensionDeclarator a)
DimensionDeclarator a -> DataType
DimensionDeclarator a -> Constr
(forall d. Data d => c (t d)) -> Maybe (c (DimensionDeclarator a))
(forall b. Data b => b -> b)
-> DimensionDeclarator a -> DimensionDeclarator a
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> DimensionDeclarator a
-> c (DimensionDeclarator a)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (DimensionDeclarator a)
forall a. Data a => Typeable (DimensionDeclarator a)
forall a. Data a => DimensionDeclarator a -> DataType
forall a. Data a => DimensionDeclarator a -> Constr
forall a.
Data a =>
(forall b. Data b => b -> b)
-> DimensionDeclarator a -> DimensionDeclarator a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> DimensionDeclarator a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> DimensionDeclarator a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DimensionDeclarator a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DimensionDeclarator a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d)
-> DimensionDeclarator a -> m (DimensionDeclarator a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> DimensionDeclarator a -> m (DimensionDeclarator a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (DimensionDeclarator a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> DimensionDeclarator a
-> c (DimensionDeclarator a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (DimensionDeclarator a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (DimensionDeclarator a))
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> DimensionDeclarator a -> u
forall u.
(forall d. Data d => d -> u) -> DimensionDeclarator a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DimensionDeclarator a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DimensionDeclarator a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DimensionDeclarator a -> m (DimensionDeclarator a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DimensionDeclarator a -> m (DimensionDeclarator a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (DimensionDeclarator a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> DimensionDeclarator a
-> c (DimensionDeclarator a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (DimensionDeclarator a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (DimensionDeclarator a))
$cDimensionDeclarator :: Constr
$tDimensionDeclarator :: DataType
gmapMo :: (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 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 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 :: 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 d. Data d => d -> u) -> DimensionDeclarator a -> [u]
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> DimensionDeclarator a -> [u]
gmapQr :: (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 :: (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 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 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 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 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)
$cp1Data :: forall a. Data a => Typeable (DimensionDeclarator a)
Data, Typeable, (forall x. DimensionDeclarator a -> Rep (DimensionDeclarator a) x)
-> (forall x.
    Rep (DimensionDeclarator a) x -> DimensionDeclarator a)
-> Generic (DimensionDeclarator a)
forall x. Rep (DimensionDeclarator a) x -> DimensionDeclarator a
forall x. DimensionDeclarator a -> Rep (DimensionDeclarator a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (DimensionDeclarator a) x -> DimensionDeclarator a
forall a x. DimensionDeclarator a -> Rep (DimensionDeclarator a) x
$cto :: forall a x. Rep (DimensionDeclarator a) x -> DimensionDeclarator a
$cfrom :: forall a x. DimensionDeclarator a -> Rep (DimensionDeclarator a) x
Generic, a -> DimensionDeclarator b -> DimensionDeclarator a
(a -> b) -> DimensionDeclarator a -> DimensionDeclarator b
(forall a b.
 (a -> b) -> DimensionDeclarator a -> DimensionDeclarator b)
-> (forall a b.
    a -> DimensionDeclarator b -> DimensionDeclarator a)
-> Functor DimensionDeclarator
forall a b. a -> DimensionDeclarator b -> DimensionDeclarator a
forall a b.
(a -> b) -> DimensionDeclarator a -> DimensionDeclarator b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> DimensionDeclarator b -> DimensionDeclarator a
$c<$ :: forall a b. a -> DimensionDeclarator b -> DimensionDeclarator a
fmap :: (a -> b) -> DimensionDeclarator a -> DimensionDeclarator b
$cfmap :: forall a b.
(a -> b) -> DimensionDeclarator a -> DimensionDeclarator b
Functor)

data UnaryOp =
    Plus
  | Minus
  | Not
  | UnCustom String
  deriving (UnaryOp -> UnaryOp -> Bool
(UnaryOp -> UnaryOp -> Bool)
-> (UnaryOp -> UnaryOp -> Bool) -> Eq UnaryOp
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: UnaryOp -> UnaryOp -> Bool
$c/= :: UnaryOp -> UnaryOp -> Bool
== :: UnaryOp -> UnaryOp -> Bool
$c== :: UnaryOp -> UnaryOp -> Bool
Eq, Eq UnaryOp
Eq UnaryOp
-> (UnaryOp -> UnaryOp -> Ordering)
-> (UnaryOp -> UnaryOp -> Bool)
-> (UnaryOp -> UnaryOp -> Bool)
-> (UnaryOp -> UnaryOp -> Bool)
-> (UnaryOp -> UnaryOp -> Bool)
-> (UnaryOp -> UnaryOp -> UnaryOp)
-> (UnaryOp -> UnaryOp -> UnaryOp)
-> Ord UnaryOp
UnaryOp -> UnaryOp -> Bool
UnaryOp -> UnaryOp -> Ordering
UnaryOp -> UnaryOp -> UnaryOp
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: UnaryOp -> UnaryOp -> UnaryOp
$cmin :: UnaryOp -> UnaryOp -> UnaryOp
max :: UnaryOp -> UnaryOp -> UnaryOp
$cmax :: UnaryOp -> UnaryOp -> UnaryOp
>= :: UnaryOp -> UnaryOp -> Bool
$c>= :: UnaryOp -> UnaryOp -> Bool
> :: UnaryOp -> UnaryOp -> Bool
$c> :: UnaryOp -> UnaryOp -> Bool
<= :: UnaryOp -> UnaryOp -> Bool
$c<= :: UnaryOp -> UnaryOp -> Bool
< :: UnaryOp -> UnaryOp -> Bool
$c< :: UnaryOp -> UnaryOp -> Bool
compare :: UnaryOp -> UnaryOp -> Ordering
$ccompare :: UnaryOp -> UnaryOp -> Ordering
$cp1Ord :: Eq UnaryOp
Ord, Int -> UnaryOp -> ShowS
[UnaryOp] -> ShowS
UnaryOp -> String
(Int -> UnaryOp -> ShowS)
-> (UnaryOp -> String) -> ([UnaryOp] -> ShowS) -> Show UnaryOp
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [UnaryOp] -> ShowS
$cshowList :: [UnaryOp] -> ShowS
show :: UnaryOp -> String
$cshow :: UnaryOp -> String
showsPrec :: Int -> UnaryOp -> ShowS
$cshowsPrec :: Int -> UnaryOp -> ShowS
Show, Typeable UnaryOp
DataType
Constr
Typeable UnaryOp
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> UnaryOp -> c UnaryOp)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c UnaryOp)
-> (UnaryOp -> Constr)
-> (UnaryOp -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c UnaryOp))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c UnaryOp))
-> ((forall b. Data b => b -> b) -> UnaryOp -> UnaryOp)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> UnaryOp -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> UnaryOp -> r)
-> (forall u. (forall d. Data d => d -> u) -> UnaryOp -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> UnaryOp -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> UnaryOp -> m UnaryOp)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> UnaryOp -> m UnaryOp)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> UnaryOp -> m UnaryOp)
-> Data UnaryOp
UnaryOp -> DataType
UnaryOp -> Constr
(forall b. Data b => b -> b) -> UnaryOp -> UnaryOp
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> UnaryOp -> c UnaryOp
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c 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)
$cUnCustom :: Constr
$cNot :: Constr
$cMinus :: Constr
$cPlus :: Constr
$tUnaryOp :: DataType
gmapMo :: (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 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 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 :: Int -> (forall d. Data d => d -> u) -> UnaryOp -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> UnaryOp -> u
gmapQ :: (forall d. Data d => d -> u) -> UnaryOp -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> UnaryOp -> [u]
gmapQr :: (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 :: (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 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 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 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 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
$cp1Data :: Typeable UnaryOp
Data, Typeable, (forall x. UnaryOp -> Rep UnaryOp x)
-> (forall x. Rep UnaryOp x -> UnaryOp) -> Generic UnaryOp
forall x. Rep UnaryOp x -> UnaryOp
forall x. UnaryOp -> Rep UnaryOp x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep UnaryOp x -> UnaryOp
$cfrom :: forall x. UnaryOp -> Rep UnaryOp x
Generic)

instance Binary UnaryOp

data BinaryOp =
    Addition
  | Subtraction
  | Multiplication
  | Division
  | Exponentiation
  | Concatenation
  | GT
  | GTE
  | LT
  | LTE
  | EQ
  | NE
  | Or
  | XOr
  | And
  | Equivalent
  | NotEquivalent
  | BinCustom String
  deriving (BinaryOp -> BinaryOp -> Bool
(BinaryOp -> BinaryOp -> Bool)
-> (BinaryOp -> BinaryOp -> Bool) -> Eq BinaryOp
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: BinaryOp -> BinaryOp -> Bool
$c/= :: BinaryOp -> BinaryOp -> Bool
== :: BinaryOp -> BinaryOp -> Bool
$c== :: BinaryOp -> BinaryOp -> Bool
Eq, Eq BinaryOp
Eq BinaryOp
-> (BinaryOp -> BinaryOp -> Ordering)
-> (BinaryOp -> BinaryOp -> Bool)
-> (BinaryOp -> BinaryOp -> Bool)
-> (BinaryOp -> BinaryOp -> Bool)
-> (BinaryOp -> BinaryOp -> Bool)
-> (BinaryOp -> BinaryOp -> BinaryOp)
-> (BinaryOp -> BinaryOp -> BinaryOp)
-> Ord BinaryOp
BinaryOp -> BinaryOp -> Bool
BinaryOp -> BinaryOp -> Ordering
BinaryOp -> BinaryOp -> BinaryOp
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: BinaryOp -> BinaryOp -> BinaryOp
$cmin :: BinaryOp -> BinaryOp -> BinaryOp
max :: BinaryOp -> BinaryOp -> BinaryOp
$cmax :: BinaryOp -> BinaryOp -> BinaryOp
>= :: BinaryOp -> BinaryOp -> Bool
$c>= :: BinaryOp -> BinaryOp -> Bool
> :: BinaryOp -> BinaryOp -> Bool
$c> :: BinaryOp -> BinaryOp -> Bool
<= :: BinaryOp -> BinaryOp -> Bool
$c<= :: BinaryOp -> BinaryOp -> Bool
< :: BinaryOp -> BinaryOp -> Bool
$c< :: BinaryOp -> BinaryOp -> Bool
compare :: BinaryOp -> BinaryOp -> Ordering
$ccompare :: BinaryOp -> BinaryOp -> Ordering
$cp1Ord :: Eq BinaryOp
Ord, Int -> BinaryOp -> ShowS
[BinaryOp] -> ShowS
BinaryOp -> String
(Int -> BinaryOp -> ShowS)
-> (BinaryOp -> String) -> ([BinaryOp] -> ShowS) -> Show BinaryOp
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [BinaryOp] -> ShowS
$cshowList :: [BinaryOp] -> ShowS
show :: BinaryOp -> String
$cshow :: BinaryOp -> String
showsPrec :: Int -> BinaryOp -> ShowS
$cshowsPrec :: Int -> BinaryOp -> ShowS
Show, Typeable BinaryOp
DataType
Constr
Typeable BinaryOp
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> BinaryOp -> c BinaryOp)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c BinaryOp)
-> (BinaryOp -> Constr)
-> (BinaryOp -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c BinaryOp))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c BinaryOp))
-> ((forall b. Data b => b -> b) -> BinaryOp -> BinaryOp)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> BinaryOp -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> BinaryOp -> r)
-> (forall u. (forall d. Data d => d -> u) -> BinaryOp -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> BinaryOp -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> BinaryOp -> m BinaryOp)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> BinaryOp -> m BinaryOp)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> BinaryOp -> m BinaryOp)
-> Data BinaryOp
BinaryOp -> DataType
BinaryOp -> Constr
(forall b. Data b => b -> b) -> BinaryOp -> BinaryOp
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BinaryOp -> c BinaryOp
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c 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)
$cBinCustom :: Constr
$cNotEquivalent :: Constr
$cEquivalent :: Constr
$cAnd :: Constr
$cXOr :: Constr
$cOr :: Constr
$cNE :: Constr
$cEQ :: Constr
$cLTE :: Constr
$cLT :: Constr
$cGTE :: Constr
$cGT :: Constr
$cConcatenation :: Constr
$cExponentiation :: Constr
$cDivision :: Constr
$cMultiplication :: Constr
$cSubtraction :: Constr
$cAddition :: Constr
$tBinaryOp :: DataType
gmapMo :: (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 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 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 :: Int -> (forall d. Data d => d -> u) -> BinaryOp -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> BinaryOp -> u
gmapQ :: (forall d. Data d => d -> u) -> BinaryOp -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> BinaryOp -> [u]
gmapQr :: (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 :: (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 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 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 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 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
$cp1Data :: Typeable BinaryOp
Data, Typeable, (forall x. BinaryOp -> Rep BinaryOp x)
-> (forall x. Rep BinaryOp x -> BinaryOp) -> Generic BinaryOp
forall x. Rep BinaryOp x -> BinaryOp
forall x. BinaryOp -> Rep BinaryOp x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep BinaryOp x -> BinaryOp
$cfrom :: forall x. BinaryOp -> Rep BinaryOp x
Generic)

instance Binary BinaryOp

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

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

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

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

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

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

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

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

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

instance (Spanned a) => Spanned [a] where
  getSpan :: [a] -> SrcSpan
getSpan [] = String -> SrcSpan
forall a. HasCallStack => String -> a
error String
"Trying to find how long an empty list spans for."
  getSpan [a
x]   = a -> SrcSpan
forall a. Spanned a => a -> SrcSpan
getSpan a
x
  getSpan (a
x:[a]
xs) = a -> a -> SrcSpan
forall a b. SpannedPair a b => a -> b -> SrcSpan
getTransSpan a
x ([a] -> a
forall a. [a] -> a
last [a]
xs)
  setSpan :: SrcSpan -> [a] -> [a]
setSpan SrcSpan
_ [a]
_ = String -> [a]
forall a. HasCallStack => String -> a
error String
"Cannot set span to an array"

instance (Spanned a, Spanned b) => Spanned (a, Maybe b) where
  getSpan :: (a, Maybe b) -> SrcSpan
getSpan (a
x, Just b
y) = a -> b -> SrcSpan
forall a b. SpannedPair a b => a -> b -> SrcSpan
getTransSpan a
x b
y
  getSpan (a
x,Maybe b
_) = a -> SrcSpan
forall a. Spanned a => a -> SrcSpan
getSpan a
x
  setSpan :: SrcSpan -> (a, Maybe b) -> (a, Maybe b)
setSpan SrcSpan
_ = (a, Maybe b) -> (a, Maybe b)
forall a. HasCallStack => a
undefined

instance (Spanned a, Spanned b) => Spanned (Maybe a, b) where
  getSpan :: (Maybe a, b) -> SrcSpan
getSpan (Just a
x,b
y) = a -> b -> SrcSpan
forall a b. SpannedPair a b => a -> b -> SrcSpan
getTransSpan a
x b
y
  getSpan (Maybe a
_,b
y) = b -> SrcSpan
forall a. Spanned a => a -> SrcSpan
getSpan b
y
  setSpan :: SrcSpan -> (Maybe a, b) -> (Maybe a, b)
setSpan SrcSpan
_ = (Maybe a, b) -> (Maybe a, b)
forall a. HasCallStack => a
undefined

instance (Spanned a, Spanned b) => Spanned (Either a b) where
  getSpan :: Either a b -> SrcSpan
getSpan (Left a
x) = a -> SrcSpan
forall a. Spanned a => a -> SrcSpan
getSpan a
x
  getSpan (Right b
x) = b -> SrcSpan
forall a. Spanned a => a -> SrcSpan
getSpan b
x
  setSpan :: SrcSpan -> Either a b -> Either a b
setSpan SrcSpan
_ = Either a b -> Either a b
forall a. HasCallStack => a
undefined

instance {-# OVERLAPPABLE #-} (Spanned a, Spanned b) => Spanned (a, b) where
  getSpan :: (a, b) -> SrcSpan
getSpan (a
x,b
y) = a -> b -> SrcSpan
forall a b. SpannedPair a b => a -> b -> SrcSpan
getTransSpan a
x b
y
  setSpan :: SrcSpan -> (a, b) -> (a, b)
setSpan SrcSpan
_ = (a, b) -> (a, b)
forall a. HasCallStack => a
undefined

instance {-# OVERLAPPING #-}(Spanned a, Spanned b, Spanned c) => Spanned (Maybe a, Maybe b, Maybe c) where
  getSpan :: (Maybe a, Maybe b, Maybe c) -> SrcSpan
getSpan (Just a
x,Maybe b
_,Just c
z) = a -> c -> SrcSpan
forall a b. SpannedPair a b => a -> b -> SrcSpan
getTransSpan a
x c
z
  getSpan (Just a
x,Just b
y,Maybe c
Nothing) = a -> b -> SrcSpan
forall a b. SpannedPair a b => a -> b -> SrcSpan
getTransSpan a
x b
y
  getSpan (Maybe a
Nothing,Just b
y,Just c
z) = b -> c -> SrcSpan
forall a b. SpannedPair a b => a -> b -> SrcSpan
getTransSpan b
y c
z
  getSpan (Just a
x,Maybe b
Nothing,Maybe c
Nothing) = a -> SrcSpan
forall a. Spanned a => a -> SrcSpan
getSpan a
x
  getSpan (Maybe a
Nothing,Just b
y,Maybe c
Nothing) = b -> SrcSpan
forall a. Spanned a => a -> SrcSpan
getSpan b
y
  getSpan (Maybe a
Nothing,Maybe b
Nothing,Just c
z) = c -> SrcSpan
forall a. Spanned a => a -> SrcSpan
getSpan c
z
  getSpan (Maybe a
Nothing,Maybe b
Nothing,Maybe c
Nothing) = SrcSpan
forall a. HasCallStack => a
undefined
  setSpan :: SrcSpan
-> (Maybe a, Maybe b, Maybe c) -> (Maybe a, Maybe b, Maybe c)
setSpan SrcSpan
_ = (Maybe a, Maybe b, Maybe c) -> (Maybe a, Maybe b, Maybe c)
forall a. HasCallStack => a
undefined

instance {-# OVERLAPPING #-}(Spanned a, Spanned b, Spanned c) => Spanned (a, Maybe b, Maybe c) where
  getSpan :: (a, Maybe b, Maybe c) -> SrcSpan
getSpan (a
x,Maybe b
_,Just c
z) = a -> c -> SrcSpan
forall a b. SpannedPair a b => a -> b -> SrcSpan
getTransSpan a
x c
z
  getSpan (a
x,Just b
y,Maybe c
Nothing) = a -> b -> SrcSpan
forall a b. SpannedPair a b => a -> b -> SrcSpan
getTransSpan a
x b
y
  getSpan (a
x,Maybe b
Nothing,Maybe c
Nothing) = a -> SrcSpan
forall a. Spanned a => a -> SrcSpan
getSpan a
x
  setSpan :: SrcSpan -> (a, Maybe b, Maybe c) -> (a, Maybe b, Maybe c)
setSpan SrcSpan
_ = (a, Maybe b, Maybe c) -> (a, Maybe b, Maybe c)
forall a. HasCallStack => a
undefined

instance {-# OVERLAPPING #-} (Spanned a, Spanned b, Spanned c) => Spanned (Maybe a, b, c) where
  getSpan :: (Maybe a, b, c) -> SrcSpan
getSpan (Just a
x,b
_,c
z) = a -> c -> SrcSpan
forall a b. SpannedPair a b => a -> b -> SrcSpan
getTransSpan a
x c
z
  getSpan (Maybe a
_,b
y,c
z) = (b, c) -> SrcSpan
forall a. Spanned a => a -> SrcSpan
getSpan (b
y,c
z)
  setSpan :: SrcSpan -> (Maybe a, b, c) -> (Maybe a, b, c)
setSpan SrcSpan
_ = (Maybe a, b, c) -> (Maybe a, b, c)
forall a. HasCallStack => a
undefined

instance {-# OVERLAPPABLE #-} (Spanned a, Spanned b, Spanned c) => Spanned (a, b, c) where
  getSpan :: (a, b, c) -> SrcSpan
getSpan (a
x,b
_,c
z) = a -> c -> SrcSpan
forall a b. SpannedPair a b => a -> b -> SrcSpan
getTransSpan a
x c
z
  setSpan :: SrcSpan -> (a, b, c) -> (a, b, c)
setSpan SrcSpan
_ = (a, b, c) -> (a, b, c)
forall a. HasCallStack => a
undefined

class (Spanned a, Spanned b) => SpannedPair a b where
  getTransSpan :: a -> b -> SrcSpan

instance {-# OVERLAPPABLE #-} (Spanned a, Spanned b) => SpannedPair a b where
  getTransSpan :: a -> b -> SrcSpan
getTransSpan a
x b
y = Position -> Position -> SrcSpan
SrcSpan Position
l1 Position
l2'
    where SrcSpan Position
l1 Position
_ = a -> SrcSpan
forall a. Spanned a => a -> SrcSpan
getSpan a
x
          SrcSpan Position
_ Position
l2' = b -> SrcSpan
forall a. Spanned a => a -> SrcSpan
getSpan b
y

instance {-# OVERLAPS #-} (Spanned a, Spanned b) => SpannedPair a [b] where
  getTransSpan :: a -> [b] -> SrcSpan
getTransSpan a
x [] = a -> SrcSpan
forall a. Spanned a => a -> SrcSpan
getSpan a
x
  getTransSpan a
x [b]
y = Position -> Position -> SrcSpan
SrcSpan Position
l1 Position
l2'
    where SrcSpan Position
l1 Position
_ = a -> SrcSpan
forall a. Spanned a => a -> SrcSpan
getSpan a
x
          SrcSpan Position
_ Position
l2' = [b] -> SrcSpan
forall a. Spanned a => a -> SrcSpan
getSpan [b]
y

instance {-# OVERLAPS #-} (Spanned a, Spanned b) => SpannedPair a [[b]] where
  getTransSpan :: a -> [[b]] -> SrcSpan
getTransSpan a
x [] = a -> SrcSpan
forall a. Spanned a => a -> SrcSpan
getSpan a
x
  getTransSpan a
x [[b]]
y | ([b] -> Bool) -> [[b]] -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
all [b] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [[b]]
y = a -> SrcSpan
forall a. Spanned a => a -> SrcSpan
getSpan a
x
  getTransSpan a
x [[b]]
y | ([b] -> Bool) -> [[b]] -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
any [b] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [[b]]
y = a -> [[b]] -> SrcSpan
forall a b. SpannedPair a b => a -> b -> SrcSpan
getTransSpan a
x (([b] -> Bool) -> [[b]] -> [[b]]
forall a. (a -> Bool) -> [a] -> [a]
filter (Bool -> Bool
not (Bool -> Bool) -> ([b] -> Bool) -> [b] -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [b] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null) [[b]]
y)
  getTransSpan a
x [[b]]
y = Position -> Position -> SrcSpan
SrcSpan Position
l1 Position
l2'
    where SrcSpan Position
l1 Position
_ = a -> SrcSpan
forall a. Spanned a => a -> SrcSpan
getSpan a
x
          SrcSpan Position
_ Position
l2' = [[b]] -> SrcSpan
forall a. Spanned a => a -> SrcSpan
getSpan [[b]]
y

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 :: Block a -> Maybe (Expression a)
getLabel (BlStatement a
_ SrcSpan
_ Maybe (Expression a)
l Statement a
_) = Maybe (Expression a)
l
  getLabel (BlIf a
_ SrcSpan
_ Maybe (Expression a)
l Maybe String
_ [Maybe (Expression a)]
_ [[Block a]]
_ Maybe (Expression a)
_) = Maybe (Expression a)
l
  getLabel (BlCase a
_ SrcSpan
_ Maybe (Expression a)
l Maybe String
_ Expression a
_ [Maybe (AList Index a)]
_ [[Block a]]
_ Maybe (Expression a)
_) = Maybe (Expression a)
l
  getLabel (BlDo a
_ SrcSpan
_ Maybe (Expression a)
l Maybe String
_ Maybe (Expression a)
_ Maybe (DoSpecification a)
_ [Block a]
_ Maybe (Expression a)
_) = Maybe (Expression a)
l
  getLabel (BlDoWhile a
_ SrcSpan
_ Maybe (Expression a)
l Maybe String
_ Maybe (Expression a)
_ Expression a
_ [Block a]
_ Maybe (Expression a)
_) = Maybe (Expression a)
l
  getLabel Block a
_ = Maybe (Expression a)
forall a. Maybe a
Nothing

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

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

class Conditioned f where
  getCondition :: f a -> Maybe (Expression a)

instance Conditioned Block where
  getCondition :: Block a -> Maybe (Expression a)
getCondition (BlStatement a
_ SrcSpan
_ Maybe (Expression a)
_ Statement a
s) = Statement a -> Maybe (Expression a)
forall (f :: * -> *) a.
Conditioned f =>
f a -> Maybe (Expression a)
getCondition Statement a
s
  getCondition Block a
_ = Maybe (Expression a)
forall a. Maybe a
Nothing

instance Conditioned Statement where
  getCondition :: Statement a -> Maybe (Expression a)
getCondition (StIfThen a
_ SrcSpan
_ Maybe String
_ Expression a
c) = Expression a -> Maybe (Expression a)
forall a. a -> Maybe a
Just Expression a
c
  getCondition (StElsif a
_ SrcSpan
_ Maybe String
_ Expression a
c) = Expression a -> Maybe (Expression a)
forall a. a -> Maybe a
Just Expression a
c
  getCondition Statement a
_ = Maybe (Expression a)
forall a. Maybe a
Nothing

data ProgramUnitName =
    Named String
  | NamelessBlockData
  | NamelessComment
  | NamelessMain
  deriving (Eq ProgramUnitName
Eq ProgramUnitName
-> (ProgramUnitName -> ProgramUnitName -> Ordering)
-> (ProgramUnitName -> ProgramUnitName -> Bool)
-> (ProgramUnitName -> ProgramUnitName -> Bool)
-> (ProgramUnitName -> ProgramUnitName -> Bool)
-> (ProgramUnitName -> ProgramUnitName -> Bool)
-> (ProgramUnitName -> ProgramUnitName -> ProgramUnitName)
-> (ProgramUnitName -> ProgramUnitName -> ProgramUnitName)
-> Ord ProgramUnitName
ProgramUnitName -> ProgramUnitName -> Bool
ProgramUnitName -> ProgramUnitName -> Ordering
ProgramUnitName -> ProgramUnitName -> ProgramUnitName
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: ProgramUnitName -> ProgramUnitName -> ProgramUnitName
$cmin :: ProgramUnitName -> ProgramUnitName -> ProgramUnitName
max :: ProgramUnitName -> ProgramUnitName -> ProgramUnitName
$cmax :: ProgramUnitName -> ProgramUnitName -> ProgramUnitName
>= :: ProgramUnitName -> ProgramUnitName -> Bool
$c>= :: ProgramUnitName -> ProgramUnitName -> Bool
> :: ProgramUnitName -> ProgramUnitName -> Bool
$c> :: ProgramUnitName -> ProgramUnitName -> Bool
<= :: ProgramUnitName -> ProgramUnitName -> Bool
$c<= :: ProgramUnitName -> ProgramUnitName -> Bool
< :: ProgramUnitName -> ProgramUnitName -> Bool
$c< :: ProgramUnitName -> ProgramUnitName -> Bool
compare :: ProgramUnitName -> ProgramUnitName -> Ordering
$ccompare :: ProgramUnitName -> ProgramUnitName -> Ordering
$cp1Ord :: Eq ProgramUnitName
Ord, ProgramUnitName -> ProgramUnitName -> Bool
(ProgramUnitName -> ProgramUnitName -> Bool)
-> (ProgramUnitName -> ProgramUnitName -> Bool)
-> Eq ProgramUnitName
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ProgramUnitName -> ProgramUnitName -> Bool
$c/= :: ProgramUnitName -> ProgramUnitName -> Bool
== :: ProgramUnitName -> ProgramUnitName -> Bool
$c== :: ProgramUnitName -> ProgramUnitName -> Bool
Eq, Int -> ProgramUnitName -> ShowS
[ProgramUnitName] -> ShowS
ProgramUnitName -> String
(Int -> ProgramUnitName -> ShowS)
-> (ProgramUnitName -> String)
-> ([ProgramUnitName] -> ShowS)
-> Show ProgramUnitName
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ProgramUnitName] -> ShowS
$cshowList :: [ProgramUnitName] -> ShowS
show :: ProgramUnitName -> String
$cshow :: ProgramUnitName -> String
showsPrec :: Int -> ProgramUnitName -> ShowS
$cshowsPrec :: Int -> ProgramUnitName -> ShowS
Show, Typeable ProgramUnitName
DataType
Constr
Typeable ProgramUnitName
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ProgramUnitName -> c ProgramUnitName)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ProgramUnitName)
-> (ProgramUnitName -> Constr)
-> (ProgramUnitName -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ProgramUnitName))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c ProgramUnitName))
-> ((forall b. Data b => b -> b)
    -> ProgramUnitName -> ProgramUnitName)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ProgramUnitName -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ProgramUnitName -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> ProgramUnitName -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> ProgramUnitName -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> ProgramUnitName -> m ProgramUnitName)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> ProgramUnitName -> m ProgramUnitName)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> ProgramUnitName -> m ProgramUnitName)
-> Data ProgramUnitName
ProgramUnitName -> DataType
ProgramUnitName -> Constr
(forall b. Data b => b -> b) -> ProgramUnitName -> ProgramUnitName
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ProgramUnitName -> c ProgramUnitName
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c 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)
$cNamelessMain :: Constr
$cNamelessComment :: Constr
$cNamelessBlockData :: Constr
$cNamed :: Constr
$tProgramUnitName :: DataType
gmapMo :: (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 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 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 :: Int -> (forall d. Data d => d -> u) -> ProgramUnitName -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> ProgramUnitName -> u
gmapQ :: (forall d. Data d => d -> u) -> ProgramUnitName -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> ProgramUnitName -> [u]
gmapQr :: (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 :: (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 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 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 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 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
$cp1Data :: Typeable ProgramUnitName
Data, Typeable, (forall x. ProgramUnitName -> Rep ProgramUnitName x)
-> (forall x. Rep ProgramUnitName x -> ProgramUnitName)
-> Generic ProgramUnitName
forall x. Rep ProgramUnitName x -> ProgramUnitName
forall x. ProgramUnitName -> Rep ProgramUnitName x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ProgramUnitName x -> ProgramUnitName
$cfrom :: forall x. ProgramUnitName -> Rep ProgramUnitName x
Generic)

instance Binary ProgramUnitName
instance NFData ProgramUnitName

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

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

instance Out FortranVersion
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 (t a)) => Out (AList t 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 (Use a)
instance Out a => Out (Attribute a)
instance Out Intent
instance Out a => Out (ImpList a)
instance Out a => Out (ImpElement a)
instance Out a => Out (Comment a)
instance Out a => Out (Block a)
instance Out a => Out (CommonGroup a)
instance Out a => Out (DataGroup a)
instance Out a => Out (StructureItem a)
instance Out a => Out (UnionMap a)
instance Out a => Out (Namelist a)
instance Out a => Out (FormatItem a)
instance Out a => Out (Expression a)
instance Out a => Out (Index a)
instance Out a => Out (DoSpecification a)
instance Out a => Out (FlushSpec a)
instance Out a => Out (Value a)
instance Out a => Out (TypeSpec a)
instance Out a => Out (Selector a)
instance Out CharacterLen
instance Out BaseType
instance Out a => Out (Declarator a)
instance Out a => Out (DimensionDeclarator a)
instance Out a => Out (ControlPair a)
instance Out a => Out (AllocOpt a)
instance Out UnaryOp
instance Out BinaryOp
instance Out a => Out (ForallHeader a)

-- Classifiers on statement and blocks ASTs

nonExecutableStatement :: FortranVersion -> Statement a -> Bool
nonExecutableStatement :: 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 :: FortranVersion -> Statement a -> Bool
executableStatement FortranVersion
v StFormat{} | FortranVersion
v FortranVersion -> FortranVersion -> Bool
forall a. Ord a => a -> a -> Bool
>= FortranVersion
Fortran90 = Bool
True
executableStatement FortranVersion
v StEntry{}  | FortranVersion
v FortranVersion -> FortranVersion -> Bool
forall a. Ord a => a -> a -> Bool
>= FortranVersion
Fortran90 = Bool
True
executableStatement FortranVersion
v StData{}   | FortranVersion
v FortranVersion -> FortranVersion -> Bool
forall a. Ord a => a -> a -> Bool
>= FortranVersion
Fortran90 = Bool
True
executableStatement FortranVersion
v Statement a
s = Bool -> Bool
not (Bool -> Bool) -> Bool -> Bool
forall a b. (a -> b) -> a -> b
$ FortranVersion -> Statement a -> Bool
forall a. FortranVersion -> Statement a -> Bool
nonExecutableStatement FortranVersion
v Statement a
s

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

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

instance (NFData a, NFData (t a)) => NFData (AList t a)
instance NFData a => NFData (ProgramFile a)
instance NFData a => NFData (ProgramUnit a)
instance NFData a => NFData (Block a)
instance NFData a => NFData (Expression a)
instance NFData a => NFData (TypeSpec a)
instance NFData a => NFData (Index a)
instance NFData a => NFData (Value a)
instance NFData a => NFData (Comment a)
instance NFData a => NFData (Statement a)
instance NFData a => NFData (ProcDecl a)
instance NFData a => NFData (ProcInterface a)
instance NFData a => NFData (DoSpecification a)
instance NFData a => NFData (Selector a)
instance NFData a => NFData (ForallHeader a)
instance NFData a => NFData (Argument a)
instance NFData a => NFData (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 (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 FortranVersion
instance NFData CharacterLen
instance NFData BaseType
instance NFData UnaryOp
instance NFData BinaryOp
instance NFData Only
instance NFData ModuleNature
instance NFData Intent