HDTenEightyP/NetNews huggingface dataset:
From: lindig@ips.cs.tu-bs.de (Christian Lindig)
Subject: Solution: Where to get informations about DYLAN
Reply-To: lindig@ips.cs.tu-bs.de
Organization: Inst. f. Informatik, TU Braunschweig, FRG
Date: Tue, 29 Sep 1992 05:15:24 GMT


Many thanks to all who replied to my question a few days ago. The
solution:

+ You will get the best informations if you FTP cambridge.apple.com
  and have a look at /pub/dylan/dylan-faq.txt. All other information
  in the article are taken mainly from the FAQ.

+ There are three mailing-lists regarding Dylan:

   	info-dylan@cambridge.apple.com
   	info-dylan-req@cambridge.apple.com (administration)
 
   	announce-dylan@cambridge.apple.com
   	announce-dylan-req@cambridge.apple.com (administration)
 
   	dylan-builders@cambridge.apple.com
   	dylan-builders-req@cambridge.apple.com (administration)

+ Adresse for sending comments to the people working on Dylan at Apple

   	dylan-comments@cambridge.apple.com

+ The manual is free (from the FAQ):
	
	The Dylan manual is not available in electronic form, but a
	bound copy may be requested by sending your name and address
	to dylan-manual-request@cambridge.apple.com.  As of this
	writing, there is no charge for the manual.

+ Other Questions answered by the FAQ:
 	
	- General Questions About Dylan

	What is Dylan?
	What is the target audience for Dylan?
	How does Dylan differ from previous OODLs?
	Are there any public mailing lists for discussing Dylan?
	Does Apple have an implementation of Dylan?
	Will there be Apple products based on Dylan?
	Are there third-party implementations of Dylan available?
	Is Dylan a proprietary language?  Why is the Dylan name trademarked?
	What should I do if I want to implement Dylan?
	Is the Dylan language design frozen?
	Are design clarifications available?
	Is there a group which promotes the use of object-oriented dynamic

	- Questions about the Dylan Language Design

	Is Apple planning to specify an alternate syntax for Dylan?
	Are there plans to specify a standard i/o package for Dylan?
	Will Dylan specify a standard threading mechanism?
	Why is 'make' allowed to return a previously allocated instance, or an
	The Dylan manual doesn't require implementations to optimize tail
	The Dylan manual doesn't say much about modules.  Will this be
	Can the 'method' special form be used to create closures?
	I don't understand how setter variables work.  Is 'setter' a special
	Why not just have 'setter' be a function which takes a getter function
	What kind of object is used to return multiple values?
	Is the specification of sealing complete?
	Will Dylan include 'eval'?
	Will Dylan include an application framework?
	Will Dylan interface to other languages?
Newsgroups: comp.lang.functional
From: miller@diego.llnl.gov (Patrick Miller)
Newsgroups: comp.lang.functional
Subject: Re: Why functional languages?
Date: 30 Sep 92 21:09:52 GMT
Organization: Lawrence Livermore National Laboratory

In article <farrell.717828892@coral>, farrell@coral.cs.jcu.edu.au (John Farrell) writes:
|> For functional language compiler dudes, they are a heck of a long way away
|> from a C compiler, but on the other hand they have referential transparency
|> to help them along.

This isn't necessarily true.   Functional language compilers can
``rediscover'' the imperative structure underneath the function structure
of the source code  -- this makes an efficient mapping possible if
you can eliminate copying and other memory problems.  This has been
done for SISAL (see CACM, Aug. 92 --- Retire FORTRAN: A Debate Rekindled by
Dave Cann).

-- 
Pat Miller                            I have many opinions, but they
patmiller@llnl.gov                      generally aren't humble ones
From: bevan@cs.man.ac.uk (Stephen J Bevan)
Newsgroups: comp.lang.functional
Subject: stupid syntax wars (was Re: Why functional languages?)
Date: 2 Oct 92 19:13:10 GMT
	<TMB.92Sep28223555@arolla.idiap.ch> <26463@castle.ed.ac.uk>
	<BvGz2u.2rv.1@cs.cmu.edu> <farrell.718005712@coral>
Organization: Department of Computer Science, University of Manchester
In-reply-to: farrell@coral.cs.jcu.edu.au's message of 2 Oct 92 06:01:52 GMT

In article <farrell.718005712@coral> farrell@coral.cs.jcu.edu.au (John Farrell) writes:

   [ lots of subjective comments on one syntax being better than
     another one ]

Please don't waste time arguing about this.  Some people like Lisp
syntax, some don't; subjective arguments aren't going to convince
anyone.


   However I don't like the ML/Haskell convention of using
   "let x = y in z" rather than "z where x = y",

Haskell has the "where" form _and_ the "let" form (though the latter
is a more recent addition); use whichever you prefer.

bevan
From: opalla@owl.informatik.uni-dortmund.de (Rudolf Opalla)
Newsgroups: comp.lang.functional
Subject: Re: logic-functional
Date: 2 Oct 1992 16:01:18 GMT
Organization: CS Department, Dortmund University, Germany
Distribution: world
NNTP-Posting-Host: owl

fpk@munta.cs.mu.OZ.AU writes:

> opalla@owl.informatik.uni-dortmund.de (Rudolf Opalla) writes:
> 
> >I don't know if this is the correct group, but if anyone is interested - I
> >have posted the logic-functional language-system ALF to ftp.germany.eu.net
> >(simpson.germany.eu.net).
> [Deleted...]
> 
>       You forgot to set the read permission for the world!!!
> 
> ----------------
> fpk@cs.mu.oz.au

Sorry,
  I have no access to the files I posted to EU.Net, but I mailed
  to the responsible person, so this should be OK now

         Rudolf Opalla

  _________________________________________________________
 |                                                         |
 | Rudolf Opalla  -  opalla@owl.informatik.uni-dortmund.de |
 |_________________________________________________________|

Newsgroups: comp.lang.functional
From: dorab@twinsun.com (Dorab Patel)
Subject: Re: Where to get DYLAN informations ?
Organization: Twin Sun, Inc
Date: Mon, 28 Sep 1992 16:16:10 GMT

From my copy of the manual...


Dylan (tm) an object-oriented dynamic language
Apple Computer Inc.
Eastern Reserarch and Technology
1992
(no ISBN listed)

Copies of the manual are available from
Apple Computer
1 Main Street
Cambridge, MA 02142
+1-617-374-5300

'dorab
From: freeman@linc.cis.upenn.edu (Jon Freeman)
Newsgroups: comp.lang.functional
Subject: SML Pretty-printing
Date: 6 Oct 92 16:20:53 GMT
Organization: University of Pennsylvania

Regarding SML, kff@dentex.tds.kth.se (Karl-Filip Faxen) says:

>|> and it seems to be difficult to indent automatically as well.
>
>In an Emacs mode, perhaps. In a pretty printer, certainly not (I've
>written one).
>
>Cheers,
>         Karl-Filip

I never even thought that writing a pretty-printer for SML was a
feasible undertaking.  Consider the following program:

--------------------------------------------------------------
datatype foo = Alpha of int | Beta of real | Gamma of string;
datatype bar = Happy of int | Dopey of real | Grumpy of string;

fun testcase (x,y) =
  case x of
    Alpha _ => ()
  | Beta _ =>
      case y of
        Happy _ => ()
      | Dopey _ => ()
      | Grumpy _ => ()
  | Gamma _ => ();       (* Hmmm... *)
--------------------------------------------------------------

Any pretty-printer that can correctly indent the last line of testcase
has to be able to discriminate between the constructors of foo and the
constructors of bar!!  Does your pretty-printer really do this?  If
so, I'm very impressed.

				Jon
From: tmb@arolla.idiap.ch (Thomas M. Breuel)
Newsgroups: comp.lang.functional
Subject: Re: Why curry? (Re: Why functional languages?)
Date: 5 Oct 92 20:00:16 GMT
	<TMB.92Sep28223555@arolla.idiap.ch> <26463@castle.ed.ac.uk>
	<BvGz2u.2rv.1@cs.cmu.edu> <NICKH.92Oct2134230@VOILA.VENARI.CS.CMU.EDU>
	<TMB.92Oct4181821@arolla.idiap.ch> <23795@alice.att.com>
Reply-To: tmb@idiap.ch
Organization: IDIAP (Institut Dalle Molle d'Intelligence Artificielle
	Perceptive)
In-reply-to: ark@alice.att.com's message of 4 Oct 92 20:13:31 GMT

In article <23795@alice.att.com> ark@alice.att.com (Andrew Koenig) writes:

   In article <TMB.92Oct4181821@arolla.idiap.ch> tmb@idiap.ch writes:

   > Why _do_ people continue to use curried syntax when they just want a
   > function with several arguments?

   Perhaps because it makes partial application easier to write.

   For example, if I want a vector whose elements are twice the corresponding
   elements of x, I can write

	   map (fn x => x * 2) x

   or, if I have a curried multiply function, I can write

	   map (mult 2) x

True. There are some functions for which partial application is not
infrequent. Those functions, I curry myself. However, I find those
functions are quite rare.

   I suppose I might ask the complementary question: why should compilers
   generate slower code for curried functions if I don't happen to make
   use of that property?

If you have a definition like

	fun f x y z u = ...

then the compiler doesn't know which way you intend to call it.  If it
wants to generate efficient entry points for it, it has to generate
four different versions of the function, or it has to make a guess,
generate one efficient entry point, and do the appropriate (slow)
transformation in the caller.

If you have a definition like

	fun f(x,y,z,u) = ...

then the compiler knows that you will call it either with four
arguments or with a tuple. That means that you have at most two
entrypoints to the function (probably, usually, calls like "f arg"
will do the destructuring in the caller, giving you only a single
entrypoint).

I think the efficiency issue is not as significant (although in NJ/SML
it's a factor of 2-3 in the benchmarks that I posted); mainly what
bothers me is that curried type signatures are much less informative
to me as a reader, and that missing arguments are not diagnosed by
the compiler.

					Thomas.
From: joe@erix.ericsson.se (Joe Armstrong)
Newsgroups: comp.lang.functional
Subject: Re: Why functional languages?
Date: 6 Oct 92 08:23:23 GMT
Organization: Ellemtel Telecom Systems Labs, Stockholm, Sweden

In article <BvGz2u.2rv.1@cs.cmu.edu>, spot@CS.CMU.EDU (Scott Draves) writes:
|> >>>>> On 1 Oct 92 12:57:12 GMT, jamesh@castle.ed.ac.uk (James Hammerton) said:
|> 
|> 
|> jamesh> (define fac
|> jamesh>  (lambda (n)
|> jamesh>   ( if (= 0 n)
|> jamesh>     1
|> jamesh>     (* n (fac (- n 1))))))
|> 
|> 
|> 
|> jamesh> fun fac 0 = 1
|> jamesh> |   fac n = n * fac (n-1) ;
|> 
|> 
|> jamesh> Now which is easier to read?!!!
|> 


	Well that depends upon how long you have been programming in lisp/
SML/whatever. 

	In my experience one doesn't really *see* syntax after about 3 weeks
of hard hacking in a language. When I started hacking lisp I was irritated
by all the brackets - after a few weeks the problem went away. SML type
errors were another problem - again after a couple of weeks they didn't bother
me.

	Probably the biggest advantage/disadvantage of ML is that it inforces
a certain "type of thinking" when problem solvoing - one is *forced* to
think in terms of types. When programming in lisp one doesn't have to think
in terms of types before writing a program. Whether this discipline is a good
or bad thing is debatable - I certainly don't believe the wild claims of certain
ML fans who say something like "once the program is type correct your problems
are over ...." - I still solve the *wrong* problems (only this time with
a type correct program :-)) - neither lisp nor ML helps me here :-(

	Rather than worrying about syntax I'd like to see a classification of
the types of problem area for which lisp/ML/C/Prolog/footran etc. are
appropriate.

	Joe Armstrong
From: hasker@m.cs.uiuc.edu (Rob Hasker)
Newsgroups: comp.lang.functional
Subject: Re: Why functional languages?
Date: 28 Sep 92 18:33:22 GMT
Organization: University of Illinois, Dept. of Comp. Sci., Urbana, IL

tmb@arolla.idiap.ch (Thomas M. Breuel) writes:

>   My primary interest in functional languages is not ease of programming
>   from a human viewpoint (after all, adding imperative features to a
>   pure FL will not make programming in it harder), but the ease of
>   manipulating programs.
>
>Too bad that languages like SML (and, moreso, Haskell) have adopted
>such a comparatively complex syntax. Writing programs to manipulate
>programs is much easier in Lisp, due to the obvious correspondence
>between external and internal representation and a standard interface
>to the compiler/type facilities (in the form of macros and type
>predicates).

All you need is a parser which translates the concrete syntax to the abstract
syntax (i.e., Lisp-like notation), and an "unparser" to translate back.  This
way the user gets the benefit of being able to write readable code and the
rewrite engine doesn't have to parse anything.  This approach works very well
for the transformation system on which I'm working (Uday Reddy's Focus system).

Rob
From: dlb@fanny.wash.inmet.com (David Barton)
Newsgroups: comp.lang.functional
Subject: Re: Type checking with physical dimensions
Date: 28 Sep 92 15:04:32 GMT
Organization: Intermetrics Inc., Washington Division, USA

I was going to respond to this by Email; however, since it might be of
general interest, I am responding to the list.

In article <14724@goanna.cs.rmit.oz.au> ok@goanna.cs.rmit.oz.au
(Richard A. O'Keefe) writes:

   Has anyone extended a Hindley/Milner-style type checker to check
   physical dimensions (mass,length,time,current,&c)?  I have my own ideas
   about how to do it, but before I start coding and writing, I'd like to
   know what has already been done.  (I already know that it is possible to
   combine polymorphism with dimension checking; I _think_ I can see a way
   to combine them with integer/float overloading; I believe that automatic
   scaling can be done in a functional language but not in a logic programming
   language, but don't ask me to prove it yet.)

We are desigining a microwave hardware description language based upon
Haskell.  We have written a Physical type which is simply another data
type under the Haskell class system; thus, overloading with standard
operators simply involves a new data instance for each appropriate
class that defined the operators for type Physical.

Our physical datatype includes (not bothering with the Haskell
syntax):

1) A 10-tuple that corresponds to the appropriate "exponent", or
dimension, of each of the standard ISO "basic" units (we added
dollars).

2) A rational multiplier (for factors of the same dimenstion: feet and
meters, for example).  A multiplier of one refers to the ISO standard
units. 

3) The numeric part (the "10" in "10 miles").

The definition of arithemetic operations on these quantities is fairly
trivial.

Please Email me if there are questions.

					Dave Barton
					dlb@hudson.wash.inmet.com
Newsgroups: comp.lang.functional
From: fjh@munta.cs.mu.OZ.AU (Fergus James HENDERSON)
Subject: Re: Why functional languages?
Organization: Computer Science, University of Melbourne, Australia
Date: Fri, 2 Oct 1992 05:47:55 GMT

spot@CS.CMU.EDU (Scott Draves) writes:

>large lisp functions retain their clarity.  large SML
>functions are horrid messes.  this is taken from the compiler itself
>(something i work on).  i didn't even have to try and find something
>bad...  (* Copyright 1989 by AT&T Bell Laboratories *).
>
>    and getroot(APP(VAR f,wl)) = (f,mix(wl,standardformals wl))
>      | getroot(APP(LABEL f,wl)) = 
>         (case know f 
>            of KNOWN((vl,e),ref(SOME fmls)) => (f,mix(wl@(map VAR vl),fmls@fmls))
>	     | KNOWN((vl,e),ref NONE) => 
>                   (let val tmp = targeting(wl,vl,e)
>                     in (f,tmp)
>                    end)
>	     | KNOWN_CHECK((vl,e),ref(SOME fmls),_) => (f,mix(wl@(map VAR vl),fmls@fmls))
>	     | KNOWN_CHECK((vl,e),ref NONE,_) => 
>                   (let val tmp = targeting(wl,vl,e)
>                     in (f,tmp)
>                    end)
>	     | STANDARD _ => (f,mix(wl,standardformals wl))
>	     | _ => die "a10 in CPSgen")

So translate it to lisp for us, and then we have something to compare it to!

>jamesh>  Even with such a simple example, it's not obvious that the
>jamesh> close brackets at the end of the lisp version are enough,
>
>i suppose you don't use an editor that matches ()s for you.

If you *have* to use such an editor to make the language useable, then
that is a definite disadvantage.

>jamesh> where it's immediately obivous that the ML version has the
>jamesh> correct syntax.
>
>where's the obvious syntax error in this:
>
>datatype foo = FOO of x
>fun bar FOO x = x

So?

>i've written a lot of SML and lisp code, and my experience is that
>syntax (especially ()s) is not a problem in lisp, but that i do have
>problems (understanding and writing) SML.

What sort of problems?

>if someone else would like to defend SML syntax, please do so...

Can we defend Haskell syntax instead?

-- 
Fergus Henderson             fjh@munta.cs.mu.OZ.AU      
This .signature virus is a self-referential statement that is true - but 
you will only be able to consistently believe it if you copy it to your own
.signature file!
From: ok@goanna.cs.rmit.oz.au (Richard A. O'Keefe)
Newsgroups: comp.lang.functional
Subject: Type checking with physical dimensions
Date: 28 Sep 92 08:08:58 GMT
Organization: Comp Sci, RMIT, Melbourne, Australia

Has anyone extended a Hindley/Milner-style type checker to check
physical dimensions (mass,length,time,current,&c)?  I have my own ideas
about how to do it, but before I start coding and writing, I'd like to
know what has already been done.  (I already know that it is possible to
combine polymorphism with dimension checking; I _think_ I can see a way
to combine them with integer/float overloading; I believe that automatic
scaling can be done in a functional language but not in a logic programming
language, but don't ask me to prove it yet.)

-- 
RMIT policy requires the use of Gender Inclusive Language in all publications
and in all information conveyed to students, staff, and potential job
applicants.  Lapses into English are the sole responsibility of the author.
The Constitution of Australia does _not_ guarantee Freedom of Speech.
From: seebauer@eos.informatik.uni-bonn.de (Heinrich Seebauer)
Subject: phd thesis available (in german)
Organization: Institut fuer Informatik Uni Bonn (BARDE Projekt)
Date: Mon, 28 Sep 1992 13:25:10 GMT

Hi folks.

My Ph.D. dissertation is available on anonymous ftp.  It
describes the implementation of a FP-like language on a dataflow
architecture.

A cheap mechanism for token synchronization is presented along with a
deadlock free method of parallelism control.

Access on	kitten.umdc.umu.se

path is		/pub/doc/thesis.

Heinrich.

--
     /---S---\		Heinrich Seebauer
BARDE---Y-----BARDE	Institut fuer Informatik Abteilung fuer Informatik IV 
     \---N---/		Roemerstr. 164, W-5300 Bonn 1, x228 / 550 223
      \---C-/		dataflow - the better way

--    To terminate or nor to terminate, that is the question    --
--                                            Alan M. Turing    --
Newsgroups: comp.lang.functional
From: farrell@coral.cs.jcu.edu.au (John Farrell)
Subject: Re: Why functional languages?
Organization: James Cook University
Date:  2 Oct 92 06:01:52 GMT

In <BvGz2u.2rv.1@cs.cmu.edu> spot@CS.CMU.EDU (Scott Draves) writes:
>i've written a lot of SML and lisp code, and my experience is that
>syntax (especially ()s) is not a problem in lisp, but that i do have
>problems (understanding and writing) SML.

  Sorry, I just don't believe you. To me, Lisp has the most disgusting syntax
imaginable. However I don't like the ML/Haskell convention of using
"let x = y in z" rather than "z where x = y", I like to read programs top down
rather than bottom up. I have considered having a PC opinion about this
syntax, i.e. you like what you're used to, but I honestly believe that Lisp
syntax is inherently evil.

John
Newsgroups: comp.lang.functional
From: hugh@cs.toronto.edu ("D. Hugh Redelmeier")
Subject: Re: Unique types etc.
Organization: Department of Computer Science, University of Toronto
Date: 6 Oct 92 04:57:00 GMT

leonp@cs.kun.nl (Leon Pillich) writes:
| A while ago I posted a reaction on a discussion about
| things that are difficult to do with functional programming
| languages. I briefly mentioned Unique types.
| I got some reactions on my post so I decided to write
| a short follow up, to tell something about unique types
| and to give some references where one can find more information.

Interesting.  These seem to be related to "dialogues" which I
discussed in a chapter of my PhD Dissertation:
D. Hugh Redelmeier, "Towards Practical Functional Programming",
Department of Computer Science, University of Toronto, 1984.

Hugh Redelmeier
hugh@mimosa.com or {utcsri, yunexus, utzoo, scocan}!redvax!hugh
When all else fails: hugh@csri.toronto.edu
+1 416 482-8253
From: bevan@cs.man.ac.uk (Stephen J Bevan)
Newsgroups: comp.lang.functional
Subject: Re: Why functional languages?
Date: 1 Oct 92 15:46:28 GMT
	<TMB.92Sep28223555@arolla.idiap.ch> <26463@castle.ed.ac.uk>
Organization: Department of Computer Science, University of Manchester
In-reply-to: jamesh@castle.ed.ac.uk's message of 1 Oct 92 12:57:12 GMT

In article <26463@castle.ed.ac.uk> jamesh@castle.ed.ac.uk (James Hammerton) writes:
   Nor to me, but I think that it is a bad example to use anyway. So lets
   try something to show the readability a bit better.  Consider the
   factorial function ...

You're on a sticky wicket if you are going to argue anything using
something the size of factorial as an example.  As has already been
pointed out, anything that uses HOF in SML will end up looking
remarkably similar to the Lisp notation.  Anyway, this is tangential,
the following is the real issue :-

   [ lots of material that discusses "nice" syntactic features of ML ]

Fine, but it misses the point of tmb's article which was that Lisp
notation allows a program to manipulate _itself_ much more simply than
most other notations.  However, assuming you have a parser/unparser
for some form of abstract syntax (as Dave McQueen has stated NJ/SML
will have) there is no real difference between the two as far as
manipulation goes.

bevan
From: jeff.zeitlin@execnet.com (jeff zeitlin)
Newsgroups: comp.lang.modula2
Subject: fst v3.0
Date: 26 Sep 92 09:36:33 GMT
Reply-To: "jeff zeitlin" <jeff.zeitlin@execnet.com>
Distribution: comp
Organization: Executive Networks Information

TH::>    I am wondering where I can get the new FST v3.0.  Hopefully is is an FT
  ::>    site.

TH::>    I have tried ftp.psg.com, but it always tells me the service is
  ::>    unavailable.  (Is there a specified time, or a specified port for this
  ::>    site?)

TH::>    Any help would be greatly appreciated.  (I have checked wuarchive...)

  I am assuming that FST is Fitted Software Tools, the authors of a
  very nice Modula-2 compiler for MS-DOS based systems.

  If so, and if you're not averse to long distance calls, they have a
  BBS.  As I recall, 2400N81.  The number is 214/517-4629.  Or at
  least it was when I got my v2.0...

  J/
  jeff.zeitlin@execnet.com
  ==================================================================
  Anything I say in this or any communication to this or any medium
  is strictly my own non-authoritative opinion, unless otherwise
  explicitly noted.  Except for myself, or where explicitly noted
  otherwise, I do not speak for any individual or organization.
  ==================================================================

 * OLX 2.2 * Bear takes over Disneyland in Pooh D'Etat!
--
Executive Network Information System  (914) 667-4567
International ILink Host