- Libraries - Haskell.org

Re: Bugfix for QuickCheck 1.1.0.0
by Patrick Perry 02 Sep '08

02 Sep '08

Jed Brown wrote: > The idea with QC is that you start with `simple' random input and > progress to more `complicated' input. If say, you are testing a > function that builds a list with length equal to the output of the > QC-generated function (Double->Int) (with positive precondition) you > could be building a huge list very early. This wouldn't happen with > other types since `simple' QC-generated functions for, say, (Int->Int) > will map small integers to small integers. I don't think this has anything to do with the definition of coarbitrary. As I understand things: coarbitrary is a function of type x -> StdGen arbitrary is a function of type StdGen -> Int -> x For the type "x -> y", arbitrary is equal to \g n -> (\x -> let g' = coarbitrary x in arbitrary g' n) I did an experiment in QC1 (with patch). Here are two properties: prop_f (f :: Double -> Int) x = trace (show $ f x) True prop_g (f :: Int -> Int) x = trace (show $ f x) True Below is the output. Do you think that one is "more simple" than the other? Patrick 1 0 2 -2 0 0 0 0 2 -3 00 11 -3 -5 -9 05 06 17 -5 49 30 -1 -1 33 -8 -4 66 27 78 09 60 01 -8 83 -12 35 -4 13 38 -1 -4 -1 02 -10 -3 45 06 -10 -12 -4 20 -7 -18 -2 84 -10 -2 13 38 29 60 -6 12 20 -12 95 -8 -22 58 49 90 -12 12 -12 -1 -1 -14 -14 27 -1 00 01 -16 23 54 25 24 -15 48 14 -10 -37 02 -19 84 17 -15 -19 -1 42 -3 1 -3 1 3 -3 -4 -4 -2 -3 10 -1 02 43 14 05 -1 07 18 -1 -3 21 -4 -5 34 25 -1 17 18 -8 -4 31 13 53 64 95 06 27 -2 -6 60 10 72 -2 -3 45 36 -9 16 39 -4 01 27 -3 -22 -7 -4 -14 -1 -6 -8 -1 -23 -13 14 45 -24 17 -1 49 -5 25 -13 11 44 05 26 12 -12 -33 00 11 27 93 35 25 -3 -6 98 -12 -20 10 -11 43 34 12 -43 17 -3 09

2 1

ANN: unicode-properties 3.2.0.0, unicode-names 3.2.0.0
by Ashley Yakeley 02 Sep '08

02 Sep '08

unicode-properties 3.2.0.0, unicode-names 3.2.0.0 These two packages are representations in Haskell of various data in the Unicode 3.2.0 Character Database. Unicode 3.2.0 was the latest version of the Unicode standard at the time I wrote most of the code; later I may move the packages to the latest version (currently 5.1.0). The unicode-properties package contains functions to determine general category, case, and a wide range of other properties, as well as to do decomposition and case-folding. The unicode-names package contains just one function, getCharacterName, for getting the name of a character. It's separated out because it's a sufficiently large proportion of the total data. Both packages use the type "Char" to represent Unicode characters (more pedantically, codepoints). In GHC Char has the range ['\x0'..'\x10FFFF'], matching the Unicode standard. The packages won't work with compilers that restrict Char to a smaller range. Hackage: <http://hackage.haskell.org/cgi-bin/hackage-scripts/package/unicode-properti…> <http://hackage.haskell.org/cgi-bin/hackage-scripts/package/unicode-names> Source for both packages: <http://code.haskell.org/unicode-properties/> Most of the data is auto-generated at build time from files downloadable from the Unicode web-site. I expect Don will have them both in Arch Linux within the hour. -- Ashley Yakeley

4 5

Re: Bugfix for QuickCheck 1.1.0.0
by Patrick Perry 02 Sep '08

02 Sep '08

Two things: First, the version of variant I gave will behave reasonably if given a negative argument, so the overflow is not catastrophic. Second, I'm not sure what you mean by a "simple" generator. Let's consider Int instead of Double. With the current version of variant, "coarbitrary 1" calls split one time, and "coarbitrary 1000" calls split 1000 times. At the end of the day, though, all random number generators are equally "complex". The only difference is that they have different seeds. You are correct the QuickCheck2 uses "toRational" instead of "decodeFlloat" for the coarbitrary instance. I don't think it matters either way which one gets used, though, and I would rather change as little code as possible in QuickCheck1. Patrick Jed Brown wrote: > I haven't looked at this in a while but I'm not sure this completely > fixes things with regard to coarbitrary. That is, we can produce very > simple Doubles (as defined by arbitrary) that produce (via > coarbitrary) > very complicated generators for other types (and there was an issue of > overflow with possible sign change due to nasty casting, hence variant > getting a negative argument). As I understand it, your fix to variant > means that variant will return in a reasonable amount of time even > with > a huge argument, but it doesn't fix the issue that coarbitrary should > produce a `simple' generator for a `simple' argument. I thought QC2 > had > a mechanism to fix this. >

2 1

2533: Generic functions that take integral arguments should work the same way as their prelude counterparts
by Jim Apple 30 Aug '08

30 Aug '08

http://hackage.haskell.org/trac/ghc/ticket/2533 Deadline: Sept 7 The Prelude functions drop, take, and splitAt are unfailing (never call error). This patch changes the Data.List generic versions to behave the same way. At present, they call error on negative arguments. Jim

16 25

Historical question about type of Data.List.group
by Jim Apple 30 Aug '08

30 Aug '08

Why isn't the type of group Eq a => [a] -> [(a,[a])] That matches more exactly what group does, and it's easy to see that functions like nubOrd = map fst . group . sort are clearly safe, whereas map head . group . sort is not. Jim

4 4

Interleave two lists
by Sean Leather 28 Aug '08

28 Aug '08

Mark Jones gave several talks at Advanced Functional Programming 2008. In one of them, he presented approaches to enumerating the elements of various datatypes. I found several interesting things in it, but one function stuck out as being perhaps useful in general. infixr 5 ||| (|||) :: [a] -> [a] -> [a] [] ||| ys = ys (x:xs) ||| ys = x : ys ||| xs It interleaves the elements of two lists. It's defined exactly as (++) with the exception that the arguments are swapped for the recursive application. This works nicely when one wants to merge infinite lists. For example, suppose you want a list of the enumerable numbers with a balance of positive and negative: enums :: (Num a, Enum a) => [a] enums = [0..] ||| map negate [1..] You can't use (++) here, because the left side never completes. Does (|||) seem useful to others? Is it already available in some other form (or in a library) of which I'm not aware? If yes and no are the answers, then I wonder if it's useful enough for Data.List (modulo any expected renaming). Sean

5 4

Developing SYB, packaging issues
by José Pedro Magalhães 24 Aug '08

24 Aug '08

Hello all, This message focuses on a problem Claus mentioned before: > One other thing I meant to ask was about procedure, > given that Syb is currently in base and hence under the > library modification process. How is this going to combine > with an active maintainer and some parts on hackage? > > Claus To be able to further develop SYB (see [1] for history), it's probably best to develop it as a separate package, which people can install, upgrade, etc. This would mean the library could be updated independently of GHC, and new GHC releases could then use the most recent version of the package. But how do these things merge? Can/should SYB be moved out of the base package? And, if this happens, can the library being developed as a separate package still use the automatic deriving mechanism? I'm sending this message to libraries(a)haskell.org too because I guess this problem might have shown up here before. Cheers, Pedro [1] http://search.gmane.org/?query=%22Owning+SYB%22&group=gmane.comp.lang.haske…

4 7

Syb Renovations? Issues with Data.Generics
by Claus Reinke 21 Aug '08

21 Aug '08

Calling all Syb/Data.Generics users!-) I keep running into problems with Data.Generics, mostly because I actually want to use it (no claims that it is the best or final solution, or that other approaches aren't equally in need of support, just that it is the best-supported working approach right now). Some tricky issues are (sometimes against published expectations) solvable, suggesting useful additions to the library, but some seemingly trivial things have me stumped, suggesting (to me, at least;-) a need for improvements either in the library or in its documentation. Part of the reason I'm interested in this now is that Data/Typeable instances seem likely (I hope:-) to be added to the GHC Api, where Thomas Schilling is working on improvements http://hackage.haskell.org/trac/ghc/wiki/GhcApiStatus http://hackage.haskell.org/trac/ghc/wiki/GhcApiAstTraversals also, the old question of porting HaRe to the GHC Api is currently being looked into again, by Chaddaï Fouché, and crucially depends on Syb's generic traversals. As it is still holiday season, it is a bit early for proposal deadlines, but I'd like to start a discussion of Syb/Data.Generics and collect the issues and solutions arising, in the hope of following up with concrete proposals for improvements. To start the discussion, a simple item: 1. inconvenient convenience instances of Data for non-"data" types Data.Generics.Instances defines instances of Data for many types, including some abstract types that don't really fit into the concrete value based model of Data, like 'IO a' and 'a->b'. Those instances give runtime errors for some class methods, and mainly offer faked (no-op) gmap traversals, serving as a convenience/enabler for 'deriving instance Data': http://www.haskell.org/pipermail/generics/2008-June/000346.html A list of the odd instances in Data.Generics.Instances, with examples of their oddities, can be found here: http://www.haskell.org/pipermail/generics/2008-June/000347.html My suggestion is to split this module into two, and stop the implicit import/export of the incomplete instances from Data.Generics. Reactions to this suggestion have been muted so far (Simon PJ was as surprised as I was about the existence of these instances, but has no strong opinion about the issue, Alexey Rodriguez supports the suggestion, Ian Lynagh points out the difficulty of transition), which is one reason why I'll try to move the discussion to libraries@. Pro: - the instances are still available, and only one explicit import away, so 'deriving instance Data' for types containing uninteresting functions is still convenient - the problematic instances are no longer implicitly imported, so applications that don't want these instances can now avoid them completely, or define their own instances - these convenience instances are not just inconvenient for some applications, due to the way intances are handled in Haskell; they actually violate some "natural" invariants like "everything queries every substructure of the specified type", "everywhere applies a transformation at every substructure of matching type" - the situation is similar to Text.Show.Functions, as the convenience instances don't provide the full expected functionality, just barely enough for deriving to get by Cons: - due to the implicit import and use of these instances, there is no obvious transition scheme; it seems that the least painful process would be to make the change without transition/deprecation period and to document the explicit import option [it would be useful to have a way of deprecating instance imports, so that any deriving scheme depending on imports from a deprecated location would trigger a warning, in this case suggesting the new import location] As I said, I'd like to wait until at least the Syb authors are back from holidays before setting any proposal deadlines, but I'd like to invite feedback from Syb users on this and other Syb issues. Here is a preview on other items I'd like to raise later on, please add your own: 2. Data.Generics.Utils Since Data/Typeable are compiler-derivable (in GHC) while other classes like Functor/Traversable/etc are not, it would be useful if generic instances for those other classes could be defined in terms of Data/Typeable. The Uniplate library already does this for its own classes via Data.Generics.PlateData, and it appears that at least Functor is defineable as well (code exists, proof is only informal at this stage, and those invariant violations and runtime errors in the implicitly imported dummy instances from (1) really get in the way): http://www.haskell.org/pipermail/generics/2008-June/000343.html http://www.haskell.org/pipermail/generics/2008-July/000349.html http://www.haskell.org/pipermail/generics/2008-July/000351.html What other classes can be defined in this way? Traversable (traverse) seems very nearly possible, what else? 3. Performance Naive use of Syb traversal schemes can lead to huge performance losses. Experienced users tend to write their own traversal schemes, using Syb's low-level Api directly, but we can take inspiration from some Uniplate/PlateData optimization techniques and generalise them for use with Syb's high-level traversal scheme Api, yielding similar performance gains for everywhere/everything: http://www.haskell.org/pipermail/generics/2008-July/000353.html Another direction that might be worth exploring is to use Maps instead of nested generic extensions to define adhoc-overloaded transformation and queries (I've actually started playing with that, but am currently stuck on GHC ticket #2463). 4. Useability There is probably nothing one can do to make the types of Syb's low-level Api less of a brain hazard, but not all of the stumbling blocks seem to be necessary consequences of the carefully crafted edifice of interactions between nearly polymorphic types, runtime type checks and type reflection. Examples: - there doesn't seem to be a way to get hold of a types' constructors, only of constructor representations, structure scaffolds, and structure generators - the actual domain on which a transformation/query acts is hidden behind the near-polymorphic default type of generic extensions - I can't seem to figure out how to use typeOf1, when the other Syb operations only give me 'forall a . Data a => a'; instead, I seem to be forced to use something like: [ mkTyConApp tyCon (init tyArgs) | not (null tyArgs) ] where (tyCon,tyArgs) = splitTyConApp typeRep - others? What are your personal gripes with Syb/Data/Typeable, and for which of them do you see a chance of addressing them by changing/adding code? Claus

5 12

Cabal question: Generated data files
by Neil Mitchell 20 Aug '08

20 Aug '08

Hi, First off, this list seems a bit off-topic for a question about Cabal, but its what the web page told me to do: http://haskell.org/cabal/ - if this isn't the place for this email, could someone update the web page? The question is about generated data files, specifically for Hoogle. Hoogle generates search databases, which I want to be installed as read-only data, in datadir. For a release I want to bundle up these databases in the tarball, pregenerated. I don't want to include these databases in the darcs version (they are fairly specific to a particular version and regularly changing), but I do want people to be able to build the darcs version using cabal. To generate these databases requires a second Haskell program (included in the darcs repo), and an installed copy of the same version of Hoogle. So, I want to generate database files, which can only be done after install time, but which I then want to be installed. Is there any way to acheive this? Or some better idea? Currently I just generate the databases and have the .cabal file reference them, which means the darcs version can't be compiled with Cabal. Thanks Neil

3 7

Proposal: Reserved module namespace for packages on Hackage
by David Menendez 20 Aug '08

20 Aug '08

In the interests of reducing module name collisions, I suggest reserving part of the module name space for individual packages on Hackage. Specifically, I'm suggesting that a new top-level module name, "Lib", be added to the module naming conventions, and that the children of "Lib" be reserved for the Hackage package with the same name. That is, "Lib.Foo" and "Lib.Foo.*" would be reserved for the package "Foo" on Hackage. This would not require packages to *use* this namespace. However, packages that do use it would have a greatly reduced chance of conflicting with other packages. Implementation costs are minor. At most, we might want some code in Hackage to prevent packages from using module names reserved for other packages. At the least, all we need to do is add "Lib" to the list of allowable top-level module names. Developers who object to giving the provenance of a module in its name are free to take their chances with the rest of the module hierarchy. Mapping package names to module names is mostly straightforward. According to the Cabal documentation, a package name consists of one or more alphanumeric words separated by hyphens, where each word contains at least one letter. Since hyphens aren't allowed in module names, they would get mapped to underscores, which are not allowed in package names. Thus, "Lib.Foo_Bar" would be reserved for package "Foo-Bar". It's less obvious what to do with packages whose names start with lower-case letters or digits. I see three possible solutions: (a) Do not reserve module names for these packages. (b) Map these package names to module names in a way that avoids conflicts, e.g., prefixing the package name with "P'", which cannot occur in a package name. That is, package "foo" would get "Lib.P'foo". (c) Change the rules for package names on Hackage by disallowing package names which start with a digit or which differ from an existing package only in the case of the first letter, and reserve module names based on capitalized package names. That is, package "foo" would get "Lib.Foo", and Hackage would not accept a new package "Foo" if there was a preexisting "foo", and vice versa. My preference is for (c). In fact, I might go further and forbid any package whose name differs only in case from an existing package in Hackage. Further thoughts: (1) I chose "Lib" because it's short and, so far as I know, unused. "Hackage" might be a better choice, since the scheme depends on Hackage to prevent name collisions. (2) It was surprisingly difficult to find out the rules for valid package naming. None of the tutorials I found discussed choosing a valid name. The GHC documentation mentions that package names must have a specific form, but I couldn't find any description of it. (3) I did not find a definition of "alphanumeric" in the Cabal documentation. Does this include non-ASCII characters? (4) We could also reserve additional module names corresponding to specific versions of packages, e.g., "Foo-1.0" might get "Lib.Foo_1_0". This does not create ambiguity, because "Foo-1-0" is not a valid package name.

7 9