- Haskell-Cafe - Haskell.org

Re: [newbie] Lazy >>= ?!
by Scott Turner 17 Feb '01

17 Feb '01

Andrew Cooke wrote: >2. Why does the following break finite lists? Wouldn't they just >become lazy lists that evaluate to finite lists once map or length or >whatever is applied? > >> Now, if this were changed to >> ~(x:xs) >>= f = f x ++ (xs >>= f) >> (a lazy pattern match) then your listList2 would work, but finite >> lists would stop working. They wouldn't just become lazy lists. A "lazy" pattern match isn't about removing unnecessary strictness. It removes strictness that's necessary for the program to function normally. A normal pattern match involves selecting among various patterns to find the one which matches; so it evaluates the expression far enough to match patterns. In the case of (x:xs) it must evaluate the list sufficiently to know that it is not an empty list. A lazy pattern match gives up the ability to select which pattern matches. For the sake of less evaluation, it opens up the possibility of a runtime error, when a reference to a named variable won't have anything to bind to. The list monad is most often used with complete finite lists, not just their initial portions. The lazy pattern match shown above breaks this because as it operates on the list, it assumes that the list is non-empty, which is not the case when the end of the list is reached. A runtime error is inevitable. -- Scott Turner p.turner(a)computer.org http://www.billygoat.org/pkturner

1 0

Revised numerical prelude, version 0.02
by Dylan Thurston 17 Feb '01

17 Feb '01

Here's a revision of the numerical prelude. Many thanks to all who helped. Changes include: * Removed "Powerful", replacing it with (^) in Num and (**) in Real. * Fixed numerous typos * Removed gcd and co. from Integral * Added shortcomings & limitation of scope * Added SmallIntegral, SmallReal * wrote skeleton VectorSpace, PowerSeries * Added framework to make it run under hugs. There are some usability issues. Any comments welcome! Best, Dylan Thurston

10 12

RE: Primitive types and Prelude shenanigans
by Simon Peyton-Jones 16 Feb '01

16 Feb '01

| On Mon, Feb 12, 2001 at 02:38:25PM -0800, William Lee Irwin III wrote: | > I had in mind looking within the compiler, actually. Where in the | > compiler? It's a big program, it might take me a while to do an | > uninformed search. I've peeked around a little bit and not gotten | > anywhere. | | If anyone else is pursuing thoughts along the same lines as I | am (and I | have suspicions), TysWiredIn.lhs appears quite relevant to the set of | primitive data types, though there is no obvious connection to the | module issue (PrelBase.Bool vs. Foo.Bool). PrelMods.lhs | appears to shed | more light on that issue in particular. $TOP/ghc/compiler/prelude/ was | the gold mine I encountered. Perhaps I should add something here. I'm very sympathetic to the idea of making it possible to do entirely without the standard Prelude, and to substitute a Prelude of one's own. The most immediate and painful stumbling block in Haskell 98 is that numeric literals, like 3, turn into (Prelude.fromInt 3), where "Prelude.fromInt" really means "the fromInt from the standard Prelude" regardless of whether the standard Prelude is imported scope. Some while ago I modified GHC to have an extra runtime flag to let you change this behaviour. The effect was that 3 turns into simply (fromInt 3), and the "fromInt" means "whatever fromInt is in scope". The same thing happens for - numeric patterns - n+k patterns (the subtraction is whatever is in scope) - negation (you get whatever "negate" is in scope, not Prelude.negate) (Of course, this is not Haskell 98 behaviour.) I think I managed to forget to tell anyone of this flag. And to my surprise I can't find it any more! But several changes I made to make it easy are still there, so I'll reinstate it shortly. That should make it easy to define a new numeric class structure. So much for numerics. It's much less obvious what to do about booleans. Of course, you can always define your own Bool type. But we're going to have to change the type that if-then-else uses, and presumably guards too. Take if-then-else. Currently it desugars to case e of True -> then-expr False -> else-expr but your new boolean might not have two constructors. So maybe we should simply assume a function if :: Bool -> a -> a -> a and use that for both if-then-else and guards.... I wonder what else? For example, can we assume that f x | otherwise = e is equivalent to f x = e That is, "otherwise" is a guard that is equivalent to the boolean "true" value. ("otherwise" might be bound to something else if you import a non-std Prelude.) If we don't assume this, we may generate rather bizarre code: f x y | x==y = e1 | otherwise = e2 ===> f x y = if (x==y) e1 (if otherwise e2 (error "non-exhaustive patterns for f")) And we'll get warnings from the pattern-match compiler. So perhaps we should guarantee that (if otherwise e1 e2) = e1. You may say that's obvious, but the point is that we have to specify what can be assumed about an alien Prelude. Matters get even more tricky if you want to define your own lists. There's quite a lot of built-in syntax for lists, and type checking that goes with it. Last time I thought about it, it made my head hurt. Tuples are even worse, because they constitute an infinite family. The bottom line is this. a) It's desirable to be able to substitute a new prelude b) It's not obvious exactly what that should mean c) And it may not be straightforward to implement It's always hard to know how to deploy finite design-and-implementation resources. Is this stuff important to a lot of people? If you guys can come up with a precise specification for (b), I'll think hard about how hard (c) really is. Simon

5 9

Re: Just for your fun and horror
by C.Reinke 16 Feb '01

16 Feb '01

> `return' in Haskell vs `return' in C,... Unless you're one of Asimov's technicians of eternity, it is a bit difficult to change the history of programming languages, and assuming that the students pay for the opportunity to learn, you can't really fire them either.. but I agree with Mathias' suggestion to go from the specific to the general. Before anyone complains that abstract and generalised concepts are so much more important and powerful that specific and simplified instances - if you believe this, you will also agree that giving students a chance to learn the general process of abstraction for themselves is more important and empowering than teaching them some specific abstractions. (I'm not sure whether it is even possible to reach all students in a course, but I will certainly not recommend to give up trying;-) One way to look at the problem is that some of your students have concrete experience with `return' in different contexts, and that Haskell tries to make different things look similar here. You say "we worked with monads for several weeks" but, you being yourself, this was probably at a fairly abstract and general level, right? My suggestion is to give your students some concrete experience to counter the one they bring into your course, by introducing the abstract monads via an intermediate step of concrete representations. As you're teaching programming language implementation anyway, why not have an algebraic datatype with return and bind *constructors*, together with some explicit *interpreters* (plural) for the language of structures built from those constructors (even as student exercises)? Perhaps we can gain a better understanding of the student perspective if we compare the situation with lists or other data structures: do we start teaching their folds and the fold-representation of data structures right away, or do we start with concrete intermediate structures, and move on to folds and deforestation later? Of course, with a concrete representation of monads, it is difficult to hold up the law, so after this intermediate step (in which students get their hands on `return' et.al., and in which interpreters can interpret `return a' in any way they please), one can move on to an abstract data type of monads. After all, that's what abstract data types are there for. Hth, Claus

1 0

Re: Just for your fun and horror
by Steinitz, Dominic J 16 Feb '01

16 Feb '01

I always liked unit rather than return. Dominic. ------------------------------------------------------------------------------------------------- 21st century air travel http://www.britishairways.com

1 0

Re: Primitive types and Prelude shenanigans
by Ketil Malde 16 Feb '01

16 Feb '01

William Lee Irwin III <wli(a)holomorphy.com> writes: > Some analysis of the value of the literal would need to be > incorporated so that something like the following happens: > literal "0" gets mapped to zero :: AdditiveMonoid t => t > literal "1" gets mapped to one :: MultiplicativeMonoid t => t Indeed. Is it a reasonable assumption that all values of literal "0" are intended to be the additive identity element? How about "1", might we not have it as a successor element in a group, where multiplication isn't defined? I guess other behaviour (e.g. using implicit fromInteger) assumes even more about the classes that can be represented by literal numbers, so it appears this would be an improvement, if it is at all workable. > literal "5" gets mapped to (fromPositiveInteger 5) Is something like (fromInteger 5) *> one (where *> is Module scalar multiplication from the left? Could we avoid having lots and lots of from* functions? I guess having to declare any datatype as Module is as bad as the explicit conversion functions... Anyway, I like it, especially the zero and one case. > I think Dylan Thurston's proposal is probably the best starting point > for something that should really get support. Indeed. How far are we from being able to import it, e.g. with "import DTlude as Prelude" or whatever mechanism, so that we can start to play with it, and see how it works out in practice? -kzm -- If I haven't seen further, it is by standing in the footprints of giants

1 0

RE: need help w/ monad comprehension syntax
by Konst Sushenko 15 Feb '01

15 Feb '01

thanks, did not know that. the articles that i read are outdated in that respect... using the "do" notation is just fine. with the list notation not working i thought that i musunderstand something about monads. ;-) konst -----Original Message----- From: Tom Pledger [mailto:Tom.Pledger@peace.com] Sent: Thursday, February 15, 2001 5:22 PM To: haskell-cafe(a)haskell.org Subject: need help w/ monad comprehension syntax Konst Sushenko writes: | what am i missing? : | > --g :: State String Char | > g = [ x | x <- return 'a' ] Hi. The comprehension syntax used to be for monads in general (in Haskell 1.4-ish), but is now (Haskell 98) back to being specific to lists. Does it help if you use do-notation instead? Regards, Tom _______________________________________________ Haskell-Cafe mailing list Haskell-Cafe(a)haskell.org http://www.haskell.org/mailman/listinfo/haskell-cafe

1 0

need help w/ monad comprehension syntax
by Konst Sushenko 15 Feb '01

15 Feb '01

hello, i am having trouble getting my program below to work. i think i implemented the monad methods correctly, but the function 'g' does not type as i would expect. Hugs thinks that it is just a list (if i remove the explicit typing). i want it to be functionally identical to the function 'h'. what am i missing? thanks konst > newtype State s a = ST (s -> (a,s)) > > unST (ST m) = m > > instance Functor (State s) where > fmap f m = ST (\s -> let (a,s') = unST m s in (f a, s')) > > instance Monad (State s) where > return a = ST (\s -> (a,s)) > m >>= f = ST (\s -> let (a,s') = unST m s in unST (f a) s') > > --g :: State String Char > g = [ x | x <- return 'a' ] > > h :: State String Char > h = return 'a'

2 1

Downloading Hugs
by zulf jafferi 15 Feb '01

15 Feb '01

hi, I tried to download the Hugs 98.after downloading Hugs 98,when i try to click on the Hugs icon it gives me an error saying COULD NOT LOAD PRELUDE.i am using Windows 2000. I would be much obliged if you could help me solve the problem. cheers!! _________________________________________________________________________ Get Your Private, Free E-mail from MSN Hotmail at http://www.hotmail.com.

1 0

Re: framework for composing monads?
by Jan Kort 15 Feb '01

15 Feb '01

Andy Gill's Monad Template Library is good for that, but the link from the Haskell library page is broken: http://www.cse.ogi.edu/~andy/monads/doc.htm Jan

1 0