Enum cons_rs::List

pub enum List<T> {
    Cons(T, Box<List<T>>),
    Nil,
}

An enum that represents a Cons list. See the module level documentation for more.

Variants

Cons(T, Box<List<T>>)

A value of type T, and a Box containing another List.

Nil

Nothing.

Implementations

impl<T> List<T>

pub fn new_val(x: T) -> List<T>

Returns a new Cons where x is the only value in the List.

This is equivalent to Cons(x, Box::new(Nil)).

Examples

let x = List::new_val(5);
assert_eq!(x, Cons(5, Box::new(Nil)));

pub const fn is_cons(&self) -> bool

Returns true if the List is a Cons value.

Examples

let x: List<i32> = List::new_val(5);
assert_eq!(x.is_cons(), true);

let x: List<i32> = Nil;
assert_eq!(x.is_cons(), false);

pub const fn is_nil(&self) -> bool

Returns true if the List is a Nil value.

Examples:

let x: List<i32> = List::new_val(5);
assert_eq!(x.is_nil(), false);

let x: List<i32> = Nil;
assert_eq!(x.is_nil(), true);

pub fn val_as_ref(&self) -> List<&T>

Converts from &List<T> to List<&T>. If self is Cons, next is always Nil. To preserve next, use as_ref.

pub fn as_ref(&self) -> List<&T>

Converts from &List<T> to List<&T>. If self is Cons, a List containing a reference to val and next is returned. To ignore next, use val_as_ref.

pub fn unwrap(self) -> (T, List<T>)

Returns the Cons value and next List, consuming self.

Usage of this function is discouraged, as it may panic. Instead, prefer to use pattern matching, unwrap_or or unwrap_or_default.

Panics

Panics if self is Nil.

Examples

let x = List::new_val(5);
assert_eq!(x.unwrap(), (5, Nil));

let x: List<i32> = Nil;
assert_eq!(x.unwrap(), (5, Nil)); // fails

pub fn unwrap_or(self, default: (T, List<T>)) -> (T, List<T>)

Returns the contained Cons value and List, or a provided default.

Examples

let x = List::new_val(5);
assert_eq!(x.unwrap_or((6, Nil)), (5, Nil));

let x: List<i32> = Nil;
assert_eq!(x.unwrap_or((6, Nil)), (6, Nil));

pub fn unwrap_or_default(self) -> (T, List<T>)where T: Default,

Returns the contained Cons value and List, or a default.

Consumes self, and if self is Cons, returns the contained value and list, otherwise, returns the default value for T and Nil.

Examples

let x = List::new_val(3);
assert_eq!(x.unwrap_or_default(), (3, Nil));

let x: List<i32> = Nil;
assert_eq!(x.unwrap_or_default(), (0, Nil));

pub fn map<U, F>(self, f: F) -> List<U>where F: FnOnce(T) -> U,

Maps List<T> to List<U> by applying a function to the contained value (if Cons, discarding the next value), or if Nil, returns Nil.

Examples

let x = List::new_val("Hello World".to_string());
let x_len = x.map(|s| s.len());
assert_eq!(x_len, List::new_val(11));

let x: List<String> = Nil;
let x_len = x.map(|s| s.len());
assert_eq!(x_len, Nil);

pub fn map_next<U, F>(self, f: F) -> List<U>where F: FnOnce(T, List<T>) -> (U, List<U>),

Maps List<T> to List<U> by applying a function to the contained value (if Cons), or returns Nil (if Nil).

Examples

let f = |x, list| (x + 1, list);
let x = List::new_val(5).map_next(f);
assert_eq!(x, Cons(6, Box::new(Nil)));

let x: List<i32> = Nil;
assert_eq!(x.map_next(f), Nil);

Trait Implementations

impl<T: Clone> Clone for List<T>

fn clone(&self) -> List<T>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Debug> Debug for List<T>

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

Formats the value using the given formatter.

impl<T> Default for List<T>

fn default() -> List<T>

Returns the “default value” for a type.

impl<T> FromIterator<T> for List<T>

fn from_iter<U: IntoIterator<Item = T>>(iter: U) -> Self

Creates a value from an iterator.

impl<T: Clone> IntoIterator for List<T>

type Item = T

The type of the elements being iterated over.

type IntoIter = ListIterator<T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T: PartialEq> PartialEq<List<T>> for List<T>

fn eq(&self, other: &List<T>) -> bool

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

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<T> StructuralPartialEq for List<T>