Thank you, the List_Image package is really cool!

I have two points to make:

On Sun, 11 Feb 2018, Lionel Draghi wrote:

> [...] to avoid forcing users to pull to much packages (unless standard) 
> with this simple utility, I tried another solution : I moved multi lines 
> declarations to platform dependent child packages named Unix_ and 
> Windows_Predefined_Styles.

Point 1:

To avoid code duplication, would it not be better to define a single 
generic package Predefined_Styples with a parameter EOL, and then creat 
the same two packages by instantiation in the spec of List_Image, as 
below?

package Windows_Predefined_Styles is new
              Predefined_Styles(EOL => Windows_EOL)

package Unix_Predefined_Styles is new
              Predefined_Styles(EOL => Unix_EOL)

> The choice will still be done explicitly in the user code.

Indeed!

> And there is a not so satisfying code duplication.

That is the problem with two different packages.


Point 2:

The entire approach gets in trouble if you ever generate and store a 
string on windows, but then use Unix to process ist, or vice versa. For 
portability, it might be better to fix an arbitrary line terminator -- LF, 
or CRLF or whatever, as long as it does never ocur as a part of a line 
itself -- and then delegate the problem of properly printing a sequence of 
lines to the user.

Oh, instead of delegating the problem to the user, you could even solve it 
for the user by defining a child package

package List_Image.Text_IO is

   procedure Put_Lines(Lines: String; EOL: String);

end List_Image.Text_IO;

The implementation would "with Ada.Text_IO", and then iterate through the 
individual lines in Lines, calling Ada.Text_IO.Put_Line for each line. If 
EOL="", Put_Lines will assume a single-line represenation and just call 
Ada.Text_IO.Put_Line(Lines);

Unlike your current approach, this would allow implementations to be 
completely independent from the operation system's line termination 
convention.

Of course, the user should always use List_Images.Text_IO.Put_Lines, to 
print the output from List_Images.Image. Calling Ada.Text_IO directly 
would be a compatibility issue. Consequently, you could (re-)define

   type Image_String is new String;

   generic
     with package Cursors is new Cursors_Signature (<>);
     with function Image (C : Cursors.Cursor) return String is <>;
     with package Style is new Image_Style (<>);
   function Image (Cont : in Cursors.Container) return Image_String;

and

   procedure Put_Lines(Lines: Image_String; EOL: String);

Would that make sense to you?

Stefan

--------  I  love  the  taste  of  Cryptanalysis  in  the morning!  --------
www.uni-weimar.de/de/medien/professuren/mediensicherheit/people/stefan-lucks
----Stefan.Lucks (at) uni-weimar.de, Bauhaus-Universität Weimar, Germany----