• API
• FAQ
• Tools
• Archive
SHARE
TWEET

Untitled

a guest Sep 17th, 2019 110 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
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;
82. struct Vec<T>;
83. struct OsStr;
84. struct CStr;
85. struct PrefixComponent;
86. struct Rc<T>;
87. struct PathBuf;
90. struct RefCell<T>;
91. struct Reverse<T>;
92. struct OsString;
93. struct BTreeMap<K, V>;
94. struct VecDeque<T>;
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>;
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>;
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.

Top