Re: ADA Popularity Discussion Request

[kevin.cline@gmail.com (Kevin Cline)]

Lionel Draghi <Lionel.nospam.Draghi@Ada-France.org> wrote in message news:<413e2fbd$0$30586$626a14ce@news.free.fr>...
> jayessay wrote:
> ...
> > Exactly.  Actually this sort of development will save you much more
> > time and money than you could ever hope for from typical static typing.
> 
> How could this be?
> With powerful typing you write code.
> Without, you write as much code and much more tests.

I code test-first, and the amount of test code is relatively
independent of the language.

> 
> Let's compare:
> 
> A :
> function Random_Index return Integer;
> -- return's a value between 1 and 10
> 
> B :
> type Index is range 1 .. 10;
> function Random_Index return Index;
> 
> If considering code and comments, both are of the same length.

The first version leaves me wondering if the comment is correct.
The second version leaves me wondering if it sometimes throws
Constraint_Error.  There's no way to verify that A always returns a
value from 1 to 10 or to verify that B never throws Constraint_Error
without inspecting the function body.

I'm also wondering what happens when you write Random_Index +
Random_Index ?
Or Random_Index * Random_Index ?

> On the other hand, in the A version, I need to check the return value on 
> each call.

That's silly.  You have to trust functions to satisfy their
postconditions.   Even in Ada relatively few post-conditions can be
handled by type checks.  Would you check after every call to
Create_Linked_List to make sure that you got an empty list?  And then
check after every call to Insert_At_Head to make sure that the list
hadn't somehow become circular?

If you want bounded types in C++ it's easy enough to write a template
class:

template <int lower_bound, int upper_bound> class bounded
{
  private: 
    int _value;
  public:
    operator int { return _value; }
    explicit bounded(int value): _value(value)
    { if (value < lower_bound || value > upper_bound) { throw(...); } 
    operator=(int value) { *this = bounded(value); } 
  }
}

Then your function is:
  bounded<1,10> random_index() {...}

If the spirit moves you, you can even write:

  template <int lb2, int ub2>
    bounded<lower_bound+lb2, upper_bound + ub2> 
      operator+(bounded<lb2, ub2> b2)
  {
    return _value + b2.value;
  }

Now adding bounded<1,10> to bounded<0,5> gives a result of the proper
type: bounded<1,15>.

In LISP-y languages, you would just write something like:
  (defun random-index () (bound 1 10 ... )