Module str

Struct CharRange

pub struct CharRange {
    ch: char,
    next: uint,
}

Trait OwnedStr

fn push_str(&mut self, v: &str)

fn push_char(&mut self, c: char)

Trait StrSlice

fn all(&self, it: &fn(char) -> bool) -> bool

fn any(&self, it: &fn(char) -> bool) -> bool

fn contains<'a>(&self, needle: &'a str) -> bool

fn contains_char(&self, needle: char) -> bool

fn each(&self, it: &fn(u8) -> bool)

fn eachi(&self, it: &fn(uint, u8) -> bool)

fn each_reverse(&self, it: &fn(u8) -> bool)

fn eachi_reverse(&self, it: &fn(uint, u8) -> bool)

fn each_char(&self, it: &fn(char) -> bool)

fn each_chari(&self, it: &fn(uint, char) -> bool)

fn each_char_reverse(&self, it: &fn(char) -> bool)

fn each_chari_reverse(&self, it: &fn(uint, char) -> bool)

fn ends_with(&self, needle: &str) -> bool

fn is_empty(&self) -> bool

fn is_whitespace(&self) -> bool

fn is_alphanumeric(&self) -> bool

fn len(&self) -> uint

fn char_len(&self) -> uint

fn slice(&self, begin: uint, end: uint) -> &'self str

fn each_split(&self, sepfn: &fn(char) -> bool, it: &fn(&'self str) -> bool)

fn each_split_char(&self, sep: char, it: &fn(&'self str) -> bool)

fn each_split_str<'a>(&self, sep: &'a str, it: &fn(&'self str) -> bool)

fn starts_with<'a>(&self, needle: &'a str) -> bool

fn substr(&self, begin: uint, n: uint) -> &'self str

fn to_lower(&self) -> ~str

fn to_upper(&self) -> ~str

fn escape_default(&self) -> ~str

fn escape_unicode(&self) -> ~str

fn trim(&self) -> &'self str

fn trim_left(&self) -> &'self str

fn trim_right(&self) -> &'self str

fn trim_chars(&self, chars_to_trim: &[char]) -> &'self str

fn trim_left_chars(&self, chars_to_trim: &[char]) -> &'self str

fn trim_right_chars(&self, chars_to_trim: &[char]) -> &'self str

fn to_owned(&self) -> ~str

fn to_managed(&self) -> @str

fn char_at(&self, i: uint) -> char

fn char_at_reverse(&self, i: uint) -> char

fn to_bytes(&self) -> ~[u8]

Implementation of ToStr for ~str

fn to_str(&self) -> ~str

Implementation of ToStr for &'self str where <'self>

fn to_str(&self) -> ~str

Implementation of ToStr for @str

fn to_str(&self) -> ~str

Implementation of TotalOrd for &'self str where <'self>

fn cmp(&self, other: &&'self str) -> Ordering

Implementation of TotalOrd for ~str

fn cmp(&self, other: &~str) -> Ordering

Implementation of TotalOrd for @str

fn cmp(&self, other: &@str) -> Ordering

Implementation of Eq for &'self str where <'self>

fn eq(&self, other: &&'self str) -> bool

fn ne(&self, other: &&'self str) -> bool

Implementation of Eq for ~str

fn eq(&self, other: &~str) -> bool

fn ne(&self, other: &~str) -> bool

Implementation of Eq for @str

fn eq(&self, other: &@str) -> bool

fn ne(&self, other: &@str) -> bool

Implementation of TotalEq for &'self str where <'self>

fn equals(&self, other: &&'self str) -> bool

Implementation of TotalEq for ~str

fn equals(&self, other: &~str) -> bool

Implementation of TotalEq for @str

fn equals(&self, other: &@str) -> bool

Implementation of Ord for ~str

fn lt(&self, other: &~str) -> bool

fn le(&self, other: &~str) -> bool

fn ge(&self, other: &~str) -> bool

fn gt(&self, other: &~str) -> bool

Implementation of Ord for &'self str where <'self>

fn lt(&self, other: &&'self str) -> bool

fn le(&self, other: &&'self str) -> bool

fn ge(&self, other: &&'self str) -> bool

fn gt(&self, other: &&'self str) -> bool

Implementation of Ord for @str

fn lt(&self, other: &@str) -> bool

fn le(&self, other: &@str) -> bool

fn ge(&self, other: &@str) -> bool

fn gt(&self, other: &@str) -> bool

Implementation of Equiv<~str> for &'self str where <'self>

fn equiv(&self, other: &~str) -> bool

Implementation of StrSlice<'self> for &'self str where <'self>

Extension methods for strings

fn all(&self, it: &fn(char) -> bool) -> bool

fn any(&self, it: &fn(char) -> bool) -> bool

fn contains<'a>(&self, needle: &'a str) -> bool

fn contains_char(&self, needle: char) -> bool

fn each(&self, it: &fn(u8) -> bool)

fn eachi(&self, it: &fn(uint, u8) -> bool)

fn each_reverse(&self, it: &fn(u8) -> bool)

fn eachi_reverse(&self, it: &fn(uint, u8) -> bool)

fn each_char(&self, it: &fn(char) -> bool)

fn each_chari(&self, it: &fn(uint, char) -> bool)

fn each_char_reverse(&self, it: &fn(char) -> bool)

fn each_chari_reverse(&self, it: &fn(uint, char) -> bool)

fn ends_with(&self, needle: &str) -> bool

fn is_empty(&self) -> bool

fn is_whitespace(&self) -> bool

fn is_alphanumeric(&self) -> bool

fn len(&self) -> uint

fn char_len(&self) -> uint

fn slice(&self, begin: uint, end: uint) -> &'self str

fn each_split(&self, sepfn: &fn(char) -> bool, it: &fn(&'self str) -> bool)

fn each_split_char(&self, sep: char, it: &fn(&'self str) -> bool)

fn each_split_str<'a>(&self, sep: &'a str, it: &fn(&'self str) -> bool)

fn starts_with<'a>(&self, needle: &'a str) -> bool

fn substr(&self, begin: uint, n: uint) -> &'self str

fn to_lower(&self) -> ~str

fn to_upper(&self) -> ~str

fn escape_default(&self) -> ~str

fn escape_unicode(&self) -> ~str

fn trim(&self) -> &'self str

fn trim_left(&self) -> &'self str

fn trim_right(&self) -> &'self str

fn trim_chars(&self, chars_to_trim: &[char]) -> &'self str

fn trim_left_chars(&self, chars_to_trim: &[char]) -> &'self str

fn trim_right_chars(&self, chars_to_trim: &[char]) -> &'self str

fn to_owned(&self) -> ~str

fn to_managed(&self) -> @str

fn char_at(&self, i: uint) -> char

fn char_at_reverse(&self, i: uint) -> char

fn to_bytes(&self) -> ~[u8]

Implementation of OwnedStr for ~str

fn push_str(&mut self, v: &str)

fn push_char(&mut self, c: char)

Implementation of Clone for ~str

fn clone(&self) -> ~str

Function all

fn all(s: &str, it: &fn(char) -> bool) -> bool

Return true if a predicate matches all characters or if the string contains no characters

Function all_between

fn all_between(s: &str, start: uint, end: uint, it: &fn(char) -> bool) -> bool

Loop through a substring, char by char

Function any

fn any(ss: &str, pred: &fn(char) -> bool) -> bool

Return true if a predicate matches any character (and false if it matches none or there are no characters)

Function any_between

fn any_between(s: &str, start: uint, end: uint, it: &fn(char) -> bool) -> bool

Loop through a substring, char by char

Function append

fn append(lhs: ~str, rhs: &str) -> ~str

Concatenate two strings together

Function as_buf

fn as_buf<T>(s: &str, f: &fn(*u8, uint) -> T) -> T

Work with the byte buffer and length of a slice.

The given length is one byte longer than the 'official' indexable length of the string. This is to permit probing the byte past the indexable area for a null byte, as is the case in slices pointing to full strings, or suffixes of them.

Function as_bytes

fn as_bytes<T>(s: &const ~str, f: &fn(&~[u8]) -> T) -> T

Work with the byte buffer of a string.

Allows for unsafe manipulation of strings, which is useful for foreign interop.

let i = str::as_bytes("Hello World") { |bytes| vec::len(bytes) };

Function as_bytes_slice

fn as_bytes_slice<'a>(s: &'a str) -> &'a [u8]

Work with the byte buffer of a string as a byte slice.

The byte slice does not include the null terminator.

Function as_c_str

fn as_c_str<T>(s: &str, f: &fn(*libc::c_char) -> T) -> T

Work with the byte buffer of a string as a null-terminated C string.

Allows for unsafe manipulation of strings, which is useful for foreign interop. This is similar to str::as_buf, but guarantees null-termination. If the given slice is not already null-terminated, this function will allocate a temporary, copy the slice, null terminate it, and pass that instead.

let s = str::as_c_str("PATH", { |path| libc::getenv(path) });

Function byte_slice

fn byte_slice<T>(s: &str, f: &fn(v: &[u8]) -> T) -> T

Work with the string as a byte slice, not including trailing null.

Function capacity

fn capacity(s: &const ~str) -> uint

Returns the number of single-byte characters the string can hold without reallocating

Function char_at

fn char_at(s: &str, i: uint) -> char

Plucks the nth character from the beginning of a string

Function char_at_reverse

fn char_at_reverse(s: &str, i: uint) -> char

Plucks the nth character from the end of a string

Function char_len

fn char_len(s: &str) -> uint

Returns the number of characters that a string holds

Function char_range_at

fn char_range_at(s: &str, i: uint) -> CharRange

Pluck a character out of a string and return the index of the next character.

This function can be used to iterate over the unicode characters of a string.

let s = "中华Việt Nam";
let i = 0u;
while i < str::len(s) {
    let CharRange {ch, next} = str::char_range_at(s, i);
    std::io::println(fmt!("%u: %c",i,ch));
    i = next;
}

0: 中
3: 华
6: V
7: i
8: ệ
11: t
12:
13: N
14: a
15: m

Function char_range_at_reverse

fn char_range_at_reverse(ss: &str, start: uint) -> CharRange

Given a byte position and a str, return the previous char and its position

This function can be used to iterate over a unicode string in reverse.

returns 0 for next index if called on start index 0

Function concat

fn concat(v: &[~str]) -> ~str

Concatenate a vector of strings

Function connect

fn connect(v: &[~str], sep: &str) -> ~str

Concatenate a vector of strings, placing a given separator between each

Function connect_slices

fn connect_slices(v: &[&str], sep: &str) -> ~str

Concatenate a vector of strings, placing a given separator between each

Function contains

fn contains<'a, 'b>(haystack: &'a str, needle: &'b str) -> bool

Returns true if one string contains another

Function contains_char

fn contains_char(haystack: &str, needle: char) -> bool

Returns true if a string contains a char.

Function count_bytes

fn count_bytes<'b>(s: &'b str, start: uint, n: uint) -> uint

Counts the number of bytes taken by the n in s starting from start.

Function count_chars

fn count_chars(s: &str, start: uint, end: uint) -> uint

As char_len but for a slice of a string

Function each

fn each(s: &str, it: &fn(u8) -> bool)

Iterate over the bytes in a string

Function each_char

fn each_char(s: &str, it: &fn(char) -> bool)

Iterate over each char of a string, without allocating

Function each_char_reverse

fn each_char_reverse(s: &str, it: &fn(char) -> bool)

Iterates over the chars in a string in reverse

Function each_chari

fn each_chari(s: &str, it: &fn(uint, char) -> bool)

Iterates over the chars in a string, with indices

Function each_chari_reverse

fn each_chari_reverse(s: &str, it: &fn(uint, char) -> bool)

Function each_line

fn each_line<'a>(s: &'a str, it: &fn(&'a str) -> bool)

Splits a string into substrings separated by LF ('\n').

Function each_line_any

fn each_line_any<'a>(s: &'a str, it: &fn(&'a str) -> bool)

Splits a string into substrings separated by LF ('\n') and/or CR LF ("\r\n")

Function each_reverse

fn each_reverse(s: &str, it: &fn(u8) -> bool)

Iterate over the bytes in a string in reverse

Function each_split

fn each_split<'a>(s: &'a str, sepfn: &fn(char) -> bool,
                  it: &fn(&'a str) -> bool)

Splits a string into substrings using a character function

Function each_split_char

fn each_split_char<'a>(s: &'a str, sep: char, it: &fn(&'a str) -> bool)

Splits a string into substrings at each occurrence of a given character

Function each_split_char_no_trailing

fn each_split_char_no_trailing<'a>(s: &'a str, sep: char,
                                   it: &fn(&'a str) -> bool)

Like each_split_char, but a trailing empty string is omitted

Function each_split_char_nonempty

fn each_split_char_nonempty<'a>(s: &'a str, sep: char,
                                it: &fn(&'a str) -> bool)

Like each_split_char, but omits empty strings

Function each_split_no_trailing

fn each_split_no_trailing<'a>(s: &'a str, sepfn: &fn(char) -> bool,
                              it: &fn(&'a str) -> bool)

Like each_split, but a trailing empty string is omitted

Function each_split_nonempty

fn each_split_nonempty<'a>(s: &'a str, sepfn: &fn(char) -> bool,
                           it: &fn(&'a str) -> bool)

Like each_split, but omits empty strings

Function each_split_str

fn each_split_str<'a, 'b>(s: &'a str, sep: &'b str, it: &fn(&'a str) -> bool)

Splits a string into a vector of the substrings separated by a given string

let mut v = ~[];
for each_split_str(".XXX.YYY.", ".") |subs| { v.push(subs); }
assert!(v == ["", "XXX", "YYY", ""]);

Function each_split_str_nonempty

fn each_split_str_nonempty<'a,
                           'b>(s: &'a str, sep: &'b str,
                               it: &fn(&'a str) -> bool)

Function each_split_within

fn each_split_within<'a>(ss: &'a str, lim: uint, it: &fn(&'a str) -> bool)

Splits a string into substrings with possibly internal whitespace, * each of them at most lim bytes long. The substrings have leading and trailing * whitespace removed, and are only cut at whitespace boundaries. * * #Failure: * * Fails during iteration if the string contains a non-whitespace * sequence longer than the limit.

Function each_splitn

fn each_splitn<'a>(s: &'a str, sepfn: &fn(char) -> bool, count: uint,
                   it: &fn(&'a str) -> bool)

Splits a string into substrings using a character function, cutting at most count times.

Function each_splitn_char

fn each_splitn_char<'a>(s: &'a str, sep: char, count: uint,
                        it: &fn(&'a str) -> bool)

Splits a string into substrings at each occurrence of a given character up to 'count' times.

The character must be a valid UTF-8/ASCII character

Function each_word

fn each_word<'a>(s: &'a str, it: &fn(&'a str) -> bool)

Splits a string into substrings separated by whitespace

Function eachi

fn eachi(s: &str, it: &fn(uint, u8) -> bool)

Iterate over the bytes in a string, with indices

Function eachi_reverse

fn eachi_reverse(s: &str, it: &fn(uint, u8) -> bool)

Iterate over the bytes in a string in reverse, with indices

Function ends_with

fn ends_with<'a, 'b>(haystack: &'a str, needle: &'b str) -> bool

Returns true if one string ends with another

Function eq

fn eq(a: &~str, b: &~str) -> bool

Bytewise string equality

Function eq_slice

fn eq_slice(a: &str, b: &str) -> bool

Bytewise slice equality

Function escape_default

fn escape_default(s: &str) -> ~str

Escape each char in s with char::escape_default.

Function escape_unicode

fn escape_unicode(s: &str) -> ~str

Escape each char in s with char::escape_unicode.

Function find

fn find(s: &str, f: &fn(char) -> bool) -> Option<uint>

Returns the byte index of the first character that satisfies the given predicate

Function find_between

fn find_between(s: &str, start: uint, end: uint, f: &fn(char) -> bool) ->
 Option<uint>

Returns the byte index of the first character that satisfies the given predicate, within a given range

Function find_char

fn find_char(s: &str, c: char) -> Option<uint>

Returns the byte index of the first matching character

Function find_char_between

fn find_char_between(s: &str, c: char, start: uint, end: uint) -> Option<uint>

Returns the byte index of the first matching character within a given range

Function find_char_from

fn find_char_from(s: &str, c: char, start: uint) -> Option<uint>

Returns the byte index of the first matching character beginning from a given byte offset

Function find_from

fn find_from(s: &str, start: uint, f: &fn(char) -> bool) -> Option<uint>

Returns the byte index of the first character that satisfies the given predicate, beginning from a given byte offset

Function find_str

fn find_str<'a, 'b>(haystack: &'a str, needle: &'b str) -> Option<uint>

Returns the byte index of the first matching substring

Function find_str_between

fn find_str_between<'a,
                    'b>(haystack: &'a str, needle: &'b str, start: uint,
                        end: uint) -> Option<uint>

Returns the byte index of the first matching substring within a given range

Function find_str_from

fn find_str_from<'a, 'b>(haystack: &'a str, needle: &'b str, start: uint) ->
 Option<uint>

Returns the byte index of the first matching substring beginning from a given byte offset

Function from_byte

fn from_byte(b: u8) -> ~str

Convert a byte to a UTF-8 string

Function from_bytes

fn from_bytes(vv: &const [u8]) -> ~str

Convert a vector of bytes to a UTF-8 string

Function from_char

fn from_char(ch: char) -> ~str

Convert a char to a string

Function from_chars

fn from_chars(chs: &[char]) -> ~str

Convert a vector of chars to a string

Function from_slice

fn from_slice(s: &str) -> ~str

Copy a slice into a new unique str

Function from_utf16

fn from_utf16(v: &[u16]) -> ~str

Function is_ascii

fn is_ascii(s: &str) -> bool

Determines if a string contains only ASCII characters

Function is_char_boundary

fn is_char_boundary(s: &str, index: uint) -> bool

Returns false if the index points into the middle of a multi-byte character sequence.

Function is_empty

fn is_empty(s: &str) -> bool

Returns true if the string has length 0

Function is_utf16

fn is_utf16(v: &[u16]) -> bool

Determines if a vector of u16 contains valid UTF-16

Function is_utf8

fn is_utf8(v: &const [u8]) -> bool

Determines if a vector of bytes contains valid UTF-8

Function is_whitespace

fn is_whitespace(s: &str) -> bool

Returns true if the string contains only whitespace

Whitespace characters are determined by char::is_whitespace

Function le

fn le(a: &str, b: &str) -> bool

Bytewise less than or equal

Function len

fn len(s: &str) -> uint

Returns the string length/size in bytes not counting the null terminator

Function levdistance

fn levdistance(s: &str, t: &str) -> uint

Levenshtein Distance between two strings

Function map

fn map(ss: &str, ff: &fn(char) -> char) -> ~str

Apply a function to each character

Function pop_char

fn pop_char(s: &mut ~str) -> char

Remove the final character from a string and return it

Function push_char

fn push_char(s: &mut ~str, ch: char)

Appends a character at the end of a string

Function push_str

fn push_str(lhs: &mut ~str, rhs: &str)

Appends a string slice to the back of a string

Function push_str_no_overallocate

fn push_str_no_overallocate(lhs: &mut ~str, rhs: &str)

Appends a string slice to the back of a string, without overallocating

Function repeat

fn repeat(ss: &str, nn: uint) -> ~str

Given a string, make a new string with repeated copies of it

Function replace

fn replace(s: &str, from: &str, to: &str) -> ~str

Replace all occurrences of one string with another

Function reserve

fn reserve(s: &mut ~str, n: uint)

Reserves capacity for exactly n bytes in the given string, not including the null terminator.

Assuming single-byte characters, the resulting string will be large enough to hold a string of length n. To account for the null terminator, the underlying buffer will have the size n + 1.

If the capacity for s is already equal to or greater than the requested capacity, then no action is taken.

Function reserve_at_least

fn reserve_at_least(s: &mut ~str, n: uint)

Reserves capacity for at least n bytes in the given string, not including the null terminator.

Assuming single-byte characters, the resulting string will be large enough to hold a string of length n. To account for the null terminator, the underlying buffer will have the size n + 1.

This function will over-allocate in order to amortize the allocation costs in scenarios where the caller may need to repeatedly reserve additional space.

If the capacity for s is already equal to or greater than the requested capacity, then no action is taken.

Function rfind

fn rfind(s: &str, f: &fn(char) -> bool) -> Option<uint>

Returns the byte index of the last character that satisfies the given predicate

Function rfind_between

fn rfind_between(s: &str, start: uint, end: uint, f: &fn(char) -> bool) ->
 Option<uint>

Returns the byte index of the last character that satisfies the given predicate, within a given range

Function rfind_char

fn rfind_char(s: &str, c: char) -> Option<uint>

Returns the byte index of the last matching character

Function rfind_char_between

fn rfind_char_between(s: &str, c: char, start: uint, end: uint) ->
 Option<uint>

Returns the byte index of the last matching character within a given range

Function rfind_char_from

fn rfind_char_from(s: &str, c: char, start: uint) -> Option<uint>

Returns the byte index of the last matching character beginning from a given byte offset

Function rfind_from

fn rfind_from(s: &str, start: uint, f: &fn(char) -> bool) -> Option<uint>

Returns the byte index of the last character that satisfies the given predicate, beginning from a given byte offset

Function shift_char

fn shift_char(s: &mut ~str) -> char

Remove the first character from a string and return it

Function slice

fn slice<'a>(s: &'a str, begin: uint, end: uint) -> &'a str

Returns a slice of the given string from the byte range [begin..end)

Fails when begin and end do not point to valid characters or beyond the last character of the string

Function slice_shift_char

fn slice_shift_char<'a>(s: &'a str) -> (char, &'a str)

Removes the first character from a string slice and returns it. This does not allocate a new string; instead, it mutates a slice to point one character beyond the character that was shifted.

Function starts_with

fn starts_with<'a, 'b>(haystack: &'a str, needle: &'b str) -> bool

Returns true if one string starts with another

Function substr

fn substr<'a>(s: &'a str, begin: uint, n: uint) -> &'a str

Take a substring of another.

Returns a slice pointing at n characters starting from byte offset begin.

Function to_bytes

fn to_bytes(s: &str) -> ~[u8]

Converts a string to a unique vector of bytes

The result vector is not null-terminated.

Function to_chars

fn to_chars(s: &str) -> ~[char]

Convert a string to a unique vector of characters

Function to_lower

fn to_lower(s: &str) -> ~str

Convert a string to lowercase. ASCII only

Function to_upper

fn to_upper(s: &str) -> ~str

Convert a string to uppercase. ASCII only

Function to_utf16

fn to_utf16(s: &str) -> ~[u16]

Converts to a vector of u16 encoded as UTF-16

Function trim

fn trim<'a>(s: &'a str) -> &'a str

Returns a string with leading and trailing whitespace removed

Function trim_chars

fn trim_chars<'a>(s: &'a str, chars_to_trim: &[char]) -> &'a str

Returns a string with leading and trailing chars_to_trim removed.

Function trim_left

fn trim_left<'a>(s: &'a str) -> &'a str

Returns a string with leading whitespace removed

Function trim_left_chars

fn trim_left_chars<'a>(s: &'a str, chars_to_trim: &[char]) -> &'a str

Returns a string with leading chars_to_trim removed.

Function trim_right

fn trim_right<'a>(s: &'a str) -> &'a str

Returns a string with trailing whitespace removed

Function trim_right_chars

fn trim_right_chars<'a>(s: &'a str, chars_to_trim: &[char]) -> &'a str

Returns a string with trailing chars_to_trim removed.

Function unshift_char

fn unshift_char(s: &mut ~str, ch: char)

Prepend a char to a string

Function utf16_chars

fn utf16_chars(v: &[u16], f: &fn(char))

Function utf8_char_width

fn utf8_char_width(b: u8) -> uint

Given a first byte, determine how many bytes are in this UTF-8 character

Function with_capacity

fn with_capacity(capacity: uint) -> ~str