Re: renaming Interfaces.Java.Ada_To_Java_String to the + operator

["Nick Roberts" <Nick.Roberts@dial.pipex.com>]

Precisely right, Mikey babe,  You've more or less listed precisely those
rare cases that I was banging on about.  I know, I know, I know, you
yourself use lots and lots of FSTs; but I would suggest, in the great
scheme of things, that large FSTs, giant arrays, etc. constitute rare
cases.  (No? :-)

To use this spot to answer Robert Dewar also (ever conscious of bandwidth,
signal to noise ratios etc.), Robert argues that the use of explicit
conversions or not depends on the level of abstraction, which I
wholeheartedly agree with.  He then says that in cases where the level of
abstraction does not suit an explicit conversion, use of the unary +
operator approximates to an implicit conversion (which Ada does not support
generally).  Well, true, it's nearer than a great long identifier and
brackets; but it's still not an implicit conversion, and it's appearance
will (probably) worry a programmer who doesn't already know what it means,
whereas the explicit identifier (probably) won't.

What I'm saying is that it is actually slightly more pragmatic to use the
explicit identifier, except in those (rare!) cases such as large FSTs,
giant arrays, etc. where reducing bulk would actually matter (and, indeed,
improve readability).

-- 

Nick Roberts
Croydon, UK

Proprietor, ThoughtWing Software; Independent Software Development
Consultant
* Nick.Roberts@dial.pipex.com * Voicemail & Fax +44 181-405 1124 *
*** Eats three shredded spams every morning for breakfast ***


Michael F Brenner <mfb@mbunix.mitre.org> wrote in article
<69ntk6$qj8@top.mitre.org>...
> Using a function call (say, about 10 characters long) versus
> using a single character (+) to represent the type change
> is more readable on a single instance of the conversion.
> 
> The place where the extra length really matters is when you
> have a lot of input to do, say 10000 lines, then you are saving
> 100000 key strokes, which could be a lot of data input money.
> 
> This almost suggests a compromise that unary operators should
> have a corresponding function name. Use the function name
> for small numbers (say 10 or fewer) instances.
> 
> Use the prefix operator when doing large amounts of stuff, like
> defining large finite state machines, filling in giant arrays,
> making test cases, defining test scenarios for a package body, etc.