idris-1.0: Functional Programming Language with Dependent Types

CopyrightLicense : BSD3
MaintainerThe Idris Community.
Safe HaskellNone
LanguageHaskell98

Idris.Core.Elaborate

Description

This is our interface to proof construction, rather than ProofState, because this gives us a language to build derived tactics out of the primitives.

Synopsis

Documentation

data ElabState aux #

Constructors

ES (ProofState, aux) String (Maybe (ElabState aux)) 

Instances

Show aux => Show (ElabState aux) # 

Methods

showsPrec :: Int -> ElabState aux -> ShowS #

show :: ElabState aux -> String #

showList :: [ElabState aux] -> ShowS #

type Elab' aux a = StateT (ElabState aux) TC a #

type Elab a = Elab' () a #

proofFail :: Elab' aux a -> Elab' aux a #

explicit :: Name -> Elab' aux () #

addPSname :: Name -> Elab' aux () #

saveState :: Elab' aux () #

loadState :: Elab' aux () #

setNextName :: Elab' aux () #

initNextNameFrom :: [Name] -> Elab' aux () #

transformErr :: (Err -> Err) -> Elab' aux a -> Elab' aux a #

Transform the error returned by an elaboration script, preserving location information and proof search failure messages.

errAt :: String -> Name -> Maybe Type -> Elab' aux a -> Elab' aux a #

erunAux :: FC -> Elab' aux a -> Elab' aux (a, aux) #

erun :: FC -> Elab' aux a -> Elab' aux a #

runElab :: aux -> Elab' aux a -> ProofState -> TC (a, ElabState aux) #

execElab :: aux -> Elab' aux a -> ProofState -> TC (ElabState aux) #

initElaborator #

Arguments

:: Name

the name of what's to be elaborated

-> String

the current source file

-> Context

the current global context

-> Ctxt TypeInfo

the value of the idris_datatypes field of IState

-> Int

the value of the idris_name field of IState

-> Type

the goal type

-> ProofState 

elaborate :: String -> Context -> Ctxt TypeInfo -> Int -> Name -> Type -> aux -> Elab' aux a -> TC (a, String) #

updateAux :: (aux -> aux) -> Elab' aux () #

Modify the auxiliary state

getAux :: Elab' aux aux #

Get the auxiliary state

unifyLog :: Bool -> Elab' aux () #

Set whether to show the unifier log

processTactic' :: Tactic -> Elab' aux () #

Process a tactic within the current elaborator state

now_elaborating :: FC -> Name -> Name -> Elab' aux () #

get_context :: Elab' aux Context #

Get the global context

set_context :: Context -> Elab' aux () #

Update the context. (should only be used for adding temporary definitions or all sorts of stuff could go wrong)

get_term :: Elab' aux Term #

get the proof term

update_term :: (Term -> Term) -> Elab' aux () #

modify the proof term

get_env :: Elab' aux Env #

get the local context at the currently in focus hole

get_inj :: Elab' aux [Name] #

get_recents :: Elab' aux [Name] #

Return recently solved names (that is, the names solved since the last call to get_recents)

goal :: Elab' aux Type #

get the current goal type

get_guess :: Elab' aux Term #

Get the guess at the current hole, if there is one

get_type :: Raw -> Elab' aux Type #

Typecheck locally

get_deferred :: Elab' aux [Name] #

get holes we've deferred for later definition

checkInjective :: (Term, Term, Term) -> Elab' aux () #

get_implementations :: Elab' aux [Name] #

get implementation argument names

get_autos :: Elab' aux [(Name, ([FailContext], [Name]))] #

get auto argument names

unique_hole :: Name -> Elab' aux Name #

given a desired hole name, return a unique hole name

elog :: String -> Elab' aux () #

attack :: Elab' aux () #

claim :: Name -> Raw -> Elab' aux () #

claimFn :: Name -> Name -> Raw -> Elab' aux () #

unifyGoal :: Raw -> Elab' aux () #

unifyTerms :: Raw -> Raw -> Elab' aux () #

exact :: Raw -> Elab' aux () #

fill :: Raw -> Elab' aux () #

match_fill :: Raw -> Elab' aux () #

prep_fill :: Name -> [Name] -> Elab' aux () #

solve :: Elab' aux () #

start_unify :: Name -> Elab' aux () #

end_unify :: Elab' aux () #

unify_all :: Elab' aux () #

regret :: Elab' aux () #

compute :: Elab' aux () #

computeLet :: Name -> Elab' aux () #

simplify :: Elab' aux () #

whnf_compute :: Elab' aux () #

eval_in :: Raw -> Elab' aux () #

check_in :: Raw -> Elab' aux () #

intro :: Maybe Name -> Elab' aux () #

introTy :: Raw -> Maybe Name -> Elab' aux () #

letbind :: Name -> Raw -> Raw -> Elab' aux () #

expandLet :: Name -> Term -> Elab' aux () #

rewrite :: Raw -> Elab' aux () #

induction :: Raw -> Elab' aux () #

casetac :: Raw -> Elab' aux () #

equiv :: Raw -> Elab' aux () #

patvar :: Name -> Elab' aux () #

Turn the current hole into a pattern variable with the provided name, made unique if not the same as the head of the hole queue

patvar' :: Name -> Elab' aux () #

Turn the current hole into a pattern variable with the provided name, but don't make MNs unique.

patbind :: Name -> RigCount -> Elab' aux () #

focus :: Name -> Elab' aux () #

movelast :: Name -> Elab' aux () #

dotterm :: Elab' aux () #

get_dotterm :: Elab' aux [(Name, [Name])] #

zipHere :: Elab' aux () #

Set the zipper in the proof state to point at the current sub term (This currently happens automatically, so this will have no effect...)

matchProblems :: Bool -> Elab' aux () #

defer :: [Name] -> Name -> Elab' aux Name #

deferType :: Name -> Raw -> [Name] -> Elab' aux () #

autoArg :: Name -> Elab' aux () #

setinj :: Name -> Elab' aux () #

proofstate :: Elab' aux () #

reorder_claims :: Name -> Elab' aux () #

qed :: Elab' aux Term #

undo :: Elab' aux () #

prepare_apply #

Arguments

:: Raw

The operation being applied

-> [Bool]

Whether arguments are implicit

-> Elab' aux [(Name, Name)]

The names of the arguments and their holes to be filled with elaborated argument values

Prepare to apply a function by creating holes to be filled by the arguments

apply #

Arguments

:: Raw

The operator to apply

-> [(Bool, Int)]

For each argument, whether to attempt to solve it and the priority in which to do so

-> Elab' aux [(Name, Name)] 

Apply an operator, solving some arguments by unification or matching.

match_apply #

Arguments

:: Raw

The operator to apply

-> [(Bool, Int)]

For each argument, whether to attempt to solve it and the priority in which to do so

-> Elab' aux [(Name, Name)] 

Apply an operator, solving some arguments by unification or matching.

apply' :: (Raw -> Elab' aux ()) -> Raw -> [(Bool, Int)] -> Elab' aux [(Name, Name)] #

apply2 :: Raw -> [Maybe (Elab' aux ())] -> Elab' aux () #

apply_elab :: Name -> [Maybe (Int, Elab' aux ())] -> Elab' aux () #

checkPiGoal :: Name -> Elab' aux () #

simple_app :: Bool -> Elab' aux () -> Elab' aux () -> String -> Elab' aux () #

infer_app :: Bool -> Elab' aux () -> Elab' aux () -> String -> Elab' aux () #

dep_app :: Elab' aux () -> Elab' aux () -> String -> Elab' aux () #

arg :: Name -> RigCount -> Maybe ImplicitInfo -> Name -> Elab' aux () #

no_errors :: Elab' aux () -> Maybe Err -> Elab' aux () #

try :: Elab' aux a -> Elab' aux a -> Elab' aux a #

handleError :: (Err -> Bool) -> Elab' aux a -> Elab' aux a -> Elab' aux a #

try' :: Elab' aux a -> Elab' aux a -> Bool -> Elab' aux a #

tryCatch :: Elab' aux a -> (Err -> Elab' aux a) -> Elab' aux a #

tryWhen :: Bool -> Elab' aux a -> Elab' aux a -> Elab' aux a #

tryAll :: [(Elab' aux a, Name)] -> Elab' aux a #

tryAll' :: Bool -> [(Elab' aux a, Name)] -> Elab' aux a #

prunStateT :: Int -> Bool -> [a] -> Maybe [b] -> StateT (ElabState t) TC t1 -> ElabState t -> TC ((t1, Int, Fails), ElabState t) #

dumpprobs :: Show a => [(t2, t1, t, a)] -> [Char] #