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

full_name: dbgTrace
code: @[never_extract, extern "lean_dbg_trace"]
def dbgTrace {α : Type u} (s : String) (f : Unit → α) : α 
goal: α

full_name: dbgTraceVal
code: def dbgTraceVal {α : Type u} [ToString α] (a : α) : α 
goal: α

full_name: dbgTraceIfShared
code: /-- Display the given message if `a` is shared, that is, RC(a) > 1 -/
@[never_extract, extern "lean_dbg_trace_if_shared"]
def dbgTraceIfShared {α : Type u} (s : String) (a : α) : α 
goal: α

full_name: dbgStackTrace
code: /-- Print stack trace to stderr before evaluating given closure. Currently supported on Linux only. -/
@[never_extract, extern "lean_dbg_stack_trace"]
def dbgStackTrace {α : Type u} (f : Unit → α) : α 
goal: α

full_name: dbgSleep
code: @[extern "lean_dbg_sleep"]
def dbgSleep {α : Type u} (ms : UInt32) (f : Unit → α) : α 
goal: α

full_name: _private.«.lake».packages.lean4.src.lean.Init.Util.0.mkPanicMessage
code: @[noinline] private def mkPanicMessage (modName : String) (line col : Nat) (msg : String) : String 
goal: String

full_name: panicWithPos
code: @[never_extract, inline] def panicWithPos {α : Type u} [Inhabited α] (modName : String) (line col : Nat) (msg : String) : α 
goal: α

full_name: _private.«.lake».packages.lean4.src.lean.Init.Util.0.mkPanicMessageWithDecl
code: @[noinline] private def mkPanicMessageWithDecl (modName : String) (declName : String) (line col : Nat) (msg : String) : String 
goal: String

full_name: panicWithPosWithDecl
code: @[never_extract, inline] def panicWithPosWithDecl {α : Type u} [Inhabited α] (modName : String) (declName : String) (line col : Nat) (msg : String) : α 
goal: α

full_name: ptrAddrUnsafe
code: @[extern "lean_ptr_addr"]
unsafe opaque ptrAddrUnsafe {α : Type u} (a : @& α) : USize
goal: USize

full_name: withPtrAddrUnsafe
code: @[inline] unsafe def withPtrAddrUnsafe {α : Type u} {β : Type v} (a : α) (k : USize → β) (h : ∀ u₁ u₂, k u₁ = k u₂) : β 
goal: β

full_name: ptrEq
code: @[inline] unsafe def ptrEq (a b : α) : Bool 
goal: Bool

full_name: ptrEqList
code: unsafe def ptrEqList : (as bs : List α) → Bool
  
goal: Bool

full_name: withPtrEqUnsafe
code: @[inline] unsafe def withPtrEqUnsafe {α : Type u} (a b : α) (k : Unit → Bool) (h : a = b → k () = true) : Bool 
goal: Bool

full_name: withPtrEq
code: @[implemented_by withPtrEqUnsafe]
def withPtrEq {α : Type u} (a b : α) (k : Unit → Bool) (h : a = b → k () = true) : Bool 
goal: Bool

full_name: withPtrEqDecEq
code: /-- `withPtrEq` for `DecidableEq` -/
@[inline] def withPtrEqDecEq {α : Type u} (a b : α) (k : Unit → Decidable (a = b)) : Decidable (a = b) 
goal: Decidable (a = b)

full_name: withPtrAddr
code: @[implemented_by withPtrAddrUnsafe]
def withPtrAddr {α : Type u} {β : Type v} (a : α) (k : USize → β) (h : ∀ u₁ u₂, k u₁ = k u₂) : β 
goal: β

full_name: Runtime.markMultiThreaded
code: /--
  Marks given value and its object graph closure as multi-threaded if currently
  marked single-threaded. This will make reference counter updates atomic and
  thus more costly. It can still be useful to do eagerly when the value will be
  shared between threads later anyway and there is available time budget to mark
  it now. -/
@[extern "lean_runtime_mark_multi_threaded"]
def Runtime.markMultiThreaded (a : α) : α 
goal: α

full_name: Runtime.markPersistent
code: /--
  Marks given value and its object graph closure as persistent. This will remove
  reference counter updates but prevent the closure from being deallocated until
  the end of the process! It can still be useful to do eagerly when the value
  will be marked persistent later anyway and there is available time budget to
  mark it now or it would be unnecessarily marked multi-threaded in between. -/
@[extern "lean_runtime_mark_persistent"]
def Runtime.markPersistent (a : α) : α 
goal: α