Resolve "Replace 'element' used in the slides with "component""

Author: frank-at-adacore

courses/fundamentals_of_ada/030_basic_types/06-character_types.rst

@@ -9,19 +9,19 @@ Language-Defined Character Types
 * :ada:`Character`
 
    - 8-bit Latin-1
-   - Base element of :ada:`String`
+   - Base component of :ada:`String`
    - Uses attributes :ada:`'Image` / :ada:`'Value`
 
 * :ada:`Wide_Character`
 
    - 16-bit Unicode
-   - Base element of :ada:`Wide_Strings`
+   - Base component of :ada:`Wide_Strings`
    - Uses attributes :ada:`'Wide_Image` / :ada:`'Wide_Value`
 
 * :ada:`Wide_Wide_Character`
 
    - 32-bit Unicode
-   - Base element of :ada:`Wide_Wide_Strings`
+   - Base component of :ada:`Wide_Wide_Strings`
    - Uses attributes :ada:`'Wide_Wide_Image` / :ada:`'Wide_Wide_Value`
 
 -----------------------------

courses/fundamentals_of_ada/050_array_types/02-constrained_array_types.rst

@@ -63,8 +63,8 @@ Quiz
 
     Explanations
 
-    A. Legal - elements are :ada:`Boolean`
+    A. Legal - components are :ada:`Boolean`
     B. Legal - object types match
-    C. Legal - elements are :ada:`Boolean`
-    D. Although the sizes are the same and the elements are the same, the type is different
+    C. Legal - components are :ada:`Boolean`
+    D. Although the sizes are the same and the components are the same, the type is different
 

courses/fundamentals_of_ada/050_array_types/03-unconstrained_array_types.rst

@@ -81,7 +81,7 @@ Null Index Range
 
 * When :ada:`'Last` of the range is smaller than :ada:`'First`
 
-  * Array is empty - no elements
+  * Array is empty - no components
 
 * When using literals, the compiler will allow out-of-range numbers to indicate empty range
 
@@ -189,7 +189,7 @@ Indefinite Types
 No Indefinite Component Types
 -------------------------------
 
-* Arrays: consecutive elements of the exact **same type**
+* Arrays: consecutive components of the exact **same type**
 * Component size must be **defined**
 
     - No indefinite types

courses/fundamentals_of_ada/050_array_types/05-operations.rst

@@ -172,7 +172,7 @@ Which statement(s) is (are) legal?
    Explanations
 
    A. All objects are just Boolean values
-   B. An element of :ada:`A` is the same type as :ada:`B`
+   B. A component of :ada:`A` is the same type as :ada:`B`
    C. Slice must be of outermost array
    D. Slicing allowed on single-dimension arrays
 

courses/fundamentals_of_ada/050_array_types/06-looping_over_objects.rst

@@ -7,7 +7,7 @@ Note on Default Initialization for Array Types
 ------------------------------------------------
 
 * In Ada, objects are not initialized by default
-* To initialize an array, you can initialize each element
+* To initialize an array, you can initialize each component
 
    * But if the array type is used in multiple places, it would be better to initialize at the type level
    * No matter how many dimensions, there is only one component type
@@ -51,7 +51,7 @@ Two High-Level For-Loop Kinds
 Array/Container For-Loops
 ---------------------------
 
-* Work in terms of elements within an object
+* Work in terms of components within an object
 * Syntax hides indexing/iterator controls
 
    .. code:: Ada
@@ -60,7 +60,7 @@ Array/Container For-Loops
       ...
       end loop;
 
-* Starts with "first" element unless you reverse it
+* Starts with "first" component unless you reverse it
 * Loop parameter name is a constant if iterating over a constant, a variable otherwise
 
 ..

courses/fundamentals_of_ada/050_array_types/07-aggregates.rst

@@ -269,7 +269,7 @@ Aggregates in Ada 2022
          Illegal : Array_T := ();
          Ada2022 : Array_T := [];
 
-   * Single element array
+   * Single component array
 
       .. code:: Ada
 
@@ -308,7 +308,7 @@ Iterated Component Association
 
       Object2 := [for Item of Object => Item * 2];
 
-   * :ada:`Object2` will have each element doubled
+   * :ada:`Object2` will have each component doubled
 
 -------------------------------
 More Information on Iterators

courses/fundamentals_of_ada/065_discriminated_records/02-variant_records.rst

@@ -116,7 +116,7 @@ Mutable Variant Record
 
    * An object can be created without a constraint (:ada:`Pat`)
    * Or we can create in immutable object where the discriminant cannot change (:ada:`Sam`)
-   * And we can create an array whose element is mutable
+   * And we can create an array whose component is mutable
 
 --------------------------------
 Mutable Variant Record Example

courses/fundamentals_of_ada/065_discriminated_records/03-discriminant_record_array_size_idiom.rst

@@ -19,12 +19,12 @@ Vectors of Varying Lengths
    + Need two pieces of data
 
       * Array contents
-      * Location of last valid element
+      * Location of last valid component
 
 * For common usage, we want this to be a type (probably a record)
 
    + Maximum size array for contents
-   + Index for last valid element
+   + Index for last valid component
 
 ---------------------------------
 Simple Vector of Varying Length

courses/fundamentals_of_ada/075_type_derivation/01-introduction.rst

@@ -18,7 +18,7 @@ Type Derivation
 Reminder: What is a Type?
 ---------------------------
 
-* A type is characterized by two elements
+* A type is characterized by two components
 
    - Its data structure
    - The set of operations that applies to it

courses/fundamentals_of_ada/080_expressions/05-quantified_expressions.rst

@@ -354,8 +354,8 @@ Quiz
    type Array2_T is array (1 .. 3) of Array1_T;
    A : Array2_T;
 
-The above describes an array A whose elements are arrays of three elements.
-Which expression would one use to determine if at least one of A's elements are sorted?
+The above describes an array A whose components are arrays of three components.
+Which expression would one use to determine if at least one of A's components are sorted?
 
 A. | ``(for some El of A => (for some Idx in 2 .. 3 =>``
    |     ``El (Idx) >= El (Idx - 1)));``
@@ -368,8 +368,8 @@ D. | ``(for all El of A => (for some Idx in 2 .. 3 =>``
 
 .. container:: animate
 
- A. Will be :ada:`True` if any element has two consecutive increasing values
- B. Will be :ada:`True` if every element is sorted
+ A. Will be :ada:`True` if any component has two consecutive increasing values
+ B. Will be :ada:`True` if every component is sorted
  C. Correct
- D. Will be :ada:`True` if every element has two consecutive increasing values
+ D. Will be :ada:`True` if every component has two consecutive increasing values