HDTenEightyP/NetNews huggingface dataset:
From: partain@dcs.glasgow.ac.uk (Will Partain)
Newsgroups: comp.lang.functional
Subject: Re: LML, Gofer and glhc for linux?
Date: 8 Jan 93 17:53:25 GMT
Organization: University of Glasgow, Computing Science Dept.

In article <1993Jan8.145344@cs.utwente.nl> ramaer@cs.utwente.nl (Mark Ramaer) writes:

   Some time ago somebody at the University of Glasgow posted an article
   that he ported LML, glhc and Gofer to linux.  I tried download these
   packages from ftp.dcs.glasgow.ac.uk but I get the response:

     Connected to vanuata.dcs.glasgow.ac.uk.
     421 Service not available, remote server has closed connection

   How can I get LML, glhc and Gofer for linux, I do not want to
   do the porting all over again.

We've been having serious system problems this week; it should be
happier next week.  As an alternative, src.doc.ic.ac.uk (a huge
archive site) mirrors our pub/haskell in languages/haskell.  I don't
know of any Linux files therein, though; ask Andr\'e Santos (andre)
about it.

Will
From: augustss@cs.chalmers.se (Lennart Augustsson)
Newsgroups: comp.lang.functional
Subject: Re: LML, Gofer and glhc for linux?
Keywords: n
Date: 9 Jan 93 11:04:24 GMT
Organization: Chalmers University of Technology


In article <PARTAIN.93Jan8175325@tegua.dcs.glasgow.ac.uk> partain@dcs.glasgow.ac.uk (Will Partain) writes:
>In article <1993Jan8.145344@cs.utwente.nl> ramaer@cs.utwente.nl (Mark Ramaer) writes:
>
>   Some time ago somebody at the University of Glasgow posted an article
>   that he ported LML, glhc and Gofer to linux.  I tried download these
>   packages from ftp.dcs.glasgow.ac.uk but I get the response:
>We've been having serious system problems this week; it should be
>happier next week.  As an alternative, src.doc.ic.ac.uk (a huge
>archive site) mirrors our pub/haskell in languages/haskell.  I don't
>know of any Linux files therein, though; ask Andr\'e Santos (andre)
>about it.
The changes to make lmlc/hbc run under linux (and 386bsd) have been
merged into the distribution and will be part of the next release
(any day now).  There will be no linux binaries in it since I don't have a
box running linux (but I could supply 386bsd binaries).

(A 33Mhz 486 runs faster than a Sparc2!)

	-- Lennart



-- 

	-- Lennart Augustsson
[This signature is intentionally left blank.]
From: tmb@arolla.idiap.ch (Thomas M. Breuel)
Newsgroups: comp.lang.functional
Subject: Re: Random permutations, linear time, fully functional?
Date: 9 Jan 93 14:06:20
Organization: IDIAP (Institut Dalle Molle d'Intelligence Artificielle
	Perceptive)
Reply-To: tmb@idiap.ch
NNTP-Posting-Host: arolla.idiap.ch
In-reply-to: pdc@dcs.ed.ac.uk's message of Sat, 9 Jan 1993 02:54:33 GMT

In article <C0KG2y.HvE@dcs.ed.ac.uk> pdc@dcs.ed.ac.uk (Paul Crowley) writes:

   Following a long and heated discussion on the topic in a local
   newsgroup in which the local ML experts have come up hands empty
   (surprising given this is Edinburgh), I'm looking for fully functional
   ways of solving certain permutation problems which imperative languages
   like C can solve in linear time.  In particular, I'd like to be able to
   compose and invert permutations and generate random ones in linear
   time.  If you don't like mixing "random" and "fully functional", you
   could always ask for a list of random numbers as input. For example, an
   equivalent of this C function would be the best part of a solution:

Use version arrays. They are an implementation of functional vectors,
and the kind of update that happens in an imperative algorithm can be
carried out in constant time. I think every functional language should
provide them, either as the default implementation of a vector, or,
at least, as another datatype. In SML, you can hack them yourself,
except that the type signature will include some weak types that
needn't be weak.

I doubt that you can do better than "n log n" if all you have is lists
and functional vectors with update by copying.

In general, you don't need special ideas ("do it by sorting") in order
to convert imperative algorithms to functional algorithms with a
logarithmic overhead. Instead, simply use a balanced tree to represent
arrays.  That will give you Theta(log n) time access and "update".

					Thomas.
Newsgroups: comp.lang.functional
From: ssmith@ug.cs.dal.ca (Susan E Smith)
Subject: Length of Arrays in SML
Organization: Math, Stats & CS, Dalhousie University, Halifax, NS, Canada
Date: Tue, 5 Jan 1993 19:49:12 GMT

PROBLEM:  I am using Standard ML (New Jersey), Version 0.66 and I am trying
to use the Array function "length" to get the length of an array.  I have
defined my array using arrayoflist:

	eg.	val My_Array = arrayoflist ["Hi","My","Name","Is","Bob"];

	Now I want to use "length My_Array" to return the integer 5.

The reference manual I am using, says that this can be done and that the
function length is one that takes an array and returns an int.

However, this gives me an error when I try it in my version of SML and when
I type "length;" it tells me that length accepts a list and returns an int,

	eg.	length My_List;  returns the length of the list, My_List.

	I have tested this and this is the case.

The discrepancy between my reference manual and my version of SML is not the
major concern here, what I really want to know is:  Is there a way to get
the length of an array in the version of SML I am using.  This is important
to my application because I have a statement that says My_Array sub i where
i is begin incremented; hence, once i is out of range for the array, I don't
want the function to continue executing.

Any help would be greatly appreciated.

Susan
ssmith@ug.cs.dal.ca
From: augustss@cs.chalmers.se (Lennart Augustsson)
Newsgroups: comp.lang.functional
Subject: Re: Random permutations, linear time, fully functional?
Keywords: n
Date: 10 Jan 93 19:59:38 GMT
Organization: Chalmers University of Technology

>Following a long and heated discussion on the topic in a local
>newsgroup in which the local ML experts have come up hands empty
>(surprising given this is Edinburgh), I'm looking for fully functional
>ways of solving certain permutation problems which imperative languages
>like C can solve in linear time.  In particular, I'd like to be able to
>compose and invert permutations and generate random ones in linear
>time.
Of course you can do it, it all depends on what primitive operations
you have available and what time they take.  Assuming that you
have updateable arrays with O(1) index and update it's trivial.
(The arrays can be packaged in any way you like to make them pure:
as a stream-to-stream function (lookup/index in, value out), as a
state monad, as version arrays, ...).  I don't consider having those
as primitive operations as cheating, all imperative languages have
them so why shouldn't we?

If, on the other hand, you only allow the pure lambda-calculus as
the programming language (with suger if you want), then I kind of doubt
that it can be done.  (Unless you have a constant time beta reduction
step and can come up with some clever coding of arrays.)

-- 

	-- Lennart Augustsson
[This signature is intentionally left blank.]
From: nw24+@andrew.cmu.edu (Nicholas Weidmann)
Newsgroups: comp.lang.functional
Subject: Backus paper on FP ?
Date: 11 Jan 93 11:10:14 GMT
Article-I.D.: andrew.YfIS8q_00WAv48lUcW
Organization: Carnegie Mellon, Pittsburgh, PA


	Can anyone give me the address of a ftp site where I could
find the original paper written by John Backus on the language FP.
Newsgroups: comp.lang.functional
Subject: Calling Mario Suedholt (summary re "Skeletons")
From: jeremy@cs.aukuni.ac.nz (Jeremy Gibbons)
Date: Mon, 11 Jan 1993 06:14:46 GMT
Organization: Computer Science Dept. University of Auckland
Keywords: Suedholt, skeletons
Cc: jeremy@cs.aukuni.ac.nz

Aargh. Missed it. Mario Suedholt, if you're reading this, could you please
send me a copy of the message you posted recently summarizing messages
about "skeletons"?

Thanks.

Jeremy

PS Hope I spelt your name right!

---
Jeremy Gibbons <jeremy@cs.aukuni.ac.nz>         tel: +64 9 373 7599
   Department of Computer Science,              fax: +64 9 373 7453
   University of Auckland, Private Bag 92019, Auckland, New Zealand.


Newsgroups: comp.lang.functional
From: pdc@dcs.ed.ac.uk (Paul Crowley)
Subject: Random permutations, linear time, fully functional?
Reply-To: pdc@dcs.ed.ac.uk (Paul Crowley)
Organization: Edinburgh University
Date: Sat, 9 Jan 1993 02:54:33 GMT

Following a long and heated discussion on the topic in a local
newsgroup in which the local ML experts have come up hands empty
(surprising given this is Edinburgh), I'm looking for fully functional
ways of solving certain permutation problems which imperative languages
like C can solve in linear time.  In particular, I'd like to be able to
compose and invert permutations and generate random ones in linear
time.  If you don't like mixing "random" and "fully functional", you
could always ask for a list of random numbers as input. For example, an
equivalent of this C function would be the best part of a solution:

/* 
 * source and result are arrays of integers of length n.
 * For random permutations, source should be made up of a lot of
 * random numbers each between 0 and n-1.
 */

void randpermute(source, result, n)
int *source, *result, n;
{
	int i, tmp;
	
	for(i = 0; i < n; i++)
		result[i] = i;
	for(i = 0; i < n; i++) {
		tmp = result[i];
		result[i] = result[source[i]];
		result[source[i]] = tmp;
	}
}

The best solution so far take O(n log n) time and involves sorting.  I
believe that Haskell has a way of offering read-only arrays accessible in
O(1) time and that might go some way towards a solution (for example,
they solve composition pretty neatly).

Be warned that many of the notables of this department have found banana
peels here...
  __                                _____
\/ o\ Paul Crowley pdc@dcs.ed.ac.uk \\ //
/\__/ "I'm the boy without a soul."  \X/
From: augustss@cs.chalmers.se (Lennart Augustsson)
Newsgroups: comp.lang.functional
Subject: Re: LML, Gofer and glhc for linux?
Keywords: n
Date: 9 Jan 93 10:57:47 GMT
Organization: Chalmers University of Technology

In article <PARTAIN.93Jan8175325@tegua.dcs.glasgow.ac.uk> partain@dcs.glasgow.ac.uk (Will Partain) writes:
>In article <1993Jan8.145344@cs.utwente.nl> ramaer@cs.utwente.nl (Mark Ramaer) writes:
>
>   Some time ago somebody at the University of Glasgow posted an article
>   that he ported LML, glhc and Gofer to linux.  I tried download these
>   packages from ftp.dcs.glasgow.ac.uk but I get the response:
>We've been having serious system problems this week; it should be
>happier next week.  As an alternative, src.doc.ic.ac.uk (a huge
>archive site) mirrors our pub/haskell in languages/haskell.  I don't
>know of any Linux files therein, though; ask Andr\'e Santos (andre)
>about it.
The changes to make lmlc/hbc run under linux (and 386bsd) have been
merged into the distribution and will be part of the next release
(any day now).  There will be no linux binaries in it since I don't have a
box running linux (but I could supply 386bsd binaries).

(A 33Mhz 486 runs faster than a Sparc2!)

	-- Lennart



-- 

	-- Lennart Augustsson
[This signature is intentionally left blank.]
Newsgroups: comp.lang.functional
From: aet@mullian.ee.mu.OZ.AU (bert thompson)
Subject: Haskell installed on SGI?
Organization: Computer Science, University of Melbourne, Australia
Date: Fri, 8 Jan 1993 02:35:12 GMT


hi!

has anyone installed a Haskell compiler on an SGI machine?
i'm interested in installing the Chalmers compiler on an SGI, however
it looks like a lot of work. 

there is a MIPS binary at animal.cs.chalmers.se however byte-order 
is wrong for SGIs, and there may be other problems as well.

i'd like to steal the binary from someone who has done all 
the hard work. 8^)

many thanks,

	bert.

---------------------------------------------------------------------------
bert thompson	aet@munagin.ee.mu.oz.au.
SITEE		school of information technology and electrical engineering
		university of melbourne
---------------------------------------------------------------------------
     g e t  t h e  p o i n t 
---------------------------------------------------------------------------
From: bevan@cs.man.ac.uk (Stephen J Bevan)
Newsgroups: comp.lang.functional
Subject: Re: Random permutations, linear time, fully functional?
Date: 9 Jan 93 18:19:26 GMT
Organization: Department of Computer Science, University of Manchester
In-reply-to: pdc@dcs.ed.ac.uk's message of 9 Jan 93 02:54:33 GMT

In article <C0KG2y.HvE@dcs.ed.ac.uk> pdc@dcs.ed.ac.uk (Paul Crowley) writes:

  [ how do you efficiently permute an array in a pure functional way? ]

Assuming that the types "Updatable_Array/Updatable_Array_Action" are
provided in the implementation, then the following Haskell code might
work for the the example problem.

 >rand_permute :: Array Int Int -> Updatable_Array Int Int -> Array Int Int
 >rand_permute source = with_updatable_array b (initalise `and_then` permute)
 >  where initialise = for_all inds init
 >        permute    = for_all inds (\i -> swap i (source!i))
 >        b          = bounds source
 >        inds       = range b
 >        init i     = store i i

 >swap :: Int -> Int -> Updatable_Array_Action Int Int ()
 >swap i j =
 >  fetch i       `giving`   \tmp ->
 >  fetch j       `giving`   \new_i ->
 >  store i new_i `and_then`
 >  store j tmp

where the various implementation defined actions have the following
signatures :- 

 >fetch :: (Ix a) => a -> Updatable_Array_Action a b b
 >store :: (Ix a) => a -> b -> Updatable_Array_Action a b ()
 >giving :: (Ix a) => Updatable_Array_Action a b c
 >       -> (c -> Updatable_Array_Action a b d)
 >       -> Updatable_Array_Action a b d
 >and_then :: (Ix a) => Updatable_Array_Action a b c
 >         -> Updatable_Array_Action a b d
 >         -> Updatable_Array_Action a b d
 >for_all :: (Ix a) => [a] -> (a -> Updatable_Array_Action a b c)
 >                         -> Updatable_Array_Action a b c
 >with_updatable_array :: (Ix a) -> (a, a)
 >                     -> Updatable_Array_Action a b c -> Array a b

yours treading carefully,

bevan
From: psanders@srd.bt.co.uk (Paul Sanders)
Newsgroups: comp.lang.functional
Subject: Looking for PolyML Supplier
Date: 7 Jan 93 15:55:50 GMT
Reply-To: psanders@srd.bt.co.uk
Distribution: uk
Organization: British Telecom

Does anyone have a contact e-mail address for the current suppliers of 
PolyML ?

Thanks

Paul.
--
   Paul Sanders      psanders@srd.bt.co.uk		Tel: +44 473 645716
     Software Research, BT Laboratories, Martlesham Heath IPSWICH IP5 7RE
Newsgroups: comp.lang.functional
From: quale@spock.cs.wisc.edu (Doug Quale)
Subject: Re: Random permutations, linear time, fully functional?
Organization: University of Wisconsin -- Madison
Date: Sun, 10 Jan 1993 08:01:53 GMT

In article <C0KG2y.HvE@dcs.ed.ac.uk> pdc@dcs.ed.ac.uk (Paul Crowley) writes:
>
>/* 
> * source and result are arrays of integers of length n.
> * For random permutations, source should be made up of a lot of
> * random numbers each between 0 and n-1.
> */
>
>void randpermute(source, result, n)
>int *source, *result, n;
>{
>	int i, tmp;
>	
>	for(i = 0; i < n; i++)
>		result[i] = i;
>	for(i = 0; i < n; i++) {
>		tmp = result[i];
>		result[i] = result[source[i]];
>		result[source[i]] = tmp;
>	}
>}
>

This C code does not solve the problem correctly.  It gives n**n
possible outcomes, and in general the number of permutations of n
objects, n!, does not divide n**n.  For example, it doesn't work
for n = 3 (try it!).
-- 
Doug Quale
quale@saavik.cs.wisc.edu
From: ark@alice.att.com (Andrew Koenig)
Newsgroups: comp.lang.functional
Subject: Re: Random permutations, linear time, fully functional?
Date: 9 Jan 93 15:13:54 GMT
Article-I.D.: alice.24581
Reply-To: ark@alice.UUCP ()
Organization: AT&T Bell Laboratories, Murray Hill NJ

In article <C0KG2y.HvE@dcs.ed.ac.uk> pdc@dcs.ed.ac.uk (Paul Crowley) writes:

> I believe that Haskell has a way of offering read-only arrays accessible in
> O(1) time and that might go some way towards a solution (for example,
> they solve composition pretty neatly).

As do some recent implementations of ML.
-- 
				--Andrew Koenig
				  ark@europa.att.com
From: pop@cs.umass.edu ( Robin Popplestone )
Newsgroups: comp.lang.functional
Subject: Permutations
Date: 11 Jan 93 14:43:34 GMT
Organization: University of Massachusetts, Amherst
Originator: pop@roo.cs.umass.edu


It does of course depend on your model of memory as to whether the C is
linear time.... one might argue that memory is logarithmic (based on the
number of gates required to decode an address) or cube-root-n (based on
the number of physically-minimal-memory-cells that one can pack in a given
space. In practice it seems to be lumpy-logarithmic.

However, let us be conventional, and suppose we have constant time  access.
It is difficult to see how to render the random permutation algorithm  into
a linear  time function.  The problem  is  that an  array is  a  (memoised)
function on a sub-range  of the integers  (or cartesian products  thereof).
Thus of course the O(1) access time available from the old POP-2  treatment
of arrays (to my mind better than the Haskell proposal) doesn't help, since
it takes O(n)  time to  make such  an array, and  you have  to remake  it n
times. [Of  course, a  cunning compiler  ought to  be able  to  transform a
log-time functional program into a linear time non-functional one.]

Incidentally, the POP-2/POP-11 treatment of arrays-as-functions allows
you to write a constant time product of permutations in a 'quasi-lazy' way.
If n is fixed then the function product:

  P1<>P2

is permutation product.  If you want n to be variable, we need something
like the following:

/* a pure function defined using the non-functional capabilities.
Operator precedence = 4. */

define 4 F with_props Props;
  lvars F,Props,F1 = copy(F);
  Props -> pdprops(F1);
enddefine;

vars domain = pdprops;

/* constant time permutation product */

define prod_perm(P1,P2);
    P1<>P2 with_props domain(P1)
enddefine;


/* linear time permutation product */

define prod_perm(P1,P2);
  lvars n = domain(P1);
  newarray([%1,n%], P1<>P2) with_props n);
enddefine;





Robin.
Newsgroups: comp.lang.functional
From: andre@dcs.glasgow.ac.uk (Andre Santos)
Newsgroups: comp.lang.functional
Subject: Re: LML, Gofer and glhc for linux?
Date: 11 Jan 93 12:16:22 GMT
Organization: Glasgow University Computing Science Dept.

ramaer@cs.utwente.nl (Mark Ramaer) writes:

>Some time ago somebody at the University of Glasgow posted an article
>that he ported LML, glhc and Gofer to linux.  I tried download these
>packages from ftp.dcs.glasgow.ac.uk but I get the response:

You probably had problems due to the systems being down most of the week.
It should be OK now.

In pub/linux you can find gofer and SML-NJ ports for linux.
I will upload tomorrow a (binary) version of LML.
I also have a version of glhc, which I will upload soon.

Andre.

-- 
---------------------------------------------------------------------
Andre Santos                     | Glasgow University               | 
e-mail: andre@dcs.glasgow.ac.uk  | Computing Science Department     | 
                                 | 17 Lilybank Gardens              | 
Newsgroups: comp.lang.functional
From: theobald@ucunix.san.uc.edu (Allen M. Theobald)
Subject: PD lisp or SML pkgs
Organization: University of Cincinnati
Date: Thu, 7 Jan 1993 23:21:45 GMT


Hello Fellow Netters!

Pardon me if this has been answered in the FAQ, but are there
any public domain lisp(like) software pkgs available for down-
loading?  And if so, where they can be located?

Any and all info welcome.  Feel free to post here or email me.
Whichever is most convenient.

		Thanks in advance!

		Allen

P.S. Please throw in any additional info for pd ML or SML also...
Newsgroups: comp.lang.functional
From: quale@spock.cs.wisc.edu (Doug Quale)
Subject: Re: Random permutations, linear time, fully functional?
Reply-To: quale@saavik.cs.wisc.edu
Organization: University of Wisconsin -- Madison
Date: Sun, 10 Jan 1993 08:09:57 GMT

In article <C0KG2y.HvE@dcs.ed.ac.uk> pdc@dcs.ed.ac.uk (Paul Crowley) writes:
>/* 
> * source and result are arrays of integers of length n.
> * For random permutations, source should be made up of a lot of
> * random numbers each between 0 and n-1.
> */
>
>void randpermute(source, result, n)
>int *source, *result, n;
>{
>	int i, tmp;
>	
>	for(i = 0; i < n; i++)
>		result[i] = i;
>	for(i = 0; i < n; i++) {
>		tmp = result[i];
>		result[i] = result[source[i]];
>		result[source[i]] = tmp;
>	}
>}
>

This C code does not solve the problem correctly.  The procedure
does not produce a random distribution because the number of possible
shuffles, n**n, is not divisible by the number of permutations, n!.

For instance, the output is skewed for n = 3 (try it!).
-- 
Doug Quale
quale@saavik.cs.wisc.edu
From: pop@cs.umass.edu ( Robin Popplestone )
Newsgroups: comp.lang.pop
Subject: Grandmothers and eggs
Date: 11 Jan 93 13:54:07 GMT
Organization: University of Massachusetts, Amherst
Originator: pop@roo.cs.umass.edu

Since not all of us were around in the sixties, I thought it might be
useful to point out that Ray Dunn was the person who really got POP-2
(complete with incremental compiler) to the state of being a tool that
worked well enough to support the work of one of the leading AI research
groups in the world. Of course, a systematic approach to portability
only arrived with Poplog, although some initial work was done by Rod
Burstall and Bill Scherliss, who implemented a POP-in-POP.

An interesting question - what is the history of incremental compilation?
We were not aware that it was done anywhere else at the time.

Robin.
From: ianr@syma.sussex.ac.uk (Ian Rogers)
Newsgroups: comp.lang.pop
Subject: Re: lvars and standards
Date: 8 Jan 93 15:19:58 GMT
Organization: University of Sussex at Brighton

kers@hplb.hpl.hp.com (Chris Dollin) writes:
> In article ... ianr@syma.sussex.ac.uk (Ian Rogers) writes:
>
>    There will be no MSDOS or Mac version of Pop11 without an
>    identifiable, sufficient subset of Pop11 commands and syntax. This
>    is why Pepper and GLOW have occurred!
>
> I can't speak for GLOW, but that *isn't* why I designed and (proto) implemented
> Pepper.

But, as far as I know, you're a Pop fan Chris. So if there'd been a subset
would you have used that instead of inventing Pepper?

Ian.
From: tmr@cs.bham.ac.uk (Tim Read)
Newsgroups: comp.lang.pop
Subject: background compilation of pop11 from within ved
Date: 5 Jan 93 12:39:59 GMT
Organization: School of Computer Science, University of Birmingham, UK

I find that if I'm compiling a buffer within ved that is loading a lot of
libraries etc, it takes an eternity, even on our very fast machine. While this
is happening I can not use any of my other ved buffers.

So the question is: How can I get pop11 to compile the buffer in the
background, so that I can continue using ved on another buffer?

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
    --------------------------------------------------------------------
From: ray@philmtl.philips.ca (Ray Dunn)
Newsgroups: comp.lang.pop
Subject: Re: lvars and standards (was: Re: List and Vector Syntax)
Date: 9 Jan 93 01:39:23 GMT
Organization: Not Philips.

In refd article, kers@hplb.hpl.hp.com (Chris Dollin) writes:
>In article ... ianr@syma.sussex.ac.uk (Ian Rogers) writes:
>
>   There will be no MSDOS or Mac version of Pop11 without an
>   identifiable, sufficient subset of Pop11 commands and syntax. This
>   is why Pepper and GLOW have occurred!
>
>I can't speak for GLOW, but that *isn't* why I designed and (proto) implemented
>Pepper. 

Nor do I see any reason why it should be so.  Anybody?

Having been hacking in 'C' for the last ..cough.. years I can't understand
why there wasn't a 'C' implementation of POP done a long time ago.

I hope the work on Pepper is being done in a portable fashion.
-- 
Ray Dunn at home        |  Beaconsfield, Quebec  |  Phone: (514) 630 3749
ray@philmtl.philips.ca  |  ray@cam.org           |  uunet!sobeco!philmtl!ray