HDTenEightyP/NetNews huggingface dataset:
From: rockwell@socrates.umd.edu (Raul Deluth Miller-Rockwell)
Subject: Re: Modula-3, Fortran, Numbers & Aliens
Organization: Traveller
	<ROCKWELL.92Apr8151628@socrates.umd.edu>
	<1992Apr8.224112.16569@newshost.lanl.gov>
Date: Thu, 9 Apr 1992 04:15:42 GMT

Jim Giles:
   Type is any static information which the user and/or the compiler
   can use to double check program correctness and enhance
   optimization.  If an attribute of an object (whether it be a
   function or data) is not static, then that attribute is part of the
   _value_ of the object and not part of its _type_.

I have no problems with this definition.

But note that I consider objects to exist independent of identifiers.

   Storage class is often (but not always) desired to be part of the
   type of an object.  J appears not to permit objects to be declared
   to be limited to a specific storage class.  In fact, it's still not
   clear to me that there are _any_ attributes about an object that
   can be statically declared.

Well, in a very real sense, all objects except identifiers are
statically declared.  Also, there is a class of identifiers which may
only be declared once.  Finally, note that a compiler would likely
create an object whose semantics are fixed.

This is independent of issues such as whether or not the compiled
object can be given a new name.

   |> Forcing the programmer to concentrate on machine specific types
   |> is not a good way to encourage robust or portable code.  [...]

   Nor does disallowing the user access to those attributes.  In fact,
   due to the nature of floating-point, _not_ letting the user have
   control over machine specific attributes may make robustness
   unattainable.

What problem are you trying to address, here?

   |> This is a complex issue.  I don't think it's a good idea to
   |> remove responsibility for this complexity from the language
   |> implementor (who concentrates on porting the language to a
   |> specific machine) just to dump it on the programmer (who
   |> concentrates on whatever arbitrary problem domain she's
   |> interested in).  Not if it means the language is less
   |> expressive...

   Expressiveness is just exactly the issue.  J does not let me
   express clearly those constraints that I know when I write the
   code.

It lets me express arbitrary constraints.  Of course, I have the
advantage of having learned the language.

   By the way, why do you assume all programmers are female?

Who said that all programmers are female?

-- 
Raul Deluth Miller-Rockwell                   <rockwell@socrates.umd.edu>
From: jlg@cochiti.lanl.gov (Jim Giles)
Newsgroups: comp.lang.misc
Subject: Re: Modula-3, Fortran, Numbers & Aliens
Date: 7 Apr 92 18:45:46 GMT
Organization: Los Alamos National Laboratory

In article <STEPHEN.92Apr6203432@estragon.uchicago.edu>, stephen@estragon.uchicago.edu (Stephen P Spackman) writes:
|> In article <1992Apr6.193950.5862@newshost.lanl.gov> jlg@cochiti.lanl.gov (Jim Giles) writes:
|> |[...]             You have yet to explain why you think the ability to 
|> |redefine globals is desirable (I don't think it is).
|> 
|> I think the redefinability of globals is a practical necessity when
|> writing languages with read-eval-print style interactivity that lack
|> first-class namespaces. Corrections welcome.

Hmm.  Ok, then I suspect my objection may be directed at languages
with read-eval-print style interactivity.  To be sure, I've learned
several such languages and liked none of them.  I've always attributed
my dislike to more specific notational quirks.  Perhaps though, it is
the whole concept of this kind of interactivity that's unfriendly.
As I said previously, J seems more like a fancy pocket-calculator
language than a programming language.

J. Giles
Newsgroups: comp.lang.misc
From: rockwell@socrates.umd.edu (Raul Deluth Miller-Rockwell)
Subject: Re: Types, arrays, generality, and notation (was: Fortran90 and Arrays)
Organization: Traveller
	<ROCKWELL.92Apr11011857@socrates.umd.edu>
	<1992Apr13.175100.3711@newshost.lanl.gov>
Date: Tue, 14 Apr 1992 06:27:38 GMT

Jim Giles:
   |> [... Very long example demonstrating exactly why I dislike J ...]

   In fact, I don't see any reason for further comment on this
   particular issue.

Indeed.

And yet, you've never presented any high-level requirement for that
particular operation.

Lacking further details, might I propose an alternate approach?  This
would be to predefine the mesh selection operation and use an
expression of the form:

     F OddMesh{  F EvenMesh{  M

Note that F, OddMesh and EvenMesh can be defined as constants.  By the
way, OddMesh and EvenMesh are index specifications, and '{' is the
index operator. F is a function which, when applied to a mesh, yields
the "next state" of array M.

Obviously, the declarations for F, OddMesh and EvenMesh would need to
depend on the particular problem of interest.

-- 
Raul Deluth Miller-Rockwell                   <rockwell@socrates.umd.edu>
Newsgroups: comp.lang.misc
From: stephen@estragon.uchicago.edu (Stephen P Spackman)
Subject: Re: Types, arrays, generality, and notation (was: Fortran90 and Arrays)
Organization: University of Chicago CILS
	<STEPHEN.92Apr11043808@estragon.uchicago.edu>
	<1992Apr13.194947.17250@newshost.lanl.gov>
	<STEPHEN.92Apr14171919@estragon.uchicago.edu>
	<ROCKWELL.92Apr15002308@socrates.umd.edu>
Date: Wed, 15 Apr 1992 06:41:40 GMT

In article <ROCKWELL.92Apr15002308@socrates.umd.edu> rockwell@socrates.umd.edu (Raul Deluth Miller-Rockwell) writes:
|Jim Giles:

Nope; I said this:

|   ||> [... reduction on empty array ...]
|   ||> Nono, you missed the point. Some operations (like "+") make
|   ||> SENSE for empty arrays, and there you supply the appropriate
|   ||> value (0). Others (like "min") only make sense on an empty
|   ||> array in an extended domain (for present purposes: don't make
|   ||> sense) and so you REQUIRE at least one element, ...
|
|I've been hoping some one else would bring this up, but:  what kind of
|implementation is this, where you've got a numeric type but no maximum
|element of that type?  I wasn't aware that could happen with a finite
|set of numbers -- at least, not for the case where those numbers are
|members of the set of real numbers.

That's not the point. The point is that if I say min({}) and you say
-32768, you are WRONG. That is NOT the answer. min({} union {x}) may
be x, but you've answered based on the extension rather than the
intension and that's a bug in *my* book. And if you say -infinity you
are only right if the type system includes a -infinity point, which it
probably doesn't. Many operations don't even HAVE a consistent
identity, even a notional one like infinity.
----------------------------------------------------------------------
stephen p spackman         Center for Information and Language Studies
stephen@estragon.uchicago.edu                    University of Chicago
----------------------------------------------------------------------
Xref: sparky comp.lang.misc:1741 comp.lang.functional:498 comp.object:1775
From: olm@daimi.aau.dk (Ole Lehrmann Madsen)
Newsgroups: comp.lang.misc,comp.lang.functional,comp.object
Subject: Re: Types as first-class values?
Date: 16 Apr 92 16:42:04 GMT
Organization: DAIMI: Computer Science Department, Aarhus University, Denmark

oscar@cui.unige.ch (Oscar Nierstrasz) writes:

>Can anyone provide any references to programming languages that
>treat types as first-class values?

>....

In BETA a pattern is a first-class value in the sense that a variable
may be assigned a pattern. Such pattern values may be passed around as 
parameters and returned as the result from functions. 

Consider patterns

	T: (# ... #)

with subpatterns

	T1: T (# ... #);
	T2: T (# ... #)

The following is a declaration of two pattern variables

	F1,F2: ## T

F1 and F2 may be assigned pattern T or subpatterns of T.

Ex.

	T1## -> F1##;  { F1 is assigned the pattern T1}
	&F1[] -> R1[]; { a new instance of F1 is created; since the value
			 of F1 is the pattern T1, an instance of  T1 is created}

	T2## -> F2##;
        F2## -> F1##   
	&F1[] -> R1[]; {an instance of T2 is created}

Since a pattern may be used as e.g. a class or a procedure, classes and
procedures may be passed around as arguments and results of functions.

By using pattern variables instead of virtual patterns (procedures)
it is possible to change the methods of an object after it has been created.

Pattern variables are relatively inexpensive in BETA and used for many
purposes. They are of course NOT like Smalltalk metaclasses.

>So, for a type to be first-class:

>1. you must be able to bind it to a variable, pass it around, etc.,

I think this is satisfied.

>2. test whether a value satisfies it (and, if it does, be able to use that
>   value in a type-safe way within the scope of the test),

	At run-time it is possible to test the value of af pattern variable

	F## = T1	true if F## denotes T1

	F## < T1	true if F## denotes a subpattern of T1

	etc.

>3. produce new types from old at run-time by means of type-operators.

	The only type-operators for combining pattern variables into
	new patterns are pattern declarations where pattern variables
	may be used as attributes. This is perhaps not what you want?

I will be happy to supply more information.

Ole Lehrmann Madsen
Computer Science Department
Aarhus University
Ny Munkegade
DK-8000 Aarhus C, DENMARK
Tel.: +45 86 12 71 88 Fax.: +45 86 13 57 25
E-mail: olmadsen@daimi.aau.dk
From: gudeman@cs.arizona.edu (David Gudeman)
Newsgroups: comp.lang.misc
Subject: Re: What is a type? (was Re: Fortran90 and Arrays)
Date: 11 Apr 92 05:48:45 GMT
Organization: U of Arizona CS Dept, Tucson

In article  <BEVAN.92Apr9151907@panda.cs.man.ac.uk> Stephen J Bevan writes:
]In article <1992Apr8.180420.9294@newshost.lanl.gov> jlg@cochiti.lanl.gov (Jim Giles) writes:
]   The word `type' means any static attribute which is associated with
]   an identifier in such a way that _every_ occurrence of the identifier
]   in a given scope has that attribute.
]
]Is this is a JLG definition or do others share this view?  It
]certainly doesn't match with what my idea of a "type" is.

This is a JLG definition.  I've never heard anything remotely like it
in the literature on types.  What JLG describes is usually refered to
as a "static property of an identifier".  The word "type" has several
completely different definitions, but none that I know of refer to
static properties in general.  Furthermore, it is only in low-level
languages that type is an attribute of identifiers at all.  In
high-level languages type is an attribute of a value.

]   In this case you _may_ decide to apply the word `type' to certain
]   properties of _values_, but such a distinction is not useful. 

Humph.  Try programming in Lisp without reference to the types of
values.
-- 
					David Gudeman
gudeman@cs.arizona.edu
noao!arizona!gudeman
Xref: sparky comp.lang.icon:235 comp.lang.lisp:1400 comp.lang.scheme:1202
From: cjeffery@optima.UUCP (Clinton Jeffery)
Newsgroups: comp.lang.icon,comp.lang.lisp,comp.lang.scheme
Subject: Re: features from Icon Language in lisp
Date: 15 Apr 92 20:03:10 GMT
Article-I.D.: optima.15341
Followup-To: comp.lang.icon

From article <1992Apr15.164314.8991@midway.uchicago.edu>, by goer@ellis.uchicago.edu (Richard L. Goerwitz):
> In article <1992Apr14.173407.28762@adobe.com> yost@adobe.COM writes:
>>Has anyone implemented any other of our favorite iconish things
>>in Common Lisp or Scheme?  Like goal-directed evaluation,
>>string scanning, ... ?

[Since he hasn't posted a response yet, I'll tattle.]
David Gudeman developed an approach to doing generators and goal-directed
evaluation in Scheme using a continuation model.  I don't think the work
went past the proof-of-concept stage.  The Lisp world is big and old and
someone may well have done more along these lines, but you should ask *them*.

> Personally, I feel good about Common LISP.
Common Lisp is the Ada of the Lisp community.  Icon isn't the Ada of anything.

> LISP, of course, isn't object-oriented
There are serious and well-done object-oriented variants of Lisp, including
Flavors and CLOS.

> LISP
> people are always quick to point out that you can do object-oriented pro-
> gramming in LISP, but this is also true of C, Pascal, or even assembler.
CLOS and Flavors provide real OO support, just as C++ does for C and Simula
does for Algol.  The point is that being based on a pre-existing language
does not preclude support for objects.  The same is true of Icon.

> The bottom line, I guess, is that we have to be bi- or better yet tri-
> lingual, if not quadrilingual+ (e.g. Icon, C, LISP, and perhaps...
I disagree.  "One language to rule them all, One language to find them,
One language to bring them all, And in the darkness Bind them."  But
seriously, no language has a monopoly on any of its intellectual
contributions: someone else can come along and do string scanning better
than Icon, and the same can be said for most of the other "domains" for
which you claimed I'd need one of these specialty languages.  Given that
claim, I reason that its possible to come along with a new language that
generalizes and subsumes more than one domain as "the best language".

> My gut feeling is that you'll be better off using Icon and LISP, Dave,
> when either is appropriate.
This part I agree with for pragmatic reasons, I just think Dave should
go ahead and add "suspend" to his Lisp if he needs it, and not have to
switch to Icon to get the feature.  I sure as heck intend to add
features to (my personal version of) Icon when they are truly needed...
From: goer@ellis.uchicago.edu (Richard L. Goerwitz)
Newsgroups: comp.lang.icon
Subject: Re: ICON debugger
Date: 11 Apr 92 03:18:19 GMT
Reply-To: goer@midway.uchicago.edu
Distribution: inet
Organization: University of Chicago Computing Organizations

janpeter@mpi.kun.nl (Jan Peter de Ruiter) writes:

>Is an interactive debugger available for ICON? Sometimes, playing
>around with &trace and putting in al lot of write() statements just
>is not convenient anymore. I gather, people who test and debug large
>ICON programs must have some means to help their debugging. I would be
>interested to know how other people debug their ICON programs.

I just use the old icont -t method, to tell you the truth.  I also tend
to insert debugging code, which can be preprocessed out, either with m4,
or with the Icon preprocessor included with the IPL distribution packed
with the source.  There is some sort of debugger in the ~ftp/icon/contrib
directory on cs.arizona.edu.  Anyone know what it is?

-- 

   -Richard L. Goerwitz              goer%ellis@uchicago.bitnet
   goer@ellis.uchicago.edu           rutgers!oddjob!ellis!goer
Newsgroups: comp.lang.icon
From: Tom Christiansen <tchrist@convex.COM>
Subject: Re: should I use ICON for a specific problem ?
Originator: tchrist@pixel.convex.com
Reply-To: tchrist@convex.COM (Tom Christiansen)
Organization: CONVEX Realtime Development, Colorado Springs, CO
Date: Thu, 9 Apr 1992 20:05:49 GMT
X-Disclaimer: This message was written by a user at CONVEX Computer
              Corp. The opinions expressed are those of the user and
              not necessarily those of CONVEX.

From the keyboard of goer@midway.uchicago.edu:
:
:There's no reason to worry about flames here.  PERL is a system adminis-
:trator's tool par excellance, with a C interface that's actually much bet-
:ter than Icon's.  Icon is a much cleaner and more disciplined language,
:with a lot more options for control and data structures, coexpressions,
:and what not.  I find PERL a mess, but that's just me.  Probably I just
:don't know it well enough.

Nope, you're right -- in more ways than I care to enumerate, it *is* a
mess.  The amazing thing is how well it gets the job done anyway.

--tom
Newsgroups: comp.lang.icon
From: yost@adobe.com (David Yost)
Subject: Re: features from Icon Language in lisp
Organization: Adobe Systems Incorporated
Date: Wed, 15 Apr 1992 20:55:38 GMT

In article <1992Apr15.164314.8991@midway.uchicago.edu> goer@midway.uchicago.edu writes:
>LISP, of course, isn't object-oriented

Heavens!  I guess you haven't hear of Common Lisp Object System, which is
IMHO considerably more advanced than the usual other suspects.  Anyone
interested in OO programming in any language should read Object Oriented
Programmin in Lisp by Sonya Keene.  CLOS is a standard part of Common Lisp
now.

 --dave yost
Xref: sparky comp.lang.icon:236 comp.lang.lisp:1404 comp.lang.scheme:1205
From: bevan@cs.man.ac.uk (Stephen J Bevan)
Newsgroups: comp.lang.icon,comp.lang.lisp,comp.lang.scheme
Subject: Re: features from Icon Language in lisp
Date: 15 Apr 92 11:03:49 GMT
Followup-To: comp.lang.icon
Organization: Department of Computer Science, University of Manchester
In-reply-to: yost@adobe.COM's message of 14 Apr 92 17:34:07 GMT

In article <1992Apr14.173407.28762@adobe.com> yost@adobe.COM (David Yost) writes:
   Has anyone implemented any other of our favorite iconish things
   in Common Lisp or Scheme?  Like goal-directed evaluation,
   string scanning, ... ?

I've implemented equivalents of (all?) the Icon string scanning
operations in Scheme.  They are part of a collection of string
scanning functions I put together which draw on the facilities of
many different languages.  Because of this, the names aren't the same
as in Icon, but that is simple to solve.  The following are a few
of examples :-

; Icon `trim(s, c)' like operations :-

>(string:trim-right "Betelgeuse   " char-set:whitespace)
"Betelgeuse"
> (string:trim-left-and-right "XXsomestuffXX" (char-set:from-string "X"))
"somestuff"

;Icon `bal(c1, c2, c3, s, i, j)'
;
> (let ((str "((2*x)+3)+(5*y)"))
>   (string:general-find-balanced-chars
>     str
>     (char-set:from-string "+")
>     (char-set:from-string "(")
>     (char-set:from-string ")")
>     0
>     (string-length str)
>     (lambda (position continuation result) position)
>     (lambda (result) #f)
>     'dummy-argument))
9


;Icon `map(s1, s2, s3)'.

> (string:map "hxmysz" "hx:my:sz" "03:56:42")
"035642"
>(string:map "123321" "123" "-*|")
"-*||*-"


; This is a special case of the Icon functions `find(s1, s2, i, j)'
; and `upto(c, s, i, j)', where `char' is considered
; as a string containing one character for `find' or a character set
; containing one character for `upto'
; The following is meant to show how the _second_ `i' in the string
; can be found
>(string:general-find-char
>  "this is a dummy"
>  #\i
>  0
>  15 
>  (lambda (pos k r) (if (= r 1) pos (k (+ 1 r))))
>  (lambda (r) "could not find the character at all")
>  0)
5  

The syntax is more verbose than Icon and also relies on some
understanding of CPS programming.  Personally I don't find the syntax
a problem, as I always hide it behind another function whose name fits
with the application being written and which supplies any necessary
default arguments e.g. the start/end point in
`string:general-find-char' above.  CPS on the other hand might put a
lot of people off.  IMHO if you understand Icon's generators and
co-expressions, you should have no problems with continuations (at
least not with the way they are being used in the above code)

If anybody is interested in the code, it is freely available via a
mailserver attached to my account.  Just send the following message,
and you should get all the information you need :-

	To: bevan@cs.man.ac.uk
	Subject: b-server-request
	send help
	send index
	send scheme/index


Note if you have a UUCP or Swiss mail addresses, you can try the
above, but experience shows that they don't often work :-<

Stephen J. Bevan			bevan@cs.man.ac.uk
Newsgroups: comp.lang.icon,comp.lang.lisp,comp.lang.scheme
From: yost@adobe.COM (David Yost)
Subject: features from Icon Language in lisp
Reply-To: yost@adobe.COM
Organization: Adobe Systems Incorporated
Date: Tue, 14 Apr 1992 17:34:07 GMT

My first exposure to a seriously higher level language than C
was Icon.  (Thank you Ralph Griswold, et al.)  Finally, I got around
to learning lisp, where I wish I had started, and found that much
of what I liked about Icon (automatic storage, everything is an
expression, lists, tables, success->value/failure->nil) was there
in Common Lisp with a (shall we say) different syntax (and a whole
lot more, of course).

Has anyone implemented any other of our favorite iconish things
in Common Lisp or Scheme?  Like goal-directed evaluation,
string scanning, ... ?

 --dave yost
From: cliff@cs.arizona.edu ("Cliff Hathaway")
Newsgroups: comp.lang.icon
Subject: address for administrative matters
Date: 15 Apr 92 16:08:42 GMT
Distribution: inet
Organization: The Internet


If you wish to subscribe/unsubscribe/change your address for the icon-group
mailing list, the correct "place" to send it is:

	icon-group-request@cs.arizona.edu

This will ensure that it receives prompt attention, and keep it from being
broadcast out to everyone else on the list, and the comp.lang.icon newsgroup,
too!

Thanks.



    Cliff Hathaway
    Dept. of Computer Science (602)621-4291
    University of Arizona     cliff@cs.arizona.edu 	        (internet) 
    Tucson, Ariz. 85721	      {cmcl2,noao,uunet}!arizona!cliff	(uucp)


Xref: sparky comp.lang.icon:238 comp.lang.lisp:1406 comp.lang.scheme:1208
From: goer@ellis.uchicago.edu (Richard L. Goerwitz)
Newsgroups: comp.lang.icon,comp.lang.lisp,comp.lang.scheme
Subject: Re: features from Icon Language in lisp
Date: 16 Apr 92 01:45:55 GMT
Reply-To: goer@midway.uchicago.edu
Followup-To: comp.lang.lisp
Organization: University of Chicago Computing Organizations

In article <1992Apr15.205538.8848@adobe.com> yost@adobe.com (David Yost) writes:

>>LISP, of course, isn't object-oriented
>
>Heavens!  I guess you haven't hear of Common Lisp Object System, which is
>IMHO considerably more advanced than the usual other suspects.  Anyone
>interested in OO programming in any language should read Object Oriented
>Programmin in Lisp by Sonya Keene.  CLOS is a standard part of Common Lisp
>now.

Guess I haven't, Dave.  But then my familiarity with LISP stopped with kcl
and akcl :-).  I just don't do things that require LISP, and so I've largely
left it off.  That and Prolog (for similar reasons).

Incidentally, what is this about CLOS?  An extended version of Common LISP?
Pretty amusing.  Is this really elegant, fast, etc.?  Or are we all talking
about the kind of bloat that probably, in part, inspired Scheme?  Just curi-
ous.

-- 

   -Richard L. Goerwitz              goer%ellis@uchicago.bitnet
   goer@ellis.uchicago.edu           rutgers!oddjob!ellis!goer
Newsgroups: comp.lang.icon,comp.lang.lisp,comp.lang.scheme