| {"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": "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 `@[macro_inline]` 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": "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": "andM", | |
| "kind": 3, | |
| "detail": "[inst : Monad m] → [inst : ToBool β] → m β → m β → m β"}, | |
| {"label": "false_and", | |
| "kind": 3, | |
| "detail": "∀ (p : Prop), (False ∧ p) = False"}, | |
| {"label": "true_and", "kind": 3, "detail": "∀ (p : Prop), (True ∧ p) = p"}, | |
| {"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": "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": "strictAnd", | |
| "kind": 3, | |
| "documentation": | |
| {"value": | |
| "`strictAnd` is the same as `and`, but it does not use short-circuit evaluation semantics:\nboth sides are evaluated, even if the first value is `false`.\n", | |
| "kind": "markdown"}, | |
| "detail": "Bool → Bool → Bool"}, | |
| {"label": "instDecidableAnd", | |
| "kind": 3, | |
| "detail": "[dp : Decidable p] → [dq : Decidable q] → Decidable (p ∧ q)"}, | |
| {"label": "instHAnd", "kind": 3, "detail": "[inst : AndOp α] → HAnd α α α"}, | |
| {"label": "Append", | |
| "kind": 7, | |
| "documentation": | |
| {"value": | |
| "The homogeneous version of `HAppend`: `a ++ b : α` where `a b : α`. ", | |
| "kind": "markdown"}, | |
| "detail": "Type u → Type u"}, | |
| {"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": "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": "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 α)"}, | |
| {"label": "instHAppend", | |
| "kind": 3, | |
| "detail": "[inst : Append α] → HAppend α α α"}], | |
| "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} |