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(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(5);
assert_eq!(x, Cons(5, Box::new(Nil)));

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

👎Deprecated since 0.3.1: Use new() instead.

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

This is equivalent to Cons(x, 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(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(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>

👎Deprecated since 0.3.1: Any usage of val_as_ref can be replaced with as_ref.

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>.

pub fn as_mut(&mut self) -> List<&mut T>

Converts from &mut List<T> to List<&mut T>.

pub fn expect(self, msg: &str) -> ConsData<T>

Returns the Cons value and next List, consuming self.

Panics

Panics if self is Nil.

Examples

let x = List::new(5);
assert_eq!(x.expect("foo"), (5, Nil));

let x: List<i32> = Nil;
x.expect("foo"); // panics with "foo"

pub fn unwrap(self) -> ConsData<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(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: ConsData<T>) -> ConsData<T>

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

Examples

let x = List::new(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) -> ConsData<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(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("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(ConsData<T>) -> ConsData<U>,

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

Examples

// you can unpack with a pattern
let f = |(x, list)| (x + 1, list);
let x = List::new(5).map_next(f);
assert_eq!(x, Cons(6, Box::new(Nil)));

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

impl<T> List<&T>

pub fn copied(self) -> List<T>where T: Copy,

Maps a List<&T> to a List<T> by copying the contents of the list.

Examples

let x = 3;
let list_x = List::new(&x);
assert_eq!(list_x, List::new(&3));

let copy_x = list_x.copied();
assert_eq!(copy_x, List::new(3));

pub fn cloned(self) -> List<T>where T: Clone,

Maps a List<&T> to a List<T> by cloning the contents of the list.

Examples

let x = 3;
let list_x = List::new(&x);
assert_eq!(list_x, List::new(&3));

let clone_x = list_x.cloned();
assert_eq!(clone_x, List::new(3));

impl<T> List<&mut T>

pub fn copied(self) -> List<T>where T: Copy,

Maps a List<&mut T> to a List<T> by copying the contents of the list.

Examples

let mut x = 3;
let list_x = List::new(&mut x);
assert_eq!(list_x, List::new(&mut 3));

let copy_x = list_x.copied();
assert_eq!(copy_x, List::new(3));

pub fn cloned(self) -> List<T>where T: Clone,

Maps a List<&mut T> to a List<T> by cloning the contents of the list.

Examples

let mut x = 3;
let list_x = List::new(&mut x);
assert_eq!(list_x, List::new(&mut 3));

let clone_x = list_x.cloned();
assert_eq!(clone_x, List::new(3));

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>