119 lines
5.2 KiB
Text
119 lines
5.2 KiB
Text
{"textDocument": {"uri": "file://completion7.lean"},
|
||
"position": {"line": 0, "character": 10}}
|
||
{"items":
|
||
[{"label": "And",
|
||
"kind": 22,
|
||
"documentation":
|
||
{"value":
|
||
"`And a b`, or `a ∧ b`, is the conjunction of propositions. It can be\nconstructed and destructed like a pair: if `ha : a` and `hb : b` then\n`⟨ha, hb⟩ : a ∧ b`, and if `h : a ∧ b` then `h.left : a` and `h.right : b`.\n",
|
||
"kind": "markdown"},
|
||
"detail": "Prop → Prop → Prop"},
|
||
{"label": "AndOp",
|
||
"kind": 7,
|
||
"documentation":
|
||
{"value":
|
||
"The homogeneous version of `HAnd`: `a &&& b : α` where `a b : α`.\n(It is called `AndOp` because `And` is taken for the propositional connective.)\n",
|
||
"kind": "markdown"},
|
||
"detail": "Type u → Type u"},
|
||
{"label": "AndThen",
|
||
"kind": 7,
|
||
"documentation":
|
||
{"value":
|
||
"The homogeneous version of `HAndThen`: `a >> b : α` where `a b : α`.\nBecause `b` is \"lazy\" in this notation, it is passed as `Unit → α` to the\nimplementation so it can decide when to evaluate it.\n",
|
||
"kind": "markdown"},
|
||
"detail": "Type u → Type u"},
|
||
{"label": "and",
|
||
"kind": 3,
|
||
"documentation":
|
||
{"value":
|
||
"`and x y`, or `x && y`, is the boolean \"and\" operation (not to be confused\nwith `And : Prop → Prop → Prop`, which is the propositional connective).\nIt is `@[macroInline]` because it has C-like short-circuiting behavior:\nif `x` is false then `y` is not evaluated.\n",
|
||
"kind": "markdown"},
|
||
"detail": "Bool → Bool → Bool"},
|
||
{"label": "andM",
|
||
"kind": 3,
|
||
"detail": "[inst : Monad m] → [inst : ToBool β] → m β → m β → m β"},
|
||
{"label": "and_false",
|
||
"kind": 3,
|
||
"detail": "∀ (p : Prop), (p ∧ False) = False"},
|
||
{"label": "and_self", "kind": 3, "detail": "∀ (p : Prop), (p ∧ p) = p"},
|
||
{"label": "and_true", "kind": 3, "detail": "∀ (p : Prop), (p ∧ True) = p"},
|
||
{"label": "Append",
|
||
"kind": 7,
|
||
"documentation":
|
||
{"value":
|
||
"The homogeneous version of `HAppend`: `a ++ b : α` where `a b : α`. ",
|
||
"kind": "markdown"},
|
||
"detail": "Type u → Type u"},
|
||
{"label": "HAnd",
|
||
"kind": 7,
|
||
"documentation":
|
||
{"value":
|
||
"The typeclass behind the notation `a &&& b : γ` where `a : α`, `b : β`. ",
|
||
"kind": "markdown"},
|
||
"detail": "Type u → Type v → outParam (Type w) → Type (max (max u v) w)"},
|
||
{"label": "HAndThen",
|
||
"kind": 7,
|
||
"documentation":
|
||
{"value":
|
||
"The typeclass behind the notation `a >> b : γ` where `a : α`, `b : β`.\nBecause `b` is \"lazy\" in this notation, it is passed as `Unit → β` to the\nimplementation so it can decide when to evaluate it.\n",
|
||
"kind": "markdown"},
|
||
"detail": "Type u → Type v → outParam (Type w) → Type (max (max u v) w)"},
|
||
{"label": "false_and",
|
||
"kind": 3,
|
||
"detail": "∀ (p : Prop), (False ∧ p) = False"},
|
||
{"label": "instAndOpUInt16", "kind": 21, "detail": "AndOp UInt16"},
|
||
{"label": "instAndOpUInt32", "kind": 21, "detail": "AndOp UInt32"},
|
||
{"label": "instAndOpUInt64", "kind": 21, "detail": "AndOp UInt64"},
|
||
{"label": "instAndOpUInt8", "kind": 21, "detail": "AndOp UInt8"},
|
||
{"label": "instAndOpUSize", "kind": 21, "detail": "AndOp USize"},
|
||
{"label": "strictAnd", "kind": 3, "detail": "Bool → Bool → Bool"},
|
||
{"label": "true_and", "kind": 3, "detail": "∀ (p : Prop), (True ∧ p) = p"},
|
||
{"label": "instDecidableAnd",
|
||
"kind": 3,
|
||
"detail": "[dp : Decidable p] → [dq : Decidable q] → Decidable (p ∧ q)"},
|
||
{"label": "instHAnd", "kind": 3, "detail": "[inst : AndOp α] → HAnd α α α"},
|
||
{"label": "instHAndThen",
|
||
"kind": 3,
|
||
"detail": "[inst : AndThen α] → HAndThen α α α"},
|
||
{"label": "compareOfLessAndEq",
|
||
"kind": 3,
|
||
"detail":
|
||
"(x y : α) → [inst : LT α] → [inst : Decidable (x < y)] → [inst : DecidableEq α] → Ordering"},
|
||
{"label": "iff_iff_implies_and_implies",
|
||
"kind": 3,
|
||
"detail": "∀ (a b : Prop), (a ↔ b) ↔ (a → b) ∧ (b → a)"},
|
||
{"label": "HAppend",
|
||
"kind": 7,
|
||
"documentation":
|
||
{"value":
|
||
"The notation typeclass for heterogeneous append.\nThis enables the notation `a ++ b : γ` where `a : α`, `b : β`.\n",
|
||
"kind": "markdown"},
|
||
"detail": "Type u → Type v → outParam (Type w) → Type (max (max u v) w)"},
|
||
{"label": "instAppendSubarray", "kind": 3, "detail": "Append (Subarray α)"}],
|
||
"isIncomplete": true}
|
||
{"textDocument": {"uri": "file://completion7.lean"},
|
||
"position": {"line": 2, "character": 11}}
|
||
{"items":
|
||
[{"label": "comm", "kind": 3, "detail": "a ∧ b ↔ b ∧ a"},
|
||
{"label": "intro",
|
||
"kind": 4,
|
||
"documentation":
|
||
{"value":
|
||
"`And.intro : a → b → a ∧ b` is the constructor for the And operation. ",
|
||
"kind": "markdown"},
|
||
"detail": "a → b → a ∧ b"},
|
||
{"label": "left",
|
||
"kind": 5,
|
||
"documentation":
|
||
{"value":
|
||
"Extract the left conjunct from a conjunction. `h : a ∧ b` then\n`h.left`, also notated as `h.1`, is a proof of `a`. ",
|
||
"kind": "markdown"},
|
||
"detail": "a ∧ b → a"},
|
||
{"label": "right",
|
||
"kind": 5,
|
||
"documentation":
|
||
{"value":
|
||
"Extract the right conjunct from a conjunction. `h : a ∧ b` then\n`h.right`, also notated as `h.2`, is a proof of `b`. ",
|
||
"kind": "markdown"},
|
||
"detail": "a ∧ b → b"}],
|
||
"isIncomplete": true}
|