blob: 6351eb000d43e32ba882a94597280760557e95ec [file]
/-
Copyright (c) 2016 Microsoft Corporation. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Author: Leonardo de Moura, Mario Carneiro
-/
module
prelude
public import Init.Data.Char.Basic
public import Init.Data.ByteArray.Bootstrap
public section
namespace String
@[deprecated Pos.Raw (since := "2025-09-30")]
abbrev Pos := Pos.Raw
instance : OfNat String.Pos.Raw (nat_lit 0) where
ofNat := {}
instance : Inhabited String where
default := ""
/--
Adds a character to the end of a string.
The internal implementation uses dynamic arrays and will perform destructive updates
if the string is not shared.
Examples:
* `"abc".push 'd' = "abcd"`
* `"".push 'a' = "a"`
-/
@[extern "lean_string_push", expose]
def push : String → Char → String
| ⟨b, h⟩, c => ⟨b.append (List.utf8Encode [c]), ?pf⟩
where finally
have ⟨m, hm⟩ := h
cases hm
exact .intro (m ++ [c]) (by simp [List.utf8Encode, List.toByteArray_append'])
/--
Returns a new string that contains only the character `c`.
Because strings are encoded in UTF-8, the resulting string may take multiple bytes.
Examples:
* `String.singleton 'L' = "L"`
* `String.singleton ' ' = " "`
* `String.singleton '"' = "\""`
* `String.singleton '𝒫' = "𝒫"`
-/
@[inline, expose] def singleton (c : Char) : String :=
"".push c
end String
namespace String.Internal
@[extern "lean_string_posof"]
opaque posOf (s : String) (c : Char) : Pos.Raw
@[extern "lean_string_offsetofpos"]
opaque offsetOfPos (s : String) (pos : Pos.Raw) : Nat
@[extern "lean_string_utf8_extract"]
opaque extract : (@& String) → (@& Pos.Raw) → (@& Pos.Raw) → String
@[extern "lean_string_length"]
opaque length : (@& String) → Nat
@[extern "lean_string_pushn"]
opaque pushn (s : String) (c : Char) (n : Nat) : String
@[extern "lean_string_append"]
opaque append : String → (@& String) → String
@[extern "lean_string_utf8_next"]
opaque next (s : @& String) (p : @& Pos.Raw) : Pos.Raw
@[extern "lean_string_isempty"]
opaque isEmpty (s : String) : Bool
@[extern "lean_string_foldl"]
opaque foldl (f : String → Char → String) (init : String) (s : String) : String
@[extern "lean_string_isprefixof"]
opaque isPrefixOf (p : String) (s : String) : Bool
@[extern "lean_string_any"]
opaque any (s : String) (p : Char → Bool) : Bool
@[extern "lean_string_contains"]
opaque contains (s : String) (c : Char) : Bool
@[extern "lean_string_utf8_get"]
opaque get (s : @& String) (p : @& Pos.Raw) : Char
@[extern "lean_string_capitalize"]
opaque capitalize (s : String) : String
@[extern "lean_string_utf8_at_end"]
opaque atEnd : (@& String) → (@& Pos.Raw) → Bool
@[extern "lean_string_nextwhile"]
opaque nextWhile (s : String) (p : Char → Bool) (i : String.Pos.Raw) : String.Pos.Raw
@[extern "lean_string_trim"]
opaque trim (s : String) : String
@[extern "lean_string_intercalate"]
opaque intercalate (s : String) : List String → String
@[extern "lean_string_front"]
opaque front (s : String) : Char
@[extern "lean_string_drop"]
opaque drop (s : String) (n : Nat) : String
@[extern "lean_string_dropright"]
opaque dropRight (s : String) (n : Nat) : String
@[extern "lean_string_get_byte_fast"]
opaque getUTF8Byte (s : @& String) (n : Nat) (h : n < s.utf8ByteSize) : UInt8
end String.Internal
/--
Creates a string that contains the characters in a list, in order.
Examples:
* `['L', '∃', '∀', 'N'].asString = "L∃∀N"`
* `[].asString = ""`
* `['a', 'a', 'a'].asString = "aaa"`
-/
@[extern "lean_string_mk", expose]
def String.ofList (data : List Char) : String :=
⟨List.utf8Encode data,.intro data rfl⟩
@[extern "lean_string_mk", expose, deprecated String.ofList (since := "2025-10-30")]
def String.mk (data : List Char) : String :=
⟨List.utf8Encode data,.intro data rfl⟩
/--
Creates a string that contains the characters in a list, in order.
Examples:
* `['L', '∃', '∀', 'N'].asString = "L∃∀N"`
* `[].asString = ""`
* `['a', 'a', 'a'].asString = "aaa"`
-/
@[expose, inline, deprecated String.ofList (since := "2025-10-30")]
def List.asString (s : List Char) : String :=
String.ofList s
namespace Substring.Raw.Internal
@[extern "lean_substring_tostring"]
opaque toString : Substring.Raw → String
@[extern "lean_substring_drop"]
opaque drop : Substring.Raw → Nat → Substring.Raw
@[extern "lean_substring_front"]
opaque front (s : Substring.Raw) : Char
@[extern "lean_substring_takewhile"]
opaque takeWhile : Substring.Raw → (Char → Bool) → Substring.Raw
@[extern "lean_substring_extract"]
opaque extract : Substring.Raw → String.Pos.Raw → String.Pos.Raw → Substring.Raw
@[extern "lean_substring_all"]
opaque all (s : Substring.Raw) (p : Char → Bool) : Bool
@[extern "lean_substring_beq"]
opaque beq (ss1 ss2 : Substring.Raw) : Bool
@[extern "lean_substring_isempty"]
opaque isEmpty (ss : Substring.Raw) : Bool
@[extern "lean_substring_get"]
opaque get : Substring.Raw → String.Pos.Raw → Char
@[extern "lean_substring_prev"]
opaque prev : Substring.Raw → String.Pos.Raw → String.Pos.Raw
end Substring.Raw.Internal
namespace String.Pos.Raw.Internal
@[extern "lean_string_pos_sub"]
opaque sub : String.Pos.Raw → String.Pos.Raw → String.Pos.Raw
@[extern "lean_string_pos_min"]
opaque min (p₁ p₂ : Pos.Raw) : Pos.Raw
end String.Pos.Raw.Internal
namespace Char
/--
Constructs a singleton string that contains only the provided character.
Examples:
* `'L'.toString = "L"`
* `'"'.toString = "\""`
-/
@[inline, expose] protected def toString (c : Char) : String :=
String.singleton c
end Char