Trait druid::piet::cairo::glib::bitflags::_core::iter::FromIterator

pub trait FromIterator<A>: Sized {
    // Required method
    fn from_iter<T>(iter: T) -> Self
       where T: IntoIterator<Item = A>;
}

Conversion from an Iterator.

By implementing FromIterator for a type, you define how it will be created from an iterator. This is common for types which describe a collection of some kind.

If you want to create a collection from the contents of an iterator, the Iterator::collect() method is preferred. However, when you need to specify the container type, FromIterator::from_iter() can be more readable than using a turbofish (e.g. ::<Vec<_>>()). See the Iterator::collect() documentation for more examples of its use.

See also: IntoIterator.

Examples

Basic usage:

let five_fives = std::iter::repeat(5).take(5);

let v = Vec::from_iter(five_fives);

assert_eq!(v, vec![5, 5, 5, 5, 5]);

Using Iterator::collect() to implicitly use FromIterator:

let five_fives = std::iter::repeat(5).take(5);

let v: Vec<i32> = five_fives.collect();

assert_eq!(v, vec![5, 5, 5, 5, 5]);

Using FromIterator::from_iter() as a more readable alternative to Iterator::collect():

use std::collections::VecDeque;
let first = (0..10).collect::<VecDeque<i32>>();
let second = VecDeque::from_iter(0..10);

assert_eq!(first, second);

Implementing FromIterator for your type:

// A sample collection, that's just a wrapper over Vec<T>
#[derive(Debug)]
struct MyCollection(Vec<i32>);

// Let's give it some methods so we can create one and add things
// to it.
impl MyCollection {
    fn new() -> MyCollection {
        MyCollection(Vec::new())
    }

    fn add(&mut self, elem: i32) {
        self.0.push(elem);
    }
}

// and we'll implement FromIterator
impl FromIterator<i32> for MyCollection {
    fn from_iter<I: IntoIterator<Item=i32>>(iter: I) -> Self {
        let mut c = MyCollection::new();

        for i in iter {
            c.add(i);
        }

        c
    }
}

// Now we can make a new iterator...
let iter = (0..5).into_iter();

// ... and make a MyCollection out of it
let c = MyCollection::from_iter(iter);

assert_eq!(c.0, vec![0, 1, 2, 3, 4]);

// collect works too!

let iter = (0..5).into_iter();
let c: MyCollection = iter.collect();

assert_eq!(c.0, vec![0, 1, 2, 3, 4]);

Required Methods

fn from_iter<T>(iter: T) -> Selfwhere T: IntoIterator<Item = A>,

Creates a value from an iterator.

See the module-level documentation for more.

Examples

Basic usage:

let five_fives = std::iter::repeat(5).take(5);

let v = Vec::from_iter(five_fives);

assert_eq!(v, vec![5, 5, 5, 5, 5]);

Implementors

impl FromIterator<PathEl> for druid::piet::kurbo::BezPath

impl FromIterator<char> for String

impl FromIterator<()> for ()

Collapses all unit items from an iterator into one.

This is more useful when combined with higher-level abstractions, like collecting to a Result<(), E> where you only care about errors:

use std::io::*;
let data = vec![1, 2, 3, 4, 5];
let res: Result<()> = data.iter()
    .map(|x| writeln!(stdout(), "{x}"))
    .collect();
assert!(res.is_ok());

impl FromIterator<PdfOutline> for PdfOutline

impl FromIterator<BindingFlags> for BindingFlags

impl FromIterator<FormatSizeFlags> for FormatSizeFlags

impl FromIterator<IOCondition> for IOCondition

impl FromIterator<KeyFileFlags> for KeyFileFlags

impl FromIterator<LogLevelFlags> for LogLevelFlags

impl FromIterator<LogLevels> for LogLevels

impl FromIterator<OptionFlags> for OptionFlags

impl FromIterator<ParamFlags> for ParamFlags

impl FromIterator<SignalFlags> for SignalFlags

impl FromIterator<SpawnFlags> for SpawnFlags

impl FromIterator<Box<str, Global>> for String

impl FromIterator<String> for String

impl FromIterator<OsString> for OsString

impl FromIterator<AccelFlags> for AccelFlags

impl FromIterator<AnchorHints> for AnchorHints

impl FromIterator<AppInfoCreateFlags> for AppInfoCreateFlags

impl FromIterator<ApplicationFlags> for ApplicationFlags

impl FromIterator<ApplicationInhibitFlags> for ApplicationInhibitFlags

impl FromIterator<AskPasswordFlags> for AskPasswordFlags

impl FromIterator<AxisFlags> for AxisFlags

impl FromIterator<BusNameOwnerFlags> for BusNameOwnerFlags

impl FromIterator<BusNameWatcherFlags> for BusNameWatcherFlags

impl FromIterator<CalendarDisplayOptions> for CalendarDisplayOptions

impl FromIterator<CellRendererState> for CellRendererState

impl FromIterator<ConverterFlags> for ConverterFlags

impl FromIterator<DBusCallFlags> for DBusCallFlags

impl FromIterator<DBusCapabilityFlags> for DBusCapabilityFlags

impl FromIterator<DBusConnectionFlags> for DBusConnectionFlags

impl FromIterator<DBusInterfaceSkeletonFlags> for DBusInterfaceSkeletonFlags

impl FromIterator<DBusMessageFlags> for DBusMessageFlags

impl FromIterator<DBusProxyFlags> for DBusProxyFlags

impl FromIterator<DBusSendMessageFlags> for DBusSendMessageFlags

impl FromIterator<DBusServerFlags> for DBusServerFlags

impl FromIterator<DBusSignalFlags> for DBusSignalFlags

impl FromIterator<DestDefaults> for DestDefaults

impl FromIterator<DialogFlags> for DialogFlags

impl FromIterator<DragAction> for DragAction

impl FromIterator<DriveStartFlags> for DriveStartFlags

impl FromIterator<EventMask> for EventMask

impl FromIterator<FileAttributeInfoFlags> for FileAttributeInfoFlags

impl FromIterator<FileCopyFlags> for FileCopyFlags

impl FromIterator<FileCreateFlags> for FileCreateFlags

impl FromIterator<FileFilterFlags> for FileFilterFlags

impl FromIterator<FileMeasureFlags> for FileMeasureFlags

impl FromIterator<FileMonitorFlags> for FileMonitorFlags

impl FromIterator<FileQueryInfoFlags> for FileQueryInfoFlags

impl FromIterator<FontMask> for FontMask

impl FromIterator<FrameClockPhase> for FrameClockPhase

impl FromIterator<HyperlinkStateFlags> for HyperlinkStateFlags

impl FromIterator<IOStreamSpliceFlags> for IOStreamSpliceFlags

impl FromIterator<IconLookupFlags> for IconLookupFlags

impl FromIterator<InputHints> for InputHints

impl FromIterator<JunctionSides> for JunctionSides

impl FromIterator<ModifierType> for ModifierType

impl FromIterator<Modifiers> for Modifiers

impl FromIterator<MountMountFlags> for MountMountFlags

impl FromIterator<MountUnmountFlags> for MountUnmountFlags

impl FromIterator<OutputStreamSpliceFlags> for OutputStreamSpliceFlags

impl FromIterator<PathEl> for BezPath

impl FromIterator<PixbufFormatFlags> for PixbufFormatFlags

impl FromIterator<PlacesOpenFlags> for PlacesOpenFlags

impl FromIterator<RecentFilterFlags> for RecentFilterFlags

impl FromIterator<RegionFlags> for RegionFlags

impl FromIterator<ResourceLookupFlags> for ResourceLookupFlags

impl FromIterator<SeatCapabilities> for SeatCapabilities

impl FromIterator<SerializeFlags> for SerializeFlags

impl FromIterator<SettingsBindFlags> for SettingsBindFlags

impl FromIterator<ShapeFlags> for ShapeFlags

impl FromIterator<ShowFlags> for ShowFlags

impl FromIterator<StateFlags> for StateFlags

impl FromIterator<StyleContextPrintFlags> for StyleContextPrintFlags

impl FromIterator<SubprocessFlags> for SubprocessFlags

impl FromIterator<TargetFlags> for TargetFlags

impl FromIterator<TextSearchFlags> for TextSearchFlags

impl FromIterator<TlsCertificateFlags> for TlsCertificateFlags

impl FromIterator<TlsDatabaseVerifyFlags> for TlsDatabaseVerifyFlags

impl FromIterator<TlsPasswordFlags> for TlsPasswordFlags

impl FromIterator<ToolPaletteDragTargets> for ToolPaletteDragTargets

impl FromIterator<Transformations> for Transformations

impl FromIterator<TreeModelFlags> for TreeModelFlags

impl FromIterator<WMDecoration> for WMDecoration

impl FromIterator<WMFunction> for WMFunction

impl FromIterator<WindowHints> for WindowHints

impl FromIterator<WindowState> for WindowState

impl<'a> FromIterator<&'a char> for String

impl<'a> FromIterator<&'a str> for String

impl<'a> FromIterator<&'a OsStr> for OsString

impl<'a> FromIterator<Cow<'a, str>> for String

impl<'a> FromIterator<Cow<'a, OsStr>> for OsString

impl<'a> FromIterator<char> for Cow<'a, str>

impl<'a> FromIterator<String> for Cow<'a, str>

impl<'a, 'b> FromIterator<&'b str> for Cow<'a, str>

impl<'a, T> FromIterator<T> for Cow<'a, [T]>where T: Clone,

impl<'args, K, V> FromIterator<(K, V)> for FluentArgs<'args>where K: Into<Cow<'args, str>>, V: Into<FluentValue<'args>>,

impl<A> FromIterator<<A as Array>::Item> for SmallVec<A>where A: Array,

impl<A> FromIterator<A> for Vector<A>where A: Clone,

impl<A, E, V> FromIterator<Result<A, E>> for Result<V, E>where V: FromIterator<A>,

impl<A, N> FromIterator<Option<A>> for SparseChunk<A, N>where N: Bits + ChunkLength<A>,

impl<A, N> FromIterator<A> for Chunk<A, N>where N: ChunkLength<A>,

impl<A, R> FromIterator<R> for OrdSet<A>where A: Ord + Clone + From<R>,

impl<A, RA, S> FromIterator<RA> for druid::im::HashSet<A, S>where A: Hash + Eq + Clone + From<RA>, S: BuildHasher + Default,

impl<A, T> FromIterator<A> for InlineArray<A, T>

impl<A, V> FromIterator<Option<A>> for Option<V>where V: FromIterator<A>,

impl<F> FromIterator<F> for JoinAll<F>where F: Future,

impl<F> FromIterator<F> for TryJoinAll<F>where F: TryFuture,

impl<Fut> FromIterator<Fut> for FuturesOrdered<Fut>where Fut: Future,

impl<Fut> FromIterator<Fut> for FuturesUnordered<Fut>

impl<Fut> FromIterator<Fut> for SelectAll<Fut>where Fut: Future + Unpin,

impl<Fut> FromIterator<Fut> for SelectOk<Fut>where Fut: TryFuture + Unpin,

impl<I> FromIterator<I> for Box<[I], Global>

impl<K, V> FromIterator<(K, V)> for BTreeMap<K, V, Global>where K: Ord,

impl<K, V, RK, RV> FromIterator<(RK, RV)> for OrdMap<K, V>where K: Ord + Clone + From<RK>, V: Clone + From<RV>,

impl<K, V, S> FromIterator<(K, V)> for druid::im::HashMap<K, V, S>where K: Hash + Eq + Clone, V: Clone, S: BuildHasher + Default,

impl<K, V, S> FromIterator<(K, V)> for std::collections::hash::map::HashMap<K, V, S>where K: Eq + Hash, S: BuildHasher + Default,

impl<P> FromIterator<P> for PathBufwhere P: AsRef<Path>,

impl<St> FromIterator<St> for SelectAll<St>where St: Stream + Unpin,

impl<T> FromIterator<(usize, T)> for Slab<T>

Create a slab from an iterator of key-value pairs.

If the iterator produces duplicate keys, the previous value is replaced with the later one. The keys does not need to be sorted beforehand, and this function always takes O(n) time. Note that the returned slab will use space proportional to the largest key, so don’t use Slab with untrusted keys.

Examples

let vec = vec![(2,'a'), (6,'b'), (7,'c')];
let slab = vec.into_iter().collect::<Slab<char>>();
assert_eq!(slab.len(), 3);
assert!(slab.capacity() >= 8);
assert_eq!(slab[2], 'a');

With duplicate and unsorted keys:

let vec = vec![(20,'a'), (10,'b'), (11,'c'), (10,'d')];
let slab = vec.into_iter().collect::<Slab<char>>();
assert_eq!(slab.len(), 3);
assert_eq!(slab[10], 'd');

impl<T> FromIterator<T> for Variantwhere T: ToVariant + StaticVariantType,

impl<T> FromIterator<T> for BinaryHeap<T>where T: Ord,

impl<T> FromIterator<T> for BTreeSet<T, Global>where T: Ord,

impl<T> FromIterator<T> for LinkedList<T>

impl<T> FromIterator<T> for VecDeque<T, Global>

impl<T> FromIterator<T> for Rc<[T]>

impl<T> FromIterator<T> for Arc<[T]>

impl<T> FromIterator<T> for Vec<T, Global>

impl<T> FromIterator<T> for RGB<T>

impl<T> FromIterator<T> for RGBA<T, T>

impl<T, L> FromIterator<(T, L)> for Targetswhere T: Into<String>, L: Into<LevelFilter>,

impl<T, S> FromIterator<T> for std::collections::hash::set::HashSet<T, S>where T: Eq + Hash, S: BuildHasher + Default,

impl<T, const CAP: usize> FromIterator<T> for ArrayVec<T, CAP>

Create an ArrayVec from an iterator.

Panics if the number of elements in the iterator exceeds the arrayvec’s capacity.