{-# LANGUAGE GeneralizedNewtypeDeriving #-}
module Language.SMV.AbsSMV where
import Prelude (Double, Integer, String)
import qualified Prelude as C (Eq, Ord, Show, Read)
import qualified Data.String
data BoolSpec
= BoolSpecSignal Ident
| BoolSpecConst BoolConst
| BoolSpecNum NumExpr
| BoolSpecCmp BoolSpec OrdOp BoolSpec
| BoolSpecNeg BoolSpec
| BoolSpecAnd BoolSpec BoolSpec
| BoolSpecOr BoolSpec BoolSpec
| BoolSpecXor BoolSpec BoolSpec
| BoolSpecImplies BoolSpec BoolSpec
| BoolSpecEquivs BoolSpec BoolSpec
| BoolSpecOp1 OpOne BoolSpec
| BoolSpecOp2 BoolSpec OpTwo BoolSpec
deriving (BoolSpec -> BoolSpec -> Bool
(BoolSpec -> BoolSpec -> Bool)
-> (BoolSpec -> BoolSpec -> Bool) -> Eq BoolSpec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: BoolSpec -> BoolSpec -> Bool
== :: BoolSpec -> BoolSpec -> Bool
$c/= :: BoolSpec -> BoolSpec -> Bool
/= :: BoolSpec -> BoolSpec -> Bool
C.Eq, Eq BoolSpec
Eq BoolSpec =>
(BoolSpec -> BoolSpec -> Ordering)
-> (BoolSpec -> BoolSpec -> Bool)
-> (BoolSpec -> BoolSpec -> Bool)
-> (BoolSpec -> BoolSpec -> Bool)
-> (BoolSpec -> BoolSpec -> Bool)
-> (BoolSpec -> BoolSpec -> BoolSpec)
-> (BoolSpec -> BoolSpec -> BoolSpec)
-> Ord BoolSpec
BoolSpec -> BoolSpec -> Bool
BoolSpec -> BoolSpec -> Ordering
BoolSpec -> BoolSpec -> BoolSpec
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
$ccompare :: BoolSpec -> BoolSpec -> Ordering
compare :: BoolSpec -> BoolSpec -> Ordering
$c< :: BoolSpec -> BoolSpec -> Bool
< :: BoolSpec -> BoolSpec -> Bool
$c<= :: BoolSpec -> BoolSpec -> Bool
<= :: BoolSpec -> BoolSpec -> Bool
$c> :: BoolSpec -> BoolSpec -> Bool
> :: BoolSpec -> BoolSpec -> Bool
$c>= :: BoolSpec -> BoolSpec -> Bool
>= :: BoolSpec -> BoolSpec -> Bool
$cmax :: BoolSpec -> BoolSpec -> BoolSpec
max :: BoolSpec -> BoolSpec -> BoolSpec
$cmin :: BoolSpec -> BoolSpec -> BoolSpec
min :: BoolSpec -> BoolSpec -> BoolSpec
C.Ord, Int -> BoolSpec -> ShowS
[BoolSpec] -> ShowS
BoolSpec -> String
(Int -> BoolSpec -> ShowS)
-> (BoolSpec -> String) -> ([BoolSpec] -> ShowS) -> Show BoolSpec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> BoolSpec -> ShowS
showsPrec :: Int -> BoolSpec -> ShowS
$cshow :: BoolSpec -> String
show :: BoolSpec -> String
$cshowList :: [BoolSpec] -> ShowS
showList :: [BoolSpec] -> ShowS
C.Show, ReadPrec [BoolSpec]
ReadPrec BoolSpec
Int -> ReadS BoolSpec
ReadS [BoolSpec]
(Int -> ReadS BoolSpec)
-> ReadS [BoolSpec]
-> ReadPrec BoolSpec
-> ReadPrec [BoolSpec]
-> Read BoolSpec
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS BoolSpec
readsPrec :: Int -> ReadS BoolSpec
$creadList :: ReadS [BoolSpec]
readList :: ReadS [BoolSpec]
$creadPrec :: ReadPrec BoolSpec
readPrec :: ReadPrec BoolSpec
$creadListPrec :: ReadPrec [BoolSpec]
readListPrec :: ReadPrec [BoolSpec]
C.Read)
data NumExpr
= NumId Ident
| NumConstI Integer
| NumConstD Double
| NumAdd NumExpr AdditiveOp NumExpr
| NumMult NumExpr MultOp NumExpr
deriving (NumExpr -> NumExpr -> Bool
(NumExpr -> NumExpr -> Bool)
-> (NumExpr -> NumExpr -> Bool) -> Eq NumExpr
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: NumExpr -> NumExpr -> Bool
== :: NumExpr -> NumExpr -> Bool
$c/= :: NumExpr -> NumExpr -> Bool
/= :: NumExpr -> NumExpr -> Bool
C.Eq, Eq NumExpr
Eq NumExpr =>
(NumExpr -> NumExpr -> Ordering)
-> (NumExpr -> NumExpr -> Bool)
-> (NumExpr -> NumExpr -> Bool)
-> (NumExpr -> NumExpr -> Bool)
-> (NumExpr -> NumExpr -> Bool)
-> (NumExpr -> NumExpr -> NumExpr)
-> (NumExpr -> NumExpr -> NumExpr)
-> Ord NumExpr
NumExpr -> NumExpr -> Bool
NumExpr -> NumExpr -> Ordering
NumExpr -> NumExpr -> NumExpr
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
$ccompare :: NumExpr -> NumExpr -> Ordering
compare :: NumExpr -> NumExpr -> Ordering
$c< :: NumExpr -> NumExpr -> Bool
< :: NumExpr -> NumExpr -> Bool
$c<= :: NumExpr -> NumExpr -> Bool
<= :: NumExpr -> NumExpr -> Bool
$c> :: NumExpr -> NumExpr -> Bool
> :: NumExpr -> NumExpr -> Bool
$c>= :: NumExpr -> NumExpr -> Bool
>= :: NumExpr -> NumExpr -> Bool
$cmax :: NumExpr -> NumExpr -> NumExpr
max :: NumExpr -> NumExpr -> NumExpr
$cmin :: NumExpr -> NumExpr -> NumExpr
min :: NumExpr -> NumExpr -> NumExpr
C.Ord, Int -> NumExpr -> ShowS
[NumExpr] -> ShowS
NumExpr -> String
(Int -> NumExpr -> ShowS)
-> (NumExpr -> String) -> ([NumExpr] -> ShowS) -> Show NumExpr
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> NumExpr -> ShowS
showsPrec :: Int -> NumExpr -> ShowS
$cshow :: NumExpr -> String
show :: NumExpr -> String
$cshowList :: [NumExpr] -> ShowS
showList :: [NumExpr] -> ShowS
C.Show, ReadPrec [NumExpr]
ReadPrec NumExpr
Int -> ReadS NumExpr
ReadS [NumExpr]
(Int -> ReadS NumExpr)
-> ReadS [NumExpr]
-> ReadPrec NumExpr
-> ReadPrec [NumExpr]
-> Read NumExpr
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS NumExpr
readsPrec :: Int -> ReadS NumExpr
$creadList :: ReadS [NumExpr]
readList :: ReadS [NumExpr]
$creadPrec :: ReadPrec NumExpr
readPrec :: ReadPrec NumExpr
$creadListPrec :: ReadPrec [NumExpr]
readListPrec :: ReadPrec [NumExpr]
C.Read)
data AdditiveOp = OpPlus | OpMinus
deriving (AdditiveOp -> AdditiveOp -> Bool
(AdditiveOp -> AdditiveOp -> Bool)
-> (AdditiveOp -> AdditiveOp -> Bool) -> Eq AdditiveOp
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: AdditiveOp -> AdditiveOp -> Bool
== :: AdditiveOp -> AdditiveOp -> Bool
$c/= :: AdditiveOp -> AdditiveOp -> Bool
/= :: AdditiveOp -> AdditiveOp -> Bool
C.Eq, Eq AdditiveOp
Eq AdditiveOp =>
(AdditiveOp -> AdditiveOp -> Ordering)
-> (AdditiveOp -> AdditiveOp -> Bool)
-> (AdditiveOp -> AdditiveOp -> Bool)
-> (AdditiveOp -> AdditiveOp -> Bool)
-> (AdditiveOp -> AdditiveOp -> Bool)
-> (AdditiveOp -> AdditiveOp -> AdditiveOp)
-> (AdditiveOp -> AdditiveOp -> AdditiveOp)
-> Ord AdditiveOp
AdditiveOp -> AdditiveOp -> Bool
AdditiveOp -> AdditiveOp -> Ordering
AdditiveOp -> AdditiveOp -> AdditiveOp
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
$ccompare :: AdditiveOp -> AdditiveOp -> Ordering
compare :: AdditiveOp -> AdditiveOp -> Ordering
$c< :: AdditiveOp -> AdditiveOp -> Bool
< :: AdditiveOp -> AdditiveOp -> Bool
$c<= :: AdditiveOp -> AdditiveOp -> Bool
<= :: AdditiveOp -> AdditiveOp -> Bool
$c> :: AdditiveOp -> AdditiveOp -> Bool
> :: AdditiveOp -> AdditiveOp -> Bool
$c>= :: AdditiveOp -> AdditiveOp -> Bool
>= :: AdditiveOp -> AdditiveOp -> Bool
$cmax :: AdditiveOp -> AdditiveOp -> AdditiveOp
max :: AdditiveOp -> AdditiveOp -> AdditiveOp
$cmin :: AdditiveOp -> AdditiveOp -> AdditiveOp
min :: AdditiveOp -> AdditiveOp -> AdditiveOp
C.Ord, Int -> AdditiveOp -> ShowS
[AdditiveOp] -> ShowS
AdditiveOp -> String
(Int -> AdditiveOp -> ShowS)
-> (AdditiveOp -> String)
-> ([AdditiveOp] -> ShowS)
-> Show AdditiveOp
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> AdditiveOp -> ShowS
showsPrec :: Int -> AdditiveOp -> ShowS
$cshow :: AdditiveOp -> String
show :: AdditiveOp -> String
$cshowList :: [AdditiveOp] -> ShowS
showList :: [AdditiveOp] -> ShowS
C.Show, ReadPrec [AdditiveOp]
ReadPrec AdditiveOp
Int -> ReadS AdditiveOp
ReadS [AdditiveOp]
(Int -> ReadS AdditiveOp)
-> ReadS [AdditiveOp]
-> ReadPrec AdditiveOp
-> ReadPrec [AdditiveOp]
-> Read AdditiveOp
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS AdditiveOp
readsPrec :: Int -> ReadS AdditiveOp
$creadList :: ReadS [AdditiveOp]
readList :: ReadS [AdditiveOp]
$creadPrec :: ReadPrec AdditiveOp
readPrec :: ReadPrec AdditiveOp
$creadListPrec :: ReadPrec [AdditiveOp]
readListPrec :: ReadPrec [AdditiveOp]
C.Read)
data MultOp = OpTimes | OpDiv
deriving (MultOp -> MultOp -> Bool
(MultOp -> MultOp -> Bool)
-> (MultOp -> MultOp -> Bool) -> Eq MultOp
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MultOp -> MultOp -> Bool
== :: MultOp -> MultOp -> Bool
$c/= :: MultOp -> MultOp -> Bool
/= :: MultOp -> MultOp -> Bool
C.Eq, Eq MultOp
Eq MultOp =>
(MultOp -> MultOp -> Ordering)
-> (MultOp -> MultOp -> Bool)
-> (MultOp -> MultOp -> Bool)
-> (MultOp -> MultOp -> Bool)
-> (MultOp -> MultOp -> Bool)
-> (MultOp -> MultOp -> MultOp)
-> (MultOp -> MultOp -> MultOp)
-> Ord MultOp
MultOp -> MultOp -> Bool
MultOp -> MultOp -> Ordering
MultOp -> MultOp -> MultOp
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
$ccompare :: MultOp -> MultOp -> Ordering
compare :: MultOp -> MultOp -> Ordering
$c< :: MultOp -> MultOp -> Bool
< :: MultOp -> MultOp -> Bool
$c<= :: MultOp -> MultOp -> Bool
<= :: MultOp -> MultOp -> Bool
$c> :: MultOp -> MultOp -> Bool
> :: MultOp -> MultOp -> Bool
$c>= :: MultOp -> MultOp -> Bool
>= :: MultOp -> MultOp -> Bool
$cmax :: MultOp -> MultOp -> MultOp
max :: MultOp -> MultOp -> MultOp
$cmin :: MultOp -> MultOp -> MultOp
min :: MultOp -> MultOp -> MultOp
C.Ord, Int -> MultOp -> ShowS
[MultOp] -> ShowS
MultOp -> String
(Int -> MultOp -> ShowS)
-> (MultOp -> String) -> ([MultOp] -> ShowS) -> Show MultOp
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MultOp -> ShowS
showsPrec :: Int -> MultOp -> ShowS
$cshow :: MultOp -> String
show :: MultOp -> String
$cshowList :: [MultOp] -> ShowS
showList :: [MultOp] -> ShowS
C.Show, ReadPrec [MultOp]
ReadPrec MultOp
Int -> ReadS MultOp
ReadS [MultOp]
(Int -> ReadS MultOp)
-> ReadS [MultOp]
-> ReadPrec MultOp
-> ReadPrec [MultOp]
-> Read MultOp
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS MultOp
readsPrec :: Int -> ReadS MultOp
$creadList :: ReadS [MultOp]
readList :: ReadS [MultOp]
$creadPrec :: ReadPrec MultOp
readPrec :: ReadPrec MultOp
$creadListPrec :: ReadPrec [MultOp]
readListPrec :: ReadPrec [MultOp]
C.Read)
data BoolConst
= BoolConstTrue | BoolConstFalse | BoolConstFTP | BoolConstLAST
deriving (BoolConst -> BoolConst -> Bool
(BoolConst -> BoolConst -> Bool)
-> (BoolConst -> BoolConst -> Bool) -> Eq BoolConst
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: BoolConst -> BoolConst -> Bool
== :: BoolConst -> BoolConst -> Bool
$c/= :: BoolConst -> BoolConst -> Bool
/= :: BoolConst -> BoolConst -> Bool
C.Eq, Eq BoolConst
Eq BoolConst =>
(BoolConst -> BoolConst -> Ordering)
-> (BoolConst -> BoolConst -> Bool)
-> (BoolConst -> BoolConst -> Bool)
-> (BoolConst -> BoolConst -> Bool)
-> (BoolConst -> BoolConst -> Bool)
-> (BoolConst -> BoolConst -> BoolConst)
-> (BoolConst -> BoolConst -> BoolConst)
-> Ord BoolConst
BoolConst -> BoolConst -> Bool
BoolConst -> BoolConst -> Ordering
BoolConst -> BoolConst -> BoolConst
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
$ccompare :: BoolConst -> BoolConst -> Ordering
compare :: BoolConst -> BoolConst -> Ordering
$c< :: BoolConst -> BoolConst -> Bool
< :: BoolConst -> BoolConst -> Bool
$c<= :: BoolConst -> BoolConst -> Bool
<= :: BoolConst -> BoolConst -> Bool
$c> :: BoolConst -> BoolConst -> Bool
> :: BoolConst -> BoolConst -> Bool
$c>= :: BoolConst -> BoolConst -> Bool
>= :: BoolConst -> BoolConst -> Bool
$cmax :: BoolConst -> BoolConst -> BoolConst
max :: BoolConst -> BoolConst -> BoolConst
$cmin :: BoolConst -> BoolConst -> BoolConst
min :: BoolConst -> BoolConst -> BoolConst
C.Ord, Int -> BoolConst -> ShowS
[BoolConst] -> ShowS
BoolConst -> String
(Int -> BoolConst -> ShowS)
-> (BoolConst -> String)
-> ([BoolConst] -> ShowS)
-> Show BoolConst
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> BoolConst -> ShowS
showsPrec :: Int -> BoolConst -> ShowS
$cshow :: BoolConst -> String
show :: BoolConst -> String
$cshowList :: [BoolConst] -> ShowS
showList :: [BoolConst] -> ShowS
C.Show, ReadPrec [BoolConst]
ReadPrec BoolConst
Int -> ReadS BoolConst
ReadS [BoolConst]
(Int -> ReadS BoolConst)
-> ReadS [BoolConst]
-> ReadPrec BoolConst
-> ReadPrec [BoolConst]
-> Read BoolConst
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS BoolConst
readsPrec :: Int -> ReadS BoolConst
$creadList :: ReadS [BoolConst]
readList :: ReadS [BoolConst]
$creadPrec :: ReadPrec BoolConst
readPrec :: ReadPrec BoolConst
$creadListPrec :: ReadPrec [BoolConst]
readListPrec :: ReadPrec [BoolConst]
C.Read)
data OpOne
= Op1Alone Op1Name
| Op1MTL Op1Name OrdOp Number
| Op1MTLRange Op1Name Number Number
deriving (OpOne -> OpOne -> Bool
(OpOne -> OpOne -> Bool) -> (OpOne -> OpOne -> Bool) -> Eq OpOne
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: OpOne -> OpOne -> Bool
== :: OpOne -> OpOne -> Bool
$c/= :: OpOne -> OpOne -> Bool
/= :: OpOne -> OpOne -> Bool
C.Eq, Eq OpOne
Eq OpOne =>
(OpOne -> OpOne -> Ordering)
-> (OpOne -> OpOne -> Bool)
-> (OpOne -> OpOne -> Bool)
-> (OpOne -> OpOne -> Bool)
-> (OpOne -> OpOne -> Bool)
-> (OpOne -> OpOne -> OpOne)
-> (OpOne -> OpOne -> OpOne)
-> Ord OpOne
OpOne -> OpOne -> Bool
OpOne -> OpOne -> Ordering
OpOne -> OpOne -> OpOne
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
$ccompare :: OpOne -> OpOne -> Ordering
compare :: OpOne -> OpOne -> Ordering
$c< :: OpOne -> OpOne -> Bool
< :: OpOne -> OpOne -> Bool
$c<= :: OpOne -> OpOne -> Bool
<= :: OpOne -> OpOne -> Bool
$c> :: OpOne -> OpOne -> Bool
> :: OpOne -> OpOne -> Bool
$c>= :: OpOne -> OpOne -> Bool
>= :: OpOne -> OpOne -> Bool
$cmax :: OpOne -> OpOne -> OpOne
max :: OpOne -> OpOne -> OpOne
$cmin :: OpOne -> OpOne -> OpOne
min :: OpOne -> OpOne -> OpOne
C.Ord, Int -> OpOne -> ShowS
[OpOne] -> ShowS
OpOne -> String
(Int -> OpOne -> ShowS)
-> (OpOne -> String) -> ([OpOne] -> ShowS) -> Show OpOne
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> OpOne -> ShowS
showsPrec :: Int -> OpOne -> ShowS
$cshow :: OpOne -> String
show :: OpOne -> String
$cshowList :: [OpOne] -> ShowS
showList :: [OpOne] -> ShowS
C.Show, ReadPrec [OpOne]
ReadPrec OpOne
Int -> ReadS OpOne
ReadS [OpOne]
(Int -> ReadS OpOne)
-> ReadS [OpOne]
-> ReadPrec OpOne
-> ReadPrec [OpOne]
-> Read OpOne
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS OpOne
readsPrec :: Int -> ReadS OpOne
$creadList :: ReadS [OpOne]
readList :: ReadS [OpOne]
$creadPrec :: ReadPrec OpOne
readPrec :: ReadPrec OpOne
$creadListPrec :: ReadPrec [OpOne]
readListPrec :: ReadPrec [OpOne]
C.Read)
data Number = NumberInt Integer
deriving (Number -> Number -> Bool
(Number -> Number -> Bool)
-> (Number -> Number -> Bool) -> Eq Number
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Number -> Number -> Bool
== :: Number -> Number -> Bool
$c/= :: Number -> Number -> Bool
/= :: Number -> Number -> Bool
C.Eq, Eq Number
Eq Number =>
(Number -> Number -> Ordering)
-> (Number -> Number -> Bool)
-> (Number -> Number -> Bool)
-> (Number -> Number -> Bool)
-> (Number -> Number -> Bool)
-> (Number -> Number -> Number)
-> (Number -> Number -> Number)
-> Ord Number
Number -> Number -> Bool
Number -> Number -> Ordering
Number -> Number -> Number
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
$ccompare :: Number -> Number -> Ordering
compare :: Number -> Number -> Ordering
$c< :: Number -> Number -> Bool
< :: Number -> Number -> Bool
$c<= :: Number -> Number -> Bool
<= :: Number -> Number -> Bool
$c> :: Number -> Number -> Bool
> :: Number -> Number -> Bool
$c>= :: Number -> Number -> Bool
>= :: Number -> Number -> Bool
$cmax :: Number -> Number -> Number
max :: Number -> Number -> Number
$cmin :: Number -> Number -> Number
min :: Number -> Number -> Number
C.Ord, Int -> Number -> ShowS
[Number] -> ShowS
Number -> String
(Int -> Number -> ShowS)
-> (Number -> String) -> ([Number] -> ShowS) -> Show Number
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Number -> ShowS
showsPrec :: Int -> Number -> ShowS
$cshow :: Number -> String
show :: Number -> String
$cshowList :: [Number] -> ShowS
showList :: [Number] -> ShowS
C.Show, ReadPrec [Number]
ReadPrec Number
Int -> ReadS Number
ReadS [Number]
(Int -> ReadS Number)
-> ReadS [Number]
-> ReadPrec Number
-> ReadPrec [Number]
-> Read Number
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Number
readsPrec :: Int -> ReadS Number
$creadList :: ReadS [Number]
readList :: ReadS [Number]
$creadPrec :: ReadPrec Number
readPrec :: ReadPrec Number
$creadListPrec :: ReadPrec [Number]
readListPrec :: ReadPrec [Number]
C.Read)
data OrdOp
= OrdOpLT | OrdOpLE | OrdOpEQ | OrdOpNE | OrdOpGT | OrdOpGE
deriving (OrdOp -> OrdOp -> Bool
(OrdOp -> OrdOp -> Bool) -> (OrdOp -> OrdOp -> Bool) -> Eq OrdOp
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: OrdOp -> OrdOp -> Bool
== :: OrdOp -> OrdOp -> Bool
$c/= :: OrdOp -> OrdOp -> Bool
/= :: OrdOp -> OrdOp -> Bool
C.Eq, Eq OrdOp
Eq OrdOp =>
(OrdOp -> OrdOp -> Ordering)
-> (OrdOp -> OrdOp -> Bool)
-> (OrdOp -> OrdOp -> Bool)
-> (OrdOp -> OrdOp -> Bool)
-> (OrdOp -> OrdOp -> Bool)
-> (OrdOp -> OrdOp -> OrdOp)
-> (OrdOp -> OrdOp -> OrdOp)
-> Ord OrdOp
OrdOp -> OrdOp -> Bool
OrdOp -> OrdOp -> Ordering
OrdOp -> OrdOp -> OrdOp
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
$ccompare :: OrdOp -> OrdOp -> Ordering
compare :: OrdOp -> OrdOp -> Ordering
$c< :: OrdOp -> OrdOp -> Bool
< :: OrdOp -> OrdOp -> Bool
$c<= :: OrdOp -> OrdOp -> Bool
<= :: OrdOp -> OrdOp -> Bool
$c> :: OrdOp -> OrdOp -> Bool
> :: OrdOp -> OrdOp -> Bool
$c>= :: OrdOp -> OrdOp -> Bool
>= :: OrdOp -> OrdOp -> Bool
$cmax :: OrdOp -> OrdOp -> OrdOp
max :: OrdOp -> OrdOp -> OrdOp
$cmin :: OrdOp -> OrdOp -> OrdOp
min :: OrdOp -> OrdOp -> OrdOp
C.Ord, Int -> OrdOp -> ShowS
[OrdOp] -> ShowS
OrdOp -> String
(Int -> OrdOp -> ShowS)
-> (OrdOp -> String) -> ([OrdOp] -> ShowS) -> Show OrdOp
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> OrdOp -> ShowS
showsPrec :: Int -> OrdOp -> ShowS
$cshow :: OrdOp -> String
show :: OrdOp -> String
$cshowList :: [OrdOp] -> ShowS
showList :: [OrdOp] -> ShowS
C.Show, ReadPrec [OrdOp]
ReadPrec OrdOp
Int -> ReadS OrdOp
ReadS [OrdOp]
(Int -> ReadS OrdOp)
-> ReadS [OrdOp]
-> ReadPrec OrdOp
-> ReadPrec [OrdOp]
-> Read OrdOp
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS OrdOp
readsPrec :: Int -> ReadS OrdOp
$creadList :: ReadS [OrdOp]
readList :: ReadS [OrdOp]
$creadPrec :: ReadPrec OrdOp
readPrec :: ReadPrec OrdOp
$creadListPrec :: ReadPrec [OrdOp]
readListPrec :: ReadPrec [OrdOp]
C.Read)
data Op1Name
= Op1Pre | Op1X | Op1G | Op1F | Op1Y | Op1Z | Op1Hist | Op1O
deriving (Op1Name -> Op1Name -> Bool
(Op1Name -> Op1Name -> Bool)
-> (Op1Name -> Op1Name -> Bool) -> Eq Op1Name
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Op1Name -> Op1Name -> Bool
== :: Op1Name -> Op1Name -> Bool
$c/= :: Op1Name -> Op1Name -> Bool
/= :: Op1Name -> Op1Name -> Bool
C.Eq, Eq Op1Name
Eq Op1Name =>
(Op1Name -> Op1Name -> Ordering)
-> (Op1Name -> Op1Name -> Bool)
-> (Op1Name -> Op1Name -> Bool)
-> (Op1Name -> Op1Name -> Bool)
-> (Op1Name -> Op1Name -> Bool)
-> (Op1Name -> Op1Name -> Op1Name)
-> (Op1Name -> Op1Name -> Op1Name)
-> Ord Op1Name
Op1Name -> Op1Name -> Bool
Op1Name -> Op1Name -> Ordering
Op1Name -> Op1Name -> Op1Name
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
$ccompare :: Op1Name -> Op1Name -> Ordering
compare :: Op1Name -> Op1Name -> Ordering
$c< :: Op1Name -> Op1Name -> Bool
< :: Op1Name -> Op1Name -> Bool
$c<= :: Op1Name -> Op1Name -> Bool
<= :: Op1Name -> Op1Name -> Bool
$c> :: Op1Name -> Op1Name -> Bool
> :: Op1Name -> Op1Name -> Bool
$c>= :: Op1Name -> Op1Name -> Bool
>= :: Op1Name -> Op1Name -> Bool
$cmax :: Op1Name -> Op1Name -> Op1Name
max :: Op1Name -> Op1Name -> Op1Name
$cmin :: Op1Name -> Op1Name -> Op1Name
min :: Op1Name -> Op1Name -> Op1Name
C.Ord, Int -> Op1Name -> ShowS
[Op1Name] -> ShowS
Op1Name -> String
(Int -> Op1Name -> ShowS)
-> (Op1Name -> String) -> ([Op1Name] -> ShowS) -> Show Op1Name
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Op1Name -> ShowS
showsPrec :: Int -> Op1Name -> ShowS
$cshow :: Op1Name -> String
show :: Op1Name -> String
$cshowList :: [Op1Name] -> ShowS
showList :: [Op1Name] -> ShowS
C.Show, ReadPrec [Op1Name]
ReadPrec Op1Name
Int -> ReadS Op1Name
ReadS [Op1Name]
(Int -> ReadS Op1Name)
-> ReadS [Op1Name]
-> ReadPrec Op1Name
-> ReadPrec [Op1Name]
-> Read Op1Name
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Op1Name
readsPrec :: Int -> ReadS Op1Name
$creadList :: ReadS [Op1Name]
readList :: ReadS [Op1Name]
$creadPrec :: ReadPrec Op1Name
readPrec :: ReadPrec Op1Name
$creadListPrec :: ReadPrec [Op1Name]
readListPrec :: ReadPrec [Op1Name]
C.Read)
data OpTwo = Op2S | Op2T | Op2V | Op2U
deriving (OpTwo -> OpTwo -> Bool
(OpTwo -> OpTwo -> Bool) -> (OpTwo -> OpTwo -> Bool) -> Eq OpTwo
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: OpTwo -> OpTwo -> Bool
== :: OpTwo -> OpTwo -> Bool
$c/= :: OpTwo -> OpTwo -> Bool
/= :: OpTwo -> OpTwo -> Bool
C.Eq, Eq OpTwo
Eq OpTwo =>
(OpTwo -> OpTwo -> Ordering)
-> (OpTwo -> OpTwo -> Bool)
-> (OpTwo -> OpTwo -> Bool)
-> (OpTwo -> OpTwo -> Bool)
-> (OpTwo -> OpTwo -> Bool)
-> (OpTwo -> OpTwo -> OpTwo)
-> (OpTwo -> OpTwo -> OpTwo)
-> Ord OpTwo
OpTwo -> OpTwo -> Bool
OpTwo -> OpTwo -> Ordering
OpTwo -> OpTwo -> OpTwo
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
$ccompare :: OpTwo -> OpTwo -> Ordering
compare :: OpTwo -> OpTwo -> Ordering
$c< :: OpTwo -> OpTwo -> Bool
< :: OpTwo -> OpTwo -> Bool
$c<= :: OpTwo -> OpTwo -> Bool
<= :: OpTwo -> OpTwo -> Bool
$c> :: OpTwo -> OpTwo -> Bool
> :: OpTwo -> OpTwo -> Bool
$c>= :: OpTwo -> OpTwo -> Bool
>= :: OpTwo -> OpTwo -> Bool
$cmax :: OpTwo -> OpTwo -> OpTwo
max :: OpTwo -> OpTwo -> OpTwo
$cmin :: OpTwo -> OpTwo -> OpTwo
min :: OpTwo -> OpTwo -> OpTwo
C.Ord, Int -> OpTwo -> ShowS
[OpTwo] -> ShowS
OpTwo -> String
(Int -> OpTwo -> ShowS)
-> (OpTwo -> String) -> ([OpTwo] -> ShowS) -> Show OpTwo
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> OpTwo -> ShowS
showsPrec :: Int -> OpTwo -> ShowS
$cshow :: OpTwo -> String
show :: OpTwo -> String
$cshowList :: [OpTwo] -> ShowS
showList :: [OpTwo] -> ShowS
C.Show, ReadPrec [OpTwo]
ReadPrec OpTwo
Int -> ReadS OpTwo
ReadS [OpTwo]
(Int -> ReadS OpTwo)
-> ReadS [OpTwo]
-> ReadPrec OpTwo
-> ReadPrec [OpTwo]
-> Read OpTwo
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS OpTwo
readsPrec :: Int -> ReadS OpTwo
$creadList :: ReadS [OpTwo]
readList :: ReadS [OpTwo]
$creadPrec :: ReadPrec OpTwo
readPrec :: ReadPrec OpTwo
$creadListPrec :: ReadPrec [OpTwo]
readListPrec :: ReadPrec [OpTwo]
C.Read)
newtype Ident = Ident String
deriving (Ident -> Ident -> Bool
(Ident -> Ident -> Bool) -> (Ident -> Ident -> Bool) -> Eq Ident
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Ident -> Ident -> Bool
== :: Ident -> Ident -> Bool
$c/= :: Ident -> Ident -> Bool
/= :: Ident -> Ident -> Bool
C.Eq, Eq Ident
Eq Ident =>
(Ident -> Ident -> Ordering)
-> (Ident -> Ident -> Bool)
-> (Ident -> Ident -> Bool)
-> (Ident -> Ident -> Bool)
-> (Ident -> Ident -> Bool)
-> (Ident -> Ident -> Ident)
-> (Ident -> Ident -> Ident)
-> Ord Ident
Ident -> Ident -> Bool
Ident -> Ident -> Ordering
Ident -> Ident -> Ident
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
$ccompare :: Ident -> Ident -> Ordering
compare :: Ident -> Ident -> Ordering
$c< :: Ident -> Ident -> Bool
< :: Ident -> Ident -> Bool
$c<= :: Ident -> Ident -> Bool
<= :: Ident -> Ident -> Bool
$c> :: Ident -> Ident -> Bool
> :: Ident -> Ident -> Bool
$c>= :: Ident -> Ident -> Bool
>= :: Ident -> Ident -> Bool
$cmax :: Ident -> Ident -> Ident
max :: Ident -> Ident -> Ident
$cmin :: Ident -> Ident -> Ident
min :: Ident -> Ident -> Ident
C.Ord, Int -> Ident -> ShowS
[Ident] -> ShowS
Ident -> String
(Int -> Ident -> ShowS)
-> (Ident -> String) -> ([Ident] -> ShowS) -> Show Ident
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Ident -> ShowS
showsPrec :: Int -> Ident -> ShowS
$cshow :: Ident -> String
show :: Ident -> String
$cshowList :: [Ident] -> ShowS
showList :: [Ident] -> ShowS
C.Show, ReadPrec [Ident]
ReadPrec Ident
Int -> ReadS Ident
ReadS [Ident]
(Int -> ReadS Ident)
-> ReadS [Ident]
-> ReadPrec Ident
-> ReadPrec [Ident]
-> Read Ident
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Ident
readsPrec :: Int -> ReadS Ident
$creadList :: ReadS [Ident]
readList :: ReadS [Ident]
$creadPrec :: ReadPrec Ident
readPrec :: ReadPrec Ident
$creadListPrec :: ReadPrec [Ident]
readListPrec :: ReadPrec [Ident]
C.Read, String -> Ident
(String -> Ident) -> IsString Ident
forall a. (String -> a) -> IsString a
$cfromString :: String -> Ident
fromString :: String -> Ident
Data.String.IsString)