1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
//! `str` 的 Trait 实现。

use crate::cmp::Ordering;
use crate::intrinsics::assert_unsafe_precondition;
use crate::ops;
use crate::ptr;
use crate::slice::SliceIndex;

use super::ParseBoolError;

/// 实现字符串排序。
///
/// 字符串按字节值按 [按字典顺序](Ord#lexicographical-comparison) 排序。
/// 这将根据 Unicode 代码点在代码图中的位置进行排序。
/// 这不一定与 "alphabetical" 顺序相同,后者因语言和区域设置而异。
/// 根据文化认可的标准对字符串进行排序需要 `str` 类型的作用域之外的特定于语言环境的数据。
///
#[stable(feature = "rust1", since = "1.0.0")]
impl Ord for str {
    #[inline]
    fn cmp(&self, other: &str) -> Ordering {
        self.as_bytes().cmp(other.as_bytes())
    }
}

#[stable(feature = "rust1", since = "1.0.0")]
impl PartialEq for str {
    #[inline]
    fn eq(&self, other: &str) -> bool {
        self.as_bytes() == other.as_bytes()
    }
}

#[stable(feature = "rust1", since = "1.0.0")]
impl Eq for str {}

/// 对字符串执行比较操作。
///
/// [按字典顺序](Ord#lexicographical-comparison) 通过字符串的字节值对字符串进行比较。
/// 这将根据 Unicode 代码点在代码表中的位置进行比较。
/// 这不一定与 "alphabetical" 顺序相同,后者因语言和区域设置而异。
/// 根据文化认可的标准比较字符串需要特定于语言环境的数据,该数据不在 `str` 类型的作用域之内。
///
#[stable(feature = "rust1", since = "1.0.0")]
impl PartialOrd for str {
    #[inline]
    fn partial_cmp(&self, other: &str) -> Option<Ordering> {
        Some(self.cmp(other))
    }
}

#[stable(feature = "rust1", since = "1.0.0")]
impl<I> ops::Index<I> for str
where
    I: SliceIndex<str>,
{
    type Output = I::Output;

    #[inline]
    fn index(&self, index: I) -> &I::Output {
        index.index(self)
    }
}

#[stable(feature = "rust1", since = "1.0.0")]
impl<I> ops::IndexMut<I> for str
where
    I: SliceIndex<str>,
{
    #[inline]
    fn index_mut(&mut self, index: I) -> &mut I::Output {
        index.index_mut(self)
    }
}

#[inline(never)]
#[cold]
#[track_caller]
const fn str_index_overflow_fail() -> ! {
    panic!("attempted to index str up to maximum usize");
}

/// 使用语法 `&self[..]` 或 `&mut self[..]` 实现子字符串切片。
///
/// 返回整个字符串的切片,即返回 `&self` 或 `&mut self`。相当于 `&self[0 ..
/// len]` 或 `&mut self[0 ..
/// len]`.
/// 与其他索引操作不同,此操作永远不能 panic。
///
/// 此运算为 *O*(1)。
///
/// 在 1.20.0 之前,`Index` 和 `IndexMut` 的直接实现仍支持这些索引操作。
///
/// 等效于 `&self[0 .. len]` 或 `&mut self[0 .. len]`。
#[stable(feature = "str_checked_slicing", since = "1.20.0")]
#[rustc_const_unstable(feature = "const_slice_index", issue = "none")]
unsafe impl SliceIndex<str> for ops::RangeFull {
    type Output = str;
    #[inline]
    fn get(self, slice: &str) -> Option<&Self::Output> {
        Some(slice)
    }
    #[inline]
    fn get_mut(self, slice: &mut str) -> Option<&mut Self::Output> {
        Some(slice)
    }
    #[inline]
    unsafe fn get_unchecked(self, slice: *const str) -> *const Self::Output {
        slice
    }
    #[inline]
    unsafe fn get_unchecked_mut(self, slice: *mut str) -> *mut Self::Output {
        slice
    }
    #[inline]
    fn index(self, slice: &str) -> &Self::Output {
        slice
    }
    #[inline]
    fn index_mut(self, slice: &mut str) -> &mut Self::Output {
        slice
    }
}

/// 使用语法 `&self[begin .. end]` 或 `&mut self[begin .. end]` 实现子字符串切片。
///
/// 从字节范围 [`begin,`end`) 返回给定字符串的切片。
///
/// 此运算为 *O*(1)。
///
/// 在 1.20.0 之前,`Index` 和 `IndexMut` 的直接实现仍支持这些索引操作。
///
/// # Panics
///
/// 如果 `begin` 或 `end` 未指向字符的起始字节偏移量 (由 `is_char_boundary` 定义),`begin > end` 或 `end > len`,就会出现 panics。
///
///
/// # Examples
///
/// ```
/// let s = "Löwe 老虎 Léopard";
/// assert_eq!(&s[0 .. 1], "L");
///
/// assert_eq!(&s[1 .. 9], "öwe 老");
///
/// // 这些将是 panic:
/// // 字节 2 位于 `ö` 内:
/// // &s[2 ..3];
///
/// // byte 8 lies within `老` &s[1 ..
/// // 8];
///
/// // 字节 100 在字符串 &s[3 之外。
/// // 100];
/// ```
///
///
///
///
#[stable(feature = "str_checked_slicing", since = "1.20.0")]
#[rustc_const_unstable(feature = "const_slice_index", issue = "none")]
unsafe impl SliceIndex<str> for ops::Range<usize> {
    type Output = str;
    #[inline]
    fn get(self, slice: &str) -> Option<&Self::Output> {
        if self.start <= self.end
            && slice.is_char_boundary(self.start)
            && slice.is_char_boundary(self.end)
        {
            // SAFETY: 刚刚检查了 `start` 和 `end` 是否在 char 边界上,并且我们传入了安全的引用,因此返回值也将为 1。
            //
            // 我们还检查了字符边界,因此这是有效的 UTF-8。
            Some(unsafe { &*self.get_unchecked(slice) })
        } else {
            None
        }
    }
    #[inline]
    fn get_mut(self, slice: &mut str) -> Option<&mut Self::Output> {
        if self.start <= self.end
            && slice.is_char_boundary(self.start)
            && slice.is_char_boundary(self.end)
        {
            // SAFETY: 刚刚检查 `start` 和 `end` 是否在字符边界上。
            // 我们知道指针是唯一的,因为我们是从 `slice` 获得的。
            Some(unsafe { &mut *self.get_unchecked_mut(slice) })
        } else {
            None
        }
    }
    #[inline]
    unsafe fn get_unchecked(self, slice: *const str) -> *const Self::Output {
        let slice = slice as *const [u8];
        // SAFETY: 调用者保证 `self` 在 `slice` 的范围内,该范围满足 `add` 的所有条件。
        //
        let ptr = unsafe {
            let this = ops::Range { ..self };
            assert_unsafe_precondition!(
                "str::get_unchecked requires that the range is within the string slice",
                (this: ops::Range<usize>, slice: *const [u8]) =>
                // 我们想检查边界是否在 char 边界上,但是如果不读取指针后面的内容,就没有真正的方法可以做到这一点,这会产生别名影响。
                //
                // 如果不为此向 `SliceIndex` 添加特殊的函数,也无法将此检查向上移动到 `str::get_unchecked`。
                //
                //
                //
                this.end >= this.start && this.end <= slice.len()
            );
            slice.as_ptr().add(self.start)
        };
        let len = self.end - self.start;
        ptr::slice_from_raw_parts(ptr, len) as *const str
    }
    #[inline]
    unsafe fn get_unchecked_mut(self, slice: *mut str) -> *mut Self::Output {
        let slice = slice as *mut [u8];
        // SAFETY: 请参见 `get_unchecked` 的注释。
        let ptr = unsafe {
            let this = ops::Range { ..self };
            assert_unsafe_precondition!(
                "str::get_unchecked_mut requires that the range is within the string slice",
                (this: ops::Range<usize>, slice: *mut [u8]) =>
                this.end >= this.start && this.end <= slice.len()
            );
            slice.as_mut_ptr().add(self.start)
        };
        let len = self.end - self.start;
        ptr::slice_from_raw_parts_mut(ptr, len) as *mut str
    }
    #[inline]
    fn index(self, slice: &str) -> &Self::Output {
        let (start, end) = (self.start, self.end);
        match self.get(slice) {
            Some(s) => s,
            None => super::slice_error_fail(slice, start, end),
        }
    }
    #[inline]
    fn index_mut(self, slice: &mut str) -> &mut Self::Output {
        // is_char_boundary 由于 NLL 问题而无法检查索引是否位于 [0, .len()] 中,因此无法如上所述重用 `get`
        //
        if self.start <= self.end
            && slice.is_char_boundary(self.start)
            && slice.is_char_boundary(self.end)
        {
            // SAFETY: 刚刚检查了 `start` 和 `end` 是否在 char 边界上,并且我们传入了安全的引用,因此返回值也将为 1。
            //
            unsafe { &mut *self.get_unchecked_mut(slice) }
        } else {
            super::slice_error_fail(slice, self.start, self.end)
        }
    }
}

/// 使用语法 `&self[.. end]` 或 `&mut self[.. end]` 实现子字符串切片。
///
/// 从字节范围 \[0, `end`) 中返回给定字符串的切片。
/// 等效于 `&self[0 .. end]` 或 `&mut self[0 .. end]`。
///
/// 此运算为 *O*(1)。
///
/// 在 1.20.0 之前,`Index` 和 `IndexMut` 的直接实现仍支持这些索引操作。
///
/// # Panics
///
/// 如果 `end` 没有指向字符的起始字节偏移量 (由 `is_char_boundary` 定义),或者 `end > len`,就会出现 panics。
///
///
///
#[stable(feature = "str_checked_slicing", since = "1.20.0")]
#[rustc_const_unstable(feature = "const_slice_index", issue = "none")]
unsafe impl SliceIndex<str> for ops::RangeTo<usize> {
    type Output = str;
    #[inline]
    fn get(self, slice: &str) -> Option<&Self::Output> {
        if slice.is_char_boundary(self.end) {
            // SAFETY: 刚刚检查了 `end` 是否在 char 边界上,并且我们传递了一个安全的引用,因此返回值也将为 1。
            //
            Some(unsafe { &*self.get_unchecked(slice) })
        } else {
            None
        }
    }
    #[inline]
    fn get_mut(self, slice: &mut str) -> Option<&mut Self::Output> {
        if slice.is_char_boundary(self.end) {
            // SAFETY: 刚刚检查了 `end` 是否在 char 边界上,并且我们传递了一个安全的引用,因此返回值也将为 1。
            //
            Some(unsafe { &mut *self.get_unchecked_mut(slice) })
        } else {
            None
        }
    }
    #[inline]
    unsafe fn get_unchecked(self, slice: *const str) -> *const Self::Output {
        // SAFETY: 调用者必须维护 `get_unchecked` 的安全保证。
        unsafe { (0..self.end).get_unchecked(slice) }
    }
    #[inline]
    unsafe fn get_unchecked_mut(self, slice: *mut str) -> *mut Self::Output {
        // SAFETY: 调用者必须维护 `get_unchecked_mut` 的安全保证。
        unsafe { (0..self.end).get_unchecked_mut(slice) }
    }
    #[inline]
    fn index(self, slice: &str) -> &Self::Output {
        let end = self.end;
        match self.get(slice) {
            Some(s) => s,
            None => super::slice_error_fail(slice, 0, end),
        }
    }
    #[inline]
    fn index_mut(self, slice: &mut str) -> &mut Self::Output {
        if slice.is_char_boundary(self.end) {
            // SAFETY: 刚刚检查了 `end` 是否在 char 边界上,并且我们传递了一个安全的引用,因此返回值也将为 1。
            //
            unsafe { &mut *self.get_unchecked_mut(slice) }
        } else {
            super::slice_error_fail(slice, 0, self.end)
        }
    }
}

/// 使用语法 `&self[begin ..]` 或 `&mut self[begin ..]` 实现子字符串切片。
///
/// 从字节范围 \[`begin`, `len`) 中返回给定字符串的切片。
/// 相当于 `&self[begin .. len]` 或 `&mut self[begin .. len]`。
///
/// 此运算为 *O*(1)。
///
/// 在 1.20.0 之前,`Index` 和 `IndexMut` 的直接实现仍支持这些索引操作。
///
/// # Panics
///
/// 如果 `begin` 没有指向字符的起始字节偏移量 (由 `is_char_boundary` 定义),或者 `begin > len`,就会出现 panics。
///
///
///
#[stable(feature = "str_checked_slicing", since = "1.20.0")]
#[rustc_const_unstable(feature = "const_slice_index", issue = "none")]
unsafe impl SliceIndex<str> for ops::RangeFrom<usize> {
    type Output = str;
    #[inline]
    fn get(self, slice: &str) -> Option<&Self::Output> {
        if slice.is_char_boundary(self.start) {
            // SAFETY: 刚刚检查了 `start` 是否在 char 边界上,并且我们传递了一个安全的引用,因此返回值也将为 1。
            //
            Some(unsafe { &*self.get_unchecked(slice) })
        } else {
            None
        }
    }
    #[inline]
    fn get_mut(self, slice: &mut str) -> Option<&mut Self::Output> {
        if slice.is_char_boundary(self.start) {
            // SAFETY: 刚刚检查了 `start` 是否在 char 边界上,并且我们传递了一个安全的引用,因此返回值也将为 1。
            //
            Some(unsafe { &mut *self.get_unchecked_mut(slice) })
        } else {
            None
        }
    }
    #[inline]
    unsafe fn get_unchecked(self, slice: *const str) -> *const Self::Output {
        let len = (slice as *const [u8]).len();
        // SAFETY: 调用者必须维护 `get_unchecked` 的安全保证。
        unsafe { (self.start..len).get_unchecked(slice) }
    }
    #[inline]
    unsafe fn get_unchecked_mut(self, slice: *mut str) -> *mut Self::Output {
        let len = (slice as *mut [u8]).len();
        // SAFETY: 调用者必须维护 `get_unchecked_mut` 的安全保证。
        unsafe { (self.start..len).get_unchecked_mut(slice) }
    }
    #[inline]
    fn index(self, slice: &str) -> &Self::Output {
        let (start, end) = (self.start, slice.len());
        match self.get(slice) {
            Some(s) => s,
            None => super::slice_error_fail(slice, start, end),
        }
    }
    #[inline]
    fn index_mut(self, slice: &mut str) -> &mut Self::Output {
        if slice.is_char_boundary(self.start) {
            // SAFETY: 刚刚检查了 `start` 是否在 char 边界上,并且我们传递了一个安全的引用,因此返回值也将为 1。
            //
            unsafe { &mut *self.get_unchecked_mut(slice) }
        } else {
            super::slice_error_fail(slice, self.start, slice.len())
        }
    }
}

/// 使用语法 `&self[begin ..= end]` 或 `&mut self[begin ..= end]` 实现子字符串切片。
///
/// 从字节范围 [`begin`, `end`] 返回给定字符串的切片。等效于 `&self [begin .. end + 1]` 或 `&mut self[begin .. end + 1]`,除非 `end` 具有 `usize` 的最大值。
///
/// 此运算为 *O*(1)。
///
/// # Panics
///
/// 如果 `begin` 没有指向字符的起始字节偏移量 (由 `is_char_boundary` 定义),如果 `end` 没有指向字符的结束字节偏移量 (`end + 1` 是起始字节偏移量或等于 `len`),如果 `begin > end`,或者如果 `end >= len`,就会出现 panics。
///
///
///
///
///
///
///
#[stable(feature = "inclusive_range", since = "1.26.0")]
#[rustc_const_unstable(feature = "const_slice_index", issue = "none")]
unsafe impl SliceIndex<str> for ops::RangeInclusive<usize> {
    type Output = str;
    #[inline]
    fn get(self, slice: &str) -> Option<&Self::Output> {
        if *self.end() == usize::MAX { None } else { self.into_slice_range().get(slice) }
    }
    #[inline]
    fn get_mut(self, slice: &mut str) -> Option<&mut Self::Output> {
        if *self.end() == usize::MAX { None } else { self.into_slice_range().get_mut(slice) }
    }
    #[inline]
    unsafe fn get_unchecked(self, slice: *const str) -> *const Self::Output {
        // SAFETY: 调用者必须遵守 `get_unchecked` 的安全保证。
        unsafe { self.into_slice_range().get_unchecked(slice) }
    }
    #[inline]
    unsafe fn get_unchecked_mut(self, slice: *mut str) -> *mut Self::Output {
        // SAFETY: 调用者必须遵守 `get_unchecked_mut` 的安全保证。
        unsafe { self.into_slice_range().get_unchecked_mut(slice) }
    }
    #[inline]
    fn index(self, slice: &str) -> &Self::Output {
        if *self.end() == usize::MAX {
            str_index_overflow_fail();
        }
        self.into_slice_range().index(slice)
    }
    #[inline]
    fn index_mut(self, slice: &mut str) -> &mut Self::Output {
        if *self.end() == usize::MAX {
            str_index_overflow_fail();
        }
        self.into_slice_range().index_mut(slice)
    }
}

/// 使用语法 `&self[..= end]` 或 `&mut self[..= end]` 实现子字符串切片。
///
/// 从字节范围 \[0, `end`\] 中返回给定字符串的切片。
/// 等效于 `&self [0 .. end + 1]`,除非 `end` 具有 `usize` 的最大值。
///
/// 此运算为 *O*(1)。
///
/// # Panics
///
/// 如果 `end` 没有指向字符的结束字节偏移量 (`end + 1` 是 `is_char_boundary` 定义的起始字节偏移量,或者等于 `len`),或者如果 `end >= len`,就会出现 panics。
///
///
///
///
#[stable(feature = "inclusive_range", since = "1.26.0")]
#[rustc_const_unstable(feature = "const_slice_index", issue = "none")]
unsafe impl SliceIndex<str> for ops::RangeToInclusive<usize> {
    type Output = str;
    #[inline]
    fn get(self, slice: &str) -> Option<&Self::Output> {
        (0..=self.end).get(slice)
    }
    #[inline]
    fn get_mut(self, slice: &mut str) -> Option<&mut Self::Output> {
        (0..=self.end).get_mut(slice)
    }
    #[inline]
    unsafe fn get_unchecked(self, slice: *const str) -> *const Self::Output {
        // SAFETY: 调用者必须遵守 `get_unchecked` 的安全保证。
        unsafe { (0..=self.end).get_unchecked(slice) }
    }
    #[inline]
    unsafe fn get_unchecked_mut(self, slice: *mut str) -> *mut Self::Output {
        // SAFETY: 调用者必须遵守 `get_unchecked_mut` 的安全保证。
        unsafe { (0..=self.end).get_unchecked_mut(slice) }
    }
    #[inline]
    fn index(self, slice: &str) -> &Self::Output {
        (0..=self.end).index(slice)
    }
    #[inline]
    fn index_mut(self, slice: &mut str) -> &mut Self::Output {
        (0..=self.end).index_mut(slice)
    }
}

/// 解析字符串中的值
///
/// FromStr 的 [`from_str`] 方法通常通过 [`str`] 的 [`parse`] 方法隐式使用。
/// 有关示例,请参见 [`parse`] 的文档。
///
/// [`from_str`]: FromStr::from_str
/// [`parse`]: str::parse
///
/// `FromStr` 没有生命周期参数,因此您只能解析本身不包含生命周期参数的类型。
///
/// 换句话说,您可以使用 `FromStr` 解析 `i32`,但是不能解析 `&i32`。
/// 您可以解析包含 `i32` 的结构体,但不能解析包含 `&i32` 的结构体。
///
/// # Examples
///
/// `FromStr` 在示例 `Point` 类型上的基本实现:
///
/// ```
/// use std::str::FromStr;
///
/// #[derive(Debug, PartialEq)]
/// struct Point {
///     x: i32,
///     y: i32
/// }
///
/// #[derive(Debug, PartialEq, Eq)]
/// struct ParsePointError;
///
/// impl FromStr for Point {
///     type Err = ParsePointError;
///
///     fn from_str(s: &str) -> Result<Self, Self::Err> {
///         let (x, y) = s
///             .strip_prefix('(')
///             .and_then(|s| s.strip_suffix(')'))
///             .and_then(|s| s.split_once(','))
///             .ok_or(ParsePointError)?;
///
///         let x_fromstr = x.parse::<i32>().map_err(|_| ParsePointError)?;
///         let y_fromstr = y.parse::<i32>().map_err(|_| ParsePointError)?;
///
///         Ok(Point { x: x_fromstr, y: y_fromstr })
///     }
/// }
///
/// let expected = Ok(Point { x: 1, y: 2 });
/// // 显式调用
/// assert_eq!(Point::from_str("(1,2)"), expected);
/// // 隐式调用,通过解析
/// assert_eq!("(1,2)".parse(), expected);
/// assert_eq!("(1,2)".parse::<Point>(), expected);
/// // 输入字符串无效
/// assert!(Point::from_str("(1 2)").is_err());
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
pub trait FromStr: Sized {
    /// 可以从解析中返回的相关错误。
    #[stable(feature = "rust1", since = "1.0.0")]
    type Err;

    /// 解析字符串 `s` 以返回此类型的值。
    ///
    /// 如果解析成功,则返回 [`Ok`] 内部的值,否则,当字符串格式错误时,返回特定于 [`Err`] 内部的错误。
    /// 错误类型特定于 trait 的实现。
    ///
    /// # Examples
    ///
    /// [`i32`] 的基本用法,一种实现 `FromStr` 的类型:
    ///
    /// ```
    /// use std::str::FromStr;
    ///
    /// let s = "5";
    /// let x = i32::from_str(s).unwrap();
    ///
    /// assert_eq!(5, x);
    /// ```
    ///
    #[stable(feature = "rust1", since = "1.0.0")]
    fn from_str(s: &str) -> Result<Self, Self::Err>;
}

#[stable(feature = "rust1", since = "1.0.0")]
impl FromStr for bool {
    type Err = ParseBoolError;

    /// 从字符串中解析 `bool`。
    ///
    /// 唯一可接受的值是 `"true"` 和 `"false"`。
    /// 任何其他输入都将返回错误。
    ///
    /// # Examples
    ///
    /// ```
    /// use std::str::FromStr;
    ///
    /// assert_eq!(FromStr::from_str("true"), Ok(true));
    /// assert_eq!(FromStr::from_str("false"), Ok(false));
    /// assert!(<bool as FromStr>::from_str("not even a boolean").is_err());
    /// ```
    ///
    /// 注意,在许多情况下,`str` 上的 `.parse()` 方法更合适。
    ///
    /// ```
    /// assert_eq!("true".parse(), Ok(true));
    /// assert_eq!("false".parse(), Ok(false));
    /// assert!("not even a boolean".parse::<bool>().is_err());
    /// ```
    #[inline]
    fn from_str(s: &str) -> Result<bool, ParseBoolError> {
        match s {
            "true" => Ok(true),
            "false" => Ok(false),
            _ => Err(ParseBoolError),
        }
    }
}