- Haskell-Cafe - Haskell.org

RE: "Lambda Dance", Haskell polemic, etc. on O'Reilly site
by Simon Marlow 30 Mar '01

30 Mar '01

> There are, perhaps good reasons for all these failures, but please > recognize them for what they are: failures to meet the needs of the > working programmer who just wants to get something done > (whether he/she > lives in YU, FR, JP, or US) > > I would love to be using Haskell for day to day programming work but I > can't at this time. Unless the community recognizes what is > required and > gets it done, I never will. There is one good reason that Haskell fails in these areas, and that's shortage of effort. We in the GHC team are actively trying to encourage our users to contribute: with an open CVS source tree, open development mailing lists, etc. We've had some good results (thanks to our developers!), but we need more. GHC is a large and complex system, and with trying to be all things to all people - a research vehicle / experimentation platform / production compiler, our developer resources are stretched a bit thin. I'm sure this goes for the other Haskell systems too. I see libraries as the biggest missing piece in the Haskell language. Let's face it, Joe Programmer isn't going to pass Haskell by just because it doesn't support a particular flavour of overlapping instance declarations. But he might if it doesn't have a networking library, or unicode support, or an XML parser. Please, join libraries(a)haskell.org. </rant> Cheers, Simon

1 0

"Lambda Dance", Haskell polemic, etc. on O'Reilly site
by Fritz K Ruehr 30 Mar '01

30 Mar '01

Forgive me if the following links were announced here and I just missed them. I found them through the O'Reilley Meerkat "Open Wire Service", in the "Lambda" channel of the "Lang" category (see: <http://www.oreillynet.com/meerkat/index.php?&c=4623&t=ALL> ). The first link is the "Lambda Dance" page, presumably inspired by the infamous "Hamster Dance" (if you don't know the latter, you are better off for it, so don't ask): <http://lambdadance.spacebar.org/> "Beta-reduce the night away", as the site says! The second link is a little polemic entitled "Why People Aren't Using Haskell", which I presume would be of interest to readers of this list (the author is Dejan Jelovic, whom I don't recognize as a regular contributor here): <http://www.jelovic.com/articles/why_people_arent_using_haskell.htm> There are several other interesting looking links on the Meerkat site ("Moving FP from Academia", "Object Functional Patterns", etc.), but I will let you investigate on your own. Enjoy ... -- Fritz Ruehr, still humming to the lambda dance

3 2

Printed Haskell 98 Report
by Mark Carroll 29 Mar '01

29 Mar '01

I don't suppose it's possible to get a reasonable printed copy of the Haskell 98 Report and Haskell 98 Library Report at a sensible price, is it? Just wondering, before I go pricing printing and binding. Thanks. -- Mark

2 1

(no subject)
by Atenea Azcue 28 Mar '01

28 Mar '01

Hello My name is Atenea . I just want to ask you that how can i Creat a program that just say "hello word" and another that can add a "matrix" if you can help me I would really going to apreciate please. Thank you for your listening --------------------------------- Do You Yahoo!? Yahoo! Mail Personal Address - Get email at your own domain with Yahoo! Mail.

2 1

(no subject)
by Atenea Azcue 28 Mar '01

28 Mar '01

Hello My name is Atenea : I�m what to ask you who can I make a program in haskell like une program that say hello word --------------------------------- Do You Yahoo!? Yahoo! Mail Personal Address - Get email at your own domain with Yahoo! Mail.

2 1

Re: the constant functor
by Tom Pledger 28 Mar '01

28 Mar '01

Tobias Haeberlein writes: | | > What is wrong with: | > | > class Functor ConstInt where | > map f (Const n) = Const n | | Ups - absolutely nothing. | I actually tried it with | | data ConstInt a = Int This version doesn't refer to the type Int. Instead, it introduces a new nullary data constructor called Int, which you could use like this: instance Functor ConstInt where fmap f Int = Int ...but I don't think that's what you were after. If you use a type alias (type ConstInt a = Int) instead of declaring a data type, it will refer to the type Int. However, then you'd need to use ConstInt partially applied in the instance declaration, which Haskell doesn't allow. I think Gofer has a more liberal type system which does allow it. | and didnt manage to make this an instance of | class Functor. Sorry for giving the wrong | example.

1 0

Re: the constant functor
by Koen Claessen 27 Mar '01

27 Mar '01

(moved reply to haskell-cafe) Hi Tobias, | data ConstInt a = Const Int | | Any ideas how to make 'ConstInt' an instance of class | Functor? What is wrong with: class Functor ConstInt where map f (Const n) = Const n ? /Koen. -- Koen Claessen http://www.cs.chalmers.se/~koen phone:+46-31-772 5424 mailto:koen@cs.chalmers.se ----------------------------------------------------- Chalmers University of Technology, Gothenburg, Sweden

1 0

Re: Linearity Requirement for Patterns
by Michael Hanus 23 Mar '01

23 Mar '01

Fergus Henderson wrote: > My understanding, from talking with Michael Hanus a few years ago, is > that Curry is not referentially transparent, in the sense that you can't > replace equals with equals, because it permits nondeterministic functions. > In particular, `let x = f y in g x x' is not the same as `g (f y) (f y)' > in Curry. Of course, as you already mentioned, one has te be very precise when talking about referential transparency. In particular, one has to say what "equals" mean. Otherwise, one could also argue that Haskell is not referential transparent: if a Haskell program has a defining equation "f 1 = 1", the expressions "(f 1)" and "1" might not be identical (if there is another equation like "f x = 0" before). In Curry, each defining equation contributes to the semantics of a function independently of the other equations for the same function, and the overall goal is to compute all values of an expression (plus possible substitutions for free variables) which can be derived from this equational reading of all rules. In this sense, Curry is refentially transparent (although I have no formal definition of this notion but only soundness, completeness and optimality results). Your "counter example" comes from a misunderstanding of the "let" in Curry. Since the kernel language is based lazy evaluation w.r.t. a set of constructor-based rewrite rules, the "let" is considered as syntactic sugar for abbreviating some function argument. For instance, the meaning of the definition h = let x = f y in g x x is defined as an abbreviation for the rules h = aux (f y) aux x = g x x W.r.t. this semantics, there is no problem even with non-deterministic functions. If you have a precise definition of "referentially transparent" at hand so that you can make your statement more precise, I would be very interested to read it. As you have seen, the slogan "replacing equals by equals" is still to fuzzy since just looking for equality symbols in a language is not sufficient. Michael

4 3

Re: Linearity Requirement for Patterns
by Michael Hanus 22 Mar '01

22 Mar '01

Bjorn Lisper wrote: > >some function argument. For instance, the meaning of the definition > > > > h = let x = f y in g x x > > > >is defined as an abbreviation for the rules > > > > h = aux (f y) > > aux x = g x x > > > >W.r.t. this semantics, there is no problem even with non-deterministic > >functions. > > How does sharing work here? I assume the "let x = ..." is intended to mean > sharing of "...". Does the same hold for function calls in Curry, so > "aux x = g x x" implies sharing of x when evaluating g? In that case I Yes. Since Curry is based on a lazy and (for a particular subclass, namely inductively sequential rules) also optimal evaluation strategy, sharing of function arguments is required and essential. > suspect you might have problems if, for instance, you inline aux naively > into g (f y) (f y) and f is nondeterministic. (Inlining should typically > work for a referentially transparent language.) The problem can be fixed > though: if you have this sharing, then "aux x = g x x" is really shorthand > for "aux x = let y = x in g y y". If this definition is inlined and the let > is kept (to preserve the sharing), then the transformation should work even > if f is nondeterministic. In the presence of nondeterministic functions (i.e., nonconfluent rules), one has several options for the semantics. For parameter passing, one can use either the call-time choice or run-time choice semantics. Curry is based on the former since there is a well-defined semantical framework for this in the presence of non-strict functions (Gonzalez-Moreno et al., Journal of Logic Programming, Vol. 40, 1999). Semantically, the call-time choice means that rewrite rules can only be applied if the arguments are constructor terms, i.e., totally evaluated. This does not necessarily imply a strict semantics since it can be implemented by lazy reduction provided that function arguments are shared. Thus, this sharing must be somehow represented in an intermediate language for executing the programs and on this level inlining is preserved, as you have remarked. Naive inlining (i.e., without lets but possibly duplicating function calls) does only work for deterministic functions (which is no restriction from a Haskell point of view since Haskell allows only deterministic functions). > I don't know how much of this applies directly to Curry, since the above is > for pure term rewriting and I suspect Curry has unification in its > evaluation mechanism (right?) which then makes the evaluation more > complex. But maybe the above can provide some ideas how to formally define > referential transparency for Curry? The paper mentioned above defines a proof calculus, model theory and operational semantics for this language where the denotation of functions distinguish between deterministic and non-deterministic functions which seems to be conform to your remarks. Although it does not explicitly define referential transparancy, it shows the equivalence of all three notions which I think is enough for reasoning about Curry programs. Nevertheless, many thanks for your hints. Michael

1 0

Re: Linearity Requirement for Patterns
by Michael Hanus 22 Mar '01

22 Mar '01

Lennart Augustsson wrote: > Yes, your definition of non-linear patterns would give you extra > power. It would also destroy the nice semantics of Haskell! > By using this facility you can now observe intensional properties > of the term, and the clean denotational semantics crumbles. > > E.g., in Haskell you can always replace equals by equals without > changing the meaning of a program. In your example `g 0' is equal > to bottom so it should be possible to replace it by any other bottom > without any change in meaning. But if I define > h x = h x > and evaluate `f (g 0) (h 0)' I will no longer get 0. > > So this definitions of non-linear patterns is not an option for a > language that claims to be "referentially transparent" (whatever that means :). I agree and the question is about "whatever that means"... Term rewriting systems (TRS) are based on replacing equals by equals and that could be also considered as "referentially transparent". Nevertheless, TRSs usually allow non-linear left-hand sides (but often come with other restrictions like termination). BTW, (g 0) and (h 0) are not considered as equal since there are no rules/equations to transform one into the other. However, I agree that there are good reasons (mainly, operational simplicity) to allow only linear patterns and constructor-based rules in a real programming language, since non-linear patterns or non-constructor-based rules require other and more advanced operational principles. I only wanted to remark that there is no simple way to translate non-linear pattterns into linear patterns in the general case. Michael

4 3