itp-interface 1.0.0__py3-none-any.whl

itp_interface/tools/repl/REPL/Lean/InfoTree.lean

@@ -0,0 +1,272 @@
+/-
+Copyright (c) 2023 Scott Morrison. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Scott Morrison
+-/
+import Lean
+
+/-!
+Additional functions to deal with `InfoTree`.
+-/
+
+open Lean Elab Meta
+
+namespace Lean.FileMap
+
+/-- Extract the range of a `Syntax` expressed as lines and columns. -/
+-- Extracted from the private declaration `Lean.Elab.formatStxRange`,
+-- in `Lean.Elab.InfoTree.Main`.
+def stxRange (fileMap : FileMap) (stx : Syntax) : Position × Position :=
+  let pos    := stx.getPos?.getD 0
+  let endPos := stx.getTailPos?.getD pos
+  (fileMap.toPosition pos, fileMap.toPosition endPos)
+
+end Lean.FileMap
+
+namespace Lean.Syntax
+
+/-- Check if a `Syntax` is an explicit invocation of the `sorry` tactic. -/
+def isSorryTactic (stx : Syntax) : Bool :=
+  s!"{stx}" = "(Tactic.tacticSorry \"sorry\")"
+
+/-- Check if a `Syntax` is an explicit `sorry` term. -/
+def isSorryTerm (stx : Syntax) : Bool :=
+  s!"{stx}" = "(Term.sorry \"sorry\")"
+
+end Lean.Syntax
+
+namespace Lean.Elab
+
+/-- Extract the range of a `Syntax` expressed as lines and columns. -/
+-- Extracted from the private declaration `Lean.Elab.formatStxRange`,
+-- in `Lean.Elab.InfoTree.Main`.
+def stxRange (fileMap : FileMap) (stx : Syntax) : Position × Position :=
+  let pos    := stx.getPos?.getD 0
+  let endPos := stx.getTailPos?.getD pos
+  (fileMap.toPosition pos, fileMap.toPosition endPos)
+
+end Lean.Elab
+
+namespace Lean.Elab.Info
+
+/-- The type of a `Lean.Elab.Info`, as a string. -/
+def kind : Info → String
+  | .ofTacticInfo         _ => "TacticInfo"
+  | .ofTermInfo           _ => "TermInfo"
+  | .ofCommandInfo        _ => "CommmandInfo"
+  | .ofMacroExpansionInfo _ => "MacroExpansionInfo"
+  | .ofOptionInfo         _ => "OptionInfo"
+  | .ofFieldInfo          _ => "FieldInfo"
+  | .ofCompletionInfo     _ => "CompletionInfo"
+  | .ofUserWidgetInfo     _ => "UserWidgetInfo"
+  | .ofCustomInfo         _ => "CustomInfo"
+  | .ofFVarAliasInfo      _ => "FVarAliasInfo"
+  | .ofFieldRedeclInfo    _ => "FieldRedeclInfo"
+  | .ofOmissionInfo       _ => "OmissionInfo"
+
+/-- The `Syntax` for a `Lean.Elab.Info`, if there is one. -/
+def stx? : Info → Option Syntax
+  | .ofTacticInfo         info => info.stx
+  | .ofTermInfo           info => info.stx
+  | .ofCommandInfo        info => info.stx
+  | .ofMacroExpansionInfo info => info.stx
+  | .ofOptionInfo         info => info.stx
+  | .ofFieldInfo          info => info.stx
+  | .ofCompletionInfo     info => info.stx
+  | .ofUserWidgetInfo     info => info.stx
+  | .ofCustomInfo         info => info.stx
+  | .ofFVarAliasInfo      _    => none
+  | .ofFieldRedeclInfo    info => info.stx
+  | .ofOmissionInfo       info => info.stx
+
+/-- Is the `Syntax` for this `Lean.Elab.Info` original, or synthetic? -/
+def isOriginal (i : Info) : Bool :=
+  match i.stx? with
+  | none => true   -- Somewhat unclear what to do with `FVarAliasInfo`, so be conservative.
+  | some stx => match stx.getHeadInfo with
+    | .original .. => true
+    | _ => false
+
+end Lean.Elab.Info
+namespace Lean.Elab.TacticInfo
+
+/-- Find the name for the outermost `Syntax` in this `TacticInfo`. -/
+def name? (t : TacticInfo) : Option Name :=
+  match t.stx with
+  | Syntax.node _ n _ => some n
+  | _ => none
+
+/-- Decide whether a tactic is "substantive",
+or is merely a tactic combinator (e.g. `by`, `;`, multiline tactics, parenthesized tactics). -/
+def isSubstantive (t : TacticInfo) : Bool :=
+  match t.name? with
+  | none => false
+  | some `null => false
+  | some ``cdot => false
+  | some ``cdotTk => false
+  | some ``Lean.Parser.Term.byTactic => false
+  | some ``Lean.Parser.Tactic.tacticSeq => false
+  | some ``Lean.Parser.Tactic.tacticSeq1Indented => false
+  | some ``Lean.Parser.Tactic.«tactic_<;>_» => false
+  | some ``Lean.Parser.Tactic.paren => false
+  | _ => true
+
+end Lean.Elab.TacticInfo
+
+namespace Lean.Elab.InfoTree
+
+/--
+Keep `.node` nodes and `.hole` nodes satisfying predicates.
+
+Returns a `List InfoTree`, although in most situations this will be a singleton.
+-/
+partial def filter (p : Info → Bool) (m : MVarId → Bool := fun _ => false) :
+    InfoTree → List InfoTree
+  | .context ctx tree => tree.filter p m |>.map (.context ctx)
+  | .node info children =>
+    if p info then
+      [.node info (children.toList.map (filter p m)).join.toPArray']
+    else
+      (children.toList.map (filter p m)).join
+  | .hole mvar => if m mvar then [.hole mvar] else []
+
+/-- Discard all nodes besides `.context` nodes and `TacticInfo` nodes. -/
+partial def retainTacticInfo (tree : InfoTree) : List InfoTree :=
+  tree.filter fun | .ofTacticInfo _ => true | _ => false
+
+/-- Retain only nodes with "original" syntax. -/
+partial def retainOriginal (tree : InfoTree) : List InfoTree :=
+  tree.filter Info.isOriginal
+
+/-- Discard all TacticInfo nodes that are tactic combinators or structuring tactics. -/
+-- There is considerable grey area here: what to do with `classical`?
+partial def retainSubstantive (tree : InfoTree) : List InfoTree :=
+  tree.filter fun | .ofTacticInfo i => i.isSubstantive | _ => true
+
+/-- Analogue of `Lean.Elab.InfoTree.findInfo?`, but that returns all results. -/
+partial def findAllInfo (t : InfoTree) (ctx? : Option ContextInfo) (p : Info → Bool) :
+    List (Info × Option ContextInfo) :=
+  match t with
+  | context ctx t => t.findAllInfo (ctx.mergeIntoOuter? ctx?) p
+  | node i ts  =>
+    let info := if p i then [(i, ctx?)] else []
+    let rest := ts.toList.bind (fun t => t.findAllInfo ctx? p)
+    info ++ rest
+  | _ => []
+
+/-- Return all `TacticInfo` nodes in an `InfoTree` with "original" syntax,
+each equipped with its relevant `ContextInfo`. -/
+def findTacticNodes (t : InfoTree) : List (TacticInfo × ContextInfo) :=
+  let infos := t.findAllInfo none fun i => match i with
+  | .ofTacticInfo i' => i.isOriginal && i'.isSubstantive
+  | _ => false
+  infos.filterMap fun p => match p with
+  | (.ofTacticInfo i, some ctx) => (i, ctx)
+  | _ => none
+
+/-- Return all `TacticInfo` nodes in an `InfoTree`
+corresponding to explicit invocations of the `sorry` tactic,
+each equipped with its relevant `ContextInfo`. -/
+def findSorryTacticNodes (t : InfoTree) : List (TacticInfo × ContextInfo) :=
+  let infos := t.findAllInfo none fun i => match i with
+  | .ofTacticInfo i => i.stx.isSorryTactic && !i.goalsBefore.isEmpty
+  | _ => false
+  infos.filterMap fun p => match p with
+  | (.ofTacticInfo i, some ctx) => (i, ctx)
+  | _ => none
+
+/-- Return all `TermInfo` nodes in an `InfoTree`
+corresponding to explicit `sorry` terms,
+each equipped with its relevant `ContextInfo`. -/
+def findSorryTermNodes (t : InfoTree) : List (TermInfo × ContextInfo) :=
+  let infos := t.findAllInfo none fun i => match i with
+  | .ofTermInfo i => i.stx.isSorryTerm
+  | _ => false
+  infos.filterMap fun p => match p with
+  | (.ofTermInfo i, some ctx) => (i, ctx)
+  | _ => none
+
+inductive SorryType
+| tactic : MVarId → SorryType
+| term : LocalContext → Option Expr → SorryType
+deriving Inhabited
+
+/--
+Finds all appearances of `sorry` in an `InfoTree`, reporting
+* the `ContextInfo` at that point,
+* the `MVarId` for a goal that was closed by `sorry`,
+  or the `Option Expr` expected type for a term supplied by `sorry`
+* and the start and end positions of the `sorry` in the file.
+-/
+def sorries (t : InfoTree) : List (ContextInfo × SorryType × Position × Position) :=
+  (t.findSorryTacticNodes.map fun ⟨i, ctx⟩ =>
+    -- HACK: creating a child ngen
+    ({ ctx with mctx := i.mctxBefore, ngen := ctx.ngen.mkChild.1 }, .tactic i.goalsBefore.head!,
+      stxRange ctx.fileMap i.stx)) ++
+  (t.findSorryTermNodes.map fun ⟨i, ctx⟩ =>
+    (ctx, .term i.lctx i.expectedType?, stxRange ctx.fileMap i.stx))
+
+def tactics (t : InfoTree) : List (ContextInfo × Syntax × List MVarId × Position × Position) :=
+  (t.findTacticNodes.map fun ⟨i, ctx⟩ =>
+    -- HACK: creating a child ngen
+     ({ ctx with mctx := i.mctxBefore, ngen := ctx.ngen.mkChild.1 }, i.stx, i.goalsBefore,
+       stxRange ctx.fileMap i.stx))
+
+
+end Lean.Elab.InfoTree
+
+namespace Lean.Elab.TacticInfo
+
+/-- Return the range of the tactic, as a pair of file positions. -/
+def range (info : TacticInfo) (ctx : ContextInfo) : Position × Position := ctx.fileMap.stxRange info.stx
+
+/-- Pretty print a tactic. -/
+def pp (info : TacticInfo) (ctx : ContextInfo) : IO Format :=
+  ctx.runMetaM {} try
+    Lean.PrettyPrinter.ppTactic ⟨info.stx⟩
+  catch _ =>
+    pure "<failed to pretty print>"
+
+open Meta
+
+/-- Run a tactic on the goals stored in a `TacticInfo`. -/
+def runMetaMGoalsBefore (info : TacticInfo) (ctx : ContextInfo) (x : List MVarId → MetaM α) : IO α := do
+  ctx.runMetaM {} <| Meta.withMCtx info.mctxBefore <| x info.goalsBefore
+
+/-- Run a tactic on the after goals stored in a `TacticInfo`. -/
+def runMetaMGoalsAfter (info : TacticInfo) (ctx : ContextInfo) (x : List MVarId → MetaM α) : IO α := do
+  ctx.runMetaM {} <| Meta.withMCtx info.mctxAfter <| x info.goalsAfter
+
+/-- Run a tactic on the main goal stored in a `TacticInfo`. -/
+def runMetaM (info : TacticInfo) (ctx : ContextInfo) (x : MVarId → MetaM α) : IO α := do
+  match info.goalsBefore.head? with
+  | none => throw <| IO.userError s!"No goals at {← info.pp ctx}"
+  | some g => info.runMetaMGoalsBefore ctx fun _ => do g.withContext <| x g
+
+def mainGoal (info : TacticInfo) (ctx : ContextInfo) : IO Expr :=
+  info.runMetaM ctx (fun g => do instantiateMVars (← g.getType))
+
+def formatMainGoal (info : TacticInfo) (ctx : ContextInfo) : IO Format :=
+  info.runMetaM ctx (fun g => do ppExpr (← instantiateMVars (← g.getType)))
+
+def goalState (info : TacticInfo) (ctx : ContextInfo) : IO (List Format) := do
+  info.runMetaMGoalsBefore ctx (fun gs => gs.mapM fun g => do Meta.ppGoal g)
+
+def goalStateAfter (info : TacticInfo) (ctx : ContextInfo) : IO (List Format) := do
+  info.runMetaMGoalsAfter ctx (fun gs => gs.mapM fun g => do Meta.ppGoal g)
+
+def ppExpr (info : TacticInfo) (ctx : ContextInfo) (e : Expr) : IO Format :=
+  info.runMetaM ctx (fun _ => do Meta.ppExpr (← instantiateMVars e))
+
+end Lean.Elab.TacticInfo
+
+namespace Lean.Elab.InfoTree
+
+/--
+Finds all tactic invocations in an `InfoTree`,
+ignoring structuring tactics (e.g. `by`, `;`, multiline tactics, parenthesized tactics).
+-/
+def substantiveTactics (t : InfoTree) : List (TacticInfo × ContextInfo) :=
+  t.findTacticNodes.filter fun i => i.1.isSubstantive
+
+end Lean.Elab.InfoTree

itp_interface/tools/repl/REPL/Main.lean

@@ -0,0 +1,323 @@
+/-
+Copyright (c) 2023 Scott Morrison. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Scott Morrison
+-/
+import REPL.JSON
+import REPL.Frontend
+import REPL.Util.Path
+import REPL.Lean.ContextInfo
+import REPL.Lean.Environment
+import REPL.Lean.InfoTree
+import REPL.Lean.InfoTree.ToJson
+import REPL.Snapshots
+
+/-!
+# A REPL for Lean.
+
+Communicates via JSON on stdin and stdout. Commands should be separated by blank lines.
+
+Commands may be of the form
+```
+{ "cmd" : "import Mathlib.Data.List.Basic\ndef f := 2" }
+```
+or
+```
+{ "cmd" : "example : f = 2 := rfl", "env" : 3 }
+```
+
+The `env` field, if present,
+must contain a number received in the `env` field of a previous response,
+and causes the command to be run in the existing environment.
+
+If there is no `env` field, a new environment is created.
+
+You can only use `import` commands when you do not specify the `env` field.
+
+You can backtrack simply by using earlier values for `env`.
+
+The results are of the form
+```
+{"sorries":
+ [{"pos": {"line": 1, "column": 18},
+   "endPos": {"line": 1, "column": 23},
+   "goal": "\n⊢ Nat"}],
+ "messages":
+ [{"severity": "error",
+   "pos": {"line": 1, "column": 23},
+   "endPos": {"line": 1, "column": 26},
+   "data":
+   "type mismatch\n  rfl\nhas type\n  f = f : Prop\nbut is expected to have type\n  f = 2 : Prop"}],
+ "env": 6}
+ ```
+ showing any messages generated, or sorries with their goal states.
+ Information is generated for tactic mode sorries, but not for term mode sorries.
+-/
+
+open Lean Elab
+
+namespace REPL
+
+/-- The monadic state for the Lean REPL. -/
+structure State where
+  /--
+  Environment snapshots after complete declarations.
+  The user can run a declaration in a given environment using `{"cmd": "def f := 37", "env": 17}`.
+  -/
+  cmdStates : Array CommandSnapshot := #[]
+  /--
+  Proof states after individual tactics.
+  The user can run a tactic in a given proof state using `{"tactic": "exact 42", "proofState": 5}`.
+  Declarations with containing `sorry` record a proof state at each sorry,
+  and report the numerical index for the recorded state at each sorry.
+  -/
+  proofStates : Array ProofSnapshot := #[]
+
+/--
+The Lean REPL monad.
+
+We only use this with `m := IO`, but it is set up as a monad transformer for flexibility.
+-/
+abbrev M (m : Type → Type) := StateT State m
+
+variable [Monad m] [MonadLiftT IO m]
+
+/-- Record an `CommandSnapshot` into the REPL state, returning its index for future use. -/
+def recordCommandSnapshot (state : CommandSnapshot) : M m Nat := do
+  let id := (← get).cmdStates.size
+  modify fun s => { s with cmdStates := s.cmdStates.push state }
+  return id
+
+/-- Record a `ProofSnapshot` into the REPL state, returning its index for future use. -/
+def recordProofSnapshot (proofState : ProofSnapshot) : M m Nat := do
+  let id := (← get).proofStates.size
+  modify fun s => { s with proofStates := s.proofStates.push proofState }
+  return id
+
+def sorries (trees : List InfoTree) (env? : Option Environment) : M m (List Sorry) :=
+  trees.bind InfoTree.sorries |>.mapM
+    fun ⟨ctx, g, pos, endPos⟩ => do
+      let (goal, proofState) ← match g with
+      | .tactic g => do
+         let s ← ProofSnapshot.create ctx none env? [g]
+         pure ("\n".intercalate <| (← s.ppGoals).map fun s => s!"{s}", some s)
+      | .term lctx (some t) => do
+         let s ← ProofSnapshot.create ctx lctx env? [] [t]
+         pure ("\n".intercalate <| (← s.ppGoals).map fun s => s!"{s}", some s)
+      | .term _ none => unreachable!
+      let proofStateId ← proofState.mapM recordProofSnapshot
+      return Sorry.of goal pos endPos proofStateId
+
+def ppTactic (ctx : ContextInfo) (stx : Syntax) : IO Format :=
+  ctx.runMetaM {} try
+    Lean.PrettyPrinter.ppTactic ⟨stx⟩
+  catch _ =>
+    pure "<failed to pretty print>"
+
+def tactics (trees : List InfoTree) : M m (List Tactic) :=
+  trees.bind InfoTree.tactics |>.mapM
+    fun ⟨ctx, stx, goals, pos, endPos⟩ => do
+      let proofState := some (← ProofSnapshot.create ctx none none goals)
+      let goals := s!"{(← ctx.ppGoals goals)}".trim
+      let tactic := Format.pretty (← ppTactic ctx stx)
+      let proofStateId ← proofState.mapM recordProofSnapshot
+      return Tactic.of goals tactic pos endPos proofStateId
+
+/-- Record a `ProofSnapshot` and generate a JSON response for it. -/
+def createProofStepReponse (proofState : ProofSnapshot) (old? : Option ProofSnapshot := none) :
+    M m ProofStepResponse := do
+  let messages := proofState.newMessages old?
+  let messages ← messages.mapM fun m => Message.of m
+  let traces ← proofState.newTraces old?
+  let trees := proofState.newInfoTrees old?
+  let trees ← match old? with
+  | some old => do
+    let (ctx, _) ← old.runMetaM do return { ← CommandContextInfo.save with }
+    let ctx := PartialContextInfo.commandCtx ctx
+    pure <| trees.map fun t => InfoTree.context ctx t
+  | none => pure trees
+  -- For debugging purposes, sometimes we print out the trees here:
+  -- trees.forM fun t => do IO.println (← t.format)
+  let sorries ← sorries trees none
+  let id ← recordProofSnapshot proofState
+  return {
+    proofState := id
+    goals := (← proofState.ppGoals).map fun s => s!"{s}"
+    messages
+    sorries
+    traces }
+
+/-- Pickle a `CommandSnapshot`, generating a JSON response. -/
+def pickleCommandSnapshot (n : PickleEnvironment) : M m (CommandResponse ⊕ Error) := do
+  match (← get).cmdStates[n.env]? with
+  | none => return .inr ⟨"Unknown environment."⟩
+  | some env =>
+    discard <| env.pickle n.pickleTo
+    return .inl { env := n.env }
+
+/-- Unpickle a `CommandSnapshot`, generating a JSON response. -/
+def unpickleCommandSnapshot (n : UnpickleEnvironment) : M IO CommandResponse := do
+  let (env, _) ← CommandSnapshot.unpickle n.unpickleEnvFrom
+  let env ← recordCommandSnapshot env
+  return { env }
+
+/-- Pickle a `ProofSnapshot`, generating a JSON response. -/
+-- This generates a new identifier, which perhaps is not what we want?
+def pickleProofSnapshot (n : PickleProofState) : M m (ProofStepResponse ⊕ Error) := do
+  match (← get).proofStates[n.proofState]? with
+  | none => return .inr ⟨"Unknown proof State."⟩
+  | some proofState =>
+    discard <| proofState.pickle n.pickleTo
+    return .inl (← createProofStepReponse proofState)
+
+/-- Unpickle a `ProofSnapshot`, generating a JSON response. -/
+def unpickleProofSnapshot (n : UnpickleProofState) : M IO (ProofStepResponse ⊕ Error) := do
+  let (cmdSnapshot?, notFound) ← do match n.env with
+  | none => pure (none, false)
+  | some i => do match (← get).cmdStates[i]? with
+    | some env => pure (some env, false)
+    | none => pure (none, true)
+  if notFound then
+    return .inr ⟨"Unknown environment."⟩
+  let (proofState, _) ← ProofSnapshot.unpickle n.unpickleProofStateFrom cmdSnapshot?
+  Sum.inl <$> createProofStepReponse proofState
+
+/--
+Run a command, returning the id of the new environment, and any messages and sorries.
+-/
+def runCommand (s : Command) : M IO (CommandResponse ⊕ Error) := do
+  let (cmdSnapshot?, notFound) ← do match s.env with
+  | none => pure (none, false)
+  | some i => do match (← get).cmdStates[i]? with
+    | some env => pure (some env, false)
+    | none => pure (none, true)
+  if notFound then
+    return .inr ⟨"Unknown environment."⟩
+  let initialCmdState? := cmdSnapshot?.map fun c => c.cmdState
+  let (cmdState, messages, trees) ← try
+    IO.processInput s.cmd initialCmdState?
+  catch ex =>
+    return .inr ⟨ex.toString⟩
+  let messages ← messages.mapM fun m => Message.of m
+  -- For debugging purposes, sometimes we print out the trees here:
+  -- trees.forM fun t => do IO.println (← t.format)
+  let sorries ← sorries trees (initialCmdState?.map (·.env))
+  let tactics ← match s.allTactics with
+  | some true => tactics trees
+  | _ => pure []
+  let cmdSnapshot :=
+  { cmdState
+    cmdContext := (cmdSnapshot?.map fun c => c.cmdContext).getD
+      { fileName := "", fileMap := default, tacticCache? := none } }
+  let env ← recordCommandSnapshot cmdSnapshot
+  let jsonTrees := match s.infotree with
+  | some "full" => trees
+  | some "tactics" => trees.bind InfoTree.retainTacticInfo
+  | some "original" => trees.bind InfoTree.retainTacticInfo |>.bind InfoTree.retainOriginal
+  | some "substantive" => trees.bind InfoTree.retainTacticInfo |>.bind InfoTree.retainSubstantive
+  | _ => []
+  let infotree := if jsonTrees.isEmpty then
+    none
+  else
+    some <| Json.arr (← jsonTrees.toArray.mapM fun t => t.toJson none)
+  return .inl
+    { env,
+      messages,
+      sorries,
+      tactics
+      infotree }
+
+def processFile (s : File) : M IO (CommandResponse ⊕ Error) := do
+  try
+    let cmd ← IO.FS.readFile s.path
+    runCommand { s with env := none, cmd }
+  catch e =>
+    pure <| .inr ⟨e.toString⟩
+
+/--
+Run a single tactic, returning the id of the new proof statement, and the new goals.
+-/
+-- TODO detect sorries?
+def runProofStep (s : ProofStep) : M IO (ProofStepResponse ⊕ Error) := do
+  match (← get).proofStates[s.proofState]? with
+  | none => return .inr ⟨"Unknown proof state."⟩
+  | some proofState =>
+    try
+      let proofState' ← proofState.runString s.tactic
+      return .inl (← createProofStepReponse proofState' proofState)
+    catch ex =>
+      return .inr ⟨"Lean error:\n" ++ ex.toString⟩
+
+end REPL
+
+open REPL
+
+/-- Get lines from stdin until a blank line is entered. -/
+partial def getLines : IO String := do
+  let line ← (← IO.getStdin).getLine
+  if line.trim.isEmpty then
+    return line
+  else
+    return line ++ (← getLines)
+
+instance [ToJson α] [ToJson β] : ToJson (α ⊕ β) where
+  toJson x := match x with
+  | .inl a => toJson a
+  | .inr b => toJson b
+
+/-- Commands accepted by the REPL. -/
+inductive Input
+| command : REPL.Command → Input
+| file : REPL.File → Input
+| proofStep : REPL.ProofStep → Input
+| pickleEnvironment : REPL.PickleEnvironment → Input
+| unpickleEnvironment : REPL.UnpickleEnvironment → Input
+| pickleProofSnapshot : REPL.PickleProofState → Input
+| unpickleProofSnapshot : REPL.UnpickleProofState → Input
+
+/-- Parse a user input string to an input command. -/
+def parse (query : String) : IO Input := do
+  let json := Json.parse query
+  match json with
+  | .error e => throw <| IO.userError <| toString <| toJson <|
+      (⟨"Could not parse JSON:\n" ++ e⟩ : Error)
+  | .ok j => match fromJson? j with
+    | .ok (r : REPL.ProofStep) => return .proofStep r
+    | .error _ => match fromJson? j with
+    | .ok (r : REPL.PickleEnvironment) => return .pickleEnvironment r
+    | .error _ => match fromJson? j with
+    | .ok (r : REPL.UnpickleEnvironment) => return .unpickleEnvironment r
+    | .error _ => match fromJson? j with
+    | .ok (r : REPL.PickleProofState) => return .pickleProofSnapshot r
+    | .error _ => match fromJson? j with
+    | .ok (r : REPL.UnpickleProofState) => return .unpickleProofSnapshot r
+    | .error _ => match fromJson? j with
+    | .ok (r : REPL.Command) => return .command r
+    | .error _ => match fromJson? j with
+    | .ok (r : REPL.File) => return .file r
+    | .error e => throw <| IO.userError <| toString <| toJson <|
+        (⟨"Could not parse as a valid JSON command:\n" ++ e⟩ : Error)
+
+/-- Read-eval-print loop for Lean. -/
+unsafe def repl : IO Unit :=
+  StateT.run' loop {}
+where loop : M IO Unit := do
+  let query ← getLines
+  if query = "" then
+    return ()
+  if query.startsWith "#" || query.startsWith "--" then loop else
+  IO.println <| toString <| ← match ← parse query with
+  | .command r => return toJson (← runCommand r)
+  | .file r => return toJson (← processFile r)
+  | .proofStep r => return toJson (← runProofStep r)
+  | .pickleEnvironment r => return toJson (← pickleCommandSnapshot r)
+  | .unpickleEnvironment r => return toJson (← unpickleCommandSnapshot r)
+  | .pickleProofSnapshot r => return toJson (← pickleProofSnapshot r)
+  | .unpickleProofSnapshot r => return toJson (← unpickleProofSnapshot r)
+  IO.println "" -- easier to parse the output if there are blank lines
+  loop
+
+/-- Main executable function, run as `lake exe repl`. -/
+unsafe def main (_ : List String) : IO Unit := do
+  initSearchPath (← Lean.findSysroot)
+  repl