Merge branch 'slides/216-use-formatting-instead-of-quoted-strings' into 'master'

Resolve "Comprehensive Rust - use formatting instead of quoted strings"

Closes #216

See merge request feng/training/material!293

Author: frank-at-adacore

courses/comprehensive_rust_training/020_hello_world/03_playground.rst

@@ -8,17 +8,17 @@ Playground
 
 The :url:`Rust Playground <https://play.rust-lang.org/>` provides an easy
 way to run short Rust programs, and is the basis for the examples and
-exercises in this course. Try running the "hello-world" program it
+exercises in this course. Try running the :command:`hello-world` program it
 starts with. It comes with a few handy features:
 
--  Under "Tools", use the :rust:`rustfmt` option to format your code in the
+-  Under :menu:`Tools`, use the :menu:`rustfmt` option to format your code in the
    "standard" way.
 
--  Rust has two main "profiles" for generating code: Debug (extra
-   runtime checks, less optimization) and Release (fewer runtime checks,
-   lots of optimization). These are accessible under "Debug" at the top.
+-  Rust has two main :dfn:`profiles` for generating code: **Debug** (extra
+   runtime checks, less optimization) and **Release** (fewer runtime checks,
+   lots of optimization). These are accessible under :menu:`Debug` at the top.
 
--  If you're interested, use "ASM" under "..." to see the generated
+-  If you're interested, use :menu:`ASM` under :menu:`...` to see the generated
    assembly code.
 
 ---------

courses/comprehensive_rust_training/040_control_flow_basics/01_if.rst

@@ -1,10 +1,10 @@
-====================
-"if" expressions
-====================
+========================
+:rust:`if` expressions
+========================
 
---------------------
-"if" expressions
---------------------
+------------------------
+:rust:`if` expressions
+------------------------
 
 You use
 :url:`if expressions <https://doc.rust-lang.org/reference/expressions/if-expr.html#if-expressions>`

courses/comprehensive_rust_training/040_control_flow_basics/02_match.rst

@@ -1,10 +1,10 @@
-=======================
-"match" Expressions
-=======================
+===========================
+:rust:`match` Expressions
+===========================
 
------------------------
-"match" Expressions
------------------------
+---------------------------
+:rust:`match` Expressions
+---------------------------
 
 :rust:`match` can be used to check a value against one or more options:
 

courses/comprehensive_rust_training/040_control_flow_basics/03_loops.rst

@@ -9,9 +9,9 @@ Loops
 There are three looping keywords in Rust: :rust:`while`, :rust:`loop`, and
 :rust:`for`:
 
------------
-"while"
------------
+---------------
+:rust:`while`
+---------------
 
 The
 :url:`while keyword <https://doc.rust-lang.org/reference/expressions/loop-expr.html#predicate-loops>`
@@ -28,9 +28,9 @@ the condition is true.
        println!("Final x: {x}");
    }
 
--------------
-"for"
--------------
+-----------------
+:rust:`for`
+-----------------
 
 The :rust:`for` `loop <https://doc.rust-lang.org/std/keyword.for.html>`__
 iterates over ranges of values or the items in a collection:
@@ -47,19 +47,19 @@ iterates over ranges of values or the items in a collection:
        }
    }
 
----------------
-"for" Details
----------------
+-------------------
+:rust:`for` Details
+-------------------
 
 -  Under the hood :rust:`for` loops use a concept called :dfn:`iterators` to
    handle iterating over different kinds of ranges/collections.
    Iterators will be discussed in more detail later.
 -  Note that the first :rust:`for` loop only iterates to :rust:`4`. Show the
    :rust:`1..=5` syntax for an inclusive range.
 
---------------
-"loop"
---------------
+------------------
+:rust:`loop`
+------------------
 
 The :rust:`loop`
 `statement <https://doc.rust-lang.org/std/keyword.loop.html>`__ just
@@ -78,9 +78,9 @@ loops forever, until a :rust:`break`.
        }
    }
 
-----------------
-"loop" Details
-----------------
+--------------------
+:rust:`loop` Details
+--------------------
 
 -  The :rust:`loop` statement works like a :rust:`while true` loop. Use it for
    things like servers which will serve connections forever.

courses/comprehensive_rust_training/040_control_flow_basics/04_break_continue.rst

@@ -1,10 +1,10 @@
-============================
-"break" and "continue"
-============================
+====================================
+:rust:`break` and :rust:`continue`
+====================================
 
-----------------------------
-"break" and "continue"
-----------------------------
+------------------------------------
+:rust:`break` and :rust:`continue`
+------------------------------------
 
 If you want to immediately start the next iteration use
 :url:`continue <https://doc.rust-lang.org/reference/expressions/loop-expr.html#continue-expressions>`.

courses/comprehensive_rust_training/050_tuples_and_arrays/02_tuples.rst

@@ -25,6 +25,6 @@ Details
 -  Fields of a tuple can be accessed by the period and the index of the
    value, e.g. :rust:`t.0`, :rust:`t.1`.
 
--  The empty tuple :rust:`()` is referred to as the "unit type" and
+-  The empty tuple :rust:`()` is referred to as the :dfn:`unit type` and
    signifies absence of a return value, akin to :rust:`void` in other
    languages.

courses/comprehensive_rust_training/050_tuples_and_arrays/04_destructuring.rst

@@ -32,7 +32,7 @@ larger value into its constituent parts:
 Details
 ---------
 
--  The patterns used here are "irrefutable", meaning that the compiler
+-  The patterns used here are :dfn:`irrefutable`, meaning that the compiler
    can statically verify that the value on the right of :rust:`=` has the
    same structure as the pattern.
 -  A variable name is an irrefutable pattern that always matches any

courses/comprehensive_rust_training/060_references/01_shared.rst

@@ -7,7 +7,7 @@ Shared References
 -------------------
 
 A reference provides a way to access another value without taking
-ownership of the value, and is also called "borrowing". Shared
+ownership of the value, and is also called :dfn:`borrowing`. Shared
 references are read-only, and the referenced data cannot change.
 
 .. code:: rust
@@ -22,7 +22,7 @@ references are read-only, and the referenced data cannot change.
    }
 
 A shared reference to a type :rust:`T` has type :rust:`&T`. A reference value is
-made with the :rust:`&` operator. The :rust:`*` operator "dereferences" a
+made with the :rust:`&` operator. The :rust:`*` operator :dfn:`dereferences` a
 reference, yielding its value.
 
 ---------
@@ -32,9 +32,9 @@ Details
 -  References can never be null in Rust, so null checking is not
    necessary.
 
--  A reference is said to "borrow" the value it refers to, and this is a
+-  A reference is said to **borrow** the value it refers to, and this is a
    good model for students not familiar with pointers: code can use the
-   reference to access the value, but is still "owned" by the original
+   reference to access the value, but is still **owned** by the original
    variable. The course will get into more detail on ownership in day 3.
 
 -  References are implemented as pointers, and a key advantage is that

courses/comprehensive_rust_training/060_references/02_exclusive.rst

@@ -24,7 +24,7 @@ Details
 
 Key points:
 
--  "Exclusive" means that only this reference can be used to access the
+-  :dfn:`Exclusive` means that only this reference can be used to access the
    value. No other references (shared or exclusive) can exist at the
    same time, and the referenced value cannot be accessed while the
    exclusive reference exists. Try making an :rust:`&point.0` or changing

courses/comprehensive_rust_training/070_user_defined_types/05_const.rst

@@ -1,10 +1,10 @@
-===========
-"const"
-===========
+===============
+:rust:`const`
+===============
 
------------
-"const"
------------
+---------------
+:rust:`const`
+---------------
 
 Constants are evaluated at compile time and their values are inlined
 wherever they are used: