API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Sep 17th, 2019
151
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 19.79 KB | None | 0 0
raw download clone embed print report
  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>;
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
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
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!