Fix typos

Author: ronan-d

features/rfc-import-array-from-address.md

@@ -49,7 +49,7 @@ example:
    type FLB_Array_Access is access all FLB_Array;
 
    function Create_C_Array_Of_Int (Size : Integer) return System.Address;
-   pragma Import (C, Create_C_Array, "create_c_array_of_int);
+   pragma Import (C, Create_C_Array, "create_c_array_of_int");
 
    V1 : Constrained_Array_Access := Constrained_Array_Access'From_Address
       (Create_C_Array_Of_Int (10));
@@ -78,7 +78,7 @@ access type instead. To some respect, not presuming the type of the object
 and not requiring the creation of an explicit access type, might be better.
 However, this requires performing all accessibility checks that don't really
 make sense when addressing external memory. It's most likely that these checks
-will need to be disabled anyway. Note that if accessibilty checks are required,
+will need to be disabled anyway. Note that if accessibility checks are required,
 it is still possible to create a local array mapped to an address instead:
 
 ```ada

features/rfc-oop-aggregates-and-assignments.rst

@@ -45,22 +45,22 @@ mechanism through a value duplication ('Clone) and post update adjustment
 Note that this extra complexity is driven from the desire to support natively
 Ada constructs (aggregates, partial copies, etc) and improve compatibility
 between classes and tagged types. Users can leverage default implementation if
-such level of control is unecessary. Some language extension may also allow
+such level of control is unnecessary. Some language extensions may also allow
 to forbid aggregates and partial update on specific types (although this
-introduces complexities in generics that now need to specify wether these
+introduces complexities in generics that now need to specify whether these
 restricted types are allowed or not).
 
 Also keep in mind that Ada Flare aggregates also need to account for types that
 have both public and private components.
 
-This RFC is about tagged record (and class records even if not explicitely
-mentionned). Simple records should also be studied when constructors are made
+This RFC is about tagged records (and class records even if not explicitly
+mentioned). Simple records should also be studied when constructors are made
 available to them.
 
 The additional capabilities need to be optimized as much as possible by the
 compiler. In particular - even if it's not a language mandate - the compiler
 should replace calls to Clone by binary copies and remove calls to Adjust when
-it knows there's no chance of calling an overriden subprogram.
+it knows there's no chance of calling an overridden subprogram.
 
 'Clone
 ------
@@ -95,17 +95,17 @@ Calls to 'Clone are statically resolved when used on definite views, and
 dynamically resolved on 'Class wide type. This is arguably a departure from the
 "all calls are dispatching" requirement from other aspects of the OOP design,
 but is required to allow partial copies of objects which are done today in
-various places Ada.
+various places in Ada.
 
 The invariant of the target object is not checked after a call to Clone, some
 parts may still be inconsistent and fixed later by Adjust.
 
 'Adjust
 -------
 
-'Adjust is a overridable attribute called after certain operations. It is
+'Adjust is an overridable attribute called after certain operations. It is
 different from the legacy Ada Adjust primitive in that it has an argument
-refering to the initial value. Note that the From parameter of adjust is
+referring to the initial value. Note that the From parameter of Adjust is
 always typed after the root type of the tagged record hierarchy - indeed, the source
 object may be higher up in the derivation chain in the case of partial
 copy. This value is provided for reference but is not expected to be