// Generated by Lisette bindgen
// Source: strings (Go stdlib)
// Go: 1.25.5
// Lisette: 0.1.14
import "go:io"
import "go:iter"
import "go:unicode"
/// Clone returns a fresh copy of s.
/// It guarantees to make a copy of s into a new allocation,
/// which can be important when retaining only a small substring
/// of a much larger string. Using Clone can help such programs
/// use less memory. Of course, since using Clone makes a copy,
/// overuse of Clone can make programs use more memory.
/// Clone should typically be used only rarely, and only when
/// profiling indicates that it is needed.
/// For strings of length zero the string "" will be returned
/// and no allocation is made.
pub fn Clone(s: string) -> string
/// Compare returns an integer comparing two strings lexicographically.
/// The result will be 0 if a == b, -1 if a < b, and +1 if a > b.
///
/// Use Compare when you need to perform a three-way comparison (with
/// [slices.SortFunc], for example). It is usually clearer and always faster
/// to use the built-in string comparison operators ==, <, >, and so on.
pub fn Compare(a: string, b: string) -> int
/// Contains reports whether substr is within s.
pub fn Contains(s: string, substr: string) -> bool
/// ContainsAny reports whether any Unicode code points in chars are within s.
pub fn ContainsAny(s: string, chars: string) -> bool
/// ContainsFunc reports whether any Unicode code points r within s satisfy f(r).
pub fn ContainsFunc(s: string, f: fn(int32) -> bool) -> bool
/// ContainsRune reports whether the Unicode code point r is within s.
pub fn ContainsRune(s: string, r: int32) -> bool
/// Count counts the number of non-overlapping instances of substr in s.
/// If substr is an empty string, Count returns 1 + the number of Unicode code points in s.
pub fn Count(s: string, substr: string) -> int
/// Cut slices s around the first instance of sep,
/// returning the text before and after sep.
/// The found result reports whether sep appears in s.
/// If sep does not appear in s, cut returns s, "", false.
pub fn Cut(s: string, sep: string) -> Option<(string, string)>
/// CutPrefix returns s without the provided leading prefix string
/// and reports whether it found the prefix.
/// If s doesn't start with prefix, CutPrefix returns s, false.
/// If prefix is the empty string, CutPrefix returns s, true.
pub fn CutPrefix(s: string, prefix: string) -> Option<string>
/// CutSuffix returns s without the provided ending suffix string
/// and reports whether it found the suffix.
/// If s doesn't end with suffix, CutSuffix returns s, false.
/// If suffix is the empty string, CutSuffix returns s, true.
pub fn CutSuffix(s: string, suffix: string) -> Option<string>
/// EqualFold reports whether s and t, interpreted as UTF-8 strings,
/// are equal under simple Unicode case-folding, which is a more general
/// form of case-insensitivity.
pub fn EqualFold(s: string, t: string) -> bool
/// Fields splits the string s around each instance of one or more consecutive white space
/// characters, as defined by [unicode.IsSpace], returning a slice of substrings of s or an
/// empty slice if s contains only white space. Every element of the returned slice is
/// non-empty. Unlike [Split], leading and trailing runs runs of white space characters
/// are discarded.
pub fn Fields(s: string) -> Slice<string>
/// FieldsFunc splits the string s at each run of Unicode code points c satisfying f(c)
/// and returns an array of slices of s. If all code points in s satisfy f(c) or the
/// string is empty, an empty slice is returned. Every element of the returned slice is
/// non-empty. Unlike [SplitFunc], leading and trailing runs of code points satisfying f(c)
/// are discarded.
///
/// FieldsFunc makes no guarantees about the order in which it calls f(c)
/// and assumes that f always returns the same value for a given c.
pub fn FieldsFunc(s: string, f: fn(int32) -> bool) -> Slice<string>
/// FieldsFuncSeq returns an iterator over substrings of s split around runs of
/// Unicode code points satisfying f(c).
/// The iterator yields the same strings that would be returned by [FieldsFunc](s),
/// but without constructing the slice.
pub fn FieldsFuncSeq(s: string, f: fn(int32) -> bool) -> iter.Seq<string>
/// FieldsSeq returns an iterator over substrings of s split around runs of
/// whitespace characters, as defined by [unicode.IsSpace].
/// The iterator yields the same strings that would be returned by [Fields](s),
/// but without constructing the slice.
pub fn FieldsSeq(s: string) -> iter.Seq<string>
/// HasPrefix reports whether the string s begins with prefix.
pub fn HasPrefix(s: string, prefix: string) -> bool
/// HasSuffix reports whether the string s ends with suffix.
pub fn HasSuffix(s: string, suffix: string) -> bool
/// Index returns the index of the first instance of substr in s, or -1 if substr is not present in s.
pub fn Index(s: string, substr: string) -> int
/// IndexAny returns the index of the first instance of any Unicode code point
/// from chars in s, or -1 if no Unicode code point from chars is present in s.
pub fn IndexAny(s: string, chars: string) -> int
/// IndexByte returns the index of the first instance of c in s, or -1 if c is not present in s.
pub fn IndexByte(s: string, c: uint8) -> int
/// IndexFunc returns the index into s of the first Unicode
/// code point satisfying f(c), or -1 if none do.
pub fn IndexFunc(s: string, f: fn(int32) -> bool) -> int
/// IndexRune returns the index of the first instance of the Unicode code point
/// r, or -1 if rune is not present in s.
/// If r is [utf8.RuneError], it returns the first instance of any
/// invalid UTF-8 byte sequence.
pub fn IndexRune(s: string, r: int32) -> int
/// Join concatenates the elements of its first argument to create a single string. The separator
/// string sep is placed between elements in the resulting string.
pub fn Join(elems: Slice<string>, sep: string) -> string
/// LastIndex returns the index of the last instance of substr in s, or -1 if substr is not present in s.
pub fn LastIndex(s: string, substr: string) -> int
/// LastIndexAny returns the index of the last instance of any Unicode code
/// point from chars in s, or -1 if no Unicode code point from chars is
/// present in s.
pub fn LastIndexAny(s: string, chars: string) -> int
/// LastIndexByte returns the index of the last instance of c in s, or -1 if c is not present in s.
pub fn LastIndexByte(s: string, c: uint8) -> int
/// LastIndexFunc returns the index into s of the last
/// Unicode code point satisfying f(c), or -1 if none do.
pub fn LastIndexFunc(s: string, f: fn(int32) -> bool) -> int
/// Lines returns an iterator over the newline-terminated lines in the string s.
/// The lines yielded by the iterator include their terminating newlines.
/// If s is empty, the iterator yields no lines at all.
/// If s does not end in a newline, the final yielded line will not end in a newline.
/// It returns a single-use iterator.
pub fn Lines(s: string) -> iter.Seq<string>
/// Map returns a copy of the string s with all its characters modified
/// according to the mapping function. If mapping returns a negative value, the character is
/// dropped from the string with no replacement.
pub fn Map(mapping: fn(int32) -> int32, s: string) -> string
pub fn NewReader(s: string) -> Ref<Reader>
pub fn NewReplacer(oldnew: VarArgs<string>) -> Ref<Replacer>
/// Repeat returns a new string consisting of count copies of the string s.
///
/// It panics if count is negative or if the result of (len(s) * count)
/// overflows.
pub fn Repeat(s: string, count: int) -> string
/// Replace returns a copy of the string s with the first n
/// non-overlapping instances of old replaced by new.
/// If old is empty, it matches at the beginning of the string
/// and after each UTF-8 sequence, yielding up to k+1 replacements
/// for a k-rune string.
/// If n < 0, there is no limit on the number of replacements.
pub fn Replace(s: string, old: string, new: string, n: int) -> string
/// ReplaceAll returns a copy of the string s with all
/// non-overlapping instances of old replaced by new.
/// If old is empty, it matches at the beginning of the string
/// and after each UTF-8 sequence, yielding up to k+1 replacements
/// for a k-rune string.
pub fn ReplaceAll(s: string, old: string, new: string) -> string
/// Split slices s into all substrings separated by sep and returns a slice of
/// the substrings between those separators.
///
/// If s does not contain sep and sep is not empty, Split returns a
/// slice of length 1 whose only element is s.
///
/// If sep is empty, Split splits after each UTF-8 sequence. If both s
/// and sep are empty, Split returns an empty slice.
///
/// It is equivalent to [SplitN] with a count of -1.
///
/// To split around the first instance of a separator, see [Cut].
pub fn Split(s: string, sep: string) -> Slice<string>
/// SplitAfter slices s into all substrings after each instance of sep and
/// returns a slice of those substrings.
///
/// If s does not contain sep and sep is not empty, SplitAfter returns
/// a slice of length 1 whose only element is s.
///
/// If sep is empty, SplitAfter splits after each UTF-8 sequence. If
/// both s and sep are empty, SplitAfter returns an empty slice.
///
/// It is equivalent to [SplitAfterN] with a count of -1.
pub fn SplitAfter(s: string, sep: string) -> Slice<string>
/// SplitAfterN slices s into substrings after each instance of sep and
/// returns a slice of those substrings.
///
/// The count determines the number of substrings to return:
/// - n > 0: at most n substrings; the last substring will be the unsplit remainder;
/// - n == 0: the result is nil (zero substrings);
/// - n < 0: all substrings.
///
/// Edge cases for s and sep (for example, empty strings) are handled
/// as described in the documentation for [SplitAfter].
pub fn SplitAfterN(s: string, sep: string, n: int) -> Slice<string>
/// SplitAfterSeq returns an iterator over substrings of s split after each instance of sep.
/// The iterator yields the same strings that would be returned by [SplitAfter](s, sep),
/// but without constructing the slice.
/// It returns a single-use iterator.
pub fn SplitAfterSeq(s: string, sep: string) -> iter.Seq<string>
/// SplitN slices s into substrings separated by sep and returns a slice of
/// the substrings between those separators.
///
/// The count determines the number of substrings to return:
/// - n > 0: at most n substrings; the last substring will be the unsplit remainder;
/// - n == 0: the result is nil (zero substrings);
/// - n < 0: all substrings.
///
/// Edge cases for s and sep (for example, empty strings) are handled
/// as described in the documentation for [Split].
///
/// To split around the first instance of a separator, see [Cut].
pub fn SplitN(s: string, sep: string, n: int) -> Slice<string>
/// SplitSeq returns an iterator over all substrings of s separated by sep.
/// The iterator yields the same strings that would be returned by [Split](s, sep),
/// but without constructing the slice.
/// It returns a single-use iterator.
pub fn SplitSeq(s: string, sep: string) -> iter.Seq<string>
/// Title returns a copy of the string s with all Unicode letters that begin words
/// mapped to their Unicode title case.
///
/// Deprecated: The rule Title uses for word boundaries does not handle Unicode
/// punctuation properly. Use golang.org/x/text/cases instead.
pub fn Title(s: string) -> string
/// ToLower returns s with all Unicode letters mapped to their lower case.
pub fn ToLower(s: string) -> string
/// ToLowerSpecial returns a copy of the string s with all Unicode letters mapped to their
/// lower case using the case mapping specified by c.
pub fn ToLowerSpecial(c: unicode.SpecialCase, s: string) -> string
/// ToTitle returns a copy of the string s with all Unicode letters mapped to
/// their Unicode title case.
pub fn ToTitle(s: string) -> string
/// ToTitleSpecial returns a copy of the string s with all Unicode letters mapped to their
/// Unicode title case, giving priority to the special casing rules.
pub fn ToTitleSpecial(c: unicode.SpecialCase, s: string) -> string
/// ToUpper returns s with all Unicode letters mapped to their upper case.
pub fn ToUpper(s: string) -> string
/// ToUpperSpecial returns a copy of the string s with all Unicode letters mapped to their
/// upper case using the case mapping specified by c.
pub fn ToUpperSpecial(c: unicode.SpecialCase, s: string) -> string
/// ToValidUTF8 returns a copy of the string s with each run of invalid UTF-8 byte sequences
/// replaced by the replacement string, which may be empty.
pub fn ToValidUTF8(s: string, replacement: string) -> string
/// Trim returns a slice of the string s with all leading and
/// trailing Unicode code points contained in cutset removed.
pub fn Trim(s: string, cutset: string) -> string
/// TrimFunc returns a slice of the string s with all leading
/// and trailing Unicode code points c satisfying f(c) removed.
pub fn TrimFunc(s: string, f: fn(int32) -> bool) -> string
/// TrimLeft returns a slice of the string s with all leading
/// Unicode code points contained in cutset removed.
///
/// To remove a prefix, use [TrimPrefix] instead.
pub fn TrimLeft(s: string, cutset: string) -> string
/// TrimLeftFunc returns a slice of the string s with all leading
/// Unicode code points c satisfying f(c) removed.
pub fn TrimLeftFunc(s: string, f: fn(int32) -> bool) -> string
/// TrimPrefix returns s without the provided leading prefix string.
/// If s doesn't start with prefix, s is returned unchanged.
pub fn TrimPrefix(s: string, prefix: string) -> string
/// TrimRight returns a slice of the string s, with all trailing
/// Unicode code points contained in cutset removed.
///
/// To remove a suffix, use [TrimSuffix] instead.
pub fn TrimRight(s: string, cutset: string) -> string
/// TrimRightFunc returns a slice of the string s with all trailing
/// Unicode code points c satisfying f(c) removed.
pub fn TrimRightFunc(s: string, f: fn(int32) -> bool) -> string
/// TrimSpace returns a slice of the string s, with all leading
/// and trailing white space removed, as defined by Unicode.
pub fn TrimSpace(s: string) -> string
/// TrimSuffix returns s without the provided trailing suffix string.
/// If s doesn't end with suffix, s is returned unchanged.
pub fn TrimSuffix(s: string, suffix: string) -> string
/// A Builder is used to efficiently build a string using [Builder.Write] methods.
/// It minimizes memory copying. The zero value is ready to use.
/// Do not copy a non-zero Builder.
pub type Builder
/// A Reader implements the [io.Reader], [io.ReaderAt], [io.ByteReader], [io.ByteScanner],
/// [io.RuneReader], [io.RuneScanner], [io.Seeker], and [io.WriterTo] interfaces by reading
/// from a string.
/// The zero value for Reader operates like a Reader of an empty string.
pub type Reader
/// Replacer replaces a list of strings with replacements.
/// It is safe for concurrent use by multiple goroutines.
pub type Replacer
impl Builder {
/// Cap returns the capacity of the builder's underlying byte slice. It is the
/// total space allocated for the string being built and includes any bytes
/// already written.
fn Cap(self: Ref<Builder>) -> int
/// Grow grows b's capacity, if necessary, to guarantee space for
/// another n bytes. After Grow(n), at least n bytes can be written to b
/// without another allocation. If n is negative, Grow panics.
fn Grow(self: Ref<Builder>, n: int)
/// Len returns the number of accumulated bytes; b.Len() == len(b.String()).
fn Len(self: Ref<Builder>) -> int
/// Reset resets the [Builder] to be empty.
fn Reset(self: Ref<Builder>)
/// String returns the accumulated string.
fn String(self: Ref<Builder>) -> string
/// Write appends the contents of p to b's buffer.
/// Write always returns len(p), nil.
fn Write(self: Ref<Builder>, p: Slice<uint8>) -> Partial<int, error>
/// WriteByte appends the byte c to b's buffer.
/// The returned error is always nil.
#[allow(unused_result)]
fn WriteByte(self: Ref<Builder>, c: uint8) -> Result<(), error>
/// WriteRune appends the UTF-8 encoding of Unicode code point r to b's buffer.
/// It returns the length of r and a nil error.
#[allow(unused_result)]
fn WriteRune(self: Ref<Builder>, r: int32) -> Result<int, error>
/// WriteString appends the contents of s to b's buffer.
/// It returns the length of s and a nil error.
#[allow(unused_result)]
fn WriteString(self: Ref<Builder>, s: string) -> Result<int, error>
}
impl Reader {
/// Len returns the number of bytes of the unread portion of the
/// string.
fn Len(self: Ref<Reader>) -> int
/// Read implements the [io.Reader] interface.
fn Read(self: Ref<Reader>, mut b: Slice<uint8>) -> Partial<int, error>
/// ReadAt implements the [io.ReaderAt] interface.
fn ReadAt(self: Ref<Reader>, mut b: Slice<uint8>, off: int64) -> Partial<int, error>
/// ReadByte implements the [io.ByteReader] interface.
fn ReadByte(self: Ref<Reader>) -> Result<uint8, error>
/// ReadRune implements the [io.RuneReader] interface.
fn ReadRune(self: Ref<Reader>) -> Result<(int32, int), error>
/// Reset resets the [Reader] to be reading from s.
fn Reset(self: Ref<Reader>, s: string)
/// Seek implements the [io.Seeker] interface.
fn Seek(self: Ref<Reader>, offset: int64, whence: int) -> Result<int64, error>
/// Size returns the original length of the underlying string.
/// Size is the number of bytes available for reading via [Reader.ReadAt].
/// The returned value is always the same and is not affected by calls
/// to any other method.
fn Size(self: Ref<Reader>) -> int64
/// UnreadByte implements the [io.ByteScanner] interface.
fn UnreadByte(self: Ref<Reader>) -> Result<(), error>
/// UnreadRune implements the [io.RuneScanner] interface.
fn UnreadRune(self: Ref<Reader>) -> Result<(), error>
/// WriteTo implements the [io.WriterTo] interface.
fn WriteTo(self: Ref<Reader>, w: io.Writer) -> Result<int64, error>
}
impl Replacer {
/// Replace returns a copy of s with all replacements performed.
fn Replace(self: Ref<Replacer>, s: string) -> string
/// WriteString writes s to w with all replacements performed.
fn WriteString(self: Ref<Replacer>, w: io.Writer, s: string) -> Result<int, error>
}