-- Module      : Verismith.Verilog2005.Utils
-- Description : AST utilitary functions.
-- Copyright   : (c) 2023 Quentin Corradi
-- License     : GPL-3
-- Maintainer  : q [dot] corradi22 [at] imperial [dot] ac [dot] uk
-- Stability   : experimental
-- Portability : POSIX

{-# LANGUAGE OverloadedLists #-}

module Verismith.Verilog2005.Utils
  ( makeIdent,
    regroup,
    addAttributed,
    genexprnumber,
    constifyIdent,
    constifyMaybeRange,
    trConstifyGenExpr,
    constifyExpr,
    constifyLV,
    expr2netlv,
    netlv2expr,
    toStatement,
    fromStatement,
    fromMybStmt,
    toMGIBlockDecl,
    fromMGIBlockDecl1,
    fromMGIBlockDecl_add,
    toStdBlockDecl,
    toSpecBlockedItem,
    fromSpecBlockedItem,
    toMGBlockedItem,
    fromMGBlockedItem1,
    fromMGBlockedItem_add,
    fromMGBlockedItem,
  )
where

import Numeric.Natural
import Text.Printf (printf)
import Data.Functor.Compose
import Data.Functor.Identity
import qualified Data.ByteString as BS
import Data.ByteString.Internal (c2w, packChars)
import qualified Data.HashSet as HS
import Data.List.NonEmpty (NonEmpty (..), (<|), toList)
import qualified Data.List.NonEmpty as NE
import Verismith.Verilog2005.Lexer (VerilogVersion (..), isIdentSimple)
import Verismith.Verilog2005.AST
import Verismith.Utils (nonEmpty, foldrMap1)

-- AST utils

makeIdent :: BS.ByteString -> Identifier
makeIdent :: ByteString -> Identifier
makeIdent =
  ByteString -> Identifier
Identifier (ByteString -> Identifier)
-> (ByteString -> ByteString) -> ByteString -> Identifier
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Word8 -> ByteString) -> ByteString -> ByteString
BS.concatMap
    (\Word8
w -> if Word8
33 Word8 -> Word8 -> Bool
forall a. Ord a => a -> a -> Bool
<= Word8
w Bool -> Bool -> Bool
&& Word8
w Word8 -> Word8 -> Bool
forall a. Ord a => a -> a -> Bool
<= Word8
126 then [Word8] -> ByteString
BS.pack [Word8
Item [Word8]
w] else [Char] -> ByteString
packChars ([Char] -> ByteString) -> [Char] -> ByteString
forall a b. (a -> b) -> a -> b
$ [Char] -> Word8 -> [Char]
forall r. PrintfType r => [Char] -> r
printf [Char]
"\\%02x" Word8
w)

-- | Groups `x`s into `y`s by converting a single `x` and merging previous `x`s to the result
regroup :: (x -> y) -> (x -> y -> Maybe y) -> NonEmpty x -> NonEmpty y
regroup :: forall x y.
(x -> y) -> (x -> y -> Maybe y) -> NonEmpty x -> NonEmpty y
regroup x -> y
mk x -> y -> Maybe y
add = (x -> NonEmpty y)
-> (x -> NonEmpty y -> NonEmpty y) -> NonEmpty x -> NonEmpty y
forall a b. (a -> b) -> (a -> b -> b) -> NonEmpty a -> b
foldrMap1 ((y -> [y] -> NonEmpty y
forall a. a -> [a] -> NonEmpty a
:|[]) (y -> NonEmpty y) -> (x -> y) -> x -> NonEmpty y
forall b c a. (b -> c) -> (a -> b) -> a -> c
. x -> y
mk) (\x
e (y
h :| [y]
t) -> NonEmpty y -> (y -> NonEmpty y) -> Maybe y -> NonEmpty y
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (x -> y
mk x
e y -> [y] -> NonEmpty y
forall a. a -> [a] -> NonEmpty a
:| y
h y -> [y] -> [y]
forall a. a -> [a] -> [a]
: [y]
t) (y -> [y] -> NonEmpty y
forall a. a -> [a] -> NonEmpty a
:| [y]
t) (Maybe y -> NonEmpty y) -> Maybe y -> NonEmpty y
forall a b. (a -> b) -> a -> b
$ x -> y -> Maybe y
add x
e y
h)

-- | Merges `Attributed x`s if we can merge `x`s
addAttributed :: (x -> y -> Maybe y) -> Attributed x -> Attributed y -> Maybe (Attributed y)
addAttributed :: forall x y.
(x -> y -> Maybe y)
-> Attributed x -> Attributed y -> Maybe (Attributed y)
addAttributed x -> y -> Maybe y
f (Attributed Attributes
na x
x) (Attributed Attributes
a y
y) =
  if Attributes
a Attributes -> Attributes -> Bool
forall a. Eq a => a -> a -> Bool
/= Attributes
na then Maybe (Attributed y)
forall a. Maybe a
Nothing else Attributes -> y -> Attributed y
forall t. Attributes -> t -> Attributed t
Attributed Attributes
a (y -> Attributed y) -> Maybe y -> Maybe (Attributed y)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> x -> y -> Maybe y
f x
x y
y

-- | Makes a Verilog2005 expression out of a number
genexprnumber :: Natural -> GenExpr i r a
genexprnumber :: forall i r a. Natural -> GenExpr i r a
genexprnumber = GenPrim i r a -> GenExpr i r a
forall i r a. GenPrim i r a -> GenExpr i r a
ExprPrim (GenPrim i r a -> GenExpr i r a)
-> (Natural -> GenPrim i r a) -> Natural -> GenExpr i r a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Maybe Natural -> Bool -> Number -> GenPrim i r a
forall i r a. Maybe Natural -> Bool -> Number -> GenPrim i r a
PrimNumber Maybe Natural
forall a. Maybe a
Nothing Bool
False (Number -> GenPrim i r a)
-> (Natural -> Number) -> Natural -> GenPrim i r a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Natural -> Number
NDecimal

-- | converts HierIdent into Identifier
constifyIdent :: HierIdent -> Maybe Identifier
constifyIdent :: HierIdent -> Maybe Identifier
constifyIdent (HierIdent [(Identifier, Maybe CExpr)]
p Identifier
i) = case [(Identifier, Maybe CExpr)]
p of [] -> Identifier -> Maybe Identifier
forall a. a -> Maybe a
Just Identifier
i; [(Identifier, Maybe CExpr)]
_ -> Maybe Identifier
forall a. Maybe a
Nothing

-- | the other way
unconstIdent :: Identifier -> HierIdent
unconstIdent :: Identifier -> HierIdent
unconstIdent = [(Identifier, Maybe CExpr)] -> Identifier -> HierIdent
HierIdent []

-- | converts Prim into GenPrim i r
constifyGenPrim ::
  (si -> Maybe di) ->
  (Maybe DimRange -> Maybe r) ->
  GenPrim si (Maybe DimRange) a ->
  Maybe (GenPrim di r a)
constifyGenPrim :: forall si di r a.
(si -> Maybe di)
-> (Maybe DimRange -> Maybe r)
-> GenPrim si (Maybe DimRange) a
-> Maybe (GenPrim di r a)
constifyGenPrim si -> Maybe di
fi Maybe DimRange -> Maybe r
fr GenPrim si (Maybe DimRange) a
x = case GenPrim si (Maybe DimRange) a
x of
  PrimNumber Maybe Natural
s Bool
b Number
n -> GenPrim di r a -> Maybe (GenPrim di r a)
forall a. a -> Maybe a
Just (GenPrim di r a -> Maybe (GenPrim di r a))
-> GenPrim di r a -> Maybe (GenPrim di r a)
forall a b. (a -> b) -> a -> b
$ Maybe Natural -> Bool -> Number -> GenPrim di r a
forall i r a. Maybe Natural -> Bool -> Number -> GenPrim i r a
PrimNumber Maybe Natural
s Bool
b Number
n
  PrimReal ByteString
s -> GenPrim di r a -> Maybe (GenPrim di r a)
forall a. a -> Maybe a
Just (GenPrim di r a -> Maybe (GenPrim di r a))
-> GenPrim di r a -> Maybe (GenPrim di r a)
forall a b. (a -> b) -> a -> b
$ ByteString -> GenPrim di r a
forall i r a. ByteString -> GenPrim i r a
PrimReal ByteString
s
  PrimIdent si
s Maybe DimRange
rng -> di -> r -> GenPrim di r a
forall i r a. i -> r -> GenPrim i r a
PrimIdent (di -> r -> GenPrim di r a)
-> Maybe di -> Maybe (r -> GenPrim di r a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> si -> Maybe di
fi si
s Maybe (r -> GenPrim di r a) -> Maybe r -> Maybe (GenPrim di r a)
forall a b. Maybe (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Maybe DimRange -> Maybe r
fr Maybe DimRange
rng
  PrimConcat NonEmpty (GenExpr si (Maybe DimRange) a)
e -> NonEmpty (GenExpr di r a) -> GenPrim di r a
forall i r a. NonEmpty (GenExpr i r a) -> GenPrim i r a
PrimConcat (NonEmpty (GenExpr di r a) -> GenPrim di r a)
-> Maybe (NonEmpty (GenExpr di r a)) -> Maybe (GenPrim di r a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (GenExpr si (Maybe DimRange) a -> Maybe (GenExpr di r a))
-> NonEmpty (GenExpr si (Maybe DimRange) a)
-> Maybe (NonEmpty (GenExpr di r a))
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> NonEmpty a -> m (NonEmpty b)
mapM GenExpr si (Maybe DimRange) a -> Maybe (GenExpr di r a)
forall {a}. GenExpr si (Maybe DimRange) a -> Maybe (GenExpr di r a)
ce NonEmpty (GenExpr si (Maybe DimRange) a)
e
  PrimMultConcat GenExpr Identifier (Maybe CRangeExpr) a
m NonEmpty (GenExpr si (Maybe DimRange) a)
e -> GenExpr Identifier (Maybe CRangeExpr) a
-> NonEmpty (GenExpr di r a) -> GenPrim di r a
forall i r a.
GenExpr Identifier (Maybe CRangeExpr) a
-> NonEmpty (GenExpr i r a) -> GenPrim i r a
PrimMultConcat GenExpr Identifier (Maybe CRangeExpr) a
m (NonEmpty (GenExpr di r a) -> GenPrim di r a)
-> Maybe (NonEmpty (GenExpr di r a)) -> Maybe (GenPrim di r a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (GenExpr si (Maybe DimRange) a -> Maybe (GenExpr di r a))
-> NonEmpty (GenExpr si (Maybe DimRange) a)
-> Maybe (NonEmpty (GenExpr di r a))
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> NonEmpty a -> m (NonEmpty b)
mapM GenExpr si (Maybe DimRange) a -> Maybe (GenExpr di r a)
forall {a}. GenExpr si (Maybe DimRange) a -> Maybe (GenExpr di r a)
ce NonEmpty (GenExpr si (Maybe DimRange) a)
e
  PrimFun si
s a
a [GenExpr si (Maybe DimRange) a]
e -> di -> a -> [GenExpr di r a] -> GenPrim di r a
forall i r a. i -> a -> [GenExpr i r a] -> GenPrim i r a
PrimFun (di -> a -> [GenExpr di r a] -> GenPrim di r a)
-> Maybe di -> Maybe (a -> [GenExpr di r a] -> GenPrim di r a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> si -> Maybe di
fi si
s Maybe (a -> [GenExpr di r a] -> GenPrim di r a)
-> Maybe a -> Maybe ([GenExpr di r a] -> GenPrim di r a)
forall a b. Maybe (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> a -> Maybe a
forall a. a -> Maybe a
forall (f :: * -> *) a. Applicative f => a -> f a
pure a
a Maybe ([GenExpr di r a] -> GenPrim di r a)
-> Maybe [GenExpr di r a] -> Maybe (GenPrim di r a)
forall a b. Maybe (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (GenExpr si (Maybe DimRange) a -> Maybe (GenExpr di r a))
-> [GenExpr si (Maybe DimRange) a] -> Maybe [GenExpr di r a]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM GenExpr si (Maybe DimRange) a -> Maybe (GenExpr di r a)
forall {a}. GenExpr si (Maybe DimRange) a -> Maybe (GenExpr di r a)
ce [GenExpr si (Maybe DimRange) a]
e
  PrimSysFun ByteString
s [GenExpr si (Maybe DimRange) a]
e -> ByteString -> [GenExpr di r a] -> GenPrim di r a
forall i r a. ByteString -> [GenExpr i r a] -> GenPrim i r a
PrimSysFun ByteString
s ([GenExpr di r a] -> GenPrim di r a)
-> Maybe [GenExpr di r a] -> Maybe (GenPrim di r a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (GenExpr si (Maybe DimRange) a -> Maybe (GenExpr di r a))
-> [GenExpr si (Maybe DimRange) a] -> Maybe [GenExpr di r a]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM GenExpr si (Maybe DimRange) a -> Maybe (GenExpr di r a)
forall {a}. GenExpr si (Maybe DimRange) a -> Maybe (GenExpr di r a)
ce [GenExpr si (Maybe DimRange) a]
e
  PrimMinTypMax (MTMSingle GenExpr si (Maybe DimRange) a
e) -> GenMinTypMax (GenExpr di r a) -> GenPrim di r a
forall i r a. GenMinTypMax (GenExpr i r a) -> GenPrim i r a
PrimMinTypMax (GenMinTypMax (GenExpr di r a) -> GenPrim di r a)
-> (GenExpr di r a -> GenMinTypMax (GenExpr di r a))
-> GenExpr di r a
-> GenPrim di r a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. GenExpr di r a -> GenMinTypMax (GenExpr di r a)
forall et. et -> GenMinTypMax et
MTMSingle (GenExpr di r a -> GenPrim di r a)
-> Maybe (GenExpr di r a) -> Maybe (GenPrim di r a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> GenExpr si (Maybe DimRange) a -> Maybe (GenExpr di r a)
forall {a}. GenExpr si (Maybe DimRange) a -> Maybe (GenExpr di r a)
ce GenExpr si (Maybe DimRange) a
e
  PrimMinTypMax (MTMFull GenExpr si (Maybe DimRange) a
l GenExpr si (Maybe DimRange) a
t GenExpr si (Maybe DimRange) a
h) -> GenMinTypMax (GenExpr di r a) -> GenPrim di r a
forall i r a. GenMinTypMax (GenExpr i r a) -> GenPrim i r a
PrimMinTypMax (GenMinTypMax (GenExpr di r a) -> GenPrim di r a)
-> Maybe (GenMinTypMax (GenExpr di r a)) -> Maybe (GenPrim di r a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (GenExpr di r a
-> GenExpr di r a
-> GenExpr di r a
-> GenMinTypMax (GenExpr di r a)
forall et. et -> et -> et -> GenMinTypMax et
MTMFull (GenExpr di r a
 -> GenExpr di r a
 -> GenExpr di r a
 -> GenMinTypMax (GenExpr di r a))
-> Maybe (GenExpr di r a)
-> Maybe
     (GenExpr di r a -> GenExpr di r a -> GenMinTypMax (GenExpr di r a))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> GenExpr si (Maybe DimRange) a -> Maybe (GenExpr di r a)
forall {a}. GenExpr si (Maybe DimRange) a -> Maybe (GenExpr di r a)
ce GenExpr si (Maybe DimRange) a
l Maybe
  (GenExpr di r a -> GenExpr di r a -> GenMinTypMax (GenExpr di r a))
-> Maybe (GenExpr di r a)
-> Maybe (GenExpr di r a -> GenMinTypMax (GenExpr di r a))
forall a b. Maybe (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> GenExpr si (Maybe DimRange) a -> Maybe (GenExpr di r a)
forall {a}. GenExpr si (Maybe DimRange) a -> Maybe (GenExpr di r a)
ce GenExpr si (Maybe DimRange) a
t Maybe (GenExpr di r a -> GenMinTypMax (GenExpr di r a))
-> Maybe (GenExpr di r a) -> Maybe (GenMinTypMax (GenExpr di r a))
forall a b. Maybe (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> GenExpr si (Maybe DimRange) a -> Maybe (GenExpr di r a)
forall {a}. GenExpr si (Maybe DimRange) a -> Maybe (GenExpr di r a)
ce GenExpr si (Maybe DimRange) a
h)
  PrimString ByteString
s -> GenPrim di r a -> Maybe (GenPrim di r a)
forall a. a -> Maybe a
Just (GenPrim di r a -> Maybe (GenPrim di r a))
-> GenPrim di r a -> Maybe (GenPrim di r a)
forall a b. (a -> b) -> a -> b
$ ByteString -> GenPrim di r a
forall i r a. ByteString -> GenPrim i r a
PrimString ByteString
s
  where
    ce :: GenExpr si (Maybe DimRange) a -> Maybe (GenExpr di r a)
ce = (si -> Maybe di)
-> (Maybe DimRange -> Maybe r)
-> GenExpr si (Maybe DimRange) a
-> Maybe (GenExpr di r a)
forall si di r a.
(si -> Maybe di)
-> (Maybe DimRange -> Maybe r)
-> GenExpr si (Maybe DimRange) a
-> Maybe (GenExpr di r a)
trConstifyGenExpr si -> Maybe di
fi Maybe DimRange -> Maybe r
fr

-- | the other way
unconstPrim :: GenPrim Identifier (Maybe CRangeExpr) a -> GenPrim HierIdent (Maybe DimRange) a
unconstPrim :: forall a.
GenPrim Identifier (Maybe CRangeExpr) a
-> GenPrim HierIdent (Maybe DimRange) a
unconstPrim GenPrim Identifier (Maybe CRangeExpr) a
x = case GenPrim Identifier (Maybe CRangeExpr) a
x of
  PrimNumber Maybe Natural
s Bool
b Number
n -> Maybe Natural
-> Bool -> Number -> GenPrim HierIdent (Maybe DimRange) a
forall i r a. Maybe Natural -> Bool -> Number -> GenPrim i r a
PrimNumber Maybe Natural
s Bool
b Number
n
  PrimReal ByteString
s -> ByteString -> GenPrim HierIdent (Maybe DimRange) a
forall i r a. ByteString -> GenPrim i r a
PrimReal ByteString
s
  PrimIdent Identifier
s Maybe CRangeExpr
rng -> HierIdent -> Maybe DimRange -> GenPrim HierIdent (Maybe DimRange) a
forall i r a. i -> r -> GenPrim i r a
PrimIdent (Identifier -> HierIdent
unconstIdent Identifier
s) ([Expr] -> GenRangeExpr Expr -> DimRange
forall e. [e] -> GenRangeExpr e -> GenDimRange e
GenDimRange [] (GenRangeExpr Expr -> DimRange)
-> (CRangeExpr -> GenRangeExpr Expr) -> CRangeExpr -> DimRange
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CRangeExpr -> GenRangeExpr Expr
unconstRange (CRangeExpr -> DimRange) -> Maybe CRangeExpr -> Maybe DimRange
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe CRangeExpr
rng)
  PrimConcat NonEmpty (GenExpr Identifier (Maybe CRangeExpr) a)
e -> NonEmpty (GenExpr HierIdent (Maybe DimRange) a)
-> GenPrim HierIdent (Maybe DimRange) a
forall i r a. NonEmpty (GenExpr i r a) -> GenPrim i r a
PrimConcat ((GenExpr Identifier (Maybe CRangeExpr) a
 -> GenExpr HierIdent (Maybe DimRange) a)
-> NonEmpty (GenExpr Identifier (Maybe CRangeExpr) a)
-> NonEmpty (GenExpr HierIdent (Maybe DimRange) a)
forall a b. (a -> b) -> NonEmpty a -> NonEmpty b
NE.map GenExpr Identifier (Maybe CRangeExpr) a
-> GenExpr HierIdent (Maybe DimRange) a
forall a.
GenExpr Identifier (Maybe CRangeExpr) a
-> GenExpr HierIdent (Maybe DimRange) a
trUnconstExpr NonEmpty (GenExpr Identifier (Maybe CRangeExpr) a)
e)
  PrimMultConcat GenExpr Identifier (Maybe CRangeExpr) a
m NonEmpty (GenExpr Identifier (Maybe CRangeExpr) a)
e -> GenExpr Identifier (Maybe CRangeExpr) a
-> NonEmpty (GenExpr HierIdent (Maybe DimRange) a)
-> GenPrim HierIdent (Maybe DimRange) a
forall i r a.
GenExpr Identifier (Maybe CRangeExpr) a
-> NonEmpty (GenExpr i r a) -> GenPrim i r a
PrimMultConcat GenExpr Identifier (Maybe CRangeExpr) a
m ((GenExpr Identifier (Maybe CRangeExpr) a
 -> GenExpr HierIdent (Maybe DimRange) a)
-> NonEmpty (GenExpr Identifier (Maybe CRangeExpr) a)
-> NonEmpty (GenExpr HierIdent (Maybe DimRange) a)
forall a b. (a -> b) -> NonEmpty a -> NonEmpty b
NE.map GenExpr Identifier (Maybe CRangeExpr) a
-> GenExpr HierIdent (Maybe DimRange) a
forall a.
GenExpr Identifier (Maybe CRangeExpr) a
-> GenExpr HierIdent (Maybe DimRange) a
trUnconstExpr NonEmpty (GenExpr Identifier (Maybe CRangeExpr) a)
e)
  PrimFun Identifier
s a
a [GenExpr Identifier (Maybe CRangeExpr) a]
e -> HierIdent
-> a
-> [GenExpr HierIdent (Maybe DimRange) a]
-> GenPrim HierIdent (Maybe DimRange) a
forall i r a. i -> a -> [GenExpr i r a] -> GenPrim i r a
PrimFun (Identifier -> HierIdent
unconstIdent Identifier
s) a
a ((GenExpr Identifier (Maybe CRangeExpr) a
 -> GenExpr HierIdent (Maybe DimRange) a)
-> [GenExpr Identifier (Maybe CRangeExpr) a]
-> [GenExpr HierIdent (Maybe DimRange) a]
forall a b. (a -> b) -> [a] -> [b]
map GenExpr Identifier (Maybe CRangeExpr) a
-> GenExpr HierIdent (Maybe DimRange) a
forall a.
GenExpr Identifier (Maybe CRangeExpr) a
-> GenExpr HierIdent (Maybe DimRange) a
trUnconstExpr [GenExpr Identifier (Maybe CRangeExpr) a]
e)
  PrimSysFun ByteString
s [GenExpr Identifier (Maybe CRangeExpr) a]
e -> ByteString
-> [GenExpr HierIdent (Maybe DimRange) a]
-> GenPrim HierIdent (Maybe DimRange) a
forall i r a. ByteString -> [GenExpr i r a] -> GenPrim i r a
PrimSysFun ByteString
s ((GenExpr Identifier (Maybe CRangeExpr) a
 -> GenExpr HierIdent (Maybe DimRange) a)
-> [GenExpr Identifier (Maybe CRangeExpr) a]
-> [GenExpr HierIdent (Maybe DimRange) a]
forall a b. (a -> b) -> [a] -> [b]
map GenExpr Identifier (Maybe CRangeExpr) a
-> GenExpr HierIdent (Maybe DimRange) a
forall a.
GenExpr Identifier (Maybe CRangeExpr) a
-> GenExpr HierIdent (Maybe DimRange) a
trUnconstExpr [GenExpr Identifier (Maybe CRangeExpr) a]
e)
  PrimMinTypMax (MTMSingle GenExpr Identifier (Maybe CRangeExpr) a
e) -> GenMinTypMax (GenExpr HierIdent (Maybe DimRange) a)
-> GenPrim HierIdent (Maybe DimRange) a
forall i r a. GenMinTypMax (GenExpr i r a) -> GenPrim i r a
PrimMinTypMax (GenExpr HierIdent (Maybe DimRange) a
-> GenMinTypMax (GenExpr HierIdent (Maybe DimRange) a)
forall et. et -> GenMinTypMax et
MTMSingle (GenExpr Identifier (Maybe CRangeExpr) a
-> GenExpr HierIdent (Maybe DimRange) a
forall a.
GenExpr Identifier (Maybe CRangeExpr) a
-> GenExpr HierIdent (Maybe DimRange) a
trUnconstExpr GenExpr Identifier (Maybe CRangeExpr) a
e))
  PrimMinTypMax (MTMFull GenExpr Identifier (Maybe CRangeExpr) a
l GenExpr Identifier (Maybe CRangeExpr) a
t GenExpr Identifier (Maybe CRangeExpr) a
h) ->
    GenMinTypMax (GenExpr HierIdent (Maybe DimRange) a)
-> GenPrim HierIdent (Maybe DimRange) a
forall i r a. GenMinTypMax (GenExpr i r a) -> GenPrim i r a
PrimMinTypMax (GenMinTypMax (GenExpr HierIdent (Maybe DimRange) a)
 -> GenPrim HierIdent (Maybe DimRange) a)
-> GenMinTypMax (GenExpr HierIdent (Maybe DimRange) a)
-> GenPrim HierIdent (Maybe DimRange) a
forall a b. (a -> b) -> a -> b
$ GenExpr HierIdent (Maybe DimRange) a
-> GenExpr HierIdent (Maybe DimRange) a
-> GenExpr HierIdent (Maybe DimRange) a
-> GenMinTypMax (GenExpr HierIdent (Maybe DimRange) a)
forall et. et -> et -> et -> GenMinTypMax et
MTMFull (GenExpr Identifier (Maybe CRangeExpr) a
-> GenExpr HierIdent (Maybe DimRange) a
forall a.
GenExpr Identifier (Maybe CRangeExpr) a
-> GenExpr HierIdent (Maybe DimRange) a
trUnconstExpr GenExpr Identifier (Maybe CRangeExpr) a
l) (GenExpr Identifier (Maybe CRangeExpr) a
-> GenExpr HierIdent (Maybe DimRange) a
forall a.
GenExpr Identifier (Maybe CRangeExpr) a
-> GenExpr HierIdent (Maybe DimRange) a
trUnconstExpr GenExpr Identifier (Maybe CRangeExpr) a
t) (GenExpr Identifier (Maybe CRangeExpr) a
-> GenExpr HierIdent (Maybe DimRange) a
forall a.
GenExpr Identifier (Maybe CRangeExpr) a
-> GenExpr HierIdent (Maybe DimRange) a
trUnconstExpr GenExpr Identifier (Maybe CRangeExpr) a
h)
  PrimString ByteString
s -> ByteString -> GenPrim HierIdent (Maybe DimRange) a
forall i r a. ByteString -> GenPrim i r a
PrimString ByteString
s

-- | converts `GenExpr si (MaybeDimRange) a` into `GenExpr i r a`
trConstifyGenExpr ::
  (si -> Maybe di) ->
  (Maybe DimRange -> Maybe r) ->
  GenExpr si (Maybe DimRange) a ->
  Maybe (GenExpr di r a)
trConstifyGenExpr :: forall si di r a.
(si -> Maybe di)
-> (Maybe DimRange -> Maybe r)
-> GenExpr si (Maybe DimRange) a
-> Maybe (GenExpr di r a)
trConstifyGenExpr si -> Maybe di
fi Maybe DimRange -> Maybe r
fr GenExpr si (Maybe DimRange) a
x = case GenExpr si (Maybe DimRange) a
x of
  ExprPrim GenPrim si (Maybe DimRange) a
p -> GenPrim di r a -> GenExpr di r a
forall i r a. GenPrim i r a -> GenExpr i r a
ExprPrim (GenPrim di r a -> GenExpr di r a)
-> Maybe (GenPrim di r a) -> Maybe (GenExpr di r a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (si -> Maybe di)
-> (Maybe DimRange -> Maybe r)
-> GenPrim si (Maybe DimRange) a
-> Maybe (GenPrim di r a)
forall si di r a.
(si -> Maybe di)
-> (Maybe DimRange -> Maybe r)
-> GenPrim si (Maybe DimRange) a
-> Maybe (GenPrim di r a)
constifyGenPrim si -> Maybe di
fi Maybe DimRange -> Maybe r
fr GenPrim si (Maybe DimRange) a
p
  ExprUnOp UnaryOperator
op a
a GenPrim si (Maybe DimRange) a
p -> UnaryOperator -> a -> GenPrim di r a -> GenExpr di r a
forall i r a. UnaryOperator -> a -> GenPrim i r a -> GenExpr i r a
ExprUnOp UnaryOperator
op a
a (GenPrim di r a -> GenExpr di r a)
-> Maybe (GenPrim di r a) -> Maybe (GenExpr di r a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (si -> Maybe di)
-> (Maybe DimRange -> Maybe r)
-> GenPrim si (Maybe DimRange) a
-> Maybe (GenPrim di r a)
forall si di r a.
(si -> Maybe di)
-> (Maybe DimRange -> Maybe r)
-> GenPrim si (Maybe DimRange) a
-> Maybe (GenPrim di r a)
constifyGenPrim si -> Maybe di
fi Maybe DimRange -> Maybe r
fr GenPrim si (Maybe DimRange) a
p
  ExprBinOp GenExpr si (Maybe DimRange) a
lhs BinaryOperator
op a
a GenExpr si (Maybe DimRange) a
rhs -> GenExpr di r a
-> BinaryOperator -> a -> GenExpr di r a -> GenExpr di r a
forall i r a.
GenExpr i r a
-> BinaryOperator -> a -> GenExpr i r a -> GenExpr i r a
ExprBinOp (GenExpr di r a
 -> BinaryOperator -> a -> GenExpr di r a -> GenExpr di r a)
-> Maybe (GenExpr di r a)
-> Maybe (BinaryOperator -> a -> GenExpr di r a -> GenExpr di r a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> GenExpr si (Maybe DimRange) a -> Maybe (GenExpr di r a)
forall {a}. GenExpr si (Maybe DimRange) a -> Maybe (GenExpr di r a)
ce GenExpr si (Maybe DimRange) a
lhs Maybe (BinaryOperator -> a -> GenExpr di r a -> GenExpr di r a)
-> Maybe BinaryOperator
-> Maybe (a -> GenExpr di r a -> GenExpr di r a)
forall a b. Maybe (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> BinaryOperator -> Maybe BinaryOperator
forall a. a -> Maybe a
forall (f :: * -> *) a. Applicative f => a -> f a
pure BinaryOperator
op Maybe (a -> GenExpr di r a -> GenExpr di r a)
-> Maybe a -> Maybe (GenExpr di r a -> GenExpr di r a)
forall a b. Maybe (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> a -> Maybe a
forall a. a -> Maybe a
forall (f :: * -> *) a. Applicative f => a -> f a
pure a
a Maybe (GenExpr di r a -> GenExpr di r a)
-> Maybe (GenExpr di r a) -> Maybe (GenExpr di r a)
forall a b. Maybe (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> GenExpr si (Maybe DimRange) a -> Maybe (GenExpr di r a)
forall {a}. GenExpr si (Maybe DimRange) a -> Maybe (GenExpr di r a)
ce GenExpr si (Maybe DimRange) a
rhs
  ExprCond GenExpr si (Maybe DimRange) a
c a
a GenExpr si (Maybe DimRange) a
t GenExpr si (Maybe DimRange) a
f -> GenExpr di r a
-> a -> GenExpr di r a -> GenExpr di r a -> GenExpr di r a
forall i r a.
GenExpr i r a
-> a -> GenExpr i r a -> GenExpr i r a -> GenExpr i r a
ExprCond (GenExpr di r a
 -> a -> GenExpr di r a -> GenExpr di r a -> GenExpr di r a)
-> Maybe (GenExpr di r a)
-> Maybe (a -> GenExpr di r a -> GenExpr di r a -> GenExpr di r a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> GenExpr si (Maybe DimRange) a -> Maybe (GenExpr di r a)
forall {a}. GenExpr si (Maybe DimRange) a -> Maybe (GenExpr di r a)
ce GenExpr si (Maybe DimRange) a
c Maybe (a -> GenExpr di r a -> GenExpr di r a -> GenExpr di r a)
-> Maybe a
-> Maybe (GenExpr di r a -> GenExpr di r a -> GenExpr di r a)
forall a b. Maybe (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> a -> Maybe a
forall a. a -> Maybe a
forall (f :: * -> *) a. Applicative f => a -> f a
pure a
a Maybe (GenExpr di r a -> GenExpr di r a -> GenExpr di r a)
-> Maybe (GenExpr di r a)
-> Maybe (GenExpr di r a -> GenExpr di r a)
forall a b. Maybe (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> GenExpr si (Maybe DimRange) a -> Maybe (GenExpr di r a)
forall {a}. GenExpr si (Maybe DimRange) a -> Maybe (GenExpr di r a)
ce GenExpr si (Maybe DimRange) a
t Maybe (GenExpr di r a -> GenExpr di r a)
-> Maybe (GenExpr di r a) -> Maybe (GenExpr di r a)
forall a b. Maybe (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> GenExpr si (Maybe DimRange) a -> Maybe (GenExpr di r a)
forall {a}. GenExpr si (Maybe DimRange) a -> Maybe (GenExpr di r a)
ce GenExpr si (Maybe DimRange) a
f
  where
    ce :: GenExpr si (Maybe DimRange) a -> Maybe (GenExpr di r a)
ce = (si -> Maybe di)
-> (Maybe DimRange -> Maybe r)
-> GenExpr si (Maybe DimRange) a
-> Maybe (GenExpr di r a)
forall si di r a.
(si -> Maybe di)
-> (Maybe DimRange -> Maybe r)
-> GenExpr si (Maybe DimRange) a
-> Maybe (GenExpr di r a)
trConstifyGenExpr si -> Maybe di
fi Maybe DimRange -> Maybe r
fr

-- | converts Expr's `DimRange` into CExpr's `CRangeExpr`
constifyMaybeRange :: Maybe DimRange -> Maybe (Maybe CRangeExpr)
constifyMaybeRange :: Maybe DimRange -> Maybe (Maybe CRangeExpr)
constifyMaybeRange =
  Maybe (Maybe CRangeExpr)
-> (DimRange -> Maybe (Maybe CRangeExpr))
-> Maybe DimRange
-> Maybe (Maybe CRangeExpr)
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (Maybe CRangeExpr -> Maybe (Maybe CRangeExpr)
forall a. a -> Maybe a
Just Maybe CRangeExpr
forall a. Maybe a
Nothing) ((DimRange -> Maybe (Maybe CRangeExpr))
 -> Maybe DimRange -> Maybe (Maybe CRangeExpr))
-> (DimRange -> Maybe (Maybe CRangeExpr))
-> Maybe DimRange
-> Maybe (Maybe CRangeExpr)
forall a b. (a -> b) -> a -> b
$ \(GenDimRange [Expr]
l GenRangeExpr Expr
r) -> if [Expr] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [Expr]
l then CRangeExpr -> Maybe CRangeExpr
forall a. a -> Maybe a
Just (CRangeExpr -> Maybe CRangeExpr)
-> Maybe CRangeExpr -> Maybe (Maybe CRangeExpr)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> GenRangeExpr Expr -> Maybe CRangeExpr
constifyRange GenRangeExpr Expr
r else Maybe (Maybe CRangeExpr)
forall a. Maybe a
Nothing

-- | converts Expr's `GenExpr` into CExpr `GenExpr`
trConstifyExpr ::
  GenExpr HierIdent (Maybe DimRange) a -> Maybe (GenExpr Identifier (Maybe CRangeExpr) a)
trConstifyExpr :: forall a.
GenExpr HierIdent (Maybe DimRange) a
-> Maybe (GenExpr Identifier (Maybe CRangeExpr) a)
trConstifyExpr = (HierIdent -> Maybe Identifier)
-> (Maybe DimRange -> Maybe (Maybe CRangeExpr))
-> GenExpr HierIdent (Maybe DimRange) a
-> Maybe (GenExpr Identifier (Maybe CRangeExpr) a)
forall si di r a.
(si -> Maybe di)
-> (Maybe DimRange -> Maybe r)
-> GenExpr si (Maybe DimRange) a
-> Maybe (GenExpr di r a)
trConstifyGenExpr HierIdent -> Maybe Identifier
constifyIdent Maybe DimRange -> Maybe (Maybe CRangeExpr)
constifyMaybeRange

-- | the other way
trUnconstExpr :: GenExpr Identifier (Maybe CRangeExpr) a -> GenExpr HierIdent (Maybe DimRange) a
trUnconstExpr :: forall a.
GenExpr Identifier (Maybe CRangeExpr) a
-> GenExpr HierIdent (Maybe DimRange) a
trUnconstExpr GenExpr Identifier (Maybe CRangeExpr) a
x = case GenExpr Identifier (Maybe CRangeExpr) a
x of
  ExprPrim GenPrim Identifier (Maybe CRangeExpr) a
p -> GenPrim HierIdent (Maybe DimRange) a
-> GenExpr HierIdent (Maybe DimRange) a
forall i r a. GenPrim i r a -> GenExpr i r a
ExprPrim (GenPrim Identifier (Maybe CRangeExpr) a
-> GenPrim HierIdent (Maybe DimRange) a
forall a.
GenPrim Identifier (Maybe CRangeExpr) a
-> GenPrim HierIdent (Maybe DimRange) a
unconstPrim GenPrim Identifier (Maybe CRangeExpr) a
p)
  ExprUnOp UnaryOperator
op a
a GenPrim Identifier (Maybe CRangeExpr) a
p -> UnaryOperator
-> a
-> GenPrim HierIdent (Maybe DimRange) a
-> GenExpr HierIdent (Maybe DimRange) a
forall i r a. UnaryOperator -> a -> GenPrim i r a -> GenExpr i r a
ExprUnOp UnaryOperator
op a
a (GenPrim Identifier (Maybe CRangeExpr) a
-> GenPrim HierIdent (Maybe DimRange) a
forall a.
GenPrim Identifier (Maybe CRangeExpr) a
-> GenPrim HierIdent (Maybe DimRange) a
unconstPrim GenPrim Identifier (Maybe CRangeExpr) a
p)
  ExprBinOp GenExpr Identifier (Maybe CRangeExpr) a
lhs BinaryOperator
op a
a GenExpr Identifier (Maybe CRangeExpr) a
rhs -> GenExpr HierIdent (Maybe DimRange) a
-> BinaryOperator
-> a
-> GenExpr HierIdent (Maybe DimRange) a
-> GenExpr HierIdent (Maybe DimRange) a
forall i r a.
GenExpr i r a
-> BinaryOperator -> a -> GenExpr i r a -> GenExpr i r a
ExprBinOp (GenExpr Identifier (Maybe CRangeExpr) a
-> GenExpr HierIdent (Maybe DimRange) a
forall a.
GenExpr Identifier (Maybe CRangeExpr) a
-> GenExpr HierIdent (Maybe DimRange) a
trUnconstExpr GenExpr Identifier (Maybe CRangeExpr) a
lhs) BinaryOperator
op a
a (GenExpr Identifier (Maybe CRangeExpr) a
-> GenExpr HierIdent (Maybe DimRange) a
forall a.
GenExpr Identifier (Maybe CRangeExpr) a
-> GenExpr HierIdent (Maybe DimRange) a
trUnconstExpr GenExpr Identifier (Maybe CRangeExpr) a
rhs)
  ExprCond GenExpr Identifier (Maybe CRangeExpr) a
c a
a GenExpr Identifier (Maybe CRangeExpr) a
t GenExpr Identifier (Maybe CRangeExpr) a
f -> GenExpr HierIdent (Maybe DimRange) a
-> a
-> GenExpr HierIdent (Maybe DimRange) a
-> GenExpr HierIdent (Maybe DimRange) a
-> GenExpr HierIdent (Maybe DimRange) a
forall i r a.
GenExpr i r a
-> a -> GenExpr i r a -> GenExpr i r a -> GenExpr i r a
ExprCond (GenExpr Identifier (Maybe CRangeExpr) a
-> GenExpr HierIdent (Maybe DimRange) a
forall a.
GenExpr Identifier (Maybe CRangeExpr) a
-> GenExpr HierIdent (Maybe DimRange) a
trUnconstExpr GenExpr Identifier (Maybe CRangeExpr) a
c) a
a (GenExpr Identifier (Maybe CRangeExpr) a
-> GenExpr HierIdent (Maybe DimRange) a
forall a.
GenExpr Identifier (Maybe CRangeExpr) a
-> GenExpr HierIdent (Maybe DimRange) a
trUnconstExpr GenExpr Identifier (Maybe CRangeExpr) a
t) (GenExpr Identifier (Maybe CRangeExpr) a
-> GenExpr HierIdent (Maybe DimRange) a
forall a.
GenExpr Identifier (Maybe CRangeExpr) a
-> GenExpr HierIdent (Maybe DimRange) a
trUnconstExpr GenExpr Identifier (Maybe CRangeExpr) a
f)

-- | converts Expr to CExpr
constifyExpr :: Expr -> Maybe CExpr
constifyExpr :: Expr -> Maybe CExpr
constifyExpr (Expr GenExpr HierIdent (Maybe DimRange) Attributes
e) = GenExpr Identifier (Maybe CRangeExpr) Attributes -> CExpr
CExpr (GenExpr Identifier (Maybe CRangeExpr) Attributes -> CExpr)
-> Maybe (GenExpr Identifier (Maybe CRangeExpr) Attributes)
-> Maybe CExpr
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> GenExpr HierIdent (Maybe DimRange) Attributes
-> Maybe (GenExpr Identifier (Maybe CRangeExpr) Attributes)
forall a.
GenExpr HierIdent (Maybe DimRange) a
-> Maybe (GenExpr Identifier (Maybe CRangeExpr) a)
trConstifyExpr GenExpr HierIdent (Maybe DimRange) Attributes
e

-- | the other way
unconstExpr :: CExpr -> Expr
unconstExpr :: CExpr -> Expr
unconstExpr (CExpr GenExpr Identifier (Maybe CRangeExpr) Attributes
e) = GenExpr HierIdent (Maybe DimRange) Attributes -> Expr
Expr (GenExpr Identifier (Maybe CRangeExpr) Attributes
-> GenExpr HierIdent (Maybe DimRange) Attributes
forall a.
GenExpr Identifier (Maybe CRangeExpr) a
-> GenExpr HierIdent (Maybe DimRange) a
trUnconstExpr GenExpr Identifier (Maybe CRangeExpr) Attributes
e)

-- | converts RangeExpr into CRangeExpr
constifyRange :: RangeExpr -> Maybe CRangeExpr
constifyRange :: GenRangeExpr Expr -> Maybe CRangeExpr
constifyRange GenRangeExpr Expr
x = case GenRangeExpr Expr
x of
  GRESingle Expr
e -> CExpr -> CRangeExpr
forall e. e -> GenRangeExpr e
GRESingle (CExpr -> CRangeExpr) -> Maybe CExpr -> Maybe CRangeExpr
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr -> Maybe CExpr
constifyExpr Expr
e
  GREPair Range2
r2 -> CRangeExpr -> Maybe CRangeExpr
forall a. a -> Maybe a
Just (CRangeExpr -> Maybe CRangeExpr) -> CRangeExpr -> Maybe CRangeExpr
forall a b. (a -> b) -> a -> b
$ Range2 -> CRangeExpr
forall e. Range2 -> GenRangeExpr e
GREPair Range2
r2
  GREBaseOff Expr
b Bool
mp CExpr
o -> (\CExpr
cb -> CExpr -> Bool -> CExpr -> CRangeExpr
forall e. e -> Bool -> CExpr -> GenRangeExpr e
GREBaseOff CExpr
cb Bool
mp CExpr
o) (CExpr -> CRangeExpr) -> Maybe CExpr -> Maybe CRangeExpr
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr -> Maybe CExpr
constifyExpr Expr
b

-- | the other way
unconstRange :: CRangeExpr -> RangeExpr
unconstRange :: CRangeExpr -> GenRangeExpr Expr
unconstRange CRangeExpr
x = case CRangeExpr
x of
  GRESingle CExpr
e -> Expr -> GenRangeExpr Expr
forall e. e -> GenRangeExpr e
GRESingle (CExpr -> Expr
unconstExpr CExpr
e)
  GREPair Range2
r2 -> Range2 -> GenRangeExpr Expr
forall e. Range2 -> GenRangeExpr e
GREPair Range2
r2
  GREBaseOff CExpr
b Bool
mp CExpr
o -> Expr -> Bool -> CExpr -> GenRangeExpr Expr
forall e. e -> Bool -> CExpr -> GenRangeExpr e
GREBaseOff (CExpr -> Expr
unconstExpr CExpr
b) Bool
mp CExpr
o

-- | converts DimRange into CDimRange
constifyDR :: GenDimRange Expr -> Maybe (GenDimRange CExpr)
constifyDR :: DimRange -> Maybe (GenDimRange CExpr)
constifyDR (GenDimRange [Expr]
dim GenRangeExpr Expr
rng) = [CExpr] -> CRangeExpr -> GenDimRange CExpr
forall e. [e] -> GenRangeExpr e -> GenDimRange e
GenDimRange ([CExpr] -> CRangeExpr -> GenDimRange CExpr)
-> Maybe [CExpr] -> Maybe (CRangeExpr -> GenDimRange CExpr)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Expr -> Maybe CExpr) -> [Expr] -> Maybe [CExpr]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM Expr -> Maybe CExpr
constifyExpr [Expr]
dim Maybe (CRangeExpr -> GenDimRange CExpr)
-> Maybe CRangeExpr -> Maybe (GenDimRange CExpr)
forall a b. Maybe (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> GenRangeExpr Expr -> Maybe CRangeExpr
constifyRange GenRangeExpr Expr
rng

-- | the other way
unconstDR :: GenDimRange CExpr -> GenDimRange Expr
unconstDR :: GenDimRange CExpr -> DimRange
unconstDR (GenDimRange [CExpr]
dim CRangeExpr
rng) = [Expr] -> GenRangeExpr Expr -> DimRange
forall e. [e] -> GenRangeExpr e -> GenDimRange e
GenDimRange ((CExpr -> Expr) -> [CExpr] -> [Expr]
forall a b. (a -> b) -> [a] -> [b]
map CExpr -> Expr
unconstExpr [CExpr]
dim) (CRangeExpr -> GenRangeExpr Expr
unconstRange CRangeExpr
rng)

-- | converts variable lvalue into net lvalue
constifyLV :: VarLValue -> Maybe NetLValue
constifyLV :: VarLValue -> Maybe NetLValue
constifyLV VarLValue
v = case VarLValue
v of
  LVSingle HierIdent
hi Maybe DimRange
mdr -> HierIdent -> Maybe (GenDimRange CExpr) -> NetLValue
forall dr. HierIdent -> Maybe dr -> LValue dr
LVSingle HierIdent
hi (Maybe (GenDimRange CExpr) -> NetLValue)
-> Maybe (Maybe (GenDimRange CExpr)) -> Maybe NetLValue
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe (Maybe (GenDimRange CExpr))
-> (DimRange -> Maybe (Maybe (GenDimRange CExpr)))
-> Maybe DimRange
-> Maybe (Maybe (GenDimRange CExpr))
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (Maybe (GenDimRange CExpr) -> Maybe (Maybe (GenDimRange CExpr))
forall a. a -> Maybe a
Just Maybe (GenDimRange CExpr)
forall a. Maybe a
Nothing) ((GenDimRange CExpr -> Maybe (GenDimRange CExpr))
-> Maybe (GenDimRange CExpr) -> Maybe (Maybe (GenDimRange CExpr))
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap GenDimRange CExpr -> Maybe (GenDimRange CExpr)
forall a. a -> Maybe a
Just (Maybe (GenDimRange CExpr) -> Maybe (Maybe (GenDimRange CExpr)))
-> (DimRange -> Maybe (GenDimRange CExpr))
-> DimRange
-> Maybe (Maybe (GenDimRange CExpr))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. DimRange -> Maybe (GenDimRange CExpr)
constifyDR) Maybe DimRange
mdr
  LVConcat NonEmpty VarLValue
l -> NonEmpty NetLValue -> NetLValue
forall dr. NonEmpty (LValue dr) -> LValue dr
LVConcat (NonEmpty NetLValue -> NetLValue)
-> Maybe (NonEmpty NetLValue) -> Maybe NetLValue
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (VarLValue -> Maybe NetLValue)
-> NonEmpty VarLValue -> Maybe (NonEmpty NetLValue)
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> NonEmpty a -> m (NonEmpty b)
mapM VarLValue -> Maybe NetLValue
constifyLV NonEmpty VarLValue
l

-- | the other way
unconstLV :: NetLValue -> VarLValue
unconstLV :: NetLValue -> VarLValue
unconstLV NetLValue
n = case NetLValue
n of
  LVSingle HierIdent
hi Maybe (GenDimRange CExpr)
dr -> HierIdent -> Maybe DimRange -> VarLValue
forall dr. HierIdent -> Maybe dr -> LValue dr
LVSingle HierIdent
hi (GenDimRange CExpr -> DimRange
unconstDR (GenDimRange CExpr -> DimRange)
-> Maybe (GenDimRange CExpr) -> Maybe DimRange
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe (GenDimRange CExpr)
dr)
  LVConcat NonEmpty NetLValue
l -> NonEmpty VarLValue -> VarLValue
forall dr. NonEmpty (LValue dr) -> LValue dr
LVConcat ((NetLValue -> VarLValue)
-> NonEmpty NetLValue -> NonEmpty VarLValue
forall a b. (a -> b) -> NonEmpty a -> NonEmpty b
NE.map NetLValue -> VarLValue
unconstLV NonEmpty NetLValue
l)

-- | converts expression into net lvalue
expr2netlv :: Expr -> Maybe NetLValue
expr2netlv :: Expr -> Maybe NetLValue
expr2netlv (Expr GenExpr HierIdent (Maybe DimRange) Attributes
x) = GenExpr HierIdent (Maybe DimRange) Attributes -> Maybe NetLValue
forall {a}. GenExpr HierIdent (Maybe DimRange) a -> Maybe NetLValue
aux GenExpr HierIdent (Maybe DimRange) Attributes
x
  where
    aux :: GenExpr HierIdent (Maybe DimRange) a -> Maybe NetLValue
aux GenExpr HierIdent (Maybe DimRange) a
x = case GenExpr HierIdent (Maybe DimRange) a
x of
      ExprPrim (PrimConcat NonEmpty (GenExpr HierIdent (Maybe DimRange) a)
c) -> NonEmpty NetLValue -> NetLValue
forall dr. NonEmpty (LValue dr) -> LValue dr
LVConcat (NonEmpty NetLValue -> NetLValue)
-> Maybe (NonEmpty NetLValue) -> Maybe NetLValue
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (GenExpr HierIdent (Maybe DimRange) a -> Maybe NetLValue)
-> NonEmpty (GenExpr HierIdent (Maybe DimRange) a)
-> Maybe (NonEmpty NetLValue)
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> NonEmpty a -> m (NonEmpty b)
mapM GenExpr HierIdent (Maybe DimRange) a -> Maybe NetLValue
aux NonEmpty (GenExpr HierIdent (Maybe DimRange) a)
c
      ExprPrim (PrimIdent HierIdent
s Maybe DimRange
sub) -> HierIdent -> Maybe (GenDimRange CExpr) -> NetLValue
forall dr. HierIdent -> Maybe dr -> LValue dr
LVSingle HierIdent
s (Maybe (GenDimRange CExpr) -> NetLValue)
-> Maybe (Maybe (GenDimRange CExpr)) -> Maybe NetLValue
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe (Maybe (GenDimRange CExpr))
-> (DimRange -> Maybe (Maybe (GenDimRange CExpr)))
-> Maybe DimRange
-> Maybe (Maybe (GenDimRange CExpr))
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (Maybe (GenDimRange CExpr) -> Maybe (Maybe (GenDimRange CExpr))
forall a. a -> Maybe a
Just Maybe (GenDimRange CExpr)
forall a. Maybe a
Nothing) (Maybe (GenDimRange CExpr) -> Maybe (Maybe (GenDimRange CExpr))
forall a. a -> Maybe a
Just (Maybe (GenDimRange CExpr) -> Maybe (Maybe (GenDimRange CExpr)))
-> (DimRange -> Maybe (GenDimRange CExpr))
-> DimRange
-> Maybe (Maybe (GenDimRange CExpr))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. DimRange -> Maybe (GenDimRange CExpr)
constifyDR) Maybe DimRange
sub
      GenExpr HierIdent (Maybe DimRange) a
_ -> Maybe NetLValue
forall a. Maybe a
Nothing

-- | the other way
netlv2expr :: NetLValue -> Expr
netlv2expr :: NetLValue -> Expr
netlv2expr = GenExpr HierIdent (Maybe DimRange) Attributes -> Expr
Expr (GenExpr HierIdent (Maybe DimRange) Attributes -> Expr)
-> (NetLValue -> GenExpr HierIdent (Maybe DimRange) Attributes)
-> NetLValue
-> Expr
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NetLValue -> GenExpr HierIdent (Maybe DimRange) Attributes
forall {a}. NetLValue -> GenExpr HierIdent (Maybe DimRange) a
aux
  where
    aux :: NetLValue -> GenExpr HierIdent (Maybe DimRange) a
aux NetLValue
x = case NetLValue
x of
      LVConcat NonEmpty NetLValue
e -> GenPrim HierIdent (Maybe DimRange) a
-> GenExpr HierIdent (Maybe DimRange) a
forall i r a. GenPrim i r a -> GenExpr i r a
ExprPrim (GenPrim HierIdent (Maybe DimRange) a
 -> GenExpr HierIdent (Maybe DimRange) a)
-> GenPrim HierIdent (Maybe DimRange) a
-> GenExpr HierIdent (Maybe DimRange) a
forall a b. (a -> b) -> a -> b
$ NonEmpty (GenExpr HierIdent (Maybe DimRange) a)
-> GenPrim HierIdent (Maybe DimRange) a
forall i r a. NonEmpty (GenExpr i r a) -> GenPrim i r a
PrimConcat (NonEmpty (GenExpr HierIdent (Maybe DimRange) a)
 -> GenPrim HierIdent (Maybe DimRange) a)
-> NonEmpty (GenExpr HierIdent (Maybe DimRange) a)
-> GenPrim HierIdent (Maybe DimRange) a
forall a b. (a -> b) -> a -> b
$ (NetLValue -> GenExpr HierIdent (Maybe DimRange) a)
-> NonEmpty NetLValue
-> NonEmpty (GenExpr HierIdent (Maybe DimRange) a)
forall a b. (a -> b) -> NonEmpty a -> NonEmpty b
NE.map NetLValue -> GenExpr HierIdent (Maybe DimRange) a
aux NonEmpty NetLValue
e
      LVSingle HierIdent
s Maybe (GenDimRange CExpr)
dr -> GenPrim HierIdent (Maybe DimRange) a
-> GenExpr HierIdent (Maybe DimRange) a
forall i r a. GenPrim i r a -> GenExpr i r a
ExprPrim (GenPrim HierIdent (Maybe DimRange) a
 -> GenExpr HierIdent (Maybe DimRange) a)
-> GenPrim HierIdent (Maybe DimRange) a
-> GenExpr HierIdent (Maybe DimRange) a
forall a b. (a -> b) -> a -> b
$ HierIdent -> Maybe DimRange -> GenPrim HierIdent (Maybe DimRange) a
forall i r a. i -> r -> GenPrim i r a
PrimIdent HierIdent
s (Maybe DimRange -> GenPrim HierIdent (Maybe DimRange) a)
-> Maybe DimRange -> GenPrim HierIdent (Maybe DimRange) a
forall a b. (a -> b) -> a -> b
$ GenDimRange CExpr -> DimRange
unconstDR (GenDimRange CExpr -> DimRange)
-> Maybe (GenDimRange CExpr) -> Maybe DimRange
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe (GenDimRange CExpr)
dr

-- | Converts Function statements to statements
toStatement :: FunctionStatement -> Statement
toStatement :: FunctionStatement -> Statement
toStatement FunctionStatement
x = case FunctionStatement
x of
  FSBlockAssign VarAssign
va -> Bool -> VarAssign -> Maybe DelayEventControl -> Statement
SBlockAssign Bool
True VarAssign
va Maybe DelayEventControl
forall a. Maybe a
Nothing
  FSCase ZOX
zox Expr
e [FCaseItem]
l MybFStmt
d -> ZOX -> Expr -> [CaseItem] -> MybStmt -> Statement
SCase ZOX
zox Expr
e ((FCaseItem -> CaseItem) -> [FCaseItem] -> [CaseItem]
forall a b. (a -> b) -> [a] -> [b]
map (\(FCaseItem NonEmpty Expr
p MybFStmt
v) -> NonEmpty Expr -> MybStmt -> CaseItem
CaseItem NonEmpty Expr
p (MybStmt -> CaseItem) -> MybStmt -> CaseItem
forall a b. (a -> b) -> a -> b
$ MybFStmt -> MybStmt
mybf MybFStmt
v) [FCaseItem]
l) (MybFStmt -> MybStmt
mybf MybFStmt
d)
  FSIf Expr
e MybFStmt
t MybFStmt
f -> Expr -> MybStmt -> MybStmt -> Statement
SIf Expr
e (MybFStmt -> MybStmt
mybf MybFStmt
t) (MybFStmt -> MybStmt
mybf MybFStmt
f)
  FSDisable HierIdent
hi -> HierIdent -> Statement
SDisable HierIdent
hi
  FSLoop LoopStatement
ls AttrFStmt
b -> LoopStatement -> AttrStmt -> Statement
SLoop LoopStatement
ls (AttrStmt -> Statement) -> AttrStmt -> Statement
forall a b. (a -> b) -> a -> b
$ FunctionStatement -> Statement
toStatement (FunctionStatement -> Statement) -> AttrFStmt -> AttrStmt
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> AttrFStmt
b
  FSBlock Maybe (Identifier, [AttrIded StdBlockDecl])
h Bool
ps [AttrFStmt]
b -> Maybe (Identifier, [AttrIded StdBlockDecl])
-> Bool -> [AttrStmt] -> Statement
SBlock Maybe (Identifier, [AttrIded StdBlockDecl])
h Bool
ps ([AttrStmt] -> Statement) -> [AttrStmt] -> Statement
forall a b. (a -> b) -> a -> b
$ (FunctionStatement -> Statement) -> AttrFStmt -> AttrStmt
forall a b. (a -> b) -> Attributed a -> Attributed b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap FunctionStatement -> Statement
toStatement (AttrFStmt -> AttrStmt) -> [AttrFStmt] -> [AttrStmt]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [AttrFStmt]
b
  where mybf :: MybFStmt -> MybStmt
mybf = (Maybe FunctionStatement -> Maybe Statement) -> MybFStmt -> MybStmt
forall a b. (a -> b) -> Attributed a -> Attributed b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((Maybe FunctionStatement -> Maybe Statement)
 -> MybFStmt -> MybStmt)
-> (Maybe FunctionStatement -> Maybe Statement)
-> MybFStmt
-> MybStmt
forall a b. (a -> b) -> a -> b
$ (FunctionStatement -> Statement)
-> Maybe FunctionStatement -> Maybe Statement
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap FunctionStatement -> Statement
toStatement

-- | the other way
fromStatement :: Statement -> Maybe FunctionStatement
fromStatement :: Statement -> Maybe FunctionStatement
fromStatement Statement
x = case Statement
x of
  SBlockAssign Bool
True VarAssign
va Maybe DelayEventControl
Nothing -> FunctionStatement -> Maybe FunctionStatement
forall a. a -> Maybe a
Just (FunctionStatement -> Maybe FunctionStatement)
-> FunctionStatement -> Maybe FunctionStatement
forall a b. (a -> b) -> a -> b
$ VarAssign -> FunctionStatement
FSBlockAssign VarAssign
va
  SCase ZOX
zox Expr
e [CaseItem]
l MybStmt
d -> ZOX -> Expr -> [FCaseItem] -> MybFStmt -> FunctionStatement
FSCase ZOX
zox Expr
e ([FCaseItem] -> MybFStmt -> FunctionStatement)
-> Maybe [FCaseItem] -> Maybe (MybFStmt -> FunctionStatement)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (CaseItem -> Maybe FCaseItem) -> [CaseItem] -> Maybe [FCaseItem]
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> [a] -> f [b]
traverse (\(CaseItem NonEmpty Expr
p MybStmt
v) -> NonEmpty Expr -> MybFStmt -> FCaseItem
FCaseItem NonEmpty Expr
p (MybFStmt -> FCaseItem) -> Maybe MybFStmt -> Maybe FCaseItem
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> MybStmt -> Maybe MybFStmt
forall {t :: * -> *} {t :: * -> *}.
(Traversable t, Traversable t) =>
t (t Statement) -> Maybe (t (t FunctionStatement))
mybf MybStmt
v) [CaseItem]
l Maybe (MybFStmt -> FunctionStatement)
-> Maybe MybFStmt -> Maybe FunctionStatement
forall a b. Maybe (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> MybStmt -> Maybe MybFStmt
forall {t :: * -> *} {t :: * -> *}.
(Traversable t, Traversable t) =>
t (t Statement) -> Maybe (t (t FunctionStatement))
mybf MybStmt
d
  SIf Expr
e MybStmt
t MybStmt
f -> Expr -> MybFStmt -> MybFStmt -> FunctionStatement
FSIf Expr
e (MybFStmt -> MybFStmt -> FunctionStatement)
-> Maybe MybFStmt -> Maybe (MybFStmt -> FunctionStatement)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> MybStmt -> Maybe MybFStmt
forall {t :: * -> *} {t :: * -> *}.
(Traversable t, Traversable t) =>
t (t Statement) -> Maybe (t (t FunctionStatement))
mybf MybStmt
t Maybe (MybFStmt -> FunctionStatement)
-> Maybe MybFStmt -> Maybe FunctionStatement
forall a b. Maybe (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> MybStmt -> Maybe MybFStmt
forall {t :: * -> *} {t :: * -> *}.
(Traversable t, Traversable t) =>
t (t Statement) -> Maybe (t (t FunctionStatement))
mybf MybStmt
f
  SDisable HierIdent
hi -> FunctionStatement -> Maybe FunctionStatement
forall a. a -> Maybe a
Just (FunctionStatement -> Maybe FunctionStatement)
-> FunctionStatement -> Maybe FunctionStatement
forall a b. (a -> b) -> a -> b
$ HierIdent -> FunctionStatement
FSDisable HierIdent
hi
  SLoop LoopStatement
ls AttrStmt
b -> LoopStatement -> AttrFStmt -> FunctionStatement
FSLoop LoopStatement
ls (AttrFStmt -> FunctionStatement)
-> Maybe AttrFStmt -> Maybe FunctionStatement
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Statement -> Maybe FunctionStatement)
-> AttrStmt -> Maybe AttrFStmt
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Attributed a -> f (Attributed b)
traverse Statement -> Maybe FunctionStatement
fromStatement AttrStmt
b
  SBlock Maybe (Identifier, [AttrIded StdBlockDecl])
h Bool
ps [AttrStmt]
b -> Maybe (Identifier, [AttrIded StdBlockDecl])
-> Bool -> [AttrFStmt] -> FunctionStatement
FSBlock Maybe (Identifier, [AttrIded StdBlockDecl])
h Bool
ps ([AttrFStmt] -> FunctionStatement)
-> Maybe [AttrFStmt] -> Maybe FunctionStatement
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (AttrStmt -> Maybe AttrFStmt) -> [AttrStmt] -> Maybe [AttrFStmt]
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> [a] -> f [b]
traverse ((Statement -> Maybe FunctionStatement)
-> AttrStmt -> Maybe AttrFStmt
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Attributed a -> f (Attributed b)
traverse Statement -> Maybe FunctionStatement
fromStatement) [AttrStmt]
b
  Statement
_ -> Maybe FunctionStatement
forall a. Maybe a
Nothing
  where mybf :: t (t Statement) -> Maybe (t (t FunctionStatement))
mybf t (t Statement)
s = (t Statement -> Maybe (t FunctionStatement))
-> t (t Statement) -> Maybe (t (t FunctionStatement))
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> t a -> f (t b)
traverse ((Statement -> Maybe FunctionStatement)
-> t Statement -> Maybe (t FunctionStatement)
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> t a -> f (t b)
traverse Statement -> Maybe FunctionStatement
fromStatement) t (t Statement)
s

-- | Converts MybStmt to AttrStmt
fromMybStmt :: MybStmt -> AttrStmt
fromMybStmt :: MybStmt -> AttrStmt
fromMybStmt MybStmt
x = case MybStmt
x of
  Attributed Attributes
_ Maybe Statement
Nothing -> Attributes -> Statement -> AttrStmt
forall t. Attributes -> t -> Attributed t
Attributed [] (Statement -> AttrStmt) -> Statement -> AttrStmt
forall a b. (a -> b) -> a -> b
$ Expr -> MybStmt -> MybStmt -> Statement
SIf (GenExpr HierIdent (Maybe DimRange) Attributes -> Expr
Expr (GenExpr HierIdent (Maybe DimRange) Attributes -> Expr)
-> GenExpr HierIdent (Maybe DimRange) Attributes -> Expr
forall a b. (a -> b) -> a -> b
$ Natural -> GenExpr HierIdent (Maybe DimRange) Attributes
forall i r a. Natural -> GenExpr i r a
genexprnumber Natural
1) MybStmt
x (MybStmt -> Statement) -> MybStmt -> Statement
forall a b. (a -> b) -> a -> b
$ Attributes -> Maybe Statement -> MybStmt
forall t. Attributes -> t -> Attributed t
Attributed [] Maybe Statement
forall a. Maybe a
Nothing
  Attributed Attributes
a (Just Statement
s) -> Attributes -> Statement -> AttrStmt
forall t. Attributes -> t -> Attributed t
Attributed Attributes
a Statement
s

type BD f t = BlockDecl (Compose f Identified) t

-- | Converts ModGenSingleItem's `BlockDecl` into ModGenBlockedItem's `BlockDecl`
toMGIBlockDecl :: BD NonEmpty t -> NonEmpty (BD Identity t)
toMGIBlockDecl :: forall t. BD NonEmpty t -> NonEmpty (BD Identity t)
toMGIBlockDecl BD NonEmpty t
x = case BD NonEmpty t
x of
  BDReg SignRange
sr Compose NonEmpty Identified t
d -> (Compose Identity Identified t -> BD Identity t)
-> Compose NonEmpty Identified t -> NonEmpty (BD Identity t)
forall {f :: * -> *} {g :: * -> *} {a} {b}.
Functor f =>
(Compose Identity g a -> b) -> Compose f g a -> f b
conv (SignRange -> Compose Identity Identified t -> BD Identity t
forall (f :: * -> *) t. SignRange -> f t -> BlockDecl f t
BDReg SignRange
sr) Compose NonEmpty Identified t
d
  BDInt Compose NonEmpty Identified t
d -> (Compose Identity Identified t -> BD Identity t)
-> Compose NonEmpty Identified t -> NonEmpty (BD Identity t)
forall {f :: * -> *} {g :: * -> *} {a} {b}.
Functor f =>
(Compose Identity g a -> b) -> Compose f g a -> f b
conv Compose Identity Identified t -> BD Identity t
forall (f :: * -> *) t. f t -> BlockDecl f t
BDInt Compose NonEmpty Identified t
d
  BDReal Compose NonEmpty Identified t
d -> (Compose Identity Identified t -> BD Identity t)
-> Compose NonEmpty Identified t -> NonEmpty (BD Identity t)
forall {f :: * -> *} {g :: * -> *} {a} {b}.
Functor f =>
(Compose Identity g a -> b) -> Compose f g a -> f b
conv Compose Identity Identified t -> BD Identity t
forall (f :: * -> *) t. f t -> BlockDecl f t
BDReal Compose NonEmpty Identified t
d
  BDTime Compose NonEmpty Identified t
d -> (Compose Identity Identified t -> BD Identity t)
-> Compose NonEmpty Identified t -> NonEmpty (BD Identity t)
forall {f :: * -> *} {g :: * -> *} {a} {b}.
Functor f =>
(Compose Identity g a -> b) -> Compose f g a -> f b
conv Compose Identity Identified t -> BD Identity t
forall (f :: * -> *) t. f t -> BlockDecl f t
BDTime Compose NonEmpty Identified t
d
  BDRealTime Compose NonEmpty Identified t
d -> (Compose Identity Identified t -> BD Identity t)
-> Compose NonEmpty Identified t -> NonEmpty (BD Identity t)
forall {f :: * -> *} {g :: * -> *} {a} {b}.
Functor f =>
(Compose Identity g a -> b) -> Compose f g a -> f b
conv Compose Identity Identified t -> BD Identity t
forall (f :: * -> *) t. f t -> BlockDecl f t
BDRealTime Compose NonEmpty Identified t
d
  BDEvent Compose NonEmpty Identified [Range2]
d -> (Compose Identity Identified [Range2] -> BD Identity t)
-> Compose NonEmpty Identified [Range2] -> NonEmpty (BD Identity t)
forall {f :: * -> *} {g :: * -> *} {a} {b}.
Functor f =>
(Compose Identity g a -> b) -> Compose f g a -> f b
conv Compose Identity Identified [Range2] -> BD Identity t
forall (f :: * -> *) t. f [Range2] -> BlockDecl f t
BDEvent Compose NonEmpty Identified [Range2]
d
  BDLocalParam ComType ()
t Compose NonEmpty Identified CMinTypMax
d -> (Compose Identity Identified CMinTypMax -> BD Identity t)
-> Compose NonEmpty Identified CMinTypMax
-> NonEmpty (BD Identity t)
forall {f :: * -> *} {g :: * -> *} {a} {b}.
Functor f =>
(Compose Identity g a -> b) -> Compose f g a -> f b
conv (ComType ()
-> Compose Identity Identified CMinTypMax -> BD Identity t
forall (f :: * -> *) t. ComType () -> f CMinTypMax -> BlockDecl f t
BDLocalParam ComType ()
t) Compose NonEmpty Identified CMinTypMax
d
  where
    conv :: (Compose Identity g a -> b) -> Compose f g a -> f b
conv Compose Identity g a -> b
f = (g a -> b) -> f (g a) -> f b
forall a b. (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Compose Identity g a -> b
f (Compose Identity g a -> b)
-> (g a -> Compose Identity g a) -> g a -> b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Identity (g a) -> Compose Identity g a
forall {k} {k1} (f :: k -> *) (g :: k1 -> k) (a :: k1).
f (g a) -> Compose f g a
Compose (Identity (g a) -> Compose Identity g a)
-> (g a -> Identity (g a)) -> g a -> Compose Identity g a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. g a -> Identity (g a)
forall a. a -> Identity a
Identity) (f (g a) -> f b)
-> (Compose f g a -> f (g a)) -> Compose f g a -> f b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Compose f g a -> f (g a)
forall {k1} {k2} (f :: k1 -> *) (g :: k2 -> k1) (a :: k2).
Compose f g a -> f (g a)
getCompose

-- | Converts one ModGenBlockedItem's `BlockDecl` into ModGenSingleItem's `BlockDecl`
fromMGIBlockDecl1 :: BD Identity t -> BD NonEmpty t
fromMGIBlockDecl1 :: forall t. BD Identity t -> BD NonEmpty t
fromMGIBlockDecl1 BD Identity t
x = case BD Identity t
x of
  BDReg SignRange
sr Compose Identity Identified t
d -> (Compose NonEmpty Identified t -> BD NonEmpty t)
-> Compose Identity Identified t -> BD NonEmpty t
forall {g :: * -> *} {a} {c}.
(Compose NonEmpty g a -> c) -> Compose Identity g a -> c
conv (SignRange -> Compose NonEmpty Identified t -> BD NonEmpty t
forall (f :: * -> *) t. SignRange -> f t -> BlockDecl f t
BDReg SignRange
sr) Compose Identity Identified t
d
  BDInt Compose Identity Identified t
d -> (Compose NonEmpty Identified t -> BD NonEmpty t)
-> Compose Identity Identified t -> BD NonEmpty t
forall {g :: * -> *} {a} {c}.
(Compose NonEmpty g a -> c) -> Compose Identity g a -> c
conv Compose NonEmpty Identified t -> BD NonEmpty t
forall (f :: * -> *) t. f t -> BlockDecl f t
BDInt Compose Identity Identified t
d
  BDReal Compose Identity Identified t
d -> (Compose NonEmpty Identified t -> BD NonEmpty t)
-> Compose Identity Identified t -> BD NonEmpty t
forall {g :: * -> *} {a} {c}.
(Compose NonEmpty g a -> c) -> Compose Identity g a -> c
conv Compose NonEmpty Identified t -> BD NonEmpty t
forall (f :: * -> *) t. f t -> BlockDecl f t
BDReal Compose Identity Identified t
d
  BDTime Compose Identity Identified t
d -> (Compose NonEmpty Identified t -> BD NonEmpty t)
-> Compose Identity Identified t -> BD NonEmpty t
forall {g :: * -> *} {a} {c}.
(Compose NonEmpty g a -> c) -> Compose Identity g a -> c
conv Compose NonEmpty Identified t -> BD NonEmpty t
forall (f :: * -> *) t. f t -> BlockDecl f t
BDTime Compose Identity Identified t
d
  BDRealTime Compose Identity Identified t
d -> (Compose NonEmpty Identified t -> BD NonEmpty t)
-> Compose Identity Identified t -> BD NonEmpty t
forall {g :: * -> *} {a} {c}.
(Compose NonEmpty g a -> c) -> Compose Identity g a -> c
conv Compose NonEmpty Identified t -> BD NonEmpty t
forall (f :: * -> *) t. f t -> BlockDecl f t
BDRealTime Compose Identity Identified t
d
  BDEvent Compose Identity Identified [Range2]
d -> (Compose NonEmpty Identified [Range2] -> BD NonEmpty t)
-> Compose Identity Identified [Range2] -> BD NonEmpty t
forall {g :: * -> *} {a} {c}.
(Compose NonEmpty g a -> c) -> Compose Identity g a -> c
conv Compose NonEmpty Identified [Range2] -> BD NonEmpty t
forall (f :: * -> *) t. f [Range2] -> BlockDecl f t
BDEvent Compose Identity Identified [Range2]
d
  BDLocalParam ComType ()
t Compose Identity Identified CMinTypMax
d -> (Compose NonEmpty Identified CMinTypMax -> BD NonEmpty t)
-> Compose Identity Identified CMinTypMax -> BD NonEmpty t
forall {g :: * -> *} {a} {c}.
(Compose NonEmpty g a -> c) -> Compose Identity g a -> c
conv (ComType ()
-> Compose NonEmpty Identified CMinTypMax -> BD NonEmpty t
forall (f :: * -> *) t. ComType () -> f CMinTypMax -> BlockDecl f t
BDLocalParam ComType ()
t) Compose Identity Identified CMinTypMax
d
  where
    conv :: (Compose NonEmpty g a -> c) -> Compose Identity g a -> c
conv Compose NonEmpty g a -> c
f = Compose NonEmpty g a -> c
f (Compose NonEmpty g a -> c)
-> (Compose Identity g a -> Compose NonEmpty g a)
-> Compose Identity g a
-> c
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NonEmpty (g a) -> Compose NonEmpty g a
forall {k} {k1} (f :: k -> *) (g :: k1 -> k) (a :: k1).
f (g a) -> Compose f g a
Compose (NonEmpty (g a) -> Compose NonEmpty g a)
-> (Compose Identity g a -> NonEmpty (g a))
-> Compose Identity g a
-> Compose NonEmpty g a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (g a -> [g a] -> NonEmpty (g a)
forall a. a -> [a] -> NonEmpty a
:|[]) (g a -> NonEmpty (g a))
-> (Compose Identity g a -> g a)
-> Compose Identity g a
-> NonEmpty (g a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Identity (g a) -> g a
forall a. Identity a -> a
runIdentity (Identity (g a) -> g a)
-> (Compose Identity g a -> Identity (g a))
-> Compose Identity g a
-> g a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Compose Identity g a -> Identity (g a)
forall {k1} {k2} (f :: k1 -> *) (g :: k2 -> k1) (a :: k2).
Compose f g a -> f (g a)
getCompose

-- | Merges one ModGenBlockedItem's `BlockDecl` with one ModGenSingleItem's `BlockDecl`
fromMGIBlockDecl_add :: BD Identity t -> BD NonEmpty t -> Maybe (BD NonEmpty t)
fromMGIBlockDecl_add :: forall t. BD Identity t -> BD NonEmpty t -> Maybe (BD NonEmpty t)
fromMGIBlockDecl_add BD Identity t
x BD NonEmpty t
y = case (BD Identity t
x, BD NonEmpty t
y) of
  (BDReg SignRange
nsr Compose Identity Identified t
d, BDReg SignRange
sr Compose NonEmpty Identified t
l) | SignRange
nsr SignRange -> SignRange -> Bool
forall a. Eq a => a -> a -> Bool
== SignRange
sr -> (Compose NonEmpty Identified t -> BD NonEmpty t)
-> Compose Identity Identified t
-> Compose NonEmpty Identified t
-> Maybe (BD NonEmpty t)
forall {g :: * -> *} {a} {a}.
(Compose NonEmpty g a -> a)
-> Compose Identity g a -> Compose NonEmpty g a -> Maybe a
add (SignRange -> Compose NonEmpty Identified t -> BD NonEmpty t
forall (f :: * -> *) t. SignRange -> f t -> BlockDecl f t
BDReg SignRange
sr) Compose Identity Identified t
d Compose NonEmpty Identified t
l
  (BDInt Compose Identity Identified t
d, BDInt Compose NonEmpty Identified t
l) -> (Compose NonEmpty Identified t -> BD NonEmpty t)
-> Compose Identity Identified t
-> Compose NonEmpty Identified t
-> Maybe (BD NonEmpty t)
forall {g :: * -> *} {a} {a}.
(Compose NonEmpty g a -> a)
-> Compose Identity g a -> Compose NonEmpty g a -> Maybe a
add Compose NonEmpty Identified t -> BD NonEmpty t
forall (f :: * -> *) t. f t -> BlockDecl f t
BDInt Compose Identity Identified t
d Compose NonEmpty Identified t
l
  (BDReal Compose Identity Identified t
d, BDReal Compose NonEmpty Identified t
l) -> (Compose NonEmpty Identified t -> BD NonEmpty t)
-> Compose Identity Identified t
-> Compose NonEmpty Identified t
-> Maybe (BD NonEmpty t)
forall {g :: * -> *} {a} {a}.
(Compose NonEmpty g a -> a)
-> Compose Identity g a -> Compose NonEmpty g a -> Maybe a
add Compose NonEmpty Identified t -> BD NonEmpty t
forall (f :: * -> *) t. f t -> BlockDecl f t
BDReal Compose Identity Identified t
d Compose NonEmpty Identified t
l
  (BDTime Compose Identity Identified t
d, BDTime Compose NonEmpty Identified t
l) -> (Compose NonEmpty Identified t -> BD NonEmpty t)
-> Compose Identity Identified t
-> Compose NonEmpty Identified t
-> Maybe (BD NonEmpty t)
forall {g :: * -> *} {a} {a}.
(Compose NonEmpty g a -> a)
-> Compose Identity g a -> Compose NonEmpty g a -> Maybe a
add Compose NonEmpty Identified t -> BD NonEmpty t
forall (f :: * -> *) t. f t -> BlockDecl f t
BDTime Compose Identity Identified t
d Compose NonEmpty Identified t
l
  (BDRealTime Compose Identity Identified t
d, BDRealTime Compose NonEmpty Identified t
l) -> (Compose NonEmpty Identified t -> BD NonEmpty t)
-> Compose Identity Identified t
-> Compose NonEmpty Identified t
-> Maybe (BD NonEmpty t)
forall {g :: * -> *} {a} {a}.
(Compose NonEmpty g a -> a)
-> Compose Identity g a -> Compose NonEmpty g a -> Maybe a
add Compose NonEmpty Identified t -> BD NonEmpty t
forall (f :: * -> *) t. f t -> BlockDecl f t
BDRealTime Compose Identity Identified t
d Compose NonEmpty Identified t
l
  (BDEvent Compose Identity Identified [Range2]
d, BDEvent Compose NonEmpty Identified [Range2]
l) -> (Compose NonEmpty Identified [Range2] -> BD NonEmpty t)
-> Compose Identity Identified [Range2]
-> Compose NonEmpty Identified [Range2]
-> Maybe (BD NonEmpty t)
forall {g :: * -> *} {a} {a}.
(Compose NonEmpty g a -> a)
-> Compose Identity g a -> Compose NonEmpty g a -> Maybe a
add Compose NonEmpty Identified [Range2] -> BD NonEmpty t
forall (f :: * -> *) t. f [Range2] -> BlockDecl f t
BDEvent Compose Identity Identified [Range2]
d Compose NonEmpty Identified [Range2]
l
  (BDLocalParam ComType ()
nt Compose Identity Identified CMinTypMax
d, BDLocalParam ComType ()
t Compose NonEmpty Identified CMinTypMax
l) | ComType ()
nt ComType () -> ComType () -> Bool
forall a. Eq a => a -> a -> Bool
== ComType ()
t -> (Compose NonEmpty Identified CMinTypMax -> BD NonEmpty t)
-> Compose Identity Identified CMinTypMax
-> Compose NonEmpty Identified CMinTypMax
-> Maybe (BD NonEmpty t)
forall {g :: * -> *} {a} {a}.
(Compose NonEmpty g a -> a)
-> Compose Identity g a -> Compose NonEmpty g a -> Maybe a
add (ComType ()
-> Compose NonEmpty Identified CMinTypMax -> BD NonEmpty t
forall (f :: * -> *) t. ComType () -> f CMinTypMax -> BlockDecl f t
BDLocalParam ComType ()
t) Compose Identity Identified CMinTypMax
d Compose NonEmpty Identified CMinTypMax
l
  (BD Identity t, BD NonEmpty t)
_ -> Maybe (BD NonEmpty t)
forall a. Maybe a
Nothing
  where
    add :: (Compose NonEmpty g a -> a)
-> Compose Identity g a -> Compose NonEmpty g a -> Maybe a
add Compose NonEmpty g a -> a
f Compose Identity g a
x Compose NonEmpty g a
l = a -> Maybe a
forall a. a -> Maybe a
Just (a -> Maybe a) -> a -> Maybe a
forall a b. (a -> b) -> a -> b
$ Compose NonEmpty g a -> a
f (Compose NonEmpty g a -> a) -> Compose NonEmpty g a -> a
forall a b. (a -> b) -> a -> b
$ NonEmpty (g a) -> Compose NonEmpty g a
forall {k} {k1} (f :: k -> *) (g :: k1 -> k) (a :: k1).
f (g a) -> Compose f g a
Compose (NonEmpty (g a) -> Compose NonEmpty g a)
-> NonEmpty (g a) -> Compose NonEmpty g a
forall a b. (a -> b) -> a -> b
$ Identity (g a) -> g a
forall a. Identity a -> a
runIdentity (Compose Identity g a -> Identity (g a)
forall {k1} {k2} (f :: k1 -> *) (g :: k2 -> k1) (a :: k2).
Compose f g a -> f (g a)
getCompose Compose Identity g a
x) g a -> NonEmpty (g a) -> NonEmpty (g a)
forall a. a -> NonEmpty a -> NonEmpty a
<| Compose NonEmpty g a -> NonEmpty (g a)
forall {k1} {k2} (f :: k1 -> *) (g :: k2 -> k1) (a :: k2).
Compose f g a -> f (g a)
getCompose Compose NonEmpty g a
l

-- | Converts ModGenSingleItem like `BlockDecl` into StdBlockDecl `BlockDecl`
toStdBlockDecl :: BD NonEmpty t -> NonEmpty (Identified (BlockDecl Identity t))
toStdBlockDecl :: forall t.
BD NonEmpty t -> NonEmpty (Identified (BlockDecl Identity t))
toStdBlockDecl BD NonEmpty t
x = case BD NonEmpty t
x of
  BDReg SignRange
sr Compose NonEmpty Identified t
d -> (Identity t -> BlockDecl Identity t)
-> Compose NonEmpty Identified t
-> NonEmpty (Identified (BlockDecl Identity t))
forall {f :: * -> *} {f :: * -> *} {a} {b}.
(Functor f, Functor f) =>
(Identity a -> b) -> Compose f f a -> f (f b)
conv (SignRange -> Identity t -> BlockDecl Identity t
forall (f :: * -> *) t. SignRange -> f t -> BlockDecl f t
BDReg SignRange
sr) Compose NonEmpty Identified t
d
  BDInt Compose NonEmpty Identified t
d -> (Identity t -> BlockDecl Identity t)
-> Compose NonEmpty Identified t
-> NonEmpty (Identified (BlockDecl Identity t))
forall {f :: * -> *} {f :: * -> *} {a} {b}.
(Functor f, Functor f) =>
(Identity a -> b) -> Compose f f a -> f (f b)
conv Identity t -> BlockDecl Identity t
forall (f :: * -> *) t. f t -> BlockDecl f t
BDInt Compose NonEmpty Identified t
d
  BDReal Compose NonEmpty Identified t
d -> (Identity t -> BlockDecl Identity t)
-> Compose NonEmpty Identified t
-> NonEmpty (Identified (BlockDecl Identity t))
forall {f :: * -> *} {f :: * -> *} {a} {b}.
(Functor f, Functor f) =>
(Identity a -> b) -> Compose f f a -> f (f b)
conv Identity t -> BlockDecl Identity t
forall (f :: * -> *) t. f t -> BlockDecl f t
BDReal Compose NonEmpty Identified t
d
  BDTime Compose NonEmpty Identified t
d -> (Identity t -> BlockDecl Identity t)
-> Compose NonEmpty Identified t
-> NonEmpty (Identified (BlockDecl Identity t))
forall {f :: * -> *} {f :: * -> *} {a} {b}.
(Functor f, Functor f) =>
(Identity a -> b) -> Compose f f a -> f (f b)
conv Identity t -> BlockDecl Identity t
forall (f :: * -> *) t. f t -> BlockDecl f t
BDTime Compose NonEmpty Identified t
d
  BDRealTime Compose NonEmpty Identified t
d -> (Identity t -> BlockDecl Identity t)
-> Compose NonEmpty Identified t
-> NonEmpty (Identified (BlockDecl Identity t))
forall {f :: * -> *} {f :: * -> *} {a} {b}.
(Functor f, Functor f) =>
(Identity a -> b) -> Compose f f a -> f (f b)
conv Identity t -> BlockDecl Identity t
forall (f :: * -> *) t. f t -> BlockDecl f t
BDRealTime Compose NonEmpty Identified t
d
  BDEvent Compose NonEmpty Identified [Range2]
d -> (Identity [Range2] -> BlockDecl Identity t)
-> Compose NonEmpty Identified [Range2]
-> NonEmpty (Identified (BlockDecl Identity t))
forall {f :: * -> *} {f :: * -> *} {a} {b}.
(Functor f, Functor f) =>
(Identity a -> b) -> Compose f f a -> f (f b)
conv Identity [Range2] -> BlockDecl Identity t
forall (f :: * -> *) t. f [Range2] -> BlockDecl f t
BDEvent Compose NonEmpty Identified [Range2]
d
  BDLocalParam ComType ()
t Compose NonEmpty Identified CMinTypMax
d -> (Identity CMinTypMax -> BlockDecl Identity t)
-> Compose NonEmpty Identified CMinTypMax
-> NonEmpty (Identified (BlockDecl Identity t))
forall {f :: * -> *} {f :: * -> *} {a} {b}.
(Functor f, Functor f) =>
(Identity a -> b) -> Compose f f a -> f (f b)
conv (ComType () -> Identity CMinTypMax -> BlockDecl Identity t
forall (f :: * -> *) t. ComType () -> f CMinTypMax -> BlockDecl f t
BDLocalParam ComType ()
t) Compose NonEmpty Identified CMinTypMax
d
  where
    conv :: (Identity a -> b) -> Compose f f a -> f (f b)
conv Identity a -> b
f = (f a -> f b) -> f (f a) -> f (f b)
forall a b. (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((a -> b) -> f a -> f b
forall a b. (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((a -> b) -> f a -> f b) -> (a -> b) -> f a -> f b
forall a b. (a -> b) -> a -> b
$ Identity a -> b
f (Identity a -> b) -> (a -> Identity a) -> a -> b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Identity a
forall a. a -> Identity a
Identity) (f (f a) -> f (f b))
-> (Compose f f a -> f (f a)) -> Compose f f a -> f (f b)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Compose f f a -> f (f a)
forall {k1} {k2} (f :: k1 -> *) (g :: k2 -> k1) (a :: k2).
Compose f g a -> f (g a)
getCompose

-- | Converts `SpecifySingleItem` into `SpecifyBlockedItem`s
toSpecBlockedItem :: SpecifySingleItem -> NonEmpty SpecifyBlockedItem
toSpecBlockedItem :: SpecifySingleItem -> NonEmpty SpecifyBlockedItem
toSpecBlockedItem SpecifySingleItem
x = case SpecifySingleItem
x of
  SISpecParam Maybe Range2
rng NonEmpty SpecParamDecl
d -> (Identity SpecParamDecl -> SpecifyBlockedItem)
-> NonEmpty SpecParamDecl -> NonEmpty SpecifyBlockedItem
forall {f :: * -> *} {a} {b}.
Functor f =>
(Identity a -> b) -> f a -> f b
conv (Maybe Range2 -> Identity SpecParamDecl -> SpecifyBlockedItem
forall (f :: * -> *).
Maybe Range2 -> f SpecParamDecl -> SpecifyItem f
SISpecParam Maybe Range2
rng) NonEmpty SpecParamDecl
d
  SIPulsestyleOnevent NonEmpty SpecTerm
st -> (Identity SpecTerm -> SpecifyBlockedItem)
-> NonEmpty SpecTerm -> NonEmpty SpecifyBlockedItem
forall {f :: * -> *} {a} {b}.
Functor f =>
(Identity a -> b) -> f a -> f b
conv Identity SpecTerm -> SpecifyBlockedItem
forall (f :: * -> *). f SpecTerm -> SpecifyItem f
SIPulsestyleOnevent NonEmpty SpecTerm
st
  SIPulsestyleOndetect NonEmpty SpecTerm
st -> (Identity SpecTerm -> SpecifyBlockedItem)
-> NonEmpty SpecTerm -> NonEmpty SpecifyBlockedItem
forall {f :: * -> *} {a} {b}.
Functor f =>
(Identity a -> b) -> f a -> f b
conv Identity SpecTerm -> SpecifyBlockedItem
forall (f :: * -> *). f SpecTerm -> SpecifyItem f
SIPulsestyleOndetect NonEmpty SpecTerm
st
  SIShowcancelled NonEmpty SpecTerm
st -> (Identity SpecTerm -> SpecifyBlockedItem)
-> NonEmpty SpecTerm -> NonEmpty SpecifyBlockedItem
forall {f :: * -> *} {a} {b}.
Functor f =>
(Identity a -> b) -> f a -> f b
conv Identity SpecTerm -> SpecifyBlockedItem
forall (f :: * -> *). f SpecTerm -> SpecifyItem f
SIShowcancelled NonEmpty SpecTerm
st
  SINoshowcancelled NonEmpty SpecTerm
st -> (Identity SpecTerm -> SpecifyBlockedItem)
-> NonEmpty SpecTerm -> NonEmpty SpecifyBlockedItem
forall {f :: * -> *} {a} {b}.
Functor f =>
(Identity a -> b) -> f a -> f b
conv Identity SpecTerm -> SpecifyBlockedItem
forall (f :: * -> *). f SpecTerm -> SpecifyItem f
SINoshowcancelled NonEmpty SpecTerm
st
  SIPathDeclaration ModulePathCondition
mpc SpecPath
con Maybe Bool
pol Maybe (Expr, Maybe Bool)
eds PathDelayValue
v -> [ModulePathCondition
-> SpecPath
-> Maybe Bool
-> Maybe (Expr, Maybe Bool)
-> PathDelayValue
-> SpecifyBlockedItem
forall (f :: * -> *).
ModulePathCondition
-> SpecPath
-> Maybe Bool
-> Maybe (Expr, Maybe Bool)
-> PathDelayValue
-> SpecifyItem f
SIPathDeclaration ModulePathCondition
mpc SpecPath
con Maybe Bool
pol Maybe (Expr, Maybe Bool)
eds PathDelayValue
v]
  SISetup STCArgs
a -> [STCArgs -> SpecifyBlockedItem
forall (f :: * -> *). STCArgs -> SpecifyItem f
SISetup STCArgs
a]
  SIHold STCArgs
a -> [STCArgs -> SpecifyBlockedItem
forall (f :: * -> *). STCArgs -> SpecifyItem f
SIHold STCArgs
a]
  SISetupHold STCArgs
a STCAddArgs
aa -> [STCArgs -> STCAddArgs -> SpecifyBlockedItem
forall (f :: * -> *). STCArgs -> STCAddArgs -> SpecifyItem f
SISetupHold STCArgs
a STCAddArgs
aa]
  SIRecovery STCArgs
a -> [STCArgs -> SpecifyBlockedItem
forall (f :: * -> *). STCArgs -> SpecifyItem f
SIRecovery STCArgs
a]
  SIRemoval STCArgs
a -> [STCArgs -> SpecifyBlockedItem
forall (f :: * -> *). STCArgs -> SpecifyItem f
SIRemoval STCArgs
a]
  SIRecrem STCArgs
a STCAddArgs
aa -> [STCArgs -> STCAddArgs -> SpecifyBlockedItem
forall (f :: * -> *). STCArgs -> STCAddArgs -> SpecifyItem f
SIRecrem STCArgs
a STCAddArgs
aa]
  SISkew STCArgs
a -> [STCArgs -> SpecifyBlockedItem
forall (f :: * -> *). STCArgs -> SpecifyItem f
SISkew STCArgs
a]
  SITimeSkew STCArgs
a Maybe CExpr
ev Maybe CExpr
rem -> [STCArgs -> Maybe CExpr -> Maybe CExpr -> SpecifyBlockedItem
forall (f :: * -> *).
STCArgs -> Maybe CExpr -> Maybe CExpr -> SpecifyItem f
SITimeSkew STCArgs
a Maybe CExpr
ev Maybe CExpr
rem]
  SIFullSkew STCArgs
a Expr
tcl Maybe CExpr
ev Maybe CExpr
rem -> [STCArgs -> Expr -> Maybe CExpr -> Maybe CExpr -> SpecifyBlockedItem
forall (f :: * -> *).
STCArgs -> Expr -> Maybe CExpr -> Maybe CExpr -> SpecifyItem f
SIFullSkew STCArgs
a Expr
tcl Maybe CExpr
ev Maybe CExpr
rem]
  SIPeriod ControlledTimingCheckEvent
ref Expr
tcl Maybe Identifier
s -> [ControlledTimingCheckEvent
-> Expr -> Maybe Identifier -> SpecifyBlockedItem
forall (f :: * -> *).
ControlledTimingCheckEvent
-> Expr -> Maybe Identifier -> SpecifyItem f
SIPeriod ControlledTimingCheckEvent
ref Expr
tcl Maybe Identifier
s]
  SIWidth ControlledTimingCheckEvent
ref Expr
tcl Maybe CExpr
t Maybe Identifier
s -> [ControlledTimingCheckEvent
-> Expr -> Maybe CExpr -> Maybe Identifier -> SpecifyBlockedItem
forall (f :: * -> *).
ControlledTimingCheckEvent
-> Expr -> Maybe CExpr -> Maybe Identifier -> SpecifyItem f
SIWidth ControlledTimingCheckEvent
ref Expr
tcl Maybe CExpr
t Maybe Identifier
s]
  SINoChange TimingCheckEvent
ref TimingCheckEvent
dat MinTypMax
st MinTypMax
en Maybe Identifier
s -> [TimingCheckEvent
-> TimingCheckEvent
-> MinTypMax
-> MinTypMax
-> Maybe Identifier
-> SpecifyBlockedItem
forall (f :: * -> *).
TimingCheckEvent
-> TimingCheckEvent
-> MinTypMax
-> MinTypMax
-> Maybe Identifier
-> SpecifyItem f
SINoChange TimingCheckEvent
ref TimingCheckEvent
dat MinTypMax
st MinTypMax
en Maybe Identifier
s]
  where
    conv :: (Identity a -> b) -> f a -> f b
conv Identity a -> b
f = (a -> b) -> f a -> f b
forall a b. (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Identity a -> b
f (Identity a -> b) -> (a -> Identity a) -> a -> b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Identity a
forall a. a -> Identity a
Identity)

fromSpecBlockedItem1 :: SpecifyBlockedItem -> SpecifySingleItem
fromSpecBlockedItem1 :: SpecifyBlockedItem -> SpecifySingleItem
fromSpecBlockedItem1 SpecifyBlockedItem
x = case SpecifyBlockedItem
x of
  SISpecParam Maybe Range2
rng Identity SpecParamDecl
d -> (NonEmpty SpecParamDecl -> SpecifySingleItem)
-> Identity SpecParamDecl -> SpecifySingleItem
forall {b} {c}. (NonEmpty b -> c) -> Identity b -> c
conv (Maybe Range2 -> NonEmpty SpecParamDecl -> SpecifySingleItem
forall (f :: * -> *).
Maybe Range2 -> f SpecParamDecl -> SpecifyItem f
SISpecParam Maybe Range2
rng) Identity SpecParamDecl
d
  SIPulsestyleOnevent Identity SpecTerm
st -> (NonEmpty SpecTerm -> SpecifySingleItem)
-> Identity SpecTerm -> SpecifySingleItem
forall {b} {c}. (NonEmpty b -> c) -> Identity b -> c
conv NonEmpty SpecTerm -> SpecifySingleItem
forall (f :: * -> *). f SpecTerm -> SpecifyItem f
SIPulsestyleOnevent Identity SpecTerm
st
  SIPulsestyleOndetect Identity SpecTerm
st -> (NonEmpty SpecTerm -> SpecifySingleItem)
-> Identity SpecTerm -> SpecifySingleItem
forall {b} {c}. (NonEmpty b -> c) -> Identity b -> c
conv NonEmpty SpecTerm -> SpecifySingleItem
forall (f :: * -> *). f SpecTerm -> SpecifyItem f
SIPulsestyleOndetect Identity SpecTerm
st
  SIShowcancelled Identity SpecTerm
st -> (NonEmpty SpecTerm -> SpecifySingleItem)
-> Identity SpecTerm -> SpecifySingleItem
forall {b} {c}. (NonEmpty b -> c) -> Identity b -> c
conv NonEmpty SpecTerm -> SpecifySingleItem
forall (f :: * -> *). f SpecTerm -> SpecifyItem f
SIShowcancelled Identity SpecTerm
st
  SINoshowcancelled Identity SpecTerm
st -> (NonEmpty SpecTerm -> SpecifySingleItem)
-> Identity SpecTerm -> SpecifySingleItem
forall {b} {c}. (NonEmpty b -> c) -> Identity b -> c
conv NonEmpty SpecTerm -> SpecifySingleItem
forall (f :: * -> *). f SpecTerm -> SpecifyItem f
SINoshowcancelled Identity SpecTerm
st
  SIPathDeclaration ModulePathCondition
mpc SpecPath
con Maybe Bool
pol Maybe (Expr, Maybe Bool)
eds PathDelayValue
v -> ModulePathCondition
-> SpecPath
-> Maybe Bool
-> Maybe (Expr, Maybe Bool)
-> PathDelayValue
-> SpecifySingleItem
forall (f :: * -> *).
ModulePathCondition
-> SpecPath
-> Maybe Bool
-> Maybe (Expr, Maybe Bool)
-> PathDelayValue
-> SpecifyItem f
SIPathDeclaration ModulePathCondition
mpc SpecPath
con Maybe Bool
pol Maybe (Expr, Maybe Bool)
eds PathDelayValue
v
  SISetup STCArgs
a -> STCArgs -> SpecifySingleItem
forall (f :: * -> *). STCArgs -> SpecifyItem f
SISetup STCArgs
a
  SIHold STCArgs
a -> STCArgs -> SpecifySingleItem
forall (f :: * -> *). STCArgs -> SpecifyItem f
SIHold STCArgs
a
  SISetupHold STCArgs
a STCAddArgs
aa -> STCArgs -> STCAddArgs -> SpecifySingleItem
forall (f :: * -> *). STCArgs -> STCAddArgs -> SpecifyItem f
SISetupHold STCArgs
a STCAddArgs
aa
  SIRecovery STCArgs
a -> STCArgs -> SpecifySingleItem
forall (f :: * -> *). STCArgs -> SpecifyItem f
SIRecovery STCArgs
a
  SIRemoval STCArgs
a -> STCArgs -> SpecifySingleItem
forall (f :: * -> *). STCArgs -> SpecifyItem f
SIRemoval STCArgs
a
  SIRecrem STCArgs
a STCAddArgs
aa -> STCArgs -> STCAddArgs -> SpecifySingleItem
forall (f :: * -> *). STCArgs -> STCAddArgs -> SpecifyItem f
SIRecrem STCArgs
a STCAddArgs
aa
  SISkew STCArgs
a -> STCArgs -> SpecifySingleItem
forall (f :: * -> *). STCArgs -> SpecifyItem f
SISkew STCArgs
a
  SITimeSkew STCArgs
a Maybe CExpr
ev Maybe CExpr
rem -> STCArgs -> Maybe CExpr -> Maybe CExpr -> SpecifySingleItem
forall (f :: * -> *).
STCArgs -> Maybe CExpr -> Maybe CExpr -> SpecifyItem f
SITimeSkew STCArgs
a Maybe CExpr
ev Maybe CExpr
rem
  SIFullSkew STCArgs
a Expr
tcl Maybe CExpr
ev Maybe CExpr
rem -> STCArgs -> Expr -> Maybe CExpr -> Maybe CExpr -> SpecifySingleItem
forall (f :: * -> *).
STCArgs -> Expr -> Maybe CExpr -> Maybe CExpr -> SpecifyItem f
SIFullSkew STCArgs
a Expr
tcl Maybe CExpr
ev Maybe CExpr
rem
  SIPeriod ControlledTimingCheckEvent
ref Expr
tcl Maybe Identifier
s -> ControlledTimingCheckEvent
-> Expr -> Maybe Identifier -> SpecifySingleItem
forall (f :: * -> *).
ControlledTimingCheckEvent
-> Expr -> Maybe Identifier -> SpecifyItem f
SIPeriod ControlledTimingCheckEvent
ref Expr
tcl Maybe Identifier
s
  SIWidth ControlledTimingCheckEvent
ref Expr
tcl Maybe CExpr
t Maybe Identifier
s -> ControlledTimingCheckEvent
-> Expr -> Maybe CExpr -> Maybe Identifier -> SpecifySingleItem
forall (f :: * -> *).
ControlledTimingCheckEvent
-> Expr -> Maybe CExpr -> Maybe Identifier -> SpecifyItem f
SIWidth ControlledTimingCheckEvent
ref Expr
tcl Maybe CExpr
t Maybe Identifier
s
  SINoChange TimingCheckEvent
ref TimingCheckEvent
dat MinTypMax
st MinTypMax
en Maybe Identifier
s -> TimingCheckEvent
-> TimingCheckEvent
-> MinTypMax
-> MinTypMax
-> Maybe Identifier
-> SpecifySingleItem
forall (f :: * -> *).
TimingCheckEvent
-> TimingCheckEvent
-> MinTypMax
-> MinTypMax
-> Maybe Identifier
-> SpecifyItem f
SINoChange TimingCheckEvent
ref TimingCheckEvent
dat MinTypMax
st MinTypMax
en Maybe Identifier
s
  where
    conv :: (NonEmpty b -> c) -> Identity b -> c
conv NonEmpty b -> c
f = NonEmpty b -> c
f (NonEmpty b -> c) -> (Identity b -> NonEmpty b) -> Identity b -> c
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (b -> [b] -> NonEmpty b
forall a. a -> [a] -> NonEmpty a
:|[]) (b -> NonEmpty b) -> (Identity b -> b) -> Identity b -> NonEmpty b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Identity b -> b
forall a. Identity a -> a
runIdentity

fromSpecBlockedItem_add :: SpecifyBlockedItem -> SpecifySingleItem -> Maybe SpecifySingleItem
fromSpecBlockedItem_add :: SpecifyBlockedItem -> SpecifySingleItem -> Maybe SpecifySingleItem
fromSpecBlockedItem_add SpecifyBlockedItem
x SpecifySingleItem
y = case (SpecifyBlockedItem
x, SpecifySingleItem
y) of
  (SISpecParam Maybe Range2
nrng Identity SpecParamDecl
d, SISpecParam Maybe Range2
rng NonEmpty SpecParamDecl
l) | Maybe Range2
nrng Maybe Range2 -> Maybe Range2 -> Bool
forall a. Eq a => a -> a -> Bool
== Maybe Range2
rng-> (NonEmpty SpecParamDecl -> SpecifySingleItem)
-> Identity SpecParamDecl
-> NonEmpty SpecParamDecl
-> Maybe SpecifySingleItem
forall {a} {a}.
(NonEmpty a -> a) -> Identity a -> NonEmpty a -> Maybe a
add (Maybe Range2 -> NonEmpty SpecParamDecl -> SpecifySingleItem
forall (f :: * -> *).
Maybe Range2 -> f SpecParamDecl -> SpecifyItem f
SISpecParam Maybe Range2
rng) Identity SpecParamDecl
d NonEmpty SpecParamDecl
l
  (SIPulsestyleOnevent Identity SpecTerm
st, SIPulsestyleOnevent NonEmpty SpecTerm
l) -> (NonEmpty SpecTerm -> SpecifySingleItem)
-> Identity SpecTerm
-> NonEmpty SpecTerm
-> Maybe SpecifySingleItem
forall {a} {a}.
(NonEmpty a -> a) -> Identity a -> NonEmpty a -> Maybe a
add NonEmpty SpecTerm -> SpecifySingleItem
forall (f :: * -> *). f SpecTerm -> SpecifyItem f
SIPulsestyleOnevent Identity SpecTerm
st NonEmpty SpecTerm
l
  (SIPulsestyleOndetect Identity SpecTerm
st, SIPulsestyleOndetect NonEmpty SpecTerm
l) -> (NonEmpty SpecTerm -> SpecifySingleItem)
-> Identity SpecTerm
-> NonEmpty SpecTerm
-> Maybe SpecifySingleItem
forall {a} {a}.
(NonEmpty a -> a) -> Identity a -> NonEmpty a -> Maybe a
add NonEmpty SpecTerm -> SpecifySingleItem
forall (f :: * -> *). f SpecTerm -> SpecifyItem f
SIPulsestyleOndetect Identity SpecTerm
st NonEmpty SpecTerm
l
  (SIShowcancelled Identity SpecTerm
st, SIShowcancelled NonEmpty SpecTerm
l) -> (NonEmpty SpecTerm -> SpecifySingleItem)
-> Identity SpecTerm
-> NonEmpty SpecTerm
-> Maybe SpecifySingleItem
forall {a} {a}.
(NonEmpty a -> a) -> Identity a -> NonEmpty a -> Maybe a
add NonEmpty SpecTerm -> SpecifySingleItem
forall (f :: * -> *). f SpecTerm -> SpecifyItem f
SIShowcancelled Identity SpecTerm
st NonEmpty SpecTerm
l
  (SINoshowcancelled Identity SpecTerm
st, SINoshowcancelled NonEmpty SpecTerm
l) -> (NonEmpty SpecTerm -> SpecifySingleItem)
-> Identity SpecTerm
-> NonEmpty SpecTerm
-> Maybe SpecifySingleItem
forall {a} {a}.
(NonEmpty a -> a) -> Identity a -> NonEmpty a -> Maybe a
add NonEmpty SpecTerm -> SpecifySingleItem
forall (f :: * -> *). f SpecTerm -> SpecifyItem f
SINoshowcancelled Identity SpecTerm
st NonEmpty SpecTerm
l
  (SpecifyBlockedItem, SpecifySingleItem)
_ -> Maybe SpecifySingleItem
forall a. Maybe a
Nothing
  where
    add :: (NonEmpty a -> a) -> Identity a -> NonEmpty a -> Maybe a
add NonEmpty a -> a
f Identity a
x NonEmpty a
y = a -> Maybe a
forall a. a -> Maybe a
Just (a -> Maybe a) -> a -> Maybe a
forall a b. (a -> b) -> a -> b
$ NonEmpty a -> a
f (NonEmpty a -> a) -> NonEmpty a -> a
forall a b. (a -> b) -> a -> b
$ Identity a -> a
forall a. Identity a -> a
runIdentity Identity a
x a -> NonEmpty a -> NonEmpty a
forall a. a -> NonEmpty a -> NonEmpty a
<| NonEmpty a
y

-- | Converts `SpecifyBlockedItem`s into `SpecifySingleItem`s
fromSpecBlockedItem :: [SpecifyBlockedItem] -> [SpecifySingleItem]
fromSpecBlockedItem :: [SpecifyBlockedItem] -> [SpecifySingleItem]
fromSpecBlockedItem = [SpecifySingleItem]
-> (NonEmpty SpecifyBlockedItem -> [SpecifySingleItem])
-> [SpecifyBlockedItem]
-> [SpecifySingleItem]
forall b a. b -> (NonEmpty a -> b) -> [a] -> b
nonEmpty [] ((NonEmpty SpecifyBlockedItem -> [SpecifySingleItem])
 -> [SpecifyBlockedItem] -> [SpecifySingleItem])
-> (NonEmpty SpecifyBlockedItem -> [SpecifySingleItem])
-> [SpecifyBlockedItem]
-> [SpecifySingleItem]
forall a b. (a -> b) -> a -> b
$ NonEmpty SpecifySingleItem -> [SpecifySingleItem]
forall a. NonEmpty a -> [a]
toList (NonEmpty SpecifySingleItem -> [SpecifySingleItem])
-> (NonEmpty SpecifyBlockedItem -> NonEmpty SpecifySingleItem)
-> NonEmpty SpecifyBlockedItem
-> [SpecifySingleItem]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (SpecifyBlockedItem -> SpecifySingleItem)
-> (SpecifyBlockedItem
    -> SpecifySingleItem -> Maybe SpecifySingleItem)
-> NonEmpty SpecifyBlockedItem
-> NonEmpty SpecifySingleItem
forall x y.
(x -> y) -> (x -> y -> Maybe y) -> NonEmpty x -> NonEmpty y
regroup SpecifyBlockedItem -> SpecifySingleItem
fromSpecBlockedItem1 SpecifyBlockedItem -> SpecifySingleItem -> Maybe SpecifySingleItem
fromSpecBlockedItem_add

-- | Converts `ModGenSingleItem` into `ModGenBlockedItem`s
toMGBlockedItem :: ModGenSingleItem -> NonEmpty ModGenBlockedItem
toMGBlockedItem :: ModGenSingleItem -> NonEmpty ModGenBlockedItem
toMGBlockedItem ModGenSingleItem
x = case ModGenSingleItem
x of
  MGINetInit NetType
nt DriveStrength
ds NetProp
np NonEmpty NetInit
ni -> (Identity NetInit -> ModGenBlockedItem)
-> NonEmpty NetInit -> NonEmpty ModGenBlockedItem
forall {f :: * -> *} {a} {b}.
Functor f =>
(Identity a -> b) -> f a -> f b
conv (NetType
-> DriveStrength
-> NetProp
-> Identity NetInit
-> ModGenBlockedItem
forall (f :: * -> *).
NetType -> DriveStrength -> NetProp -> f NetInit -> ModGenItem f
MGINetInit NetType
nt DriveStrength
ds NetProp
np) NonEmpty NetInit
ni
  MGINetDecl NetType
nt NetProp
np NonEmpty NetDecl
nd -> (Identity NetDecl -> ModGenBlockedItem)
-> NonEmpty NetDecl -> NonEmpty ModGenBlockedItem
forall {f :: * -> *} {a} {b}.
Functor f =>
(Identity a -> b) -> f a -> f b
conv (NetType -> NetProp -> Identity NetDecl -> ModGenBlockedItem
forall (f :: * -> *).
NetType -> NetProp -> f NetDecl -> ModGenItem f
MGINetDecl NetType
nt NetProp
np) NonEmpty NetDecl
nd
  MGITriD DriveStrength
ds NetProp
np NonEmpty NetInit
ni -> (Identity NetInit -> ModGenBlockedItem)
-> NonEmpty NetInit -> NonEmpty ModGenBlockedItem
forall {f :: * -> *} {a} {b}.
Functor f =>
(Identity a -> b) -> f a -> f b
conv (DriveStrength -> NetProp -> Identity NetInit -> ModGenBlockedItem
forall (f :: * -> *).
DriveStrength -> NetProp -> f NetInit -> ModGenItem f
MGITriD DriveStrength
ds NetProp
np) NonEmpty NetInit
ni
  MGITriC ChargeStrength
cs NetProp
np NonEmpty NetDecl
nd -> (Identity NetDecl -> ModGenBlockedItem)
-> NonEmpty NetDecl -> NonEmpty ModGenBlockedItem
forall {f :: * -> *} {a} {b}.
Functor f =>
(Identity a -> b) -> f a -> f b
conv (ChargeStrength -> NetProp -> Identity NetDecl -> ModGenBlockedItem
forall (f :: * -> *).
ChargeStrength -> NetProp -> f NetDecl -> ModGenItem f
MGITriC ChargeStrength
cs NetProp
np) NonEmpty NetDecl
nd
  MGIBlockDecl BlockDecl (Compose NonEmpty Identified) (Either [Range2] CExpr)
d -> (BlockDecl (Compose Identity Identified) (Either [Range2] CExpr)
 -> ModGenBlockedItem)
-> NonEmpty
     (BlockDecl (Compose Identity Identified) (Either [Range2] CExpr))
-> NonEmpty ModGenBlockedItem
forall a b. (a -> b) -> NonEmpty a -> NonEmpty b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap BlockDecl (Compose Identity Identified) (Either [Range2] CExpr)
-> ModGenBlockedItem
forall (f :: * -> *).
BlockDecl (Compose f Identified) (Either [Range2] CExpr)
-> ModGenItem f
MGIBlockDecl (NonEmpty
   (BlockDecl (Compose Identity Identified) (Either [Range2] CExpr))
 -> NonEmpty ModGenBlockedItem)
-> NonEmpty
     (BlockDecl (Compose Identity Identified) (Either [Range2] CExpr))
-> NonEmpty ModGenBlockedItem
forall a b. (a -> b) -> a -> b
$ BlockDecl (Compose NonEmpty Identified) (Either [Range2] CExpr)
-> NonEmpty
     (BlockDecl (Compose Identity Identified) (Either [Range2] CExpr))
forall t. BD NonEmpty t -> NonEmpty (BD Identity t)
toMGIBlockDecl BlockDecl (Compose NonEmpty Identified) (Either [Range2] CExpr)
d
  MGIGenVar NonEmpty Identifier
i -> (Identity Identifier -> ModGenBlockedItem)
-> NonEmpty Identifier -> NonEmpty ModGenBlockedItem
forall {f :: * -> *} {a} {b}.
Functor f =>
(Identity a -> b) -> f a -> f b
conv Identity Identifier -> ModGenBlockedItem
forall (f :: * -> *). f Identifier -> ModGenItem f
MGIGenVar NonEmpty Identifier
i
  MGITask Bool
b Identifier
i [AttrIded (TFBlockDecl Dir)]
d MybStmt
s -> [Bool
-> Identifier
-> [AttrIded (TFBlockDecl Dir)]
-> MybStmt
-> ModGenBlockedItem
forall (f :: * -> *).
Bool
-> Identifier
-> [AttrIded (TFBlockDecl Dir)]
-> MybStmt
-> ModGenItem f
MGITask Bool
b Identifier
i [AttrIded (TFBlockDecl Dir)]
d MybStmt
s]
  MGIFunc Bool
b Maybe (ComType ())
t Identifier
i [AttrIded (TFBlockDecl ())]
d FunctionStatement
s -> [Bool
-> Maybe (ComType ())
-> Identifier
-> [AttrIded (TFBlockDecl ())]
-> FunctionStatement
-> ModGenBlockedItem
forall (f :: * -> *).
Bool
-> Maybe (ComType ())
-> Identifier
-> [AttrIded (TFBlockDecl ())]
-> FunctionStatement
-> ModGenItem f
MGIFunc Bool
b Maybe (ComType ())
t Identifier
i [AttrIded (TFBlockDecl ())]
d FunctionStatement
s]
  MGIDefParam NonEmpty ParamOver
po -> (Identity ParamOver -> ModGenBlockedItem)
-> NonEmpty ParamOver -> NonEmpty ModGenBlockedItem
forall {f :: * -> *} {a} {b}.
Functor f =>
(Identity a -> b) -> f a -> f b
conv Identity ParamOver -> ModGenBlockedItem
forall (f :: * -> *). f ParamOver -> ModGenItem f
MGIDefParam NonEmpty ParamOver
po
  MGIContAss DriveStrength
ds Maybe Delay3
d3 NonEmpty NetAssign
na -> (Identity NetAssign -> ModGenBlockedItem)
-> NonEmpty NetAssign -> NonEmpty ModGenBlockedItem
forall {f :: * -> *} {a} {b}.
Functor f =>
(Identity a -> b) -> f a -> f b
conv (DriveStrength
-> Maybe Delay3 -> Identity NetAssign -> ModGenBlockedItem
forall (f :: * -> *).
DriveStrength -> Maybe Delay3 -> f NetAssign -> ModGenItem f
MGIContAss DriveStrength
ds Maybe Delay3
d3) NonEmpty NetAssign
na
  MGICMos Bool
r Maybe Delay3
d3 NonEmpty GICMos
l -> (Identity GICMos -> ModGenBlockedItem)
-> NonEmpty GICMos -> NonEmpty ModGenBlockedItem
forall {f :: * -> *} {a} {b}.
Functor f =>
(Identity a -> b) -> f a -> f b
conv (Bool -> Maybe Delay3 -> Identity GICMos -> ModGenBlockedItem
forall (f :: * -> *).
Bool -> Maybe Delay3 -> f GICMos -> ModGenItem f
MGICMos Bool
r Maybe Delay3
d3) NonEmpty GICMos
l
  MGIEnable Bool
r Bool
b DriveStrength
ds Maybe Delay3
d3 NonEmpty GIEnable
l -> (Identity GIEnable -> ModGenBlockedItem)
-> NonEmpty GIEnable -> NonEmpty ModGenBlockedItem
forall {f :: * -> *} {a} {b}.
Functor f =>
(Identity a -> b) -> f a -> f b
conv (Bool
-> Bool
-> DriveStrength
-> Maybe Delay3
-> Identity GIEnable
-> ModGenBlockedItem
forall (f :: * -> *).
Bool
-> Bool
-> DriveStrength
-> Maybe Delay3
-> f GIEnable
-> ModGenItem f
MGIEnable Bool
r Bool
b DriveStrength
ds Maybe Delay3
d3) NonEmpty GIEnable
l
  MGIMos Bool
r Bool
np Maybe Delay3
d3 NonEmpty GIMos
l -> (Identity GIMos -> ModGenBlockedItem)
-> NonEmpty GIMos -> NonEmpty ModGenBlockedItem
forall {f :: * -> *} {a} {b}.
Functor f =>
(Identity a -> b) -> f a -> f b
conv (Bool -> Bool -> Maybe Delay3 -> Identity GIMos -> ModGenBlockedItem
forall (f :: * -> *).
Bool -> Bool -> Maybe Delay3 -> f GIMos -> ModGenItem f
MGIMos Bool
r Bool
np Maybe Delay3
d3) NonEmpty GIMos
l
  MGINIn NInputType
nt Bool
n DriveStrength
ds Maybe Delay2
d2 NonEmpty GINIn
l -> (Identity GINIn -> ModGenBlockedItem)
-> NonEmpty GINIn -> NonEmpty ModGenBlockedItem
forall {f :: * -> *} {a} {b}.
Functor f =>
(Identity a -> b) -> f a -> f b
conv (NInputType
-> Bool
-> DriveStrength
-> Maybe Delay2
-> Identity GINIn
-> ModGenBlockedItem
forall (f :: * -> *).
NInputType
-> Bool -> DriveStrength -> Maybe Delay2 -> f GINIn -> ModGenItem f
MGINIn NInputType
nt Bool
n DriveStrength
ds Maybe Delay2
d2) NonEmpty GINIn
l
  MGINOut Bool
r DriveStrength
ds Maybe Delay2
d2 NonEmpty GINOut
l -> (Identity GINOut -> ModGenBlockedItem)
-> NonEmpty GINOut -> NonEmpty ModGenBlockedItem
forall {f :: * -> *} {a} {b}.
Functor f =>
(Identity a -> b) -> f a -> f b
conv (Bool
-> DriveStrength
-> Maybe Delay2
-> Identity GINOut
-> ModGenBlockedItem
forall (f :: * -> *).
Bool -> DriveStrength -> Maybe Delay2 -> f GINOut -> ModGenItem f
MGINOut Bool
r DriveStrength
ds Maybe Delay2
d2) NonEmpty GINOut
l
  MGIPassEn Bool
r Bool
b Maybe Delay2
d2 NonEmpty GIPassEn
l -> (Identity GIPassEn -> ModGenBlockedItem)
-> NonEmpty GIPassEn -> NonEmpty ModGenBlockedItem
forall {f :: * -> *} {a} {b}.
Functor f =>
(Identity a -> b) -> f a -> f b
conv (Bool
-> Bool -> Maybe Delay2 -> Identity GIPassEn -> ModGenBlockedItem
forall (f :: * -> *).
Bool -> Bool -> Maybe Delay2 -> f GIPassEn -> ModGenItem f
MGIPassEn Bool
r Bool
b Maybe Delay2
d2) NonEmpty GIPassEn
l
  MGIPass Bool
r NonEmpty GIPass
l -> (Identity GIPass -> ModGenBlockedItem)
-> NonEmpty GIPass -> NonEmpty ModGenBlockedItem
forall {f :: * -> *} {a} {b}.
Functor f =>
(Identity a -> b) -> f a -> f b
conv (Bool -> Identity GIPass -> ModGenBlockedItem
forall (f :: * -> *). Bool -> f GIPass -> ModGenItem f
MGIPass Bool
r) NonEmpty GIPass
l
  MGIPull Bool
b DriveStrength
ds NonEmpty GIPull
l -> (Identity GIPull -> ModGenBlockedItem)
-> NonEmpty GIPull -> NonEmpty ModGenBlockedItem
forall {f :: * -> *} {a} {b}.
Functor f =>
(Identity a -> b) -> f a -> f b
conv (Bool -> DriveStrength -> Identity GIPull -> ModGenBlockedItem
forall (f :: * -> *).
Bool -> DriveStrength -> f GIPull -> ModGenItem f
MGIPull Bool
b DriveStrength
ds) NonEmpty GIPull
l
  MGIUDPInst Identifier
udp DriveStrength
ds Maybe Delay2
d2 NonEmpty UDPInst
i -> (Identity UDPInst -> ModGenBlockedItem)
-> NonEmpty UDPInst -> NonEmpty ModGenBlockedItem
forall {f :: * -> *} {a} {b}.
Functor f =>
(Identity a -> b) -> f a -> f b
conv (Identifier
-> DriveStrength
-> Maybe Delay2
-> Identity UDPInst
-> ModGenBlockedItem
forall (f :: * -> *).
Identifier
-> DriveStrength -> Maybe Delay2 -> f UDPInst -> ModGenItem f
MGIUDPInst Identifier
udp DriveStrength
ds Maybe Delay2
d2) NonEmpty UDPInst
i
  MGIModInst Identifier
mod ParamAssign
pa NonEmpty ModInst
i -> (Identity ModInst -> ModGenBlockedItem)
-> NonEmpty ModInst -> NonEmpty ModGenBlockedItem
forall {f :: * -> *} {a} {b}.
Functor f =>
(Identity a -> b) -> f a -> f b
conv (Identifier -> ParamAssign -> Identity ModInst -> ModGenBlockedItem
forall (f :: * -> *).
Identifier -> ParamAssign -> f ModInst -> ModGenItem f
MGIModInst Identifier
mod ParamAssign
pa) NonEmpty ModInst
i
  MGIUnknownInst Identifier
t Maybe (Either Expr (Expr, Expr))
p NonEmpty UknInst
i -> (Identity UknInst -> ModGenBlockedItem)
-> NonEmpty UknInst -> NonEmpty ModGenBlockedItem
forall {f :: * -> *} {a} {b}.
Functor f =>
(Identity a -> b) -> f a -> f b
conv (Identifier
-> Maybe (Either Expr (Expr, Expr))
-> Identity UknInst
-> ModGenBlockedItem
forall (f :: * -> *).
Identifier
-> Maybe (Either Expr (Expr, Expr)) -> f UknInst -> ModGenItem f
MGIUnknownInst Identifier
t Maybe (Either Expr (Expr, Expr))
p) NonEmpty UknInst
i
  MGIInitial AttrStmt
s -> [AttrStmt -> ModGenBlockedItem
forall (f :: * -> *). AttrStmt -> ModGenItem f
MGIInitial AttrStmt
s]
  MGIAlways AttrStmt
s -> [AttrStmt -> ModGenBlockedItem
forall (f :: * -> *). AttrStmt -> ModGenItem f
MGIAlways AttrStmt
s]
  MGILoopGen Identifier
ii CExpr
iv CExpr
c Identifier
ui CExpr
uv GenerateBlock
b -> [Identifier
-> CExpr
-> CExpr
-> Identifier
-> CExpr
-> GenerateBlock
-> ModGenBlockedItem
forall (f :: * -> *).
Identifier
-> CExpr
-> CExpr
-> Identifier
-> CExpr
-> GenerateBlock
-> ModGenItem f
MGILoopGen Identifier
ii CExpr
iv CExpr
c Identifier
ui CExpr
uv GenerateBlock
b]
  MGICondItem ModGenCondItem
ci -> [ModGenCondItem -> ModGenBlockedItem
forall (f :: * -> *). ModGenCondItem -> ModGenItem f
MGICondItem ModGenCondItem
ci]
  where
    conv :: (Identity a -> b) -> f a -> f b
conv Identity a -> b
f = (a -> b) -> f a -> f b
forall a b. (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Identity a -> b
f (Identity a -> b) -> (a -> Identity a) -> a -> b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Identity a
forall a. a -> Identity a
Identity)

fromMGBlockedItem1 :: ModGenBlockedItem -> ModGenSingleItem
fromMGBlockedItem1 :: ModGenBlockedItem -> ModGenSingleItem
fromMGBlockedItem1 ModGenBlockedItem
x = case ModGenBlockedItem
x of
  MGINetInit NetType
nt DriveStrength
ds NetProp
np Identity NetInit
ni -> (NonEmpty NetInit -> ModGenSingleItem)
-> Identity NetInit -> ModGenSingleItem
forall {b} {c}. (NonEmpty b -> c) -> Identity b -> c
conv (NetType
-> DriveStrength -> NetProp -> NonEmpty NetInit -> ModGenSingleItem
forall (f :: * -> *).
NetType -> DriveStrength -> NetProp -> f NetInit -> ModGenItem f
MGINetInit NetType
nt DriveStrength
ds NetProp
np) Identity NetInit
ni
  MGINetDecl NetType
nt NetProp
np Identity NetDecl
nd -> (NonEmpty NetDecl -> ModGenSingleItem)
-> Identity NetDecl -> ModGenSingleItem
forall {b} {c}. (NonEmpty b -> c) -> Identity b -> c
conv (NetType -> NetProp -> NonEmpty NetDecl -> ModGenSingleItem
forall (f :: * -> *).
NetType -> NetProp -> f NetDecl -> ModGenItem f
MGINetDecl NetType
nt NetProp
np) Identity NetDecl
nd
  MGITriD DriveStrength
ds NetProp
np Identity NetInit
ni -> (NonEmpty NetInit -> ModGenSingleItem)
-> Identity NetInit -> ModGenSingleItem
forall {b} {c}. (NonEmpty b -> c) -> Identity b -> c
conv (DriveStrength -> NetProp -> NonEmpty NetInit -> ModGenSingleItem
forall (f :: * -> *).
DriveStrength -> NetProp -> f NetInit -> ModGenItem f
MGITriD DriveStrength
ds NetProp
np) Identity NetInit
ni
  MGITriC ChargeStrength
cs NetProp
np Identity NetDecl
nd -> (NonEmpty NetDecl -> ModGenSingleItem)
-> Identity NetDecl -> ModGenSingleItem
forall {b} {c}. (NonEmpty b -> c) -> Identity b -> c
conv (ChargeStrength -> NetProp -> NonEmpty NetDecl -> ModGenSingleItem
forall (f :: * -> *).
ChargeStrength -> NetProp -> f NetDecl -> ModGenItem f
MGITriC ChargeStrength
cs NetProp
np) Identity NetDecl
nd
  MGIBlockDecl BlockDecl (Compose Identity Identified) (Either [Range2] CExpr)
d -> BlockDecl (Compose NonEmpty Identified) (Either [Range2] CExpr)
-> ModGenSingleItem
forall (f :: * -> *).
BlockDecl (Compose f Identified) (Either [Range2] CExpr)
-> ModGenItem f
MGIBlockDecl (BlockDecl (Compose NonEmpty Identified) (Either [Range2] CExpr)
 -> ModGenSingleItem)
-> BlockDecl (Compose NonEmpty Identified) (Either [Range2] CExpr)
-> ModGenSingleItem
forall a b. (a -> b) -> a -> b
$ BlockDecl (Compose Identity Identified) (Either [Range2] CExpr)
-> BlockDecl (Compose NonEmpty Identified) (Either [Range2] CExpr)
forall t. BD Identity t -> BD NonEmpty t
fromMGIBlockDecl1 BlockDecl (Compose Identity Identified) (Either [Range2] CExpr)
d
  MGIGenVar Identity Identifier
i -> (NonEmpty Identifier -> ModGenSingleItem)
-> Identity Identifier -> ModGenSingleItem
forall {b} {c}. (NonEmpty b -> c) -> Identity b -> c
conv NonEmpty Identifier -> ModGenSingleItem
forall (f :: * -> *). f Identifier -> ModGenItem f
MGIGenVar Identity Identifier
i
  MGITask Bool
b Identifier
i [AttrIded (TFBlockDecl Dir)]
d MybStmt
s -> Bool
-> Identifier
-> [AttrIded (TFBlockDecl Dir)]
-> MybStmt
-> ModGenSingleItem
forall (f :: * -> *).
Bool
-> Identifier
-> [AttrIded (TFBlockDecl Dir)]
-> MybStmt
-> ModGenItem f
MGITask Bool
b Identifier
i [AttrIded (TFBlockDecl Dir)]
d MybStmt
s
  MGIFunc Bool
b Maybe (ComType ())
t Identifier
i [AttrIded (TFBlockDecl ())]
d FunctionStatement
s -> Bool
-> Maybe (ComType ())
-> Identifier
-> [AttrIded (TFBlockDecl ())]
-> FunctionStatement
-> ModGenSingleItem
forall (f :: * -> *).
Bool
-> Maybe (ComType ())
-> Identifier
-> [AttrIded (TFBlockDecl ())]
-> FunctionStatement
-> ModGenItem f
MGIFunc Bool
b Maybe (ComType ())
t Identifier
i [AttrIded (TFBlockDecl ())]
d FunctionStatement
s
  MGIDefParam Identity ParamOver
po -> (NonEmpty ParamOver -> ModGenSingleItem)
-> Identity ParamOver -> ModGenSingleItem
forall {b} {c}. (NonEmpty b -> c) -> Identity b -> c
conv NonEmpty ParamOver -> ModGenSingleItem
forall (f :: * -> *). f ParamOver -> ModGenItem f
MGIDefParam Identity ParamOver
po
  MGIContAss DriveStrength
ds Maybe Delay3
d3 Identity NetAssign
na -> (NonEmpty NetAssign -> ModGenSingleItem)
-> Identity NetAssign -> ModGenSingleItem
forall {b} {c}. (NonEmpty b -> c) -> Identity b -> c
conv (DriveStrength
-> Maybe Delay3 -> NonEmpty NetAssign -> ModGenSingleItem
forall (f :: * -> *).
DriveStrength -> Maybe Delay3 -> f NetAssign -> ModGenItem f
MGIContAss DriveStrength
ds Maybe Delay3
d3) Identity NetAssign
na
  MGICMos Bool
r Maybe Delay3
d3 Identity GICMos
i -> (NonEmpty GICMos -> ModGenSingleItem)
-> Identity GICMos -> ModGenSingleItem
forall {b} {c}. (NonEmpty b -> c) -> Identity b -> c
conv (Bool -> Maybe Delay3 -> NonEmpty GICMos -> ModGenSingleItem
forall (f :: * -> *).
Bool -> Maybe Delay3 -> f GICMos -> ModGenItem f
MGICMos Bool
r Maybe Delay3
d3) Identity GICMos
i
  MGIEnable Bool
r Bool
b DriveStrength
ds Maybe Delay3
d3 Identity GIEnable
i -> (NonEmpty GIEnable -> ModGenSingleItem)
-> Identity GIEnable -> ModGenSingleItem
forall {b} {c}. (NonEmpty b -> c) -> Identity b -> c
conv (Bool
-> Bool
-> DriveStrength
-> Maybe Delay3
-> NonEmpty GIEnable
-> ModGenSingleItem
forall (f :: * -> *).
Bool
-> Bool
-> DriveStrength
-> Maybe Delay3
-> f GIEnable
-> ModGenItem f
MGIEnable Bool
r Bool
b DriveStrength
ds Maybe Delay3
d3) Identity GIEnable
i
  MGIMos Bool
r Bool
np Maybe Delay3
d3 Identity GIMos
i -> (NonEmpty GIMos -> ModGenSingleItem)
-> Identity GIMos -> ModGenSingleItem
forall {b} {c}. (NonEmpty b -> c) -> Identity b -> c
conv (Bool -> Bool -> Maybe Delay3 -> NonEmpty GIMos -> ModGenSingleItem
forall (f :: * -> *).
Bool -> Bool -> Maybe Delay3 -> f GIMos -> ModGenItem f
MGIMos Bool
r Bool
np Maybe Delay3
d3) Identity GIMos
i
  MGINIn NInputType
nt Bool
n DriveStrength
ds Maybe Delay2
d2 Identity GINIn
i -> (NonEmpty GINIn -> ModGenSingleItem)
-> Identity GINIn -> ModGenSingleItem
forall {b} {c}. (NonEmpty b -> c) -> Identity b -> c
conv (NInputType
-> Bool
-> DriveStrength
-> Maybe Delay2
-> NonEmpty GINIn
-> ModGenSingleItem
forall (f :: * -> *).
NInputType
-> Bool -> DriveStrength -> Maybe Delay2 -> f GINIn -> ModGenItem f
MGINIn NInputType
nt Bool
n DriveStrength
ds Maybe Delay2
d2) Identity GINIn
i
  MGINOut Bool
r DriveStrength
ds Maybe Delay2
d2 Identity GINOut
i -> (NonEmpty GINOut -> ModGenSingleItem)
-> Identity GINOut -> ModGenSingleItem
forall {b} {c}. (NonEmpty b -> c) -> Identity b -> c
conv (Bool
-> DriveStrength
-> Maybe Delay2
-> NonEmpty GINOut
-> ModGenSingleItem
forall (f :: * -> *).
Bool -> DriveStrength -> Maybe Delay2 -> f GINOut -> ModGenItem f
MGINOut Bool
r DriveStrength
ds Maybe Delay2
d2) Identity GINOut
i
  MGIPassEn Bool
r Bool
b Maybe Delay2
d2 Identity GIPassEn
i -> (NonEmpty GIPassEn -> ModGenSingleItem)
-> Identity GIPassEn -> ModGenSingleItem
forall {b} {c}. (NonEmpty b -> c) -> Identity b -> c
conv (Bool
-> Bool -> Maybe Delay2 -> NonEmpty GIPassEn -> ModGenSingleItem
forall (f :: * -> *).
Bool -> Bool -> Maybe Delay2 -> f GIPassEn -> ModGenItem f
MGIPassEn Bool
r Bool
b Maybe Delay2
d2) Identity GIPassEn
i
  MGIPass Bool
r Identity GIPass
i -> (NonEmpty GIPass -> ModGenSingleItem)
-> Identity GIPass -> ModGenSingleItem
forall {b} {c}. (NonEmpty b -> c) -> Identity b -> c
conv (Bool -> NonEmpty GIPass -> ModGenSingleItem
forall (f :: * -> *). Bool -> f GIPass -> ModGenItem f
MGIPass Bool
r) Identity GIPass
i
  MGIPull Bool
b DriveStrength
ds Identity GIPull
i -> (NonEmpty GIPull -> ModGenSingleItem)
-> Identity GIPull -> ModGenSingleItem
forall {b} {c}. (NonEmpty b -> c) -> Identity b -> c
conv (Bool -> DriveStrength -> NonEmpty GIPull -> ModGenSingleItem
forall (f :: * -> *).
Bool -> DriveStrength -> f GIPull -> ModGenItem f
MGIPull Bool
b DriveStrength
ds) Identity GIPull
i
  MGIUDPInst Identifier
udp DriveStrength
ds Maybe Delay2
d2 Identity UDPInst
i -> (NonEmpty UDPInst -> ModGenSingleItem)
-> Identity UDPInst -> ModGenSingleItem
forall {b} {c}. (NonEmpty b -> c) -> Identity b -> c
conv (Identifier
-> DriveStrength
-> Maybe Delay2
-> NonEmpty UDPInst
-> ModGenSingleItem
forall (f :: * -> *).
Identifier
-> DriveStrength -> Maybe Delay2 -> f UDPInst -> ModGenItem f
MGIUDPInst Identifier
udp DriveStrength
ds Maybe Delay2
d2) Identity UDPInst
i
  MGIModInst Identifier
mod ParamAssign
pa Identity ModInst
i -> (NonEmpty ModInst -> ModGenSingleItem)
-> Identity ModInst -> ModGenSingleItem
forall {b} {c}. (NonEmpty b -> c) -> Identity b -> c
conv (Identifier -> ParamAssign -> NonEmpty ModInst -> ModGenSingleItem
forall (f :: * -> *).
Identifier -> ParamAssign -> f ModInst -> ModGenItem f
MGIModInst Identifier
mod ParamAssign
pa) Identity ModInst
i
  MGIUnknownInst Identifier
t Maybe (Either Expr (Expr, Expr))
p Identity UknInst
i -> (NonEmpty UknInst -> ModGenSingleItem)
-> Identity UknInst -> ModGenSingleItem
forall {b} {c}. (NonEmpty b -> c) -> Identity b -> c
conv (Identifier
-> Maybe (Either Expr (Expr, Expr))
-> NonEmpty UknInst
-> ModGenSingleItem
forall (f :: * -> *).
Identifier
-> Maybe (Either Expr (Expr, Expr)) -> f UknInst -> ModGenItem f
MGIUnknownInst Identifier
t Maybe (Either Expr (Expr, Expr))
p) Identity UknInst
i
  MGIInitial AttrStmt
s -> AttrStmt -> ModGenSingleItem
forall (f :: * -> *). AttrStmt -> ModGenItem f
MGIInitial AttrStmt
s
  MGIAlways AttrStmt
s -> AttrStmt -> ModGenSingleItem
forall (f :: * -> *). AttrStmt -> ModGenItem f
MGIAlways AttrStmt
s
  MGILoopGen Identifier
ii CExpr
iv CExpr
c Identifier
ui CExpr
uv GenerateBlock
b -> Identifier
-> CExpr
-> CExpr
-> Identifier
-> CExpr
-> GenerateBlock
-> ModGenSingleItem
forall (f :: * -> *).
Identifier
-> CExpr
-> CExpr
-> Identifier
-> CExpr
-> GenerateBlock
-> ModGenItem f
MGILoopGen Identifier
ii CExpr
iv CExpr
c Identifier
ui CExpr
uv GenerateBlock
b
  MGICondItem ModGenCondItem
ci -> ModGenCondItem -> ModGenSingleItem
forall (f :: * -> *). ModGenCondItem -> ModGenItem f
MGICondItem ModGenCondItem
ci
  where
    conv :: (NonEmpty b -> c) -> Identity b -> c
conv NonEmpty b -> c
f = NonEmpty b -> c
f (NonEmpty b -> c) -> (Identity b -> NonEmpty b) -> Identity b -> c
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (b -> [b] -> NonEmpty b
forall a. a -> [a] -> NonEmpty a
:|[]) (b -> NonEmpty b) -> (Identity b -> b) -> Identity b -> NonEmpty b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Identity b -> b
forall a. Identity a -> a
runIdentity

fromMGBlockedItem_add :: ModGenBlockedItem -> ModGenSingleItem -> Maybe ModGenSingleItem
fromMGBlockedItem_add :: ModGenBlockedItem -> ModGenSingleItem -> Maybe ModGenSingleItem
fromMGBlockedItem_add ModGenBlockedItem
x ModGenSingleItem
y = case (ModGenBlockedItem
x, ModGenSingleItem
y) of
  (MGINetInit NetType
nnt DriveStrength
nds NetProp
nnp Identity NetInit
ni, MGINetInit NetType
nt DriveStrength
ds NetProp
np NonEmpty NetInit
l) | NetType
nnt NetType -> NetType -> Bool
forall a. Eq a => a -> a -> Bool
== NetType
nt Bool -> Bool -> Bool
&& DriveStrength
nds DriveStrength -> DriveStrength -> Bool
forall a. Eq a => a -> a -> Bool
== DriveStrength
ds Bool -> Bool -> Bool
&& NetProp
nnp NetProp -> NetProp -> Bool
forall a. Eq a => a -> a -> Bool
== NetProp
np ->
    (NonEmpty NetInit -> ModGenSingleItem)
-> Identity NetInit -> NonEmpty NetInit -> Maybe ModGenSingleItem
forall {a} {a}.
(NonEmpty a -> a) -> Identity a -> NonEmpty a -> Maybe a
add (NetType
-> DriveStrength -> NetProp -> NonEmpty NetInit -> ModGenSingleItem
forall (f :: * -> *).
NetType -> DriveStrength -> NetProp -> f NetInit -> ModGenItem f
MGINetInit NetType
nt DriveStrength
ds NetProp
np) Identity NetInit
ni NonEmpty NetInit
l
  (MGINetDecl NetType
nnt NetProp
nnp Identity NetDecl
nd, MGINetDecl NetType
nt NetProp
np NonEmpty NetDecl
l) | NetType
nnt NetType -> NetType -> Bool
forall a. Eq a => a -> a -> Bool
== NetType
nt Bool -> Bool -> Bool
&& NetProp
nnp NetProp -> NetProp -> Bool
forall a. Eq a => a -> a -> Bool
== NetProp
np ->
    (NonEmpty NetDecl -> ModGenSingleItem)
-> Identity NetDecl -> NonEmpty NetDecl -> Maybe ModGenSingleItem
forall {a} {a}.
(NonEmpty a -> a) -> Identity a -> NonEmpty a -> Maybe a
add (NetType -> NetProp -> NonEmpty NetDecl -> ModGenSingleItem
forall (f :: * -> *).
NetType -> NetProp -> f NetDecl -> ModGenItem f
MGINetDecl NetType
nt NetProp
np) Identity NetDecl
nd NonEmpty NetDecl
l
  (MGITriD DriveStrength
nds NetProp
nnp Identity NetInit
ni, MGITriD DriveStrength
ds NetProp
np NonEmpty NetInit
l) | DriveStrength
nds DriveStrength -> DriveStrength -> Bool
forall a. Eq a => a -> a -> Bool
== DriveStrength
ds Bool -> Bool -> Bool
&& NetProp
nnp NetProp -> NetProp -> Bool
forall a. Eq a => a -> a -> Bool
== NetProp
np -> (NonEmpty NetInit -> ModGenSingleItem)
-> Identity NetInit -> NonEmpty NetInit -> Maybe ModGenSingleItem
forall {a} {a}.
(NonEmpty a -> a) -> Identity a -> NonEmpty a -> Maybe a
add (DriveStrength -> NetProp -> NonEmpty NetInit -> ModGenSingleItem
forall (f :: * -> *).
DriveStrength -> NetProp -> f NetInit -> ModGenItem f
MGITriD DriveStrength
ds NetProp
np) Identity NetInit
ni NonEmpty NetInit
l
  (MGITriC ChargeStrength
ncs NetProp
nnp Identity NetDecl
nd, MGITriC ChargeStrength
cs NetProp
np NonEmpty NetDecl
l) | ChargeStrength
ncs ChargeStrength -> ChargeStrength -> Bool
forall a. Eq a => a -> a -> Bool
== ChargeStrength
cs Bool -> Bool -> Bool
&& NetProp
nnp NetProp -> NetProp -> Bool
forall a. Eq a => a -> a -> Bool
== NetProp
np -> (NonEmpty NetDecl -> ModGenSingleItem)
-> Identity NetDecl -> NonEmpty NetDecl -> Maybe ModGenSingleItem
forall {a} {a}.
(NonEmpty a -> a) -> Identity a -> NonEmpty a -> Maybe a
add (ChargeStrength -> NetProp -> NonEmpty NetDecl -> ModGenSingleItem
forall (f :: * -> *).
ChargeStrength -> NetProp -> f NetDecl -> ModGenItem f
MGITriC ChargeStrength
cs NetProp
np) Identity NetDecl
nd NonEmpty NetDecl
l
  (MGIBlockDecl BlockDecl (Compose Identity Identified) (Either [Range2] CExpr)
d, MGIBlockDecl BlockDecl (Compose NonEmpty Identified) (Either [Range2] CExpr)
l) -> BlockDecl (Compose NonEmpty Identified) (Either [Range2] CExpr)
-> ModGenSingleItem
forall (f :: * -> *).
BlockDecl (Compose f Identified) (Either [Range2] CExpr)
-> ModGenItem f
MGIBlockDecl (BlockDecl (Compose NonEmpty Identified) (Either [Range2] CExpr)
 -> ModGenSingleItem)
-> Maybe
     (BlockDecl (Compose NonEmpty Identified) (Either [Range2] CExpr))
-> Maybe ModGenSingleItem
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> BlockDecl (Compose Identity Identified) (Either [Range2] CExpr)
-> BlockDecl (Compose NonEmpty Identified) (Either [Range2] CExpr)
-> Maybe
     (BlockDecl (Compose NonEmpty Identified) (Either [Range2] CExpr))
forall t. BD Identity t -> BD NonEmpty t -> Maybe (BD NonEmpty t)
fromMGIBlockDecl_add BlockDecl (Compose Identity Identified) (Either [Range2] CExpr)
d BlockDecl (Compose NonEmpty Identified) (Either [Range2] CExpr)
l
  (MGIGenVar Identity Identifier
i, MGIGenVar NonEmpty Identifier
l) -> (NonEmpty Identifier -> ModGenSingleItem)
-> Identity Identifier
-> NonEmpty Identifier
-> Maybe ModGenSingleItem
forall {a} {a}.
(NonEmpty a -> a) -> Identity a -> NonEmpty a -> Maybe a
add NonEmpty Identifier -> ModGenSingleItem
forall (f :: * -> *). f Identifier -> ModGenItem f
MGIGenVar Identity Identifier
i NonEmpty Identifier
l
  (MGIDefParam Identity ParamOver
po, MGIDefParam NonEmpty ParamOver
l) -> (NonEmpty ParamOver -> ModGenSingleItem)
-> Identity ParamOver
-> NonEmpty ParamOver
-> Maybe ModGenSingleItem
forall {a} {a}.
(NonEmpty a -> a) -> Identity a -> NonEmpty a -> Maybe a
add NonEmpty ParamOver -> ModGenSingleItem
forall (f :: * -> *). f ParamOver -> ModGenItem f
MGIDefParam Identity ParamOver
po NonEmpty ParamOver
l
  (MGIContAss DriveStrength
nds Maybe Delay3
nd3 Identity NetAssign
na, MGIContAss DriveStrength
ds Maybe Delay3
d3 NonEmpty NetAssign
l) | DriveStrength
nds DriveStrength -> DriveStrength -> Bool
forall a. Eq a => a -> a -> Bool
== DriveStrength
ds Bool -> Bool -> Bool
&& Maybe Delay3
nd3 Maybe Delay3 -> Maybe Delay3 -> Bool
forall a. Eq a => a -> a -> Bool
== Maybe Delay3
d3 ->
    (NonEmpty NetAssign -> ModGenSingleItem)
-> Identity NetAssign
-> NonEmpty NetAssign
-> Maybe ModGenSingleItem
forall {a} {a}.
(NonEmpty a -> a) -> Identity a -> NonEmpty a -> Maybe a
add (DriveStrength
-> Maybe Delay3 -> NonEmpty NetAssign -> ModGenSingleItem
forall (f :: * -> *).
DriveStrength -> Maybe Delay3 -> f NetAssign -> ModGenItem f
MGIContAss DriveStrength
ds Maybe Delay3
d3) Identity NetAssign
na NonEmpty NetAssign
l
  (MGICMos Bool
nr Maybe Delay3
nd3 Identity GICMos
i, MGICMos Bool
r Maybe Delay3
d3 NonEmpty GICMos
l) | Bool
nr Bool -> Bool -> Bool
forall a. Eq a => a -> a -> Bool
== Bool
r Bool -> Bool -> Bool
&& Maybe Delay3
nd3 Maybe Delay3 -> Maybe Delay3 -> Bool
forall a. Eq a => a -> a -> Bool
== Maybe Delay3
d3 -> (NonEmpty GICMos -> ModGenSingleItem)
-> Identity GICMos -> NonEmpty GICMos -> Maybe ModGenSingleItem
forall {a} {a}.
(NonEmpty a -> a) -> Identity a -> NonEmpty a -> Maybe a
add (Bool -> Maybe Delay3 -> NonEmpty GICMos -> ModGenSingleItem
forall (f :: * -> *).
Bool -> Maybe Delay3 -> f GICMos -> ModGenItem f
MGICMos Bool
r Maybe Delay3
d3) Identity GICMos
i NonEmpty GICMos
l
  (MGIEnable Bool
nr Bool
nb DriveStrength
nds Maybe Delay3
nd3 Identity GIEnable
i, MGIEnable Bool
r Bool
b DriveStrength
ds Maybe Delay3
d3 NonEmpty GIEnable
l)
   | Bool
nr Bool -> Bool -> Bool
forall a. Eq a => a -> a -> Bool
== Bool
r Bool -> Bool -> Bool
&& Bool
nb Bool -> Bool -> Bool
forall a. Eq a => a -> a -> Bool
== Bool
b Bool -> Bool -> Bool
&& DriveStrength
nds DriveStrength -> DriveStrength -> Bool
forall a. Eq a => a -> a -> Bool
== DriveStrength
ds Bool -> Bool -> Bool
&& Maybe Delay3
nd3 Maybe Delay3 -> Maybe Delay3 -> Bool
forall a. Eq a => a -> a -> Bool
== Maybe Delay3
d3 -> (NonEmpty GIEnable -> ModGenSingleItem)
-> Identity GIEnable -> NonEmpty GIEnable -> Maybe ModGenSingleItem
forall {a} {a}.
(NonEmpty a -> a) -> Identity a -> NonEmpty a -> Maybe a
add (Bool
-> Bool
-> DriveStrength
-> Maybe Delay3
-> NonEmpty GIEnable
-> ModGenSingleItem
forall (f :: * -> *).
Bool
-> Bool
-> DriveStrength
-> Maybe Delay3
-> f GIEnable
-> ModGenItem f
MGIEnable Bool
r Bool
b DriveStrength
ds Maybe Delay3
d3) Identity GIEnable
i NonEmpty GIEnable
l
  (MGIMos Bool
nr Bool
nnp Maybe Delay3
nd3 Identity GIMos
i, MGIMos Bool
r Bool
np Maybe Delay3
d3 NonEmpty GIMos
l) | Bool
nr Bool -> Bool -> Bool
forall a. Eq a => a -> a -> Bool
== Bool
r Bool -> Bool -> Bool
&& Bool
nnp Bool -> Bool -> Bool
forall a. Eq a => a -> a -> Bool
== Bool
np Bool -> Bool -> Bool
&& Maybe Delay3
nd3 Maybe Delay3 -> Maybe Delay3 -> Bool
forall a. Eq a => a -> a -> Bool
== Maybe Delay3
d3 ->
    (NonEmpty GIMos -> ModGenSingleItem)
-> Identity GIMos -> NonEmpty GIMos -> Maybe ModGenSingleItem
forall {a} {a}.
(NonEmpty a -> a) -> Identity a -> NonEmpty a -> Maybe a
add (Bool -> Bool -> Maybe Delay3 -> NonEmpty GIMos -> ModGenSingleItem
forall (f :: * -> *).
Bool -> Bool -> Maybe Delay3 -> f GIMos -> ModGenItem f
MGIMos Bool
r Bool
np Maybe Delay3
d3) Identity GIMos
i NonEmpty GIMos
l
  (MGINIn NInputType
nnt Bool
nn DriveStrength
nds Maybe Delay2
nd2 Identity GINIn
i, MGINIn NInputType
nt Bool
n DriveStrength
ds Maybe Delay2
d2 NonEmpty GINIn
l)
    | NInputType
nnt NInputType -> NInputType -> Bool
forall a. Eq a => a -> a -> Bool
== NInputType
nt Bool -> Bool -> Bool
&& Bool
nn Bool -> Bool -> Bool
forall a. Eq a => a -> a -> Bool
== Bool
n Bool -> Bool -> Bool
&& DriveStrength
nds DriveStrength -> DriveStrength -> Bool
forall a. Eq a => a -> a -> Bool
== DriveStrength
ds Bool -> Bool -> Bool
&& Maybe Delay2
nd2 Maybe Delay2 -> Maybe Delay2 -> Bool
forall a. Eq a => a -> a -> Bool
== Maybe Delay2
d2 -> (NonEmpty GINIn -> ModGenSingleItem)
-> Identity GINIn -> NonEmpty GINIn -> Maybe ModGenSingleItem
forall {a} {a}.
(NonEmpty a -> a) -> Identity a -> NonEmpty a -> Maybe a
add (NInputType
-> Bool
-> DriveStrength
-> Maybe Delay2
-> NonEmpty GINIn
-> ModGenSingleItem
forall (f :: * -> *).
NInputType
-> Bool -> DriveStrength -> Maybe Delay2 -> f GINIn -> ModGenItem f
MGINIn NInputType
nt Bool
n DriveStrength
ds Maybe Delay2
d2) Identity GINIn
i NonEmpty GINIn
l
  (MGINOut Bool
nr DriveStrength
nds Maybe Delay2
nd2 Identity GINOut
i, MGINOut Bool
r DriveStrength
ds Maybe Delay2
d2 NonEmpty GINOut
l) | Bool
nr Bool -> Bool -> Bool
forall a. Eq a => a -> a -> Bool
== Bool
r Bool -> Bool -> Bool
&& DriveStrength
nds DriveStrength -> DriveStrength -> Bool
forall a. Eq a => a -> a -> Bool
== DriveStrength
ds Bool -> Bool -> Bool
&& Maybe Delay2
nd2 Maybe Delay2 -> Maybe Delay2 -> Bool
forall a. Eq a => a -> a -> Bool
== Maybe Delay2
d2 ->
    (NonEmpty GINOut -> ModGenSingleItem)
-> Identity GINOut -> NonEmpty GINOut -> Maybe ModGenSingleItem
forall {a} {a}.
(NonEmpty a -> a) -> Identity a -> NonEmpty a -> Maybe a
add (Bool
-> DriveStrength
-> Maybe Delay2
-> NonEmpty GINOut
-> ModGenSingleItem
forall (f :: * -> *).
Bool -> DriveStrength -> Maybe Delay2 -> f GINOut -> ModGenItem f
MGINOut Bool
r DriveStrength
ds Maybe Delay2
d2) Identity GINOut
i NonEmpty GINOut
l
  (MGIPassEn Bool
nr Bool
nb Maybe Delay2
nd2 Identity GIPassEn
i, MGIPassEn Bool
r Bool
b Maybe Delay2
d2 NonEmpty GIPassEn
l) | Bool
nr Bool -> Bool -> Bool
forall a. Eq a => a -> a -> Bool
== Bool
r Bool -> Bool -> Bool
&& Bool
nb Bool -> Bool -> Bool
forall a. Eq a => a -> a -> Bool
== Bool
b Bool -> Bool -> Bool
&& Maybe Delay2
nd2 Maybe Delay2 -> Maybe Delay2 -> Bool
forall a. Eq a => a -> a -> Bool
== Maybe Delay2
d2 ->
    (NonEmpty GIPassEn -> ModGenSingleItem)
-> Identity GIPassEn -> NonEmpty GIPassEn -> Maybe ModGenSingleItem
forall {a} {a}.
(NonEmpty a -> a) -> Identity a -> NonEmpty a -> Maybe a
add (Bool
-> Bool -> Maybe Delay2 -> NonEmpty GIPassEn -> ModGenSingleItem
forall (f :: * -> *).
Bool -> Bool -> Maybe Delay2 -> f GIPassEn -> ModGenItem f
MGIPassEn Bool
r Bool
b Maybe Delay2
d2) Identity GIPassEn
i NonEmpty GIPassEn
l
  (MGIPass Bool
nr Identity GIPass
i, MGIPass Bool
r NonEmpty GIPass
l) | Bool
nr Bool -> Bool -> Bool
forall a. Eq a => a -> a -> Bool
== Bool
r -> (NonEmpty GIPass -> ModGenSingleItem)
-> Identity GIPass -> NonEmpty GIPass -> Maybe ModGenSingleItem
forall {a} {a}.
(NonEmpty a -> a) -> Identity a -> NonEmpty a -> Maybe a
add (Bool -> NonEmpty GIPass -> ModGenSingleItem
forall (f :: * -> *). Bool -> f GIPass -> ModGenItem f
MGIPass Bool
r) Identity GIPass
i NonEmpty GIPass
l
  (MGIPull Bool
nb DriveStrength
nds Identity GIPull
i, MGIPull Bool
b DriveStrength
ds NonEmpty GIPull
l) | Bool
nb Bool -> Bool -> Bool
forall a. Eq a => a -> a -> Bool
== Bool
b Bool -> Bool -> Bool
&& DriveStrength
nds DriveStrength -> DriveStrength -> Bool
forall a. Eq a => a -> a -> Bool
== DriveStrength
ds -> (NonEmpty GIPull -> ModGenSingleItem)
-> Identity GIPull -> NonEmpty GIPull -> Maybe ModGenSingleItem
forall {a} {a}.
(NonEmpty a -> a) -> Identity a -> NonEmpty a -> Maybe a
add (Bool -> DriveStrength -> NonEmpty GIPull -> ModGenSingleItem
forall (f :: * -> *).
Bool -> DriveStrength -> f GIPull -> ModGenItem f
MGIPull Bool
b DriveStrength
ds) Identity GIPull
i NonEmpty GIPull
l
  (MGIUDPInst Identifier
nudp DriveStrength
nds Maybe Delay2
nd2 Identity UDPInst
i, MGIUDPInst Identifier
udp DriveStrength
ds Maybe Delay2
d2 NonEmpty UDPInst
l)
    | Identifier
nudp Identifier -> Identifier -> Bool
forall a. Eq a => a -> a -> Bool
== Identifier
udp Bool -> Bool -> Bool
&& DriveStrength
nds DriveStrength -> DriveStrength -> Bool
forall a. Eq a => a -> a -> Bool
== DriveStrength
ds Bool -> Bool -> Bool
&& Maybe Delay2
nd2 Maybe Delay2 -> Maybe Delay2 -> Bool
forall a. Eq a => a -> a -> Bool
== Maybe Delay2
d2 -> (NonEmpty UDPInst -> ModGenSingleItem)
-> Identity UDPInst -> NonEmpty UDPInst -> Maybe ModGenSingleItem
forall {a} {a}.
(NonEmpty a -> a) -> Identity a -> NonEmpty a -> Maybe a
add (Identifier
-> DriveStrength
-> Maybe Delay2
-> NonEmpty UDPInst
-> ModGenSingleItem
forall (f :: * -> *).
Identifier
-> DriveStrength -> Maybe Delay2 -> f UDPInst -> ModGenItem f
MGIUDPInst Identifier
udp DriveStrength
ds Maybe Delay2
d2) Identity UDPInst
i NonEmpty UDPInst
l
  (MGIModInst Identifier
nmod ParamAssign
npa Identity ModInst
i, MGIModInst Identifier
mod ParamAssign
pa NonEmpty ModInst
l) | Identifier
nmod Identifier -> Identifier -> Bool
forall a. Eq a => a -> a -> Bool
== Identifier
mod Bool -> Bool -> Bool
&& ParamAssign
npa ParamAssign -> ParamAssign -> Bool
forall a. Eq a => a -> a -> Bool
== ParamAssign
pa ->
    (NonEmpty ModInst -> ModGenSingleItem)
-> Identity ModInst -> NonEmpty ModInst -> Maybe ModGenSingleItem
forall {a} {a}.
(NonEmpty a -> a) -> Identity a -> NonEmpty a -> Maybe a
add (Identifier -> ParamAssign -> NonEmpty ModInst -> ModGenSingleItem
forall (f :: * -> *).
Identifier -> ParamAssign -> f ModInst -> ModGenItem f
MGIModInst Identifier
mod ParamAssign
pa) Identity ModInst
i NonEmpty ModInst
l
  (MGIUnknownInst Identifier
nt Maybe (Either Expr (Expr, Expr))
np Identity UknInst
i, MGIUnknownInst Identifier
t Maybe (Either Expr (Expr, Expr))
p NonEmpty UknInst
l) | Identifier
nt Identifier -> Identifier -> Bool
forall a. Eq a => a -> a -> Bool
== Identifier
t Bool -> Bool -> Bool
&& Maybe (Either Expr (Expr, Expr))
np Maybe (Either Expr (Expr, Expr))
-> Maybe (Either Expr (Expr, Expr)) -> Bool
forall a. Eq a => a -> a -> Bool
== Maybe (Either Expr (Expr, Expr))
p ->
    (NonEmpty UknInst -> ModGenSingleItem)
-> Identity UknInst -> NonEmpty UknInst -> Maybe ModGenSingleItem
forall {a} {a}.
(NonEmpty a -> a) -> Identity a -> NonEmpty a -> Maybe a
add (Identifier
-> Maybe (Either Expr (Expr, Expr))
-> NonEmpty UknInst
-> ModGenSingleItem
forall (f :: * -> *).
Identifier
-> Maybe (Either Expr (Expr, Expr)) -> f UknInst -> ModGenItem f
MGIUnknownInst Identifier
t Maybe (Either Expr (Expr, Expr))
p) Identity UknInst
i NonEmpty UknInst
l
  (ModGenBlockedItem, ModGenSingleItem)
_ -> Maybe ModGenSingleItem
forall a. Maybe a
Nothing
  where
    add :: (NonEmpty a -> a) -> Identity a -> NonEmpty a -> Maybe a
add NonEmpty a -> a
f Identity a
x NonEmpty a
y = a -> Maybe a
forall a. a -> Maybe a
Just (a -> Maybe a) -> a -> Maybe a
forall a b. (a -> b) -> a -> b
$ NonEmpty a -> a
f (NonEmpty a -> a) -> NonEmpty a -> a
forall a b. (a -> b) -> a -> b
$ Identity a -> a
forall a. Identity a -> a
runIdentity Identity a
x a -> NonEmpty a -> NonEmpty a
forall a. a -> NonEmpty a -> NonEmpty a
<| NonEmpty a
y

-- | Converts `ModGenBlockedItem`s into `ModGenSingleItem`s
fromMGBlockedItem :: [Attributed ModGenBlockedItem] -> [Attributed ModGenSingleItem]
fromMGBlockedItem :: [Attributed ModGenBlockedItem] -> [Attributed ModGenSingleItem]
fromMGBlockedItem =
  [Attributed ModGenSingleItem]
-> (NonEmpty (Attributed ModGenBlockedItem)
    -> [Attributed ModGenSingleItem])
-> [Attributed ModGenBlockedItem]
-> [Attributed ModGenSingleItem]
forall b a. b -> (NonEmpty a -> b) -> [a] -> b
nonEmpty [] ((NonEmpty (Attributed ModGenBlockedItem)
  -> [Attributed ModGenSingleItem])
 -> [Attributed ModGenBlockedItem] -> [Attributed ModGenSingleItem])
-> (NonEmpty (Attributed ModGenBlockedItem)
    -> [Attributed ModGenSingleItem])
-> [Attributed ModGenBlockedItem]
-> [Attributed ModGenSingleItem]
forall a b. (a -> b) -> a -> b
$ NonEmpty (Attributed ModGenSingleItem)
-> [Attributed ModGenSingleItem]
forall a. NonEmpty a -> [a]
toList (NonEmpty (Attributed ModGenSingleItem)
 -> [Attributed ModGenSingleItem])
-> (NonEmpty (Attributed ModGenBlockedItem)
    -> NonEmpty (Attributed ModGenSingleItem))
-> NonEmpty (Attributed ModGenBlockedItem)
-> [Attributed ModGenSingleItem]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Attributed ModGenBlockedItem -> Attributed ModGenSingleItem)
-> (Attributed ModGenBlockedItem
    -> Attributed ModGenSingleItem
    -> Maybe (Attributed ModGenSingleItem))
-> NonEmpty (Attributed ModGenBlockedItem)
-> NonEmpty (Attributed ModGenSingleItem)
forall x y.
(x -> y) -> (x -> y -> Maybe y) -> NonEmpty x -> NonEmpty y
regroup ((ModGenBlockedItem -> ModGenSingleItem)
-> Attributed ModGenBlockedItem -> Attributed ModGenSingleItem
forall a b. (a -> b) -> Attributed a -> Attributed b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ModGenBlockedItem -> ModGenSingleItem
fromMGBlockedItem1) ((ModGenBlockedItem -> ModGenSingleItem -> Maybe ModGenSingleItem)
-> Attributed ModGenBlockedItem
-> Attributed ModGenSingleItem
-> Maybe (Attributed ModGenSingleItem)
forall x y.
(x -> y -> Maybe y)
-> Attributed x -> Attributed y -> Maybe (Attributed y)
addAttributed ModGenBlockedItem -> ModGenSingleItem -> Maybe ModGenSingleItem
fromMGBlockedItem_add)