of
Informatics at Edinburgh is among the strongest in the world, and Edinburgh
is known as a cultural centre providing a high quality of life.
If interested, please contact Prof. Philip Wadler .
Full details are here
<https://elxw.fa.em3.oraclecloud.com/hcmUI/CandidateExperience/en/sites/CX_1001/job/2
Yes, you've located last year's syllabus! Go well, -- P
. \ Philip Wadler, Professor of Theoretical Computer Science,
. /\ School of Informatics, University of Edinburgh
. / \ and Senior Research Fellow, IOHK
. http://homepages.inf.ed.ac.uk/wadler/
On Tue, 8 Sep 2020 at 21:20, Howard B
number of capable tutors. This year, we will take advantage of remote
delivery to recruit tutors from both within and without Edinburgh.
Tutorials are expected to be on Thursdays and Fridays each
week. Wadler will monitor tutorials, and expects to be in a position
to write letters of recommendation
IOHK Cardano Virtual Summit continues. Today's sessions include:
*16.00 (UK time) Fri 3 Jul* *Haskell, then and now: What is the future
for **functional
programming languages?* Prof Simon Peyton-Jones, Prof John Hughes, Prof
Philip Wadler, Dr Kevin Hammond, Dr Duncan Coutts.
You can submit
Cardano Virtual Summit 2020 takes place today and tomorrow. Some talks that
may be of interest:
*16.00 Thu 2 Jul* *An overview of IOHK research* Prof Aggelos Kiayias, Prof
Elias Koutsoupias, Prof Alexander Russell, Prof Phil Wadler.
*18.30 Thu 2 Jul* *Architecting the internet: what I would have
ssed to Prof Philip Wadler (
wad...@inf.ed.ac.uk).
Lecturer Grade: UE08 (£41,526 - £49,553)
Senior Lecturer or Reader Grade: UE09 (£52,559 - £59,135)
The School is advertising a number of positions, including this one, as
described here:
https://www.ed.ac.uk/informatics/about/work-with-us/vacan
are strongly encouraged
to apply. The deadline is March 12th, please see:
https://www.ed.ac.uk/informatics/about/work-with-us/vacancies/chancellor-fellowship-digital-technologies
for further information. Feel free to contact me if you have questions.
Yours, -- P
. \ Philip Wadler, Professor
to live with the
problem. Any ideas?
I don’t think we can steal “group” as a keyword -- it’s a function exported
by Data.List, and I don’t think the benefit justifies the cost.
So you are saying you prefer then group to group?
Yours, -- P
--
.\ Philip Wadler, Professor of Theoretical
George, Thanks very much for this. I like your suggestion, which
fits the logical structure perfectly; and you've suggested a neat way
around the ugliness of 'group groupBy'. I also note that if we aren't
so worried about not introducing new keywords, that 'then group' could
become 'group'.
. ...
family.phelpsinc.com/branches/haskell/ - 28k - Cached - Similar pages
Philip Wadler, Professor of Theoretical Computer Science
School of Informatics, University of Edinburgh
JCMB, Mayfield Road, Edinburgh EH9 3JZ SCOTLAND
+44 131 650 5174 http://homepages.inf.ed.ac.uk/wadler
Volker suggests using SGML/DSSSL for documentation. If one were to
take this route, I think XML/XSLT would be a more sensible combination.
See
http://www.cs.bell-labs.com/~wadler/xml
for a quick intro to XML. Runciman and Wallace at York have a nice
XML library for Haskell
://www.cs.bell-labs.com/~wadler/icfp2000
Call and submission details online
Below is the call for ICFP 2000. You may prefer to view it on the web:
http://www.cs.bell-labs.com/~wadler/icfp2000
The submission deadline is fast approaching: 1 March 2000!
Two invited speakers have accepted:
Carl Seger, Intel
Benjamin Pierce, University
Chris, I admit your argument about symmetry is attractive.
If you could put forward a concrete application, on a par with
the `break into blocks' application given earlier, you would
likely sway me. -- P
So doesn't my proposal give you precisely what you want, and no more?
Because my interest is as much in documentation as in constraints on
how the program executes (I admit your method achieves the latter).
If I write, say,
data Eq a = Assoc a b
then I'd like the signatures to ensure that
"S. Alexander Jacobson" [EMAIL PROTECTED] writes:
So, if they are making sure that all platforms have a scheme interpreter,
why not make the spec language agnostic. i.e. allow the user to use any
language that can be compiled/translated into scheme (by code written in
scheme?).
Your
te Haskell for the transformation
part of XSL, if they choose.
-- Phil Wadler (member of the XSL working group)
PS. If anyone has any suggestions about *small and reasonable* changes
to the XSL working draft that would be an improvement, please let me know.
XSL working draft: http://www.w3.org/TR/WD-x
class Monad m where
return :: m a
(=) :: m a - (a - m b) - m b
() :: m a - m b - m b
fail :: String - m a
fail s = error s
IO.fail becomes IO.ioError
Looks good.
class Monad m = MonadPlus m where
mzero :: m
Here's an even better idea: replace mfail with fail.
It is, after all, the fail of the IO monad!
Option 4'': Monad ((=), return, fail)
-- P
Ralph writes,
Unfortunately not, fail of IO fame has type
IOError - IO a
and not
String - m a
as Monad's new member.
Here's my suggestion:
o Monad ((=), return, fail)
o throw (thanks Frank) instead of fail for the IO operation
o raise for Haskell-2's
John Peterson writes
Int is really not a nice
datatype and we shouldn't be allowing it to crop up unexpectedly.
Yes, but if we believed that, we should use Integer, not Int, for
length.
You are right, beginners may stub their toe on factorial. On the other
hand, with the default set to
- The simple-context restriction. My difficulty here is that there
is just no good place to stop. The 'type variable in head position'
option is attractive, but it's unimplemented, untested, and it's
neither the status quo nor a final destination. On the other hand,
we
There is no need to have both `mzero' and `mfail' in every monad.
Just have `mfail'. Leave `zero' and `plus' to MonadPlus. This should
make Eric partially happy. It also means one can simply write
instance Monad [] where
...return, =, as before...
mfail s = []
Simon says,
Here are the two proposals I suggested in
http://research.microsoft.com/Users/simonpj
1.Fix up the current version.
use MonadZero for do expressions with *irrefutable* patterns
(instead of *unfailable* patterns as now)
2.Nuke MonadZero altogether.
Simon says,
Sorry, I don't understand option 2, can you please explain?
* Eliminate MonadZero
* Add 'mfail :: m a' to Monad, with a suitable default decl
* Every do expression has a type in Monad
I must be dense this morning, as I'm still in the dark. What is the
Thanks for the further explanation.
On reflection there probably shouldn't be a default declaration for mzero.
Any compiler for Haskell must do *something* if a method is
called for which there is neither an explicit declaration in
the instance, nor a default method. ... Leaving out
Consider the function
t :: T a = T a - T a
I think that it's far from clear what each of the T's mean!
Worse, in Haskell 2 we'll also have
t :: T T = T a - T a
In (T T) one is class and the other is a type constructor.
Let's leave the language as it is: class names and
re details on the web page
Functional Programming in the Real World
http://www.cs.bell-labs.com/~wadler/realword/
-- P
Hi Simon, This really seems to have touched off a firestorm! I think
the meta-argument made by Simon T (and by you) is sensible, so I don't
object to maintaining the status quo. But you implied that changing
the libraries led to `a ball of spaghetti', and I don't see that, can
you please
Simon proposes not to change the prelude to support Integer,
giving this argument:
The more this topic gets discussed the more I that it's like
other Prelude things: you pull on one thing and the plate of
spaghetti ends up in your lap.
I'm confused. I thought at the ICFP Haskell meeting
Simon PJ writes:
I think we should
- generalise length, splitAt, drop, take, replicate
- generalise toEnum, fromEnum
- leave (!!) alone (arrays must fit in an address space)
I don't know what to do about RealFloat. Sigh
If the goal is to make life easy for beginners (and
You're right. The restriction is excessive. Thanks for pointing
this out. Probably we should only require that at least one
of the class variables is constrained.
Why even require this? (All x) = x - x uses the class `All'
which restricts its argument not one whit. -- P
on this mailing
list without difficulty]
In my opinion, such a book should assume the reader has already been
through Bird and Wadler or whatever, is familiar with the lambda calculus,
and has written substantial programs. Please, no more "introduction to fp"
books!
How about secon
Rossberg writes,
thinking about whether the pretty printer proposed by Wadler requires
some changes to be efficient in a strict language, I stumbled over the
the last case defining `flatten':
flatten (x :| y) = flatten x
I wonder why it is necessary here to recurse on x
Expert have been widely used
in industry, and both have training courses that cover at least some
of what you want. For a quick intro to these, see
www.cs.bell-labs.com/~wadler/topics/recent.html#angry
and follow the pointers from there. (This paper also contains just
what you don't want
Phil, Could you send the following POPL 98 Call for Participation message to
the Haskell mailing list for me? Thanks, Dave
---
ACM PRINCIPLES OF PROGRAMMING LANGUAGES (POPL '98)
Briefly, what is the difference between Damas-Milner and Hindley-Milner
typing?
None. They are different names for the same thing.
The actual algorithm was discovered a number of times. Hindley
wrote a history of it, which I don't have to hand. He notes that
it had already been
home page. -- P
---
Philip Wadler [EMAIL PROTECTED]
Bell Laboratories http://cm.bell-labs.com/cm/cs/who/wadler/
Lucent Technologies office: +1 908 582 4004
600
Pizza Sites
More information on Pizza is available at the following web sites
(which mirror each other):
http://www.cis.unisa.edu.au/~pizza
University of South Australia
http://cm.bell-labs.com/cm/cs/who/wadler/pizza/welcome.html
Bell Labs, Lucent Technologies
Pizza Sites
More information on Pizza is available at the following web sites
(which mirror each other):
http://www.cis.unisa.edu.au/~pizza
University of South Australia
http://cm.bell-labs.com/cm/cs/who/wadler/pizza/welcome.html
Bell Labs, Lucent Technologies
I think that Java might be slow, just because of this automatic garbage
collection.
I can't let this chestnut go unchallenged. Let's not bandy about
claims without evidence. GC is perfectly fine for building into phone
switches (via Erlang) so it can't be all that slow. -- P
Now, for monads, Phil Wadler writes a law:
m = \x - k x ++ h x = m = k ++ n = k
in which 'h' appears on the lhs but not the rhs, and 'n' on the rhs but
not the lhs. ... perhaps the equation should read as follows?
m = \x - k x ++ h x = m = k ++ m = h
Yes, of course
Maybe we should do it as follows:
At the moment you make an instance of a class that has default definitions
for one of its superclasses, and there is no corresponding instance for
that class, we implicitly insert the specified default instance. If
there are more instances to choose from
subscribe. -- Philip Wadler, Editor-in-Chief, JFP
JFP 6.4 July 1996
=
Representing demand by partial projections
John Launchbury and Gebreselassie Baraki
New dimensions in heap profiling
Colin Runciman and Nicklas Rojemo
Benchmarking implementations of functional languages
Tommy Thorn writes:
My only worry is that Haskell (if not already) is turning into the C++
of functional languages, ie. feature upon feature. Haskell is already
quite a mouthfull to learn.
This worries me too. Not least is the problem that - is not a
particularly natural syntax for this
I think the report has it about right.
* A conforming implementation of Haskell 1.4 must support mutually recursive
modules. That is, a collection of individually legal mutually recursive
modules is a legal Haskell program.
* The Report recognises that implementations available in
This isn't muddling implemenation with language design. The language design
says mutual recursion is OK. A particular implementation supporting separate
compilation will typically require a variety of "help", such as a Makefile
with accurate dependencies. Requiring type signatures, or
It looks ugly, but we could say that a data declaration does not
have to have any constructors:
data Empty =
-- Lennart
I agree that the best way to fix this is to have a form of data
declaration with no constructors, but I'm not keen on the syntax you
propose. How about if
power x n | n 0 = x * power x (n-1)
completely obscures the similarity between `power' and `product'.
As a case in point, I cannot see a way to rewrite the Bird and Wadler
text without (n+1) patterns. This is profoundly disappointing,
because now that Haskell 1.3 is coming out, it seems
Alistair, I agree with Mike Gunter on this one. -- P
Mike Gunter writes:
The By functions in the 1.3 PreludeList (elemBy, deleteBy, etc.)
all take ``equality'' predicates with type a - a - Bool. Most of
these functions (with no change in definition that I see in a quick
Sebastian suggests using some syntax other than pattern
matching to express the isomorphism involved in a newtype.
I can't see any advantage in this.
Further, Simon PJ claims that if someone has written
data Age = Age Int
foo (Age n) = (n, Age (n+1))
that we want to be able to
Well, I'm glad to see I provoked some discussion!
Simon writes:
Lennart writes:
| So if we had
|
|data Age = Age !Int
|foo (Age n) = (n, Age (n+1))
|
| it would translate to
|
|foo (MakeAge n) = (n, seq MakeAge (n+1))
|
| [makeAge is the
The design of newtype appears to me incorrect.
The WWW page says that declaring
newtype Foo = Foo Int
is distinct from declaring
data Foo = Foo !Int
(where ! is a strictness annotation) because the former gives
case Foo undefined of Foo _ - True = True
and the
are there as well:
Imperative Functional Programming
Monads for Functional Programming
The Essence of Functional Programming
Comprehending Monads
Cheers, -- P
---
Professor Philip Wadler
---
Professor Philip Wadler[EMAIL PROTECTED]
Department of Computing Science tel: +44 141 330 4966
University of Glasgow fax: +44 141 330 4913
Glasgow G12 8QQ, SCOTLAND
In all of this, I neglected to mention *why* I think unlifted tuples
are a good idea. I've given various reasons, but not the real one.
The real one is: Embarassment. I wrote an implementation of linear
logic in Haskell. It took a while before I discovered why my
implementation got into a
It might help to recall some terminology from domain theory. I assume
here that all domains are pointed, i.e., have a bottom element. (John
Launchbury's note refer to a semantics with unpointed domains).
1. Products, a \times b.
These are unlifted products, with (\bot,\bot)=\bot, and with
Simon notes that lifted functions prevent certain optimisations, and
then Joe wonders if lifting tuples prevents optimisations. Arvind has
already answered this question. Unlifted tuples satisfy the type
isomorphism
(a,(b,c)) = (a,b,c)
which is heavily used for optimising Id, but
* My taste is that isomorphic possibly-abstract types should get a new kind
of type declaration (newtype, isotype, or whatever), perhaps defined to be
exactly equivalent to a algebraic data type with just one strict
constructor. But I don't feel strongly about this.
(At least
I've separated this from my previous note, because it's about the
precise question of strictness annotations rather than the more general
question of laws.
I would rather tell someone that to define a new type exactly
isomorphic to an old type they need to write
newtype Type =
If Lennart was asking, `Shall we make laws a paramount design feature
of Haskell, and therefore go for unlifted tuples, unlifted functions,
and no n+k or literal patterns', my answer would be `let's go for it'.
But I suspect what Lennart is really asking is `Shall we ignore laws,
have lifted
Paul writes,
I think it's important to realize that laws aren't being entirely
lost -- they're just being weakened a (wee) bit, in the form of
carrying an extra constraint. For example, eta conversion:
\x - f x = f
must simply be modified slightly:
\x -
John notes that recursive type synonyms may lead to less comprehensible
error messages. Good point!
As John says, experimentation would be a good idea. Any takers?
Cheers, -- P
Oops! I should have underlined in my last message where I wrote
`newtype' instead of `datatype'. As a result, Simon seems to have
completely misunderstood my proposal. Sorry about that.
Simon seems to think I am proposing that if one writes
datatype T a_1 ... a_k = C t_1 ... t_n
Gerald Ostheimer notes that in Abramsky and Ong's lazy lambda calculus
that (\x - bottom) differs from bottom. That's correct.
But just because they call it `lazy' doesn't mean that it really is
the essence of laziness. I prefer to use the more neutral name `lifted
lambda calculus' for their
it!
The obvious way to go is for someone to implement it first, to
make sure it's not difficult. Mark Jones, have you tried this
in Gofer yet?
Cheers, -- P
---
Professor Philip Wadler[EMAIL PROTECTED
---
Professor Philip Wadler[EMAIL PROTECTED]
Department of Computing Sciencetel: +44 41 330 4966
University of Glasgow fax: +44 41 330 4913
Glasgow G12 8QQ, SCOTLAND
Wadler[EMAIL PROTECTED]
Department of Computing Sciencetel: +44 41 330 4966
University of Glasgow fax: +44 41 330 4913
Glasgow G12 8QQ, SCOTLAND
Three cheers for Brian, for his work to keep Haskell a
living and growing entity.
I propose as a touchstone for 1.3 that they should only look
at extensions that have been incorporated in one or more
Haskell implementations. Hence the following are all good
candidates for 1.3's scrutiny:
Joe writes:
| Phil Writes:
|
| | The closest one can come is
| |
| |class G a where
| |g :: a - Bool
| |g x = g [x]
| |
| |instance G Int
| |instance G [Int]
| |instance G [[Int]]
| |...
| |
| |which requires an
Joe writes:
I forgot to mention that I did try it with hbc:
... transcript of working program omitted ...
That's surprising! I'd be interested to know if `maptry' works,
since in that case it makes sense to run the program, as well
as type it. Cheers, -- P
to define `maptrie'. On the other hand,
both ML and Haskell type classes admit the useful compiling
technique of transforming polymorphism to monomorphism; ML+ does
not.
Cheers, -- P
---
Philip Wadler
You are quite right. I'd forgotten about local rebinding,
because I feel that all local rebinding should be disallowed.
Anyone want to start a movement to eliminate local
rebinding? (1/2 :-) Cheers, -- P
- Begin Included Message -
From [EMAIL PROTECTED] Tue May 18 14:56:37 1993
Both (=) and (-) belong to classes defined in PreludeCore,
and hence cannot be rebound. This was a deliberate decision,
made in order to turn your point into a non-problem.
Long live (n+k)! -- P
- Begin Included Message -
From [EMAIL PROTECTED] Mon May 17 21:33:41 1993
From:
Given your correction, I think that the type declaration
data FooTree a b = Leaf b | Node a (FooTree a b) a (FooTree a b)
will handle things only a little less neatly than the use of
wrappers, and will allow you to use type inference in much the
way you wish. What do you think? Cheers,
Guy, You write,
But now suppose that some of the annotations refer to FooTree items
(another thing I forgot to say). I suppose I could do
data FooTree a b = Leaf b | Node a (FooTree a b)
a (FooTree a b)
Guy,
I agree that the report should be updated to express the restriction we
really have in mind. Simon: as editor, this is your bailiwick!
I also think its neat that you seem to have found a use for cyclic
unification. This is definitely an impetus to extend the language to
include cyclic
Included Message -
From [EMAIL PROTECTED] Thu Feb 18 17:21:56 1993
From: Guy Steele [EMAIL PROTECTED]
Date: Thu, 18 Feb 93 12:20:44 EST
To: wadler [EMAIL PROTECTED]
Cc: [EMAIL PROTECTED]
Subject: Re: Stupid Haskell question
Cc: [EMAIL PROTECTED], [EMAIL PROTECTED], [EMAIL PROTECTED],
[EMAIL
| I am part of a group working on a new language for Microwave hardware
| design (MHDL). As it turns out, we are incorporating almost all of
| Haskell 1.2 into it.
If there is anything written about this language, please send a pointer
to this mailing list; and please keep us appraised of your
Evan writes:
| Consider a polymorphic continuation request such as the following:
|
| someRequest :: T a - (U a - Dialogue)
and then shows this does not work in the stream model, unless one has
existential types.
Quite true, but note that there are *no* polymorphic IO functions!
At least,
! It is the responsibility of the programmer to enforce bounds
! checking when required in non-derived instances of class @Ix@.
! An implementation is not required to check that an index
! lies within the bounds of an array when accessing that array.
The above is fine by me, but here is a more
I gather the change you propose makes `div` consistent with
SML and Miranda, and uses `quo` for what Scheme calls `quotient`.
Sounds good to me. -- P
The function "exit" in PreludeIO would suit its purpose better if:
(a) It wrote to "stderr" rather than "stdout",
(b) It followed the error message with a newline.
Easy and quick to change! What do people think? (Especially Paul
and Joe.) -- P
Here is my current list of Haskell implementations.
If anyone has corrections or additions, please send them to me.
Cheers, -- P
HASKELL, Sun-3 and Sun-4
Glasgow Haskell
by Cordy Hall, Kevin Hammond, Will Partain, Simon Peyton Jones, Phil Wadler
compiler, implemented in Haskell, runs stand
(n+k) patterns are still causing difficulties in the syntax.
I would be happy with the following:
On a lhs, only allow (n+k) patterns in arguments.
Thus
n+1 = ...
is ALWAYS a definition of (+), but
f (n+1) =
case m of {n+1 - ...}
are still allowed.
RFC-822-HEADERS:
Original-Via:
==
We seem to be converging here. I prefer Simon's suggestion of
an appendix to Paul's suggestion of a Section 1.6, but am not
too bothered either way. Will also try to work in Simon's note
about file extensions. I am happy to leave the question
Despite Paul having ruled on the matter, the debate still rages, with
about half saying that is wonderful, and half saying it is awful.
Under these circumstances, Paul's ruling seems right: it is pointless
to legislate as part of the language.
On the other hand, the current circumstance is
87 matches
Mail list logo
