Re: Surprise in array concatenation

[Georg Bauhaus <bauhaus@futureapps.de>]

Dmitry A. Kazakov wrote:
> On Tue, 06 Sep 2005 13:52:53 +0200, Georg Bauhaus wrote:
> 
> 
>>If the world is logical, as you claim, then our sentences
>>cannot be illogical, thus our sentences must be proper
>>propositions, thus decidable.
> 
> 
> OK, see mathematical type theory (starting for Russel & Whitehead)

(And hope to see what? There is no way out, we can only agree
on something. Mathematics declares the swamp away
into which it is built, and says so. But there are swamps in the
problem domain.)


> The violation is in inability to construct empty arrays and ranges for some
> types.

Many kinds of structured data cannot be constructed
from Ada's types because of Ada's rules. How does this violate Ada's
contracts? A contract is not necessarily simple, nor without deliberately
chosen limitations.


> That becomes funny. What is a "finite" value? Is 1/3 finite? What about
> 0.1? (:-))

Earlier I said, forget about real numbers (from mathematics) in real
computers. 1/3 is indeed an example in binary computers: An interval
representing two real numbers close to 1/3 is not 1/3, and you cannot
hope to be computing using real numbers using the facilities of a
real computing machine. That is because almost all reals cannot be
represented in a finite computer. The problem cannot in general be solved
by using intervals. For example, try to approximate 1/3,
using the analog of my fly-hits-windshield example. That is,
represent all numbers required for such a computation, and compare them.


> LOL! Any program represents anything symbolically.

No, an executing program has an interpretation.
This makes "representing" have a meaning.

An explosion (triggered by a signal coming through a cable plugged
into a computer outlet) is itself not a symbol that stands for something
else. Neither is The signal. You can have a bit pattern standing for the
explosing, thus a symbol. But a symbol is finite, and there can only
be finitely many in any computation in a real computer.


> Do you really believe
> that 1 is *the* 1? Did you see a label "made in Heaven" on it? (:-))

Type Positive starts at 1 and ends with Positive'Last.
Ignoring the literal 1 distraction for the moment, the phrase "counting
the value-elements in type Positive" has meaning. In real Ada programs,
the count is always finite. Here is a type of cardinality 1:

> type Infinite is (Infinity);

This is a finite type, obviously. For it's intended meaning as
fooling us into believing that a real computer could represent
infinite types, see my fly-windshield example.

Similarly, (the set of) universal integers can only be finite inside
the computer. If your program is to pick just any, not one particular
that happens to be small enough, the limit is the same.


>>>Presently the case A'Last < A'First is used to indicate that there
>>>is no bounds.
>>
>>That's wrong, in that it just indicates that A'Last < A'First yields
>>an empty range.
> 
> 
> The way how the operation ".." is defined on its operands has nothing to do
> with existence of bounds of the result.

The index values A'First etc. of an array always exist.
The elements might not exist.
This is consistent with how Ada is defined, AFAICT, and it is consistent
with the definitions in programming languages, and libraries.
It is also considered useful by many.


>>>It is a quite silly way to handle errors. Instead of an
>>>immediate response you return nonsensical values
>>
>>What nonsensical values are returned in text like "3 .. 1"?
> 
> 
> Nothing. 3 and 1 are literals. A'First and A'Last aren't.

What nonsensical values are returned in text like "A'First .. A'Last"
when A'First > A'Last? The fact that A'First doesn't always refer
to an element is not different from the fact that A'Length / 2
doesn't always refer to an element, even when the array isn't empty.
Of what use is the test A'Length = 0 in this case?