fixed typos and included last feedback

Author: QuentinOchem

features/rfc-oop-constructors.rst

@@ -474,6 +474,31 @@ call to the super constructor
 - the child type does not need to declare additional discriminant anymore just
 for the purpose of setting the parent ones.
 
+With discriminants, you may have situations where components are not available.
+In this case, the Initialization list need to only refer to components that are
+available for the discriminant provided - a constraint error is to be raised
+otherwise. For example:
+
+.. code-block:: ada
+
+   type Bla (V : Boolean) is record
+      case V is
+         when True =>
+            A : Integer;
+         when False =>
+            B : Integer;
+      end case;
+   end record;
+
+   procedure Bla'Constructor
+      with Initialize => (V => True, B => 10); -- Constraint Error
+   is
+      null;
+   end Bla'Constructor;
+
+This is consistent with discriminants used to constrain arrays (the value of the
+array would need to match the constrained component).
+
 Subtyping and Discriminants
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 

features/rfc-oop-dispatching.rst

@@ -211,6 +211,47 @@ different version of the subprogram depending on the context. Note that
 this means that subsequent usage of the 'Access attribute may not yield the
 same address, which is allowed.
 
+'Specialized
+------------
+
+In some situation, in particular in the context of post conditions, we need to
+be able to implement "specialization" calls as opposed to dispatching. A
+specialized call. A specialized call can only be written on a class wide
+post-condition. It is always static, called after the static type of the
+parameter. Upon derivation, said postcondition is modified to call the derived
+specialized subprogram if any. For example:
+
+.. code-block:: ada
+
+   package P is
+      type Root is tagged null record;
+
+      function Is_Init (Self : Root) return Boolean is (True);
+
+      procedure Init (Self : out Root) is abstract with
+      Post'Class => Self'Specialized.Is_Init;
+
+      type Child is new Root with record
+         F : Integer;
+      end record;
+
+      function Is_Init (Self : Child) return Boolean is (Self.F >= 1);
+
+      procedure Init (Self : out Child);
+      -- Also inherits Post => Self'Specialized.Is_Init, but this time statically call the child Is_Init.
+   end P;
+
+   package body P is
+
+      procedure Init (Self : out Child) is
+      begin
+         Self'Super.Init;
+         Self.F := 1;
+      end Init;
+
+   end P;
+
+
 Reference-level explanation
 ===========================
 

features/rfc-oop-primitives.rst

@@ -157,7 +157,7 @@ It is possible to also scope primitives in regular records:
 
    package P is
 
-      type R is record
+      type R is class record
          F : Integer;
 
          procedure Prim (Self : in out R; V : Integer);
@@ -245,7 +245,7 @@ E.g:
 
    package body P is
 
-      type body R is record
+      type body R is class record
          procedure Prim (Self : in out R; V : Integer) is
          begin
             Self.F := V;