Re: Unknown constraints and type composition

[Jacob Sparre Andersen <jacob@jacob-sparre.dk>]

J-P. Rosen wrote:

> Even better, the default can be a raise expression (or a function that
> raises an exception for pre-2012), so no uninitialized object can be
> created. This is a run-time check, but a decent compiler would warn
> you at compile time.

This does not give a warning at compile time with FSF GNAT 8
(Debian/sid), nor with GNAT CE 2018, but you get the correct run-time
error with both compilers:

   private with Ada.Strings.Unbounded;
   
   package Initialisation_Required is
   
      type Instance is private;
   
      function Create (Name : in String) return Instance;
   
   private
   
      type Instance is
         record
            Name : Ada.Strings.Unbounded.Unbounded_String := raise Constraint_Error with "Uninitialised object.";
         end record;
   
   end Initialisation_Required;

   package body Initialisation_Required is
   
      function Create (Name : in String) return Instance is
      begin
         return R : Instance do
            R.Name := Ada.Strings.Unbounded.To_Unbounded_String (Name);
         end return;
      end Create;
   
   end Initialisation_Required;

   with Initialisation_Required;
   
   procedure Demo is
      O : Initialisation_Required.Instance := Initialisation_Required.Create (Name => "Hello");
   begin
      O := Initialisation_Required.Create (Name => "Hello");
   end Demo;

Another problem with this is that you can't wait until you leave your
internal constructor function, before the initialisation has to happen.

With the example above, you get your exception already at "return R :
Instance do", which isn't what we want.  (Easy to work around, but
something you should be aware of.)

Greetings,

Jacob
-- 
"Sleep is just a cheap substitute for coffee"