Re: Char type verification

[Yves Bailly <kafka.fr@laposte.net>]

Jeffrey R. Carter wrote:
>> It was intended as "How do you translate this example to Ada? How would
>> you, as a presumably experienced Ada coder, do it? What hoops would we
>> jump through?
> 
> What this example does is output whether the 1st character of the 1st
> command-line argument is in the range 'A' .. 'Z'. In the Ada world, we
> tend to ignore the details of badly designed examples in poorly designed
> languages and simply implement the same functionality. Since there is no
> reason for your conversions and home-grown function, we're not going to
> waste effort translating them.

I'm very sorry Jeffrey, but I'm afraid you're missing the point. The given
example is no more than what it is : an example. There are plenty of ways
to know if a character is upper-case or not (what about the procedure
Is_Upper in the package Ada.Characters.Handling, by the way? did I missed
it in the replies?), and I'm quite sure Koray would have found most of them,
if not all (assuming it's possible).

As I understand it, the real question was : "having a list of contiguous
values of some type, how to know if a given value of that same type is
contained into the list". It's a kind of basic hashing: you can assume
to always be able to map your type's values to integers. So you can
replace "list of contiguous values" by "range of values".

So, here's my modest contribution. Don't bother to say it's overcomplex.

First create a generic package:
--8<-----8<-----8<-----8<-----8<-----8<-----8<---
generic
   type T is private;
   type H is range <>;
   with function Hash(val: in T) return H;
package P is
   function Is_In_Range(lower: in T;
                        upper: in T;
                        value: in T)
      return Boolean;
end P;
--8<-----8<-----8<-----8<-----8<-----8<-----8<---

The body performs the actual check of validity:
--8<-----8<-----8<-----8<-----8<-----8<-----8<---
package body P is

   function Is_In_Range(lower: in T;
                        upper: in T;
                        value: in T)
      return Boolean is
   begin
      return Hash(value) in Hash(lower)..Hash(upper);
   end Is_In_Range;

end P;
--8<-----8<-----8<-----8<-----8<-----8<-----8<---

And now use it in a test program:
--8<-----8<-----8<-----8<-----8<-----8<-----8<---
with Ada.Text_IO; use Ada.Text_IO;
with Ada.Command_Line; use Ada.Command_Line;
with P;
procedure Test is

   function To_Natural(c: in Character)
      return Natural is
   begin
      return Natural(Character'Pos(c));
   end To_Natural;

   package P_Char is new P(T => Character,
                           H => Natural,
                           Hash => To_Natural);
   c: Character;
begin
   c := Argument(1)(1);
   Put("Is_Upper('" & c & "') = ");
   Put_Line(Boolean'Image(P_Char.Is_In_Range('A', 'Z', c)));
end Test;
--8<-----8<-----8<-----8<-----8<-----8<-----8<---

Isn't Ada delightfull?  :-)

Regards,

-- 
(o< | Yves Bailly  : http://kafka-fr.net   | -o)
//\ | Linux Dijon  : http://www.coagul.org | //\
\_/ |                                      | \_/`