Loogle!
Result
Found 525 declarations whose name contains "Syntax". Of these, only the first 200 are shown.
- Lean.Syntax 📋 Init.Prelude
: Type - Lean.SyntaxNodeKind 📋 Init.Prelude
: Type - Lean.SyntaxNodeKinds 📋 Init.Prelude
: Type - Lean.Syntax.Preresolved 📋 Init.Prelude
: Type - Lean.Syntax.missing 📋 Init.Prelude
: Lean.Syntax - Lean.Macro.Exception.unsupportedSyntax 📋 Init.Prelude
: Lean.Macro.Exception - Lean.TSyntax 📋 Init.Prelude
(ks : Lean.SyntaxNodeKinds) : Type - Lean.TSyntaxArray 📋 Init.Prelude
(ks : Lean.SyntaxNodeKinds) : Type - Lean.instInhabitedSyntax 📋 Init.Prelude
: Inhabited Lean.Syntax - Lean.Syntax.SepArray 📋 Init.Prelude
(sep : String) : Type - Lean.Syntax.getHeadInfo 📋 Init.Prelude
(stx : Lean.Syntax) : Lean.SourceInfo - Lean.Syntax.getId 📋 Init.Prelude
: Lean.Syntax → Lean.Name - Lean.Syntax.getKind 📋 Init.Prelude
(stx : Lean.Syntax) : Lean.SyntaxNodeKind - Lean.Syntax.getNumArgs 📋 Init.Prelude
(stx : Lean.Syntax) : ℕ - Lean.Syntax.isIdent 📋 Init.Prelude
: Lean.Syntax → Bool - Lean.Syntax.isMissing 📋 Init.Prelude
: Lean.Syntax → Bool - Lean.Syntax.Preresolved.namespace 📋 Init.Prelude
(ns : Lean.Name) : Lean.Syntax.Preresolved - Lean.Syntax.TSepArray 📋 Init.Prelude
(ks : Lean.SyntaxNodeKinds) (sep : String) : Type - Lean.Syntax.atom 📋 Init.Prelude
(info : Lean.SourceInfo) (val : String) : Lean.Syntax - Lean.Syntax.getArg 📋 Init.Prelude
(stx : Lean.Syntax) (i : ℕ) : Lean.Syntax - Lean.Syntax.getArgs 📋 Init.Prelude
(stx : Lean.Syntax) : Array Lean.Syntax - Lean.Syntax.getHeadInfo? 📋 Init.Prelude
: Lean.Syntax → Option Lean.SourceInfo - Lean.Syntax.getInfo? 📋 Init.Prelude
: Lean.Syntax → Option Lean.SourceInfo - Lean.Syntax.getOptional? 📋 Init.Prelude
(stx : Lean.Syntax) : Option Lean.Syntax - Lean.Syntax.isOfKind 📋 Init.Prelude
(stx : Lean.Syntax) (k : Lean.SyntaxNodeKind) : Bool - Lean.Syntax.matchesIdent 📋 Init.Prelude
(stx : Lean.Syntax) (id : Lean.Name) : Bool - Lean.Syntax.matchesNull 📋 Init.Prelude
(stx : Lean.Syntax) (n : ℕ) : Bool - Lean.Syntax.setKind 📋 Init.Prelude
(stx : Lean.Syntax) (k : Lean.SyntaxNodeKind) : Lean.Syntax - Lean.instInhabitedTSyntax 📋 Init.Prelude
{ks : Lean.SyntaxNodeKinds} : Inhabited (Lean.TSyntax ks) - Lean.Syntax.isNodeOf 📋 Init.Prelude
(stx : Lean.Syntax) (k : Lean.SyntaxNodeKind) (n : ℕ) : Bool - Lean.Syntax.matchesLit 📋 Init.Prelude
(stx : Lean.Syntax) (k : Lean.SyntaxNodeKind) (val : String) : Bool - Lean.Syntax.node1 📋 Init.Prelude
(info : Lean.SourceInfo) (kind : Lean.SyntaxNodeKind) (a₁ : Lean.Syntax) : Lean.Syntax - Lean.TSyntax.mk 📋 Init.Prelude
{ks : Lean.SyntaxNodeKinds} (raw : Lean.Syntax) : Lean.TSyntax ks - Lean.TSyntax.raw 📋 Init.Prelude
{ks : Lean.SyntaxNodeKinds} (self : Lean.TSyntax ks) : Lean.Syntax - Lean.Syntax.Preresolved.decl 📋 Init.Prelude
(n : Lean.Name) (fields : List String) : Lean.Syntax.Preresolved - Lean.Syntax.node 📋 Init.Prelude
(info : Lean.SourceInfo) (kind : Lean.SyntaxNodeKind) (args : Array Lean.Syntax) : Lean.Syntax - Lean.Syntax.node2 📋 Init.Prelude
(info : Lean.SourceInfo) (kind : Lean.SyntaxNodeKind) (a₁ a₂ : Lean.Syntax) : Lean.Syntax - Lean.TSyntaxArray.mk 📋 Init.Prelude
{ks : Lean.SyntaxNodeKinds} (as : Array Lean.Syntax) : Lean.TSyntaxArray ks - Lean.TSyntaxArray.mkImpl 📋 Init.Prelude
{ks : Lean.SyntaxNodeKinds} : Array Lean.Syntax → Lean.TSyntaxArray ks - Lean.TSyntaxArray.raw 📋 Init.Prelude
{ks : Lean.SyntaxNodeKinds} (as : Lean.TSyntaxArray ks) : Array Lean.Syntax - Lean.TSyntaxArray.rawImpl 📋 Init.Prelude
{ks : Lean.SyntaxNodeKinds} : Lean.TSyntaxArray ks → Array Lean.Syntax - Lean.Syntax.SepArray.elemsAndSeps 📋 Init.Prelude
{sep : String} (self : Lean.Syntax.SepArray sep) : Array Lean.Syntax - Lean.Syntax.SepArray.mk 📋 Init.Prelude
{sep : String} (elemsAndSeps : Array Lean.Syntax) : Lean.Syntax.SepArray sep - Lean.Syntax.getPos? 📋 Init.Prelude
(stx : Lean.Syntax) (canonicalOnly : Bool := false) : Option String.Pos.Raw - Lean.Syntax.getTailPos? 📋 Init.Prelude
(stx : Lean.Syntax) (canonicalOnly : Bool := false) : Option String.Pos.Raw - Lean.Syntax.ident 📋 Init.Prelude
(info : Lean.SourceInfo) (rawVal : Substring.Raw) (val : Lean.Name) (preresolved : List Lean.Syntax.Preresolved) : Lean.Syntax - Lean.Syntax.node3 📋 Init.Prelude
(info : Lean.SourceInfo) (kind : Lean.SyntaxNodeKind) (a₁ a₂ a₃ : Lean.Syntax) : Lean.Syntax - Lean.Syntax.node4 📋 Init.Prelude
(info : Lean.SourceInfo) (kind : Lean.SyntaxNodeKind) (a₁ a₂ a₃ a₄ : Lean.Syntax) : Lean.Syntax - Lean.Syntax.TSepArray.elemsAndSeps 📋 Init.Prelude
{ks : Lean.SyntaxNodeKinds} {sep : String} (self : Lean.Syntax.TSepArray ks sep) : Array Lean.Syntax - Lean.Syntax.TSepArray.mk 📋 Init.Prelude
{ks : Lean.SyntaxNodeKinds} {sep : String} (elemsAndSeps : Array Lean.Syntax) : Lean.Syntax.TSepArray ks sep - Lean.Syntax.node5 📋 Init.Prelude
(info : Lean.SourceInfo) (kind : Lean.SyntaxNodeKind) (a₁ a₂ a₃ a₄ a₅ : Lean.Syntax) : Lean.Syntax - Lean.Syntax.node6 📋 Init.Prelude
(info : Lean.SourceInfo) (kind : Lean.SyntaxNodeKind) (a₁ a₂ a₃ a₄ a₅ a₆ : Lean.Syntax) : Lean.Syntax - Lean.Syntax.node7 📋 Init.Prelude
(info : Lean.SourceInfo) (kind : Lean.SyntaxNodeKind) (a₁ a₂ a₃ a₄ a₅ a₆ a₇ : Lean.Syntax) : Lean.Syntax - Lean.Syntax.node8 📋 Init.Prelude
(info : Lean.SourceInfo) (kind : Lean.SyntaxNodeKind) (a₁ a₂ a₃ a₄ a₅ a₆ a₇ a₈ : Lean.Syntax) : Lean.Syntax - Lean.Parser.Syntax.addPrec 📋 Init.Notation
: Lean.TrailingParserDescr - Lean.Parser.Syntax.addPrio 📋 Init.Notation
: Lean.TrailingParserDescr - Lean.Parser.Syntax.subPrec 📋 Init.Notation
: Lean.TrailingParserDescr - Lean.Parser.Syntax.subPrio 📋 Init.Notation
: Lean.TrailingParserDescr - Lean.instCoeSyntaxNodeKindSyntaxNodeKinds 📋 Init.Notation
: Coe Lean.SyntaxNodeKind Lean.SyntaxNodeKinds - Lean.instCoeOutTSyntaxSyntax 📋 Init.Notation
{ks : Lean.SyntaxNodeKinds} : CoeOut (Lean.TSyntax ks) Lean.Syntax - Lean.instCoeSyntaxTSyntaxConsSyntaxNodeKindMkStr1Nil 📋 Init.Notation
: Coe Lean.Syntax (Lean.TSyntax `rawStx) - Lean.Parser.Syntax.exact? 📋 Init.Tactics
: Lean.ParserDescr - Lean.Syntax.instGetElemNatTrue 📋 Init.GetElem
: GetElem Lean.Syntax ℕ Lean.Syntax fun x x_1 => True - Lean.Syntax.CharLit 📋 Init.Meta.Defs
: Type - Lean.Syntax.Command 📋 Init.Meta.Defs
: Type - Lean.Syntax.HexNum 📋 Init.Meta.Defs
: Type - Lean.Syntax.HygieneInfo 📋 Init.Meta.Defs
: Type - Lean.Syntax.Ident 📋 Init.Meta.Defs
: Type - Lean.Syntax.Level 📋 Init.Meta.Defs
: Type - Lean.Syntax.NameLit 📋 Init.Meta.Defs
: Type - Lean.Syntax.NumLit 📋 Init.Meta.Defs
: Type - Lean.Syntax.Prec 📋 Init.Meta.Defs
: Type - Lean.Syntax.Prio 📋 Init.Meta.Defs
: Type - Lean.Syntax.ScientificLit 📋 Init.Meta.Defs
: Type - Lean.Syntax.StrLit 📋 Init.Meta.Defs
: Type - Lean.Syntax.Tactic 📋 Init.Meta.Defs
: Type - Lean.Syntax.Term 📋 Init.Meta.Defs
: Type - Lean.Syntax.getTailInfo 📋 Init.Meta.Defs
(stx : Lean.Syntax) : Lean.SourceInfo - Lean.Syntax.getTrailingSize 📋 Init.Meta.Defs
(stx : Lean.Syntax) : ℕ - Lean.Syntax.hasArgs 📋 Init.Meta.Defs
: Lean.Syntax → Bool - Lean.Syntax.instBEq 📋 Init.Meta.Defs
: BEq Lean.Syntax - Lean.Syntax.instBEqPreresolved 📋 Init.Meta.Defs
: BEq Lean.Syntax.Preresolved - Lean.Syntax.instRepr 📋 Init.Meta.Defs
: Repr Lean.Syntax - Lean.Syntax.instReprPreresolved 📋 Init.Meta.Defs
: Repr Lean.Syntax.Preresolved - Lean.Syntax.isAtom 📋 Init.Meta.Defs
: Lean.Syntax → Bool - Lean.Syntax.isNone 📋 Init.Meta.Defs
(stx : Lean.Syntax) : Bool - Lean.Syntax.mkSynthetic 📋 Init.Meta.Defs
(stx : Lean.Syntax) : Lean.Syntax - Lean.Syntax.toNat 📋 Init.Meta.Defs
(stx : Lean.Syntax) : ℕ - Lean.Syntax.unsetTrailing 📋 Init.Meta.Defs
(stx : Lean.Syntax) : Lean.Syntax - Lean.TSyntax.getChar 📋 Init.Meta.Defs
(s : Lean.CharLit) : Char - Lean.TSyntax.getHexNumSize 📋 Init.Meta.Defs
(s : Lean.Syntax.HexNum) : ℕ - Lean.TSyntax.getHexNumVal 📋 Init.Meta.Defs
(s : Lean.Syntax.HexNum) : ℕ - Lean.TSyntax.getHygieneInfo 📋 Init.Meta.Defs
(s : Lean.HygieneInfo) : Lean.Name - Lean.TSyntax.getId 📋 Init.Meta.Defs
(s : Lean.Ident) : Lean.Name - Lean.TSyntax.getName 📋 Init.Meta.Defs
(s : Lean.NameLit) : Lean.Name - Lean.TSyntax.getNat 📋 Init.Meta.Defs
(s : Lean.NumLit) : ℕ - Lean.TSyntax.getString 📋 Init.Meta.Defs
(s : Lean.StrLit) : String - Lean.Syntax.copyHeadTailInfoFrom 📋 Init.Meta.Defs
(target source : Lean.Syntax) : Lean.Syntax - Lean.Syntax.decodeCharLit 📋 Init.Meta.Defs
(s : String) : Option Char - Lean.Syntax.decodeNameLit 📋 Init.Meta.Defs
(s : String) : Option Lean.Name - Lean.Syntax.decodeNatLitVal? 📋 Init.Meta.Defs
(s : String) : Option ℕ - Lean.Syntax.decodeStrLit 📋 Init.Meta.Defs
(s : String) : Option String - Lean.Syntax.getHead? 📋 Init.Meta.Defs
: Lean.Syntax → Option Lean.Syntax - Lean.Syntax.getOptionalIdent? 📋 Init.Meta.Defs
(stx : Lean.Syntax) : Option Lean.Name - Lean.Syntax.getSepArgs 📋 Init.Meta.Defs
(stx : Lean.Syntax) : Array Lean.Syntax - Lean.Syntax.getTailInfo? 📋 Init.Meta.Defs
: Lean.Syntax → Option Lean.SourceInfo - Lean.Syntax.getTrailing? 📋 Init.Meta.Defs
(stx : Lean.Syntax) : Option Substring.Raw - Lean.Syntax.isCharLit? 📋 Init.Meta.Defs
(stx : Lean.Syntax) : Option Char - Lean.Syntax.isFieldIdx? 📋 Init.Meta.Defs
(s : Lean.Syntax) : Option ℕ - Lean.Syntax.isIdOrAtom? 📋 Init.Meta.Defs
: Lean.Syntax → Option String - Lean.Syntax.isInterpolatedStrLit? 📋 Init.Meta.Defs
(stx : Lean.Syntax) : Option String - Lean.Syntax.isNameLit? 📋 Init.Meta.Defs
(stx : Lean.Syntax) : Option Lean.Name - Lean.Syntax.isNatLit? 📋 Init.Meta.Defs
(s : Lean.Syntax) : Option ℕ - Lean.Syntax.isStrLit? 📋 Init.Meta.Defs
(stx : Lean.Syntax) : Option String - Lean.Syntax.isToken 📋 Init.Meta.Defs
(token : String) : Lean.Syntax → Bool - Lean.Syntax.setHeadInfo 📋 Init.Meta.Defs
(stx : Lean.Syntax) (info : Lean.SourceInfo) : Lean.Syntax - Lean.Syntax.setInfo 📋 Init.Meta.Defs
(info : Lean.SourceInfo) : Lean.Syntax → Lean.Syntax - Lean.Syntax.setTailInfo 📋 Init.Meta.Defs
(stx : Lean.Syntax) (info : Lean.SourceInfo) : Lean.Syntax - Lean.Syntax.splitNameLit 📋 Init.Meta.Defs
(ss : Substring.Raw) : List Substring.Raw - Lean.Syntax.structEq 📋 Init.Meta.Defs
: Lean.Syntax → Lean.Syntax → Bool - Lean.TSyntax.instCoeCharLitTerm 📋 Init.Meta.Defs
: Coe Lean.CharLit Lean.Term - Lean.TSyntax.instCoeIdentLevel 📋 Init.Meta.Defs
: Coe Lean.Ident Lean.Syntax.Level - Lean.TSyntax.instCoeIdentTerm 📋 Init.Meta.Defs
: Coe Lean.Ident Lean.Term - Lean.TSyntax.instCoeNameLitTerm 📋 Init.Meta.Defs
: Coe Lean.NameLit Lean.Term - Lean.TSyntax.instCoeNumLitPrec 📋 Init.Meta.Defs
: Coe Lean.NumLit Lean.Prec - Lean.TSyntax.instCoeNumLitPrio 📋 Init.Meta.Defs
: Coe Lean.NumLit Lean.Prio - Lean.TSyntax.instCoeNumLitTerm 📋 Init.Meta.Defs
: Coe Lean.NumLit Lean.Term - Lean.TSyntax.instCoeScientificLitTerm 📋 Init.Meta.Defs
: Coe Lean.ScientificLit Lean.Term - Lean.TSyntax.instCoeStrLitTerm 📋 Init.Meta.Defs
: Coe Lean.StrLit Lean.Term - Lean.Syntax.instBEqPreresolved.beq 📋 Init.Meta.Defs
: Lean.Syntax.Preresolved → Lean.Syntax.Preresolved → Bool - Lean.Syntax.instRepr.repr 📋 Init.Meta.Defs
: Lean.Syntax → ℕ → Std.Format - Lean.Syntax.instReprPreresolved.repr 📋 Init.Meta.Defs
: Lean.Syntax.Preresolved → ℕ → Std.Format - Lean.Syntax.decodeRawStrLitAux 📋 Init.Meta.Defs
(s : String) (i : String.Pos.Raw) (num : ℕ) : String - Lean.Syntax.decodeStringGap 📋 Init.Meta.Defs
(s : String) (i : String.Pos.Raw) : Option String.Pos.Raw - Lean.Syntax.instBEqTSyntax 📋 Init.Meta.Defs
{k : Lean.SyntaxNodeKinds} : BEq (Lean.TSyntax k) - Lean.Syntax.instEmptyCollectionSepArray 📋 Init.Meta.Defs
{sep : String} : EmptyCollection (Lean.Syntax.SepArray sep) - Lean.Syntax.instReprTSyntax 📋 Init.Meta.Defs
{ks✝ : Lean.SyntaxNodeKinds} : Repr (Lean.TSyntax ks✝) - Lean.Syntax.isLit? 📋 Init.Meta.Defs
(litKind : Lean.SyntaxNodeKind) (stx : Lean.Syntax) : Option String - Lean.Syntax.mkSep 📋 Init.Meta.Defs
(a : Array Lean.Syntax) (sep : Lean.Syntax) : Lean.Syntax - Lean.Syntax.setHeadInfoAux 📋 Init.Meta.Defs
(info : Lean.SourceInfo) : Lean.Syntax → Option Lean.Syntax - Lean.Syntax.setTailInfoAux 📋 Init.Meta.Defs
(info : Lean.SourceInfo) : Lean.Syntax → Option Lean.Syntax - Lean.Syntax.decodeStrLitAux 📋 Init.Meta.Defs
(s : String) (i : String.Pos.Raw) (acc : String) : Option String - Lean.Syntax.find? 📋 Init.Meta.Defs
(stx : Lean.Syntax) (p : Lean.Syntax → Bool) : Option Lean.Syntax - Lean.Syntax.findAux 📋 Init.Meta.Defs
(p : Lean.Syntax → Bool) : Lean.Syntax → Option Lean.Syntax - Lean.Syntax.mkCharLit 📋 Init.Meta.Defs
(val : Char) (info : Lean.SourceInfo := Lean.SourceInfo.none) : Lean.CharLit - Lean.Syntax.mkNameLit 📋 Init.Meta.Defs
(val : String) (info : Lean.SourceInfo := Lean.SourceInfo.none) : Lean.NameLit - Lean.Syntax.mkNatLit 📋 Init.Meta.Defs
(val : ℕ) (info : Lean.SourceInfo := Lean.SourceInfo.none) : Lean.NumLit - Lean.Syntax.mkNumLit 📋 Init.Meta.Defs
(val : String) (info : Lean.SourceInfo := Lean.SourceInfo.none) : Lean.NumLit - Lean.Syntax.mkStrLit 📋 Init.Meta.Defs
(val : String) (info : Lean.SourceInfo := Lean.SourceInfo.none) : Lean.StrLit - Lean.Syntax.SepArray.getElems 📋 Init.Meta.Defs
{sep : String} (sa : Lean.Syntax.SepArray sep) : Array Lean.Syntax - Lean.Syntax.SepArray.ofElems 📋 Init.Meta.Defs
{sep : String} (elems : Array Lean.Syntax) : Lean.Syntax.SepArray sep - Lean.Syntax.instReprTSyntax.repr 📋 Init.Meta.Defs
{ks✝ : Lean.SyntaxNodeKinds} : Lean.TSyntax ks✝ → ℕ → Std.Format - Lean.TSyntax.Compat.instCoeTailSyntax 📋 Init.Meta.Defs
{k : Lean.SyntaxNodeKinds} : CoeTail Lean.Syntax (Lean.TSyntax k) - Lean.Syntax.decodeQuotedChar 📋 Init.Meta.Defs
(s : String) (i : String.Pos.Raw) : Option (Char × String.Pos.Raw) - Lean.Syntax.getTrailingTailPos? 📋 Init.Meta.Defs
(stx : Lean.Syntax) (canonicalOnly : Bool := false) : Option String.Pos.Raw - Lean.Syntax.instCoeArraySepArray 📋 Init.Meta.Defs
{sep : String} : Coe (Array Lean.Syntax) (Lean.Syntax.SepArray sep) - Lean.Syntax.instCoeOutSepArrayArray 📋 Init.Meta.Defs
{sep : String} : CoeOut (Lean.Syntax.SepArray sep) (Array Lean.Syntax) - Lean.Syntax.instCoeOutTSyntaxArrayArray 📋 Init.Meta.Defs
{k : Lean.SyntaxNodeKinds} : CoeOut (Lean.TSyntaxArray k) (Array Lean.Syntax) - Lean.Syntax.instEmptyCollectionTSepArray 📋 Init.Meta.Defs
{sep : Lean.SyntaxNodeKinds} {k : String} : EmptyCollection (Lean.Syntax.TSepArray sep k) - Lean.TSyntax.getScientific 📋 Init.Meta.Defs
(s : Lean.ScientificLit) : ℕ × Bool × ℕ - Lean.TSyntax.Compat.instCoeTailArraySyntaxTSyntaxArray 📋 Init.Meta.Defs
{k : Lean.SyntaxNodeKinds} : CoeTail (Array Lean.Syntax) (Lean.TSyntaxArray k) - Lean.Syntax.decodeScientificLitVal? 📋 Init.Meta.Defs
(s : String) : Option (ℕ × Bool × ℕ) - Lean.Syntax.isScientificLit? 📋 Init.Meta.Defs
(stx : Lean.Syntax) : Option (ℕ × Bool × ℕ) - Lean.Syntax.TSepArray.getElems 📋 Init.Meta.Defs
{k : Lean.SyntaxNodeKinds} {sep : String} (sa : Lean.Syntax.TSepArray k sep) : Lean.TSyntaxArray k - Lean.Syntax.instCoeOutTSepArrayTSyntaxArray 📋 Init.Meta.Defs
{k : Lean.SyntaxNodeKinds} {sep : String} : CoeOut (Lean.Syntax.TSepArray k sep) (Lean.TSyntaxArray k) - Lean.Syntax.instCoeTSyntaxArrayTSepArray 📋 Init.Meta.Defs
{k : Lean.SyntaxNodeKinds} {sep : String} : Coe (Lean.TSyntaxArray k) (Lean.Syntax.TSepArray k sep) - Lean.Syntax.TSepArray.ofElems 📋 Init.Meta.Defs
{k : Lean.SyntaxNodeKinds} {sep : String} (elems : Array (Lean.TSyntax k)) : Lean.Syntax.TSepArray k sep - Lean.TSyntax.Compat.instCoeTailArraySyntaxTSepArray 📋 Init.Meta.Defs
{k : Lean.SyntaxNodeKinds} {sep : String} : CoeTail (Array Lean.Syntax) (Lean.Syntax.TSepArray k sep) - Lean.Syntax.getSubstring? 📋 Init.Meta.Defs
(stx : Lean.Syntax) (withLeading withTrailing : Bool := true) : Option Substring.Raw - Lean.Syntax.mkApp 📋 Init.Meta.Defs
(fn : Lean.Term) (args : Lean.TSyntaxArray `term) : Lean.Term - Lean.Syntax.mkCApp 📋 Init.Meta.Defs
(fn : Lean.Name) (args : Lean.TSyntaxArray `term) : Lean.Term - Lean.Syntax.mkScientificLit 📋 Init.Meta.Defs
(val : String) (info : Lean.SourceInfo := Lean.SourceInfo.none) : Lean.TSyntax Lean.scientificLitKind - Lean.TSyntax.instCoeConsSyntaxNodeKind 📋 Init.Meta.Defs
{ks : Lean.SyntaxNodeKinds} {k' : Lean.SyntaxNodeKind} : Coe (Lean.TSyntax ks) (Lean.TSyntax (k' :: ks)) - Lean.Syntax.TSepArray.push 📋 Init.Meta.Defs
{k : Lean.SyntaxNodeKinds} {sep : String} (sa : Lean.Syntax.TSepArray k sep) (e : Lean.TSyntax k) : Lean.Syntax.TSepArray k sep - Lean.Syntax.mkLit 📋 Init.Meta.Defs
(kind : Lean.SyntaxNodeKind) (val : String) (info : Lean.SourceInfo := Lean.SourceInfo.none) : Lean.TSyntax kind - Lean.TSyntax.getDocString 📋 Init.Meta.Defs
(stx : Lean.TSyntax `Lean.Parser.Command.docComment) : String - Lean.Syntax.instCoeIdentTSyntaxConsSyntaxNodeKindMkStr4Nil 📋 Init.Meta.Defs
: Coe Lean.Ident (Lean.TSyntax `Lean.Parser.Command.declId) - Lean.Syntax.instCoeTSyntaxArrayOfTSyntax 📋 Init.Meta.Defs
{k k' : Lean.SyntaxNodeKinds} [Coe (Lean.TSyntax k) (Lean.TSyntax k')] : Coe (Lean.TSyntaxArray k) (Lean.TSyntaxArray k') - Lean.Syntax.instCoeTermTSyntaxConsSyntaxNodeKindMkStr4Nil 📋 Init.Meta.Defs
: Coe Lean.Term (Lean.TSyntax `Lean.Parser.Term.funBinder) - Lean.Syntax.SepArray.ofElemsUsingRef 📋 Init.Meta.Defs
{m : Type → Type} [Monad m] [Lean.MonadRef m] {sep : String} (elems : Array Lean.Syntax) : m (Lean.Syntax.SepArray sep) - Lean.TSyntax.expandInterpolatedStr 📋 Init.Meta.Defs
(interpStr : Lean.TSyntax Lean.interpolatedStrKind) (type ofInterpFn : Lean.Term) (ofLitFn : Lean.Term := ofInterpFn) : Lean.MacroM Lean.Term - Lean.TSyntax.expandInterpolatedStrChunks 📋 Init.Meta.Defs
(chunks : Array Lean.Syntax) (mkAppend : Lean.Syntax → Lean.Syntax → Lean.MacroM Lean.Syntax) (mkElem : Lean.Syntax → Lean.MacroM Lean.Syntax) (mkLit : String → Lean.MacroM Lean.Syntax) : Lean.MacroM Lean.Syntax - Lean.TSyntax.instCoeConsSyntaxNodeKindNil 📋 Init.Meta.Defs
{k : Lean.SyntaxNodeKind} {ks : List Lean.SyntaxNodeKind} : Coe (Lean.TSyntax k) (Lean.TSyntax (k :: ks)) - Lean.TSyntax.instCoeDepTermMkIdentIdent 📋 Init.Meta.Defs
{info : Lean.SourceInfo} {ss : Substring.Raw} {n : Lean.Name} {res : List Lean.Syntax.Preresolved} : CoeDep Lean.Term { raw := Lean.Syntax.ident info ss n res } Lean.Ident - Lean.instQuoteOfCoeHTCTTSyntaxConsSyntaxNodeKindNil 📋 Init.Meta.Defs
{α : Type} {k k' : Lean.SyntaxNodeKind} [Lean.Quote α k] [CoeHTCT (Lean.TSyntax k) (Lean.TSyntax k')] : Lean.Quote α k' - Lean.Syntax.setArg 📋 Init.Syntax
(stx : Lean.Syntax) (i : ℕ) (arg : Lean.Syntax) : Lean.Syntax - Lean.Syntax.setArgs 📋 Init.Syntax
(stx : Lean.Syntax) (args : Array Lean.Syntax) : Lean.Syntax - unexpandTSyntax 📋 Init.NotationExtra
: Lean.PrettyPrinter.Unexpander - unexpandTSyntaxArray 📋 Init.NotationExtra
: Lean.PrettyPrinter.Unexpander - Lean.Syntax.instToFormat 📋 Init.Data.Format.Syntax
: Std.ToFormat Lean.Syntax - Lean.Syntax.instToString 📋 Init.Data.Format.Syntax
: ToString Lean.Syntax - Lean.Syntax.instToFormatTSyntax 📋 Init.Data.Format.Syntax
{k : Lean.SyntaxNodeKinds} : Std.ToFormat (Lean.TSyntax k) - Lean.Syntax.instToStringTSyntax 📋 Init.Data.Format.Syntax
{k : Lean.SyntaxNodeKinds} : ToString (Lean.TSyntax k) - Lean.Syntax.formatStxAux 📋 Init.Data.Format.Syntax
(maxDepth : Option ℕ) (showInfo : Bool) (depth : ℕ) : Lean.Syntax → Std.Format - Lean.Syntax.formatStx 📋 Init.Data.Format.Syntax
(stx : Lean.Syntax) (maxDepth : Option ℕ := none) (showInfo : Bool := false) : Std.Format - Lean.DataValue.ofSyntax 📋 Lean.Data.KVMap
(v : Lean.Syntax) : Lean.DataValue - Lean.KVMap.instValueSyntax 📋 Lean.Data.KVMap
: Lean.KVMap.Value Lean.Syntax - Lean.instCoeSyntaxDataValue 📋 Lean.Data.KVMap
: Coe Lean.Syntax Lean.DataValue - Lean.KVMap.setSyntax 📋 Lean.Data.KVMap
(m : Lean.KVMap) (k : Lean.Name) (v : Lean.Syntax) : Lean.KVMap - Lean.KVMap.updateSyntax 📋 Lean.Data.KVMap
(m : Lean.KVMap) (k : Lean.Name) (f : Lean.Syntax → Lean.Syntax) : Lean.KVMap
About
Loogle searches Lean and Mathlib definitions and theorems.
You can use Loogle from within the Lean4 VSCode language extension
using (by default) Ctrl-K Ctrl-S. You can also try the
#loogle command from LeanSearchClient,
the CLI version, the Loogle
VS Code extension, the lean.nvim
integration or the Zulip bot.
Usage
Loogle finds definitions and lemmas in various ways:
By constant:
🔍Real.sin
finds all lemmas whose statement somehow mentions the sine function.By lemma name substring:
🔍"differ"
finds all lemmas that have"differ"somewhere in their lemma name.By subexpression:
🔍_ * (_ ^ _)
finds all lemmas whose statements somewhere include a product where the second argument is raised to some power.The pattern can also be non-linear, as in
🔍Real.sqrt ?a * Real.sqrt ?aIf the pattern has parameters, they are matched in any order. Both of these will find
List.map:
🔍(?a -> ?b) -> List ?a -> List ?b
🔍List ?a -> (?a -> ?b) -> List ?bBy main conclusion:
🔍|- tsum _ = _ * tsum _
finds all lemmas where the conclusion (the subexpression to the right of all→and∀) has the given shape.As before, if the pattern has parameters, they are matched against the hypotheses of the lemma in any order; for example,
🔍|- _ < _ → tsum _ < tsum _
will findtsum_lt_tsumeven though the hypothesisf i < g iis not the last.
If you pass more than one such search filter, separated by commas
Loogle will return lemmas which match all of them. The
search
🔍 Real.sin, "two", tsum, _ * _, _ ^ _, |- _ < _ → _
would find all lemmas which mention the constants Real.sin
and tsum, have "two" as a substring of the
lemma name, include a product and a power somewhere in the type,
and have a hypothesis of the form _ < _ (if
there were any such lemmas). Metavariables (?a) are
assigned independently in each filter.
The #lucky button will directly send you to the
documentation of the first hit.
Source code
You can find the source code for this service at https://github.com/nomeata/loogle. The https://loogle.lean-lang.org/ service is provided by the Lean FRO.
This is Loogle revision 401c76f serving mathlib revision a3d2529