{-# LANGUAGE GeneralizedNewtypeDeriving #-}
module Language.Lustre.AbsLustre where
import Prelude (Double, Integer, String)
import qualified Prelude as C (Eq, Ord, Show, Read)
import qualified Data.String
data BoolSpec
= BoolSpecPar BoolSpec
| BoolSpecConstI Integer
| BoolSpecConstD Double
| BoolSpecConstB BoolConst
| BoolSpecSignal Ident
| BoolSpecOp1Pre Op1Pre BoolSpec
| BoolSpecOp2In BoolSpec Op2In BoolSpec
| BoolSpecOp2Pre Op2Pre BoolSpec BoolSpec
| BoolSpecOp2OT NumExpr NumExpr BoolSpec
| BoolSpecOp2HT NumExpr NumExpr BoolSpec
| BoolSpecOp2ST NumExpr NumExpr BoolSpec 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 Op1Pre
= Op1Once
| Op1Pre
| Op1YtoPre
| Op1ZtoPre
| Op1Hist
| Op1Y
| Op1Not
| Op1Bang
deriving (Op1Pre -> Op1Pre -> Bool
(Op1Pre -> Op1Pre -> Bool)
-> (Op1Pre -> Op1Pre -> Bool) -> Eq Op1Pre
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Op1Pre -> Op1Pre -> Bool
== :: Op1Pre -> Op1Pre -> Bool
$c/= :: Op1Pre -> Op1Pre -> Bool
/= :: Op1Pre -> Op1Pre -> Bool
C.Eq, Eq Op1Pre
Eq Op1Pre =>
(Op1Pre -> Op1Pre -> Ordering)
-> (Op1Pre -> Op1Pre -> Bool)
-> (Op1Pre -> Op1Pre -> Bool)
-> (Op1Pre -> Op1Pre -> Bool)
-> (Op1Pre -> Op1Pre -> Bool)
-> (Op1Pre -> Op1Pre -> Op1Pre)
-> (Op1Pre -> Op1Pre -> Op1Pre)
-> Ord Op1Pre
Op1Pre -> Op1Pre -> Bool
Op1Pre -> Op1Pre -> Ordering
Op1Pre -> Op1Pre -> Op1Pre
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 :: Op1Pre -> Op1Pre -> Ordering
compare :: Op1Pre -> Op1Pre -> Ordering
$c< :: Op1Pre -> Op1Pre -> Bool
< :: Op1Pre -> Op1Pre -> Bool
$c<= :: Op1Pre -> Op1Pre -> Bool
<= :: Op1Pre -> Op1Pre -> Bool
$c> :: Op1Pre -> Op1Pre -> Bool
> :: Op1Pre -> Op1Pre -> Bool
$c>= :: Op1Pre -> Op1Pre -> Bool
>= :: Op1Pre -> Op1Pre -> Bool
$cmax :: Op1Pre -> Op1Pre -> Op1Pre
max :: Op1Pre -> Op1Pre -> Op1Pre
$cmin :: Op1Pre -> Op1Pre -> Op1Pre
min :: Op1Pre -> Op1Pre -> Op1Pre
C.Ord, Int -> Op1Pre -> ShowS
[Op1Pre] -> ShowS
Op1Pre -> String
(Int -> Op1Pre -> ShowS)
-> (Op1Pre -> String) -> ([Op1Pre] -> ShowS) -> Show Op1Pre
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Op1Pre -> ShowS
showsPrec :: Int -> Op1Pre -> ShowS
$cshow :: Op1Pre -> String
show :: Op1Pre -> String
$cshowList :: [Op1Pre] -> ShowS
showList :: [Op1Pre] -> ShowS
C.Show, ReadPrec [Op1Pre]
ReadPrec Op1Pre
Int -> ReadS Op1Pre
ReadS [Op1Pre]
(Int -> ReadS Op1Pre)
-> ReadS [Op1Pre]
-> ReadPrec Op1Pre
-> ReadPrec [Op1Pre]
-> Read Op1Pre
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Op1Pre
readsPrec :: Int -> ReadS Op1Pre
$creadList :: ReadS [Op1Pre]
readList :: ReadS [Op1Pre]
$creadPrec :: ReadPrec Op1Pre
readPrec :: ReadPrec Op1Pre
$creadListPrec :: ReadPrec [Op1Pre]
readListPrec :: ReadPrec [Op1Pre]
C.Read)
data Op2In
= Op2And
| Op2Amp
| Op2Or
| Op2Impl
| Op2NumOp NumOp2In
| Op2NumCmp BoolNumOp
| Op2InPre
deriving (Op2In -> Op2In -> Bool
(Op2In -> Op2In -> Bool) -> (Op2In -> Op2In -> Bool) -> Eq Op2In
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Op2In -> Op2In -> Bool
== :: Op2In -> Op2In -> Bool
$c/= :: Op2In -> Op2In -> Bool
/= :: Op2In -> Op2In -> Bool
C.Eq, Eq Op2In
Eq Op2In =>
(Op2In -> Op2In -> Ordering)
-> (Op2In -> Op2In -> Bool)
-> (Op2In -> Op2In -> Bool)
-> (Op2In -> Op2In -> Bool)
-> (Op2In -> Op2In -> Bool)
-> (Op2In -> Op2In -> Op2In)
-> (Op2In -> Op2In -> Op2In)
-> Ord Op2In
Op2In -> Op2In -> Bool
Op2In -> Op2In -> Ordering
Op2In -> Op2In -> Op2In
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 :: Op2In -> Op2In -> Ordering
compare :: Op2In -> Op2In -> Ordering
$c< :: Op2In -> Op2In -> Bool
< :: Op2In -> Op2In -> Bool
$c<= :: Op2In -> Op2In -> Bool
<= :: Op2In -> Op2In -> Bool
$c> :: Op2In -> Op2In -> Bool
> :: Op2In -> Op2In -> Bool
$c>= :: Op2In -> Op2In -> Bool
>= :: Op2In -> Op2In -> Bool
$cmax :: Op2In -> Op2In -> Op2In
max :: Op2In -> Op2In -> Op2In
$cmin :: Op2In -> Op2In -> Op2In
min :: Op2In -> Op2In -> Op2In
C.Ord, Int -> Op2In -> ShowS
[Op2In] -> ShowS
Op2In -> String
(Int -> Op2In -> ShowS)
-> (Op2In -> String) -> ([Op2In] -> ShowS) -> Show Op2In
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Op2In -> ShowS
showsPrec :: Int -> Op2In -> ShowS
$cshow :: Op2In -> String
show :: Op2In -> String
$cshowList :: [Op2In] -> ShowS
showList :: [Op2In] -> ShowS
C.Show, ReadPrec [Op2In]
ReadPrec Op2In
Int -> ReadS Op2In
ReadS [Op2In]
(Int -> ReadS Op2In)
-> ReadS [Op2In]
-> ReadPrec Op2In
-> ReadPrec [Op2In]
-> Read Op2In
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Op2In
readsPrec :: Int -> ReadS Op2In
$creadList :: ReadS [Op2In]
readList :: ReadS [Op2In]
$creadPrec :: ReadPrec Op2In
readPrec :: ReadPrec Op2In
$creadListPrec :: ReadPrec [Op2In]
readListPrec :: ReadPrec [Op2In]
C.Read)
data Op2Pre = Op2SI | Op2OT
deriving (Op2Pre -> Op2Pre -> Bool
(Op2Pre -> Op2Pre -> Bool)
-> (Op2Pre -> Op2Pre -> Bool) -> Eq Op2Pre
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Op2Pre -> Op2Pre -> Bool
== :: Op2Pre -> Op2Pre -> Bool
$c/= :: Op2Pre -> Op2Pre -> Bool
/= :: Op2Pre -> Op2Pre -> Bool
C.Eq, Eq Op2Pre
Eq Op2Pre =>
(Op2Pre -> Op2Pre -> Ordering)
-> (Op2Pre -> Op2Pre -> Bool)
-> (Op2Pre -> Op2Pre -> Bool)
-> (Op2Pre -> Op2Pre -> Bool)
-> (Op2Pre -> Op2Pre -> Bool)
-> (Op2Pre -> Op2Pre -> Op2Pre)
-> (Op2Pre -> Op2Pre -> Op2Pre)
-> Ord Op2Pre
Op2Pre -> Op2Pre -> Bool
Op2Pre -> Op2Pre -> Ordering
Op2Pre -> Op2Pre -> Op2Pre
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 :: Op2Pre -> Op2Pre -> Ordering
compare :: Op2Pre -> Op2Pre -> Ordering
$c< :: Op2Pre -> Op2Pre -> Bool
< :: Op2Pre -> Op2Pre -> Bool
$c<= :: Op2Pre -> Op2Pre -> Bool
<= :: Op2Pre -> Op2Pre -> Bool
$c> :: Op2Pre -> Op2Pre -> Bool
> :: Op2Pre -> Op2Pre -> Bool
$c>= :: Op2Pre -> Op2Pre -> Bool
>= :: Op2Pre -> Op2Pre -> Bool
$cmax :: Op2Pre -> Op2Pre -> Op2Pre
max :: Op2Pre -> Op2Pre -> Op2Pre
$cmin :: Op2Pre -> Op2Pre -> Op2Pre
min :: Op2Pre -> Op2Pre -> Op2Pre
C.Ord, Int -> Op2Pre -> ShowS
[Op2Pre] -> ShowS
Op2Pre -> String
(Int -> Op2Pre -> ShowS)
-> (Op2Pre -> String) -> ([Op2Pre] -> ShowS) -> Show Op2Pre
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Op2Pre -> ShowS
showsPrec :: Int -> Op2Pre -> ShowS
$cshow :: Op2Pre -> String
show :: Op2Pre -> String
$cshowList :: [Op2Pre] -> ShowS
showList :: [Op2Pre] -> ShowS
C.Show, ReadPrec [Op2Pre]
ReadPrec Op2Pre
Int -> ReadS Op2Pre
ReadS [Op2Pre]
(Int -> ReadS Op2Pre)
-> ReadS [Op2Pre]
-> ReadPrec Op2Pre
-> ReadPrec [Op2Pre]
-> Read Op2Pre
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Op2Pre
readsPrec :: Int -> ReadS Op2Pre
$creadList :: ReadS [Op2Pre]
readList :: ReadS [Op2Pre]
$creadPrec :: ReadPrec Op2Pre
readPrec :: ReadPrec Op2Pre
$creadListPrec :: ReadPrec [Op2Pre]
readListPrec :: ReadPrec [Op2Pre]
C.Read)
data NumExpr
= NumExprNum Integer
| NumExprId Ident
| NumExprPar NumExpr
| NumExprOp2In NumExpr NumOp2In 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 NumOp2In = NumOp2Plus | NumOp2Minus | NumOp2Mult
deriving (NumOp2In -> NumOp2In -> Bool
(NumOp2In -> NumOp2In -> Bool)
-> (NumOp2In -> NumOp2In -> Bool) -> Eq NumOp2In
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: NumOp2In -> NumOp2In -> Bool
== :: NumOp2In -> NumOp2In -> Bool
$c/= :: NumOp2In -> NumOp2In -> Bool
/= :: NumOp2In -> NumOp2In -> Bool
C.Eq, Eq NumOp2In
Eq NumOp2In =>
(NumOp2In -> NumOp2In -> Ordering)
-> (NumOp2In -> NumOp2In -> Bool)
-> (NumOp2In -> NumOp2In -> Bool)
-> (NumOp2In -> NumOp2In -> Bool)
-> (NumOp2In -> NumOp2In -> Bool)
-> (NumOp2In -> NumOp2In -> NumOp2In)
-> (NumOp2In -> NumOp2In -> NumOp2In)
-> Ord NumOp2In
NumOp2In -> NumOp2In -> Bool
NumOp2In -> NumOp2In -> Ordering
NumOp2In -> NumOp2In -> NumOp2In
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 :: NumOp2In -> NumOp2In -> Ordering
compare :: NumOp2In -> NumOp2In -> Ordering
$c< :: NumOp2In -> NumOp2In -> Bool
< :: NumOp2In -> NumOp2In -> Bool
$c<= :: NumOp2In -> NumOp2In -> Bool
<= :: NumOp2In -> NumOp2In -> Bool
$c> :: NumOp2In -> NumOp2In -> Bool
> :: NumOp2In -> NumOp2In -> Bool
$c>= :: NumOp2In -> NumOp2In -> Bool
>= :: NumOp2In -> NumOp2In -> Bool
$cmax :: NumOp2In -> NumOp2In -> NumOp2In
max :: NumOp2In -> NumOp2In -> NumOp2In
$cmin :: NumOp2In -> NumOp2In -> NumOp2In
min :: NumOp2In -> NumOp2In -> NumOp2In
C.Ord, Int -> NumOp2In -> ShowS
[NumOp2In] -> ShowS
NumOp2In -> String
(Int -> NumOp2In -> ShowS)
-> (NumOp2In -> String) -> ([NumOp2In] -> ShowS) -> Show NumOp2In
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> NumOp2In -> ShowS
showsPrec :: Int -> NumOp2In -> ShowS
$cshow :: NumOp2In -> String
show :: NumOp2In -> String
$cshowList :: [NumOp2In] -> ShowS
showList :: [NumOp2In] -> ShowS
C.Show, ReadPrec [NumOp2In]
ReadPrec NumOp2In
Int -> ReadS NumOp2In
ReadS [NumOp2In]
(Int -> ReadS NumOp2In)
-> ReadS [NumOp2In]
-> ReadPrec NumOp2In
-> ReadPrec [NumOp2In]
-> Read NumOp2In
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS NumOp2In
readsPrec :: Int -> ReadS NumOp2In
$creadList :: ReadS [NumOp2In]
readList :: ReadS [NumOp2In]
$creadPrec :: ReadPrec NumOp2In
readPrec :: ReadPrec NumOp2In
$creadListPrec :: ReadPrec [NumOp2In]
readListPrec :: ReadPrec [NumOp2In]
C.Read)
data BoolNumOp
= BoolNumOp2Eq
| BoolNumOp2Ne
| BoolNumOp2Le
| BoolNumOp2Lt
| BoolNumOp2Gt
| BoolNumOp2Ge
deriving (BoolNumOp -> BoolNumOp -> Bool
(BoolNumOp -> BoolNumOp -> Bool)
-> (BoolNumOp -> BoolNumOp -> Bool) -> Eq BoolNumOp
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: BoolNumOp -> BoolNumOp -> Bool
== :: BoolNumOp -> BoolNumOp -> Bool
$c/= :: BoolNumOp -> BoolNumOp -> Bool
/= :: BoolNumOp -> BoolNumOp -> Bool
C.Eq, Eq BoolNumOp
Eq BoolNumOp =>
(BoolNumOp -> BoolNumOp -> Ordering)
-> (BoolNumOp -> BoolNumOp -> Bool)
-> (BoolNumOp -> BoolNumOp -> Bool)
-> (BoolNumOp -> BoolNumOp -> Bool)
-> (BoolNumOp -> BoolNumOp -> Bool)
-> (BoolNumOp -> BoolNumOp -> BoolNumOp)
-> (BoolNumOp -> BoolNumOp -> BoolNumOp)
-> Ord BoolNumOp
BoolNumOp -> BoolNumOp -> Bool
BoolNumOp -> BoolNumOp -> Ordering
BoolNumOp -> BoolNumOp -> BoolNumOp
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 :: BoolNumOp -> BoolNumOp -> Ordering
compare :: BoolNumOp -> BoolNumOp -> Ordering
$c< :: BoolNumOp -> BoolNumOp -> Bool
< :: BoolNumOp -> BoolNumOp -> Bool
$c<= :: BoolNumOp -> BoolNumOp -> Bool
<= :: BoolNumOp -> BoolNumOp -> Bool
$c> :: BoolNumOp -> BoolNumOp -> Bool
> :: BoolNumOp -> BoolNumOp -> Bool
$c>= :: BoolNumOp -> BoolNumOp -> Bool
>= :: BoolNumOp -> BoolNumOp -> Bool
$cmax :: BoolNumOp -> BoolNumOp -> BoolNumOp
max :: BoolNumOp -> BoolNumOp -> BoolNumOp
$cmin :: BoolNumOp -> BoolNumOp -> BoolNumOp
min :: BoolNumOp -> BoolNumOp -> BoolNumOp
C.Ord, Int -> BoolNumOp -> ShowS
[BoolNumOp] -> ShowS
BoolNumOp -> String
(Int -> BoolNumOp -> ShowS)
-> (BoolNumOp -> String)
-> ([BoolNumOp] -> ShowS)
-> Show BoolNumOp
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> BoolNumOp -> ShowS
showsPrec :: Int -> BoolNumOp -> ShowS
$cshow :: BoolNumOp -> String
show :: BoolNumOp -> String
$cshowList :: [BoolNumOp] -> ShowS
showList :: [BoolNumOp] -> ShowS
C.Show, ReadPrec [BoolNumOp]
ReadPrec BoolNumOp
Int -> ReadS BoolNumOp
ReadS [BoolNumOp]
(Int -> ReadS BoolNumOp)
-> ReadS [BoolNumOp]
-> ReadPrec BoolNumOp
-> ReadPrec [BoolNumOp]
-> Read BoolNumOp
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS BoolNumOp
readsPrec :: Int -> ReadS BoolNumOp
$creadList :: ReadS [BoolNumOp]
readList :: ReadS [BoolNumOp]
$creadPrec :: ReadPrec BoolNumOp
readPrec :: ReadPrec BoolNumOp
$creadListPrec :: ReadPrec [BoolNumOp]
readListPrec :: ReadPrec [BoolNumOp]
C.Read)
data BoolConst = BoolConstTrue | BoolConstFalse | BoolConstFTP
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)
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)