Trait nom::lib::std::prelude::v1::v1::Send

pub unsafe auto trait Send { }

Types that can be transferred across thread boundaries.

This trait is automatically implemented when the compiler determines it's appropriate.

An example of a non-Send type is the reference-counting pointer rc::Rc. If two threads attempt to clone Rcs that point to the same reference-counted value, they might try to update the reference count at the same time, which is undefined behavior because Rc doesn't use atomic operations. Its cousin sync::Arc does use atomic operations (incurring some overhead) and thus is Send.

See the Nomicon for more details.

Implementations on Foreign Types

impl<'a, T> !Send for MutexGuard<'a, T> where     T: ?Sized,

impl<T> Send for Receiver<T> where     T: Send,

impl<'a, T> !Send for RwLockWriteGuard<'a, T> where     T: ?Sized,

impl<'a, T> !Send for RwLockReadGuard<'a, T> where     T: ?Sized,

impl<T> Send for Mutex<T> where     T: Send + ?Sized,

impl !Send for Args

impl<T> Send for RwLock<T> where     T: Send + ?Sized,

impl !Send for ArgsOs

impl !Send for Select

impl<T> Send for Sender<T> where     T: Send,

impl<T> Send for SyncSender<T> where     T: Send,

impl Send for Once

impl<T> Send for AtomicPtr<T>

impl<T> Send for Cell<T> where     T: Send,

impl<T> Send for RefCell<T> where     T: Send + ?Sized,

impl<T> !Send for NonNull<T> where     T: ?Sized,

NonNull pointers are not Send because the data they reference may be aliased.

impl<T> !Send for *mut T where     T: ?Sized,

impl<T> !Send for *const T where     T: ?Sized,

impl<'a, T> Send for &'a mut T where     T: Send + ?Sized,

impl<'a, T> Send for &'a T where     T: Sync + ?Sized,

impl<T> Send for Arc<T> where     T: Send + Sync + ?Sized,

impl<T> !Send for Weak<T> where     T: ?Sized,

impl<T> Send for Weak<T> where     T: Send + Sync + ?Sized,

impl<T> !Send for Rc<T> where     T: ?Sized,

impl Send for isize

impl Send for i8

impl Send for i16

impl Send for i32

impl Send for i64

impl Send for i128

impl Send for usize

impl Send for u8

impl Send for u16

impl Send for u32

impl Send for u64

impl Send for u128

impl Send for f32

impl Send for f64

impl Send for f32

impl Send for f64

impl Send for char

impl Send for str

impl Send for str

impl Send for Argument

impl Send for FormatSpec

impl Send for Alignment

impl Send for Count

impl Send for Position

Implementors

• impl<'a, T> Send for nom::lib::std::slice::Iter<'a, T> where     T: Sync,

• impl<'a, T> Send for nom::lib::std::slice::IterMut<'a, T> where     T: Send,

• impl<'a, T> Send for nom::lib::std::collections::vec_deque::Drain<'a, T> where     T: Send,

• impl<'a> Send for nom::lib::std::string::Drain<'a>

• impl<T> Send for nom::lib::std::vec::IntoIter<T> where     T: Send,

• impl<'a, T> Send for nom::lib::std::collections::linked_list::IterMut<'a, T> where     T: Send,

• impl<'a, T> Send for nom::lib::std::vec::Drain<'a, T> where     T: Send,

• impl<'a, T> Send for nom::lib::std::collections::linked_list::Iter<'a, T> where     T: Sync,

• impl<T> Send for LinkedList<T> where     T: Send,

Auto implementors

• impl Send for CompareResult

• impl<E> Send for ErrorKind<E> where     E: Send,

• impl Send for Needed

• impl<I, E> Send for Err<I, E> where     E: Send,     I: Send,

• impl Send for Endianness

• impl<T: ?Sized> Send for Box<T> where     T: Send,

• impl<T: ?Sized> Send for PinBox<T> where     T: Send,

• impl Send for Ordering

• impl<T> Send for Reverse<T> where     T: Send,

• impl Send for RandomState

• impl<'a, K, V> Send for nom::lib::std::collections::hash_map::Drain<'a, K, V> where     K: Send,     V: Send,

• impl<'a, K, V> Send for nom::lib::std::collections::hash_map::ValuesMut<'a, K, V> where     K: Send,     V: Send,

• impl<'a, K, V> !Send for nom::lib::std::collections::hash_map::VacantEntry<'a, K, V>

• impl<'a, K, V> Send for nom::lib::std::collections::hash_map::Keys<'a, K, V> where     K: Sync,     V: Sync,

• impl<K, V> Send for nom::lib::std::collections::hash_map::IntoIter<K, V> where     K: Send,     V: Send,

• impl<'a, K, V> !Send for nom::lib::std::collections::hash_map::Entry<'a, K, V>

• impl<'a, K, V> Send for nom::lib::std::collections::hash_map::Values<'a, K, V> where     K: Sync,     V: Sync,

• impl<'a, K, V> !Send for nom::lib::std::collections::hash_map::OccupiedEntry<'a, K, V>

• impl Send for DefaultHasher

• impl<K, V, S> Send for HashMap<K, V, S> where     K: Send,     S: Send,     V: Send,

• impl<'a, K, V> Send for nom::lib::std::collections::hash_map::Iter<'a, K, V> where     K: Sync,     V: Sync,

• impl<'a, K, V> Send for nom::lib::std::collections::hash_map::IterMut<'a, K, V> where     K: Send,     V: Send,

• impl<'a, T, S> Send for nom::lib::std::collections::hash_set::SymmetricDifference<'a, T, S> where     S: Sync,     T: Sync,

• impl<'a, K> Send for nom::lib::std::collections::hash_set::Drain<'a, K> where     K: Send,

• impl<'a, T, S> Send for nom::lib::std::collections::hash_set::Intersection<'a, T, S> where     S: Sync,     T: Sync,

• impl<T, S> Send for HashSet<T, S> where     S: Send,     T: Send,

• impl<K> Send for nom::lib::std::collections::hash_set::IntoIter<K> where     K: Send,

• impl<'a, T, S> Send for nom::lib::std::collections::hash_set::Difference<'a, T, S> where     S: Sync,     T: Sync,

• impl<'a, T, S> Send for nom::lib::std::collections::hash_set::Union<'a, T, S> where     S: Sync,     T: Sync,

• impl<'a, K> Send for nom::lib::std::collections::hash_set::Iter<'a, K> where     K: Sync,

• impl<T> Send for BinaryHeap<T> where     T: Send,

• impl<'a, T> Send for PeekMut<'a, T> where     T: Send,

• impl<'a, T> Send for nom::lib::std::collections::binary_heap::Iter<'a, T> where     T: Sync,

• impl<T> Send for nom::lib::std::collections::binary_heap::IntoIter<T> where     T: Send,

• impl<'a, T> Send for nom::lib::std::collections::binary_heap::Drain<'a, T> where     T: Send,

• impl<T> Send for BTreeSet<T> where     T: Send,

• impl<'a, K, V> Send for nom::lib::std::collections::btree_map::Keys<'a, K, V> where     K: Sync,     V: Sync,

• impl<'a, K, V> Send for nom::lib::std::collections::btree_map::VacantEntry<'a, K, V> where     K: Send,     V: Send,

• impl<'a, K, V> Send for nom::lib::std::collections::btree_map::Iter<'a, K, V> where     K: Sync,     V: Sync,

• impl<'a, K, V> Send for nom::lib::std::collections::btree_map::OccupiedEntry<'a, K, V> where     K: Send,     V: Send,

• impl<'a, K, V> Send for nom::lib::std::collections::btree_map::Range<'a, K, V> where     K: Sync,     V: Sync,

• impl<'a, K, V> Send for nom::lib::std::collections::btree_map::ValuesMut<'a, K, V> where     K: Send,     V: Send,

• impl<K, V> Send for BTreeMap<K, V> where     K: Send,     V: Send,

• impl<'a, K, V> Send for nom::lib::std::collections::btree_map::Entry<'a, K, V> where     K: Send,     V: Send,

• impl<'a, K, V> Send for nom::lib::std::collections::btree_map::IterMut<'a, K, V> where     K: Send,     V: Send,

• impl<K, V> Send for nom::lib::std::collections::btree_map::IntoIter<K, V> where     K: Send,     V: Send,

• impl<'a, K, V> Send for nom::lib::std::collections::btree_map::Values<'a, K, V> where     K: Sync,     V: Sync,

• impl<'a, K, V> Send for RangeMut<'a, K, V> where     K: Send,     V: Send,

• impl<T> Send for VecDeque<T> where     T: Send,

• impl<T> Send for nom::lib::std::collections::linked_list::IntoIter<T> where     T: Send,

• impl<'a, T, F> !Send for nom::lib::std::collections::linked_list::DrainFilter<'a, T, F>

• impl<T> Send for Bound<T> where     T: Send,

• impl Send for CollectionAllocErr

• impl<'a, T> Send for nom::lib::std::collections::vec_deque::Iter<'a, T> where     T: Sync,

• impl<'a, T> Send for nom::lib::std::collections::vec_deque::IterMut<'a, T> where     T: Send,

• impl<T> Send for nom::lib::std::collections::vec_deque::IntoIter<T> where     T: Send,

• impl<'a, T> Send for nom::lib::std::collections::btree_set::Union<'a, T> where     T: Sync,

• impl<'a, T> Send for nom::lib::std::collections::btree_set::SymmetricDifference<'a, T> where     T: Sync,

• impl<'a, T> Send for nom::lib::std::collections::btree_set::Difference<'a, T> where     T: Sync,

• impl<'a, T> Send for nom::lib::std::collections::btree_set::Iter<'a, T> where     T: Sync,

• impl<'a, T> Send for nom::lib::std::collections::btree_set::Range<'a, T> where     T: Sync,

• impl<'a, T> Send for nom::lib::std::collections::btree_set::Intersection<'a, T> where     T: Sync,

• impl<T> Send for nom::lib::std::collections::btree_set::IntoIter<T> where     T: Send,

• impl<'a, 'b> !Send for DebugList<'a, 'b>

• impl Send for Error

• impl<'a, 'b> !Send for DebugTuple<'a, 'b>

• impl<'a, 'b> !Send for DebugStruct<'a, 'b>

• impl<'a> !Send for Formatter<'a>

• impl<'a, 'b> !Send for DebugSet<'a, 'b>

• impl<'a, 'b> !Send for DebugMap<'a, 'b>

• impl<'a> !Send for Arguments<'a>

• impl<H> Send for BuildHasherDefault<H> where     H: Send,

• impl Send for SipHasher

• impl<T> Send for Rev<T> where     T: Send,

• impl<I> Send for Cloned<I> where     I: Send,

• impl<I> Send for Cycle<I> where     I: Send,

• impl<I> Send for StepBy<I> where     I: Send,

• impl<A, B> Send for Chain<A, B> where     A: Send,     B: Send,

• impl<A, B> Send for Zip<A, B> where     A: Send,     B: Send,

• impl<I, F> Send for Map<I, F> where     F: Send,     I: Send,

• impl<I, P> Send for Filter<I, P> where     I: Send,     P: Send,

• impl<I, F> Send for FilterMap<I, F> where     F: Send,     I: Send,

• impl<I> Send for Enumerate<I> where     I: Send,

• impl<I> Send for Peekable<I> where     I: Send,     <I as Iterator>::Item: Send,

• impl<I, P> Send for SkipWhile<I, P> where     I: Send,     P: Send,

• impl<I, P> Send for TakeWhile<I, P> where     I: Send,     P: Send,

• impl<I> Send for Skip<I> where     I: Send,

• impl<I> Send for Take<I> where     I: Send,

• impl<I, St, F> Send for Scan<I, St, F> where     F: Send,     I: Send,     St: Send,

• impl<I, U, F> Send for FlatMap<I, U, F> where     F: Send,     I: Send,     <U as IntoIterator>::IntoIter: Send,

• impl<I> Send for Flatten<I> where     I: Send,     <<I as Iterator>::Item as IntoIterator>::IntoIter: Send,

• impl<I> Send for Fuse<I> where     I: Send,

• impl<I, F> Send for Inspect<I, F> where     F: Send,     I: Send,

• impl<F> Send for RepeatWith<F> where     F: Send,

• impl<T> Send for nom::lib::std::iter::Once<T> where     T: Send,

• impl<T> Send for Empty<T> where     T: Send,

• impl<A> Send for Repeat<A> where     A: Send,

• impl<T> Send for Discriminant<T>

• impl<T> Send for ManuallyDrop<T> where     T: Send,

• impl<'a, T: ?Sized> Send for PinMut<'a, T> where     T: Send,

• impl<Idx> Send for RangeToInclusive<Idx> where     Idx: Send,

• impl<Idx> Send for RangeFrom<Idx> where     Idx: Send,

• impl<Idx> Send for RangeInclusive<Idx> where     Idx: Send,

• impl<Idx> Send for nom::lib::std::ops::Range<Idx> where     Idx: Send,

• impl<Y, R> Send for GeneratorState<Y, R> where     R: Send,     Y: Send,

• impl<Idx> Send for RangeTo<Idx> where     Idx: Send,

• impl Send for RangeFull

• impl<T> Send for Option<T> where     T: Send,

• impl<'a, A> Send for nom::lib::std::option::Iter<'a, A> where     A: Sync,

• impl<'a, A> Send for nom::lib::std::option::IterMut<'a, A> where     A: Send,

• impl<A> Send for nom::lib::std::option::IntoIter<A> where     A: Send,

• impl Send for NoneError

• impl<T, E> Send for Result<T, E> where     E: Send,     T: Send,

• impl<'a, T> Send for nom::lib::std::result::Iter<'a, T> where     T: Sync,

• impl<'a, T> Send for nom::lib::std::result::IterMut<'a, T> where     T: Send,

• impl<T> Send for nom::lib::std::result::IntoIter<T> where     T: Send,

• impl<'a, T, P> Send for SplitMut<'a, T, P> where     P: Send,     T: Send,

• impl<'a, T, P> Send for SplitNMut<'a, T, P> where     P: Send,     T: Send,

• impl<'a, T> Send for Windows<'a, T> where     T: Sync,

• impl<'a, T, P> Send for nom::lib::std::slice::RSplitN<'a, T, P> where     P: Send,     T: Sync,

• impl<'a, T> Send for ExactChunksMut<'a, T> where     T: Send,

• impl<'a, T, P> Send for nom::lib::std::slice::Split<'a, T, P> where     P: Send,     T: Sync,

• impl<'a, T, P> Send for nom::lib::std::slice::SplitN<'a, T, P> where     P: Send,     T: Sync,

• impl<'a, T, P> Send for nom::lib::std::slice::RSplit<'a, T, P> where     P: Send,     T: Sync,

• impl<'a, T> Send for ExactChunks<'a, T> where     T: Sync,

• impl<'a, T> Send for Chunks<'a, T> where     T: Sync,

• impl<'a, T, P> Send for RSplitNMut<'a, T, P> where     P: Send,     T: Send,

• impl<'a, T> Send for ChunksMut<'a, T> where     T: Send,

• impl<'a, T, P> Send for RSplitMut<'a, T, P> where     P: Send,     T: Send,

• impl Send for ParseBoolError

• impl<'a, P> Send for SplitTerminator<'a, P> where     <P as Pattern<'a>>::Searcher: Send,

• impl Send for Utf8Error

• impl<'a> Send for EncodeUtf16<'a>

• impl<'a, P> Send for MatchIndices<'a, P> where     <P as Pattern<'a>>::Searcher: Send,

• impl Send for SearchStep

• impl<'a> Send for CharSearcher<'a>

• impl<'a, 'b> Send for CharSliceSearcher<'a, 'b>

• impl<'a, F> Send for CharPredicateSearcher<'a, F> where     F: Send,

• impl<'a, 'b> Send for StrSearcher<'a, 'b>

• impl<'a> Send for Chars<'a>

• impl<'a, P> Send for nom::lib::std::str::RSplitN<'a, P> where     <P as Pattern<'a>>::Searcher: Send,

• impl<'a, P> Send for RMatches<'a, P> where     <P as Pattern<'a>>::Searcher: Send,

• impl<'a, P> Send for nom::lib::std::str::Split<'a, P> where     <P as Pattern<'a>>::Searcher: Send,

• impl<'a, P> Send for nom::lib::std::str::SplitN<'a, P> where     <P as Pattern<'a>>::Searcher: Send,

• impl<'a, P> Send for nom::lib::std::str::RSplit<'a, P> where     <P as Pattern<'a>>::Searcher: Send,

• impl<'a, P> Send for Matches<'a, P> where     <P as Pattern<'a>>::Searcher: Send,

• impl<'a> Send for LinesAny<'a>

• impl<'a> Send for Lines<'a>

• impl<'a> Send for Bytes<'a>

• impl<'a> Send for SplitWhitespace<'a>

• impl<'a, P> Send for RSplitTerminator<'a, P> where     <P as Pattern<'a>>::Searcher: Send,

• impl<'a, P> Send for RMatchIndices<'a, P> where     <P as Pattern<'a>>::Searcher: Send,

• impl<'a> Send for CharIndices<'a>

• impl Send for String

• impl Send for FromUtf8Error

• impl Send for FromUtf16Error

• impl Send for ParseError

• impl<T> Send for Vec<T> where     T: Send,

• impl<'a, I> Send for Splice<'a, I> where     I: Send,     <I as Iterator>::Item: Send,

• impl<'a, T, F> Send for nom::lib::std::vec::DrainFilter<'a, T, F> where     F: Send,     T: Send,

• impl<I, E> Send for Context<I, E> where     E: Send,     I: Send,

• impl<'a> Send for CompleteStr<'a>

• impl<'a> Send for CompleteByteSlice<'a>

• impl<T> Send for Input<T> where     T: Send,