{-# LANGUAGE CPP, DeriveDataTypeable, DeriveFoldable, DeriveFunctor,
DeriveGeneric, DeriveTraversable, FlexibleContexts,
FlexibleInstances, FunctionalDependencies, MultiParamTypeClasses,
PatternGuards, TypeSynonymInstances #-}
{-# OPTIONS_GHC -fwarn-incomplete-patterns #-}
module Idris.Core.TT(
AppStatus(..), ArithTy(..), Binder(..), Const(..), Ctxt(..)
, ConstraintFC(..), DataOpt(..), DataOpts(..), Datatype(..)
, Env(..), EnvTT(..), Err(..), Err'(..), ErrorReportPart(..)
, FC(..), FC'(..), ImplicitInfo(..), IntTy(..), Name(..)
, NameOutput(..), NameType(..), NativeTy(..), OutputAnnotation(..)
, Provenance(..), Raw(..), RigCount(..), SpecialName(..), TC(..), Term(..)
, TermSize(..), TextFormatting(..), TT(..),Type(..), TypeInfo(..)
, UConstraint(..), UCs(..), UExp(..), Universe(..)
, addAlist, addBinder, addDef, allTTNames, arity, bindAll
, bindingOf, bindTyArgs, caseName, constDocs, constIsType, deleteDefExact
, discard, emptyContext, emptyFC, explicitNames, fc_end, fc_fname
, fc_start, fcIn, fileFC, finalise, fmapMB, forget, forgetEnv
, freeNames, getArgTys, getRetTy, substRetTy, implicitable, instantiate, internalNS
, intTyName, isInjective, isTypeConst, lookupCtxt
, lookupCtxtExact, lookupCtxtName, mapCtxt, mkApp, nativeTyWidth
, nextName, noOccurrence, nsroot, occurrences
, pEraseType, pmap, pprintRaw, pprintTT, pprintTTClause, prettyEnv, psubst
, pToV, pToVs, pureTerm, raw_apply, raw_unapply, refsIn, safeForget
, safeForgetEnv, showCG, showEnv, showEnvDbg, showSep
, sImplementationN, sMN, sNS, str, subst, substNames, substTerm
, substV, sUN, tcname, termSmallerThan, tfail, thead, tnull
, toAlist, traceWhen, txt, unApply, uniqueBinders, uniqueName
, uniqueNameFrom, uniqueNameSet, unList, updateDef, vToP, weakenTm
, rigPlus, rigMult, fstEnv, rigEnv, sndEnv, lookupBinder, envBinders
, envZero
) where
import Util.Pretty hiding (Str)
import Prelude (Bool(..), Double, Enum(..), Eq(..), FilePath, Int, Integer,
Maybe(..), Monoid(..), Num(..), Ord(..), Ordering(..), Show(..),
String, div, error, fst, max, min, mod, not, otherwise, read,
snd, ($), (&&), (.), (||))
#if (MIN_VERSION_base(4,11,0))
import qualified Prelude as S (Semigroup(..))
#endif
import Control.Applicative (Alternative, Applicative(..))
import qualified Control.Applicative as A (Alternative(..))
import Control.DeepSeq (($!!))
import qualified Control.Monad.Fail as Fail
import Control.Monad.State.Strict
import Data.Binary hiding (get, put)
import Data.Char
import Data.Data (Data)
import Data.Foldable (Foldable)
import Data.List hiding (group, insert)
import qualified Data.Map.Strict as Map
import Data.Maybe (listToMaybe)
import Data.Set (Set, fromList, insert, member)
import qualified Data.Text as T
import Data.Traversable (Traversable)
import Data.Typeable (Typeable)
import Debug.Trace
import GHC.Generics (Generic)
import Numeric (showIntAtBase)
import Numeric.IEEE (IEEE(identicalIEEE))
data Option = TTypeInTType
| CheckConv
deriving Option -> Option -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Option -> Option -> Bool
$c/= :: Option -> Option -> Bool
== :: Option -> Option -> Bool
$c== :: Option -> Option -> Bool
Eq
data FC = FC { FC -> String
_fc_fname :: String,
FC -> (Int, Int)
_fc_start :: (Int, Int),
FC -> (Int, Int)
_fc_end :: (Int, Int)
}
| NoFC
| FileFC { _fc_fname :: String }
deriving (Typeable FC
FC -> Constr
FC -> DataType
(forall b. Data b => b -> b) -> FC -> FC
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) -> FC -> u
forall u. (forall d. Data d => d -> u) -> FC -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FC -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FC -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> FC -> m FC
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FC -> m FC
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FC
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FC -> c FC
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c FC)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FC)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FC -> m FC
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FC -> m FC
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FC -> m FC
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FC -> m FC
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> FC -> m FC
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> FC -> m FC
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> FC -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> FC -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> FC -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> FC -> [u]
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FC -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FC -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FC -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FC -> r
gmapT :: (forall b. Data b => b -> b) -> FC -> FC
$cgmapT :: (forall b. Data b => b -> b) -> FC -> FC
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FC)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FC)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c FC)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c FC)
dataTypeOf :: FC -> DataType
$cdataTypeOf :: FC -> DataType
toConstr :: FC -> Constr
$ctoConstr :: FC -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FC
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FC
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FC -> c FC
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FC -> c FC
Data, forall x. Rep FC x -> FC
forall x. FC -> Rep FC x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep FC x -> FC
$cfrom :: forall x. FC -> Rep FC x
Generic, Typeable, Eq FC
FC -> FC -> Bool
FC -> FC -> Ordering
FC -> FC -> FC
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 :: FC -> FC -> FC
$cmin :: FC -> FC -> FC
max :: FC -> FC -> FC
$cmax :: FC -> FC -> FC
>= :: FC -> FC -> Bool
$c>= :: FC -> FC -> Bool
> :: FC -> FC -> Bool
$c> :: FC -> FC -> Bool
<= :: FC -> FC -> Bool
$c<= :: FC -> FC -> Bool
< :: FC -> FC -> Bool
$c< :: FC -> FC -> Bool
compare :: FC -> FC -> Ordering
$ccompare :: FC -> FC -> Ordering
Ord)
fc_fname :: FC -> String
fc_fname :: FC -> String
fc_fname (FC String
f (Int, Int)
_ (Int, Int)
_) = String
f
fc_fname FC
NoFC = String
"(no file)"
fc_fname (FileFC String
f) = String
f
fc_start :: FC -> (Int, Int)
fc_start :: FC -> (Int, Int)
fc_start (FC String
_ (Int, Int)
start (Int, Int)
_) = (Int, Int)
start
fc_start FC
NoFC = (Int
0, Int
0)
fc_start (FileFC String
f) = (Int
0, Int
0)
fc_end :: FC -> (Int, Int)
fc_end :: FC -> (Int, Int)
fc_end (FC String
_ (Int, Int)
_ (Int, Int)
end) = (Int, Int)
end
fc_end FC
NoFC = (Int
0, Int
0)
fc_end (FileFC String
f) = (Int
0, Int
0)
#if (MIN_VERSION_base(4,11,0))
instance S.Semigroup FC where
<> :: FC -> FC -> FC
(<>) = forall a. Monoid a => a -> a -> a
mappend
#endif
instance Monoid FC where
mempty :: FC
mempty = FC
NoFC
mappend :: FC -> FC -> FC
mappend (FC String
f (Int, Int)
start (Int, Int)
end) (FC String
f' (Int, Int)
start' (Int, Int)
end')
| String
f forall a. Eq a => a -> a -> Bool
== String
f' = String -> (Int, Int) -> (Int, Int) -> FC
FC String
f (forall a. Ord a => a -> a -> a
min (Int, Int)
start (Int, Int)
start') (forall a. Ord a => a -> a -> a
max (Int, Int)
end (Int, Int)
end')
| Bool
otherwise = FC
NoFC
mappend fc :: FC
fc@(FC String
f (Int, Int)
_ (Int, Int)
_) (FileFC String
f') | String
f forall a. Eq a => a -> a -> Bool
== String
f' = FC
fc
| Bool
otherwise = FC
NoFC
mappend (FileFC String
f') fc :: FC
fc@(FC String
f (Int, Int)
_ (Int, Int)
_) | String
f forall a. Eq a => a -> a -> Bool
== String
f' = FC
fc
| Bool
otherwise = FC
NoFC
mappend (FileFC String
f) (FileFC String
f') | String
f forall a. Eq a => a -> a -> Bool
== String
f' = String -> FC
FileFC String
f
| Bool
otherwise = FC
NoFC
mappend FC
NoFC FC
fc = FC
fc
mappend FC
fc FC
NoFC = FC
fc
fcIn :: FC -> FC -> Bool
fcIn :: FC -> FC -> Bool
fcIn FC
NoFC FC
_ = Bool
False
fcIn (FileFC String
_) FC
_ = Bool
False
fcIn (FC {}) FC
NoFC = Bool
False
fcIn (FC {}) (FileFC String
_) = Bool
False
fcIn (FC String
fn1 (Int
sl1, Int
sc1) (Int
el1, Int
ec1)) (FC String
fn2 (Int
sl2, Int
sc2) (Int
el2, Int
ec2)) =
String
fn1 forall a. Eq a => a -> a -> Bool
== String
fn2 Bool -> Bool -> Bool
&&
(Int
sl1 forall a. Eq a => a -> a -> Bool
== Int
sl2 Bool -> Bool -> Bool
&& Int
sc1 forall a. Ord a => a -> a -> Bool
> Int
sc2 Bool -> Bool -> Bool
|| Int
sl1 forall a. Ord a => a -> a -> Bool
> Int
sl2) Bool -> Bool -> Bool
&&
(Int
el1 forall a. Eq a => a -> a -> Bool
== Int
el2 Bool -> Bool -> Bool
&& Int
ec1 forall a. Ord a => a -> a -> Bool
< Int
ec2 Bool -> Bool -> Bool
|| Int
el1 forall a. Ord a => a -> a -> Bool
< Int
el2)
instance Eq FC where
FC
_ == :: FC -> FC -> Bool
== FC
_ = Bool
True
newtype FC' = FC' { FC' -> FC
unwrapFC :: FC } deriving (Typeable FC'
FC' -> Constr
FC' -> DataType
(forall b. Data b => b -> b) -> FC' -> FC'
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) -> FC' -> u
forall u. (forall d. Data d => d -> u) -> FC' -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FC' -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FC' -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> FC' -> m FC'
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FC' -> m FC'
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FC'
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FC' -> c FC'
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c FC')
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FC')
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FC' -> m FC'
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FC' -> m FC'
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FC' -> m FC'
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FC' -> m FC'
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> FC' -> m FC'
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> FC' -> m FC'
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> FC' -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> FC' -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> FC' -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> FC' -> [u]
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FC' -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FC' -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FC' -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FC' -> r
gmapT :: (forall b. Data b => b -> b) -> FC' -> FC'
$cgmapT :: (forall b. Data b => b -> b) -> FC' -> FC'
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FC')
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FC')
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c FC')
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c FC')
dataTypeOf :: FC' -> DataType
$cdataTypeOf :: FC' -> DataType
toConstr :: FC' -> Constr
$ctoConstr :: FC' -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FC'
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FC'
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FC' -> c FC'
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FC' -> c FC'
Data, forall x. Rep FC' x -> FC'
forall x. FC' -> Rep FC' x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep FC' x -> FC'
$cfrom :: forall x. FC' -> Rep FC' x
Generic, Typeable, Eq FC'
FC' -> FC' -> Bool
FC' -> FC' -> Ordering
FC' -> FC' -> FC'
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 :: FC' -> FC' -> FC'
$cmin :: FC' -> FC' -> FC'
max :: FC' -> FC' -> FC'
$cmax :: FC' -> FC' -> FC'
>= :: FC' -> FC' -> Bool
$c>= :: FC' -> FC' -> Bool
> :: FC' -> FC' -> Bool
$c> :: FC' -> FC' -> Bool
<= :: FC' -> FC' -> Bool
$c<= :: FC' -> FC' -> Bool
< :: FC' -> FC' -> Bool
$c< :: FC' -> FC' -> Bool
compare :: FC' -> FC' -> Ordering
$ccompare :: FC' -> FC' -> Ordering
Ord)
instance Eq FC' where
FC' FC
fc == :: FC' -> FC' -> Bool
== FC' FC
fc' = FC -> FC -> Bool
fcEq FC
fc FC
fc'
where fcEq :: FC -> FC -> Bool
fcEq (FC String
n (Int, Int)
s (Int, Int)
e) (FC String
n' (Int, Int)
s' (Int, Int)
e') = String
n forall a. Eq a => a -> a -> Bool
== String
n' Bool -> Bool -> Bool
&& (Int, Int)
s forall a. Eq a => a -> a -> Bool
== (Int, Int)
s' Bool -> Bool -> Bool
&& (Int, Int)
e forall a. Eq a => a -> a -> Bool
== (Int, Int)
e'
fcEq FC
NoFC FC
NoFC = Bool
True
fcEq (FileFC String
f) (FileFC String
f') = String
f forall a. Eq a => a -> a -> Bool
== String
f'
fcEq FC
_ FC
_ = Bool
False
instance Show FC' where
showsPrec :: Int -> FC' -> ShowS
showsPrec Int
d (FC' FC
fc) = forall a. Show a => Int -> a -> ShowS
showsPrec Int
d FC
fc
emptyFC :: FC
emptyFC :: FC
emptyFC = FC
NoFC
fileFC :: String -> FC
fileFC :: String -> FC
fileFC String
s = String -> FC
FileFC String
s
instance Sized FC where
size :: FC -> Int
size (FC String
f (Int, Int)
s (Int, Int)
e) = Int
4 forall a. Num a => a -> a -> a
+ forall (t :: * -> *) a. Foldable t => t a -> Int
length String
f
size FC
NoFC = Int
1
size (FileFC String
f) = forall (t :: * -> *) a. Foldable t => t a -> Int
length String
f
instance Show FC where
show :: FC -> String
show (FC String
f (Int, Int)
s (Int, Int)
e) = String
f forall a. [a] -> [a] -> [a]
++ String
":" forall a. [a] -> [a] -> [a]
++ forall {a} {a}.
(Eq a, Eq a, Show a, Show a) =>
(a, a) -> (a, a) -> String
showLC (Int, Int)
s (Int, Int)
e
where showLC :: (a, a) -> (a, a) -> String
showLC (a
sl, a
sc) (a
el, a
ec) | a
sl forall a. Eq a => a -> a -> Bool
== a
el Bool -> Bool -> Bool
&& a
sc forall a. Eq a => a -> a -> Bool
== a
ec = forall a. Show a => a -> String
show a
sl forall a. [a] -> [a] -> [a]
++ String
":" forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show a
sc
| a
sl forall a. Eq a => a -> a -> Bool
== a
el = forall a. Show a => a -> String
show a
sl forall a. [a] -> [a] -> [a]
++ String
":" forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show a
sc forall a. [a] -> [a] -> [a]
++ String
"-" forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show a
ec
| Bool
otherwise = forall a. Show a => a -> String
show a
sl forall a. [a] -> [a] -> [a]
++ String
":" forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show a
sc forall a. [a] -> [a] -> [a]
++ String
"-" forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show a
el forall a. [a] -> [a] -> [a]
++ String
":" forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show a
ec
show FC
NoFC = String
"No location"
show (FileFC String
f) = String
f
data NameOutput = TypeOutput | FunOutput | DataOutput | MetavarOutput | PostulateOutput deriving (Int -> NameOutput -> ShowS
[NameOutput] -> ShowS
NameOutput -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [NameOutput] -> ShowS
$cshowList :: [NameOutput] -> ShowS
show :: NameOutput -> String
$cshow :: NameOutput -> String
showsPrec :: Int -> NameOutput -> ShowS
$cshowsPrec :: Int -> NameOutput -> ShowS
Show, NameOutput -> NameOutput -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: NameOutput -> NameOutput -> Bool
$c/= :: NameOutput -> NameOutput -> Bool
== :: NameOutput -> NameOutput -> Bool
$c== :: NameOutput -> NameOutput -> Bool
Eq, Eq NameOutput
NameOutput -> NameOutput -> Bool
NameOutput -> NameOutput -> Ordering
NameOutput -> NameOutput -> NameOutput
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 :: NameOutput -> NameOutput -> NameOutput
$cmin :: NameOutput -> NameOutput -> NameOutput
max :: NameOutput -> NameOutput -> NameOutput
$cmax :: NameOutput -> NameOutput -> NameOutput
>= :: NameOutput -> NameOutput -> Bool
$c>= :: NameOutput -> NameOutput -> Bool
> :: NameOutput -> NameOutput -> Bool
$c> :: NameOutput -> NameOutput -> Bool
<= :: NameOutput -> NameOutput -> Bool
$c<= :: NameOutput -> NameOutput -> Bool
< :: NameOutput -> NameOutput -> Bool
$c< :: NameOutput -> NameOutput -> Bool
compare :: NameOutput -> NameOutput -> Ordering
$ccompare :: NameOutput -> NameOutput -> Ordering
Ord, forall x. Rep NameOutput x -> NameOutput
forall x. NameOutput -> Rep NameOutput x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep NameOutput x -> NameOutput
$cfrom :: forall x. NameOutput -> Rep NameOutput x
Generic)
data TextFormatting = BoldText | ItalicText | UnderlineText deriving (Int -> TextFormatting -> ShowS
[TextFormatting] -> ShowS
TextFormatting -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TextFormatting] -> ShowS
$cshowList :: [TextFormatting] -> ShowS
show :: TextFormatting -> String
$cshow :: TextFormatting -> String
showsPrec :: Int -> TextFormatting -> ShowS
$cshowsPrec :: Int -> TextFormatting -> ShowS
Show, TextFormatting -> TextFormatting -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TextFormatting -> TextFormatting -> Bool
$c/= :: TextFormatting -> TextFormatting -> Bool
== :: TextFormatting -> TextFormatting -> Bool
$c== :: TextFormatting -> TextFormatting -> Bool
Eq, Eq TextFormatting
TextFormatting -> TextFormatting -> Bool
TextFormatting -> TextFormatting -> Ordering
TextFormatting -> TextFormatting -> TextFormatting
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 :: TextFormatting -> TextFormatting -> TextFormatting
$cmin :: TextFormatting -> TextFormatting -> TextFormatting
max :: TextFormatting -> TextFormatting -> TextFormatting
$cmax :: TextFormatting -> TextFormatting -> TextFormatting
>= :: TextFormatting -> TextFormatting -> Bool
$c>= :: TextFormatting -> TextFormatting -> Bool
> :: TextFormatting -> TextFormatting -> Bool
$c> :: TextFormatting -> TextFormatting -> Bool
<= :: TextFormatting -> TextFormatting -> Bool
$c<= :: TextFormatting -> TextFormatting -> Bool
< :: TextFormatting -> TextFormatting -> Bool
$c< :: TextFormatting -> TextFormatting -> Bool
compare :: TextFormatting -> TextFormatting -> Ordering
$ccompare :: TextFormatting -> TextFormatting -> Ordering
Ord, forall x. Rep TextFormatting x -> TextFormatting
forall x. TextFormatting -> Rep TextFormatting x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep TextFormatting x -> TextFormatting
$cfrom :: forall x. TextFormatting -> Rep TextFormatting x
Generic)
data OutputAnnotation = AnnName Name (Maybe NameOutput) (Maybe String) (Maybe String)
| AnnBoundName Name Bool
| AnnConst Const
| AnnData String String
| AnnType String String
| AnnKeyword
| AnnFC FC
| AnnTextFmt TextFormatting
| AnnLink String
| AnnTerm [(Name, Bool)] (TT Name)
| AnnSearchResult Ordering
| AnnErr Err
| AnnNamespace [T.Text] (Maybe FilePath)
| AnnQuasiquote
| AnnAntiquote
| AnnSyntax String
deriving (Int -> OutputAnnotation -> ShowS
[OutputAnnotation] -> ShowS
OutputAnnotation -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [OutputAnnotation] -> ShowS
$cshowList :: [OutputAnnotation] -> ShowS
show :: OutputAnnotation -> String
$cshow :: OutputAnnotation -> String
showsPrec :: Int -> OutputAnnotation -> ShowS
$cshowsPrec :: Int -> OutputAnnotation -> ShowS
Show, OutputAnnotation -> OutputAnnotation -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: OutputAnnotation -> OutputAnnotation -> Bool
$c/= :: OutputAnnotation -> OutputAnnotation -> Bool
== :: OutputAnnotation -> OutputAnnotation -> Bool
$c== :: OutputAnnotation -> OutputAnnotation -> Bool
Eq, forall x. Rep OutputAnnotation x -> OutputAnnotation
forall x. OutputAnnotation -> Rep OutputAnnotation x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep OutputAnnotation x -> OutputAnnotation
$cfrom :: forall x. OutputAnnotation -> Rep OutputAnnotation x
Generic, Eq OutputAnnotation
OutputAnnotation -> OutputAnnotation -> Bool
OutputAnnotation -> OutputAnnotation -> Ordering
OutputAnnotation -> OutputAnnotation -> OutputAnnotation
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 :: OutputAnnotation -> OutputAnnotation -> OutputAnnotation
$cmin :: OutputAnnotation -> OutputAnnotation -> OutputAnnotation
max :: OutputAnnotation -> OutputAnnotation -> OutputAnnotation
$cmax :: OutputAnnotation -> OutputAnnotation -> OutputAnnotation
>= :: OutputAnnotation -> OutputAnnotation -> Bool
$c>= :: OutputAnnotation -> OutputAnnotation -> Bool
> :: OutputAnnotation -> OutputAnnotation -> Bool
$c> :: OutputAnnotation -> OutputAnnotation -> Bool
<= :: OutputAnnotation -> OutputAnnotation -> Bool
$c<= :: OutputAnnotation -> OutputAnnotation -> Bool
< :: OutputAnnotation -> OutputAnnotation -> Bool
$c< :: OutputAnnotation -> OutputAnnotation -> Bool
compare :: OutputAnnotation -> OutputAnnotation -> Ordering
$ccompare :: OutputAnnotation -> OutputAnnotation -> Ordering
Ord)
data ErrorReportPart = TextPart String
| NamePart Name
| TermPart Term
| RawPart Raw
| SubReport [ErrorReportPart]
deriving (Int -> ErrorReportPart -> ShowS
[ErrorReportPart] -> ShowS
ErrorReportPart -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ErrorReportPart] -> ShowS
$cshowList :: [ErrorReportPart] -> ShowS
show :: ErrorReportPart -> String
$cshow :: ErrorReportPart -> String
showsPrec :: Int -> ErrorReportPart -> ShowS
$cshowsPrec :: Int -> ErrorReportPart -> ShowS
Show, ErrorReportPart -> ErrorReportPart -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ErrorReportPart -> ErrorReportPart -> Bool
$c/= :: ErrorReportPart -> ErrorReportPart -> Bool
== :: ErrorReportPart -> ErrorReportPart -> Bool
$c== :: ErrorReportPart -> ErrorReportPart -> Bool
Eq, Eq ErrorReportPart
ErrorReportPart -> ErrorReportPart -> Bool
ErrorReportPart -> ErrorReportPart -> Ordering
ErrorReportPart -> ErrorReportPart -> ErrorReportPart
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 :: ErrorReportPart -> ErrorReportPart -> ErrorReportPart
$cmin :: ErrorReportPart -> ErrorReportPart -> ErrorReportPart
max :: ErrorReportPart -> ErrorReportPart -> ErrorReportPart
$cmax :: ErrorReportPart -> ErrorReportPart -> ErrorReportPart
>= :: ErrorReportPart -> ErrorReportPart -> Bool
$c>= :: ErrorReportPart -> ErrorReportPart -> Bool
> :: ErrorReportPart -> ErrorReportPart -> Bool
$c> :: ErrorReportPart -> ErrorReportPart -> Bool
<= :: ErrorReportPart -> ErrorReportPart -> Bool
$c<= :: ErrorReportPart -> ErrorReportPart -> Bool
< :: ErrorReportPart -> ErrorReportPart -> Bool
$c< :: ErrorReportPart -> ErrorReportPart -> Bool
compare :: ErrorReportPart -> ErrorReportPart -> Ordering
$ccompare :: ErrorReportPart -> ErrorReportPart -> Ordering
Ord, Typeable ErrorReportPart
ErrorReportPart -> Constr
ErrorReportPart -> DataType
(forall b. Data b => b -> b) -> ErrorReportPart -> ErrorReportPart
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) -> ErrorReportPart -> u
forall u. (forall d. Data d => d -> u) -> ErrorReportPart -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ErrorReportPart -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ErrorReportPart -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> ErrorReportPart -> m ErrorReportPart
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ErrorReportPart -> m ErrorReportPart
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ErrorReportPart
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ErrorReportPart -> c ErrorReportPart
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ErrorReportPart)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ErrorReportPart)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ErrorReportPart -> m ErrorReportPart
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ErrorReportPart -> m ErrorReportPart
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ErrorReportPart -> m ErrorReportPart
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ErrorReportPart -> m ErrorReportPart
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> ErrorReportPart -> m ErrorReportPart
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> ErrorReportPart -> m ErrorReportPart
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> ErrorReportPart -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> ErrorReportPart -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> ErrorReportPart -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> ErrorReportPart -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ErrorReportPart -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ErrorReportPart -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ErrorReportPart -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ErrorReportPart -> r
gmapT :: (forall b. Data b => b -> b) -> ErrorReportPart -> ErrorReportPart
$cgmapT :: (forall b. Data b => b -> b) -> ErrorReportPart -> ErrorReportPart
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ErrorReportPart)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ErrorReportPart)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ErrorReportPart)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ErrorReportPart)
dataTypeOf :: ErrorReportPart -> DataType
$cdataTypeOf :: ErrorReportPart -> DataType
toConstr :: ErrorReportPart -> Constr
$ctoConstr :: ErrorReportPart -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ErrorReportPart
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ErrorReportPart
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ErrorReportPart -> c ErrorReportPart
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ErrorReportPart -> c ErrorReportPart
Data, forall x. Rep ErrorReportPart x -> ErrorReportPart
forall x. ErrorReportPart -> Rep ErrorReportPart x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ErrorReportPart x -> ErrorReportPart
$cfrom :: forall x. ErrorReportPart -> Rep ErrorReportPart x
Generic, Typeable)
data Provenance = ExpectedType
| TooManyArgs Term
| InferredVal
| GivenVal
| SourceTerm Term
deriving (Int -> Provenance -> ShowS
[Provenance] -> ShowS
Provenance -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Provenance] -> ShowS
$cshowList :: [Provenance] -> ShowS
show :: Provenance -> String
$cshow :: Provenance -> String
showsPrec :: Int -> Provenance -> ShowS
$cshowsPrec :: Int -> Provenance -> ShowS
Show, Provenance -> Provenance -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Provenance -> Provenance -> Bool
$c/= :: Provenance -> Provenance -> Bool
== :: Provenance -> Provenance -> Bool
$c== :: Provenance -> Provenance -> Bool
Eq, Eq Provenance
Provenance -> Provenance -> Bool
Provenance -> Provenance -> Ordering
Provenance -> Provenance -> Provenance
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 :: Provenance -> Provenance -> Provenance
$cmin :: Provenance -> Provenance -> Provenance
max :: Provenance -> Provenance -> Provenance
$cmax :: Provenance -> Provenance -> Provenance
>= :: Provenance -> Provenance -> Bool
$c>= :: Provenance -> Provenance -> Bool
> :: Provenance -> Provenance -> Bool
$c> :: Provenance -> Provenance -> Bool
<= :: Provenance -> Provenance -> Bool
$c<= :: Provenance -> Provenance -> Bool
< :: Provenance -> Provenance -> Bool
$c< :: Provenance -> Provenance -> Bool
compare :: Provenance -> Provenance -> Ordering
$ccompare :: Provenance -> Provenance -> Ordering
Ord, Typeable Provenance
Provenance -> Constr
Provenance -> DataType
(forall b. Data b => b -> b) -> Provenance -> Provenance
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) -> Provenance -> u
forall u. (forall d. Data d => d -> u) -> Provenance -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Provenance -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Provenance -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Provenance -> m Provenance
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Provenance -> m Provenance
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Provenance
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Provenance -> c Provenance
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Provenance)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Provenance)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Provenance -> m Provenance
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Provenance -> m Provenance
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Provenance -> m Provenance
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Provenance -> m Provenance
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Provenance -> m Provenance
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Provenance -> m Provenance
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Provenance -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Provenance -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> Provenance -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Provenance -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Provenance -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Provenance -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Provenance -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Provenance -> r
gmapT :: (forall b. Data b => b -> b) -> Provenance -> Provenance
$cgmapT :: (forall b. Data b => b -> b) -> Provenance -> Provenance
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Provenance)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Provenance)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Provenance)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Provenance)
dataTypeOf :: Provenance -> DataType
$cdataTypeOf :: Provenance -> DataType
toConstr :: Provenance -> Constr
$ctoConstr :: Provenance -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Provenance
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Provenance
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Provenance -> c Provenance
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Provenance -> c Provenance
Data, forall x. Rep Provenance x -> Provenance
forall x. Provenance -> Rep Provenance x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Provenance x -> Provenance
$cfrom :: forall x. Provenance -> Rep Provenance x
Generic, Typeable)
data Err' t
= Msg String
| InternalMsg String
| CantUnify Bool (t, Maybe Provenance)
(t, Maybe Provenance)
(Err' t) [(Name, t)] Int
| InfiniteUnify Name t [(Name, t)]
| CantConvert t t [(Name, t)]
| CantSolveGoal t [(Name, t)]
| UnifyScope Name Name t [(Name, t)]
| CantInferType String
| NonFunctionType t t
| NotEquality t t
| TooManyArguments Name
| CantIntroduce t
| NoSuchVariable Name
| WithFnType t
| NoTypeDecl Name
| NotInjective t t t
| CantResolve Bool
t (Err' t)
| InvalidTCArg Name t
| CantResolveAlts [Name]
| NoValidAlts [Name]
| IncompleteTerm t
| UniverseError FC UExp (Int, Int) (Int, Int) [ConstraintFC]
| UniqueError Universe Name
| UniqueKindError Universe Name
|
| Inaccessible Name
| UnknownImplicit Name Name
| CantMatch t
| NonCollapsiblePostulate Name
| AlreadyDefined Name
| ProofSearchFail (Err' t)
| NoRewriting t t t
| At FC (Err' t)
| Elaborating String Name (Maybe t) (Err' t)
| ElaboratingArg Name Name [(Name, Name)] (Err' t)
| ProviderError String
| LoadingFailed String (Err' t)
| ReflectionError [[ErrorReportPart]] (Err' t)
| ReflectionFailed String (Err' t)
| ElabScriptDebug [ErrorReportPart] t [(Name, t, [(Name, Binder t)])]
| ElabScriptStuck t
| RunningElabScript (Err' t)
| ElabScriptStaging Name
| FancyMsg [ErrorReportPart]
deriving (Err' t -> Err' t -> Bool
forall t. Eq t => Err' t -> Err' t -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Err' t -> Err' t -> Bool
$c/= :: forall t. Eq t => Err' t -> Err' t -> Bool
== :: Err' t -> Err' t -> Bool
$c== :: forall t. Eq t => Err' t -> Err' t -> Bool
Eq, Err' t -> Err' t -> Ordering
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
forall {t}. Ord t => Eq (Err' t)
forall t. Ord t => Err' t -> Err' t -> Bool
forall t. Ord t => Err' t -> Err' t -> Ordering
forall t. Ord t => Err' t -> Err' t -> Err' t
min :: Err' t -> Err' t -> Err' t
$cmin :: forall t. Ord t => Err' t -> Err' t -> Err' t
max :: Err' t -> Err' t -> Err' t
$cmax :: forall t. Ord t => Err' t -> Err' t -> Err' t
>= :: Err' t -> Err' t -> Bool
$c>= :: forall t. Ord t => Err' t -> Err' t -> Bool
> :: Err' t -> Err' t -> Bool
$c> :: forall t. Ord t => Err' t -> Err' t -> Bool
<= :: Err' t -> Err' t -> Bool
$c<= :: forall t. Ord t => Err' t -> Err' t -> Bool
< :: Err' t -> Err' t -> Bool
$c< :: forall t. Ord t => Err' t -> Err' t -> Bool
compare :: Err' t -> Err' t -> Ordering
$ccompare :: forall t. Ord t => Err' t -> Err' t -> Ordering
Ord, forall a b. a -> Err' b -> Err' a
forall a b. (a -> b) -> Err' a -> Err' b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: forall a b. a -> Err' b -> Err' a
$c<$ :: forall a b. a -> Err' b -> Err' a
fmap :: forall a b. (a -> b) -> Err' a -> Err' b
$cfmap :: forall a b. (a -> b) -> Err' a -> Err' b
Functor, Err' t -> Constr
Err' t -> DataType
forall {t}. Data t => Typeable (Err' t)
forall t. Data t => Err' t -> Constr
forall t. Data t => Err' t -> DataType
forall t.
Data t =>
(forall b. Data b => b -> b) -> Err' t -> Err' t
forall t u.
Data t =>
Int -> (forall d. Data d => d -> u) -> Err' t -> u
forall t u. Data t => (forall d. Data d => d -> u) -> Err' t -> [u]
forall t r r'.
Data t =>
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Err' t -> r
forall t r r'.
Data t =>
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Err' t -> r
forall t (m :: * -> *).
(Data t, Monad m) =>
(forall d. Data d => d -> m d) -> Err' t -> m (Err' t)
forall t (m :: * -> *).
(Data t, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Err' t -> m (Err' t)
forall t (c :: * -> *).
Data t =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Err' t)
forall t (c :: * -> *).
Data t =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Err' t -> c (Err' t)
forall t (t :: * -> *) (c :: * -> *).
(Data t, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Err' t))
forall t (t :: * -> * -> *) (c :: * -> *).
(Data t, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Err' t))
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 (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Err' t)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Err' t -> c (Err' t)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Err' t))
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Err' t -> m (Err' t)
$cgmapMo :: forall t (m :: * -> *).
(Data t, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Err' t -> m (Err' t)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Err' t -> m (Err' t)
$cgmapMp :: forall t (m :: * -> *).
(Data t, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Err' t -> m (Err' t)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Err' t -> m (Err' t)
$cgmapM :: forall t (m :: * -> *).
(Data t, Monad m) =>
(forall d. Data d => d -> m d) -> Err' t -> m (Err' t)
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Err' t -> u
$cgmapQi :: forall t u.
Data t =>
Int -> (forall d. Data d => d -> u) -> Err' t -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> Err' t -> [u]
$cgmapQ :: forall t u. Data t => (forall d. Data d => d -> u) -> Err' t -> [u]
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Err' t -> r
$cgmapQr :: forall t r r'.
Data t =>
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Err' t -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Err' t -> r
$cgmapQl :: forall t r r'.
Data t =>
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Err' t -> r
gmapT :: (forall b. Data b => b -> b) -> Err' t -> Err' t
$cgmapT :: forall t.
Data t =>
(forall b. Data b => b -> b) -> Err' t -> Err' t
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Err' t))
$cdataCast2 :: forall t (t :: * -> * -> *) (c :: * -> *).
(Data t, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Err' t))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Err' t))
$cdataCast1 :: forall t (t :: * -> *) (c :: * -> *).
(Data t, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Err' t))
dataTypeOf :: Err' t -> DataType
$cdataTypeOf :: forall t. Data t => Err' t -> DataType
toConstr :: Err' t -> Constr
$ctoConstr :: forall t. Data t => Err' t -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Err' t)
$cgunfold :: forall t (c :: * -> *).
Data t =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Err' t)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Err' t -> c (Err' t)
$cgfoldl :: forall t (c :: * -> *).
Data t =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Err' t -> c (Err' t)
Data, forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall t x. Rep (Err' t) x -> Err' t
forall t x. Err' t -> Rep (Err' t) x
$cto :: forall t x. Rep (Err' t) x -> Err' t
$cfrom :: forall t x. Err' t -> Rep (Err' t) x
Generic, Typeable)
type Err = Err' Term
data TC a = OK !a
| Error Err
deriving (TC a -> TC a -> Bool
forall a. Eq a => TC a -> TC a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TC a -> TC a -> Bool
$c/= :: forall a. Eq a => TC a -> TC a -> Bool
== :: TC a -> TC a -> Bool
$c== :: forall a. Eq a => TC a -> TC a -> Bool
Eq, forall a b. a -> TC b -> TC a
forall a b. (a -> b) -> TC a -> TC b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: forall a b. a -> TC b -> TC a
$c<$ :: forall a b. a -> TC b -> TC a
fmap :: forall a b. (a -> b) -> TC a -> TC b
$cfmap :: forall a b. (a -> b) -> TC a -> TC b
Functor)
bindTC :: TC a -> (a -> TC b) -> TC b
bindTC :: forall a b. TC a -> (a -> TC b) -> TC b
bindTC TC a
x a -> TC b
k = case TC a
x of
OK a
v -> a -> TC b
k a
v
Error Err
e -> forall a. Err -> TC a
Error Err
e
{-# INLINE bindTC #-}
instance Monad TC where
return :: forall a. a -> TC a
return a
x = forall a. a -> TC a
OK a
x
TC a
x >>= :: forall a b. TC a -> (a -> TC b) -> TC b
>>= a -> TC b
k = forall a b. TC a -> (a -> TC b) -> TC b
bindTC TC a
x a -> TC b
k
#if !(MIN_VERSION_base(4,13,0))
fail = Fail.fail
#endif
instance Fail.MonadFail TC where
fail :: forall a. String -> TC a
fail String
e = forall a. Err -> TC a
Error (forall t. String -> Err' t
InternalMsg String
e)
instance MonadPlus TC where
mzero :: forall a. TC a
mzero = forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"Unknown error"
(OK a
x) mplus :: forall a. TC a -> TC a -> TC a
`mplus` TC a
_ = forall a. a -> TC a
OK a
x
TC a
_ `mplus` (OK a
y) = forall a. a -> TC a
OK a
y
TC a
err `mplus` TC a
_ = TC a
err
instance Applicative TC where
pure :: forall a. a -> TC a
pure = forall (m :: * -> *) a. Monad m => a -> m a
return
<*> :: forall a b. TC (a -> b) -> TC a -> TC b
(<*>) = forall (m :: * -> *) a b. Monad m => m (a -> b) -> m a -> m b
ap
instance Alternative TC where
empty :: forall a. TC a
empty = forall (m :: * -> *) a. MonadPlus m => m a
mzero
<|> :: forall a. TC a -> TC a -> TC a
(<|>) = forall (m :: * -> *) a. MonadPlus m => m a -> m a -> m a
mplus
instance Sized ErrorReportPart where
size :: ErrorReportPart -> Int
size (TextPart String
msg) = Int
1 forall a. Num a => a -> a -> a
+ forall (t :: * -> *) a. Foldable t => t a -> Int
length String
msg
size (TermPart TT Name
t) = Int
1 forall a. Num a => a -> a -> a
+ forall a. Sized a => a -> Int
size TT Name
t
size (RawPart Raw
r) = Int
1 forall a. Num a => a -> a -> a
+ forall a. Sized a => a -> Int
size Raw
r
size (NamePart Name
n) = Int
1 forall a. Num a => a -> a -> a
+ forall a. Sized a => a -> Int
size Name
n
size (SubReport [ErrorReportPart]
rs) = Int
1 forall a. Num a => a -> a -> a
+ forall a. Sized a => a -> Int
size [ErrorReportPart]
rs
instance Sized Err where
size :: Err -> Int
size (Msg String
msg) = forall (t :: * -> *) a. Foldable t => t a -> Int
length String
msg
size (InternalMsg String
msg) = forall (t :: * -> *) a. Foldable t => t a -> Int
length String
msg
size (CantUnify Bool
_ (TT Name, Maybe Provenance)
left (TT Name, Maybe Provenance)
right Err
err [(Name, TT Name)]
_ Int
score) = forall a. Sized a => a -> Int
size (forall a b. (a, b) -> a
fst (TT Name, Maybe Provenance)
left) forall a. Num a => a -> a -> a
+ forall a. Sized a => a -> Int
size (forall a b. (a, b) -> a
fst (TT Name, Maybe Provenance)
right) forall a. Num a => a -> a -> a
+ forall a. Sized a => a -> Int
size Err
err
size (InfiniteUnify Name
_ TT Name
right [(Name, TT Name)]
_) = forall a. Sized a => a -> Int
size TT Name
right
size (CantConvert TT Name
left TT Name
right [(Name, TT Name)]
_) = forall a. Sized a => a -> Int
size TT Name
left forall a. Num a => a -> a -> a
+ forall a. Sized a => a -> Int
size TT Name
right
size (UnifyScope Name
_ Name
_ TT Name
right [(Name, TT Name)]
_) = forall a. Sized a => a -> Int
size TT Name
right
size (NoSuchVariable Name
name) = forall a. Sized a => a -> Int
size Name
name
size (NoTypeDecl Name
name) = forall a. Sized a => a -> Int
size Name
name
size (NotInjective TT Name
l TT Name
c TT Name
r) = forall a. Sized a => a -> Int
size TT Name
l forall a. Num a => a -> a -> a
+ forall a. Sized a => a -> Int
size TT Name
c forall a. Num a => a -> a -> a
+ forall a. Sized a => a -> Int
size TT Name
r
size (CantResolve Bool
_ TT Name
trm Err
_) = forall a. Sized a => a -> Int
size TT Name
trm
size (NoRewriting TT Name
l TT Name
r TT Name
t) = forall a. Sized a => a -> Int
size TT Name
l forall a. Num a => a -> a -> a
+ forall a. Sized a => a -> Int
size TT Name
r forall a. Num a => a -> a -> a
+ forall a. Sized a => a -> Int
size TT Name
t
size (CantResolveAlts [Name]
_) = Int
1
size (IncompleteTerm TT Name
trm) = forall a. Sized a => a -> Int
size TT Name
trm
size Err
ProgramLineComment = Int
1
size (At FC
fc Err
err) = forall a. Sized a => a -> Int
size FC
fc forall a. Num a => a -> a -> a
+ forall a. Sized a => a -> Int
size Err
err
size (Elaborating String
_ Name
_ Maybe (TT Name)
_ Err
err) = forall a. Sized a => a -> Int
size Err
err
size (ElaboratingArg Name
_ Name
_ [(Name, Name)]
_ Err
err) = forall a. Sized a => a -> Int
size Err
err
size (ProviderError String
msg) = forall (t :: * -> *) a. Foldable t => t a -> Int
length String
msg
size (LoadingFailed String
fn Err
e) = Int
1 forall a. Num a => a -> a -> a
+ forall (t :: * -> *) a. Foldable t => t a -> Int
length String
fn forall a. Num a => a -> a -> a
+ forall a. Sized a => a -> Int
size Err
e
size Err
_ = Int
1
instance Show Err where
show :: Err -> String
show (Msg String
s) = String
s
show (InternalMsg String
s) = String
"Internal error: " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show String
s
show (CantUnify Bool
rcv (TT Name, Maybe Provenance)
l (TT Name, Maybe Provenance)
r Err
e [(Name, TT Name)]
sc Int
i) = String
"CantUnify " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show Bool
rcv forall a. [a] -> [a] -> [a]
++ String
" " forall a. [a] -> [a] -> [a]
++
forall a. Show a => a -> String
show (TT Name, Maybe Provenance)
l forall a. [a] -> [a] -> [a]
++ String
" and " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show (TT Name, Maybe Provenance)
r forall a. [a] -> [a] -> [a]
++ String
" " forall a. [a] -> [a] -> [a]
++
forall a. Show a => a -> String
show Err
e forall a. [a] -> [a] -> [a]
++ String
" in " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show [(Name, TT Name)]
sc forall a. [a] -> [a] -> [a]
++ String
" " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show Int
i
show (CantConvert TT Name
l TT Name
r [(Name, TT Name)]
sc) = String
"CantConvert " forall a. [a] -> [a] -> [a]
++
forall a. Show a => a -> String
show TT Name
l forall a. [a] -> [a] -> [a]
++ String
" and " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show TT Name
r forall a. [a] -> [a] -> [a]
++ String
" " forall a. [a] -> [a] -> [a]
++
String
" in " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show [(Name, TT Name)]
sc
show (CantSolveGoal TT Name
g [(Name, TT Name)]
_) = String
"CantSolve " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show TT Name
g
show (Inaccessible Name
n) = forall a. Show a => a -> String
show Name
n forall a. [a] -> [a] -> [a]
++ String
" is not an accessible pattern variable"
show (UnknownImplicit Name
n Name
f) = forall a. Show a => a -> String
show Name
n forall a. [a] -> [a] -> [a]
++ String
" is not an implicit argument of " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show Name
f
show (ProviderError String
msg) = String
"Type provider error: " forall a. [a] -> [a] -> [a]
++ String
msg
show (LoadingFailed String
fn Err
e) = String
"Loading " forall a. [a] -> [a] -> [a]
++ String
fn forall a. [a] -> [a] -> [a]
++ String
" failed: (TT) " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show Err
e
show Err
ProgramLineComment = String
"Program line next to comment"
show (At FC
f Err
e) = forall a. Show a => a -> String
show FC
f forall a. [a] -> [a] -> [a]
++ String
":" forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show Err
e
show (ElaboratingArg Name
f Name
x [(Name, Name)]
prev Err
e) = String
"Elaborating " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show Name
f forall a. [a] -> [a] -> [a]
++ String
" arg " forall a. [a] -> [a] -> [a]
++
forall a. Show a => a -> String
show Name
x forall a. [a] -> [a] -> [a]
++ String
": " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show Err
e
show (Elaborating String
what Name
n Maybe (TT Name)
ty Err
e) = String
"Elaborating " forall a. [a] -> [a] -> [a]
++ String
what forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show Name
n forall a. [a] -> [a] -> [a]
++
forall {a}. Show a => Maybe a -> String
showType Maybe (TT Name)
ty forall a. [a] -> [a] -> [a]
++ String
":" forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show Err
e
where
showType :: Maybe a -> String
showType Maybe a
Nothing = String
""
showType (Just a
ty) = String
" with expected type " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show a
ty
show (ProofSearchFail Err
e) = String
"Proof search fail: " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show Err
e
show (InfiniteUnify Name
_ TT Name
_ [(Name, TT Name)]
_) = String
"InfiniteUnify"
show (UnifyScope Name
_ Name
_ TT Name
_ [(Name, TT Name)]
_) = String
"UnifyScope"
show (NonFunctionType TT Name
_ TT Name
_) = String
"NonFunctionType"
show (NotEquality TT Name
_ TT Name
_) = String
"NotEquality"
show (TooManyArguments Name
_) = String
"TooManyArguments"
show (CantIntroduce TT Name
_) = String
"CantIntroduce"
show (NoSuchVariable Name
n) = String
"NoSuchVariable " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show Name
n
show (WithFnType TT Name
_) = String
"WithFnType"
show (NoTypeDecl Name
_) = String
"NoTypeDecl"
show (NotInjective TT Name
_ TT Name
_ TT Name
_) = String
"NotInjective"
show (CantResolve Bool
_ TT Name
_ Err
_) = String
"CantResolve"
show (InvalidTCArg Name
_ TT Name
_) = String
"InvalidTCArg"
show (CantResolveAlts [Name]
_) = String
"CantResolveAlts"
show (NoValidAlts [Name]
_) = String
"NoValidAlts"
show (IncompleteTerm TT Name
_) = String
"IncompleteTerm"
show Err
_ = String
"Error"
instance Pretty Err OutputAnnotation where
pretty :: Err -> Doc OutputAnnotation
pretty (Msg String
m) = forall a. String -> Doc a
text String
m
pretty (CantUnify Bool
_ (TT Name
l, Maybe Provenance
_) (TT Name
r, Maybe Provenance
_) Err
e [(Name, TT Name)]
_ Int
i) =
forall a. String -> Doc a
text String
"Cannot unify" forall a. Doc a -> Doc a -> Doc a
<+> forall a. Doc a
colon forall a. Doc a -> Doc a -> Doc a
<+> forall a ty. Pretty a ty => a -> Doc ty
pretty TT Name
l forall a. Doc a -> Doc a -> Doc a
<+> forall a. String -> Doc a
text String
"and" forall a. Doc a -> Doc a -> Doc a
<+> forall a ty. Pretty a ty => a -> Doc ty
pretty TT Name
r forall a. Doc a -> Doc a -> Doc a
<+>
forall a. Int -> Doc a -> Doc a
nest Int
nestingSize (forall a. String -> Doc a
text String
"where" forall a. Doc a -> Doc a -> Doc a
<+> forall a ty. Pretty a ty => a -> Doc ty
pretty Err
e forall a. Doc a -> Doc a -> Doc a
<+> forall a. String -> Doc a
text String
"with" forall a. Doc a -> Doc a -> Doc a
<+> (forall a. String -> Doc a
text forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Show a => a -> String
show forall a b. (a -> b) -> a -> b
$ Int
i))
pretty (ProviderError String
msg) = forall a. String -> Doc a
text String
msg
pretty err :: Err
err@(LoadingFailed String
_ Err
_) = forall a. String -> Doc a
text (forall a. Show a => a -> String
show Err
err)
pretty Err
_ = forall a. String -> Doc a
text String
"Error"
instance (Pretty a OutputAnnotation) => Pretty (TC a) OutputAnnotation where
pretty :: TC a -> Doc OutputAnnotation
pretty (OK a
ok) = forall a ty. Pretty a ty => a -> Doc ty
pretty a
ok
pretty (Error Err
err) =
forall a. String -> Doc a
text String
"Error" forall a. Doc a -> Doc a -> Doc a
<+> forall a. Doc a
colon forall a. Doc a -> Doc a -> Doc a
<+> forall a ty. Pretty a ty => a -> Doc ty
pretty Err
err
instance Show a => Show (TC a) where
show :: TC a -> String
show (OK a
x) = forall a. Show a => a -> String
show a
x
show (Error Err
str) = String
"Error: " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show Err
str
tfail :: Err -> TC a
tfail :: forall a. Err -> TC a
tfail Err
e = forall a. Err -> TC a
Error Err
e
discard :: Monad m => m a -> m ()
discard :: forall (m :: * -> *) a. Monad m => m a -> m ()
discard m a
f = m a
f forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *) a. Monad m => a -> m a
return ()
showSep :: String -> [String] -> String
showSep :: String -> [String] -> String
showSep String
sep [] = String
""
showSep String
sep [String
x] = String
x
showSep String
sep (String
x:[String]
xs) = String
x forall a. [a] -> [a] -> [a]
++ String
sep forall a. [a] -> [a] -> [a]
++ String -> [String] -> String
showSep String
sep [String]
xs
pmap :: (t -> b) -> (t, t) -> (b, b)
pmap t -> b
f (t
x, t
y) = (t -> b
f t
x, t -> b
f t
y)
traceWhen :: Bool -> String -> a -> a
traceWhen Bool
True String
msg a
a = forall a. String -> a -> a
trace String
msg a
a
traceWhen Bool
False String
_ a
a = a
a
data Name = UN !T.Text
| NS !Name [T.Text]
| MN !Int !T.Text
| SN !SpecialName
| SymRef Int
deriving (Name -> Name -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Name -> Name -> Bool
$c/= :: Name -> Name -> Bool
== :: Name -> Name -> Bool
$c== :: Name -> Name -> Bool
Eq, Eq Name
Name -> Name -> Bool
Name -> Name -> Ordering
Name -> Name -> Name
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 :: Name -> Name -> Name
$cmin :: Name -> Name -> Name
max :: Name -> Name -> Name
$cmax :: Name -> Name -> Name
>= :: Name -> Name -> Bool
$c>= :: Name -> Name -> Bool
> :: Name -> Name -> Bool
$c> :: Name -> Name -> Bool
<= :: Name -> Name -> Bool
$c<= :: Name -> Name -> Bool
< :: Name -> Name -> Bool
$c< :: Name -> Name -> Bool
compare :: Name -> Name -> Ordering
$ccompare :: Name -> Name -> Ordering
Ord, Typeable Name
Name -> Constr
Name -> DataType
(forall b. Data b => b -> b) -> Name -> Name
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) -> Name -> u
forall u. (forall d. Data d => d -> u) -> Name -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Name -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Name -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Name -> m Name
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Name -> m Name
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Name
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Name -> c Name
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Name)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Name)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Name -> m Name
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Name -> m Name
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Name -> m Name
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Name -> m Name
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Name -> m Name
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Name -> m Name
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Name -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Name -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> Name -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Name -> [u]
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Name -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Name -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Name -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Name -> r
gmapT :: (forall b. Data b => b -> b) -> Name -> Name
$cgmapT :: (forall b. Data b => b -> b) -> Name -> Name
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Name)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Name)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Name)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Name)
dataTypeOf :: Name -> DataType
$cdataTypeOf :: Name -> DataType
toConstr :: Name -> Constr
$ctoConstr :: Name -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Name
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Name
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Name -> c Name
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Name -> c Name
Data, forall x. Rep Name x -> Name
forall x. Name -> Rep Name x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Name x -> Name
$cfrom :: forall x. Name -> Rep Name x
Generic, Typeable)
txt :: String -> T.Text
txt :: String -> Text
txt = String -> Text
T.pack
str :: T.Text -> String
str :: Text -> String
str = Text -> String
T.unpack
tnull :: T.Text -> Bool
tnull :: Text -> Bool
tnull = Text -> Bool
T.null
thead :: T.Text -> Char
thead :: Text -> Char
thead = Text -> Char
T.head
sUN :: String -> Name
sUN :: String -> Name
sUN String
s = Text -> Name
UN (String -> Text
txt String
s)
sNS :: Name -> [String] -> Name
sNS :: Name -> [String] -> Name
sNS Name
n [String]
ss = Name -> [Text] -> Name
NS Name
n forall a b. NFData a => (a -> b) -> a -> b
$!! (forall a b. (a -> b) -> [a] -> [b]
map String -> Text
txt [String]
ss)
sMN :: Int -> String -> Name
sMN :: Int -> String -> Name
sMN Int
i String
s = Int -> Text -> Name
MN Int
i (String -> Text
txt String
s)
caseName :: Name -> Bool
caseName (SN (CaseN FC'
_ Name
_)) = Bool
True
caseName (NS Name
n [Text]
_) = Name -> Bool
caseName Name
n
caseName Name
_ = Bool
False
data SpecialName = WhereN !Int !Name !Name
| WithN !Int !Name
| ImplementationN !Name [T.Text]
| ParentN !Name !T.Text
| MethodN !Name
| CaseN !FC' !Name
| ImplementationCtorN !Name
| MetaN !Name !Name
deriving (SpecialName -> SpecialName -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SpecialName -> SpecialName -> Bool
$c/= :: SpecialName -> SpecialName -> Bool
== :: SpecialName -> SpecialName -> Bool
$c== :: SpecialName -> SpecialName -> Bool
Eq, Eq SpecialName
SpecialName -> SpecialName -> Bool
SpecialName -> SpecialName -> Ordering
SpecialName -> SpecialName -> SpecialName
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 :: SpecialName -> SpecialName -> SpecialName
$cmin :: SpecialName -> SpecialName -> SpecialName
max :: SpecialName -> SpecialName -> SpecialName
$cmax :: SpecialName -> SpecialName -> SpecialName
>= :: SpecialName -> SpecialName -> Bool
$c>= :: SpecialName -> SpecialName -> Bool
> :: SpecialName -> SpecialName -> Bool
$c> :: SpecialName -> SpecialName -> Bool
<= :: SpecialName -> SpecialName -> Bool
$c<= :: SpecialName -> SpecialName -> Bool
< :: SpecialName -> SpecialName -> Bool
$c< :: SpecialName -> SpecialName -> Bool
compare :: SpecialName -> SpecialName -> Ordering
$ccompare :: SpecialName -> SpecialName -> Ordering
Ord, Typeable SpecialName
SpecialName -> Constr
SpecialName -> DataType
(forall b. Data b => b -> b) -> SpecialName -> SpecialName
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) -> SpecialName -> u
forall u. (forall d. Data d => d -> u) -> SpecialName -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SpecialName -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SpecialName -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SpecialName -> m SpecialName
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SpecialName -> m SpecialName
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SpecialName
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SpecialName -> c SpecialName
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SpecialName)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SpecialName)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SpecialName -> m SpecialName
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SpecialName -> m SpecialName
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SpecialName -> m SpecialName
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SpecialName -> m SpecialName
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SpecialName -> m SpecialName
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SpecialName -> m SpecialName
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> SpecialName -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> SpecialName -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> SpecialName -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> SpecialName -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SpecialName -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SpecialName -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SpecialName -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SpecialName -> r
gmapT :: (forall b. Data b => b -> b) -> SpecialName -> SpecialName
$cgmapT :: (forall b. Data b => b -> b) -> SpecialName -> SpecialName
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SpecialName)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SpecialName)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SpecialName)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SpecialName)
dataTypeOf :: SpecialName -> DataType
$cdataTypeOf :: SpecialName -> DataType
toConstr :: SpecialName -> Constr
$ctoConstr :: SpecialName -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SpecialName
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SpecialName
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SpecialName -> c SpecialName
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SpecialName -> c SpecialName
Data, forall x. Rep SpecialName x -> SpecialName
forall x. SpecialName -> Rep SpecialName x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep SpecialName x -> SpecialName
$cfrom :: forall x. SpecialName -> Rep SpecialName x
Generic, Typeable)
sImplementationN :: Name -> [String] -> SpecialName
sImplementationN :: Name -> [String] -> SpecialName
sImplementationN Name
n [String]
ss = Name -> [Text] -> SpecialName
ImplementationN Name
n (forall a b. (a -> b) -> [a] -> [b]
map String -> Text
T.pack [String]
ss)
instance Sized Name where
size :: Name -> Int
size (UN Text
n) = Int
1
size (NS Name
n [Text]
els) = Int
1 forall a. Num a => a -> a -> a
+ forall (t :: * -> *) a. Foldable t => t a -> Int
length [Text]
els
size (MN Int
i Text
n) = Int
1
size Name
_ = Int
1
instance Pretty Name OutputAnnotation where
pretty :: Name -> Doc OutputAnnotation
pretty n :: Name
n@(UN Text
n') = forall a. a -> Doc a -> Doc a
annotate (Name
-> Maybe NameOutput
-> Maybe String
-> Maybe String
-> OutputAnnotation
AnnName Name
n forall a. Maybe a
Nothing forall a. Maybe a
Nothing forall a. Maybe a
Nothing) forall a b. (a -> b) -> a -> b
$ forall a. String -> Doc a
text (Text -> String
T.unpack Text
n')
pretty n :: Name
n@(NS Name
un [Text]
s) = forall a. a -> Doc a -> Doc a
annotate (Name
-> Maybe NameOutput
-> Maybe String
-> Maybe String
-> OutputAnnotation
AnnName Name
n forall a. Maybe a
Nothing forall a. Maybe a
Nothing forall a. Maybe a
Nothing) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Doc a -> Doc a
noAnnotate forall a b. (a -> b) -> a -> b
$ forall a ty. Pretty a ty => a -> Doc ty
pretty Name
un
pretty n :: Name
n@(MN Int
i Text
s) = forall a. a -> Doc a -> Doc a
annotate (Name
-> Maybe NameOutput
-> Maybe String
-> Maybe String
-> OutputAnnotation
AnnName Name
n forall a. Maybe a
Nothing forall a. Maybe a
Nothing forall a. Maybe a
Nothing) forall a b. (a -> b) -> a -> b
$
forall a. Doc a
lbrace forall a. Doc a -> Doc a -> Doc a
<+> forall a. String -> Doc a
text (Text -> String
T.unpack Text
s) forall a. Doc a -> Doc a -> Doc a
<+> (forall a. String -> Doc a
text forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Show a => a -> String
show forall a b. (a -> b) -> a -> b
$ Int
i) forall a. Doc a -> Doc a -> Doc a
<+> forall a. Doc a
rbrace
pretty n :: Name
n@(SN SpecialName
s) = forall a. a -> Doc a -> Doc a
annotate (Name
-> Maybe NameOutput
-> Maybe String
-> Maybe String
-> OutputAnnotation
AnnName Name
n forall a. Maybe a
Nothing forall a. Maybe a
Nothing forall a. Maybe a
Nothing) forall a b. (a -> b) -> a -> b
$ forall a. String -> Doc a
text (forall a. Show a => a -> String
show SpecialName
s)
pretty n :: Name
n@(SymRef Int
i) = forall a. a -> Doc a -> Doc a
annotate (Name
-> Maybe NameOutput
-> Maybe String
-> Maybe String
-> OutputAnnotation
AnnName Name
n forall a. Maybe a
Nothing forall a. Maybe a
Nothing forall a. Maybe a
Nothing) forall a b. (a -> b) -> a -> b
$
forall a. String -> Doc a
text forall a b. (a -> b) -> a -> b
$ String
"##symbol" forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show Int
i forall a. [a] -> [a] -> [a]
++ String
"##"
instance Pretty [Name] OutputAnnotation where
pretty :: [Name] -> Doc OutputAnnotation
pretty = forall a. Doc a -> Doc a -> Doc a -> [Doc a] -> Doc a
encloseSep forall a. Doc a
empty forall a. Doc a
empty forall a. Doc a
comma forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a -> b) -> [a] -> [b]
map forall a ty. Pretty a ty => a -> Doc ty
pretty
instance Show Name where
show :: Name -> String
show (UN Text
n) = Text -> String
str Text
n
show (NS Name
n [Text]
s) = String -> [String] -> String
showSep String
"." (forall a b. (a -> b) -> [a] -> [b]
map Text -> String
T.unpack (forall a. [a] -> [a]
reverse [Text]
s)) forall a. [a] -> [a] -> [a]
++ String
"." forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show Name
n
show (MN Int
_ Text
u) | Text
u forall a. Eq a => a -> a -> Bool
== String -> Text
txt String
"underscore" = String
"_"
show (MN Int
i Text
s) = String
"{" forall a. [a] -> [a] -> [a]
++ Text -> String
str Text
s forall a. [a] -> [a] -> [a]
++ String
"_" forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show Int
i forall a. [a] -> [a] -> [a]
++ String
"}"
show (SN SpecialName
s) = forall a. Show a => a -> String
show SpecialName
s
show (SymRef Int
i) = String
"##symbol" forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show Int
i forall a. [a] -> [a] -> [a]
++ String
"##"
instance Show SpecialName where
show :: SpecialName -> String
show (WhereN Int
i Name
p Name
c) = forall a. Show a => a -> String
show Name
p forall a. [a] -> [a] -> [a]
++ String
", " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show Name
c
show (WithN Int
i Name
n) = String
"with block in " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show Name
n
show (ImplementationN Name
cl [Text]
impl) = String -> [String] -> String
showSep String
", " (forall a b. (a -> b) -> [a] -> [b]
map Text -> String
T.unpack [Text]
impl) forall a. [a] -> [a] -> [a]
++ String
" implementation of " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show Name
cl
show (MethodN Name
m) = String
"method " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show Name
m
show (ParentN Name
p Text
c) = forall a. Show a => a -> String
show Name
p forall a. [a] -> [a] -> [a]
++ String
"#" forall a. [a] -> [a] -> [a]
++ Text -> String
T.unpack Text
c
show (CaseN FC'
fc Name
n) = String
"case block in " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show Name
n forall a. [a] -> [a] -> [a]
++
if FC'
fc forall a. Eq a => a -> a -> Bool
== FC -> FC'
FC' FC
emptyFC then String
"" else String
" at " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show FC'
fc
show (ImplementationCtorN Name
n) = String
"constructor of " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show Name
n
show (MetaN Name
parent Name
meta) = String
"<<" forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show Name
parent forall a. [a] -> [a] -> [a]
++ String
" " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show Name
meta forall a. [a] -> [a] -> [a]
++ String
">>"
showCG :: Name -> String
showCG :: Name -> String
showCG (UN Text
n) = Text -> String
T.unpack Text
n
showCG (NS Name
n [Text]
s) = String -> [String] -> String
showSep String
"." (forall a b. (a -> b) -> [a] -> [b]
map Text -> String
T.unpack (forall a. [a] -> [a]
reverse [Text]
s)) forall a. [a] -> [a] -> [a]
++ String
"." forall a. [a] -> [a] -> [a]
++ Name -> String
showCG Name
n
showCG (MN Int
_ Text
u) | Text
u forall a. Eq a => a -> a -> Bool
== String -> Text
txt String
"underscore" = String
"_"
showCG (MN Int
i Text
s) = String
"{" forall a. [a] -> [a] -> [a]
++ Text -> String
T.unpack Text
s forall a. [a] -> [a] -> [a]
++ String
"_" forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show Int
i forall a. [a] -> [a] -> [a]
++ String
"}"
showCG (SN SpecialName
s) = SpecialName -> String
showCG' SpecialName
s
where showCG' :: SpecialName -> String
showCG' (WhereN Int
i Name
p Name
c) = Name -> String
showCG Name
p forall a. [a] -> [a] -> [a]
++ String
":" forall a. [a] -> [a] -> [a]
++ Name -> String
showCG Name
c forall a. [a] -> [a] -> [a]
++ String
":" forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show Int
i
showCG' (WithN Int
i Name
n) = String
"_" forall a. [a] -> [a] -> [a]
++ Name -> String
showCG Name
n forall a. [a] -> [a] -> [a]
++ String
"_with_" forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show Int
i
showCG' (ImplementationN Name
cl [Text]
impl) = Char
'@'forall a. a -> [a] -> [a]
:Name -> String
showCG Name
cl forall a. [a] -> [a] -> [a]
++ Char
'$'forall a. a -> [a] -> [a]
:String -> [String] -> String
showSep String
":" (forall a b. (a -> b) -> [a] -> [b]
map Text -> String
T.unpack [Text]
impl)
showCG' (MethodN Name
m) = Char
'!'forall a. a -> [a] -> [a]
:Name -> String
showCG Name
m
showCG' (ParentN Name
p Text
c) = Name -> String
showCG Name
p forall a. [a] -> [a] -> [a]
++ String
"#" forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show Text
c
showCG' (CaseN FC'
fc Name
c) = Name -> String
showCG Name
c forall a. [a] -> [a] -> [a]
++ FC' -> String
showFC' FC'
fc forall a. [a] -> [a] -> [a]
++ String
"_case"
showCG' (ImplementationCtorN Name
n) = Name -> String
showCG Name
n forall a. [a] -> [a] -> [a]
++ String
"_ictor"
showCG' (MetaN Name
parent Name
meta) = Name -> String
showCG Name
parent forall a. [a] -> [a] -> [a]
++ String
"_meta_" forall a. [a] -> [a] -> [a]
++ Name -> String
showCG Name
meta
showFC' :: FC' -> String
showFC' (FC' FC
NoFC) = String
""
showFC' (FC' (FileFC String
f)) = String
"_" forall a. [a] -> [a] -> [a]
++ ShowS
cgFN String
f
showFC' (FC' (FC String
f (Int, Int)
s (Int, Int)
e))
| (Int, Int)
s forall a. Eq a => a -> a -> Bool
== (Int, Int)
e = String
"_" forall a. [a] -> [a] -> [a]
++ ShowS
cgFN String
f forall a. [a] -> [a] -> [a]
++
String
"_" forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show (forall a b. (a, b) -> a
fst (Int, Int)
s) forall a. [a] -> [a] -> [a]
++ String
"_" forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show (forall a b. (a, b) -> b
snd (Int, Int)
s)
| Bool
otherwise = String
"_" forall a. [a] -> [a] -> [a]
++ ShowS
cgFN String
f forall a. [a] -> [a] -> [a]
++
String
"_" forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show (forall a b. (a, b) -> a
fst (Int, Int)
s) forall a. [a] -> [a] -> [a]
++ String
"_" forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show (forall a b. (a, b) -> b
snd (Int, Int)
s) forall a. [a] -> [a] -> [a]
++
String
"_" forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show (forall a b. (a, b) -> a
fst (Int, Int)
e) forall a. [a] -> [a] -> [a]
++ String
"_" forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show (forall a b. (a, b) -> b
snd (Int, Int)
e)
cgFN :: ShowS
cgFN = forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap (\Char
c -> if Bool -> Bool
not (Char -> Bool
isDigit Char
c Bool -> Bool -> Bool
|| Char -> Bool
isLetter Char
c) then String
"__" else [Char
c])
showCG (SymRef Int
i) = forall a. HasCallStack => String -> a
error String
"can't do codegen for a symbol reference"
type Ctxt a = Map.Map Name (Map.Map Name a)
emptyContext :: Map k a
emptyContext = forall k a. Map k a
Map.empty
mapCtxt :: (a -> b) -> Ctxt a -> Ctxt b
mapCtxt :: forall a b. (a -> b) -> Ctxt a -> Ctxt b
mapCtxt = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap
tcname :: Name -> Bool
tcname (UN Text
xs) = Bool
False
tcname (NS Name
n [Text]
_) = Name -> Bool
tcname Name
n
tcname (SN (ImplementationN Name
_ [Text]
_)) = Bool
True
tcname (SN (MethodN Name
_)) = Bool
True
tcname (SN (ParentN Name
_ Text
_)) = Bool
True
tcname Name
_ = Bool
False
implicitable :: Name -> Bool
implicitable (NS Name
n [Text]
_) = Bool
False
implicitable (UN Text
xs) | Text -> Bool
T.null Text
xs = Bool
False
| Bool
otherwise = Char -> Bool
isLower (Text -> Char
T.head Text
xs) Bool -> Bool -> Bool
||
Text -> Char
T.head Text
xs forall a. Eq a => a -> a -> Bool
== Char
'_'
implicitable (MN Int
_ Text
x) = Bool -> Bool
not (Text -> Bool
tnull Text
x) Bool -> Bool -> Bool
&& Text -> Char
thead Text
x forall a. Eq a => a -> a -> Bool
/= Char
'_'
implicitable Name
_ = Bool
False
nsroot :: Name -> Name
nsroot (NS Name
n [Text]
_) = Name
n
nsroot Name
n = Name
n
addDef :: Name -> a -> Ctxt a -> Ctxt a
addDef :: forall a. Name -> a -> Ctxt a -> Ctxt a
addDef Name
n a
v Ctxt a
ctxt = case forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup (Name -> Name
nsroot Name
n) Ctxt a
ctxt of
Maybe (Map Name a)
Nothing -> forall k a. Ord k => k -> a -> Map k a -> Map k a
Map.insert (Name -> Name
nsroot Name
n)
(forall k a. Ord k => k -> a -> Map k a -> Map k a
Map.insert Name
n a
v forall k a. Map k a
Map.empty) Ctxt a
ctxt
Just Map Name a
xs -> forall k a. Ord k => k -> a -> Map k a -> Map k a
Map.insert (Name -> Name
nsroot Name
n)
(forall k a. Ord k => k -> a -> Map k a -> Map k a
Map.insert Name
n a
v Map Name a
xs) Ctxt a
ctxt
lookupCtxtName :: Name -> Ctxt a -> [(Name, a)]
lookupCtxtName :: forall a. Name -> Ctxt a -> [(Name, a)]
lookupCtxtName Name
n Ctxt a
ctxt = case forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup (Name -> Name
nsroot Name
n) Ctxt a
ctxt of
Just Map Name a
xs -> forall {b}. [(Name, b)] -> [(Name, b)]
filterNS (forall k a. Map k a -> [(k, a)]
Map.toList Map Name a
xs)
Maybe (Map Name a)
Nothing -> []
where
filterNS :: [(Name, b)] -> [(Name, b)]
filterNS [] = []
filterNS ((Name
found, b
v) : [(Name, b)]
xs)
| Name -> Name -> Bool
nsmatch Name
n Name
found = (Name
found, b
v) forall a. a -> [a] -> [a]
: [(Name, b)] -> [(Name, b)]
filterNS [(Name, b)]
xs
| Bool
otherwise = [(Name, b)] -> [(Name, b)]
filterNS [(Name, b)]
xs
nsmatch :: Name -> Name -> Bool
nsmatch (NS Name
n [Text]
ns) (NS Name
p [Text]
ps) = [Text]
ns forall a. Eq a => [a] -> [a] -> Bool
`isPrefixOf` [Text]
ps
nsmatch (NS Name
_ [Text]
_) Name
_ = Bool
False
nsmatch Name
looking Name
found = Bool
True
lookupCtxt :: Name -> Ctxt a -> [a]
lookupCtxt :: forall a. Name -> Ctxt a -> [a]
lookupCtxt Name
n Ctxt a
ctxt = forall a b. (a -> b) -> [a] -> [b]
map forall a b. (a, b) -> b
snd (forall a. Name -> Ctxt a -> [(Name, a)]
lookupCtxtName Name
n Ctxt a
ctxt)
lookupCtxtExact :: Name -> Ctxt a -> Maybe a
lookupCtxtExact :: forall a. Name -> Ctxt a -> Maybe a
lookupCtxtExact Name
n Ctxt a
ctxt = forall a. [a] -> Maybe a
listToMaybe [ a
v | (Name
nm, a
v) <- forall a. Name -> Ctxt a -> [(Name, a)]
lookupCtxtName Name
n Ctxt a
ctxt, Name
nm forall a. Eq a => a -> a -> Bool
== Name
n]
deleteDefExact :: Name -> Ctxt a -> Ctxt a
deleteDefExact :: forall a. Name -> Ctxt a -> Ctxt a
deleteDefExact Name
n = forall k a. Ord k => (a -> a) -> k -> Map k a -> Map k a
Map.adjust (forall k a. Ord k => k -> Map k a -> Map k a
Map.delete Name
n) (Name -> Name
nsroot Name
n)
updateDef :: Name -> (a -> a) -> Ctxt a -> Ctxt a
updateDef :: forall a. Name -> (a -> a) -> Ctxt a -> Ctxt a
updateDef Name
n a -> a
f Ctxt a
ctxt
= case forall a. Name -> Ctxt a -> Maybe a
lookupCtxtExact Name
n Ctxt a
ctxt of
Just a
t -> forall a. Name -> a -> Ctxt a -> Ctxt a
addDef Name
n (a -> a
f a
t) Ctxt a
ctxt
Maybe a
Nothing -> Ctxt a
ctxt
toAlist :: Ctxt a -> [(Name, a)]
toAlist :: forall a. Ctxt a -> [(Name, a)]
toAlist Ctxt a
ctxt = let allns :: [Map Name a]
allns = forall a b. (a -> b) -> [a] -> [b]
map forall a b. (a, b) -> b
snd (forall k a. Map k a -> [(k, a)]
Map.toList Ctxt a
ctxt) in
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap (forall k a. Map k a -> [(k, a)]
Map.toList) [Map Name a]
allns
addAlist :: [(Name, a)] -> Ctxt a -> Ctxt a
addAlist :: forall a. [(Name, a)] -> Ctxt a -> Ctxt a
addAlist [] Ctxt a
ctxt = Ctxt a
ctxt
addAlist ((Name
n, a
tm) : [(Name, a)]
ds) Ctxt a
ctxt = forall a. Name -> a -> Ctxt a -> Ctxt a
addDef Name
n a
tm (forall a. [(Name, a)] -> Ctxt a -> Ctxt a
addAlist [(Name, a)]
ds Ctxt a
ctxt)
data NativeTy = IT8 | IT16 | IT32 | IT64
deriving (Int -> NativeTy -> ShowS
[NativeTy] -> ShowS
NativeTy -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [NativeTy] -> ShowS
$cshowList :: [NativeTy] -> ShowS
show :: NativeTy -> String
$cshow :: NativeTy -> String
showsPrec :: Int -> NativeTy -> ShowS
$cshowsPrec :: Int -> NativeTy -> ShowS
Show, NativeTy -> NativeTy -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: NativeTy -> NativeTy -> Bool
$c/= :: NativeTy -> NativeTy -> Bool
== :: NativeTy -> NativeTy -> Bool
$c== :: NativeTy -> NativeTy -> Bool
Eq, Eq NativeTy
NativeTy -> NativeTy -> Bool
NativeTy -> NativeTy -> Ordering
NativeTy -> NativeTy -> NativeTy
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 :: NativeTy -> NativeTy -> NativeTy
$cmin :: NativeTy -> NativeTy -> NativeTy
max :: NativeTy -> NativeTy -> NativeTy
$cmax :: NativeTy -> NativeTy -> NativeTy
>= :: NativeTy -> NativeTy -> Bool
$c>= :: NativeTy -> NativeTy -> Bool
> :: NativeTy -> NativeTy -> Bool
$c> :: NativeTy -> NativeTy -> Bool
<= :: NativeTy -> NativeTy -> Bool
$c<= :: NativeTy -> NativeTy -> Bool
< :: NativeTy -> NativeTy -> Bool
$c< :: NativeTy -> NativeTy -> Bool
compare :: NativeTy -> NativeTy -> Ordering
$ccompare :: NativeTy -> NativeTy -> Ordering
Ord, Int -> NativeTy
NativeTy -> Int
NativeTy -> [NativeTy]
NativeTy -> NativeTy
NativeTy -> NativeTy -> [NativeTy]
NativeTy -> NativeTy -> NativeTy -> [NativeTy]
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: NativeTy -> NativeTy -> NativeTy -> [NativeTy]
$cenumFromThenTo :: NativeTy -> NativeTy -> NativeTy -> [NativeTy]
enumFromTo :: NativeTy -> NativeTy -> [NativeTy]
$cenumFromTo :: NativeTy -> NativeTy -> [NativeTy]
enumFromThen :: NativeTy -> NativeTy -> [NativeTy]
$cenumFromThen :: NativeTy -> NativeTy -> [NativeTy]
enumFrom :: NativeTy -> [NativeTy]
$cenumFrom :: NativeTy -> [NativeTy]
fromEnum :: NativeTy -> Int
$cfromEnum :: NativeTy -> Int
toEnum :: Int -> NativeTy
$ctoEnum :: Int -> NativeTy
pred :: NativeTy -> NativeTy
$cpred :: NativeTy -> NativeTy
succ :: NativeTy -> NativeTy
$csucc :: NativeTy -> NativeTy
Enum, Typeable NativeTy
NativeTy -> Constr
NativeTy -> DataType
(forall b. Data b => b -> b) -> NativeTy -> NativeTy
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) -> NativeTy -> u
forall u. (forall d. Data d => d -> u) -> NativeTy -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NativeTy -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NativeTy -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> NativeTy -> m NativeTy
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NativeTy -> m NativeTy
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c NativeTy
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NativeTy -> c NativeTy
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c NativeTy)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NativeTy)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NativeTy -> m NativeTy
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NativeTy -> m NativeTy
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NativeTy -> m NativeTy
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NativeTy -> m NativeTy
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> NativeTy -> m NativeTy
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> NativeTy -> m NativeTy
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> NativeTy -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> NativeTy -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> NativeTy -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> NativeTy -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NativeTy -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NativeTy -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NativeTy -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NativeTy -> r
gmapT :: (forall b. Data b => b -> b) -> NativeTy -> NativeTy
$cgmapT :: (forall b. Data b => b -> b) -> NativeTy -> NativeTy
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NativeTy)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NativeTy)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c NativeTy)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c NativeTy)
dataTypeOf :: NativeTy -> DataType
$cdataTypeOf :: NativeTy -> DataType
toConstr :: NativeTy -> Constr
$ctoConstr :: NativeTy -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c NativeTy
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c NativeTy
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NativeTy -> c NativeTy
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NativeTy -> c NativeTy
Data, forall x. Rep NativeTy x -> NativeTy
forall x. NativeTy -> Rep NativeTy x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep NativeTy x -> NativeTy
$cfrom :: forall x. NativeTy -> Rep NativeTy x
Generic, Typeable)
instance Pretty NativeTy OutputAnnotation where
pretty :: NativeTy -> Doc OutputAnnotation
pretty NativeTy
IT8 = forall a. String -> Doc a
text String
"Bits8"
pretty NativeTy
IT16 = forall a. String -> Doc a
text String
"Bits16"
pretty NativeTy
IT32 = forall a. String -> Doc a
text String
"Bits32"
pretty NativeTy
IT64 = forall a. String -> Doc a
text String
"Bits64"
data IntTy = ITFixed NativeTy | ITNative | ITBig | ITChar
deriving (Int -> IntTy -> ShowS
[IntTy] -> ShowS
IntTy -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [IntTy] -> ShowS
$cshowList :: [IntTy] -> ShowS
show :: IntTy -> String
$cshow :: IntTy -> String
showsPrec :: Int -> IntTy -> ShowS
$cshowsPrec :: Int -> IntTy -> ShowS
Show, IntTy -> IntTy -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: IntTy -> IntTy -> Bool
$c/= :: IntTy -> IntTy -> Bool
== :: IntTy -> IntTy -> Bool
$c== :: IntTy -> IntTy -> Bool
Eq, Eq IntTy
IntTy -> IntTy -> Bool
IntTy -> IntTy -> Ordering
IntTy -> IntTy -> IntTy
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 :: IntTy -> IntTy -> IntTy
$cmin :: IntTy -> IntTy -> IntTy
max :: IntTy -> IntTy -> IntTy
$cmax :: IntTy -> IntTy -> IntTy
>= :: IntTy -> IntTy -> Bool
$c>= :: IntTy -> IntTy -> Bool
> :: IntTy -> IntTy -> Bool
$c> :: IntTy -> IntTy -> Bool
<= :: IntTy -> IntTy -> Bool
$c<= :: IntTy -> IntTy -> Bool
< :: IntTy -> IntTy -> Bool
$c< :: IntTy -> IntTy -> Bool
compare :: IntTy -> IntTy -> Ordering
$ccompare :: IntTy -> IntTy -> Ordering
Ord, Typeable IntTy
IntTy -> Constr
IntTy -> DataType
(forall b. Data b => b -> b) -> IntTy -> IntTy
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) -> IntTy -> u
forall u. (forall d. Data d => d -> u) -> IntTy -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> IntTy -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> IntTy -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> IntTy -> m IntTy
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> IntTy -> m IntTy
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c IntTy
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> IntTy -> c IntTy
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c IntTy)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c IntTy)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> IntTy -> m IntTy
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> IntTy -> m IntTy
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> IntTy -> m IntTy
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> IntTy -> m IntTy
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> IntTy -> m IntTy
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> IntTy -> m IntTy
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> IntTy -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> IntTy -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> IntTy -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> IntTy -> [u]
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> IntTy -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> IntTy -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> IntTy -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> IntTy -> r
gmapT :: (forall b. Data b => b -> b) -> IntTy -> IntTy
$cgmapT :: (forall b. Data b => b -> b) -> IntTy -> IntTy
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c IntTy)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c IntTy)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c IntTy)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c IntTy)
dataTypeOf :: IntTy -> DataType
$cdataTypeOf :: IntTy -> DataType
toConstr :: IntTy -> Constr
$ctoConstr :: IntTy -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c IntTy
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c IntTy
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> IntTy -> c IntTy
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> IntTy -> c IntTy
Data, forall x. Rep IntTy x -> IntTy
forall x. IntTy -> Rep IntTy x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep IntTy x -> IntTy
$cfrom :: forall x. IntTy -> Rep IntTy x
Generic, Typeable)
intTyName :: IntTy -> String
intTyName :: IntTy -> String
intTyName IntTy
ITNative = String
"Int"
intTyName IntTy
ITBig = String
"BigInt"
intTyName (ITFixed NativeTy
sized) = String
"B" forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show (NativeTy -> Int
nativeTyWidth NativeTy
sized)
intTyName (IntTy
ITChar) = String
"Char"
data ArithTy = ATInt IntTy | ATFloat
deriving (Int -> ArithTy -> ShowS
[ArithTy] -> ShowS
ArithTy -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ArithTy] -> ShowS
$cshowList :: [ArithTy] -> ShowS
show :: ArithTy -> String
$cshow :: ArithTy -> String
showsPrec :: Int -> ArithTy -> ShowS
$cshowsPrec :: Int -> ArithTy -> ShowS
Show, ArithTy -> ArithTy -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ArithTy -> ArithTy -> Bool
$c/= :: ArithTy -> ArithTy -> Bool
== :: ArithTy -> ArithTy -> Bool
$c== :: ArithTy -> ArithTy -> Bool
Eq, Eq ArithTy
ArithTy -> ArithTy -> Bool
ArithTy -> ArithTy -> Ordering
ArithTy -> ArithTy -> ArithTy
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 :: ArithTy -> ArithTy -> ArithTy
$cmin :: ArithTy -> ArithTy -> ArithTy
max :: ArithTy -> ArithTy -> ArithTy
$cmax :: ArithTy -> ArithTy -> ArithTy
>= :: ArithTy -> ArithTy -> Bool
$c>= :: ArithTy -> ArithTy -> Bool
> :: ArithTy -> ArithTy -> Bool
$c> :: ArithTy -> ArithTy -> Bool
<= :: ArithTy -> ArithTy -> Bool
$c<= :: ArithTy -> ArithTy -> Bool
< :: ArithTy -> ArithTy -> Bool
$c< :: ArithTy -> ArithTy -> Bool
compare :: ArithTy -> ArithTy -> Ordering
$ccompare :: ArithTy -> ArithTy -> Ordering
Ord, Typeable ArithTy
ArithTy -> Constr
ArithTy -> DataType
(forall b. Data b => b -> b) -> ArithTy -> ArithTy
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) -> ArithTy -> u
forall u. (forall d. Data d => d -> u) -> ArithTy -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ArithTy -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ArithTy -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ArithTy -> m ArithTy
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ArithTy -> m ArithTy
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ArithTy
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ArithTy -> c ArithTy
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ArithTy)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ArithTy)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ArithTy -> m ArithTy
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ArithTy -> m ArithTy
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ArithTy -> m ArithTy
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ArithTy -> m ArithTy
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ArithTy -> m ArithTy
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ArithTy -> m ArithTy
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ArithTy -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ArithTy -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> ArithTy -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> ArithTy -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ArithTy -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ArithTy -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ArithTy -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ArithTy -> r
gmapT :: (forall b. Data b => b -> b) -> ArithTy -> ArithTy
$cgmapT :: (forall b. Data b => b -> b) -> ArithTy -> ArithTy
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ArithTy)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ArithTy)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ArithTy)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ArithTy)
dataTypeOf :: ArithTy -> DataType
$cdataTypeOf :: ArithTy -> DataType
toConstr :: ArithTy -> Constr
$ctoConstr :: ArithTy -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ArithTy
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ArithTy
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ArithTy -> c ArithTy
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ArithTy -> c ArithTy
Data, forall x. Rep ArithTy x -> ArithTy
forall x. ArithTy -> Rep ArithTy x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ArithTy x -> ArithTy
$cfrom :: forall x. ArithTy -> Rep ArithTy x
Generic, Typeable)
instance Pretty ArithTy OutputAnnotation where
pretty :: ArithTy -> Doc OutputAnnotation
pretty (ATInt IntTy
ITNative) = forall a. String -> Doc a
text String
"Int"
pretty (ATInt IntTy
ITBig) = forall a. String -> Doc a
text String
"BigInt"
pretty (ATInt IntTy
ITChar) = forall a. String -> Doc a
text String
"Char"
pretty (ATInt (ITFixed NativeTy
n)) = forall a ty. Pretty a ty => a -> Doc ty
pretty NativeTy
n
pretty ArithTy
ATFloat = forall a. String -> Doc a
text String
"Float"
nativeTyWidth :: NativeTy -> Int
nativeTyWidth :: NativeTy -> Int
nativeTyWidth NativeTy
IT8 = Int
8
nativeTyWidth NativeTy
IT16 = Int
16
nativeTyWidth NativeTy
IT32 = Int
32
nativeTyWidth NativeTy
IT64 = Int
64
data Const = I Int | BI Integer | Fl Double | Ch Char | Str String
| B8 Word8 | B16 Word16 | B32 Word32 | B64 Word64
| AType ArithTy | StrType
| WorldType | TheWorld
| VoidType | Forgot
deriving (Eq Const
Const -> Const -> Bool
Const -> Const -> Ordering
Const -> Const -> Const
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 :: Const -> Const -> Const
$cmin :: Const -> Const -> Const
max :: Const -> Const -> Const
$cmax :: Const -> Const -> Const
>= :: Const -> Const -> Bool
$c>= :: Const -> Const -> Bool
> :: Const -> Const -> Bool
$c> :: Const -> Const -> Bool
<= :: Const -> Const -> Bool
$c<= :: Const -> Const -> Bool
< :: Const -> Const -> Bool
$c< :: Const -> Const -> Bool
compare :: Const -> Const -> Ordering
$ccompare :: Const -> Const -> Ordering
Ord, Typeable Const
Const -> Constr
Const -> DataType
(forall b. Data b => b -> b) -> Const -> Const
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) -> Const -> u
forall u. (forall d. Data d => d -> u) -> Const -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Const -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Const -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Const -> m Const
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Const -> m Const
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Const
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Const -> c Const
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Const)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Const)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Const -> m Const
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Const -> m Const
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Const -> m Const
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Const -> m Const
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Const -> m Const
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Const -> m Const
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Const -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Const -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> Const -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Const -> [u]
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Const -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Const -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Const -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Const -> r
gmapT :: (forall b. Data b => b -> b) -> Const -> Const
$cgmapT :: (forall b. Data b => b -> b) -> Const -> Const
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Const)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Const)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Const)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Const)
dataTypeOf :: Const -> DataType
$cdataTypeOf :: Const -> DataType
toConstr :: Const -> Constr
$ctoConstr :: Const -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Const
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Const
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Const -> c Const
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Const -> c Const
Data, forall x. Rep Const x -> Const
forall x. Const -> Rep Const x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Const x -> Const
$cfrom :: forall x. Const -> Rep Const x
Generic, Typeable)
instance Eq Const where
I Int
i == :: Const -> Const -> Bool
== I Int
j = Int
i forall a. Eq a => a -> a -> Bool
== Int
j
BI Integer
i == BI Integer
j = Integer
i forall a. Eq a => a -> a -> Bool
== Integer
j
Fl Double
i == Fl Double
j = forall a. IEEE a => a -> a -> Bool
identicalIEEE Double
i Double
j
Ch Char
i == Ch Char
j = Char
i forall a. Eq a => a -> a -> Bool
== Char
j
Str String
i == Str String
j = String
i forall a. Eq a => a -> a -> Bool
== String
j
B8 Word8
i == B8 Word8
j = Word8
i forall a. Eq a => a -> a -> Bool
== Word8
j
B16 Word16
i == B16 Word16
j = Word16
i forall a. Eq a => a -> a -> Bool
== Word16
j
B32 Word32
i == B32 Word32
j = Word32
i forall a. Eq a => a -> a -> Bool
== Word32
j
B64 Word64
i == B64 Word64
j = Word64
i forall a. Eq a => a -> a -> Bool
== Word64
j
AType ArithTy
i == AType ArithTy
j = ArithTy
i forall a. Eq a => a -> a -> Bool
== ArithTy
j
Const
StrType == Const
StrType = Bool
True
Const
WorldType == Const
WorldType = Bool
True
Const
TheWorld == Const
TheWorld = Bool
True
Const
VoidType == Const
VoidType = Bool
True
Const
Forgot == Const
Forgot = Bool
True
Const
_ == Const
_ = Bool
False
isTypeConst :: Const -> Bool
isTypeConst :: Const -> Bool
isTypeConst (AType ArithTy
_) = Bool
True
isTypeConst Const
StrType = Bool
True
isTypeConst Const
WorldType = Bool
True
isTypeConst Const
VoidType = Bool
True
isTypeConst Const
_ = Bool
False
instance Sized Const where
size :: Const -> Int
size Const
_ = Int
1
instance Pretty Const OutputAnnotation where
pretty :: Const -> Doc OutputAnnotation
pretty (I Int
i) = forall a. String -> Doc a
text forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Show a => a -> String
show forall a b. (a -> b) -> a -> b
$ Int
i
pretty (BI Integer
i) = forall a. String -> Doc a
text forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Show a => a -> String
show forall a b. (a -> b) -> a -> b
$ Integer
i
pretty (Fl Double
f) = forall a. String -> Doc a
text forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Show a => a -> String
show forall a b. (a -> b) -> a -> b
$ Double
f
pretty (Ch Char
c) = forall a. String -> Doc a
text forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Show a => a -> String
show forall a b. (a -> b) -> a -> b
$ Char
c
pretty (Str String
s) = forall a. String -> Doc a
text String
s
pretty (AType ArithTy
a) = forall a ty. Pretty a ty => a -> Doc ty
pretty ArithTy
a
pretty Const
StrType = forall a. String -> Doc a
text String
"String"
pretty Const
TheWorld = forall a. String -> Doc a
text String
"%theWorld"
pretty Const
WorldType = forall a. String -> Doc a
text String
"prim__World"
pretty Const
VoidType = forall a. String -> Doc a
text String
"Void"
pretty Const
Forgot = forall a. String -> Doc a
text String
"Forgot"
pretty (B8 Word8
w) = forall a. String -> Doc a
text forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Show a => a -> String
show forall a b. (a -> b) -> a -> b
$ Word8
w
pretty (B16 Word16
w) = forall a. String -> Doc a
text forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Show a => a -> String
show forall a b. (a -> b) -> a -> b
$ Word16
w
pretty (B32 Word32
w) = forall a. String -> Doc a
text forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Show a => a -> String
show forall a b. (a -> b) -> a -> b
$ Word32
w
pretty (B64 Word64
w) = forall a. String -> Doc a
text forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Show a => a -> String
show forall a b. (a -> b) -> a -> b
$ Word64
w
constIsType :: Const -> Bool
constIsType :: Const -> Bool
constIsType (I Int
_) = Bool
False
constIsType (BI Integer
_) = Bool
False
constIsType (Fl Double
_) = Bool
False
constIsType (Ch Char
_) = Bool
False
constIsType (Str String
_) = Bool
False
constIsType (B8 Word8
_) = Bool
False
constIsType (B16 Word16
_) = Bool
False
constIsType (B32 Word32
_) = Bool
False
constIsType (B64 Word64
_) = Bool
False
constIsType Const
_ = Bool
True
constDocs :: Const -> String
constDocs :: Const -> String
constDocs c :: Const
c@(AType (ATInt IntTy
ITBig)) = String
"Arbitrary-precision integers"
constDocs c :: Const
c@(AType (ATInt IntTy
ITNative)) = String
"Fixed-precision integers of undefined size"
constDocs c :: Const
c@(AType (ATInt IntTy
ITChar)) = String
"Characters in some unspecified encoding"
constDocs c :: Const
c@(AType ArithTy
ATFloat) = String
"Double-precision floating-point numbers"
constDocs Const
StrType = String
"Strings in some unspecified encoding"
constDocs c :: Const
c@(AType (ATInt (ITFixed NativeTy
IT8))) = String
"Eight bits (unsigned)"
constDocs c :: Const
c@(AType (ATInt (ITFixed NativeTy
IT16))) = String
"Sixteen bits (unsigned)"
constDocs c :: Const
c@(AType (ATInt (ITFixed NativeTy
IT32))) = String
"Thirty-two bits (unsigned)"
constDocs c :: Const
c@(AType (ATInt (ITFixed NativeTy
IT64))) = String
"Sixty-four bits (unsigned)"
constDocs (Fl Double
f) = String
"A float"
constDocs (I Int
i) = String
"A fixed-precision integer"
constDocs (BI Integer
i) = String
"An arbitrary-precision integer"
constDocs (Str String
s) = String
"A string of length " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show (forall (t :: * -> *) a. Foldable t => t a -> Int
length String
s)
constDocs (Ch Char
c) = String
"A character"
constDocs (B8 Word8
w) = String
"The eight-bit value 0x" forall a. [a] -> [a] -> [a]
++
forall a. (Integral a, Show a) => a -> (Int -> Char) -> a -> ShowS
showIntAtBase Word8
16 Int -> Char
intToDigit Word8
w String
""
constDocs (B16 Word16
w) = String
"The sixteen-bit value 0x" forall a. [a] -> [a] -> [a]
++
forall a. (Integral a, Show a) => a -> (Int -> Char) -> a -> ShowS
showIntAtBase Word16
16 Int -> Char
intToDigit Word16
w String
""
constDocs (B32 Word32
w) = String
"The thirty-two-bit value 0x" forall a. [a] -> [a] -> [a]
++
forall a. (Integral a, Show a) => a -> (Int -> Char) -> a -> ShowS
showIntAtBase Word32
16 Int -> Char
intToDigit Word32
w String
""
constDocs (B64 Word64
w) = String
"The sixty-four-bit value 0x" forall a. [a] -> [a] -> [a]
++
forall a. (Integral a, Show a) => a -> (Int -> Char) -> a -> ShowS
showIntAtBase Word64
16 Int -> Char
intToDigit Word64
w String
""
constDocs Const
prim = String
"Undocumented"
data Universe = NullType | UniqueType | AllTypes
deriving (Universe -> Universe -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Universe -> Universe -> Bool
$c/= :: Universe -> Universe -> Bool
== :: Universe -> Universe -> Bool
$c== :: Universe -> Universe -> Bool
Eq, Eq Universe
Universe -> Universe -> Bool
Universe -> Universe -> Ordering
Universe -> Universe -> Universe
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 :: Universe -> Universe -> Universe
$cmin :: Universe -> Universe -> Universe
max :: Universe -> Universe -> Universe
$cmax :: Universe -> Universe -> Universe
>= :: Universe -> Universe -> Bool
$c>= :: Universe -> Universe -> Bool
> :: Universe -> Universe -> Bool
$c> :: Universe -> Universe -> Bool
<= :: Universe -> Universe -> Bool
$c<= :: Universe -> Universe -> Bool
< :: Universe -> Universe -> Bool
$c< :: Universe -> Universe -> Bool
compare :: Universe -> Universe -> Ordering
$ccompare :: Universe -> Universe -> Ordering
Ord, Typeable Universe
Universe -> Constr
Universe -> DataType
(forall b. Data b => b -> b) -> Universe -> Universe
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) -> Universe -> u
forall u. (forall d. Data d => d -> u) -> Universe -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Universe -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Universe -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Universe -> m Universe
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Universe -> m Universe
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Universe
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Universe -> c Universe
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Universe)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Universe)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Universe -> m Universe
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Universe -> m Universe
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Universe -> m Universe
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Universe -> m Universe
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Universe -> m Universe
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Universe -> m Universe
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Universe -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Universe -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> Universe -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Universe -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Universe -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Universe -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Universe -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Universe -> r
gmapT :: (forall b. Data b => b -> b) -> Universe -> Universe
$cgmapT :: (forall b. Data b => b -> b) -> Universe -> Universe
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Universe)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Universe)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Universe)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Universe)
dataTypeOf :: Universe -> DataType
$cdataTypeOf :: Universe -> DataType
toConstr :: Universe -> Constr
$ctoConstr :: Universe -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Universe
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Universe
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Universe -> c Universe
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Universe -> c Universe
Data, forall x. Rep Universe x -> Universe
forall x. Universe -> Rep Universe x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Universe x -> Universe
$cfrom :: forall x. Universe -> Rep Universe x
Generic, Typeable)
instance Show Universe where
show :: Universe -> String
show Universe
UniqueType = String
"UniqueType"
show Universe
NullType = String
"NullType"
show Universe
AllTypes = String
"AnyType"
data Raw = Var Name
| RBind Name (Binder Raw) Raw
| RApp Raw Raw
| RType
| RUType Universe
| RConstant Const
deriving (Int -> Raw -> ShowS
[Raw] -> ShowS
Raw -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Raw] -> ShowS
$cshowList :: [Raw] -> ShowS
show :: Raw -> String
$cshow :: Raw -> String
showsPrec :: Int -> Raw -> ShowS
$cshowsPrec :: Int -> Raw -> ShowS
Show, Raw -> Raw -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Raw -> Raw -> Bool
$c/= :: Raw -> Raw -> Bool
== :: Raw -> Raw -> Bool
$c== :: Raw -> Raw -> Bool
Eq, Eq Raw
Raw -> Raw -> Bool
Raw -> Raw -> Ordering
Raw -> Raw -> Raw
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 :: Raw -> Raw -> Raw
$cmin :: Raw -> Raw -> Raw
max :: Raw -> Raw -> Raw
$cmax :: Raw -> Raw -> Raw
>= :: Raw -> Raw -> Bool
$c>= :: Raw -> Raw -> Bool
> :: Raw -> Raw -> Bool
$c> :: Raw -> Raw -> Bool
<= :: Raw -> Raw -> Bool
$c<= :: Raw -> Raw -> Bool
< :: Raw -> Raw -> Bool
$c< :: Raw -> Raw -> Bool
compare :: Raw -> Raw -> Ordering
$ccompare :: Raw -> Raw -> Ordering
Ord, Typeable Raw
Raw -> Constr
Raw -> DataType
(forall b. Data b => b -> b) -> Raw -> Raw
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) -> Raw -> u
forall u. (forall d. Data d => d -> u) -> Raw -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Raw -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Raw -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Raw -> m Raw
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Raw -> m Raw
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Raw
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Raw -> c Raw
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Raw)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Raw)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Raw -> m Raw
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Raw -> m Raw
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Raw -> m Raw
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Raw -> m Raw
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Raw -> m Raw
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Raw -> m Raw
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Raw -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Raw -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> Raw -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Raw -> [u]
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Raw -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Raw -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Raw -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Raw -> r
gmapT :: (forall b. Data b => b -> b) -> Raw -> Raw
$cgmapT :: (forall b. Data b => b -> b) -> Raw -> Raw
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Raw)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Raw)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Raw)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Raw)
dataTypeOf :: Raw -> DataType
$cdataTypeOf :: Raw -> DataType
toConstr :: Raw -> Constr
$ctoConstr :: Raw -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Raw
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Raw
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Raw -> c Raw
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Raw -> c Raw
Data, forall x. Rep Raw x -> Raw
forall x. Raw -> Rep Raw x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Raw x -> Raw
$cfrom :: forall x. Raw -> Rep Raw x
Generic, Typeable)
instance Sized Raw where
size :: Raw -> Int
size (Var Name
name) = Int
1
size (RBind Name
name Binder Raw
bind Raw
right) = Int
1 forall a. Num a => a -> a -> a
+ forall a. Sized a => a -> Int
size Binder Raw
bind forall a. Num a => a -> a -> a
+ forall a. Sized a => a -> Int
size Raw
right
size (RApp Raw
left Raw
right) = Int
1 forall a. Num a => a -> a -> a
+ forall a. Sized a => a -> Int
size Raw
left forall a. Num a => a -> a -> a
+ forall a. Sized a => a -> Int
size Raw
right
size Raw
RType = Int
1
size (RUType Universe
_) = Int
1
size (RConstant Const
const) = forall a. Sized a => a -> Int
size Const
const
instance Pretty Raw OutputAnnotation where
pretty :: Raw -> Doc OutputAnnotation
pretty = forall a. String -> Doc a
text forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Show a => a -> String
show
data ImplicitInfo = Impl { ImplicitInfo -> Bool
tcimplementation :: Bool, ImplicitInfo -> Bool
toplevel_imp :: Bool,
ImplicitInfo -> Bool
machine_gen :: Bool }
deriving (Int -> ImplicitInfo -> ShowS
[ImplicitInfo] -> ShowS
ImplicitInfo -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ImplicitInfo] -> ShowS
$cshowList :: [ImplicitInfo] -> ShowS
show :: ImplicitInfo -> String
$cshow :: ImplicitInfo -> String
showsPrec :: Int -> ImplicitInfo -> ShowS
$cshowsPrec :: Int -> ImplicitInfo -> ShowS
Show, ImplicitInfo -> ImplicitInfo -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ImplicitInfo -> ImplicitInfo -> Bool
$c/= :: ImplicitInfo -> ImplicitInfo -> Bool
== :: ImplicitInfo -> ImplicitInfo -> Bool
$c== :: ImplicitInfo -> ImplicitInfo -> Bool
Eq, Eq ImplicitInfo
ImplicitInfo -> ImplicitInfo -> Bool
ImplicitInfo -> ImplicitInfo -> Ordering
ImplicitInfo -> ImplicitInfo -> ImplicitInfo
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 :: ImplicitInfo -> ImplicitInfo -> ImplicitInfo
$cmin :: ImplicitInfo -> ImplicitInfo -> ImplicitInfo
max :: ImplicitInfo -> ImplicitInfo -> ImplicitInfo
$cmax :: ImplicitInfo -> ImplicitInfo -> ImplicitInfo
>= :: ImplicitInfo -> ImplicitInfo -> Bool
$c>= :: ImplicitInfo -> ImplicitInfo -> Bool
> :: ImplicitInfo -> ImplicitInfo -> Bool
$c> :: ImplicitInfo -> ImplicitInfo -> Bool
<= :: ImplicitInfo -> ImplicitInfo -> Bool
$c<= :: ImplicitInfo -> ImplicitInfo -> Bool
< :: ImplicitInfo -> ImplicitInfo -> Bool
$c< :: ImplicitInfo -> ImplicitInfo -> Bool
compare :: ImplicitInfo -> ImplicitInfo -> Ordering
$ccompare :: ImplicitInfo -> ImplicitInfo -> Ordering
Ord, Typeable ImplicitInfo
ImplicitInfo -> Constr
ImplicitInfo -> DataType
(forall b. Data b => b -> b) -> ImplicitInfo -> ImplicitInfo
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) -> ImplicitInfo -> u
forall u. (forall d. Data d => d -> u) -> ImplicitInfo -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ImplicitInfo -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ImplicitInfo -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ImplicitInfo -> m ImplicitInfo
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ImplicitInfo -> m ImplicitInfo
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ImplicitInfo
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ImplicitInfo -> c ImplicitInfo
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ImplicitInfo)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ImplicitInfo)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ImplicitInfo -> m ImplicitInfo
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ImplicitInfo -> m ImplicitInfo
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ImplicitInfo -> m ImplicitInfo
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ImplicitInfo -> m ImplicitInfo
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ImplicitInfo -> m ImplicitInfo
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ImplicitInfo -> m ImplicitInfo
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ImplicitInfo -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ImplicitInfo -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> ImplicitInfo -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> ImplicitInfo -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ImplicitInfo -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ImplicitInfo -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ImplicitInfo -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ImplicitInfo -> r
gmapT :: (forall b. Data b => b -> b) -> ImplicitInfo -> ImplicitInfo
$cgmapT :: (forall b. Data b => b -> b) -> ImplicitInfo -> ImplicitInfo
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ImplicitInfo)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ImplicitInfo)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ImplicitInfo)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ImplicitInfo)
dataTypeOf :: ImplicitInfo -> DataType
$cdataTypeOf :: ImplicitInfo -> DataType
toConstr :: ImplicitInfo -> Constr
$ctoConstr :: ImplicitInfo -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ImplicitInfo
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ImplicitInfo
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ImplicitInfo -> c ImplicitInfo
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ImplicitInfo -> c ImplicitInfo
Data, forall x. Rep ImplicitInfo x -> ImplicitInfo
forall x. ImplicitInfo -> Rep ImplicitInfo x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ImplicitInfo x -> ImplicitInfo
$cfrom :: forall x. ImplicitInfo -> Rep ImplicitInfo x
Generic, Typeable)
data Binder b = Lam { forall b. Binder b -> RigCount
binderCount :: RigCount,
forall b. Binder b -> b
binderTy :: !b }
| Pi { binderCount :: RigCount,
forall b. Binder b -> Maybe ImplicitInfo
binderImpl :: Maybe ImplicitInfo,
binderTy :: !b,
forall b. Binder b -> b
binderKind :: !b }
| Let { binderCount :: RigCount,
binderTy :: !b,
forall b. Binder b -> b
binderVal :: b }
| NLet { binderTy :: !b,
binderVal :: b }
| Hole { binderTy :: !b}
| GHole { forall b. Binder b -> Int
envlen :: Int,
forall b. Binder b -> [Name]
localnames :: [Name],
binderTy :: !b}
| Guess { binderTy :: !b,
binderVal :: b }
| PVar { binderCount :: RigCount,
binderTy :: !b }
| PVTy { binderTy :: !b }
deriving (Int -> Binder b -> ShowS
forall b. Show b => Int -> Binder b -> ShowS
forall b. Show b => [Binder b] -> ShowS
forall b. Show b => Binder b -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Binder b] -> ShowS
$cshowList :: forall b. Show b => [Binder b] -> ShowS
show :: Binder b -> String
$cshow :: forall b. Show b => Binder b -> String
showsPrec :: Int -> Binder b -> ShowS
$cshowsPrec :: forall b. Show b => Int -> Binder b -> ShowS
Show, Binder b -> Binder b -> Bool
forall b. Eq b => Binder b -> Binder b -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Binder b -> Binder b -> Bool
$c/= :: forall b. Eq b => Binder b -> Binder b -> Bool
== :: Binder b -> Binder b -> Bool
$c== :: forall b. Eq b => Binder b -> Binder b -> Bool
Eq, Binder b -> Binder b -> Ordering
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
forall {b}. Ord b => Eq (Binder b)
forall b. Ord b => Binder b -> Binder b -> Bool
forall b. Ord b => Binder b -> Binder b -> Ordering
forall b. Ord b => Binder b -> Binder b -> Binder b
min :: Binder b -> Binder b -> Binder b
$cmin :: forall b. Ord b => Binder b -> Binder b -> Binder b
max :: Binder b -> Binder b -> Binder b
$cmax :: forall b. Ord b => Binder b -> Binder b -> Binder b
>= :: Binder b -> Binder b -> Bool
$c>= :: forall b. Ord b => Binder b -> Binder b -> Bool
> :: Binder b -> Binder b -> Bool
$c> :: forall b. Ord b => Binder b -> Binder b -> Bool
<= :: Binder b -> Binder b -> Bool
$c<= :: forall b. Ord b => Binder b -> Binder b -> Bool
< :: Binder b -> Binder b -> Bool
$c< :: forall b. Ord b => Binder b -> Binder b -> Bool
compare :: Binder b -> Binder b -> Ordering
$ccompare :: forall b. Ord b => Binder b -> Binder b -> Ordering
Ord, forall a b. a -> Binder b -> Binder a
forall a b. (a -> b) -> Binder a -> Binder b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: forall a b. a -> Binder b -> Binder a
$c<$ :: forall a b. a -> Binder b -> Binder a
fmap :: forall a b. (a -> b) -> Binder a -> Binder b
$cfmap :: forall a b. (a -> b) -> Binder a -> Binder b
Functor, forall a. Eq a => a -> Binder a -> Bool
forall a. Num a => Binder a -> a
forall a. Ord a => Binder a -> a
forall m. Monoid m => Binder m -> m
forall a. Binder a -> Bool
forall b. Binder b -> Int
forall a. Binder a -> [a]
forall a. (a -> a -> a) -> Binder a -> a
forall m a. Monoid m => (a -> m) -> Binder a -> m
forall b a. (b -> a -> b) -> b -> Binder a -> b
forall a b. (a -> b -> b) -> b -> Binder a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: forall a. Num a => Binder a -> a
$cproduct :: forall a. Num a => Binder a -> a
sum :: forall a. Num a => Binder a -> a
$csum :: forall a. Num a => Binder a -> a
minimum :: forall a. Ord a => Binder a -> a
$cminimum :: forall a. Ord a => Binder a -> a
maximum :: forall a. Ord a => Binder a -> a
$cmaximum :: forall a. Ord a => Binder a -> a
elem :: forall a. Eq a => a -> Binder a -> Bool
$celem :: forall a. Eq a => a -> Binder a -> Bool
length :: forall b. Binder b -> Int
$clength :: forall b. Binder b -> Int
null :: forall a. Binder a -> Bool
$cnull :: forall a. Binder a -> Bool
toList :: forall a. Binder a -> [a]
$ctoList :: forall a. Binder a -> [a]
foldl1 :: forall a. (a -> a -> a) -> Binder a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> Binder a -> a
foldr1 :: forall a. (a -> a -> a) -> Binder a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> Binder a -> a
foldl' :: forall b a. (b -> a -> b) -> b -> Binder a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> Binder a -> b
foldl :: forall b a. (b -> a -> b) -> b -> Binder a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> Binder a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> Binder a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> Binder a -> b
foldr :: forall a b. (a -> b -> b) -> b -> Binder a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> Binder a -> b
foldMap' :: forall m a. Monoid m => (a -> m) -> Binder a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> Binder a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> Binder a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> Binder a -> m
fold :: forall m. Monoid m => Binder m -> m
$cfold :: forall m. Monoid m => Binder m -> m
Foldable, Functor Binder
Foldable Binder
forall (t :: * -> *).
Functor t
-> Foldable t
-> (forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a. Monad m => Binder (m a) -> m (Binder a)
forall (f :: * -> *) a.
Applicative f =>
Binder (f a) -> f (Binder a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Binder a -> m (Binder b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Binder a -> f (Binder b)
sequence :: forall (m :: * -> *) a. Monad m => Binder (m a) -> m (Binder a)
$csequence :: forall (m :: * -> *) a. Monad m => Binder (m a) -> m (Binder a)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Binder a -> m (Binder b)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Binder a -> m (Binder b)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
Binder (f a) -> f (Binder a)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
Binder (f a) -> f (Binder a)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Binder a -> f (Binder b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Binder a -> f (Binder b)
Traversable, Binder b -> Constr
Binder b -> DataType
forall {b}. Data b => Typeable (Binder b)
forall b. Data b => Binder b -> Constr
forall b. Data b => Binder b -> DataType
forall b.
Data b =>
(forall b. Data b => b -> b) -> Binder b -> Binder b
forall b u.
Data b =>
Int -> (forall d. Data d => d -> u) -> Binder b -> u
forall b u.
Data b =>
(forall d. Data d => d -> u) -> Binder b -> [u]
forall b r r'.
Data b =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Binder b -> r
forall b r r'.
Data b =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Binder b -> r
forall b (m :: * -> *).
(Data b, Monad m) =>
(forall d. Data d => d -> m d) -> Binder b -> m (Binder b)
forall b (m :: * -> *).
(Data b, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Binder b -> m (Binder b)
forall b (c :: * -> *).
Data b =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Binder b)
forall b (c :: * -> *).
Data b =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Binder b -> c (Binder b)
forall b (t :: * -> *) (c :: * -> *).
(Data b, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Binder b))
forall b (t :: * -> * -> *) (c :: * -> *).
(Data b, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Binder b))
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 (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Binder b)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Binder b -> c (Binder b)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Binder b))
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Binder b -> m (Binder b)
$cgmapMo :: forall b (m :: * -> *).
(Data b, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Binder b -> m (Binder b)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Binder b -> m (Binder b)
$cgmapMp :: forall b (m :: * -> *).
(Data b, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Binder b -> m (Binder b)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Binder b -> m (Binder b)
$cgmapM :: forall b (m :: * -> *).
(Data b, Monad m) =>
(forall d. Data d => d -> m d) -> Binder b -> m (Binder b)
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Binder b -> u
$cgmapQi :: forall b u.
Data b =>
Int -> (forall d. Data d => d -> u) -> Binder b -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> Binder b -> [u]
$cgmapQ :: forall b u.
Data b =>
(forall d. Data d => d -> u) -> Binder b -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Binder b -> r
$cgmapQr :: forall b r r'.
Data b =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Binder b -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Binder b -> r
$cgmapQl :: forall b r r'.
Data b =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Binder b -> r
gmapT :: (forall b. Data b => b -> b) -> Binder b -> Binder b
$cgmapT :: forall b.
Data b =>
(forall b. Data b => b -> b) -> Binder b -> Binder b
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Binder b))
$cdataCast2 :: forall b (t :: * -> * -> *) (c :: * -> *).
(Data b, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Binder b))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Binder b))
$cdataCast1 :: forall b (t :: * -> *) (c :: * -> *).
(Data b, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Binder b))
dataTypeOf :: Binder b -> DataType
$cdataTypeOf :: forall b. Data b => Binder b -> DataType
toConstr :: Binder b -> Constr
$ctoConstr :: forall b. Data b => Binder b -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Binder b)
$cgunfold :: forall b (c :: * -> *).
Data b =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Binder b)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Binder b -> c (Binder b)
$cgfoldl :: forall b (c :: * -> *).
Data b =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Binder b -> c (Binder b)
Data, forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall b x. Rep (Binder b) x -> Binder b
forall b x. Binder b -> Rep (Binder b) x
$cto :: forall b x. Rep (Binder b) x -> Binder b
$cfrom :: forall b x. Binder b -> Rep (Binder b) x
Generic, Typeable)
instance Sized a => Sized (Binder a) where
size :: Binder a -> Int
size (Lam RigCount
_ a
ty) = Int
1 forall a. Num a => a -> a -> a
+ forall a. Sized a => a -> Int
size a
ty
size (Pi RigCount
_ Maybe ImplicitInfo
_ a
ty a
_) = Int
1 forall a. Num a => a -> a -> a
+ forall a. Sized a => a -> Int
size a
ty
size (Let RigCount
_ a
ty a
val) = Int
1 forall a. Num a => a -> a -> a
+ forall a. Sized a => a -> Int
size a
ty forall a. Num a => a -> a -> a
+ forall a. Sized a => a -> Int
size a
val
size (NLet a
ty a
val) = Int
1 forall a. Num a => a -> a -> a
+ forall a. Sized a => a -> Int
size a
ty forall a. Num a => a -> a -> a
+ forall a. Sized a => a -> Int
size a
val
size (Hole a
ty) = Int
1 forall a. Num a => a -> a -> a
+ forall a. Sized a => a -> Int
size a
ty
size (GHole Int
_ [Name]
_ a
ty) = Int
1 forall a. Num a => a -> a -> a
+ forall a. Sized a => a -> Int
size a
ty
size (Guess a
ty a
val) = Int
1 forall a. Num a => a -> a -> a
+ forall a. Sized a => a -> Int
size a
ty forall a. Num a => a -> a -> a
+ forall a. Sized a => a -> Int
size a
val
size (PVar RigCount
_ a
ty) = Int
1 forall a. Num a => a -> a -> a
+ forall a. Sized a => a -> Int
size a
ty
size (PVTy a
ty) = Int
1 forall a. Num a => a -> a -> a
+ forall a. Sized a => a -> Int
size a
ty
fmapMB :: Monad m => (a -> m b) -> Binder a -> m (Binder b)
fmapMB :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Binder a -> m (Binder b)
fmapMB a -> m b
f (Let RigCount
c a
t a
v) = forall (m :: * -> *) a1 a2 r.
Monad m =>
(a1 -> a2 -> r) -> m a1 -> m a2 -> m r
liftM2 (forall b. RigCount -> b -> b -> Binder b
Let RigCount
c) (a -> m b
f a
t) (a -> m b
f a
v)
fmapMB a -> m b
f (NLet a
t a
v) = forall (m :: * -> *) a1 a2 r.
Monad m =>
(a1 -> a2 -> r) -> m a1 -> m a2 -> m r
liftM2 forall b. b -> b -> Binder b
NLet (a -> m b
f a
t) (a -> m b
f a
v)
fmapMB a -> m b
f (Guess a
t a
v) = forall (m :: * -> *) a1 a2 r.
Monad m =>
(a1 -> a2 -> r) -> m a1 -> m a2 -> m r
liftM2 forall b. b -> b -> Binder b
Guess (a -> m b
f a
t) (a -> m b
f a
v)
fmapMB a -> m b
f (Lam RigCount
c a
t) = forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM (forall b. RigCount -> b -> Binder b
Lam RigCount
c) (a -> m b
f a
t)
fmapMB a -> m b
f (Pi RigCount
c Maybe ImplicitInfo
i a
t a
k) = forall (m :: * -> *) a1 a2 r.
Monad m =>
(a1 -> a2 -> r) -> m a1 -> m a2 -> m r
liftM2 (forall b. RigCount -> Maybe ImplicitInfo -> b -> b -> Binder b
Pi RigCount
c Maybe ImplicitInfo
i) (a -> m b
f a
t) (a -> m b
f a
k)
fmapMB a -> m b
f (Hole a
t) = forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM forall b. b -> Binder b
Hole (a -> m b
f a
t)
fmapMB a -> m b
f (GHole Int
i [Name]
ns a
t) = forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM (forall b. Int -> [Name] -> b -> Binder b
GHole Int
i [Name]
ns) (a -> m b
f a
t)
fmapMB a -> m b
f (PVar RigCount
c a
t) = forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM (forall b. RigCount -> b -> Binder b
PVar RigCount
c) (a -> m b
f a
t)
fmapMB a -> m b
f (PVTy a
t) = forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM forall b. b -> Binder b
PVTy (a -> m b
f a
t)
raw_apply :: Raw -> [Raw] -> Raw
raw_apply :: Raw -> [Raw] -> Raw
raw_apply Raw
f [] = Raw
f
raw_apply Raw
f (Raw
a : [Raw]
as) = Raw -> [Raw] -> Raw
raw_apply (Raw -> Raw -> Raw
RApp Raw
f Raw
a) [Raw]
as
raw_unapply :: Raw -> (Raw, [Raw])
raw_unapply :: Raw -> (Raw, [Raw])
raw_unapply Raw
t = [Raw] -> Raw -> (Raw, [Raw])
ua [] Raw
t where
ua :: [Raw] -> Raw -> (Raw, [Raw])
ua [Raw]
args (RApp Raw
f Raw
a) = [Raw] -> Raw -> (Raw, [Raw])
ua (Raw
aforall a. a -> [a] -> [a]
:[Raw]
args) Raw
f
ua [Raw]
args Raw
t = (Raw
t, [Raw]
args)
internalNS :: String
internalNS :: String
internalNS = String
"(internal)"
data UExp = UVar String Int
| UVal Int
deriving (UExp -> UExp -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: UExp -> UExp -> Bool
$c/= :: UExp -> UExp -> Bool
== :: UExp -> UExp -> Bool
$c== :: UExp -> UExp -> Bool
Eq, Eq UExp
UExp -> UExp -> Bool
UExp -> UExp -> Ordering
UExp -> UExp -> UExp
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 :: UExp -> UExp -> UExp
$cmin :: UExp -> UExp -> UExp
max :: UExp -> UExp -> UExp
$cmax :: UExp -> UExp -> UExp
>= :: UExp -> UExp -> Bool
$c>= :: UExp -> UExp -> Bool
> :: UExp -> UExp -> Bool
$c> :: UExp -> UExp -> Bool
<= :: UExp -> UExp -> Bool
$c<= :: UExp -> UExp -> Bool
< :: UExp -> UExp -> Bool
$c< :: UExp -> UExp -> Bool
compare :: UExp -> UExp -> Ordering
$ccompare :: UExp -> UExp -> Ordering
Ord, Typeable UExp
UExp -> Constr
UExp -> DataType
(forall b. Data b => b -> b) -> UExp -> UExp
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) -> UExp -> u
forall u. (forall d. Data d => d -> u) -> UExp -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UExp -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UExp -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> UExp -> m UExp
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> UExp -> m UExp
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c UExp
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> UExp -> c UExp
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c UExp)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c UExp)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> UExp -> m UExp
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> UExp -> m UExp
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> UExp -> m UExp
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> UExp -> m UExp
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> UExp -> m UExp
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> UExp -> m UExp
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> UExp -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> UExp -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> UExp -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> UExp -> [u]
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UExp -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UExp -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UExp -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UExp -> r
gmapT :: (forall b. Data b => b -> b) -> UExp -> UExp
$cgmapT :: (forall b. Data b => b -> b) -> UExp -> UExp
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c UExp)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c UExp)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c UExp)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c UExp)
dataTypeOf :: UExp -> DataType
$cdataTypeOf :: UExp -> DataType
toConstr :: UExp -> Constr
$ctoConstr :: UExp -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c UExp
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c UExp
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> UExp -> c UExp
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> UExp -> c UExp
Data, forall x. Rep UExp x -> UExp
forall x. UExp -> Rep UExp x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep UExp x -> UExp
$cfrom :: forall x. UExp -> Rep UExp x
Generic, Typeable)
instance Sized UExp where
size :: UExp -> Int
size UExp
_ = Int
1
instance Show UExp where
show :: UExp -> String
show (UVar String
ns Int
x)
| Int
x forall a. Ord a => a -> a -> Bool
< Int
26 = String
ns forall a. [a] -> [a] -> [a]
++ String
"." forall a. [a] -> [a] -> [a]
++ [forall a. Enum a => Int -> a
toEnum (Int
x forall a. Num a => a -> a -> a
+ forall a. Enum a => a -> Int
fromEnum Char
'a')]
| Bool
otherwise = String
ns forall a. [a] -> [a] -> [a]
++ String
"." forall a. [a] -> [a] -> [a]
++ forall a. Enum a => Int -> a
toEnum ((Int
x forall a. Integral a => a -> a -> a
`mod` Int
26) forall a. Num a => a -> a -> a
+ forall a. Enum a => a -> Int
fromEnum Char
'a') forall a. a -> [a] -> [a]
: forall a. Show a => a -> String
show (Int
x forall a. Integral a => a -> a -> a
`div` Int
26)
show (UVal Int
x) = forall a. Show a => a -> String
show Int
x
data UConstraint = ULT UExp UExp
| ULE UExp UExp
deriving (UConstraint -> UConstraint -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: UConstraint -> UConstraint -> Bool
$c/= :: UConstraint -> UConstraint -> Bool
== :: UConstraint -> UConstraint -> Bool
$c== :: UConstraint -> UConstraint -> Bool
Eq, Eq UConstraint
UConstraint -> UConstraint -> Bool
UConstraint -> UConstraint -> Ordering
UConstraint -> UConstraint -> UConstraint
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 :: UConstraint -> UConstraint -> UConstraint
$cmin :: UConstraint -> UConstraint -> UConstraint
max :: UConstraint -> UConstraint -> UConstraint
$cmax :: UConstraint -> UConstraint -> UConstraint
>= :: UConstraint -> UConstraint -> Bool
$c>= :: UConstraint -> UConstraint -> Bool
> :: UConstraint -> UConstraint -> Bool
$c> :: UConstraint -> UConstraint -> Bool
<= :: UConstraint -> UConstraint -> Bool
$c<= :: UConstraint -> UConstraint -> Bool
< :: UConstraint -> UConstraint -> Bool
$c< :: UConstraint -> UConstraint -> Bool
compare :: UConstraint -> UConstraint -> Ordering
$ccompare :: UConstraint -> UConstraint -> Ordering
Ord, Typeable UConstraint
UConstraint -> Constr
UConstraint -> DataType
(forall b. Data b => b -> b) -> UConstraint -> UConstraint
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) -> UConstraint -> u
forall u. (forall d. Data d => d -> u) -> UConstraint -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> UConstraint -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> UConstraint -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> UConstraint -> m UConstraint
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> UConstraint -> m UConstraint
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c UConstraint
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> UConstraint -> c UConstraint
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c UConstraint)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c UConstraint)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> UConstraint -> m UConstraint
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> UConstraint -> m UConstraint
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> UConstraint -> m UConstraint
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> UConstraint -> m UConstraint
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> UConstraint -> m UConstraint
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> UConstraint -> m UConstraint
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> UConstraint -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> UConstraint -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> UConstraint -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> UConstraint -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> UConstraint -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> UConstraint -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> UConstraint -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> UConstraint -> r
gmapT :: (forall b. Data b => b -> b) -> UConstraint -> UConstraint
$cgmapT :: (forall b. Data b => b -> b) -> UConstraint -> UConstraint
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c UConstraint)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c UConstraint)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c UConstraint)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c UConstraint)
dataTypeOf :: UConstraint -> DataType
$cdataTypeOf :: UConstraint -> DataType
toConstr :: UConstraint -> Constr
$ctoConstr :: UConstraint -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c UConstraint
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c UConstraint
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> UConstraint -> c UConstraint
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> UConstraint -> c UConstraint
Data, forall x. Rep UConstraint x -> UConstraint
forall x. UConstraint -> Rep UConstraint x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep UConstraint x -> UConstraint
$cfrom :: forall x. UConstraint -> Rep UConstraint x
Generic, Typeable)
data ConstraintFC = ConstraintFC { ConstraintFC -> UConstraint
uconstraint :: UConstraint,
ConstraintFC -> FC
ufc :: FC }
deriving (Int -> ConstraintFC -> ShowS
[ConstraintFC] -> ShowS
ConstraintFC -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ConstraintFC] -> ShowS
$cshowList :: [ConstraintFC] -> ShowS
show :: ConstraintFC -> String
$cshow :: ConstraintFC -> String
showsPrec :: Int -> ConstraintFC -> ShowS
$cshowsPrec :: Int -> ConstraintFC -> ShowS
Show, Typeable ConstraintFC
ConstraintFC -> Constr
ConstraintFC -> DataType
(forall b. Data b => b -> b) -> ConstraintFC -> ConstraintFC
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) -> ConstraintFC -> u
forall u. (forall d. Data d => d -> u) -> ConstraintFC -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ConstraintFC -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ConstraintFC -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ConstraintFC -> m ConstraintFC
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ConstraintFC -> m ConstraintFC
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ConstraintFC
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ConstraintFC -> c ConstraintFC
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ConstraintFC)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ConstraintFC)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ConstraintFC -> m ConstraintFC
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ConstraintFC -> m ConstraintFC
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ConstraintFC -> m ConstraintFC
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ConstraintFC -> m ConstraintFC
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ConstraintFC -> m ConstraintFC
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ConstraintFC -> m ConstraintFC
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ConstraintFC -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ConstraintFC -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> ConstraintFC -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> ConstraintFC -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ConstraintFC -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ConstraintFC -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ConstraintFC -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ConstraintFC -> r
gmapT :: (forall b. Data b => b -> b) -> ConstraintFC -> ConstraintFC
$cgmapT :: (forall b. Data b => b -> b) -> ConstraintFC -> ConstraintFC
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ConstraintFC)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ConstraintFC)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ConstraintFC)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ConstraintFC)
dataTypeOf :: ConstraintFC -> DataType
$cdataTypeOf :: ConstraintFC -> DataType
toConstr :: ConstraintFC -> Constr
$ctoConstr :: ConstraintFC -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ConstraintFC
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ConstraintFC
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ConstraintFC -> c ConstraintFC
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ConstraintFC -> c ConstraintFC
Data, forall x. Rep ConstraintFC x -> ConstraintFC
forall x. ConstraintFC -> Rep ConstraintFC x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ConstraintFC x -> ConstraintFC
$cfrom :: forall x. ConstraintFC -> Rep ConstraintFC x
Generic, Typeable)
instance Eq ConstraintFC where
ConstraintFC
x == :: ConstraintFC -> ConstraintFC -> Bool
== ConstraintFC
y = ConstraintFC -> UConstraint
uconstraint ConstraintFC
x forall a. Eq a => a -> a -> Bool
== ConstraintFC -> UConstraint
uconstraint ConstraintFC
y
instance Ord ConstraintFC where
compare :: ConstraintFC -> ConstraintFC -> Ordering
compare ConstraintFC
x ConstraintFC
y = forall a. Ord a => a -> a -> Ordering
compare (ConstraintFC -> UConstraint
uconstraint ConstraintFC
x) (ConstraintFC -> UConstraint
uconstraint ConstraintFC
y)
instance Show UConstraint where
show :: UConstraint -> String
show (ULT UExp
x UExp
y) = forall a. Show a => a -> String
show UExp
x forall a. [a] -> [a] -> [a]
++ String
" < " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show UExp
y
show (ULE UExp
x UExp
y) = forall a. Show a => a -> String
show UExp
x forall a. [a] -> [a] -> [a]
++ String
" <= " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show UExp
y
type UCs = (Int, [UConstraint])
data NameType = Bound
| Ref
| DCon {NameType -> Int
nt_tag :: Int, NameType -> Int
nt_arity :: Int, NameType -> Bool
nt_unique :: Bool}
| TCon {nt_tag :: Int, nt_arity :: Int}
deriving (Int -> NameType -> ShowS
[NameType] -> ShowS
NameType -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [NameType] -> ShowS
$cshowList :: [NameType] -> ShowS
show :: NameType -> String
$cshow :: NameType -> String
showsPrec :: Int -> NameType -> ShowS
$cshowsPrec :: Int -> NameType -> ShowS
Show, Eq NameType
NameType -> NameType -> Bool
NameType -> NameType -> Ordering
NameType -> NameType -> NameType
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 :: NameType -> NameType -> NameType
$cmin :: NameType -> NameType -> NameType
max :: NameType -> NameType -> NameType
$cmax :: NameType -> NameType -> NameType
>= :: NameType -> NameType -> Bool
$c>= :: NameType -> NameType -> Bool
> :: NameType -> NameType -> Bool
$c> :: NameType -> NameType -> Bool
<= :: NameType -> NameType -> Bool
$c<= :: NameType -> NameType -> Bool
< :: NameType -> NameType -> Bool
$c< :: NameType -> NameType -> Bool
compare :: NameType -> NameType -> Ordering
$ccompare :: NameType -> NameType -> Ordering
Ord, Typeable NameType
NameType -> Constr
NameType -> DataType
(forall b. Data b => b -> b) -> NameType -> NameType
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) -> NameType -> u
forall u. (forall d. Data d => d -> u) -> NameType -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NameType -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NameType -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> NameType -> m NameType
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NameType -> m NameType
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c NameType
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NameType -> c NameType
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c NameType)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NameType)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NameType -> m NameType
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NameType -> m NameType
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NameType -> m NameType
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NameType -> m NameType
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> NameType -> m NameType
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> NameType -> m NameType
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> NameType -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> NameType -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> NameType -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> NameType -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NameType -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NameType -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NameType -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NameType -> r
gmapT :: (forall b. Data b => b -> b) -> NameType -> NameType
$cgmapT :: (forall b. Data b => b -> b) -> NameType -> NameType
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NameType)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NameType)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c NameType)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c NameType)
dataTypeOf :: NameType -> DataType
$cdataTypeOf :: NameType -> DataType
toConstr :: NameType -> Constr
$ctoConstr :: NameType -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c NameType
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c NameType
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NameType -> c NameType
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NameType -> c NameType
Data, forall x. Rep NameType x -> NameType
forall x. NameType -> Rep NameType x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep NameType x -> NameType
$cfrom :: forall x. NameType -> Rep NameType x
Generic, Typeable)
instance Sized NameType where
size :: NameType -> Int
size NameType
_ = Int
1
instance Pretty NameType OutputAnnotation where
pretty :: NameType -> Doc OutputAnnotation
pretty = forall a. String -> Doc a
text forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Show a => a -> String
show
instance Eq NameType where
NameType
Bound == :: NameType -> NameType -> Bool
== NameType
Bound = Bool
True
NameType
Ref == NameType
Ref = Bool
True
DCon Int
_ Int
a Bool
_ == DCon Int
_ Int
b Bool
_ = (Int
a forall a. Eq a => a -> a -> Bool
== Int
b)
TCon Int
_ Int
a == TCon Int
_ Int
b = (Int
a forall a. Eq a => a -> a -> Bool
== Int
b)
NameType
_ == NameType
_ = Bool
False
data AppStatus n = Complete
| MaybeHoles
| Holes [n]
deriving (AppStatus n -> AppStatus n -> Bool
forall n. Eq n => AppStatus n -> AppStatus n -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: AppStatus n -> AppStatus n -> Bool
$c/= :: forall n. Eq n => AppStatus n -> AppStatus n -> Bool
== :: AppStatus n -> AppStatus n -> Bool
$c== :: forall n. Eq n => AppStatus n -> AppStatus n -> Bool
Eq, AppStatus n -> AppStatus n -> Bool
AppStatus n -> AppStatus n -> Ordering
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
forall {n}. Ord n => Eq (AppStatus n)
forall n. Ord n => AppStatus n -> AppStatus n -> Bool
forall n. Ord n => AppStatus n -> AppStatus n -> Ordering
forall n. Ord n => AppStatus n -> AppStatus n -> AppStatus n
min :: AppStatus n -> AppStatus n -> AppStatus n
$cmin :: forall n. Ord n => AppStatus n -> AppStatus n -> AppStatus n
max :: AppStatus n -> AppStatus n -> AppStatus n
$cmax :: forall n. Ord n => AppStatus n -> AppStatus n -> AppStatus n
>= :: AppStatus n -> AppStatus n -> Bool
$c>= :: forall n. Ord n => AppStatus n -> AppStatus n -> Bool
> :: AppStatus n -> AppStatus n -> Bool
$c> :: forall n. Ord n => AppStatus n -> AppStatus n -> Bool
<= :: AppStatus n -> AppStatus n -> Bool
$c<= :: forall n. Ord n => AppStatus n -> AppStatus n -> Bool
< :: AppStatus n -> AppStatus n -> Bool
$c< :: forall n. Ord n => AppStatus n -> AppStatus n -> Bool
compare :: AppStatus n -> AppStatus n -> Ordering
$ccompare :: forall n. Ord n => AppStatus n -> AppStatus n -> Ordering
Ord, forall a b. a -> AppStatus b -> AppStatus a
forall a b. (a -> b) -> AppStatus a -> AppStatus b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: forall a b. a -> AppStatus b -> AppStatus a
$c<$ :: forall a b. a -> AppStatus b -> AppStatus a
fmap :: forall a b. (a -> b) -> AppStatus a -> AppStatus b
$cfmap :: forall a b. (a -> b) -> AppStatus a -> AppStatus b
Functor, AppStatus n -> Constr
AppStatus n -> DataType
forall {n}. Data n => Typeable (AppStatus n)
forall n. Data n => AppStatus n -> Constr
forall n. Data n => AppStatus n -> DataType
forall n.
Data n =>
(forall b. Data b => b -> b) -> AppStatus n -> AppStatus n
forall n u.
Data n =>
Int -> (forall d. Data d => d -> u) -> AppStatus n -> u
forall n u.
Data n =>
(forall d. Data d => d -> u) -> AppStatus n -> [u]
forall n r r'.
Data n =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> AppStatus n -> r
forall n r r'.
Data n =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> AppStatus n -> r
forall n (m :: * -> *).
(Data n, Monad m) =>
(forall d. Data d => d -> m d) -> AppStatus n -> m (AppStatus n)
forall n (m :: * -> *).
(Data n, MonadPlus m) =>
(forall d. Data d => d -> m d) -> AppStatus n -> m (AppStatus n)
forall n (c :: * -> *).
Data n =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (AppStatus n)
forall n (c :: * -> *).
Data n =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> AppStatus n -> c (AppStatus n)
forall n (t :: * -> *) (c :: * -> *).
(Data n, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (AppStatus n))
forall n (t :: * -> * -> *) (c :: * -> *).
(Data n, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (AppStatus n))
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 (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (AppStatus n)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> AppStatus n -> c (AppStatus n)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (AppStatus n))
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> AppStatus n -> m (AppStatus n)
$cgmapMo :: forall n (m :: * -> *).
(Data n, MonadPlus m) =>
(forall d. Data d => d -> m d) -> AppStatus n -> m (AppStatus n)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> AppStatus n -> m (AppStatus n)
$cgmapMp :: forall n (m :: * -> *).
(Data n, MonadPlus m) =>
(forall d. Data d => d -> m d) -> AppStatus n -> m (AppStatus n)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> AppStatus n -> m (AppStatus n)
$cgmapM :: forall n (m :: * -> *).
(Data n, Monad m) =>
(forall d. Data d => d -> m d) -> AppStatus n -> m (AppStatus n)
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> AppStatus n -> u
$cgmapQi :: forall n u.
Data n =>
Int -> (forall d. Data d => d -> u) -> AppStatus n -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> AppStatus n -> [u]
$cgmapQ :: forall n u.
Data n =>
(forall d. Data d => d -> u) -> AppStatus n -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> AppStatus n -> r
$cgmapQr :: forall n r r'.
Data n =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> AppStatus n -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> AppStatus n -> r
$cgmapQl :: forall n r r'.
Data n =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> AppStatus n -> r
gmapT :: (forall b. Data b => b -> b) -> AppStatus n -> AppStatus n
$cgmapT :: forall n.
Data n =>
(forall b. Data b => b -> b) -> AppStatus n -> AppStatus n
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (AppStatus n))
$cdataCast2 :: forall n (t :: * -> * -> *) (c :: * -> *).
(Data n, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (AppStatus n))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (AppStatus n))
$cdataCast1 :: forall n (t :: * -> *) (c :: * -> *).
(Data n, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (AppStatus n))
dataTypeOf :: AppStatus n -> DataType
$cdataTypeOf :: forall n. Data n => AppStatus n -> DataType
toConstr :: AppStatus n -> Constr
$ctoConstr :: forall n. Data n => AppStatus n -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (AppStatus n)
$cgunfold :: forall n (c :: * -> *).
Data n =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (AppStatus n)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> AppStatus n -> c (AppStatus n)
$cgfoldl :: forall n (c :: * -> *).
Data n =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> AppStatus n -> c (AppStatus n)
Data, forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall n x. Rep (AppStatus n) x -> AppStatus n
forall n x. AppStatus n -> Rep (AppStatus n) x
$cto :: forall n x. Rep (AppStatus n) x -> AppStatus n
$cfrom :: forall n x. AppStatus n -> Rep (AppStatus n) x
Generic, Typeable, Int -> AppStatus n -> ShowS
forall n. Show n => Int -> AppStatus n -> ShowS
forall n. Show n => [AppStatus n] -> ShowS
forall n. Show n => AppStatus n -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [AppStatus n] -> ShowS
$cshowList :: forall n. Show n => [AppStatus n] -> ShowS
show :: AppStatus n -> String
$cshow :: forall n. Show n => AppStatus n -> String
showsPrec :: Int -> AppStatus n -> ShowS
$cshowsPrec :: forall n. Show n => Int -> AppStatus n -> ShowS
Show)
data TT n = P NameType n (TT n)
| V !Int
| Bind n !(Binder (TT n)) (TT n)
| App (AppStatus n) !(TT n) (TT n)
| Constant Const
| Proj (TT n) !Int
| Erased
| Impossible
| Inferred (TT n)
| TType UExp
| UType Universe
deriving (TT n -> TT n -> Ordering
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
forall {n}. Ord n => Eq (TT n)
forall n. Ord n => TT n -> TT n -> Bool
forall n. Ord n => TT n -> TT n -> Ordering
forall n. Ord n => TT n -> TT n -> TT n
min :: TT n -> TT n -> TT n
$cmin :: forall n. Ord n => TT n -> TT n -> TT n
max :: TT n -> TT n -> TT n
$cmax :: forall n. Ord n => TT n -> TT n -> TT n
>= :: TT n -> TT n -> Bool
$c>= :: forall n. Ord n => TT n -> TT n -> Bool
> :: TT n -> TT n -> Bool
$c> :: forall n. Ord n => TT n -> TT n -> Bool
<= :: TT n -> TT n -> Bool
$c<= :: forall n. Ord n => TT n -> TT n -> Bool
< :: TT n -> TT n -> Bool
$c< :: forall n. Ord n => TT n -> TT n -> Bool
compare :: TT n -> TT n -> Ordering
$ccompare :: forall n. Ord n => TT n -> TT n -> Ordering
Ord, forall a b. a -> TT b -> TT a
forall a b. (a -> b) -> TT a -> TT b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: forall a b. a -> TT b -> TT a
$c<$ :: forall a b. a -> TT b -> TT a
fmap :: forall a b. (a -> b) -> TT a -> TT b
$cfmap :: forall a b. (a -> b) -> TT a -> TT b
Functor, TT n -> Constr
TT n -> DataType
forall {n}. Data n => Typeable (TT n)
forall n. Data n => TT n -> Constr
forall n. Data n => TT n -> DataType
forall n. Data n => (forall b. Data b => b -> b) -> TT n -> TT n
forall n u.
Data n =>
Int -> (forall d. Data d => d -> u) -> TT n -> u
forall n u. Data n => (forall d. Data d => d -> u) -> TT n -> [u]
forall n r r'.
Data n =>
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TT n -> r
forall n r r'.
Data n =>
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TT n -> r
forall n (m :: * -> *).
(Data n, Monad m) =>
(forall d. Data d => d -> m d) -> TT n -> m (TT n)
forall n (m :: * -> *).
(Data n, MonadPlus m) =>
(forall d. Data d => d -> m d) -> TT n -> m (TT n)
forall n (c :: * -> *).
Data n =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (TT n)
forall n (c :: * -> *).
Data n =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TT n -> c (TT n)
forall n (t :: * -> *) (c :: * -> *).
(Data n, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (TT n))
forall n (t :: * -> * -> *) (c :: * -> *).
(Data n, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (TT n))
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 (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (TT n)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TT n -> c (TT n)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (TT n))
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TT n -> m (TT n)
$cgmapMo :: forall n (m :: * -> *).
(Data n, MonadPlus m) =>
(forall d. Data d => d -> m d) -> TT n -> m (TT n)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TT n -> m (TT n)
$cgmapMp :: forall n (m :: * -> *).
(Data n, MonadPlus m) =>
(forall d. Data d => d -> m d) -> TT n -> m (TT n)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TT n -> m (TT n)
$cgmapM :: forall n (m :: * -> *).
(Data n, Monad m) =>
(forall d. Data d => d -> m d) -> TT n -> m (TT n)
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> TT n -> u
$cgmapQi :: forall n u.
Data n =>
Int -> (forall d. Data d => d -> u) -> TT n -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> TT n -> [u]
$cgmapQ :: forall n u. Data n => (forall d. Data d => d -> u) -> TT n -> [u]
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TT n -> r
$cgmapQr :: forall n r r'.
Data n =>
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TT n -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TT n -> r
$cgmapQl :: forall n r r'.
Data n =>
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TT n -> r
gmapT :: (forall b. Data b => b -> b) -> TT n -> TT n
$cgmapT :: forall n. Data n => (forall b. Data b => b -> b) -> TT n -> TT n
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (TT n))
$cdataCast2 :: forall n (t :: * -> * -> *) (c :: * -> *).
(Data n, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (TT n))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (TT n))
$cdataCast1 :: forall n (t :: * -> *) (c :: * -> *).
(Data n, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (TT n))
dataTypeOf :: TT n -> DataType
$cdataTypeOf :: forall n. Data n => TT n -> DataType
toConstr :: TT n -> Constr
$ctoConstr :: forall n. Data n => TT n -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (TT n)
$cgunfold :: forall n (c :: * -> *).
Data n =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (TT n)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TT n -> c (TT n)
$cgfoldl :: forall n (c :: * -> *).
Data n =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TT n -> c (TT n)
Data, forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall n x. Rep (TT n) x -> TT n
forall n x. TT n -> Rep (TT n) x
$cto :: forall n x. Rep (TT n) x -> TT n
$cfrom :: forall n x. TT n -> Rep (TT n) x
Generic, Typeable)
class TermSize a where
termsize :: Name -> a -> Int
instance TermSize a => TermSize [a] where
termsize :: Name -> [a] -> Int
termsize Name
n [] = Int
0
termsize Name
n (a
x : [a]
xs) = forall a. TermSize a => Name -> a -> Int
termsize Name
n a
x forall a. Num a => a -> a -> a
+ forall a. TermSize a => Name -> a -> Int
termsize Name
n [a]
xs
instance TermSize (TT Name) where
termsize :: Name -> TT Name -> Int
termsize Name
n (P NameType
_ Name
n' TT Name
_)
| Name
n' forall a. Eq a => a -> a -> Bool
== Name
n = Int
1000000
| Name -> Bool
caseName Name
n' = Int
1000000
| Bool
otherwise = Int
1
termsize Name
n (V Int
_) = Int
1
termsize Name
n (Bind Name
n' (Let RigCount
c TT Name
t TT Name
v) TT Name
sc)
= let rn :: Name
rn = if Name
n forall a. Eq a => a -> a -> Bool
== Name
n' then Int -> String -> Name
sMN Int
0 String
"noname" else Name
n in
forall a. TermSize a => Name -> a -> Int
termsize Name
rn TT Name
v forall a. Num a => a -> a -> a
+ forall a. TermSize a => Name -> a -> Int
termsize Name
rn TT Name
sc
termsize Name
n (Bind Name
n' Binder (TT Name)
b TT Name
sc)
= let rn :: Name
rn = if Name
n forall a. Eq a => a -> a -> Bool
== Name
n' then Int -> String -> Name
sMN Int
0 String
"noname" else Name
n in
forall a. TermSize a => Name -> a -> Int
termsize Name
rn TT Name
sc
termsize Name
n (App AppStatus Name
_ TT Name
f TT Name
a) = forall a. TermSize a => Name -> a -> Int
termsize Name
n TT Name
f forall a. Num a => a -> a -> a
+ forall a. TermSize a => Name -> a -> Int
termsize Name
n TT Name
a
termsize Name
n (Proj TT Name
t Int
i) = forall a. TermSize a => Name -> a -> Int
termsize Name
n TT Name
t
termsize Name
n TT Name
_ = Int
1
instance Sized Universe where
size :: Universe -> Int
size Universe
u = Int
1
instance Sized a => Sized (TT a) where
size :: TT a -> Int
size (P NameType
name a
n TT a
trm) = Int
1 forall a. Num a => a -> a -> a
+ forall a. Sized a => a -> Int
size NameType
name forall a. Num a => a -> a -> a
+ forall a. Sized a => a -> Int
size a
n forall a. Num a => a -> a -> a
+ forall a. Sized a => a -> Int
size TT a
trm
size (V Int
v) = Int
1
size (Bind a
nm Binder (TT a)
binder TT a
bdy) = Int
1 forall a. Num a => a -> a -> a
+ forall a. Sized a => a -> Int
size a
nm forall a. Num a => a -> a -> a
+ forall a. Sized a => a -> Int
size Binder (TT a)
binder forall a. Num a => a -> a -> a
+ forall a. Sized a => a -> Int
size TT a
bdy
size (App AppStatus a
_ TT a
l TT a
r) = Int
1 forall a. Num a => a -> a -> a
+ forall a. Sized a => a -> Int
size TT a
l forall a. Num a => a -> a -> a
+ forall a. Sized a => a -> Int
size TT a
r
size (Constant Const
c) = forall a. Sized a => a -> Int
size Const
c
size TT a
Erased = Int
1
size (TType UExp
u) = Int
1 forall a. Num a => a -> a -> a
+ forall a. Sized a => a -> Int
size UExp
u
size (Proj TT a
a Int
_) = Int
1 forall a. Num a => a -> a -> a
+ forall a. Sized a => a -> Int
size TT a
a
size TT a
Impossible = Int
1
size (Inferred TT a
t) = forall a. Sized a => a -> Int
size TT a
t
size (UType Universe
u) = Int
1 forall a. Num a => a -> a -> a
+ forall a. Sized a => a -> Int
size Universe
u
instance Pretty a o => Pretty (TT a) o where
pretty :: TT a -> Doc o
pretty TT a
_ = forall a. String -> Doc a
text String
"test"
data RigCount = Rig0 | Rig1 | RigW
deriving (Int -> RigCount -> ShowS
[RigCount] -> ShowS
RigCount -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [RigCount] -> ShowS
$cshowList :: [RigCount] -> ShowS
show :: RigCount -> String
$cshow :: RigCount -> String
showsPrec :: Int -> RigCount -> ShowS
$cshowsPrec :: Int -> RigCount -> ShowS
Show, RigCount -> RigCount -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RigCount -> RigCount -> Bool
$c/= :: RigCount -> RigCount -> Bool
== :: RigCount -> RigCount -> Bool
$c== :: RigCount -> RigCount -> Bool
Eq, Eq RigCount
RigCount -> RigCount -> Bool
RigCount -> RigCount -> Ordering
RigCount -> RigCount -> RigCount
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 :: RigCount -> RigCount -> RigCount
$cmin :: RigCount -> RigCount -> RigCount
max :: RigCount -> RigCount -> RigCount
$cmax :: RigCount -> RigCount -> RigCount
>= :: RigCount -> RigCount -> Bool
$c>= :: RigCount -> RigCount -> Bool
> :: RigCount -> RigCount -> Bool
$c> :: RigCount -> RigCount -> Bool
<= :: RigCount -> RigCount -> Bool
$c<= :: RigCount -> RigCount -> Bool
< :: RigCount -> RigCount -> Bool
$c< :: RigCount -> RigCount -> Bool
compare :: RigCount -> RigCount -> Ordering
$ccompare :: RigCount -> RigCount -> Ordering
Ord, Typeable RigCount
RigCount -> Constr
RigCount -> DataType
(forall b. Data b => b -> b) -> RigCount -> RigCount
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) -> RigCount -> u
forall u. (forall d. Data d => d -> u) -> RigCount -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> RigCount -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> RigCount -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> RigCount -> m RigCount
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RigCount -> m RigCount
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c RigCount
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RigCount -> c RigCount
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c RigCount)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RigCount)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RigCount -> m RigCount
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RigCount -> m RigCount
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RigCount -> m RigCount
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RigCount -> m RigCount
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> RigCount -> m RigCount
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> RigCount -> m RigCount
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> RigCount -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> RigCount -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> RigCount -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> RigCount -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> RigCount -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> RigCount -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> RigCount -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> RigCount -> r
gmapT :: (forall b. Data b => b -> b) -> RigCount -> RigCount
$cgmapT :: (forall b. Data b => b -> b) -> RigCount -> RigCount
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RigCount)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RigCount)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c RigCount)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c RigCount)
dataTypeOf :: RigCount -> DataType
$cdataTypeOf :: RigCount -> DataType
toConstr :: RigCount -> Constr
$ctoConstr :: RigCount -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c RigCount
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c RigCount
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RigCount -> c RigCount
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RigCount -> c RigCount
Data, forall x. Rep RigCount x -> RigCount
forall x. RigCount -> Rep RigCount x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep RigCount x -> RigCount
$cfrom :: forall x. RigCount -> Rep RigCount x
Generic, Typeable)
rigPlus :: RigCount -> RigCount -> RigCount
rigPlus :: RigCount -> RigCount -> RigCount
rigPlus RigCount
Rig0 RigCount
Rig0 = RigCount
Rig0
rigPlus RigCount
Rig0 RigCount
Rig1 = RigCount
Rig1
rigPlus RigCount
Rig0 RigCount
RigW = RigCount
RigW
rigPlus RigCount
Rig1 RigCount
Rig0 = RigCount
Rig1
rigPlus RigCount
Rig1 RigCount
Rig1 = RigCount
RigW
rigPlus RigCount
Rig1 RigCount
RigW = RigCount
RigW
rigPlus RigCount
RigW RigCount
Rig0 = RigCount
RigW
rigPlus RigCount
RigW RigCount
Rig1 = RigCount
RigW
rigPlus RigCount
RigW RigCount
RigW = RigCount
RigW
rigMult :: RigCount -> RigCount -> RigCount
rigMult :: RigCount -> RigCount -> RigCount
rigMult RigCount
Rig0 RigCount
Rig0 = RigCount
Rig0
rigMult RigCount
Rig0 RigCount
Rig1 = RigCount
Rig0
rigMult RigCount
Rig0 RigCount
RigW = RigCount
Rig0
rigMult RigCount
Rig1 RigCount
Rig0 = RigCount
Rig0
rigMult RigCount
Rig1 RigCount
Rig1 = RigCount
Rig1
rigMult RigCount
Rig1 RigCount
RigW = RigCount
RigW
rigMult RigCount
RigW RigCount
Rig0 = RigCount
Rig0
rigMult RigCount
RigW RigCount
Rig1 = RigCount
RigW
rigMult RigCount
RigW RigCount
RigW = RigCount
RigW
type EnvTT n = [(n, RigCount, Binder (TT n))]
fstEnv :: (a, b, c) -> a
fstEnv (a
n, b
c, c
b) = a
n
rigEnv :: (a, b, c) -> b
rigEnv (a
n, b
c, c
b) = b
c
sndEnv :: (a, b, c) -> c
sndEnv (a
n, b
c, c
b) = c
b
envBinders :: [(a, b, b)] -> [(a, b)]
envBinders = forall a b. (a -> b) -> [a] -> [b]
map (\(a
n, b
_, b
b) -> (a
n, b
b))
envZero :: [(a, b, c)] -> [(a, RigCount, c)]
envZero = forall a b. (a -> b) -> [a] -> [b]
map (\(a
n, b
_, c
b) -> (a
n, RigCount
Rig0, c
b))
lookupBinder :: Eq n => n -> EnvTT n -> Maybe (Binder (TT n))
lookupBinder :: forall n. Eq n => n -> EnvTT n -> Maybe (Binder (TT n))
lookupBinder n
n = forall a b. Eq a => a -> [(a, b)] -> Maybe b
lookup n
n forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall {a} {b} {b}. [(a, b, b)] -> [(a, b)]
envBinders
data Datatype n = Data { forall n. Datatype n -> n
d_typename :: n,
forall n. Datatype n -> Int
d_typetag :: Int,
forall n. Datatype n -> TT n
d_type :: (TT n),
forall n. Datatype n -> Bool
d_unique :: Bool,
forall n. Datatype n -> [(n, TT n)]
d_cons :: [(n, TT n)] }
deriving (Int -> Datatype n -> ShowS
forall n. (Show n, Eq n) => Int -> Datatype n -> ShowS
forall n. (Show n, Eq n) => [Datatype n] -> ShowS
forall n. (Show n, Eq n) => Datatype n -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Datatype n] -> ShowS
$cshowList :: forall n. (Show n, Eq n) => [Datatype n] -> ShowS
show :: Datatype n -> String
$cshow :: forall n. (Show n, Eq n) => Datatype n -> String
showsPrec :: Int -> Datatype n -> ShowS
$cshowsPrec :: forall n. (Show n, Eq n) => Int -> Datatype n -> ShowS
Show, forall a b. a -> Datatype b -> Datatype a
forall a b. (a -> b) -> Datatype a -> Datatype b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: forall a b. a -> Datatype b -> Datatype a
$c<$ :: forall a b. a -> Datatype b -> Datatype a
fmap :: forall a b. (a -> b) -> Datatype a -> Datatype b
$cfmap :: forall a b. (a -> b) -> Datatype a -> Datatype b
Functor, Datatype n -> Datatype n -> Bool
forall n. Eq n => Datatype n -> Datatype n -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Datatype n -> Datatype n -> Bool
$c/= :: forall n. Eq n => Datatype n -> Datatype n -> Bool
== :: Datatype n -> Datatype n -> Bool
$c== :: forall n. Eq n => Datatype n -> Datatype n -> Bool
Eq)
data DataOpt = Codata
| DataErrRev
deriving (Int -> DataOpt -> ShowS
[DataOpt] -> ShowS
DataOpt -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DataOpt] -> ShowS
$cshowList :: [DataOpt] -> ShowS
show :: DataOpt -> String
$cshow :: DataOpt -> String
showsPrec :: Int -> DataOpt -> ShowS
$cshowsPrec :: Int -> DataOpt -> ShowS
Show, DataOpt -> DataOpt -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DataOpt -> DataOpt -> Bool
$c/= :: DataOpt -> DataOpt -> Bool
== :: DataOpt -> DataOpt -> Bool
$c== :: DataOpt -> DataOpt -> Bool
Eq, forall x. Rep DataOpt x -> DataOpt
forall x. DataOpt -> Rep DataOpt x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep DataOpt x -> DataOpt
$cfrom :: forall x. DataOpt -> Rep DataOpt x
Generic)
type DataOpts = [DataOpt]
data TypeInfo = TI { TypeInfo -> [Name]
con_names :: [Name],
TypeInfo -> Bool
codata :: Bool,
TypeInfo -> [DataOpt]
data_opts :: DataOpts,
TypeInfo -> [Int]
param_pos :: [Int],
TypeInfo -> [Name]
mutual_types :: [Name],
TypeInfo -> Bool
linear_con :: Bool
}
deriving (Int -> TypeInfo -> ShowS
[TypeInfo] -> ShowS
TypeInfo -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TypeInfo] -> ShowS
$cshowList :: [TypeInfo] -> ShowS
show :: TypeInfo -> String
$cshow :: TypeInfo -> String
showsPrec :: Int -> TypeInfo -> ShowS
$cshowsPrec :: Int -> TypeInfo -> ShowS
Show, forall x. Rep TypeInfo x -> TypeInfo
forall x. TypeInfo -> Rep TypeInfo x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep TypeInfo x -> TypeInfo
$cfrom :: forall x. TypeInfo -> Rep TypeInfo x
Generic)
instance Eq n => Eq (TT n) where
== :: TT n -> TT n -> Bool
(==) (P NameType
xt n
x TT n
_) (P NameType
yt n
y TT n
_) = n
x forall a. Eq a => a -> a -> Bool
== n
y
(==) (V Int
x) (V Int
y) = Int
x forall a. Eq a => a -> a -> Bool
== Int
y
(==) (Bind n
_ Binder (TT n)
xb TT n
xs) (Bind n
_ Binder (TT n)
yb TT n
ys) = TT n
xs forall a. Eq a => a -> a -> Bool
== TT n
ys Bool -> Bool -> Bool
&& Binder (TT n)
xb forall a. Eq a => a -> a -> Bool
== Binder (TT n)
yb
(==) (App AppStatus n
_ TT n
fx TT n
ax) (App AppStatus n
_ TT n
fy TT n
ay) = TT n
ax forall a. Eq a => a -> a -> Bool
== TT n
ay Bool -> Bool -> Bool
&& TT n
fx forall a. Eq a => a -> a -> Bool
== TT n
fy
(==) (TType UExp
_) (TType UExp
_) = Bool
True
(==) (Constant Const
x) (Constant Const
y) = Const
x forall a. Eq a => a -> a -> Bool
== Const
y
(==) (Proj TT n
x Int
i) (Proj TT n
y Int
j) = TT n
x forall a. Eq a => a -> a -> Bool
== TT n
y Bool -> Bool -> Bool
&& Int
i forall a. Eq a => a -> a -> Bool
== Int
j
(==) TT n
Erased TT n
_ = Bool
True
(==) TT n
_ TT n
Erased = Bool
True
(==) TT n
_ TT n
_ = Bool
False
isInjective :: TT n -> Bool
isInjective :: forall n. TT n -> Bool
isInjective (P (DCon Int
_ Int
_ Bool
_) n
_ TT n
_) = Bool
True
isInjective (P (TCon Int
_ Int
_) n
_ TT n
_) = Bool
True
isInjective (Constant Const
_) = Bool
True
isInjective (TType UExp
x) = Bool
True
isInjective (Bind n
_ (Pi RigCount
_ Maybe ImplicitInfo
_ TT n
_ TT n
_) TT n
sc) = Bool
True
isInjective (App AppStatus n
_ TT n
f TT n
a) = forall n. TT n -> Bool
isInjective TT n
f
isInjective TT n
_ = Bool
False
instantiate :: TT n -> TT n -> TT n
instantiate :: forall n. TT n -> TT n -> TT n
instantiate TT n
e = Int -> TT n -> TT n
subst Int
0 where
subst :: Int -> TT n -> TT n
subst Int
i (P NameType
nt n
x TT n
ty) = forall n. NameType -> n -> TT n -> TT n
P NameType
nt n
x (Int -> TT n -> TT n
subst Int
i TT n
ty)
subst Int
i (V Int
x) | Int
i forall a. Eq a => a -> a -> Bool
== Int
x = TT n
e
subst Int
i (Bind n
x Binder (TT n)
b TT n
sc) = forall n. n -> Binder (TT n) -> TT n -> TT n
Bind n
x (forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Int -> TT n -> TT n
subst Int
i) Binder (TT n)
b) (Int -> TT n -> TT n
subst (Int
iforall a. Num a => a -> a -> a
+Int
1) TT n
sc)
subst Int
i (App AppStatus n
s TT n
f TT n
a) = forall n. AppStatus n -> TT n -> TT n -> TT n
App AppStatus n
s (Int -> TT n -> TT n
subst Int
i TT n
f) (Int -> TT n -> TT n
subst Int
i TT n
a)
subst Int
i (Proj TT n
x Int
idx) = forall n. TT n -> Int -> TT n
Proj (Int -> TT n -> TT n
subst Int
i TT n
x) Int
idx
subst Int
i TT n
t = TT n
t
substV :: TT n -> TT n -> TT n
substV :: forall n. TT n -> TT n -> TT n
substV TT n
x TT n
tm = forall {n}. Int -> TT n -> TT n
dropV Int
0 (forall n. TT n -> TT n -> TT n
instantiate TT n
x TT n
tm) where
dropV :: Int -> TT n -> TT n
dropV Int
i (P NameType
nt n
x TT n
ty) = forall n. NameType -> n -> TT n -> TT n
P NameType
nt n
x (Int -> TT n -> TT n
dropV Int
i TT n
ty)
dropV Int
i (V Int
x) | Int
x forall a. Ord a => a -> a -> Bool
> Int
i = forall n. Int -> TT n
V (Int
x forall a. Num a => a -> a -> a
- Int
1)
| Bool
otherwise = forall n. Int -> TT n
V Int
x
dropV Int
i (Bind n
x Binder (TT n)
b TT n
sc) = forall n. n -> Binder (TT n) -> TT n -> TT n
Bind n
x (forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Int -> TT n -> TT n
dropV Int
i) Binder (TT n)
b) (Int -> TT n -> TT n
dropV (Int
iforall a. Num a => a -> a -> a
+Int
1) TT n
sc)
dropV Int
i (App AppStatus n
s TT n
f TT n
a) = forall n. AppStatus n -> TT n -> TT n -> TT n
App AppStatus n
s (Int -> TT n -> TT n
dropV Int
i TT n
f) (Int -> TT n -> TT n
dropV Int
i TT n
a)
dropV Int
i (Proj TT n
x Int
idx) = forall n. TT n -> Int -> TT n
Proj (Int -> TT n -> TT n
dropV Int
i TT n
x) Int
idx
dropV Int
i TT n
t = TT n
t
explicitNames :: TT n -> TT n
explicitNames :: forall n. TT n -> TT n
explicitNames (Bind n
x Binder (TT n)
b TT n
sc) = let b' :: Binder (TT n)
b' = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall n. TT n -> TT n
explicitNames Binder (TT n)
b in
forall n. n -> Binder (TT n) -> TT n -> TT n
Bind n
x Binder (TT n)
b'
(forall n. TT n -> TT n
explicitNames (forall n. TT n -> TT n -> TT n
instantiate
(forall n. NameType -> n -> TT n -> TT n
P NameType
Bound n
x (forall b. Binder b -> b
binderTy Binder (TT n)
b')) TT n
sc))
explicitNames (App AppStatus n
s TT n
f TT n
a) = forall n. AppStatus n -> TT n -> TT n -> TT n
App AppStatus n
s (forall n. TT n -> TT n
explicitNames TT n
f) (forall n. TT n -> TT n
explicitNames TT n
a)
explicitNames (Proj TT n
x Int
idx) = forall n. TT n -> Int -> TT n
Proj (forall n. TT n -> TT n
explicitNames TT n
x) Int
idx
explicitNames TT n
t = TT n
t
pToV :: Eq n => n -> TT n -> TT n
pToV :: forall n. Eq n => n -> TT n -> TT n
pToV n
n = forall {t}. Eq t => t -> Int -> TT t -> TT t
pToV' n
n Int
0
pToV' :: t -> Int -> TT t -> TT t
pToV' t
n Int
i (P NameType
_ t
x TT t
_) | t
n forall a. Eq a => a -> a -> Bool
== t
x = forall n. Int -> TT n
V Int
i
pToV' t
n Int
i (Bind t
x Binder (TT t)
b TT t
sc)
| t
n forall a. Eq a => a -> a -> Bool
== t
x = forall n. n -> Binder (TT n) -> TT n -> TT n
Bind t
x (forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (t -> Int -> TT t -> TT t
pToV' t
n Int
i) Binder (TT t)
b) TT t
sc
| Bool
otherwise = forall n. n -> Binder (TT n) -> TT n -> TT n
Bind t
x (forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (t -> Int -> TT t -> TT t
pToV' t
n Int
i) Binder (TT t)
b) (t -> Int -> TT t -> TT t
pToV' t
n (Int
iforall a. Num a => a -> a -> a
+Int
1) TT t
sc)
pToV' t
n Int
i (App AppStatus t
s TT t
f TT t
a) = forall n. AppStatus n -> TT n -> TT n -> TT n
App AppStatus t
s (t -> Int -> TT t -> TT t
pToV' t
n Int
i TT t
f) (t -> Int -> TT t -> TT t
pToV' t
n Int
i TT t
a)
pToV' t
n Int
i (Proj TT t
t Int
idx) = forall n. TT n -> Int -> TT n
Proj (t -> Int -> TT t -> TT t
pToV' t
n Int
i TT t
t) Int
idx
pToV' t
n Int
i TT t
t = TT t
t
addBinder :: TT n -> TT n
addBinder :: forall n. TT n -> TT n
addBinder TT n
t = forall {n}. Int -> TT n -> TT n
ab Int
0 TT n
t
where
ab :: Int -> TT n -> TT n
ab Int
top (V Int
i) | Int
i forall a. Ord a => a -> a -> Bool
>= Int
top = forall n. Int -> TT n
V (Int
i forall a. Num a => a -> a -> a
+ Int
1)
| Bool
otherwise = forall n. Int -> TT n
V Int
i
ab Int
top (Bind n
x Binder (TT n)
b TT n
sc) = forall n. n -> Binder (TT n) -> TT n -> TT n
Bind n
x (forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Int -> TT n -> TT n
ab Int
top) Binder (TT n)
b) (Int -> TT n -> TT n
ab (Int
top forall a. Num a => a -> a -> a
+ Int
1) TT n
sc)
ab Int
top (App AppStatus n
s TT n
f TT n
a) = forall n. AppStatus n -> TT n -> TT n -> TT n
App AppStatus n
s (Int -> TT n -> TT n
ab Int
top TT n
f) (Int -> TT n -> TT n
ab Int
top TT n
a)
ab Int
top (Proj TT n
t Int
idx) = forall n. TT n -> Int -> TT n
Proj (Int -> TT n -> TT n
ab Int
top TT n
t) Int
idx
ab Int
top TT n
t = TT n
t
pToVs :: Eq n => [n] -> TT n -> TT n
pToVs :: forall n. Eq n => [n] -> TT n -> TT n
pToVs [n]
ns TT n
tm = forall {t}. Eq t => [t] -> TT t -> Int -> TT t
pToVs' [n]
ns TT n
tm Int
0 where
pToVs' :: [t] -> TT t -> Int -> TT t
pToVs' [] TT t
tm Int
i = TT t
tm
pToVs' (t
n:[t]
ns) TT t
tm Int
i = forall {t}. Eq t => t -> Int -> TT t -> TT t
pToV' t
n Int
i ([t] -> TT t -> Int -> TT t
pToVs' [t]
ns TT t
tm (Int
iforall a. Num a => a -> a -> a
+Int
1))
vToP :: TT n -> TT n
vToP :: forall n. TT n -> TT n
vToP = forall {n}. [(n, Binder (TT n))] -> TT n -> TT n
vToP' [] where
vToP' :: [(n, Binder (TT n))] -> TT n -> TT n
vToP' [(n, Binder (TT n))]
env (V Int
i) = let (n
n, Binder (TT n)
b) = ([(n, Binder (TT n))]
env forall a. [a] -> Int -> a
!! Int
i) in
forall n. NameType -> n -> TT n -> TT n
P NameType
Bound n
n (forall b. Binder b -> b
binderTy Binder (TT n)
b)
vToP' [(n, Binder (TT n))]
env (Bind n
n Binder (TT n)
b TT n
sc) = let b' :: Binder (TT n)
b' = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ([(n, Binder (TT n))] -> TT n -> TT n
vToP' [(n, Binder (TT n))]
env) Binder (TT n)
b in
forall n. n -> Binder (TT n) -> TT n -> TT n
Bind n
n Binder (TT n)
b' ([(n, Binder (TT n))] -> TT n -> TT n
vToP' ((n
n, Binder (TT n)
b')forall a. a -> [a] -> [a]
:[(n, Binder (TT n))]
env) TT n
sc)
vToP' [(n, Binder (TT n))]
env (App AppStatus n
s TT n
f TT n
a) = forall n. AppStatus n -> TT n -> TT n -> TT n
App AppStatus n
s ([(n, Binder (TT n))] -> TT n -> TT n
vToP' [(n, Binder (TT n))]
env TT n
f) ([(n, Binder (TT n))] -> TT n -> TT n
vToP' [(n, Binder (TT n))]
env TT n
a)
vToP' [(n, Binder (TT n))]
env TT n
t = TT n
t
finalise :: Eq n => TT n -> TT n
finalise :: forall n. Eq n => TT n -> TT n
finalise (Bind n
x Binder (TT n)
b TT n
sc) = forall n. n -> Binder (TT n) -> TT n -> TT n
Bind n
x (forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall n. Eq n => TT n -> TT n
finalise Binder (TT n)
b) (forall n. Eq n => n -> TT n -> TT n
pToV n
x (forall n. Eq n => TT n -> TT n
finalise TT n
sc))
finalise (App AppStatus n
s TT n
f TT n
a) = forall n. AppStatus n -> TT n -> TT n -> TT n
App AppStatus n
s (forall n. Eq n => TT n -> TT n
finalise TT n
f) (forall n. Eq n => TT n -> TT n
finalise TT n
a)
finalise TT n
t = TT n
t
pEraseType :: TT n -> TT n
pEraseType :: forall n. TT n -> TT n
pEraseType (P NameType
nt n
t TT n
_) = forall n. NameType -> n -> TT n -> TT n
P NameType
nt n
t forall n. TT n
Erased
pEraseType (App AppStatus n
s TT n
f TT n
a) = forall n. AppStatus n -> TT n -> TT n -> TT n
App AppStatus n
s (forall n. TT n -> TT n
pEraseType TT n
f) (forall n. TT n -> TT n
pEraseType TT n
a)
pEraseType (Bind n
n Binder (TT n)
b TT n
sc) = forall n. n -> Binder (TT n) -> TT n -> TT n
Bind n
n (forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall n. TT n -> TT n
pEraseType Binder (TT n)
b) (forall n. TT n -> TT n
pEraseType TT n
sc)
pEraseType TT n
t = TT n
t
subst :: Eq n => n ->
TT n ->
TT n ->
TT n
subst :: forall n. Eq n => n -> TT n -> TT n -> TT n
subst n
n TT n
v TT n
tm = forall a b. (a, b) -> a
fst forall a b. (a -> b) -> a -> b
$ Int -> TT n -> (TT n, Bool)
subst' Int
0 TT n
tm
where
subst' :: Int -> TT n -> (TT n, Bool)
subst' Int
i (V Int
x) | Int
i forall a. Eq a => a -> a -> Bool
== Int
x = (TT n
v, Bool
True)
subst' Int
i (P NameType
_ n
x TT n
_) | n
n forall a. Eq a => a -> a -> Bool
== n
x = (TT n
v, Bool
True)
subst' Int
i t :: TT n
t@(P NameType
nt n
x TT n
ty)
= let (TT n
ty', Bool
ut) = Int -> TT n -> (TT n, Bool)
subst' Int
i TT n
ty in
if Bool
ut then (forall n. NameType -> n -> TT n -> TT n
P NameType
nt n
x TT n
ty', Bool
True) else (TT n
t, Bool
False)
subst' Int
i t :: TT n
t@(Bind n
x Binder (TT n)
b TT n
sc) | n
x forall a. Eq a => a -> a -> Bool
/= n
n
= let (Binder (TT n)
b', Bool
ub) = Int -> Binder (TT n) -> (Binder (TT n), Bool)
substB' Int
i Binder (TT n)
b
(TT n
sc', Bool
usc) = Int -> TT n -> (TT n, Bool)
subst' (Int
iforall a. Num a => a -> a -> a
+Int
1) TT n
sc in
if Bool
ub Bool -> Bool -> Bool
|| Bool
usc then (forall n. n -> Binder (TT n) -> TT n -> TT n
Bind n
x Binder (TT n)
b' TT n
sc', Bool
True) else (TT n
t, Bool
False)
subst' Int
i t :: TT n
t@(App AppStatus n
s TT n
f TT n
a) = let (TT n
f', Bool
uf) = Int -> TT n -> (TT n, Bool)
subst' Int
i TT n
f
(TT n
a', Bool
ua) = Int -> TT n -> (TT n, Bool)
subst' Int
i TT n
a in
if Bool
uf Bool -> Bool -> Bool
|| Bool
ua then (forall n. AppStatus n -> TT n -> TT n -> TT n
App AppStatus n
s TT n
f' TT n
a', Bool
True) else (TT n
t, Bool
False)
subst' Int
i t :: TT n
t@(Proj TT n
x Int
idx) = let (TT n
x', Bool
u) = Int -> TT n -> (TT n, Bool)
subst' Int
i TT n
x in
if Bool
u then (forall n. TT n -> Int -> TT n
Proj TT n
x' Int
idx, Bool
u) else (TT n
t, Bool
False)
subst' Int
i TT n
t = (TT n
t, Bool
False)
substB' :: Int -> Binder (TT n) -> (Binder (TT n), Bool)
substB' Int
i b :: Binder (TT n)
b@(Let RigCount
c TT n
t TT n
v) = let (TT n
t', Bool
ut) = Int -> TT n -> (TT n, Bool)
subst' Int
i TT n
t
(TT n
v', Bool
uv) = Int -> TT n -> (TT n, Bool)
subst' Int
i TT n
v in
if Bool
ut Bool -> Bool -> Bool
|| Bool
uv then (forall b. RigCount -> b -> b -> Binder b
Let RigCount
c TT n
t' TT n
v', Bool
True)
else (Binder (TT n)
b, Bool
False)
substB' Int
i b :: Binder (TT n)
b@(Guess TT n
t TT n
v) = let (TT n
t', Bool
ut) = Int -> TT n -> (TT n, Bool)
subst' Int
i TT n
t
(TT n
v', Bool
uv) = Int -> TT n -> (TT n, Bool)
subst' Int
i TT n
v in
if Bool
ut Bool -> Bool -> Bool
|| Bool
uv then (forall b. b -> b -> Binder b
Guess TT n
t' TT n
v', Bool
True)
else (Binder (TT n)
b, Bool
False)
substB' Int
i Binder (TT n)
b = let (TT n
ty', Bool
u) = Int -> TT n -> (TT n, Bool)
subst' Int
i (forall b. Binder b -> b
binderTy Binder (TT n)
b) in
if Bool
u then (Binder (TT n)
b { binderTy :: TT n
binderTy = TT n
ty' }, Bool
u) else (Binder (TT n)
b, Bool
False)
psubst :: Eq n => n -> TT n -> TT n -> TT n
psubst :: forall n. Eq n => n -> TT n -> TT n -> TT n
psubst n
n TT n
v TT n
tm = Int -> TT n -> TT n
s' Int
0 TT n
tm where
s' :: Int -> TT n -> TT n
s' Int
i (V Int
x) | Int
x forall a. Ord a => a -> a -> Bool
> Int
i = forall n. Int -> TT n
V (Int
x forall a. Num a => a -> a -> a
- Int
1)
| Int
x forall a. Eq a => a -> a -> Bool
== Int
i = TT n
v
| Bool
otherwise = forall n. Int -> TT n
V Int
x
s' Int
i (P NameType
_ n
x TT n
_) | n
n forall a. Eq a => a -> a -> Bool
== n
x = TT n
v
s' Int
i (Bind n
x Binder (TT n)
b TT n
sc) | n
n forall a. Eq a => a -> a -> Bool
== n
x = forall n. n -> Binder (TT n) -> TT n -> TT n
Bind n
x (forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Int -> TT n -> TT n
s' Int
i) Binder (TT n)
b) TT n
sc
| Bool
otherwise = forall n. n -> Binder (TT n) -> TT n -> TT n
Bind n
x (forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Int -> TT n -> TT n
s' Int
i) Binder (TT n)
b) (Int -> TT n -> TT n
s' (Int
iforall a. Num a => a -> a -> a
+Int
1) TT n
sc)
s' Int
i (App AppStatus n
st TT n
f TT n
a) = forall n. AppStatus n -> TT n -> TT n -> TT n
App AppStatus n
st (Int -> TT n -> TT n
s' Int
i TT n
f) (Int -> TT n -> TT n
s' Int
i TT n
a)
s' Int
i (Proj TT n
t Int
idx) = forall n. TT n -> Int -> TT n
Proj (Int -> TT n -> TT n
s' Int
i TT n
t) Int
idx
s' Int
i TT n
t = TT n
t
substNames :: Eq n => [(n, TT n)] -> TT n -> TT n
substNames :: forall n. Eq n => [(n, TT n)] -> TT n -> TT n
substNames [] TT n
t = TT n
t
substNames ((n
n, TT n
tm) : [(n, TT n)]
xs) TT n
t = forall n. Eq n => n -> TT n -> TT n -> TT n
subst n
n TT n
tm (forall n. Eq n => [(n, TT n)] -> TT n -> TT n
substNames [(n, TT n)]
xs TT n
t)
substTerm :: Eq n => TT n ->
TT n ->
TT n
-> TT n
substTerm :: forall n. Eq n => TT n -> TT n -> TT n -> TT n
substTerm TT n
old TT n
new = TT n -> TT n
st where
st :: TT n -> TT n
st TT n
t | forall {b}. Eq b => [(b, b)] -> TT b -> TT b -> Bool
eqAlpha [] TT n
t TT n
old = TT n
new
st (App AppStatus n
s TT n
f TT n
a) = forall n. AppStatus n -> TT n -> TT n -> TT n
App AppStatus n
s (TT n -> TT n
st TT n
f) (TT n -> TT n
st TT n
a)
st (Bind n
x Binder (TT n)
b TT n
sc) = forall n. n -> Binder (TT n) -> TT n -> TT n
Bind n
x (forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap TT n -> TT n
st Binder (TT n)
b) (TT n -> TT n
st TT n
sc)
st TT n
t = TT n
t
eqAlpha :: [(b, b)] -> TT b -> TT b -> Bool
eqAlpha [(b, b)]
as (P NameType
_ b
x TT b
_) (P NameType
_ b
y TT b
_)
= b
x forall a. Eq a => a -> a -> Bool
== b
y Bool -> Bool -> Bool
|| (b
x, b
y) forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [(b, b)]
as Bool -> Bool -> Bool
|| (b
y, b
x) forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [(b, b)]
as
eqAlpha [(b, b)]
as (V Int
x) (V Int
y) = Int
x forall a. Eq a => a -> a -> Bool
== Int
y
eqAlpha [(b, b)]
as (Bind b
x Binder (TT b)
xb TT b
xs) (Bind b
y Binder (TT b)
yb TT b
ys)
= [(b, b)] -> Binder (TT b) -> Binder (TT b) -> Bool
eqAlphaB [(b, b)]
as Binder (TT b)
xb Binder (TT b)
yb Bool -> Bool -> Bool
&& [(b, b)] -> TT b -> TT b -> Bool
eqAlpha ((b
x, b
y) forall a. a -> [a] -> [a]
: [(b, b)]
as) TT b
xs TT b
ys
eqAlpha [(b, b)]
as (App AppStatus b
_ TT b
fx TT b
ax) (App AppStatus b
_ TT b
fy TT b
ay) = [(b, b)] -> TT b -> TT b -> Bool
eqAlpha [(b, b)]
as TT b
fx TT b
fy Bool -> Bool -> Bool
&& [(b, b)] -> TT b -> TT b -> Bool
eqAlpha [(b, b)]
as TT b
ax TT b
ay
eqAlpha [(b, b)]
as TT b
x TT b
y = TT b
x forall a. Eq a => a -> a -> Bool
== TT b
y
eqAlphaB :: [(b, b)] -> Binder (TT b) -> Binder (TT b) -> Bool
eqAlphaB [(b, b)]
as (Let RigCount
xc TT b
xt TT b
xv) (Let RigCount
yc TT b
yt TT b
yv)
= [(b, b)] -> TT b -> TT b -> Bool
eqAlpha [(b, b)]
as TT b
xt TT b
yt Bool -> Bool -> Bool
&& [(b, b)] -> TT b -> TT b -> Bool
eqAlpha [(b, b)]
as TT b
xv TT b
yv
eqAlphaB [(b, b)]
as (Guess TT b
xt TT b
xv) (Guess TT b
yt TT b
yv)
= [(b, b)] -> TT b -> TT b -> Bool
eqAlpha [(b, b)]
as TT b
xt TT b
yt Bool -> Bool -> Bool
&& [(b, b)] -> TT b -> TT b -> Bool
eqAlpha [(b, b)]
as TT b
xv TT b
yv
eqAlphaB [(b, b)]
as Binder (TT b)
bx Binder (TT b)
by = [(b, b)] -> TT b -> TT b -> Bool
eqAlpha [(b, b)]
as (forall b. Binder b -> b
binderTy Binder (TT b)
bx) (forall b. Binder b -> b
binderTy Binder (TT b)
by)
occurrences :: Eq n => n -> TT n -> Int
occurrences :: forall n. Eq n => n -> TT n -> Int
occurrences n
n TT n
t = forall s a. State s a -> s -> s
execState (forall {s} {m :: * -> *}.
(MonadState s m, Num s) =>
Int -> TT n -> m ()
no' Int
0 TT n
t) Int
0
where
no' :: Int -> TT n -> m ()
no' Int
i (V Int
x) | Int
i forall a. Eq a => a -> a -> Bool
== Int
x = do s
num <- forall s (m :: * -> *). MonadState s m => m s
get; forall s (m :: * -> *). MonadState s m => s -> m ()
put (s
num forall a. Num a => a -> a -> a
+ s
1)
no' Int
i (P NameType
Bound n
x TT n
_) | n
n forall a. Eq a => a -> a -> Bool
== n
x = do s
num <- forall s (m :: * -> *). MonadState s m => m s
get; forall s (m :: * -> *). MonadState s m => s -> m ()
put (s
num forall a. Num a => a -> a -> a
+ s
1)
no' Int
i (Bind n
n Binder (TT n)
b TT n
sc) = do Int -> Binder (TT n) -> m ()
noB' Int
i Binder (TT n)
b; Int -> TT n -> m ()
no' (Int
iforall a. Num a => a -> a -> a
+Int
1) TT n
sc
where noB' :: Int -> Binder (TT n) -> m ()
noB' Int
i (Let RigCount
c TT n
t TT n
v) = do Int -> TT n -> m ()
no' Int
i TT n
t; Int -> TT n -> m ()
no' Int
i TT n
v
noB' Int
i (Guess TT n
t TT n
v) = do Int -> TT n -> m ()
no' Int
i TT n
t; Int -> TT n -> m ()
no' Int
i TT n
v
noB' Int
i Binder (TT n)
b = Int -> TT n -> m ()
no' Int
i (forall b. Binder b -> b
binderTy Binder (TT n)
b)
no' Int
i (App AppStatus n
_ TT n
f TT n
a) = do Int -> TT n -> m ()
no' Int
i TT n
f; Int -> TT n -> m ()
no' Int
i TT n
a
no' Int
i (Proj TT n
x Int
_) = Int -> TT n -> m ()
no' Int
i TT n
x
no' Int
i TT n
_ = forall (m :: * -> *) a. Monad m => a -> m a
return ()
noOccurrence :: Eq n => n -> TT n -> Bool
noOccurrence :: forall n. Eq n => n -> TT n -> Bool
noOccurrence n
n TT n
t = Int -> TT n -> Bool
no' Int
0 TT n
t
where
no' :: Int -> TT n -> Bool
no' Int
i (V Int
x) = Bool -> Bool
not (Int
i forall a. Eq a => a -> a -> Bool
== Int
x)
no' Int
i (P NameType
Bound n
x TT n
_) = Bool -> Bool
not (n
n forall a. Eq a => a -> a -> Bool
== n
x)
no' Int
i (Bind n
n Binder (TT n)
b TT n
sc) = Int -> Binder (TT n) -> Bool
noB' Int
i Binder (TT n)
b Bool -> Bool -> Bool
&& Int -> TT n -> Bool
no' (Int
iforall a. Num a => a -> a -> a
+Int
1) TT n
sc
where noB' :: Int -> Binder (TT n) -> Bool
noB' Int
i (Let RigCount
c TT n
t TT n
v) = Int -> TT n -> Bool
no' Int
i TT n
t Bool -> Bool -> Bool
&& Int -> TT n -> Bool
no' Int
i TT n
v
noB' Int
i (Guess TT n
t TT n
v) = Int -> TT n -> Bool
no' Int
i TT n
t Bool -> Bool -> Bool
&& Int -> TT n -> Bool
no' Int
i TT n
v
noB' Int
i Binder (TT n)
b = Int -> TT n -> Bool
no' Int
i (forall b. Binder b -> b
binderTy Binder (TT n)
b)
no' Int
i (App AppStatus n
_ TT n
f TT n
a) = Int -> TT n -> Bool
no' Int
i TT n
f Bool -> Bool -> Bool
&& Int -> TT n -> Bool
no' Int
i TT n
a
no' Int
i (Proj TT n
x Int
_) = Int -> TT n -> Bool
no' Int
i TT n
x
no' Int
i TT n
_ = Bool
True
freeNames :: Eq n => TT n -> [n]
freeNames :: forall n. Eq n => TT n -> [n]
freeNames TT n
t = forall a. Eq a => [a] -> [a]
nub forall a b. (a -> b) -> a -> b
$ forall n. Eq n => TT n -> [n]
freeNames' TT n
t
where
freeNames' :: TT a -> [a]
freeNames' (P NameType
_ a
n TT a
_) = [a
n]
freeNames' (Bind a
n (Let RigCount
c TT a
t TT a
v) TT a
sc) = TT a -> [a]
freeNames' TT a
v forall a. [a] -> [a] -> [a]
++ (TT a -> [a]
freeNames' TT a
sc forall a. Eq a => [a] -> [a] -> [a]
\\ [a
n])
forall a. [a] -> [a] -> [a]
++ TT a -> [a]
freeNames' TT a
t
freeNames' (Bind a
n Binder (TT a)
b TT a
sc) = TT a -> [a]
freeNames' (forall b. Binder b -> b
binderTy Binder (TT a)
b) forall a. [a] -> [a] -> [a]
++ (TT a -> [a]
freeNames' TT a
sc forall a. Eq a => [a] -> [a] -> [a]
\\ [a
n])
freeNames' (App AppStatus a
_ TT a
f TT a
a) = TT a -> [a]
freeNames' TT a
f forall a. [a] -> [a] -> [a]
++ TT a -> [a]
freeNames' TT a
a
freeNames' (Proj TT a
x Int
i) = TT a -> [a]
freeNames' TT a
x
freeNames' TT a
_ = []
arity :: TT n -> Int
arity :: forall n. TT n -> Int
arity (Bind n
n (Pi RigCount
_ Maybe ImplicitInfo
_ TT n
t TT n
_) TT n
sc) = Int
1 forall a. Num a => a -> a -> a
+ forall n. TT n -> Int
arity TT n
sc
arity TT n
_ = Int
0
unApply :: TT n -> (TT n, [TT n])
unApply :: forall n. TT n -> (TT n, [TT n])
unApply TT n
t = forall {n}. [TT n] -> TT n -> (TT n, [TT n])
ua [] TT n
t where
ua :: [TT n] -> TT n -> (TT n, [TT n])
ua [TT n]
args (App AppStatus n
_ TT n
f TT n
a) = [TT n] -> TT n -> (TT n, [TT n])
ua (TT n
aforall a. a -> [a] -> [a]
:[TT n]
args) TT n
f
ua [TT n]
args TT n
t = (TT n
t, [TT n]
args)
mkApp :: TT n -> [TT n] -> TT n
mkApp :: forall n. TT n -> [TT n] -> TT n
mkApp TT n
f [] = TT n
f
mkApp TT n
f (TT n
a:[TT n]
as) = forall n. TT n -> [TT n] -> TT n
mkApp (forall n. AppStatus n -> TT n -> TT n -> TT n
App forall n. AppStatus n
MaybeHoles TT n
f TT n
a) [TT n]
as
unList :: Term -> Maybe [Term]
unList :: TT Name -> Maybe [TT Name]
unList TT Name
tm = case forall n. TT n -> (TT n, [TT n])
unApply TT Name
tm of
(TT Name
nil, [TT Name
_]) -> forall a. a -> Maybe a
Just []
(TT Name
cons, ([TT Name
_, TT Name
x, TT Name
xs])) ->
do [TT Name]
rest <- TT Name -> Maybe [TT Name]
unList TT Name
xs
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ TT Name
xforall a. a -> [a] -> [a]
:[TT Name]
rest
(TT Name
f, [TT Name]
args) -> forall a. Maybe a
Nothing
termSmallerThan :: Int -> Term -> Bool
termSmallerThan :: Int -> TT Name -> Bool
termSmallerThan Int
x TT Name
tm | Int
x forall a. Ord a => a -> a -> Bool
<= Int
0 = Bool
False
termSmallerThan Int
x (P NameType
_ Name
_ TT Name
ty) = Int -> TT Name -> Bool
termSmallerThan (Int
xforall a. Num a => a -> a -> a
-Int
1) TT Name
ty
termSmallerThan Int
x (Bind Name
_ Binder (TT Name)
_ TT Name
tm) = Int -> TT Name -> Bool
termSmallerThan (Int
xforall a. Num a => a -> a -> a
-Int
1) TT Name
tm
termSmallerThan Int
x (App AppStatus Name
_ TT Name
f TT Name
a) = Int -> TT Name -> Bool
termSmallerThan (Int
xforall a. Num a => a -> a -> a
-Int
1) TT Name
f Bool -> Bool -> Bool
&& Int -> TT Name -> Bool
termSmallerThan (Int
xforall a. Num a => a -> a -> a
-Int
1) TT Name
a
termSmallerThan Int
x (Proj TT Name
tm Int
_) = Int -> TT Name -> Bool
termSmallerThan (Int
xforall a. Num a => a -> a -> a
-Int
1) TT Name
tm
termSmallerThan Int
x (V Int
i) = Bool
True
termSmallerThan Int
x (Constant Const
c) = Bool
True
termSmallerThan Int
x TT Name
Erased = Bool
True
termSmallerThan Int
x TT Name
Impossible = Bool
True
termSmallerThan Int
x (Inferred TT Name
t) = Int -> TT Name -> Bool
termSmallerThan Int
x TT Name
t
termSmallerThan Int
x (TType UExp
u) = Bool
True
termSmallerThan Int
x (UType Universe
u) = Bool
True
forget :: TT Name -> Raw
forget :: TT Name -> Raw
forget TT Name
tm = [Name] -> TT Name -> Raw
forgetEnv [] TT Name
tm
safeForget :: TT Name -> Maybe Raw
safeForget :: TT Name -> Maybe Raw
safeForget TT Name
tm = [Name] -> TT Name -> Maybe Raw
safeForgetEnv [] TT Name
tm
forgetEnv :: [Name] -> TT Name -> Raw
forgetEnv :: [Name] -> TT Name -> Raw
forgetEnv [Name]
env TT Name
tm = case [Name] -> TT Name -> Maybe Raw
safeForgetEnv [Name]
env TT Name
tm of
Just Raw
t' -> Raw
t'
Maybe Raw
Nothing -> forall a. HasCallStack => String -> a
error forall a b. (a -> b) -> a -> b
$ String
"Scope error in " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show TT Name
tm forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show [Name]
env
safeForgetEnv :: [Name] -> TT Name -> Maybe Raw
safeForgetEnv :: [Name] -> TT Name -> Maybe Raw
safeForgetEnv [Name]
env (P NameType
_ Name
n TT Name
_) = forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ Name -> Raw
Var Name
n
safeForgetEnv [Name]
env (V Int
i) | Int
i forall a. Ord a => a -> a -> Bool
< forall (t :: * -> *) a. Foldable t => t a -> Int
length [Name]
env = forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ Name -> Raw
Var ([Name]
env forall a. [a] -> Int -> a
!! Int
i)
| Bool
otherwise = forall a. Maybe a
Nothing
safeForgetEnv [Name]
env (Bind Name
n Binder (TT Name)
b TT Name
sc)
= do let n' :: Name
n' = Name -> [Name] -> Name
uniqueName Name
n [Name]
env
Binder Raw
b' <- [Name] -> Binder (TT Name) -> Maybe (Binder Raw)
safeForgetEnvB [Name]
env Binder (TT Name)
b
Raw
sc' <- [Name] -> TT Name -> Maybe Raw
safeForgetEnv (Name
n'forall a. a -> [a] -> [a]
:[Name]
env) TT Name
sc
forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ Name -> Binder Raw -> Raw -> Raw
RBind Name
n' Binder Raw
b' Raw
sc'
where safeForgetEnvB :: [Name] -> Binder (TT Name) -> Maybe (Binder Raw)
safeForgetEnvB [Name]
env (Let RigCount
c TT Name
t TT Name
v) = forall (m :: * -> *) a1 a2 r.
Monad m =>
(a1 -> a2 -> r) -> m a1 -> m a2 -> m r
liftM2 (forall b. RigCount -> b -> b -> Binder b
Let RigCount
c) ([Name] -> TT Name -> Maybe Raw
safeForgetEnv [Name]
env TT Name
t)
([Name] -> TT Name -> Maybe Raw
safeForgetEnv [Name]
env TT Name
v)
safeForgetEnvB [Name]
env (Guess TT Name
t TT Name
v) = forall (m :: * -> *) a1 a2 r.
Monad m =>
(a1 -> a2 -> r) -> m a1 -> m a2 -> m r
liftM2 forall b. b -> b -> Binder b
Guess ([Name] -> TT Name -> Maybe Raw
safeForgetEnv [Name]
env TT Name
t)
([Name] -> TT Name -> Maybe Raw
safeForgetEnv [Name]
env TT Name
v)
safeForgetEnvB [Name]
env Binder (TT Name)
b = do Raw
ty' <- [Name] -> TT Name -> Maybe Raw
safeForgetEnv [Name]
env (forall b. Binder b -> b
binderTy Binder (TT Name)
b)
forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\TT Name
_ -> Raw
ty') Binder (TT Name)
b
safeForgetEnv [Name]
env (App AppStatus Name
_ TT Name
f TT Name
a) = forall (m :: * -> *) a1 a2 r.
Monad m =>
(a1 -> a2 -> r) -> m a1 -> m a2 -> m r
liftM2 Raw -> Raw -> Raw
RApp ([Name] -> TT Name -> Maybe Raw
safeForgetEnv [Name]
env TT Name
f) ([Name] -> TT Name -> Maybe Raw
safeForgetEnv [Name]
env TT Name
a)
safeForgetEnv [Name]
env (Constant Const
c) = forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ Const -> Raw
RConstant Const
c
safeForgetEnv [Name]
env (TType UExp
i) = forall a. a -> Maybe a
Just Raw
RType
safeForgetEnv [Name]
env (UType Universe
u) = forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ Universe -> Raw
RUType Universe
u
safeForgetEnv [Name]
env TT Name
Erased = forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ Const -> Raw
RConstant Const
Forgot
safeForgetEnv [Name]
env (Proj TT Name
tm Int
i) = forall a. HasCallStack => String -> a
error String
"Don't know how to forget a projection"
safeForgetEnv [Name]
env TT Name
Impossible = forall a. HasCallStack => String -> a
error String
"Don't know how to forget Impossible"
safeForgetEnv [Name]
env (Inferred TT Name
t) = [Name] -> TT Name -> Maybe Raw
safeForgetEnv [Name]
env TT Name
t
bindAll :: [(n, Binder (TT n))] -> TT n -> TT n
bindAll :: forall {n}. [(n, Binder (TT n))] -> TT n -> TT n
bindAll [] TT n
t = TT n
t
bindAll ((n
n, Binder (TT n)
b) : [(n, Binder (TT n))]
bs) TT n
t = forall n. n -> Binder (TT n) -> TT n -> TT n
Bind n
n Binder (TT n)
b (forall {n}. [(n, Binder (TT n))] -> TT n -> TT n
bindAll [(n, Binder (TT n))]
bs TT n
t)
bindTyArgs :: (TT n -> Binder (TT n)) -> [(n, TT n)] -> TT n -> TT n
bindTyArgs :: forall n. (TT n -> Binder (TT n)) -> [(n, TT n)] -> TT n -> TT n
bindTyArgs TT n -> Binder (TT n)
b [(n, TT n)]
xs = forall {n}. [(n, Binder (TT n))] -> TT n -> TT n
bindAll (forall a b. (a -> b) -> [a] -> [b]
map (\ (n
n, TT n
ty) -> (n
n, TT n -> Binder (TT n)
b TT n
ty)) [(n, TT n)]
xs)
getArgTys :: TT n -> [(n, TT n)]
getArgTys :: forall n. TT n -> [(n, TT n)]
getArgTys (Bind n
n (PVar RigCount
_ TT n
_) TT n
sc) = forall n. TT n -> [(n, TT n)]
getArgTys TT n
sc
getArgTys (Bind n
n (PVTy TT n
_) TT n
sc) = forall n. TT n -> [(n, TT n)]
getArgTys TT n
sc
getArgTys (Bind n
n (Pi RigCount
_ Maybe ImplicitInfo
_ TT n
t TT n
_) TT n
sc) = (n
n, TT n
t) forall a. a -> [a] -> [a]
: forall n. TT n -> [(n, TT n)]
getArgTys TT n
sc
getArgTys TT n
_ = []
getRetTy :: TT n -> TT n
getRetTy :: forall n. TT n -> TT n
getRetTy (Bind n
n (PVar RigCount
_ TT n
_) TT n
sc) = forall n. TT n -> TT n
getRetTy TT n
sc
getRetTy (Bind n
n (PVTy TT n
_) TT n
sc) = forall n. TT n -> TT n
getRetTy TT n
sc
getRetTy (Bind n
n (Pi RigCount
_ Maybe ImplicitInfo
_ TT n
_ TT n
_) TT n
sc) = forall n. TT n -> TT n
getRetTy TT n
sc
getRetTy TT n
sc = TT n
sc
substRetTy :: TT n -> TT n
substRetTy :: forall n. TT n -> TT n
substRetTy (Bind n
n (PVar RigCount
_ TT n
ty) TT n
sc) = forall n. TT n -> TT n
substRetTy (forall n. TT n -> TT n -> TT n
substV (forall n. NameType -> n -> TT n -> TT n
P NameType
Ref n
n TT n
ty) TT n
sc)
substRetTy (Bind n
n (PVTy TT n
ty) TT n
sc) = forall n. TT n -> TT n
substRetTy (forall n. TT n -> TT n -> TT n
substV (forall n. NameType -> n -> TT n -> TT n
P NameType
Ref n
n TT n
ty) TT n
sc)
substRetTy (Bind n
n (Pi RigCount
_ Maybe ImplicitInfo
_ TT n
ty TT n
_) TT n
sc) = forall n. TT n -> TT n
substRetTy (forall n. TT n -> TT n -> TT n
substV (forall n. NameType -> n -> TT n -> TT n
P NameType
Ref n
n TT n
ty) TT n
sc)
substRetTy TT n
sc = TT n
sc
uniqueNameFrom :: [Name] -> [Name] -> Name
uniqueNameFrom :: [Name] -> [Name] -> Name
uniqueNameFrom [] [Name]
hs = Name -> [Name] -> Name
uniqueName (Name -> Name
nextName (String -> Name
sUN String
"x")) [Name]
hs
uniqueNameFrom (Name
s : [Name]
supply) [Name]
hs
| Name
s forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [Name]
hs = [Name] -> [Name] -> Name
uniqueNameFrom [Name]
supply [Name]
hs
| Bool
otherwise = Name
s
uniqueName :: Name -> [Name] -> Name
uniqueName :: Name -> [Name] -> Name
uniqueName Name
n [Name]
hs | Name
n forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [Name]
hs = Name -> [Name] -> Name
uniqueName (Name -> Name
nextName Name
n) [Name]
hs
| Bool
otherwise = Name
n
uniqueNameSet :: Name -> Set Name -> Name
uniqueNameSet :: Name -> Set Name -> Name
uniqueNameSet Name
n Set Name
hs | Name
n forall a. Ord a => a -> Set a -> Bool
`member` Set Name
hs = Name -> Set Name -> Name
uniqueNameSet (Name -> Name
nextName Name
n) Set Name
hs
| Bool
otherwise = Name
n
uniqueBinders :: [Name] -> TT Name -> TT Name
uniqueBinders :: [Name] -> TT Name -> TT Name
uniqueBinders [Name]
ns = Set Name -> TT Name -> TT Name
ubSet (forall a. Ord a => [a] -> Set a
fromList [Name]
ns) where
ubSet :: Set Name -> TT Name -> TT Name
ubSet Set Name
ns (Bind Name
n Binder (TT Name)
b TT Name
sc)
= let n' :: Name
n' = Name -> Set Name -> Name
uniqueNameSet Name
n Set Name
ns
ns' :: Set Name
ns' = forall a. Ord a => a -> Set a -> Set a
insert Name
n' Set Name
ns in
forall n. n -> Binder (TT n) -> TT n -> TT n
Bind Name
n' (forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Set Name -> TT Name -> TT Name
ubSet Set Name
ns') Binder (TT Name)
b) (Set Name -> TT Name -> TT Name
ubSet Set Name
ns' TT Name
sc)
ubSet Set Name
ns (App AppStatus Name
s TT Name
f TT Name
a) = forall n. AppStatus n -> TT n -> TT n -> TT n
App AppStatus Name
s (Set Name -> TT Name -> TT Name
ubSet Set Name
ns TT Name
f) (Set Name -> TT Name -> TT Name
ubSet Set Name
ns TT Name
a)
ubSet Set Name
ns TT Name
t = TT Name
t
nextName :: Name -> Name
nextName :: Name -> Name
nextName (NS Name
x [Text]
s) = Name -> [Text] -> Name
NS (Name -> Name
nextName Name
x) [Text]
s
nextName (MN Int
i Text
n) = Int -> Text -> Name
MN (Int
iforall a. Num a => a -> a -> a
+Int
1) Text
n
nextName (UN Text
x) = let (Text
num', Text
nm') = (Char -> Bool) -> Text -> (Text, Text)
T.span Char -> Bool
isDigit (Text -> Text
T.reverse Text
x)
nm :: Text
nm = Text -> Text
T.reverse Text
nm'
num :: Integer
num = forall {a}. (Read a, Num a) => Text -> a
readN (Text -> Text
T.reverse Text
num') in
Text -> Name
UN (Text
nm Text -> Text -> Text
`T.append` String -> Text
txt (forall a. Show a => a -> String
show (Integer
numforall a. Num a => a -> a -> a
+Integer
1)))
where
readN :: Text -> a
readN Text
x | Bool -> Bool
not (Text -> Bool
T.null Text
x) = forall a. Read a => String -> a
read (Text -> String
T.unpack Text
x)
readN Text
x = a
0
nextName (SN SpecialName
x) = SpecialName -> Name
SN (SpecialName -> SpecialName
nextName' SpecialName
x)
where
nextName' :: SpecialName -> SpecialName
nextName' (WhereN Int
i Name
f Name
x) = Int -> Name -> Name -> SpecialName
WhereN Int
i Name
f (Name -> Name
nextName Name
x)
nextName' (WithN Int
i Name
n) = Int -> Name -> SpecialName
WithN Int
i (Name -> Name
nextName Name
n)
nextName' (ImplementationN Name
n [Text]
ns) = Name -> [Text] -> SpecialName
ImplementationN (Name -> Name
nextName Name
n) [Text]
ns
nextName' (ParentN Name
n Text
ns) = Name -> Text -> SpecialName
ParentN (Name -> Name
nextName Name
n) Text
ns
nextName' (CaseN FC'
fc Name
n) = FC' -> Name -> SpecialName
CaseN FC'
fc (Name -> Name
nextName Name
n)
nextName' (MethodN Name
n) = Name -> SpecialName
MethodN (Name -> Name
nextName Name
n)
nextName' (ImplementationCtorN Name
n) = Name -> SpecialName
ImplementationCtorN (Name -> Name
nextName Name
n)
nextName' (MetaN Name
parent Name
meta) = Name -> Name -> SpecialName
MetaN Name
parent (Name -> Name
nextName Name
meta)
nextName (SymRef Int
i) = forall a. HasCallStack => String -> a
error String
"Can't generate a name from a symbol reference"
type Term = TT Name
type Type = Term
type Env = EnvTT Name
newtype WkEnvTT n = Wk (EnvTT n)
type WkEnv = WkEnvTT Name
instance (Eq n, Show n) => Show (TT n) where
show :: TT n -> String
show TT n
t = forall n. (Eq n, Show n) => EnvTT n -> TT n -> String
showEnv [] TT n
t
itBitsName :: NativeTy -> String
itBitsName NativeTy
IT8 = String
"Bits8"
itBitsName NativeTy
IT16 = String
"Bits16"
itBitsName NativeTy
IT32 = String
"Bits32"
itBitsName NativeTy
IT64 = String
"Bits64"
instance Show Const where
show :: Const -> String
show (I Int
i) = forall a. Show a => a -> String
show Int
i
show (BI Integer
i) = forall a. Show a => a -> String
show Integer
i
show (Fl Double
f) = forall a. Show a => a -> String
show Double
f
show (Ch Char
c) = forall a. Show a => a -> String
show Char
c
show (Str String
s) = forall a. Show a => a -> String
show String
s
show (B8 Word8
x) = forall a. Show a => a -> String
show Word8
x
show (B16 Word16
x) = forall a. Show a => a -> String
show Word16
x
show (B32 Word32
x) = forall a. Show a => a -> String
show Word32
x
show (B64 Word64
x) = forall a. Show a => a -> String
show Word64
x
show (AType ArithTy
ATFloat) = String
"Double"
show (AType (ATInt IntTy
ITBig)) = String
"Integer"
show (AType (ATInt IntTy
ITNative)) = String
"Int"
show (AType (ATInt IntTy
ITChar)) = String
"Char"
show (AType (ATInt (ITFixed NativeTy
it))) = NativeTy -> String
itBitsName NativeTy
it
show Const
TheWorld = String
"prim__TheWorld"
show Const
WorldType = String
"prim__WorldType"
show Const
StrType = String
"String"
show Const
VoidType = String
"Void"
show Const
Forgot = String
"Forgot"
showEnv :: (Eq n, Show n) => EnvTT n -> TT n -> String
showEnv :: forall n. (Eq n, Show n) => EnvTT n -> TT n -> String
showEnv EnvTT n
env TT n
t = forall {a}.
(Show a, Eq a) =>
[(a, RigCount, Binder (TT a))] -> TT a -> Bool -> String
showEnv' EnvTT n
env TT n
t Bool
False
showEnvDbg :: [(a, RigCount, Binder (TT a))] -> TT a -> String
showEnvDbg [(a, RigCount, Binder (TT a))]
env TT a
t = forall {a}.
(Show a, Eq a) =>
[(a, RigCount, Binder (TT a))] -> TT a -> Bool -> String
showEnv' [(a, RigCount, Binder (TT a))]
env TT a
t Bool
True
prettyEnv :: Env -> Term -> Doc OutputAnnotation
prettyEnv :: Env -> TT Name -> Doc OutputAnnotation
prettyEnv Env
env TT Name
t = forall {a} {a}.
(Show a, Pretty a a, Pretty NameType a, Pretty Const a, Eq a) =>
[(a, RigCount, Binder (TT a))] -> TT a -> Bool -> Doc a
prettyEnv' Env
env TT Name
t Bool
False
where
prettyEnv' :: [(a, RigCount, Binder (TT a))] -> TT a -> Bool -> Doc a
prettyEnv' [(a, RigCount, Binder (TT a))]
env TT a
t Bool
dbg = forall {t} {a} {a}.
(Num t, Show a, Ord t, Pretty a a, Pretty NameType a,
Pretty Const a, Eq a) =>
t -> [(a, RigCount, Binder (TT a))] -> TT a -> Bool -> Doc a
prettySe Integer
10 [(a, RigCount, Binder (TT a))]
env TT a
t Bool
dbg
bracket :: a -> a -> Doc a -> Doc a
bracket a
outer a
inner Doc a
p
| a
inner forall a. Ord a => a -> a -> Bool
> a
outer = forall a. Doc a
lparen forall a. Doc a -> Doc a -> Doc a
<> Doc a
p forall a. Doc a -> Doc a -> Doc a
<> forall a. Doc a
rparen
| Bool
otherwise = Doc a
p
prettySe :: t -> [(a, RigCount, Binder (TT a))] -> TT a -> Bool -> Doc a
prettySe t
p [(a, RigCount, Binder (TT a))]
env (P NameType
nt a
n TT a
t) Bool
debug =
forall a ty. Pretty a ty => a -> Doc ty
pretty a
n forall a. Doc a -> Doc a -> Doc a
<+>
if Bool
debug then
forall a. Doc a
lbracket forall a. Doc a -> Doc a -> Doc a
<+> forall a ty. Pretty a ty => a -> Doc ty
pretty NameType
nt forall a. Doc a -> Doc a -> Doc a
<+> forall a. Doc a
colon forall a. Doc a -> Doc a -> Doc a
<+> t -> [(a, RigCount, Binder (TT a))] -> TT a -> Bool -> Doc a
prettySe t
10 [(a, RigCount, Binder (TT a))]
env TT a
t Bool
debug forall a. Doc a -> Doc a -> Doc a
<+> forall a. Doc a
rbracket
else
forall a. Doc a
empty
prettySe t
p [(a, RigCount, Binder (TT a))]
env (V Int
i) Bool
debug
| Int
i forall a. Ord a => a -> a -> Bool
< forall (t :: * -> *) a. Foldable t => t a -> Int
length [(a, RigCount, Binder (TT a))]
env =
if Bool
debug then
forall a. String -> Doc a
text forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Show a => a -> String
show forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall {a} {b} {c}. (a, b, c) -> a
fstEnv forall a b. (a -> b) -> a -> b
$ [(a, RigCount, Binder (TT a))]
envforall a. [a] -> Int -> a
!!Int
i
else
forall a. Doc a
lbracket forall a. Doc a -> Doc a -> Doc a
<+> forall a. String -> Doc a
text (forall a. Show a => a -> String
show Int
i) forall a. Doc a -> Doc a -> Doc a
<+> forall a. Doc a
rbracket
| Bool
otherwise = forall a. String -> Doc a
text String
"unbound" forall a. Doc a -> Doc a -> Doc a
<+> forall a. String -> Doc a
text (forall a. Show a => a -> String
show Int
i) forall a. Doc a -> Doc a -> Doc a
<+> forall a. String -> Doc a
text String
"!"
prettySe t
p [(a, RigCount, Binder (TT a))]
env (Bind a
n b :: Binder (TT a)
b@(Pi RigCount
_ Maybe ImplicitInfo
_ TT a
t TT a
_) TT a
sc) Bool
debug
| forall n. Eq n => n -> TT n -> Bool
noOccurrence a
n TT a
sc Bool -> Bool -> Bool
&& Bool -> Bool
not Bool
debug =
forall {a} {a}. Ord a => a -> a -> Doc a -> Doc a
bracket t
p t
2 forall a b. (a -> b) -> a -> b
$ [(a, RigCount, Binder (TT a))]
-> a -> Binder (TT a) -> Bool -> Doc a
prettySb [(a, RigCount, Binder (TT a))]
env a
n Binder (TT a)
b Bool
debug forall a. Doc a -> Doc a -> Doc a
<> t -> [(a, RigCount, Binder (TT a))] -> TT a -> Bool -> Doc a
prettySe t
10 ((a
n, RigCount
Rig0, Binder (TT a)
b)forall a. a -> [a] -> [a]
:[(a, RigCount, Binder (TT a))]
env) TT a
sc Bool
debug
prettySe t
p [(a, RigCount, Binder (TT a))]
env (Bind a
n Binder (TT a)
b TT a
sc) Bool
debug =
forall {a} {a}. Ord a => a -> a -> Doc a -> Doc a
bracket t
p t
2 forall a b. (a -> b) -> a -> b
$ [(a, RigCount, Binder (TT a))]
-> a -> Binder (TT a) -> Bool -> Doc a
prettySb [(a, RigCount, Binder (TT a))]
env a
n Binder (TT a)
b Bool
debug forall a. Doc a -> Doc a -> Doc a
<> t -> [(a, RigCount, Binder (TT a))] -> TT a -> Bool -> Doc a
prettySe t
10 ((a
n, RigCount
Rig0, Binder (TT a)
b)forall a. a -> [a] -> [a]
:[(a, RigCount, Binder (TT a))]
env) TT a
sc Bool
debug
prettySe t
p [(a, RigCount, Binder (TT a))]
env (App AppStatus a
_ TT a
f TT a
a) Bool
debug =
forall {a} {a}. Ord a => a -> a -> Doc a -> Doc a
bracket t
p t
1 forall a b. (a -> b) -> a -> b
$ t -> [(a, RigCount, Binder (TT a))] -> TT a -> Bool -> Doc a
prettySe t
1 [(a, RigCount, Binder (TT a))]
env TT a
f Bool
debug forall a. Doc a -> Doc a -> Doc a
<+> t -> [(a, RigCount, Binder (TT a))] -> TT a -> Bool -> Doc a
prettySe t
0 [(a, RigCount, Binder (TT a))]
env TT a
a Bool
debug
prettySe t
p [(a, RigCount, Binder (TT a))]
env (Proj TT a
x Int
i) Bool
debug =
t -> [(a, RigCount, Binder (TT a))] -> TT a -> Bool -> Doc a
prettySe t
1 [(a, RigCount, Binder (TT a))]
env TT a
x Bool
debug forall a. Doc a -> Doc a -> Doc a
<+> forall a. String -> Doc a
text (String
"!" forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show Int
i)
prettySe t
p [(a, RigCount, Binder (TT a))]
env (Constant Const
c) Bool
debug = forall a ty. Pretty a ty => a -> Doc ty
pretty Const
c
prettySe t
p [(a, RigCount, Binder (TT a))]
env TT a
Erased Bool
debug = forall a. String -> Doc a
text String
"[_]"
prettySe t
p [(a, RigCount, Binder (TT a))]
env (TType UExp
i) Bool
debug = forall a. String -> Doc a
text String
"Type" forall a. Doc a -> Doc a -> Doc a
<+> (forall a. String -> Doc a
text forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Show a => a -> String
show forall a b. (a -> b) -> a -> b
$ UExp
i)
prettySe t
p [(a, RigCount, Binder (TT a))]
env TT a
Impossible Bool
debug = forall a. String -> Doc a
text String
"Impossible"
prettySe t
p [(a, RigCount, Binder (TT a))]
env (Inferred TT a
tm) Bool
debug = forall a. String -> Doc a
text String
"<" forall a. Doc a -> Doc a -> Doc a
<+> t -> [(a, RigCount, Binder (TT a))] -> TT a -> Bool -> Doc a
prettySe t
p [(a, RigCount, Binder (TT a))]
env TT a
tm Bool
debug forall a. Doc a -> Doc a -> Doc a
<+> forall a. String -> Doc a
text String
">"
prettySe t
p [(a, RigCount, Binder (TT a))]
env (UType Universe
u) Bool
debug = forall a. String -> Doc a
text (forall a. Show a => a -> String
show Universe
u)
prettySb :: [(a, RigCount, Binder (TT a))]
-> a -> Binder (TT a) -> Bool -> Doc a
prettySb [(a, RigCount, Binder (TT a))]
env a
n (Lam RigCount
_ TT a
t) = [(a, RigCount, Binder (TT a))]
-> String -> String -> a -> TT a -> Bool -> Doc a
prettyB [(a, RigCount, Binder (TT a))]
env String
"λ" String
"=>" a
n TT a
t
prettySb [(a, RigCount, Binder (TT a))]
env a
n (Hole TT a
t) = [(a, RigCount, Binder (TT a))]
-> String -> String -> a -> TT a -> Bool -> Doc a
prettyB [(a, RigCount, Binder (TT a))]
env String
"?defer" String
"." a
n TT a
t
prettySb [(a, RigCount, Binder (TT a))]
env a
n (GHole Int
_ [Name]
_ TT a
t) = [(a, RigCount, Binder (TT a))]
-> String -> String -> a -> TT a -> Bool -> Doc a
prettyB [(a, RigCount, Binder (TT a))]
env String
"?gdefer" String
"." a
n TT a
t
prettySb [(a, RigCount, Binder (TT a))]
env a
n (Pi RigCount
Rig0 Maybe ImplicitInfo
_ TT a
t TT a
_) = [(a, RigCount, Binder (TT a))]
-> String -> String -> a -> TT a -> Bool -> Doc a
prettyB [(a, RigCount, Binder (TT a))]
env String
"(" String
") ->" a
n TT a
t
prettySb [(a, RigCount, Binder (TT a))]
env a
n (Pi RigCount
Rig1 Maybe ImplicitInfo
_ TT a
t TT a
_) = [(a, RigCount, Binder (TT a))]
-> String -> String -> a -> TT a -> Bool -> Doc a
prettyB [(a, RigCount, Binder (TT a))]
env String
"(" String
") -o" a
n TT a
t
prettySb [(a, RigCount, Binder (TT a))]
env a
n (Pi RigCount
RigW Maybe ImplicitInfo
_ TT a
t TT a
_) = [(a, RigCount, Binder (TT a))]
-> String -> String -> a -> TT a -> Bool -> Doc a
prettyB [(a, RigCount, Binder (TT a))]
env String
"(" String
") ->" a
n TT a
t
prettySb [(a, RigCount, Binder (TT a))]
env a
n (PVar RigCount
Rig1 TT a
t) = [(a, RigCount, Binder (TT a))]
-> String -> String -> a -> TT a -> Bool -> Doc a
prettyB [(a, RigCount, Binder (TT a))]
env String
"pat 1 " String
"." a
n TT a
t
prettySb [(a, RigCount, Binder (TT a))]
env a
n (PVar RigCount
_ TT a
t) = [(a, RigCount, Binder (TT a))]
-> String -> String -> a -> TT a -> Bool -> Doc a
prettyB [(a, RigCount, Binder (TT a))]
env String
"pat" String
"." a
n TT a
t
prettySb [(a, RigCount, Binder (TT a))]
env a
n (PVTy TT a
t) = [(a, RigCount, Binder (TT a))]
-> String -> String -> a -> TT a -> Bool -> Doc a
prettyB [(a, RigCount, Binder (TT a))]
env String
"pty" String
"." a
n TT a
t
prettySb [(a, RigCount, Binder (TT a))]
env a
n (Let RigCount
Rig1 TT a
t TT a
v) = [(a, RigCount, Binder (TT a))]
-> String -> String -> a -> TT a -> TT a -> Bool -> Doc a
prettyBv [(a, RigCount, Binder (TT a))]
env String
"let 1 " String
"in" a
n TT a
t TT a
v
prettySb [(a, RigCount, Binder (TT a))]
env a
n (Let RigCount
_ TT a
t TT a
v) = [(a, RigCount, Binder (TT a))]
-> String -> String -> a -> TT a -> TT a -> Bool -> Doc a
prettyBv [(a, RigCount, Binder (TT a))]
env String
"let" String
"in" a
n TT a
t TT a
v
prettySb [(a, RigCount, Binder (TT a))]
env a
n (NLet TT a
t TT a
v) = [(a, RigCount, Binder (TT a))]
-> String -> String -> a -> TT a -> TT a -> Bool -> Doc a
prettyBv [(a, RigCount, Binder (TT a))]
env String
"nlet" String
"in" a
n TT a
t TT a
v
prettySb [(a, RigCount, Binder (TT a))]
env a
n (Guess TT a
t TT a
v) = [(a, RigCount, Binder (TT a))]
-> String -> String -> a -> TT a -> TT a -> Bool -> Doc a
prettyBv [(a, RigCount, Binder (TT a))]
env String
"??" String
"in" a
n TT a
t TT a
v
prettyB :: [(a, RigCount, Binder (TT a))]
-> String -> String -> a -> TT a -> Bool -> Doc a
prettyB [(a, RigCount, Binder (TT a))]
env String
op String
sc a
n TT a
t Bool
debug =
forall a. String -> Doc a
text String
op forall a. Doc a -> Doc a -> Doc a
<> forall a ty. Pretty a ty => a -> Doc ty
pretty a
n forall a. Doc a -> Doc a -> Doc a
<+> forall a. Doc a
colon forall a. Doc a -> Doc a -> Doc a
<+> t -> [(a, RigCount, Binder (TT a))] -> TT a -> Bool -> Doc a
prettySe t
10 [(a, RigCount, Binder (TT a))]
env TT a
t Bool
debug forall a. Doc a -> Doc a -> Doc a
<> forall a. String -> Doc a
text String
sc
prettyBv :: [(a, RigCount, Binder (TT a))]
-> String -> String -> a -> TT a -> TT a -> Bool -> Doc a
prettyBv [(a, RigCount, Binder (TT a))]
env String
op String
sc a
n TT a
t TT a
v Bool
debug =
forall a. String -> Doc a
text String
op forall a. Doc a -> Doc a -> Doc a
<> forall a ty. Pretty a ty => a -> Doc ty
pretty a
n forall a. Doc a -> Doc a -> Doc a
<+> forall a. Doc a
colon forall a. Doc a -> Doc a -> Doc a
<+> t -> [(a, RigCount, Binder (TT a))] -> TT a -> Bool -> Doc a
prettySe t
10 [(a, RigCount, Binder (TT a))]
env TT a
t Bool
debug forall a. Doc a -> Doc a -> Doc a
<+> forall a. String -> Doc a
text String
"=" forall a. Doc a -> Doc a -> Doc a
<+>
t -> [(a, RigCount, Binder (TT a))] -> TT a -> Bool -> Doc a
prettySe t
10 [(a, RigCount, Binder (TT a))]
env TT a
v Bool
debug forall a. Doc a -> Doc a -> Doc a
<> forall a. String -> Doc a
text String
sc
showEnv' :: [(a, RigCount, Binder (TT a))] -> TT a -> Bool -> String
showEnv' [(a, RigCount, Binder (TT a))]
env TT a
t Bool
dbg = forall {a} {t}.
(Show a, Num t, Ord t, Eq a) =>
t -> [(a, RigCount, Binder (TT a))] -> TT a -> String
se Integer
10 [(a, RigCount, Binder (TT a))]
env TT a
t where
se :: t -> [(a, RigCount, Binder (TT a))] -> TT a -> String
se t
p [(a, RigCount, Binder (TT a))]
env (P NameType
nt a
n TT a
t) = forall a. Show a => a -> String
show a
n
forall a. [a] -> [a] -> [a]
++ if Bool
dbg then String
"{" forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show NameType
nt forall a. [a] -> [a] -> [a]
++ String
" : " forall a. [a] -> [a] -> [a]
++ t -> [(a, RigCount, Binder (TT a))] -> TT a -> String
se t
10 [(a, RigCount, Binder (TT a))]
env TT a
t forall a. [a] -> [a] -> [a]
++ String
"}" else String
""
se t
p [(a, RigCount, Binder (TT a))]
env (V Int
i) | Int
i forall a. Ord a => a -> a -> Bool
< forall (t :: * -> *) a. Foldable t => t a -> Int
length [(a, RigCount, Binder (TT a))]
env Bool -> Bool -> Bool
&& Int
i forall a. Ord a => a -> a -> Bool
>= Int
0
= (forall a. Show a => a -> String
show forall a b. (a -> b) -> a -> b
$ forall {a} {b} {c}. (a, b, c) -> a
fstEnv forall a b. (a -> b) -> a -> b
$ [(a, RigCount, Binder (TT a))]
envforall a. [a] -> Int -> a
!!Int
i) forall a. [a] -> [a] -> [a]
++
if Bool
dbg then String
"{" forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show Int
i forall a. [a] -> [a] -> [a]
++ String
"}" else String
""
| Bool
otherwise = String
"!!V " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show Int
i forall a. [a] -> [a] -> [a]
++ String
"!!"
se t
p [(a, RigCount, Binder (TT a))]
env (Bind a
n b :: Binder (TT a)
b@(Pi RigCount
rig (Just ImplicitInfo
_) TT a
t TT a
k) TT a
sc)
= forall {a}. Ord a => a -> a -> ShowS
bracket t
p t
2 forall a b. (a -> b) -> a -> b
$ [(a, RigCount, Binder (TT a))] -> a -> Binder (TT a) -> String
sb [(a, RigCount, Binder (TT a))]
env a
n Binder (TT a)
b forall a. [a] -> [a] -> [a]
++ t -> [(a, RigCount, Binder (TT a))] -> TT a -> String
se t
10 ((a
n, RigCount
rig, Binder (TT a)
b)forall a. a -> [a] -> [a]
:[(a, RigCount, Binder (TT a))]
env) TT a
sc
se t
p [(a, RigCount, Binder (TT a))]
env (Bind a
n b :: Binder (TT a)
b@(Pi RigCount
rig Maybe ImplicitInfo
_ TT a
t TT a
k) TT a
sc)
| forall n. Eq n => n -> TT n -> Bool
noOccurrence a
n TT a
sc Bool -> Bool -> Bool
&& Bool -> Bool
not Bool
dbg = forall {a}. Ord a => a -> a -> ShowS
bracket t
p t
2 forall a b. (a -> b) -> a -> b
$ t -> [(a, RigCount, Binder (TT a))] -> TT a -> String
se t
1 [(a, RigCount, Binder (TT a))]
env TT a
t forall a. [a] -> [a] -> [a]
++ RigCount -> String
arrow RigCount
rig forall a. [a] -> [a] -> [a]
++ t -> [(a, RigCount, Binder (TT a))] -> TT a -> String
se t
10 ((a
n,RigCount
Rig0,Binder (TT a)
b)forall a. a -> [a] -> [a]
:[(a, RigCount, Binder (TT a))]
env) TT a
sc
where arrow :: RigCount -> String
arrow RigCount
Rig0 = String
" 0-> "
arrow RigCount
Rig1 = String
" -o "
arrow RigCount
RigW = String
" -> "
se t
p [(a, RigCount, Binder (TT a))]
env (Bind a
n Binder (TT a)
b TT a
sc) = forall {a}. Ord a => a -> a -> ShowS
bracket t
p t
2 forall a b. (a -> b) -> a -> b
$ [(a, RigCount, Binder (TT a))] -> a -> Binder (TT a) -> String
sb [(a, RigCount, Binder (TT a))]
env a
n Binder (TT a)
b forall a. [a] -> [a] -> [a]
++ t -> [(a, RigCount, Binder (TT a))] -> TT a -> String
se t
10 ((a
n,RigCount
Rig0,Binder (TT a)
b)forall a. a -> [a] -> [a]
:[(a, RigCount, Binder (TT a))]
env) TT a
sc
se t
p [(a, RigCount, Binder (TT a))]
env (App AppStatus a
_ TT a
f TT a
a) = forall {a}. Ord a => a -> a -> ShowS
bracket t
p t
1 forall a b. (a -> b) -> a -> b
$ t -> [(a, RigCount, Binder (TT a))] -> TT a -> String
se t
1 [(a, RigCount, Binder (TT a))]
env TT a
f forall a. [a] -> [a] -> [a]
++ String
" " forall a. [a] -> [a] -> [a]
++ t -> [(a, RigCount, Binder (TT a))] -> TT a -> String
se t
0 [(a, RigCount, Binder (TT a))]
env TT a
a
se t
p [(a, RigCount, Binder (TT a))]
env (Proj TT a
x Int
i) = t -> [(a, RigCount, Binder (TT a))] -> TT a -> String
se t
1 [(a, RigCount, Binder (TT a))]
env TT a
x forall a. [a] -> [a] -> [a]
++ String
"!" forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show Int
i
se t
p [(a, RigCount, Binder (TT a))]
env (Constant Const
c) = forall a. Show a => a -> String
show Const
c
se t
p [(a, RigCount, Binder (TT a))]
env TT a
Erased = String
"[__]"
se t
p [(a, RigCount, Binder (TT a))]
env TT a
Impossible = String
"[impossible]"
se t
p [(a, RigCount, Binder (TT a))]
env (Inferred TT a
t) = String
"<" forall a. [a] -> [a] -> [a]
++ t -> [(a, RigCount, Binder (TT a))] -> TT a -> String
se t
p [(a, RigCount, Binder (TT a))]
env TT a
t forall a. [a] -> [a] -> [a]
++ String
">"
se t
p [(a, RigCount, Binder (TT a))]
env (TType UExp
i) = String
"Type " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show UExp
i
se t
p [(a, RigCount, Binder (TT a))]
env (UType Universe
u) = forall a. Show a => a -> String
show Universe
u
sb :: [(a, RigCount, Binder (TT a))] -> a -> Binder (TT a) -> String
sb [(a, RigCount, Binder (TT a))]
env a
n (Lam RigCount
Rig1 TT a
t) = [(a, RigCount, Binder (TT a))]
-> String -> String -> a -> TT a -> String
showb [(a, RigCount, Binder (TT a))]
env String
"\\ 1 " String
" => " a
n TT a
t
sb [(a, RigCount, Binder (TT a))]
env a
n (Lam RigCount
_ TT a
t) = [(a, RigCount, Binder (TT a))]
-> String -> String -> a -> TT a -> String
showb [(a, RigCount, Binder (TT a))]
env String
"\\ " String
" => " a
n TT a
t
sb [(a, RigCount, Binder (TT a))]
env a
n (Hole TT a
t) = [(a, RigCount, Binder (TT a))]
-> String -> String -> a -> TT a -> String
showb [(a, RigCount, Binder (TT a))]
env String
"? " String
". " a
n TT a
t
sb [(a, RigCount, Binder (TT a))]
env a
n (GHole Int
i [Name]
ns TT a
t) = [(a, RigCount, Binder (TT a))]
-> String -> String -> a -> TT a -> String
showb [(a, RigCount, Binder (TT a))]
env String
"?defer " String
". " a
n TT a
t
sb [(a, RigCount, Binder (TT a))]
env a
n (Pi RigCount
Rig1 (Just ImplicitInfo
_) TT a
t TT a
_) = [(a, RigCount, Binder (TT a))]
-> String -> String -> a -> TT a -> String
showb [(a, RigCount, Binder (TT a))]
env String
"{" String
"} -o " a
n TT a
t
sb [(a, RigCount, Binder (TT a))]
env a
n (Pi RigCount
_ (Just ImplicitInfo
_) TT a
t TT a
_) = [(a, RigCount, Binder (TT a))]
-> String -> String -> a -> TT a -> String
showb [(a, RigCount, Binder (TT a))]
env String
"{" String
"} -> " a
n TT a
t
sb [(a, RigCount, Binder (TT a))]
env a
n (Pi RigCount
Rig1 Maybe ImplicitInfo
_ TT a
t TT a
_) = [(a, RigCount, Binder (TT a))]
-> String -> String -> a -> TT a -> String
showb [(a, RigCount, Binder (TT a))]
env String
"(" String
") -0 " a
n TT a
t
sb [(a, RigCount, Binder (TT a))]
env a
n (Pi RigCount
_ Maybe ImplicitInfo
_ TT a
t TT a
_) = [(a, RigCount, Binder (TT a))]
-> String -> String -> a -> TT a -> String
showb [(a, RigCount, Binder (TT a))]
env String
"(" String
") -> " a
n TT a
t
sb [(a, RigCount, Binder (TT a))]
env a
n (PVar RigCount
Rig0 TT a
t) = [(a, RigCount, Binder (TT a))]
-> String -> String -> a -> TT a -> String
showb [(a, RigCount, Binder (TT a))]
env String
"pat 0 " String
". " a
n TT a
t
sb [(a, RigCount, Binder (TT a))]
env a
n (PVar RigCount
Rig1 TT a
t) = [(a, RigCount, Binder (TT a))]
-> String -> String -> a -> TT a -> String
showb [(a, RigCount, Binder (TT a))]
env String
"pat 1 " String
". " a
n TT a
t
sb [(a, RigCount, Binder (TT a))]
env a
n (PVar RigCount
_ TT a
t) = [(a, RigCount, Binder (TT a))]
-> String -> String -> a -> TT a -> String
showb [(a, RigCount, Binder (TT a))]
env String
"pat " String
". " a
n TT a
t
sb [(a, RigCount, Binder (TT a))]
env a
n (PVTy TT a
t) = [(a, RigCount, Binder (TT a))]
-> String -> String -> a -> TT a -> String
showb [(a, RigCount, Binder (TT a))]
env String
"pty " String
". " a
n TT a
t
sb [(a, RigCount, Binder (TT a))]
env a
n (Let RigCount
Rig0 TT a
t TT a
v) = [(a, RigCount, Binder (TT a))]
-> String -> String -> a -> TT a -> TT a -> String
showbv [(a, RigCount, Binder (TT a))]
env String
"let 0 " String
" in " a
n TT a
t TT a
v
sb [(a, RigCount, Binder (TT a))]
env a
n (Let RigCount
Rig1 TT a
t TT a
v) = [(a, RigCount, Binder (TT a))]
-> String -> String -> a -> TT a -> TT a -> String
showbv [(a, RigCount, Binder (TT a))]
env String
"let 1 " String
" in " a
n TT a
t TT a
v
sb [(a, RigCount, Binder (TT a))]
env a
n (Let RigCount
_ TT a
t TT a
v) = [(a, RigCount, Binder (TT a))]
-> String -> String -> a -> TT a -> TT a -> String
showbv [(a, RigCount, Binder (TT a))]
env String
"let " String
" in " a
n TT a
t TT a
v
sb [(a, RigCount, Binder (TT a))]
env a
n (NLet TT a
t TT a
v) = [(a, RigCount, Binder (TT a))]
-> String -> String -> a -> TT a -> TT a -> String
showbv [(a, RigCount, Binder (TT a))]
env String
"nlet " String
" in " a
n TT a
t TT a
v
sb [(a, RigCount, Binder (TT a))]
env a
n (Guess TT a
t TT a
v) = [(a, RigCount, Binder (TT a))]
-> String -> String -> a -> TT a -> TT a -> String
showbv [(a, RigCount, Binder (TT a))]
env String
"?? " String
" in " a
n TT a
t TT a
v
showb :: [(a, RigCount, Binder (TT a))]
-> String -> String -> a -> TT a -> String
showb [(a, RigCount, Binder (TT a))]
env String
op String
sc a
n TT a
t = String
op forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show a
n forall a. [a] -> [a] -> [a]
++ String
" : " forall a. [a] -> [a] -> [a]
++ t -> [(a, RigCount, Binder (TT a))] -> TT a -> String
se t
10 [(a, RigCount, Binder (TT a))]
env TT a
t forall a. [a] -> [a] -> [a]
++ String
sc
showbv :: [(a, RigCount, Binder (TT a))]
-> String -> String -> a -> TT a -> TT a -> String
showbv [(a, RigCount, Binder (TT a))]
env String
op String
sc a
n TT a
t TT a
v = String
op forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show a
n forall a. [a] -> [a] -> [a]
++ String
" : " forall a. [a] -> [a] -> [a]
++ t -> [(a, RigCount, Binder (TT a))] -> TT a -> String
se t
10 [(a, RigCount, Binder (TT a))]
env TT a
t forall a. [a] -> [a] -> [a]
++ String
" = " forall a. [a] -> [a] -> [a]
++
t -> [(a, RigCount, Binder (TT a))] -> TT a -> String
se t
10 [(a, RigCount, Binder (TT a))]
env TT a
v forall a. [a] -> [a] -> [a]
++ String
sc
bracket :: a -> a -> ShowS
bracket a
outer a
inner String
str | a
inner forall a. Ord a => a -> a -> Bool
> a
outer = String
"(" forall a. [a] -> [a] -> [a]
++ String
str forall a. [a] -> [a] -> [a]
++ String
")"
| Bool
otherwise = String
str
pureTerm :: TT Name -> Bool
pureTerm :: TT Name -> Bool
pureTerm (App AppStatus Name
_ TT Name
f TT Name
a) = TT Name -> Bool
pureTerm TT Name
f Bool -> Bool -> Bool
&& TT Name -> Bool
pureTerm TT Name
a
pureTerm (Bind Name
n Binder (TT Name)
b TT Name
sc) = Name -> Bool
notInterfaceName Name
n Bool -> Bool -> Bool
&& Binder (TT Name) -> Bool
pureBinder Binder (TT Name)
b Bool -> Bool -> Bool
&& TT Name -> Bool
pureTerm TT Name
sc where
pureBinder :: Binder (TT Name) -> Bool
pureBinder (Hole TT Name
_) = Bool
False
pureBinder (Guess TT Name
_ TT Name
_) = Bool
False
pureBinder (Let RigCount
c TT Name
t TT Name
v) = TT Name -> Bool
pureTerm TT Name
t Bool -> Bool -> Bool
&& TT Name -> Bool
pureTerm TT Name
v
pureBinder Binder (TT Name)
t = TT Name -> Bool
pureTerm (forall b. Binder b -> b
binderTy Binder (TT Name)
t)
notInterfaceName :: Name -> Bool
notInterfaceName (MN Int
_ Text
c) | Text
c forall a. Eq a => a -> a -> Bool
== String -> Text
txt String
"__interface" = Bool
False
notInterfaceName Name
_ = Bool
True
pureTerm TT Name
_ = Bool
True
weakenTm :: Int -> TT n -> TT n
weakenTm :: forall {n}. Int -> TT n -> TT n
weakenTm Int
i TT n
t = forall {n}. Int -> Int -> TT n -> TT n
wk Int
i Int
0 TT n
t
where wk :: Int -> Int -> TT n -> TT n
wk Int
i Int
min (V Int
x) | Int
x forall a. Ord a => a -> a -> Bool
>= Int
min = forall n. Int -> TT n
V (Int
i forall a. Num a => a -> a -> a
+ Int
x)
wk Int
i Int
m (App AppStatus n
s TT n
f TT n
a) = forall n. AppStatus n -> TT n -> TT n -> TT n
App AppStatus n
s (Int -> Int -> TT n -> TT n
wk Int
i Int
m TT n
f) (Int -> Int -> TT n -> TT n
wk Int
i Int
m TT n
a)
wk Int
i Int
m (Bind n
x Binder (TT n)
b TT n
sc) = forall n. n -> Binder (TT n) -> TT n -> TT n
Bind n
x (Int -> Int -> Binder (TT n) -> Binder (TT n)
wkb Int
i Int
m Binder (TT n)
b) (Int -> Int -> TT n -> TT n
wk Int
i (Int
m forall a. Num a => a -> a -> a
+ Int
1) TT n
sc)
wk Int
i Int
m TT n
t = TT n
t
wkb :: Int -> Int -> Binder (TT n) -> Binder (TT n)
wkb Int
i Int
m Binder (TT n)
t = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Int -> Int -> TT n -> TT n
wk Int
i Int
m) Binder (TT n)
t
weakenEnv :: EnvTT n -> EnvTT n
weakenEnv :: forall n. EnvTT n -> EnvTT n
weakenEnv EnvTT n
env = forall {a} {b} {n}.
Int -> [(a, b, Binder (TT n))] -> [(a, b, Binder (TT n))]
wk (forall (t :: * -> *) a. Foldable t => t a -> Int
length EnvTT n
env forall a. Num a => a -> a -> a
- Int
1) EnvTT n
env
where wk :: Int -> [(a, b, Binder (TT n))] -> [(a, b, Binder (TT n))]
wk Int
i [] = []
wk Int
i ((a
n, b
c, Binder (TT n)
b) : [(a, b, Binder (TT n))]
bs) = (a
n, b
c, forall {n}. Int -> Binder (TT n) -> Binder (TT n)
weakenTmB Int
i Binder (TT n)
b) forall a. a -> [a] -> [a]
: Int -> [(a, b, Binder (TT n))] -> [(a, b, Binder (TT n))]
wk (Int
i forall a. Num a => a -> a -> a
- Int
1) [(a, b, Binder (TT n))]
bs
weakenTmB :: Int -> Binder (TT n) -> Binder (TT n)
weakenTmB Int
i (Let RigCount
c TT n
t TT n
v) = forall b. RigCount -> b -> b -> Binder b
Let RigCount
c (forall {n}. Int -> TT n -> TT n
weakenTm Int
i TT n
t) (forall {n}. Int -> TT n -> TT n
weakenTm Int
i TT n
v)
weakenTmB Int
i (Guess TT n
t TT n
v) = forall b. b -> b -> Binder b
Guess (forall {n}. Int -> TT n -> TT n
weakenTm Int
i TT n
t) (forall {n}. Int -> TT n -> TT n
weakenTm Int
i TT n
v)
weakenTmB Int
i Binder (TT n)
t = Binder (TT n)
t { binderTy :: TT n
binderTy = forall {n}. Int -> TT n -> TT n
weakenTm Int
i (forall b. Binder b -> b
binderTy Binder (TT n)
t) }
weakenTmEnv :: Int -> EnvTT n -> EnvTT n
weakenTmEnv :: forall n. Int -> EnvTT n -> EnvTT n
weakenTmEnv Int
i = forall a b. (a -> b) -> [a] -> [b]
map (\ (n
n, RigCount
c, Binder (TT n)
b) -> (n
n, RigCount
c, forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (forall {n}. Int -> TT n -> TT n
weakenTm Int
i) Binder (TT n)
b))
refsIn :: TT Name -> [Name]
refsIn :: TT Name -> [Name]
refsIn (P NameType
_ Name
n TT Name
_) = [Name
n]
refsIn (Bind Name
n Binder (TT Name)
b TT Name
t) = forall a. Eq a => [a] -> [a]
nub forall a b. (a -> b) -> a -> b
$ Binder (TT Name) -> [Name]
nb Binder (TT Name)
b forall a. [a] -> [a] -> [a]
++ TT Name -> [Name]
refsIn TT Name
t
where nb :: Binder (TT Name) -> [Name]
nb (Let RigCount
_ TT Name
t TT Name
v) = forall a. Eq a => [a] -> [a]
nub (TT Name -> [Name]
refsIn TT Name
t) forall a. [a] -> [a] -> [a]
++ forall a. Eq a => [a] -> [a]
nub (TT Name -> [Name]
refsIn TT Name
v)
nb (Guess TT Name
t TT Name
v) = forall a. Eq a => [a] -> [a]
nub (TT Name -> [Name]
refsIn TT Name
t) forall a. [a] -> [a] -> [a]
++ forall a. Eq a => [a] -> [a]
nub (TT Name -> [Name]
refsIn TT Name
v)
nb Binder (TT Name)
t = TT Name -> [Name]
refsIn (forall b. Binder b -> b
binderTy Binder (TT Name)
t)
refsIn (App AppStatus Name
s TT Name
f TT Name
a) = forall a. Eq a => [a] -> [a]
nub (TT Name -> [Name]
refsIn TT Name
f forall a. [a] -> [a] -> [a]
++ TT Name -> [Name]
refsIn TT Name
a)
refsIn TT Name
_ = []
allTTNames :: Eq n => TT n -> [n]
allTTNames :: forall n. Eq n => TT n -> [n]
allTTNames = forall a. Eq a => [a] -> [a]
nub forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall {a}. TT a -> [a]
allNamesIn
where allNamesIn :: TT a -> [a]
allNamesIn (P NameType
_ a
n TT a
_) = [a
n]
allNamesIn (Bind a
n Binder (TT a)
b TT a
t) = [a
n] forall a. [a] -> [a] -> [a]
++ Binder (TT a) -> [a]
nb Binder (TT a)
b forall a. [a] -> [a] -> [a]
++ TT a -> [a]
allNamesIn TT a
t
where nb :: Binder (TT a) -> [a]
nb (Let RigCount
_ TT a
t TT a
v) = TT a -> [a]
allNamesIn TT a
t forall a. [a] -> [a] -> [a]
++ TT a -> [a]
allNamesIn TT a
v
nb (Guess TT a
t TT a
v) = TT a -> [a]
allNamesIn TT a
t forall a. [a] -> [a] -> [a]
++ TT a -> [a]
allNamesIn TT a
v
nb Binder (TT a)
t = TT a -> [a]
allNamesIn (forall b. Binder b -> b
binderTy Binder (TT a)
t)
allNamesIn (App AppStatus a
_ TT a
f TT a
a) = TT a -> [a]
allNamesIn TT a
f forall a. [a] -> [a] -> [a]
++ TT a -> [a]
allNamesIn TT a
a
allNamesIn TT a
_ = []
pprintTT :: [Name]
-> TT Name
-> Doc OutputAnnotation
pprintTT :: [Name] -> TT Name -> Doc OutputAnnotation
pprintTT [Name]
bound TT Name
tm = Integer -> [Name] -> TT Name -> Doc OutputAnnotation
pp Integer
startPrec [Name]
bound TT Name
tm
where
startPrec :: Integer
startPrec = Integer
0
appPrec :: Integer
appPrec = Integer
10
pp :: Integer -> [Name] -> TT Name -> Doc OutputAnnotation
pp Integer
p [Name]
bound (P NameType
Bound Name
n TT Name
ty) = forall a. a -> Doc a -> Doc a
annotate (Name -> Bool -> OutputAnnotation
AnnBoundName Name
n Bool
False) (forall a. String -> Doc a
text forall a b. (a -> b) -> a -> b
$ forall a. Show a => a -> String
show Name
n)
pp Integer
p [Name]
bound (P NameType
nt Name
n TT Name
ty) = forall a. a -> Doc a -> Doc a
annotate (Name
-> Maybe NameOutput
-> Maybe String
-> Maybe String
-> OutputAnnotation
AnnName Name
n forall a. Maybe a
Nothing forall a. Maybe a
Nothing forall a. Maybe a
Nothing)
(forall a. String -> Doc a
text forall a b. (a -> b) -> a -> b
$ forall a. Show a => a -> String
show Name
n)
pp Integer
p [Name]
bound (V Int
i)
| Int
i forall a. Ord a => a -> a -> Bool
< forall (t :: * -> *) a. Foldable t => t a -> Int
length [Name]
bound = let n :: Name
n = [Name]
bound forall a. [a] -> Int -> a
!! Int
i
in forall a. a -> Doc a -> Doc a
annotate (Name -> Bool -> OutputAnnotation
AnnBoundName Name
n Bool
False) (forall a. String -> Doc a
text forall a b. (a -> b) -> a -> b
$ forall a. Show a => a -> String
show Name
n)
| Bool
otherwise = forall a. String -> Doc a
text (String
"{{{V" forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show Int
i forall a. [a] -> [a] -> [a]
++ String
"}}}")
pp Integer
p [Name]
bound (Bind Name
n Binder (TT Name)
b TT Name
sc) = Integer
-> [Name]
-> Name
-> Binder (TT Name)
-> Doc OutputAnnotation
-> Doc OutputAnnotation
ppb Integer
p [Name]
bound Name
n Binder (TT Name)
b forall a b. (a -> b) -> a -> b
$
Integer -> [Name] -> TT Name -> Doc OutputAnnotation
pp Integer
startPrec (Name
nforall a. a -> [a] -> [a]
:[Name]
bound) TT Name
sc
pp Integer
p [Name]
bound (App AppStatus Name
_ TT Name
tm1 TT Name
tm2) =
forall {a} {a}. Ord a => a -> a -> Doc a -> Doc a
bracket Integer
p Integer
appPrec forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Doc a -> Doc a
group forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Int -> Doc a -> Doc a
hang Int
2 forall a b. (a -> b) -> a -> b
$
Integer -> [Name] -> TT Name -> Doc OutputAnnotation
pp Integer
appPrec [Name]
bound TT Name
tm1 forall a. Doc a -> Doc a -> Doc a
<> forall a. Doc a
line forall a. Doc a -> Doc a -> Doc a
<>
Integer -> [Name] -> TT Name -> Doc OutputAnnotation
pp (Integer
appPrec forall a. Num a => a -> a -> a
+ Integer
1) [Name]
bound TT Name
tm2
pp Integer
p [Name]
bound (Constant Const
c) = forall a. a -> Doc a -> Doc a
annotate (Const -> OutputAnnotation
AnnConst Const
c) (forall a. String -> Doc a
text (forall a. Show a => a -> String
show Const
c))
pp Integer
p [Name]
bound (Proj TT Name
tm Int
i) =
forall a. Doc a
lparen forall a. Doc a -> Doc a -> Doc a
<> Integer -> [Name] -> TT Name -> Doc OutputAnnotation
pp Integer
startPrec [Name]
bound TT Name
tm forall a. Doc a -> Doc a -> Doc a
<> forall a. Doc a
rparen forall a. Doc a -> Doc a -> Doc a
<>
forall a. String -> Doc a
text String
"!" forall a. Doc a -> Doc a -> Doc a
<> forall a. String -> Doc a
text (forall a. Show a => a -> String
show Int
i)
pp Integer
p [Name]
bound TT Name
Erased = forall a. String -> Doc a
text String
"<<<erased>>>"
pp Integer
p [Name]
bound TT Name
Impossible = forall a. String -> Doc a
text String
"<<<impossible>>>"
pp Integer
p [Name]
bound (Inferred TT Name
t) = forall a. String -> Doc a
text String
"<" forall a. Doc a -> Doc a -> Doc a
<+> Integer -> [Name] -> TT Name -> Doc OutputAnnotation
pp Integer
p [Name]
bound TT Name
t forall a. Doc a -> Doc a -> Doc a
<+> forall a. String -> Doc a
text String
">"
pp Integer
p [Name]
bound (TType UExp
ue) = forall a. a -> Doc a -> Doc a
annotate (String -> String -> OutputAnnotation
AnnType String
"Type" String
"The type of types") forall a b. (a -> b) -> a -> b
$
forall a. String -> Doc a
text String
"Type"
pp Integer
p [Name]
bound (UType Universe
u) = forall a. String -> Doc a
text (forall a. Show a => a -> String
show Universe
u)
ppb :: Integer
-> [Name]
-> Name
-> Binder (TT Name)
-> Doc OutputAnnotation
-> Doc OutputAnnotation
ppb Integer
p [Name]
bound Name
n (Lam RigCount
rig TT Name
ty) Doc OutputAnnotation
sc =
forall {a} {a}. Ord a => a -> a -> Doc a -> Doc a
bracket Integer
p Integer
startPrec forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Doc a -> Doc a
group forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Doc a -> Doc a
align forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Int -> Doc a -> Doc a
hang Int
2 forall a b. (a -> b) -> a -> b
$
forall a. String -> Doc a
text String
"λ" forall a. Doc a -> Doc a -> Doc a
<+> Name -> Bool -> Doc OutputAnnotation
bindingOf Name
n Bool
False forall a. Doc a -> Doc a -> Doc a
<+> forall a. String -> Doc a
text String
"." forall a. Doc a -> Doc a -> Doc a
<> forall a. Doc a
line forall a. Doc a -> Doc a -> Doc a
<> Doc OutputAnnotation
sc
ppb Integer
p [Name]
bound Name
n (Pi RigCount
rig Maybe ImplicitInfo
_ TT Name
ty TT Name
k) Doc OutputAnnotation
sc =
forall {a} {a}. Ord a => a -> a -> Doc a -> Doc a
bracket Integer
p Integer
startPrec forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Doc a -> Doc a
group forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Doc a -> Doc a
align forall a b. (a -> b) -> a -> b
$
forall a. Doc a
lparen forall a. Doc a -> Doc a -> Doc a
<> (Name -> Bool -> Doc OutputAnnotation
bindingOf Name
n Bool
False) forall a. Doc a -> Doc a -> Doc a
<+> forall a. Doc a
colon forall a. Doc a -> Doc a -> Doc a
<+>
(forall a. Doc a -> Doc a
group forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Doc a -> Doc a
align) (Integer -> [Name] -> TT Name -> Doc OutputAnnotation
pp Integer
startPrec [Name]
bound TT Name
ty) forall a. Doc a -> Doc a -> Doc a
<>
forall a. Doc a
rparen forall a. Doc a -> Doc a -> Doc a
<+> forall {a}. RigCount -> Doc a
mkArrow RigCount
rig forall a. Doc a -> Doc a -> Doc a
<> forall a. Doc a
line forall a. Doc a -> Doc a -> Doc a
<> Doc OutputAnnotation
sc
where mkArrow :: RigCount -> Doc a
mkArrow RigCount
Rig1 = forall a. String -> Doc a
text String
"⇴"
mkArrow RigCount
Rig0 = forall a. String -> Doc a
text String
"⥛"
mkArrow RigCount
_ = forall a. String -> Doc a
text String
"→"
ppb Integer
p [Name]
bound Name
n (Let RigCount
_ TT Name
ty TT Name
val) Doc OutputAnnotation
sc =
forall {a} {a}. Ord a => a -> a -> Doc a -> Doc a
bracket Integer
p Integer
startPrec forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Doc a -> Doc a
group forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Doc a -> Doc a
align forall a b. (a -> b) -> a -> b
$
(forall a. Doc a -> Doc a
group forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Int -> Doc a -> Doc a
hang Int
2) (forall a. a -> Doc a -> Doc a
annotate OutputAnnotation
AnnKeyword (forall a. String -> Doc a
text String
"let") forall a. Doc a -> Doc a -> Doc a
<+>
Name -> Bool -> Doc OutputAnnotation
bindingOf Name
n Bool
False forall a. Doc a -> Doc a -> Doc a
<+> forall a. Doc a
colon forall a. Doc a -> Doc a -> Doc a
<+>
Integer -> [Name] -> TT Name -> Doc OutputAnnotation
pp Integer
startPrec [Name]
bound TT Name
ty forall a. Doc a -> Doc a -> Doc a
<+>
forall a. String -> Doc a
text String
"=" forall a. Doc a -> Doc a -> Doc a
<> forall a. Doc a
line forall a. Doc a -> Doc a -> Doc a
<>
Integer -> [Name] -> TT Name -> Doc OutputAnnotation
pp Integer
startPrec [Name]
bound TT Name
val) forall a. Doc a -> Doc a -> Doc a
<> forall a. Doc a
line forall a. Doc a -> Doc a -> Doc a
<>
(forall a. Doc a -> Doc a
group forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Int -> Doc a -> Doc a
hang Int
2) (forall a. a -> Doc a -> Doc a
annotate OutputAnnotation
AnnKeyword (forall a. String -> Doc a
text String
"in") forall a. Doc a -> Doc a -> Doc a
<+> Doc OutputAnnotation
sc)
ppb Integer
p [Name]
bound Name
n (NLet TT Name
ty TT Name
val) Doc OutputAnnotation
sc =
forall {a} {a}. Ord a => a -> a -> Doc a -> Doc a
bracket Integer
p Integer
startPrec forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Doc a -> Doc a
group forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Doc a -> Doc a
align forall a b. (a -> b) -> a -> b
$
(forall a. Doc a -> Doc a
group forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Int -> Doc a -> Doc a
hang Int
2) (forall a. a -> Doc a -> Doc a
annotate OutputAnnotation
AnnKeyword (forall a. String -> Doc a
text String
"nlet") forall a. Doc a -> Doc a -> Doc a
<+>
Name -> Bool -> Doc OutputAnnotation
bindingOf Name
n Bool
False forall a. Doc a -> Doc a -> Doc a
<+> forall a. Doc a
colon forall a. Doc a -> Doc a -> Doc a
<+>
Integer -> [Name] -> TT Name -> Doc OutputAnnotation
pp Integer
startPrec [Name]
bound TT Name
ty forall a. Doc a -> Doc a -> Doc a
<+>
forall a. String -> Doc a
text String
"=" forall a. Doc a -> Doc a -> Doc a
<> forall a. Doc a
line forall a. Doc a -> Doc a -> Doc a
<>
Integer -> [Name] -> TT Name -> Doc OutputAnnotation
pp Integer
startPrec [Name]
bound TT Name
val) forall a. Doc a -> Doc a -> Doc a
<> forall a. Doc a
line forall a. Doc a -> Doc a -> Doc a
<>
(forall a. Doc a -> Doc a
group forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Int -> Doc a -> Doc a
hang Int
2) (forall a. a -> Doc a -> Doc a
annotate OutputAnnotation
AnnKeyword (forall a. String -> Doc a
text String
"in") forall a. Doc a -> Doc a -> Doc a
<+> Doc OutputAnnotation
sc)
ppb Integer
p [Name]
bound Name
n (Hole TT Name
ty) Doc OutputAnnotation
sc =
forall {a} {a}. Ord a => a -> a -> Doc a -> Doc a
bracket Integer
p Integer
startPrec forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Doc a -> Doc a
group forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Doc a -> Doc a
align forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Int -> Doc a -> Doc a
hang Int
2 forall a b. (a -> b) -> a -> b
$
forall a. String -> Doc a
text String
"?" forall a. Doc a -> Doc a -> Doc a
<+> Name -> Bool -> Doc OutputAnnotation
bindingOf Name
n Bool
False forall a. Doc a -> Doc a -> Doc a
<+> forall a. String -> Doc a
text String
"." forall a. Doc a -> Doc a -> Doc a
<> forall a. Doc a
line forall a. Doc a -> Doc a -> Doc a
<> Doc OutputAnnotation
sc
ppb Integer
p [Name]
bound Name
n (GHole Int
_ [Name]
_ TT Name
ty) Doc OutputAnnotation
sc =
forall {a} {a}. Ord a => a -> a -> Doc a -> Doc a
bracket Integer
p Integer
startPrec forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Doc a -> Doc a
group forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Doc a -> Doc a
align forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Int -> Doc a -> Doc a
hang Int
2 forall a b. (a -> b) -> a -> b
$
forall a. String -> Doc a
text String
"¿" forall a. Doc a -> Doc a -> Doc a
<+> Name -> Bool -> Doc OutputAnnotation
bindingOf Name
n Bool
False forall a. Doc a -> Doc a -> Doc a
<+> forall a. String -> Doc a
text String
"." forall a. Doc a -> Doc a -> Doc a
<> forall a. Doc a
line forall a. Doc a -> Doc a -> Doc a
<> Doc OutputAnnotation
sc
ppb Integer
p [Name]
bound Name
n (Guess TT Name
ty TT Name
val) Doc OutputAnnotation
sc =
forall {a} {a}. Ord a => a -> a -> Doc a -> Doc a
bracket Integer
p Integer
startPrec forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Doc a -> Doc a
group forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Doc a -> Doc a
align forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Int -> Doc a -> Doc a
hang Int
2 forall a b. (a -> b) -> a -> b
$
forall a. String -> Doc a
text String
"?" forall a. Doc a -> Doc a -> Doc a
<> Name -> Bool -> Doc OutputAnnotation
bindingOf Name
n Bool
False forall a. Doc a -> Doc a -> Doc a
<+>
forall a. String -> Doc a
text String
"≈" forall a. Doc a -> Doc a -> Doc a
<+> Integer -> [Name] -> TT Name -> Doc OutputAnnotation
pp Integer
startPrec [Name]
bound TT Name
val forall a. Doc a -> Doc a -> Doc a
<+>
forall a. String -> Doc a
text String
"." forall a. Doc a -> Doc a -> Doc a
<> forall a. Doc a
line forall a. Doc a -> Doc a -> Doc a
<> Doc OutputAnnotation
sc
ppb Integer
p [Name]
bound Name
n (PVar RigCount
_ TT Name
ty) Doc OutputAnnotation
sc =
forall {a} {a}. Ord a => a -> a -> Doc a -> Doc a
bracket Integer
p Integer
startPrec forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Doc a -> Doc a
group forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Doc a -> Doc a
align forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Int -> Doc a -> Doc a
hang Int
2 forall a b. (a -> b) -> a -> b
$
forall a. a -> Doc a -> Doc a
annotate OutputAnnotation
AnnKeyword (forall a. String -> Doc a
text String
"pat") forall a. Doc a -> Doc a -> Doc a
<+>
Name -> Bool -> Doc OutputAnnotation
bindingOf Name
n Bool
False forall a. Doc a -> Doc a -> Doc a
<+> forall a. Doc a
colon forall a. Doc a -> Doc a -> Doc a
<+> Integer -> [Name] -> TT Name -> Doc OutputAnnotation
pp Integer
startPrec [Name]
bound TT Name
ty forall a. Doc a -> Doc a -> Doc a
<+>
forall a. String -> Doc a
text String
"." forall a. Doc a -> Doc a -> Doc a
<> forall a. Doc a
line forall a. Doc a -> Doc a -> Doc a
<>
Doc OutputAnnotation
sc
ppb Integer
p [Name]
bound Name
n (PVTy TT Name
ty) Doc OutputAnnotation
sc =
forall {a} {a}. Ord a => a -> a -> Doc a -> Doc a
bracket Integer
p Integer
startPrec forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Doc a -> Doc a
group forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Doc a -> Doc a
align forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Int -> Doc a -> Doc a
hang Int
2 forall a b. (a -> b) -> a -> b
$
forall a. a -> Doc a -> Doc a
annotate OutputAnnotation
AnnKeyword (forall a. String -> Doc a
text String
"patTy") forall a. Doc a -> Doc a -> Doc a
<+>
Name -> Bool -> Doc OutputAnnotation
bindingOf Name
n Bool
False forall a. Doc a -> Doc a -> Doc a
<+> forall a. Doc a
colon forall a. Doc a -> Doc a -> Doc a
<+> Integer -> [Name] -> TT Name -> Doc OutputAnnotation
pp Integer
startPrec [Name]
bound TT Name
ty forall a. Doc a -> Doc a -> Doc a
<+>
forall a. String -> Doc a
text String
"." forall a. Doc a -> Doc a -> Doc a
<> forall a. Doc a
line forall a. Doc a -> Doc a -> Doc a
<>
Doc OutputAnnotation
sc
bracket :: a -> a -> Doc a -> Doc a
bracket a
outer a
inner Doc a
doc
| a
outer forall a. Ord a => a -> a -> Bool
> a
inner = forall a. Doc a
lparen forall a. Doc a -> Doc a -> Doc a
<> Doc a
doc forall a. Doc a -> Doc a -> Doc a
<> forall a. Doc a
rparen
| Bool
otherwise = Doc a
doc
pprintTTClause :: [(Name, Type)] -> Term -> Term -> Doc OutputAnnotation
pprintTTClause :: [(Name, TT Name)] -> TT Name -> TT Name -> Doc OutputAnnotation
pprintTTClause [(Name, TT Name)]
pvars TT Name
lhs TT Name
rhs =
[(Name, TT Name)] -> Doc OutputAnnotation -> Doc OutputAnnotation
vars [(Name, TT Name)]
pvars forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Doc a -> Doc a
group forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Doc a -> Doc a
align forall a b. (a -> b) -> a -> b
$
[Name] -> TT Name -> Doc OutputAnnotation
pprintTT (forall a b. (a -> b) -> [a] -> [b]
map forall a b. (a, b) -> a
fst [(Name, TT Name)]
pvars) TT Name
lhs forall a. Doc a -> Doc a -> Doc a
<$>
forall a. String -> Doc a
text String
"↦" forall a. Doc a -> Doc a -> Doc a
<$>
([Name] -> TT Name -> Doc OutputAnnotation
pprintTT (forall a b. (a -> b) -> [a] -> [b]
map forall a b. (a, b) -> a
fst [(Name, TT Name)]
pvars) TT Name
rhs)
where vars :: [(Name, TT Name)] -> Doc OutputAnnotation -> Doc OutputAnnotation
vars [] Doc OutputAnnotation
terms = Doc OutputAnnotation
terms
vars ((Name, TT Name)
v:[(Name, TT Name)]
vs) Doc OutputAnnotation
terms =
forall a. a -> Doc a -> Doc a
annotate OutputAnnotation
AnnKeyword (forall a. String -> Doc a
text String
"var") forall a. Doc a -> Doc a -> Doc a
<+>
forall a. Doc a -> Doc a
group (forall a. Doc a -> Doc a
align (forall a. [Doc a] -> Doc a
sep (forall a. Doc a -> [Doc a] -> [Doc a]
punctuate forall a. Doc a
comma (forall a. [a] -> [a]
reverse ([Name] -> [(Name, TT Name)] -> [Doc OutputAnnotation]
bindVars [] ((Name, TT Name)
vforall a. a -> [a] -> [a]
:[(Name, TT Name)]
vs)))))) forall a. Doc a -> Doc a -> Doc a
<+>
forall a. a -> Doc a -> Doc a
annotate OutputAnnotation
AnnKeyword (forall a. String -> Doc a
text String
".") forall a. Doc a -> Doc a -> Doc a
<$>
forall a. Int -> Doc a -> Doc a
indent Int
2 Doc OutputAnnotation
terms
bindVars :: [Name] -> [(Name, TT Name)] -> [Doc OutputAnnotation]
bindVars [Name]
_ [] = []
bindVars [Name]
ns ((Name
n, TT Name
ty):[(Name, TT Name)]
vs) =
Name -> Bool -> Doc OutputAnnotation
bindingOf Name
n Bool
False forall a. Doc a -> Doc a -> Doc a
<+> forall a. Doc a
colon forall a. Doc a -> Doc a -> Doc a
<+> [Name] -> TT Name -> Doc OutputAnnotation
pprintTT [Name]
ns TT Name
ty forall a. a -> [a] -> [a]
: [Name] -> [(Name, TT Name)] -> [Doc OutputAnnotation]
bindVars (Name
nforall a. a -> [a] -> [a]
:[Name]
ns) [(Name, TT Name)]
vs
pprintRaw :: [Name]
-> Raw
-> Doc OutputAnnotation
pprintRaw :: [Name] -> Raw -> Doc OutputAnnotation
pprintRaw [Name]
bound (Var Name
n) =
forall a. Doc a -> Doc a -> Doc a -> Doc a
enclose forall a. Doc a
lparen forall a. Doc a
rparen forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Doc a -> Doc a
group forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Doc a -> Doc a
align forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Int -> Doc a -> Doc a
hang Int
2 forall a b. (a -> b) -> a -> b
$
(forall a. String -> Doc a
text String
"Var") forall a. Doc a -> Doc a -> Doc a
<$> forall a. a -> Doc a -> Doc a
annotate (if Name
n forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [Name]
bound
then Name -> Bool -> OutputAnnotation
AnnBoundName Name
n Bool
False
else Name
-> Maybe NameOutput
-> Maybe String
-> Maybe String
-> OutputAnnotation
AnnName Name
n forall a. Maybe a
Nothing forall a. Maybe a
Nothing forall a. Maybe a
Nothing)
(forall a. String -> Doc a
text forall a b. (a -> b) -> a -> b
$ forall a. Show a => a -> String
show Name
n)
pprintRaw [Name]
bound (RBind Name
n Binder Raw
b Raw
body) =
forall a. Doc a -> Doc a -> Doc a -> Doc a
enclose forall a. Doc a
lparen forall a. Doc a
rparen forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Doc a -> Doc a
group forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Doc a -> Doc a
align forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Int -> Doc a -> Doc a
hang Int
2 forall a b. (a -> b) -> a -> b
$
forall a. [Doc a] -> Doc a
vsep [ forall a. String -> Doc a
text String
"RBind"
, forall a. a -> Doc a -> Doc a
annotate (Name -> Bool -> OutputAnnotation
AnnBoundName Name
n Bool
False) (forall a. String -> Doc a
text forall a b. (a -> b) -> a -> b
$ forall a. Show a => a -> String
show Name
n)
, Binder Raw -> Doc OutputAnnotation
ppb Binder Raw
b
, [Name] -> Raw -> Doc OutputAnnotation
pprintRaw (Name
nforall a. a -> [a] -> [a]
:[Name]
bound) Raw
body]
where
ppb :: Binder Raw -> Doc OutputAnnotation
ppb (Lam RigCount
_ Raw
ty) = forall a. Doc a -> Doc a -> Doc a -> Doc a
enclose forall a. Doc a
lparen forall a. Doc a
rparen forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Doc a -> Doc a
group forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Doc a -> Doc a
align forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Int -> Doc a -> Doc a
hang Int
2 forall a b. (a -> b) -> a -> b
$
forall a. String -> Doc a
text String
"Lam" forall a. Doc a -> Doc a -> Doc a
<$> [Name] -> Raw -> Doc OutputAnnotation
pprintRaw [Name]
bound Raw
ty
ppb (Pi RigCount
_ Maybe ImplicitInfo
_ Raw
ty Raw
k) = forall a. Doc a -> Doc a -> Doc a -> Doc a
enclose forall a. Doc a
lparen forall a. Doc a
rparen forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Doc a -> Doc a
group forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Doc a -> Doc a
align forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Int -> Doc a -> Doc a
hang Int
2 forall a b. (a -> b) -> a -> b
$
forall a. [Doc a] -> Doc a
vsep [forall a. String -> Doc a
text String
"Pi", [Name] -> Raw -> Doc OutputAnnotation
pprintRaw [Name]
bound Raw
ty, [Name] -> Raw -> Doc OutputAnnotation
pprintRaw [Name]
bound Raw
k]
ppb (Let RigCount
c Raw
ty Raw
v) = forall a. Doc a -> Doc a -> Doc a -> Doc a
enclose forall a. Doc a
lparen forall a. Doc a
rparen forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Doc a -> Doc a
group forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Doc a -> Doc a
align forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Int -> Doc a -> Doc a
hang Int
2 forall a b. (a -> b) -> a -> b
$
forall a. [Doc a] -> Doc a
vsep [forall a. String -> Doc a
text String
"Let", [Name] -> Raw -> Doc OutputAnnotation
pprintRaw [Name]
bound Raw
ty, [Name] -> Raw -> Doc OutputAnnotation
pprintRaw [Name]
bound Raw
v]
ppb (NLet Raw
ty Raw
v) = forall a. Doc a -> Doc a -> Doc a -> Doc a
enclose forall a. Doc a
lparen forall a. Doc a
rparen forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Doc a -> Doc a
group forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Doc a -> Doc a
align forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Int -> Doc a -> Doc a
hang Int
2 forall a b. (a -> b) -> a -> b
$
forall a. [Doc a] -> Doc a
vsep [forall a. String -> Doc a
text String
"NLet", [Name] -> Raw -> Doc OutputAnnotation
pprintRaw [Name]
bound Raw
ty, [Name] -> Raw -> Doc OutputAnnotation
pprintRaw [Name]
bound Raw
v]
ppb (Hole Raw
ty) = forall a. Doc a -> Doc a -> Doc a -> Doc a
enclose forall a. Doc a
lparen forall a. Doc a
rparen forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Doc a -> Doc a
group forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Doc a -> Doc a
align forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Int -> Doc a -> Doc a
hang Int
2 forall a b. (a -> b) -> a -> b
$
forall a. String -> Doc a
text String
"Hole" forall a. Doc a -> Doc a -> Doc a
<$> [Name] -> Raw -> Doc OutputAnnotation
pprintRaw [Name]
bound Raw
ty
ppb (GHole Int
_ [Name]
_ Raw
ty) = forall a. Doc a -> Doc a -> Doc a -> Doc a
enclose forall a. Doc a
lparen forall a. Doc a
rparen forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Doc a -> Doc a
group forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Doc a -> Doc a
align forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Int -> Doc a -> Doc a
hang Int
2 forall a b. (a -> b) -> a -> b
$
forall a. String -> Doc a
text String
"GHole" forall a. Doc a -> Doc a -> Doc a
<$> [Name] -> Raw -> Doc OutputAnnotation
pprintRaw [Name]
bound Raw
ty
ppb (Guess Raw
ty Raw
v) = forall a. Doc a -> Doc a -> Doc a -> Doc a
enclose forall a. Doc a
lparen forall a. Doc a
rparen forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Doc a -> Doc a
group forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Doc a -> Doc a
align forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Int -> Doc a -> Doc a
hang Int
2 forall a b. (a -> b) -> a -> b
$
forall a. [Doc a] -> Doc a
vsep [forall a. String -> Doc a
text String
"Guess", [Name] -> Raw -> Doc OutputAnnotation
pprintRaw [Name]
bound Raw
ty, [Name] -> Raw -> Doc OutputAnnotation
pprintRaw [Name]
bound Raw
v]
ppb (PVar RigCount
_ Raw
ty) = forall a. Doc a -> Doc a -> Doc a -> Doc a
enclose forall a. Doc a
lparen forall a. Doc a
rparen forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Doc a -> Doc a
group forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Doc a -> Doc a
align forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Int -> Doc a -> Doc a
hang Int
2 forall a b. (a -> b) -> a -> b
$
forall a. String -> Doc a
text String
"PVar" forall a. Doc a -> Doc a -> Doc a
<$> [Name] -> Raw -> Doc OutputAnnotation
pprintRaw [Name]
bound Raw
ty
ppb (PVTy Raw
ty) = forall a. Doc a -> Doc a -> Doc a -> Doc a
enclose forall a. Doc a
lparen forall a. Doc a
rparen forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Doc a -> Doc a
group forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Doc a -> Doc a
align forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Int -> Doc a -> Doc a
hang Int
2 forall a b. (a -> b) -> a -> b
$
forall a. String -> Doc a
text String
"PVTy" forall a. Doc a -> Doc a -> Doc a
<$> [Name] -> Raw -> Doc OutputAnnotation
pprintRaw [Name]
bound Raw
ty
pprintRaw [Name]
bound (RApp Raw
f Raw
x) =
forall a. Doc a -> Doc a -> Doc a -> Doc a
enclose forall a. Doc a
lparen forall a. Doc a
rparen forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Doc a -> Doc a
group forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Doc a -> Doc a
align forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Int -> Doc a -> Doc a
hang Int
2 forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. [Doc a] -> Doc a
vsep forall a b. (a -> b) -> a -> b
$
[forall a. String -> Doc a
text String
"RApp", [Name] -> Raw -> Doc OutputAnnotation
pprintRaw [Name]
bound Raw
f, [Name] -> Raw -> Doc OutputAnnotation
pprintRaw [Name]
bound Raw
x]
pprintRaw [Name]
bound Raw
RType = forall a. String -> Doc a
text String
"RType"
pprintRaw [Name]
bound (RUType Universe
u) = forall a. Doc a -> Doc a -> Doc a -> Doc a
enclose forall a. Doc a
lparen forall a. Doc a
rparen forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Doc a -> Doc a
group forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Doc a -> Doc a
align forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Int -> Doc a -> Doc a
hang Int
2 forall a b. (a -> b) -> a -> b
$
forall a. String -> Doc a
text String
"RUType" forall a. Doc a -> Doc a -> Doc a
<$> forall a. String -> Doc a
text (forall a. Show a => a -> String
show Universe
u)
pprintRaw [Name]
bound (RConstant Const
c) =
forall a. Doc a -> Doc a -> Doc a -> Doc a
enclose forall a. Doc a
lparen forall a. Doc a
rparen forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Doc a -> Doc a
group forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Doc a -> Doc a
align forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Int -> Doc a -> Doc a
hang Int
2 forall a b. (a -> b) -> a -> b
$
forall a. [Doc a] -> Doc a
vsep [forall a. String -> Doc a
text String
"RConstant", forall a. a -> Doc a -> Doc a
annotate (Const -> OutputAnnotation
AnnConst Const
c) (forall a. String -> Doc a
text (forall a. Show a => a -> String
show Const
c))]
bindingOf :: Name
-> Bool
-> Doc OutputAnnotation
bindingOf :: Name -> Bool -> Doc OutputAnnotation
bindingOf Name
n Bool
imp = forall a. a -> Doc a -> Doc a
annotate (Name -> Bool -> OutputAnnotation
AnnBoundName Name
n Bool
imp) (forall a. String -> Doc a
text (forall a. Show a => a -> String
show Name
n))