Struct char_list::CharList

pub struct CharList { /* private fields */ }

An efficient string type with the same API as a linked-list of characters.

Specifically, a CharList supports the following two methods:

1. cons which immutably prepends a character, and
2. car_cdr which immutably splits self into its first character and everything except the first character.

Implementations

impl CharList

pub fn new() -> Self

Creates an empty CharList.

Example

let empty = CharList::new();
assert!(empty.len() == 0);

pub fn len(&self) -> usize

Returns the length of self.

This length is in bytes, not chars or graphemes. In other words, it might not be what a human considers the length of the string.

Examples

Basic usage:

let foo = CharList::from("foo");
assert!(foo.len() == 3);

let fancy_foo = CharList::from("ƒoo"); // fancy f!
assert!(fancy_foo.len() == 4);
assert!(fancy_foo.chars().count() == 3);

pub fn is_empty(&self) -> bool

pub fn chars(&self) -> Chars<'_>

pub fn with_capacity(capacity: usize) -> Self

pub fn cons(&self, ch: char) -> Self

Creates a new CharList which is a copy of self, but with the given character added onto the front.

Example

let lick = CharList::from("lick");
let slick = lick.cons('s');
assert!(slick == "slick");

pub fn cons_str(&self, s: impl AsRef<str>) -> Self

Creates a new CharList which is a copy of self, but with the contents of the given &str added onto the front.

Example

let tonic = CharList::from("tonic");
let uh_oh = tonic.cons_str("cata");
assert!(uh_oh == "catatonic");

pub fn car_cdr(&self) -> Option<(char, Self)>

Returns a pair containing the first character of self and a CharList made up of everything after the first character of self.

Returns None if self is empty.

Example

let (g, oats) = CharList::from("goats").car_cdr().unwrap();
assert!((g, oats) == ('g', CharList::from("oats")));

let empty = CharList::new();
assert!(empty.car_cdr() == None);

pub fn as_str(&self) -> &str

Extracts a string slice which references self’s entire view of the underlying text.

pub fn from_utf8(vec: Vec<u8>) -> Result<Self, FromUtf8Error>

pub fn from_utf8_lossy(bytes: &[u8]) -> Self

pub unsafe fn from_utf8_unchecked(bytes: &[u8]) -> Self

Safety

See str::from_utf8_unchecked for safety requirements.

pub fn without_prefix<'a, P>(&'a self, prefix: P) -> Option<Self>where
    P: Pattern<'a>,

Returns an optional CharList representing self if prefix had been removed from the front.

let creepy_book = CharList::from("necronomicon");
let informational_book = creepy_book.without_prefix("necro");
assert!(informational_book == Some(CharList::from("nomicon")));

Trait Implementations

impl Add<CharList> for CharList

type Output = CharList

The resulting type after applying the + operator.

fn add(self, rhs: CharList) -> Self::Output

Performs the + operation.

impl AddAssign<CharList> for String

fn add_assign(&mut self, rhs: CharList)

Performs the += operation.

impl AsRef<str> for CharList

fn as_ref(&self) -> &str

Converts this type into a shared reference of the (usually inferred) input type.

impl Borrow<str> for CharList

fn borrow(&self) -> &str

Immutably borrows from an owned value.

impl Debug for CharList

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for CharList

fn default() -> Self

Returns the “default value” for a type.

impl Display for CharList

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Drop for CharList

fn drop(&mut self)

Executes the destructor for this type.

impl From<&str> for CharList

fn from(s: &str) -> Self

Converts to this type from the input type.

impl From<String> for CharList

fn from(string: String) -> Self

Converts to this type from the input type.

impl FromIterator<char> for CharList

fn from_iter<I: IntoIterator<Item = char>>(iter: I) -> Self

Given an iterator over the &str "abc", the CharList "abc" will be created.

impl Hash for CharList

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)where
    H: Hasher,
    Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for CharList

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

This method returns an Ordering between self and other.

const fn max(self, other: Self) -> Selfwhere
    Self: Sized,

Compares and returns the maximum of two values.

const fn min(self, other: Self) -> Selfwhere
    Self: Sized,

Compares and returns the minimum of two values.

const fn clamp(self, min: Self, max: Self) -> Selfwhere
    Self: Sized + PartialOrd<Self>,

Restrict a value to a certain interval.

impl<S> PartialEq<S> for CharListwhere
    S: AsRef<str>,

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

This method tests for self and other values to be equal, and is used by ==.

const fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<S> PartialOrd<S> for CharListwhere
    S: AsRef<str>,

fn partial_cmp(&self, other: &S) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

const fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

const fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

const fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

const fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl Eq for CharList