class ToString (α : Type u) : Type u

• toString : α → String

instance instToStringId {α : Type u_1} [ToString α] : ToString (id α)

instance instToStringId_1 {α : Type u_1} [ToString α] : ToString (Id α)

Equations

• instToStringId_1 = inferInstanceAs (ToString α)

instance instToStringString : ToString String

Equations

• instToStringString = { toString := fun (s : String) => s }

instance instToStringSubstring : ToString Substring

instance instToStringIterator : ToString String.Iterator

instance instToStringBool : ToString Bool

instance instToStringDecidable {p : Prop} : ToString (Decidable p)

Equations

• instToStringDecidable = { toString := fun (h : Decidable p) => match h with | isTrue h => "true" | isFalse h => "false" }

def List.toString {α : Type u_1} [ToString α] : List α → String

Equations

• [].toString = "[]"
• [x_1].toString = "[" ++ toString x_1 ++ "]"
• (x_1 :: xs).toString = (List.foldl (fun (x1 : String) (x2 : α) => x1 ++ ", " ++ toString x2) ("[" ++ toString x_1) xs).push ']'

instance instToStringList {α : Type u} [ToString α] : ToString (List α)

instance instToStringPUnit : ToString PUnit

Equations

• instToStringPUnit = { toString := fun (x : PUnit) => "()" }

instance instToStringULift {α : Type u} [ToString α] : ToString (ULift α)

instance instToStringUnit : ToString Unit

Equations

• instToStringUnit = { toString := fun (x : Unit) => "()" }

instance instToStringNat : ToString Nat

Equations

• instToStringNat = { toString := fun (n : Nat) => n.repr }

instance instToStringPos : ToString String.Pos

instance instToStringInt : ToString Int

Equations

• instToStringInt = { toString := fun (x : Int) => match x with | Int.ofNat m => toString m | Int.negSucc m => "-" ++ toString m.succ }

instance instToStringChar : ToString Char

Equations

• instToStringChar = { toString := fun (c : Char) => c.toString }

instance instToStringFin (n : Nat) : ToString (Fin n)

Equations

• instToStringFin n = { toString := fun (f : Fin n) => toString ↑f }

instance instToStringUInt8 : ToString UInt8

Equations

• instToStringUInt8 = { toString := fun (n : UInt8) => toString n.toNat }

instance instToStringUInt16 : ToString UInt16

instance instToStringUInt32 : ToString UInt32

Equations

• instToStringUInt32 = { toString := fun (n : UInt32) => toString n.toNat }

instance instToStringUInt64 : ToString UInt64

instance instToStringUSize : ToString USize

instance instToStringFormat : ToString Lean.Format

Equations

• instToStringFormat = { toString := fun (f : Lean.Format) => f.pretty }

def addParenHeuristic (s : String) : String

instance instToStringOption {α : Type u} [ToString α] : ToString (Option α)

Equations

• instToStringOption = { toString := fun (x : Option α) => match x with | none => "none" | some a => "(some " ++ addParenHeuristic (toString a) ++ ")" }

instance instToStringSum {α : Type u} {β : Type v} [ToString α] [ToString β] : ToString (α ⊕ β)

instance instToStringProd {α : Type u} {β : Type v} [ToString α] [ToString β] : ToString (α × β)

Equations

• instToStringProd = { toString := fun (x : α × β) => match x with | (a, b) => "(" ++ toString a ++ ", " ++ toString b ++ ")" }

instance instToStringSigma {α : Type u} {β : α → Type v} [ToString α] [(x : α) → ToString (β x)] : ToString (Sigma β)

Equations

• instToStringSigma = { toString := fun (x : Sigma β) => match x with | ⟨a, b⟩ => "⟨" ++ toString a ++ ", " ++ toString b ++ "⟩" }

instance instToStringSubtype {α : Type u} {p : α → Prop} [ToString α] : ToString (Subtype p)

Equations

• instToStringSubtype = { toString := fun (s : Subtype p) => toString s.val }

def String.toInt? (s : String) : Option Int

Equations

• s.toInt? = if s.get 0 = '-' then do let v ← (s.toSubstring.drop 1).toNat? pure (-Int.ofNat v) else Int.ofNat <$> s.toNat?

def String.isInt (s : String) : Bool

Equations

• s.isInt = if s.get 0 = '-' then (s.toSubstring.drop 1).isNat else s.isNat

def String.toInt! (s : String) : Int

instance instToStringExcept {ε : Type u_1} {α : Type u_2} [ToString ε] [ToString α] : ToString (Except ε α)

Equations

• instToStringExcept = { toString := fun (x : Except ε α) => match x with | Except.error e => "error: " ++ toString e | Except.ok a => "ok: " ++ toString a }

instance instReprExcept {ε : Type u_1} {α : Type u_2} [Repr ε] [Repr α] : Repr (Except ε α)