-- Module      : Verismith.Verilog2005.AST
-- Description : Partial Verilog 2005 AST.
-- Copyright   : (c) 2023 Quentin Corradi
-- License     : GPL-3
-- Maintainer  : q [dot] corradi22 [at] imperial [dot] ac [dot] uk
-- Stability   : experimental
-- Portability : POSIX
{-# LANGUAGE DeriveDataTypeable, DeriveGeneric, StandaloneDeriving, QuantifiedConstraints #-}
{-# LANGUAGE UndecidableInstances, FlexibleInstances #-}
{-# LANGUAGE TemplateHaskell #-}

module Verismith.Verilog2005.AST
  ( GenMinTypMax (..),
    CMinTypMax,
    MinTypMax,
    Identifier (..),
    Identified (..),
    UnaryOperator (..),
    BinaryOperator (..),
    Number (..),
    GenPrim (..),
    HierIdent (..),
    GenDimRange (..),
    DimRange,
    CDimRange,
    GenExpr (..),
    CExpr (..),
    Expr (..),
    Attribute (..),
    Attributes,
    Attributed (..),
    AttrIded (..),
    Range2 (..),
    GenRangeExpr (..),
    RangeExpr,
    CRangeExpr,
    NumIdent (..),
    Delay3 (..),
    Delay2 (..),
    Delay1 (..),
    SignRange (..),
    SpecTerm (..),
    EventPrefix (..),
    Dir (..),
    AbsType (..),
    ComType (..),
    NetType (..),
    Strength (..),
    DriveStrength (..),
    dsDefault,
    ChargeStrength (..),
    LValue (..),
    NetLValue,
    VarLValue,
    Assign (..),
    NetAssign,
    VarAssign,
    Parameter (..),
    ParamOver (..),
    ParamAssign (..),
    PortAssign (..),
    EventPrim (..),
    EventControl (..),
    DelayEventControl (..),
    ProcContAssign (..),
    LoopStatement (..),
    FCaseItem (..),
    CaseItem (..),
    FunctionStatement (..),
    AttrFStmt,
    MybFStmt,
    Statement (..),
    AttrStmt,
    MybStmt,
    NInputType (..),
    EdgeDesc (..),
    InstanceName (..),
    GICMos (..),
    GIEnable (..),
    GIMos (..),
    GINIn (..),
    GINOut (..),
    GIPassEn (..),
    GIPass (..),
    GIPull (..),
    TimingCheckEvent (..),
    ControlledTimingCheckEvent (..),
    STCArgs (..),
    STCAddArgs (..),
    ModulePathCondition (..),
    SpecPath (..),
    PathDelayValue (..),
    SpecifyItem (..),
    SpecifySingleItem,
    SpecifyBlockedItem,
    SpecParamDecl (..),
    NetProp (..),
    NetDecl (..),
    NetInit (..),
    BlockDecl (..),
    StdBlockDecl (..),
    TFBlockDecl (..),
    GenCaseItem (..),
    UDPInst (..),
    ModInst (..),
    UknInst (..),
    ModGenCondItem (..),
    GenerateCondBlock (..),
    ModGenItem (..),
    ModGenBlockedItem,
    ModGenSingleItem,
    ModuleItem (..),
    GenerateBlock,
    ModuleBlock (..),
    SigLevel (..),
    ZOX (..),
    CombRow (..),
    Edge (..),
    SeqIn (..),
    SeqRow (..),
    PrimTable (..),
    PrimPort (..),
    PrimitiveBlock (..),
    Dot1Ident (..),
    Cell_inst (..),
    LLU (..),
    ConfigItem (..),
    ConfigBlock (..),
    Verilog2005 (..),
    SystemFunction (..),
    Logic (..),
    sfMap,
    BXZ (..),
    OXZ (..),
    HXZ (..),
    hiPath,
    mbIdent,
    pbIdent,
    _CIInst,
    ciCell_inst,
    cbIdent,
    cbBody,
  )
where

import Control.Lens
import Data.Functor.Compose
import Data.Functor.Classes
import Data.ByteString (ByteString)
import Data.ByteString.Internal (c2w, packChars)
import Data.Data
import Data.Data.Lens
import Data.String (IsString (..))
import Text.Show (showListWith)
import Text.Printf (printf)
import qualified Data.HashMap.Strict as HashMap
import Data.List.NonEmpty (NonEmpty)
import qualified Data.Vector.Unboxed as V
import GHC.Generics (Generic)
import Numeric.Natural
import Verismith.Verilog2005.Token (BXZ (..), HXZ (..), OXZ (..), ZOX (..))

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

type CMinTypMax = GenMinTypMax CExpr

type MinTypMax = GenMinTypMax Expr

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

instance IsString Identifier where
  fromString :: String -> Identifier
fromString =
    ByteString -> Identifier
Identifier (ByteString -> Identifier)
-> (String -> ByteString) -> String -> Identifier
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> ByteString
packChars (String -> ByteString) -> ShowS -> String -> ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Char -> String) -> ShowS
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap
      (\Char
c -> if Char
' ' Char -> Char -> Bool
forall a. Ord a => a -> a -> Bool
< Char
c Bool -> Bool -> Bool
&& Char
c Char -> Char -> Bool
forall a. Ord a => a -> a -> Bool
<= Char
'~' then [Char
c] else String -> Char -> String
forall r. PrintfType r => String -> r
printf String
"\\%02x" Char
c)

-- | Quickly add an identifier to all members of a sum type, other uses are discouraged
data Identified t = Identified {forall t. Identified t -> Identifier
_identIdent :: !Identifier, forall t. Identified t -> t
_identData :: !t}
  deriving (Int -> Identified t -> ShowS
[Identified t] -> ShowS
Identified t -> String
(Int -> Identified t -> ShowS)
-> (Identified t -> String)
-> ([Identified t] -> ShowS)
-> Show (Identified t)
forall t. Show t => Int -> Identified t -> ShowS
forall t. Show t => [Identified t] -> ShowS
forall t. Show t => Identified t -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall t. Show t => Int -> Identified t -> ShowS
showsPrec :: Int -> Identified t -> ShowS
$cshow :: forall t. Show t => Identified t -> String
show :: Identified t -> String
$cshowList :: forall t. Show t => [Identified t] -> ShowS
showList :: [Identified t] -> ShowS
Show, Identified t -> Identified t -> Bool
(Identified t -> Identified t -> Bool)
-> (Identified t -> Identified t -> Bool) -> Eq (Identified t)
forall t. Eq t => Identified t -> Identified t -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall t. Eq t => Identified t -> Identified t -> Bool
== :: Identified t -> Identified t -> Bool
$c/= :: forall t. Eq t => Identified t -> Identified t -> Bool
/= :: Identified t -> Identified t -> Bool
Eq, Typeable (Identified t)
Typeable (Identified t) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Identified t -> c (Identified t))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Identified t))
-> (Identified t -> Constr)
-> (Identified t -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Identified t)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Identified t)))
-> ((forall b. Data b => b -> b) -> Identified t -> Identified t)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Identified t -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Identified t -> r)
-> (forall u. (forall d. Data d => d -> u) -> Identified t -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Identified t -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Identified t -> m (Identified t))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Identified t -> m (Identified t))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Identified t -> m (Identified t))
-> Data (Identified t)
Identified t -> Constr
Identified t -> DataType
(forall b. Data b => b -> b) -> Identified t -> Identified t
forall t. Data t => Typeable (Identified t)
forall t. Data t => Identified t -> Constr
forall t. Data t => Identified t -> DataType
forall t.
Data t =>
(forall b. Data b => b -> b) -> Identified t -> Identified t
forall t u.
Data t =>
Int -> (forall d. Data d => d -> u) -> Identified t -> u
forall t u.
Data t =>
(forall d. Data d => d -> u) -> Identified t -> [u]
forall t r r'.
Data t =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Identified t -> r
forall t r r'.
Data t =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Identified t -> r
forall t (m :: * -> *).
(Data t, Monad m) =>
(forall d. Data d => d -> m d) -> Identified t -> m (Identified t)
forall t (m :: * -> *).
(Data t, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Identified t -> m (Identified t)
forall t (c :: * -> *).
Data t =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Identified t)
forall t (c :: * -> *).
Data t =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Identified t -> c (Identified t)
forall t (t :: * -> *) (c :: * -> *).
(Data t, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Identified t))
forall t (t :: * -> * -> *) (c :: * -> *).
(Data t, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Identified t))
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) -> Identified t -> u
forall u. (forall d. Data d => d -> u) -> Identified t -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Identified t -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Identified t -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Identified t -> m (Identified t)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Identified t -> m (Identified t)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Identified t)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Identified t -> c (Identified t)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Identified t))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Identified t))
$cgfoldl :: forall t (c :: * -> *).
Data t =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Identified t -> c (Identified t)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Identified t -> c (Identified t)
$cgunfold :: forall t (c :: * -> *).
Data t =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Identified t)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Identified t)
$ctoConstr :: forall t. Data t => Identified t -> Constr
toConstr :: Identified t -> Constr
$cdataTypeOf :: forall t. Data t => Identified t -> DataType
dataTypeOf :: Identified t -> DataType
$cdataCast1 :: forall t (t :: * -> *) (c :: * -> *).
(Data t, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Identified t))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Identified t))
$cdataCast2 :: forall t (t :: * -> * -> *) (c :: * -> *).
(Data t, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Identified t))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Identified t))
$cgmapT :: forall t.
Data t =>
(forall b. Data b => b -> b) -> Identified t -> Identified t
gmapT :: (forall b. Data b => b -> b) -> Identified t -> Identified t
$cgmapQl :: forall t r r'.
Data t =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Identified t -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Identified t -> r
$cgmapQr :: forall t r r'.
Data t =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Identified t -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Identified t -> r
$cgmapQ :: forall t u.
Data t =>
(forall d. Data d => d -> u) -> Identified t -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Identified t -> [u]
$cgmapQi :: forall t u.
Data t =>
Int -> (forall d. Data d => d -> u) -> Identified t -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Identified t -> u
$cgmapM :: forall t (m :: * -> *).
(Data t, Monad m) =>
(forall d. Data d => d -> m d) -> Identified t -> m (Identified t)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Identified t -> m (Identified t)
$cgmapMp :: forall t (m :: * -> *).
(Data t, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Identified t -> m (Identified t)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Identified t -> m (Identified t)
$cgmapMo :: forall t (m :: * -> *).
(Data t, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Identified t -> m (Identified t)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Identified t -> m (Identified t)
Data, (forall x. Identified t -> Rep (Identified t) x)
-> (forall x. Rep (Identified t) x -> Identified t)
-> Generic (Identified t)
forall x. Rep (Identified t) x -> Identified t
forall x. Identified t -> Rep (Identified t) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall t x. Rep (Identified t) x -> Identified t
forall t x. Identified t -> Rep (Identified t) x
$cfrom :: forall t x. Identified t -> Rep (Identified t) x
from :: forall x. Identified t -> Rep (Identified t) x
$cto :: forall t x. Rep (Identified t) x -> Identified t
to :: forall x. Rep (Identified t) x -> Identified t
Generic)

instance Functor Identified where
  fmap :: forall a b. (a -> b) -> Identified a -> Identified b
fmap a -> b
f (Identified Identifier
i a
x) = Identifier -> b -> Identified b
forall t. Identifier -> t -> Identified t
Identified Identifier
i (b -> Identified b) -> b -> Identified b
forall a b. (a -> b) -> a -> b
$ a -> b
f a
x

showHelper :: (Int -> a -> ShowS) -> Identified a -> ShowS
showHelper :: forall a. (Int -> a -> ShowS) -> Identified a -> ShowS
showHelper Int -> a -> ShowS
fp (Identified Identifier
i a
x) = String -> ShowS
showString String
"Identified " ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Identifier -> ShowS
forall a. Show a => a -> ShowS
shows Identifier
i ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> ShowS
showChar Char
' ' ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> a -> ShowS
fp Int
0 a
x

instance Show1 Identified where
  liftShowsPrec :: forall a.
(Int -> a -> ShowS)
-> ([a] -> ShowS) -> Int -> Identified a -> ShowS
liftShowsPrec Int -> a -> ShowS
fp [a] -> ShowS
_ Int
p = (Int -> a -> ShowS) -> Identified a -> ShowS
forall a. (Int -> a -> ShowS) -> Identified a -> ShowS
showHelper Int -> a -> ShowS
fp
  liftShowList :: forall a.
(Int -> a -> ShowS) -> ([a] -> ShowS) -> [Identified a] -> ShowS
liftShowList Int -> a -> ShowS
fp [a] -> ShowS
_ = (Identified a -> ShowS) -> [Identified a] -> ShowS
forall a. (a -> ShowS) -> [a] -> ShowS
showListWith ((Identified a -> ShowS) -> [Identified a] -> ShowS)
-> (Identified a -> ShowS) -> [Identified a] -> ShowS
forall a b. (a -> b) -> a -> b
$ (Int -> a -> ShowS) -> Identified a -> ShowS
forall a. (Int -> a -> ShowS) -> Identified a -> ShowS
showHelper Int -> a -> ShowS
fp
instance Eq1 Identified where
  liftEq :: forall a b.
(a -> b -> Bool) -> Identified a -> Identified b -> Bool
liftEq a -> b -> Bool
f (Identified Identifier
ia a
a) (Identified Identifier
ib b
b) = Identifier
ia Identifier -> Identifier -> Bool
forall a. Eq a => a -> a -> Bool
== Identifier
ib Bool -> Bool -> Bool
&& a -> b -> Bool
f a
a b
b

-- | Unary operators
data UnaryOperator
  = UnPlus
  | UnMinus
  | UnLNot
  | UnNot
  | UnAnd
  | UnNand
  | UnOr
  | UnNor
  | UnXor
  | UnXNor
  deriving (UnaryOperator -> UnaryOperator -> Bool
(UnaryOperator -> UnaryOperator -> Bool)
-> (UnaryOperator -> UnaryOperator -> Bool) -> Eq UnaryOperator
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: UnaryOperator -> UnaryOperator -> Bool
== :: UnaryOperator -> UnaryOperator -> Bool
$c/= :: UnaryOperator -> UnaryOperator -> Bool
/= :: UnaryOperator -> UnaryOperator -> Bool
Eq, Typeable UnaryOperator
Typeable UnaryOperator =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> UnaryOperator -> c UnaryOperator)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c UnaryOperator)
-> (UnaryOperator -> Constr)
-> (UnaryOperator -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c UnaryOperator))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c UnaryOperator))
-> ((forall b. Data b => b -> b) -> UnaryOperator -> UnaryOperator)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> UnaryOperator -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> UnaryOperator -> r)
-> (forall u. (forall d. Data d => d -> u) -> UnaryOperator -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> UnaryOperator -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> UnaryOperator -> m UnaryOperator)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> UnaryOperator -> m UnaryOperator)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> UnaryOperator -> m UnaryOperator)
-> Data UnaryOperator
UnaryOperator -> Constr
UnaryOperator -> DataType
(forall b. Data b => b -> b) -> UnaryOperator -> UnaryOperator
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) -> UnaryOperator -> u
forall u. (forall d. Data d => d -> u) -> UnaryOperator -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> UnaryOperator -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> UnaryOperator -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> UnaryOperator -> m UnaryOperator
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> UnaryOperator -> m UnaryOperator
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c UnaryOperator
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> UnaryOperator -> c UnaryOperator
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c UnaryOperator)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c UnaryOperator)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> UnaryOperator -> c UnaryOperator
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> UnaryOperator -> c UnaryOperator
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c UnaryOperator
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c UnaryOperator
$ctoConstr :: UnaryOperator -> Constr
toConstr :: UnaryOperator -> Constr
$cdataTypeOf :: UnaryOperator -> DataType
dataTypeOf :: UnaryOperator -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c UnaryOperator)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c UnaryOperator)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c UnaryOperator)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c UnaryOperator)
$cgmapT :: (forall b. Data b => b -> b) -> UnaryOperator -> UnaryOperator
gmapT :: (forall b. Data b => b -> b) -> UnaryOperator -> UnaryOperator
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> UnaryOperator -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> UnaryOperator -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> UnaryOperator -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> UnaryOperator -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> UnaryOperator -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> UnaryOperator -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> UnaryOperator -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> UnaryOperator -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> UnaryOperator -> m UnaryOperator
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> UnaryOperator -> m UnaryOperator
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> UnaryOperator -> m UnaryOperator
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> UnaryOperator -> m UnaryOperator
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> UnaryOperator -> m UnaryOperator
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> UnaryOperator -> m UnaryOperator
Data, (forall x. UnaryOperator -> Rep UnaryOperator x)
-> (forall x. Rep UnaryOperator x -> UnaryOperator)
-> Generic UnaryOperator
forall x. Rep UnaryOperator x -> UnaryOperator
forall x. UnaryOperator -> Rep UnaryOperator x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. UnaryOperator -> Rep UnaryOperator x
from :: forall x. UnaryOperator -> Rep UnaryOperator x
$cto :: forall x. Rep UnaryOperator x -> UnaryOperator
to :: forall x. Rep UnaryOperator x -> UnaryOperator
Generic, Int -> UnaryOperator
UnaryOperator -> Int
UnaryOperator -> [UnaryOperator]
UnaryOperator -> UnaryOperator
UnaryOperator -> UnaryOperator -> [UnaryOperator]
UnaryOperator -> UnaryOperator -> UnaryOperator -> [UnaryOperator]
(UnaryOperator -> UnaryOperator)
-> (UnaryOperator -> UnaryOperator)
-> (Int -> UnaryOperator)
-> (UnaryOperator -> Int)
-> (UnaryOperator -> [UnaryOperator])
-> (UnaryOperator -> UnaryOperator -> [UnaryOperator])
-> (UnaryOperator -> UnaryOperator -> [UnaryOperator])
-> (UnaryOperator
    -> UnaryOperator -> UnaryOperator -> [UnaryOperator])
-> Enum UnaryOperator
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: UnaryOperator -> UnaryOperator
succ :: UnaryOperator -> UnaryOperator
$cpred :: UnaryOperator -> UnaryOperator
pred :: UnaryOperator -> UnaryOperator
$ctoEnum :: Int -> UnaryOperator
toEnum :: Int -> UnaryOperator
$cfromEnum :: UnaryOperator -> Int
fromEnum :: UnaryOperator -> Int
$cenumFrom :: UnaryOperator -> [UnaryOperator]
enumFrom :: UnaryOperator -> [UnaryOperator]
$cenumFromThen :: UnaryOperator -> UnaryOperator -> [UnaryOperator]
enumFromThen :: UnaryOperator -> UnaryOperator -> [UnaryOperator]
$cenumFromTo :: UnaryOperator -> UnaryOperator -> [UnaryOperator]
enumFromTo :: UnaryOperator -> UnaryOperator -> [UnaryOperator]
$cenumFromThenTo :: UnaryOperator -> UnaryOperator -> UnaryOperator -> [UnaryOperator]
enumFromThenTo :: UnaryOperator -> UnaryOperator -> UnaryOperator -> [UnaryOperator]
Enum, UnaryOperator
UnaryOperator -> UnaryOperator -> Bounded UnaryOperator
forall a. a -> a -> Bounded a
$cminBound :: UnaryOperator
minBound :: UnaryOperator
$cmaxBound :: UnaryOperator
maxBound :: UnaryOperator
Bounded)

instance Show UnaryOperator where
  show :: UnaryOperator -> String
show UnaryOperator
x = case UnaryOperator
x of
    UnaryOperator
UnPlus -> String
"+"
    UnaryOperator
UnMinus -> String
"-"
    UnaryOperator
UnLNot -> String
"!"
    UnaryOperator
UnNot -> String
"~"
    UnaryOperator
UnAnd -> String
"&"
    UnaryOperator
UnNand -> String
"~&"
    UnaryOperator
UnOr -> String
"|"
    UnaryOperator
UnNor -> String
"~|"
    UnaryOperator
UnXor -> String
"^"
    UnaryOperator
UnXNor -> String
"~^"

-- | Binary operators
data BinaryOperator
  = BinPlus
  | BinMinus
  | BinTimes
  | BinDiv
  | BinMod
  | BinEq
  | BinNEq
  | BinCEq
  | BinCNEq
  | BinLAnd
  | BinLOr
  | BinLT
  | BinLEq
  | BinGT
  | BinGEq
  | BinAnd
  | BinOr
  | BinXor
  | BinXNor
  | BinPower
  | BinLSL
  | BinLSR
  | BinASL
  | BinASR
  deriving (BinaryOperator -> BinaryOperator -> Bool
(BinaryOperator -> BinaryOperator -> Bool)
-> (BinaryOperator -> BinaryOperator -> Bool) -> Eq BinaryOperator
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: BinaryOperator -> BinaryOperator -> Bool
== :: BinaryOperator -> BinaryOperator -> Bool
$c/= :: BinaryOperator -> BinaryOperator -> Bool
/= :: BinaryOperator -> BinaryOperator -> Bool
Eq, Typeable BinaryOperator
Typeable BinaryOperator =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> BinaryOperator -> c BinaryOperator)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c BinaryOperator)
-> (BinaryOperator -> Constr)
-> (BinaryOperator -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c BinaryOperator))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c BinaryOperator))
-> ((forall b. Data b => b -> b)
    -> BinaryOperator -> BinaryOperator)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> BinaryOperator -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> BinaryOperator -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> BinaryOperator -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> BinaryOperator -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> BinaryOperator -> m BinaryOperator)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> BinaryOperator -> m BinaryOperator)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> BinaryOperator -> m BinaryOperator)
-> Data BinaryOperator
BinaryOperator -> Constr
BinaryOperator -> DataType
(forall b. Data b => b -> b) -> BinaryOperator -> BinaryOperator
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) -> BinaryOperator -> u
forall u. (forall d. Data d => d -> u) -> BinaryOperator -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> BinaryOperator -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> BinaryOperator -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> BinaryOperator -> m BinaryOperator
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> BinaryOperator -> m BinaryOperator
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c BinaryOperator
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BinaryOperator -> c BinaryOperator
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c BinaryOperator)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c BinaryOperator)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BinaryOperator -> c BinaryOperator
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BinaryOperator -> c BinaryOperator
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c BinaryOperator
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c BinaryOperator
$ctoConstr :: BinaryOperator -> Constr
toConstr :: BinaryOperator -> Constr
$cdataTypeOf :: BinaryOperator -> DataType
dataTypeOf :: BinaryOperator -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c BinaryOperator)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c BinaryOperator)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c BinaryOperator)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c BinaryOperator)
$cgmapT :: (forall b. Data b => b -> b) -> BinaryOperator -> BinaryOperator
gmapT :: (forall b. Data b => b -> b) -> BinaryOperator -> BinaryOperator
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> BinaryOperator -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> BinaryOperator -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> BinaryOperator -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> BinaryOperator -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> BinaryOperator -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> BinaryOperator -> [u]
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> BinaryOperator -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> BinaryOperator -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> BinaryOperator -> m BinaryOperator
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> BinaryOperator -> m BinaryOperator
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> BinaryOperator -> m BinaryOperator
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> BinaryOperator -> m BinaryOperator
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> BinaryOperator -> m BinaryOperator
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> BinaryOperator -> m BinaryOperator
Data, (forall x. BinaryOperator -> Rep BinaryOperator x)
-> (forall x. Rep BinaryOperator x -> BinaryOperator)
-> Generic BinaryOperator
forall x. Rep BinaryOperator x -> BinaryOperator
forall x. BinaryOperator -> Rep BinaryOperator x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. BinaryOperator -> Rep BinaryOperator x
from :: forall x. BinaryOperator -> Rep BinaryOperator x
$cto :: forall x. Rep BinaryOperator x -> BinaryOperator
to :: forall x. Rep BinaryOperator x -> BinaryOperator
Generic, Int -> BinaryOperator
BinaryOperator -> Int
BinaryOperator -> [BinaryOperator]
BinaryOperator -> BinaryOperator
BinaryOperator -> BinaryOperator -> [BinaryOperator]
BinaryOperator
-> BinaryOperator -> BinaryOperator -> [BinaryOperator]
(BinaryOperator -> BinaryOperator)
-> (BinaryOperator -> BinaryOperator)
-> (Int -> BinaryOperator)
-> (BinaryOperator -> Int)
-> (BinaryOperator -> [BinaryOperator])
-> (BinaryOperator -> BinaryOperator -> [BinaryOperator])
-> (BinaryOperator -> BinaryOperator -> [BinaryOperator])
-> (BinaryOperator
    -> BinaryOperator -> BinaryOperator -> [BinaryOperator])
-> Enum BinaryOperator
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: BinaryOperator -> BinaryOperator
succ :: BinaryOperator -> BinaryOperator
$cpred :: BinaryOperator -> BinaryOperator
pred :: BinaryOperator -> BinaryOperator
$ctoEnum :: Int -> BinaryOperator
toEnum :: Int -> BinaryOperator
$cfromEnum :: BinaryOperator -> Int
fromEnum :: BinaryOperator -> Int
$cenumFrom :: BinaryOperator -> [BinaryOperator]
enumFrom :: BinaryOperator -> [BinaryOperator]
$cenumFromThen :: BinaryOperator -> BinaryOperator -> [BinaryOperator]
enumFromThen :: BinaryOperator -> BinaryOperator -> [BinaryOperator]
$cenumFromTo :: BinaryOperator -> BinaryOperator -> [BinaryOperator]
enumFromTo :: BinaryOperator -> BinaryOperator -> [BinaryOperator]
$cenumFromThenTo :: BinaryOperator
-> BinaryOperator -> BinaryOperator -> [BinaryOperator]
enumFromThenTo :: BinaryOperator
-> BinaryOperator -> BinaryOperator -> [BinaryOperator]
Enum, BinaryOperator
BinaryOperator -> BinaryOperator -> Bounded BinaryOperator
forall a. a -> a -> Bounded a
$cminBound :: BinaryOperator
minBound :: BinaryOperator
$cmaxBound :: BinaryOperator
maxBound :: BinaryOperator
Bounded)

instance Show BinaryOperator where
  show :: BinaryOperator -> String
show BinaryOperator
x = case BinaryOperator
x of
    BinaryOperator
BinPlus -> String
"+"
    BinaryOperator
BinMinus -> String
"-"
    BinaryOperator
BinTimes -> String
"*"
    BinaryOperator
BinDiv -> String
"/"
    BinaryOperator
BinMod -> String
"%"
    BinaryOperator
BinEq -> String
"=="
    BinaryOperator
BinNEq -> String
"!="
    BinaryOperator
BinCEq -> String
"==="
    BinaryOperator
BinCNEq -> String
"!=="
    BinaryOperator
BinLAnd -> String
"&&"
    BinaryOperator
BinLOr -> String
"||"
    BinaryOperator
BinLT -> String
"<"
    BinaryOperator
BinLEq -> String
"<="
    BinaryOperator
BinGT -> String
">"
    BinaryOperator
BinGEq -> String
">="
    BinaryOperator
BinAnd -> String
"&"
    BinaryOperator
BinOr -> String
"|"
    BinaryOperator
BinXor -> String
"^"
    BinaryOperator
BinXNor -> String
"~^"
    BinaryOperator
BinPower -> String
"**"
    BinaryOperator
BinLSL -> String
"<<"
    BinaryOperator
BinLSR -> String
">>"
    BinaryOperator
BinASL -> String
"<<<"
    BinaryOperator
BinASR -> String
">>>"

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

-- | Parametric primary expression
data GenPrim i r a
  = PrimNumber
      { forall i r a. GenPrim i r a -> Maybe Natural
_pnSize :: !(Maybe Natural),
        forall i r a. GenPrim i r a -> Bool
_pnSigned :: !Bool,
        forall i r a. GenPrim i r a -> Number
_pnValue :: !Number
      }
  | PrimReal !ByteString
  | PrimIdent
      { forall i r a. GenPrim i r a -> i
_piIdent :: !i,
        forall i r a. GenPrim i r a -> r
_piSub :: !r
      }
  | PrimConcat !(NonEmpty (GenExpr i r a))
  | PrimMultConcat
      { forall i r a.
GenPrim i r a -> GenExpr Identifier (Maybe CRangeExpr) a
_pmcMul :: !(GenExpr Identifier (Maybe CRangeExpr) a),
        forall i r a. GenPrim i r a -> NonEmpty (GenExpr i r a)
_pmcExpr :: !(NonEmpty (GenExpr i r a))
      }
  | PrimFun
      { forall i r a. GenPrim i r a -> i
_pfIdent :: !i,
        forall i r a. GenPrim i r a -> a
_pfAttr :: !a,
        forall i r a. GenPrim i r a -> [GenExpr i r a]
_pfArg :: ![GenExpr i r a]
      }
  | PrimSysFun
      { forall i r a. GenPrim i r a -> ByteString
_psfIdent :: !ByteString,
        forall i r a. GenPrim i r a -> [GenExpr i r a]
_psfArg :: ![GenExpr i r a]
      }
  | PrimMinTypMax !(GenMinTypMax (GenExpr i r a))
  | PrimString !ByteString
  deriving (Int -> GenPrim i r a -> ShowS
[GenPrim i r a] -> ShowS
GenPrim i r a -> String
(Int -> GenPrim i r a -> ShowS)
-> (GenPrim i r a -> String)
-> ([GenPrim i r a] -> ShowS)
-> Show (GenPrim i r a)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall i r a.
(Show r, Show i, Show a) =>
Int -> GenPrim i r a -> ShowS
forall i r a. (Show r, Show i, Show a) => [GenPrim i r a] -> ShowS
forall i r a. (Show r, Show i, Show a) => GenPrim i r a -> String
$cshowsPrec :: forall i r a.
(Show r, Show i, Show a) =>
Int -> GenPrim i r a -> ShowS
showsPrec :: Int -> GenPrim i r a -> ShowS
$cshow :: forall i r a. (Show r, Show i, Show a) => GenPrim i r a -> String
show :: GenPrim i r a -> String
$cshowList :: forall i r a. (Show r, Show i, Show a) => [GenPrim i r a] -> ShowS
showList :: [GenPrim i r a] -> ShowS
Show, GenPrim i r a -> GenPrim i r a -> Bool
(GenPrim i r a -> GenPrim i r a -> Bool)
-> (GenPrim i r a -> GenPrim i r a -> Bool) -> Eq (GenPrim i r a)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall i r a.
(Eq r, Eq i, Eq a) =>
GenPrim i r a -> GenPrim i r a -> Bool
$c== :: forall i r a.
(Eq r, Eq i, Eq a) =>
GenPrim i r a -> GenPrim i r a -> Bool
== :: GenPrim i r a -> GenPrim i r a -> Bool
$c/= :: forall i r a.
(Eq r, Eq i, Eq a) =>
GenPrim i r a -> GenPrim i r a -> Bool
/= :: GenPrim i r a -> GenPrim i r a -> Bool
Eq, Typeable (GenPrim i r a)
Typeable (GenPrim i r a) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> GenPrim i r a -> c (GenPrim i r a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (GenPrim i r a))
-> (GenPrim i r a -> Constr)
-> (GenPrim i r a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (GenPrim i r a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (GenPrim i r a)))
-> ((forall b. Data b => b -> b) -> GenPrim i r a -> GenPrim i r a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> GenPrim i r a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> GenPrim i r a -> r)
-> (forall u. (forall d. Data d => d -> u) -> GenPrim i r a -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> GenPrim i r a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> GenPrim i r a -> m (GenPrim i r a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> GenPrim i r a -> m (GenPrim i r a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> GenPrim i r a -> m (GenPrim i r a))
-> Data (GenPrim i r a)
GenPrim i r a -> Constr
GenPrim i r a -> DataType
(forall b. Data b => b -> b) -> GenPrim i r a -> GenPrim i r 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) -> GenPrim i r a -> u
forall u. (forall d. Data d => d -> u) -> GenPrim i r a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> GenPrim i r a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> GenPrim i r a -> r
forall i r a. (Data r, Data i, Data a) => Typeable (GenPrim i r a)
forall i r a. (Data r, Data i, Data a) => GenPrim i r a -> Constr
forall i r a. (Data r, Data i, Data a) => GenPrim i r a -> DataType
forall i r a.
(Data r, Data i, Data a) =>
(forall b. Data b => b -> b) -> GenPrim i r a -> GenPrim i r a
forall i r a u.
(Data r, Data i, Data a) =>
Int -> (forall d. Data d => d -> u) -> GenPrim i r a -> u
forall i r a u.
(Data r, Data i, Data a) =>
(forall d. Data d => d -> u) -> GenPrim i r a -> [u]
forall i r a r r'.
(Data r, Data i, Data a) =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> GenPrim i r a -> r
forall i r a r r'.
(Data r, Data i, Data a) =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> GenPrim i r a -> r
forall i r a (m :: * -> *).
(Data r, Data i, Data a, Monad m) =>
(forall d. Data d => d -> m d)
-> GenPrim i r a -> m (GenPrim i r a)
forall i r a (m :: * -> *).
(Data r, Data i, Data a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> GenPrim i r a -> m (GenPrim i r a)
forall i r a (c :: * -> *).
(Data r, Data i, Data a) =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (GenPrim i r a)
forall i r a (c :: * -> *).
(Data r, Data i, Data a) =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> GenPrim i r a -> c (GenPrim i r a)
forall i r a (t :: * -> *) (c :: * -> *).
(Data r, Data i, Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (GenPrim i r a))
forall i r a (t :: * -> * -> *) (c :: * -> *).
(Data r, Data i, Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (GenPrim i r a))
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> GenPrim i r a -> m (GenPrim i r a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> GenPrim i r a -> m (GenPrim i r a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (GenPrim i r a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> GenPrim i r a -> c (GenPrim i r a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (GenPrim i r a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (GenPrim i r a))
$cgfoldl :: forall i r a (c :: * -> *).
(Data r, Data i, Data a) =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> GenPrim i r a -> c (GenPrim i r a)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> GenPrim i r a -> c (GenPrim i r a)
$cgunfold :: forall i r a (c :: * -> *).
(Data r, Data i, Data a) =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (GenPrim i r a)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (GenPrim i r a)
$ctoConstr :: forall i r a. (Data r, Data i, Data a) => GenPrim i r a -> Constr
toConstr :: GenPrim i r a -> Constr
$cdataTypeOf :: forall i r a. (Data r, Data i, Data a) => GenPrim i r a -> DataType
dataTypeOf :: GenPrim i r a -> DataType
$cdataCast1 :: forall i r a (t :: * -> *) (c :: * -> *).
(Data r, Data i, Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (GenPrim i r a))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (GenPrim i r a))
$cdataCast2 :: forall i r a (t :: * -> * -> *) (c :: * -> *).
(Data r, Data i, Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (GenPrim i r a))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (GenPrim i r a))
$cgmapT :: forall i r a.
(Data r, Data i, Data a) =>
(forall b. Data b => b -> b) -> GenPrim i r a -> GenPrim i r a
gmapT :: (forall b. Data b => b -> b) -> GenPrim i r a -> GenPrim i r a
$cgmapQl :: forall i r a r r'.
(Data r, Data i, Data a) =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> GenPrim i r a -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> GenPrim i r a -> r
$cgmapQr :: forall i r a r r'.
(Data r, Data i, Data a) =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> GenPrim i r a -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> GenPrim i r a -> r
$cgmapQ :: forall i r a u.
(Data r, Data i, Data a) =>
(forall d. Data d => d -> u) -> GenPrim i r a -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> GenPrim i r a -> [u]
$cgmapQi :: forall i r a u.
(Data r, Data i, Data a) =>
Int -> (forall d. Data d => d -> u) -> GenPrim i r a -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> GenPrim i r a -> u
$cgmapM :: forall i r a (m :: * -> *).
(Data r, Data i, Data a, Monad m) =>
(forall d. Data d => d -> m d)
-> GenPrim i r a -> m (GenPrim i r a)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> GenPrim i r a -> m (GenPrim i r a)
$cgmapMp :: forall i r a (m :: * -> *).
(Data r, Data i, Data a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> GenPrim i r a -> m (GenPrim i r a)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> GenPrim i r a -> m (GenPrim i r a)
$cgmapMo :: forall i r a (m :: * -> *).
(Data r, Data i, Data a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> GenPrim i r a -> m (GenPrim i r a)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> GenPrim i r a -> m (GenPrim i r a)
Data, (forall x. GenPrim i r a -> Rep (GenPrim i r a) x)
-> (forall x. Rep (GenPrim i r a) x -> GenPrim i r a)
-> Generic (GenPrim i r a)
forall x. Rep (GenPrim i r a) x -> GenPrim i r a
forall x. GenPrim i r a -> Rep (GenPrim i r a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall i r a x. Rep (GenPrim i r a) x -> GenPrim i r a
forall i r a x. GenPrim i r a -> Rep (GenPrim i r a) x
$cfrom :: forall i r a x. GenPrim i r a -> Rep (GenPrim i r a) x
from :: forall x. GenPrim i r a -> Rep (GenPrim i r a) x
$cto :: forall i r a x. Rep (GenPrim i r a) x -> GenPrim i r a
to :: forall x. Rep (GenPrim i r a) x -> GenPrim i r a
Generic)

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

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

type DimRange = GenDimRange Expr

type CDimRange = GenDimRange CExpr

-- | Parametric expression
data GenExpr i r a
  = ExprPrim !(GenPrim i r a)
  | ExprUnOp
      { forall i r a. GenExpr i r a -> UnaryOperator
_euOp :: !UnaryOperator,
        forall i r a. GenExpr i r a -> a
_euAttr :: !a,
        forall i r a. GenExpr i r a -> GenPrim i r a
_euPrim :: !(GenPrim i r a)
      }
  | ExprBinOp
      { forall i r a. GenExpr i r a -> GenExpr i r a
_ebLhs :: !(GenExpr i r a),
        forall i r a. GenExpr i r a -> BinaryOperator
_ebOp :: !BinaryOperator,
        forall i r a. GenExpr i r a -> a
_ebAttr :: !a,
        forall i r a. GenExpr i r a -> GenExpr i r a
_ebRhs :: !(GenExpr i r a)
      }
  | ExprCond
      { forall i r a. GenExpr i r a -> GenExpr i r a
_ecCond :: !(GenExpr i r a),
        forall i r a. GenExpr i r a -> a
_ecAttr :: !a,
        forall i r a. GenExpr i r a -> GenExpr i r a
_ecTrue :: !(GenExpr i r a),
        forall i r a. GenExpr i r a -> GenExpr i r a
_ecFalse :: !(GenExpr i r a)
      }
  deriving (Int -> GenExpr i r a -> ShowS
[GenExpr i r a] -> ShowS
GenExpr i r a -> String
(Int -> GenExpr i r a -> ShowS)
-> (GenExpr i r a -> String)
-> ([GenExpr i r a] -> ShowS)
-> Show (GenExpr i r a)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall i r a.
(Show r, Show i, Show a) =>
Int -> GenExpr i r a -> ShowS
forall i r a. (Show r, Show i, Show a) => [GenExpr i r a] -> ShowS
forall i r a. (Show r, Show i, Show a) => GenExpr i r a -> String
$cshowsPrec :: forall i r a.
(Show r, Show i, Show a) =>
Int -> GenExpr i r a -> ShowS
showsPrec :: Int -> GenExpr i r a -> ShowS
$cshow :: forall i r a. (Show r, Show i, Show a) => GenExpr i r a -> String
show :: GenExpr i r a -> String
$cshowList :: forall i r a. (Show r, Show i, Show a) => [GenExpr i r a] -> ShowS
showList :: [GenExpr i r a] -> ShowS
Show, GenExpr i r a -> GenExpr i r a -> Bool
(GenExpr i r a -> GenExpr i r a -> Bool)
-> (GenExpr i r a -> GenExpr i r a -> Bool) -> Eq (GenExpr i r a)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall i r a.
(Eq r, Eq i, Eq a) =>
GenExpr i r a -> GenExpr i r a -> Bool
$c== :: forall i r a.
(Eq r, Eq i, Eq a) =>
GenExpr i r a -> GenExpr i r a -> Bool
== :: GenExpr i r a -> GenExpr i r a -> Bool
$c/= :: forall i r a.
(Eq r, Eq i, Eq a) =>
GenExpr i r a -> GenExpr i r a -> Bool
/= :: GenExpr i r a -> GenExpr i r a -> Bool
Eq, Typeable (GenExpr i r a)
Typeable (GenExpr i r a) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> GenExpr i r a -> c (GenExpr i r a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (GenExpr i r a))
-> (GenExpr i r a -> Constr)
-> (GenExpr i r a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (GenExpr i r a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (GenExpr i r a)))
-> ((forall b. Data b => b -> b) -> GenExpr i r a -> GenExpr i r a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> GenExpr i r a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> GenExpr i r a -> r)
-> (forall u. (forall d. Data d => d -> u) -> GenExpr i r a -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> GenExpr i r a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> GenExpr i r a -> m (GenExpr i r a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> GenExpr i r a -> m (GenExpr i r a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> GenExpr i r a -> m (GenExpr i r a))
-> Data (GenExpr i r a)
GenExpr i r a -> Constr
GenExpr i r a -> DataType
(forall b. Data b => b -> b) -> GenExpr i r a -> GenExpr i r 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) -> GenExpr i r a -> u
forall u. (forall d. Data d => d -> u) -> GenExpr i r a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> GenExpr i r a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> GenExpr i r a -> r
forall i r a. (Data i, Data r, Data a) => Typeable (GenExpr i r a)
forall i r a. (Data i, Data r, Data a) => GenExpr i r a -> Constr
forall i r a. (Data i, Data r, Data a) => GenExpr i r a -> DataType
forall i r a.
(Data i, Data r, Data a) =>
(forall b. Data b => b -> b) -> GenExpr i r a -> GenExpr i r a
forall i r a u.
(Data i, Data r, Data a) =>
Int -> (forall d. Data d => d -> u) -> GenExpr i r a -> u
forall i r a u.
(Data i, Data r, Data a) =>
(forall d. Data d => d -> u) -> GenExpr i r a -> [u]
forall i r a r r'.
(Data i, Data r, Data a) =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> GenExpr i r a -> r
forall i r a r r'.
(Data i, Data r, Data a) =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> GenExpr i r a -> r
forall i r a (m :: * -> *).
(Data i, Data r, Data a, Monad m) =>
(forall d. Data d => d -> m d)
-> GenExpr i r a -> m (GenExpr i r a)
forall i r a (m :: * -> *).
(Data i, Data r, Data a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> GenExpr i r a -> m (GenExpr i r a)
forall i r a (c :: * -> *).
(Data i, Data r, Data a) =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (GenExpr i r a)
forall i r a (c :: * -> *).
(Data i, Data r, Data a) =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> GenExpr i r a -> c (GenExpr i r a)
forall i r a (t :: * -> *) (c :: * -> *).
(Data i, Data r, Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (GenExpr i r a))
forall i r a (t :: * -> * -> *) (c :: * -> *).
(Data i, Data r, Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (GenExpr i r a))
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> GenExpr i r a -> m (GenExpr i r a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> GenExpr i r a -> m (GenExpr i r a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (GenExpr i r a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> GenExpr i r a -> c (GenExpr i r a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (GenExpr i r a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (GenExpr i r a))
$cgfoldl :: forall i r a (c :: * -> *).
(Data i, Data r, Data a) =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> GenExpr i r a -> c (GenExpr i r a)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> GenExpr i r a -> c (GenExpr i r a)
$cgunfold :: forall i r a (c :: * -> *).
(Data i, Data r, Data a) =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (GenExpr i r a)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (GenExpr i r a)
$ctoConstr :: forall i r a. (Data i, Data r, Data a) => GenExpr i r a -> Constr
toConstr :: GenExpr i r a -> Constr
$cdataTypeOf :: forall i r a. (Data i, Data r, Data a) => GenExpr i r a -> DataType
dataTypeOf :: GenExpr i r a -> DataType
$cdataCast1 :: forall i r a (t :: * -> *) (c :: * -> *).
(Data i, Data r, Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (GenExpr i r a))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (GenExpr i r a))
$cdataCast2 :: forall i r a (t :: * -> * -> *) (c :: * -> *).
(Data i, Data r, Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (GenExpr i r a))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (GenExpr i r a))
$cgmapT :: forall i r a.
(Data i, Data r, Data a) =>
(forall b. Data b => b -> b) -> GenExpr i r a -> GenExpr i r a
gmapT :: (forall b. Data b => b -> b) -> GenExpr i r a -> GenExpr i r a
$cgmapQl :: forall i r a r r'.
(Data i, Data r, Data a) =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> GenExpr i r a -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> GenExpr i r a -> r
$cgmapQr :: forall i r a r r'.
(Data i, Data r, Data a) =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> GenExpr i r a -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> GenExpr i r a -> r
$cgmapQ :: forall i r a u.
(Data i, Data r, Data a) =>
(forall d. Data d => d -> u) -> GenExpr i r a -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> GenExpr i r a -> [u]
$cgmapQi :: forall i r a u.
(Data i, Data r, Data a) =>
Int -> (forall d. Data d => d -> u) -> GenExpr i r a -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> GenExpr i r a -> u
$cgmapM :: forall i r a (m :: * -> *).
(Data i, Data r, Data a, Monad m) =>
(forall d. Data d => d -> m d)
-> GenExpr i r a -> m (GenExpr i r a)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> GenExpr i r a -> m (GenExpr i r a)
$cgmapMp :: forall i r a (m :: * -> *).
(Data i, Data r, Data a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> GenExpr i r a -> m (GenExpr i r a)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> GenExpr i r a -> m (GenExpr i r a)
$cgmapMo :: forall i r a (m :: * -> *).
(Data i, Data r, Data a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> GenExpr i r a -> m (GenExpr i r a)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> GenExpr i r a -> m (GenExpr i r a)
Data, (forall x. GenExpr i r a -> Rep (GenExpr i r a) x)
-> (forall x. Rep (GenExpr i r a) x -> GenExpr i r a)
-> Generic (GenExpr i r a)
forall x. Rep (GenExpr i r a) x -> GenExpr i r a
forall x. GenExpr i r a -> Rep (GenExpr i r a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall i r a x. Rep (GenExpr i r a) x -> GenExpr i r a
forall i r a x. GenExpr i r a -> Rep (GenExpr i r a) x
$cfrom :: forall i r a x. GenExpr i r a -> Rep (GenExpr i r a) x
from :: forall x. GenExpr i r a -> Rep (GenExpr i r a) x
$cto :: forall i r a x. Rep (GenExpr i r a) x -> GenExpr i r a
to :: forall x. Rep (GenExpr i r a) x -> GenExpr i r a
Generic)

instance (Data i, Data r, Data a) => Plated (GenExpr i r a) where
  plate :: Traversal' (GenExpr i r a) (GenExpr i r a)
plate = (GenExpr i r a -> f (GenExpr i r a))
-> GenExpr i r a -> f (GenExpr i r a)
forall a. Data a => Traversal' a a
Traversal' (GenExpr i r a) (GenExpr i r a)
uniplate

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

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

-- | Attributes which can be set to various nodes in the AST.
data Attribute = Attribute
  { Attribute -> ByteString
_attrIdent :: !ByteString,
    Attribute -> Maybe (GenExpr Identifier (Maybe CRangeExpr) ())
_attrValue :: !(Maybe (GenExpr Identifier (Maybe CRangeExpr) ()))
  }
  deriving (Int -> Attribute -> ShowS
[Attribute] -> ShowS
Attribute -> String
(Int -> Attribute -> ShowS)
-> (Attribute -> String)
-> ([Attribute] -> ShowS)
-> Show Attribute
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Attribute -> ShowS
showsPrec :: Int -> Attribute -> ShowS
$cshow :: Attribute -> String
show :: Attribute -> String
$cshowList :: [Attribute] -> ShowS
showList :: [Attribute] -> ShowS
Show, Attribute -> Attribute -> Bool
(Attribute -> Attribute -> Bool)
-> (Attribute -> Attribute -> Bool) -> Eq Attribute
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Attribute -> Attribute -> Bool
== :: Attribute -> Attribute -> Bool
$c/= :: Attribute -> Attribute -> Bool
/= :: Attribute -> Attribute -> Bool
Eq, Typeable Attribute
Typeable Attribute =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Attribute -> c Attribute)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Attribute)
-> (Attribute -> Constr)
-> (Attribute -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Attribute))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Attribute))
-> ((forall b. Data b => b -> b) -> Attribute -> Attribute)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Attribute -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Attribute -> r)
-> (forall u. (forall d. Data d => d -> u) -> Attribute -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Attribute -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Attribute -> m Attribute)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Attribute -> m Attribute)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Attribute -> m Attribute)
-> Data Attribute
Attribute -> Constr
Attribute -> DataType
(forall b. Data b => b -> b) -> Attribute -> Attribute
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 -> u
forall u. (forall d. Data d => d -> u) -> Attribute -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Attribute -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Attribute -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Attribute -> m Attribute
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Attribute -> m Attribute
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Attribute
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Attribute -> c Attribute
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Attribute)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Attribute)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Attribute -> c Attribute
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Attribute -> c Attribute
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Attribute
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Attribute
$ctoConstr :: Attribute -> Constr
toConstr :: Attribute -> Constr
$cdataTypeOf :: Attribute -> DataType
dataTypeOf :: Attribute -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Attribute)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Attribute)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Attribute)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Attribute)
$cgmapT :: (forall b. Data b => b -> b) -> Attribute -> Attribute
gmapT :: (forall b. Data b => b -> b) -> Attribute -> Attribute
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Attribute -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Attribute -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Attribute -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Attribute -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Attribute -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Attribute -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Attribute -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Attribute -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Attribute -> m Attribute
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Attribute -> m Attribute
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Attribute -> m Attribute
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Attribute -> m Attribute
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Attribute -> m Attribute
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Attribute -> m Attribute
Data, (forall x. Attribute -> Rep Attribute x)
-> (forall x. Rep Attribute x -> Attribute) -> Generic Attribute
forall x. Rep Attribute x -> Attribute
forall x. Attribute -> Rep Attribute x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Attribute -> Rep Attribute x
from :: forall x. Attribute -> Rep Attribute x
$cto :: forall x. Rep Attribute x -> Attribute
to :: forall x. Rep Attribute x -> Attribute
Generic)

type Attributes = [[Attribute]]

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

instance Functor Attributed where
  fmap :: forall a b. (a -> b) -> Attributed a -> Attributed b
fmap a -> b
f (Attributed Attributes
a a
x) = Attributes -> b -> Attributed b
forall t. Attributes -> t -> Attributed t
Attributed Attributes
a (b -> Attributed b) -> b -> Attributed b
forall a b. (a -> b) -> a -> b
$ a -> b
f a
x

instance Applicative Attributed where
  pure :: forall a. a -> Attributed a
pure = Attributes -> a -> Attributed a
forall t. Attributes -> t -> Attributed t
Attributed []
  <*> :: forall a b. Attributed (a -> b) -> Attributed a -> Attributed b
(<*>) (Attributed Attributes
a1 a -> b
f) (Attributed Attributes
a2 a
x) = Attributes -> b -> Attributed b
forall t. Attributes -> t -> Attributed t
Attributed (Attributes
a1 Attributes -> Attributes -> Attributes
forall a. Semigroup a => a -> a -> a
<> Attributes
a2) (b -> Attributed b) -> b -> Attributed b
forall a b. (a -> b) -> a -> b
$ a -> b
f a
x

instance Foldable Attributed where
  foldMap :: forall m a. Monoid m => (a -> m) -> Attributed a -> m
foldMap a -> m
f (Attributed Attributes
_ a
x) = a -> m
f a
x

instance Traversable Attributed where
  sequenceA :: forall (f :: * -> *) a.
Applicative f =>
Attributed (f a) -> f (Attributed a)
sequenceA (Attributed Attributes
a f a
x) = (a -> Attributed a) -> f a -> f (Attributed a)
forall a b. (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Attributes -> a -> Attributed a
forall t. Attributes -> t -> Attributed t
Attributed Attributes
a) f a
x

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

instance Functor AttrIded where
  fmap :: forall a b. (a -> b) -> AttrIded a -> AttrIded b
fmap a -> b
f (AttrIded Attributes
a Identifier
s a
x) = Attributes -> Identifier -> b -> AttrIded b
forall t. Attributes -> Identifier -> t -> AttrIded t
AttrIded Attributes
a Identifier
s (b -> AttrIded b) -> b -> AttrIded b
forall a b. (a -> b) -> a -> b
$ a -> b
f a
x

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

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

type RangeExpr = GenRangeExpr Expr

type CRangeExpr = GenRangeExpr CExpr

-- TODO? this can definitely be omitted and expressed as a MTM
-- | Number or Identifier
data NumIdent
  = NIIdent !Identifier
  | NIReal !ByteString
  | NINumber !Natural
  deriving (Int -> NumIdent -> ShowS
[NumIdent] -> ShowS
NumIdent -> String
(Int -> NumIdent -> ShowS)
-> (NumIdent -> String) -> ([NumIdent] -> ShowS) -> Show NumIdent
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> NumIdent -> ShowS
showsPrec :: Int -> NumIdent -> ShowS
$cshow :: NumIdent -> String
show :: NumIdent -> String
$cshowList :: [NumIdent] -> ShowS
showList :: [NumIdent] -> ShowS
Show, NumIdent -> NumIdent -> Bool
(NumIdent -> NumIdent -> Bool)
-> (NumIdent -> NumIdent -> Bool) -> Eq NumIdent
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: NumIdent -> NumIdent -> Bool
== :: NumIdent -> NumIdent -> Bool
$c/= :: NumIdent -> NumIdent -> Bool
/= :: NumIdent -> NumIdent -> Bool
Eq, Typeable NumIdent
Typeable NumIdent =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> NumIdent -> c NumIdent)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c NumIdent)
-> (NumIdent -> Constr)
-> (NumIdent -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c NumIdent))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NumIdent))
-> ((forall b. Data b => b -> b) -> NumIdent -> NumIdent)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> NumIdent -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> NumIdent -> r)
-> (forall u. (forall d. Data d => d -> u) -> NumIdent -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> NumIdent -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> NumIdent -> m NumIdent)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> NumIdent -> m NumIdent)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> NumIdent -> m NumIdent)
-> Data NumIdent
NumIdent -> Constr
NumIdent -> DataType
(forall b. Data b => b -> b) -> NumIdent -> NumIdent
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) -> NumIdent -> u
forall u. (forall d. Data d => d -> u) -> NumIdent -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NumIdent -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NumIdent -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> NumIdent -> m NumIdent
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NumIdent -> m NumIdent
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c NumIdent
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NumIdent -> c NumIdent
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c NumIdent)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NumIdent)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NumIdent -> c NumIdent
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NumIdent -> c NumIdent
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c NumIdent
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c NumIdent
$ctoConstr :: NumIdent -> Constr
toConstr :: NumIdent -> Constr
$cdataTypeOf :: NumIdent -> DataType
dataTypeOf :: NumIdent -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c NumIdent)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c NumIdent)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NumIdent)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NumIdent)
$cgmapT :: (forall b. Data b => b -> b) -> NumIdent -> NumIdent
gmapT :: (forall b. Data b => b -> b) -> NumIdent -> NumIdent
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NumIdent -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NumIdent -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NumIdent -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NumIdent -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> NumIdent -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> NumIdent -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> NumIdent -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> NumIdent -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> NumIdent -> m NumIdent
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> NumIdent -> m NumIdent
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NumIdent -> m NumIdent
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NumIdent -> m NumIdent
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NumIdent -> m NumIdent
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NumIdent -> m NumIdent
Data, (forall x. NumIdent -> Rep NumIdent x)
-> (forall x. Rep NumIdent x -> NumIdent) -> Generic NumIdent
forall x. Rep NumIdent x -> NumIdent
forall x. NumIdent -> Rep NumIdent x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. NumIdent -> Rep NumIdent x
from :: forall x. NumIdent -> Rep NumIdent x
$cto :: forall x. Rep NumIdent x -> NumIdent
to :: forall x. Rep NumIdent x -> NumIdent
Generic)

-- TODO? Base and 1 can be expressed as 3, not 2 though, option delay means delay 0
-- | Delay3
data Delay3
  = D3Base !NumIdent
  | D31 !MinTypMax
  | D32 { Delay3 -> MinTypMax
_d32Rise :: !MinTypMax, Delay3 -> MinTypMax
_d32Fall :: !MinTypMax }
  | D33 { Delay3 -> MinTypMax
_d33Rise :: !MinTypMax, Delay3 -> MinTypMax
_d33Fall :: !MinTypMax, Delay3 -> MinTypMax
_d33HighZ :: !MinTypMax }
  deriving (Int -> Delay3 -> ShowS
[Delay3] -> ShowS
Delay3 -> String
(Int -> Delay3 -> ShowS)
-> (Delay3 -> String) -> ([Delay3] -> ShowS) -> Show Delay3
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Delay3 -> ShowS
showsPrec :: Int -> Delay3 -> ShowS
$cshow :: Delay3 -> String
show :: Delay3 -> String
$cshowList :: [Delay3] -> ShowS
showList :: [Delay3] -> ShowS
Show, Delay3 -> Delay3 -> Bool
(Delay3 -> Delay3 -> Bool)
-> (Delay3 -> Delay3 -> Bool) -> Eq Delay3
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Delay3 -> Delay3 -> Bool
== :: Delay3 -> Delay3 -> Bool
$c/= :: Delay3 -> Delay3 -> Bool
/= :: Delay3 -> Delay3 -> Bool
Eq, Typeable Delay3
Typeable Delay3 =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Delay3 -> c Delay3)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Delay3)
-> (Delay3 -> Constr)
-> (Delay3 -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Delay3))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Delay3))
-> ((forall b. Data b => b -> b) -> Delay3 -> Delay3)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Delay3 -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Delay3 -> r)
-> (forall u. (forall d. Data d => d -> u) -> Delay3 -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Delay3 -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Delay3 -> m Delay3)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Delay3 -> m Delay3)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Delay3 -> m Delay3)
-> Data Delay3
Delay3 -> Constr
Delay3 -> DataType
(forall b. Data b => b -> b) -> Delay3 -> Delay3
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) -> Delay3 -> u
forall u. (forall d. Data d => d -> u) -> Delay3 -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Delay3 -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Delay3 -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Delay3 -> m Delay3
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Delay3 -> m Delay3
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Delay3
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Delay3 -> c Delay3
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Delay3)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Delay3)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Delay3 -> c Delay3
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Delay3 -> c Delay3
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Delay3
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Delay3
$ctoConstr :: Delay3 -> Constr
toConstr :: Delay3 -> Constr
$cdataTypeOf :: Delay3 -> DataType
dataTypeOf :: Delay3 -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Delay3)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Delay3)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Delay3)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Delay3)
$cgmapT :: (forall b. Data b => b -> b) -> Delay3 -> Delay3
gmapT :: (forall b. Data b => b -> b) -> Delay3 -> Delay3
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Delay3 -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Delay3 -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Delay3 -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Delay3 -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Delay3 -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Delay3 -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Delay3 -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Delay3 -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Delay3 -> m Delay3
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Delay3 -> m Delay3
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Delay3 -> m Delay3
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Delay3 -> m Delay3
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Delay3 -> m Delay3
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Delay3 -> m Delay3
Data, (forall x. Delay3 -> Rep Delay3 x)
-> (forall x. Rep Delay3 x -> Delay3) -> Generic Delay3
forall x. Rep Delay3 x -> Delay3
forall x. Delay3 -> Rep Delay3 x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Delay3 -> Rep Delay3 x
from :: forall x. Delay3 -> Rep Delay3 x
$cto :: forall x. Rep Delay3 x -> Delay3
to :: forall x. Rep Delay3 x -> Delay3
Generic)

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

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

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

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

-- | Event expression prefix
data EventPrefix = EPAny | EPPos | EPNeg
  deriving (Int -> EventPrefix -> ShowS
[EventPrefix] -> ShowS
EventPrefix -> String
(Int -> EventPrefix -> ShowS)
-> (EventPrefix -> String)
-> ([EventPrefix] -> ShowS)
-> Show EventPrefix
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> EventPrefix -> ShowS
showsPrec :: Int -> EventPrefix -> ShowS
$cshow :: EventPrefix -> String
show :: EventPrefix -> String
$cshowList :: [EventPrefix] -> ShowS
showList :: [EventPrefix] -> ShowS
Show, EventPrefix -> EventPrefix -> Bool
(EventPrefix -> EventPrefix -> Bool)
-> (EventPrefix -> EventPrefix -> Bool) -> Eq EventPrefix
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: EventPrefix -> EventPrefix -> Bool
== :: EventPrefix -> EventPrefix -> Bool
$c/= :: EventPrefix -> EventPrefix -> Bool
/= :: EventPrefix -> EventPrefix -> Bool
Eq, EventPrefix
EventPrefix -> EventPrefix -> Bounded EventPrefix
forall a. a -> a -> Bounded a
$cminBound :: EventPrefix
minBound :: EventPrefix
$cmaxBound :: EventPrefix
maxBound :: EventPrefix
Bounded, Int -> EventPrefix
EventPrefix -> Int
EventPrefix -> [EventPrefix]
EventPrefix -> EventPrefix
EventPrefix -> EventPrefix -> [EventPrefix]
EventPrefix -> EventPrefix -> EventPrefix -> [EventPrefix]
(EventPrefix -> EventPrefix)
-> (EventPrefix -> EventPrefix)
-> (Int -> EventPrefix)
-> (EventPrefix -> Int)
-> (EventPrefix -> [EventPrefix])
-> (EventPrefix -> EventPrefix -> [EventPrefix])
-> (EventPrefix -> EventPrefix -> [EventPrefix])
-> (EventPrefix -> EventPrefix -> EventPrefix -> [EventPrefix])
-> Enum EventPrefix
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: EventPrefix -> EventPrefix
succ :: EventPrefix -> EventPrefix
$cpred :: EventPrefix -> EventPrefix
pred :: EventPrefix -> EventPrefix
$ctoEnum :: Int -> EventPrefix
toEnum :: Int -> EventPrefix
$cfromEnum :: EventPrefix -> Int
fromEnum :: EventPrefix -> Int
$cenumFrom :: EventPrefix -> [EventPrefix]
enumFrom :: EventPrefix -> [EventPrefix]
$cenumFromThen :: EventPrefix -> EventPrefix -> [EventPrefix]
enumFromThen :: EventPrefix -> EventPrefix -> [EventPrefix]
$cenumFromTo :: EventPrefix -> EventPrefix -> [EventPrefix]
enumFromTo :: EventPrefix -> EventPrefix -> [EventPrefix]
$cenumFromThenTo :: EventPrefix -> EventPrefix -> EventPrefix -> [EventPrefix]
enumFromThenTo :: EventPrefix -> EventPrefix -> EventPrefix -> [EventPrefix]
Enum, Typeable EventPrefix
Typeable EventPrefix =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> EventPrefix -> c EventPrefix)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c EventPrefix)
-> (EventPrefix -> Constr)
-> (EventPrefix -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c EventPrefix))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c EventPrefix))
-> ((forall b. Data b => b -> b) -> EventPrefix -> EventPrefix)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> EventPrefix -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> EventPrefix -> r)
-> (forall u. (forall d. Data d => d -> u) -> EventPrefix -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> EventPrefix -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> EventPrefix -> m EventPrefix)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> EventPrefix -> m EventPrefix)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> EventPrefix -> m EventPrefix)
-> Data EventPrefix
EventPrefix -> Constr
EventPrefix -> DataType
(forall b. Data b => b -> b) -> EventPrefix -> EventPrefix
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) -> EventPrefix -> u
forall u. (forall d. Data d => d -> u) -> EventPrefix -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> EventPrefix -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> EventPrefix -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> EventPrefix -> m EventPrefix
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> EventPrefix -> m EventPrefix
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c EventPrefix
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> EventPrefix -> c EventPrefix
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c EventPrefix)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c EventPrefix)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> EventPrefix -> c EventPrefix
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> EventPrefix -> c EventPrefix
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c EventPrefix
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c EventPrefix
$ctoConstr :: EventPrefix -> Constr
toConstr :: EventPrefix -> Constr
$cdataTypeOf :: EventPrefix -> DataType
dataTypeOf :: EventPrefix -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c EventPrefix)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c EventPrefix)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c EventPrefix)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c EventPrefix)
$cgmapT :: (forall b. Data b => b -> b) -> EventPrefix -> EventPrefix
gmapT :: (forall b. Data b => b -> b) -> EventPrefix -> EventPrefix
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> EventPrefix -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> EventPrefix -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> EventPrefix -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> EventPrefix -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> EventPrefix -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> EventPrefix -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> EventPrefix -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> EventPrefix -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> EventPrefix -> m EventPrefix
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> EventPrefix -> m EventPrefix
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> EventPrefix -> m EventPrefix
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> EventPrefix -> m EventPrefix
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> EventPrefix -> m EventPrefix
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> EventPrefix -> m EventPrefix
Data, (forall x. EventPrefix -> Rep EventPrefix x)
-> (forall x. Rep EventPrefix x -> EventPrefix)
-> Generic EventPrefix
forall x. Rep EventPrefix x -> EventPrefix
forall x. EventPrefix -> Rep EventPrefix x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. EventPrefix -> Rep EventPrefix x
from :: forall x. EventPrefix -> Rep EventPrefix x
$cto :: forall x. Rep EventPrefix x -> EventPrefix
to :: forall x. Rep EventPrefix x -> EventPrefix
Generic)

-- | Port datatransfer directions
data Dir = DirIn | DirOut | DirInOut
  deriving (Dir -> Dir -> Bool
(Dir -> Dir -> Bool) -> (Dir -> Dir -> Bool) -> Eq Dir
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Dir -> Dir -> Bool
== :: Dir -> Dir -> Bool
$c/= :: Dir -> Dir -> Bool
/= :: Dir -> Dir -> Bool
Eq, Dir
Dir -> Dir -> Bounded Dir
forall a. a -> a -> Bounded a
$cminBound :: Dir
minBound :: Dir
$cmaxBound :: Dir
maxBound :: Dir
Bounded, Int -> Dir
Dir -> Int
Dir -> [Dir]
Dir -> Dir
Dir -> Dir -> [Dir]
Dir -> Dir -> Dir -> [Dir]
(Dir -> Dir)
-> (Dir -> Dir)
-> (Int -> Dir)
-> (Dir -> Int)
-> (Dir -> [Dir])
-> (Dir -> Dir -> [Dir])
-> (Dir -> Dir -> [Dir])
-> (Dir -> Dir -> Dir -> [Dir])
-> Enum Dir
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: Dir -> Dir
succ :: Dir -> Dir
$cpred :: Dir -> Dir
pred :: Dir -> Dir
$ctoEnum :: Int -> Dir
toEnum :: Int -> Dir
$cfromEnum :: Dir -> Int
fromEnum :: Dir -> Int
$cenumFrom :: Dir -> [Dir]
enumFrom :: Dir -> [Dir]
$cenumFromThen :: Dir -> Dir -> [Dir]
enumFromThen :: Dir -> Dir -> [Dir]
$cenumFromTo :: Dir -> Dir -> [Dir]
enumFromTo :: Dir -> Dir -> [Dir]
$cenumFromThenTo :: Dir -> Dir -> Dir -> [Dir]
enumFromThenTo :: Dir -> Dir -> Dir -> [Dir]
Enum, Typeable Dir
Typeable Dir =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Dir -> c Dir)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Dir)
-> (Dir -> Constr)
-> (Dir -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Dir))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Dir))
-> ((forall b. Data b => b -> b) -> Dir -> Dir)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Dir -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Dir -> r)
-> (forall u. (forall d. Data d => d -> u) -> Dir -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Dir -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Dir -> m Dir)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Dir -> m Dir)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Dir -> m Dir)
-> Data Dir
Dir -> Constr
Dir -> DataType
(forall b. Data b => b -> b) -> Dir -> Dir
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) -> Dir -> u
forall u. (forall d. Data d => d -> u) -> Dir -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Dir -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Dir -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Dir -> m Dir
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Dir -> m Dir
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Dir
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Dir -> c Dir
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Dir)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Dir)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Dir -> c Dir
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Dir -> c Dir
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Dir
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Dir
$ctoConstr :: Dir -> Constr
toConstr :: Dir -> Constr
$cdataTypeOf :: Dir -> DataType
dataTypeOf :: Dir -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Dir)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Dir)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Dir)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Dir)
$cgmapT :: (forall b. Data b => b -> b) -> Dir -> Dir
gmapT :: (forall b. Data b => b -> b) -> Dir -> Dir
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Dir -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Dir -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Dir -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Dir -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Dir -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Dir -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Dir -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Dir -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Dir -> m Dir
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Dir -> m Dir
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Dir -> m Dir
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Dir -> m Dir
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Dir -> m Dir
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Dir -> m Dir
Data, (forall x. Dir -> Rep Dir x)
-> (forall x. Rep Dir x -> Dir) -> Generic Dir
forall x. Rep Dir x -> Dir
forall x. Dir -> Rep Dir x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Dir -> Rep Dir x
from :: forall x. Dir -> Rep Dir x
$cto :: forall x. Rep Dir x -> Dir
to :: forall x. Rep Dir x -> Dir
Generic)

instance Show Dir where
  show :: Dir -> String
show Dir
x = case Dir
x of Dir
DirIn -> String
"input"; Dir
DirOut -> String
"output"; Dir
DirInOut -> String
"inout"

-- | Abstract types for variables, parameters, functions and tasks
data AbsType = ATInteger | ATReal | ATRealtime | ATTime
  deriving (AbsType -> AbsType -> Bool
(AbsType -> AbsType -> Bool)
-> (AbsType -> AbsType -> Bool) -> Eq AbsType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: AbsType -> AbsType -> Bool
== :: AbsType -> AbsType -> Bool
$c/= :: AbsType -> AbsType -> Bool
/= :: AbsType -> AbsType -> Bool
Eq, AbsType
AbsType -> AbsType -> Bounded AbsType
forall a. a -> a -> Bounded a
$cminBound :: AbsType
minBound :: AbsType
$cmaxBound :: AbsType
maxBound :: AbsType
Bounded, Int -> AbsType
AbsType -> Int
AbsType -> [AbsType]
AbsType -> AbsType
AbsType -> AbsType -> [AbsType]
AbsType -> AbsType -> AbsType -> [AbsType]
(AbsType -> AbsType)
-> (AbsType -> AbsType)
-> (Int -> AbsType)
-> (AbsType -> Int)
-> (AbsType -> [AbsType])
-> (AbsType -> AbsType -> [AbsType])
-> (AbsType -> AbsType -> [AbsType])
-> (AbsType -> AbsType -> AbsType -> [AbsType])
-> Enum AbsType
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: AbsType -> AbsType
succ :: AbsType -> AbsType
$cpred :: AbsType -> AbsType
pred :: AbsType -> AbsType
$ctoEnum :: Int -> AbsType
toEnum :: Int -> AbsType
$cfromEnum :: AbsType -> Int
fromEnum :: AbsType -> Int
$cenumFrom :: AbsType -> [AbsType]
enumFrom :: AbsType -> [AbsType]
$cenumFromThen :: AbsType -> AbsType -> [AbsType]
enumFromThen :: AbsType -> AbsType -> [AbsType]
$cenumFromTo :: AbsType -> AbsType -> [AbsType]
enumFromTo :: AbsType -> AbsType -> [AbsType]
$cenumFromThenTo :: AbsType -> AbsType -> AbsType -> [AbsType]
enumFromThenTo :: AbsType -> AbsType -> AbsType -> [AbsType]
Enum, Typeable AbsType
Typeable AbsType =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> AbsType -> c AbsType)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c AbsType)
-> (AbsType -> Constr)
-> (AbsType -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c AbsType))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AbsType))
-> ((forall b. Data b => b -> b) -> AbsType -> AbsType)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> AbsType -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> AbsType -> r)
-> (forall u. (forall d. Data d => d -> u) -> AbsType -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> AbsType -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> AbsType -> m AbsType)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> AbsType -> m AbsType)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> AbsType -> m AbsType)
-> Data AbsType
AbsType -> Constr
AbsType -> DataType
(forall b. Data b => b -> b) -> AbsType -> AbsType
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) -> AbsType -> u
forall u. (forall d. Data d => d -> u) -> AbsType -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> AbsType -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> AbsType -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> AbsType -> m AbsType
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> AbsType -> m AbsType
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c AbsType
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> AbsType -> c AbsType
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c AbsType)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AbsType)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> AbsType -> c AbsType
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> AbsType -> c AbsType
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c AbsType
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c AbsType
$ctoConstr :: AbsType -> Constr
toConstr :: AbsType -> Constr
$cdataTypeOf :: AbsType -> DataType
dataTypeOf :: AbsType -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c AbsType)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c AbsType)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AbsType)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AbsType)
$cgmapT :: (forall b. Data b => b -> b) -> AbsType -> AbsType
gmapT :: (forall b. Data b => b -> b) -> AbsType -> AbsType
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> AbsType -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> AbsType -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> AbsType -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> AbsType -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> AbsType -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> AbsType -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> AbsType -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> AbsType -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> AbsType -> m AbsType
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> AbsType -> m AbsType
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> AbsType -> m AbsType
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> AbsType -> m AbsType
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> AbsType -> m AbsType
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> AbsType -> m AbsType
Data, (forall x. AbsType -> Rep AbsType x)
-> (forall x. Rep AbsType x -> AbsType) -> Generic AbsType
forall x. Rep AbsType x -> AbsType
forall x. AbsType -> Rep AbsType x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. AbsType -> Rep AbsType x
from :: forall x. AbsType -> Rep AbsType x
$cto :: forall x. Rep AbsType x -> AbsType
to :: forall x. Rep AbsType x -> AbsType
Generic)

instance Show AbsType where
  show :: AbsType -> String
show AbsType
x = case AbsType
x of
    AbsType
ATInteger -> String
"integer"
    AbsType
ATReal -> String
"real"
    AbsType
ATRealtime -> String
"realtime"
    AbsType
ATTime -> String
"time"

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

-- | Net type
data NetType
  = NTSupply1
  | NTSupply0
  | NTTri
  | NTTriAnd
  | NTTriOr
  | NTTri1
  | NTTri0
  | NTUwire
  | NTWire
  | NTWAnd
  | NTWOr
  deriving (NetType -> NetType -> Bool
(NetType -> NetType -> Bool)
-> (NetType -> NetType -> Bool) -> Eq NetType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: NetType -> NetType -> Bool
== :: NetType -> NetType -> Bool
$c/= :: NetType -> NetType -> Bool
/= :: NetType -> NetType -> Bool
Eq, NetType
NetType -> NetType -> Bounded NetType
forall a. a -> a -> Bounded a
$cminBound :: NetType
minBound :: NetType
$cmaxBound :: NetType
maxBound :: NetType
Bounded, Int -> NetType
NetType -> Int
NetType -> [NetType]
NetType -> NetType
NetType -> NetType -> [NetType]
NetType -> NetType -> NetType -> [NetType]
(NetType -> NetType)
-> (NetType -> NetType)
-> (Int -> NetType)
-> (NetType -> Int)
-> (NetType -> [NetType])
-> (NetType -> NetType -> [NetType])
-> (NetType -> NetType -> [NetType])
-> (NetType -> NetType -> NetType -> [NetType])
-> Enum NetType
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: NetType -> NetType
succ :: NetType -> NetType
$cpred :: NetType -> NetType
pred :: NetType -> NetType
$ctoEnum :: Int -> NetType
toEnum :: Int -> NetType
$cfromEnum :: NetType -> Int
fromEnum :: NetType -> Int
$cenumFrom :: NetType -> [NetType]
enumFrom :: NetType -> [NetType]
$cenumFromThen :: NetType -> NetType -> [NetType]
enumFromThen :: NetType -> NetType -> [NetType]
$cenumFromTo :: NetType -> NetType -> [NetType]
enumFromTo :: NetType -> NetType -> [NetType]
$cenumFromThenTo :: NetType -> NetType -> NetType -> [NetType]
enumFromThenTo :: NetType -> NetType -> NetType -> [NetType]
Enum, Typeable NetType
Typeable NetType =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> NetType -> c NetType)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c NetType)
-> (NetType -> Constr)
-> (NetType -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c NetType))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NetType))
-> ((forall b. Data b => b -> b) -> NetType -> NetType)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> NetType -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> NetType -> r)
-> (forall u. (forall d. Data d => d -> u) -> NetType -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> NetType -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> NetType -> m NetType)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> NetType -> m NetType)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> NetType -> m NetType)
-> Data NetType
NetType -> Constr
NetType -> DataType
(forall b. Data b => b -> b) -> NetType -> NetType
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) -> NetType -> u
forall u. (forall d. Data d => d -> u) -> NetType -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NetType -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NetType -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> NetType -> m NetType
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NetType -> m NetType
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c NetType
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NetType -> c NetType
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c NetType)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NetType)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NetType -> c NetType
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NetType -> c NetType
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c NetType
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c NetType
$ctoConstr :: NetType -> Constr
toConstr :: NetType -> Constr
$cdataTypeOf :: NetType -> DataType
dataTypeOf :: NetType -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c NetType)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c NetType)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NetType)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NetType)
$cgmapT :: (forall b. Data b => b -> b) -> NetType -> NetType
gmapT :: (forall b. Data b => b -> b) -> NetType -> NetType
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NetType -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NetType -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NetType -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NetType -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> NetType -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> NetType -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> NetType -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> NetType -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> NetType -> m NetType
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> NetType -> m NetType
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NetType -> m NetType
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NetType -> m NetType
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NetType -> m NetType
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NetType -> m NetType
Data, (forall x. NetType -> Rep NetType x)
-> (forall x. Rep NetType x -> NetType) -> Generic NetType
forall x. Rep NetType x -> NetType
forall x. NetType -> Rep NetType x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. NetType -> Rep NetType x
from :: forall x. NetType -> Rep NetType x
$cto :: forall x. Rep NetType x -> NetType
to :: forall x. Rep NetType x -> NetType
Generic)

instance Show NetType where
  show :: NetType -> String
show NetType
x = case NetType
x of
    NetType
NTSupply1 -> String
"supply1"
    NetType
NTSupply0 -> String
"supply0"
    NetType
NTTri -> String
"tri"
    NetType
NTTriAnd -> String
"triand"
    NetType
NTTriOr -> String
"trior"
    NetType
NTTri1 -> String
"tri1"
    NetType
NTTri0 -> String
"tri0"
    NetType
NTUwire -> String
"uwire"
    NetType
NTWire -> String
"wire"
    NetType
NTWAnd -> String
"wand"
    NetType
NTWOr -> String
"wor"

-- | Net drive strengths
data Strength = StrSupply | StrStrong {-default-} | StrPull | StrWeak
  deriving (Strength -> Strength -> Bool
(Strength -> Strength -> Bool)
-> (Strength -> Strength -> Bool) -> Eq Strength
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Strength -> Strength -> Bool
== :: Strength -> Strength -> Bool
$c/= :: Strength -> Strength -> Bool
/= :: Strength -> Strength -> Bool
Eq, Strength
Strength -> Strength -> Bounded Strength
forall a. a -> a -> Bounded a
$cminBound :: Strength
minBound :: Strength
$cmaxBound :: Strength
maxBound :: Strength
Bounded, Int -> Strength
Strength -> Int
Strength -> [Strength]
Strength -> Strength
Strength -> Strength -> [Strength]
Strength -> Strength -> Strength -> [Strength]
(Strength -> Strength)
-> (Strength -> Strength)
-> (Int -> Strength)
-> (Strength -> Int)
-> (Strength -> [Strength])
-> (Strength -> Strength -> [Strength])
-> (Strength -> Strength -> [Strength])
-> (Strength -> Strength -> Strength -> [Strength])
-> Enum Strength
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: Strength -> Strength
succ :: Strength -> Strength
$cpred :: Strength -> Strength
pred :: Strength -> Strength
$ctoEnum :: Int -> Strength
toEnum :: Int -> Strength
$cfromEnum :: Strength -> Int
fromEnum :: Strength -> Int
$cenumFrom :: Strength -> [Strength]
enumFrom :: Strength -> [Strength]
$cenumFromThen :: Strength -> Strength -> [Strength]
enumFromThen :: Strength -> Strength -> [Strength]
$cenumFromTo :: Strength -> Strength -> [Strength]
enumFromTo :: Strength -> Strength -> [Strength]
$cenumFromThenTo :: Strength -> Strength -> Strength -> [Strength]
enumFromThenTo :: Strength -> Strength -> Strength -> [Strength]
Enum, Typeable Strength
Typeable Strength =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Strength -> c Strength)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Strength)
-> (Strength -> Constr)
-> (Strength -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Strength))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Strength))
-> ((forall b. Data b => b -> b) -> Strength -> Strength)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Strength -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Strength -> r)
-> (forall u. (forall d. Data d => d -> u) -> Strength -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Strength -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Strength -> m Strength)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Strength -> m Strength)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Strength -> m Strength)
-> Data Strength
Strength -> Constr
Strength -> DataType
(forall b. Data b => b -> b) -> Strength -> Strength
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) -> Strength -> u
forall u. (forall d. Data d => d -> u) -> Strength -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Strength -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Strength -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Strength -> m Strength
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Strength -> m Strength
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Strength
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Strength -> c Strength
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Strength)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Strength)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Strength -> c Strength
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Strength -> c Strength
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Strength
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Strength
$ctoConstr :: Strength -> Constr
toConstr :: Strength -> Constr
$cdataTypeOf :: Strength -> DataType
dataTypeOf :: Strength -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Strength)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Strength)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Strength)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Strength)
$cgmapT :: (forall b. Data b => b -> b) -> Strength -> Strength
gmapT :: (forall b. Data b => b -> b) -> Strength -> Strength
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Strength -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Strength -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Strength -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Strength -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Strength -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Strength -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Strength -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Strength -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Strength -> m Strength
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Strength -> m Strength
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Strength -> m Strength
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Strength -> m Strength
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Strength -> m Strength
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Strength -> m Strength
Data, (forall x. Strength -> Rep Strength x)
-> (forall x. Rep Strength x -> Strength) -> Generic Strength
forall x. Rep Strength x -> Strength
forall x. Strength -> Rep Strength x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Strength -> Rep Strength x
from :: forall x. Strength -> Rep Strength x
$cto :: forall x. Rep Strength x -> Strength
to :: forall x. Rep Strength x -> Strength
Generic)

instance Show Strength where
  show :: Strength -> String
show Strength
x = case Strength
x of
    Strength
StrSupply -> String
"supply"
    Strength
StrStrong -> String
"strong"
    Strength
StrPull -> String
"pull"
    Strength
StrWeak -> String
"weak"

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

dsDefault :: DriveStrength
dsDefault = DSNormal {_ds0 :: Strength
_ds0 = Strength
StrStrong, _ds1 :: Strength
_ds1 = Strength
StrStrong}

-- | Capacitor charge
data ChargeStrength = CSSmall | CSMedium {-default-} | CSLarge
  deriving (ChargeStrength -> ChargeStrength -> Bool
(ChargeStrength -> ChargeStrength -> Bool)
-> (ChargeStrength -> ChargeStrength -> Bool) -> Eq ChargeStrength
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ChargeStrength -> ChargeStrength -> Bool
== :: ChargeStrength -> ChargeStrength -> Bool
$c/= :: ChargeStrength -> ChargeStrength -> Bool
/= :: ChargeStrength -> ChargeStrength -> Bool
Eq, ChargeStrength
ChargeStrength -> ChargeStrength -> Bounded ChargeStrength
forall a. a -> a -> Bounded a
$cminBound :: ChargeStrength
minBound :: ChargeStrength
$cmaxBound :: ChargeStrength
maxBound :: ChargeStrength
Bounded, Int -> ChargeStrength
ChargeStrength -> Int
ChargeStrength -> [ChargeStrength]
ChargeStrength -> ChargeStrength
ChargeStrength -> ChargeStrength -> [ChargeStrength]
ChargeStrength
-> ChargeStrength -> ChargeStrength -> [ChargeStrength]
(ChargeStrength -> ChargeStrength)
-> (ChargeStrength -> ChargeStrength)
-> (Int -> ChargeStrength)
-> (ChargeStrength -> Int)
-> (ChargeStrength -> [ChargeStrength])
-> (ChargeStrength -> ChargeStrength -> [ChargeStrength])
-> (ChargeStrength -> ChargeStrength -> [ChargeStrength])
-> (ChargeStrength
    -> ChargeStrength -> ChargeStrength -> [ChargeStrength])
-> Enum ChargeStrength
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: ChargeStrength -> ChargeStrength
succ :: ChargeStrength -> ChargeStrength
$cpred :: ChargeStrength -> ChargeStrength
pred :: ChargeStrength -> ChargeStrength
$ctoEnum :: Int -> ChargeStrength
toEnum :: Int -> ChargeStrength
$cfromEnum :: ChargeStrength -> Int
fromEnum :: ChargeStrength -> Int
$cenumFrom :: ChargeStrength -> [ChargeStrength]
enumFrom :: ChargeStrength -> [ChargeStrength]
$cenumFromThen :: ChargeStrength -> ChargeStrength -> [ChargeStrength]
enumFromThen :: ChargeStrength -> ChargeStrength -> [ChargeStrength]
$cenumFromTo :: ChargeStrength -> ChargeStrength -> [ChargeStrength]
enumFromTo :: ChargeStrength -> ChargeStrength -> [ChargeStrength]
$cenumFromThenTo :: ChargeStrength
-> ChargeStrength -> ChargeStrength -> [ChargeStrength]
enumFromThenTo :: ChargeStrength
-> ChargeStrength -> ChargeStrength -> [ChargeStrength]
Enum, Typeable ChargeStrength
Typeable ChargeStrength =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> ChargeStrength -> c ChargeStrength)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ChargeStrength)
-> (ChargeStrength -> Constr)
-> (ChargeStrength -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ChargeStrength))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c ChargeStrength))
-> ((forall b. Data b => b -> b)
    -> ChargeStrength -> ChargeStrength)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ChargeStrength -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ChargeStrength -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> ChargeStrength -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> ChargeStrength -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> ChargeStrength -> m ChargeStrength)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> ChargeStrength -> m ChargeStrength)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> ChargeStrength -> m ChargeStrength)
-> Data ChargeStrength
ChargeStrength -> Constr
ChargeStrength -> DataType
(forall b. Data b => b -> b) -> ChargeStrength -> ChargeStrength
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) -> ChargeStrength -> u
forall u. (forall d. Data d => d -> u) -> ChargeStrength -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ChargeStrength -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ChargeStrength -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> ChargeStrength -> m ChargeStrength
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ChargeStrength -> m ChargeStrength
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ChargeStrength
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ChargeStrength -> c ChargeStrength
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ChargeStrength)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ChargeStrength)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ChargeStrength -> c ChargeStrength
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ChargeStrength -> c ChargeStrength
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ChargeStrength
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ChargeStrength
$ctoConstr :: ChargeStrength -> Constr
toConstr :: ChargeStrength -> Constr
$cdataTypeOf :: ChargeStrength -> DataType
dataTypeOf :: ChargeStrength -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ChargeStrength)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ChargeStrength)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ChargeStrength)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ChargeStrength)
$cgmapT :: (forall b. Data b => b -> b) -> ChargeStrength -> ChargeStrength
gmapT :: (forall b. Data b => b -> b) -> ChargeStrength -> ChargeStrength
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ChargeStrength -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ChargeStrength -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ChargeStrength -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ChargeStrength -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> ChargeStrength -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> ChargeStrength -> [u]
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> ChargeStrength -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> ChargeStrength -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> ChargeStrength -> m ChargeStrength
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> ChargeStrength -> m ChargeStrength
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ChargeStrength -> m ChargeStrength
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ChargeStrength -> m ChargeStrength
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ChargeStrength -> m ChargeStrength
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ChargeStrength -> m ChargeStrength
Data, (forall x. ChargeStrength -> Rep ChargeStrength x)
-> (forall x. Rep ChargeStrength x -> ChargeStrength)
-> Generic ChargeStrength
forall x. Rep ChargeStrength x -> ChargeStrength
forall x. ChargeStrength -> Rep ChargeStrength x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. ChargeStrength -> Rep ChargeStrength x
from :: forall x. ChargeStrength -> Rep ChargeStrength x
$cto :: forall x. Rep ChargeStrength x -> ChargeStrength
to :: forall x. Rep ChargeStrength x -> ChargeStrength
Generic)

instance Show ChargeStrength where
  show :: ChargeStrength -> String
show ChargeStrength
x = case ChargeStrength
x of ChargeStrength
CSSmall -> String
"(small)"; ChargeStrength
CSMedium -> String
"(medium)"; ChargeStrength
CSLarge -> String
"(large)"

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

type NetLValue = LValue CDimRange

type VarLValue = LValue DimRange

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

type NetAssign = Assign CDimRange
type VarAssign = Assign DimRange

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

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

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

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

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

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

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

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

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

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

-- | Function statement, more limited than general statement because they are purely combinational
data FunctionStatement
  = FSBlockAssign !VarAssign
  | FSCase
      { FunctionStatement -> ZOX
_fscType :: !ZOX,
        FunctionStatement -> Expr
_fscExpr :: !Expr,
        FunctionStatement -> [FCaseItem]
_fscBody :: ![FCaseItem],
        FunctionStatement -> MybFStmt
_fscDef :: !MybFStmt
      }
  | FSIf
      { FunctionStatement -> Expr
_fsiExpr :: !Expr,
        FunctionStatement -> MybFStmt
_fsiTrue :: !MybFStmt,
        FunctionStatement -> MybFStmt
_fsiFalse :: !MybFStmt
      }
  | FSDisable !HierIdent
  | FSLoop
      { FunctionStatement -> LoopStatement
_fslHead :: !LoopStatement,
        FunctionStatement -> AttrFStmt
_fslBody :: !AttrFStmt
      }
  | FSBlock
      { FunctionStatement -> Maybe (Identifier, [AttrIded StdBlockDecl])
_fsbHeader :: !(Maybe (Identifier, [AttrIded StdBlockDecl])),
        FunctionStatement -> Bool
_fsbPar_seq :: !Bool,
        FunctionStatement -> [AttrFStmt]
_fsbStmt :: ![AttrFStmt]
      }
  deriving (Int -> FunctionStatement -> ShowS
[FunctionStatement] -> ShowS
FunctionStatement -> String
(Int -> FunctionStatement -> ShowS)
-> (FunctionStatement -> String)
-> ([FunctionStatement] -> ShowS)
-> Show FunctionStatement
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> FunctionStatement -> ShowS
showsPrec :: Int -> FunctionStatement -> ShowS
$cshow :: FunctionStatement -> String
show :: FunctionStatement -> String
$cshowList :: [FunctionStatement] -> ShowS
showList :: [FunctionStatement] -> ShowS
Show, FunctionStatement -> FunctionStatement -> Bool
(FunctionStatement -> FunctionStatement -> Bool)
-> (FunctionStatement -> FunctionStatement -> Bool)
-> Eq FunctionStatement
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: FunctionStatement -> FunctionStatement -> Bool
== :: FunctionStatement -> FunctionStatement -> Bool
$c/= :: FunctionStatement -> FunctionStatement -> Bool
/= :: FunctionStatement -> FunctionStatement -> Bool
Eq, Typeable FunctionStatement
Typeable FunctionStatement =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g)
 -> FunctionStatement
 -> c FunctionStatement)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c FunctionStatement)
-> (FunctionStatement -> Constr)
-> (FunctionStatement -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c FunctionStatement))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c FunctionStatement))
-> ((forall b. Data b => b -> b)
    -> FunctionStatement -> FunctionStatement)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> FunctionStatement -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> FunctionStatement -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> FunctionStatement -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> FunctionStatement -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> FunctionStatement -> m FunctionStatement)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> FunctionStatement -> m FunctionStatement)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> FunctionStatement -> m FunctionStatement)
-> Data FunctionStatement
FunctionStatement -> Constr
FunctionStatement -> DataType
(forall b. Data b => b -> b)
-> FunctionStatement -> FunctionStatement
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) -> FunctionStatement -> u
forall u. (forall d. Data d => d -> u) -> FunctionStatement -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FunctionStatement -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FunctionStatement -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> FunctionStatement -> m FunctionStatement
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> FunctionStatement -> m FunctionStatement
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FunctionStatement
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FunctionStatement -> c FunctionStatement
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c FunctionStatement)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c FunctionStatement)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FunctionStatement -> c FunctionStatement
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FunctionStatement -> c FunctionStatement
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FunctionStatement
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FunctionStatement
$ctoConstr :: FunctionStatement -> Constr
toConstr :: FunctionStatement -> Constr
$cdataTypeOf :: FunctionStatement -> DataType
dataTypeOf :: FunctionStatement -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c FunctionStatement)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c FunctionStatement)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c FunctionStatement)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c FunctionStatement)
$cgmapT :: (forall b. Data b => b -> b)
-> FunctionStatement -> FunctionStatement
gmapT :: (forall b. Data b => b -> b)
-> FunctionStatement -> FunctionStatement
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FunctionStatement -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FunctionStatement -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FunctionStatement -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FunctionStatement -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> FunctionStatement -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> FunctionStatement -> [u]
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> FunctionStatement -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> FunctionStatement -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> FunctionStatement -> m FunctionStatement
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> FunctionStatement -> m FunctionStatement
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> FunctionStatement -> m FunctionStatement
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> FunctionStatement -> m FunctionStatement
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> FunctionStatement -> m FunctionStatement
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> FunctionStatement -> m FunctionStatement
Data, (forall x. FunctionStatement -> Rep FunctionStatement x)
-> (forall x. Rep FunctionStatement x -> FunctionStatement)
-> Generic FunctionStatement
forall x. Rep FunctionStatement x -> FunctionStatement
forall x. FunctionStatement -> Rep FunctionStatement x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. FunctionStatement -> Rep FunctionStatement x
from :: forall x. FunctionStatement -> Rep FunctionStatement x
$cto :: forall x. Rep FunctionStatement x -> FunctionStatement
to :: forall x. Rep FunctionStatement x -> FunctionStatement
Generic)

instance Plated FunctionStatement where
  plate :: Traversal' FunctionStatement FunctionStatement
plate = (FunctionStatement -> f FunctionStatement)
-> FunctionStatement -> f FunctionStatement
forall a. Data a => Traversal' a a
Traversal' FunctionStatement FunctionStatement
uniplate

type AttrFStmt = Attributed FunctionStatement

type MybFStmt = Attributed (Maybe FunctionStatement)

-- | Statement
data Statement
  = SBlockAssign
      { Statement -> Bool
_sbaBlock :: !Bool,
        Statement -> VarAssign
_sbaAssign :: !VarAssign,
        Statement -> Maybe DelayEventControl
_sbaDelev :: !(Maybe DelayEventControl)
      }
  | SCase
      { Statement -> ZOX
_scType :: !ZOX,
        Statement -> Expr
_scExpr :: !Expr,
        Statement -> [CaseItem]
_scBody :: ![CaseItem],
        Statement -> MybStmt
_scDef :: !MybStmt
      }
  | SIf
      { Statement -> Expr
_siExpr :: !Expr,
        Statement -> MybStmt
_siTrue :: !MybStmt,
        Statement -> MybStmt
_siFalse :: !MybStmt
      }
  | SDisable !HierIdent
  | SEventTrigger
      { Statement -> HierIdent
_setIdent :: !HierIdent,
        Statement -> [Expr]
_setIndex :: ![Expr]
      }
  | SLoop
      { Statement -> LoopStatement
_slHead :: !LoopStatement,
        Statement -> AttrStmt
_slBody :: !AttrStmt
      }
  | SProcContAssign !ProcContAssign
  | SProcTimingControl
      { Statement -> Either Delay1 EventControl
_sptcControl :: !(Either Delay1 EventControl),
        Statement -> MybStmt
_sptcStmt :: !MybStmt
      }
  | SBlock
      { Statement -> Maybe (Identifier, [AttrIded StdBlockDecl])
_sbHeader :: !(Maybe (Identifier, [AttrIded StdBlockDecl])),
        Statement -> Bool
_sbPar_seq :: !Bool,
        Statement -> [AttrStmt]
_sbStmt :: ![AttrStmt]
      }
  | SSysTaskEnable
      { Statement -> ByteString
_ssteIdent :: !ByteString,
        Statement -> [Maybe Expr]
_ssteArgs :: ![Maybe Expr]
      }
  | STaskEnable
      { Statement -> HierIdent
_steIdent :: !HierIdent,
        Statement -> [Expr]
_steArgs :: ![Expr]
      }
  | SWait
      { Statement -> Expr
_swExpr :: !Expr,
        Statement -> MybStmt
_swStmt :: !MybStmt
      }
  deriving (Int -> Statement -> ShowS
[Statement] -> ShowS
Statement -> String
(Int -> Statement -> ShowS)
-> (Statement -> String)
-> ([Statement] -> ShowS)
-> Show Statement
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Statement -> ShowS
showsPrec :: Int -> Statement -> ShowS
$cshow :: Statement -> String
show :: Statement -> String
$cshowList :: [Statement] -> ShowS
showList :: [Statement] -> ShowS
Show, Statement -> Statement -> Bool
(Statement -> Statement -> Bool)
-> (Statement -> Statement -> Bool) -> Eq Statement
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Statement -> Statement -> Bool
== :: Statement -> Statement -> Bool
$c/= :: Statement -> Statement -> Bool
/= :: Statement -> Statement -> Bool
Eq, Typeable Statement
Typeable Statement =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Statement -> c Statement)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Statement)
-> (Statement -> Constr)
-> (Statement -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Statement))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Statement))
-> ((forall b. Data b => b -> b) -> Statement -> Statement)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Statement -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Statement -> r)
-> (forall u. (forall d. Data d => d -> u) -> Statement -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Statement -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Statement -> m Statement)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Statement -> m Statement)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Statement -> m Statement)
-> Data Statement
Statement -> Constr
Statement -> DataType
(forall b. Data b => b -> b) -> Statement -> Statement
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 -> u
forall u. (forall d. Data d => d -> u) -> Statement -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Statement -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Statement -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Statement -> m Statement
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Statement -> m Statement
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Statement
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Statement -> c Statement
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Statement)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Statement)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Statement -> c Statement
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Statement -> c Statement
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Statement
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Statement
$ctoConstr :: Statement -> Constr
toConstr :: Statement -> Constr
$cdataTypeOf :: Statement -> DataType
dataTypeOf :: Statement -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Statement)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Statement)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Statement)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Statement)
$cgmapT :: (forall b. Data b => b -> b) -> Statement -> Statement
gmapT :: (forall b. Data b => b -> b) -> Statement -> Statement
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Statement -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Statement -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Statement -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Statement -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Statement -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Statement -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Statement -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Statement -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Statement -> m Statement
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Statement -> m Statement
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Statement -> m Statement
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Statement -> m Statement
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Statement -> m Statement
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Statement -> m Statement
Data, (forall x. Statement -> Rep Statement x)
-> (forall x. Rep Statement x -> Statement) -> Generic Statement
forall x. Rep Statement x -> Statement
forall x. Statement -> Rep Statement x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Statement -> Rep Statement x
from :: forall x. Statement -> Rep Statement x
$cto :: forall x. Rep Statement x -> Statement
to :: forall x. Rep Statement x -> Statement
Generic)

instance Plated Statement where
  plate :: Traversal' Statement Statement
plate = (Statement -> f Statement) -> Statement -> f Statement
forall a. Data a => Traversal' a a
Traversal' Statement Statement
uniplate

type AttrStmt = Attributed Statement

type MybStmt = Attributed (Maybe Statement)

-- | N-input logic gate types
data NInputType = NITAnd | NITOr | NITXor
  deriving (NInputType -> NInputType -> Bool
(NInputType -> NInputType -> Bool)
-> (NInputType -> NInputType -> Bool) -> Eq NInputType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: NInputType -> NInputType -> Bool
== :: NInputType -> NInputType -> Bool
$c/= :: NInputType -> NInputType -> Bool
/= :: NInputType -> NInputType -> Bool
Eq, NInputType
NInputType -> NInputType -> Bounded NInputType
forall a. a -> a -> Bounded a
$cminBound :: NInputType
minBound :: NInputType
$cmaxBound :: NInputType
maxBound :: NInputType
Bounded, Int -> NInputType
NInputType -> Int
NInputType -> [NInputType]
NInputType -> NInputType
NInputType -> NInputType -> [NInputType]
NInputType -> NInputType -> NInputType -> [NInputType]
(NInputType -> NInputType)
-> (NInputType -> NInputType)
-> (Int -> NInputType)
-> (NInputType -> Int)
-> (NInputType -> [NInputType])
-> (NInputType -> NInputType -> [NInputType])
-> (NInputType -> NInputType -> [NInputType])
-> (NInputType -> NInputType -> NInputType -> [NInputType])
-> Enum NInputType
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: NInputType -> NInputType
succ :: NInputType -> NInputType
$cpred :: NInputType -> NInputType
pred :: NInputType -> NInputType
$ctoEnum :: Int -> NInputType
toEnum :: Int -> NInputType
$cfromEnum :: NInputType -> Int
fromEnum :: NInputType -> Int
$cenumFrom :: NInputType -> [NInputType]
enumFrom :: NInputType -> [NInputType]
$cenumFromThen :: NInputType -> NInputType -> [NInputType]
enumFromThen :: NInputType -> NInputType -> [NInputType]
$cenumFromTo :: NInputType -> NInputType -> [NInputType]
enumFromTo :: NInputType -> NInputType -> [NInputType]
$cenumFromThenTo :: NInputType -> NInputType -> NInputType -> [NInputType]
enumFromThenTo :: NInputType -> NInputType -> NInputType -> [NInputType]
Enum, Typeable NInputType
Typeable NInputType =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> NInputType -> c NInputType)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c NInputType)
-> (NInputType -> Constr)
-> (NInputType -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c NInputType))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c NInputType))
-> ((forall b. Data b => b -> b) -> NInputType -> NInputType)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> NInputType -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> NInputType -> r)
-> (forall u. (forall d. Data d => d -> u) -> NInputType -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> NInputType -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> NInputType -> m NInputType)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> NInputType -> m NInputType)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> NInputType -> m NInputType)
-> Data NInputType
NInputType -> Constr
NInputType -> DataType
(forall b. Data b => b -> b) -> NInputType -> NInputType
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) -> NInputType -> u
forall u. (forall d. Data d => d -> u) -> NInputType -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NInputType -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NInputType -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> NInputType -> m NInputType
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NInputType -> m NInputType
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c NInputType
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NInputType -> c NInputType
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c NInputType)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NInputType)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NInputType -> c NInputType
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NInputType -> c NInputType
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c NInputType
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c NInputType
$ctoConstr :: NInputType -> Constr
toConstr :: NInputType -> Constr
$cdataTypeOf :: NInputType -> DataType
dataTypeOf :: NInputType -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c NInputType)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c NInputType)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NInputType)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NInputType)
$cgmapT :: (forall b. Data b => b -> b) -> NInputType -> NInputType
gmapT :: (forall b. Data b => b -> b) -> NInputType -> NInputType
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NInputType -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NInputType -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NInputType -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NInputType -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> NInputType -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> NInputType -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> NInputType -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> NInputType -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> NInputType -> m NInputType
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> NInputType -> m NInputType
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NInputType -> m NInputType
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NInputType -> m NInputType
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NInputType -> m NInputType
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NInputType -> m NInputType
Data, (forall x. NInputType -> Rep NInputType x)
-> (forall x. Rep NInputType x -> NInputType) -> Generic NInputType
forall x. Rep NInputType x -> NInputType
forall x. NInputType -> Rep NInputType x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. NInputType -> Rep NInputType x
from :: forall x. NInputType -> Rep NInputType x
$cto :: forall x. Rep NInputType x -> NInputType
to :: forall x. Rep NInputType x -> NInputType
Generic)

instance Show NInputType where
  show :: NInputType -> String
show NInputType
x = case NInputType
x of NInputType
NITAnd -> String
"and"; NInputType
NITOr -> String
"or"; NInputType
NITXor -> String
"xor"

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

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

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

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

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

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

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

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

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

-- | Edge descriptor, a 6 Bool array (01, 0x, 10, 1x, x0, x1)
type EdgeDesc = V.Vector Bool

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

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

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

-- | Setuphold and Recrem additionnal arguments
data STCAddArgs = STCAddArgs
  { STCAddArgs -> Expr
_stcaaTimChkLim :: !Expr,
    STCAddArgs -> Maybe MinTypMax
_stcaaStampCond :: !(Maybe MinTypMax),
    STCAddArgs -> Maybe MinTypMax
_stcaaChkTimCond :: !(Maybe MinTypMax),
    STCAddArgs -> Maybe (Identified (Maybe CMinTypMax))
_stcaaDelayedRef :: !(Maybe (Identified (Maybe CMinTypMax))),
    STCAddArgs -> Maybe (Identified (Maybe CMinTypMax))
_stcaaDelayedData :: !(Maybe (Identified (Maybe CMinTypMax)))
  }
  deriving (Int -> STCAddArgs -> ShowS
[STCAddArgs] -> ShowS
STCAddArgs -> String
(Int -> STCAddArgs -> ShowS)
-> (STCAddArgs -> String)
-> ([STCAddArgs] -> ShowS)
-> Show STCAddArgs
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> STCAddArgs -> ShowS
showsPrec :: Int -> STCAddArgs -> ShowS
$cshow :: STCAddArgs -> String
show :: STCAddArgs -> String
$cshowList :: [STCAddArgs] -> ShowS
showList :: [STCAddArgs] -> ShowS
Show, STCAddArgs -> STCAddArgs -> Bool
(STCAddArgs -> STCAddArgs -> Bool)
-> (STCAddArgs -> STCAddArgs -> Bool) -> Eq STCAddArgs
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: STCAddArgs -> STCAddArgs -> Bool
== :: STCAddArgs -> STCAddArgs -> Bool
$c/= :: STCAddArgs -> STCAddArgs -> Bool
/= :: STCAddArgs -> STCAddArgs -> Bool
Eq, Typeable STCAddArgs
Typeable STCAddArgs =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> STCAddArgs -> c STCAddArgs)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c STCAddArgs)
-> (STCAddArgs -> Constr)
-> (STCAddArgs -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c STCAddArgs))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c STCAddArgs))
-> ((forall b. Data b => b -> b) -> STCAddArgs -> STCAddArgs)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> STCAddArgs -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> STCAddArgs -> r)
-> (forall u. (forall d. Data d => d -> u) -> STCAddArgs -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> STCAddArgs -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> STCAddArgs -> m STCAddArgs)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> STCAddArgs -> m STCAddArgs)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> STCAddArgs -> m STCAddArgs)
-> Data STCAddArgs
STCAddArgs -> Constr
STCAddArgs -> DataType
(forall b. Data b => b -> b) -> STCAddArgs -> STCAddArgs
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) -> STCAddArgs -> u
forall u. (forall d. Data d => d -> u) -> STCAddArgs -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> STCAddArgs -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> STCAddArgs -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> STCAddArgs -> m STCAddArgs
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> STCAddArgs -> m STCAddArgs
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c STCAddArgs
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> STCAddArgs -> c STCAddArgs
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c STCAddArgs)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c STCAddArgs)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> STCAddArgs -> c STCAddArgs
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> STCAddArgs -> c STCAddArgs
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c STCAddArgs
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c STCAddArgs
$ctoConstr :: STCAddArgs -> Constr
toConstr :: STCAddArgs -> Constr
$cdataTypeOf :: STCAddArgs -> DataType
dataTypeOf :: STCAddArgs -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c STCAddArgs)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c STCAddArgs)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c STCAddArgs)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c STCAddArgs)
$cgmapT :: (forall b. Data b => b -> b) -> STCAddArgs -> STCAddArgs
gmapT :: (forall b. Data b => b -> b) -> STCAddArgs -> STCAddArgs
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> STCAddArgs -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> STCAddArgs -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> STCAddArgs -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> STCAddArgs -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> STCAddArgs -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> STCAddArgs -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> STCAddArgs -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> STCAddArgs -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> STCAddArgs -> m STCAddArgs
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> STCAddArgs -> m STCAddArgs
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> STCAddArgs -> m STCAddArgs
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> STCAddArgs -> m STCAddArgs
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> STCAddArgs -> m STCAddArgs
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> STCAddArgs -> m STCAddArgs
Data, (forall x. STCAddArgs -> Rep STCAddArgs x)
-> (forall x. Rep STCAddArgs x -> STCAddArgs) -> Generic STCAddArgs
forall x. Rep STCAddArgs x -> STCAddArgs
forall x. STCAddArgs -> Rep STCAddArgs x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. STCAddArgs -> Rep STCAddArgs x
from :: forall x. STCAddArgs -> Rep STCAddArgs x
$cto :: forall x. Rep STCAddArgs x -> STCAddArgs
to :: forall x. Rep STCAddArgs x -> STCAddArgs
Generic)

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

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

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

-- | Specify block item
-- | f is either Identity or NonEmpty
-- | it is used to abstract between several specify items in a block and a single comma separated one
data SpecifyItem f
  = SISpecParam
    { forall (f :: * -> *). SpecifyItem f -> Maybe Range2
_sipcRange :: !(Maybe Range2),
      forall (f :: * -> *). SpecifyItem f -> f SpecParamDecl
_sipcDecl :: !(f SpecParamDecl)
    }
  | SIPulsestyleOnevent !(f SpecTerm)
  | SIPulsestyleOndetect !(f SpecTerm)
  | SIShowcancelled !(f SpecTerm)
  | SINoshowcancelled !(f SpecTerm)
  | SIPathDeclaration
      { forall (f :: * -> *). SpecifyItem f -> ModulePathCondition
_sipdCond :: !ModulePathCondition,
        forall (f :: * -> *). SpecifyItem f -> SpecPath
_sipdConn :: !SpecPath,
        forall (f :: * -> *). SpecifyItem f -> Maybe Bool
_sipdPolarity :: !(Maybe Bool),
        forall (f :: * -> *). SpecifyItem f -> Maybe (Expr, Maybe Bool)
_sipdEDS :: !(Maybe (Expr, Maybe Bool)),
        forall (f :: * -> *). SpecifyItem f -> PathDelayValue
_sipdValue :: !PathDelayValue
      }
  | SISetup !STCArgs
  | SIHold !STCArgs
  | SISetupHold
      { forall (f :: * -> *). SpecifyItem f -> STCArgs
_sishArgs :: !STCArgs,
        forall (f :: * -> *). SpecifyItem f -> STCAddArgs
_sishAddArgs :: !STCAddArgs
      }
  | SIRecovery !STCArgs
  | SIRemoval !STCArgs
  | SIRecrem
      { forall (f :: * -> *). SpecifyItem f -> STCArgs
_sirArgs :: !STCArgs,
        forall (f :: * -> *). SpecifyItem f -> STCAddArgs
_sirAddArgs :: !STCAddArgs
      }
  | SISkew !STCArgs
  | SITimeSkew
      { forall (f :: * -> *). SpecifyItem f -> STCArgs
_sitsArgs :: !STCArgs,
        forall (f :: * -> *). SpecifyItem f -> Maybe CExpr
_sitsEvBased :: !(Maybe CExpr),
        forall (f :: * -> *). SpecifyItem f -> Maybe CExpr
_sitsRemActive :: !(Maybe CExpr)
      }
  | SIFullSkew
      { forall (f :: * -> *). SpecifyItem f -> STCArgs
_sifsArgs :: !STCArgs,
        forall (f :: * -> *). SpecifyItem f -> Expr
_sifsTimChkLim :: !Expr,
        forall (f :: * -> *). SpecifyItem f -> Maybe CExpr
_sifsEvBased :: !(Maybe CExpr),
        forall (f :: * -> *). SpecifyItem f -> Maybe CExpr
_sifsRemActive :: !(Maybe CExpr)
      }
  | SIPeriod
      { forall (f :: * -> *). SpecifyItem f -> ControlledTimingCheckEvent
_sipCRefEvent :: !ControlledTimingCheckEvent,
        forall (f :: * -> *). SpecifyItem f -> Expr
_sipTimCtlLim :: !Expr,
        forall (f :: * -> *). SpecifyItem f -> Maybe Identifier
_sipNotif :: !(Maybe Identifier)
      }
  | SIWidth
      { forall (f :: * -> *). SpecifyItem f -> ControlledTimingCheckEvent
_siwRefEvent :: !ControlledTimingCheckEvent,
        forall (f :: * -> *). SpecifyItem f -> Expr
_siwTimCtlLim :: !Expr,
        forall (f :: * -> *). SpecifyItem f -> Maybe CExpr
_siwThresh :: !(Maybe CExpr),
        forall (f :: * -> *). SpecifyItem f -> Maybe Identifier
_siwNotif :: !(Maybe Identifier)
      }
  | SINoChange
      { forall (f :: * -> *). SpecifyItem f -> TimingCheckEvent
_sincRefEvent :: !TimingCheckEvent,
        forall (f :: * -> *). SpecifyItem f -> TimingCheckEvent
_sincDataEvent :: !TimingCheckEvent,
        forall (f :: * -> *). SpecifyItem f -> MinTypMax
_sincStartEdgeOff :: !MinTypMax,
        forall (f :: * -> *). SpecifyItem f -> MinTypMax
_sincEndEdgeOff :: !MinTypMax,
        forall (f :: * -> *). SpecifyItem f -> Maybe Identifier
_sincNotif :: !(Maybe Identifier)
      }

deriving instance (Show1 f, forall a. Show a => Show (f a)) => Show (SpecifyItem f)
deriving instance (Eq1 f, forall a. Eq a => Eq (f a)) => Eq (SpecifyItem f)
deriving instance (Typeable f, forall a. Data a => Data (f a)) => Data (SpecifyItem f)
deriving instance (forall a. Generic a => Generic (f a)) => Generic (SpecifyItem f)

type SpecifySingleItem = SpecifyItem NonEmpty
type SpecifyBlockedItem = SpecifyItem Identity

-- | Specparam declaration
data SpecParamDecl
  = SPDAssign
    { SpecParamDecl -> Identifier
_spdaIdent :: !Identifier,
      SpecParamDecl -> CMinTypMax
_spdaValue :: !CMinTypMax
    }
  | SPDPathPulse -- Not completely accurate input/output as it is ambiguous
      { SpecParamDecl -> Maybe (SpecTerm, SpecTerm)
_spdpInOut :: !(Maybe (SpecTerm, SpecTerm)),
        SpecParamDecl -> CMinTypMax
_spdpReject :: !CMinTypMax,
        SpecParamDecl -> CMinTypMax
_spdpError :: !CMinTypMax
      }
  deriving (Int -> SpecParamDecl -> ShowS
[SpecParamDecl] -> ShowS
SpecParamDecl -> String
(Int -> SpecParamDecl -> ShowS)
-> (SpecParamDecl -> String)
-> ([SpecParamDecl] -> ShowS)
-> Show SpecParamDecl
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SpecParamDecl -> ShowS
showsPrec :: Int -> SpecParamDecl -> ShowS
$cshow :: SpecParamDecl -> String
show :: SpecParamDecl -> String
$cshowList :: [SpecParamDecl] -> ShowS
showList :: [SpecParamDecl] -> ShowS
Show, SpecParamDecl -> SpecParamDecl -> Bool
(SpecParamDecl -> SpecParamDecl -> Bool)
-> (SpecParamDecl -> SpecParamDecl -> Bool) -> Eq SpecParamDecl
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SpecParamDecl -> SpecParamDecl -> Bool
== :: SpecParamDecl -> SpecParamDecl -> Bool
$c/= :: SpecParamDecl -> SpecParamDecl -> Bool
/= :: SpecParamDecl -> SpecParamDecl -> Bool
Eq, Typeable SpecParamDecl
Typeable SpecParamDecl =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> SpecParamDecl -> c SpecParamDecl)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c SpecParamDecl)
-> (SpecParamDecl -> Constr)
-> (SpecParamDecl -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c SpecParamDecl))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c SpecParamDecl))
-> ((forall b. Data b => b -> b) -> SpecParamDecl -> SpecParamDecl)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> SpecParamDecl -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> SpecParamDecl -> r)
-> (forall u. (forall d. Data d => d -> u) -> SpecParamDecl -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> SpecParamDecl -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> SpecParamDecl -> m SpecParamDecl)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> SpecParamDecl -> m SpecParamDecl)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> SpecParamDecl -> m SpecParamDecl)
-> Data SpecParamDecl
SpecParamDecl -> Constr
SpecParamDecl -> DataType
(forall b. Data b => b -> b) -> SpecParamDecl -> SpecParamDecl
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) -> SpecParamDecl -> u
forall u. (forall d. Data d => d -> u) -> SpecParamDecl -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SpecParamDecl -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SpecParamDecl -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SpecParamDecl -> m SpecParamDecl
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SpecParamDecl -> m SpecParamDecl
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SpecParamDecl
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SpecParamDecl -> c SpecParamDecl
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SpecParamDecl)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SpecParamDecl)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SpecParamDecl -> c SpecParamDecl
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SpecParamDecl -> c SpecParamDecl
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SpecParamDecl
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SpecParamDecl
$ctoConstr :: SpecParamDecl -> Constr
toConstr :: SpecParamDecl -> Constr
$cdataTypeOf :: SpecParamDecl -> DataType
dataTypeOf :: SpecParamDecl -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SpecParamDecl)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SpecParamDecl)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SpecParamDecl)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SpecParamDecl)
$cgmapT :: (forall b. Data b => b -> b) -> SpecParamDecl -> SpecParamDecl
gmapT :: (forall b. Data b => b -> b) -> SpecParamDecl -> SpecParamDecl
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SpecParamDecl -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SpecParamDecl -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SpecParamDecl -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SpecParamDecl -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> SpecParamDecl -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> SpecParamDecl -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> SpecParamDecl -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> SpecParamDecl -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SpecParamDecl -> m SpecParamDecl
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SpecParamDecl -> m SpecParamDecl
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SpecParamDecl -> m SpecParamDecl
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SpecParamDecl -> m SpecParamDecl
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SpecParamDecl -> m SpecParamDecl
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SpecParamDecl -> m SpecParamDecl
Data, (forall x. SpecParamDecl -> Rep SpecParamDecl x)
-> (forall x. Rep SpecParamDecl x -> SpecParamDecl)
-> Generic SpecParamDecl
forall x. Rep SpecParamDecl x -> SpecParamDecl
forall x. SpecParamDecl -> Rep SpecParamDecl x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. SpecParamDecl -> Rep SpecParamDecl x
from :: forall x. SpecParamDecl -> Rep SpecParamDecl x
$cto :: forall x. Rep SpecParamDecl x -> SpecParamDecl
to :: forall x. Rep SpecParamDecl x -> SpecParamDecl
Generic)

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

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

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

-- | Block declaration
-- | t is used to abstract between block_decl and modgen_decl
-- | f is used to abstract between the separated and grouped modgen_item
data BlockDecl f t
  = BDReg
    { forall (f :: * -> *) t. BlockDecl f t -> SignRange
_bdrgSR :: !SignRange,
      forall (f :: * -> *) t. BlockDecl f t -> f t
_bdrgData :: !(f t)
    }
  | BDInt !(f t)
  | BDReal !(f t)
  | BDTime !(f t)
  | BDRealTime !(f t)
  | BDEvent !(f [Range2])
  | BDLocalParam
    { forall (f :: * -> *) t. BlockDecl f t -> ComType ()
_bdlpType :: !(ComType ()),
      forall (f :: * -> *) t. BlockDecl f t -> f CMinTypMax
_bdlpValue :: !(f CMinTypMax)
    }

deriving instance (Show t, forall a. Show a => Show (f a)) => Show (BlockDecl f t)
deriving instance (Eq t, forall a. Eq a => Eq (f a)) => Eq (BlockDecl f t)
deriving instance (Typeable t, Data t, Typeable f, forall a. Data a => Data (f a)) => Data (BlockDecl f t)
deriving instance (Generic t, forall a. Generic a => Generic (f a)) => Generic (BlockDecl f t)

-- | Block item declaration (for statement blocks [begin/fork], tasks, and functions)
data StdBlockDecl
  = SBDBlockDecl !(BlockDecl Identity [Range2])
  | SBDParameter !Parameter
  deriving (Int -> StdBlockDecl -> ShowS
[StdBlockDecl] -> ShowS
StdBlockDecl -> String
(Int -> StdBlockDecl -> ShowS)
-> (StdBlockDecl -> String)
-> ([StdBlockDecl] -> ShowS)
-> Show StdBlockDecl
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> StdBlockDecl -> ShowS
showsPrec :: Int -> StdBlockDecl -> ShowS
$cshow :: StdBlockDecl -> String
show :: StdBlockDecl -> String
$cshowList :: [StdBlockDecl] -> ShowS
showList :: [StdBlockDecl] -> ShowS
Show, StdBlockDecl -> StdBlockDecl -> Bool
(StdBlockDecl -> StdBlockDecl -> Bool)
-> (StdBlockDecl -> StdBlockDecl -> Bool) -> Eq StdBlockDecl
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: StdBlockDecl -> StdBlockDecl -> Bool
== :: StdBlockDecl -> StdBlockDecl -> Bool
$c/= :: StdBlockDecl -> StdBlockDecl -> Bool
/= :: StdBlockDecl -> StdBlockDecl -> Bool
Eq, Typeable StdBlockDecl
Typeable StdBlockDecl =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> StdBlockDecl -> c StdBlockDecl)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c StdBlockDecl)
-> (StdBlockDecl -> Constr)
-> (StdBlockDecl -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c StdBlockDecl))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c StdBlockDecl))
-> ((forall b. Data b => b -> b) -> StdBlockDecl -> StdBlockDecl)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> StdBlockDecl -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> StdBlockDecl -> r)
-> (forall u. (forall d. Data d => d -> u) -> StdBlockDecl -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> StdBlockDecl -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> StdBlockDecl -> m StdBlockDecl)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> StdBlockDecl -> m StdBlockDecl)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> StdBlockDecl -> m StdBlockDecl)
-> Data StdBlockDecl
StdBlockDecl -> Constr
StdBlockDecl -> DataType
(forall b. Data b => b -> b) -> StdBlockDecl -> StdBlockDecl
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) -> StdBlockDecl -> u
forall u. (forall d. Data d => d -> u) -> StdBlockDecl -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> StdBlockDecl -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> StdBlockDecl -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> StdBlockDecl -> m StdBlockDecl
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> StdBlockDecl -> m StdBlockDecl
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c StdBlockDecl
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> StdBlockDecl -> c StdBlockDecl
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c StdBlockDecl)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c StdBlockDecl)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> StdBlockDecl -> c StdBlockDecl
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> StdBlockDecl -> c StdBlockDecl
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c StdBlockDecl
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c StdBlockDecl
$ctoConstr :: StdBlockDecl -> Constr
toConstr :: StdBlockDecl -> Constr
$cdataTypeOf :: StdBlockDecl -> DataType
dataTypeOf :: StdBlockDecl -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c StdBlockDecl)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c StdBlockDecl)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c StdBlockDecl)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c StdBlockDecl)
$cgmapT :: (forall b. Data b => b -> b) -> StdBlockDecl -> StdBlockDecl
gmapT :: (forall b. Data b => b -> b) -> StdBlockDecl -> StdBlockDecl
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> StdBlockDecl -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> StdBlockDecl -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> StdBlockDecl -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> StdBlockDecl -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> StdBlockDecl -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> StdBlockDecl -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> StdBlockDecl -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> StdBlockDecl -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> StdBlockDecl -> m StdBlockDecl
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> StdBlockDecl -> m StdBlockDecl
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> StdBlockDecl -> m StdBlockDecl
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> StdBlockDecl -> m StdBlockDecl
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> StdBlockDecl -> m StdBlockDecl
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> StdBlockDecl -> m StdBlockDecl
Data, (forall x. StdBlockDecl -> Rep StdBlockDecl x)
-> (forall x. Rep StdBlockDecl x -> StdBlockDecl)
-> Generic StdBlockDecl
forall x. Rep StdBlockDecl x -> StdBlockDecl
forall x. StdBlockDecl -> Rep StdBlockDecl x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. StdBlockDecl -> Rep StdBlockDecl x
from :: forall x. StdBlockDecl -> Rep StdBlockDecl x
$cto :: forall x. Rep StdBlockDecl x -> StdBlockDecl
to :: forall x. Rep StdBlockDecl x -> StdBlockDecl
Generic)

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

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

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

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

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

-- | Module or Generate conditional item because scoping rules are special
data ModGenCondItem
  = MGCIIf
      { ModGenCondItem -> CExpr
_mgiiExpr :: !CExpr,
        ModGenCondItem -> GenerateCondBlock
_mgiiTrue :: !GenerateCondBlock,
        ModGenCondItem -> GenerateCondBlock
_mgiiFalse :: !GenerateCondBlock
      }
  | MGCICase
      { ModGenCondItem -> CExpr
_mgicExpr :: !CExpr,
        ModGenCondItem -> [GenCaseItem]
_mgicBranch :: ![GenCaseItem],
        ModGenCondItem -> GenerateCondBlock
_mgicDefault :: !GenerateCondBlock
      }
  deriving (Int -> ModGenCondItem -> ShowS
[ModGenCondItem] -> ShowS
ModGenCondItem -> String
(Int -> ModGenCondItem -> ShowS)
-> (ModGenCondItem -> String)
-> ([ModGenCondItem] -> ShowS)
-> Show ModGenCondItem
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ModGenCondItem -> ShowS
showsPrec :: Int -> ModGenCondItem -> ShowS
$cshow :: ModGenCondItem -> String
show :: ModGenCondItem -> String
$cshowList :: [ModGenCondItem] -> ShowS
showList :: [ModGenCondItem] -> ShowS
Show, ModGenCondItem -> ModGenCondItem -> Bool
(ModGenCondItem -> ModGenCondItem -> Bool)
-> (ModGenCondItem -> ModGenCondItem -> Bool) -> Eq ModGenCondItem
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ModGenCondItem -> ModGenCondItem -> Bool
== :: ModGenCondItem -> ModGenCondItem -> Bool
$c/= :: ModGenCondItem -> ModGenCondItem -> Bool
/= :: ModGenCondItem -> ModGenCondItem -> Bool
Eq, Typeable ModGenCondItem
Typeable ModGenCondItem =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> ModGenCondItem -> c ModGenCondItem)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ModGenCondItem)
-> (ModGenCondItem -> Constr)
-> (ModGenCondItem -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ModGenCondItem))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c ModGenCondItem))
-> ((forall b. Data b => b -> b)
    -> ModGenCondItem -> ModGenCondItem)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ModGenCondItem -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ModGenCondItem -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> ModGenCondItem -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> ModGenCondItem -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> ModGenCondItem -> m ModGenCondItem)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> ModGenCondItem -> m ModGenCondItem)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> ModGenCondItem -> m ModGenCondItem)
-> Data ModGenCondItem
ModGenCondItem -> Constr
ModGenCondItem -> DataType
(forall b. Data b => b -> b) -> ModGenCondItem -> ModGenCondItem
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) -> ModGenCondItem -> u
forall u. (forall d. Data d => d -> u) -> ModGenCondItem -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ModGenCondItem -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ModGenCondItem -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> ModGenCondItem -> m ModGenCondItem
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ModGenCondItem -> m ModGenCondItem
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ModGenCondItem
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ModGenCondItem -> c ModGenCondItem
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ModGenCondItem)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ModGenCondItem)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ModGenCondItem -> c ModGenCondItem
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ModGenCondItem -> c ModGenCondItem
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ModGenCondItem
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ModGenCondItem
$ctoConstr :: ModGenCondItem -> Constr
toConstr :: ModGenCondItem -> Constr
$cdataTypeOf :: ModGenCondItem -> DataType
dataTypeOf :: ModGenCondItem -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ModGenCondItem)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ModGenCondItem)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ModGenCondItem)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ModGenCondItem)
$cgmapT :: (forall b. Data b => b -> b) -> ModGenCondItem -> ModGenCondItem
gmapT :: (forall b. Data b => b -> b) -> ModGenCondItem -> ModGenCondItem
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ModGenCondItem -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ModGenCondItem -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ModGenCondItem -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ModGenCondItem -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> ModGenCondItem -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> ModGenCondItem -> [u]
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> ModGenCondItem -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> ModGenCondItem -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> ModGenCondItem -> m ModGenCondItem
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> ModGenCondItem -> m ModGenCondItem
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ModGenCondItem -> m ModGenCondItem
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ModGenCondItem -> m ModGenCondItem
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ModGenCondItem -> m ModGenCondItem
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ModGenCondItem -> m ModGenCondItem
Data, (forall x. ModGenCondItem -> Rep ModGenCondItem x)
-> (forall x. Rep ModGenCondItem x -> ModGenCondItem)
-> Generic ModGenCondItem
forall x. Rep ModGenCondItem x -> ModGenCondItem
forall x. ModGenCondItem -> Rep ModGenCondItem x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. ModGenCondItem -> Rep ModGenCondItem x
from :: forall x. ModGenCondItem -> Rep ModGenCondItem x
$cto :: forall x. Rep ModGenCondItem x -> ModGenCondItem
to :: forall x. Rep ModGenCondItem x -> ModGenCondItem
Generic)

-- | Generate Block or Conditional Item or nothing because scoping rules are special
data GenerateCondBlock
  = GCBEmpty
  | GCBBlock !GenerateBlock
  | GCBConditional !(Attributed ModGenCondItem)
  deriving (Int -> GenerateCondBlock -> ShowS
[GenerateCondBlock] -> ShowS
GenerateCondBlock -> String
(Int -> GenerateCondBlock -> ShowS)
-> (GenerateCondBlock -> String)
-> ([GenerateCondBlock] -> ShowS)
-> Show GenerateCondBlock
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> GenerateCondBlock -> ShowS
showsPrec :: Int -> GenerateCondBlock -> ShowS
$cshow :: GenerateCondBlock -> String
show :: GenerateCondBlock -> String
$cshowList :: [GenerateCondBlock] -> ShowS
showList :: [GenerateCondBlock] -> ShowS
Show, GenerateCondBlock -> GenerateCondBlock -> Bool
(GenerateCondBlock -> GenerateCondBlock -> Bool)
-> (GenerateCondBlock -> GenerateCondBlock -> Bool)
-> Eq GenerateCondBlock
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: GenerateCondBlock -> GenerateCondBlock -> Bool
== :: GenerateCondBlock -> GenerateCondBlock -> Bool
$c/= :: GenerateCondBlock -> GenerateCondBlock -> Bool
/= :: GenerateCondBlock -> GenerateCondBlock -> Bool
Eq, Typeable GenerateCondBlock
Typeable GenerateCondBlock =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g)
 -> GenerateCondBlock
 -> c GenerateCondBlock)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c GenerateCondBlock)
-> (GenerateCondBlock -> Constr)
-> (GenerateCondBlock -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c GenerateCondBlock))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c GenerateCondBlock))
-> ((forall b. Data b => b -> b)
    -> GenerateCondBlock -> GenerateCondBlock)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> GenerateCondBlock -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> GenerateCondBlock -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> GenerateCondBlock -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> GenerateCondBlock -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> GenerateCondBlock -> m GenerateCondBlock)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> GenerateCondBlock -> m GenerateCondBlock)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> GenerateCondBlock -> m GenerateCondBlock)
-> Data GenerateCondBlock
GenerateCondBlock -> Constr
GenerateCondBlock -> DataType
(forall b. Data b => b -> b)
-> GenerateCondBlock -> GenerateCondBlock
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) -> GenerateCondBlock -> u
forall u. (forall d. Data d => d -> u) -> GenerateCondBlock -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> GenerateCondBlock -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> GenerateCondBlock -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> GenerateCondBlock -> m GenerateCondBlock
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> GenerateCondBlock -> m GenerateCondBlock
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c GenerateCondBlock
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> GenerateCondBlock -> c GenerateCondBlock
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c GenerateCondBlock)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c GenerateCondBlock)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> GenerateCondBlock -> c GenerateCondBlock
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> GenerateCondBlock -> c GenerateCondBlock
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c GenerateCondBlock
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c GenerateCondBlock
$ctoConstr :: GenerateCondBlock -> Constr
toConstr :: GenerateCondBlock -> Constr
$cdataTypeOf :: GenerateCondBlock -> DataType
dataTypeOf :: GenerateCondBlock -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c GenerateCondBlock)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c GenerateCondBlock)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c GenerateCondBlock)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c GenerateCondBlock)
$cgmapT :: (forall b. Data b => b -> b)
-> GenerateCondBlock -> GenerateCondBlock
gmapT :: (forall b. Data b => b -> b)
-> GenerateCondBlock -> GenerateCondBlock
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> GenerateCondBlock -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> GenerateCondBlock -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> GenerateCondBlock -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> GenerateCondBlock -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> GenerateCondBlock -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> GenerateCondBlock -> [u]
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> GenerateCondBlock -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> GenerateCondBlock -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> GenerateCondBlock -> m GenerateCondBlock
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> GenerateCondBlock -> m GenerateCondBlock
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> GenerateCondBlock -> m GenerateCondBlock
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> GenerateCondBlock -> m GenerateCondBlock
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> GenerateCondBlock -> m GenerateCondBlock
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> GenerateCondBlock -> m GenerateCondBlock
Data, (forall x. GenerateCondBlock -> Rep GenerateCondBlock x)
-> (forall x. Rep GenerateCondBlock x -> GenerateCondBlock)
-> Generic GenerateCondBlock
forall x. Rep GenerateCondBlock x -> GenerateCondBlock
forall x. GenerateCondBlock -> Rep GenerateCondBlock x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. GenerateCondBlock -> Rep GenerateCondBlock x
from :: forall x. GenerateCondBlock -> Rep GenerateCondBlock x
$cto :: forall x. Rep GenerateCondBlock x -> GenerateCondBlock
to :: forall x. Rep GenerateCondBlock x -> GenerateCondBlock
Generic)

-- | Module or Generate item
-- | f is either Identity or NonEmpty
-- | it is used to abstract between several modgen items in a block and a single comma separated one
data ModGenItem f
  = MGINetInit
      { forall (f :: * -> *). ModGenItem f -> NetType
_mginiType :: !NetType,
        forall (f :: * -> *). ModGenItem f -> DriveStrength
_mginiDrive :: !DriveStrength,
        forall (f :: * -> *). ModGenItem f -> NetProp
_mginiProp :: !NetProp,
        forall (f :: * -> *). ModGenItem f -> f NetInit
_mginiInit :: !(f NetInit)
      }
  | MGINetDecl
      { forall (f :: * -> *). ModGenItem f -> NetType
_mgindType :: !NetType,
        forall (f :: * -> *). ModGenItem f -> NetProp
_mgindProp :: !NetProp,
        forall (f :: * -> *). ModGenItem f -> f NetDecl
_mgindDecl :: !(f NetDecl)
      }
  | MGITriD
      { forall (f :: * -> *). ModGenItem f -> DriveStrength
_mgitdDrive :: !DriveStrength,
        forall (f :: * -> *). ModGenItem f -> NetProp
_mgitdProp :: !NetProp,
        forall (f :: * -> *). ModGenItem f -> f NetInit
_mgitdInit :: !(f NetInit)
      }
  | MGITriC
      { forall (f :: * -> *). ModGenItem f -> ChargeStrength
_mgitcCharge :: !ChargeStrength,
        forall (f :: * -> *). ModGenItem f -> NetProp
_mgitcProp :: !NetProp,
        forall (f :: * -> *). ModGenItem f -> f NetDecl
_mgitcDecl :: !(f NetDecl)
      }
  | MGIBlockDecl !(BlockDecl (Compose f Identified) (Either [Range2] CExpr))
  | MGIGenVar !(f Identifier)
  | MGITask
      { forall (f :: * -> *). ModGenItem f -> Bool
_mgitAuto :: !Bool,
        forall (f :: * -> *). ModGenItem f -> Identifier
_mgitIdent :: !Identifier,
        forall (f :: * -> *). ModGenItem f -> [AttrIded (TFBlockDecl Dir)]
_mgitDecl :: ![AttrIded (TFBlockDecl Dir)],
        forall (f :: * -> *). ModGenItem f -> MybStmt
_mgitBody :: !MybStmt
      }
  | MGIFunc
      { forall (f :: * -> *). ModGenItem f -> Bool
_mgifAuto :: !Bool,
        forall (f :: * -> *). ModGenItem f -> Maybe (ComType ())
_mgifType :: !(Maybe (ComType ())),
        forall (f :: * -> *). ModGenItem f -> Identifier
_mgifIdent :: !Identifier,
        forall (f :: * -> *). ModGenItem f -> [AttrIded (TFBlockDecl ())]
_mgifDecl :: ![AttrIded (TFBlockDecl ())],
        forall (f :: * -> *). ModGenItem f -> FunctionStatement
_mgifBody :: !FunctionStatement
      }
  | MGIDefParam !(f ParamOver)
  | MGIContAss
      { forall (f :: * -> *). ModGenItem f -> DriveStrength
_mgicaStrength :: !DriveStrength,
        forall (f :: * -> *). ModGenItem f -> Maybe Delay3
_mgicaDelay :: !(Maybe Delay3),
        forall (f :: * -> *). ModGenItem f -> f NetAssign
_mgicaAssign :: !(f NetAssign)
      }
  | MGICMos
      { forall (f :: * -> *). ModGenItem f -> Bool
_mgicmR :: !Bool,
        forall (f :: * -> *). ModGenItem f -> Maybe Delay3
_mgicmDelay :: !(Maybe Delay3),
        forall (f :: * -> *). ModGenItem f -> f GICMos
_mgicmInst :: !(f GICMos)
      }
  | MGIEnable
      { forall (f :: * -> *). ModGenItem f -> Bool
_mgieR :: !Bool,
        forall (f :: * -> *). ModGenItem f -> Bool
_mgie1_0 :: !Bool,
        forall (f :: * -> *). ModGenItem f -> DriveStrength
_mgieStrength :: !DriveStrength,
        forall (f :: * -> *). ModGenItem f -> Maybe Delay3
_mgieDelay :: !(Maybe Delay3),
        forall (f :: * -> *). ModGenItem f -> f GIEnable
_mgieInst :: !(f GIEnable)
      }
  | MGIMos
      { forall (f :: * -> *). ModGenItem f -> Bool
_mgimR :: !Bool,
        forall (f :: * -> *). ModGenItem f -> Bool
_mgimN_P :: !Bool,
        forall (f :: * -> *). ModGenItem f -> Maybe Delay3
_mgimDelay :: !(Maybe Delay3),
        forall (f :: * -> *). ModGenItem f -> f GIMos
_mgimInst :: !(f GIMos)
      }
  | MGINIn
      { forall (f :: * -> *). ModGenItem f -> NInputType
_mgininType :: !NInputType,
        forall (f :: * -> *). ModGenItem f -> Bool
_mgininN :: !Bool,
        forall (f :: * -> *). ModGenItem f -> DriveStrength
_mgininStrength :: !DriveStrength,
        forall (f :: * -> *). ModGenItem f -> Maybe Delay2
_mgininDelay :: !(Maybe Delay2),
        forall (f :: * -> *). ModGenItem f -> f GINIn
_mgininInst :: !(f GINIn)
      }
  | MGINOut
      { forall (f :: * -> *). ModGenItem f -> Bool
_mginoR :: !Bool,
        forall (f :: * -> *). ModGenItem f -> DriveStrength
_mginoStrength :: !DriveStrength,
        forall (f :: * -> *). ModGenItem f -> Maybe Delay2
_mginoDelay :: !(Maybe Delay2),
        forall (f :: * -> *). ModGenItem f -> f GINOut
_mginoInst :: !(f GINOut)
      }
  | MGIPassEn
      { forall (f :: * -> *). ModGenItem f -> Bool
_mgipeR :: !Bool,
        forall (f :: * -> *). ModGenItem f -> Bool
_mgipe1_0 :: !Bool,
        forall (f :: * -> *). ModGenItem f -> Maybe Delay2
_mgipeDelay :: !(Maybe Delay2),
        forall (f :: * -> *). ModGenItem f -> f GIPassEn
_mgipeInst :: !(f GIPassEn)
      }
  | MGIPass
      { forall (f :: * -> *). ModGenItem f -> Bool
_mgipsR :: !Bool,
        forall (f :: * -> *). ModGenItem f -> f GIPass
_mgipsInst :: !(f GIPass)
      }
  | MGIPull
      { forall (f :: * -> *). ModGenItem f -> Bool
_mgiplUp_down :: !Bool,
        forall (f :: * -> *). ModGenItem f -> DriveStrength
_mgiplStrength :: !DriveStrength,
        forall (f :: * -> *). ModGenItem f -> f GIPull
_mgiplInst :: !(f GIPull)
      }
  | MGIUDPInst
      { forall (f :: * -> *). ModGenItem f -> Identifier
_mgiudpiUDP :: !Identifier,
        forall (f :: * -> *). ModGenItem f -> DriveStrength
_mgiudpiStrength :: !DriveStrength,
        forall (f :: * -> *). ModGenItem f -> Maybe Delay2
_mgiudpiDelay :: !(Maybe Delay2),
        forall (f :: * -> *). ModGenItem f -> f UDPInst
_mgiudpiInst :: !(f UDPInst)
      }
  | MGIModInst
      { forall (f :: * -> *). ModGenItem f -> Identifier
_mgimiMod :: !Identifier,
        forall (f :: * -> *). ModGenItem f -> ParamAssign
_mgimiParams :: !ParamAssign,
        forall (f :: * -> *). ModGenItem f -> f ModInst
_mgimiInst :: !(f ModInst)
      }
  | MGIUnknownInst -- Sometimes identifying what is instantiated is impossible
      { forall (f :: * -> *). ModGenItem f -> Identifier
_mgiuiType :: !Identifier,
        forall (f :: * -> *).
ModGenItem f -> Maybe (Either Expr (Expr, Expr))
_mgiuiParam :: !(Maybe (Either Expr (Expr, Expr))),
        forall (f :: * -> *). ModGenItem f -> f UknInst
_mgiuiInst :: !(f UknInst)
      }
  | MGIInitial !AttrStmt
  | MGIAlways !AttrStmt
  | MGILoopGen
      { forall (f :: * -> *). ModGenItem f -> Identifier
_mgilgInitIdent :: !Identifier,
        forall (f :: * -> *). ModGenItem f -> CExpr
_mgilgInitValue :: !CExpr,
        forall (f :: * -> *). ModGenItem f -> CExpr
_mgilgCond :: !CExpr,
        forall (f :: * -> *). ModGenItem f -> Identifier
_mgilgUpdIdent :: !Identifier,
        forall (f :: * -> *). ModGenItem f -> CExpr
_mgilgUpdValue :: !CExpr,
        forall (f :: * -> *). ModGenItem f -> GenerateBlock
_mgilgBody :: !GenerateBlock
      }
  | MGICondItem !ModGenCondItem

deriving instance (Show1 f, forall a. Show a => Show (f a)) => Show (ModGenItem f)
deriving instance (Eq1 f, forall a. Eq a => Eq (f a)) => Eq (ModGenItem f)
deriving instance (Typeable f, forall a. Data a => Data (f a)) => Data (ModGenItem f)
deriving instance (forall a. Generic a => Generic (f a)) => Generic (ModGenItem f)

type ModGenBlockedItem = ModGenItem Identity
type ModGenSingleItem = ModGenItem NonEmpty

instance Plated ModGenBlockedItem where
  plate :: Traversal' ModGenBlockedItem ModGenBlockedItem
plate = (ModGenBlockedItem -> f ModGenBlockedItem)
-> ModGenBlockedItem -> f ModGenBlockedItem
forall a. Data a => Traversal' a a
Traversal' ModGenBlockedItem ModGenBlockedItem
uniplate

-- | Module item: body of module
-- | Caution: if MIPort sign is False then it can be overriden by a MGINetDecl/Init
data ModuleItem
  = MIMGI !(Attributed ModGenBlockedItem)
  | MIPort !(AttrIded (Dir, SignRange))
  | MIParameter !(AttrIded Parameter)
  | MIGenReg ![Attributed ModGenBlockedItem]
  | MISpecParam
    { ModuleItem -> Attributes
_mispAttribute :: !Attributes,
      ModuleItem -> Maybe Range2
_mispRange :: !(Maybe Range2),
      ModuleItem -> SpecParamDecl
_mispDecl :: !SpecParamDecl
    }
  | MISpecBlock ![SpecifyBlockedItem]
  deriving (Int -> ModuleItem -> ShowS
[ModuleItem] -> ShowS
ModuleItem -> String
(Int -> ModuleItem -> ShowS)
-> (ModuleItem -> String)
-> ([ModuleItem] -> ShowS)
-> Show ModuleItem
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ModuleItem -> ShowS
showsPrec :: Int -> ModuleItem -> ShowS
$cshow :: ModuleItem -> String
show :: ModuleItem -> String
$cshowList :: [ModuleItem] -> ShowS
showList :: [ModuleItem] -> ShowS
Show, ModuleItem -> ModuleItem -> Bool
(ModuleItem -> ModuleItem -> Bool)
-> (ModuleItem -> ModuleItem -> Bool) -> Eq ModuleItem
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ModuleItem -> ModuleItem -> Bool
== :: ModuleItem -> ModuleItem -> Bool
$c/= :: ModuleItem -> ModuleItem -> Bool
/= :: ModuleItem -> ModuleItem -> Bool
Eq, Typeable ModuleItem
Typeable ModuleItem =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> ModuleItem -> c ModuleItem)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ModuleItem)
-> (ModuleItem -> Constr)
-> (ModuleItem -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ModuleItem))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c ModuleItem))
-> ((forall b. Data b => b -> b) -> ModuleItem -> ModuleItem)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ModuleItem -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ModuleItem -> r)
-> (forall u. (forall d. Data d => d -> u) -> ModuleItem -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> ModuleItem -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ModuleItem -> m ModuleItem)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ModuleItem -> m ModuleItem)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ModuleItem -> m ModuleItem)
-> Data ModuleItem
ModuleItem -> Constr
ModuleItem -> DataType
(forall b. Data b => b -> b) -> ModuleItem -> ModuleItem
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) -> ModuleItem -> u
forall u. (forall d. Data d => d -> u) -> ModuleItem -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ModuleItem -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ModuleItem -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ModuleItem -> m ModuleItem
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ModuleItem -> m ModuleItem
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ModuleItem
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ModuleItem -> c ModuleItem
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ModuleItem)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ModuleItem)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ModuleItem -> c ModuleItem
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ModuleItem -> c ModuleItem
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ModuleItem
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ModuleItem
$ctoConstr :: ModuleItem -> Constr
toConstr :: ModuleItem -> Constr
$cdataTypeOf :: ModuleItem -> DataType
dataTypeOf :: ModuleItem -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ModuleItem)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ModuleItem)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ModuleItem)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ModuleItem)
$cgmapT :: (forall b. Data b => b -> b) -> ModuleItem -> ModuleItem
gmapT :: (forall b. Data b => b -> b) -> ModuleItem -> ModuleItem
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ModuleItem -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ModuleItem -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ModuleItem -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ModuleItem -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> ModuleItem -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> ModuleItem -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ModuleItem -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ModuleItem -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ModuleItem -> m ModuleItem
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ModuleItem -> m ModuleItem
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ModuleItem -> m ModuleItem
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ModuleItem -> m ModuleItem
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ModuleItem -> m ModuleItem
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ModuleItem -> m ModuleItem
Data, (forall x. ModuleItem -> Rep ModuleItem x)
-> (forall x. Rep ModuleItem x -> ModuleItem) -> Generic ModuleItem
forall x. Rep ModuleItem x -> ModuleItem
forall x. ModuleItem -> Rep ModuleItem x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. ModuleItem -> Rep ModuleItem x
from :: forall x. ModuleItem -> Rep ModuleItem x
$cto :: forall x. Rep ModuleItem x -> ModuleItem
to :: forall x. Rep ModuleItem x -> ModuleItem
Generic)

type GenerateBlock = Identified [Attributed ModGenBlockedItem]

-- | Module block
-- TODO: remember whether the module is a module or macromodule because implementation dependent
data ModuleBlock = ModuleBlock
  { ModuleBlock -> Attributes
_mbAttr :: !Attributes,
    ModuleBlock -> Identifier
_mbIdent :: !Identifier,
    ModuleBlock -> [Identified [Identified (Maybe CRangeExpr)]]
_mbPortInter :: ![Identified [Identified (Maybe CRangeExpr)]],
    ModuleBlock -> [ModuleItem]
_mbBody :: ![ModuleItem],
    ModuleBlock -> Maybe (Int, Int)
_mbTimescale :: !(Maybe (Int, Int)),
    ModuleBlock -> Bool
_mbCell :: !Bool,
    ModuleBlock -> Maybe Bool
_mbPull :: !(Maybe Bool),
    ModuleBlock -> Maybe NetType
_mbDefNetType :: !(Maybe NetType)
  }
  deriving (Int -> ModuleBlock -> ShowS
[ModuleBlock] -> ShowS
ModuleBlock -> String
(Int -> ModuleBlock -> ShowS)
-> (ModuleBlock -> String)
-> ([ModuleBlock] -> ShowS)
-> Show ModuleBlock
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ModuleBlock -> ShowS
showsPrec :: Int -> ModuleBlock -> ShowS
$cshow :: ModuleBlock -> String
show :: ModuleBlock -> String
$cshowList :: [ModuleBlock] -> ShowS
showList :: [ModuleBlock] -> ShowS
Show, ModuleBlock -> ModuleBlock -> Bool
(ModuleBlock -> ModuleBlock -> Bool)
-> (ModuleBlock -> ModuleBlock -> Bool) -> Eq ModuleBlock
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ModuleBlock -> ModuleBlock -> Bool
== :: ModuleBlock -> ModuleBlock -> Bool
$c/= :: ModuleBlock -> ModuleBlock -> Bool
/= :: ModuleBlock -> ModuleBlock -> Bool
Eq, Typeable ModuleBlock
Typeable ModuleBlock =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> ModuleBlock -> c ModuleBlock)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ModuleBlock)
-> (ModuleBlock -> Constr)
-> (ModuleBlock -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ModuleBlock))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c ModuleBlock))
-> ((forall b. Data b => b -> b) -> ModuleBlock -> ModuleBlock)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ModuleBlock -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ModuleBlock -> r)
-> (forall u. (forall d. Data d => d -> u) -> ModuleBlock -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> ModuleBlock -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ModuleBlock -> m ModuleBlock)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ModuleBlock -> m ModuleBlock)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ModuleBlock -> m ModuleBlock)
-> Data ModuleBlock
ModuleBlock -> Constr
ModuleBlock -> DataType
(forall b. Data b => b -> b) -> ModuleBlock -> ModuleBlock
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) -> ModuleBlock -> u
forall u. (forall d. Data d => d -> u) -> ModuleBlock -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ModuleBlock -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ModuleBlock -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ModuleBlock -> m ModuleBlock
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ModuleBlock -> m ModuleBlock
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ModuleBlock
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ModuleBlock -> c ModuleBlock
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ModuleBlock)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ModuleBlock)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ModuleBlock -> c ModuleBlock
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ModuleBlock -> c ModuleBlock
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ModuleBlock
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ModuleBlock
$ctoConstr :: ModuleBlock -> Constr
toConstr :: ModuleBlock -> Constr
$cdataTypeOf :: ModuleBlock -> DataType
dataTypeOf :: ModuleBlock -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ModuleBlock)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ModuleBlock)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ModuleBlock)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ModuleBlock)
$cgmapT :: (forall b. Data b => b -> b) -> ModuleBlock -> ModuleBlock
gmapT :: (forall b. Data b => b -> b) -> ModuleBlock -> ModuleBlock
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ModuleBlock -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ModuleBlock -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ModuleBlock -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ModuleBlock -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> ModuleBlock -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> ModuleBlock -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ModuleBlock -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ModuleBlock -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ModuleBlock -> m ModuleBlock
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ModuleBlock -> m ModuleBlock
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ModuleBlock -> m ModuleBlock
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ModuleBlock -> m ModuleBlock
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ModuleBlock -> m ModuleBlock
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ModuleBlock -> m ModuleBlock
Data, (forall x. ModuleBlock -> Rep ModuleBlock x)
-> (forall x. Rep ModuleBlock x -> ModuleBlock)
-> Generic ModuleBlock
forall x. Rep ModuleBlock x -> ModuleBlock
forall x. ModuleBlock -> Rep ModuleBlock x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. ModuleBlock -> Rep ModuleBlock x
from :: forall x. ModuleBlock -> Rep ModuleBlock x
$cto :: forall x. Rep ModuleBlock x -> ModuleBlock
to :: forall x. Rep ModuleBlock x -> ModuleBlock
Generic)

-- | Signal level
data SigLevel = L0 | L1 | LX | LQ | LB
  deriving (SigLevel -> SigLevel -> Bool
(SigLevel -> SigLevel -> Bool)
-> (SigLevel -> SigLevel -> Bool) -> Eq SigLevel
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SigLevel -> SigLevel -> Bool
== :: SigLevel -> SigLevel -> Bool
$c/= :: SigLevel -> SigLevel -> Bool
/= :: SigLevel -> SigLevel -> Bool
Eq, SigLevel
SigLevel -> SigLevel -> Bounded SigLevel
forall a. a -> a -> Bounded a
$cminBound :: SigLevel
minBound :: SigLevel
$cmaxBound :: SigLevel
maxBound :: SigLevel
Bounded, Int -> SigLevel
SigLevel -> Int
SigLevel -> [SigLevel]
SigLevel -> SigLevel
SigLevel -> SigLevel -> [SigLevel]
SigLevel -> SigLevel -> SigLevel -> [SigLevel]
(SigLevel -> SigLevel)
-> (SigLevel -> SigLevel)
-> (Int -> SigLevel)
-> (SigLevel -> Int)
-> (SigLevel -> [SigLevel])
-> (SigLevel -> SigLevel -> [SigLevel])
-> (SigLevel -> SigLevel -> [SigLevel])
-> (SigLevel -> SigLevel -> SigLevel -> [SigLevel])
-> Enum SigLevel
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: SigLevel -> SigLevel
succ :: SigLevel -> SigLevel
$cpred :: SigLevel -> SigLevel
pred :: SigLevel -> SigLevel
$ctoEnum :: Int -> SigLevel
toEnum :: Int -> SigLevel
$cfromEnum :: SigLevel -> Int
fromEnum :: SigLevel -> Int
$cenumFrom :: SigLevel -> [SigLevel]
enumFrom :: SigLevel -> [SigLevel]
$cenumFromThen :: SigLevel -> SigLevel -> [SigLevel]
enumFromThen :: SigLevel -> SigLevel -> [SigLevel]
$cenumFromTo :: SigLevel -> SigLevel -> [SigLevel]
enumFromTo :: SigLevel -> SigLevel -> [SigLevel]
$cenumFromThenTo :: SigLevel -> SigLevel -> SigLevel -> [SigLevel]
enumFromThenTo :: SigLevel -> SigLevel -> SigLevel -> [SigLevel]
Enum, Typeable SigLevel
Typeable SigLevel =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> SigLevel -> c SigLevel)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c SigLevel)
-> (SigLevel -> Constr)
-> (SigLevel -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c SigLevel))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SigLevel))
-> ((forall b. Data b => b -> b) -> SigLevel -> SigLevel)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> SigLevel -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> SigLevel -> r)
-> (forall u. (forall d. Data d => d -> u) -> SigLevel -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> SigLevel -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> SigLevel -> m SigLevel)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> SigLevel -> m SigLevel)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> SigLevel -> m SigLevel)
-> Data SigLevel
SigLevel -> Constr
SigLevel -> DataType
(forall b. Data b => b -> b) -> SigLevel -> SigLevel
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) -> SigLevel -> u
forall u. (forall d. Data d => d -> u) -> SigLevel -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SigLevel -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SigLevel -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SigLevel -> m SigLevel
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SigLevel -> m SigLevel
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SigLevel
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SigLevel -> c SigLevel
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SigLevel)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SigLevel)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SigLevel -> c SigLevel
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SigLevel -> c SigLevel
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SigLevel
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SigLevel
$ctoConstr :: SigLevel -> Constr
toConstr :: SigLevel -> Constr
$cdataTypeOf :: SigLevel -> DataType
dataTypeOf :: SigLevel -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SigLevel)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SigLevel)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SigLevel)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SigLevel)
$cgmapT :: (forall b. Data b => b -> b) -> SigLevel -> SigLevel
gmapT :: (forall b. Data b => b -> b) -> SigLevel -> SigLevel
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SigLevel -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SigLevel -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SigLevel -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SigLevel -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> SigLevel -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> SigLevel -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> SigLevel -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> SigLevel -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SigLevel -> m SigLevel
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SigLevel -> m SigLevel
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SigLevel -> m SigLevel
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SigLevel -> m SigLevel
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SigLevel -> m SigLevel
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SigLevel -> m SigLevel
Data, (forall x. SigLevel -> Rep SigLevel x)
-> (forall x. Rep SigLevel x -> SigLevel) -> Generic SigLevel
forall x. Rep SigLevel x -> SigLevel
forall x. SigLevel -> Rep SigLevel x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. SigLevel -> Rep SigLevel x
from :: forall x. SigLevel -> Rep SigLevel x
$cto :: forall x. Rep SigLevel x -> SigLevel
to :: forall x. Rep SigLevel x -> SigLevel
Generic)

instance Show SigLevel where
  show :: SigLevel -> String
show SigLevel
x = case SigLevel
x of SigLevel
L0 -> String
"0"; SigLevel
L1 -> String
"1"; SigLevel
LX -> String
"x"; SigLevel
LQ -> String
"?"; SigLevel
LB -> String
"b"

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

-- | Edge specifier
data Edge
  = EdgePos_neg !Bool
  | EdgeDesc
      { Edge -> SigLevel
_edFrom :: !SigLevel,
        Edge -> SigLevel
_edTo :: !SigLevel
      }
  deriving (Edge -> Edge -> Bool
(Edge -> Edge -> Bool) -> (Edge -> Edge -> Bool) -> Eq Edge
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Edge -> Edge -> Bool
== :: Edge -> Edge -> Bool
$c/= :: Edge -> Edge -> Bool
/= :: Edge -> Edge -> Bool
Eq, Typeable Edge
Typeable Edge =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Edge -> c Edge)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Edge)
-> (Edge -> Constr)
-> (Edge -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Edge))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Edge))
-> ((forall b. Data b => b -> b) -> Edge -> Edge)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Edge -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Edge -> r)
-> (forall u. (forall d. Data d => d -> u) -> Edge -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Edge -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Edge -> m Edge)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Edge -> m Edge)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Edge -> m Edge)
-> Data Edge
Edge -> Constr
Edge -> DataType
(forall b. Data b => b -> b) -> Edge -> Edge
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) -> Edge -> u
forall u. (forall d. Data d => d -> u) -> Edge -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Edge -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Edge -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Edge -> m Edge
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Edge -> m Edge
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Edge
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Edge -> c Edge
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Edge)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Edge)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Edge -> c Edge
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Edge -> c Edge
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Edge
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Edge
$ctoConstr :: Edge -> Constr
toConstr :: Edge -> Constr
$cdataTypeOf :: Edge -> DataType
dataTypeOf :: Edge -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Edge)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Edge)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Edge)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Edge)
$cgmapT :: (forall b. Data b => b -> b) -> Edge -> Edge
gmapT :: (forall b. Data b => b -> b) -> Edge -> Edge
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Edge -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Edge -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Edge -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Edge -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Edge -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Edge -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Edge -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Edge -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Edge -> m Edge
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Edge -> m Edge
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Edge -> m Edge
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Edge -> m Edge
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Edge -> m Edge
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Edge -> m Edge
Data, (forall x. Edge -> Rep Edge x)
-> (forall x. Rep Edge x -> Edge) -> Generic Edge
forall x. Rep Edge x -> Edge
forall x. Edge -> Rep Edge x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Edge -> Rep Edge x
from :: forall x. Edge -> Rep Edge x
$cto :: forall x. Rep Edge x -> Edge
to :: forall x. Rep Edge x -> Edge
Generic)

instance Show Edge where
  show :: Edge -> String
show Edge
x = case Edge
x of
    EdgePos_neg Bool
b -> if Bool
b then String
"p" else String
"n"
    EdgeDesc SigLevel
LQ SigLevel
LQ -> String
"*"
    EdgeDesc SigLevel
f SigLevel
t -> Char
'(' Char -> ShowS
forall a. a -> [a] -> [a]
: SigLevel -> String
forall a. Show a => a -> String
show SigLevel
f String -> ShowS
forall a. [a] -> [a] -> [a]
++ SigLevel -> String
forall a. Show a => a -> String
show SigLevel
t String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
")"

-- | Seqential table inputs: a list of input levels with at most 1 edge specifier
data SeqIn
  = SIComb !(NonEmpty SigLevel)
  | SISeq ![SigLevel] !Edge ![SigLevel]
  deriving (SeqIn -> SeqIn -> Bool
(SeqIn -> SeqIn -> Bool) -> (SeqIn -> SeqIn -> Bool) -> Eq SeqIn
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SeqIn -> SeqIn -> Bool
== :: SeqIn -> SeqIn -> Bool
$c/= :: SeqIn -> SeqIn -> Bool
/= :: SeqIn -> SeqIn -> Bool
Eq, Typeable SeqIn
Typeable SeqIn =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> SeqIn -> c SeqIn)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c SeqIn)
-> (SeqIn -> Constr)
-> (SeqIn -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c SeqIn))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SeqIn))
-> ((forall b. Data b => b -> b) -> SeqIn -> SeqIn)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SeqIn -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SeqIn -> r)
-> (forall u. (forall d. Data d => d -> u) -> SeqIn -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> SeqIn -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> SeqIn -> m SeqIn)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> SeqIn -> m SeqIn)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> SeqIn -> m SeqIn)
-> Data SeqIn
SeqIn -> Constr
SeqIn -> DataType
(forall b. Data b => b -> b) -> SeqIn -> SeqIn
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) -> SeqIn -> u
forall u. (forall d. Data d => d -> u) -> SeqIn -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SeqIn -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SeqIn -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SeqIn -> m SeqIn
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SeqIn -> m SeqIn
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SeqIn
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SeqIn -> c SeqIn
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SeqIn)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SeqIn)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SeqIn -> c SeqIn
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SeqIn -> c SeqIn
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SeqIn
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SeqIn
$ctoConstr :: SeqIn -> Constr
toConstr :: SeqIn -> Constr
$cdataTypeOf :: SeqIn -> DataType
dataTypeOf :: SeqIn -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SeqIn)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SeqIn)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SeqIn)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SeqIn)
$cgmapT :: (forall b. Data b => b -> b) -> SeqIn -> SeqIn
gmapT :: (forall b. Data b => b -> b) -> SeqIn -> SeqIn
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SeqIn -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SeqIn -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SeqIn -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SeqIn -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> SeqIn -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> SeqIn -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> SeqIn -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> SeqIn -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SeqIn -> m SeqIn
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SeqIn -> m SeqIn
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SeqIn -> m SeqIn
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SeqIn -> m SeqIn
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SeqIn -> m SeqIn
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SeqIn -> m SeqIn
Data, (forall x. SeqIn -> Rep SeqIn x)
-> (forall x. Rep SeqIn x -> SeqIn) -> Generic SeqIn
forall x. Rep SeqIn x -> SeqIn
forall x. SeqIn -> Rep SeqIn x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. SeqIn -> Rep SeqIn x
from :: forall x. SeqIn -> Rep SeqIn x
$cto :: forall x. Rep SeqIn x -> SeqIn
to :: forall x. Rep SeqIn x -> SeqIn
Generic)

instance Show SeqIn where
  show :: SeqIn -> String
show SeqIn
x = case SeqIn
x of
    SIComb NonEmpty SigLevel
l -> (SigLevel -> String) -> NonEmpty SigLevel -> String
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap SigLevel -> String
forall a. Show a => a -> String
show NonEmpty SigLevel
l
    SISeq [SigLevel]
l0 Edge
e [SigLevel]
l1 -> (SigLevel -> String) -> [SigLevel] -> String
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap SigLevel -> String
forall a. Show a => a -> String
show [SigLevel]
l0 String -> ShowS
forall a. [a] -> [a] -> [a]
++ Edge -> String
forall a. Show a => a -> String
show Edge
e String -> ShowS
forall a. [a] -> [a] -> [a]
++ (SigLevel -> String) -> [SigLevel] -> String
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap SigLevel -> String
forall a. Show a => a -> String
show [SigLevel]
l1

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

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

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

-- | Primitive block
data PrimitiveBlock = PrimitiveBlock
  { PrimitiveBlock -> Attributes
_pbAttr :: !Attributes,
    PrimitiveBlock -> Identifier
_pbIdent :: !Identifier,
    PrimitiveBlock -> Identifier
_pbOutput :: !Identifier,
    PrimitiveBlock -> NonEmpty Identifier
_pbInput :: !(NonEmpty Identifier),
    PrimitiveBlock -> NonEmpty (AttrIded PrimPort)
_pbPortDecl :: !(NonEmpty (AttrIded PrimPort)),
    PrimitiveBlock -> PrimTable
_pbBody :: !PrimTable
  }
  deriving (Int -> PrimitiveBlock -> ShowS
[PrimitiveBlock] -> ShowS
PrimitiveBlock -> String
(Int -> PrimitiveBlock -> ShowS)
-> (PrimitiveBlock -> String)
-> ([PrimitiveBlock] -> ShowS)
-> Show PrimitiveBlock
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> PrimitiveBlock -> ShowS
showsPrec :: Int -> PrimitiveBlock -> ShowS
$cshow :: PrimitiveBlock -> String
show :: PrimitiveBlock -> String
$cshowList :: [PrimitiveBlock] -> ShowS
showList :: [PrimitiveBlock] -> ShowS
Show, PrimitiveBlock -> PrimitiveBlock -> Bool
(PrimitiveBlock -> PrimitiveBlock -> Bool)
-> (PrimitiveBlock -> PrimitiveBlock -> Bool) -> Eq PrimitiveBlock
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: PrimitiveBlock -> PrimitiveBlock -> Bool
== :: PrimitiveBlock -> PrimitiveBlock -> Bool
$c/= :: PrimitiveBlock -> PrimitiveBlock -> Bool
/= :: PrimitiveBlock -> PrimitiveBlock -> Bool
Eq, Typeable PrimitiveBlock
Typeable PrimitiveBlock =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> PrimitiveBlock -> c PrimitiveBlock)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c PrimitiveBlock)
-> (PrimitiveBlock -> Constr)
-> (PrimitiveBlock -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c PrimitiveBlock))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c PrimitiveBlock))
-> ((forall b. Data b => b -> b)
    -> PrimitiveBlock -> PrimitiveBlock)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> PrimitiveBlock -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> PrimitiveBlock -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> PrimitiveBlock -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> PrimitiveBlock -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> PrimitiveBlock -> m PrimitiveBlock)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> PrimitiveBlock -> m PrimitiveBlock)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> PrimitiveBlock -> m PrimitiveBlock)
-> Data PrimitiveBlock
PrimitiveBlock -> Constr
PrimitiveBlock -> DataType
(forall b. Data b => b -> b) -> PrimitiveBlock -> PrimitiveBlock
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) -> PrimitiveBlock -> u
forall u. (forall d. Data d => d -> u) -> PrimitiveBlock -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PrimitiveBlock -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PrimitiveBlock -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> PrimitiveBlock -> m PrimitiveBlock
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> PrimitiveBlock -> m PrimitiveBlock
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PrimitiveBlock
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PrimitiveBlock -> c PrimitiveBlock
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c PrimitiveBlock)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c PrimitiveBlock)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PrimitiveBlock -> c PrimitiveBlock
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PrimitiveBlock -> c PrimitiveBlock
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PrimitiveBlock
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PrimitiveBlock
$ctoConstr :: PrimitiveBlock -> Constr
toConstr :: PrimitiveBlock -> Constr
$cdataTypeOf :: PrimitiveBlock -> DataType
dataTypeOf :: PrimitiveBlock -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c PrimitiveBlock)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c PrimitiveBlock)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c PrimitiveBlock)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c PrimitiveBlock)
$cgmapT :: (forall b. Data b => b -> b) -> PrimitiveBlock -> PrimitiveBlock
gmapT :: (forall b. Data b => b -> b) -> PrimitiveBlock -> PrimitiveBlock
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PrimitiveBlock -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PrimitiveBlock -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PrimitiveBlock -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PrimitiveBlock -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> PrimitiveBlock -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> PrimitiveBlock -> [u]
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> PrimitiveBlock -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> PrimitiveBlock -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> PrimitiveBlock -> m PrimitiveBlock
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> PrimitiveBlock -> m PrimitiveBlock
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> PrimitiveBlock -> m PrimitiveBlock
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> PrimitiveBlock -> m PrimitiveBlock
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> PrimitiveBlock -> m PrimitiveBlock
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> PrimitiveBlock -> m PrimitiveBlock
Data, (forall x. PrimitiveBlock -> Rep PrimitiveBlock x)
-> (forall x. Rep PrimitiveBlock x -> PrimitiveBlock)
-> Generic PrimitiveBlock
forall x. Rep PrimitiveBlock x -> PrimitiveBlock
forall x. PrimitiveBlock -> Rep PrimitiveBlock x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. PrimitiveBlock -> Rep PrimitiveBlock x
from :: forall x. PrimitiveBlock -> Rep PrimitiveBlock x
$cto :: forall x. Rep PrimitiveBlock x -> PrimitiveBlock
to :: forall x. Rep PrimitiveBlock x -> PrimitiveBlock
Generic)

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

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

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

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

-- | Config Block: Identifier, Design lines, Configuration items
data ConfigBlock = ConfigBlock
  { ConfigBlock -> Identifier
_cbIdent :: !Identifier,
    ConfigBlock -> [Dot1Ident]
_cbDesign :: ![Dot1Ident],
    ConfigBlock -> [ConfigItem]
_cbBody :: ![ConfigItem],
    ConfigBlock -> [ByteString]
_cbDef :: ![ByteString]
  }
  deriving (Int -> ConfigBlock -> ShowS
[ConfigBlock] -> ShowS
ConfigBlock -> String
(Int -> ConfigBlock -> ShowS)
-> (ConfigBlock -> String)
-> ([ConfigBlock] -> ShowS)
-> Show ConfigBlock
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ConfigBlock -> ShowS
showsPrec :: Int -> ConfigBlock -> ShowS
$cshow :: ConfigBlock -> String
show :: ConfigBlock -> String
$cshowList :: [ConfigBlock] -> ShowS
showList :: [ConfigBlock] -> ShowS
Show, ConfigBlock -> ConfigBlock -> Bool
(ConfigBlock -> ConfigBlock -> Bool)
-> (ConfigBlock -> ConfigBlock -> Bool) -> Eq ConfigBlock
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ConfigBlock -> ConfigBlock -> Bool
== :: ConfigBlock -> ConfigBlock -> Bool
$c/= :: ConfigBlock -> ConfigBlock -> Bool
/= :: ConfigBlock -> ConfigBlock -> Bool
Eq, Typeable ConfigBlock
Typeable ConfigBlock =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> ConfigBlock -> c ConfigBlock)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ConfigBlock)
-> (ConfigBlock -> Constr)
-> (ConfigBlock -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ConfigBlock))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c ConfigBlock))
-> ((forall b. Data b => b -> b) -> ConfigBlock -> ConfigBlock)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ConfigBlock -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ConfigBlock -> r)
-> (forall u. (forall d. Data d => d -> u) -> ConfigBlock -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> ConfigBlock -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ConfigBlock -> m ConfigBlock)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ConfigBlock -> m ConfigBlock)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ConfigBlock -> m ConfigBlock)
-> Data ConfigBlock
ConfigBlock -> Constr
ConfigBlock -> DataType
(forall b. Data b => b -> b) -> ConfigBlock -> ConfigBlock
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) -> ConfigBlock -> u
forall u. (forall d. Data d => d -> u) -> ConfigBlock -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ConfigBlock -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ConfigBlock -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ConfigBlock -> m ConfigBlock
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ConfigBlock -> m ConfigBlock
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ConfigBlock
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ConfigBlock -> c ConfigBlock
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ConfigBlock)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ConfigBlock)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ConfigBlock -> c ConfigBlock
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ConfigBlock -> c ConfigBlock
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ConfigBlock
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ConfigBlock
$ctoConstr :: ConfigBlock -> Constr
toConstr :: ConfigBlock -> Constr
$cdataTypeOf :: ConfigBlock -> DataType
dataTypeOf :: ConfigBlock -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ConfigBlock)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ConfigBlock)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ConfigBlock)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ConfigBlock)
$cgmapT :: (forall b. Data b => b -> b) -> ConfigBlock -> ConfigBlock
gmapT :: (forall b. Data b => b -> b) -> ConfigBlock -> ConfigBlock
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ConfigBlock -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ConfigBlock -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ConfigBlock -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ConfigBlock -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> ConfigBlock -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> ConfigBlock -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ConfigBlock -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ConfigBlock -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ConfigBlock -> m ConfigBlock
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ConfigBlock -> m ConfigBlock
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ConfigBlock -> m ConfigBlock
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ConfigBlock -> m ConfigBlock
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ConfigBlock -> m ConfigBlock
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ConfigBlock -> m ConfigBlock
Data, (forall x. ConfigBlock -> Rep ConfigBlock x)
-> (forall x. Rep ConfigBlock x -> ConfigBlock)
-> Generic ConfigBlock
forall x. Rep ConfigBlock x -> ConfigBlock
forall x. ConfigBlock -> Rep ConfigBlock x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. ConfigBlock -> Rep ConfigBlock x
from :: forall x. ConfigBlock -> Rep ConfigBlock x
$cto :: forall x. Rep ConfigBlock x -> ConfigBlock
to :: forall x. Rep ConfigBlock x -> ConfigBlock
Generic)

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

instance Semigroup Verilog2005 where
  <> :: Verilog2005 -> Verilog2005 -> Verilog2005
(<>) Verilog2005
v2a Verilog2005
v2b =
    Verilog2005
v2a
      { _vModule = _vModule v2a <> _vModule v2b,
        _vPrimitive = _vPrimitive v2a <> _vPrimitive v2b,
        _vConfig = _vConfig v2a <> _vConfig v2b
      }

instance Monoid Verilog2005 where
  mempty :: Verilog2005
mempty = [ModuleBlock] -> [PrimitiveBlock] -> [ConfigBlock] -> Verilog2005
Verilog2005 [] [] []

$(makeLenses ''HierIdent)
$(makeLenses ''ModuleBlock)
$(makeLenses ''PrimitiveBlock)
$(makePrisms ''Cell_inst)
$(makeLenses ''ConfigItem)
$(makeLenses ''ConfigBlock)

data Logic = LAnd | LOr | LNand | LNor
  deriving (Logic -> Logic -> Bool
(Logic -> Logic -> Bool) -> (Logic -> Logic -> Bool) -> Eq Logic
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Logic -> Logic -> Bool
== :: Logic -> Logic -> Bool
$c/= :: Logic -> Logic -> Bool
/= :: Logic -> Logic -> Bool
Eq, Typeable Logic
Typeable Logic =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Logic -> c Logic)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Logic)
-> (Logic -> Constr)
-> (Logic -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Logic))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Logic))
-> ((forall b. Data b => b -> b) -> Logic -> Logic)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Logic -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Logic -> r)
-> (forall u. (forall d. Data d => d -> u) -> Logic -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Logic -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Logic -> m Logic)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Logic -> m Logic)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Logic -> m Logic)
-> Data Logic
Logic -> Constr
Logic -> DataType
(forall b. Data b => b -> b) -> Logic -> Logic
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) -> Logic -> u
forall u. (forall d. Data d => d -> u) -> Logic -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Logic -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Logic -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Logic -> m Logic
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Logic -> m Logic
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Logic
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Logic -> c Logic
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Logic)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Logic)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Logic -> c Logic
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Logic -> c Logic
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Logic
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Logic
$ctoConstr :: Logic -> Constr
toConstr :: Logic -> Constr
$cdataTypeOf :: Logic -> DataType
dataTypeOf :: Logic -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Logic)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Logic)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Logic)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Logic)
$cgmapT :: (forall b. Data b => b -> b) -> Logic -> Logic
gmapT :: (forall b. Data b => b -> b) -> Logic -> Logic
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Logic -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Logic -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Logic -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Logic -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Logic -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Logic -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Logic -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Logic -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Logic -> m Logic
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Logic -> m Logic
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Logic -> m Logic
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Logic -> m Logic
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Logic -> m Logic
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Logic -> m Logic
Data)

instance Show Logic where
  show :: Logic -> String
show Logic
x = case Logic
x of Logic
LAnd -> String
"and"; Logic
LOr -> String
"or"; Logic
LNand -> String
"nand"; Logic
LNor -> String
"nor"

data SystemFunction
  = SFDisplay
  | SFDisplayb
  | SFDisplayh
  | SFDisplayo
  | SFStrobe
  | SFStrobeb
  | SFStrobeh
  | SFStrobeo
  | SFWrite
  | SFWriteb
  | SFWriteh
  | SFWriteo
  | SFMonitor
  | SFMonitorb
  | SFMonitorh
  | SFMonitoro
  | SFMonitoroff
  | SFMonitoron
  | SFFclose
  | SFFdisplay
  | SFFdisplayb
  | SFFdisplayh
  | SFFdisplayo
  | SFFstrobe
  | SFFstrobeb
  | SFFstrobeh
  | SFFstrobeo
  | SFSwrite
  | SFSwriteb
  | SFSwriteh
  | SFSwriteo
  | SFFscanf
  | SFFread
  | SFFseek
  | SFFflush
  | SFFeof
  | SFSdfannotate
  | SFFopen
  | SFFwrite
  | SFFwriteb
  | SFFwriteh
  | SFFwriteo
  | SFFmonitor
  | SFFmonitorb
  | SFFmonitorh
  | SFFmonitoro
  | SFSformat
  | SFFgetc
  | SFUngetc
  | SFFgets
  | SFSscanf
  | SFRewind
  | SFFtell
  | SFFerror
  | SFReadmemb
  | SFReadmemh
  | SFPrinttimescale
  | SFTimeformat
  | SFFinish
  | SFStop
  | SFQinitialize
  | SFQremove
  | SFQexam
  | SFQadd
  | SFQfull
  | SFRealtime
  | SFTime
  | SFStime
  | SFBitstoreal
  | SFItor
  | SFSigned
  | SFRealtobits
  | SFRtoi
  | SFUnsigned
  | SFRandom
  | SFDisterlang
  | SFDistnormal
  | SFDistt
  | SFDistchisquare
  | SFDistexponential
  | SFDistpoisson
  | SFDistuniform
  | SFClog2
  | SFLn
  | SFLog10
  | SFExp
  | SFSqrt
  | SFPow
  | SFFloor
  | SFCeil
  | SFSin
  | SFCos
  | SFTan
  | SFAsin
  | SFAcos
  | SFAtan
  | SFAtan2
  | SFHypot
  | SFSinh
  | SFCosh
  | SFTanh
  | SFAsinh
  | SFAcosh
  | SFAtanh
  | SFTestplusargs
  | SFValueplusargs
  | SFPla
      { SystemFunction -> Bool
_sfpSync :: !Bool,
        SystemFunction -> Logic
_sfpLogic :: !Logic,
        SystemFunction -> Bool
_sfpPla_arr :: !Bool
      }
  | SFSVPast
  | SFSVStable
  | SFSVRose
  | SFSVFell
  deriving (SystemFunction -> SystemFunction -> Bool
(SystemFunction -> SystemFunction -> Bool)
-> (SystemFunction -> SystemFunction -> Bool) -> Eq SystemFunction
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SystemFunction -> SystemFunction -> Bool
== :: SystemFunction -> SystemFunction -> Bool
$c/= :: SystemFunction -> SystemFunction -> Bool
/= :: SystemFunction -> SystemFunction -> Bool
Eq, Typeable SystemFunction
Typeable SystemFunction =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> SystemFunction -> c SystemFunction)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c SystemFunction)
-> (SystemFunction -> Constr)
-> (SystemFunction -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c SystemFunction))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c SystemFunction))
-> ((forall b. Data b => b -> b)
    -> SystemFunction -> SystemFunction)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> SystemFunction -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> SystemFunction -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> SystemFunction -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> SystemFunction -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> SystemFunction -> m SystemFunction)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> SystemFunction -> m SystemFunction)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> SystemFunction -> m SystemFunction)
-> Data SystemFunction
SystemFunction -> Constr
SystemFunction -> DataType
(forall b. Data b => b -> b) -> SystemFunction -> SystemFunction
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) -> SystemFunction -> u
forall u. (forall d. Data d => d -> u) -> SystemFunction -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SystemFunction -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SystemFunction -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> SystemFunction -> m SystemFunction
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> SystemFunction -> m SystemFunction
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SystemFunction
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SystemFunction -> c SystemFunction
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SystemFunction)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SystemFunction)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SystemFunction -> c SystemFunction
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SystemFunction -> c SystemFunction
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SystemFunction
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SystemFunction
$ctoConstr :: SystemFunction -> Constr
toConstr :: SystemFunction -> Constr
$cdataTypeOf :: SystemFunction -> DataType
dataTypeOf :: SystemFunction -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SystemFunction)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SystemFunction)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SystemFunction)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SystemFunction)
$cgmapT :: (forall b. Data b => b -> b) -> SystemFunction -> SystemFunction
gmapT :: (forall b. Data b => b -> b) -> SystemFunction -> SystemFunction
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SystemFunction -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SystemFunction -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SystemFunction -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SystemFunction -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> SystemFunction -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> SystemFunction -> [u]
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> SystemFunction -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> SystemFunction -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> SystemFunction -> m SystemFunction
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> SystemFunction -> m SystemFunction
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> SystemFunction -> m SystemFunction
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> SystemFunction -> m SystemFunction
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> SystemFunction -> m SystemFunction
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> SystemFunction -> m SystemFunction
Data)

instance Show SystemFunction where
  show :: SystemFunction -> String
show SystemFunction
x = case SystemFunction
x of
    SystemFunction
SFDisplay -> String
"display"
    SystemFunction
SFDisplayb -> String
"displayb"
    SystemFunction
SFDisplayh -> String
"displayh"
    SystemFunction
SFDisplayo -> String
"displayo"
    SystemFunction
SFStrobe -> String
"strobe"
    SystemFunction
SFStrobeb -> String
"strobeb"
    SystemFunction
SFStrobeh -> String
"strobeh"
    SystemFunction
SFStrobeo -> String
"strobeo"
    SystemFunction
SFWrite -> String
"write"
    SystemFunction
SFWriteb -> String
"writeb"
    SystemFunction
SFWriteh -> String
"writeh"
    SystemFunction
SFWriteo -> String
"writeo"
    SystemFunction
SFMonitor -> String
"monitor"
    SystemFunction
SFMonitorb -> String
"monitorb"
    SystemFunction
SFMonitorh -> String
"monitorh"
    SystemFunction
SFMonitoro -> String
"monitoro"
    SystemFunction
SFMonitoroff -> String
"monitoroff"
    SystemFunction
SFMonitoron -> String
"monitoron"
    SystemFunction
SFFclose -> String
"fclose"
    SystemFunction
SFFdisplay -> String
"fdisplay"
    SystemFunction
SFFdisplayb -> String
"fdisplayb"
    SystemFunction
SFFdisplayh -> String
"fdisplayh"
    SystemFunction
SFFdisplayo -> String
"fdisplayo"
    SystemFunction
SFFstrobe -> String
"fstrobe"
    SystemFunction
SFFstrobeb -> String
"fstrobeb"
    SystemFunction
SFFstrobeh -> String
"fstrobeh"
    SystemFunction
SFFstrobeo -> String
"fstrobeo"
    SystemFunction
SFSwrite -> String
"swrite"
    SystemFunction
SFSwriteb -> String
"swriteb"
    SystemFunction
SFSwriteh -> String
"swriteh"
    SystemFunction
SFSwriteo -> String
"swriteo"
    SystemFunction
SFFscanf -> String
"fscanf"
    SystemFunction
SFFread -> String
"fread"
    SystemFunction
SFFseek -> String
"fseek"
    SystemFunction
SFFflush -> String
"fflush"
    SystemFunction
SFFeof -> String
"feof"
    SystemFunction
SFSdfannotate -> String
"sdf_annotate"
    SystemFunction
SFFopen -> String
"fopen"
    SystemFunction
SFFwrite -> String
"fwrite"
    SystemFunction
SFFwriteb -> String
"fwriteb"
    SystemFunction
SFFwriteh -> String
"fwriteh"
    SystemFunction
SFFwriteo -> String
"fwriteo"
    SystemFunction
SFFmonitor -> String
"fmonitor"
    SystemFunction
SFFmonitorb -> String
"fmonitorb"
    SystemFunction
SFFmonitorh -> String
"fmonitorh"
    SystemFunction
SFFmonitoro -> String
"fmonitoro"
    SystemFunction
SFSformat -> String
"sformat"
    SystemFunction
SFFgetc -> String
"fgetc"
    SystemFunction
SFUngetc -> String
"ungetc"
    SystemFunction
SFFgets -> String
"gets"
    SystemFunction
SFSscanf -> String
"sscanf"
    SystemFunction
SFRewind -> String
"rewind"
    SystemFunction
SFFtell -> String
"ftell"
    SystemFunction
SFFerror -> String
"ferror"
    SystemFunction
SFReadmemb -> String
"readmemb"
    SystemFunction
SFReadmemh -> String
"readmemh"
    SystemFunction
SFPrinttimescale -> String
"printtimescale"
    SystemFunction
SFTimeformat -> String
"timeformat"
    SystemFunction
SFFinish -> String
"finish"
    SystemFunction
SFStop -> String
"stop"
    SystemFunction
SFQinitialize -> String
"q_initialize"
    SystemFunction
SFQremove -> String
"q_remove"
    SystemFunction
SFQexam -> String
"q_exam"
    SystemFunction
SFQadd -> String
"q_add"
    SystemFunction
SFQfull -> String
"q_full"
    SystemFunction
SFRealtime -> String
"realtime"
    SystemFunction
SFTime -> String
"time"
    SystemFunction
SFStime -> String
"stime"
    SystemFunction
SFBitstoreal -> String
"bitstoreal"
    SystemFunction
SFItor -> String
"itor"
    SystemFunction
SFSigned -> String
"signed"
    SystemFunction
SFRealtobits -> String
"realtobits"
    SystemFunction
SFRtoi -> String
"rtoi"
    SystemFunction
SFUnsigned -> String
"unsigned"
    SystemFunction
SFRandom -> String
"random"
    SystemFunction
SFDisterlang -> String
"dist_erlang"
    SystemFunction
SFDistnormal -> String
"dist_normal"
    SystemFunction
SFDistt -> String
"dist_t"
    SystemFunction
SFDistchisquare -> String
"dist_chi_square"
    SystemFunction
SFDistexponential -> String
"dist_exponential"
    SystemFunction
SFDistpoisson -> String
"dist_poisson"
    SystemFunction
SFDistuniform -> String
"dist_uniform"
    SystemFunction
SFClog2 -> String
"clog2"
    SystemFunction
SFLn -> String
"ln"
    SystemFunction
SFLog10 -> String
"log10"
    SystemFunction
SFExp -> String
"exp"
    SystemFunction
SFSqrt -> String
"sqrt"
    SystemFunction
SFPow -> String
"pow"
    SystemFunction
SFFloor -> String
"floor"
    SystemFunction
SFCeil -> String
"ceil"
    SystemFunction
SFSin -> String
"sin"
    SystemFunction
SFCos -> String
"cos"
    SystemFunction
SFTan -> String
"tan"
    SystemFunction
SFAsin -> String
"asin"
    SystemFunction
SFAcos -> String
"acos"
    SystemFunction
SFAtan -> String
"atan"
    SystemFunction
SFAtan2 -> String
"atan2"
    SystemFunction
SFHypot -> String
"hypot"
    SystemFunction
SFSinh -> String
"sinh"
    SystemFunction
SFCosh -> String
"cosh"
    SystemFunction
SFTanh -> String
"tanh"
    SystemFunction
SFAsinh -> String
"asinh"
    SystemFunction
SFAcosh -> String
"acosh"
    SystemFunction
SFAtanh -> String
"atanh"
    SystemFunction
SFTestplusargs -> String
"test$plusargs"
    SystemFunction
SFValueplusargs -> String
"value$plusargs"
    SFPla {_sfpSync :: SystemFunction -> Bool
_sfpSync = Bool
True, _sfpLogic :: SystemFunction -> Logic
_sfpLogic = Logic
LAnd, _sfpPla_arr :: SystemFunction -> Bool
_sfpPla_arr = Bool
False} -> String
"sync$and$array"
    SFPla {_sfpSync :: SystemFunction -> Bool
_sfpSync = Bool
True, _sfpLogic :: SystemFunction -> Logic
_sfpLogic = Logic
LAnd, _sfpPla_arr :: SystemFunction -> Bool
_sfpPla_arr = Bool
True} -> String
"sync$and$plane"
    SFPla {_sfpSync :: SystemFunction -> Bool
_sfpSync = Bool
True, _sfpLogic :: SystemFunction -> Logic
_sfpLogic = Logic
LOr, _sfpPla_arr :: SystemFunction -> Bool
_sfpPla_arr = Bool
False} -> String
"sync$or$array"
    SFPla {_sfpSync :: SystemFunction -> Bool
_sfpSync = Bool
True, _sfpLogic :: SystemFunction -> Logic
_sfpLogic = Logic
LOr, _sfpPla_arr :: SystemFunction -> Bool
_sfpPla_arr = Bool
True} -> String
"sync$or$plane"
    SFPla {_sfpSync :: SystemFunction -> Bool
_sfpSync = Bool
True, _sfpLogic :: SystemFunction -> Logic
_sfpLogic = Logic
LNand, _sfpPla_arr :: SystemFunction -> Bool
_sfpPla_arr = Bool
False} -> String
"sync$nand$array"
    SFPla {_sfpSync :: SystemFunction -> Bool
_sfpSync = Bool
True, _sfpLogic :: SystemFunction -> Logic
_sfpLogic = Logic
LNand, _sfpPla_arr :: SystemFunction -> Bool
_sfpPla_arr = Bool
True} -> String
"sync$nand$plane"
    SFPla {_sfpSync :: SystemFunction -> Bool
_sfpSync = Bool
True, _sfpLogic :: SystemFunction -> Logic
_sfpLogic = Logic
LNor, _sfpPla_arr :: SystemFunction -> Bool
_sfpPla_arr = Bool
False} -> String
"sync$nor$array"
    SFPla {_sfpSync :: SystemFunction -> Bool
_sfpSync = Bool
True, _sfpLogic :: SystemFunction -> Logic
_sfpLogic = Logic
LNor, _sfpPla_arr :: SystemFunction -> Bool
_sfpPla_arr = Bool
True} -> String
"sync$nor$plane"
    SFPla {_sfpSync :: SystemFunction -> Bool
_sfpSync = Bool
False, _sfpLogic :: SystemFunction -> Logic
_sfpLogic = Logic
LAnd, _sfpPla_arr :: SystemFunction -> Bool
_sfpPla_arr = Bool
False} -> String
"async$and$array"
    SFPla {_sfpSync :: SystemFunction -> Bool
_sfpSync = Bool
False, _sfpLogic :: SystemFunction -> Logic
_sfpLogic = Logic
LAnd, _sfpPla_arr :: SystemFunction -> Bool
_sfpPla_arr = Bool
True} -> String
"async$and$plane"
    SFPla {_sfpSync :: SystemFunction -> Bool
_sfpSync = Bool
False, _sfpLogic :: SystemFunction -> Logic
_sfpLogic = Logic
LOr, _sfpPla_arr :: SystemFunction -> Bool
_sfpPla_arr = Bool
False} -> String
"async$or$array"
    SFPla {_sfpSync :: SystemFunction -> Bool
_sfpSync = Bool
False, _sfpLogic :: SystemFunction -> Logic
_sfpLogic = Logic
LOr, _sfpPla_arr :: SystemFunction -> Bool
_sfpPla_arr = Bool
True} -> String
"async$or$plane"
    SFPla {_sfpSync :: SystemFunction -> Bool
_sfpSync = Bool
False, _sfpLogic :: SystemFunction -> Logic
_sfpLogic = Logic
LNand, _sfpPla_arr :: SystemFunction -> Bool
_sfpPla_arr = Bool
False} -> String
"async$nand$array"
    SFPla {_sfpSync :: SystemFunction -> Bool
_sfpSync = Bool
False, _sfpLogic :: SystemFunction -> Logic
_sfpLogic = Logic
LNand, _sfpPla_arr :: SystemFunction -> Bool
_sfpPla_arr = Bool
True} -> String
"async$nand$plane"
    SFPla {_sfpSync :: SystemFunction -> Bool
_sfpSync = Bool
False, _sfpLogic :: SystemFunction -> Logic
_sfpLogic = Logic
LNor, _sfpPla_arr :: SystemFunction -> Bool
_sfpPla_arr = Bool
False} -> String
"async$nor$array"
    SFPla {_sfpSync :: SystemFunction -> Bool
_sfpSync = Bool
False, _sfpLogic :: SystemFunction -> Logic
_sfpLogic = Logic
LNor, _sfpPla_arr :: SystemFunction -> Bool
_sfpPla_arr = Bool
True} -> String
"async$nor$plane"
    SystemFunction
SFSVPast -> String
"past"
    SystemFunction
SFSVStable -> String
"stable"
    SystemFunction
SFSVRose -> String
"rose"
    SystemFunction
SFSVFell -> String
"fell"

sfMap :: HashMap.HashMap ByteString SystemFunction
sfMap :: HashMap ByteString SystemFunction
sfMap =
  [(ByteString, SystemFunction)] -> HashMap ByteString SystemFunction
forall k v. (Eq k, Hashable k) => [(k, v)] -> HashMap k v
HashMap.fromList
    [ (ByteString
"display", SystemFunction
SFDisplay),
      (ByteString
"displayb", SystemFunction
SFDisplayb),
      (ByteString
"displayh", SystemFunction
SFDisplayh),
      (ByteString
"displayo", SystemFunction
SFDisplayo),
      (ByteString
"strobe", SystemFunction
SFStrobe),
      (ByteString
"strobeb", SystemFunction
SFStrobeb),
      (ByteString
"strobeh", SystemFunction
SFStrobeh),
      (ByteString
"strobeo", SystemFunction
SFStrobeo),
      (ByteString
"write", SystemFunction
SFWrite),
      (ByteString
"writeb", SystemFunction
SFWriteb),
      (ByteString
"writeh", SystemFunction
SFWriteh),
      (ByteString
"writeo", SystemFunction
SFWriteo),
      (ByteString
"monitor", SystemFunction
SFMonitor),
      (ByteString
"monitorb", SystemFunction
SFMonitorb),
      (ByteString
"monitorh", SystemFunction
SFMonitorh),
      (ByteString
"monitoro", SystemFunction
SFMonitoro),
      (ByteString
"monitoroff", SystemFunction
SFMonitoroff),
      (ByteString
"monitoron", SystemFunction
SFMonitoron),
      (ByteString
"fclose", SystemFunction
SFFclose),
      (ByteString
"fdisplay", SystemFunction
SFFdisplay),
      (ByteString
"fdisplayb", SystemFunction
SFFdisplayb),
      (ByteString
"fdisplayh", SystemFunction
SFFdisplayh),
      (ByteString
"fdisplayo", SystemFunction
SFFdisplayo),
      (ByteString
"fstrobe", SystemFunction
SFFstrobe),
      (ByteString
"fstrobeb", SystemFunction
SFFstrobeb),
      (ByteString
"fstrobeh", SystemFunction
SFFstrobeh),
      (ByteString
"fstrobeo", SystemFunction
SFFstrobeo),
      (ByteString
"swrite", SystemFunction
SFSwrite),
      (ByteString
"swriteb", SystemFunction
SFSwriteb),
      (ByteString
"swriteh", SystemFunction
SFSwriteh),
      (ByteString
"swriteo", SystemFunction
SFSwriteo),
      (ByteString
"fscanf", SystemFunction
SFFscanf),
      (ByteString
"fread", SystemFunction
SFFread),
      (ByteString
"fseek", SystemFunction
SFFseek),
      (ByteString
"fflush", SystemFunction
SFFflush),
      (ByteString
"feof", SystemFunction
SFFeof),
      (ByteString
"sdf_annotate", SystemFunction
SFSdfannotate),
      (ByteString
"fopen", SystemFunction
SFFopen),
      (ByteString
"fwrite", SystemFunction
SFFwrite),
      (ByteString
"fwriteb", SystemFunction
SFFwriteb),
      (ByteString
"fwriteh", SystemFunction
SFFwriteh),
      (ByteString
"fwriteo", SystemFunction
SFFwriteo),
      (ByteString
"fmonitor", SystemFunction
SFFmonitor),
      (ByteString
"fmonitorb", SystemFunction
SFFmonitorb),
      (ByteString
"fmonitorh", SystemFunction
SFFmonitorh),
      (ByteString
"fmonitoro", SystemFunction
SFFmonitoro),
      (ByteString
"sformat", SystemFunction
SFSformat),
      (ByteString
"fgetc", SystemFunction
SFFgetc),
      (ByteString
"ungetc", SystemFunction
SFUngetc),
      (ByteString
"gets", SystemFunction
SFFgets),
      (ByteString
"sscanf", SystemFunction
SFSscanf),
      (ByteString
"rewind", SystemFunction
SFRewind),
      (ByteString
"ftell", SystemFunction
SFFtell),
      (ByteString
"ferror", SystemFunction
SFFerror),
      (ByteString
"readmemb", SystemFunction
SFReadmemb),
      (ByteString
"readmemh", SystemFunction
SFReadmemh),
      (ByteString
"printtimescale", SystemFunction
SFPrinttimescale),
      (ByteString
"timeformat", SystemFunction
SFTimeformat),
      (ByteString
"finish", SystemFunction
SFFinish),
      (ByteString
"stop", SystemFunction
SFStop),
      (ByteString
"q_initialize", SystemFunction
SFQinitialize),
      (ByteString
"q_remove", SystemFunction
SFQremove),
      (ByteString
"q_exam", SystemFunction
SFQexam),
      (ByteString
"q_add", SystemFunction
SFQadd),
      (ByteString
"q_full", SystemFunction
SFQfull),
      (ByteString
"realtime", SystemFunction
SFRealtime),
      (ByteString
"time", SystemFunction
SFTime),
      (ByteString
"stime", SystemFunction
SFStime),
      (ByteString
"bitstoreal", SystemFunction
SFBitstoreal),
      (ByteString
"itor", SystemFunction
SFItor),
      (ByteString
"signed", SystemFunction
SFSigned),
      (ByteString
"realtobits", SystemFunction
SFRealtobits),
      (ByteString
"rtoi", SystemFunction
SFRtoi),
      (ByteString
"unsigned", SystemFunction
SFUnsigned),
      (ByteString
"random", SystemFunction
SFRandom),
      (ByteString
"dist_erlang", SystemFunction
SFDisterlang),
      (ByteString
"dist_normal", SystemFunction
SFDistnormal),
      (ByteString
"dist_t", SystemFunction
SFDistt),
      (ByteString
"dist_chi_square", SystemFunction
SFDistchisquare),
      (ByteString
"dist_exponential", SystemFunction
SFDistexponential),
      (ByteString
"dist_poisson", SystemFunction
SFDistpoisson),
      (ByteString
"dist_uniform", SystemFunction
SFDistuniform),
      (ByteString
"clog2", SystemFunction
SFClog2),
      (ByteString
"ln", SystemFunction
SFLn),
      (ByteString
"log10", SystemFunction
SFLog10),
      (ByteString
"exp", SystemFunction
SFExp),
      (ByteString
"sqrt", SystemFunction
SFSqrt),
      (ByteString
"pow", SystemFunction
SFPow),
      (ByteString
"floor", SystemFunction
SFFloor),
      (ByteString
"ceil", SystemFunction
SFCeil),
      (ByteString
"sin", SystemFunction
SFSin),
      (ByteString
"cos", SystemFunction
SFCos),
      (ByteString
"tan", SystemFunction
SFTan),
      (ByteString
"asin", SystemFunction
SFAsin),
      (ByteString
"acos", SystemFunction
SFAcos),
      (ByteString
"atan", SystemFunction
SFAtan),
      (ByteString
"atan2", SystemFunction
SFAtan2),
      (ByteString
"hypot", SystemFunction
SFHypot),
      (ByteString
"sinh", SystemFunction
SFSinh),
      (ByteString
"cosh", SystemFunction
SFCosh),
      (ByteString
"tanh", SystemFunction
SFTanh),
      (ByteString
"asinh", SystemFunction
SFAsinh),
      (ByteString
"acosh", SystemFunction
SFAcosh),
      (ByteString
"atanh", SystemFunction
SFAtanh),
      (ByteString
"test$plusargs", SystemFunction
SFTestplusargs),
      (ByteString
"value$plusargs", SystemFunction
SFValueplusargs),
      (ByteString
"sync$and$array", SFPla {_sfpSync :: Bool
_sfpSync = Bool
True, _sfpLogic :: Logic
_sfpLogic = Logic
LAnd, _sfpPla_arr :: Bool
_sfpPla_arr = Bool
False}),
      (ByteString
"sync$and$plane", SFPla {_sfpSync :: Bool
_sfpSync = Bool
True, _sfpLogic :: Logic
_sfpLogic = Logic
LAnd, _sfpPla_arr :: Bool
_sfpPla_arr = Bool
True}),
      (ByteString
"sync$or$array", SFPla {_sfpSync :: Bool
_sfpSync = Bool
True, _sfpLogic :: Logic
_sfpLogic = Logic
LOr, _sfpPla_arr :: Bool
_sfpPla_arr = Bool
False}),
      (ByteString
"sync$or$plane", SFPla {_sfpSync :: Bool
_sfpSync = Bool
True, _sfpLogic :: Logic
_sfpLogic = Logic
LOr, _sfpPla_arr :: Bool
_sfpPla_arr = Bool
True}),
      (ByteString
"sync$nand$array", SFPla {_sfpSync :: Bool
_sfpSync = Bool
True, _sfpLogic :: Logic
_sfpLogic = Logic
LNand, _sfpPla_arr :: Bool
_sfpPla_arr = Bool
False}),
      (ByteString
"sync$nand$plane", SFPla {_sfpSync :: Bool
_sfpSync = Bool
True, _sfpLogic :: Logic
_sfpLogic = Logic
LNand, _sfpPla_arr :: Bool
_sfpPla_arr = Bool
True}),
      (ByteString
"sync$nor$array", SFPla {_sfpSync :: Bool
_sfpSync = Bool
True, _sfpLogic :: Logic
_sfpLogic = Logic
LNor, _sfpPla_arr :: Bool
_sfpPla_arr = Bool
False}),
      (ByteString
"sync$nor$plane", SFPla {_sfpSync :: Bool
_sfpSync = Bool
True, _sfpLogic :: Logic
_sfpLogic = Logic
LNor, _sfpPla_arr :: Bool
_sfpPla_arr = Bool
True}),
      (ByteString
"async$and$array", SFPla {_sfpSync :: Bool
_sfpSync = Bool
False, _sfpLogic :: Logic
_sfpLogic = Logic
LAnd, _sfpPla_arr :: Bool
_sfpPla_arr = Bool
False}),
      (ByteString
"async$and$plane", SFPla {_sfpSync :: Bool
_sfpSync = Bool
False, _sfpLogic :: Logic
_sfpLogic = Logic
LAnd, _sfpPla_arr :: Bool
_sfpPla_arr = Bool
True}),
      (ByteString
"async$or$array", SFPla {_sfpSync :: Bool
_sfpSync = Bool
False, _sfpLogic :: Logic
_sfpLogic = Logic
LOr, _sfpPla_arr :: Bool
_sfpPla_arr = Bool
False}),
      (ByteString
"async$or$plane", SFPla {_sfpSync :: Bool
_sfpSync = Bool
False, _sfpLogic :: Logic
_sfpLogic = Logic
LOr, _sfpPla_arr :: Bool
_sfpPla_arr = Bool
True}),
      (ByteString
"async$nand$array", SFPla {_sfpSync :: Bool
_sfpSync = Bool
False, _sfpLogic :: Logic
_sfpLogic = Logic
LNand, _sfpPla_arr :: Bool
_sfpPla_arr = Bool
False}),
      (ByteString
"async$nand$plane", SFPla {_sfpSync :: Bool
_sfpSync = Bool
False, _sfpLogic :: Logic
_sfpLogic = Logic
LNand, _sfpPla_arr :: Bool
_sfpPla_arr = Bool
True}),
      (ByteString
"async$nor$array", SFPla {_sfpSync :: Bool
_sfpSync = Bool
False, _sfpLogic :: Logic
_sfpLogic = Logic
LNor, _sfpPla_arr :: Bool
_sfpPla_arr = Bool
False}),
      (ByteString
"async$nor$plane", SFPla {_sfpSync :: Bool
_sfpSync = Bool
False, _sfpLogic :: Logic
_sfpLogic = Logic
LNor, _sfpPla_arr :: Bool
_sfpPla_arr = Bool
True}),
      (ByteString
"past", SystemFunction
SFSVPast),
      (ByteString
"stable", SystemFunction
SFSVStable),
      (ByteString
"rose", SystemFunction
SFSVRose),
      (ByteString
"fell", SystemFunction
SFSVFell)
    ]