HDTenEightyP/NetNews huggingface dataset:
From: maxtal@extro.ucc.su.OZ.AU (John MAX Skaller)
Subject: Re: const on pass by value
Organization: MAXTAL P/L C/- University Computing Centre, Sydney
Date: Tue, 28 Jul 1992 18:20:49 GMT

In article <9220801.5026@mulga.cs.mu.OZ.AU> fjh@munta.cs.mu.OZ.AU (Fergus James HENDERSON) writes:
>>
>>It's not nitpicking.  It's part of something called const correctness.
>>Your program has it or doesn't.  Programs that have it are almost immune
>>to a certain large family of errors.
>
>Huh? In this example, it IS just nitpicking.
>How could the presence or absence of const in the declaration for foo
>affect the program's const correctness?
>
>For pass-by-value arguments, using const is a matter of taste.
>Personally I don't bother: programs have been traditionally written without
>const in these cases, and I don't see any reason to change.
>(Besides, this avoids unnecessary typing :-)

	Isn't there a rule about EXACT matches for
templates? (Anyone know the status here?)

-- 
;----------------------------------------------------------------------
        JOHN (MAX) SKALLER,         maxtal@extro.ucc.su.oz.au
	Maxtal Pty Ltd, 6 MacKay St ASHFIELD, NSW 2131, AUSTRALIA
;--------------- SCIENTIFIC AND ENGINEERING SOFTWARE ------------------
From: jkn@ohm.york.ac.uk (John Nicoll)
Newsgroups: comp.lang.c++
Subject: MSC++ v7 bug? <new> constructor not found!
Keywords: Microsoft C++ new error bug
Date: 21 Jul 92 13:29:31 GMT
Organization: Electronics Department, University of York, UK



Hello All,
	any ideas why the following compiles fine
under MSC++ v7 with the S,M,C & L models, but gives

Error C2559: new: no match for specified operator?



#include "iostream.h"



main()
	{
	int *Temp=new int [1000];
	
	delete [] Temp;
	return(0);
	}



email replies preferred. Thank you
	

	john N

-- 
john nicoll (jkn@ohm.york.ac.uk)
Department of Electronics  University of York
Heslington   YORK YO1 5DD U.K
Tel +44 (904) 432381   Fax +44 (904) 432335
From: dwo1@gte.com (Donald W. Ottens)
Newsgroups: comp.lang.c++
Subject: tutor and general help
Keywords: tutor general help
Date: 29 Jul 92 20:22:44 GMT
Distribution: usa
Organization: GTE Laboratories Incorporated, Waltham MA

Hi,

I really need some tutoring (i.e., help) on a few programs in c++.  I would
like to have this help within the next week, either via email or in person.

I will pay ($) a negotiable rate.  Is there anyone out there that can spare
a few hours (no more than 2 - 4 hours during the next week).

Please call me at work  617 - 466 - 2071 

or email:  dwo1@gte.com

thank you.

don o
From: kinne@delfin.com (Kinne Strong)
Newsgroups: comp.lang.c++
Subject: Re: template argument as base class
Date: 24 Jul 92 19:50:32 GMT
Reply-To: kinne@netcom.com
Organization: Foxglove Associates
X-Newsreader: Tin 1.1 PL4

stefan@mpi-sb.mpg.de (Stefan Naeher) writes:
: 
: template <class T> class XYZ : public T { };
: 
: cfront says
: "sorry, not implemented: formal type parameter T used as base class of
: template"
: 
: A possible application is the implementation of data types with implementation
: parameters, e.g., dictionary<skiplist>, dictionary<red_black_tree>, ....

It sounds to me like what you really want is inheritance and virtual
functions.

class Dictionary
{
public:
    virtual Definition &Lookup(Word &);
//...
}

class SkipListDictionary : public Dictionary
{
public:
    virtual Definition &Lookup(Word &);
//...
}

Definition &Dictionary::Lookup(Word &w)
{
    // Normal lookup goes here.
}

Definition &SkipListDictionary::Lookup(Word &w)
{
    // Lookup with a skip list goes here, and has access to all of the
    // normal Dictionary:: stuff.
}

--
Kinne Strong
kinne@netcom.com
From: bs@alice.att.com (Bjarne Stroustrup)
Newsgroups: comp.lang.c++
Subject: Re: Language extensions for run-time type identification
Date: 21 Jul 92 17:25:52 GMT
Organization: AT&T Bell Laboratories, Murray Hill NJ




tmb@arolla.idiap.ch (Thomas M. Breuel @ IDIAP (Institut Dalle Molle d'Intelligence Artificielle
Perceptive)) writes

 > As I understand it (I haven't read the proposal), there will
 > apparently be a half-hearted attempt at adding runtime type tags to
 > some user-defined classes. From the descriptions of the proposal that
 > I have heard, that will not be sufficient to make the C++ language
 > safe (in the sense of eliminating most sources of "undefined
 > behavior"). In fact, at best, it will encourage a careless programming
 > style that relies on runtime type tests rather than inheritance and
 > virtual functions.

I have no doubts that whatever mechanism for run-time type identification
added to C++ (if any) will fail to please everybody. In fact, that is unavoidable
since the the desires of various people in this area are quite contradictory.
However, it might be an idea for people to refrain from condemning a proposal
until they have seen it. Also, the mechanism will probably change based on
discussion and constructive critism.
Xref: sparky comp.lang.c++:11636 comp.lang.eiffel:992
From: ychang@cs.tamu.edu (Yeimkuan Chang)
Newsgroups: comp.lang.c++,comp.lang.eiffel
Subject: Interesting results of Borland's compilers
Keywords: Borland
Date: 27 Jul 1992 21:57:10 GMT
Organization: Computer Science Department, Texas A&M University

Hi:
   I have interesting results of a simple program which is attached at 
   the end of this post. What the program does is only the floating point
   assignment. But the execution speed has a very big difference, 15 and
   69 seconds compiled by Turboc C 2.0 and Borland C++ 1.5, respectively.
   The compiler options are large model and 80286 instruction set. If the
   program performs floating point multiplicaton and division, the difference 
   will be much bigger.

   My questions are:
   1. what the results showed above imply? I thought the more recent 
      Borland compiler should give us better performance.
   2. How about Borland C++ 2.0 or 2.1? Can any one test it since I can not 
      access these compilers right now.
   3. If the program has something wrong, please tell me.

   Albert

p.s. the PC I used to test this program is clone AT 286.

-------- code of the test program ---------------
#include <stdio.h>
#include <time.h>
#include <sys\timeb.h>

/*#define DEBUG
  */

void rantest();
/*void rantest(struct block_type *a, int size);
print_time_diff(struct timeb *bt, struct timeb *et);
  */

#define NUM 2000
float n[NUM];
main()
{
/* struct block_type a;*/

 struct timeb bt, et;

 ftime(&bt);
 #if defined(DEBUG)
 printf("%ld.%d\n", bt.time, bt.millitm);
 #endif
/* rantest(n, 100);*/
rantest(NUM);

 ftime(&et);

 #if defined(DEBUG)
 printf("%ld.%d\n", et.time, et.millitm);
 #endif
 print_time_diff(&bt,&et);
}

print_time_diff(bt,et)
struct timeb *bt, *et;
{
 struct timeb t;

 if(et->millitm < bt->millitm){
   t.millitm = et->millitm+1000 - bt->millitm;
   et->time = et->time - 1;
 } else t.millitm  = et->millitm - bt->millitm;

 t.time = et->time - bt->time;
 printf("%ld.%d\n", t.time, t.millitm);

}

void rantest(size)
int size;
{
 int i, j;
 int k1, k2, k3;
 float t;

 for(i=0; i<size; i++){
   n[i] = (float) i/100.0;
   #if defined(DEBUG)
    if(i%5==0 && i!=0) printf("\n");
    printf("%f ", n[i]);
   #endif
 }
 #if defined(DEBUG)
 if(i%5==0 && i!=0) printf("\n");
 #endif

 k1 = 0; k2 = 33; k3 = 66;
 for(j=0; j<100; j++)
 for(i=0; i<10000; i++){
    t = n[k1];
    t = n[k2];
    t = n[k3];
    k1++; k2++; k3++;
    if(k1 == size) k1 = 0;
    if(k2 == size) k2 = 0;
    if(k3 == size) k3 = 0;
 }
}
From: jkn@ohm.york.ac.uk (John Nicoll)
Newsgroups: comp.lang.c++
Subject: MSCv7 bug?: <new> constructor (still) not found!
Date: 23 Jul 92 05:31:34 GMT
Organization: Electronics Department, University of York, UK

From comp.lang.c++ Thu Jul 23 06:27:25 1992
Newsgroups: comp.lang.c++
From: jkn@ohm.york.ac.uk (John Nicoll)
Subject: MSC++ v7 bug? <new> constructor not found!
Keywords: Microsoft C++ new error bug
Organization: Electronics Department, University of York, UK
Date: Tue, 21 Jul 92 13:29:31 GMT



Hello All (trying again 'cos my original post was a mess)
	any ideas why the following compiles fine
under MSC++ v7 with the S,M,C & L models, but gives

Error C2559: new: no match for specified operator?

in the Huge model?

----- cut here --------
#include "iostream.h"
main()
	{
	int *Temp=new int [1000];
	
	delete [] Temp;
	return(0);
	}
----cut here--------


email replies preferred. Thank you
	

	john N



-- 
john nicoll (jkn@ohm.york.ac.uk)
Department of Electronics  University of York
Heslington   YORK YO1 5DD U.K
Tel +44 (904) 432381   Fax +44 (904) 432335
Newsgroups: comp.lang.c++
From: jimad@microsoft.com (Jim Adcock)
Subject: Re: const on pass by value
Date: 27 Jul 92 18:59:31 GMT
Organization: Microsoft Corporation

In article <1992Jul24.151010.11969@PacBell.COM> pjcondi@lepton (Paul Condie) writes:
|Should pass by value arguments be declared as "const" for
|good coding style?  Or is that nit picking?
|
|For example:
|
|void foo (const int a);
|or
|void foo (int a);

The confusion here is that declaring a param really declares two different
things:

1) It declares the external interface to the function

2) It declares the internal type of the param.

In both cases above the external interface is to a function foo taking an
int returning void.

The first case makes the further claim that the parameter will be used
as a constant within the function.  This claim about the internal use
of "a" might be very useful to the implementor of the function, the
maintainer of the function, and in some cases might even aid the
code generator in creating better machine code.

So, yes, declaring the param "const" is a "good idea" even if the constness
only applies to the "internal" use of the param within the function.

Note that this param declaration is a very different situation from 
the similar looking:

void foo(const Bar& b)

where the "const" represents BOTH an external interface and a internal 
constraint on the use of b [note that people from the Humpty-Dumpty camp would 
claim otherwise that the "const" only refers to the *external* interface, and
that *internal* to foo the function implementor should be free to molest
b as they so desire.  Currently C++ permits such molestation, but I would
claim that people doing so are showing very bad programming style]
Newsgroups: comp.lang.c++
From: krc@wam.umd.edu (Kevin R. Coombes)
Subject: Re: boolean (was: Re: typedef vs enum)
Organization: University of Maryland, College Park
Date: Thu, 23 Jul 1992 12:54:31 GMT

In article <1992Jul21.170922.26941@ucc.su.OZ.AU> maxtal@extro.ucc.su.OZ.AU (John MAX Skaller) writes:
>	While we're talking of a boolean type (which has two
>values equivalent to 0 and 1), how about a ZERO type?
>
>	Type ZERO only has ONE value---0 of course.
>
>	What use is it, you ask?
>
>	Plenty. 0 is very important.
>
>	How often have you wanted to allow assignment
>or initialisation of a class to 0 (but not any other value?)
>
>	For example, if p is a pointer, you can write
>
>	p=0; // null pointer
>
>But if it is a *smart* pointer, you would have to declare
>assignment of say int->smart, and give a run-time error
>if the int was non-zero.
>
>[There are NO variables of type zero, the type name is, of course 0]
>
>	class smart {
>		operator=(0) { // set pointer to null state }
>	};
>
>Anyone?
>	
>
>-- 
>;----------------------------------------------------------------------
>        JOHN (MAX) SKALLER,         maxtal@extro.ucc.su.oz.au
>	Maxtal Pty Ltd, 6 MacKay St ASHFIELD, NSW 2131, AUSTRALIA
>;--------------- SCIENTIFIC AND ENGINEERING SOFTWARE ------------------

I liike this idea (but don't expect it to go anywhere). After all,
0 is a type different from any other integer. If, for example, you have
an overloaded function

void f(long);
void f(void *);

the call f(0) is an error, because it is ambiguous. No other integer
has that property.

But shouldn't the type be called NULL? :-)

Kevin Coombes <krc@math.umd.edu>
From: amonge@cs.ucsd.edu (Alvaro Monge)
Newsgroups: comp.lang.c++
Subject: Manipulating logical expressions...
Date: 21 Jul 92 23:03:01 GMT
Distribution: usa
Organization: CSE Dept., U.C. San Diego


This question is related to my article asking for a name generator:

I am in need of a C++ class definition and code which manipulates
logical expressions involving variabled and literal constants.

An important operation of such a program is:
   Standardizing apart of names:
     i.e.
	Given 2 expressions.  Want them to each have different
	variable names.  That is do the necessary alfa conversions
	on the expression(s) to make sure that they do not share
	any variable names.

Thanks,
Al Monge
amonge@cs.ucsd.edu
Newsgroups: comp.lang.c++
From: pabuhr@watmsg.waterloo.edu (Peter A. Buhr)
Subject: Please Explain
Organization: University of Waterloo
Date: Mon, 27 Jul 1992 17:21:22 GMT

Can anyone explain why I get this error from this program and if there is a
work around? Please mail directly to me. Compiled with AT&T Cfront 3.0.

class fred {
  protected:
    int x;
  public:
    enum xxx { low, HIGH };
};

class inbetween : private fred {
};

class mary : public inbetween {
  public:
    fred::xxx jane( fred::xxx xp = fred::low ) {
	return xp;
    }
};
    
cd /u/pabuhr/
CC test.cc
CC  test.cc:
"test.cc", line 13: error:  mary cannot access low : fred  is a  private  base class
1 error

Compilation exited abnormally with code 1 at Mon Jul 27 13:11:23
From: jlg@cochiti.lanl.gov (Jim Giles)
Newsgroups: comp.lang.c++,comp.lang.c
Subject: Re: Population count.
Date: 22 Jul 92 21:19:11 GMT
Organization: Los Alamos National Laboratory

Assuming 32-bit ints and right shifts that zero fill:

  #define mask_01 014545454545
  #define mask_03 030303030303
   int pop_count(int x){
      register int c;
      c=(x&mask_01)+(x>>1&mask_01);
      return ((c&mask_03)+(c>>2&mask_03)+(c>>4&mask_03))%63;
   }

This is not efficient, nor recomended, but it is usually faster than a loop
that just counts the bits.  The above algorithm was found in a specification 
for a functional language (I translated it to C).

Slightly slower (but useful for word sizes up to 254-bits) is:

  #define mask_01 0x55555555    /* extend these masks to the same size as */
  #define mask_03 0x33333333    /* your word length - when necessary*/
  #define mask_0F 0x0f0f0f0f

   int pop_count(int x) {
      register int c;
      c = (x&mask_01)+(x>>1&mask_01);
      c = (c&mask_03)+(c>>2&mask_03);
      c = (c&mask_0f)+(c>>4&mask_0f);
      return c%255;
   }

This second uses one more bit-wise `and' operation than the first.

-- 
J. Giles

PS. Sorry to anyone who sees this twice.  I made an error the first time
I posted.  I canceled the article, but you may have read it before the
cancellation went through.
From: jonas@beppe.ericsson.se (Jonas Nygren)
Subject: new
Reply-To: clarke@ses.com
Organization: Ericsson
Date: Fri, 24 Jul 1992 06:33:23 GMT

I am reposting the message below on behalf of Allan Clarke. /jonas


I don't have the ability to post to news so I am replying by email.
Your scheme of setting a variable will not work in all cases unless
you override ::new() instead of myclass::new(). The reason is that
arrays of objects are allocated using ::new() (ARM p 60).

A "sure-fire" way to do this (though it may need to be adjusted on
porting the code) is:

boolean isStackObject (void* candidate)
{
	int i;
	return (candidate >= &i);
}

(I got this tip from Desmond DSouza, although he might disavow any
knowledge of this.)

Allan

(P.S. Could you post this to comp.lang.c++ for me?)

|  Allan Clarke  | "All that is necessary for evil to abound is for
| clarke@ses.com |              good men to do nothing"
|    SES, Inc.   |
| Austin, Texas  |           512/328-5544  512/327-6646(fax)


Newsgroups: comp.lang.c++
From: mat@mole-end.matawan.nj.us
Subject: Re: const on pass by value
Organization: :
Date: Tue, 28 Jul 1992 18:07:13 GMT

In article <9220801.5026@mulga.cs.mu.OZ.AU>, fjh@munta.cs.mu.OZ.AU (Fergus James HENDERSON) writes:
> mat@uunet.uu.net!mole-end writes:
> 
> >In article <1992Jul24.151010.11969@PacBell.COM>, pjcondi@lepton (Paul Condie) writes:
> >> Should pass by value arguments be declared as "const" for
> >> good coding style?  Or is that nit picking?

> >> void foo (const int a);
> >> or
> >> void foo (int a);
> >
> >It's not nitpicking.  It's part of something called const correctness.
> >Your program has it or doesn't.  Programs that have it are almost immune
> >to a certain large family of errors.
 
> Huh? In this example, it IS just nitpicking.  How could the presence or
> absence of const in the declaration for foo affect the program's const
> correctness?

It affects what version of overloads are applied to the variable/object
and the confidence of the reader that the variables are/are not changed.

Everything that _can_ be  const  _should_ be  const .
-- 
 (This man's opinions are his own.)
 From mole-end				Mark Terribile

 mat@mole-end.matawan.nj.us, Somewhere in Matawan, NJ
Newsgroups: comp.lang.c++
From: jimad@microsoft.com (Jim Adcock)
Subject: Re: C++ success stories
Date: 27 Jul 92 19:08:36 GMT
Organization: Microsoft Corporation
Distribution: na
Keywords: C++, Success, Industry

In article <672@trwacs.fp.trw.com> george@trwacs.fp.trw.com (George Fletcher) writes:
|OK, so I waited to long and am now in a crunch.  I am in *desparate*
|need of the names of companies that have successfully developed
|software systems using C++.  

Note that the Computer Select database lists about:

8000 software products written in or for "C"
 250 software products written in or for "C++"
  64 software products written in or for "Ada"

Said database also includes information in detail about these products and
the companies that provide them.
From: kinne@delfin.com (Kinne Strong)
Newsgroups: comp.lang.c++
Subject: Re: classes referenced each in their declaration
Date: 23 Jul 92 20:54:54 GMT
Reply-To: kinne@netcom.com
Organization: Foxglove Associates
X-Newsreader: Tin 1.1 PL4

gs4t@virginia.edu (Gnanasekaran Swaminathan) writes:
: class Y;
: 
: class X {
: 	Y&	y;
:     public:
: 	X(const Y& y1): y(y1) {}
: };
: 
: class Y {
: 	X	x;
:     public:
: 	Y(): x(*this) {}
: 	Y(const Y& y): x(y) {}
: };

That's cute. I like it.

It isn't clear to me that always having the Y contain an X that refers
back to the containing Y is what the original poster wanted. In any
case, what you have done probably can be generalized to get anything
reasonable.

--
Kinne Strong
kinne@netcom.com
Newsgroups: comp.lang.c++
From: gyu@cis.ohio-state.edu (george yu)
Subject: How to avoid calling destructor twice after fork()?
Originator: gyu@eggplant.cis.ohio-state.edu
Organization: The Ohio State University, Department of Computer and Information Science
Date: Wed, 29 Jul 1992 18:06:55 GMT

I am using fork() system call in my C++ program. The problem is that each
calling of fork() creates a copy of calling process. The problem is any
instances created and not destroyed before fork() calling will be 
destroyed twice. The following figure shows the problem.

class MY_CLASS;
main()
{	
   MY_CLASS my_class;

   if(fork()==0)
    {
       // process 1
    }
   else
    {
       // process 2
    }
   
   // everything beyond this point will be executed twice, including
   // the destructor of my_class.
}

Any suggestions?

Thanks in advance.

George Yu
Newsgroups: comp.lang.c++
From: jkelly@oodis01.af.mil (Jerry Kelly)
Newsgroups: comp.lang.c++,comp.lang.c
Subject: Re: Result of spawn
Date: 21 Jul 92 14:57:17 GMT
Followup-To: comp.lang.c++
Organization: Hill AFB, Utah


Try using a logical name..

$SPAWN
$DEFINE/TABLE=LNM$JOB retval 12345
$LO
$SHOW LOG retval

then use the lexical function F$TRNLNM to convert it to a string/number

jerry kelly
jkelly@oodis01.af.mil
Newsgroups: comp.lang.functional
From: wg@opal.cs.tu-berlin.de (Wolfgang Grieskamp)
Subject: Re: ** LAZY LANGUAGES FASTER?? **
Followup-To: comp.lang.functional
Reply-To: wg@cs.tu-berlin.de
Organization: Technical University of Berlin
Date: Wed, 29 Jul 1992 13:15:49 GMT

fjh@munta.cs.mu.OZ.AU (Fergus James HENDERSON) writes:

>erik@wsinfo03.win.tue.nl (Erik Poll) writes:
>
>>In lazy languages, an argument is evaluated once for every time that it 
>>is used. If the argument is used N times, it will be evaluated N times. 
>
>As everyone has pointed out, lazy evaluation means evaluating each argument
>at most once. The correct term for the sort of evaluation strategy you
>were describing is "normal-order evaluation" (at least according to my
>programming languages textbook).

Dont know if Erik was intentionally joking or not but ... 

Actually each argument is evaluated once for every time that it is
used. As others have already pointed out, the evaluation at least
includes the inspection if the argument is already evaluated... For
many small operations, this can be as expensive as the "real"
evaluation. 

--
Wolfgang Grieskamp  wg@cs.tu-berlin.de tub!tubopal!wg  wg%opal@DB0TUI11.BITNET
Newsgroups: comp.lang.functional
From: fs@cs.tulane.edu (Frank Silbermann)
Subject: Re: ** LAZY LANGUAGES FASTER?? **
Nntp-Posting-Host-[nntpd-14766]: caesar
Organization: Computer Science Dept., Tulane Univ., New Orleans, LA
Date: Mon, 27 Jul 1992 21:59:24 GMT

In article <3737@svin02.info.win.tue.nl> erik@win.tue.nl writes:
>david@gdstech.grumman.com (David Nettles) writes:
>
>	Lazy evaluation does indeed save time by not evaluating arguments
>	that are not needed. However, eager evaluation saves times by never
>	evaluating the same argument twice.
>	In eager languages, all arguments are evaluated ONCE,
>	regardless of whether they are actually needed.

This assumes implementation via string reduction.
With string reduction, lazy programs execute very slowly.
(Did somebody mention the speed of continental drift?) :-)

With graph reduction, lazy evaluation means evaluation _at most_ once.
The challenge of laziness is to find a way to implement graph
reduction without imposing a large constant-factor overhead.
------------------------------------------
Frank Silbermann	fs@cs.tulane.edu
Tulane University	New Orleans, Louisiana  USA
From: erik@wsinfo03.win.tue.nl (Erik Poll)
Newsgroups: comp.lang.functional
Subject: Re: ** LAZY LANGUAGES FASTER?? **
Date: 27 Jul 92 10:25:55 GMT
Reply-To: erik@win.tue.nl

david@gdstech.grumman.com (David Nettles) writes:

>My intuition says that a lazy language would be a lot faster than an
>eager language simply because the eager language evaluates all of its
>arguements regardless of whether they are all needed by the function.

>The lazy language, by evaluating only what is necessary, appears to
>save time.

Lazy evaluation does indeed save time by not evaluating arguments
that are not needed. However, eager evaluation saves times by never
evaluating the same argument twice.

In eager languages, all arguments are evaluated ONCE, regardless of
whether they are actually needed.

In lazy languages, an argument is evaluated once for every time that it 
is used. If the argument is used N times, it will be evaluated N times. 
So if the argument is not used, it will not be evaluated,
   if the argument is used once, it will be evaluated once,
   if the argument is used twice, it will be evaluated *TWICE*, etc.

For example, consider the function (\x.\y.xx) (where \ is lambda),
applied to arguments A and B which evaluate to a and b, resp.

(i)  lazy evaluation
     (\x.\y.xx)AB reduces to AA, which reduces to aa

(ii) eager evaluation
     (\x.\y.xx)AB reduces to (\x.\y.xx)ab, which reduces to aa

(i) saves time by not evaluating B. On the other hand, (ii) saves time 
by evaluating A only once, whereas in (i) A has to be evaluated twice.
Which of the two is faster depends on the cost of evaluating A and B.


Erik

>****************************************************************************
>   David E. Nettles
>   Grumman Data Systems             Internet: avid@gdstech.grumman.com
>   1000 Woodbury Road                  Phone: (516) 682-8464
>   Woodbury, NY 11797                    FAX: (516) 682-8022
>   MS D12/237
>****************************************************************************
Newsgroups: comp.lang.functional