- Haskell-Cafe - Haskell.org

Some random newbie questions
by Derek Elkins 07 Jan '05

07 Jan '05

> OK, I'm taking the plunge and using Haskell in a course I'm teaching > this semester. To get ready, I've been doing quite a bit of Haskell > programming myself, and this has raised a few questions... > > * What are the relative advantages of Hugs and GHC, beyond the obvious > (Hugs is smaller and easier for people not named Simon to modify, > while GHC is a real compiler and has the most up-to-date hacks to > the type checker)? Do people generally use one or the other for > everything, or are they similar enough to use Hugs at some moments and > GHC at others? All the below is my personal opinion: My impression is that GHC is by far the most used Haskell implementation. In my opinion, the only reason Hugs should be used is if it's the only implementation that will run on your system, otherwise GHC or NHC will likely make a better choice. Some of the differences between GHC and the last version of Hugs I've looked at are: 1) GHCi views it's repl as being in a do-block, with the most important consequence being the ability to define functions interactively, Hugs views the input as an expression so functions can only be defined locally. Neither are rather impressive interactive environments (not when compared to Squeak or CL listeners), but GHCi's is definitely more convenient. 2) GHC is generally acknowledged to do a (significantly) better job with error messages (both type and run-time errors). To me, the difference is so significant that, all other things being equal, GHC would still win hands-down. 3) Most development of third-party libraries and tools target GHC first, part of that has to do with 4) Beyond enhancements to type checking, GHC has many other extensions such as: template haskell, preemptive concurrency (Hugs does have cooperative concurrency), asynchronous exceptions, built-in arrow notation, support for generics, and more. 5) And of course, (3) is also caused by second order effects of itself, e.g. Yi uses GHC because it uses hs-plugins which is intimately related to GHC. 6) GHC has support for profiling.

1 0

The implementation of Functional
by robert dockins 06 Jan '05

06 Jan '05

The following discussion occurred last September. Is there any kind of update on any version of this book? ----------------------------------------- John Meacham writes: > > >I am looking for the book "The implementation of Functional > > >Programming languages" by S. L. Peyton Jones. > > This book is out of print and currently there is no electronic version > > of it. The Haskell bookstore folk are working on reconstructing it and > > making it available for print-on-demand, > > http://www.cafepress.com/haskell_books/, but it's not clear when > > exactly it will be available. > > > > Your other option is to try to find a used copy, but they are pretty > > expensive. > > I am working on getting that book available in the haskell bookstore. I > searched quite a while before I found a used printed copy at a > reasonable price and my search was part of my motivation for creating > the bookstore. > > It is a bit trickier than the other books on the site because I only > have a scanned in copy of the print version to work with, rather than > LaTeX source. but I should have time this week to get it online. > John My wife (mainly) and I, with Simon's permission, have been working on getting a web-enabled version of this available for quite some time. It hovers on the brink of completion, and should be there Real Soon Now as well. This will include a web enabled table of contents and next and back buttons. If I'd known how much time she would put in, I'd have never asked her for "a small favor"....... Dave Barton EDAptive Computing

2 1

urls
by Tristan Wibberley 06 Jan '05

06 Jan '05

http://research.microsoft.com/Users/simonpj/papers/assoc-types/index.htm http://www.haskell.org/hawiki/GHC_206_2e4

1 1

Begginer question
by Maurício 06 Jan '05

06 Jan '05

Hi, When compiling this: ************ import Complex; complex_root :: (Float, Float, Float) -> (Complex Float, Complex Float) complex_root (a,b,c) = (x1,x2) where { delta = b * b - 4 * a * c :: Float; sqr_delta = if delta >= 0 then (sqrt delta) :+ 0 else 0 :+ (sqrt delta) :: (Complex Float); x1 = (b + sqr_delta)/(2 * a); x2 = (b - sqr_delta)/(2 * a); } *********** I get this error message: ********** Couldn't match `Float' against `Complex Float' Expected type: Float Inferred type: Complex Float In the second argument of `(+)', namely `sqr_delta' In the definition of `x1': x1 = (b + sqr_delta) *********** Can you help me finding what is wrong? Shouldn't "b" be converted to Complex Float and be summed to sqr_delta? Thanks for your help, Maurício

5 7

RE: [Haskell-cafe] Seeking comments on this IO proposal
by Simon Marlow 06 Jan '05

06 Jan '05

On 17 December 2004 16:49, John Goerzen wrote: > First, if someone were to make a working, useful package out of this, > is it likely that it would become the "standard" (whatever that > means) IO system in Haskell anytime in the near future? I ask > because I don't want to put a lot of time into developing an IO > library, and code that works with it, only to have nobody use my code > because it's incompatible with everything they're doing. I'm keen to transition over to a more general IO framework, and I believe Bens/my proposal is heading in the right direction. When we have a more complete implementation, I'd be happy to include it with GHC for experimentation, and over time transition code to use the new framework while leaving the old System.IO in place for the time being. The design isn't by any means set in stone at this stage though. > Second is my own level of expertise. I frankly don't understand how > much of that code could even compile (example: I couldn't find > setNonBlockingFD anywhere in my docs; maybe it's from one of those > GHC.* areas), and I don't really understand the whole array/buffer > situation either. I spent some time reading docs, and I'm still not > sure exactly how one builds a mutable, resiable array. I've also > never done anything but the most trivial FFI work. Much of the reason for the complexity is because I was paying careful attention to performance (perhaps too much attention). I don't want the addition of a text encoding/decoding layer to the IO subsystem to affect performance more than is necessary, and that means doing the translation on raw character buffers rather than strings. Unfortunately this does mean that porting to other compilers is going to be more work. Cheers, Simon

1 0

RE: [Haskell-cafe] Re: Utility functions
by Simon Marlow 06 Jan '05

06 Jan '05

On 06 January 2005 12:20, Ketil Malde wrote: > "Simon Marlow" <simonmar(a)microsoft.com> writes: > >> There are already a couple of bits of (L)GPL under fptools: GMP and >> readline. GMP we'd like to replace because it is necessarily a part >> of every compiled Haskell program; readline isn't so important but >> it would be nice to have a BSD-licensed replacement. > > Readline is GPL and GMP LGPL, aren't they? Yes. > So GMP only restricts > what you can do with modifications to that library (and thus only > affects developers who want to release a modified GHC without source), > while linking with readline will potentially affect regular users of > GHC. Strictly speaking you have to dynamically link GMP to avoid your program being affected by the LGPL. Most GHC installations use a dynamically linked GMP, but some do not. Readline's license affects GHC (because GHC itself links with it), but it doesn't affect programs you compile with GHC unless you explicitly request the readline package (unlike GMP, which is always linked in). Cheers, Simon

1 0

RE: [Haskell-cafe] Re: Utility functions
by Simon Marlow 06 Jan '05

06 Jan '05

On 30 December 2004 05:25, Philippa Cowderoy wrote: > On Wed, 29 Dec 2004, John Goerzen wrote: > >> But like I've said, I am willing to negotiate with people that >> require code under a license that lets them use it without releasing >> the code. I have also stated that I will put any part of the code >> I've written under the fptools license if that code will be added to >> fptools. (I perceive that as a greater good than license pragmatism >> in this instance.) > > This is the bit I was worried about, the idea of GPLed library code in > fptools disturbs me somewhat. There are already a couple of bits of (L)GPL under fptools: GMP and readline. GMP we'd like to replace because it is necessarily a part of every compiled Haskell program; readline isn't so important but it would be nice to have a BSD-licensed replacement. The policy for Haskell libraries in fptools is that licenses are assigned no finer than package granularity, so that a user of a package can have a reasonable chance of telling whether they are complying with the relevant licenses. Cheers, Simon

2 1

Initial (term) algebra for a state monad
by oleg＠pobox.com 06 Jan '05

06 Jan '05

Andrew Bromage wrote: << -- WARNING: This code is untested under GHC HEAD data State s a = Bind :: State s a -> (a -> State s b) -> State s b | Return :: a -> State s a | Get :: State s s | Put :: s -> State s () instance Monad (State s) where (>>=) = Bind return = Return instance MonadState s (State s) where get = Get put = Put runState :: State s a -> s -> (s,a) runState (Return a) s = (s,a) runState Get s = (s,s) runState (Put s) _ = (s,()) runState (Bind (Return a) k) s = runState (k a) s runState (Bind Get k) s = runState (k s) s runState (Bind (Puts) k) _ = runState (k ()) s runState (Bind (Bind m k1) k2) s = runState m (\x -> Bind (k1 x) k2) s >> The following is the code that does run, on GHC 6.2.1. Typeclasses are just as good at pattern-matching as (G)ADT, and GHC is quite good at suggesting the constraints that I have missed. The latter comes quite handy when one programs half-asleep. {-# OPTIONS -fglasgow-exts #-} {-# OPTIONS -fallow-undecidable-instances #-} module B where import Control.Monad import Control.Monad.State hiding (runState) -- data State s a -- = Bind :: State s a -> (a -> State s b) -> State s b -- | Return :: a -> State s a -- | Get :: State s s -- | Put :: s -> State s () class RunBind t s a => RunState t s a | t s -> a where runst :: t -> s -> (s,a) data Bind t1 t2 = Bind t1 t2 data Return t = Return t data Get = Get data Put t = Put t instance RunState (Return a) s a where runst (Return a) s = (s,a) instance RunState Get s s where runst _ s = (s,s) instance RunState (Put s) s () where runst (Put s) _ = (s,()) instance (RunState m s a, RunState t s b) => RunState (Bind m (a->t)) s b where runst (Bind m k) s = runbind m k s class RunBind m s a where runbind :: RunState t s b => m -> (a->t) -> s -> (s,b) instance RunBind (Return a) s a where runbind (Return a) k s = runst (k a) s instance RunBind (Get) s s where runbind Get k s = runst (k s) s instance RunBind (Put s) s () where runbind (Put s) k _ = runst (k ()) s instance (RunBind m s x, RunState y s w) => RunBind (Bind m (x->y)) s w where runbind (Bind m f) k s = runbind m (\x -> Bind (f x) k) s data Statte s a = forall t. RunState t s a => Statte t instance RunState (Statte s a) s a where runst (Statte t) s = runst t s instance RunBind (Statte s a) s a where runbind (Statte m) k s = runbind m k s instance Monad (Statte s) where (Statte m) >>= f = Statte (Bind m (\x -> f x)) return = Statte . Return instance MonadState s (Statte s) where get = Statte Get put = Statte . Put test1 (a::a) = runst (do x <- (return a :: Statte Char a) y <- get put 'b' return (y,x)) 'a' test1' = test1 "ok" test2 = runst (return True :: Statte Char Bool) 'a'

4 3

Tutorial for server programming in concurrent Haskell
by Ahn Ki-yung 05 Jan '05

05 Jan '05

I've recently started a small tutorial for server programming in concurrent Haskell. http://kyagrd.dyndns.org/wiki/HaskellServerProgramming For newbies in Haskell and/or server programming, there should be an interoductory tutorial with concrete and simple examples before Simon Marlow's papers about web server implementation in Haskell. This tutorial consists of two famous examples, Echo and Chat, with the source code and makefile to be downloaded, compliled and tested right away. I hope this could be some helpt to those who want to start server programming in Haskell. Server programming in modern fucntional language with concurrency support is a real pleasure! You should also try Erlang if you havnt' tried yet.

2 1

Re: [Haskell-cafe] ReadS with Maybe
by Jon Cast 05 Jan '05

05 Jan '05

Henning Thielemann <lemming(a)henning-thielemann.de> wrote: > What is the reason for the definition > ReadS a = [(a, String)] > not being > ReadS a = Maybe (a, String) > ? The latter one reflects that either one or no value is read, whereas > the first definition allows an arbitrary number of read values which > is confusing and unsafe in my opinion. List is a backtracking monad, while Maybe is merely an error monad. You have to have backtracking to bet better than LL(1) or LR(1) parsing, and LL(1) is not an acceptable restriction for a fundamental function like read. Jonathan Cast

1 0