{"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,
   "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": "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}