- Libraries - Haskell.org

Type of Control.Monad.Writer.listens
by Tom Pledger 05 May '03

05 May '03

Hi. Is this an appropriate place to report library bugs, or should I post to the various <implementation>-bugs lists instead? According to http://www.haskell.org/ghc/docs/latest/html/base/Control.Monad.Writer.html listens :: (MonadWriter w m) => (w -> w) -> m a -> m (a, w) but the inferred type is more general (and more useful) listens :: (MonadWriter w m) => (w -> b) -> m a -> m (a, b) Regards, Tom

1 0

Library hierarchy.
by Axel Simon 02 May '03

02 May '03

Hi, it is quite late to complain about the hierarchy of the new hierarchical library. But I think I should do it eventually. There is a path Graphics.UI which I think is conceptually wrong. User Interfaces are not a subset of Graphics but rather the other way round. I don't know if it makes sense to do graphics without interacting with the user, if not then I would expect the hierarchy to look more like this: UI.GUI -- GUI stuff like ObjectIO or CGA UI.Graphics -- stand-alone graphics stuff like HOpenGL UI.Joystick -- An example of a non-graphical user interface I guess for compatibility, Graphics has to stay. Could we have a top-level UI branch so the CGA can go in there? Axel.

1 0

Italian-crafted Rolex - only $65 - $140!! Free SHIPPING ! !
by james＠hello.com 01 May '03

01 May '03

1 0

RE: Ideas for library infrastructure
by Simon Marlow 29 Apr '03

29 Apr '03

[oops, accidentally sent the message before I'd finished it...] Ralf Hinze writes: > I like Andres' proposal. It puts some burden on the > compiler writers (but this work has to be invested > only once) and considerably simplifies things for > the library writers. Putting the burden on the compiler writers is exactly what we want to avoid - us compiler writers tend to be too busy writing compilers! Instead, what I would like to see is a separate library infrastructure that smooths over the differences between systems and compilers, and provides something that library writers can just plug their library sources into. I don't think we need to (or indeed, should) go as far as specifying installation locations, or extra tools that compilers should provide. All this should be embodied in the library infrastructure, which is written once and maintained by a single group of individuals. Cheers, Simon

4 4

Ideas for library infrastructure
by Andres Loeh 29 Apr '03

29 Apr '03

This is an attempt to summarize and separate the problems, in the way I see them: There are two things that are too complicated right now: [1] A library writer needs clear instructions what he can do with his library to package it in a standardized way usable with as many Haskell systems as possible. [2] A library user needs a normalized way to install additional libraries into his Haskell system(s) and keep them up-to-date. The following factors make both problems hard to solve: [A] There are multiple Haskell "compilers" out there, with very different properties. They support a different number of extensions, have different command line flags, one isn't even a compiler ;-) Furthemore, they have their own package systems which are incompatible. [B] Different versions of the same compiler are binary-incompatible. So on a compiler upgrade, the user will either need to reinstall libraries completely or at least do something to recompile the libraries. The current approach, as mentioned before, is to make the set of standard libraries increasingly large. I agree that this is not a really good solution, because compile times increase, the users may get huge sets of libraries they don't really need, and they may get them multiple times. A project that works that way, for example, is KDE. It is quite hard to upgrade single packages without upgrading the entire Desktop environment plus libraries. There, I don't find that situation ideal, and still, KDE is at least centrally organized and has global releases. The Haskell compilers are all separate and should stay that way. The situation as it is almost completely rules out binary-only versions of libraries. I will thus try to focus on source based libraries from now on. I vote for a two-level approach: I. Define a clear and precise way how and where a Haskell library has to be installed on a system. This installation should be as compiler-independent as possible. The files should go in a central place, and there should be additional information at that location of the kind that is now for example stored in GHC's package configuration file. As far as a library does not depend on a particular Haskell compiler (for example, it needs C libraries as well), these C libraries may well aready be built and installed. But the Haskell code should be installed in source form. Authors of libraries should find these guidlines in a clear and easy to understand form somewhere on the web, and there should be tool support to facilitate conforming to the standard. I'd go for some well-documented Makefile includes, but if nicely written, a Haskell based system may also work. But I think, the system and language here is secondary, as long as it is clear _what_ needs to be done ... II. Each Haskell compiler should be extended with a tool that can take a library from the standardized source based install described in I. This tool could be similar in interface to ghc-pkg, but should not only collect package configuration information, but also _build_ the Haskell code for the compiler and create and install libraries to the right positions as necessary. The tool should provide a way to _add_, to _remove_, and to _completely regenerate_ libraries. Additionaly, there needs to be one single tool, that levels the potential differences between the package tools of the Haskell compilers and keeps track of all the compilers installed in a system. Let's call it "global package manager". The last thing that would be called in the Makefile (or whatever) that is supplied with a library is the global package manager with the option "add" and the library name. The global package manager would look in the standardized central place for the library, find out for which of the installed Haskell compilers it works, and call their respective package managers that will the build and add the library individually. The last thing that would be called in the Makefile (or whatever) of a Haskell compiler would be its own package manager with the option to regenerate all libraries. Because they are installed in a place independent of the compiler itself, they will survive a compiler upgrade and can automatically be rebuilt for the new version. For hugs rebuilding would be nearly trivial, for GHC is might take a long time, but that's life. Summary of the proposal: * Define a clear standard to install Haskell libraries on a system in a way that is independent of a specific Haskell compiler (both type and version). * Support library writers by tools to make sure they can conform easily to that standard. This includes a global package manager that can be called in the end to pass responsibility over the library to the compilers installed on the system. * For each Haskell compiler, write a/modify the package manager so that it can handle the addition, removal, and complete regeneration of such source-based installed libraries. [1] This will make the situation easier for package writers, because they do not have to care about actually _building_ the library for a specific compiler or compiler version. They will only have to conform to a specific installation format, and that will be supported by tools. [2] This makes life easier for the users, because they can just install additional libraries and "never" have to worry about them again. If they install additional Haskell compilers or upgrade to newer compiler versions, the libraries will always automatically become available. Of course I realize that I probably have forgotten many things and that I may not have made myself clear at all points. So you're all invited to tear this proposal apart! Best, Andres -- Andres Loeh, Universiteit Utrecht mailto:andres@cs.uu.nl mailto:mail@andres-loeh.de http://www.andres-loeh.de

3 2

RE: bug in hGetPS?
by Simon Marlow 28 Apr '03

28 Apr '03

> I don't see that hGetPS should be consistent with hGetLine. > If hGetLine > returns and empty string, you assume the file has two > newlines in a row, > while if hGetPS returns an empty string, since you asked for > a given number > of chars, you know that you've reached the end of the file. I mean that hGetPS is inconsistent with hGetLine in the sense that hGetPS never throws the EOF exception. The consistent interpretation would be for hGetPS to throw an EOF exception if the Handle is positioned at the end of the file, unless the requested byte count is zero. It wouldn't make sense to have hGetLine behave in the same way as hGetPS does now, because as you say there would be two possible meanings for an empty string returned. Cheers, Simon

1 0

RE: bug in hGetPS?
by Simon Marlow 28 Apr '03

28 Apr '03

> I'm not sure if this counts as a bug or a feature... > > If hGetPS h len encounters an EOF before len, it returns a > PackedString > containing the remainder of the file. However, if h is > already at the end > of the file, an exception is raised rather than returning an > empty string. > To me this is rather counter-intuitive. It matches the behaviour of System.IO.hGetLine. Data.PackedString.hGetPS behaves in the way you're suggesting: it just returns short reads instead of flagging EOF. Unfortuantely this is inconsistent with hGetLine, so I'm not sure if the behaviour should stay that way. Cheers, Simon

2 1

possible bug in Eq of packedStrings
by David Roundy 28 Apr '03

28 Apr '03

I think I've come across a bug in the (==) function of PackedString, but it's hard to reproduce. I'm attaching a set of files that hopefully will reproduce the problem. My assumption is that if two packed strings are unequal, then when their unpacked versions must also be equal. This is, of course, assuming one starts with the packed versions, since packing of strings may be lossy... Anyhow, the guts of the problem is in the following (where c1 and c2 are packed strings): if c1 == c2 then return True else do putStr $ "First version:\n" putStr $ unpackPS c1 ++ "\n" putStr $ "second version:\n" putStr $ unpackPS c2 ++ "\n" if unpackPS c1 == unpackPS c2 then putStr "But unpacked, they are the same!!!\n" else putStr "And unpacked they are different!\n" return False I think that it is a bug if the line "But unpacked, they are the same!!!" ever gets printed (which it does--but it's hard to reproduce). This bug is rather troubling to me, since one of the reasons I'm using packed strings is for the assumed efficiency of comparison, the other being of course storage space, which would be sufficient in itself to mandate packed strings. Anyhow, I'm attaching a test program with a test file (which needs to be named both test1 and test2) which is able to reproduce an error in the above. Sorry I haven't made it any simpler. -- David Roundy http://www.abridgegame.org

2 2

RE: Ideas for library infrastructure
by Simon Marlow 28 Apr '03

28 Apr '03

Ralf Hinze writes: > I like Andres' proposal. It puts some burden on the > compiler writers (but this work has to be invested > only once) and considerably simplifies things for > the library writers. Putting the burden on the compiler writers is exactly what we want to avoid - us compiler writers tend to be too busy writing compilers! Instead, what I would like to see is a separate library infrastructure built by non-compiler writers that smooths over the differences between

1 0

bug in hGetPS?
by David Roundy 26 Apr '03

26 Apr '03

I'm not sure if this counts as a bug or a feature... If hGetPS h len encounters an EOF before len, it returns a PackedString containing the remainder of the file. However, if h is already at the end of the file, an exception is raised rather than returning an empty string. To me this is rather counter-intuitive. Since hGetPS already has one way of flagging the EOF condition (returning a string shorter than len), I would prefer to be able (for example) to simply copy a file by a loop such as: cp h1 h2 = do ps <- hGetPS h1 buflen hPutPS h2 ps if lengthPS ps == buflen then cp h1 h2 else return () I know I could just as easily write the same code as: cp h1 h2 = do ps <- hGetPS h1 buflen hPutPS h2 ps eof <- hIsEOF h1 if not eof then cp h1 h2 else return () but since the first should be as fast as the second, I don't see why it shouldn't be made safe. -- David Roundy http://www.abridgegame.org

1 0