Agda-2.5.2: A dependently typed functional programming language and proof assistant

Safe Haskell | None
Language | Haskell2010

Agda.Interaction.InteractionTop

Contents

- Operations for manipulating `oldInteractionScopes`.
- Orphan instances

Synopsis

- data CommandState = CommandState {
  - theInteractionPoints :: [InteractionId]
  - theCurrentFile :: Maybe (AbsolutePath, ClockTime)
  - optionsOnReload :: CommandLineOptions
  - oldInteractionScopes :: !OldInteractionScopes
  }
- type OldInteractionScopes = Map InteractionId ScopeInfo
- initCommandState :: CommandState
- type CommandM = StateT CommandState TCM
- localStateCommandM :: CommandM a -> CommandM a
- liftLocalState :: TCM a -> CommandM a
- revLift :: MonadState st m => (forall c. m c -> st -> k (c, st)) -> (forall b. k b -> m b) -> (forall x. (m a -> k x) -> k x) -> m a
- commandMToIO :: (forall x. (CommandM a -> IO x) -> IO x) -> CommandM a
- liftCommandMT :: (forall a. TCM a -> TCM a) -> CommandM a -> CommandM a
- liftCommandMTLocalState :: (forall a. TCM a -> TCM a) -> CommandM a -> CommandM a
- putResponse :: Response -> CommandM ()
- modifyTheInteractionPoints :: ([InteractionId] -> [InteractionId]) -> CommandM ()
- modifyOldInteractionScopes :: (OldInteractionScopes -> OldInteractionScopes) -> CommandM ()
- insertOldInteractionScope :: InteractionId -> ScopeInfo -> CommandM ()
- removeOldInteractionScope :: InteractionId -> CommandM ()
- getOldInteractionScope :: InteractionId -> CommandM ScopeInfo
- handleCommand_ :: CommandM () -> CommandM ()
- handleCommand :: (forall a. CommandM a -> CommandM a) -> CommandM () -> CommandM () -> CommandM ()
- runInteraction :: IOTCM -> CommandM ()
- type Interaction = Interaction' Range
- data Interaction' range
  - = Cmd_load FilePath [String]
  - | Cmd_compile Backend FilePath [String]
  - | Cmd_constraints
  - | Cmd_metas
  - | Cmd_warnings
  - | Cmd_show_module_contents_toplevel Rewrite String
  - | Cmd_search_about_toplevel Rewrite String
  - | Cmd_solveAll Rewrite
  - | Cmd_solveOne Rewrite InteractionId range String
  - | Cmd_infer_toplevel Rewrite String
  - | Cmd_compute_toplevel ComputeMode String
  - | Cmd_load_highlighting_info FilePath
  - | Cmd_highlight InteractionId range String
  - | ShowImplicitArgs Bool
  - | ToggleImplicitArgs
  - | Cmd_give InteractionId range String
  - | Cmd_refine InteractionId range String
  - | Cmd_intro Bool InteractionId range String
  - | Cmd_refine_or_intro Bool InteractionId range String
  - | Cmd_auto InteractionId range String
  - | Cmd_context Rewrite InteractionId range String
  - | Cmd_helper_function Rewrite InteractionId range String
  - | Cmd_infer Rewrite InteractionId range String
  - | Cmd_goal_type Rewrite InteractionId range String
  - | Cmd_goal_type_context Rewrite InteractionId range String
  - | Cmd_goal_type_context_infer Rewrite InteractionId range String
  - | Cmd_show_module_contents Rewrite InteractionId range String
  - | Cmd_make_case InteractionId range String
  - | Cmd_compute ComputeMode InteractionId range String
  - | Cmd_why_in_scope InteractionId range String
  - | Cmd_why_in_scope_toplevel String
  - | Cmd_show_version
- type IOTCM = IOTCM' Range
- data IOTCM' range = IOTCM FilePath HighlightingLevel HighlightingMethod (Interaction' range)
- type Parse a = ExceptT String (StateT String Identity) a
- readsToParse :: String -> (String -> Maybe (a, String)) -> Parse a
- parseToReadsPrec :: Parse a -> Int -> String -> [(a, String)]
- exact :: String -> Parse ()
- readParse :: Read a => Parse a
- parens' :: Parse a -> Parse a
- independent :: Interaction -> Bool
- interpret :: Interaction -> CommandM ()
- interpretWarnings :: CommandM (String, String)
- solveInstantiatedGoals :: Rewrite -> Maybe InteractionId -> CommandM ()
- showOpenMetas :: TCM [String]
- cmd_load' :: FilePath -> [String] -> Bool -> ((Interface, MaybeWarnings) -> CommandM ()) -> CommandM ()
- withCurrentFile :: CommandM a -> CommandM a
- data Backend
  - = GHC
  - | GHCNoMain
  - | JS
  - | LaTeX
- data GiveRefine
  - = Give
  - | Refine
  - | Intro
- give_gen :: InteractionId -> Range -> String -> GiveRefine -> CommandM ()
- highlightExpr :: Expr -> TCM ()
- sortInteractionPoints :: [InteractionId] -> TCM [InteractionId]
- prettyTypeOfMeta :: Rewrite -> InteractionId -> TCM Doc
- prettyContext :: Rewrite -> Bool -> InteractionId -> TCM Doc
- cmd_helper_function :: Rewrite -> InteractionId -> Range -> String -> TCM Doc
- cmd_goal_type_context_and :: Doc -> Rewrite -> InteractionId -> Range -> String -> StateT CommandState (TCMT IO) ()
- showModuleContents :: Rewrite -> Range -> String -> CommandM ()
- searchAbout :: Rewrite -> Range -> String -> CommandM ()
- whyInScope :: String -> CommandM ()
- setCommandLineOpts :: CommandLineOptions -> CommandM ()
- status :: CommandM Status
- displayStatus :: CommandM ()
- display_info :: DisplayInfo -> CommandM ()
- refreshStr :: [String] -> String -> ([String], String)
- nameModifiers :: [String]
- parseAndDoAtToplevel' :: (Expr -> TCM Doc) -> (Doc -> DisplayInfo) -> String -> CommandM ()
- parseAndDoAtToplevel :: (Expr -> TCM Expr) -> (Doc -> DisplayInfo) -> String -> CommandM ()
- maybeTimed :: CommandM a -> CommandM (Maybe Doc, a)
- tellToUpdateHighlighting :: Maybe (HighlightingInfo, ModuleToSource) -> IO [Response]
- tellEmacsToJumpToError :: Range -> [Response]

# Documentation

data CommandState #

Auxiliary state of an interactive computation.

Constructors

CommandState |
Fields theInteractionPoints :: [InteractionId] The interaction points of the buffer, in the order in which they appear in the buffer. The interaction points are recorded in `theTCState`, but when new interaction points are added by give or refine Agda does not ensure that the ranges of later interaction points are updated. theCurrentFile :: Maybe (AbsolutePath, ClockTime) The file which the state applies to. Only stored if the module was successfully type checked (potentially with warnings). The `ClockTime` is the modification time stamp of the file when it was last loaded. optionsOnReload :: CommandLineOptions Reset the options on each reload to these. oldInteractionScopes :: !OldInteractionScopes We remember (the scope of) old interaction points to make it possible to parse and compute highlighting information for the expression that it got replaced by.

type OldInteractionScopes = Map InteractionId ScopeInfo #

initCommandState :: CommandState #

Initial auxiliary interaction state

type CommandM = StateT CommandState TCM #

Monad for computing answers to interactive commands.

`CommandM` is `TCM` extended with state `CommandState`.

localStateCommandM :: CommandM a -> CommandM a #

Restore both `TCState` and `CommandState`.

liftLocalState :: TCM a -> CommandM a #

Restore `TCState`, do not touch `CommandState`.

revLift #

Arguments

:: MonadState st m |
=> (forall c. m c -> st -> k (c, st)) | run
-> (forall b. k b -> m b) | lift
-> (forall x. (m a -> k x) -> k x) |
-> m a | reverse lift in double negative position

Build an opposite action to `lift` for state monads.

commandMToIO :: (forall x. (CommandM a -> IO x) -> IO x) -> CommandM a #

Opposite of `liftIO` for `CommandM`. Use only if main errors are already catched.

liftCommandMT :: (forall a. TCM a -> TCM a) -> CommandM a -> CommandM a #

Lift a TCM action transformer to a CommandM action transformer.

liftCommandMTLocalState :: (forall a. TCM a -> TCM a) -> CommandM a -> CommandM a #

Ditto, but restore state.

putResponse :: Response -> CommandM () #

Put a response by the callback function given by `stInteractionOutputCallback`.

modifyTheInteractionPoints :: ([InteractionId] -> [InteractionId]) -> CommandM () #

A Lens for `theInteractionPoints`.

# Operations for manipulating `oldInteractionScopes`.

modifyOldInteractionScopes :: (OldInteractionScopes -> OldInteractionScopes) -> CommandM () #

A Lens for `oldInteractionScopes`.

insertOldInteractionScope :: InteractionId -> ScopeInfo -> CommandM () #

removeOldInteractionScope :: InteractionId -> CommandM () #

getOldInteractionScope :: InteractionId -> CommandM ScopeInfo #

handleCommand_ :: CommandM () -> CommandM () #

Do setup and error handling for a command.

handleCommand :: (forall a. CommandM a -> CommandM a) -> CommandM () -> CommandM () -> CommandM () #

runInteraction :: IOTCM -> CommandM () #

Run an `IOTCM` value, catch the exceptions, emit output

If an error happens the state of `CommandM` does not change, but stPersistent may change (which contains successfully loaded interfaces for example).

type Interaction = Interaction' Range #

An interactive computation.

data Interaction' range #

Constructors

Cmd_load FilePath [String] | `cmd_load m argv` loads the module in file `m`, using `argv` as the command-line options.
Cmd_compile Backend FilePath [String] | `cmd_compile b m argv` compiles the module in file `m` using the backend `b`, using `argv` as the command-line options.
Cmd_constraints |
Cmd_metas | Show unsolved metas. If there are no unsolved metas but unsolved constraints show those instead.
Cmd_warnings | Display all warnings.
Cmd_show_module_contents_toplevel Rewrite String | Shows all the top-level names in the given module, along with their types. Uses the top-level scope.
Cmd_search_about_toplevel Rewrite String | Shows all the top-level names in scope which mention all the given identifiers in their type.
Cmd_solveAll Rewrite | Solve (all goals / the goal at point) whose values are determined by the constraints.
Cmd_solveOne Rewrite InteractionId range String |
Cmd_infer_toplevel Rewrite String | Parse the given expression (as if it were defined at the top-level of the current module) and infer its type.
Cmd_compute_toplevel ComputeMode String | Parse and type check the given expression (as if it were defined at the top-level of the current module) and normalise it.
Cmd_load_highlighting_info FilePath | `cmd_load_highlighting_info source` loads syntax highlighting information for the module in `source`, and asks Emacs to apply highlighting info from this file. If the module does not exist, or its module name is malformed or cannot be determined, or the module has not already been visited, or the cached info is out of date, then no highlighting information is printed. This command is used to load syntax highlighting information when a new file is opened, and it would probably be annoying if jumping to the definition of an identifier reset the proof state, so this command tries not to do that. One result of this is that the command uses the current include directories, whatever they happen to be.
Cmd_highlight InteractionId range String | Tells Agda to compute highlighting information for the expression just spliced into an interaction point.
ShowImplicitArgs Bool | Tells Agda whether or not to show implicit arguments.
ToggleImplicitArgs | Toggle display of implicit arguments.
Cmd_give InteractionId range String | Goal commands If the range is `noRange`, then the string comes from the minibuffer rather than the goal.
Cmd_refine InteractionId range String |
Cmd_intro Bool InteractionId range String |
Cmd_refine_or_intro Bool InteractionId range String |
Cmd_auto InteractionId range String |
Cmd_context Rewrite InteractionId range String |
Cmd_helper_function Rewrite InteractionId range String |
Cmd_infer Rewrite InteractionId range String |
Cmd_goal_type Rewrite InteractionId range String |
Cmd_goal_type_context Rewrite InteractionId range String | Displays the current goal and context.
Cmd_goal_type_context_infer Rewrite InteractionId range String | Displays the current goal and context and infers the type of an expression.
Cmd_show_module_contents Rewrite InteractionId range String | Shows all the top-level names in the given module, along with their types. Uses the scope of the given goal.
Cmd_make_case InteractionId range String |
Cmd_compute ComputeMode InteractionId range String |
Cmd_why_in_scope InteractionId range String |
Cmd_why_in_scope_toplevel String |
Cmd_show_version | Displays version of the running Agda

Instances

Functor Interaction' # |
Methods fmap :: (a -> b) -> Interaction' a -> Interaction' b # (<$) :: a -> Interaction' b -> Interaction' a #
Foldable Interaction' # |
Methods fold :: Monoid m => Interaction' m -> m # foldMap :: Monoid m => (a -> m) -> Interaction' a -> m # foldr :: (a -> b -> b) -> b -> Interaction' a -> b # foldr' :: (a -> b -> b) -> b -> Interaction' a -> b # foldl :: (b -> a -> b) -> b -> Interaction' a -> b # foldl' :: (b -> a -> b) -> b -> Interaction' a -> b # foldr1 :: (a -> a -> a) -> Interaction' a -> a # foldl1 :: (a -> a -> a) -> Interaction' a -> a # toList :: Interaction' a -> [a] # null :: Interaction' a -> Bool # length :: Interaction' a -> Int # elem :: Eq a => a -> Interaction' a -> Bool # maximum :: Ord a => Interaction' a -> a # minimum :: Ord a => Interaction' a -> a # sum :: Num a => Interaction' a -> a # product :: Num a => Interaction' a -> a #
Traversable Interaction' # |
Methods traverse :: Applicative f => (a -> f b) -> Interaction' a -> f (Interaction' b) # sequenceA :: Applicative f => Interaction' (f a) -> f (Interaction' a) # mapM :: Monad m => (a -> m b) -> Interaction' a -> m (Interaction' b) # sequence :: Monad m => Interaction' (m a) -> m (Interaction' a) #
Read range => Read (Interaction' range) # |
Methods readsPrec :: Int -> ReadS (Interaction' range) # readList :: ReadS [Interaction' range] # readPrec :: ReadPrec (Interaction' range) # readListPrec :: ReadPrec [Interaction' range] #

type IOTCM = IOTCM' Range #

data IOTCM' range #

Constructors

IOTCM FilePath HighlightingLevel HighlightingMethod (Interaction' range) |

Instances

Functor IOTCM' # |
Methods fmap :: (a -> b) -> IOTCM' a -> IOTCM' b # (<$) :: a -> IOTCM' b -> IOTCM' a #
Foldable IOTCM' # |
Methods fold :: Monoid m => IOTCM' m -> m # foldMap :: Monoid m => (a -> m) -> IOTCM' a -> m # foldr :: (a -> b -> b) -> b -> IOTCM' a -> b # foldr' :: (a -> b -> b) -> b -> IOTCM' a -> b # foldl :: (b -> a -> b) -> b -> IOTCM' a -> b # foldl' :: (b -> a -> b) -> b -> IOTCM' a -> b # foldr1 :: (a -> a -> a) -> IOTCM' a -> a # foldl1 :: (a -> a -> a) -> IOTCM' a -> a # toList :: IOTCM' a -> [a] # null :: IOTCM' a -> Bool # length :: IOTCM' a -> Int # elem :: Eq a => a -> IOTCM' a -> Bool # maximum :: Ord a => IOTCM' a -> a # minimum :: Ord a => IOTCM' a -> a # sum :: Num a => IOTCM' a -> a # product :: Num a => IOTCM' a -> a #
Traversable IOTCM' # |
Methods traverse :: Applicative f => (a -> f b) -> IOTCM' a -> f (IOTCM' b) # sequenceA :: Applicative f => IOTCM' (f a) -> f (IOTCM' a) # mapM :: Monad m => (a -> m b) -> IOTCM' a -> m (IOTCM' b) # sequence :: Monad m => IOTCM' (m a) -> m (IOTCM' a) #
Read range => Read (IOTCM' range) # |
Methods readsPrec :: Int -> ReadS (IOTCM' range) # readList :: ReadS [IOTCM' range] # readPrec :: ReadPrec (IOTCM' range) # readListPrec :: ReadPrec [IOTCM' range] #

type Parse a = ExceptT String (StateT String Identity) a #

The `Parse` monad. `StateT` state holds the remaining input.

readsToParse :: String -> (String -> Maybe (a, String)) -> Parse a #

Converter from the type of `reads` to `Parse` The first paramter is part of the error message in case the parse fails.

parseToReadsPrec :: Parse a -> Int -> String -> [(a, String)] #

exact :: String -> Parse () #

Demand an exact string.

readParse :: Read a => Parse a #

parens' :: Parse a -> Parse a #

independent :: Interaction -> Bool #

Can the command run even if the relevant file has not been loaded into the state?

interpret :: Interaction -> CommandM () #

Interpret an interaction

interpretWarnings :: CommandM (String, String) #

Show warnings

solveInstantiatedGoals :: Rewrite -> Maybe InteractionId -> CommandM () #

Solved goals already instantiated internally The second argument potentially limits it to one specific goal.

showOpenMetas :: TCM [String] #

Print open metas nicely.

cmd_load' #

Arguments

:: FilePath |
-> [String] |
-> Bool | Allow unsolved meta-variables?
-> ((Interface, MaybeWarnings) -> CommandM ()) |
-> CommandM () |

`cmd_load' file argv unsolvedOk cmd` loads the module in file `file`, using `argv` as the command-line options.

If type checking completes without any exceptions having been encountered then the command `cmd r` is executed, where `r` is the result of `typeCheckMain`.

withCurrentFile :: CommandM a -> CommandM a #

Set `envCurrentPath` to `theCurrentFile`, if any.

data Backend #

Available backends.

Constructors

GHC |
GHCNoMain |
JS |
LaTeX |

Instances

Eq Backend # |
Methods (==) :: Backend -> Backend -> Bool # (/=) :: Backend -> Backend -> Bool #
Read Backend # |
Methods readsPrec :: Int -> ReadS Backend # readList :: ReadS [Backend] # readPrec :: ReadPrec Backend # readListPrec :: ReadPrec [Backend] #
Show Backend # |
Methods showsPrec :: Int -> Backend -> ShowS # show :: Backend -> String # showList :: [Backend] -> ShowS #

data GiveRefine #

Constructors

Give |
Refine |
Intro |

Instances

Eq GiveRefine # |
Methods (==) :: GiveRefine -> GiveRefine -> Bool # (/=) :: GiveRefine -> GiveRefine -> Bool #
Show GiveRefine # |
Methods showsPrec :: Int -> GiveRefine -> ShowS # show :: GiveRefine -> String # showList :: [GiveRefine] -> ShowS #

give_gen :: InteractionId -> Range -> String -> GiveRefine -> CommandM () #

A "give"-like action (give, refine, etc).

`give_gen ii rng s give_ref mk_newtxt` acts on interaction point `ii` occupying range `rng`, placing the new content given by string `s`, and replacing `ii` by the newly created interaction points in the state.

highlightExpr :: Expr -> TCM () #

sortInteractionPoints :: [InteractionId] -> TCM [InteractionId] #

Sorts interaction points based on their ranges.

prettyTypeOfMeta :: Rewrite -> InteractionId -> TCM Doc #

Pretty-prints the type of the meta-variable.

prettyContext #

Arguments

:: Rewrite | Normalise?
-> Bool | Print the elements in reverse order?
-> InteractionId |
-> TCM Doc |

Pretty-prints the context of the given meta-variable.

cmd_helper_function :: Rewrite -> InteractionId -> Range -> String -> TCM Doc #

Create type of application of new helper function that would solve the goal.

cmd_goal_type_context_and :: Doc -> Rewrite -> InteractionId -> Range -> String -> StateT CommandState (TCMT IO) () #

Displays the current goal, the given document, and the current context.

Should not modify the state.

showModuleContents :: Rewrite -> Range -> String -> CommandM () #

Shows all the top-level names in the given module, along with their types.

searchAbout :: Rewrite -> Range -> String -> CommandM () #

Shows all the top-level names in scope which mention all the given identifiers in their type.

whyInScope :: String -> CommandM () #

Explain why something is in scope.

setCommandLineOpts :: CommandLineOptions -> CommandM () #

Sets the command line options and updates the status information.

status :: CommandM Status #

Computes some status information.

Does not change the state.

displayStatus :: CommandM () #

Displays or updates status information.

Does not change the state.

display_info :: DisplayInfo -> CommandM () #

`display_info` does what ``display_info'` False` does, but additionally displays some status information (see `status` and `displayStatus`).

refreshStr :: [String] -> String -> ([String], String) #

nameModifiers :: [String] #

parseAndDoAtToplevel' #

Arguments

:: (Expr -> TCM Doc) | The command to perform.
-> (Doc -> DisplayInfo) | The name to use for the buffer displaying the output.
-> String | The expression to parse.
-> CommandM () |

Parses and scope checks an expression (using the "inside scope" as the scope), performs the given command with the expression as input, and displays the result.

parseAndDoAtToplevel :: (Expr -> TCM Expr) -> (Doc -> DisplayInfo) -> String -> CommandM () #

maybeTimed :: CommandM a -> CommandM (Maybe Doc, a) #

tellToUpdateHighlighting :: Maybe (HighlightingInfo, ModuleToSource) -> IO [Response] #

Tell to highlight the code using the given highlighting info (unless it is `Nothing`).

tellEmacsToJumpToError :: Range -> [Response] #

Tells the Emacs mode to go to the first error position (if any).

# Orphan instances

Read AbsolutePath # |
Methods readsPrec :: Int -> ReadS AbsolutePath # readList :: ReadS [AbsolutePath] # readPrec :: ReadPrec AbsolutePath # readListPrec :: ReadPrec [AbsolutePath] #
Read InteractionId # |
Methods readsPrec :: Int -> ReadS InteractionId # readList :: ReadS [InteractionId] # readPrec :: ReadPrec InteractionId # readListPrec :: ReadPrec [InteractionId] #
Read a => Read (Range' a) # | Note that the grammar implemented by this instance does not necessarily match the current representation of ranges.
Methods readsPrec :: Int -> ReadS (Range' a) # readList :: ReadS [Range' a] # readPrec :: ReadPrec (Range' a) # readListPrec :: ReadPrec [Range' a] #
Read a => Read (Interval' a) # |
Methods readsPrec :: Int -> ReadS (Interval' a) # readList :: ReadS [Interval' a] # readPrec :: ReadPrec (Interval' a) # readListPrec :: ReadPrec [Interval' a] #
Read a => Read (Position' a) # |
Methods readsPrec :: Int -> ReadS (Position' a) # readList :: ReadS [Position' a] # readPrec :: ReadPrec (Position' a) # readListPrec :: ReadPrec [Position' a] #