Trait VectorFn 

pub trait VectorFn<T> {
    // Required methods
    fn len(&self) -> usize;
    fn at(&self, i: usize) -> T;

    // Provided methods
    fn into_iter(self) -> VectorFnIter<Self, T> 
       where Self: Sized { ... }
    fn iter<'a>(&'a self) -> VectorFnIter<&'a Self, T>  { ... }
    fn map_fn<F: Fn(T) -> U, U>(self, func: F) -> VectorFnMap<Self, T, U, F>
       where Self: Sized { ... }
    fn step_by_fn(self, step_by: usize) -> StepByFn<Self, T>
       where Self: Sized { ... }
}

A trait for objects that provides random-position access to a 1-dimensional sequence (or vector) of elements that returned by value.

Related traits

Other traits that represent sequences are

• ExactSizeIterator: Also returns elements by value; However, to avoid copying elements, an ExactSizeIterator returns every item only once, and only in the order of the underlying vector.
• VectorView: Returns only references to the underlying data, but also supports random-position access. Note that VectorView<T> is not the same as VectorFn<&T>, since the lifetime of returned references &T in the case of VectorView is the lifetime of the vector, but in the case of VectorFn, it must be a fixed lifetime parameter.

Finally, there is the subtrait SelfSubvectorFn, which directly supports taking subvectors.

Example

fn compute_sum<V: VectorFn<usize>>(vec: V) -> usize {
    let mut result = 0;
    for i in 0..vec.len() {
        result += vec.at(i);
    }
    return result;
}
assert_eq!(10, compute_sum(1..5));
assert_eq!(10, compute_sum([1, 2, 3, 4].copy_els()));
assert_eq!(10, compute_sum(vec![1, 2, 3, 4].copy_els()));
assert_eq!(10, compute_sum((&[1, 2, 3, 4, 5][..4]).copy_els()));

Required Methods

fn len(&self) -> usize

fn at(&self, i: usize) -> T

Provided Methods

fn into_iter(self) -> VectorFnIter<Self, T>

where Self: Sized,

Produces an iterator over the elements of this VectorFn.

This transfers ownership of the object to the iterator. If this is not desired, consider using VectorFn::iter().

Note that VectorFns do not necessarily implement IntoIterator and instead use this function. The reason for that is twofold:

• the only way of making all types implementing VectorFns to also implement IntoIterator would be to define VectorFn as a subtrait of IntoIterator. However, this conflicts with the decision to have VectorFn have the element type as generic parameter, since IntoIterator uses an associated type.
• If the above problem could somehow be circumvented, for types that implement both Iterator and VectorFn (like Range), calling into_iter() would then require fully-qualified call syntax, which is very unwieldy.

fn iter<'a>(&'a self) -> VectorFnIter<&'a Self, T>

Produces an iterator over the elements of this VectorFn.

See also VectorFn::into_iter() if a transfer of ownership is required.

fn map_fn<F: Fn(T) -> U, U>(self, func: F) -> VectorFnMap<Self, T, U, F>

where Self: Sized,

NB: Named map_fn to avoid conflicts with map of Iterator

fn step_by_fn(self, step_by: usize) -> StepByFn<Self, T>

where Self: Sized,

NB: Named step_by_fn to avoid conflicts with step_by of Iterator

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl VectorFn<usize> for Range<usize>

Why no impl for Range<i64> etc?

It is a common pattern to write (0..n).map_fn(|x| ...) to create general VectorFns. If we provide impls for multiple Ranges, then in this case however, explicit type arguments will be necessary. Instead, if you require a VectorFn over another numerical type T, consider using ((start as usize)..(end as usize)).map_fn(|x| x as T).

fn at(&self, i: usize) -> usize

fn len(&self) -> usize

impl<'a, T, V: ?Sized + VectorFn<T>> VectorFn<T> for &'a V

fn len(&self) -> usize

fn at(&self, i: usize) -> T

Implementors

impl<'a, V: ?Sized + VectorView<T>, T: ?Sized> VectorFn<&'a T> for VectorViewFn<'a, V, T>

impl<V: VectorFn<T>, T> VectorFn<T> for StepByFn<V, T>

impl<V: VectorFn<T>, T> VectorFn<T> for SubvectorFn<V, T>

impl<V: VectorFn<T>, T, U, F: Fn(T) -> U> VectorFn<U> for VectorFnMap<V, T, U, F>

impl<V: VectorView<T>, T, F: Fn(&T) -> T> VectorFn<T> for CloneElFn<V, T, F>