dfd3d18530
This PR significantly improves the test coverage of the language server, providing at least a single basic test for every request that is used by the client. It also implements infrastructure for testing all of these requests, e.g. the ability to run interactive tests in a project context and refactors the interactive test runner to be more maintainable. Finally, it also fixes a small bug with the recently implemented unknown identifier code actions for auto-implicits (#10442) that was discovered in testing, where the "import all unambiguous unknown identifiers" code action didn't work correctly on auto-implicit identifiers.
1740 lines
91 KiB
Text
1740 lines
91 KiB
Text
{"textDocument": {"uri": "file:///completionTactics.lean"},
|
|
"position": {"line": 20, "character": 20}}
|
|
{"items": [], "isIncomplete": true}
|
|
{"textDocument": {"uri": "file:///completionTactics.lean"},
|
|
"position": {"line": 23, "character": 21}}
|
|
{"items":
|
|
[{"label": "Lean.Parser.Tactic.open",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"`open Foo in tacs` (the tactic) acts like `open Foo` at command level,\nbut it opens a namespace only within the tactics `tacs`. ",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 23, 21, 0]},
|
|
{"label": "Lean.Parser.Tactic.match",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"`match` performs case analysis on one or more expressions.\nSee [Induction and Recursion][tpil4].\nThe syntax for the `match` tactic is the same as term-mode `match`, except that\nthe match arms are tactics instead of expressions.\n```\nexample (n : Nat) : n = n := by\n match n with\n | 0 => rfl\n | i+1 => simp\n```\n\n[tpil4]: https://lean-lang.org/theorem_proving_in_lean4/induction_and_recursion.html\n",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 23, 21, 0]},
|
|
{"label": "Lean.Parser.Tactic.set_option",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"`set_option opt val in tacs` (the tactic) acts like `set_option opt val` at the command level,\nbut it sets the option only within the tactics `tacs`. ",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 23, 21, 0]},
|
|
{"label": "skip",
|
|
"kind": 14,
|
|
"documentation": {"value": "A docstring ", "kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 23, 21, 0]},
|
|
{"label": "Lean.Parser.Tactic.nestedTactic",
|
|
"kind": 14,
|
|
"data": ["«external:file:///completionTactics.lean»", 23, 21, 0]},
|
|
{"label": "Lean.Parser.Tactic.unknown",
|
|
"kind": 14,
|
|
"data": ["«external:file:///completionTactics.lean»", 23, 21, 0]},
|
|
{"label": "exact",
|
|
"kind": 14,
|
|
"documentation": {"value": "Another docstring ", "kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 23, 21, 0]},
|
|
{"label": "Lean.Parser.Tactic.introMatch",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"The tactic\n```\nintro\n| pat1 => tac1\n| pat2 => tac2\n```\nis the same as:\n```\nintro x\nmatch x with\n| pat1 => tac1\n| pat2 => tac2\n```\nThat is, `intro` can be followed by match arms and it introduces the values while\ndoing a pattern match. This is equivalent to `fun` with match arms in term mode.\n",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 23, 21, 0]}],
|
|
"isIncomplete": true}
|
|
Resolution of Lean.Parser.Tactic.open:
|
|
{"label": "Lean.Parser.Tactic.open",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"`open Foo in tacs` (the tactic) acts like `open Foo` at command level,\nbut it opens a namespace only within the tactics `tacs`. ",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 23, 21, 0]}
|
|
Resolution of Lean.Parser.Tactic.match:
|
|
{"label": "Lean.Parser.Tactic.match",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"`match` performs case analysis on one or more expressions.\nSee [Induction and Recursion][tpil4].\nThe syntax for the `match` tactic is the same as term-mode `match`, except that\nthe match arms are tactics instead of expressions.\n```\nexample (n : Nat) : n = n := by\n match n with\n | 0 => rfl\n | i+1 => simp\n```\n\n[tpil4]: https://lean-lang.org/theorem_proving_in_lean4/induction_and_recursion.html\n",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 23, 21, 0]}
|
|
Resolution of Lean.Parser.Tactic.set_option:
|
|
{"label": "Lean.Parser.Tactic.set_option",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"`set_option opt val in tacs` (the tactic) acts like `set_option opt val` at the command level,\nbut it sets the option only within the tactics `tacs`. ",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 23, 21, 0]}
|
|
Resolution of skip:
|
|
{"label": "skip",
|
|
"kind": 14,
|
|
"documentation": {"value": "A docstring ", "kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 23, 21, 0]}
|
|
Resolution of Lean.Parser.Tactic.nestedTactic:
|
|
{"label": "Lean.Parser.Tactic.nestedTactic",
|
|
"kind": 14,
|
|
"data": ["«external:file:///completionTactics.lean»", 23, 21, 0]}
|
|
Resolution of Lean.Parser.Tactic.unknown:
|
|
{"label": "Lean.Parser.Tactic.unknown",
|
|
"kind": 14,
|
|
"data": ["«external:file:///completionTactics.lean»", 23, 21, 0]}
|
|
Resolution of exact:
|
|
{"label": "exact",
|
|
"kind": 14,
|
|
"documentation": {"value": "Another docstring ", "kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 23, 21, 0]}
|
|
Resolution of Lean.Parser.Tactic.introMatch:
|
|
{"label": "Lean.Parser.Tactic.introMatch",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"The tactic\n```\nintro\n| pat1 => tac1\n| pat2 => tac2\n```\nis the same as:\n```\nintro x\nmatch x with\n| pat1 => tac1\n| pat2 => tac2\n```\nThat is, `intro` can be followed by match arms and it introduces the values while\ndoing a pattern match. This is equivalent to `fun` with match arms in term mode.\n",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 23, 21, 0]}
|
|
{"textDocument": {"uri": "file:///completionTactics.lean"},
|
|
"position": {"line": 26, "character": 24}}
|
|
{"items":
|
|
[{"label": "Lean.Parser.Tactic.open",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"`open Foo in tacs` (the tactic) acts like `open Foo` at command level,\nbut it opens a namespace only within the tactics `tacs`. ",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 26, 24, 0]},
|
|
{"label": "Lean.Parser.Tactic.match",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"`match` performs case analysis on one or more expressions.\nSee [Induction and Recursion][tpil4].\nThe syntax for the `match` tactic is the same as term-mode `match`, except that\nthe match arms are tactics instead of expressions.\n```\nexample (n : Nat) : n = n := by\n match n with\n | 0 => rfl\n | i+1 => simp\n```\n\n[tpil4]: https://lean-lang.org/theorem_proving_in_lean4/induction_and_recursion.html\n",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 26, 24, 0]},
|
|
{"label": "Lean.Parser.Tactic.set_option",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"`set_option opt val in tacs` (the tactic) acts like `set_option opt val` at the command level,\nbut it sets the option only within the tactics `tacs`. ",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 26, 24, 0]},
|
|
{"label": "skip",
|
|
"kind": 14,
|
|
"documentation": {"value": "A docstring ", "kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 26, 24, 0]},
|
|
{"label": "Lean.Parser.Tactic.nestedTactic",
|
|
"kind": 14,
|
|
"data": ["«external:file:///completionTactics.lean»", 26, 24, 0]},
|
|
{"label": "Lean.Parser.Tactic.unknown",
|
|
"kind": 14,
|
|
"data": ["«external:file:///completionTactics.lean»", 26, 24, 0]},
|
|
{"label": "exact",
|
|
"kind": 14,
|
|
"documentation": {"value": "Another docstring ", "kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 26, 24, 0]},
|
|
{"label": "Lean.Parser.Tactic.introMatch",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"The tactic\n```\nintro\n| pat1 => tac1\n| pat2 => tac2\n```\nis the same as:\n```\nintro x\nmatch x with\n| pat1 => tac1\n| pat2 => tac2\n```\nThat is, `intro` can be followed by match arms and it introduces the values while\ndoing a pattern match. This is equivalent to `fun` with match arms in term mode.\n",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 26, 24, 0]}],
|
|
"isIncomplete": false}
|
|
Resolution of Lean.Parser.Tactic.open:
|
|
{"label": "Lean.Parser.Tactic.open",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"`open Foo in tacs` (the tactic) acts like `open Foo` at command level,\nbut it opens a namespace only within the tactics `tacs`. ",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 26, 24, 0]}
|
|
Resolution of Lean.Parser.Tactic.match:
|
|
{"label": "Lean.Parser.Tactic.match",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"`match` performs case analysis on one or more expressions.\nSee [Induction and Recursion][tpil4].\nThe syntax for the `match` tactic is the same as term-mode `match`, except that\nthe match arms are tactics instead of expressions.\n```\nexample (n : Nat) : n = n := by\n match n with\n | 0 => rfl\n | i+1 => simp\n```\n\n[tpil4]: https://lean-lang.org/theorem_proving_in_lean4/induction_and_recursion.html\n",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 26, 24, 0]}
|
|
Resolution of Lean.Parser.Tactic.set_option:
|
|
{"label": "Lean.Parser.Tactic.set_option",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"`set_option opt val in tacs` (the tactic) acts like `set_option opt val` at the command level,\nbut it sets the option only within the tactics `tacs`. ",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 26, 24, 0]}
|
|
Resolution of skip:
|
|
{"label": "skip",
|
|
"kind": 14,
|
|
"documentation": {"value": "A docstring ", "kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 26, 24, 0]}
|
|
Resolution of Lean.Parser.Tactic.nestedTactic:
|
|
{"label": "Lean.Parser.Tactic.nestedTactic",
|
|
"kind": 14,
|
|
"data": ["«external:file:///completionTactics.lean»", 26, 24, 0]}
|
|
Resolution of Lean.Parser.Tactic.unknown:
|
|
{"label": "Lean.Parser.Tactic.unknown",
|
|
"kind": 14,
|
|
"data": ["«external:file:///completionTactics.lean»", 26, 24, 0]}
|
|
Resolution of exact:
|
|
{"label": "exact",
|
|
"kind": 14,
|
|
"documentation": {"value": "Another docstring ", "kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 26, 24, 0]}
|
|
Resolution of Lean.Parser.Tactic.introMatch:
|
|
{"label": "Lean.Parser.Tactic.introMatch",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"The tactic\n```\nintro\n| pat1 => tac1\n| pat2 => tac2\n```\nis the same as:\n```\nintro x\nmatch x with\n| pat1 => tac1\n| pat2 => tac2\n```\nThat is, `intro` can be followed by match arms and it introduces the values while\ndoing a pattern match. This is equivalent to `fun` with match arms in term mode.\n",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 26, 24, 0]}
|
|
{"textDocument": {"uri": "file:///completionTactics.lean"},
|
|
"position": {"line": 29, "character": 25}}
|
|
{"items": [], "isIncomplete": true}
|
|
{"textDocument": {"uri": "file:///completionTactics.lean"},
|
|
"position": {"line": 32, "character": 26}}
|
|
{"items":
|
|
[{"label": "Lean.Parser.Tactic.open",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"`open Foo in tacs` (the tactic) acts like `open Foo` at command level,\nbut it opens a namespace only within the tactics `tacs`. ",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 32, 26, 0]},
|
|
{"label": "Lean.Parser.Tactic.match",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"`match` performs case analysis on one or more expressions.\nSee [Induction and Recursion][tpil4].\nThe syntax for the `match` tactic is the same as term-mode `match`, except that\nthe match arms are tactics instead of expressions.\n```\nexample (n : Nat) : n = n := by\n match n with\n | 0 => rfl\n | i+1 => simp\n```\n\n[tpil4]: https://lean-lang.org/theorem_proving_in_lean4/induction_and_recursion.html\n",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 32, 26, 0]},
|
|
{"label": "Lean.Parser.Tactic.set_option",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"`set_option opt val in tacs` (the tactic) acts like `set_option opt val` at the command level,\nbut it sets the option only within the tactics `tacs`. ",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 32, 26, 0]},
|
|
{"label": "skip",
|
|
"kind": 14,
|
|
"documentation": {"value": "A docstring ", "kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 32, 26, 0]},
|
|
{"label": "Lean.Parser.Tactic.nestedTactic",
|
|
"kind": 14,
|
|
"data": ["«external:file:///completionTactics.lean»", 32, 26, 0]},
|
|
{"label": "Lean.Parser.Tactic.unknown",
|
|
"kind": 14,
|
|
"data": ["«external:file:///completionTactics.lean»", 32, 26, 0]},
|
|
{"label": "exact",
|
|
"kind": 14,
|
|
"documentation": {"value": "Another docstring ", "kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 32, 26, 0]},
|
|
{"label": "Lean.Parser.Tactic.introMatch",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"The tactic\n```\nintro\n| pat1 => tac1\n| pat2 => tac2\n```\nis the same as:\n```\nintro x\nmatch x with\n| pat1 => tac1\n| pat2 => tac2\n```\nThat is, `intro` can be followed by match arms and it introduces the values while\ndoing a pattern match. This is equivalent to `fun` with match arms in term mode.\n",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 32, 26, 0]}],
|
|
"isIncomplete": true}
|
|
Resolution of Lean.Parser.Tactic.open:
|
|
{"label": "Lean.Parser.Tactic.open",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"`open Foo in tacs` (the tactic) acts like `open Foo` at command level,\nbut it opens a namespace only within the tactics `tacs`. ",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 32, 26, 0]}
|
|
Resolution of Lean.Parser.Tactic.match:
|
|
{"label": "Lean.Parser.Tactic.match",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"`match` performs case analysis on one or more expressions.\nSee [Induction and Recursion][tpil4].\nThe syntax for the `match` tactic is the same as term-mode `match`, except that\nthe match arms are tactics instead of expressions.\n```\nexample (n : Nat) : n = n := by\n match n with\n | 0 => rfl\n | i+1 => simp\n```\n\n[tpil4]: https://lean-lang.org/theorem_proving_in_lean4/induction_and_recursion.html\n",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 32, 26, 0]}
|
|
Resolution of Lean.Parser.Tactic.set_option:
|
|
{"label": "Lean.Parser.Tactic.set_option",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"`set_option opt val in tacs` (the tactic) acts like `set_option opt val` at the command level,\nbut it sets the option only within the tactics `tacs`. ",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 32, 26, 0]}
|
|
Resolution of skip:
|
|
{"label": "skip",
|
|
"kind": 14,
|
|
"documentation": {"value": "A docstring ", "kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 32, 26, 0]}
|
|
Resolution of Lean.Parser.Tactic.nestedTactic:
|
|
{"label": "Lean.Parser.Tactic.nestedTactic",
|
|
"kind": 14,
|
|
"data": ["«external:file:///completionTactics.lean»", 32, 26, 0]}
|
|
Resolution of Lean.Parser.Tactic.unknown:
|
|
{"label": "Lean.Parser.Tactic.unknown",
|
|
"kind": 14,
|
|
"data": ["«external:file:///completionTactics.lean»", 32, 26, 0]}
|
|
Resolution of exact:
|
|
{"label": "exact",
|
|
"kind": 14,
|
|
"documentation": {"value": "Another docstring ", "kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 32, 26, 0]}
|
|
Resolution of Lean.Parser.Tactic.introMatch:
|
|
{"label": "Lean.Parser.Tactic.introMatch",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"The tactic\n```\nintro\n| pat1 => tac1\n| pat2 => tac2\n```\nis the same as:\n```\nintro x\nmatch x with\n| pat1 => tac1\n| pat2 => tac2\n```\nThat is, `intro` can be followed by match arms and it introduces the values while\ndoing a pattern match. This is equivalent to `fun` with match arms in term mode.\n",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 32, 26, 0]}
|
|
{"textDocument": {"uri": "file:///completionTactics.lean"},
|
|
"position": {"line": 35, "character": 27}}
|
|
{"items":
|
|
[{"label": "Lean.Parser.Tactic.open",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"`open Foo in tacs` (the tactic) acts like `open Foo` at command level,\nbut it opens a namespace only within the tactics `tacs`. ",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 35, 27, 0]},
|
|
{"label": "Lean.Parser.Tactic.match",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"`match` performs case analysis on one or more expressions.\nSee [Induction and Recursion][tpil4].\nThe syntax for the `match` tactic is the same as term-mode `match`, except that\nthe match arms are tactics instead of expressions.\n```\nexample (n : Nat) : n = n := by\n match n with\n | 0 => rfl\n | i+1 => simp\n```\n\n[tpil4]: https://lean-lang.org/theorem_proving_in_lean4/induction_and_recursion.html\n",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 35, 27, 0]},
|
|
{"label": "Lean.Parser.Tactic.set_option",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"`set_option opt val in tacs` (the tactic) acts like `set_option opt val` at the command level,\nbut it sets the option only within the tactics `tacs`. ",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 35, 27, 0]},
|
|
{"label": "skip",
|
|
"kind": 14,
|
|
"documentation": {"value": "A docstring ", "kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 35, 27, 0]},
|
|
{"label": "Lean.Parser.Tactic.nestedTactic",
|
|
"kind": 14,
|
|
"data": ["«external:file:///completionTactics.lean»", 35, 27, 0]},
|
|
{"label": "Lean.Parser.Tactic.unknown",
|
|
"kind": 14,
|
|
"data": ["«external:file:///completionTactics.lean»", 35, 27, 0]},
|
|
{"label": "exact",
|
|
"kind": 14,
|
|
"documentation": {"value": "Another docstring ", "kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 35, 27, 0]},
|
|
{"label": "Lean.Parser.Tactic.introMatch",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"The tactic\n```\nintro\n| pat1 => tac1\n| pat2 => tac2\n```\nis the same as:\n```\nintro x\nmatch x with\n| pat1 => tac1\n| pat2 => tac2\n```\nThat is, `intro` can be followed by match arms and it introduces the values while\ndoing a pattern match. This is equivalent to `fun` with match arms in term mode.\n",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 35, 27, 0]}],
|
|
"isIncomplete": true}
|
|
Resolution of Lean.Parser.Tactic.open:
|
|
{"label": "Lean.Parser.Tactic.open",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"`open Foo in tacs` (the tactic) acts like `open Foo` at command level,\nbut it opens a namespace only within the tactics `tacs`. ",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 35, 27, 0]}
|
|
Resolution of Lean.Parser.Tactic.match:
|
|
{"label": "Lean.Parser.Tactic.match",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"`match` performs case analysis on one or more expressions.\nSee [Induction and Recursion][tpil4].\nThe syntax for the `match` tactic is the same as term-mode `match`, except that\nthe match arms are tactics instead of expressions.\n```\nexample (n : Nat) : n = n := by\n match n with\n | 0 => rfl\n | i+1 => simp\n```\n\n[tpil4]: https://lean-lang.org/theorem_proving_in_lean4/induction_and_recursion.html\n",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 35, 27, 0]}
|
|
Resolution of Lean.Parser.Tactic.set_option:
|
|
{"label": "Lean.Parser.Tactic.set_option",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"`set_option opt val in tacs` (the tactic) acts like `set_option opt val` at the command level,\nbut it sets the option only within the tactics `tacs`. ",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 35, 27, 0]}
|
|
Resolution of skip:
|
|
{"label": "skip",
|
|
"kind": 14,
|
|
"documentation": {"value": "A docstring ", "kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 35, 27, 0]}
|
|
Resolution of Lean.Parser.Tactic.nestedTactic:
|
|
{"label": "Lean.Parser.Tactic.nestedTactic",
|
|
"kind": 14,
|
|
"data": ["«external:file:///completionTactics.lean»", 35, 27, 0]}
|
|
Resolution of Lean.Parser.Tactic.unknown:
|
|
{"label": "Lean.Parser.Tactic.unknown",
|
|
"kind": 14,
|
|
"data": ["«external:file:///completionTactics.lean»", 35, 27, 0]}
|
|
Resolution of exact:
|
|
{"label": "exact",
|
|
"kind": 14,
|
|
"documentation": {"value": "Another docstring ", "kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 35, 27, 0]}
|
|
Resolution of Lean.Parser.Tactic.introMatch:
|
|
{"label": "Lean.Parser.Tactic.introMatch",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"The tactic\n```\nintro\n| pat1 => tac1\n| pat2 => tac2\n```\nis the same as:\n```\nintro x\nmatch x with\n| pat1 => tac1\n| pat2 => tac2\n```\nThat is, `intro` can be followed by match arms and it introduces the values while\ndoing a pattern match. This is equivalent to `fun` with match arms in term mode.\n",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 35, 27, 0]}
|
|
{"textDocument": {"uri": "file:///completionTactics.lean"},
|
|
"position": {"line": 40, "character": 7}}
|
|
{"items":
|
|
[{"label": "Lean.Parser.Tactic.open",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"`open Foo in tacs` (the tactic) acts like `open Foo` at command level,\nbut it opens a namespace only within the tactics `tacs`. ",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 40, 7, 0]},
|
|
{"label": "Lean.Parser.Tactic.match",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"`match` performs case analysis on one or more expressions.\nSee [Induction and Recursion][tpil4].\nThe syntax for the `match` tactic is the same as term-mode `match`, except that\nthe match arms are tactics instead of expressions.\n```\nexample (n : Nat) : n = n := by\n match n with\n | 0 => rfl\n | i+1 => simp\n```\n\n[tpil4]: https://lean-lang.org/theorem_proving_in_lean4/induction_and_recursion.html\n",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 40, 7, 0]},
|
|
{"label": "Lean.Parser.Tactic.set_option",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"`set_option opt val in tacs` (the tactic) acts like `set_option opt val` at the command level,\nbut it sets the option only within the tactics `tacs`. ",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 40, 7, 0]},
|
|
{"label": "skip",
|
|
"kind": 14,
|
|
"documentation": {"value": "A docstring ", "kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 40, 7, 0]},
|
|
{"label": "Lean.Parser.Tactic.nestedTactic",
|
|
"kind": 14,
|
|
"data": ["«external:file:///completionTactics.lean»", 40, 7, 0]},
|
|
{"label": "Lean.Parser.Tactic.unknown",
|
|
"kind": 14,
|
|
"data": ["«external:file:///completionTactics.lean»", 40, 7, 0]},
|
|
{"label": "exact",
|
|
"kind": 14,
|
|
"documentation": {"value": "Another docstring ", "kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 40, 7, 0]},
|
|
{"label": "Lean.Parser.Tactic.introMatch",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"The tactic\n```\nintro\n| pat1 => tac1\n| pat2 => tac2\n```\nis the same as:\n```\nintro x\nmatch x with\n| pat1 => tac1\n| pat2 => tac2\n```\nThat is, `intro` can be followed by match arms and it introduces the values while\ndoing a pattern match. This is equivalent to `fun` with match arms in term mode.\n",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 40, 7, 0]}],
|
|
"isIncomplete": true}
|
|
Resolution of Lean.Parser.Tactic.open:
|
|
{"label": "Lean.Parser.Tactic.open",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"`open Foo in tacs` (the tactic) acts like `open Foo` at command level,\nbut it opens a namespace only within the tactics `tacs`. ",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 40, 7, 0]}
|
|
Resolution of Lean.Parser.Tactic.match:
|
|
{"label": "Lean.Parser.Tactic.match",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"`match` performs case analysis on one or more expressions.\nSee [Induction and Recursion][tpil4].\nThe syntax for the `match` tactic is the same as term-mode `match`, except that\nthe match arms are tactics instead of expressions.\n```\nexample (n : Nat) : n = n := by\n match n with\n | 0 => rfl\n | i+1 => simp\n```\n\n[tpil4]: https://lean-lang.org/theorem_proving_in_lean4/induction_and_recursion.html\n",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 40, 7, 0]}
|
|
Resolution of Lean.Parser.Tactic.set_option:
|
|
{"label": "Lean.Parser.Tactic.set_option",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"`set_option opt val in tacs` (the tactic) acts like `set_option opt val` at the command level,\nbut it sets the option only within the tactics `tacs`. ",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 40, 7, 0]}
|
|
Resolution of skip:
|
|
{"label": "skip",
|
|
"kind": 14,
|
|
"documentation": {"value": "A docstring ", "kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 40, 7, 0]}
|
|
Resolution of Lean.Parser.Tactic.nestedTactic:
|
|
{"label": "Lean.Parser.Tactic.nestedTactic",
|
|
"kind": 14,
|
|
"data": ["«external:file:///completionTactics.lean»", 40, 7, 0]}
|
|
Resolution of Lean.Parser.Tactic.unknown:
|
|
{"label": "Lean.Parser.Tactic.unknown",
|
|
"kind": 14,
|
|
"data": ["«external:file:///completionTactics.lean»", 40, 7, 0]}
|
|
Resolution of exact:
|
|
{"label": "exact",
|
|
"kind": 14,
|
|
"documentation": {"value": "Another docstring ", "kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 40, 7, 0]}
|
|
Resolution of Lean.Parser.Tactic.introMatch:
|
|
{"label": "Lean.Parser.Tactic.introMatch",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"The tactic\n```\nintro\n| pat1 => tac1\n| pat2 => tac2\n```\nis the same as:\n```\nintro x\nmatch x with\n| pat1 => tac1\n| pat2 => tac2\n```\nThat is, `intro` can be followed by match arms and it introduces the values while\ndoing a pattern match. This is equivalent to `fun` with match arms in term mode.\n",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 40, 7, 0]}
|
|
{"textDocument": {"uri": "file:///completionTactics.lean"},
|
|
"position": {"line": 44, "character": 2}}
|
|
{"items":
|
|
[{"label": "Lean.Parser.Tactic.open",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"`open Foo in tacs` (the tactic) acts like `open Foo` at command level,\nbut it opens a namespace only within the tactics `tacs`. ",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 44, 2, 0]},
|
|
{"label": "Lean.Parser.Tactic.match",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"`match` performs case analysis on one or more expressions.\nSee [Induction and Recursion][tpil4].\nThe syntax for the `match` tactic is the same as term-mode `match`, except that\nthe match arms are tactics instead of expressions.\n```\nexample (n : Nat) : n = n := by\n match n with\n | 0 => rfl\n | i+1 => simp\n```\n\n[tpil4]: https://lean-lang.org/theorem_proving_in_lean4/induction_and_recursion.html\n",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 44, 2, 0]},
|
|
{"label": "Lean.Parser.Tactic.set_option",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"`set_option opt val in tacs` (the tactic) acts like `set_option opt val` at the command level,\nbut it sets the option only within the tactics `tacs`. ",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 44, 2, 0]},
|
|
{"label": "skip",
|
|
"kind": 14,
|
|
"documentation": {"value": "A docstring ", "kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 44, 2, 0]},
|
|
{"label": "Lean.Parser.Tactic.nestedTactic",
|
|
"kind": 14,
|
|
"data": ["«external:file:///completionTactics.lean»", 44, 2, 0]},
|
|
{"label": "Lean.Parser.Tactic.unknown",
|
|
"kind": 14,
|
|
"data": ["«external:file:///completionTactics.lean»", 44, 2, 0]},
|
|
{"label": "exact",
|
|
"kind": 14,
|
|
"documentation": {"value": "Another docstring ", "kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 44, 2, 0]},
|
|
{"label": "Lean.Parser.Tactic.introMatch",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"The tactic\n```\nintro\n| pat1 => tac1\n| pat2 => tac2\n```\nis the same as:\n```\nintro x\nmatch x with\n| pat1 => tac1\n| pat2 => tac2\n```\nThat is, `intro` can be followed by match arms and it introduces the values while\ndoing a pattern match. This is equivalent to `fun` with match arms in term mode.\n",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 44, 2, 0]}],
|
|
"isIncomplete": true}
|
|
Resolution of Lean.Parser.Tactic.open:
|
|
{"label": "Lean.Parser.Tactic.open",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"`open Foo in tacs` (the tactic) acts like `open Foo` at command level,\nbut it opens a namespace only within the tactics `tacs`. ",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 44, 2, 0]}
|
|
Resolution of Lean.Parser.Tactic.match:
|
|
{"label": "Lean.Parser.Tactic.match",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"`match` performs case analysis on one or more expressions.\nSee [Induction and Recursion][tpil4].\nThe syntax for the `match` tactic is the same as term-mode `match`, except that\nthe match arms are tactics instead of expressions.\n```\nexample (n : Nat) : n = n := by\n match n with\n | 0 => rfl\n | i+1 => simp\n```\n\n[tpil4]: https://lean-lang.org/theorem_proving_in_lean4/induction_and_recursion.html\n",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 44, 2, 0]}
|
|
Resolution of Lean.Parser.Tactic.set_option:
|
|
{"label": "Lean.Parser.Tactic.set_option",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"`set_option opt val in tacs` (the tactic) acts like `set_option opt val` at the command level,\nbut it sets the option only within the tactics `tacs`. ",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 44, 2, 0]}
|
|
Resolution of skip:
|
|
{"label": "skip",
|
|
"kind": 14,
|
|
"documentation": {"value": "A docstring ", "kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 44, 2, 0]}
|
|
Resolution of Lean.Parser.Tactic.nestedTactic:
|
|
{"label": "Lean.Parser.Tactic.nestedTactic",
|
|
"kind": 14,
|
|
"data": ["«external:file:///completionTactics.lean»", 44, 2, 0]}
|
|
Resolution of Lean.Parser.Tactic.unknown:
|
|
{"label": "Lean.Parser.Tactic.unknown",
|
|
"kind": 14,
|
|
"data": ["«external:file:///completionTactics.lean»", 44, 2, 0]}
|
|
Resolution of exact:
|
|
{"label": "exact",
|
|
"kind": 14,
|
|
"documentation": {"value": "Another docstring ", "kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 44, 2, 0]}
|
|
Resolution of Lean.Parser.Tactic.introMatch:
|
|
{"label": "Lean.Parser.Tactic.introMatch",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"The tactic\n```\nintro\n| pat1 => tac1\n| pat2 => tac2\n```\nis the same as:\n```\nintro x\nmatch x with\n| pat1 => tac1\n| pat2 => tac2\n```\nThat is, `intro` can be followed by match arms and it introduces the values while\ndoing a pattern match. This is equivalent to `fun` with match arms in term mode.\n",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 44, 2, 0]}
|
|
{"textDocument": {"uri": "file:///completionTactics.lean"},
|
|
"position": {"line": 49, "character": 2}}
|
|
{"items":
|
|
[{"label": "Lean.Parser.Tactic.open",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"`open Foo in tacs` (the tactic) acts like `open Foo` at command level,\nbut it opens a namespace only within the tactics `tacs`. ",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 49, 2, 0]},
|
|
{"label": "Lean.Parser.Tactic.match",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"`match` performs case analysis on one or more expressions.\nSee [Induction and Recursion][tpil4].\nThe syntax for the `match` tactic is the same as term-mode `match`, except that\nthe match arms are tactics instead of expressions.\n```\nexample (n : Nat) : n = n := by\n match n with\n | 0 => rfl\n | i+1 => simp\n```\n\n[tpil4]: https://lean-lang.org/theorem_proving_in_lean4/induction_and_recursion.html\n",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 49, 2, 0]},
|
|
{"label": "Lean.Parser.Tactic.set_option",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"`set_option opt val in tacs` (the tactic) acts like `set_option opt val` at the command level,\nbut it sets the option only within the tactics `tacs`. ",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 49, 2, 0]},
|
|
{"label": "skip",
|
|
"kind": 14,
|
|
"documentation": {"value": "A docstring ", "kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 49, 2, 0]},
|
|
{"label": "Lean.Parser.Tactic.nestedTactic",
|
|
"kind": 14,
|
|
"data": ["«external:file:///completionTactics.lean»", 49, 2, 0]},
|
|
{"label": "Lean.Parser.Tactic.unknown",
|
|
"kind": 14,
|
|
"data": ["«external:file:///completionTactics.lean»", 49, 2, 0]},
|
|
{"label": "exact",
|
|
"kind": 14,
|
|
"documentation": {"value": "Another docstring ", "kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 49, 2, 0]},
|
|
{"label": "Lean.Parser.Tactic.introMatch",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"The tactic\n```\nintro\n| pat1 => tac1\n| pat2 => tac2\n```\nis the same as:\n```\nintro x\nmatch x with\n| pat1 => tac1\n| pat2 => tac2\n```\nThat is, `intro` can be followed by match arms and it introduces the values while\ndoing a pattern match. This is equivalent to `fun` with match arms in term mode.\n",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 49, 2, 0]}],
|
|
"isIncomplete": true}
|
|
Resolution of Lean.Parser.Tactic.open:
|
|
{"label": "Lean.Parser.Tactic.open",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"`open Foo in tacs` (the tactic) acts like `open Foo` at command level,\nbut it opens a namespace only within the tactics `tacs`. ",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 49, 2, 0]}
|
|
Resolution of Lean.Parser.Tactic.match:
|
|
{"label": "Lean.Parser.Tactic.match",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"`match` performs case analysis on one or more expressions.\nSee [Induction and Recursion][tpil4].\nThe syntax for the `match` tactic is the same as term-mode `match`, except that\nthe match arms are tactics instead of expressions.\n```\nexample (n : Nat) : n = n := by\n match n with\n | 0 => rfl\n | i+1 => simp\n```\n\n[tpil4]: https://lean-lang.org/theorem_proving_in_lean4/induction_and_recursion.html\n",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 49, 2, 0]}
|
|
Resolution of Lean.Parser.Tactic.set_option:
|
|
{"label": "Lean.Parser.Tactic.set_option",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"`set_option opt val in tacs` (the tactic) acts like `set_option opt val` at the command level,\nbut it sets the option only within the tactics `tacs`. ",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 49, 2, 0]}
|
|
Resolution of skip:
|
|
{"label": "skip",
|
|
"kind": 14,
|
|
"documentation": {"value": "A docstring ", "kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 49, 2, 0]}
|
|
Resolution of Lean.Parser.Tactic.nestedTactic:
|
|
{"label": "Lean.Parser.Tactic.nestedTactic",
|
|
"kind": 14,
|
|
"data": ["«external:file:///completionTactics.lean»", 49, 2, 0]}
|
|
Resolution of Lean.Parser.Tactic.unknown:
|
|
{"label": "Lean.Parser.Tactic.unknown",
|
|
"kind": 14,
|
|
"data": ["«external:file:///completionTactics.lean»", 49, 2, 0]}
|
|
Resolution of exact:
|
|
{"label": "exact",
|
|
"kind": 14,
|
|
"documentation": {"value": "Another docstring ", "kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 49, 2, 0]}
|
|
Resolution of Lean.Parser.Tactic.introMatch:
|
|
{"label": "Lean.Parser.Tactic.introMatch",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"The tactic\n```\nintro\n| pat1 => tac1\n| pat2 => tac2\n```\nis the same as:\n```\nintro x\nmatch x with\n| pat1 => tac1\n| pat2 => tac2\n```\nThat is, `intro` can be followed by match arms and it introduces the values while\ndoing a pattern match. This is equivalent to `fun` with match arms in term mode.\n",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 49, 2, 0]}
|
|
{"textDocument": {"uri": "file:///completionTactics.lean"},
|
|
"position": {"line": 53, "character": 2}}
|
|
{"items":
|
|
[{"label": "Lean.Parser.Tactic.open",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"`open Foo in tacs` (the tactic) acts like `open Foo` at command level,\nbut it opens a namespace only within the tactics `tacs`. ",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 53, 2, 0]},
|
|
{"label": "Lean.Parser.Tactic.match",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"`match` performs case analysis on one or more expressions.\nSee [Induction and Recursion][tpil4].\nThe syntax for the `match` tactic is the same as term-mode `match`, except that\nthe match arms are tactics instead of expressions.\n```\nexample (n : Nat) : n = n := by\n match n with\n | 0 => rfl\n | i+1 => simp\n```\n\n[tpil4]: https://lean-lang.org/theorem_proving_in_lean4/induction_and_recursion.html\n",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 53, 2, 0]},
|
|
{"label": "Lean.Parser.Tactic.set_option",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"`set_option opt val in tacs` (the tactic) acts like `set_option opt val` at the command level,\nbut it sets the option only within the tactics `tacs`. ",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 53, 2, 0]},
|
|
{"label": "skip",
|
|
"kind": 14,
|
|
"documentation": {"value": "A docstring ", "kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 53, 2, 0]},
|
|
{"label": "Lean.Parser.Tactic.nestedTactic",
|
|
"kind": 14,
|
|
"data": ["«external:file:///completionTactics.lean»", 53, 2, 0]},
|
|
{"label": "Lean.Parser.Tactic.unknown",
|
|
"kind": 14,
|
|
"data": ["«external:file:///completionTactics.lean»", 53, 2, 0]},
|
|
{"label": "exact",
|
|
"kind": 14,
|
|
"documentation": {"value": "Another docstring ", "kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 53, 2, 0]},
|
|
{"label": "Lean.Parser.Tactic.introMatch",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"The tactic\n```\nintro\n| pat1 => tac1\n| pat2 => tac2\n```\nis the same as:\n```\nintro x\nmatch x with\n| pat1 => tac1\n| pat2 => tac2\n```\nThat is, `intro` can be followed by match arms and it introduces the values while\ndoing a pattern match. This is equivalent to `fun` with match arms in term mode.\n",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 53, 2, 0]}],
|
|
"isIncomplete": true}
|
|
Resolution of Lean.Parser.Tactic.open:
|
|
{"label": "Lean.Parser.Tactic.open",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"`open Foo in tacs` (the tactic) acts like `open Foo` at command level,\nbut it opens a namespace only within the tactics `tacs`. ",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 53, 2, 0]}
|
|
Resolution of Lean.Parser.Tactic.match:
|
|
{"label": "Lean.Parser.Tactic.match",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"`match` performs case analysis on one or more expressions.\nSee [Induction and Recursion][tpil4].\nThe syntax for the `match` tactic is the same as term-mode `match`, except that\nthe match arms are tactics instead of expressions.\n```\nexample (n : Nat) : n = n := by\n match n with\n | 0 => rfl\n | i+1 => simp\n```\n\n[tpil4]: https://lean-lang.org/theorem_proving_in_lean4/induction_and_recursion.html\n",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 53, 2, 0]}
|
|
Resolution of Lean.Parser.Tactic.set_option:
|
|
{"label": "Lean.Parser.Tactic.set_option",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"`set_option opt val in tacs` (the tactic) acts like `set_option opt val` at the command level,\nbut it sets the option only within the tactics `tacs`. ",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 53, 2, 0]}
|
|
Resolution of skip:
|
|
{"label": "skip",
|
|
"kind": 14,
|
|
"documentation": {"value": "A docstring ", "kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 53, 2, 0]}
|
|
Resolution of Lean.Parser.Tactic.nestedTactic:
|
|
{"label": "Lean.Parser.Tactic.nestedTactic",
|
|
"kind": 14,
|
|
"data": ["«external:file:///completionTactics.lean»", 53, 2, 0]}
|
|
Resolution of Lean.Parser.Tactic.unknown:
|
|
{"label": "Lean.Parser.Tactic.unknown",
|
|
"kind": 14,
|
|
"data": ["«external:file:///completionTactics.lean»", 53, 2, 0]}
|
|
Resolution of exact:
|
|
{"label": "exact",
|
|
"kind": 14,
|
|
"documentation": {"value": "Another docstring ", "kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 53, 2, 0]}
|
|
Resolution of Lean.Parser.Tactic.introMatch:
|
|
{"label": "Lean.Parser.Tactic.introMatch",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"The tactic\n```\nintro\n| pat1 => tac1\n| pat2 => tac2\n```\nis the same as:\n```\nintro x\nmatch x with\n| pat1 => tac1\n| pat2 => tac2\n```\nThat is, `intro` can be followed by match arms and it introduces the values while\ndoing a pattern match. This is equivalent to `fun` with match arms in term mode.\n",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 53, 2, 0]}
|
|
{"textDocument": {"uri": "file:///completionTactics.lean"},
|
|
"position": {"line": 59, "character": 4}}
|
|
{"items":
|
|
[{"label": "Lean.Parser.Tactic.open",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"`open Foo in tacs` (the tactic) acts like `open Foo` at command level,\nbut it opens a namespace only within the tactics `tacs`. ",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 59, 4, 0]},
|
|
{"label": "Lean.Parser.Tactic.match",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"`match` performs case analysis on one or more expressions.\nSee [Induction and Recursion][tpil4].\nThe syntax for the `match` tactic is the same as term-mode `match`, except that\nthe match arms are tactics instead of expressions.\n```\nexample (n : Nat) : n = n := by\n match n with\n | 0 => rfl\n | i+1 => simp\n```\n\n[tpil4]: https://lean-lang.org/theorem_proving_in_lean4/induction_and_recursion.html\n",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 59, 4, 0]},
|
|
{"label": "Lean.Parser.Tactic.set_option",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"`set_option opt val in tacs` (the tactic) acts like `set_option opt val` at the command level,\nbut it sets the option only within the tactics `tacs`. ",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 59, 4, 0]},
|
|
{"label": "skip",
|
|
"kind": 14,
|
|
"documentation": {"value": "A docstring ", "kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 59, 4, 0]},
|
|
{"label": "Lean.Parser.Tactic.nestedTactic",
|
|
"kind": 14,
|
|
"data": ["«external:file:///completionTactics.lean»", 59, 4, 0]},
|
|
{"label": "Lean.Parser.Tactic.unknown",
|
|
"kind": 14,
|
|
"data": ["«external:file:///completionTactics.lean»", 59, 4, 0]},
|
|
{"label": "exact",
|
|
"kind": 14,
|
|
"documentation": {"value": "Another docstring ", "kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 59, 4, 0]},
|
|
{"label": "Lean.Parser.Tactic.introMatch",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"The tactic\n```\nintro\n| pat1 => tac1\n| pat2 => tac2\n```\nis the same as:\n```\nintro x\nmatch x with\n| pat1 => tac1\n| pat2 => tac2\n```\nThat is, `intro` can be followed by match arms and it introduces the values while\ndoing a pattern match. This is equivalent to `fun` with match arms in term mode.\n",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 59, 4, 0]}],
|
|
"isIncomplete": true}
|
|
Resolution of Lean.Parser.Tactic.open:
|
|
{"label": "Lean.Parser.Tactic.open",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"`open Foo in tacs` (the tactic) acts like `open Foo` at command level,\nbut it opens a namespace only within the tactics `tacs`. ",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 59, 4, 0]}
|
|
Resolution of Lean.Parser.Tactic.match:
|
|
{"label": "Lean.Parser.Tactic.match",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"`match` performs case analysis on one or more expressions.\nSee [Induction and Recursion][tpil4].\nThe syntax for the `match` tactic is the same as term-mode `match`, except that\nthe match arms are tactics instead of expressions.\n```\nexample (n : Nat) : n = n := by\n match n with\n | 0 => rfl\n | i+1 => simp\n```\n\n[tpil4]: https://lean-lang.org/theorem_proving_in_lean4/induction_and_recursion.html\n",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 59, 4, 0]}
|
|
Resolution of Lean.Parser.Tactic.set_option:
|
|
{"label": "Lean.Parser.Tactic.set_option",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"`set_option opt val in tacs` (the tactic) acts like `set_option opt val` at the command level,\nbut it sets the option only within the tactics `tacs`. ",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 59, 4, 0]}
|
|
Resolution of skip:
|
|
{"label": "skip",
|
|
"kind": 14,
|
|
"documentation": {"value": "A docstring ", "kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 59, 4, 0]}
|
|
Resolution of Lean.Parser.Tactic.nestedTactic:
|
|
{"label": "Lean.Parser.Tactic.nestedTactic",
|
|
"kind": 14,
|
|
"data": ["«external:file:///completionTactics.lean»", 59, 4, 0]}
|
|
Resolution of Lean.Parser.Tactic.unknown:
|
|
{"label": "Lean.Parser.Tactic.unknown",
|
|
"kind": 14,
|
|
"data": ["«external:file:///completionTactics.lean»", 59, 4, 0]}
|
|
Resolution of exact:
|
|
{"label": "exact",
|
|
"kind": 14,
|
|
"documentation": {"value": "Another docstring ", "kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 59, 4, 0]}
|
|
Resolution of Lean.Parser.Tactic.introMatch:
|
|
{"label": "Lean.Parser.Tactic.introMatch",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"The tactic\n```\nintro\n| pat1 => tac1\n| pat2 => tac2\n```\nis the same as:\n```\nintro x\nmatch x with\n| pat1 => tac1\n| pat2 => tac2\n```\nThat is, `intro` can be followed by match arms and it introduces the values while\ndoing a pattern match. This is equivalent to `fun` with match arms in term mode.\n",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 59, 4, 0]}
|
|
{"textDocument": {"uri": "file:///completionTactics.lean"},
|
|
"position": {"line": 64, "character": 2}}
|
|
{"items":
|
|
[{"label": "Lean.Parser.Tactic.open",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"`open Foo in tacs` (the tactic) acts like `open Foo` at command level,\nbut it opens a namespace only within the tactics `tacs`. ",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 64, 2, 0]},
|
|
{"label": "Lean.Parser.Tactic.match",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"`match` performs case analysis on one or more expressions.\nSee [Induction and Recursion][tpil4].\nThe syntax for the `match` tactic is the same as term-mode `match`, except that\nthe match arms are tactics instead of expressions.\n```\nexample (n : Nat) : n = n := by\n match n with\n | 0 => rfl\n | i+1 => simp\n```\n\n[tpil4]: https://lean-lang.org/theorem_proving_in_lean4/induction_and_recursion.html\n",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 64, 2, 0]},
|
|
{"label": "Lean.Parser.Tactic.set_option",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"`set_option opt val in tacs` (the tactic) acts like `set_option opt val` at the command level,\nbut it sets the option only within the tactics `tacs`. ",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 64, 2, 0]},
|
|
{"label": "skip",
|
|
"kind": 14,
|
|
"documentation": {"value": "A docstring ", "kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 64, 2, 0]},
|
|
{"label": "Lean.Parser.Tactic.nestedTactic",
|
|
"kind": 14,
|
|
"data": ["«external:file:///completionTactics.lean»", 64, 2, 0]},
|
|
{"label": "Lean.Parser.Tactic.unknown",
|
|
"kind": 14,
|
|
"data": ["«external:file:///completionTactics.lean»", 64, 2, 0]},
|
|
{"label": "exact",
|
|
"kind": 14,
|
|
"documentation": {"value": "Another docstring ", "kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 64, 2, 0]},
|
|
{"label": "Lean.Parser.Tactic.introMatch",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"The tactic\n```\nintro\n| pat1 => tac1\n| pat2 => tac2\n```\nis the same as:\n```\nintro x\nmatch x with\n| pat1 => tac1\n| pat2 => tac2\n```\nThat is, `intro` can be followed by match arms and it introduces the values while\ndoing a pattern match. This is equivalent to `fun` with match arms in term mode.\n",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 64, 2, 0]}],
|
|
"isIncomplete": true}
|
|
Resolution of Lean.Parser.Tactic.open:
|
|
{"label": "Lean.Parser.Tactic.open",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"`open Foo in tacs` (the tactic) acts like `open Foo` at command level,\nbut it opens a namespace only within the tactics `tacs`. ",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 64, 2, 0]}
|
|
Resolution of Lean.Parser.Tactic.match:
|
|
{"label": "Lean.Parser.Tactic.match",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"`match` performs case analysis on one or more expressions.\nSee [Induction and Recursion][tpil4].\nThe syntax for the `match` tactic is the same as term-mode `match`, except that\nthe match arms are tactics instead of expressions.\n```\nexample (n : Nat) : n = n := by\n match n with\n | 0 => rfl\n | i+1 => simp\n```\n\n[tpil4]: https://lean-lang.org/theorem_proving_in_lean4/induction_and_recursion.html\n",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 64, 2, 0]}
|
|
Resolution of Lean.Parser.Tactic.set_option:
|
|
{"label": "Lean.Parser.Tactic.set_option",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"`set_option opt val in tacs` (the tactic) acts like `set_option opt val` at the command level,\nbut it sets the option only within the tactics `tacs`. ",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 64, 2, 0]}
|
|
Resolution of skip:
|
|
{"label": "skip",
|
|
"kind": 14,
|
|
"documentation": {"value": "A docstring ", "kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 64, 2, 0]}
|
|
Resolution of Lean.Parser.Tactic.nestedTactic:
|
|
{"label": "Lean.Parser.Tactic.nestedTactic",
|
|
"kind": 14,
|
|
"data": ["«external:file:///completionTactics.lean»", 64, 2, 0]}
|
|
Resolution of Lean.Parser.Tactic.unknown:
|
|
{"label": "Lean.Parser.Tactic.unknown",
|
|
"kind": 14,
|
|
"data": ["«external:file:///completionTactics.lean»", 64, 2, 0]}
|
|
Resolution of exact:
|
|
{"label": "exact",
|
|
"kind": 14,
|
|
"documentation": {"value": "Another docstring ", "kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 64, 2, 0]}
|
|
Resolution of Lean.Parser.Tactic.introMatch:
|
|
{"label": "Lean.Parser.Tactic.introMatch",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"The tactic\n```\nintro\n| pat1 => tac1\n| pat2 => tac2\n```\nis the same as:\n```\nintro x\nmatch x with\n| pat1 => tac1\n| pat2 => tac2\n```\nThat is, `intro` can be followed by match arms and it introduces the values while\ndoing a pattern match. This is equivalent to `fun` with match arms in term mode.\n",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 64, 2, 0]}
|
|
{"textDocument": {"uri": "file:///completionTactics.lean"},
|
|
"position": {"line": 70, "character": 4}}
|
|
{"items":
|
|
[{"label": "Lean.Parser.Tactic.open",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"`open Foo in tacs` (the tactic) acts like `open Foo` at command level,\nbut it opens a namespace only within the tactics `tacs`. ",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 70, 4, 0]},
|
|
{"label": "Lean.Parser.Tactic.match",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"`match` performs case analysis on one or more expressions.\nSee [Induction and Recursion][tpil4].\nThe syntax for the `match` tactic is the same as term-mode `match`, except that\nthe match arms are tactics instead of expressions.\n```\nexample (n : Nat) : n = n := by\n match n with\n | 0 => rfl\n | i+1 => simp\n```\n\n[tpil4]: https://lean-lang.org/theorem_proving_in_lean4/induction_and_recursion.html\n",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 70, 4, 0]},
|
|
{"label": "Lean.Parser.Tactic.set_option",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"`set_option opt val in tacs` (the tactic) acts like `set_option opt val` at the command level,\nbut it sets the option only within the tactics `tacs`. ",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 70, 4, 0]},
|
|
{"label": "skip",
|
|
"kind": 14,
|
|
"documentation": {"value": "A docstring ", "kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 70, 4, 0]},
|
|
{"label": "Lean.Parser.Tactic.nestedTactic",
|
|
"kind": 14,
|
|
"data": ["«external:file:///completionTactics.lean»", 70, 4, 0]},
|
|
{"label": "Lean.Parser.Tactic.unknown",
|
|
"kind": 14,
|
|
"data": ["«external:file:///completionTactics.lean»", 70, 4, 0]},
|
|
{"label": "exact",
|
|
"kind": 14,
|
|
"documentation": {"value": "Another docstring ", "kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 70, 4, 0]},
|
|
{"label": "Lean.Parser.Tactic.introMatch",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"The tactic\n```\nintro\n| pat1 => tac1\n| pat2 => tac2\n```\nis the same as:\n```\nintro x\nmatch x with\n| pat1 => tac1\n| pat2 => tac2\n```\nThat is, `intro` can be followed by match arms and it introduces the values while\ndoing a pattern match. This is equivalent to `fun` with match arms in term mode.\n",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 70, 4, 0]}],
|
|
"isIncomplete": true}
|
|
Resolution of Lean.Parser.Tactic.open:
|
|
{"label": "Lean.Parser.Tactic.open",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"`open Foo in tacs` (the tactic) acts like `open Foo` at command level,\nbut it opens a namespace only within the tactics `tacs`. ",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 70, 4, 0]}
|
|
Resolution of Lean.Parser.Tactic.match:
|
|
{"label": "Lean.Parser.Tactic.match",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"`match` performs case analysis on one or more expressions.\nSee [Induction and Recursion][tpil4].\nThe syntax for the `match` tactic is the same as term-mode `match`, except that\nthe match arms are tactics instead of expressions.\n```\nexample (n : Nat) : n = n := by\n match n with\n | 0 => rfl\n | i+1 => simp\n```\n\n[tpil4]: https://lean-lang.org/theorem_proving_in_lean4/induction_and_recursion.html\n",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 70, 4, 0]}
|
|
Resolution of Lean.Parser.Tactic.set_option:
|
|
{"label": "Lean.Parser.Tactic.set_option",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"`set_option opt val in tacs` (the tactic) acts like `set_option opt val` at the command level,\nbut it sets the option only within the tactics `tacs`. ",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 70, 4, 0]}
|
|
Resolution of skip:
|
|
{"label": "skip",
|
|
"kind": 14,
|
|
"documentation": {"value": "A docstring ", "kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 70, 4, 0]}
|
|
Resolution of Lean.Parser.Tactic.nestedTactic:
|
|
{"label": "Lean.Parser.Tactic.nestedTactic",
|
|
"kind": 14,
|
|
"data": ["«external:file:///completionTactics.lean»", 70, 4, 0]}
|
|
Resolution of Lean.Parser.Tactic.unknown:
|
|
{"label": "Lean.Parser.Tactic.unknown",
|
|
"kind": 14,
|
|
"data": ["«external:file:///completionTactics.lean»", 70, 4, 0]}
|
|
Resolution of exact:
|
|
{"label": "exact",
|
|
"kind": 14,
|
|
"documentation": {"value": "Another docstring ", "kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 70, 4, 0]}
|
|
Resolution of Lean.Parser.Tactic.introMatch:
|
|
{"label": "Lean.Parser.Tactic.introMatch",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"The tactic\n```\nintro\n| pat1 => tac1\n| pat2 => tac2\n```\nis the same as:\n```\nintro x\nmatch x with\n| pat1 => tac1\n| pat2 => tac2\n```\nThat is, `intro` can be followed by match arms and it introduces the values while\ndoing a pattern match. This is equivalent to `fun` with match arms in term mode.\n",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 70, 4, 0]}
|
|
{"textDocument": {"uri": "file:///completionTactics.lean"},
|
|
"position": {"line": 76, "character": 2}}
|
|
{"items":
|
|
[{"label": "Lean.Parser.Tactic.open",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"`open Foo in tacs` (the tactic) acts like `open Foo` at command level,\nbut it opens a namespace only within the tactics `tacs`. ",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 76, 2, 0]},
|
|
{"label": "Lean.Parser.Tactic.match",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"`match` performs case analysis on one or more expressions.\nSee [Induction and Recursion][tpil4].\nThe syntax for the `match` tactic is the same as term-mode `match`, except that\nthe match arms are tactics instead of expressions.\n```\nexample (n : Nat) : n = n := by\n match n with\n | 0 => rfl\n | i+1 => simp\n```\n\n[tpil4]: https://lean-lang.org/theorem_proving_in_lean4/induction_and_recursion.html\n",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 76, 2, 0]},
|
|
{"label": "Lean.Parser.Tactic.set_option",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"`set_option opt val in tacs` (the tactic) acts like `set_option opt val` at the command level,\nbut it sets the option only within the tactics `tacs`. ",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 76, 2, 0]},
|
|
{"label": "skip",
|
|
"kind": 14,
|
|
"documentation": {"value": "A docstring ", "kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 76, 2, 0]},
|
|
{"label": "Lean.Parser.Tactic.nestedTactic",
|
|
"kind": 14,
|
|
"data": ["«external:file:///completionTactics.lean»", 76, 2, 0]},
|
|
{"label": "Lean.Parser.Tactic.unknown",
|
|
"kind": 14,
|
|
"data": ["«external:file:///completionTactics.lean»", 76, 2, 0]},
|
|
{"label": "exact",
|
|
"kind": 14,
|
|
"documentation": {"value": "Another docstring ", "kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 76, 2, 0]},
|
|
{"label": "Lean.Parser.Tactic.introMatch",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"The tactic\n```\nintro\n| pat1 => tac1\n| pat2 => tac2\n```\nis the same as:\n```\nintro x\nmatch x with\n| pat1 => tac1\n| pat2 => tac2\n```\nThat is, `intro` can be followed by match arms and it introduces the values while\ndoing a pattern match. This is equivalent to `fun` with match arms in term mode.\n",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 76, 2, 0]}],
|
|
"isIncomplete": true}
|
|
Resolution of Lean.Parser.Tactic.open:
|
|
{"label": "Lean.Parser.Tactic.open",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"`open Foo in tacs` (the tactic) acts like `open Foo` at command level,\nbut it opens a namespace only within the tactics `tacs`. ",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 76, 2, 0]}
|
|
Resolution of Lean.Parser.Tactic.match:
|
|
{"label": "Lean.Parser.Tactic.match",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"`match` performs case analysis on one or more expressions.\nSee [Induction and Recursion][tpil4].\nThe syntax for the `match` tactic is the same as term-mode `match`, except that\nthe match arms are tactics instead of expressions.\n```\nexample (n : Nat) : n = n := by\n match n with\n | 0 => rfl\n | i+1 => simp\n```\n\n[tpil4]: https://lean-lang.org/theorem_proving_in_lean4/induction_and_recursion.html\n",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 76, 2, 0]}
|
|
Resolution of Lean.Parser.Tactic.set_option:
|
|
{"label": "Lean.Parser.Tactic.set_option",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"`set_option opt val in tacs` (the tactic) acts like `set_option opt val` at the command level,\nbut it sets the option only within the tactics `tacs`. ",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 76, 2, 0]}
|
|
Resolution of skip:
|
|
{"label": "skip",
|
|
"kind": 14,
|
|
"documentation": {"value": "A docstring ", "kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 76, 2, 0]}
|
|
Resolution of Lean.Parser.Tactic.nestedTactic:
|
|
{"label": "Lean.Parser.Tactic.nestedTactic",
|
|
"kind": 14,
|
|
"data": ["«external:file:///completionTactics.lean»", 76, 2, 0]}
|
|
Resolution of Lean.Parser.Tactic.unknown:
|
|
{"label": "Lean.Parser.Tactic.unknown",
|
|
"kind": 14,
|
|
"data": ["«external:file:///completionTactics.lean»", 76, 2, 0]}
|
|
Resolution of exact:
|
|
{"label": "exact",
|
|
"kind": 14,
|
|
"documentation": {"value": "Another docstring ", "kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 76, 2, 0]}
|
|
Resolution of Lean.Parser.Tactic.introMatch:
|
|
{"label": "Lean.Parser.Tactic.introMatch",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"The tactic\n```\nintro\n| pat1 => tac1\n| pat2 => tac2\n```\nis the same as:\n```\nintro x\nmatch x with\n| pat1 => tac1\n| pat2 => tac2\n```\nThat is, `intro` can be followed by match arms and it introduces the values while\ndoing a pattern match. This is equivalent to `fun` with match arms in term mode.\n",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 76, 2, 0]}
|
|
{"textDocument": {"uri": "file:///completionTactics.lean"},
|
|
"position": {"line": 81, "character": 4}}
|
|
{"items": [], "isIncomplete": true}
|
|
{"textDocument": {"uri": "file:///completionTactics.lean"},
|
|
"position": {"line": 86, "character": 2}}
|
|
{"items":
|
|
[{"label": "Lean.Parser.Tactic.open",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"`open Foo in tacs` (the tactic) acts like `open Foo` at command level,\nbut it opens a namespace only within the tactics `tacs`. ",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 86, 2, 0]},
|
|
{"label": "Lean.Parser.Tactic.match",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"`match` performs case analysis on one or more expressions.\nSee [Induction and Recursion][tpil4].\nThe syntax for the `match` tactic is the same as term-mode `match`, except that\nthe match arms are tactics instead of expressions.\n```\nexample (n : Nat) : n = n := by\n match n with\n | 0 => rfl\n | i+1 => simp\n```\n\n[tpil4]: https://lean-lang.org/theorem_proving_in_lean4/induction_and_recursion.html\n",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 86, 2, 0]},
|
|
{"label": "Lean.Parser.Tactic.set_option",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"`set_option opt val in tacs` (the tactic) acts like `set_option opt val` at the command level,\nbut it sets the option only within the tactics `tacs`. ",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 86, 2, 0]},
|
|
{"label": "skip",
|
|
"kind": 14,
|
|
"documentation": {"value": "A docstring ", "kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 86, 2, 0]},
|
|
{"label": "Lean.Parser.Tactic.nestedTactic",
|
|
"kind": 14,
|
|
"data": ["«external:file:///completionTactics.lean»", 86, 2, 0]},
|
|
{"label": "Lean.Parser.Tactic.unknown",
|
|
"kind": 14,
|
|
"data": ["«external:file:///completionTactics.lean»", 86, 2, 0]},
|
|
{"label": "exact",
|
|
"kind": 14,
|
|
"documentation": {"value": "Another docstring ", "kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 86, 2, 0]},
|
|
{"label": "Lean.Parser.Tactic.introMatch",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"The tactic\n```\nintro\n| pat1 => tac1\n| pat2 => tac2\n```\nis the same as:\n```\nintro x\nmatch x with\n| pat1 => tac1\n| pat2 => tac2\n```\nThat is, `intro` can be followed by match arms and it introduces the values while\ndoing a pattern match. This is equivalent to `fun` with match arms in term mode.\n",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 86, 2, 0]}],
|
|
"isIncomplete": true}
|
|
Resolution of Lean.Parser.Tactic.open:
|
|
{"label": "Lean.Parser.Tactic.open",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"`open Foo in tacs` (the tactic) acts like `open Foo` at command level,\nbut it opens a namespace only within the tactics `tacs`. ",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 86, 2, 0]}
|
|
Resolution of Lean.Parser.Tactic.match:
|
|
{"label": "Lean.Parser.Tactic.match",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"`match` performs case analysis on one or more expressions.\nSee [Induction and Recursion][tpil4].\nThe syntax for the `match` tactic is the same as term-mode `match`, except that\nthe match arms are tactics instead of expressions.\n```\nexample (n : Nat) : n = n := by\n match n with\n | 0 => rfl\n | i+1 => simp\n```\n\n[tpil4]: https://lean-lang.org/theorem_proving_in_lean4/induction_and_recursion.html\n",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 86, 2, 0]}
|
|
Resolution of Lean.Parser.Tactic.set_option:
|
|
{"label": "Lean.Parser.Tactic.set_option",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"`set_option opt val in tacs` (the tactic) acts like `set_option opt val` at the command level,\nbut it sets the option only within the tactics `tacs`. ",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 86, 2, 0]}
|
|
Resolution of skip:
|
|
{"label": "skip",
|
|
"kind": 14,
|
|
"documentation": {"value": "A docstring ", "kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 86, 2, 0]}
|
|
Resolution of Lean.Parser.Tactic.nestedTactic:
|
|
{"label": "Lean.Parser.Tactic.nestedTactic",
|
|
"kind": 14,
|
|
"data": ["«external:file:///completionTactics.lean»", 86, 2, 0]}
|
|
Resolution of Lean.Parser.Tactic.unknown:
|
|
{"label": "Lean.Parser.Tactic.unknown",
|
|
"kind": 14,
|
|
"data": ["«external:file:///completionTactics.lean»", 86, 2, 0]}
|
|
Resolution of exact:
|
|
{"label": "exact",
|
|
"kind": 14,
|
|
"documentation": {"value": "Another docstring ", "kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 86, 2, 0]}
|
|
Resolution of Lean.Parser.Tactic.introMatch:
|
|
{"label": "Lean.Parser.Tactic.introMatch",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"The tactic\n```\nintro\n| pat1 => tac1\n| pat2 => tac2\n```\nis the same as:\n```\nintro x\nmatch x with\n| pat1 => tac1\n| pat2 => tac2\n```\nThat is, `intro` can be followed by match arms and it introduces the values while\ndoing a pattern match. This is equivalent to `fun` with match arms in term mode.\n",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 86, 2, 0]}
|
|
{"textDocument": {"uri": "file:///completionTactics.lean"},
|
|
"position": {"line": 91, "character": 4}}
|
|
{"items":
|
|
[{"label": "Lean.Parser.Tactic.open",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"`open Foo in tacs` (the tactic) acts like `open Foo` at command level,\nbut it opens a namespace only within the tactics `tacs`. ",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 91, 4, 0]},
|
|
{"label": "Lean.Parser.Tactic.match",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"`match` performs case analysis on one or more expressions.\nSee [Induction and Recursion][tpil4].\nThe syntax for the `match` tactic is the same as term-mode `match`, except that\nthe match arms are tactics instead of expressions.\n```\nexample (n : Nat) : n = n := by\n match n with\n | 0 => rfl\n | i+1 => simp\n```\n\n[tpil4]: https://lean-lang.org/theorem_proving_in_lean4/induction_and_recursion.html\n",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 91, 4, 0]},
|
|
{"label": "Lean.Parser.Tactic.set_option",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"`set_option opt val in tacs` (the tactic) acts like `set_option opt val` at the command level,\nbut it sets the option only within the tactics `tacs`. ",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 91, 4, 0]},
|
|
{"label": "skip",
|
|
"kind": 14,
|
|
"documentation": {"value": "A docstring ", "kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 91, 4, 0]},
|
|
{"label": "Lean.Parser.Tactic.nestedTactic",
|
|
"kind": 14,
|
|
"data": ["«external:file:///completionTactics.lean»", 91, 4, 0]},
|
|
{"label": "Lean.Parser.Tactic.unknown",
|
|
"kind": 14,
|
|
"data": ["«external:file:///completionTactics.lean»", 91, 4, 0]},
|
|
{"label": "exact",
|
|
"kind": 14,
|
|
"documentation": {"value": "Another docstring ", "kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 91, 4, 0]},
|
|
{"label": "Lean.Parser.Tactic.introMatch",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"The tactic\n```\nintro\n| pat1 => tac1\n| pat2 => tac2\n```\nis the same as:\n```\nintro x\nmatch x with\n| pat1 => tac1\n| pat2 => tac2\n```\nThat is, `intro` can be followed by match arms and it introduces the values while\ndoing a pattern match. This is equivalent to `fun` with match arms in term mode.\n",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 91, 4, 0]}],
|
|
"isIncomplete": true}
|
|
Resolution of Lean.Parser.Tactic.open:
|
|
{"label": "Lean.Parser.Tactic.open",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"`open Foo in tacs` (the tactic) acts like `open Foo` at command level,\nbut it opens a namespace only within the tactics `tacs`. ",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 91, 4, 0]}
|
|
Resolution of Lean.Parser.Tactic.match:
|
|
{"label": "Lean.Parser.Tactic.match",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"`match` performs case analysis on one or more expressions.\nSee [Induction and Recursion][tpil4].\nThe syntax for the `match` tactic is the same as term-mode `match`, except that\nthe match arms are tactics instead of expressions.\n```\nexample (n : Nat) : n = n := by\n match n with\n | 0 => rfl\n | i+1 => simp\n```\n\n[tpil4]: https://lean-lang.org/theorem_proving_in_lean4/induction_and_recursion.html\n",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 91, 4, 0]}
|
|
Resolution of Lean.Parser.Tactic.set_option:
|
|
{"label": "Lean.Parser.Tactic.set_option",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"`set_option opt val in tacs` (the tactic) acts like `set_option opt val` at the command level,\nbut it sets the option only within the tactics `tacs`. ",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 91, 4, 0]}
|
|
Resolution of skip:
|
|
{"label": "skip",
|
|
"kind": 14,
|
|
"documentation": {"value": "A docstring ", "kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 91, 4, 0]}
|
|
Resolution of Lean.Parser.Tactic.nestedTactic:
|
|
{"label": "Lean.Parser.Tactic.nestedTactic",
|
|
"kind": 14,
|
|
"data": ["«external:file:///completionTactics.lean»", 91, 4, 0]}
|
|
Resolution of Lean.Parser.Tactic.unknown:
|
|
{"label": "Lean.Parser.Tactic.unknown",
|
|
"kind": 14,
|
|
"data": ["«external:file:///completionTactics.lean»", 91, 4, 0]}
|
|
Resolution of exact:
|
|
{"label": "exact",
|
|
"kind": 14,
|
|
"documentation": {"value": "Another docstring ", "kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 91, 4, 0]}
|
|
Resolution of Lean.Parser.Tactic.introMatch:
|
|
{"label": "Lean.Parser.Tactic.introMatch",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"The tactic\n```\nintro\n| pat1 => tac1\n| pat2 => tac2\n```\nis the same as:\n```\nintro x\nmatch x with\n| pat1 => tac1\n| pat2 => tac2\n```\nThat is, `intro` can be followed by match arms and it introduces the values while\ndoing a pattern match. This is equivalent to `fun` with match arms in term mode.\n",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 91, 4, 0]}
|
|
{"textDocument": {"uri": "file:///completionTactics.lean"},
|
|
"position": {"line": 96, "character": 2}}
|
|
{"items":
|
|
[{"label": "Lean.Parser.Tactic.open",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"`open Foo in tacs` (the tactic) acts like `open Foo` at command level,\nbut it opens a namespace only within the tactics `tacs`. ",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 96, 2, 0]},
|
|
{"label": "Lean.Parser.Tactic.match",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"`match` performs case analysis on one or more expressions.\nSee [Induction and Recursion][tpil4].\nThe syntax for the `match` tactic is the same as term-mode `match`, except that\nthe match arms are tactics instead of expressions.\n```\nexample (n : Nat) : n = n := by\n match n with\n | 0 => rfl\n | i+1 => simp\n```\n\n[tpil4]: https://lean-lang.org/theorem_proving_in_lean4/induction_and_recursion.html\n",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 96, 2, 0]},
|
|
{"label": "Lean.Parser.Tactic.set_option",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"`set_option opt val in tacs` (the tactic) acts like `set_option opt val` at the command level,\nbut it sets the option only within the tactics `tacs`. ",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 96, 2, 0]},
|
|
{"label": "skip",
|
|
"kind": 14,
|
|
"documentation": {"value": "A docstring ", "kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 96, 2, 0]},
|
|
{"label": "Lean.Parser.Tactic.nestedTactic",
|
|
"kind": 14,
|
|
"data": ["«external:file:///completionTactics.lean»", 96, 2, 0]},
|
|
{"label": "Lean.Parser.Tactic.unknown",
|
|
"kind": 14,
|
|
"data": ["«external:file:///completionTactics.lean»", 96, 2, 0]},
|
|
{"label": "exact",
|
|
"kind": 14,
|
|
"documentation": {"value": "Another docstring ", "kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 96, 2, 0]},
|
|
{"label": "Lean.Parser.Tactic.introMatch",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"The tactic\n```\nintro\n| pat1 => tac1\n| pat2 => tac2\n```\nis the same as:\n```\nintro x\nmatch x with\n| pat1 => tac1\n| pat2 => tac2\n```\nThat is, `intro` can be followed by match arms and it introduces the values while\ndoing a pattern match. This is equivalent to `fun` with match arms in term mode.\n",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 96, 2, 0]}],
|
|
"isIncomplete": true}
|
|
Resolution of Lean.Parser.Tactic.open:
|
|
{"label": "Lean.Parser.Tactic.open",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"`open Foo in tacs` (the tactic) acts like `open Foo` at command level,\nbut it opens a namespace only within the tactics `tacs`. ",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 96, 2, 0]}
|
|
Resolution of Lean.Parser.Tactic.match:
|
|
{"label": "Lean.Parser.Tactic.match",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"`match` performs case analysis on one or more expressions.\nSee [Induction and Recursion][tpil4].\nThe syntax for the `match` tactic is the same as term-mode `match`, except that\nthe match arms are tactics instead of expressions.\n```\nexample (n : Nat) : n = n := by\n match n with\n | 0 => rfl\n | i+1 => simp\n```\n\n[tpil4]: https://lean-lang.org/theorem_proving_in_lean4/induction_and_recursion.html\n",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 96, 2, 0]}
|
|
Resolution of Lean.Parser.Tactic.set_option:
|
|
{"label": "Lean.Parser.Tactic.set_option",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"`set_option opt val in tacs` (the tactic) acts like `set_option opt val` at the command level,\nbut it sets the option only within the tactics `tacs`. ",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 96, 2, 0]}
|
|
Resolution of skip:
|
|
{"label": "skip",
|
|
"kind": 14,
|
|
"documentation": {"value": "A docstring ", "kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 96, 2, 0]}
|
|
Resolution of Lean.Parser.Tactic.nestedTactic:
|
|
{"label": "Lean.Parser.Tactic.nestedTactic",
|
|
"kind": 14,
|
|
"data": ["«external:file:///completionTactics.lean»", 96, 2, 0]}
|
|
Resolution of Lean.Parser.Tactic.unknown:
|
|
{"label": "Lean.Parser.Tactic.unknown",
|
|
"kind": 14,
|
|
"data": ["«external:file:///completionTactics.lean»", 96, 2, 0]}
|
|
Resolution of exact:
|
|
{"label": "exact",
|
|
"kind": 14,
|
|
"documentation": {"value": "Another docstring ", "kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 96, 2, 0]}
|
|
Resolution of Lean.Parser.Tactic.introMatch:
|
|
{"label": "Lean.Parser.Tactic.introMatch",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"The tactic\n```\nintro\n| pat1 => tac1\n| pat2 => tac2\n```\nis the same as:\n```\nintro x\nmatch x with\n| pat1 => tac1\n| pat2 => tac2\n```\nThat is, `intro` can be followed by match arms and it introduces the values while\ndoing a pattern match. This is equivalent to `fun` with match arms in term mode.\n",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 96, 2, 0]}
|
|
{"textDocument": {"uri": "file:///completionTactics.lean"},
|
|
"position": {"line": 102, "character": 4}}
|
|
{"items":
|
|
[{"label": "Lean.Parser.Tactic.open",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"`open Foo in tacs` (the tactic) acts like `open Foo` at command level,\nbut it opens a namespace only within the tactics `tacs`. ",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 102, 4, 0]},
|
|
{"label": "Lean.Parser.Tactic.match",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"`match` performs case analysis on one or more expressions.\nSee [Induction and Recursion][tpil4].\nThe syntax for the `match` tactic is the same as term-mode `match`, except that\nthe match arms are tactics instead of expressions.\n```\nexample (n : Nat) : n = n := by\n match n with\n | 0 => rfl\n | i+1 => simp\n```\n\n[tpil4]: https://lean-lang.org/theorem_proving_in_lean4/induction_and_recursion.html\n",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 102, 4, 0]},
|
|
{"label": "Lean.Parser.Tactic.set_option",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"`set_option opt val in tacs` (the tactic) acts like `set_option opt val` at the command level,\nbut it sets the option only within the tactics `tacs`. ",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 102, 4, 0]},
|
|
{"label": "skip",
|
|
"kind": 14,
|
|
"documentation": {"value": "A docstring ", "kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 102, 4, 0]},
|
|
{"label": "Lean.Parser.Tactic.nestedTactic",
|
|
"kind": 14,
|
|
"data": ["«external:file:///completionTactics.lean»", 102, 4, 0]},
|
|
{"label": "Lean.Parser.Tactic.unknown",
|
|
"kind": 14,
|
|
"data": ["«external:file:///completionTactics.lean»", 102, 4, 0]},
|
|
{"label": "exact",
|
|
"kind": 14,
|
|
"documentation": {"value": "Another docstring ", "kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 102, 4, 0]},
|
|
{"label": "Lean.Parser.Tactic.introMatch",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"The tactic\n```\nintro\n| pat1 => tac1\n| pat2 => tac2\n```\nis the same as:\n```\nintro x\nmatch x with\n| pat1 => tac1\n| pat2 => tac2\n```\nThat is, `intro` can be followed by match arms and it introduces the values while\ndoing a pattern match. This is equivalent to `fun` with match arms in term mode.\n",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 102, 4, 0]}],
|
|
"isIncomplete": true}
|
|
Resolution of Lean.Parser.Tactic.open:
|
|
{"label": "Lean.Parser.Tactic.open",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"`open Foo in tacs` (the tactic) acts like `open Foo` at command level,\nbut it opens a namespace only within the tactics `tacs`. ",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 102, 4, 0]}
|
|
Resolution of Lean.Parser.Tactic.match:
|
|
{"label": "Lean.Parser.Tactic.match",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"`match` performs case analysis on one or more expressions.\nSee [Induction and Recursion][tpil4].\nThe syntax for the `match` tactic is the same as term-mode `match`, except that\nthe match arms are tactics instead of expressions.\n```\nexample (n : Nat) : n = n := by\n match n with\n | 0 => rfl\n | i+1 => simp\n```\n\n[tpil4]: https://lean-lang.org/theorem_proving_in_lean4/induction_and_recursion.html\n",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 102, 4, 0]}
|
|
Resolution of Lean.Parser.Tactic.set_option:
|
|
{"label": "Lean.Parser.Tactic.set_option",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"`set_option opt val in tacs` (the tactic) acts like `set_option opt val` at the command level,\nbut it sets the option only within the tactics `tacs`. ",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 102, 4, 0]}
|
|
Resolution of skip:
|
|
{"label": "skip",
|
|
"kind": 14,
|
|
"documentation": {"value": "A docstring ", "kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 102, 4, 0]}
|
|
Resolution of Lean.Parser.Tactic.nestedTactic:
|
|
{"label": "Lean.Parser.Tactic.nestedTactic",
|
|
"kind": 14,
|
|
"data": ["«external:file:///completionTactics.lean»", 102, 4, 0]}
|
|
Resolution of Lean.Parser.Tactic.unknown:
|
|
{"label": "Lean.Parser.Tactic.unknown",
|
|
"kind": 14,
|
|
"data": ["«external:file:///completionTactics.lean»", 102, 4, 0]}
|
|
Resolution of exact:
|
|
{"label": "exact",
|
|
"kind": 14,
|
|
"documentation": {"value": "Another docstring ", "kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 102, 4, 0]}
|
|
Resolution of Lean.Parser.Tactic.introMatch:
|
|
{"label": "Lean.Parser.Tactic.introMatch",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"The tactic\n```\nintro\n| pat1 => tac1\n| pat2 => tac2\n```\nis the same as:\n```\nintro x\nmatch x with\n| pat1 => tac1\n| pat2 => tac2\n```\nThat is, `intro` can be followed by match arms and it introduces the values while\ndoing a pattern match. This is equivalent to `fun` with match arms in term mode.\n",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 102, 4, 0]}
|
|
{"textDocument": {"uri": "file:///completionTactics.lean"},
|
|
"position": {"line": 108, "character": 2}}
|
|
{"items": [], "isIncomplete": true}
|
|
{"textDocument": {"uri": "file:///completionTactics.lean"},
|
|
"position": {"line": 112, "character": 2}}
|
|
{"items":
|
|
[{"label": "Lean.Parser.Tactic.open",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"`open Foo in tacs` (the tactic) acts like `open Foo` at command level,\nbut it opens a namespace only within the tactics `tacs`. ",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 112, 2, 0]},
|
|
{"label": "Lean.Parser.Tactic.match",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"`match` performs case analysis on one or more expressions.\nSee [Induction and Recursion][tpil4].\nThe syntax for the `match` tactic is the same as term-mode `match`, except that\nthe match arms are tactics instead of expressions.\n```\nexample (n : Nat) : n = n := by\n match n with\n | 0 => rfl\n | i+1 => simp\n```\n\n[tpil4]: https://lean-lang.org/theorem_proving_in_lean4/induction_and_recursion.html\n",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 112, 2, 0]},
|
|
{"label": "Lean.Parser.Tactic.set_option",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"`set_option opt val in tacs` (the tactic) acts like `set_option opt val` at the command level,\nbut it sets the option only within the tactics `tacs`. ",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 112, 2, 0]},
|
|
{"label": "skip",
|
|
"kind": 14,
|
|
"documentation": {"value": "A docstring ", "kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 112, 2, 0]},
|
|
{"label": "Lean.Parser.Tactic.nestedTactic",
|
|
"kind": 14,
|
|
"data": ["«external:file:///completionTactics.lean»", 112, 2, 0]},
|
|
{"label": "Lean.Parser.Tactic.unknown",
|
|
"kind": 14,
|
|
"data": ["«external:file:///completionTactics.lean»", 112, 2, 0]},
|
|
{"label": "exact",
|
|
"kind": 14,
|
|
"documentation": {"value": "Another docstring ", "kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 112, 2, 0]},
|
|
{"label": "Lean.Parser.Tactic.introMatch",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"The tactic\n```\nintro\n| pat1 => tac1\n| pat2 => tac2\n```\nis the same as:\n```\nintro x\nmatch x with\n| pat1 => tac1\n| pat2 => tac2\n```\nThat is, `intro` can be followed by match arms and it introduces the values while\ndoing a pattern match. This is equivalent to `fun` with match arms in term mode.\n",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 112, 2, 0]}],
|
|
"isIncomplete": true}
|
|
Resolution of Lean.Parser.Tactic.open:
|
|
{"label": "Lean.Parser.Tactic.open",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"`open Foo in tacs` (the tactic) acts like `open Foo` at command level,\nbut it opens a namespace only within the tactics `tacs`. ",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 112, 2, 0]}
|
|
Resolution of Lean.Parser.Tactic.match:
|
|
{"label": "Lean.Parser.Tactic.match",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"`match` performs case analysis on one or more expressions.\nSee [Induction and Recursion][tpil4].\nThe syntax for the `match` tactic is the same as term-mode `match`, except that\nthe match arms are tactics instead of expressions.\n```\nexample (n : Nat) : n = n := by\n match n with\n | 0 => rfl\n | i+1 => simp\n```\n\n[tpil4]: https://lean-lang.org/theorem_proving_in_lean4/induction_and_recursion.html\n",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 112, 2, 0]}
|
|
Resolution of Lean.Parser.Tactic.set_option:
|
|
{"label": "Lean.Parser.Tactic.set_option",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"`set_option opt val in tacs` (the tactic) acts like `set_option opt val` at the command level,\nbut it sets the option only within the tactics `tacs`. ",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 112, 2, 0]}
|
|
Resolution of skip:
|
|
{"label": "skip",
|
|
"kind": 14,
|
|
"documentation": {"value": "A docstring ", "kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 112, 2, 0]}
|
|
Resolution of Lean.Parser.Tactic.nestedTactic:
|
|
{"label": "Lean.Parser.Tactic.nestedTactic",
|
|
"kind": 14,
|
|
"data": ["«external:file:///completionTactics.lean»", 112, 2, 0]}
|
|
Resolution of Lean.Parser.Tactic.unknown:
|
|
{"label": "Lean.Parser.Tactic.unknown",
|
|
"kind": 14,
|
|
"data": ["«external:file:///completionTactics.lean»", 112, 2, 0]}
|
|
Resolution of exact:
|
|
{"label": "exact",
|
|
"kind": 14,
|
|
"documentation": {"value": "Another docstring ", "kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 112, 2, 0]}
|
|
Resolution of Lean.Parser.Tactic.introMatch:
|
|
{"label": "Lean.Parser.Tactic.introMatch",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"The tactic\n```\nintro\n| pat1 => tac1\n| pat2 => tac2\n```\nis the same as:\n```\nintro x\nmatch x with\n| pat1 => tac1\n| pat2 => tac2\n```\nThat is, `intro` can be followed by match arms and it introduces the values while\ndoing a pattern match. This is equivalent to `fun` with match arms in term mode.\n",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 112, 2, 0]}
|
|
{"textDocument": {"uri": "file:///completionTactics.lean"},
|
|
"position": {"line": 118, "character": 4}}
|
|
{"items":
|
|
[{"label": "Lean.Parser.Tactic.open",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"`open Foo in tacs` (the tactic) acts like `open Foo` at command level,\nbut it opens a namespace only within the tactics `tacs`. ",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 118, 4, 0]},
|
|
{"label": "Lean.Parser.Tactic.match",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"`match` performs case analysis on one or more expressions.\nSee [Induction and Recursion][tpil4].\nThe syntax for the `match` tactic is the same as term-mode `match`, except that\nthe match arms are tactics instead of expressions.\n```\nexample (n : Nat) : n = n := by\n match n with\n | 0 => rfl\n | i+1 => simp\n```\n\n[tpil4]: https://lean-lang.org/theorem_proving_in_lean4/induction_and_recursion.html\n",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 118, 4, 0]},
|
|
{"label": "Lean.Parser.Tactic.set_option",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"`set_option opt val in tacs` (the tactic) acts like `set_option opt val` at the command level,\nbut it sets the option only within the tactics `tacs`. ",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 118, 4, 0]},
|
|
{"label": "skip",
|
|
"kind": 14,
|
|
"documentation": {"value": "A docstring ", "kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 118, 4, 0]},
|
|
{"label": "Lean.Parser.Tactic.nestedTactic",
|
|
"kind": 14,
|
|
"data": ["«external:file:///completionTactics.lean»", 118, 4, 0]},
|
|
{"label": "Lean.Parser.Tactic.unknown",
|
|
"kind": 14,
|
|
"data": ["«external:file:///completionTactics.lean»", 118, 4, 0]},
|
|
{"label": "exact",
|
|
"kind": 14,
|
|
"documentation": {"value": "Another docstring ", "kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 118, 4, 0]},
|
|
{"label": "Lean.Parser.Tactic.introMatch",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"The tactic\n```\nintro\n| pat1 => tac1\n| pat2 => tac2\n```\nis the same as:\n```\nintro x\nmatch x with\n| pat1 => tac1\n| pat2 => tac2\n```\nThat is, `intro` can be followed by match arms and it introduces the values while\ndoing a pattern match. This is equivalent to `fun` with match arms in term mode.\n",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 118, 4, 0]}],
|
|
"isIncomplete": true}
|
|
Resolution of Lean.Parser.Tactic.open:
|
|
{"label": "Lean.Parser.Tactic.open",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"`open Foo in tacs` (the tactic) acts like `open Foo` at command level,\nbut it opens a namespace only within the tactics `tacs`. ",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 118, 4, 0]}
|
|
Resolution of Lean.Parser.Tactic.match:
|
|
{"label": "Lean.Parser.Tactic.match",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"`match` performs case analysis on one or more expressions.\nSee [Induction and Recursion][tpil4].\nThe syntax for the `match` tactic is the same as term-mode `match`, except that\nthe match arms are tactics instead of expressions.\n```\nexample (n : Nat) : n = n := by\n match n with\n | 0 => rfl\n | i+1 => simp\n```\n\n[tpil4]: https://lean-lang.org/theorem_proving_in_lean4/induction_and_recursion.html\n",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 118, 4, 0]}
|
|
Resolution of Lean.Parser.Tactic.set_option:
|
|
{"label": "Lean.Parser.Tactic.set_option",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"`set_option opt val in tacs` (the tactic) acts like `set_option opt val` at the command level,\nbut it sets the option only within the tactics `tacs`. ",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 118, 4, 0]}
|
|
Resolution of skip:
|
|
{"label": "skip",
|
|
"kind": 14,
|
|
"documentation": {"value": "A docstring ", "kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 118, 4, 0]}
|
|
Resolution of Lean.Parser.Tactic.nestedTactic:
|
|
{"label": "Lean.Parser.Tactic.nestedTactic",
|
|
"kind": 14,
|
|
"data": ["«external:file:///completionTactics.lean»", 118, 4, 0]}
|
|
Resolution of Lean.Parser.Tactic.unknown:
|
|
{"label": "Lean.Parser.Tactic.unknown",
|
|
"kind": 14,
|
|
"data": ["«external:file:///completionTactics.lean»", 118, 4, 0]}
|
|
Resolution of exact:
|
|
{"label": "exact",
|
|
"kind": 14,
|
|
"documentation": {"value": "Another docstring ", "kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 118, 4, 0]}
|
|
Resolution of Lean.Parser.Tactic.introMatch:
|
|
{"label": "Lean.Parser.Tactic.introMatch",
|
|
"kind": 14,
|
|
"documentation":
|
|
{"value":
|
|
"The tactic\n```\nintro\n| pat1 => tac1\n| pat2 => tac2\n```\nis the same as:\n```\nintro x\nmatch x with\n| pat1 => tac1\n| pat2 => tac2\n```\nThat is, `intro` can be followed by match arms and it introduces the values while\ndoing a pattern match. This is equivalent to `fun` with match arms in term mode.\n",
|
|
"kind": "markdown"},
|
|
"data": ["«external:file:///completionTactics.lean»", 118, 4, 0]}
|