blob: 2e2d053325e31ac2b5e8a1a1dccf184ffbfb75ea [file]
{"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}