{-# LANGUAGE DeriveDataTypeable #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE LambdaCase #-}
{-# LANGUAGE PatternSynonyms #-}
{-# LANGUAGE ViewPatterns #-}

-- |
-- Module      : Jikka.Core.Language.Expr
-- Description : has data types of our core language. / core 言語のためのデータ型を持ちます。
-- Copyright   : (c) Kimiyuki Onaka, 2020
-- License     : Apache License 2.0
-- Maintainer  : kimiyuki95@gmail.com
-- Stability   : experimental
-- Portability : portable
--
-- `Jikka.Core.Language.Expr` module has the basic data types for our core language.
-- They are similar to the GHC Core language.
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

-- | `Type` represents the types of our core language. This is similar to the `Type` of GHC Core.
-- See also [commentary/compiler/type-type](https://gitlab.haskell.org/ghc/ghc/-/wikis/commentary/compiler/type-type).
--
-- \[
--     \newcommand\int{\mathbf{int}}
--     \newcommand\bool{\mathbf{bool}}
--     \newcommand\list{\mathbf{list}}
--     \begin{array}{rl}
--         \tau ::= & \alpha \\
--         \vert & \int \\
--         \vert & \bool \\
--         \vert & \list(\tau) \\
--         \vert & \tau \times \tau \times \dots \times \tau \\
--         \vert & \tau \to \tau \\
--         \vert & \mathrm{data\_structure}
--     \end{array}
-- \]
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)

-- | TODO: What is the difference between `Literal` and `Builtin`?
data Builtin
  = -- arithmetical functions

    -- | \(: \int \to \int\)
    Negate
  | -- | \(: \int \to \int \to \int\)
    Plus
  | -- | \(: \int \to \int \to \int\)
    Minus
  | -- | \(: \int \to \int \to \int\)
    Mult
  | -- | \(: \int \to \int \to \int\)
    FloorDiv
  | -- | \(: \int \to \int \to \int\)
    FloorMod
  | -- | \(: \int \to \int \to \int\)
    CeilDiv
  | -- | \(: \int \to \int \to \int\)
    CeilMod
  | -- | divison which has no remainder \(: \int \to \int \to \int\)
    JustDiv
  | -- | \(: \int \to \int \to \int\)
    Pow
  | -- advanced arithmetical functions

    -- | \(: \int \to \int\)
    Abs
  | -- | \(: \int \to \int \to \int\)
    Gcd
  | -- | \(: \int \to \int \to \int\)
    Lcm
  | -- | \(: \forall \alpha. \alpha \to \alpha \to \alpha\)
    Min2
  | -- | \(: \forall \alpha. \alpha \to \alpha \to \alpha\)
    Max2
  | -- | iterated application \((\lambda k f x. f^k(x)): \forall \alpha. \int \to (\alpha \to \alpha) \to \alpha \to \alpha\)
    Iterate
  | -- logical functions

    -- | \(: \bool \to \bool\)
    Not
  | -- | \(: \bool \to \bool \to \bool\)
    And
  | -- | \(: \bool \to \bool \to \bool\)
    Or
  | -- | \(: \bool \to \bool \to \bool\)
    Implies
  | -- | \(: \forall \alpha. \bool \to \alpha \to \alpha \to \alpha\)
    If
  | -- bitwise functions

    -- | \(: \int \to \int\)
    BitNot
  | -- | \(: \int \to \int \to \int\)
    BitAnd
  | -- | \(: \int \to \int \to \int\)
    BitOr
  | -- | \(: \int \to \int \to \int\)
    BitXor
  | -- | \(: \int \to \int \to \int\)
    BitLeftShift
  | -- | \(: \int \to \int \to \int\)
    BitRightShift
  | -- matrix functions

    -- | matrix application \(: \int^{H \times W} \to \int^W \to \int^H\)
    MatAp Integer Integer
  | -- | zero matrix \(: \to \int^{h \times w}\)
    MatZero Integer Integer
  | -- | unit matrix \(: \to \int^{n \times n}\)
    MatOne Integer
  | -- | matrix addition \(: \int^{H \times W} \to \int^{H \times W} \to \int^{H \times W}\)
    MatAdd Integer Integer
  | -- | matrix multiplication \(: \int^{H \times n} \to \int^{n \times W} \to \int^{H \times W}\)
    MatMul Integer Integer Integer
  | -- | matrix power \(: \int^{n \times n} \to \int \to \int^{n \times n}\)
    MatPow Integer
  | -- | vector point-wise floor-mod \(: \int^{n} \to \int \to \int^{n}\)
    VecFloorMod Integer
  | -- | matrix point-wise floor-mod \(: \int^{H \times W} \to \int \to \int^{H \times W}\)
    MatFloorMod Integer Integer
  | -- modular functions

    -- | \(: \int \to \int \to \int\)
    ModNegate
  | -- | \(: \int \to \int \to \int \to \int\)
    ModPlus
  | -- | \(: \int \to \int \to \int \to \int\)
    ModMinus
  | -- | \(: \int \to \int \to \int \to \int\)
    ModMult
  | -- | \(: \int \to \int \to \int\)
    ModInv
  | -- | \(: \int \to \int \to \int \to \int\)
    ModPow
  | -- | matrix application \(: \int^{H \times W} \to \int^W \to \int \to \int^H\)
    ModMatAp Integer Integer
  | -- | matrix addition \(: \int^{H \times W} \to \int^{H \times W} \to \int \to \int^{H \times W}\)
    ModMatAdd Integer Integer
  | -- | matrix multiplication \(: \int^{H \times n} \to \int^{n \times W} \to \int \to \int^{H \times W}\)
    ModMatMul Integer Integer Integer
  | -- | matrix power \(: \int^{n \times n} \to \int \to \int^{n \times n}\)
    ModMatPow Integer
  | -- list functions

    -- | \(: \forall \alpha. \alpha \to \list(\alpha) \to \list(\alpha)\)
    Cons
  | -- | \(: \forall \alpha. \list(alpha) \to \alpha \to \list(\alpha)\)
    Snoc
  | -- | \(: \forall \alpha \beta. (\beta \to \alpha \to \beta) \to \beta \to \list(\alpha) \to \beta\)
    Foldl
  | -- | \(: \forall \alpha \beta. (\beta \to \alpha \to \beta) \to \beta \to \list(\alpha) \to \list(\beta)\)
    Scanl
  | -- | \(\lambda f a n.\) repeat @a <- snoc a (f a)@ @n@ times \(: \forall \alpha. (\list(\alpha) \to \alpha) \to \list(\alpha) \to \int \to \list(\alpha)\)
    Build
  | -- | \(: \forall \alpha. \list(\alpha) \to \int\)
    Len
  | -- | \(: \forall \alpha \beta. (\alpha \to \beta) \to \list(\alpha) \to \list(\beta)\)
    Map
  | -- | \(: \forall \alpha \beta. (\alpha \to \bool) \to \list(\alpha) \to \list(\beta)\)
    Filter
  | -- | \(: \forall \alpha. \list(\alpha) \to \int \to \alpha\)
    At
  | -- | \(: \forall \alpha. \list(\alpha) \to \int \to \alpha \to \list(\alpha)\)
    SetAt
  | -- | \(: \forall \alpha. \alpha \to \list(\alpha) \to \bool\)
    Elem
  | -- | \(: \list(\int) \to \int\)
    Sum
  | -- | \(: \list(\int) \to \int\)
    Product
  | -- | \(: \list(\int) \to \int \to \int\)
    ModSum
  | -- | \(: \list(\int) \to \int \to \int\)
    ModProduct
  | -- | \(: \forall \alpha. \list(\alpha) \to \alpha\)
    Min1
  | -- | \(: \forall \alpha. \list(\alpha) \to \alpha\)
    Max1
  | -- | \(: \forall \alpha. \list(\alpha) \to \int\)
    ArgMin
  | -- | \(: \forall \alpha. \list(\alpha) \to \int\)
    ArgMax
  | -- | \(: \list(\int) \to \int\)
    Gcd1
  | -- | \(: \list(\int) \to \int\)
    Lcm1
  | -- | \(: \list(\bool) \to \bool\)
    All
  | -- | \(: \list(\bool) \to \bool\)
    Any
  | -- | \(: \forall \alpha. \list(\alpha) \to \list(\alpha)\)
    Sorted
  | -- | \(: \forall \alpha. \list(\alpha) \to \list(\alpha)\)
    Reversed
  | -- | \(: \int \to \list(\int)\)
    Range1
  | -- | \(: \int \to \int \to \list(\int)\)
    Range2
  | -- | \(: \int \to \int \to \int \to \list(\int)\)
    Range3
  | -- tuple functions

    -- | \(: \forall \alpha_0 \alpha_1 \dots \alpha _ {n - 1}. \alpha_0 \to \dots \to \alpha _ {n - 1} \to \alpha_0 \times \dots \times \alpha _ {n - 1}\)
    Tuple
  | -- | \(: \forall \alpha_0 \alpha_1 \dots \alpha _ {n - 1}. \alpha_0 \times \dots \times \alpha _ {n - 1} \to \alpha_i\)
    --
    -- `Jikka.Core.Parse` may make broken `Proj` with its list of type arguments is empty. This is fixed by `Jikka.Core.Convert.TypeInfer` module.
    Proj Integer
  | -- comparison

    -- | \(: \forall \alpha. \alpha \to \alpha \to \bool\)
    LessThan
  | -- | \(: \forall \alpha. \alpha \to \alpha \to \bool\)
    LessEqual
  | -- | \(: \forall \alpha. \alpha \to \alpha \to \bool\)
    GreaterThan
  | -- | \(: \forall \alpha. \alpha \to \alpha \to \bool\)
    GreaterEqual
  | -- | \(: \forall \alpha. \alpha \to \alpha \to \bool\)
    Equal
  | -- | \(: \forall \alpha. \alpha \to \alpha \to \bool\)
    NotEqual
  | -- combinational functions

    -- | \(: \int \to \int\)
    Fact
  | -- | \(: \int \to \int \to \int\)
    Choose
  | -- | \(: \int \to \int \to \int\)
    Permute
  | -- | \(: \int \to \int \to \int\)
    MultiChoose
  | -- data structures

    -- | \(: \mathrm{convex\_hull\_trick}\)
    ConvexHullTrickInit
  | -- | \(: \mathrm{convex\_hull\_trick} \to \int \to \int\)
    ConvexHullTrickGetMin
  | -- | \(: \mathrm{convex\_hull\_trick} \to \int \to \int \to \mathrm{convex\_hull\_trick}\)
    ConvexHullTrickInsert
  | -- | \(: \list(S) \to \mathrm{segment\_tree}(S)\) for a semigroup \(S)
    SegmentTreeInitList Semigroup'
  | -- | \(: \mathrm{segment\_tree}(S) \to \int \to \int \to S\) for a semigroup \(S)
    SegmentTreeGetRange Semigroup'
  | -- | \(: \mathrm{segment\_tree}(S) \to \int \to S \to \mathrm{segment\_tree}(S)\) for a semigroup \(S)
    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]
  | -- | \(: \forall \alpha. \int\)
    LitInt Integer
  | -- | \(: \forall \alpha. \bool\)
    LitBool Bool
  | -- | \(: \forall \alpha. \list(\alpha)\)
    LitNil Type
  | -- | \(: \bot : \forall \alpha. \alpha\). The second argument is its error message.
    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)

-- | `Expr` represents the exprs of our core language. This is similar to the `Expr` of GHC Core.
-- See also [commentary/compiler/core-syn-type](https://gitlab.haskell.org/ghc/ghc/-/wikis/commentary/compiler/core-syn-type).
--
-- \[
--     \begin{array}{rl}
--         e ::= & x \\
--         \vert & \mathrm{literal}\ldots \\
--         \vert & e_0(e_1, e_2, \dots, e_n) \\
--         \vert & \lambda ~ x_0\colon \tau_0, x_1\colon \tau_1, \dots, x_{n-1}\colon \tau_{n-1}. ~ e \\
--         \vert & \mathbf{let} ~ x\colon \tau = e_1 ~ \mathbf{in} ~ e_2 \\
--         \vert & \mathbf{assert} ~ e_1 ~ \mathbf{in} ~ e_2
--     \end{array}
-- \]
data Expr
  = Var VarName
  | Lit Literal
  | App Expr Expr
  | Lam VarName Type Expr
  | -- | This "let" is not recursive.
    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))

-- | `ToplevelExpr` is the toplevel exprs. In our core, "let rec" is allowed only on the toplevel.
--
-- \[
--     \begin{array}{rl}
--         \mathrm{tle} ::= & e \\
--         \vert & \mathbf{let}~ x: \tau = e ~\mathbf{in}~ \mathrm{tle} \\
--         \vert & \mathbf{let~rec}~ x(x: \tau, x: \tau, \dots, x: \tau): \tau = e ~\mathbf{in}~ \mathrm{tle} \\
--         \vert & \mathbf{assert}~ e ~\mathbf{in}~ \mathrm{tle}
--     \end{array}
-- \]
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