Re: Mixing public and private member of a class. Dealing with what to hide and not

[Jere <jhb.chat@gmail.com>]

On Wednesday, February 13, 2019 at 12:40:24 PM UTC-5, Daniel wrote:
> <SNIPPED>
> 
> Any help or ideas of how to do it? (if it possible respecting 1 "with" dependency in the outter world side)
> 
> Thank you very much and Best regards.

After fixing syntax errors, the example you gave compiled fine in 
GCC 7.1.1 (there were quite a few syntax errors however).

That said, I'm not a fan of the two stage extension method.  I prefer
one of two ways (depending on if the "public" component is limited or
not:

1.  Non-limited built in components:  I just make them private but
use getter and setter functions with the same name as the component.

2.  Complex or limited components:  I use "reference types" to get 
access to them.  In order to make this work, the record component 
needs to be aliased.  I'll give an example of this below.  I'm using
simple built in types for the example, but hopefully you can 
extrapolate the example to types like your notebook type.

EXAMPLE:
with Ada.Text_IO; use Ada.Text_IO;
procedure Hello is

    package Thing is
        type Instance is tagged limited private;
        subtype Class is Instance'Class;
        
        -- This defines a reference type for a 
        -- component that can be modified by
        -- a client package
        type Natural_Holder
            (Element : not null access Natural)
        is limited null record
            with Implicit_Dereference => Element;
        
        -- This function returns that reference
        -- type.  Notice the name of the function
        -- matches the field (not required, but
        -- I like this nomenclature)
        function Value
            (Self : aliased in out Instance) 
             return Natural_Holder;
             
        -- This defines a reference type for a 
        -- component that cannot be modified by
        -- a client package.  It is essentially
        -- constant
        type Constant_Character_Holder
            (Element : not null access constant Character)
        is limited null record
            with Implicit_Dereference => Element;
            
        -- This function returns that reference
        -- type.  Notice the name of the function
        -- matches the field (not required, but
        -- I like this nomenclature)
        function Constant_Value
            (Self : aliased Instance)
             return Constant_Character_Holder;
        
    private
    
        type Instance is tagged limited record
            Value          : aliased Natural   := 0;
            Constant_Value : aliased Character := 'W';
        end record;
        
        function Value
            (Self : aliased in out Instance) 
             return Natural_Holder
        is (Element => Self.Value'Access);
        
        function Constant_Value
            (Self : aliased Instance)
             return Constant_Character_Holder
        is (Element => Self.Constant_Value'Access);
        
    end Thing; 
    
    Something : Thing.Instance;

begin
    Put_Line("Value ="  & Natural'Image(Something.Value));
    Something.Value := 23;
    Put_Line("Value ="  & Natural'Image(Something.Value));
    
    Put_Line("Constant_Value ="  
             & Character'Image(Something.Constant_Value));
             
    -- Fails to compile next line since the value is constant       
    --Something.Constant_Value := 'C';
    
end Hello;

RM section on user defined references:
http://www.ada-auth.org/standards/rm12_w_tc1/html/RM-4-1-5.html#I2450