HDTenEightyP/NetNews huggingface dataset:
From: kh@dcs.glasgow.ac.uk (Kevin Hammond)
Newsgroups: comp.lang.functional
Subject: Re: FPL on Macintosh
Date: 21 Jan 93 15:33:27 GMT
Organization: Computing Sci, Glasgow Univ, Scotland

In article <1993Jan21.134744.4873@lth.se> d92mbe@efd.lth.se (Martin Bergendahl) writes:
>>there is concurrent Clean for the Mac available by ftp from University of Nijmegen which also offers the scope for stand-alone applications.
>
>How large is it?  Can you do good applications with it? What is the
>difference between concurrent Clean and Standard ML? 

They're pretty different.  The Clean people will tell you how.

> Is Clean, Gofer or maybe Dylan the future for FPL on mac? 
> Answers, comments please!

As far as I'm aware, Dylan isn't a pure functional language (or
released?), so that leaves Clean or MacGofer, at the moment. 
I see these as complementary rather than competing systems.

MacGofer is an interpreter, and so is good for prototyping, or teaching.
It runs in 1M.  The Gofer language is similar to Haskell.  

Clean is a compiler, which produces fast standalone applications, and
so is good for development.  There is a built-in converter from a more
conventional syntax to Clean.  Clean memory requirements tend to be
higher than MacGofer (but still acceptable on a reasonably well-equipped
Mac).

Try both, see which you like best: they're both free.

Kevin

[Incidentally, I'm planning to release a new MacGofer in the next few days,
 so you might like to wait before grabbing it from Glasgow...]
-- 
Dept. of Computing Science, Glasgow University.    E-mail: kh@dcs.glasgow.ac.uk

This Signature Intentionally segmentation fault
Newsgroups: comp.lang.functional
From: bazet@chailly.ensmp.fr (Philippe BAZET)
Subject: Adding Constraints to Automate Programming
Organization: /home/users/bazet/.organization
Distribution: comp
Date: 27 Jan 93 19:48:55

Hi net,


Let us consider a circular list. It can be defined by an ML-like data
type such as

	list 'a = nil | cons of 'a * list 'a ;

and the assertion:

	The last element for the list is the first one.

Does anyone know of programming systems in which such assertions can be
expressed formally and used at either run-time or compile-time?  I know
of Ait Kaci's LIFE which is mainly restricted to local structure
constraints.  

Thanks in advance,
Philippe Bazet.
e-mail: bazet@cri.ensmp.fr
From: dat@ukc.ac.uk (D.A.Turner)
Newsgroups: comp.lang.functional
Subject: Re: Recommended Miranda implementations
Date: 21 Jan 93 09:36:59 GMT
Reply-To: dat@ukc.ac.uk (D.A.Turner)
Organization: Computing Lab, University of Kent at Canterbury, UK.

(In reply Gary Osborne's question):
Miranda(TM) is a modern  functional  language  with  polymorphic  strong
typing, lazy evaluation, and a simple but powerful module system.  It is
currently running at over 500  sites,  and  is  being  widely  used  for
teaching (among other purposes).  It is distributed by Research Software
Ltd.

Information about Miranda is obtainable from
	mira-request@ukc.ac.uk

or non-electronically from
	Research Software Ltd
	23 St Augsustines Road
	Canterbury CT1 1XP
	England

	fax: (+44) 227 454458
	phone: (+44) 227 471844 (24 hours)
From: torbenm@diku.dk (Torben AEgidius Mogensen)
Newsgroups: comp.lang.functional
Subject: Re: Recommended Miranda implementations
Date: 21 Jan 93 11:10:14 GMT
Organization: Department of Computer Science, U of Copenhagen

garyo@apricot.co.uk (Gary Osborne) writes:

>Hi,

>Can anyone recommend (and give a source) a Miranda implementation
>that I can use.  Any info would be greatly appreciated.

As D.A. Turner already has said, Miranda is available from Research
Sofware Limited. Note that this is the only legal source for Miranda,
as it is trademarked by RSL. The RSL Miranda implementations are quite
costly, and you can't get any PD implementations. If you do not
require exactly Miranda, but something with the same flavour, you can
get Gofer, which is a PD Haskell system that runs on many small
machines. Gofer is available through FTP from many sources, e.g.
Chalmers and Glasgow.

	Torben Mogensen (torbenm@diku.dk)
From: uwe@infopro.spb.su (Valeriy E. Ushakov)
Newsgroups: comp.lang.functional
Subject: Compiler requests. Seems, FAQ is needed.
Date: 20 Jan 93 00:49:17 GMT
Organization: Novintech-INFOPRO ltd.
X-Newsreader: Tin 1.1 PL4


Hi, folks!

Being a permanent reader of the group, I noticed,
that requests like "Is there any or some particular
FPL realization for Foo exists and where can I get
a compiler?" becomes FAQ.

M.b. there is a sense to post such a FAQ regulary.
(If there is someone who will agree to do this work,
of course).

Sincerly to say, I myself is very interested in such
information. Unfortunately, at present time I have
no possibility to use ftp, 'cos here in Russia access
to Internet is smth difficult (we use good(?) old(!)
uucp links, so if I try to get smth from ftp, my boss
will kill me when he'll see the bill for traffic :-)
But in near future we'll get normal TCP/IP connection
with West, so I hope I will be able to drain some
things I'm interested in.

P.S:
BTW, at 22 of January eastern New Year is celebrated.
So, my best regards to all of you out there.

						Uwe.
--
Valeriy E. Ushakov (aka Uwe)        |           Zu gruende kommen
uwe@infopro.spb.su                  |           Ist zu gruende gehen
From: amohamed@loria.crin.fr (AIT MOHAMED Othmene)
Newsgroups: comp.lang.functional
Subject: concurrent ML
Date: 22 Jan 93 11:10:33 GMT
Organization: CRIN (CNRS) Nancy - INRIA Lorraine


I am looking for papers/thesis/article on concurrent ML (cml). Interested
in functional language and parallelism, I am interested in knowing wether
any research is being done in this area. If so, how to get the relevant 
materail.

 Thanks in advance.


  
    Otmane AIT MOHAMED
     amohamed@loria.fr






Newsgroups: comp.lang.functional
From: beckmann@Informatik.Mathematik.Uni-Mainz.DE (Markus Beckmann)
Subject: Re: FPL on Macintosh
Organization: Computer Science, Johannes Gutenberg-Universitaet
Date: Thu, 21 Jan 1993 14:37:28 GMT

In article <1993Jan20.144949.6651@sstl.uucp>, will@sstl.uucp (William Pickles) writes:
|> In article <1993Jan15.170624.1277@qucis.queensu.ca> malton@qucis.queensu.ca (Andrew Malton) writes:
|> 
|>    .... Is there a modern functional programming
|>    language available for the Macintosh?
|> 
|> there is concurrent Clean for the Mac available by ftp from University of Nijmegen which also offers the scope for stand-alone applications.
|> 

How can I ftp from  University of Nijmegen (address needed) ?

Newsgroups: comp.lang.functional
From: Howard S Goodman <hsg@cs.bham.ac.uk>
Subject: Input/output streams in Haskell and Miranda
Originator: hsg@jemima
Organization: School of Computer Science, University of Birmingham, England
Date: Thu, 28 Jan 1993 16:29:10 GMT

Is it  possible to  model Miranda's  simple   [char] -> [char]   input/output
technique in Haskell?  Can $- or $+ be simulated using ReadChan stdin?

If anyone has achieved this, I would  very  much like to  know how, as I have
been struggling with it for some time ...

Thank you ...

+-------------------+-------------------------------------------------------+
| howard s goodman  | school of computer science - university of birmingham |
| hsg@cs.bham.ac.uk |		 	   - BIRMINGHAM - B15 2TT - england |
+-------------------+-------------------------------------------------------+
From: amd2@ukc.ac.uk (A.M.Douglas)
Newsgroups: comp.lang.functional
Subject: Miranda to LML
Date: 26 Jan 93 22:39:16 GMT
Organization: Computing Lab, University of Kent at Canterbury, UK.

I'm sure this has been asked before, but does anyone have a Miranda
to LML translator?

Andrew.
From: dat@ukc.ac.uk (D.A.Turner)
Newsgroups: comp.lang.functional
Subject: c.l.f archive
Date: 23 Jan 93 18:24:07 GMT
Organization: Computing Lab, University of Kent at Canterbury, UK.

Does anyone know if there is kept somewhere an archive of this
newsgroup (comp.lang.functional)?  Thanks for any info.

David Turner
Newsgroups: comp.lang.functional
From: gandalf@sabrina.dei.unipd.it (ROBERTO AVANZI)
Subject: Re: Recommended Miranda implementations
Organization: D.E.I. Universita' di Padova, Italia
Date: Mon, 25 Jan 1993 16:18:39 GMT

In article <1993Jan21.111014.177@odin.diku.dk> torbenm@diku.dk (Torben AEgidius Mogensen) writes:
>garyo@apricot.co.uk (Gary Osborne) writes:
>
>>Hi,
>
>>Can anyone recommend (and give a source) a Miranda implementation
>>that I can use.  Any info would be greatly appreciated.
>
>As D.A. Turner already has said, Miranda is available from Research
>Sofware Limited. Note that this is the only legal source for Miranda,
>as it is trademarked by RSL. The RSL Miranda implementations are quite
>costly, and you can't get any PD implementations. If you do not
>require exactly Miranda, but something with the same flavour, you can
>get Gofer, which is a PD Haskell system that runs on many small
>machines. Gofer is available through FTP from many sources, e.g.
>Chalmers and Glasgow.
>
>	Torben Mogensen (torbenm@diku.dk)

Also Clean (available for Mac, SUn3,Sun4, and a transputer architecture)
will soon be able to import Miranda scripts and run them. It will
indeed compile the Miranda to Clean translated source to 680x0 binaries
or to sparc or transputer binaries. there is currently no official
time for the release of this system, as far as i can understand from
the Clean manual.
Hope this helps
Cheers
Roberto

Newsgroups: comp.lang.functional
From: d92mbe@efd.lth.se (Martin Bergendahl)
Subject: Re: FPL on Macintosh
Organization: Lund Institute of Technology, Sweden
Date: Thu, 21 Jan 1993 13:47:44 GMT

>there is concurrent Clean for the Mac available by ftp from University of Nijmegen which also offers the scope for stand-alone applications.

How large is it? Can you do good applications with it? What is the
difference between concurrent Clean and Standard ML? Is Clean, Gofer
or maybe Dylan the future for FPL on mac? Answers, comments please!

< Martin Bergendahl >
From: dat@ukc.ac.uk (D.A.Turner)
Newsgroups: comp.lang.functional
Subject: Re: Recommended Miranda implementations
Date: 27 Jan 93 20:11:08 GMT
Reply-To: dat@ukc.ac.uk (D.A.Turner)
Organization: Computing Lab, University of Kent at Canterbury, UK.

There have been a couple of rather  misleading  postings  implying  that
Gofer  is  effectively  a  public domain replacement for Miranda(TM).  I
wish to claim a right of reply on Miranda's behalf.

First - a minor point - Gofer is not public domain.  As anyone  who  has
the  Gofer software will see from the header files, it is copyright Mark
Jones, 1992.  Mark Jones chooses to allow it be freely  distributed  for
personal  and  academic use - along with the copyright notice specifying
the terms of the distribution.  That is not the same as being PD.

Second, Gofer and Miranda don't do anything like the same job.  Gofer is
a Haskell subset, and thus a different language. Also each has important
features the  other  lacks:  Gofer  has  typeclasses,  but  Miranda  has
abstract data types, a module system, and an on-line manual.

Gofer is a nice system, and I don't wish to criticise it.  But here  are
some advantages of Miranda:-

1) Miranda is widely used for teaching in conjunction with the excellent
textbook by Bird and Wadler.  The notation in Bird and Wadler is closely
based on Miranda (and quite a  lot  different  from  Gofer,  which  uses
Haskell syntax).

2) High quality arithmetic.  The Miranda type `num' is a  dynamic  union
of double precision floating point and unbounded precision integer (like
LISP bignums).  Gofer has 32bit arithmetic,  and  silently  gives  wrong
answers on overflow.

3) Miranda has  abstract  data  types  and  a  powerful  module  system,
including  "parameterised modules".  There is a fully automated built-in
`make' feature, so object files cannot get out  of  step  with  sources.
(Gofer has no equivalent features.)

4) Miranda is a robust and mature  system,  running  at  more  than  500
sites.   It was awarded a medal for technical achievement by the British
Computer Society (BCS Awards, 1990).  It is an interpreter (like  gofer)
but a compiler is preparation.

Miranda is commercial software -  ie  not  free  -  but  has  relatively
inexpensive  educational  licenses.  For example the (USA only) price of
an educational site license, covering an unlimited number of machines of
one type, is $1360.

I will be happy to supply further information on request  (or  from  the
coordinates below).

David Turner
(Director, Research Software Ltd)
-----------------------------------------------------------------------
	Research Software Ltd
	23 St Augustines Road		  Fax: (+44) 227 454458
	Canterbury CT1 1XP		Phone: (+44) 227 471844
	England			  Email: mira-request@ukc.ac.uk
-----------------------------------------------------------------------
From: mxh@dcs.ed.ac.uk (Martin Hofmann)
Newsgroups: comp.lang.functional
Subject: ML program with callcc
Keywords: continuations
Date: 27 Jan 93 18:31:22 GMT
Organization: Department of Computer Science, University of Edinburgh

Hello,

I am interested in the use of type theory for the verification of functional
programs and it is in this context that i'm looking for ml-programs which

make nontrivial use of callcc

and nevertheless do neither use references nor mixed variance datatypes 

the latter means that there are no datatypes like

datatype D=A of int|B of D->D

where the recursively def'd type occurs to the left of an arrow.

Can anybody help?
-- 
                 Martin Hofmann         	
 Laboratory for Foundations of Computer Science 	      	
       The King's Buildings, Mayfield Rd
 Edinburgh EH9 3JZ               Phone 650 5188
Newsgroups: comp.lang.pop
From: tmr@emotsun.bham.ac.uk (Tim Read)
Subject: Re: EMACS and POP
Organization: School of Computer Science, University of Birmingham, UK
Date: Thu, 28 Jan 1993 13:43:41 GMT

>>>>> On 27 Jan 93 00:13:22 GMT, pop@cs.umass.edu ( Robin Popplestone ) said:

> There is an improved version of the EMACS - POPLOG interface which was done
> here by Gordon Dakin. This "knows" that POPLOG has 4 languages (not a
> natural concept to EMACS). I did send it across the Atlantic some time ago,
> but don't know if it will be in contrib for 14.2.  It will work in
> conjunction with XVED to give access to help files

Yes, we have a copy here at Birmingham which I find pretty good. The one
thing that an emacs interface to pop11 lacks at the moment (there may well
be more than one) is an interface to the debugger. This excellent and very
useful tool, can `sort-of' be used within a pop immediate mode within emacs,
but you can't display the source at the same time. A real drag.

>(I don't know why people like EMACS but they do...)

Why does anyone like anything? It is a subjective issue, based upon all
sorts of non directly related things. Personally I came across micro emacs
years ago (it was the only editor on our system), and after using that for
some time GNU emacs came along and I switched over to that (it was the
natural move to make), and have been using it ever since. 

I did spend some time on a VMS machine, so obviously started using eve which
is a very powerful editor, but soon found a clash between it and my emacs
knowledge, so was glad when I could give it up and go back to unix.

With emacs, it is the same as anything, as more people invest more time and
effort producing more and more modes for it, its usefulness grows and grows.
The result is that at the moment emacs may be far from perfect, but I know it
very well, and don't see the point of converting to another editor like ved
that may be better in some ways but worse in others. This is subjective of
course, but so are likes and dislikes.

If I am going to learn a new editor, then I would tend to want to learn
something like sam, the plan 9 editor, which philosophically speaking
represents the way forward for editors. It is very small and fast and highly
integrated to its applications.

It is amusing to point out that in fact I have had to learn a little ved,
not only to get around the debugger problem, but also in order to
demonstrate pop11 to MSC students. Mind you when I have to go and help them
with a problem, and I try and use their set up, I have to ask things like
"Can you remind me how to mark this line" etc...

Tim
--
    --------------------------------------------------------------------
    Tim Read, Email: tmr@cs.bham.ac.uk, The Attention and Affect Project
    Room LG23, School of Computer Science, The University of Birmingham,
    B15 2TT, England, Phone: +44-(0)21-414-4766, Fax: +44-(0)21-414-4281
    --------------------------------------------------------------------


Newsgroups: comp.lang.pop
From: lpb@cs.bham.ac.uk (Luc Beaudoin)
Subject: Re: Re: dlocals etc. (and shallow binding)
Organization: School of Computer Science, University of Birmingham, UK
Date: Tue, 26 Jan 1993 20:55:24 GMT

sfk@otter.hpl.hp.com (Steve Knight) writes:

>     constant foo = {'dog'};
> then the variable foo is immutable -- it always points to the same

Ok, I thought there might have been some other technical meaning. (I
also thought we might want to say that constants aren't variables
since they're not variable (at the top level)! But given your
message and help files, I see that the usage is to refer to
constants as variables. Fair enough.)

Luc
-- 
-------------------------------------- -----------------------------------
Luc Beaudoin                          |  School of Computer Science
E-mail: lpb@cs.bham.ac.uk             |  University of Birmingham
voice:  +44 (21) 414-4766 or 3743     |  Birmingham B15 2TT, UK
From: pop@cs.umass.edu ( Robin Popplestone )
Newsgroups: comp.lang.pop
Subject: Mutability
Date: 27 Jan 93 14:46:06 GMT
Organization: University of Massachusetts, Amherst
Originator: pop@roo.cs.umass.edu

I seem to recall hearing that early versions of Fortran would accept
statements like

   3 = 4

and interpret them as specifying that the constant "3" should have the
value "4" from now on.
From: sfk@otter.hpl.hp.com (Steve Knight)
Date: Thu, 21 Jan 1993 18:13:33 GMT
Subject: Re: lvars and standards (was: Re: List and Vector Syntax)
Organization: Hewlett-Packard Laboratories, Bristol, UK.
Newsgroups: comp.lang.pop

Brian writes:
> Now I'm really confused.  If B isn't lexically within A, then LA is *not*
> visible. I'm thinking about an example like this.  (Not beng a Pop programmer,
> I'll have to use another language, sorry...)  You've written some general
> utility procedure, such as

Umm, looking at my previous note I think I muddied the water by not 
properly distinguishing lexical scope and dynamic visibility.  And
since that is what this discussion is about I hereby smack myself on
the wrist.  (Ouch!)
 
I'll have one more go at this.  Brian is obviously correct in suggesting
that LA is not in scope (by definition) but conflates this with 
visibility.  The point I was trying to make is that a common interpretation
of the dynamic environment for lexical bindings gives a meaning to LA 
within B's environment.  To put this in a concrete framework, here's 
Brian's example.

> ; a deliberately faulty program
> 
> (define (nth num lst)
>   (if (= n 0)
>       (car lst)
>       (nth (- num 1) (cdr lst)) ))
>
> (define (last sequence)
>   (let ((size (length sequence)))
>     (nth size sequence) ))           ; error
> 
> Here you have forgotten that nth counts from zero, so the last element
> is number SIZE-1, not number SIZE.  You try running the program and it
> blows up, attempting to apply CDR to an empty list.  The error is caught
> in NTH, but the error is really in LAST.
> 
> Since NTH is not lexically within LAST, at the moment when the error
> is caught the variable SIZE is not visible; it's in the wrong scope.
> And that's the variable you have to examine to figure out what went
> wrong.

It is true that NTH is not lexically within LAST.  However,
dynamic visibility is not the same as lexical scope.  When we inspect the 
dynamic bindings (if we use the normal meaning given by the
denotational semantics) all the bindings are visible.  My suggestion
is that this interpretation of the binding environment makes the
distinction between dynamic and lexical binding moot.

The issue is that if you use lexical binding, the compiler doesn't have to
generate a run-time structure to represent the dynamic bindings.  Most
compiler-writers exploit this performance enhancement and thereby 
undermine the ability to implement an interactive break loop.  By contrast,
the obvious implementation of dynamic binding generates a run-time 
structure that directly implements the dynamic environment.

I hope this makes the general idea clear.  You can get interactive access 
to lexical variables in a break loop -- but the implementation of this
is much more awkward than for dynamic variables.

Steve
From: ray@philmtl.philips.ca (Ray Dunn)
Newsgroups: comp.lang.pop
Subject: Re: Grandmothers and eggs
Date: 26 Jan 93 02:27:12 GMT
Organization: Not Philips.

In refd article, jadwa@isg.reading.ac.uk (James Anderson) writes:
>You don't suck, you blow'.
>
>So now you know Ray!

Hmm...  How should I take this?


(:-)
[sorry it took me so long to get back to this]
-- 
Ray Dunn at home        |  Beaconsfield, Quebec  |  Phone: (514) 630 3749
ray@philmtl.philips.ca  |  ray@cam.org           |  uunet!sobeco!philmtl!ray
From: kers@hplb.hpl.hp.com (Chris Dollin)
Date: Thu, 28 Jan 1993 13:42:21 GMT
Subject: Re: Re: dlocals etc. (and shallow binding)
Organization: Hewlett-Packard Laboratories, Bristol, UK.
Newsgroups: comp.lang.pop

In article ... kers@hplb.hpl.hp.com (Chris Dollin) wrote ...

... quite a lot, actually.

   The Pepper solution is this. First, there are two kinds of declarations,
   ``val'' and ``var''. Identifiers declared by ``val'' are not assignable
   (the declaration initialises them), while those declared by ``val'' are.
								 ^
Of course, you will have noticed that I should have said ``var'' | ...

   [Quickly scanning the Pepper code to hand, I see more than 750 ``val''s 
   and less than 250 ``var''s. ...]

I realised (thanks, Steve) that I had completely forgotten about for
loop identifiers and procedure parameters! There were 92 for loops
(each contributing one val identifier) and about 1170 parameters,
of which about 20 were var's (by default, they'd be val's). That
brings to total to approximately 1900 val's versus 270 var's, so
val's make up about 7/8ths of the variables in my code.

The numbers are only approximate, because I used grep, tr, and wc
to do my counting. But they shouldn't be too far off. Perhaps one
day I'll hack the compiler to do the stats for me.
--

Regards,    | "You're better off  not dreaming of  the things to come;
Kers.       | Dreams  are always ending  far too soon." - Caravan.
From: axs@cs.bham.ac.uk (Aaron Sloman)
Newsgroups: comp.lang.pop
Subject: Re: lvars and standards (was: Re: List and Vector Syntax)
Date: 20 Jan 93 16:08:34 GMT
Organization: School of Computer Science, University of Birmingham, UK

bh@anarres.CS.Berkeley.EDU (Brian Harvey) writes:

> Date: 18 Jan 93 15:13:00 GMT
> Organization: University of California, Berkeley

> ....It's
> easy to write a Pascal compiler in Logo because the dynamic scope at
> compile time matches the lexical scope at run time.

This is not strictly relevant, but I remember that some years ago
(late 1970s?) there was an attempt to write a Logo interpreter
(including store manager and garbage collector) in Pascal and they
eventually had to give up because Pascal was such an impoverished
and unsuitable language. It's interesting that the reverse is
easier, even though many people think of Logo as a  "toy" language,
since it was designed for children.

[advert: see
    A.Sloman
    `Beginners need powerful systems', in
    New Horizons in Educational Computing,
    ed. M.Yazdani,
    Ellis Horwood and John Wiley, 1984.]

Aaron
-- 
Aaron Sloman,
School of Computer Science, The University of Birmingham, B15 2TT, England
EMAIL   A.Sloman@cs.bham.ac.uk  OR A.Sloman@bham.ac.uk
Phone: +44-(0)21-414-3711       Fax:   +44-(0)21-414-4281
Newsgroups: comp.lang.pop,comp.compilers