File: .lake/packages/lean4/src/lean/Init/NotationExtra.lean

full_name: Lean.unbracketedExplicitBinders
code: syntax unbracketedExplicitBinders := (ppSpace binderIdent)+ (" : " term)?
goal: Lean.ParserDescr

full_name: Lean.bracketedExplicitBinders
code: syntax bracketedExplicitBinders   := "(" withoutPosition((binderIdent ppSpace)+ ": " term) ")"
goal: Lean.ParserDescr

full_name: Lean.explicitBinders
code: syntax explicitBinders            := (ppSpace bracketedExplicitBinders)+ <|> unbracketedExplicitBinders
goal: Lean.ParserDescr

full_name: Lean.expandExplicitBindersAux
code: def expandExplicitBindersAux (combinator : Syntax) (idents : Array Syntax) (type? : Option Syntax) (body : Syntax) : MacroM Syntax 
goal: Lean.MacroM Lean.Syntax

full_name: Lean.expandExplicitBindersAux.loop
code: def expandExplicitBindersAux (combinator : Syntax) (idents : Array Syntax) (type? : Option Syntax) (body : Syntax) : MacroM Syntax 
goal: Lean.MacroM Lean.Syntax

full_name: Lean.expandBrackedBindersAux
code: def expandBrackedBindersAux (combinator : Syntax) (binders : Array Syntax) (body : Syntax) : MacroM Syntax 
goal: Lean.MacroM Lean.Syntax

full_name: Lean.expandBrackedBindersAux.loop
code: def expandBrackedBindersAux (combinator : Syntax) (binders : Array Syntax) (body : Syntax) : MacroM Syntax 
goal: Lean.MacroM Lean.Syntax

full_name: Lean.expandExplicitBinders
code: def expandExplicitBinders (combinatorDeclName : Name) (explicitBinders : Syntax) (body : Syntax) : MacroM Syntax 
goal: Lean.MacroM Lean.Syntax

full_name: Lean.expandBrackedBinders
code: def expandBrackedBinders (combinatorDeclName : Name) (bracketedExplicitBinders : Syntax) (body : Syntax) : MacroM Syntax 
goal: Lean.MacroM Lean.Syntax

full_name: Lean.unifConstraint
code: syntax unifConstraint := term patternIgnore(" =?= " <|> " ≟ ") term
goal: Lean.ParserDescr

full_name: Lean.unifConstraintElem
code: syntax unifConstraintElem := colGe unifConstraint ", "?
goal: Lean.ParserDescr

full_name: Lean.«command__Unif_hint____Where_|_-⊢_»
code: syntax (docComment)? attrKind "unif_hint" (ppSpace ident)? (ppSpace bracketedBinder)*
  " where " withPosition(unifConstraintElem*) patternIgnore(atomic("|" noWs "-") <|> "⊢") unifConstraint : command
goal: Lean.ParserDescr

full_name: Lean.«_aux_.lake_packages_lean4_src_lean_Init_NotationExtra___macroRules_Lean_command__Unif_hint____Where_|_-⊢__1»
code: macro_rules
  | `($[$doc?:docComment]? $kind:attrKind unif_hint $(n)? $bs* where $[$cs₁ ≟ $cs₂]* |- $t₁ ≟ $t₂) => do
    let mut body ← `($t₁ = $t₂)
    for (c₁, c₂) in cs₁.zip cs₂ |>.reverse do
      body ← `($c₁ = $c₂ → $body)
    let hint : Ident ← `(hint)
    `($[$doc?:docComment]? @[$kind unification_hint] def $(n.getD hint) $bs* : Sort _ := $body)
goal: Lean.Macro

full_name: «_aux_.lake_packages_lean4_src_lean_Init_NotationExtra___macroRules_term∃_,__1»
code: macro "∃" xs:explicitBinders ", " b:term : term => expandExplicitBinders ``Exists xs b
goal: Lean.Macro

full_name: «term∃_,_»
code: macro "∃" xs:explicitBinders ", " b:term : term => expandExplicitBinders ``Exists xs b
goal: Lean.ParserDescr

full_name: «termExists_,_»
code: macro "exists" xs:explicitBinders ", " b:term : term => expandExplicitBinders ``Exists xs b
goal: Lean.ParserDescr

full_name: «_aux_.lake_packages_lean4_src_lean_Init_NotationExtra___macroRules_termExists_,__1»
code: macro "exists" xs:explicitBinders ", " b:term : term => expandExplicitBinders ``Exists xs b
goal: Lean.Macro

full_name: «_aux_.lake_packages_lean4_src_lean_Init_NotationExtra___macroRules_termΣ_,__1»
code: macro "Σ" xs:explicitBinders ", " b:term : term => expandExplicitBinders ``Sigma xs b
goal: Lean.Macro

full_name: «termΣ_,_»
code: macro "Σ" xs:explicitBinders ", " b:term : term => expandExplicitBinders ``Sigma xs b
goal: Lean.ParserDescr

full_name: «_aux_.lake_packages_lean4_src_lean_Init_NotationExtra___macroRules_termΣ'_,__1»
code: macro "Σ'" xs:explicitBinders ", " b:term : term => expandExplicitBinders ``PSigma xs b
goal: Lean.Macro

full_name: «termΣ'_,_»
code: macro "Σ'" xs:explicitBinders ", " b:term : term => expandExplicitBinders ``PSigma xs b
goal: Lean.ParserDescr

full_name: «term_×__1»
code: macro:35 xs:bracketedExplicitBinders " × " b:term:35  : term => expandBrackedBinders ``Sigma xs b
goal: Lean.ParserDescr

full_name: «_aux_.lake_packages_lean4_src_lean_Init_NotationExtra___macroRules_term_×__1_1»
code: macro:35 xs:bracketedExplicitBinders " × " b:term:35  : term => expandBrackedBinders ``Sigma xs b
goal: Lean.Macro

full_name: «_aux_.lake_packages_lean4_src_lean_Init_NotationExtra___macroRules_term_×'__1»
code: macro:35 xs:bracketedExplicitBinders " ×' " b:term:35 : term => expandBrackedBinders ``PSigma xs b
goal: Lean.Macro

full_name: «term_×'_»
code: macro:35 xs:bracketedExplicitBinders " ×' " b:term:35 : term => expandBrackedBinders ``PSigma xs b
goal: Lean.ParserDescr

full_name: Lean.calcFirstStep
code: syntax calcFirstStep := ppIndent(colGe term (" := " term)?)
goal: Lean.ParserDescr

full_name: Lean.calcStep
code: syntax calcStep := ppIndent(colGe term " := " term)
goal: Lean.ParserDescr

full_name: Lean.calcSteps
code: syntax calcSteps := ppLine withPosition(calcFirstStep) withPosition((ppLine linebreak calcStep)*)
goal: Lean.ParserDescr

full_name: Lean.calc
code: /-- Step-wise reasoning over transitive relations.
```
calc
  a = b := pab
  b = c := pbc
  ...
  y = z := pyz
```
proves `a = z` from the given step-wise proofs. `=` can be replaced with any
relation implementing the typeclass `Trans`. Instead of repeating the right-
hand sides, subsequent left-hand sides can be replaced with `_`.
```
calc
  a = b := pab
  _ = c := pbc
  ...
  _ = z := pyz
```
It is also possible to write the *first* relation as `<lhs>\n  _ = <rhs> :=
<proof>`. This is useful for aligning relation symbols, especially on longer:
identifiers:
```
calc abc
  _ = bce := pabce
  _ = cef := pbcef
  ...
  _ = xyz := pwxyz
```

`calc` works as a term, as a tactic or as a `conv` tactic.

See [Theorem Proving in Lean 4][tpil4] for more information.

[tpil4]: https://lean-lang.org/theorem_proving_in_lean4/quantifiers_and_equality.html#calculational-proofs
-/
syntax (name := calc) "calc" calcSteps : term
goal: Lean.ParserDescr

full_name: Lean.calcTactic
code: @[inherit_doc «calc»]
syntax (name := calcTactic) "calc" calcSteps : tactic
goal: Lean.ParserDescr

full_name: Lean.convCalc_
code: macro tk:"calc" steps:calcSteps : conv =>
  `(conv| tactic => calc%$tk $steps)
goal: Lean.ParserDescr

full_name: Lean.«_aux_.lake_packages_lean4_src_lean_Init_NotationExtra___macroRules_Lean_convCalc__1»
code: macro tk:"calc" steps:calcSteps : conv =>
  `(conv| tactic => calc%$tk $steps)
goal: Lean.Macro

full_name: unexpandUnit
code: @[app_unexpander Unit.unit] def unexpandUnit : Lean.PrettyPrinter.Unexpander
  
goal: Lean.PrettyPrinter.Unexpander

full_name: unexpandListNil
code: @[app_unexpander List.nil] def unexpandListNil : Lean.PrettyPrinter.Unexpander
  
goal: Lean.PrettyPrinter.Unexpander

full_name: unexpandListCons
code: @[app_unexpander List.cons] def unexpandListCons : Lean.PrettyPrinter.Unexpander
  
goal: Lean.PrettyPrinter.Unexpander

full_name: unexpandListToArray
code: @[app_unexpander List.toArray] def unexpandListToArray : Lean.PrettyPrinter.Unexpander
  
goal: Lean.PrettyPrinter.Unexpander

full_name: unexpandProdMk
code: @[app_unexpander Prod.mk] def unexpandProdMk : Lean.PrettyPrinter.Unexpander
  
goal: Lean.PrettyPrinter.Unexpander

full_name: unexpandIte
code: @[app_unexpander ite] def unexpandIte : Lean.PrettyPrinter.Unexpander
  
goal: Lean.PrettyPrinter.Unexpander

full_name: unexpandSorryAx
code: @[app_unexpander sorryAx] def unexpandSorryAx : Lean.PrettyPrinter.Unexpander
  
goal: Lean.PrettyPrinter.Unexpander

full_name: unexpandEqNDRec
code: @[app_unexpander Eq.ndrec] def unexpandEqNDRec : Lean.PrettyPrinter.Unexpander
  
goal: Lean.PrettyPrinter.Unexpander

full_name: unexpandEqRec
code: @[app_unexpander Eq.rec] def unexpandEqRec : Lean.PrettyPrinter.Unexpander
  
goal: Lean.PrettyPrinter.Unexpander

full_name: unexpandExists
code: @[app_unexpander Exists] def unexpandExists : Lean.PrettyPrinter.Unexpander
  
goal: Lean.PrettyPrinter.Unexpander

full_name: unexpandSigma
code: @[app_unexpander Sigma] def unexpandSigma : Lean.PrettyPrinter.Unexpander
  
goal: Lean.PrettyPrinter.Unexpander

full_name: unexpandPSigma
code: @[app_unexpander PSigma] def unexpandPSigma : Lean.PrettyPrinter.Unexpander
  
goal: Lean.PrettyPrinter.Unexpander

full_name: unexpandSubtype
code: @[app_unexpander Subtype] def unexpandSubtype : Lean.PrettyPrinter.Unexpander
  
goal: Lean.PrettyPrinter.Unexpander

full_name: unexpandTSyntax
code: @[app_unexpander TSyntax] def unexpandTSyntax : Lean.PrettyPrinter.Unexpander
  
goal: Lean.PrettyPrinter.Unexpander

full_name: unexpandTSyntaxArray
code: @[app_unexpander TSyntaxArray] def unexpandTSyntaxArray : Lean.PrettyPrinter.Unexpander
  
goal: Lean.PrettyPrinter.Unexpander

full_name: unexpandTSepArray
code: @[app_unexpander Syntax.TSepArray] def unexpandTSepArray : Lean.PrettyPrinter.Unexpander
  
goal: Lean.PrettyPrinter.Unexpander

full_name: unexpandGetElem
code: @[app_unexpander GetElem.getElem] def unexpandGetElem : Lean.PrettyPrinter.Unexpander
  
goal: Lean.PrettyPrinter.Unexpander

full_name: unexpandGetElem!
code: @[app_unexpander getElem!] def unexpandGetElem! : Lean.PrettyPrinter.Unexpander
  
goal: Lean.PrettyPrinter.Unexpander

full_name: unexpandGetElem?
code: @[app_unexpander getElem?] def unexpandGetElem? : Lean.PrettyPrinter.Unexpander
  
goal: Lean.PrettyPrinter.Unexpander

full_name: unexpandMkStr1
code: @[app_unexpander Name.mkStr1] def unexpandMkStr1 : Lean.PrettyPrinter.Unexpander
  
goal: Lean.PrettyPrinter.Unexpander

full_name: unexpandMkStr2
code: @[app_unexpander Name.mkStr2] def unexpandMkStr2 : Lean.PrettyPrinter.Unexpander
  
goal: Lean.PrettyPrinter.Unexpander

full_name: unexpandMkStr3
code: @[app_unexpander Name.mkStr3] def unexpandMkStr3 : Lean.PrettyPrinter.Unexpander
  
goal: Lean.PrettyPrinter.Unexpander

full_name: unexpandMkStr4
code: @[app_unexpander Name.mkStr4] def unexpandMkStr4 : Lean.PrettyPrinter.Unexpander
  
goal: Lean.PrettyPrinter.Unexpander

full_name: unexpandMkStr5
code: @[app_unexpander Name.mkStr5] def unexpandMkStr5 : Lean.PrettyPrinter.Unexpander
  
goal: Lean.PrettyPrinter.Unexpander

full_name: unexpandMkStr6
code: @[app_unexpander Name.mkStr6] def unexpandMkStr6 : Lean.PrettyPrinter.Unexpander
  
goal: Lean.PrettyPrinter.Unexpander

full_name: unexpandMkStr7
code: @[app_unexpander Name.mkStr7] def unexpandMkStr7 : Lean.PrettyPrinter.Unexpander
  
goal: Lean.PrettyPrinter.Unexpander

full_name: unexpandMkStr8
code: @[app_unexpander Name.mkStr8] def unexpandMkStr8 : Lean.PrettyPrinter.Unexpander
  
goal: Lean.PrettyPrinter.Unexpander

full_name: unexpandArrayEmpty
code: @[app_unexpander Array.empty] def unexpandArrayEmpty : Lean.PrettyPrinter.Unexpander
  
goal: Lean.PrettyPrinter.Unexpander

full_name: unexpandMkArray0
code: @[app_unexpander Array.mkArray0] def unexpandMkArray0 : Lean.PrettyPrinter.Unexpander
  
goal: Lean.PrettyPrinter.Unexpander

full_name: unexpandMkArray1
code: @[app_unexpander Array.mkArray1] def unexpandMkArray1 : Lean.PrettyPrinter.Unexpander
  
goal: Lean.PrettyPrinter.Unexpander

full_name: unexpandMkArray2
code: @[app_unexpander Array.mkArray2] def unexpandMkArray2 : Lean.PrettyPrinter.Unexpander
  
goal: Lean.PrettyPrinter.Unexpander

full_name: unexpandMkArray3
code: @[app_unexpander Array.mkArray3] def unexpandMkArray3 : Lean.PrettyPrinter.Unexpander
  
goal: Lean.PrettyPrinter.Unexpander

full_name: unexpandMkArray4
code: @[app_unexpander Array.mkArray4] def unexpandMkArray4 : Lean.PrettyPrinter.Unexpander
  
goal: Lean.PrettyPrinter.Unexpander

full_name: unexpandMkArray5
code: @[app_unexpander Array.mkArray5] def unexpandMkArray5 : Lean.PrettyPrinter.Unexpander
  
goal: Lean.PrettyPrinter.Unexpander

full_name: unexpandMkArray6
code: @[app_unexpander Array.mkArray6] def unexpandMkArray6 : Lean.PrettyPrinter.Unexpander
  
goal: Lean.PrettyPrinter.Unexpander

full_name: unexpandMkArray7
code: @[app_unexpander Array.mkArray7] def unexpandMkArray7 : Lean.PrettyPrinter.Unexpander
  
goal: Lean.PrettyPrinter.Unexpander

full_name: unexpandMkArray8
code: @[app_unexpander Array.mkArray8] def unexpandMkArray8 : Lean.PrettyPrinter.Unexpander
  
goal: Lean.PrettyPrinter.Unexpander

full_name: tacticFunext___
code: /--
Apply function extensionality and introduce new hypotheses.
The tactic `funext` will keep applying the `funext` lemma until the goal target is not reducible to
```
  |-  ((fun x => ...) = (fun x => ...))
```
The variant `funext h₁ ... hₙ` applies `funext` `n` times, and uses the given identifiers to name the new hypotheses.
Patterns can be used like in the `intro` tactic. Example, given a goal
```
  |-  ((fun x : Nat × Bool => ...) = (fun x => ...))
```
`funext (a, b)` applies `funext` once and performs pattern matching on the newly introduced pair.
-/
syntax "funext" (ppSpace colGt term:max)* : tactic
goal: Lean.ParserDescr

full_name: «_aux_.lake_packages_lean4_src_lean_Init_NotationExtra___macroRules_tacticFunext____1»
code: macro_rules
  | `(tactic|funext) => `(tactic| repeat (apply funext; intro))
  | `(tactic|funext $x) => `(tactic| apply funext; intro $x:term)
  | `(tactic|funext $x $xs*) => `(tactic| apply funext; intro $x:term; funext $xs*)
goal: Lean.Macro

full_name: «_aux_.lake_packages_lean4_src_lean_Init_NotationExtra___macroRules_term%[_|_]_1»
code: macro_rules
  | `(%[ $[$x],* | $k ]) =>
    if x.size < 8 then
      x.foldrM (β := Term) (init := k) fun x k =>
        `(List.cons $x $k)
    else
      let m := x.size / 2
      let y := x[m:]
      let z := x[:m]
      `(let y := %[ $[$y],* | $k ]
        %[ $[$z],* | y ])
goal: Lean.Macro

full_name: Lean.Parser.Command.classAbbrev
code: /--
  Expands
  ```
  class abbrev C <params> := D_1, ..., D_n
  ```
  into
  ```
  class C <params> extends D_1, ..., D_n
  attribute [instance] C.mk
  ```
-/
syntax (name := Lean.Parser.Command.classAbbrev)
  declModifiers "class " "abbrev " declId bracketedBinder* (":" term)?
  ":=" withPosition(group(colGe term ","?)*) : command
goal: Lean.ParserDescr

full_name: «_aux_.lake_packages_lean4_src_lean_Init_NotationExtra___macroRules_Lean_Parser_Command_classAbbrev_1»
code: macro_rules
  | `($mods:declModifiers class abbrev $id $params* $[: $ty]? := $[ $parents $[,]? ]*) =>
    let ctor := mkIdentFrom id <| id.raw[0].getId.modifyBase (. ++ `mk)
    `($mods:declModifiers class $id $params* extends $parents,* $[: $ty]?
      attribute [instance] $ctor)
goal: Lean.Macro

full_name: «_aux_.lake_packages_lean4_src_lean_Init_NotationExtra___macroRules_Lean_Parser_Term_haveI_1»
code: macro_rules
  | `(haveI $hy:hygieneInfo $bs* $[: $ty]? := $val; $body) =>
    `(haveI $(HygieneInfo.mkIdent hy `this (canonical := true)) $bs* $[: $ty]? := $val; $body)
  | `(haveI _ $bs* := $val; $body) => `(haveI x $bs* : _ := $val; $body)
  | `(haveI _ $bs* : $ty := $val; $body) => `(haveI x $bs* : $ty := $val; $body)
  | `(haveI $x:ident $bs* := $val; $body) => `(haveI $x $bs* : _ := $val; $body)
  | `(haveI $_:ident $_* : $_ := $_; $_) => Lean.Macro.throwUnsupported
goal: Lean.Macro

full_name: «_aux_.lake_packages_lean4_src_lean_Init_NotationExtra___macroRules_Lean_Parser_Term_letI_1»
code: macro_rules
  | `(letI $hy:hygieneInfo $bs* $[: $ty]? := $val; $body) =>
    `(letI $(HygieneInfo.mkIdent hy `this (canonical := true)) $bs* $[: $ty]? := $val; $body)
  | `(letI _ $bs* := $val; $body) => `(letI x $bs* : _ := $val; $body)
  | `(letI _ $bs* : $ty := $val; $body) => `(letI x $bs* : $ty := $val; $body)
  | `(letI $x:ident $bs* := $val; $body) => `(letI $x $bs* : _ := $val; $body)
  | `(letI $_:ident $_* : $_ := $_; $_) => Lean.Macro.throwUnsupported
goal: Lean.Macro

full_name: Lean.cdotTk
code: syntax cdotTk := patternIgnore("· " <|> ". ")
goal: Lean.ParserDescr

full_name: Lean.cdot
code: /-- `· tac` focuses on the main goal and tries to solve it using `tac`, or else fails. -/
syntax (name := cdot) cdotTk tacticSeqIndentGt : tactic
goal: Lean.ParserDescr

full_name: Lean.solveTactic
code: /--
  Similar to `first`, but succeeds only if one the given tactics solves the current goal.
-/
syntax (name := solveTactic) "solve" withPosition((ppDedent(ppLine) colGe "| " tacticSeq)+) : tactic
goal: Lean.ParserDescr

full_name: Lean.«_aux_.lake_packages_lean4_src_lean_Init_NotationExtra___macroRules_Lean_solveTactic_1»
code: macro_rules
  | `(tactic| solve $[| $ts]* ) => `(tactic| focus first $[| ($ts); done]*)
goal: Lean.Macro

full_name: Lean.Loop
code: inductive Loop where
  | mk
goal: Type

full_name: Lean.Loop.mk
code: inductive Loop where
  | mk
goal: Lean.Loop

full_name: Lean.Loop.forIn.loop
code: @[inline]
partial def Loop.forIn {β : Type u} {m : Type u → Type v} [Monad m] (_ : Loop) (init : β) (f : Unit → β → m (ForInStep β)) : m β 
goal: m β

full_name: Lean.Loop.forIn
code: @[inline]
partial def Loop.forIn {β : Type u} {m : Type u → Type v} [Monad m] (_ : Loop) (init : β) (f : Unit → β → m (ForInStep β)) : m β 
goal: Lean.Loop → β → (Unit → β → m (ForInStep β)) → m β

full_name: Lean.instForInLoopUnit
code: instance : ForIn m Loop Unit 
goal: ForIn m Lean.Loop Unit

full_name: Lean.doElemRepeat_
code: syntax "repeat " doSeq : doElem
goal: Lean.ParserDescr

full_name: Lean.«_aux_.lake_packages_lean4_src_lean_Init_NotationExtra___macroRules_Lean_doElemRepeat__1»
code: macro_rules
  | `(doElem| repeat $seq) => `(doElem| for _ in Loop.mk do $seq)
goal: Lean.Macro

full_name: Lean.«doElemWhile_:_Do_»
code: syntax "while " ident " : " termBeforeDo " do " doSeq : doElem
goal: Lean.ParserDescr

full_name: Lean.«_aux_.lake_packages_lean4_src_lean_Init_NotationExtra___macroRules_Lean_doElemWhile_:_Do__1»
code: macro_rules
  | `(doElem| while $h : $cond do $seq) => `(doElem| repeat if $h : $cond then $seq else break)
goal: Lean.Macro

full_name: Lean.doElemWhile_Do_
code: syntax "while " termBeforeDo " do " doSeq : doElem
goal: Lean.ParserDescr

full_name: Lean.«_aux_.lake_packages_lean4_src_lean_Init_NotationExtra___macroRules_Lean_doElemWhile_Do__1»
code: macro_rules
  | `(doElem| while $cond do $seq) => `(doElem| repeat if $cond then $seq else break)
goal: Lean.Macro

full_name: Lean.doElemRepeat__Until_
code: syntax "repeat " doSeq ppDedent(ppLine) "until " term : doElem
goal: Lean.ParserDescr

full_name: Lean.«_aux_.lake_packages_lean4_src_lean_Init_NotationExtra___macroRules_Lean_doElemRepeat__Until__1»
code: macro_rules
  | `(doElem| repeat $seq until $cond) => `(doElem| repeat do $seq:doSeq; if $cond then break)
goal: Lean.Macro

full_name: Lean.«term_Matches_|»
code: macro:50 e:term:51 " matches " p:sepBy1(term:51, " | ") : term =>
  `(((match $e:term with | $[$p:term]|* => true | _ => false) : Bool))
goal: Lean.TrailingParserDescr

full_name: Lean.«_aux_.lake_packages_lean4_src_lean_Init_NotationExtra___macroRules_Lean_term_Matches_|_1»
code: macro:50 e:term:51 " matches " p:sepBy1(term:51, " | ") : term =>
  `(((match $e:term with | $[$p:term]|* => true | _ => false) : Bool))
goal: Lean.Macro

full_name: «term{_}»
code: syntax "{" term,+ "}" : term
goal: Lean.ParserDescr

full_name: «_aux_.lake_packages_lean4_src_lean_Init_NotationExtra___macroRules_term{_}_1»
code: macro_rules
  | `({$x:term}) => `(singleton $x)
  | `({$x:term, $xs:term,*}) => `(insert $x {$xs:term,*})
goal: Lean.Macro

full_name: Lean.singletonUnexpander
code: /-- Unexpander for the `{ x }` notation. -/
@[app_unexpander singleton]
def singletonUnexpander : Lean.PrettyPrinter.Unexpander
  
goal: Lean.PrettyPrinter.Unexpander

full_name: Lean.insertUnexpander
code: /-- Unexpander for the `{ x, y, ... }` notation. -/
@[app_unexpander insert]
def insertUnexpander : Lean.PrettyPrinter.Unexpander
  
goal: Lean.PrettyPrinter.Unexpander