{-# LANGUAGE DeriveDataTypeable #-}
-----------------------------------------------------------------------------
-- |
-- Module      :  Language.C.Syntax.Ops
-- Copyright   :  (c) 2008 Benedikt Huber
-- License     :  BSD-style
-- Maintainer  : benedikt.huber@gmail.com
-- Stability   : experimental
-- Portability : ghc
--
-- Unary, binary and asssignment operators. Exported via AST.
-----------------------------------------------------------------------------
module Language.C.Syntax.Ops (
-- * Assignment operators
CAssignOp(..),
assignBinop,
-- * Binary operators
CBinaryOp(..),
isCmpOp,
isPtrOp,
isBitOp,
isLogicOp,
-- * Unary operators
CUnaryOp(..),
isEffectfulOp
)
where
import Data.Data (Data)
import Data.Typeable (Typeable)
import GHC.Generics (Generic)
import Control.DeepSeq (NFData)
-- | C assignment operators (K&R A7.17)
data CAssignOp = CAssignOp
               | CMulAssOp
               | CDivAssOp
               | CRmdAssOp              -- ^ remainder and assignment
               | CAddAssOp
               | CSubAssOp
               | CShlAssOp
               | CShrAssOp
               | CAndAssOp
               | CXorAssOp
               | COrAssOp
               deriving (CAssignOp -> CAssignOp -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CAssignOp -> CAssignOp -> Bool
$c/= :: CAssignOp -> CAssignOp -> Bool
== :: CAssignOp -> CAssignOp -> Bool
$c== :: CAssignOp -> CAssignOp -> Bool
Eq,Eq CAssignOp
CAssignOp -> CAssignOp -> Bool
CAssignOp -> CAssignOp -> Ordering
CAssignOp -> CAssignOp -> CAssignOp
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: CAssignOp -> CAssignOp -> CAssignOp
$cmin :: CAssignOp -> CAssignOp -> CAssignOp
max :: CAssignOp -> CAssignOp -> CAssignOp
$cmax :: CAssignOp -> CAssignOp -> CAssignOp
>= :: CAssignOp -> CAssignOp -> Bool
$c>= :: CAssignOp -> CAssignOp -> Bool
> :: CAssignOp -> CAssignOp -> Bool
$c> :: CAssignOp -> CAssignOp -> Bool
<= :: CAssignOp -> CAssignOp -> Bool
$c<= :: CAssignOp -> CAssignOp -> Bool
< :: CAssignOp -> CAssignOp -> Bool
$c< :: CAssignOp -> CAssignOp -> Bool
compare :: CAssignOp -> CAssignOp -> Ordering
$ccompare :: CAssignOp -> CAssignOp -> Ordering
Ord,Int -> CAssignOp -> ShowS
[CAssignOp] -> ShowS
CAssignOp -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CAssignOp] -> ShowS
$cshowList :: [CAssignOp] -> ShowS
show :: CAssignOp -> String
$cshow :: CAssignOp -> String
showsPrec :: Int -> CAssignOp -> ShowS
$cshowsPrec :: Int -> CAssignOp -> ShowS
Show,Typeable CAssignOp
CAssignOp -> DataType
CAssignOp -> Constr
(forall b. Data b => b -> b) -> CAssignOp -> CAssignOp
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> CAssignOp -> u
forall u. (forall d. Data d => d -> u) -> CAssignOp -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CAssignOp -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CAssignOp -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CAssignOp -> m CAssignOp
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CAssignOp -> m CAssignOp
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CAssignOp
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CAssignOp -> c CAssignOp
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CAssignOp)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CAssignOp)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CAssignOp -> m CAssignOp
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CAssignOp -> m CAssignOp
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CAssignOp -> m CAssignOp
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CAssignOp -> m CAssignOp
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CAssignOp -> m CAssignOp
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CAssignOp -> m CAssignOp
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> CAssignOp -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> CAssignOp -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> CAssignOp -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> CAssignOp -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CAssignOp -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CAssignOp -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CAssignOp -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CAssignOp -> r
gmapT :: (forall b. Data b => b -> b) -> CAssignOp -> CAssignOp
$cgmapT :: (forall b. Data b => b -> b) -> CAssignOp -> CAssignOp
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CAssignOp)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CAssignOp)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CAssignOp)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CAssignOp)
dataTypeOf :: CAssignOp -> DataType
$cdataTypeOf :: CAssignOp -> DataType
toConstr :: CAssignOp -> Constr
$ctoConstr :: CAssignOp -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CAssignOp
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CAssignOp
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CAssignOp -> c CAssignOp
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CAssignOp -> c CAssignOp
Data,Typeable,forall x. Rep CAssignOp x -> CAssignOp
forall x. CAssignOp -> Rep CAssignOp x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep CAssignOp x -> CAssignOp
$cfrom :: forall x. CAssignOp -> Rep CAssignOp x
Generic)

instance NFData CAssignOp

assignBinop :: CAssignOp -> CBinaryOp
assignBinop :: CAssignOp -> CBinaryOp
assignBinop CAssignOp
CAssignOp = forall a. HasCallStack => String -> a
error String
"direct assignment has no binary operator"
assignBinop CAssignOp
CMulAssOp = CBinaryOp
CMulOp
assignBinop CAssignOp
CDivAssOp = CBinaryOp
CDivOp
assignBinop CAssignOp
CRmdAssOp = CBinaryOp
CRmdOp
assignBinop CAssignOp
CAddAssOp = CBinaryOp
CAddOp
assignBinop CAssignOp
CSubAssOp = CBinaryOp
CSubOp
assignBinop CAssignOp
CShlAssOp = CBinaryOp
CShlOp
assignBinop CAssignOp
CShrAssOp = CBinaryOp
CShrOp
assignBinop CAssignOp
CAndAssOp = CBinaryOp
CAndOp
assignBinop CAssignOp
CXorAssOp = CBinaryOp
CXorOp
assignBinop CAssignOp
COrAssOp  = CBinaryOp
COrOp

-- | C binary operators (K&R A7.6-15)
--
data CBinaryOp = CMulOp
               | CDivOp
               | CRmdOp                 -- ^ remainder of division
               | CAddOp
               | CSubOp
               | CShlOp                 -- ^ shift left
               | CShrOp                 -- ^ shift right
               | CLeOp                  -- ^ less
               | CGrOp                  -- ^ greater
               | CLeqOp                 -- ^ less or equal
               | CGeqOp                 -- ^ greater or equal
               | CEqOp                  -- ^ equal
               | CNeqOp                 -- ^ not equal
               | CAndOp                 -- ^ bitwise and
               | CXorOp                 -- ^ exclusive bitwise or
               | COrOp                  -- ^ inclusive bitwise or
               | CLndOp                 -- ^ logical and
               | CLorOp                 -- ^ logical or
               deriving (CBinaryOp -> CBinaryOp -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CBinaryOp -> CBinaryOp -> Bool
$c/= :: CBinaryOp -> CBinaryOp -> Bool
== :: CBinaryOp -> CBinaryOp -> Bool
$c== :: CBinaryOp -> CBinaryOp -> Bool
Eq,Eq CBinaryOp
CBinaryOp -> CBinaryOp -> Bool
CBinaryOp -> CBinaryOp -> Ordering
CBinaryOp -> CBinaryOp -> CBinaryOp
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: CBinaryOp -> CBinaryOp -> CBinaryOp
$cmin :: CBinaryOp -> CBinaryOp -> CBinaryOp
max :: CBinaryOp -> CBinaryOp -> CBinaryOp
$cmax :: CBinaryOp -> CBinaryOp -> CBinaryOp
>= :: CBinaryOp -> CBinaryOp -> Bool
$c>= :: CBinaryOp -> CBinaryOp -> Bool
> :: CBinaryOp -> CBinaryOp -> Bool
$c> :: CBinaryOp -> CBinaryOp -> Bool
<= :: CBinaryOp -> CBinaryOp -> Bool
$c<= :: CBinaryOp -> CBinaryOp -> Bool
< :: CBinaryOp -> CBinaryOp -> Bool
$c< :: CBinaryOp -> CBinaryOp -> Bool
compare :: CBinaryOp -> CBinaryOp -> Ordering
$ccompare :: CBinaryOp -> CBinaryOp -> Ordering
Ord,Int -> CBinaryOp -> ShowS
[CBinaryOp] -> ShowS
CBinaryOp -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CBinaryOp] -> ShowS
$cshowList :: [CBinaryOp] -> ShowS
show :: CBinaryOp -> String
$cshow :: CBinaryOp -> String
showsPrec :: Int -> CBinaryOp -> ShowS
$cshowsPrec :: Int -> CBinaryOp -> ShowS
Show,Typeable CBinaryOp
CBinaryOp -> DataType
CBinaryOp -> Constr
(forall b. Data b => b -> b) -> CBinaryOp -> CBinaryOp
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> CBinaryOp -> u
forall u. (forall d. Data d => d -> u) -> CBinaryOp -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CBinaryOp -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CBinaryOp -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CBinaryOp -> m CBinaryOp
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CBinaryOp -> m CBinaryOp
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CBinaryOp
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CBinaryOp -> c CBinaryOp
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CBinaryOp)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CBinaryOp)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CBinaryOp -> m CBinaryOp
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CBinaryOp -> m CBinaryOp
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CBinaryOp -> m CBinaryOp
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CBinaryOp -> m CBinaryOp
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CBinaryOp -> m CBinaryOp
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CBinaryOp -> m CBinaryOp
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> CBinaryOp -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> CBinaryOp -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> CBinaryOp -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> CBinaryOp -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CBinaryOp -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CBinaryOp -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CBinaryOp -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CBinaryOp -> r
gmapT :: (forall b. Data b => b -> b) -> CBinaryOp -> CBinaryOp
$cgmapT :: (forall b. Data b => b -> b) -> CBinaryOp -> CBinaryOp
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CBinaryOp)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CBinaryOp)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CBinaryOp)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CBinaryOp)
dataTypeOf :: CBinaryOp -> DataType
$cdataTypeOf :: CBinaryOp -> DataType
toConstr :: CBinaryOp -> Constr
$ctoConstr :: CBinaryOp -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CBinaryOp
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CBinaryOp
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CBinaryOp -> c CBinaryOp
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CBinaryOp -> c CBinaryOp
Data,Typeable,forall x. Rep CBinaryOp x -> CBinaryOp
forall x. CBinaryOp -> Rep CBinaryOp x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep CBinaryOp x -> CBinaryOp
$cfrom :: forall x. CBinaryOp -> Rep CBinaryOp x
Generic)

instance NFData CBinaryOp

isCmpOp :: CBinaryOp -> Bool
isCmpOp :: CBinaryOp -> Bool
isCmpOp CBinaryOp
op = CBinaryOp
op forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [ CBinaryOp
CLeqOp, CBinaryOp
CGeqOp, CBinaryOp
CLeOp, CBinaryOp
CGrOp, CBinaryOp
CEqOp, CBinaryOp
CNeqOp ]

isPtrOp :: CBinaryOp -> Bool
isPtrOp :: CBinaryOp -> Bool
isPtrOp CBinaryOp
op = CBinaryOp
op forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [ CBinaryOp
CAddOp, CBinaryOp
CSubOp ]

isBitOp :: CBinaryOp -> Bool
isBitOp :: CBinaryOp -> Bool
isBitOp CBinaryOp
op = CBinaryOp
op forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [ CBinaryOp
CShlOp, CBinaryOp
CShrOp, CBinaryOp
CAndOp, CBinaryOp
COrOp, CBinaryOp
CXorOp ]

isLogicOp :: CBinaryOp -> Bool
isLogicOp :: CBinaryOp -> Bool
isLogicOp CBinaryOp
op = CBinaryOp
op forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [ CBinaryOp
CLndOp, CBinaryOp
CLorOp ]

-- | C unary operator (K&R A7.3-4)
--
data CUnaryOp = CPreIncOp               -- ^ prefix increment operator
              | CPreDecOp               -- ^ prefix decrement operator
              | CPostIncOp              -- ^ postfix increment operator
              | CPostDecOp              -- ^ postfix decrement operator
              | CAdrOp                  -- ^ address operator
              | CIndOp                  -- ^ indirection operator
              | CPlusOp                 -- ^ prefix plus
              | CMinOp                  -- ^ prefix minus
              | CCompOp                 -- ^ one's complement
              | CNegOp                  -- ^ logical negation
              deriving (CUnaryOp -> CUnaryOp -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CUnaryOp -> CUnaryOp -> Bool
$c/= :: CUnaryOp -> CUnaryOp -> Bool
== :: CUnaryOp -> CUnaryOp -> Bool
$c== :: CUnaryOp -> CUnaryOp -> Bool
Eq,Eq CUnaryOp
CUnaryOp -> CUnaryOp -> Bool
CUnaryOp -> CUnaryOp -> Ordering
CUnaryOp -> CUnaryOp -> CUnaryOp
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: CUnaryOp -> CUnaryOp -> CUnaryOp
$cmin :: CUnaryOp -> CUnaryOp -> CUnaryOp
max :: CUnaryOp -> CUnaryOp -> CUnaryOp
$cmax :: CUnaryOp -> CUnaryOp -> CUnaryOp
>= :: CUnaryOp -> CUnaryOp -> Bool
$c>= :: CUnaryOp -> CUnaryOp -> Bool
> :: CUnaryOp -> CUnaryOp -> Bool
$c> :: CUnaryOp -> CUnaryOp -> Bool
<= :: CUnaryOp -> CUnaryOp -> Bool
$c<= :: CUnaryOp -> CUnaryOp -> Bool
< :: CUnaryOp -> CUnaryOp -> Bool
$c< :: CUnaryOp -> CUnaryOp -> Bool
compare :: CUnaryOp -> CUnaryOp -> Ordering
$ccompare :: CUnaryOp -> CUnaryOp -> Ordering
Ord,Int -> CUnaryOp -> ShowS
[CUnaryOp] -> ShowS
CUnaryOp -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CUnaryOp] -> ShowS
$cshowList :: [CUnaryOp] -> ShowS
show :: CUnaryOp -> String
$cshow :: CUnaryOp -> String
showsPrec :: Int -> CUnaryOp -> ShowS
$cshowsPrec :: Int -> CUnaryOp -> ShowS
Show,Typeable CUnaryOp
CUnaryOp -> DataType
CUnaryOp -> Constr
(forall b. Data b => b -> b) -> CUnaryOp -> CUnaryOp
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> CUnaryOp -> u
forall u. (forall d. Data d => d -> u) -> CUnaryOp -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CUnaryOp -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CUnaryOp -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CUnaryOp -> m CUnaryOp
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CUnaryOp -> m CUnaryOp
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CUnaryOp
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CUnaryOp -> c CUnaryOp
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CUnaryOp)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CUnaryOp)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CUnaryOp -> m CUnaryOp
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CUnaryOp -> m CUnaryOp
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CUnaryOp -> m CUnaryOp
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CUnaryOp -> m CUnaryOp
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CUnaryOp -> m CUnaryOp
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CUnaryOp -> m CUnaryOp
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> CUnaryOp -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> CUnaryOp -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> CUnaryOp -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> CUnaryOp -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CUnaryOp -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CUnaryOp -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CUnaryOp -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CUnaryOp -> r
gmapT :: (forall b. Data b => b -> b) -> CUnaryOp -> CUnaryOp
$cgmapT :: (forall b. Data b => b -> b) -> CUnaryOp -> CUnaryOp
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CUnaryOp)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CUnaryOp)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CUnaryOp)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CUnaryOp)
dataTypeOf :: CUnaryOp -> DataType
$cdataTypeOf :: CUnaryOp -> DataType
toConstr :: CUnaryOp -> Constr
$ctoConstr :: CUnaryOp -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CUnaryOp
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CUnaryOp
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CUnaryOp -> c CUnaryOp
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CUnaryOp -> c CUnaryOp
Data,Typeable,forall x. Rep CUnaryOp x -> CUnaryOp
forall x. CUnaryOp -> Rep CUnaryOp x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep CUnaryOp x -> CUnaryOp
$cfrom :: forall x. CUnaryOp -> Rep CUnaryOp x
Generic)

instance NFData CUnaryOp

isEffectfulOp :: CUnaryOp -> Bool
isEffectfulOp :: CUnaryOp -> Bool
isEffectfulOp CUnaryOp
op = CUnaryOp
op forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [ CUnaryOp
CPreIncOp, CUnaryOp
CPreDecOp, CUnaryOp
CPostIncOp, CUnaryOp
CPostDecOp ]