Стоит ли изучать новый язык Rust? (8 стр)

// Copyright 2012-2015 The Rust Project Developers. See the COPYRIGHT// file at the top-level directory of this distribution and at// http://rust-lang.org/COPYRIGHT.//// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your// option. This file may not be copied, modified, or distributed// except according to those terms.//! A doubly-linked list with owned nodes.//!//! The `LinkedList` allows pushing and popping elements at either end//! in constant time.//!//! Almost always it is better to use `Vec` or [`VecDeque`] instead of//! [`LinkedList`]. In general, array-based containers are faster,//! more memory efficient and make better use of CPU cache.//!//! [`LinkedList`]: ../linked_list/struct.LinkedList.html//! [`VecDeque`]: ../vec_deque/struct.VecDeque.html#![stable(feature = "rust1", since = "1.0.0")]use core::cmp::Ordering;use core::fmt;use core::hash::{Hasher, Hash};use core::iter::{FromIterator, FusedIterator};use core::marker::PhantomData;use core::mem;use core::ops::{BoxPlace, InPlace, Place, Placer};use core::ptr::{self, NonNull};use boxed::{Box, IntermediateBox};use super::SpecExtend;/// A doubly-linked list with owned nodes.////// The `LinkedList` allows pushing and popping elements at either end/// in constant time.////// Almost always it is better to use `Vec` or `VecDeque` instead of/// `LinkedList`. In general, array-based containers are faster,/// more memory efficient and make better use of CPU cache.#[stable(feature = "rust1", since = "1.0.0")]pub struct LinkedList<T> { head: Option<NonNull<Node<T>>>, tail: Option<NonNull<Node<T>>>, len: usize, marker: PhantomData<Box<Node<T>>>,}struct Node<T> { next: Option<NonNull<Node<T>>>, prev: Option<NonNull<Node<T>>>, element: T,}/// An iterator over the elements of a `LinkedList`.////// This `struct` is created by the [`iter`] method on [`LinkedList`]. See its/// documentation for more.////// [`iter`]: struct.LinkedList.html#method.iter/// [`LinkedList`]: struct.LinkedList.html#[stable(feature = "rust1", since = "1.0.0")]pub struct Iter<'a, T: 'a> { head: Option<NonNull<Node<T>>>, tail: Option<NonNull<Node<T>>>, len: usize, marker: PhantomData<&'a Node<T>>,}#[stable(feature = "collection_debug", since = "1.17.0")]impl<'a, T: 'a + fmt::Debug> fmt::Debug for Iter<'a, T> { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { f.debug_tuple("Iter") .field(&self.len) .finish() }}// FIXME(#26925) Remove in favor of `#[derive(Clone)]`#[stable(feature = "rust1", since = "1.0.0")]impl<'a, T> Clone for Iter<'a, T> { fn clone(&self) -> Self { Iter { ..*self } }}/// A mutable iterator over the elements of a `LinkedList`.////// This `struct` is created by the [`iter_mut`] method on [`LinkedList`]. See its/// documentation for more.////// [`iter_mut`]: struct.LinkedList.html#method.iter_mut/// [`LinkedList`]: struct.LinkedList.html#[stable(feature = "rust1", since = "1.0.0")]pub struct IterMut<'a, T: 'a> { list: &'a mut LinkedList<T>, head: Option<NonNull<Node<T>>>, tail: Option<NonNull<Node<T>>>, len: usize,}#[stable(feature = "collection_debug", since = "1.17.0")]impl<'a, T: 'a + fmt::Debug> fmt::Debug for IterMut<'a, T> { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { f.debug_tuple("IterMut") .field(&self.list) .field(&self.len) .finish() }}/// An owning iterator over the elements of a `LinkedList`.////// This `struct` is created by the [`into_iter`] method on [`LinkedList`][`LinkedList`]/// (provided by the `IntoIterator` trait). See its documentation for more.////// [`into_iter`]: struct.LinkedList.html#method.into_iter/// [`LinkedList`]: struct.LinkedList.html#[derive(Clone)]#[stable(feature = "rust1", since = "1.0.0")]pub struct IntoIter<T> { list: LinkedList<T>,}#[stable(feature = "collection_debug", since = "1.17.0")]impl<T: fmt::Debug> fmt::Debug for IntoIter<T> { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { f.debug_tuple("IntoIter") .field(&self.list) .finish() }}impl<T> Node<T> { fn new(element: T) -> Self { Node { next: None, prev: None, element, } } fn into_element(self: Box<Self>) -> T { self.element }}// private methodsimpl<T> LinkedList<T> { /// Adds the given node to the front of the list. #[inline] fn push_front_node(&mut self, mut node: Box<Node<T>>) { unsafe { node.next = self.head; node.prev = None; let node = Some(Box::into_raw_non_null(node)); match self.head { None => self.tail = node, Some(mut head) => head.as_mut().prev = node, } self.head = node; self.len += 1; } } /// Removes and returns the node at the front of the list. #[inline] fn pop_front_node(&mut self) -> Option<Box<Node<T>>> { self.head.map(|node| unsafe { let node = Box::from_raw(node.as_ptr()); self.head = node.next; match self.head { None => self.tail = None, Some(mut head) => head.as_mut().prev = None, } self.len -= 1; node }) } /// Adds the given node to the back of the list. #[inline] fn push_back_node(&mut self, mut node: Box<Node<T>>) { unsafe { node.next = None; node.prev = self.tail; let node = Some(Box::into_raw_non_null(node)); match self.tail { None => self.head = node, Some(mut tail) => tail.as_mut().next = node, } self.tail = node; self.len += 1; } } /// Removes and returns the node at the back of the list. #[inline] fn pop_back_node(&mut self) -> Option<Box<Node<T>>> { self.tail.map(|node| unsafe { let node = Box::from_raw(node.as_ptr()); self.tail = node.prev; match self.tail { None => self.head = None, Some(mut tail) => tail.as_mut().next = None, } self.len -= 1; node }) } /// Unlinks the specified node from the current list. /// /// Warning: this will not check that the provided node belongs to the current list. #[inline] unsafe fn unlink_node(&mut self, mut node: NonNull<Node<T>>) { let node = node.as_mut(); match node.prev { Some(mut prev) => prev.as_mut().next = node.next.clone(), // this node is the head node None => self.head = node.next.clone(), }; match node.next { Some(mut next) => next.as_mut().prev = node.prev.clone(), // this node is the tail node None => self.tail = node.prev.clone(), }; self.len -= 1; }}#[stable(feature = "rust1", since = "1.0.0")]impl<T> Default for LinkedList<T> { /// Creates an empty `LinkedList<T>`. #[inline] fn default() -> Self { Self::new() }}impl<T> LinkedList<T> { /// Creates an empty `LinkedList`. /// /// # Examples /// /// ``` /// use std::collections::LinkedList; /// /// let list: LinkedList<u32> = LinkedList::new(); /// ``` #[inline] #[stable(feature = "rust1", since = "1.0.0")] pub fn new() -> Self { LinkedList { head: None, tail: None, len: 0, marker: PhantomData, } } /// Moves all elements from `other` to the end of the list. /// /// This reuses all the nodes from `other` and moves them into `self`. After /// this operation, `other` becomes empty. /// /// This operation should compute in O(1) time and O(1) memory. /// /// # Examples /// /// ``` /// use std::collections::LinkedList; /// /// let mut list1 = LinkedList::new(); /// list1.push_back('a'); /// /// let mut list2 = LinkedList::new(); /// list2.push_back('b'); /// list2.push_back('c'); /// /// list1.append(&mut list2); /// /// let mut iter = list1.iter(); /// assert_eq!(iter.next(), Some(&'a')); /// assert_eq!(iter.next(), Some(&'b')); /// assert_eq!(iter.next(), Some(&'c')); /// assert!(iter.next().is_none()); /// /// assert!(list2.is_empty()); /// ``` #[stable(feature = "rust1", since = "1.0.0")] pub fn append(&mut self, other: &mut Self) { match self.tail { None => mem::swap(self, other), Some(mut tail) => { if let Some(mut other_head) = other.head.take() { unsafe { tail.as_mut().next = Some(other_head); other_head.as_mut().prev = Some(tail); } self.tail = other.tail.take(); self.len += mem::replace(&mut other.len, 0); } } } } /// Provides a forward iterator. /// /// # Examples /// /// ``` /// use std::collections::LinkedList; /// /// let mut list: LinkedList<u32> = LinkedList::new(); /// /// list.push_back(0); /// list.push_back(1); /// list.push_back(2); /// /// let mut iter = list.iter(); /// assert_eq!(iter.next(), Some(&0)); /// assert_eq!(iter.next(), Some(&1)); /// assert_eq!(iter.next(), Some(&2)); /// assert_eq!(iter.next(), None); /// ``` #[inline] #[stable(feature = "rust1", since = "1.0.0")] pub fn iter(&self) -> Iter<T> { Iter { head: self.head, tail: self.tail, len: self.len, marker: PhantomData, } } /// Provides a forward iterator with mutable references. /// /// # Examples /// /// ``` /// use std::collections::LinkedList; /// /// let mut list: LinkedList<u32> = LinkedList::new(); /// /// list.push_back(0); /// list.push_back(1); /// list.push_back(2);