May 2001 - Haskell - Haskell.org

Teaching Assistantships in the Computing Lab, University of Kent
by S.J.Thompson 31 May '01

31 May '01

Haskellers welcome! Simon Teaching Assistantships in the Computing Lab, University of Kent Applications are invited for two posts of teaching assistant in the Computing Laboratory at the University of Kent. These posts are for a fixed-term period of four years and are intended to support postgraduate researchers during their period of registration for a part-time PhD in one of the research groups in the Computing Laboratory. The successful applicants will be required to participate in up to eight hours teaching per week during academic terms. Applicants will be expected to provide evidence of their experience in teaching or equivalent activities. Total remuneration is at the rate of 13,231 GBP per annum, made up of 6931 GBP salary and 6300 GBP PhD bursary; PhD fees are paid in addition to this. Application procedure Applications should be sent by email to the professorial secretary, Mrs Jenny Oatley, jao(a)ukc.ac.uk, with the subject line 'Teaching Assistant Application'. Applications should include - A brief curriculum vitae, detailing - educational history and qualifications; - employment history; - details of teaching experience, if any; - country of residence, native language (if not English please include TOEFL/IELTS score). - A statement of your proposed research project, including the research group in which that research project lies. - Names, addresses and email addresses of two academic referees. The deadline for applications is 21 June 2001, and interviews will take place on 28 June 2001. Applicants who are unable to attend interviews may be asked for telephone interview.

1 0

FW: Eq instance for (a,b,c,d,e) and upwards
by Simon Peyton-Jones 31 May '01

31 May '01

Henrik Nilsson wrote: > So, if, in the interest of being conservative, the stated minimal > bound cannot be "infinity", could it at least be a great deal bigger > than what reasonably would be used in *hand-written* code? Say 15. An > arbitrary choice, of course, but it is not excessive from an > implementation perspective, yet large enough that I cannot imagine > hand-written code getting close to the limit. A fair point. If you care either way, send me a note. (Not to the list.) Henrik leaves open the question of which tuple *instances* you can rely on. Up to 7, like zip and friends? Or up to 15? By analogy with the zip functions, I think I'd go for 7. Again, let me know, but don't trouble the list unless you want to raise a new point. Simon

1 0

RE: Haskell 98 Report
by Simon Peyton-Jones 31 May '01

31 May '01

I don't think there was a deep reason, but the current story makes it more like the other 'By' functions. Anyway, this is one thing that is not going to change! (Not that you were proposing that it should.) Simon | -----Original Message----- | From: Zhanyong Wan [mailto:zhanyong.wan@yale.edu] | Sent: 30 May 2001 18:42 | To: Simon Peyton-Jones | Cc: haskell(a)haskell.org | Subject: Re: Haskell 98 Report | | | Hello Simon, | | Looking at the definition for deleteBy: | | deleteBy :: (x -> a -> Bool) -> x -> [a] -> [a] | deleteBy eq x [] = [] | deleteBy eq x (y:ys) = if x `eq` y then ys else | y : deleteBy eq x ys | | I can't help wondering why it isn't | | deleteBy' :: (a -> Bool) -> [a] -> [a] | deleteBy' f [] = [] | deleteBy' f (y:ys) = if f y then ys else | y : deleteBy' f ys | | The point is that in the definition of deleteBy, all | references to eq and x are in the form (eq x), and hence the | two parameters can be combined. Is there a reason that the | current design was favored when Prelude was designed? Thanks. | | - Zhanyong | | -- | # Zhanyong Wan http://pantheon.yale.edu/~zw23/ ____ | # Yale University, Dept of Computer Science /\___\ | # P.O.Box 208285, New Haven, CT 06520-8285 ||___| |

1 0

RE: Eq instance for (a,b,c,d,e) and upwards
by Simon Peyton-Jones 31 May '01

31 May '01

Folks, I'm about to put out (what I hope is) the final revised Haskell98 report. Here, though, is one good point I propose to clarify. I propose to say that every H98 impl must support tuples up to size 7 and their instances for Eq, Ord, Bounded, Read, Show [Of course, one might hope that impls would do better, but the report should be conservative.] Simon | -----Original Message----- | From: Olaf Chitil [mailto:olaf@cs.york.ac.uk] | Sent: 23 April 2001 12:11 | To: nhc-users(a)cs.york.ac.uk | Cc: haskell(a)haskell.org; Simon Peyton-Jones | Subject: Re: Eq instance for (a,b,c,d,e) and upwards | | | | I think that this discussion about tuples shows that there is | a problem with the Haskell 98 report which should be | corrected. I hope Simon accepts it as a minor bug fix. | | 1) The current wording of paragraph 6.1.4 is highly ambigious. | | > 6.1.4 Tuples | > | > Tuples are algebraic datatypes with special syntax, as defined | > in Section 3.8. Each tuple type has a single constructor. There | > is no upper bound on the size of a tuple. However, some Haskell | > implementations may restrict the size of tuples and limit the | > instances associated with larger tuples. The Prelude and | libraries | > define tuple functions such as zip for tuples up to a | size of 7. All | > tuples are instances of Eq, Ord, Bounded, Read, and Show. Classes | > defined in the libraries may also supply instances for | tuple types. | | May the limit for the size of tuples and the limit for | instances be different? Do tuples exist at least for a size | up to 7? What is the purpose of the last sentence? | | We should decide what we want and the paragraph should then | state it clearly. | | 2) The arbitrary restrictions that Haskell implementations | are permitted to apply, basically imply that you shouldn't | use tuples at all if you want your code to be portable. Maybe | there isn't even a Show instance for ()? | | So I think the report should demand that tuples and instances | for Eq,Ord,Bounded,Read and Show should be implemented for at | least up to a size of a given number n. | | 3) I propose this number n to be 7. This fits well with the | fact that zip etc are defined for tuples up to a size of 7. I | agree with Martin that you should use a labelled record or at | least an own type instead of large tuples anyway. | Programs that generate code should als generate definitions | for data types, if large product types are needed. | | Olaf | | -- | OLAF CHITIL, | Dept. of Computer Science, University of York, York YO10 5DD, UK. | URL: http://www.cs.york.ac.uk/~olaf/ | Tel: +44 1904 434756; Fax: +44 1904 432767 |

4 3

RE: Haskell 98 Report
by Simon Peyton-Jones 30 May '01

30 May '01

| Sorry to get this comment in so late, but it is a small | change. In the List module, the type signature for deleteBy | is not as general as it could be, given the definition. It | could be generalized to the following (no change to the definition): | | deleteBy :: (a -> b -> Bool) -> a -> [b] -> [b] | | I've found it usefully used at this more general type. Indeed, and deleteFirstsBy :: (a -> b -> Bool) -> [b] -> [a] -> [b] I can't see any reason not to do this. Furthermore, the Report omits to export deleteFirstsBy, though GHC and Hugs both remember to do so. Simon

6 7

Announcement: new HOpenGL Tutorial
by Andre W B Furtado 30 May '01

30 May '01

Hello there. I've just released the first version of my HOpenGL (Haskell Open Graphics Library) tutorial. I hope it will encourage (and help) people around the world to use this great library/binding. I also would like to hear some feedback from you. You can visit the tutorial at: www.cin.ufpe.br/~haskell/hopengl/ Thank you, Andre W B Furtado

2 1

Recursive types?
by David Bakin 29 May '01

29 May '01

I'm having trouble understanding recursive types (e.g., as described in Functional Programming with Overloading and Higher-Order Polymorphism by Jones. He gives as an example > data Mu f = In (f (Mu f)) > data NatF s = Zero | Succ s > type Nat = Mu NatF Among the things I don't get are: 1. Comparing this to the non-higher-order type: > data NatX = Zero | Succ NatX What are the advantages of the higher-order type? What are the disadvantages (incl. runtime costs)? 2. How are values of type Nat represented? (It helps me to think about these things concretely.) Thanks! -- Dave

3 2

Re: Notation question
by John Hughes 29 May '01

29 May '01

> > > G |- f :: all x::S . T G |- s :: S > > >-------------------------------------- > > > G |- f s :: [s/x]T > Any more takers? I still don't have any pointers to literature where this theorem notation is explained more fully, and I'd really like to have some. This is a standard notation for describing type systems in articles on the subject -- so standard that it's hard to think of a good reference that actually explains it! However, I'd suggest looking at Michael Schwartzbach's lecture notes on Polymorphic Type Inference, which are on the web at http://www.daimi.aau.dk/~mis/typeinf.ps The typing rule notation is explained in the first couple of pages, and then used to explain many variants on type systems, show how inference works, etc. I have a collection of links to such articles at http://www.md.chalmers.se/~rjmh/tutorials.html which you might find useful. John Hughes

4 3

SFP Call for Participation
by Phil Trinder 29 May '01

29 May '01

CALL FOR PARTICIPATION 3rd Scottish Functional Programming Workshop University of Stirling Aug 22nd-24th, 2001 You are invited to participate in the 3rd Scottish Functional Programming Workshop. The draft programme is below, and both registration form and additional information are available at: http://www.cee.hw.ac.uk/~greg/sfp3/ SFP'3 Draft Programme ===================== Parallelism ----------- A Comparative Study of Skeleton-based Parallel Programming Environments Allowing Arbitrary Nesting Remi Coudarcher, Jocelyn Serot, Jean-Pierre Derutin Universite Blaise Pascal - Clermont II, France BSP in a Lazy Functional Context Quentin Miller Universite d'Orleans, France Parallel Functional Genetic Programming Graeme McHale and Greg Michaelson Heriot-Watt University, Scotland Introduction of Pipelining into Gaussian Elimination Joy Goodman Glasgow University, Scotland The Efficiency of Parallel Graph Reduction on a Loosely-coupled Multiprocessor Hans Wolfgang Loidl An SPMD environment machine for functional BSP programs Armelle Merlin, Gaetan Hains Universite d'Orleans, France Implementing and Measuring GdH Skeletons Phil Trinder Heriot-Watt University, Scotland Distribution ------------ Distributed Programming with Dynamic Reply Channels Rita Loogen, Steffen Priebe Philips-Universitat Marburg, Germany Distributed Applications in GdH Robert Pointon Heriot-Watt University, Scotland Applications ------------ Haskell: Language for Business Systems Dominic Steinitz, British Airways Chris Reade, Dan Russell, Phil Molyneux, Barry Avery Kingston Business School, England Functional programming languages for verification tools: experiences with ML and Haskell Martin Leucker, Thomas Noll, Perdita Stevens, Michael Weber RWTCH Aachen, Germany/University of Edinburgh, Scotland Infinite Pretty Printing in eXene Allen Stoughton Kansas State University, USA Derivation and Transformation ----------------------------- Extending Higher-Order Deforestation: Transforming Programs to Eliminate Even More Trees Geoff Hamilton, Dublin City University, Ireland Deriving Non-heirarchical Process Topologies Ricardo Pena, Fernando Rubio, Clara Segura Universidad Complutense de Madrid, Spain Language Design and Implementation ---------------------------------- Some Experiences Connecting Functional Languages and Java Andre Rauber Du Bois, Antonio Carlos da Rocha Costa Universidade Federal do Rio Grande do Sul/ Universidade Catolica de Pelotas, Brazil Paging Behaviour of List-based Memory in a Distributed Virtual Memory System for Pure Functional Languages Marco T. Morazan and Douglas R. Troeger City University of New York, USA Types ----- How to Fix Type Errors Automatically Bruce J. McAdam University of Edinburgh, Scotland Function Types and Complete type Inference Manfred Widera, Christoph Bierle Fern Universitat Hagen, Germany Human-like Explanations of Polymorphic Types Yang Jun, Greg Michaelson, Phil Trinder Heriot-Watt University, Scotland Theory ------ The dual of grafting is decoration Tarmo Uustalu, Varmo Vene Universidade do Minho, Portugal University of Tartu, Estonia Towards a Denotational semantics for Eden Mercedes Hidalgo-Herrero, Yolanda Ortega-Mallen Universidad Complutense de Madrid, Spain

1 0

Notation question
by Juan Carlos Arevalo Baeza 29 May '01

29 May '01

Just a very naive question, because I'm really curious. I've seen in previous messages here discussions about type systems using this kind of notation: > G |- f :: all x::S . T G |- s :: S >-------------------------------------- > G |- f s :: [s/x]T I'd never seen it before, and a few searches I've launched over the net have turned up just a couple more examples of this notation, but without a single reference to how it works or what it means, or even what it's called, for that matter. I'd appreciate any pointers. Salutaciones, JCAB --------------------------------------------------------------------- Juan Carlos "JCAB" Arevalo Baeza | http://www.roningames.com Senior Technology programmer | mailto:jcab@roningames.com Ronin Entertainment | ICQ: 10913692 (my opinions are only mine) JCAB's Rumblings: http://www.metro.net/jcab/Rumblings/html/index.html

4 4