Debugging helper functions

@[never_extract, extern lean_dbg_trace]

def dbgTrace {α : Type u} (s : String) (f : Unit → α) : α

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

@[never_extract, extern lean_dbg_trace_if_shared]

def dbgTraceIfShared {α : Type u} (s : String) (a : α) : α

Display the given message if a is shared, that is, RC(a) > 1

@[never_extract, extern lean_dbg_stack_trace]

def dbgStackTrace {α : Type u} (f : Unit → α) : α

Print stack trace to stderr before evaluating given closure. Currently supported on Linux only.

@[extern lean_dbg_sleep]

def dbgSleep {α : Type u} (ms : UInt32) (f : Unit → α) : α

@[never_extract, inline]

def panicWithPos {α : Sort u} [Inhabited α] (modName : String) (line col : Nat) (msg : String) : α

@[never_extract, inline]

def panicWithPosWithDecl {α : Sort u} [Inhabited α] (modName declName : String) (line col : Nat) (msg : String) : α

@[extern lean_ptr_addr]

unsafe opaque ptrAddrUnsafe {α : Type u} (a : α) : USize

Returns the address at which an object is allocated.

This function is unsafe because it can distinguish between definitionally equal values.

@[extern lean_is_exclusive_obj]

unsafe opaque isExclusiveUnsafe {α : Type u} (a : α) : Bool

Returns true if a is an exclusive object.

An object is exclusive if it is single-threaded and its reference counter is 1. This function is unsafe because it can distinguish between definitionally equal values.

@[inline]

unsafe def withPtrAddrUnsafe {α : Type u} {β : Type v} (a : α) (k : USize → β) (h : ∀ (u₁ u₂ : USize), k u₁ = k u₂) : β

@[inline]

unsafe def ptrEq {α : Type u_1} (a b : α) : Bool

Compares two objects for pointer equality.

Two objects are pointer-equal if, at runtime, they are allocated at exactly the same address. This function is unsafe because it can distinguish between definitionally equal values.

unsafe def ptrEqList {α : Type u_1} (as bs : List α) : Bool

Compares two lists of objects for element-wise pointer equality. Returns true if both lists are the same length and the objects at the corresponding indices of each list are pointer-equal.

Two objects are pointer-equal if, at runtime, they are allocated at exactly the same address. This function is unsafe because it can distinguish between definitionally equal values.

@[inline]

unsafe def withPtrEqUnsafe {α : Type u} (a b : α) (k : Unit → Bool) (h : a = b → k () = true) : Bool

@[implemented_by withPtrEqUnsafe]

def withPtrEq {α : Type u} (a b : α) (k : Unit → Bool) (h : a = b → k () = true) : Bool

@[inline]

def withPtrEqDecEq {α : Type u} (a b : α) (k : Unit → Decidable (a = b)) : Decidable (a = b)

withPtrEq for DecidableEq

@[implemented_by withPtrAddrUnsafe]

def withPtrAddr {α : Type u} {β : Type v} (a : α) (k : USize → β) (h : ∀ (u₁ u₂ : USize), k u₁ = k u₂) : β