Struct dioxus_shareables::list::List

pub struct List<T>(_);

A list of shareable values.

Using a List<T> rather than a Vec<T> allows components which use only one or two list items to get updated only when the specific list items they use are changed.

use dioxus_shareables::{shareable, List, ListEntry};

shareable!(Numbers: List<usize> = [3, 5, 7].into_iter().collect());

#[allow(non_snake_case)]
fn ListNumbers(cx: Scope) -> Element {
    let nums = Numbers.use_rw(&cx); // This component is updated when new items are added to or
                                    // removed from the list, but not when the individual list
                                    // items change.
    let w = nums.clone();
    cx.render(rsx! {
        ul {
            nums.read().iter().map(|n| rsx! { ListItem { num: n } })
        }
        button {
            onclick: move |_| {
                let mut w = w.write();
                let sum = w.iter().map(|n| *n.share_without_hook().read()).sum();
                w.push(sum)
            },
            "Sum"
        }
    })
}

#[allow(non_snake_case)]
#[inline_props]
fn ListItem(cx: Scope, num: ListEntry<usize>) -> Element {
    let num = num.use_rw(&cx); // This component is updated when this specific entry in the
                               // list is modified.
    let w1 = num.clone();
    let w2 = num.clone();
    let num = num.read();

    cx.render(rsx! {
        li {
            "{num}",
            button { onclick: move |_| *w1.write() += 1, "+" }
            button { onclick: move |_| *w2.write() -= 1, "-" }
        }
    })
}

List is a Vec internally, and the methods it implements therefore get their names and behavior from Vec.

Implementations

impl<T> List<T>

pub fn append(&mut self, o: &mut Self)

See Vec::append

pub fn capacity(&self) -> usize

See Vec::capacity

pub fn clear(&mut self)

See Vec::clear

pub fn dedup(&mut self)where
    T: PartialEq,

See Vec::dedup

pub fn dedup_by<F: FnMut(&T, &T) -> bool>(&mut self, f: F)

See Vec::dedup_by

pub fn dedup_by_key<K: PartialEq, F: FnMut(&T) -> K>(&mut self, f: F)

See Vec::dedup_by_key

pub fn drain<'a, R: RangeBounds<usize>>(
    &'a mut self,
    range: R
) -> Map<Drain<'a, ListEntry<T>>, fn(_: ListEntry<T>) -> Shared<T, W>>where
    T: 'static,

See Vec::drain

pub fn insert(&mut self, index: usize, element: T)

See Vec::insert

pub fn is_empty(&self) -> bool

See Vec::is_empty

pub fn len(&self) -> usize

See Vec::len

pub fn new() -> Self

See Vec::new

pub fn pop(&mut self) -> Option<Shared<T, W>>

See Vec::pop

pub fn push(&mut self, value: T)

See Vec::push

pub fn remove(&mut self, index: usize) -> Shared<T, W>

See Vec::remove

pub fn reserve(&mut self, additional: usize)

See Vec::reserve

pub fn reserve_exact(&mut self, additional: usize)

See Vec::reserve_exact

pub fn resize(&mut self, new_len: usize, t: T)where
    T: Clone,

See Vec::resize

pub fn resize_with<F: FnMut() -> T>(&mut self, new_len: usize, f: F)

See Vec::resize_with

pub fn retain<F: FnMut(&T) -> bool>(&mut self, f: F)

See Vec::retain

pub fn retain_mut<F: FnMut(&mut ListEntry<T>) -> bool>(&mut self, f: F)where
    T: 'static,

See Vec::retain

pub fn shrink_to(&mut self, min_capacity: usize)

See Vec::shrink_to

pub fn shrink_to_fit(&mut self)

See Vec::shrink_to_fit

pub fn splice<'a, R: RangeBounds<usize>, I: 'a + IntoIterator<Item = T>>(
    &'a mut self,
    range: R,
    replace_with: I
) -> impl 'a + Iterator<Item = Shared<T, W>>where
    T: 'static,

See Vec::splice

pub fn split_off(&mut self, at: usize) -> Self

See Vec::split_off

pub fn swap_remove(&mut self, index: usize) -> Shared<T, W>

See Vec::swap_remove

pub fn truncate(&mut self, len: usize)

See [’Vec::truncate`]

pub fn try_reserve(&mut self, additional: usize) -> Result<(), TryReserveError>

See [’Vec::try_reserve`]

pub fn try_reserve_exact(
    &mut self,
    additional: usize
) -> Result<(), TryReserveError>

See [’Vec::try_reserve_exact`]

pub fn with_capcity(capacity: usize) -> Self

See [’Vec::with_capacity`]

pub fn binary_search(&self, x: &T) -> Result<usize, usize>where
    T: Ord,

See [[_]::binary_search]

pub fn binary_search_by<F: FnMut(&T) -> Ordering>(
    &self,
    f: F
) -> Result<usize, usize>

See [[_]::binary_search]

pub fn binary_search_by_key<B: Ord, F: FnMut(&T) -> B>(
    &self,
    b: &B,
    f: F
) -> Result<usize, usize>

See [[_]::binary_search_by_key]

pub fn contains(&self, x: &T) -> boolwhere
    T: PartialEq,

See [[_]::contains]

pub fn ends_with(&self, needle: &[T]) -> boolwhere
    T: PartialEq,

See [[_]::ends_with]

pub fn fill(&mut self, t: T)where
    T: Clone,

See [[_]::fill]

Note: This replaces items, rather than changing their value, so components which were linked to the list before will not (necessarily) update.

pub fn fill_with<F: FnMut() -> T>(&mut self, f: F)

See [[_]::fill_with]

Note: This replaces items, rather than changing their value, so components which were linked to the list before will not (necessarily) update.

pub fn first(&self) -> Option<ListEntry<T>>

See [[_]::first]

pub fn get(&self, index: usize) -> Option<ListEntry<T>>

See [[_]::get]

pub unsafe fn get_unchecked(&self, index: usize) -> ListEntry<T>

See [[_]::get_unchecked]

pub fn iter<'a>(&'a self) -> <&'a Self as IntoIterator>::IntoIter

See [[_]::iter]

pub fn last(&self) -> Option<ListEntry<T>>

See [[_]::last]

pub fn partition_point<P: FnMut(&T) -> bool>(&self, pred: P) -> usize

See [[_]::partition_point]

pub fn reverse(&mut self)

See [[_]::reverse]

pub fn rotate_left(&mut self, mid: usize)

See [[_]::rotate_left]

pub fn rotate_right(&mut self, mid: usize)

See [[_]::rotate_right]

pub fn sort(&mut self)where
    T: Ord,

See [[_]::sort]

pub fn sort_by<F: FnMut(&T, &T) -> Ordering>(&mut self, f: F)

See [[_]::sort_by]

pub fn sort_by_cached_key<U: Ord, F: FnMut(&T) -> U>(&mut self, f: F)

See [[_]::sort_by]

pub fn sort_by_key<U: Ord, F: FnMut(&T) -> U>(&mut self, f: F)

See [[_]::sort_by]

pub fn sort_unstable(&mut self)where
    T: Ord,

See [[_]::sort]

pub fn sort_unstable_by<F: FnMut(&T, &T) -> Ordering>(&mut self, f: F)

See [[_]::sort_by]

pub fn sort_unstable_by_key<U: Ord, F: FnMut(&T) -> U>(&mut self, f: F)

See [[_]::sort_by]

pub fn starts_with(&self, needle: &[T]) -> boolwhere
    T: PartialEq,

See [[_]::starts_with]

pub fn swap(&mut self, a: usize, b: usize)

See [[_]::swap]

Trait Implementations

impl<'a, T: 'a + Clone> Extend<&'a T> for List<T>

fn extend<I: IntoIterator<Item = &'a T>>(&mut self, iter: I)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl<T> Extend<T> for List<T>

fn extend<I: IntoIterator<Item = T>>(&mut self, iter: I)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

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

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

Creates a value from an iterator.

impl<'a, T> IntoIterator for &'a List<T>

type Item = ListEntry<T>

The type of the elements being iterated over.

type IntoIter = Cloned<Iter<'a, ListEntry<T>>>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.