Loogle!
Result
Found 1488 declarations mentioning Lean.Syntax. Of these, only the first 200 are shown.
- Lean.Syntax π Init.Prelude
: Type - Lean.Syntax.missing π Init.Prelude
: Lean.Syntax - Lean.instInhabitedSyntax π Init.Prelude
: Inhabited Lean.Syntax - Lean.mkAtom π Init.Prelude
(val : String) : Lean.Syntax - 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.Macro.Context.ref π Init.Prelude
(self : Lean.Macro.Context) : Lean.Syntax - Lean.replaceRef π Init.Prelude
(ref oldRef : Lean.Syntax) : Lean.Syntax - 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.Macro.Exception.error π Init.Prelude
: Lean.Syntax β String β Lean.Macro.Exception - Lean.Macro.expandMacro? π Init.Prelude
(stx : Lean.Syntax) : Lean.MacroM (Option Lean.Syntax) - 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.Macro.throwErrorAt π Init.Prelude
{Ξ± : Type} (ref : Lean.Syntax) (msg : String) : Lean.MacroM Ξ± - Lean.SourceInfo.fromRef π Init.Prelude
(ref : Lean.Syntax) (canonical : Bool := false) : Lean.SourceInfo - 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.Macro.Methods.expandMacro? π Init.Prelude
(self : Lean.Macro.Methods) : Lean.Syntax β Lean.MacroM (Option 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.getHeadInfo?.loop π Init.Prelude
(args : Array Lean.Syntax) (i : β) : Option Lean.SourceInfo - Lean.mkAtomFrom π Init.Prelude
(src : Lean.Syntax) (val : String) (canonical : Bool := false) : Lean.Syntax - Lean.mkNullNode π Init.Prelude
(args : Array Lean.Syntax := #[]) : Lean.Syntax - Lean.Macro.withIncRecDepth π Init.Prelude
{Ξ± : Type} (ref : Lean.Syntax) (x : Lean.MacroM Ξ±) : Lean.MacroM Ξ± - Lean.MonadRef.getRef π Init.Prelude
{m : Type β Type} [self : Lean.MonadRef m] : m Lean.Syntax - Lean.Syntax.getPos? π Init.Prelude
(stx : Lean.Syntax) (canonicalOnly : Bool := false) : Option String.Pos - Lean.Syntax.getTailPos? π Init.Prelude
(stx : Lean.Syntax) (canonicalOnly : Bool := false) : Option String.Pos - Lean.Syntax.ident π Init.Prelude
(info : Lean.SourceInfo) (rawVal : Substring) (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.Macro.Context.mk π Init.Prelude
(methods : Lean.Macro.MethodsRefβ) (mainModule : Lean.Name) (currMacroScope : Lean.MacroScope) (currRecDepth maxRecDepth : β) (ref : Lean.Syntax) : Lean.Macro.Context - 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.getTailPos?.loop π Init.Prelude
(canonicalOnly : Bool := false) (args : Array Lean.Syntax) (i : β) : Option String.Pos - Lean.mkNode π Init.Prelude
(k : Lean.SyntaxNodeKind) (args : Array Lean.Syntax) : Lean.TSyntax k - Lean.Syntax.node6 π Init.Prelude
(info : Lean.SourceInfo) (kind : Lean.SyntaxNodeKind) (aβ aβ aβ aβ aβ aβ : Lean.Syntax) : Lean.Syntax - Lean.MonadRef.withRef π Init.Prelude
{m : Type β Type} [self : Lean.MonadRef m] {Ξ± : Type} : Lean.Syntax β m Ξ± β m Ξ± - 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.withRef π Init.Prelude
{m : Type β Type} [Monad m] [Lean.MonadRef m] {Ξ± : Type} (ref : Lean.Syntax) (x : m Ξ±) : m Ξ± - Lean.MonadRef.mk π Init.Prelude
{m : Type β Type} (getRef : m Lean.Syntax) (withRef : {Ξ± : Type} β Lean.Syntax β m Ξ± β m Ξ±) : Lean.MonadRef m - Lean.withRef? π Init.Prelude
{m : Type β Type} [Monad m] [Lean.MonadRef m] {Ξ± : Type} (ref? : Option Lean.Syntax) (x : m Ξ±) : m Ξ± - Lean.Macro.Methods.mk π Init.Prelude
(expandMacro? : Lean.Syntax β Lean.MacroM (Option Lean.Syntax)) (getCurrNamespace : Lean.MacroM Lean.Name) (hasDecl : Lean.Name β Lean.MacroM Bool) (resolveNamespace : Lean.Name β Lean.MacroM (List Lean.Name)) (resolveGlobalName : Lean.Name β Lean.MacroM (List (Lean.Name Γ List String))) : Lean.Macro.Methods - Lean.instCoeOutTSyntaxSyntax π Init.Notation
{ks : Lean.SyntaxNodeKinds} : CoeOut (Lean.TSyntax ks) Lean.Syntax - Lean.instCoeSyntaxTSyntaxConsSyntaxNodeKindMkStr1Nil π Init.Notation
: Coe Lean.Syntax (Lean.TSyntax `rawStx) - autoParam π Init.Tactics
(Ξ± : Sort u) (tactic : Lean.Syntax) : Sort u - Lean.Syntax.missing.sizeOf_spec π Init.SizeOf
: sizeOf Lean.Syntax.missing = 1 - Lean.TSyntax.mk.sizeOf_spec π Init.SizeOf
{ks : Lean.SyntaxNodeKinds} (raw : Lean.Syntax) : sizeOf { raw := raw } = 1 + sizeOf raw - Lean.Syntax.SepArray.mk.sizeOf_spec π Init.SizeOf
{sep : String} (elemsAndSeps : Array Lean.Syntax) : sizeOf { elemsAndSeps := elemsAndSeps } = 1 + sizeOf elemsAndSeps - Lean.Macro.Methods.mk.sizeOf_spec π Init.SizeOf
(expandMacro? : Lean.Syntax β Lean.MacroM (Option Lean.Syntax)) (getCurrNamespace : Lean.MacroM Lean.Name) (hasDecl : Lean.Name β Lean.MacroM Bool) (resolveNamespace : Lean.Name β Lean.MacroM (List Lean.Name)) (resolveGlobalName : Lean.Name β Lean.MacroM (List (Lean.Name Γ List String))) : sizeOf { expandMacro? := expandMacro?, getCurrNamespace := getCurrNamespace, hasDecl := hasDecl, resolveNamespace := resolveNamespace, resolveGlobalName := resolveGlobalName } = 1 - Lean.Syntax.TSepArray.mk.sizeOf_spec π Init.SizeOf
{ks : Lean.SyntaxNodeKinds} {sep : String} (elemsAndSeps : Array Lean.Syntax) : sizeOf { elemsAndSeps := elemsAndSeps } = 1 + sizeOf elemsAndSeps - Lean.Syntax.atom.sizeOf_spec π Init.SizeOf
(info : Lean.SourceInfo) (val : String) : sizeOf (Lean.Syntax.atom info val) = 1 + sizeOf info + sizeOf val - Lean.Macro.Exception.error.sizeOf_spec π Init.SizeOf
(aβ : Lean.Syntax) (aβΒΉ : String) : sizeOf (Lean.Macro.Exception.error aβ aβΒΉ) = 1 + sizeOf aβ + sizeOf aβΒΉ - Lean.Syntax.node.sizeOf_spec π Init.SizeOf
(info : Lean.SourceInfo) (kind : Lean.SyntaxNodeKind) (args : Array Lean.Syntax) : sizeOf (Lean.Syntax.node info kind args) = 1 + sizeOf info + sizeOf kind + sizeOf args - Lean.Syntax.ident.sizeOf_spec π Init.SizeOf
(info : Lean.SourceInfo) (rawVal : Substring) (val : Lean.Name) (preresolved : List Lean.Syntax.Preresolved) : sizeOf (Lean.Syntax.ident info rawVal val preresolved) = 1 + sizeOf info + sizeOf rawVal + sizeOf val + sizeOf preresolved - Lean.Macro.Context.mk.sizeOf_spec π Init.SizeOf
(methods : Lean.Macro.MethodsRefβ) (mainModule : Lean.Name) (currMacroScope : Lean.MacroScope) (currRecDepth maxRecDepth : β) (ref : Lean.Syntax) : sizeOf { methods := methods, mainModule := mainModule, currMacroScope := currMacroScope, currRecDepth := currRecDepth, maxRecDepth := maxRecDepth, ref := ref } = 1 + sizeOf methods + sizeOf mainModule + sizeOf currMacroScope + sizeOf currRecDepth + sizeOf maxRecDepth + sizeOf ref - Lean.Syntax.atom.injEq π Init.Core
(info : Lean.SourceInfo) (val : String) (infoβ : Lean.SourceInfo) (valβ : String) : (Lean.Syntax.atom info val = Lean.Syntax.atom infoβ valβ) = (info = infoβ β§ val = valβ) - Lean.Syntax.node.injEq π Init.Core
(info : Lean.SourceInfo) (kind : Lean.SyntaxNodeKind) (args : Array Lean.Syntax) (infoβ : Lean.SourceInfo) (kindβ : Lean.SyntaxNodeKind) (argsβ : Array Lean.Syntax) : (Lean.Syntax.node info kind args = Lean.Syntax.node infoβ kindβ argsβ) = (info = infoβ β§ kind = kindβ β§ args = argsβ) - Lean.Syntax.ident.injEq π Init.Core
(info : Lean.SourceInfo) (rawVal : Substring) (val : Lean.Name) (preresolved : List Lean.Syntax.Preresolved) (infoβ : Lean.SourceInfo) (rawValβ : Substring) (valβ : Lean.Name) (preresolvedβ : List Lean.Syntax.Preresolved) : (Lean.Syntax.ident info rawVal val preresolved = Lean.Syntax.ident infoβ rawValβ valβ preresolvedβ) = (info = infoβ β§ rawVal = rawValβ β§ val = valβ β§ preresolved = preresolvedβ) - Lean.Module.header π Init.MetaTypes
(self : Lean.Module) : Lean.Syntax - Lean.Module.commands π Init.MetaTypes
(self : Lean.Module) : Array Lean.Syntax - Lean.Module.mk π Init.MetaTypes
(header : Lean.Syntax) (commands : Array Lean.Syntax) : Lean.Module - Lean.Module.mk.injEq π Init.MetaTypes
(header : Lean.Syntax) (commands : Array Lean.Syntax) (headerβ : Lean.Syntax) (commandsβ : Array Lean.Syntax) : ({ header := header, commands := commands } = { header := headerβ, commands := commandsβ }) = (header = headerβ β§ commands = commandsβ) - Lean.Module.mk.sizeOf_spec π Init.MetaTypes
(header : Lean.Syntax) (commands : Array Lean.Syntax) : sizeOf { header := header, commands := commands } = 1 + sizeOf header + sizeOf commands - Lean.Syntax.instGetElemNatTrue π Init.GetElem
: GetElem Lean.Syntax β Lean.Syntax fun x x => True - 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 - Lean.Syntax.getTailInfo π Init.Meta
(stx : Lean.Syntax) : Lean.SourceInfo - Lean.Syntax.getTrailingSize π Init.Meta
(stx : Lean.Syntax) : β - Lean.Syntax.hasArgs π Init.Meta
: Lean.Syntax β Bool - Lean.Syntax.instBEq π Init.Meta
: BEq Lean.Syntax - Lean.Syntax.instRepr π Init.Meta
: Repr Lean.Syntax - Lean.Syntax.isAtom π Init.Meta
: Lean.Syntax β Bool - Lean.Syntax.isNone π Init.Meta
(stx : Lean.Syntax) : Bool - Lean.Syntax.mkSynthetic π Init.Meta
(stx : Lean.Syntax) : Lean.Syntax - Lean.Syntax.toNat π Init.Meta
(stx : Lean.Syntax) : β - Lean.Syntax.unsetTrailing π Init.Meta
(stx : Lean.Syntax) : Lean.Syntax - Lean.evalPrec π Init.Meta
(stx : Lean.Syntax) : Lean.MacroM β - Lean.evalPrio π Init.Meta
(stx : Lean.Syntax) : Lean.MacroM β - Lean.mkOptionalNode π Init.Meta
(arg : Option Lean.Syntax) : Lean.Syntax - Lean.Syntax.copyHeadTailInfoFrom π Init.Meta
(target source : Lean.Syntax) : Lean.Syntax - Lean.Syntax.getHead? π Init.Meta
: Lean.Syntax β Option Lean.Syntax - Lean.Syntax.getOptionalIdent? π Init.Meta
(stx : Lean.Syntax) : Option Lean.Name - Lean.Syntax.getSepArgs π Init.Meta
(stx : Lean.Syntax) : Array Lean.Syntax - Lean.Syntax.getTailInfo? π Init.Meta
: Lean.Syntax β Option Lean.SourceInfo - Lean.Syntax.getTrailing? π Init.Meta
(stx : Lean.Syntax) : Option Substring - Lean.Syntax.isCharLit? π Init.Meta
(stx : Lean.Syntax) : Option Char - Lean.Syntax.isFieldIdx? π Init.Meta
(s : Lean.Syntax) : Option β - Lean.Syntax.isIdOrAtom? π Init.Meta
: Lean.Syntax β Option String - Lean.Syntax.isInterpolatedStrLit? π Init.Meta
(stx : Lean.Syntax) : Option String - Lean.Syntax.isNameLit? π Init.Meta
(stx : Lean.Syntax) : Option Lean.Name - Lean.Syntax.isNatLit? π Init.Meta
(s : Lean.Syntax) : Option β - Lean.Syntax.isStrLit? π Init.Meta
(stx : Lean.Syntax) : Option String - Lean.Syntax.isToken π Init.Meta
(token : String) : Lean.Syntax β Bool - Lean.Syntax.setHeadInfo π Init.Meta
(stx : Lean.Syntax) (info : Lean.SourceInfo) : Lean.Syntax - Lean.Syntax.setInfo π Init.Meta
(info : Lean.SourceInfo) : Lean.Syntax β Lean.Syntax - Lean.Syntax.setTailInfo π Init.Meta
(stx : Lean.Syntax) (info : Lean.SourceInfo) : Lean.Syntax - Lean.Syntax.structEq π Init.Meta
: Lean.Syntax β Lean.Syntax β Bool - Lean.Syntax.isLit? π Init.Meta
(litKind : Lean.SyntaxNodeKind) (stx : Lean.Syntax) : Option String - Lean.Syntax.mkSep π Init.Meta
(a : Array Lean.Syntax) (sep : Lean.Syntax) : Lean.Syntax - Lean.Syntax.setHeadInfoAux π Init.Meta
(info : Lean.SourceInfo) : Lean.Syntax β Option Lean.Syntax - Lean.Syntax.setTailInfoAux π Init.Meta
(info : Lean.SourceInfo) : Lean.Syntax β Option Lean.Syntax - Lean.mkHole π Init.Meta
(ref : Lean.Syntax) (canonical : Bool := false) : Lean.Syntax - Lean.mkSepArray π Init.Meta
(as : Array Lean.Syntax) (sep : Lean.Syntax) : Array Lean.Syntax - Lean.Syntax.find? π Init.Meta
(stx : Lean.Syntax) (p : Lean.Syntax β Bool) : Option Lean.Syntax - Lean.Syntax.findAux π Init.Meta
(p : Lean.Syntax β Bool) : Lean.Syntax β Option Lean.Syntax - Lean.Syntax.SepArray.getElems π Init.Meta
{sep : String} (sa : Lean.Syntax.SepArray sep) : Array Lean.Syntax - Lean.Syntax.SepArray.ofElems π Init.Meta
{sep : String} (elems : Array Lean.Syntax) : Lean.Syntax.SepArray sep - Lean.TSyntax.Compat.instCoeTailSyntax π Init.Meta
{k : Lean.SyntaxNodeKinds} : CoeTail Lean.Syntax (Lean.TSyntax k) - Array.filterSepElems π Init.Meta
(a : Array Lean.Syntax) (p : Lean.Syntax β Bool) : Array Lean.Syntax - Array.mapSepElems π Init.Meta
(a : Array Lean.Syntax) (f : Lean.Syntax β Lean.Syntax) : Array Lean.Syntax - Lean.mkCIdentFrom π Init.Meta
(src : Lean.Syntax) (c : Lean.Name) (canonical : Bool := false) : Lean.Ident - Lean.mkIdentFrom π Init.Meta
(src : Lean.Syntax) (val : Lean.Name) (canonical : Bool := false) : Lean.Ident - Lean.Syntax.getTrailingTailPos? π Init.Meta
(stx : Lean.Syntax) (canonicalOnly : Bool := false) : Option String.Pos - Lean.Syntax.instCoeArraySepArray π Init.Meta
{sep : String} : Coe (Array Lean.Syntax) (Lean.Syntax.SepArray sep) - Lean.Syntax.instCoeOutSepArrayArray π Init.Meta
{sep : String} : CoeOut (Lean.Syntax.SepArray sep) (Array Lean.Syntax) - Lean.Syntax.instCoeOutTSyntaxArrayArray π Init.Meta
{k : Lean.SyntaxNodeKinds} : CoeOut (Lean.TSyntaxArray k) (Array Lean.Syntax) - Lean.TSyntax.Compat.instCoeTailArraySyntaxTSyntaxArray π Init.Meta
{k : Lean.SyntaxNodeKinds} : CoeTail (Array Lean.Syntax) (Lean.TSyntaxArray k) - Lean.Syntax.isScientificLit? π Init.Meta
(stx : Lean.Syntax) : Option (β Γ Bool Γ β) - Lean.mkGroupNode π Init.Meta
(args : Array Lean.Syntax := #[]) : Lean.Syntax - Lean.TSyntax.Compat.instCoeTailArraySyntaxTSepArray π Init.Meta
{k : Lean.SyntaxNodeKinds} {sep : String} : CoeTail (Array Lean.Syntax) (Lean.Syntax.TSepArray k sep) - Lean.Syntax.getSubstring? π Init.Meta
(stx : Lean.Syntax) (withLeading withTrailing : Bool := true) : Option Substring - Lean.TSyntax.expandInterpolatedStrChunks π Init.Meta
(chunks : Array Lean.Syntax) (mkAppend : Lean.Syntax β Lean.Syntax β Lean.MacroM Lean.Syntax) (mkElem : Lean.Syntax β Lean.MacroM Lean.Syntax) : Lean.MacroM Lean.Syntax - Lean.Parser.Tactic.getConfigItems π Init.Meta
(c : Lean.Syntax) : Lean.TSyntaxArray `Lean.Parser.Tactic.configItem - Array.filterSepElemsM π Init.Meta
{m : Type β Type} [Monad m] (a : Array Lean.Syntax) (p : Lean.Syntax β m Bool) : m (Array Lean.Syntax) - Array.mapSepElemsM π Init.Meta
{m : Type β Type} [Monad m] (a : Array Lean.Syntax) (f : Lean.Syntax β m Lean.Syntax) : m (Array Lean.Syntax) - Lean.mkCIdentFromRef π Init.Meta
{m : Type β Type} [Monad m] [Lean.MonadRef m] (c : Lean.Name) (canonical : Bool := false) : m Lean.Syntax - Lean.Parser.Tactic.appendConfig π Init.Meta
(cfg cfg' : Lean.Syntax) : Lean.TSyntax `Lean.Parser.Tactic.optConfig - Lean.Syntax.SepArray.ofElemsUsingRef π Init.Meta
{m : Type β Type} [Monad m] [Lean.MonadRef m] {sep : String} (elems : Array Lean.Syntax) : m (Lean.Syntax.SepArray sep) - Lean.expandMacros π Init.Meta
(stx : Lean.Syntax) (p : Lean.SyntaxNodeKind β Bool := fun k => k != `Lean.Parser.Term.byTactic) : Lean.MacroM Lean.Syntax - Lean.expandBrackedBinders π Init.NotationExtra
(combinatorDeclName : Lean.Name) (bracketedExplicitBinders body : Lean.Syntax) : Lean.MacroM Lean.Syntax - Lean.expandExplicitBinders π Init.NotationExtra
(combinatorDeclName : Lean.Name) (explicitBinders body : Lean.Syntax) : Lean.MacroM Lean.Syntax - Lean.expandBrackedBindersAux π Init.NotationExtra
(combinator : Lean.Syntax) (binders : Array Lean.Syntax) (body : Lean.Syntax) : Lean.MacroM Lean.Syntax - Lean.expandExplicitBindersAux π Init.NotationExtra
(combinator : Lean.Syntax) (idents : Array Lean.Syntax) (type? : Option Lean.Syntax) (body : Lean.Syntax) : Lean.MacroM Lean.Syntax - Lean.expandBrackedBindersAux.loop π Init.NotationExtra
(combinator : Lean.Syntax) (binders : Array Lean.Syntax) (i : β) (h : i β€ binders.size) (acc : Lean.Syntax) : Lean.MacroM Lean.Syntax - Lean.expandExplicitBindersAux.loop π Init.NotationExtra
(combinator : Lean.Syntax) (idents : Array Lean.Syntax) (type? : Option Lean.Syntax) (i : β) (h : i β€ idents.size) (acc : Lean.Syntax) : Lean.MacroM Lean.Syntax - Lean.Syntax.instToFormat π Init.Data.Format.Syntax
: Std.ToFormat Lean.Syntax - Lean.Syntax.instToString π Init.Data.Format.Syntax
: ToString Lean.Syntax - 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 - Lean.KVMap.getSyntax π Lean.Data.KVMap
(m : Lean.KVMap) (k : Lean.Name) (defVal : Lean.Syntax := Lean.Syntax.missing) : Lean.Syntax - Lean.DataValue.ofSyntax.injEq π Lean.Data.KVMap
(v vβ : Lean.Syntax) : (Lean.DataValue.ofSyntax v = Lean.DataValue.ofSyntax vβ) = (v = vβ) - Lean.DataValue.ofSyntax.sizeOf_spec π Lean.Data.KVMap
(v : Lean.Syntax) : sizeOf (Lean.DataValue.ofSyntax v) = 1 + sizeOf v - Lean.Unhygienic.Context.ref π Lean.Hygiene
(self : Lean.Unhygienic.Context) : Lean.Syntax - Lean.Unhygienic.Context.mk π Lean.Hygiene
(ref : Lean.Syntax) (scope : Lean.MacroScope) : Lean.Unhygienic.Context - Lean.sanitizeSyntax π Lean.Hygiene
(stx : Lean.Syntax) : StateM Lean.NameSanitizerState Lean.Syntax - Lean.Unhygienic.Context.mk.injEq π Lean.Hygiene
(ref : Lean.Syntax) (scope : Lean.MacroScope) (refβ : Lean.Syntax) (scopeβ : Lean.MacroScope) : ({ ref := ref, scope := scope } = { ref := refβ, scope := scopeβ }) = (ref = refβ β§ scope = scopeβ) - Lean.Unhygienic.Context.mk.sizeOf_spec π Lean.Hygiene
(ref : Lean.Syntax) (scope : Lean.MacroScope) : sizeOf { ref := ref, scope := scope } = 1 + sizeOf ref + sizeOf scope - Lean.mkPatternWithRef π Lean.Expr
(p : Lean.Expr) (stx : Lean.Syntax) : Lean.Expr - Lean.patternWithRef? π Lean.Expr
(p : Lean.Expr) : Option (Lean.Syntax Γ Lean.Expr) - Lean.IsNode π Lean.Syntax
: Lean.Syntax β Prop - Lean.Syntax.asNode π Lean.Syntax
: Lean.Syntax β Lean.SyntaxNode - Lean.Syntax.getAntiquotSpliceSuffix π Lean.Syntax
(stx : Lean.Syntax) : Lean.Syntax - Lean.Syntax.getAntiquotSuffixSpliceInner π Lean.Syntax
(stx : Lean.Syntax) : Lean.Syntax - Lean.Syntax.getAntiquotTerm π Lean.Syntax
(stx : Lean.Syntax) : Lean.Syntax - Lean.Syntax.getAtomVal π Lean.Syntax
: Lean.Syntax β String - Lean.Syntax.getCanonicalAntiquot π Lean.Syntax
(stx : Lean.Syntax) : Lean.Syntax - Lean.Syntax.getQuotContent π Lean.Syntax
(stx : Lean.Syntax) : Lean.Syntax - Lean.Syntax.hasMissing π Lean.Syntax
(stx : Lean.Syntax) : Bool - Lean.Syntax.isAntiquot π Lean.Syntax
: Lean.Syntax β Bool - Lean.Syntax.isAntiquotSplice π Lean.Syntax
(stx : Lean.Syntax) : Bool - Lean.Syntax.isAntiquotSuffixSplice π Lean.Syntax
(stx : Lean.Syntax) : Bool - Lean.Syntax.isAntiquots π Lean.Syntax
(stx : Lean.Syntax) : Bool - Lean.Syntax.isAnyAntiquot π Lean.Syntax
(stx : Lean.Syntax) : Bool - Lean.Syntax.isEscapedAntiquot π Lean.Syntax
(stx : Lean.Syntax) : Bool - Lean.Syntax.isQuot π Lean.Syntax
: Lean.Syntax β Bool - Lean.Syntax.isTokenAntiquot π Lean.Syntax
(stx : Lean.Syntax) : Bool - Lean.Syntax.unescapeAntiquot π Lean.Syntax
(stx : Lean.Syntax) : Lean.Syntax - Lean.Syntax.updateLeading π Lean.Syntax
: Lean.Syntax β Lean.Syntax - Lean.Syntax.TopDown.stx π Lean.Syntax
(self : Lean.Syntax.TopDown) : Lean.Syntax - Lean.Syntax.Traverser.cur π Lean.Syntax
(self : Lean.Syntax.Traverser) : Lean.Syntax - Lean.Syntax.Traverser.fromSyntax π Lean.Syntax
(stx : Lean.Syntax) : Lean.Syntax.Traverser - Lean.mkListNode π Lean.Syntax
(args : Array Lean.Syntax) : Lean.Syntax - Lean.Syntax.antiquotSpliceKind? π Lean.Syntax
: Lean.Syntax β Option Lean.SyntaxNodeKind
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 ?a
If 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 ?b
By 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_tsum
even though the hypothesisf i < g i
is 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 19971e9
serving mathlib revision 5f22769