May 2003 - Haskell - Haskell.org

Enum on Float/Double
by George Russell 23 Oct '03

23 Oct '03

The situation with Enum on Ratio is pretty bad but at least it's not hopeless, since rational numbers are at least exact. But for Float/Double it seems to be a total disaster area. Since it seems to be impossible to abolish Enum Float/Double altogether, would it at least be possible to make it rather more useful, by making succ x return the next representable float after x (or x if x is non-finite) and pred x the previous representable float. This would (a) be useful; (b) make mathematical sense; (c) is tricky to implement with the existing primitives. Before someone else points it out, this is of course unimplementable should someone in the future implement infinite-precision reals in Haskell, but as (barring a solution to the halting problem) Eq would be as well, that does not bother me. My preference would be for succ (+-0) to return the smallest positive real, since then you could define succ x to be the unique y with x < y and forall z . z < y => not (x < z), where such a y exists, and I'm not sure if the Haskell standard knows about signed zeros. Feri wrote > Everybody working with floats should know their quirks While in an ideal world, everyone who represented a mouse position or anything else as a float should have a PhD in numerical analysis, in practice they do not. Indeed I think the Haskell Library Report contains quite a few examples of floating point code which a numerical analyst would have written rather better. So I don't think it's good enough to treat every Float/Double operation as if it had an implicit "UNSAFE" flag indicating that the compiler was entitled to wierd behaviour only comprehensible to experts, as seems to be the case with floating enumerations now.

8 11

ANNOUNCE: GHC version 6.0
by Simon Marlow 13 Jun '03

13 Jun '03

============================================================ The (Interactive) Glasgow Haskell Compiler -- version 6.0 ============================================================ We are pleased to announce a new major release of the Glasgow Haskell Compiler (GHC), version 6.0. As with all ".0" releases, this release should be considered beta-quality; if you want real stability, then stick with 5.04.3 for the time being. Highlights of this release include: * Template Haskell, a new metaprogramming extension. * More hierarchical libraries. * Conformance with the latest FFI specification. * Sweeping internal changes to switch the evaluation model from "push/enter" to "eval/apply". See the release notes for a full list of the changes: http://www.haskell.org/ghc/docs/latest/html/users_guide/release-6-0.html How to get it ~~~~~~~~~~~~~ The easy way is to go to the WWW page, which should be self-explanatory: http://www.haskell.org/ghc/ We supply binary builds in the native package format for various flavours of Linux and BSD, and in Windows Installer (MSI) form for Windows folks. Binary builds for other platforms are available as a .tar.gz which can be installed wherever you want. The source distribution is also available from the same place. Packages will appear as they are built - if the package for your system isn't available yet, please try again later. Background ~~~~~~~~~~ Haskell is a standard lazy functional programming language; the current language version is Haskell 98, agreed in December 1998, and revised in December 2002. GHC is a state-of-the-art programming suite for Haskell. Included is an optimising compiler generating good code for a variety of platforms, together with an interactive system for convenient, quick development. The distribution includes space and time profiling facilities, a large collection of libraries, and support for various language extensions, including concurrency, exceptions, and foreign language interfaces (C, whatever). GHC is distributed under a BSD-style open source license. A wide variety of Haskell related resources (tutorials, libraries, specifications, documentation, compilers, interpreters, references, contact information, links to research groups) are available from the Haskell home page (see below). On-line GHC-related resources ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Relevant URLs on the World-Wide Web: GHC home page http://www.haskell.org/ghc/ Haskell home page http://www.haskell.org/ comp.lang.functional FAQ http://www.cs.nott.ac.uk/~gmh/faq.html System requirements ~~~~~~~~~~~~~~~~~~~ To compile programs with GHC, you need a machine with 64+MB memory, GCC and perl. This release is known to work on the following platforms: * i386-unknown-{linux,*bsd,mingw32} * sparc-sun-solaris2 * alpha-dec-osf3 * powerpc-apple-darwin (MacOS/X) Ports to the following platforms should be relatively easy (for a wunderhacker), but haven't been tested due to lack of time/hardware: * hppa1.1-hp-hpux{9,10} * i386-unknown-solaris2 * mips-sgi-irix{5,6} * {rs6000,powerpc}-ibm-aix The builder's guide on the web site gives a complete run-down of what ports work; it can be found at http://www.haskell.org/ghc/docs/latest/html/building/building-guide.html Mailing lists ~~~~~~~~~~~~~ We run mailing lists for GHC users and bug reports; to subscribe, use the web interfaces at http://www.haskell.org/mailman/listinfo/glasgow-haskell-users http://www.haskell.org/mailman/listinfo/glasgow-haskell-bugs There are several other haskell and ghc-related mailing lists on www.haskell.org; for the full list, see http://www.haskell.org/mailman/listinfo/ Please report bugs using our SourceForge page at http://sourceforge.net/projects/ghc/ or send them to glasgow-haskell-bugs(a)haskell.org. GHC users hang out on glasgow-haskell-users(a)haskell.org. Bleeding edge CVS users party on cvs-ghc(a)haskell.org.

5 7

ANN: H98 FFI Addendum 1.0, Release Candidate 10
by Manuel M T Chakravarty 12 Jun '03

12 Jun '03

Dear Haskell Folks, Release Candidate 10 of the H98 FFI Addendum 1.0 is now available from http://www.cse.unsw.edu.au/~chak/haskell/ffi/ The change log since RC 7, which was the last version circulated via haskell(a)haskell.org, is appended below. Please review this specification carefully. If no suggestion that leads to a serious change is made within two weeks, I will freeze version 1.0. Thanks, Manuel -=- Changes since RC9: * 1: Mentioning interaction with foreign threads as an open problem. * 2 & 3: Removed `threadsafe' again, as the proposal for thread support is still evolving and it is not yet clear whether a new safety level is required. * 5.5: Added the type synonym `FinalizerPtr' and rewrite the documentation of finalizers. * 5.6: Clarified the description of `StablePtr' * 5.8: Added `finalizerFree' * 6.2: All the types in CTypes must be newtypes that are exported abstractly. Changes since RC8: * 5.8: `MarshallAlloc.reallocBytes' is no longer permitted on memory allocated with `alloca' or `allocaBytes'. * 6.1: Deinitialisation of the RTS via `hs_exit()' followed by (re)initialisation with `hs_init()' must be supported. Changes since RC7: * Clarified the lexis of C identifiers and C header file names * In `ForeignPtr', added `mallocForeignPtrArray' and `mallocForeignPtrArray0' * Clarified spec of allocations functions adding constraints taken from the corresponding C routines * `mallocBytes' and `allocaBytes' must align memory sufficiently for any basic foreign type that fits into the allocated block * Removed typos in the description of the module `ForeignPtr' * Added Peter Gammie to the list of acknowledged people * `addForeignPtrFinalizer' guarantees that finalizers for a single foreign pointer are executed in the opposite order as they were added. * `Storable': Require that the size is divisible by the alignment * Added Ross Paterson to the list of acknowledged people * Added hs_free_fun_ptr() and hs_free_stable_ptr() * Changed order of arguments of `mkIOError' and `annotateIOError' to match with the current implementation in GHC's FFI libraries.

4 13

Gtk2hs - developer snapshot 0.9.3 now available
by Axel Simon 05 Jun '03

05 Jun '03

This release should compile on FreeBSD, Linux, MacOS X, Solaris and Windows. It features loads of small additions, in particular many functions of the Pixbuf library. It compiles against Gtk 2.0 and Gtk 2.2. Despite the fact that the configure script suggests it, GtkGLExt and OpenGL is not yet supported (but this is certainly one of the next goals). Concerning the future development of gtk2hs: The Gtk library will exhibit the same interface as it does now. Once the Common GUI API effort produces some first suggestions, the Mogul layer will change accordingly. The only useful thing in Mogul are the table functions which could be moved into Gtk, so I hope this will not result in major problems. Please report all bugs and requests to: gtk2hs-users(a)sourceforge.net Thanks for taking interest in gtk2hs, Axel.

2 1

Implementing RefMonads in Haskell without ST,IO
by Tim Sweeney 04 Jun '03

04 Jun '03

Given the common definition of RefMonad: class Monad m => RefMonad m r | m -> r where newRef :: a -> m (r a) readRef :: r a -> m a writeRef :: r a -> a -> m () Is it possible to actually implement a working instance of RefMonad in Haskell, without making use of a built-in monad like IO or ST? If so, I'd love any tips -- I've been making good use of monads for a while, but can't figure this one out. The Java programmer in me wants to implement RefMonad by passing around a function from integers (think of them as pointers or heap indices) to "objects", and in readRef, "cast" the "object" to the appropriate type "t". If it's not possible to implement a typesafe RefMonad instance directly in Haskell, without making use of built-in imperative features like IO, then doesn't this refute the claims that monads implement imperative features functionally? -Tim

6 7

Eval in Haskell
by oleg＠pobox.com 03 Jun '03

03 Jun '03

Simon Marlow wrote: > The test driver makes use of 'eval'-style scripting, which none of the > existing Haskell systems has. Doesn't the following qualify as eval? A similar code works even in Hugs. > import System (system, ExitCode(ExitSuccess)) > import Posix(executeFile) > > myconfig_file = "/tmp/config" > > phaseII_var = "/tmp/Config.hs" > phaseII_const = "/tmp/a.hs" > phaseII_eval = "ghc --make " > phaseII_result = "/tmp/a.out" > > nl = "\n" > > writeConfig :: Int -> IO () > writeConfig num = > do > writeFile phaseII_var $ > concat > ["module Config (config_item) where", nl, > "config_item =", show num, nl] > > > runSuperIO () = system (phaseII_eval ++ > phaseII_const ++ " -o " ++ phaseII_result) > >>= \ExitSuccess -> > executeFile phaseII_result False [] Nothing > > main = readFile myconfig_file >>= writeConfig . read >>= runSuperIO The context: http://www.haskell.org/pipermail/haskell-cafe/2003-February/003912.html Furthermore, if GHCi can (after some prodding by the user) launch ghc to compile a module and then load the resulting .o file in and apply some function in thus loaded file, doesn't it feel like an eval?

4 4

lecture
by Filip 02 Jun '03

02 Jun '03

Hi, I am student of Computer Science and I have to write a lecture on ghc network module. Where can I get some code samples of this module. I am looking for short progrmas that show how to use network module. Thanks.

2 1

RE: ANNOUNCE: GHC version 6.0
by Simon Peyton-Jones 30 May '03

30 May '03

| > We are pleased to announce a new major release of the Glasgow Haskell | > Compiler (GHC), version 6.0. | | The release notes make me very happy :) There is a broken link: | | http://www.haskell.org/ghc/docs/latest/html/base/Data.Generics.html Yes, we found that yesterday. Fix committed to the HEAD. We'll put up a substitute shortly S

1 0

class MonadPlus m => MonadRing m
by Tim Sweeney 30 May '03

30 May '03

class MonadPlus m => MonadRing m where mone :: m a ** :: m a -> m a -> m a Does anybody have experience with a construct like MonadRing above? I'm interested in prior implementations, examples of instances, and coherence rules. A conceptual example: consider ListMonad, used to implement "non-determinism", or computations that may produce multiple values. In this context, the order or duplication of elements in a list is not significant; we think of them as sets of values: >From Functor: fmap f xs -- apply a function to all elements in the set, and collect the results in a set >From Monad: xs>>=f -- apply a set-returning function to all elements of x, and merge all the results into a set return xs -- generate a singleton set containing only x >From MonadPlus: mzero -- the empty set xs++ys -- the union of sets xs and ys >From MonadRing: xs ** ys -- the intersection of the sets xs and ys. mone -- the unit of **. conceptually, "the set of all sets". With Haskell's type system, this notion isn't feasible with ListMonad directly, but could be used with similar "set-like" monads containing elements drawn from a finite set. For set-like monads, there is then a further notion of a partial order relation defined by set inclusion. This could be defined along the lines of "mcontains :: m a -> m b -> m bool". For ListMonad, mcontains xs ys can be defined as true iff xs contains all elements of ys, in order, allowing arbitrary new elements that happen to occur between them. I'm not sure of the practical utility of these constructs in the Haskell world, but I've been working with them for a while in an experimental language and have found them very powerful, especially when coupled with first-class types with set-like functionality a la David McAllester "Ontic" language. In my particular case, I have found the following syntactic sugar to aid a great deal in the readability of complex monad expressions: -- Non-monad constructs: f(x) -- call function f with parameter x let x=v in e -- let-binding. -- Functor syntactic sugar: f($x) -- like map f x let x$=v in e -- like map (\x -> e) x -- Monad syntactic sugar: f(%x) -- like x >>= f let x%=v in e -- like v >>= \x -> e This could be considered a syntactic alternative to the "do" notation and list comprehension notation. -Tim Sweeney

1 0

Fudgets with GHC 5.04.3
by Bas van Dijk 29 May '03

29 May '03

Hi, Does anybody have the Fudgets library working with GHC 5.04.3 ? I know the library is tested under GHC 5.02 but I would rather not install two versions of GHC. Bas.

3 6