Enum list::List
[-]
[+]
[src]
pub enum List<A> { Nil, Cons(A, Box<List<A>>), }
Rust implementation of OCaml's 'a list
.
Variants
Nil | |
Cons |
Methods
impl<A> List<A>
impl<A: Clone> List<A>
fn hd(&self) -> Option<A>
Return the first element of the given list. Return None
if the list is
empty.
fn tl(&self) -> Option<List<A>>
Return the given list without its first element. Return None
if the
list is empty.
fn nth(&self, i: uint) -> Option<A>
Return the n
-th element of the given list. The first element (head of
the list) is at position 0. Return None
if the list is too short.
fn rev(&self) -> List<A>
List reversal.
fn append(&self, ys: &List<A>) -> List<A>
Catenate two lists.
fn rev_append(&self, ys: &List<A>) -> List<A>
l1.rev_append(l2)
reverses l1
and concatenates it to l2
. This is
equivalent to l1.rev().append(l2)
.
fn concat<A: Clone>(xss: List<&List<A>>) -> List<A>
Concatenate a list of lists. The elements of the argument are all concatenated together (in the same order) to give the result.
fn flatten<A: Clone>(xss: List<&List<A>>) -> List<A>
Same as concat
.
impl<'a, A> List<A>
fn iter(&'a self, f: |&'a A|)
list![a1, ..., an].iter(f)
applies f
in turn to a1, ..., an
. It is
equivalent to {f(a1); f(a2); ...; f(an);}
.
fn iteri(&'a self, f: |int, &'a A|)
Same as iter
, but the function is applied to the index of the elements
as first argument (counting from 0), and the element itself as second
argument.
fn map<B>(&'a self, f: |&'a A| -> B) -> List<B>
list![a1, ..., an].map(f)
applies function f
to a1, ..., an
, and
builds the list list![f(a1), ..., f(an)]
with the results returned by
f
.
fn mapi<B>(&'a self, f: |int, &'a A| -> B) -> List<B>
Same as map
, but the function is applied to the index of the elements
as first argument (counting from 0), and the element itself as second
argument.
fn rev_map<B>(&'a self, f: |&'a A| -> B) -> List<B>
l.rev_map(f)
gives the same results as l.rev().map(f)
.
fn fold_left<B>(&'a self, f: |B, &'a A| -> B, a: B) -> B
list![b1, ..., bn].fold_left(f, a)
is f (... (f ( f a b1) b2) ... )
bn
.
fn fold_right<B>(&'a self, f: |&'a A, B| -> B, a: B) -> B
list![a1, ..., an].fold_right(f, b)
is f a1 (f a2 (... (f an b) ...))
.
fn iter2<'b, B>(&'a self, f: |&'a A, &'b B|, ys: &'b List<B>) -> Option<()>
list![a1, ..., an].iter2(f, list![b1, ..., bn])
calls in turn
f(a1, b1), ..., f(an, bn)
. Return None
if the two lists have
different lengths.
fn map2<'b, B, C>(&'a self, f: |&'a A, &'b B| -> C, ys: &'b List<B>) -> Option<List<C>>
list![a1, ..., an].map2(f, list![b1, ..., bn])
is
list![f(a1, b1), ..., f(an, bn)]
. Return None
if the two lists have
different lengths.
fn rev_map2<'b, B, C>(&'a self, f: |&'a A, &'b B| -> C, ys: &'b List<B>) -> Option<List<C>>
l1.rev_map2(f, l2)
gives the same result as l1.map2(f, l2).rev()
.
fn fold_left2<'b, B, C>(&'a self, f: |C, &'a A, &'b B| -> C, a: C, ys: &'b List<B>) -> Option<C>
list![a1, ..., an].fold_left2(f, a, list![b1, ..., bn])
is
f (... (f (f a a1 b1) a2 b2) ...) an bn
. Return None
if the two
lists have different length.
fn fold_right2<'b, B, C>(&'a self, f: |&'a A, &'b B, C| -> C, ys: &'b List<B>, a: C) -> Option<C>
list![a1, ..., an].fold_right2(f, a, list![b1, ..., bn])
is
f a1 b1 (f a2 b2 (... (f an bn a) ...))
. Return None
if the two
lists have different length.
fn for_all(&'a self, p: |&'a A| -> bool) -> bool
list![a1, ..., an].for_all(p)
checks if all elements of the list
satisfy the predicate p
. That is, it returns
(p(a1)) && (p(a2)) && ... && (p(an))
fn exists(&'a self, p: |&'a A| -> bool) -> bool
list![a1, ..., an].for_all(p)
checks if at least one element of the
list satisfies the predicate p
. That is, it returns
(p(a1)) || (p(a2)) || ... || (p(an))
fn for_all2<'b, B>(&'a self, p: |&'a A, &'b B| -> bool, ys: &'b List<B>) -> Option<bool>
Same as List::for_all
, but for a two-argument predicate. Return None
if the two lists have different lengths.
fn exists2<'b, B>(&'a self, p: |&'a A, &'b B| -> bool, ys: &'b List<B>) -> Option<bool>
Same as List::exists
, but for a two-argument predicate. Return None
if the two lists have different lengths.
impl<'a, A: Eq> List<A>
impl<A: Clone> List<A>
fn find(&self, p: |&A| -> bool) -> Option<A>
l.find(p)
returns the first element of the list l
that satisfies the
predicate p
. Return None
if there is no value that satisfies p
in
the list l
.
fn filter(&self, p: |&A| -> bool) -> List<A>
l.filter(p)
returns all the elements of the list l
that satisfy the
predicate p
. The order of the elements in the input list is preserved.
fn find_all(&self, p: |&A| -> bool) -> List<A>
find_all
is another name for filter
.
fn partition(&self, p: |&A| -> bool) -> (List<A>, List<A>)
l.partition(p)
returns a pair of lists (l1, l2)
where l1
is the
list of all the elements of l
that satisfy the predicate p
, and l2
is the list of all elements of l
that do not satisfy p
. The order of
the elements in the input list is preserved.
impl<A: Eq, B: Clone> List<(A, B)>
fn assoc(&self, x: A) -> Option<B>
l.assoc(a)
returns the value associated with key x
in the list of
pairs l
. That is, list![..., (x, y), ...].assoc(x) == y
if (x, y)
is the leftmost binding of a
in list l
. Return None
if there is no
value associated with x
in the list l
.
impl<A: Eq, B> List<(A, B)>
fn mem_assoc(&self, x: A) -> bool
Same as assoc
, but simple return true if a binding exists, and false
if no bindings exist for the given key.
impl<A: Eq + Clone, B: Clone> List<(A, B)>
fn remove_assoc(&self, x: A) -> List<(A, B)>
l.remove_assoc(x)
returns the list of pairs l
without the first pair
with key x
, if any.
impl<A: Clone, B: Clone> List<(A, B)>
fn split(&self) -> (List<A>, List<B>)
Transform a list of pairs into a pair of lists: list![(a1, b1), ...,
(an, bn)].split()
is (list![a1, ..., an], list![b1, ..., bn])
.
impl<A: Clone> List<A>
fn combine<B: Clone>(&self, ys: &List<B>) -> Option<List<(A, B)>>
Transform a pair of lists into a list of pairs:
list![a1, ..., an].combine(list![b1, ..., bn])
is list![(a1,b2), ...,
(an,bn)]
. Return None
if the two lists have different lengths.
fn sort(&self, cmp: |&A, &A| -> int) -> List<A>
Sort a list in increasing order according to a comparison function. The comparison function must return 0 if the arguments compare as equal, a positive integer if the first is greater, and a negative integer if the first is smaller. The resulting list is sorted in increasing order.
fn stable_sort(&self, cmp: |&A, &A| -> int) -> List<A>
Same as sort
but the sorting algorithm is guaranteed to be stable
(i.e. elements that compare equal are kept in their original order).
fn fast_sort(&self, cmp: |&A, &A| -> int) -> List<A>
Same as sort
or stable_sort
, whichever is faster on typical input.
fn sort_uniq(&self, cmp: |&A, &A| -> int) -> List<A>
Same as sort
, but also remove duplicates.
fn merge(&self, cmp: |&A, &A| -> int, ys: &List<A>) -> List<A>
Merge two lists: Assuming that l1
and l2
are sorted according to the
comparison function cmp
, l1.merge(cmp, l2)
will return a sorted list
containing all the elemnts of l1
and l2
. If several elements compare
equal, the elements of l1
will be before the elements of l2
.
impl<A> List<A>
fn into_hd(self) -> Option<A>
Non-borrowing implementation of hd
.
fn into_tl(self) -> Option<List<A>>
Non-borrowing implementation of tl
.
fn into_nth(self, i: uint) -> Option<A>
Non-borrowing implementation of nth
.
fn appended(self, ys: List<A>) -> List<A>
Non-borrowing implementation of append
.
fn rev_appended(self, ys: List<A>) -> List<A>
Non-borrowing implementation of rev_append
.
fn concated<A>(xss: List<List<A>>) -> List<A>
Non-borrowing implementation of concat
.
fn flattened<A>(xss: List<List<A>>) -> List<A>
Non-borrowing implementation of flatten
.
fn itered(self, f: |A|)
Non-borrowing implementation of iter
.
fn iteried(self, f: |int, A|)
Non-borrowing implementation of iteri
.
fn mapped<B>(self, f: |A| -> B) -> List<B>
Non-borrowing implementation of map
.
fn mapied<B>(self, f: |int, A| -> B) -> List<B>
Non-borrowing implementation of mapi
.
fn rev_mapped<B>(self, f: |A| -> B) -> List<B>
Non-borrowing implementation of rev_map
.
fn folded_left<B>(self, f: |B, A| -> B, a: B) -> B
Non-borrowing implementation of fold_left
.
fn folded_right<B>(self, f: |A, B| -> B, a: B) -> B
Non-borrowing implementation of fold_right
.
fn itered2<B>(self, f: |A, B|, ys: List<B>) -> Option<()>
Non-borrowing implementation of iter2
.
fn mapped2<B, C>(self, f: |A, B| -> C, ys: List<B>) -> Option<List<C>>
Non-borrowing implementation of map2
.
fn rev_mapped2<B, C>(self, f: |A, B| -> C, ys: List<B>) -> Option<List<C>>
Non-borrowing implementation of rev_map2
.
fn folded_left2<B, C>(self, f: |C, A, B| -> C, a: C, ys: List<B>) -> Option<C>
Non-borrowing implementation of fold_left2
.
fn folded_right2<B, C>(self, f: |A, B, C| -> C, ys: List<B>, a: C) -> Option<C>
Non-borrowing implementation of fold_right2
.
fn for_alled(self, p: |A| -> bool) -> bool
Non-borrowing implementation of for_all
.
fn into_exists(self, p: |A| -> bool) -> bool
Non-borrowing implementation of exists
.
fn for_alled2<B>(self, p: |A, B| -> bool, ys: List<B>) -> Option<bool>
Non-borrowing implementation of for_all2
.
fn into_exists2<B>(self, p: |A, B| -> bool, ys: List<B>) -> Option<bool>
Non-borrowing implementation of exists2
.
impl<A: Eq> List<A>
impl<A> List<A>
fn found(self, p: |&A| -> bool) -> Option<A>
Non-borrowing implementation of find
.
fn filtered(self, p: |&A| -> bool) -> List<A>
Non-borrowing implementation of filter
.
fn found_all(self, p: |&A| -> bool) -> List<A>
Non-borrowing implementation of find_all
.
fn partitioned(self, p: |&A| -> bool) -> (List<A>, List<A>)
Non-borrowing implementation of partition
.
impl<A: Eq, B> List<(A, B)>
fn assoced(self, x: A) -> Option<B>
Non-borrowing implementation of assoc
.
fn mem_assoced(self, x: A) -> bool
Non-borrowing implementation of mem_assoc
.
fn remove_assoced(self, x: A) -> List<(A, B)>
Non-borrowing implementation of remove_assoc
.
impl<A, B> List<(A, B)>
impl<A> List<A>
fn combined<B>(self, ys: List<B>) -> Option<List<(A, B)>>
Non-borrowing implementation of combine
.
fn sorted(self, cmp: |&A, &A| -> int) -> List<A>
Non-borrowing implementation of sort
.
fn stable_sorted(self, cmp: |&A, &A| -> int) -> List<A>
Non-borrowing implementation of stable_sort
.
fn fast_sorted(self, cmp: |&A, &A| -> int) -> List<A>
Non-borrowing implementation of fast_sort
.
fn sorted_uniq(self, cmp: |&A, &A| -> int) -> List<A>
Non-borrowing implementation of sort_uniq
.
fn merged(self, cmp: |&A, &A| -> int, ys: List<A>) -> List<A>
Non-borrowing implementation of merge
.
impl<'a, A> List<A>
impl<A> List<A>
Trait Implementations
impl<A> FromIterator<A> for List<A>
impl<A: Show> Show for List<A>
fn fmt(&self, f: &mut Formatter) -> Result
let nil: List<int> = Nil; assert_eq!(format!("{}", nil), "[]"); assert_eq!(format!("{}", list![1i]), "[1]"); assert_eq!(format!("{}", list![1i, 2]), "[1, 2]"); assert_eq!(format!("{}", list![1i, 2, 3]), "[1, 2, 3]");