ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
File: .lake/packages/batteries/Batteries/Classes/RatCast.lean

full_name: RatCast.ratCast
code: /-- Type class for the canonical homomorphism `Rat → K`. -/
class RatCast (K : Type u) where
  /-- The canonical homomorphism `Rat → K`. -/
  protected ratCast : Rat → K
goal: Rat → K

full_name: RatCast
code: /-- Type class for the canonical homomorphism `Rat → K`. -/
class RatCast (K : Type u) where
  /-- The canonical homomorphism `Rat → K`. -/
  protected ratCast : Rat → K
goal: Type u

full_name: instRatCastRat
code: instance : RatCast Rat 
goal: RatCast Rat

full_name: Rat.cast
code: /-- Canonical homomorphism from `Rat` to a division ring `K`.
This is just the bare function in order to aid in creating instances of `DivisionRing`. -/
@[coe, reducible, match_pattern] protected def Rat.cast {K : Type u} [RatCast K] : Rat → K 
goal: Rat → K

full_name: instCoeTailRatOfRatCast
code: instance [RatCast K] : CoeTail Rat K 
goal: CoeTail Rat K

full_name: instCoeHTCTRatOfRatCast
code: instance [RatCast K] : CoeHTCT Rat K 
goal: CoeHTCT Rat K
File: .lake/packages/batteries/Batteries/Tactic/Lint/TypeClass.lean

full_name: Std.Tactic.Lint.impossibleInstance
code: /--
Lints for instances with arguments that cannot be filled in, like
```
instance {α β : Type} [Group α] : Mul α where ...
```
-/
@[env_linter] def impossibleInstance : Linter 
goal: Std.Tactic.Lint.Linter

full_name: Std.Tactic.Lint.nonClassInstance
code: /--
A linter for checking if any declaration whose type is not a class is marked as an instance.
-/
@[env_linter] def nonClassInstance : Linter 
goal: Std.Tactic.Lint.Linter
File: .lake/packages/batteries/Batteries/Tactic/Exact.lean

full_name: Lean.MVarId.assignIfDefeq
code: /--
`MetaM` version of `Lean.Elab.Tactic.evalExact`: add `mvarId := x` to the metavariable assignment.
This method wraps `Lean.MVarId.assign`, checking whether `mvarId` is already assigned, and whether
the expression has the right type. -/
def Lean.MVarId.assignIfDefeq (g : MVarId) (e : Expr) : MetaM Unit 
goal: Lean.MetaM Unit
File: .lake/packages/batteries/Batteries/Tactic/Unreachable.lean

full_name: Batteries.Tactic.unreachable
code: /--
This tactic causes a panic when run (at compile time).
(This is distinct from `exact unreachable!`, which inserts code which will panic at run time.)

It is intended for tests to assert that a tactic will never be executed, which is otherwise an
unusual thing to do (and the `unreachableTactic` linter will give a warning if you do).

The `unreachableTactic` linter has a special exception for uses of `unreachable!`.
```
example : True := by trivial <;> unreachable!
```
-/
elab (name := unreachable) "unreachable!" : tactic => do
  panic! "unreachable tactic has been reached"
  -- Note that `panic!` does not actually halt execution or early exit,
  -- so we still have to throw an error after panicking.
  throwError "unreachable tactic has been reached"
goal: Lean.ParserDescr

full_name: Batteries.Tactic.«_aux_.lake_packages_batteries_Batteries_Tactic_Unreachable___elabRules_Batteries_Tactic_unreachable_1»
code: /--
This tactic causes a panic when run (at compile time).
(This is distinct from `exact unreachable!`, which inserts code which will panic at run time.)

It is intended for tests to assert that a tactic will never be executed, which is otherwise an
unusual thing to do (and the `unreachableTactic` linter will give a warning if you do).

The `unreachableTactic` linter has a special exception for uses of `unreachable!`.
```
example : True := by trivial <;> unreachable!
```
-/
elab (name := unreachable) "unreachable!" : tactic => do
  panic! "unreachable tactic has been reached"
  -- Note that `panic!` does not actually halt execution or early exit,
  -- so we still have to throw an error after panicking.
  throwError "unreachable tactic has been reached"
goal: Lean.Elab.Tactic.Tactic

full_name: Batteries.Tactic.«_aux_.lake_packages_batteries_Batteries_Tactic_Unreachable___macroRules_Batteries_Tactic_unreachableConv_1»
code: macro (name := unreachableConv) "unreachable!" : conv =>
  `(conv| tactic' => unreachable!)
goal: Lean.Macro

full_name: Batteries.Tactic.unreachableConv
code: macro (name := unreachableConv) "unreachable!" : conv =>
  `(conv| tactic' => unreachable!)
goal: Lean.ParserDescr
File: .lake/packages/batteries/Batteries/Tactic/Where.lean

full_name: _private.«.lake».packages.batteries.Batteries.Tactic.Where.0.Batteries.Tactic.Where.describeOpenDecls
code: private def describeOpenDecls (ds : List OpenDecl) : MessageData 
goal: Lean.MessageData

full_name: _private.«.lake».packages.batteries.Batteries.Tactic.Where.0.Batteries.Tactic.Where.describeOptions
code: private def describeOptions (opts : Options) : CommandElabM (Option MessageData) 
goal: Lean.Elab.Command.CommandElabM (Option Lean.MessageData)

full_name: Batteries.Tactic.Where.«command#where»
code: /-- `#where` gives a description of the global scope at this point in the module.
This includes the namespace, `open` namespaces, `universe` and `variable` commands,
and options set with `set_option`. -/
elab "#where" : command => do
  let scope ← getScope
  let mut msg : Array MessageData := #[]
  -- Noncomputable
  if scope.isNoncomputable then
    msg := msg.push m!"noncomputable section"
  -- Namespace
  if !scope.currNamespace.isAnonymous then
    msg := msg.push m!"namespace {scope.currNamespace}"
  -- Open namespaces
  if !scope.openDecls.isEmpty then
    msg := msg.push <| describeOpenDecls scope.openDecls.reverse
  -- Universe levels
  if !scope.levelNames.isEmpty then
    let levels := scope.levelNames.reverse.map toMessageData
    msg := msg.push <| "universe " ++ MessageData.joinSep levels " "
  -- Variables
  if !scope.varDecls.isEmpty then
    msg := msg.push <| ← `(command| variable $scope.varDecls*)
  -- Options
  if let some m ← describeOptions scope.opts then
    msg := msg.push m
  if msg.isEmpty then
    msg := #[m!"-- In root namespace with initial scope"]
  logInfo <| m!"{MessageData.joinSep msg.toList "\n\n"}"
goal: Lean.ParserDescr

full_name: Batteries.Tactic.Where.«_aux_.lake_packages_batteries_Batteries_Tactic_Where___elabRules_Batteries_Tactic_Where_command#where_1»
code: /-- `#where` gives a description of the global scope at this point in the module.
This includes the namespace, `open` namespaces, `universe` and `variable` commands,
and options set with `set_option`. -/
elab "#where" : command => do
  let scope ← getScope
  let mut msg : Array MessageData := #[]
  -- Noncomputable
  if scope.isNoncomputable then
    msg := msg.push m!"noncomputable section"
  -- Namespace
  if !scope.currNamespace.isAnonymous then
    msg := msg.push m!"namespace {scope.currNamespace}"
  -- Open namespaces
  if !scope.openDecls.isEmpty then
    msg := msg.push <| describeOpenDecls scope.openDecls.reverse
  -- Universe levels
  if !scope.levelNames.isEmpty then
    let levels := scope.levelNames.reverse.map toMessageData
    msg := msg.push <| "universe " ++ MessageData.joinSep levels " "
  -- Variables
  if !scope.varDecls.isEmpty then
    msg := msg.push <| ← `(command| variable $scope.varDecls*)
  -- Options
  if let some m ← describeOptions scope.opts then
    msg := msg.push m
  if msg.isEmpty then
    msg := #[m!"-- In root namespace with initial scope"]
  logInfo <| m!"{MessageData.joinSep msg.toList "\n\n"}"
goal: Lean.Elab.Command.CommandElab
File: .lake/packages/batteries/Batteries/Tactic/SeqFocus.lean

full_name: Batteries.Tactic.«_aux_.lake_packages_batteries_Batteries_Tactic_SeqFocus___elabRules_Batteries_Tactic_tacticMap_tacs[_;]_1»
code: /-- Assuming there are `n` goals, `map_tacs [t1; t2; ...; tn]` applies each `ti` to the respective
goal and leaves the resulting subgoals. -/
elab "map_tacs " "[" ts:sepBy(tactic, "; ") "]" : tactic => do
  let goals ← getUnsolvedGoals
  let tacs := ts.getElems
  let length := tacs.size
  if length < goals.length then
    throwError "not enough tactics"
  else if length > goals.length then
    throwError "too many tactics"
  let mut goalsNew := #[]
  for tac in tacs, goal in goals do
    if ← goal.isAssigned then continue
    setGoals [goal]
    try
      evalTactic tac
      goalsNew := goalsNew ++ (← getUnsolvedGoals)
    catch ex =>
      if (← read).recover then
        logException ex
        goalsNew := goalsNew.push goal
      else
        throw ex
  setGoals goalsNew.toList
goal: Lean.Elab.Tactic.Tactic

full_name: Batteries.Tactic.«tacticMap_tacs[_;]»
code: /-- Assuming there are `n` goals, `map_tacs [t1; t2; ...; tn]` applies each `ti` to the respective
goal and leaves the resulting subgoals. -/
elab "map_tacs " "[" ts:sepBy(tactic, "; ") "]" : tactic => do
  let goals ← getUnsolvedGoals
  let tacs := ts.getElems
  let length := tacs.size
  if length < goals.length then
    throwError "not enough tactics"
  else if length > goals.length then
    throwError "too many tactics"
  let mut goalsNew := #[]
  for tac in tacs, goal in goals do
    if ← goal.isAssigned then continue
    setGoals [goal]
    try
      evalTactic tac
      goalsNew := goalsNew ++ (← getUnsolvedGoals)
    catch ex =>
      if (← read).recover then
        logException ex
        goalsNew := goalsNew.push goal
      else
        throw ex
  setGoals goalsNew.toList
goal: Lean.ParserDescr

full_name: Batteries.Tactic.seq_focus
code: macro:1 (name := seq_focus) t:tactic " <;> " "[" ts:sepBy(tactic, "; ") "]" : tactic =>
  `(tactic| focus ( $t:tactic; map_tacs [$ts;*]) )
goal: Lean.TrailingParserDescr

full_name: Batteries.Tactic.«_aux_.lake_packages_batteries_Batteries_Tactic_SeqFocus___macroRules_Batteries_Tactic_seq_focus_1»
code: macro:1 (name := seq_focus) t:tactic " <;> " "[" ts:sepBy(tactic, "; ") "]" : tactic =>
  `(tactic| focus ( $t:tactic; map_tacs [$ts;*]) )
goal: Lean.Macro
File: .lake/packages/batteries/Batteries/Tactic/Classical.lean

full_name: Batteries.Tactic.classical
code: /--
`classical t` runs `t` in a scope where `Classical.propDecidable` is a low priority
local instance.
-/
def classical [Monad m] [MonadEnv m] [MonadFinally m] [MonadLiftT MetaM m] (t : m α) :
    m α 
goal: m α

full_name: Batteries.Tactic.«_aux_.lake_packages_batteries_Batteries_Tactic_Classical___elabRules_Batteries_Tactic_tacticClassical!_1»
code: /-- `classical!` has been removed; use `classical` instead -/
-- Deprecated 2024-04-19
elab "classical!" : tactic => do
  throwError "`classical!` has been removed; use `classical` instead"
goal: Lean.Elab.Tactic.Tactic

full_name: Batteries.Tactic.tacticClassical!
code: /-- `classical!` has been removed; use `classical` instead -/
-- Deprecated 2024-04-19
elab "classical!" : tactic => do
  throwError "`classical!` has been removed; use `classical` instead"
goal: Lean.ParserDescr

full_name: Batteries.Tactic.«_aux_.lake_packages_batteries_Batteries_Tactic_Classical___elabRules_Batteries_Tactic_tacticClassical__1»
code: /--
`classical tacs` runs `tacs` in a scope where `Classical.propDecidable` is a low priority
local instance.

Note that (unlike lean 3) `classical` is a scoping tactic - it adds the instance only within the
scope of the tactic.
-/
-- FIXME: using ppDedent looks good in the common case, but produces the incorrect result when
-- the `classical` does not scope over the rest of the block.
elab "classical" tacs:ppDedent(tacticSeq) : tactic => do
  classical <| Elab.Tactic.evalTactic tacs
goal: Lean.Elab.Tactic.Tactic

full_name: Batteries.Tactic.tacticClassical_
code: /--
`classical tacs` runs `tacs` in a scope where `Classical.propDecidable` is a low priority
local instance.

Note that (unlike lean 3) `classical` is a scoping tactic - it adds the instance only within the
scope of the tactic.
-/
-- FIXME: using ppDedent looks good in the common case, but produces the incorrect result when
-- the `classical` does not scope over the rest of the block.
elab "classical" tacs:ppDedent(tacticSeq) : tactic => do
  classical <| Elab.Tactic.evalTactic tacs
goal: Lean.ParserDescr
File: .lake/packages/batteries/Batteries/Util/ProofWanted.lean

full_name: proof_wanted
code: /-- This proof would be a welcome contribution to the library!

The syntax of `proof_wanted` declarations is just like that of `theorem`, but without `:=` or the
proof. Lean checks that `proof_wanted` declarations are well-formed (e.g. it ensures that all the
mentioned names are in scope, and that the theorem statement is a valid proposition), but they are
discarded afterwards. This means that they cannot be used as axioms.

Typical usage:
```
@[simp] proof_wanted empty_find? [BEq α] [Hashable α] {a : α} :
    (∅ : HashMap α β).find? a = none
```
-/
@[command_parser]
def «proof_wanted» 
goal: Lean.Parser.Parser

full_name: elabProofWanted
code: /-- Elaborate a `proof_wanted` declaration. The declaration is translated to an axiom during
elaboration, but it's then removed from the environment.
-/
@[command_elab «proof_wanted»]
def elabProofWanted : CommandElab
  
goal: Lean.Elab.Command.CommandElab
File: .lake/packages/batteries/Batteries/Lean/Except.lean

full_name: Except.emoji
code: /-- Visualize an `Except` using a checkmark or a cross. -/
def Except.emoji : Except ε α → String
  
goal: Except ε α → String
File: .lake/packages/batteries/Batteries/Lean/Syntax.lean

full_name: Lean.TSyntax.replaceM
code: /--
Applies the given function to every subsyntax.

Like `Syntax.replaceM` but for typed syntax.
(Note there are no guarantees of type correctness here.)
-/
def TSyntax.replaceM [Monad M] (f : Syntax → M (Option Syntax)) (stx : TSyntax k) : M (TSyntax k) 
goal: M (Lean.TSyntax k)
File: .lake/packages/batteries/Batteries/CodeAction/Deprecated.lean

full_name: Std.machineApplicableDeprecated
code: /-- An environment extension for identifying `@[deprecated]` definitions which can be auto-fixed -/
initialize machineApplicableDeprecated : TagDeclarationExtension ← mkTagDeclarationExtension
goal: Lean.TagDeclarationExtension

full_name: Std.initFn._@..lake.packages.batteries.Batteries.CodeAction.Deprecated._hyg.6
code: /-- An environment extension for identifying `@[deprecated]` definitions which can be auto-fixed -/
initialize machineApplicableDeprecated : TagDeclarationExtension ← mkTagDeclarationExtension
goal: IO Lean.TagDeclarationExtension

full_name: Std.CodeAction.deprecatedCodeActionProvider
code: /-- A code action which applies replacements for `@[deprecated]` definitions. -/
@[code_action_provider]
def deprecatedCodeActionProvider : CodeActionProvider 
goal: Lean.Server.CodeActionProvider
File: .lake/packages/batteries/Batteries/Util/LibraryNote.lean

full_name: Batteries.Util.LibraryNote.LibraryNoteEntry
code: /-- A library note consists of a (short) tag and a (long) note. -/
def LibraryNoteEntry 
goal: Type

full_name: Batteries.Util.LibraryNote.libraryNoteExt
code: /-- Environment extension supporting `library_note`. -/
initialize libraryNoteExt : SimplePersistentEnvExtension LibraryNoteEntry (Array LibraryNoteEntry) ←
  registerSimplePersistentEnvExtension {
    addEntryFn := Array.push
    addImportedFn := Array.concatMap id
  }
goal: Lean.SimplePersistentEnvExtension Batteries.Util.LibraryNote.LibraryNoteEntry
  (Array Batteries.Util.LibraryNote.LibraryNoteEntry)

full_name: Batteries.Util.LibraryNote.initFn._@..lake.packages.batteries.Batteries.Util.LibraryNote._hyg.14
code: /-- Environment extension supporting `library_note`. -/
initialize libraryNoteExt : SimplePersistentEnvExtension LibraryNoteEntry (Array LibraryNoteEntry) ←
  registerSimplePersistentEnvExtension {
    addEntryFn := Array.push
    addImportedFn := Array.concatMap id
  }
goal: IO
  (Lean.SimplePersistentEnvExtension Batteries.Util.LibraryNote.LibraryNoteEntry
    (Array Batteries.Util.LibraryNote.LibraryNoteEntry))

full_name: Batteries.Util.LibraryNote.commandLibrary_note___
code: /--
```
library_note "some tag" /--
... some explanation ...
-/
```
creates a new "library note", which can then be cross-referenced using
```
-- See note [some tag]
```
in doc-comments.
-/
elab "library_note " title:strLit ppSpace text:docComment : command => do
  modifyEnv (libraryNoteExt.addEntry · (title.getString, text.getDocString))
goal: Lean.ParserDescr

full_name: Batteries.Util.LibraryNote.«_aux_.lake_packages_batteries_Batteries_Util_LibraryNote___elabRules_Batteries_Util_LibraryNote_commandLibrary_note____1»
code: /--
```
library_note "some tag" /--
... some explanation ...
-/
```
creates a new "library note", which can then be cross-referenced using
```
-- See note [some tag]
```
in doc-comments.
-/
elab "library_note " title:strLit ppSpace text:docComment : command => do
  modifyEnv (libraryNoteExt.addEntry · (title.getString, text.getDocString))
goal: Lean.Elab.Command.CommandElab
File: .lake/packages/batteries/Batteries/Util/ExtendedBinder.lean

full_name: Batteries.ExtendedBinder.extBinder
code: /--
An extended binder has the form `x`, `x : ty`, or `x pred`
where `pred` is a `binderPred` like `< 2`.
-/
syntax extBinder := binderIdent ((" : " term) <|> binderPred)?
goal: Lean.ParserDescr

full_name: Batteries.ExtendedBinder.extBinderParenthesized
code: /-- A extended binder in parentheses -/
syntax extBinderParenthesized := " (" extBinder ")"
goal: Lean.ParserDescr

full_name: Batteries.ExtendedBinder.extBinderCollection
code: /-- A list of parenthesized binders -/
syntax extBinderCollection := extBinderParenthesized*
goal: Lean.ParserDescr

full_name: Batteries.ExtendedBinder.extBinders
code: /-- A single (unparenthesized) binder, or a list of parenthesized binders -/
syntax extBinders := (ppSpace extBinder) <|> extBinderCollection
goal: Lean.ParserDescr

full_name: Batteries.ExtendedBinder.«term∃ᵉ_,_»
code: /-- The syntax `∃ᵉ (x < 2) (y < 3), p x y` is shorthand for `∃ x < 2, ∃ y < 3, p x y`. -/
syntax "∃ᵉ" extBinders ", " term : term
goal: Lean.ParserDescr

full_name: Batteries.ExtendedBinder.«_aux_.lake_packages_batteries_Batteries_Util_ExtendedBinder___macroRules_Batteries_ExtendedBinder_term∃ᵉ_,__1»
code: macro_rules
  | `(∃ᵉ, $b) => pure b
  | `(∃ᵉ ($p:extBinder) $[($ps:extBinder)]*, $b) =>
    `(∃ᵉ $p:extBinder, ∃ᵉ $[($ps:extBinder)]*, $b)
goal: Lean.Macro

full_name: Batteries.ExtendedBinder.«_aux_.lake_packages_batteries_Batteries_Util_ExtendedBinder___macroRules_Batteries_ExtendedBinder_term∃ᵉ_,__2»
code: macro_rules -- TODO: merging the two macro_rules breaks expansion
  | `(∃ᵉ $x:binderIdent, $b) => `(∃ $x:binderIdent, $b)
  | `(∃ᵉ $x:binderIdent : $ty:term, $b) => `(∃ $x:binderIdent : $ty:term, $b)
  | `(∃ᵉ $x:binderIdent $p:binderPred, $b) => `(∃ $x:binderIdent $p:binderPred, $b)
goal: Lean.Macro

full_name: Batteries.ExtendedBinder.«term∀ᵉ_,_»
code: /-- The syntax `∀ᵉ (x < 2) (y < 3), p x y` is shorthand for `∀ x < 2, ∀ y < 3, p x y`. -/
syntax "∀ᵉ" extBinders ", " term : term
goal: Lean.ParserDescr

full_name: Batteries.ExtendedBinder.«_aux_.lake_packages_batteries_Batteries_Util_ExtendedBinder___macroRules_Batteries_ExtendedBinder_term∀ᵉ_,__1»
code: macro_rules
  | `(∀ᵉ, $b) => pure b
  | `(∀ᵉ ($p:extBinder) $[($ps:extBinder)]*, $b) =>
    `(∀ᵉ $p:extBinder, ∀ᵉ $[($ps:extBinder)]*, $b)
goal: Lean.Macro

full_name: Batteries.ExtendedBinder.«_aux_.lake_packages_batteries_Batteries_Util_ExtendedBinder___macroRules_Batteries_ExtendedBinder_term∀ᵉ_,__2»
code: macro_rules -- TODO: merging the two macro_rules breaks expansion
  | `(∀ᵉ _, $b) => `(∀ _, $b)
  | `(∀ᵉ $x:ident, $b) => `(∀ $x:ident, $b)
  | `(∀ᵉ _ : $ty:term, $b) => `(∀ _ : $ty:term, $b)
  | `(∀ᵉ $x:ident : $ty:term, $b) => `(∀ $x:ident : $ty:term, $b)
  | `(∀ᵉ $x:binderIdent $p:binderPred, $b) => `(∀ $x:binderIdent $p:binderPred, $b)
goal: Lean.Macro
File: .lake/packages/batteries/Batteries/Lean/MonadBacktrack.lean

full_name: Lean.withoutModifyingState'
code: /--
Execute the action `x`, then restore the initial state. Returns the state after
`x` finished.
-/
def withoutModifyingState' [Monad m] [MonadBacktrack s m] [MonadFinally m]
    (x : m α) : m (α × s) 
goal: m (α × s)
File: .lake/packages/batteries/Batteries/Lean/TagAttribute.lean

full_name: Lean.TagAttribute.getDecls.core
code: /-- Get the list of declarations tagged with the tag attribute `attr`. -/
def Lean.TagAttribute.getDecls (attr : TagAttribute) (env : Environment) : Array Name 
goal: Array Lean.Name

full_name: Lean.TagAttribute.getDecls
code: /-- Get the list of declarations tagged with the tag attribute `attr`. -/
def Lean.TagAttribute.getDecls (attr : TagAttribute) (env : Environment) : Array Name 
goal: Array Lean.Name
File: .lake/packages/batteries/Batteries/Lean/PersistentHashSet.lean

full_name: Lean.PersistentHashSet.«instForIn_.lake»
code: instance : ForIn m (PersistentHashSet α) α 
goal: ForIn m (Lean.PersistentHashSet α) α

full_name: Lean.PersistentHashSet.anyM
code: /--
Returns `true` if `f` returns `true` for any element of the set.
-/
@[specialize]
def anyM [Monad m] (s : PersistentHashSet α) (f : α → m Bool) : m Bool 
goal: m Bool

full_name: Lean.PersistentHashSet.any
code: /--
Returns `true` if `f` returns `true` for any element of the set.
-/
@[inline]
def any (s : PersistentHashSet α) (f : α → Bool) : Bool 
goal: Bool

full_name: Lean.PersistentHashSet.allM
code: /--
Returns `true` if `f` returns `true` for all elements of the set.
-/
@[specialize]
def allM [Monad m] (s : PersistentHashSet α) (f : α → m Bool) : m Bool 
goal: m Bool

full_name: Lean.PersistentHashSet.all
code: /--
Returns `true` if `f` returns `true` for all elements of the set.
-/
@[inline]
def all (s : PersistentHashSet α) (f : α → Bool) : Bool 
goal: Bool

full_name: Lean.PersistentHashSet.«instBEq_.lake»
code: instance : BEq (PersistentHashSet α) 
goal: BEq (Lean.PersistentHashSet α)

full_name: Lean.PersistentHashSet.insertMany
code: /--
Insert all elements from a collection into a `PersistentHashSet`.
-/
def insertMany [ForIn Id ρ α] (s : PersistentHashSet α) (as : ρ) :
    PersistentHashSet α 
goal: Lean.PersistentHashSet α

full_name: Lean.PersistentHashSet.ofArray
code: /--
Obtain a `PersistentHashSet` from an array.
-/
@[inline]
protected def ofArray [BEq α] [Hashable α] (as : Array α) : PersistentHashSet α 
goal: Lean.PersistentHashSet α

full_name: Lean.PersistentHashSet.ofList
code: /--
Obtain a `PersistentHashSet` from a list.
-/
@[inline]
protected def ofList [BEq α] [Hashable α] (as : List α) : PersistentHashSet α 
goal: Lean.PersistentHashSet α

full_name: Lean.PersistentHashSet.merge
code: /--
Merge two `PersistentHashSet`s.
-/
@[inline]
def merge (s t : PersistentHashSet α) : PersistentHashSet α 
goal: Lean.PersistentHashSet α
File: .lake/packages/batteries/Batteries/Lean/HashSet.lean

full_name: Lean.HashSet.«instSingleton_.lake»
code: instance : Singleton α (HashSet α) 
goal: Singleton α (Lean.HashSet α)

full_name: Lean.HashSet.«instInsert_.lake»
code: instance : Insert α (HashSet α) 
goal: Insert α (Lean.HashSet α)

full_name: Lean.HashSet.anyM
code: /--
`O(n)`. Returns `true` if `f` returns `true` for any element of the set.
-/
@[specialize]
def anyM [Monad m] (s : HashSet α) (f : α → m Bool) : m Bool 
goal: m Bool

full_name: Lean.HashSet.any
code: /--
`O(n)`. Returns `true` if `f` returns `true` for any element of the set.
-/
@[inline]
def any (s : HashSet α) (f : α → Bool) : Bool 
goal: Bool

full_name: Lean.HashSet.allM
code: /--
`O(n)`. Returns `true` if `f` returns `true` for all elements of the set.
-/
@[specialize]
def allM [Monad m] (s : HashSet α) (f : α → m Bool) : m Bool 
goal: m Bool

full_name: Lean.HashSet.all
code: /--
`O(n)`. Returns `true` if `f` returns `true` for all elements of the set.
-/
@[inline]
def all (s : HashSet α) (f : α → Bool) : Bool 
goal: Bool

full_name: Lean.HashSet.«instBEq_.lake»
code: instance : BEq (HashSet α) 
goal: BEq (Lean.HashSet α)

full_name: Lean.HashSet.insert'
code: /--
`O(1)` amortized. Similar to `insert`, but also returns a Boolean flag indicating whether an
existing entry has been replaced with `a => b`.
-/
@[inline]
def insert' (s : HashSet α) (a : α) : HashSet α × Bool 
goal: Lean.HashSet α × Bool

full_name: Lean.HashSet.ofArray
code: /--
`O(n)`. Obtain a `HashSet` from an array.
-/
@[inline]
protected def ofArray [BEq α] [Hashable α] (as : Array α) : HashSet α 
goal: Lean.HashSet α

full_name: Lean.HashSet.ofList
code: /--
`O(n)`. Obtain a `HashSet` from a list.
-/
@[inline]
protected def ofList [BEq α] [Hashable α] (as : List α) : HashSet α 
goal: Lean.HashSet α