{-# LANGUAGE DeriveDataTypeable #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE LambdaCase #-}
{-# LANGUAGE PatternSynonyms #-}
{-# LANGUAGE ViewPatterns #-}
module Jikka.Core.Language.Expr where
import Data.Data
import Data.String (IsString)
newtype VarName = VarName String deriving (VarName -> VarName -> Bool
(VarName -> VarName -> Bool)
-> (VarName -> VarName -> Bool) -> Eq VarName
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VarName -> VarName -> Bool
$c/= :: VarName -> VarName -> Bool
== :: VarName -> VarName -> Bool
$c== :: VarName -> VarName -> Bool
Eq, Eq VarName
Eq VarName
-> (VarName -> VarName -> Ordering)
-> (VarName -> VarName -> Bool)
-> (VarName -> VarName -> Bool)
-> (VarName -> VarName -> Bool)
-> (VarName -> VarName -> Bool)
-> (VarName -> VarName -> VarName)
-> (VarName -> VarName -> VarName)
-> Ord VarName
VarName -> VarName -> Bool
VarName -> VarName -> Ordering
VarName -> VarName -> VarName
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 :: VarName -> VarName -> VarName
$cmin :: VarName -> VarName -> VarName
max :: VarName -> VarName -> VarName
$cmax :: VarName -> VarName -> VarName
>= :: VarName -> VarName -> Bool
$c>= :: VarName -> VarName -> Bool
> :: VarName -> VarName -> Bool
$c> :: VarName -> VarName -> Bool
<= :: VarName -> VarName -> Bool
$c<= :: VarName -> VarName -> Bool
< :: VarName -> VarName -> Bool
$c< :: VarName -> VarName -> Bool
compare :: VarName -> VarName -> Ordering
$ccompare :: VarName -> VarName -> Ordering
$cp1Ord :: Eq VarName
Ord, Int -> VarName -> ShowS
[VarName] -> ShowS
VarName -> String
(Int -> VarName -> ShowS)
-> (VarName -> String) -> ([VarName] -> ShowS) -> Show VarName
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [VarName] -> ShowS
$cshowList :: [VarName] -> ShowS
show :: VarName -> String
$cshow :: VarName -> String
showsPrec :: Int -> VarName -> ShowS
$cshowsPrec :: Int -> VarName -> ShowS
Show, ReadPrec [VarName]
ReadPrec VarName
Int -> ReadS VarName
ReadS [VarName]
(Int -> ReadS VarName)
-> ReadS [VarName]
-> ReadPrec VarName
-> ReadPrec [VarName]
-> Read VarName
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [VarName]
$creadListPrec :: ReadPrec [VarName]
readPrec :: ReadPrec VarName
$creadPrec :: ReadPrec VarName
readList :: ReadS [VarName]
$creadList :: ReadS [VarName]
readsPrec :: Int -> ReadS VarName
$creadsPrec :: Int -> ReadS VarName
Read, Typeable VarName
DataType
Constr
Typeable VarName
-> (forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> VarName -> c VarName)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c VarName)
-> (VarName -> Constr)
-> (VarName -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c VarName))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c VarName))
-> ((forall b. Data b => b -> b) -> VarName -> VarName)
-> (forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> VarName -> r)
-> (forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> VarName -> r)
-> (forall u. (forall d. Data d => d -> u) -> VarName -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> VarName -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> VarName -> m VarName)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> VarName -> m VarName)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> VarName -> m VarName)
-> Data VarName
VarName -> DataType
VarName -> Constr
(forall b. Data b => b -> b) -> VarName -> VarName
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> VarName -> c VarName
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c VarName
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) -> VarName -> u
forall u. (forall d. Data d => d -> u) -> VarName -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> VarName -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> VarName -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> VarName -> m VarName
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> VarName -> m VarName
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c VarName
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> VarName -> c VarName
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c VarName)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c VarName)
$cVarName :: Constr
$tVarName :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> VarName -> m VarName
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> VarName -> m VarName
gmapMp :: (forall d. Data d => d -> m d) -> VarName -> m VarName
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> VarName -> m VarName
gmapM :: (forall d. Data d => d -> m d) -> VarName -> m VarName
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> VarName -> m VarName
gmapQi :: Int -> (forall d. Data d => d -> u) -> VarName -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> VarName -> u
gmapQ :: (forall d. Data d => d -> u) -> VarName -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> VarName -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> VarName -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> VarName -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> VarName -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> VarName -> r
gmapT :: (forall b. Data b => b -> b) -> VarName -> VarName
$cgmapT :: (forall b. Data b => b -> b) -> VarName -> VarName
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c VarName)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c VarName)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c VarName)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c VarName)
dataTypeOf :: VarName -> DataType
$cdataTypeOf :: VarName -> DataType
toConstr :: VarName -> Constr
$ctoConstr :: VarName -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c VarName
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c VarName
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> VarName -> c VarName
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> VarName -> c VarName
$cp1Data :: Typeable VarName
Data, Typeable, String -> VarName
(String -> VarName) -> IsString VarName
forall a. (String -> a) -> IsString a
fromString :: String -> VarName
$cfromString :: String -> VarName
IsString)
unVarName :: VarName -> String
unVarName :: VarName -> String
unVarName (VarName String
name) = String
name
newtype TypeName = TypeName String deriving (TypeName -> TypeName -> Bool
(TypeName -> TypeName -> Bool)
-> (TypeName -> TypeName -> Bool) -> Eq TypeName
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TypeName -> TypeName -> Bool
$c/= :: TypeName -> TypeName -> Bool
== :: TypeName -> TypeName -> Bool
$c== :: TypeName -> TypeName -> Bool
Eq, Eq TypeName
Eq TypeName
-> (TypeName -> TypeName -> Ordering)
-> (TypeName -> TypeName -> Bool)
-> (TypeName -> TypeName -> Bool)
-> (TypeName -> TypeName -> Bool)
-> (TypeName -> TypeName -> Bool)
-> (TypeName -> TypeName -> TypeName)
-> (TypeName -> TypeName -> TypeName)
-> Ord TypeName
TypeName -> TypeName -> Bool
TypeName -> TypeName -> Ordering
TypeName -> TypeName -> TypeName
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 :: TypeName -> TypeName -> TypeName
$cmin :: TypeName -> TypeName -> TypeName
max :: TypeName -> TypeName -> TypeName
$cmax :: TypeName -> TypeName -> TypeName
>= :: TypeName -> TypeName -> Bool
$c>= :: TypeName -> TypeName -> Bool
> :: TypeName -> TypeName -> Bool
$c> :: TypeName -> TypeName -> Bool
<= :: TypeName -> TypeName -> Bool
$c<= :: TypeName -> TypeName -> Bool
< :: TypeName -> TypeName -> Bool
$c< :: TypeName -> TypeName -> Bool
compare :: TypeName -> TypeName -> Ordering
$ccompare :: TypeName -> TypeName -> Ordering
$cp1Ord :: Eq TypeName
Ord, Int -> TypeName -> ShowS
[TypeName] -> ShowS
TypeName -> String
(Int -> TypeName -> ShowS)
-> (TypeName -> String) -> ([TypeName] -> ShowS) -> Show TypeName
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TypeName] -> ShowS
$cshowList :: [TypeName] -> ShowS
show :: TypeName -> String
$cshow :: TypeName -> String
showsPrec :: Int -> TypeName -> ShowS
$cshowsPrec :: Int -> TypeName -> ShowS
Show, ReadPrec [TypeName]
ReadPrec TypeName
Int -> ReadS TypeName
ReadS [TypeName]
(Int -> ReadS TypeName)
-> ReadS [TypeName]
-> ReadPrec TypeName
-> ReadPrec [TypeName]
-> Read TypeName
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [TypeName]
$creadListPrec :: ReadPrec [TypeName]
readPrec :: ReadPrec TypeName
$creadPrec :: ReadPrec TypeName
readList :: ReadS [TypeName]
$creadList :: ReadS [TypeName]
readsPrec :: Int -> ReadS TypeName
$creadsPrec :: Int -> ReadS TypeName
Read, Typeable TypeName
DataType
Constr
Typeable TypeName
-> (forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TypeName -> c TypeName)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TypeName)
-> (TypeName -> Constr)
-> (TypeName -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TypeName))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TypeName))
-> ((forall b. Data b => b -> b) -> TypeName -> TypeName)
-> (forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TypeName -> r)
-> (forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TypeName -> r)
-> (forall u. (forall d. Data d => d -> u) -> TypeName -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> TypeName -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TypeName -> m TypeName)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TypeName -> m TypeName)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TypeName -> m TypeName)
-> Data TypeName
TypeName -> DataType
TypeName -> Constr
(forall b. Data b => b -> b) -> TypeName -> TypeName
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TypeName -> c TypeName
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TypeName
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) -> TypeName -> u
forall u. (forall d. Data d => d -> u) -> TypeName -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TypeName -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TypeName -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TypeName -> m TypeName
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TypeName -> m TypeName
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TypeName
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TypeName -> c TypeName
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TypeName)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TypeName)
$cTypeName :: Constr
$tTypeName :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> TypeName -> m TypeName
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TypeName -> m TypeName
gmapMp :: (forall d. Data d => d -> m d) -> TypeName -> m TypeName
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TypeName -> m TypeName
gmapM :: (forall d. Data d => d -> m d) -> TypeName -> m TypeName
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TypeName -> m TypeName
gmapQi :: Int -> (forall d. Data d => d -> u) -> TypeName -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> TypeName -> u
gmapQ :: (forall d. Data d => d -> u) -> TypeName -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> TypeName -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TypeName -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TypeName -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TypeName -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TypeName -> r
gmapT :: (forall b. Data b => b -> b) -> TypeName -> TypeName
$cgmapT :: (forall b. Data b => b -> b) -> TypeName -> TypeName
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TypeName)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TypeName)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c TypeName)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TypeName)
dataTypeOf :: TypeName -> DataType
$cdataTypeOf :: TypeName -> DataType
toConstr :: TypeName -> Constr
$ctoConstr :: TypeName -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TypeName
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TypeName
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TypeName -> c TypeName
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TypeName -> c TypeName
$cp1Data :: Typeable TypeName
Data, Typeable, String -> TypeName
(String -> TypeName) -> IsString TypeName
forall a. (String -> a) -> IsString a
fromString :: String -> TypeName
$cfromString :: String -> TypeName
IsString)
unTypeName :: TypeName -> String
unTypeName :: TypeName -> String
unTypeName (TypeName String
name) = String
name
data Type
= VarTy TypeName
| IntTy
| BoolTy
| ListTy Type
| TupleTy [Type]
| FunTy Type Type
| DataStructureTy DataStructure
deriving (Type -> Type -> Bool
(Type -> Type -> Bool) -> (Type -> Type -> Bool) -> Eq Type
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Type -> Type -> Bool
$c/= :: Type -> Type -> Bool
== :: Type -> Type -> Bool
$c== :: Type -> Type -> Bool
Eq, Eq Type
Eq Type
-> (Type -> Type -> Ordering)
-> (Type -> Type -> Bool)
-> (Type -> Type -> Bool)
-> (Type -> Type -> Bool)
-> (Type -> Type -> Bool)
-> (Type -> Type -> Type)
-> (Type -> Type -> Type)
-> Ord Type
Type -> Type -> Bool
Type -> Type -> Ordering
Type -> Type -> Type
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 :: Type -> Type -> Type
$cmin :: Type -> Type -> Type
max :: Type -> Type -> Type
$cmax :: Type -> Type -> Type
>= :: Type -> Type -> Bool
$c>= :: Type -> Type -> Bool
> :: Type -> Type -> Bool
$c> :: Type -> Type -> Bool
<= :: Type -> Type -> Bool
$c<= :: Type -> Type -> Bool
< :: Type -> Type -> Bool
$c< :: Type -> Type -> Bool
compare :: Type -> Type -> Ordering
$ccompare :: Type -> Type -> Ordering
$cp1Ord :: Eq Type
Ord, Int -> Type -> ShowS
[Type] -> ShowS
Type -> String
(Int -> Type -> ShowS)
-> (Type -> String) -> ([Type] -> ShowS) -> Show Type
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Type] -> ShowS
$cshowList :: [Type] -> ShowS
show :: Type -> String
$cshow :: Type -> String
showsPrec :: Int -> Type -> ShowS
$cshowsPrec :: Int -> Type -> ShowS
Show, ReadPrec [Type]
ReadPrec Type
Int -> ReadS Type
ReadS [Type]
(Int -> ReadS Type)
-> ReadS [Type] -> ReadPrec Type -> ReadPrec [Type] -> Read Type
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Type]
$creadListPrec :: ReadPrec [Type]
readPrec :: ReadPrec Type
$creadPrec :: ReadPrec Type
readList :: ReadS [Type]
$creadList :: ReadS [Type]
readsPrec :: Int -> ReadS Type
$creadsPrec :: Int -> ReadS Type
Read, Typeable Type
DataType
Constr
Typeable Type
-> (forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Type -> c Type)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Type)
-> (Type -> Constr)
-> (Type -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Type))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Type))
-> ((forall b. Data b => b -> b) -> Type -> Type)
-> (forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Type -> r)
-> (forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Type -> r)
-> (forall u. (forall d. Data d => d -> u) -> Type -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Type -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Type -> m Type)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Type -> m Type)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Type -> m Type)
-> Data Type
Type -> DataType
Type -> Constr
(forall b. Data b => b -> b) -> Type -> Type
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Type -> c Type
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Type
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) -> Type -> u
forall u. (forall d. Data d => d -> u) -> Type -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Type -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Type -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Type -> m Type
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Type -> m Type
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Type
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Type -> c Type
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Type)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Type)
$cDataStructureTy :: Constr
$cFunTy :: Constr
$cTupleTy :: Constr
$cListTy :: Constr
$cBoolTy :: Constr
$cIntTy :: Constr
$cVarTy :: Constr
$tType :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Type -> m Type
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Type -> m Type
gmapMp :: (forall d. Data d => d -> m d) -> Type -> m Type
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Type -> m Type
gmapM :: (forall d. Data d => d -> m d) -> Type -> m Type
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Type -> m Type
gmapQi :: Int -> (forall d. Data d => d -> u) -> Type -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Type -> u
gmapQ :: (forall d. Data d => d -> u) -> Type -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Type -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Type -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Type -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Type -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Type -> r
gmapT :: (forall b. Data b => b -> b) -> Type -> Type
$cgmapT :: (forall b. Data b => b -> b) -> Type -> Type
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Type)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Type)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Type)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Type)
dataTypeOf :: Type -> DataType
$cdataTypeOf :: Type -> DataType
toConstr :: Type -> Constr
$ctoConstr :: Type -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Type
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Type
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Type -> c Type
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Type -> c Type
$cp1Data :: Typeable Type
Data, Typeable)
data DataStructure
= ConvexHullTrick
| SegmentTree Semigroup'
deriving (DataStructure -> DataStructure -> Bool
(DataStructure -> DataStructure -> Bool)
-> (DataStructure -> DataStructure -> Bool) -> Eq DataStructure
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DataStructure -> DataStructure -> Bool
$c/= :: DataStructure -> DataStructure -> Bool
== :: DataStructure -> DataStructure -> Bool
$c== :: DataStructure -> DataStructure -> Bool
Eq, Eq DataStructure
Eq DataStructure
-> (DataStructure -> DataStructure -> Ordering)
-> (DataStructure -> DataStructure -> Bool)
-> (DataStructure -> DataStructure -> Bool)
-> (DataStructure -> DataStructure -> Bool)
-> (DataStructure -> DataStructure -> Bool)
-> (DataStructure -> DataStructure -> DataStructure)
-> (DataStructure -> DataStructure -> DataStructure)
-> Ord DataStructure
DataStructure -> DataStructure -> Bool
DataStructure -> DataStructure -> Ordering
DataStructure -> DataStructure -> DataStructure
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 :: DataStructure -> DataStructure -> DataStructure
$cmin :: DataStructure -> DataStructure -> DataStructure
max :: DataStructure -> DataStructure -> DataStructure
$cmax :: DataStructure -> DataStructure -> DataStructure
>= :: DataStructure -> DataStructure -> Bool
$c>= :: DataStructure -> DataStructure -> Bool
> :: DataStructure -> DataStructure -> Bool
$c> :: DataStructure -> DataStructure -> Bool
<= :: DataStructure -> DataStructure -> Bool
$c<= :: DataStructure -> DataStructure -> Bool
< :: DataStructure -> DataStructure -> Bool
$c< :: DataStructure -> DataStructure -> Bool
compare :: DataStructure -> DataStructure -> Ordering
$ccompare :: DataStructure -> DataStructure -> Ordering
$cp1Ord :: Eq DataStructure
Ord, Int -> DataStructure -> ShowS
[DataStructure] -> ShowS
DataStructure -> String
(Int -> DataStructure -> ShowS)
-> (DataStructure -> String)
-> ([DataStructure] -> ShowS)
-> Show DataStructure
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DataStructure] -> ShowS
$cshowList :: [DataStructure] -> ShowS
show :: DataStructure -> String
$cshow :: DataStructure -> String
showsPrec :: Int -> DataStructure -> ShowS
$cshowsPrec :: Int -> DataStructure -> ShowS
Show, ReadPrec [DataStructure]
ReadPrec DataStructure
Int -> ReadS DataStructure
ReadS [DataStructure]
(Int -> ReadS DataStructure)
-> ReadS [DataStructure]
-> ReadPrec DataStructure
-> ReadPrec [DataStructure]
-> Read DataStructure
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [DataStructure]
$creadListPrec :: ReadPrec [DataStructure]
readPrec :: ReadPrec DataStructure
$creadPrec :: ReadPrec DataStructure
readList :: ReadS [DataStructure]
$creadList :: ReadS [DataStructure]
readsPrec :: Int -> ReadS DataStructure
$creadsPrec :: Int -> ReadS DataStructure
Read, Typeable DataStructure
DataType
Constr
Typeable DataStructure
-> (forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DataStructure -> c DataStructure)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DataStructure)
-> (DataStructure -> Constr)
-> (DataStructure -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DataStructure))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DataStructure))
-> ((forall b. Data b => b -> b) -> DataStructure -> DataStructure)
-> (forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DataStructure -> r)
-> (forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DataStructure -> r)
-> (forall u. (forall d. Data d => d -> u) -> DataStructure -> [u])
-> (forall u.
Int -> (forall d. Data d => d -> u) -> DataStructure -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DataStructure -> m DataStructure)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DataStructure -> m DataStructure)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DataStructure -> m DataStructure)
-> Data DataStructure
DataStructure -> DataType
DataStructure -> Constr
(forall b. Data b => b -> b) -> DataStructure -> DataStructure
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DataStructure -> c DataStructure
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DataStructure
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) -> DataStructure -> u
forall u. (forall d. Data d => d -> u) -> DataStructure -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DataStructure -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DataStructure -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DataStructure -> m DataStructure
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DataStructure -> m DataStructure
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DataStructure
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DataStructure -> c DataStructure
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DataStructure)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DataStructure)
$cSegmentTree :: Constr
$cConvexHullTrick :: Constr
$tDataStructure :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> DataStructure -> m DataStructure
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DataStructure -> m DataStructure
gmapMp :: (forall d. Data d => d -> m d) -> DataStructure -> m DataStructure
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DataStructure -> m DataStructure
gmapM :: (forall d. Data d => d -> m d) -> DataStructure -> m DataStructure
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DataStructure -> m DataStructure
gmapQi :: Int -> (forall d. Data d => d -> u) -> DataStructure -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DataStructure -> u
gmapQ :: (forall d. Data d => d -> u) -> DataStructure -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DataStructure -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DataStructure -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DataStructure -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DataStructure -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DataStructure -> r
gmapT :: (forall b. Data b => b -> b) -> DataStructure -> DataStructure
$cgmapT :: (forall b. Data b => b -> b) -> DataStructure -> DataStructure
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DataStructure)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DataStructure)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c DataStructure)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DataStructure)
dataTypeOf :: DataStructure -> DataType
$cdataTypeOf :: DataStructure -> DataType
toConstr :: DataStructure -> Constr
$ctoConstr :: DataStructure -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DataStructure
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DataStructure
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DataStructure -> c DataStructure
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DataStructure -> c DataStructure
$cp1Data :: Typeable DataStructure
Data, Typeable)
data Semigroup'
= SemigroupIntPlus
| SemigroupIntMin
| SemigroupIntMax
| SemigroupIntGcd
| SemigroupIntLcm
deriving (Semigroup' -> Semigroup' -> Bool
(Semigroup' -> Semigroup' -> Bool)
-> (Semigroup' -> Semigroup' -> Bool) -> Eq Semigroup'
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Semigroup' -> Semigroup' -> Bool
$c/= :: Semigroup' -> Semigroup' -> Bool
== :: Semigroup' -> Semigroup' -> Bool
$c== :: Semigroup' -> Semigroup' -> Bool
Eq, Eq Semigroup'
Eq Semigroup'
-> (Semigroup' -> Semigroup' -> Ordering)
-> (Semigroup' -> Semigroup' -> Bool)
-> (Semigroup' -> Semigroup' -> Bool)
-> (Semigroup' -> Semigroup' -> Bool)
-> (Semigroup' -> Semigroup' -> Bool)
-> (Semigroup' -> Semigroup' -> Semigroup')
-> (Semigroup' -> Semigroup' -> Semigroup')
-> Ord Semigroup'
Semigroup' -> Semigroup' -> Bool
Semigroup' -> Semigroup' -> Ordering
Semigroup' -> Semigroup' -> Semigroup'
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 :: Semigroup' -> Semigroup' -> Semigroup'
$cmin :: Semigroup' -> Semigroup' -> Semigroup'
max :: Semigroup' -> Semigroup' -> Semigroup'
$cmax :: Semigroup' -> Semigroup' -> Semigroup'
>= :: Semigroup' -> Semigroup' -> Bool
$c>= :: Semigroup' -> Semigroup' -> Bool
> :: Semigroup' -> Semigroup' -> Bool
$c> :: Semigroup' -> Semigroup' -> Bool
<= :: Semigroup' -> Semigroup' -> Bool
$c<= :: Semigroup' -> Semigroup' -> Bool
< :: Semigroup' -> Semigroup' -> Bool
$c< :: Semigroup' -> Semigroup' -> Bool
compare :: Semigroup' -> Semigroup' -> Ordering
$ccompare :: Semigroup' -> Semigroup' -> Ordering
$cp1Ord :: Eq Semigroup'
Ord, Int -> Semigroup' -> ShowS
[Semigroup'] -> ShowS
Semigroup' -> String
(Int -> Semigroup' -> ShowS)
-> (Semigroup' -> String)
-> ([Semigroup'] -> ShowS)
-> Show Semigroup'
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Semigroup'] -> ShowS
$cshowList :: [Semigroup'] -> ShowS
show :: Semigroup' -> String
$cshow :: Semigroup' -> String
showsPrec :: Int -> Semigroup' -> ShowS
$cshowsPrec :: Int -> Semigroup' -> ShowS
Show, ReadPrec [Semigroup']
ReadPrec Semigroup'
Int -> ReadS Semigroup'
ReadS [Semigroup']
(Int -> ReadS Semigroup')
-> ReadS [Semigroup']
-> ReadPrec Semigroup'
-> ReadPrec [Semigroup']
-> Read Semigroup'
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Semigroup']
$creadListPrec :: ReadPrec [Semigroup']
readPrec :: ReadPrec Semigroup'
$creadPrec :: ReadPrec Semigroup'
readList :: ReadS [Semigroup']
$creadList :: ReadS [Semigroup']
readsPrec :: Int -> ReadS Semigroup'
$creadsPrec :: Int -> ReadS Semigroup'
Read, Typeable Semigroup'
DataType
Constr
Typeable Semigroup'
-> (forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Semigroup' -> c Semigroup')
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Semigroup')
-> (Semigroup' -> Constr)
-> (Semigroup' -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Semigroup'))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c Semigroup'))
-> ((forall b. Data b => b -> b) -> Semigroup' -> Semigroup')
-> (forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Semigroup' -> r)
-> (forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Semigroup' -> r)
-> (forall u. (forall d. Data d => d -> u) -> Semigroup' -> [u])
-> (forall u.
Int -> (forall d. Data d => d -> u) -> Semigroup' -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Semigroup' -> m Semigroup')
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Semigroup' -> m Semigroup')
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Semigroup' -> m Semigroup')
-> Data Semigroup'
Semigroup' -> DataType
Semigroup' -> Constr
(forall b. Data b => b -> b) -> Semigroup' -> Semigroup'
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Semigroup' -> c Semigroup'
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Semigroup'
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) -> Semigroup' -> u
forall u. (forall d. Data d => d -> u) -> Semigroup' -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Semigroup' -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Semigroup' -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Semigroup' -> m Semigroup'
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Semigroup' -> m Semigroup'
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Semigroup'
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Semigroup' -> c Semigroup'
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Semigroup')
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Semigroup')
$cSemigroupIntLcm :: Constr
$cSemigroupIntGcd :: Constr
$cSemigroupIntMax :: Constr
$cSemigroupIntMin :: Constr
$cSemigroupIntPlus :: Constr
$tSemigroup' :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Semigroup' -> m Semigroup'
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Semigroup' -> m Semigroup'
gmapMp :: (forall d. Data d => d -> m d) -> Semigroup' -> m Semigroup'
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Semigroup' -> m Semigroup'
gmapM :: (forall d. Data d => d -> m d) -> Semigroup' -> m Semigroup'
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Semigroup' -> m Semigroup'
gmapQi :: Int -> (forall d. Data d => d -> u) -> Semigroup' -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Semigroup' -> u
gmapQ :: (forall d. Data d => d -> u) -> Semigroup' -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Semigroup' -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Semigroup' -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Semigroup' -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Semigroup' -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Semigroup' -> r
gmapT :: (forall b. Data b => b -> b) -> Semigroup' -> Semigroup'
$cgmapT :: (forall b. Data b => b -> b) -> Semigroup' -> Semigroup'
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Semigroup')
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Semigroup')
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Semigroup')
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Semigroup')
dataTypeOf :: Semigroup' -> DataType
$cdataTypeOf :: Semigroup' -> DataType
toConstr :: Semigroup' -> Constr
$ctoConstr :: Semigroup' -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Semigroup'
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Semigroup'
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Semigroup' -> c Semigroup'
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Semigroup' -> c Semigroup'
$cp1Data :: Typeable Semigroup'
Data, Typeable)
data Builtin
=
Negate
|
Plus
|
Minus
|
Mult
|
FloorDiv
|
FloorMod
|
CeilDiv
|
CeilMod
|
JustDiv
|
Pow
|
Abs
|
Gcd
|
Lcm
|
Min2
|
Max2
|
Iterate
|
Not
|
And
|
Or
|
Implies
|
If
|
BitNot
|
BitAnd
|
BitOr
|
BitXor
|
BitLeftShift
|
BitRightShift
|
MatAp Integer Integer
|
MatZero Integer Integer
|
MatOne Integer
|
MatAdd Integer Integer
|
MatMul Integer Integer Integer
|
MatPow Integer
|
VecFloorMod Integer
|
MatFloorMod Integer Integer
|
ModNegate
|
ModPlus
|
ModMinus
|
ModMult
|
ModInv
|
ModPow
|
ModMatAp Integer Integer
|
ModMatAdd Integer Integer
|
ModMatMul Integer Integer Integer
|
ModMatPow Integer
|
Cons
|
Snoc
|
Foldl
|
Scanl
|
Build
|
Len
|
Map
|
Filter
|
At
|
SetAt
|
Elem
|
Sum
|
Product
|
ModSum
|
ModProduct
|
Min1
|
Max1
|
ArgMin
|
ArgMax
|
Gcd1
|
Lcm1
|
All
|
Any
|
Sorted
|
Reversed
|
Range1
|
Range2
|
Range3
|
Tuple
|
Proj Integer
|
LessThan
|
LessEqual
|
GreaterThan
|
GreaterEqual
|
Equal
|
NotEqual
|
Fact
|
Choose
|
Permute
|
MultiChoose
|
ConvexHullTrickInit
|
ConvexHullTrickGetMin
|
ConvexHullTrickInsert
|
SegmentTreeInitList Semigroup'
|
SegmentTreeGetRange Semigroup'
|
SegmentTreeSetPoint Semigroup'
deriving (Builtin -> Builtin -> Bool
(Builtin -> Builtin -> Bool)
-> (Builtin -> Builtin -> Bool) -> Eq Builtin
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Builtin -> Builtin -> Bool
$c/= :: Builtin -> Builtin -> Bool
== :: Builtin -> Builtin -> Bool
$c== :: Builtin -> Builtin -> Bool
Eq, Eq Builtin
Eq Builtin
-> (Builtin -> Builtin -> Ordering)
-> (Builtin -> Builtin -> Bool)
-> (Builtin -> Builtin -> Bool)
-> (Builtin -> Builtin -> Bool)
-> (Builtin -> Builtin -> Bool)
-> (Builtin -> Builtin -> Builtin)
-> (Builtin -> Builtin -> Builtin)
-> Ord Builtin
Builtin -> Builtin -> Bool
Builtin -> Builtin -> Ordering
Builtin -> Builtin -> Builtin
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 :: Builtin -> Builtin -> Builtin
$cmin :: Builtin -> Builtin -> Builtin
max :: Builtin -> Builtin -> Builtin
$cmax :: Builtin -> Builtin -> Builtin
>= :: Builtin -> Builtin -> Bool
$c>= :: Builtin -> Builtin -> Bool
> :: Builtin -> Builtin -> Bool
$c> :: Builtin -> Builtin -> Bool
<= :: Builtin -> Builtin -> Bool
$c<= :: Builtin -> Builtin -> Bool
< :: Builtin -> Builtin -> Bool
$c< :: Builtin -> Builtin -> Bool
compare :: Builtin -> Builtin -> Ordering
$ccompare :: Builtin -> Builtin -> Ordering
$cp1Ord :: Eq Builtin
Ord, Int -> Builtin -> ShowS
[Builtin] -> ShowS
Builtin -> String
(Int -> Builtin -> ShowS)
-> (Builtin -> String) -> ([Builtin] -> ShowS) -> Show Builtin
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Builtin] -> ShowS
$cshowList :: [Builtin] -> ShowS
show :: Builtin -> String
$cshow :: Builtin -> String
showsPrec :: Int -> Builtin -> ShowS
$cshowsPrec :: Int -> Builtin -> ShowS
Show, ReadPrec [Builtin]
ReadPrec Builtin
Int -> ReadS Builtin
ReadS [Builtin]
(Int -> ReadS Builtin)
-> ReadS [Builtin]
-> ReadPrec Builtin
-> ReadPrec [Builtin]
-> Read Builtin
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Builtin]
$creadListPrec :: ReadPrec [Builtin]
readPrec :: ReadPrec Builtin
$creadPrec :: ReadPrec Builtin
readList :: ReadS [Builtin]
$creadList :: ReadS [Builtin]
readsPrec :: Int -> ReadS Builtin
$creadsPrec :: Int -> ReadS Builtin
Read, Typeable Builtin
DataType
Constr
Typeable Builtin
-> (forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Builtin -> c Builtin)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Builtin)
-> (Builtin -> Constr)
-> (Builtin -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Builtin))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Builtin))
-> ((forall b. Data b => b -> b) -> Builtin -> Builtin)
-> (forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Builtin -> r)
-> (forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Builtin -> r)
-> (forall u. (forall d. Data d => d -> u) -> Builtin -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Builtin -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Builtin -> m Builtin)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Builtin -> m Builtin)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Builtin -> m Builtin)
-> Data Builtin
Builtin -> DataType
Builtin -> Constr
(forall b. Data b => b -> b) -> Builtin -> Builtin
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Builtin -> c Builtin
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Builtin
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) -> Builtin -> u
forall u. (forall d. Data d => d -> u) -> Builtin -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Builtin -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Builtin -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Builtin -> m Builtin
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Builtin -> m Builtin
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Builtin
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Builtin -> c Builtin
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Builtin)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Builtin)
$cSegmentTreeSetPoint :: Constr
$cSegmentTreeGetRange :: Constr
$cSegmentTreeInitList :: Constr
$cConvexHullTrickInsert :: Constr
$cConvexHullTrickGetMin :: Constr
$cConvexHullTrickInit :: Constr
$cMultiChoose :: Constr
$cPermute :: Constr
$cChoose :: Constr
$cFact :: Constr
$cNotEqual :: Constr
$cEqual :: Constr
$cGreaterEqual :: Constr
$cGreaterThan :: Constr
$cLessEqual :: Constr
$cLessThan :: Constr
$cProj :: Constr
$cTuple :: Constr
$cRange3 :: Constr
$cRange2 :: Constr
$cRange1 :: Constr
$cReversed :: Constr
$cSorted :: Constr
$cAny :: Constr
$cAll :: Constr
$cLcm1 :: Constr
$cGcd1 :: Constr
$cArgMax :: Constr
$cArgMin :: Constr
$cMax1 :: Constr
$cMin1 :: Constr
$cModProduct :: Constr
$cModSum :: Constr
$cProduct :: Constr
$cSum :: Constr
$cElem :: Constr
$cSetAt :: Constr
$cAt :: Constr
$cFilter :: Constr
$cMap :: Constr
$cLen :: Constr
$cBuild :: Constr
$cScanl :: Constr
$cFoldl :: Constr
$cSnoc :: Constr
$cCons :: Constr
$cModMatPow :: Constr
$cModMatMul :: Constr
$cModMatAdd :: Constr
$cModMatAp :: Constr
$cModPow :: Constr
$cModInv :: Constr
$cModMult :: Constr
$cModMinus :: Constr
$cModPlus :: Constr
$cModNegate :: Constr
$cMatFloorMod :: Constr
$cVecFloorMod :: Constr
$cMatPow :: Constr
$cMatMul :: Constr
$cMatAdd :: Constr
$cMatOne :: Constr
$cMatZero :: Constr
$cMatAp :: Constr
$cBitRightShift :: Constr
$cBitLeftShift :: Constr
$cBitXor :: Constr
$cBitOr :: Constr
$cBitAnd :: Constr
$cBitNot :: Constr
$cIf :: Constr
$cImplies :: Constr
$cOr :: Constr
$cAnd :: Constr
$cNot :: Constr
$cIterate :: Constr
$cMax2 :: Constr
$cMin2 :: Constr
$cLcm :: Constr
$cGcd :: Constr
$cAbs :: Constr
$cPow :: Constr
$cJustDiv :: Constr
$cCeilMod :: Constr
$cCeilDiv :: Constr
$cFloorMod :: Constr
$cFloorDiv :: Constr
$cMult :: Constr
$cMinus :: Constr
$cPlus :: Constr
$cNegate :: Constr
$tBuiltin :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Builtin -> m Builtin
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Builtin -> m Builtin
gmapMp :: (forall d. Data d => d -> m d) -> Builtin -> m Builtin
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Builtin -> m Builtin
gmapM :: (forall d. Data d => d -> m d) -> Builtin -> m Builtin
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Builtin -> m Builtin
gmapQi :: Int -> (forall d. Data d => d -> u) -> Builtin -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Builtin -> u
gmapQ :: (forall d. Data d => d -> u) -> Builtin -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Builtin -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Builtin -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Builtin -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Builtin -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Builtin -> r
gmapT :: (forall b. Data b => b -> b) -> Builtin -> Builtin
$cgmapT :: (forall b. Data b => b -> b) -> Builtin -> Builtin
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Builtin)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Builtin)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Builtin)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Builtin)
dataTypeOf :: Builtin -> DataType
$cdataTypeOf :: Builtin -> DataType
toConstr :: Builtin -> Constr
$ctoConstr :: Builtin -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Builtin
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Builtin
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Builtin -> c Builtin
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Builtin -> c Builtin
$cp1Data :: Typeable Builtin
Data, Typeable)
data Literal
= LitBuiltin Builtin [Type]
|
LitInt Integer
|
LitBool Bool
|
LitNil Type
|
LitBottom Type String
deriving (Literal -> Literal -> Bool
(Literal -> Literal -> Bool)
-> (Literal -> Literal -> Bool) -> Eq Literal
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Literal -> Literal -> Bool
$c/= :: Literal -> Literal -> Bool
== :: Literal -> Literal -> Bool
$c== :: Literal -> Literal -> Bool
Eq, Eq Literal
Eq Literal
-> (Literal -> Literal -> Ordering)
-> (Literal -> Literal -> Bool)
-> (Literal -> Literal -> Bool)
-> (Literal -> Literal -> Bool)
-> (Literal -> Literal -> Bool)
-> (Literal -> Literal -> Literal)
-> (Literal -> Literal -> Literal)
-> Ord Literal
Literal -> Literal -> Bool
Literal -> Literal -> Ordering
Literal -> Literal -> Literal
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 :: Literal -> Literal -> Literal
$cmin :: Literal -> Literal -> Literal
max :: Literal -> Literal -> Literal
$cmax :: Literal -> Literal -> Literal
>= :: Literal -> Literal -> Bool
$c>= :: Literal -> Literal -> Bool
> :: Literal -> Literal -> Bool
$c> :: Literal -> Literal -> Bool
<= :: Literal -> Literal -> Bool
$c<= :: Literal -> Literal -> Bool
< :: Literal -> Literal -> Bool
$c< :: Literal -> Literal -> Bool
compare :: Literal -> Literal -> Ordering
$ccompare :: Literal -> Literal -> Ordering
$cp1Ord :: Eq Literal
Ord, Int -> Literal -> ShowS
[Literal] -> ShowS
Literal -> String
(Int -> Literal -> ShowS)
-> (Literal -> String) -> ([Literal] -> ShowS) -> Show Literal
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Literal] -> ShowS
$cshowList :: [Literal] -> ShowS
show :: Literal -> String
$cshow :: Literal -> String
showsPrec :: Int -> Literal -> ShowS
$cshowsPrec :: Int -> Literal -> ShowS
Show, ReadPrec [Literal]
ReadPrec Literal
Int -> ReadS Literal
ReadS [Literal]
(Int -> ReadS Literal)
-> ReadS [Literal]
-> ReadPrec Literal
-> ReadPrec [Literal]
-> Read Literal
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Literal]
$creadListPrec :: ReadPrec [Literal]
readPrec :: ReadPrec Literal
$creadPrec :: ReadPrec Literal
readList :: ReadS [Literal]
$creadList :: ReadS [Literal]
readsPrec :: Int -> ReadS Literal
$creadsPrec :: Int -> ReadS Literal
Read, Typeable Literal
DataType
Constr
Typeable Literal
-> (forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Literal -> c Literal)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Literal)
-> (Literal -> Constr)
-> (Literal -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Literal))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Literal))
-> ((forall b. Data b => b -> b) -> Literal -> Literal)
-> (forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Literal -> r)
-> (forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Literal -> r)
-> (forall u. (forall d. Data d => d -> u) -> Literal -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Literal -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Literal -> m Literal)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Literal -> m Literal)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Literal -> m Literal)
-> Data Literal
Literal -> DataType
Literal -> Constr
(forall b. Data b => b -> b) -> Literal -> Literal
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Literal -> c Literal
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Literal
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) -> Literal -> u
forall u. (forall d. Data d => d -> u) -> Literal -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Literal -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Literal -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Literal -> m Literal
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Literal -> m Literal
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Literal
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Literal -> c Literal
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Literal)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Literal)
$cLitBottom :: Constr
$cLitNil :: Constr
$cLitBool :: Constr
$cLitInt :: Constr
$cLitBuiltin :: Constr
$tLiteral :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Literal -> m Literal
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Literal -> m Literal
gmapMp :: (forall d. Data d => d -> m d) -> Literal -> m Literal
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Literal -> m Literal
gmapM :: (forall d. Data d => d -> m d) -> Literal -> m Literal
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Literal -> m Literal
gmapQi :: Int -> (forall d. Data d => d -> u) -> Literal -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Literal -> u
gmapQ :: (forall d. Data d => d -> u) -> Literal -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Literal -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Literal -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Literal -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Literal -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Literal -> r
gmapT :: (forall b. Data b => b -> b) -> Literal -> Literal
$cgmapT :: (forall b. Data b => b -> b) -> Literal -> Literal
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Literal)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Literal)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Literal)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Literal)
dataTypeOf :: Literal -> DataType
$cdataTypeOf :: Literal -> DataType
toConstr :: Literal -> Constr
$ctoConstr :: Literal -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Literal
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Literal
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Literal -> c Literal
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Literal -> c Literal
$cp1Data :: Typeable Literal
Data, Typeable)
data Expr
= Var VarName
| Lit Literal
| App Expr Expr
| Lam VarName Type Expr
|
Let VarName Type Expr Expr
| Assert Expr Expr
deriving (Expr -> Expr -> Bool
(Expr -> Expr -> Bool) -> (Expr -> Expr -> Bool) -> Eq Expr
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Expr -> Expr -> Bool
$c/= :: Expr -> Expr -> Bool
== :: Expr -> Expr -> Bool
$c== :: Expr -> Expr -> Bool
Eq, Eq Expr
Eq Expr
-> (Expr -> Expr -> Ordering)
-> (Expr -> Expr -> Bool)
-> (Expr -> Expr -> Bool)
-> (Expr -> Expr -> Bool)
-> (Expr -> Expr -> Bool)
-> (Expr -> Expr -> Expr)
-> (Expr -> Expr -> Expr)
-> Ord Expr
Expr -> Expr -> Bool
Expr -> Expr -> Ordering
Expr -> Expr -> Expr
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 :: Expr -> Expr -> Expr
$cmin :: Expr -> Expr -> Expr
max :: Expr -> Expr -> Expr
$cmax :: Expr -> Expr -> Expr
>= :: Expr -> Expr -> Bool
$c>= :: Expr -> Expr -> Bool
> :: Expr -> Expr -> Bool
$c> :: Expr -> Expr -> Bool
<= :: Expr -> Expr -> Bool
$c<= :: Expr -> Expr -> Bool
< :: Expr -> Expr -> Bool
$c< :: Expr -> Expr -> Bool
compare :: Expr -> Expr -> Ordering
$ccompare :: Expr -> Expr -> Ordering
$cp1Ord :: Eq Expr
Ord, Int -> Expr -> ShowS
[Expr] -> ShowS
Expr -> String
(Int -> Expr -> ShowS)
-> (Expr -> String) -> ([Expr] -> ShowS) -> Show Expr
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Expr] -> ShowS
$cshowList :: [Expr] -> ShowS
show :: Expr -> String
$cshow :: Expr -> String
showsPrec :: Int -> Expr -> ShowS
$cshowsPrec :: Int -> Expr -> ShowS
Show, ReadPrec [Expr]
ReadPrec Expr
Int -> ReadS Expr
ReadS [Expr]
(Int -> ReadS Expr)
-> ReadS [Expr] -> ReadPrec Expr -> ReadPrec [Expr] -> Read Expr
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Expr]
$creadListPrec :: ReadPrec [Expr]
readPrec :: ReadPrec Expr
$creadPrec :: ReadPrec Expr
readList :: ReadS [Expr]
$creadList :: ReadS [Expr]
readsPrec :: Int -> ReadS Expr
$creadsPrec :: Int -> ReadS Expr
Read, Typeable Expr
DataType
Constr
Typeable Expr
-> (forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Expr -> c Expr)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Expr)
-> (Expr -> Constr)
-> (Expr -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Expr))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Expr))
-> ((forall b. Data b => b -> b) -> Expr -> Expr)
-> (forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Expr -> r)
-> (forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Expr -> r)
-> (forall u. (forall d. Data d => d -> u) -> Expr -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Expr -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Expr -> m Expr)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Expr -> m Expr)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Expr -> m Expr)
-> Data Expr
Expr -> DataType
Expr -> Constr
(forall b. Data b => b -> b) -> Expr -> Expr
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Expr -> c Expr
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Expr
forall a.
Typeable a
-> (forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Expr -> u
forall u. (forall d. Data d => d -> u) -> Expr -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Expr -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Expr -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Expr -> m Expr
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Expr -> m Expr
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Expr
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Expr -> c Expr
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Expr)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Expr)
$cAssert :: Constr
$cLet :: Constr
$cLam :: Constr
$cApp :: Constr
$cLit :: Constr
$cVar :: Constr
$tExpr :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Expr -> m Expr
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Expr -> m Expr
gmapMp :: (forall d. Data d => d -> m d) -> Expr -> m Expr
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Expr -> m Expr
gmapM :: (forall d. Data d => d -> m d) -> Expr -> m Expr
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Expr -> m Expr
gmapQi :: Int -> (forall d. Data d => d -> u) -> Expr -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Expr -> u
gmapQ :: (forall d. Data d => d -> u) -> Expr -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Expr -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Expr -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Expr -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Expr -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Expr -> r
gmapT :: (forall b. Data b => b -> b) -> Expr -> Expr
$cgmapT :: (forall b. Data b => b -> b) -> Expr -> Expr
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Expr)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Expr)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Expr)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Expr)
dataTypeOf :: Expr -> DataType
$cdataTypeOf :: Expr -> DataType
toConstr :: Expr -> Constr
$ctoConstr :: Expr -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Expr
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Expr
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Expr -> c Expr
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Expr -> c Expr
$cp1Data :: Typeable Expr
Data, Typeable)
pattern $bFun2Ty :: Type -> Type -> Type -> Type
$mFun2Ty :: forall r. Type -> (Type -> Type -> Type -> r) -> (Void# -> r) -> r
Fun2Ty t1 t2 ret = FunTy t1 (FunTy t2 ret)
pattern $bFun3Ty :: Type -> Type -> Type -> Type -> Type
$mFun3Ty :: forall r.
Type -> (Type -> Type -> Type -> Type -> r) -> (Void# -> r) -> r
Fun3Ty t1 t2 t3 ret = FunTy t1 (FunTy t2 (FunTy t3 ret))
pattern $bFun1STy :: Type -> Type
$mFun1STy :: forall r. Type -> (Type -> r) -> (Void# -> r) -> r
Fun1STy t <-
(\case FunTy t1 ret | t1 == ret -> Just ret; _ -> Nothing -> Just t)
where
Fun1STy Type
t = Type -> Type -> Type
FunTy Type
t Type
t
pattern $bFun2STy :: Type -> Type
$mFun2STy :: forall r. Type -> (Type -> r) -> (Void# -> r) -> r
Fun2STy t <-
(\case Fun2Ty t1 t2 ret | t1 == ret && t2 == ret -> Just ret; _ -> Nothing -> Just t)
where
Fun2STy Type
t = Type -> Type -> Type -> Type
Fun2Ty Type
t Type
t Type
t
pattern $bFun3STy :: Type -> Type
$mFun3STy :: forall r. Type -> (Type -> r) -> (Void# -> r) -> r
Fun3STy t <-
(\case Fun3Ty t1 t2 t3 ret | t1 == ret && t2 == ret && t3 == ret -> Just ret; _ -> Nothing -> Just t)
where
Fun3STy Type
t = Type -> Type -> Type -> Type -> Type
Fun3Ty Type
t Type
t Type
t Type
t
pattern $bFunLTy :: Type -> Type
$mFunLTy :: forall r. Type -> (Type -> r) -> (Void# -> r) -> r
FunLTy t <-
(\case FunTy (ListTy t1) ret | t1 == ret -> Just ret; _ -> Nothing -> Just t)
where
FunLTy Type
t = Type -> Type -> Type
FunTy (Type -> Type
ListTy Type
t) Type
t
vectorTy :: Integer -> Type
vectorTy :: Integer -> Type
vectorTy Integer
n
| Integer
0 Integer -> Integer -> Bool
forall a. Ord a => a -> a -> Bool
<= Integer
n Bool -> Bool -> Bool
&& Integer
n Integer -> Integer -> Bool
forall a. Ord a => a -> a -> Bool
< Integer
10000 = [Type] -> Type
TupleTy (Int -> Type -> [Type]
forall a. Int -> a -> [a]
replicate (Integer -> Int
forall a. Num a => Integer -> a
fromInteger Integer
n) Type
IntTy)
| Bool
otherwise = String -> Type
forall a. HasCallStack => String -> a
error (String -> Type) -> String -> Type
forall a b. (a -> b) -> a -> b
$ String
"Jikka.Core.Language.Expr.vectorTy: invalid size: " String -> ShowS
forall a. [a] -> [a] -> [a]
++ Integer -> String
forall a. Show a => a -> String
show Integer
n
matrixTy :: Integer -> Integer -> Type
matrixTy :: Integer -> Integer -> Type
matrixTy Integer
h Integer
w
| Integer
0 Integer -> Integer -> Bool
forall a. Ord a => a -> a -> Bool
<= Integer
h Bool -> Bool -> Bool
&& Integer
h Integer -> Integer -> Bool
forall a. Ord a => a -> a -> Bool
< Integer
10000 Bool -> Bool -> Bool
&& Integer
0 Integer -> Integer -> Bool
forall a. Ord a => a -> a -> Bool
<= Integer
w Bool -> Bool -> Bool
&& Integer
w Integer -> Integer -> Bool
forall a. Ord a => a -> a -> Bool
< Integer
10000 = [Type] -> Type
TupleTy (Int -> Type -> [Type]
forall a. Int -> a -> [a]
replicate (Integer -> Int
forall a. Num a => Integer -> a
fromInteger Integer
h) ([Type] -> Type
TupleTy (Int -> Type -> [Type]
forall a. Int -> a -> [a]
replicate (Integer -> Int
forall a. Num a => Integer -> a
fromInteger Integer
w) Type
IntTy)))
| Bool
otherwise = String -> Type
forall a. HasCallStack => String -> a
error (String -> Type) -> String -> Type
forall a b. (a -> b) -> a -> b
$ String
"Jikka.Core.Language.Expr.matrixTy: invalid size: " String -> ShowS
forall a. [a] -> [a] -> [a]
++ (Integer, Integer) -> String
forall a. Show a => a -> String
show (Integer
h, Integer
w)
pattern $bUnitTy :: Type
$mUnitTy :: forall r. Type -> (Void# -> r) -> (Void# -> r) -> r
UnitTy = TupleTy []
pattern $bConvexHullTrickTy :: Type
$mConvexHullTrickTy :: forall r. Type -> (Void# -> r) -> (Void# -> r) -> r
ConvexHullTrickTy = DataStructureTy ConvexHullTrick
pattern $bSegmentTreeTy :: Semigroup' -> Type
$mSegmentTreeTy :: forall r. Type -> (Semigroup' -> r) -> (Void# -> r) -> r
SegmentTreeTy semigrp = DataStructureTy (SegmentTree semigrp)
pattern $bLitInt' :: Integer -> Expr
$mLitInt' :: forall r. Expr -> (Integer -> r) -> (Void# -> r) -> r
LitInt' n = Lit (LitInt n)
pattern $bLit0 :: Expr
$mLit0 :: forall r. Expr -> (Void# -> r) -> (Void# -> r) -> r
Lit0 = Lit (LitInt 0)
pattern $bLit1 :: Expr
$mLit1 :: forall r. Expr -> (Void# -> r) -> (Void# -> r) -> r
Lit1 = Lit (LitInt 1)
pattern $bLit2 :: Expr
$mLit2 :: forall r. Expr -> (Void# -> r) -> (Void# -> r) -> r
Lit2 = Lit (LitInt 2)
pattern $bLitMinus1 :: Expr
$mLitMinus1 :: forall r. Expr -> (Void# -> r) -> (Void# -> r) -> r
LitMinus1 = Lit (LitInt (-1))
pattern $bLitBool' :: Bool -> Expr
$mLitBool' :: forall r. Expr -> (Bool -> r) -> (Void# -> r) -> r
LitBool' p = Lit (LitBool p)
pattern $bLitTrue :: Expr
$mLitTrue :: forall r. Expr -> (Void# -> r) -> (Void# -> r) -> r
LitTrue = Lit (LitBool True)
pattern $bLitFalse :: Expr
$mLitFalse :: forall r. Expr -> (Void# -> r) -> (Void# -> r) -> r
LitFalse = Lit (LitBool False)
pattern $bBuiltin :: Builtin -> Expr
$mBuiltin :: forall r. Expr -> (Builtin -> r) -> (Void# -> r) -> r
Builtin builtin = Lit (LitBuiltin builtin [])
pattern $bBuiltin1 :: Builtin -> Type -> Expr
$mBuiltin1 :: forall r. Expr -> (Builtin -> Type -> r) -> (Void# -> r) -> r
Builtin1 builtin t1 = Lit (LitBuiltin builtin [t1])
pattern $bBuiltin2 :: Builtin -> Type -> Type -> Expr
$mBuiltin2 :: forall r.
Expr -> (Builtin -> Type -> Type -> r) -> (Void# -> r) -> r
Builtin2 builtin t1 t2 = Lit (LitBuiltin builtin [t1, t2])
pattern $bApp2 :: Expr -> Expr -> Expr -> Expr
$mApp2 :: forall r. Expr -> (Expr -> Expr -> Expr -> r) -> (Void# -> r) -> r
App2 f e1 e2 = App (App f e1) e2
pattern $bApp3 :: Expr -> Expr -> Expr -> Expr -> Expr
$mApp3 :: forall r.
Expr -> (Expr -> Expr -> Expr -> Expr -> r) -> (Void# -> r) -> r
App3 f e1 e2 e3 = App (App (App f e1) e2) e3
pattern $bApp4 :: Expr -> Expr -> Expr -> Expr -> Expr -> Expr
$mApp4 :: forall r.
Expr
-> (Expr -> Expr -> Expr -> Expr -> Expr -> r) -> (Void# -> r) -> r
App4 f e1 e2 e3 e4 = App (App (App (App f e1) e2) e3) e4
pattern $bAppBuiltin1 :: Builtin -> Expr -> Expr
$mAppBuiltin1 :: forall r. Expr -> (Builtin -> Expr -> r) -> (Void# -> r) -> r
AppBuiltin1 builtin e1 = App (Lit (LitBuiltin builtin [])) e1
pattern $bAppBuiltin11 :: Builtin -> Type -> Expr -> Expr
$mAppBuiltin11 :: forall r.
Expr -> (Builtin -> Type -> Expr -> r) -> (Void# -> r) -> r
AppBuiltin11 builtin t1 e1 = App (Lit (LitBuiltin builtin [t1])) e1
pattern $bAppBuiltin2 :: Builtin -> Expr -> Expr -> Expr
$mAppBuiltin2 :: forall r.
Expr -> (Builtin -> Expr -> Expr -> r) -> (Void# -> r) -> r
AppBuiltin2 builtin e1 e2 = App2 (Lit (LitBuiltin builtin [])) e1 e2
pattern $bAppBuiltin12 :: Builtin -> Type -> Expr -> Expr -> Expr
$mAppBuiltin12 :: forall r.
Expr -> (Builtin -> Type -> Expr -> Expr -> r) -> (Void# -> r) -> r
AppBuiltin12 builtin t1 e1 e2 = App2 (Lit (LitBuiltin builtin [t1])) e1 e2
pattern $bAppBuiltin22 :: Builtin -> Type -> Type -> Expr -> Expr -> Expr
$mAppBuiltin22 :: forall r.
Expr
-> (Builtin -> Type -> Type -> Expr -> Expr -> r)
-> (Void# -> r)
-> r
AppBuiltin22 builtin t1 t2 e1 e2 = App2 (Lit (LitBuiltin builtin [t1, t2])) e1 e2
pattern $bAppBuiltin3 :: Builtin -> Expr -> Expr -> Expr -> Expr
$mAppBuiltin3 :: forall r.
Expr -> (Builtin -> Expr -> Expr -> Expr -> r) -> (Void# -> r) -> r
AppBuiltin3 builtin e1 e2 e3 = App3 (Lit (LitBuiltin builtin [])) e1 e2 e3
pattern $bAppBuiltin13 :: Builtin -> Type -> Expr -> Expr -> Expr -> Expr
$mAppBuiltin13 :: forall r.
Expr
-> (Builtin -> Type -> Expr -> Expr -> Expr -> r)
-> (Void# -> r)
-> r
AppBuiltin13 builtin t1 e1 e2 e3 = App3 (Lit (LitBuiltin builtin [t1])) e1 e2 e3
pattern $bAppBuiltin23 :: Builtin -> Type -> Type -> Expr -> Expr -> Expr -> Expr
$mAppBuiltin23 :: forall r.
Expr
-> (Builtin -> Type -> Type -> Expr -> Expr -> Expr -> r)
-> (Void# -> r)
-> r
AppBuiltin23 builtin t1 t2 e1 e2 e3 = App3 (Lit (LitBuiltin builtin [t1, t2])) e1 e2 e3
pattern $bAppBuiltin14 :: Builtin -> Type -> Type -> Expr -> Expr -> Expr -> Expr
$mAppBuiltin14 :: forall r.
Expr
-> (Builtin -> Type -> Type -> Expr -> Expr -> Expr -> r)
-> (Void# -> r)
-> r
AppBuiltin14 builtin t1 t2 e1 e2 e3 = App3 (Lit (LitBuiltin builtin [t1, t2])) e1 e2 e3
pattern $bLam2 :: VarName -> Type -> VarName -> Type -> Expr -> Expr
$mLam2 :: forall r.
Expr
-> (VarName -> Type -> VarName -> Type -> Expr -> r)
-> (Void# -> r)
-> r
Lam2 x1 t1 x2 t2 e = Lam x1 t1 (Lam x2 t2 e)
pattern $bLam3 :: VarName
-> Type -> VarName -> Type -> VarName -> Type -> Expr -> Expr
$mLam3 :: forall r.
Expr
-> (VarName
-> Type -> VarName -> Type -> VarName -> Type -> Expr -> r)
-> (Void# -> r)
-> r
Lam3 x1 t1 x2 t2 x3 t3 e = Lam x1 t1 (Lam x2 t2 (Lam x3 t3 e))
data ToplevelExpr
= ResultExpr Expr
| ToplevelLet VarName Type Expr ToplevelExpr
| ToplevelLetRec VarName [(VarName, Type)] Type Expr ToplevelExpr
| ToplevelAssert Expr ToplevelExpr
deriving (ToplevelExpr -> ToplevelExpr -> Bool
(ToplevelExpr -> ToplevelExpr -> Bool)
-> (ToplevelExpr -> ToplevelExpr -> Bool) -> Eq ToplevelExpr
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ToplevelExpr -> ToplevelExpr -> Bool
$c/= :: ToplevelExpr -> ToplevelExpr -> Bool
== :: ToplevelExpr -> ToplevelExpr -> Bool
$c== :: ToplevelExpr -> ToplevelExpr -> Bool
Eq, Eq ToplevelExpr
Eq ToplevelExpr
-> (ToplevelExpr -> ToplevelExpr -> Ordering)
-> (ToplevelExpr -> ToplevelExpr -> Bool)
-> (ToplevelExpr -> ToplevelExpr -> Bool)
-> (ToplevelExpr -> ToplevelExpr -> Bool)
-> (ToplevelExpr -> ToplevelExpr -> Bool)
-> (ToplevelExpr -> ToplevelExpr -> ToplevelExpr)
-> (ToplevelExpr -> ToplevelExpr -> ToplevelExpr)
-> Ord ToplevelExpr
ToplevelExpr -> ToplevelExpr -> Bool
ToplevelExpr -> ToplevelExpr -> Ordering
ToplevelExpr -> ToplevelExpr -> ToplevelExpr
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 :: ToplevelExpr -> ToplevelExpr -> ToplevelExpr
$cmin :: ToplevelExpr -> ToplevelExpr -> ToplevelExpr
max :: ToplevelExpr -> ToplevelExpr -> ToplevelExpr
$cmax :: ToplevelExpr -> ToplevelExpr -> ToplevelExpr
>= :: ToplevelExpr -> ToplevelExpr -> Bool
$c>= :: ToplevelExpr -> ToplevelExpr -> Bool
> :: ToplevelExpr -> ToplevelExpr -> Bool
$c> :: ToplevelExpr -> ToplevelExpr -> Bool
<= :: ToplevelExpr -> ToplevelExpr -> Bool
$c<= :: ToplevelExpr -> ToplevelExpr -> Bool
< :: ToplevelExpr -> ToplevelExpr -> Bool
$c< :: ToplevelExpr -> ToplevelExpr -> Bool
compare :: ToplevelExpr -> ToplevelExpr -> Ordering
$ccompare :: ToplevelExpr -> ToplevelExpr -> Ordering
$cp1Ord :: Eq ToplevelExpr
Ord, Int -> ToplevelExpr -> ShowS
[ToplevelExpr] -> ShowS
ToplevelExpr -> String
(Int -> ToplevelExpr -> ShowS)
-> (ToplevelExpr -> String)
-> ([ToplevelExpr] -> ShowS)
-> Show ToplevelExpr
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ToplevelExpr] -> ShowS
$cshowList :: [ToplevelExpr] -> ShowS
show :: ToplevelExpr -> String
$cshow :: ToplevelExpr -> String
showsPrec :: Int -> ToplevelExpr -> ShowS
$cshowsPrec :: Int -> ToplevelExpr -> ShowS
Show, ReadPrec [ToplevelExpr]
ReadPrec ToplevelExpr
Int -> ReadS ToplevelExpr
ReadS [ToplevelExpr]
(Int -> ReadS ToplevelExpr)
-> ReadS [ToplevelExpr]
-> ReadPrec ToplevelExpr
-> ReadPrec [ToplevelExpr]
-> Read ToplevelExpr
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ToplevelExpr]
$creadListPrec :: ReadPrec [ToplevelExpr]
readPrec :: ReadPrec ToplevelExpr
$creadPrec :: ReadPrec ToplevelExpr
readList :: ReadS [ToplevelExpr]
$creadList :: ReadS [ToplevelExpr]
readsPrec :: Int -> ReadS ToplevelExpr
$creadsPrec :: Int -> ReadS ToplevelExpr
Read, Typeable ToplevelExpr
DataType
Constr
Typeable ToplevelExpr
-> (forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ToplevelExpr -> c ToplevelExpr)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ToplevelExpr)
-> (ToplevelExpr -> Constr)
-> (ToplevelExpr -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ToplevelExpr))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ToplevelExpr))
-> ((forall b. Data b => b -> b) -> ToplevelExpr -> ToplevelExpr)
-> (forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ToplevelExpr -> r)
-> (forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ToplevelExpr -> r)
-> (forall u. (forall d. Data d => d -> u) -> ToplevelExpr -> [u])
-> (forall u.
Int -> (forall d. Data d => d -> u) -> ToplevelExpr -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ToplevelExpr -> m ToplevelExpr)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ToplevelExpr -> m ToplevelExpr)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ToplevelExpr -> m ToplevelExpr)
-> Data ToplevelExpr
ToplevelExpr -> DataType
ToplevelExpr -> Constr
(forall b. Data b => b -> b) -> ToplevelExpr -> ToplevelExpr
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ToplevelExpr -> c ToplevelExpr
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ToplevelExpr
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) -> ToplevelExpr -> u
forall u. (forall d. Data d => d -> u) -> ToplevelExpr -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ToplevelExpr -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ToplevelExpr -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ToplevelExpr -> m ToplevelExpr
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ToplevelExpr -> m ToplevelExpr
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ToplevelExpr
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ToplevelExpr -> c ToplevelExpr
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ToplevelExpr)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ToplevelExpr)
$cToplevelAssert :: Constr
$cToplevelLetRec :: Constr
$cToplevelLet :: Constr
$cResultExpr :: Constr
$tToplevelExpr :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> ToplevelExpr -> m ToplevelExpr
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ToplevelExpr -> m ToplevelExpr
gmapMp :: (forall d. Data d => d -> m d) -> ToplevelExpr -> m ToplevelExpr
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ToplevelExpr -> m ToplevelExpr
gmapM :: (forall d. Data d => d -> m d) -> ToplevelExpr -> m ToplevelExpr
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ToplevelExpr -> m ToplevelExpr
gmapQi :: Int -> (forall d. Data d => d -> u) -> ToplevelExpr -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ToplevelExpr -> u
gmapQ :: (forall d. Data d => d -> u) -> ToplevelExpr -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> ToplevelExpr -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ToplevelExpr -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ToplevelExpr -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ToplevelExpr -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ToplevelExpr -> r
gmapT :: (forall b. Data b => b -> b) -> ToplevelExpr -> ToplevelExpr
$cgmapT :: (forall b. Data b => b -> b) -> ToplevelExpr -> ToplevelExpr
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ToplevelExpr)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ToplevelExpr)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c ToplevelExpr)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ToplevelExpr)
dataTypeOf :: ToplevelExpr -> DataType
$cdataTypeOf :: ToplevelExpr -> DataType
toConstr :: ToplevelExpr -> Constr
$ctoConstr :: ToplevelExpr -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ToplevelExpr
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ToplevelExpr
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ToplevelExpr -> c ToplevelExpr
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ToplevelExpr -> c ToplevelExpr
$cp1Data :: Typeable ToplevelExpr
Data, Typeable)
type Program = ToplevelExpr