<html xmlns:v="urn:schemas-microsoft-com:vml" xmlns:o="urn:schemas-microsoft-com:office:office" xmlns:w="urn:schemas-microsoft-com:office:word" xmlns:m="http://schemas.microsoft.com/office/2004/12/omml" xmlns="http://www.w3.org/TR/REC-html40">
<head>
<meta http-equiv=Content-Type content="text/html; charset=us-ascii">
<meta name=Generator content="Microsoft Word 12 (filtered medium)">
<style>
<!--
/* Font Definitions */
@font-face
{font-family:Helvetica;
panose-1:2 11 6 4 2 2 2 2 2 4;}
@font-face
{font-family:Courier;
panose-1:2 7 4 9 2 2 5 2 4 4;}
@font-face
{font-family:"Cambria Math";
panose-1:2 4 5 3 5 4 6 3 2 4;}
@font-face
{font-family:Calibri;
panose-1:2 15 5 2 2 2 4 3 2 4;}
@font-face
{font-family:Tahoma;
panose-1:2 11 6 4 3 5 4 4 2 4;}
/* Style Definitions */
p.MsoNormal, li.MsoNormal, div.MsoNormal
{margin:0in;
margin-bottom:.0001pt;
font-size:12.0pt;
font-family:"Times New Roman","serif";}
a:link, span.MsoHyperlink
{mso-style-priority:99;
color:blue;
text-decoration:underline;}
a:visited, span.MsoHyperlinkFollowed
{mso-style-priority:99;
color:purple;
text-decoration:underline;}
p.MsoListParagraph, li.MsoListParagraph, div.MsoListParagraph
{mso-style-priority:34;
margin-top:0in;
margin-right:0in;
margin-bottom:0in;
margin-left:.5in;
margin-bottom:.0001pt;
font-size:12.0pt;
font-family:"Times New Roman","serif";}
span.apple-style-span
{mso-style-name:apple-style-span;}
span.EmailStyle18
{mso-style-type:personal-reply;
font-family:"Calibri","sans-serif";
color:#1F497D;}
.MsoChpDefault
{mso-style-type:export-only;
font-size:10.0pt;}
@page Section1
{size:8.5in 11.0in;
margin:1.0in 1.0in 1.0in 1.0in;}
div.Section1
{page:Section1;}
/* List Definitions */
@list l0
{mso-list-id:1035691374;
mso-list-type:hybrid;
mso-list-template-ids:2058903014 67698703 67698713 67698715 67698703 67698713 67698715 67698703 67698713 67698715;}
@list l0:level1
{mso-level-tab-stop:none;
mso-level-number-position:left;
text-indent:-.25in;}
ol
{margin-bottom:0in;}
ul
{margin-bottom:0in;}
-->
</style>
<!--[if gte mso 9]><xml>
<o:shapedefaults v:ext="edit" spidmax="1026" />
</xml><![endif]--><!--[if gte mso 9]><xml>
<o:shapelayout v:ext="edit">
<o:idmap v:ext="edit" data="1" />
</o:shapelayout></xml><![endif]-->
</head>
<body lang=EN-US link=blue vlink=purple style='word-wrap: break-word;
-webkit-nbsp-mode: space;-webkit-line-break: after-white-space'>
<div class=Section1>
<p class=MsoNormal><span style='font-size:11.0pt;font-family:"Calibri","sans-serif";
color:#1F497D'>Tony:<o:p></o:p></span></p>
<p class=MsoNormal><span style='font-size:11.0pt;font-family:"Calibri","sans-serif";
color:#1F497D'><o:p> </o:p></span></p>
<p class=MsoNormal><b><i><span style='font-family:"Calibri","sans-serif";
color:#1F497D'>Sorry, I have been too long-winded here. To answer your
questions succinctly: <o:p></o:p></span></i></b></p>
<p class=MsoNormal><b><i><span style='font-family:"Calibri","sans-serif";
color:#1F497D'><o:p> </o:p></span></i></b></p>
<p class=MsoNormal><b><i><span style='font-family:"Calibri","sans-serif";
color:#1F497D'>1. I can relax on the <u>requirement</u> for overflow
checking, but programmers should never count on it silently wrapping around.<o:p></o:p></span></i></b></p>
<p class=MsoNormal><b><i><span style='font-family:"Calibri","sans-serif";
color:#1F497D'><o:p> </o:p></span></i></b></p>
<p class=MsoNormal><b><i><span style='font-family:"Calibri","sans-serif";
color:#1F497D'>2. I think checked assignability gets us onto the slippery
slope (see below). Using differently named conversion operators would
lesson some of the ugliness of ORD/VAL and also prevent confusion with their
intended use as enumeration/INTEGER conversions.<o:p></o:p></span></i></b></p>
<p class=MsoNormal><b><i><span style='font-family:"Calibri","sans-serif";
color:#1F497D'><o:p> </o:p></span></i></b></p>
<p class=MsoNormal><b><i><span style='font-family:"Calibri","sans-serif";
color:#1F497D'>Read on for the long-winded version…<o:p></o:p></span></i></b></p>
<p class=MsoNormal><span style='font-size:11.0pt;font-family:"Calibri","sans-serif";
color:#1F497D'><o:p> </o:p></span></p>
<p class=MsoNormal><span style='font-size:11.0pt;font-family:"Calibri","sans-serif";
color:#1F497D'>According to NELSON (SPwM3), ORD and VAL convert between <b><u>enumerations</u></b>
and INTEGERs, and INTEGER is all integers represented by the <u>implementation</u>.
So, the range of INTEGER is likely different for 8-bit, 16-bit, 32-bit, and 64-bit
processors. <o:p></o:p></span></p>
<p class=MsoNormal><span style='font-size:11.0pt;font-family:"Calibri","sans-serif";
color:#1F497D'><o:p> </o:p></span></p>
<p class=MsoNormal><span style='font-size:11.0pt;font-family:"Calibri","sans-serif";
color:#1F497D'>Today we see 32-bit and 64-bit processors as predominant, but I
remember the day when 8-bit and 16-bit were the norm. Someday we may see
128-bit processors as the norm. <o:p></o:p></span></p>
<p class=MsoNormal><span style='font-size:11.0pt;font-family:"Calibri","sans-serif";
color:#1F497D'><o:p> </o:p></span></p>
<p class=MsoNormal><span style='font-size:11.0pt;font-family:"Calibri","sans-serif";
color:#1F497D'>(I’ve been cleaning up my basement office and ran across a
box of 8-inch floppy disks. When I showed them to my daughter she
understood the meaning of “floppy” as opposed to the rigid 3.5-inch
floppies of today. But, I digress.)<o:p></o:p></span></p>
<p class=MsoNormal><span style='font-size:11.0pt;font-family:"Calibri","sans-serif";
color:#1F497D'><o:p> </o:p></span></p>
<p class=MsoNormal><span style='font-size:11.0pt;font-family:"Calibri","sans-serif";
color:#1F497D'>On a 64-bit processor, this whole idea of LONGINT as 64-bits then
becomes mute since INTEGER will be 64 bits also. But on a 16-bit machine
(assuming we had an implementation for one) the native word size would be less
than the 32-bits we seem to take for granted now.<o:p></o:p></span></p>
<p class=MsoNormal><span style='font-size:11.0pt;font-family:"Calibri","sans-serif";
color:#1F497D'><o:p> </o:p></span></p>
<p class=MsoNormal><span style='font-size:11.0pt;font-family:"Calibri","sans-serif";
color:#1F497D'>One problem is that one doesn’t really know the range of
LONGINT unless we define it as some number of bits. Rodney’s
proposal simply stated that LONGINT was at least as big as INTEGER but could be
larger. So, on a 64-bit machine, are LONGINT and INTEGER really the same
in terms of implementation?, whereas on a 32-bit the LONGINT would have an
additional 32-bits more than INTEGER? What about a 128-bit machine?<o:p></o:p></span></p>
<p class=MsoNormal><span style='font-size:11.0pt;font-family:"Calibri","sans-serif";
color:#1F497D'><o:p> </o:p></span></p>
<p class=MsoNormal><span style='font-size:11.0pt;font-family:"Calibri","sans-serif";
color:#1F497D'>I say all this to point out the obvious, namely that LONGINT and
INTEGER are different <b><u>types</u></b>. <o:p></o:p></span></p>
<p class=MsoNormal><span style='font-size:11.0pt;font-family:"Calibri","sans-serif";
color:#1F497D'><o:p> </o:p></span></p>
<p class=MsoNormal><span style='font-size:11.0pt;font-family:"Calibri","sans-serif";
color:#1F497D'>Therefore, IMO the language must make it clear how these
different types interact.<o:p></o:p></span></p>
<p class=MsoNormal><span style='font-size:11.0pt;font-family:"Calibri","sans-serif";
color:#1F497D'><o:p> </o:p></span></p>
<p class=MsoNormal><span style='font-size:11.0pt;font-family:"Calibri","sans-serif";
color:#1F497D'>I would argue that <o:p></o:p></span></p>
<p class=MsoNormal><span style='font-size:11.0pt;font-family:"Calibri","sans-serif";
color:#1F497D'> x: LONGINT := 23;<o:p></o:p></span></p>
<p class=MsoNormal><span style='font-size:11.0pt;font-family:"Calibri","sans-serif";
color:#1F497D'>is wrong! The programmer should have to write<o:p></o:p></span></p>
<p class=MsoNormal><span style='font-size:11.0pt;font-family:"Calibri","sans-serif";
color:#1F497D'> x: LONGINT := 23L;<o:p></o:p></span></p>
<p class=MsoNormal><span style='font-size:11.0pt;font-family:"Calibri","sans-serif";
color:#1F497D'>instead.<o:p></o:p></span></p>
<p class=MsoNormal><span style='font-size:11.0pt;font-family:"Calibri","sans-serif";
color:#1F497D'><o:p> </o:p></span></p>
<p class=MsoNormal><span style='font-size:11.0pt;font-family:"Calibri","sans-serif";
color:#1F497D'>A subrange of LONGINT would be written as [23L..4200L] and would
be a different type than the integer subrange [23..4200] even though the ranges
are identical.<o:p></o:p></span></p>
<p class=MsoNormal><span style='font-size:11.0pt;font-family:"Calibri","sans-serif";
color:#1F497D'><o:p> </o:p></span></p>
<p class=MsoNormal><span style='font-size:11.0pt;font-family:"Calibri","sans-serif";
color:#1F497D'>Likewise, IMO mixed arithmetic with the compiler deciding what
to do is wrong. The programmer should have to explicitly write
conversions to a common type for arithmetic.<o:p></o:p></span></p>
<p class=MsoNormal><span style='font-size:11.0pt;font-family:"Calibri","sans-serif";
color:#1F497D'><o:p> </o:p></span></p>
<p class=MsoNormal><span style='font-size:11.0pt;font-family:"Calibri","sans-serif";
color:#1F497D'>I have no problem with extending the existing operators to deal
with LONGINT; it’s just that the result should be LONGINT.<o:p></o:p></span></p>
<p class=MsoNormal><span style='font-size:11.0pt;font-family:"Calibri","sans-serif";
color:#1F497D'>Given x: LONGINT := 49L;<o:p></o:p></span></p>
<p class=MsoNormal><span style='font-size:11.0pt;font-family:"Calibri","sans-serif";
color:#1F497D'> INC(x) yields 50L<o:p></o:p></span></p>
<p class=MsoNormal><span style='font-size:11.0pt;font-family:"Calibri","sans-serif";
color:#1F497D'> INC(x, 3L) yields 52L<o:p></o:p></span></p>
<p class=MsoNormal><span style='font-size:11.0pt;font-family:"Calibri","sans-serif";
color:#1F497D'> note that INC(x, 3) would be a
syntax error since 3 is an INTEGER and x is a LONGINT<o:p></o:p></span></p>
<p class=MsoNormal><span style='font-size:11.0pt;font-family:"Calibri","sans-serif";
color:#1F497D'> (x + 20L) yields 69L<o:p></o:p></span></p>
<p class=MsoNormal><span style='font-size:11.0pt;font-family:"Calibri","sans-serif";
color:#1F497D'> note that (x + 20) would be a
syntax error since 20 is an INTEGER and x is a LONGINT<o:p></o:p></span></p>
<p class=MsoNormal><span style='font-size:11.0pt;font-family:"Calibri","sans-serif";
color:#1F497D'> LAST(LONGINT) yields a LONGINT<o:p></o:p></span></p>
<p class=MsoNormal><span style='font-size:11.0pt;font-family:"Calibri","sans-serif";
color:#1F497D'><o:p> </o:p></span></p>
<p class=MsoNormal><span style='font-size:11.0pt;font-family:"Calibri","sans-serif";
color:#1F497D'>Now that I think about it more, I have a problem using ORD/VAL
for the conversion since NELSON defines these as converting between <b><u>enumerations</u></b>
and INTEGERs, and since LONGINT is a different type than INTEGER and quite
possibly has a greater range than INTEGER. Is the proposal to also allow
enumerations to use the range of LONGINT ? Enumerations currently are
defined as having a range no greater than INTEGER. To extend them to
LONGINT would lose the obvious performance benefits of keeping them same range
as native INTEGER.<o:p></o:p></span></p>
<p class=MsoNormal><span style='font-size:11.0pt;font-family:"Calibri","sans-serif";
color:#1F497D'><o:p> </o:p></span></p>
<p class=MsoNormal><span style='font-size:11.0pt;font-family:"Calibri","sans-serif";
color:#1F497D'>Maybe we should invent new names for the conversions between
INTEGER and LONGINT. Perhaps PROMOTE and DEMOTE or some such. These
are probably bad names, but I use them below simply to illustrate (feel free to
come up with better names):<o:p></o:p></span></p>
<p class=MsoNormal><span style='font-size:11.0pt;font-family:"Calibri","sans-serif";
color:#1F497D'> Given longInt: LONGINT; and
int: INTEGER;<o:p></o:p></span></p>
<p class=MsoNormal><span style='font-size:11.0pt;font-family:"Calibri","sans-serif";
color:#1F497D'> int := DEMOTE(longInt); would perform the
conversion from LONGINT to INTEGER and would give a runtime range check error if
longInt is too big/small to fit in an INTEGER.<o:p></o:p></span></p>
<p class=MsoNormal><span style='font-size:11.0pt;font-family:"Calibri","sans-serif";
color:#1F497D'> longInt := PROMOTE(int) would always succeed in
performing the conversion from INTEGER to LONGINT but would make the conversion
explicit<o:p></o:p></span></p>
<p class=MsoNormal><span style='font-size:11.0pt;font-family:"Calibri","sans-serif";
color:#1F497D'> int + DEMOTE(longInt) would yield an INTEGER result
with all arithmetic being done in the range of INTEGER<o:p></o:p></span></p>
<p class=MsoNormal><span style='font-size:11.0pt;font-family:"Calibri","sans-serif";
color:#1F497D'> longInt + PROMOTE(int) would yield a LONGINT result
with all arithmetic being done in the range of LONGINT<o:p></o:p></span></p>
<p class=MsoNormal><span style='font-size:11.0pt;font-family:"Calibri","sans-serif";
color:#1F497D'><o:p> </o:p></span></p>
<p class=MsoNormal><span style='font-size:11.0pt;font-family:"Calibri","sans-serif";
color:#1F497D'>Now if we were to allow checked assignability (as Tony is
leaning toward), I think we begin to get on the slippery slope. How far
do we extend this to the point that it is not clear in the expression of the
code what is happening? If I can write “int := longInt;” why
not “int := 23L;” and why not “int := longInt + 57;”
and is this different than “int := longInt + 57L;”? etc. etc.<o:p></o:p></span></p>
<p class=MsoNormal><span style='font-size:11.0pt;font-family:"Calibri","sans-serif";
color:#1F497D'><o:p> </o:p></span></p>
<p class=MsoNormal><span style='font-size:11.0pt;font-family:"Calibri","sans-serif";
color:#1F497D'>I agree the ORD/VAL syntax is ugly, so that is another reason
(besides them applying to enumerations only) we should use different names for
the INTEGER/LONGINT conversions.<o:p></o:p></span></p>
<p class=MsoNormal><span style='font-size:11.0pt;font-family:"Calibri","sans-serif";
color:#1F497D'><o:p> </o:p></span></p>
<p class=MsoNormal><b><span style='font-size:14.0pt;font-family:"Calibri","sans-serif";
color:#1F497D'>Sorry, I have been too long-winded here. To answer your
questions succinctly: <o:p></o:p></span></b></p>
<p class=MsoNormal><b><span style='font-size:14.0pt;font-family:"Calibri","sans-serif";
color:#1F497D'><o:p> </o:p></span></b></p>
<p class=MsoNormal><b><span style='font-size:14.0pt;font-family:"Calibri","sans-serif";
color:#1F497D'>1. I can relax on the <u>requirement</u> for overflow
checking, but programmers should never count on it silently wrapping around.<o:p></o:p></span></b></p>
<p class=MsoNormal><b><span style='font-size:14.0pt;font-family:"Calibri","sans-serif";
color:#1F497D'><o:p> </o:p></span></b></p>
<p class=MsoNormal><b><span style='font-size:14.0pt;font-family:"Calibri","sans-serif";
color:#1F497D'>2. I think checked assignability gets us onto the slippery
slope. Using differently named conversion operators would lesson some of
the ugliness of ORD/VAL and also prevent confusion with their intended use as enumeration/INTEGER
conversions.<o:p></o:p></span></b></p>
<p class=MsoNormal><span style='font-size:11.0pt;font-family:"Calibri","sans-serif";
color:#1F497D'><o:p> </o:p></span></p>
<p class=MsoNormal><span style='font-size:11.0pt;font-family:"Calibri","sans-serif";
color:#1F497D'>Regards,<o:p></o:p></span></p>
<p class=MsoNormal><span style='font-size:11.0pt;font-family:"Calibri","sans-serif";
color:#1F497D'>Randy Coleburn<o:p></o:p></span></p>
<p class=MsoNormal><span style='font-size:11.0pt;font-family:"Calibri","sans-serif";
color:#1F497D'><o:p> </o:p></span></p>
<div>
<div style='border:none;border-top:solid #B5C4DF 1.0pt;padding:3.0pt 0in 0in 0in'>
<p class=MsoNormal style='margin-left:.5in'><b><span style='font-size:10.0pt;
font-family:"Tahoma","sans-serif"'>From:</span></b><span style='font-size:10.0pt;
font-family:"Tahoma","sans-serif"'> Tony Hosking [mailto:hosking@cs.purdue.edu]
<br>
<b>Sent:</b> Sunday, January 10, 2010 3:43 PM<br>
<b>To:</b> Randy Coleburn<br>
<b>Cc:</b> m3devel<br>
<b>Subject:</b> Re: [M3devel] the LONGINT proposal<o:p></o:p></span></p>
</div>
</div>
<p class=MsoNormal style='margin-left:.5in'><o:p> </o:p></p>
<div>
<p class=MsoNormal style='margin-left:.5in'>Hi Randy,<o:p></o:p></p>
</div>
<div>
<p class=MsoNormal style='margin-left:.5in'><o:p> </o:p></p>
</div>
<div>
<p class=MsoNormal style='margin-left:.5in'>As someone who has actually written
Modula-3 programs for a living your opinions are always highly valued. I
agree with you in principle and aims, except for requiring overflow to be a
checked run-time error. The language definition already has a mechanism
for handling this in the require FloatMode interface. It is not something
that the compiler should be involved in. I also just now raised
a question about perhaps having integer literals adapt their type to the
context in which they are used.<o:p></o:p></p>
</div>
<div>
<p class=MsoNormal style='margin-left:.5in'><o:p> </o:p></p>
</div>
<div>
<p class=MsoNormal style='margin-left:.5in'>I should point out that the current
mainline implementation does exactly what you propose (except overflow
checking). It captures the fundamental spirit of Rodney's proposal but
does not permit mixed arithmetic or assignment. Can I ask what your issue
is w.r.to checked assignability? I am still leaning in favor. It is
not much different from assignment from an INTEGER to a subrange, which
requires no explicit check, though of course there is a run-time range check. Having
programmers explicitly write:<o:p></o:p></p>
</div>
<div>
<p class=MsoNormal style='margin-left:.5in'><o:p> </o:p></p>
</div>
<div>
<p class=MsoNormal style='margin-left:.5in'><span class=apple-style-span><span
style='font-size:9.0pt;font-family:Courier'>x: INTEGER := ORD(longint,
INTEGER);</span></span><o:p></o:p></p>
</div>
<div>
<p class=MsoNormal style='margin-left:.5in'><o:p> </o:p></p>
</div>
<div>
<p class=MsoNormal style='margin-left:.5in'>seems unnecessary when they could
just write<o:p></o:p></p>
</div>
<div>
<p class=MsoNormal style='margin-left:.5in'><o:p> </o:p></p>
</div>
<div>
<p class=MsoNormal style='margin-left:.5in'><span class=apple-style-span><span
style='font-size:9.0pt;font-family:Courier'>x: INTEGER := longint;</span></span><o:p></o:p></p>
</div>
<div>
<p class=MsoNormal style='margin-left:.5in'><o:p> </o:p></p>
</div>
<div>
<div>
<div>
<p class=MsoNormal style='margin-left:.5in'><span class=apple-style-span><span
style='font-size:13.5pt;font-family:"Helvetica","sans-serif";color:black'>This
is similar in spirit to:</span></span><span style='font-size:9.0pt;font-family:
"Helvetica","sans-serif";color:black'><o:p></o:p></span></p>
</div>
</div>
</div>
<div>
<p class=MsoNormal style='margin-left:.5in'><o:p> </o:p></p>
</div>
<div>
<p class=MsoNormal style='margin-left:.5in'><span class=apple-style-span><span
style='font-size:9.0pt;font-family:Courier'>x: [lo..hi] := integer;</span></span><o:p></o:p></p>
</div>
<div>
<p class=MsoNormal style='margin-left:.5in'><o:p> </o:p></p>
</div>
<div>
<p class=MsoNormal style='margin-left:.5in'><o:p> </o:p></p>
</div>
<div>
<div>
<p class=MsoNormal style='margin-left:.5in'>On 10 Jan 2010, at 15:00, Randy
Coleburn wrote:<o:p></o:p></p>
</div>
<p class=MsoNormal style='margin-left:.5in'><br>
<br>
<o:p></o:p></p>
<div>
<p class=MsoNormal style='margin-left:.5in'>I've been trying to follow along on
this topic.<br>
<br>
Here are my thoughts:<br>
<br>
1. LONGINT should be a distinct type different from INTEGER.<br>
<br>
2. There should be no mixed arithmetic between the types. The
programmer must code conversions using ORD/VAL to make explicit the intention.
Don't rely on some ill-remembered built-in conversion rule.<br>
<br>
3. Overflow should be a checked run-time error, not silently wrapped
around.<br>
<br>
4. WRT assignability, I think explicit conversions should be used.<br>
<br>
These statements may make me unpopular with some who don't like to type much,
but I've always hated the tradeoff of understandability for brevity in
expression.<br>
<br>
The important thing is not how fast we can type up a program, it is rather how
hard is it to make a mistake. I think the spirit of Modula-3 is that the
language makes you a better programmer by forcing you to make your intentions
explicit rather than relying on the compiler to infer your intentions. We
need correct and maintainable software, especially at the systems level.
Whatever is decided about LONGINT, we need to keep to the original design
tenants of the language. <br>
<br>
And yes, I do think we need a LONGINT type, not just to deal with large file
sizes.<br>
<br>
But even for long-lived readers/writers, whatever type you choose for the index
will eventually be insufficient, so you have to code for the possibility that
the range of the long lived reader/writer exceeds the range of your index type.
That is just good programming.<br>
<br>
I think sometimes that the new generation of programmers has been warped by
what I call the "Microsoft Mentality" where you must expect that you
need to reboot/restart every so often to maintain proper performance.
Programs should be written to run forever or until their job is completed
or they are commanded to stop. <br>
<br>
As "we" begin to converge on the design changes, I like having
something concrete to look at, ala Rodney's proposal. Can we take that
and keep tweaking it in these emails until we reach a final version acceptable
to all? To me this keeps the discussion focused rather than the many
different emails. Thus, what I am trying to say is put forth a numbered
proposal and each subsequent email must show adjustment to that proposal rather
than just a bunch of emails discussing various aspects. Perhaps we should
vote on each proposed change, then decide to call a final vote on the whole
thing. Who should be involved in such votes? Right now the main
persons on the thread are Tony, Jay, Rodney, Mika, Hendrik, Olaf, John, and me.<br>
<br>
My two cents.<br>
<br>
Regards,<br>
Randy Coleburn<o:p></o:p></p>
</div>
</div>
<p class=MsoNormal style='margin-left:.5in'><o:p> </o:p></p>
</div>
</body>
</html>