keyword_docs.rs.html -- source
Description: Source to the Rust file `src/libstd/keyword_docs.rs`.
Keywords: rust, rustlang, rust-lang

      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
    613
    614
    615
    616
    617
    618
    619
    620
    621
    622
    623
    624
    625
    626
    627
    628
    629
    630
    631
    632
    633
    634
    635
    636
    637
    638
    639
    640
    641
    642
    643
    644
    645
    646
    647
    648
    649
    650
    651
    652
    653
    654
    655
    656
    657
    658
    659
    660
    661
    662
    663
    664
    665
    666
    667
    668
    669
    670
    671
    672
    673
    674
    675
    676
    677
    678
    679
    680
    681
    682
    683
    684
    685
    686
    687
    688
    689
    690
    691
    692
    693
    694
    695
    696
    697
    698
    699
    700
    701
    702
    703
    704
    705
    706
    707
    708
    709
    710
    711
    712
    713
    714
    715
    716
    717
    718
    719
    720

    // Copyright 2018 The Rust Project Developers. See the COPYRIGHT
    // file at the top-level directory of this distribution and at
    // http://rust-lang.org/COPYRIGHT.
    //
    // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
    // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
    // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
    // option. This file may not be copied, modified, or distributed
    // except according to those terms.

    #[doc(keyword = "as")]
    //
    /// The keyword for casting a value to a type.
    ///
    /// `as` is most commonly used to turn primitive types into other primitive types, but it has other
    /// uses that include turning pointers into addresses, addresses into pointers, and pointers into
    /// other pointers.
    ///
    /// ```rust
    /// let thing1: u8 = 89.0 as u8;
    /// assert_eq!('B' as u32, 66);
    /// assert_eq!(thing1 as char, 'Y');
    /// let thing2: f32 = thing1 as f32 + 10.5;
    /// assert_eq!(true as u8 + thing2 as u8, 100);
    /// ```
    ///
    /// In general, any cast that can be performed via ascribing the type can also be done using `as`,
    /// so instead of writing `let x: u32 = 123`, you can write `let x = 123 as u32` (Note: `let x: u32
    /// = 123` would be best in that situation). The same is not true in the other direction, however,
    /// explicitly using `as` allows a few more coercions that aren't allowed implicitly, such as
    /// changing the type of a raw pointer or turning closures into raw pointers.
    ///
    /// Other places `as` is used include as extra syntax for [`crate`] and `use`, to change the name
    /// something is imported as.
    ///
    /// For more information on what `as` is capable of, see the [Reference]
    ///
    /// [Reference]:
    /// https://doc.rust-lang.org/reference/expressions/operator-expr.html#type-cast-expressions
    /// [`crate`]: keyword.crate.html
    mod as_keyword { }

    #[doc(keyword = "const")]
    //
    /// The keyword for defining constants.
    ///
    /// Sometimes a certain value is used many times throughout a program, and it can become
    /// inconvenient to copy it over and over. What's more, it's not always possible or desirable to
    /// make it a variable that gets carried around to each function that needs it. In these cases, the
    /// `const` keyword provides a convenient alternative to code duplication.
    ///
    /// ```rust
    /// const THING: u32 = 0xABAD1DEA;
    ///
    /// let foo = 123 + THING;
    /// ```
    ///
    /// Constants must be explicitly typed, unlike with `let` you can't ignore its type and let the
    /// compiler figure it out. Any constant value can be defined in a const, which in practice happens
    /// to be most things that would be reasonable to have a constant (barring `const fn`s, coming
    /// soon). For example, you can't have a File as a `const`.
    ///
    /// The only lifetime allowed in a constant is `'static`, which is the lifetime that encompasses
    /// all others in a Rust program. For example, if you wanted to define a constant string, it would
    /// look like this:
    ///
    /// ```rust
    /// const WORDS: &'static str = "hello rust!";
    /// ```
    ///
    /// Thanks to static lifetime elision, you usually don't have to explicitly use 'static:
    ///
    /// ```rust
    /// const WORDS: &str = "hello convenience!";
    /// ```
    ///
    /// `const` items looks remarkably similar to `static` items, which introduces some confusion as
    /// to which one should be used at which times. To put it simply, constants are inlined wherever
    /// they're used, making using them identical to simply replacing the name of the const with its
    /// value. Static variables on the other hand point to a single location in memory, which all
    /// accesses share. This means that, unlike with constants, they can't have destructors, and act as
    /// a single value across the entire codebase.
    ///
    /// Constants, as with statics, should always be in SCREAMING_SNAKE_CASE.
    ///
    /// The `const` keyword is also used in raw pointers in combination with `mut`, as seen in `*const
    /// T` and `*mut T`. More about that can be read at the [pointer] primitive part of the Rust docs.
    ///
    /// For more detail on `const`, see the [Rust Book] or the [Reference]
    ///
    /// [pointer]: primitive.pointer.html
    /// [Rust Book]:
    /// https://doc.rust-lang.org/stable/book/2018-edition/ch03-01-variables-and-mutability.html#differences-between-variables-and-constants
    /// [Reference]: https://doc.rust-lang.org/reference/items/constant-items.html
    mod const_keyword { }

    #[doc(keyword = "crate")]
    //
    /// The `crate` keyword.
    ///
    /// The primary use of the `crate` keyword is as a part of `extern crate` declarations, which are
    /// used to specify a dependency on a crate external to the one it's declared in. Crates are the
    /// fundamental compilation unit of Rust code, and can be seen as libraries or projects. More can
    /// be read about crates in the [Reference].
    ///
    /// ```rust ignore
    /// extern crate rand;
    /// extern crate my_crate as thing;
    /// extern crate std; // implicitly added to the root of every Rust project
    /// ```
    ///
    /// The `as` keyword can be used to change what the crate is referred to as in your project. If a
    /// crate name includes a dash, it is implicitly imported with the dashes replaced by underscores.
    ///
    /// `crate` is also used as in conjunction with `pub` to signify that the item it's attached to
    /// is public only to other members of the same crate it's in.
    ///
    /// ```rust
    /// # #[allow(unused_imports)]
    /// pub(crate) use std::io::Error as IoError;
    /// pub(crate) enum CoolMarkerType { }
    /// pub struct PublicThing {
    ///     pub(crate) semi_secret_thing: bool,
    /// }
    /// ```
    ///
    /// [Reference]: https://doc.rust-lang.org/reference/items/extern-crates.html
    mod crate_keyword { }

    #[doc(keyword = "enum")]
    //
    /// For defining enumerations.
    ///
    /// Enums in Rust are similar to those of other compiled languages like C, but have important
    /// differences that make them considerably more powerful. What Rust calls enums are more commonly
    /// known as [Algebraic Data Types] if you're coming from a functional programming background. The
    /// important detail is that each enum variant can have data to go along with it.
    ///
    /// ```rust
    /// # struct Coord;
    /// enum SimpleEnum {
    ///     FirstVariant,
    ///     SecondVariant,
    ///     ThirdVariant,
    /// }
    ///
    /// enum Location {
    ///     Unknown,
    ///     Anonymous,
    ///     Known(Coord),
    /// }
    ///
    /// enum ComplexEnum {
    ///     Nothing,
    ///     Something(u32),
    ///     LotsOfThings {
    ///         usual_struct_stuff: bool,
    ///         blah: String,
    ///     }
    /// }
    ///
    /// enum EmptyEnum { }
    /// ```
    ///
    /// The first enum shown is the usual kind of enum you'd find in a C-style language. The second
    /// shows off a hypothetical example of something storing location data, with `Coord` being any
    /// other type that's needed, for example a struct. The third example demonstrates the kind of
    /// data a variant can store, ranging from nothing, to a tuple, to an anonymous struct.
    ///
    /// Instantiating enum variants involves explicitly using the enum's name as its namespace,
    /// followed by one of its variants. `SimpleEnum::SecondVariant` would be an example from above.
    /// When data follows along with a variant, such as with rust's built-in [`Option`] type, the data
    /// is added as the type describes, for example `Option::Some(123)`. The same follows with
    /// struct-like variants, with things looking like `ComplexEnum::LotsOfThings { usual_struct_stuff:
    /// true, blah: "hello!".to_string(), }`. Empty Enums are similar to () in that they cannot be
    /// instantiated at all, and are used mainly to mess with the type system in interesting ways.
    ///
    /// For more information, take a look at the [Rust Book] or the [Reference]
    ///
    /// [Algebraic Data Types]: https://en.wikipedia.org/wiki/Algebraic_data_type
    /// [`Option`]: option/enum.Option.html
    /// [Rust Book]: https://doc.rust-lang.org/book/second-edition/ch06-01-defining-an-enum.html
    /// [Reference]: https://doc.rust-lang.org/reference/items/enumerations.html
    mod enum_keyword { }

    #[doc(keyword = "extern")]
    //
    /// For external connections in Rust code.
    ///
    /// The `extern` keyword is used in two places in Rust. One is in conjunction with the [`crate`]
    /// keyword to make your Rust code aware of other Rust crates in your project, i.e. `extern crate
    /// lazy_static;`. The other use is in foreign function interfaces (FFI).
    ///
    /// `extern` is used in two different contexts within FFI. The first is in the form of external
    /// blocks, for declaring function interfaces that Rust code can call foreign code by.
    ///
    /// ```rust ignore
    /// #[link(name = "my_c_library")]
    /// extern "C" {
    ///     fn my_c_function(x: i32) -> bool;
    /// }
    /// ```
    ///
    /// This code would attempt to link with `libmy_c_library.so` on unix-like systems and
    /// `my_c_library.dll` on Windows at runtime, and panic if it can't find something to link to. Rust
    /// code could then use `my_c_function` as if it were any other unsafe Rust function. Working with
    /// non-Rust languages and FFI is inherently unsafe, so wrappers are usually built around C APIs.
    ///
    /// The mirror use case of FFI is also done via the `extern` keyword:
    ///
    /// ```rust
    /// #[no_mangle]
    /// pub extern fn callable_from_c(x: i32) -> bool {
    ///     x % 3 == 0
    /// }
    /// ```
    ///
    /// If compiled as a dylib, the resulting .so could then be linked to from a C library, and the
    /// function could be used as if it was from any other library.
    ///
    /// For more information on FFI, check the [Rust book] or the [Reference].
    ///
    /// [Rust book]:
    /// https://doc.rust-lang.org/book/second-edition/ch19-01-unsafe-rust.html#using-extern-functions-to-call-external-code
    /// [Reference]: https://doc.rust-lang.org/reference/items/external-blocks.html
    mod extern_keyword { }

    #[doc(keyword = "fn")]
    //
    /// The keyword for defining functions.
    ///
    /// Functions are the primary way code is executed within Rust. Function blocks, usually just
    /// called functions, can be defined in a variety of different places and be assigned many
    /// different attributes and modifiers.
    ///
    /// Standalone functions that just sit within a module not attached to anything else are common,
    /// but most functions will end up being inside [`impl`] blocks, either on another type itself, or
    /// as a trait impl for that type.
    ///
    /// ```rust
    /// fn standalone_function() {
    ///     // code
    /// }
    ///
    /// pub fn public_thing(argument: bool) -> String {
    ///     // code
    ///     # "".to_string()
    /// }
    ///
    /// struct Thing {
    ///     foo: i32,
    /// }
    ///
    /// impl Thing {
    ///     pub fn new() -> Self {
    ///         Self {
    ///             foo: 42,
    ///         }
    ///     }
    /// }
    /// ```
    ///
    /// In addition to presenting fixed types in the form of `fn name(arg: type, ..) -> return_type`,
    /// functions can also declare a list of type parameters along with trait bounds that they fall
    /// into.
    ///
    /// ```rust
    /// fn generic_function<T: Clone>(x: T) -> (T, T, T) {
    ///     (x.clone(), x.clone(), x.clone())
    /// }
    ///
    /// fn generic_where<T>(x: T) -> T
    ///     where T: std::ops::Add<Output=T> + Copy
    /// {
    ///     x + x + x
    /// }
    /// ```
    ///
    /// Declaring trait bounds in the angle brackets is functionally identical to using a `where`
    /// clause. It's up to the programmer to decide which works better in each situation, but `where`
    /// tends to be better when things get longer than one line.
    ///
    /// Along with being made public via `pub`, `fn` can also have an [`extern`] added for use in
    /// FFI.
    ///
    /// For more information on the various types of functions and how they're used, consult the [Rust
    /// book] or the [Reference].
    ///
    /// [`impl`]: keyword.impl.html
    /// [`extern`]: keyword.extern.html
    /// [Rust book]: https://doc.rust-lang.org/book/second-edition/ch03-03-how-functions-work.html
    /// [Reference]: https://doc.rust-lang.org/reference/items/functions.html
    mod fn_keyword { }

    #[doc(keyword = "for")]
    //
    /// The `for` keyword.
    ///
    /// `for` is primarily used in for-in-loops, but it has a few other pieces of syntactic uses such as
    /// `impl Trait for Type` (see [`impl`] for more info on that). for-in-loops, or to be more
    /// precise, iterator loops, are a simple syntactic sugar over an exceedingly common practice
    /// within Rust, which is to loop over an iterator until that iterator returns None (or `break`
    /// is called).
    ///
    /// ```rust
    /// for i in 0..5 {
    ///     println!("{}", i * 2);
    /// }
    ///
    /// for i in std::iter::repeat(5) {
    ///     println!("turns out {} never stops being 5", i);
    ///     break; // would loop forever otherwise
    /// }
    ///
    /// 'outer: for x in 5..50 {
    ///     for y in 0..10 {
    ///         if x == y {
    ///             break 'outer;
    ///         }
    ///     }
    /// }
    /// ```
    ///
    /// As shown in the example above, `for` loops (along with all other loops) can be tagged, using
    /// similar syntax to lifetimes (only visually similar, entirely distinct in practice). Giving the
    /// same tag to `break` breaks the tagged loop, which is useful for inner loops. It is definitely
    /// not a goto.
    ///
    /// A `for` loop expands as shown:
    ///
    /// ```rust
    /// # fn code() { }
    /// # let iterator = 0..2;
    /// for loop_variable in iterator {
    ///     code()
    /// }
    /// ```
    ///
    /// ```rust
    /// # fn code() { }
    /// # let iterator = 0..2;
    /// {
    ///     let mut _iter = std::iter::IntoIterator::into_iter(iterator);
    ///     loop {
    ///         match _iter.next() {
    ///             Some(loop_variable) => {
    ///                 code()
    ///             },
    ///             None => break,
    ///         }
    ///     }
    /// }
    /// ```
    ///
    /// More details on the functionality shown can be seen at the [`IntoIterator`] docs.
    ///
    /// For more information on for-loops, see the [Rust book] or the [Reference].
    ///
    /// [`impl`]: keyword.impl.html
    /// [`IntoIterator`]: iter/trait.IntoIterator.html
    /// [Rust book]:
    /// https://doc.rust-lang.org/book/2018-edition/ch03-05-control-flow.html#looping-through-a-collection-with-for
    /// [Reference]: https://doc.rust-lang.org/reference/expressions/loop-expr.html#iterator-loops
    mod for_keyword { }

    #[doc(keyword = "if")]
    //
    /// If statements and expressions.
    ///
    /// `if` is a familiar construct to most programmers, and is the main way you'll often do logic in
    /// your code. However, unlike in most languages, `if` blocks can also act as expressions.
    ///
    /// ```rust
    /// # let rude = true;
    /// if 1 == 2 {
    ///     println!("whoops, mathematics broke");
    /// } else {
    ///     println!("everything's fine!");
    /// }
    ///
    /// let greeting = if rude {
    ///     "sup nerd."
    /// } else {
    ///     "hello, friend!"
    /// };
    ///
    /// if let Ok(x) = "123".parse::<i32>() {
    ///     println!("{} double that and you get {}!", greeting, x * 2);
    /// }
    /// ```
    ///
    /// Shown above are the three typical forms an `if` block comes in. First is the usual kind of
    /// thing you'd see in many languages, with an optional `else` block. Second uses `if` as an
    /// expression, which is only possible if all branches return the same type. An `if` expression can
    /// be used everywhere you'd expect. The third kind of `if` block is an `if let` block, which
    /// behaves similarly to using a `match` expression:
    ///
    /// ```rust
    /// if let Some(x) = Some(123) {
    ///     // code
    ///     # let _ = x;
    /// } else {
    ///     // something else
    /// }
    ///
    /// match Some(123) {
    ///     Some(x) => {
    ///         // code
    ///         # let _ = x;
    ///     },
    ///     _ => {
    ///         // something else
    ///     },
    /// }
    /// ```
    ///
    /// Each kind of `if` expression can be mixed and matched as needed.
    ///
    /// ```rust
    /// if true == false {
    ///     println!("oh no");
    /// } else if "something" == "other thing" {
    ///     println!("oh dear");
    /// } else if let Some(200) = "blarg".parse::<i32>().ok() {
    ///     println!("uh oh");
    /// } else {
    ///     println!("phew, nothing's broken");
    /// }
    /// ```
    ///
    /// The `if` keyword is used in one other place in Rust, namely as a part of pattern matching
    /// itself, allowing patterns such as `Some(x) if x > 200` to be used.
    ///
    /// For more information on `if` expressions, see the [Rust book] or the [Reference].
    ///
    /// [Rust book]:
    /// https://doc.rust-lang.org/stable/book/2018-edition/ch03-05-control-flow.html#if-expressions
    /// [Reference]: https://doc.rust-lang.org/reference/expressions/if-expr.html
    mod if_keyword { }

    #[doc(keyword = "impl")]
    //
    /// The implementation-defining keyword.
    ///
    /// The `impl` keyword is primarily used to define implementations on types. Inherent
    /// implementations are standalone, while trait implementations are used to implement traits for
    /// types, or other traits.
    ///
    /// Functions and consts can both be defined in an implementation. A function defined in an
    /// `impl` block can be standalone, meaning it would be called like `Foo::bar()`. If the function
    /// takes `self`, `&self`, or `&mut self` as its first argument, it can also be called using
    /// method-call syntax, a familiar feature to any object oriented programmer, like `foo.bar()`.
    ///
    /// ```rust
    /// struct Example {
    ///     number: i32,
    /// }
    ///
    /// impl Example {
    ///     fn boo() {
    ///         println!("boo! Example::boo() was called!");
    ///     }
    ///
    ///     fn answer(&mut self) {
    ///         self.number += 42;
    ///     }
    ///
    ///     fn get_number(&self) -> i32 {
    ///         self.number
    ///     }
    /// }
    ///
    /// trait Thingy {
    ///     fn do_thingy(&self);
    /// }
    ///
    /// impl Thingy for Example {
    ///     fn do_thingy(&self) {
    ///         println!("doing a thing! also, number is {}!", self.number);
    ///     }
    /// }
    /// ```
    ///
    /// For more information on implementations, see the [Rust book][book1] or the [Reference].
    ///
    /// The other use of the `impl` keyword is in `impl Trait` syntax, which can be seen as a shorthand
    /// for "a concrete type that implements this trait". Its primary use is working with closures,
    /// which have type definitions generated at compile time that can't be simply typed out.
    ///
    /// ```rust
    /// fn thing_returning_closure() -> impl Fn(i32) -> bool {
    ///     println!("here's a closure for you!");
    ///     |x: i32| x % 3 == 0
    /// }
    /// ```
    ///
    /// For more information on `impl Trait` syntax, see the [Rust book][book2].
    ///
    /// [book1]: https://doc.rust-lang.org/stable/book/2018-edition/ch05-03-method-syntax.html
    /// [Reference]: https://doc.rust-lang.org/reference/items/implementations.html
    /// [book2]:
    /// https://doc.rust-lang.org/stable/book/2018-edition/ch10-02-traits.html#returning-traits
    mod impl_keyword { }

    #[doc(keyword = "let")]
    //
    /// The variable binding keyword.
    ///
    /// The primary use for the `let` keyword is in `let` statements, which are used to introduce a new
    /// set of variables into the current scope, as given by a pattern.
    ///
    /// ```rust
    /// # #![allow(unused_assignments)]
    /// let thing1: i32 = 100;
    /// let thing2 = 200 + thing1;
    ///
    /// let mut changing_thing = true;
    /// changing_thing = false;
    ///
    /// let (part1, part2) = ("first", "second");
    ///
    /// struct Example {
    ///     a: bool,
    ///     b: u64,
    /// }
    ///
    /// let Example { a, b: _ } = Example {
    ///     a: true,
    ///     b: 10004,
    /// };
    /// assert!(a);
    /// ```
    ///
    /// The pattern is most commonly a single variable, which means no pattern matching is done and
    /// the expression given is bound to the variable. Apart from that, patterns used in `let` bindings
    /// can be as complicated as needed, given that the pattern is exhaustive. See the [Rust
    /// book][book1] for more information on pattern matching. The type of the pattern is optionally
    /// given afterwards, but if left blank is automatically inferred by the compiler if possible.
    ///
    /// Variables in Rust are immutable by default, and require the `mut` keyword to be made mutable.
    ///
    /// Multiple variables can be defined with the same name, known as shadowing. This doesn't affect
    /// the original variable in any way beyond being unable to directly access it beyond the point of
    /// shadowing. It continues to remain in scope, getting dropped only when it falls out of scope.
    /// Shadowed variables don't need to have the same type as the variables shadowing them.
    ///
    /// ```rust
    /// let shadowing_example = true;
    /// let shadowing_example = 123.4;
    /// let shadowing_example = shadowing_example as u32;
    /// let mut shadowing_example = format!("cool! {}", shadowing_example);
    /// shadowing_example += " something else!"; // not shadowing
    /// ```
    ///
    /// Other places the `let` keyword is used include along with [`if`], in the form of `if let`
    /// expressions. They're useful if the pattern being matched isn't exhaustive, such as with
    /// enumerations. `while let` also exists, which runs a loop with a pattern matched value until
    /// that pattern can't be matched.
    ///
    /// For more information on the `let` keyword, see the [Rust book] or the [Reference]
    ///
    /// [book1]: https://doc.rust-lang.org/stable/book/2018-edition/ch06-02-match.html
    /// [`if`]: keyword.if.html
    /// [book2]:
    /// https://doc.rust-lang.org/stable/book/2018-edition/ch18-01-all-the-places-for-patterns.html#let-statements
    /// [Reference]: https://doc.rust-lang.org/reference/statements.html#let-statements
    mod let_keyword { }

    #[doc(keyword = "loop")]
    //
    /// The loop-defining keyword.
    ///
    /// `loop` is used to define the simplest kind of loop supported in Rust. It runs the code inside
    /// it until the code uses `break` or the program exits.
    ///
    /// ```rust
    /// loop {
    ///     println!("hello world forever!");
    ///     # break;
    /// }
    ///
    /// let mut i = 0;
    /// loop {
    ///     println!("i is {}", i);
    ///     if i > 10 {
    ///         break;
    ///     }
    ///     i += 1;
    /// }
    /// ```
    ///
    /// Unlike the other kinds of loops in Rust (`while`, `while let`, and `for`), loops can be used as
    /// expressions that return values via `break`.
    ///
    /// ```rust
    /// let mut i = 1;
    /// let something = loop {
    ///     i *= 2;
    ///     if i > 100 {
    ///         break i;
    ///     }
    /// };
    /// assert_eq!(something, 128);
    /// ```
    ///
    /// Every `break` in a loop has to have the same type. When it's not explicitly giving something,
    /// `break;` returns `()`.
    ///
    /// For more information on `loop` and loops in general, see the [Reference].
    ///
    /// [Reference]: https://doc.rust-lang.org/reference/expressions/loop-expr.html
    mod loop_keyword { }

    #[doc(keyword = "struct")]
    //
    /// The keyword used to define structs.
    ///
    /// Structs in Rust come in three flavors: Structs with named fields, tuple structs, and unit
    /// structs.
    ///
    /// ```rust
    /// struct Regular {
    ///     field1: f32,
    ///     field2: String,
    ///     pub field3: bool
    /// }
    ///
    /// struct Tuple(u32, String);
    ///
    /// struct Unit;
    /// ```
    ///
    /// Regular structs are the most commonly used. Each field defined within them has a name and a
    /// type, and once defined can be accessed using `example_struct.field` syntax. The fields of a
    /// struct share its mutability, so `foo.bar = 2;` would only be valid if `foo` was mutable. Adding
    /// `pub` to a field makes it visible to code in other modules, as well as allowing it to be
    /// directly accessed and modified.
    ///
    /// Tuple structs are similar to regular structs, but its fields have no names. They are used like
    /// tuples, with deconstruction possible via `let TupleStruct(x, y) = foo;` syntax.  For accessing
    /// individual variables, the same syntax is used as with regular tuples, namely `foo.0`, `foo.1`,
    /// etc, starting at zero.
    ///
    /// Unit structs are most commonly used as marker. They have a size of zero bytes, but unlike empty
    /// enums they can be instantiated, making them isomorphic to the unit type `()`. Unit structs are
    /// useful when you need to implement a trait on something, but don't need to store any data inside
    /// it.
    ///
    /// # Instantiation
    ///
    /// Structs can be instantiated in different ways, all of which can be mixed and
    /// matched as needed. The most common way to make a new struct is via a constructor method such as
    /// `new()`, but when that isn't available (or you're writing the constructor itself), struct
    /// literal syntax is used:
    ///
    /// ```rust
    /// # struct Foo { field1: f32, field2: String, etc: bool }
    /// let example = Foo {
    ///     field1: 42.0,
    ///     field2: "blah".to_string(),
    ///     etc: true,
    /// };
    /// ```
    ///
    /// It's only possible to directly instantiate a struct using struct literal syntax when all of its
    /// fields are visible to you.
    ///
    /// There are a handful of shortcuts provided to make writing constructors more convenient, most
    /// common of which is the Field Init shorthand. When there is a variable and a field of the same
    /// name, the assignment can be simplified from `field: field` into simply `field`. The following
    /// example of a hypothetical constructor demonstrates this:
    ///
    /// ```rust
    /// struct User {
    ///     name: String,
    ///     admin: bool,
    /// }
    ///
    /// impl User {
    ///     pub fn new(name: String) -> Self {
    ///         Self {
    ///             name,
    ///             admin: false,
    ///         }
    ///     }
    /// }
    /// ```
    ///
    /// Another shortcut for struct instantiation is available, used when you need to make a new
    /// struct that has the same values as most of a previous struct of the same type, called struct
    /// update syntax:
    ///
    /// ```rust
    /// # struct Foo { field1: String, field2: () }
    /// # let thing = Foo { field1: "".to_string(), field2: () };
    /// let updated_thing = Foo {
    ///     field1: "a new value".to_string(),
    ///     ..thing
    /// };
    /// ```
    ///
    /// Tuple structs are instantiated in the same way as tuples themselves, except with the struct's
    /// name as a prefix: `Foo(123, false, 0.1)`.
    ///
    /// Empty structs are instantiated with just their name, and don't need anything else. `let thing =
    /// EmptyStruct;`
    ///
    /// # Style conventions
    ///
    /// Structs are always written in CamelCase, with few exceptions. While the trailing comma on a
    /// struct's list of fields can be omitted, it's usually kept for convenience in adding and
    /// removing fields down the line.
    ///
    /// For more information on structs, take a look at the [Rust Book][book] or the
    /// [Reference][reference].
    ///
    /// [`PhantomData`]: marker/struct.PhantomData.html
    /// [book]: https://doc.rust-lang.org/book/second-edition/ch05-01-defining-structs.html
    /// [reference]: https://doc.rust-lang.org/reference/items/structs.html
    mod struct_keyword { }

# Help

## Keyboard Shortcuts

`?`
  Show this help dialog
`S`
  Focus the search field
`↑`
  Move up in search results
`↓`
  Move down in search results
`↹`
  Switch tab
`⏎`
  Go to active search result
`+`
  Expand all sections
`-`
  Collapse all sections

## Search Tricks

Prefix searches with a type followed by a colon (e.g. `fn:`) to restrict the search to a given type.

Accepted types are: `fn`, `mod`, `struct`, `enum`, `trait`, `type`, `macro`, and `const`.

Search functions by type signature (e.g. `vec -> usize` or `* -> vec`)

Search multiple things at once by splitting your query with comma (e.g. `str,u8` or `String,struct:Vec,test`)