SHARE
TWEET

Untitled

a guest Sep 17th, 2019 110 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. // GOAL: Implements(?0: FromRadix10Checked)
  2. trait FromRadix10Checked {}
  3. impl<I> FromRadix10Checked for I where I: Zero, I: One, I: FromRadix10, I: CheckedMul, I: CheckedAdd, I: MaxNumDigits {}
  4. trait MaxNumDigits {}
  5. impl<I> MaxNumDigits for I where I: Bounded, I: Zero, I: DivAssign<Self>, I: Ord, I: Copy {}
  6. trait Copy {}
  7. impl<T> Copy for *mut T {}
  8. impl<T> Copy for Discriminant<T> {}
  9. impl<T> Copy for *const T {}
  10. impl<K, V, Type> Copy for NodeRef<Immut, K, V, Type> where {error}, {error} {}
  11. impl<T> Copy for Unique<T> {}
  12. impl Copy for ! {}
  13. impl<T> Copy for NonNull<T> {}
  14. impl<T> Copy for &T {}
  15. impl<Node, Type> Copy for Handle<Node, Type> where Node: Copy {}
  16. trait Ord {}
  17. impl Ord for Infallible {}
  18. impl<T> Ord for Arc<T> where T: Ord {}
  19. impl Ord for Components {}
  20. impl<T> Ord for NonNull<T> {}
  21. impl<T> Ord for Cell<T> where T: Ord, T: Copy {}
  22. impl Ord for Ordering {}
  23. impl Ord for Path {}
  24. impl Ord for str {}
  25. impl Ord for Ipv6Addr {}
  26. impl Ord for () {}
  27. impl<T> Ord for Vec<T> where T: Ord {}
  28. impl<T> Ord for [T] where T: Ord {}
  29. impl Ord for OsStr {}
  30. impl<B> Ord for Cow<B> where B: Ord, B: ToOwned {}
  31. impl Ord for CStr {}
  32. impl Ord for PrefixComponent {}
  33. impl<T> Ord for Rc<T> where T: Ord {}
  34. impl Ord for PathBuf {}
  35. impl Ord for Ipv4Addr {}
  36. impl<T> Ord for LinkedList<T> where T: Ord {}
  37. impl<A> Ord for &mut A where A: Ord {}
  38. impl<T> Ord for RefCell<T> where T: Ord {}
  39. impl<T> Ord for Reverse<T> where T: Ord {}
  40. impl<T> Ord for *mut T {}
  41. impl<T> Ord for *const T {}
  42. impl Ord for OsString {}
  43. impl Ord for ! {}
  44. impl<A> Ord for &A where A: Ord {}
  45. impl<K, V> Ord for BTreeMap<K, V> where K: Ord, V: Ord {}
  46. impl<A> Ord for VecDeque<A> where A: Ord {}
  47. impl Ord for bool {}
  48. struct Discriminant<T>;
  49. trait DivAssign<Rhs> {}
  50. impl DivAssign<u32> for Duration {}
  51. struct Unique<T>;
  52. struct NonNull<T>;
  53. struct Handle<Node, Type>;
  54. struct Infallible;
  55. struct Arc<T>;
  56. struct Components;
  57. trait ToOwned {
  58.   type Owned;
  59. }
  60. impl ToOwned for str {
  61.   type Owned = String;
  62. }
  63. impl ToOwned for CStr {
  64.   type Owned = CString;
  65. }
  66. impl<T> ToOwned for T where T: Clone {
  67.   type Owned = T;
  68. }
  69. impl<T> ToOwned for [T] where T: Clone {
  70.   type Owned = Vec<T>;
  71. }
  72. impl ToOwned for Path {
  73.   type Owned = PathBuf;
  74. }
  75. impl ToOwned for OsStr {
  76.   type Owned = OsString;
  77. }
  78. struct Cell<T>;
  79. struct Ordering;
  80. struct Path;
  81. struct Ipv6Addr;
  82. struct Vec<T>;
  83. struct OsStr;
  84. struct CStr;
  85. struct PrefixComponent;
  86. struct Rc<T>;
  87. struct PathBuf;
  88. struct Ipv4Addr;
  89. struct LinkedList<T>;
  90. struct RefCell<T>;
  91. struct Reverse<T>;
  92. struct OsString;
  93. struct BTreeMap<K, V>;
  94. struct VecDeque<T>;
  95. trait CheckedAdd {}
  96. trait Clone {}
  97. impl<A> Clone for Iter<A> {}
  98. impl<B> Clone for Cow<B> where B: ToOwned {}
  99. impl<I, U> Clone for Flatten<I> where I: Iterator, I: Clone, U: Iterator, U: Clone, {unknown}: IntoIterator, <{unknown} as IntoIterator>::IntoIter = U, <{unknown} as IntoIterator>::Item = {unknown} {}
  100. impl<T> Clone for SymmetricDifference<T> {}
  101. impl<T> Clone for Iter<T> {}
  102. impl Clone for ! {}
  103. impl Clone for Ipv6Addr {}
  104. impl<K, V> Clone for Keys<K, V> {}
  105. impl<T> Clone for ChunksExact<T> {}
  106. impl<S> Clone for Hasher<S> where S: Sip {}
  107. impl<T> Clone for NonNull<T> {}
  108. impl<T> Clone for Chunks<T> {}
  109. impl<T> Clone for Weak<T> {}
  110. impl<Node, Type> Clone for Handle<Node, Type> where Node: Copy {}
  111. impl<T, S> Clone for Intersection<T, S> {}
  112. impl<T> Clone for *mut T {}
  113. impl Clone for Box<Path> {}
  114. impl Clone for Waker {}
  115. impl<T> Clone for Difference<T> {}
  116. impl<T> Clone for RChunks<T> {}
  117. impl Clone for String {}
  118. impl<K, V> Clone for Keys<K, V> {}
  119. impl<K> Clone for Iter<K> {}
  120. impl<T> Clone for Discriminant<T> {}
  121. impl Clone for SocketAddrV4 {}
  122. impl<T> Clone for Iter<T> {}
  123. impl<H> Clone for BuildHasherDefault<H> {}
  124. impl<K, V> Clone for Values<K, V> {}
  125. impl<T> Clone for BinaryHeap<T> where T: Clone {}
  126. impl Clone for BorrowRef {}
  127. impl<T> Clone for Windows<T> {}
  128. impl<T> Clone for Arc<T> {}
  129. impl<T> Clone for VecDeque<T> where T: Clone {}
  130. impl<K, V> Clone for Iter<K, V> {}
  131. impl<T, E> Clone for Result<T, E> where T: Clone, E: Clone {}
  132. impl<T> Clone for Sender<T> {}
  133. impl<T> Clone for LinkedList<T> where T: Clone {}
  134. impl<K, V> Clone for Values<K, V> {}
  135. impl<T> Clone for Unique<T> {}
  136. impl Clone for VaListImpl {}
  137. impl<T, S> Clone for Union<T, S> {}
  138. impl<K, V> Clone for BTreeMap<K, V> where K: Clone, V: Clone {}
  139. impl<T> Clone for RefCell<T> where T: Clone {}
  140. impl<T, S> Clone for SymmetricDifference<T, S> {}
  141. impl Clone for Ipv4Addr {}
  142. impl<T> Clone for Union<T> {}
  143. impl<T> Clone for Vec<T> where T: Clone {}
  144. impl Clone for Droppable {}
  145. impl<T, P> Clone for Split<T, P> where P: Clone, P: FnMut<{unknown}> {}
  146. impl<K, V> Clone for Range<K, V> {}
  147. impl Clone for Infallible {}
  148. impl<T> Clone for *const T {}
  149. impl<T> Clone for Iter<T> {}
  150. impl<K, V, Type> Clone for NodeRef<Immut, K, V, Type> where {error}, {error} {}
  151. impl<T> Clone for MaybeUninit<T> where T: Copy {}
  152. impl<T> Clone for RChunksExact<T> {}
  153. impl<T> Clone for Iter<T> {}
  154. impl Clone for SocketAddrV6 {}
  155. impl<T> Clone for Intersection<T> {}
  156. impl<T> Clone for Iter<T> {}
  157. impl<T> Clone for IntoIter<T> where T: Clone {}
  158. impl<T> Clone for SyncSender<T> {}
  159. impl<T> Clone for &T {}
  160. impl<T> Clone for Weak<T> {}
  161. impl<T> Clone for Iter<T> {}
  162. impl<T, S> Clone for Difference<T, S> {}
  163. impl<T> Clone for Option<T> where T: Clone {}
  164. impl<T> Clone for Cell<T> where T: Copy {}
  165. impl Clone for Box<OsStr> {}
  166. impl Clone for Box<CStr> {}
  167. impl<T> Clone for Rc<T> {}
  168. impl<T> Clone for Empty<T> {}
  169. impl<I, U, F> Clone for FlatMap<I, U, F> where I: Clone, U: Clone, U: IntoIterator, F: Clone, <U as IntoIterator>::IntoIter: Clone {}
  170. impl<T> Clone for Range<T> {}
  171. impl<K, V> Clone for Iter<K, V> {}
  172. struct Cow<B>;
  173. struct Iter<A>;
  174. impl<T> IntoIterator for &mut VecDeque<T> {
  175.   type Item = &mut T;
  176.   type IntoIter = IterMut<T>;
  177. }
  178. impl<T> IntoIterator for &LinkedList<T> {
  179.   type Item = &T;
  180.   type IntoIter = Iter<T>;
  181. }
  182. impl<K, V> IntoIterator for BTreeMap<K, V> {
  183.   type Item = (K, V);
  184.   type IntoIter = IntoIter<K, V>;
  185. }
  186. impl<T> IntoIterator for Vec<T> {
  187.   type Item = T;
  188.   type IntoIter = IntoIter<T>;
  189. }
  190. impl<K, V> IntoIterator for &mut BTreeMap<K, V> where {error}, {error} {
  191.   type Item = (&K, &mut V);
  192.   type IntoIter = IterMut<K, V>;
  193. }
  194. impl<T, E> IntoIterator for &mut Result<T, E> {
  195.   type Item = &mut T;
  196.   type IntoIter = IterMut<T>;
  197. }
  198. impl<K, V, S> IntoIterator for &HashMap<K, V, S> {
  199.   type Item = (&K, &V);
  200.   type IntoIter = Iter<K, V>;
  201. }
  202. impl<I> IntoIterator for I where I: Iterator {
  203.   type Item = {unknown};
  204.   type IntoIter = I;
  205. }
  206. impl<T> IntoIterator for BinaryHeap<T> {
  207.   type Item = T;
  208.   type IntoIter = IntoIter<T>;
  209. }
  210. impl<T> IntoIterator for &[T] {
  211.   type Item = &T;
  212.   type IntoIter = Iter<T>;
  213. }
  214. impl<T> IntoIterator for &mut [T] {
  215.   type Item = &mut T;
  216.   type IntoIter = IterMut<T>;
  217. }
  218. impl<K, V> IntoIterator for &BTreeMap<K, V> where {error}, {error} {
  219.   type Item = (&K, &V);
  220.   type IntoIter = Iter<K, V>;
  221. }
  222. impl IntoIterator for &Path {
  223.   type Item = &OsStr;
  224.   type IntoIter = Iter;
  225. }
  226. impl<T, E> IntoIterator for &Result<T, E> {
  227.   type Item = &T;
  228.   type IntoIter = Iter<T>;
  229. }
  230. impl<T, E> IntoIterator for Result<T, E> {
  231.   type Item = T;
  232.   type IntoIter = IntoIter<T>;
  233. }
  234. impl<T> IntoIterator for &Option<T> {
  235.   type Item = &T;
  236.   type IntoIter = Iter<T>;
  237. }
  238. impl<T, S> IntoIterator for &HashSet<T, S> {
  239.   type Item = &T;
  240.   type IntoIter = Iter<T>;
  241. }
  242. impl<K, V, S> IntoIterator for &mut HashMap<K, V, S> {
  243.   type Item = (&K, &mut V);
  244.   type IntoIter = IterMut<K, V>;
  245. }
  246. impl<T> IntoIterator for Receiver<T> {
  247.   type Item = T;
  248.   type IntoIter = IntoIter<T>;
  249. }
  250. impl<T> IntoIterator for &BinaryHeap<T> {
  251.   type Item = &T;
  252.   type IntoIter = Iter<T>;
  253. }
  254. impl<T> IntoIterator for BTreeSet<T> {
  255.   type Item = T;
  256.   type IntoIter = IntoIter<T>;
  257. }
  258. impl<T> IntoIterator for &Receiver<T> {
  259.   type Item = T;
  260.   type IntoIter = Iter<T>;
  261. }
  262. impl<T> IntoIterator for VecDeque<T> {
  263.   type Item = T;
  264.   type IntoIter = IntoIter<T>;
  265. }
  266. impl<T> IntoIterator for &mut Vec<T> {
  267.   type Item = &mut T;
  268.   type IntoIter = IterMut<T>;
  269. }
  270. impl<T> IntoIterator for &mut LinkedList<T> {
  271.   type Item = &mut T;
  272.   type IntoIter = IterMut<T>;
  273. }
  274. impl<T> IntoIterator for LinkedList<T> {
  275.   type Item = T;
  276.   type IntoIter = IntoIter<T>;
  277. }
  278. impl<T> IntoIterator for &Vec<T> {
  279.   type Item = &T;
  280.   type IntoIter = Iter<T>;
  281. }
  282. impl IntoIterator for &PathBuf {
  283.   type Item = &OsStr;
  284.   type IntoIter = Iter;
  285. }
  286. impl<T> IntoIterator for &mut Option<T> {
  287.   type Item = &mut T;
  288.   type IntoIter = IterMut<T>;
  289. }
  290. impl<T> IntoIterator for Option<T> {
  291.   type Item = T;
  292.   type IntoIter = IntoIter<T>;
  293. }
  294. impl<K, V, S> IntoIterator for HashMap<K, V, S> {
  295.   type Item = (K, V);
  296.   type IntoIter = IntoIter<K, V>;
  297. }
  298. impl<T, S> IntoIterator for HashSet<T, S> {
  299.   type Item = T;
  300.   type IntoIter = IntoIter<T>;
  301. }
  302. impl<T> IntoIterator for &BTreeSet<T> {
  303.   type Item = &T;
  304.   type IntoIter = Iter<T>;
  305. }
  306. impl<T> IntoIterator for &VecDeque<T> {
  307.   type Item = &T;
  308.   type IntoIter = Iter<T>;
  309. }
  310. trait Iterator {
  311.   type Item;
  312. }
  313. impl<A, B> Iterator for Zip<A, B> where A: Iterator, B: Iterator {
  314.   type Item = ({unknown}, {unknown});
  315. }
  316. impl Iterator for EncodeUtf16 {
  317.   type Item = u16;
  318. }
  319. impl<I> Iterator for Peekable<I> where I: Iterator {
  320.   type Item = {unknown};
  321. }
  322. impl<T> Iterator for IntoIter<T> {
  323.   type Item = T;
  324. }
  325. impl<K, V> Iterator for Iter<K, V> where {error}, {error} {
  326.   type Item = (&K, &V);
  327. }
  328. impl<I> Iterator for Fuse<I> where I: FusedIterator {}
  329. impl<T> Iterator for Once<T> {
  330.   type Item = T;
  331. }
  332. impl Iterator for CharIndices {
  333.   type Item = (usize, {unknown});
  334. }
  335. impl<K, V> Iterator for IntoIter<K, V> {
  336.   type Item = (K, V);
  337. }
  338. impl<T> Iterator for Union<T> where T: Ord {
  339.   type Item = &T;
  340. }
  341. impl<T> Iterator for RChunksExactMut<T> {
  342.   type Item = &mut [T];
  343. }
  344. impl<T, F> Iterator for Successors<T, F> where F: FnMut<{unknown}> {
  345.   type Item = T;
  346. }
  347. impl<I, U, F> Iterator for FlatMap<I, U, F> where I: Iterator, U: IntoIterator, F: FnMut<{unknown}> {
  348.   type Item = {unknown};
  349. }
  350. impl<T> Iterator for Iter<T> {
  351.   type Item = &T;
  352. }
  353. impl<T> Iterator for ChunksExactMut<T> {
  354.   type Item = &mut [T];
  355. }
  356. impl Iterator for ErrorIter {
  357.   type Item = &dyn Error + {error};
  358. }
  359. impl<T, S> Iterator for SymmetricDifference<T, S> where T: Eq, T: Hash, S: BuildHasher {
  360.   type Item = &T;
  361. }
  362. impl<T, P> Iterator for Split<T, P> where P: FnMut<{unknown}> {
  363.   type Item = &[T];
  364. }
  365. impl<B> Iterator for Split<B> where B: BufRead {
  366.   type Item = Result<Vec<u8>, Error>;
  367. }
  368. impl Iterator for ToLowercase {
  369.   type Item = char;
  370. }
  371. impl<A, F> Iterator for RepeatWith<F> where F: FnMut<{unknown}> {
  372.   type Item = A;
  373. }
  374. impl Iterator for Iter {
  375.   type Item = &OsStr;
  376. }
  377. impl<T, I> Iterator for GenericSplitN<I> where I: SplitIter, {error} {
  378.   type Item = T;
  379. }
  380. impl<I, T> Iterator for Copied<I> where {error}, I: Iterator, <I as Iterator>::Item = &T, T: Copy {
  381.   type Item = T;
  382. }
  383. impl<I> Iterator for Skip<I> where I: Iterator {
  384.   type Item = <I as Iterator>::Item;
  385. }
  386. impl Iterator for SplitPaths {
  387.   type Item = PathBuf;
  388. }
  389. impl Iterator for ArgsOs {
  390.   type Item = OsString;
  391. }
  392. impl<T> Iterator for IntoIter<T> {
  393.   type Item = T;
  394. }
  395. impl<T> Iterator for Drain<T> {
  396.   type Item = T;
  397. }
  398. impl Iterator for EncodeWide {
  399.   type Item = u16;
  400. }
  401. impl<I> Iterator for &mut I where I: Iterator {
  402.   type Item = {unknown};
  403. }
  404. impl<K, V, I> Iterator for MergeIter<K, V, I> where K: Ord, I: Iterator, <I as Iterator>::Item = (K, V) {
  405.   type Item = (K, V);
  406. }
  407. impl<T, P> Iterator for SplitMut<T, P> where P: FnMut<{unknown}> {
  408.   type Item = &mut [T];
  409. }
  410. impl<I, T> Iterator for Cloned<I> where {error}, I: Iterator, <I as Iterator>::Item = &T, T: Clone {
  411.   type Item = T;
  412. }
  413. impl<B, I, St, F> Iterator for Scan<I, St, F> where I: Iterator, F: FnMut<{unknown}> {
  414.   type Item = B;
  415. }
  416. impl Iterator for Utf8LossyChunksIter {
  417.   type Item = Utf8LossyChunk;
  418. }
  419. impl<I> Iterator for DecodeUtf16<I> where I: Iterator, <I as Iterator>::Item = u16 {
  420.   type Item = Result<char, DecodeUtf16Error>;
  421. }
  422. impl Iterator for EscapeDefault {
  423.   type Item = u8;
  424. }
  425. impl<K, V> Iterator for IterMut<K, V> where {error}, {error} {
  426.   type Item = (&K, &mut V);
  427. }
  428. impl<K, V> Iterator for IterMut<K, V> {
  429.   type Item = (&K, &mut V);
  430. }
  431. impl<T> Iterator for Iter<T> {
  432.   type Item = &T;
  433. }
  434. impl Iterator for Incoming {
  435.   type Item = Result<TcpStream, Error>;
  436. }
  437. impl<T> Iterator for IntoIter<T> {
  438.   type Item = T;
  439. }
  440. impl<T> Iterator for Windows<T> {
  441.   type Item = &[T];
  442. }
  443. impl<B, I, F> Iterator for Map<I, F> where I: Iterator, F: FnMut<{unknown}> {
  444.   type Item = B;
  445. }
  446. impl<T, F> Iterator for DrainFilter<T, F> where F: FnMut<{unknown}> {
  447.   type Item = T;
  448. }
  449. impl<T> Iterator for RChunksExact<T> {
  450.   type Item = &[T];
  451. }
  452. impl<T> Iterator for Intersection<T> where T: Ord {
  453.   type Item = &T;
  454. }
  455. impl<T> Iterator for Drain<T> {
  456.   type Item = T;
  457. }
  458. impl Iterator for Drain {
  459.   type Item = char;
  460. }
  461. impl Iterator for Vars {
  462.   type Item = (String, String);
  463. }
  464. impl Iterator for SplitAsciiWhitespace {
  465.   type Item = &str;
  466. }
  467. impl<T> Iterator for RChunksMut<T> {
  468.   type Item = &mut [T];
  469. }
  470. impl<B> Iterator for Lines<B> where B: BufRead {
  471.   type Item = Result<String, Error>;
  472. }
  473. impl Iterator for Args {
  474.   type Item = String;
  475. }
  476. impl<T> Iterator for ChunksMut<T> {
  477.   type Item = &mut [T];
  478. }
  479. impl<T> Iterator for TryIter<T> {
  480.   type Item = T;
  481. }
  482. impl<T> Iterator for IntoIter<T> {
  483.   type Item = T;
  484. }
  485. impl Iterator for Chars {
  486.   type Item = {unknown};
  487. }
  488. impl<T> Iterator for Drain<T> {
  489.   type Item = T;
  490. }
  491. impl<T, S> Iterator for Difference<T, S> where T: Eq, T: Hash, S: BuildHasher {
  492.   type Item = &T;
  493. }
  494. impl<A> Iterator for IterMut<A> {
  495.   type Item = &mut A;
  496. }
  497. impl<K, V> Iterator for ValuesMut<K, V> {
  498.   type Item = &mut V;
  499. }
  500. impl Iterator for Components {
  501.   type Item = Component;
  502. }
  503. impl<T> Iterator for IterMut<T> {
  504.   type Item = &mut T;
  505. }
  506. impl<T, P> Iterator for RSplitMut<T, P> where P: FnMut<{unknown}> {
  507.   type Item = &mut [T];
  508. }
  509. impl<I> Iterator for Take<I> where I: Iterator {
  510.   type Item = <I as Iterator>::Item;
  511. }
  512. impl Iterator for EscapeDebug {
  513.   type Item = char;
  514. }
  515. impl Iterator for EscapeDefault {
  516.   type Item = char;
  517. }
  518. impl<A> Iterator for Repeat<A> where A: Clone {
  519.   type Item = A;
  520. }
  521. impl<T> Iterator for IterMut<T> {
  522.   type Item = &mut T;
  523. }
  524. impl<K, V> Iterator for Iter<K, V> {
  525.   type Item = (&K, &V);
  526. }
  527. impl<K, V> Iterator for ValuesMut<K, V> {
  528.   type Item = &mut V;
  529. }
  530. impl<T> Iterator for Range<T> {
  531.   type Item = &T;
  532. }
  533. impl<I, P> Iterator for TakeWhile<I, P> where I: Iterator, P: FnMut<{unknown}> {
  534.   type Item = {unknown};
  535. }
  536. impl Iterator for VarsOs {
  537.   type Item = (OsString, OsString);
  538. }
  539. impl<A> Iterator for Range<A> where A: Step {
  540.   type Item = A;
  541. }
  542. impl<R> Iterator for Bytes<R> where R: Read {
  543.   type Item = Result<u8, Error>;
  544. }
  545. impl<K> Iterator for Drain<K> {
  546.   type Item = K;
  547. }
  548. impl<T> Iterator for IntoIter<T> {
  549.   type Item = T;
  550. }
  551. impl<K> Iterator for IntoIter<K> {
  552.   type Item = K;
  553. }
  554. impl<A> Iterator for Iter<A> {
  555.   type Item = &A;
  556. }
  557. impl<T> Iterator for IterMut<T> {
  558.   type Item = &mut T;
  559. }
  560. impl<I, T, E> Iterator for ResultShunt<I, E> where I: Iterator, <I as Iterator>::Item = Result<T, E> {
  561.   type Item = T;
  562. }
  563. impl<T, S> Iterator for Union<T, S> where T: Eq, T: Hash, S: BuildHasher {
  564.   type Item = &T;
  565. }
  566. impl<T, P> Iterator for RSplit<T, P> where P: FnMut<{unknown}> {
  567.   type Item = &[T];
  568. }
  569. impl<I, U> Iterator for Flatten<I> where I: Iterator, U: Iterator, {unknown}: IntoIterator, <{unknown} as IntoIterator>::IntoIter = U, <{unknown} as IntoIterator>::Item = {unknown} {
  570.   type Item = {unknown};
  571. }
  572. impl<K, V> Iterator for IntoIter<K, V> {
  573.   type Item = (K, V);
  574. }
  575. impl<T> Iterator for SymmetricDifference<T> where T: Ord {
  576.   type Item = &T;
  577. }
  578. impl<T> Iterator for Iter<T> {
  579.   type Item = &T;
  580. }
  581. impl<T> Iterator for Iter<T> {
  582.   type Item = &T;
  583. }
  584. impl<A, B> Iterator for Chain<A, B> where A: Iterator, B: Iterator, <B as Iterator>::Item = {unknown} {
  585.   type Item = {unknown};
  586. }
  587. impl<T> Iterator for IntoIter<T> {
  588.   type Item = T;
  589. }
  590. impl<I> Iterator for Enumerate<I> where I: Iterator {
  591.   type Item = ({unknown}, <I as Iterator>::Item);
  592. }
  593. impl<I> Iterator for StepBy<I> where I: Iterator {
  594.   type Item = {unknown};
  595. }
  596. impl Iterator for Ancestors {
  597.   type Item = &Path;
  598. }
  599. impl<I> Iterator for Fuse<I> where I: Iterator {
  600.   type Item = <I as Iterator>::Item;
  601. }
  602. impl<K, V> Iterator for Values<K, V> {
  603.   type Item = &V;
  604. }
  605. impl<I> Iterator for Rev<I> where I: DoubleEndedIterator {
  606.   type Item = <I as Iterator>::Item;
  607. }
  608. impl<T> Iterator for IntoIter<T> {
  609.   type Item = T;
  610. }
  611. impl<A> Iterator for RangeInclusive<A> where A: Step {
  612.   type Item = A;
  613. }
  614. impl<K, V> Iterator for Values<K, V> {
  615.   type Item = &V;
  616. }
  617. impl<I, P> Iterator for Filter<I, P> where I: Iterator, P: FnMut<{unknown}> {
  618.   type Item = {unknown};
  619. }
  620. impl<T> Iterator for ChunksExact<T> {
  621.   type Item = &[T];
  622. }
  623. impl<K, V> Iterator for Drain<K, V> {
  624.   type Item = (K, V);
  625. }
  626. impl<T> Iterator for Chunks<T> {
  627.   type Item = &[T];
  628. }
  629. impl Iterator for Bytes {
  630.   type Item = u8;
  631. }
  632. impl<I> Iterator for Splice<I> where I: Iterator {
  633.   type Item = {unknown};
  634. }
  635. impl<K, V> Iterator for Keys<K, V> {
  636.   type Item = &K;
  637. }
  638. impl<T> Iterator for Iter<T> {
  639.   type Item = &T;
  640. }
  641. impl Iterator for SplitWhitespace {
  642.   type Item = &str;
  643. }
  644. impl<A> Iterator for RangeFrom<A> where A: Step {
  645.   type Item = A;
  646. }
  647. impl<T> Iterator for Iter<T> {
  648.   type Item = T;
  649. }
  650. impl<T, S> Iterator for Intersection<T, S> where T: Eq, T: Hash, S: BuildHasher {
  651.   type Item = &T;
  652. }
  653. impl Iterator for EscapeUnicode {
  654.   type Item = char;
  655. }
  656. impl<K, V> Iterator for RangeMut<K, V> {
  657.   type Item = (&K, &mut V);
  658. }
  659. impl<A> Iterator for Item<A> {
  660.   type Item = A;
  661. }
  662. impl<T> Iterator for Empty<T> {
  663.   type Item = T;
  664. }
  665. impl Iterator for Wtf8CodePoints {
  666.   type Item = CodePoint;
  667. }
  668. impl<A, F> Iterator for OnceWith<F> where F: FnOnce<{unknown}> {
  669.   type Item = A;
  670. }
  671. impl<T, F> Iterator for DrainFilter<T, F> where F: FnMut<{unknown}> {
  672.   type Item = T;
  673. }
  674. impl Iterator for LinesAny {
  675.   type Item = &str;
  676. }
  677. impl<T> Iterator for RChunks<T> {
  678.   type Item = &[T];
  679. }
  680. impl<I, P> Iterator for SkipWhile<I, P> where I: Iterator, P: FnMut<{unknown}> {
  681.   type Item = {unknown};
  682. }
  683. impl Iterator for CaseMappingIter {
  684.   type Item = char;
  685. }
  686. impl<T> Iterator for Difference<T> where T: Ord {
  687.   type Item = &T;
  688. }
  689. impl<A> Iterator for IntoIter<A> {
  690.   type Item = A;
  691. }
  692. impl Iterator for ToUppercase {
  693.   type Item = char;
  694. }
  695. impl<K> Iterator for Iter<K> {
  696.   type Item = &K;
  697. }
  698. impl<I, T> Iterator for OptionShunt<I> where I: Iterator, <I as Iterator>::Item = Option<T> {
  699.   type Item = T;
  700. }
  701. impl<I, F> Iterator for Inspect<I, F> where I: Iterator, F: FnMut<{unknown}> {
  702.   type Item = {unknown};
  703. }
  704. impl<I> Iterator for Cycle<I> where I: Clone, I: Iterator {
  705.   type Item = <I as Iterator>::Item;
  706. }
  707. impl<I, U> Iterator for FlattenCompat<I, U> where I: Iterator, U: Iterator, {unknown}: IntoIterator, <{unknown} as IntoIterator>::IntoIter = U, <{unknown} as IntoIterator>::Item = {unknown} {
  708.   type Item = {unknown};
  709. }
  710. impl<K, V> Iterator for Keys<K, V> {
  711.   type Item = &K;
  712. }
  713. impl Iterator for Lines {
  714.   type Item = &str;
  715. }
  716. impl<T, F> Iterator for FromFn<F> where F: FnMut<{unknown}> {
  717.   type Item = T;
  718. }
  719. impl<K, V> Iterator for Range<K, V> {
  720.   type Item = (&K, &V);
  721. }
  722. impl<B, I, F> Iterator for FilterMap<I, F> where I: Iterator, F: FnMut<{unknown}> {
  723.   type Item = B;
  724. }
  725. impl Iterator for ReadDir {
  726.   type Item = Result<DirEntry, Error>;
  727. }
  728. struct SymmetricDifference<T>;
  729. struct Iter<T>;
  730. struct Keys<K, V>;
  731. struct ChunksExact<T>;
  732. trait Sip {}
  733. impl Sip for Sip13Rounds {}
  734. impl Sip for Sip24Rounds {}
  735. struct Chunks<T>;
  736. struct Weak<T>;
  737. struct Intersection<T, S>;
  738. struct Box<T>;
  739. struct Waker;
  740. struct Difference<T>;
  741. struct RChunks<T>;
  742. struct String;
  743. struct Keys<K, V>;
  744. struct Iter<K>;
  745. struct SocketAddrV4;
  746. struct Iter<T>;
  747. struct BuildHasherDefault<H>;
  748. struct Values<K, V>;
  749. struct BinaryHeap<T>;
  750. struct BorrowRef;
  751. struct Windows<T>;
  752. struct Iter<K, V>;
  753. struct Sender<T>;
  754. struct Values<K, V>;
  755. struct VaListImpl;
  756. struct Union<T, S>;
  757. struct SymmetricDifference<T, S>;
  758. struct Union<T>;
  759. struct Droppable;
  760. trait FnMut<Args> {}
  761. impl<A, F> FnMut<A> for &mut F where F: FnMut<A> {}
  762. impl<A, F> FnMut<A> for &F where F: Fn<A> {}
  763. struct Range<K, V>;
  764. struct Iter<T>;
  765. struct MaybeUninit<T>;
  766. struct RChunksExact<T>;
  767. struct Iter<T>;
  768. struct SocketAddrV6;
  769. struct Intersection<T>;
  770. struct Iter<T>;
  771. struct IntoIter<T>;
  772. struct SyncSender<T>;
  773. struct Weak<T>;
  774. struct Iter<T>;
  775. struct Difference<T, S>;
  776. struct Option<T>;
  777. struct Empty<T>;
  778. struct Range<T>;
  779. struct Iter<K, V>;
  780. struct Hasher<S>;
  781. trait Fn<Args> {}
  782. impl<A, F> Fn<A> for &F where F: Fn<A> {}
  783. struct Result<T, E>;
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
 
Top