June 2009 - Haskell-Cafe

ANNOUNCE: The Haskell Platform 2009.2.0.1
by Don Stewart 03 Jun '09

03 Jun '09

We're pleased to announce the second release of the Haskell Platform: a single, standard Haskell distribution for everyone. The specification, along with installers (including Windows and Unix installers for a full Haskell environment) are available. Download the Haskell Platform 2009.2.0.1: http://hackage.haskell.org/platform/ The Haskell Platform is a blessed library and tool suite for Haskell distilled from Hackage, along with installers for a wide variety of systems. It saves developers work picking and choosing the best Haskell libraries and tools to use for a task. Distro maintainers that support the Haskell Platform can be confident they're fully supporting Haskell as the developers intend it. Developers targetting the platform can be confident they have a trusted base of code to work with. What you get: http://hackage.haskell.org/platform/contents.html With regular time-based releases, we expect the platform will grow into a rich, indispensable development environment for all Haskell projects. Please note that this is a beta release. We do not expect all the installers to work perfectly, nor every developer need met, and we would appreciate feedback. You can help out by packaging the platform for your distro, or reporting bugs and feature requests, or installing Haskell onto your friends' machines. The process for adding new tools and libraries will be outlined in coming weeks. The Haskell Platform would not have been possible without the hard work of the Cabal development team, the Hackage developers and maintainers, the individual compiler, tool and library authors who contributed to the suite, and the distro maintainers who build and distribute the Haskell Platform. Thanks! -- The Platform Infrastructure Team

3 2

Bool as type class to serve EDSLs.
by Sebastiaan Visser 03 Jun '09

03 Jun '09

Hello, While playing with embedded domain specific languages in Haskell I discovered the Num type class is a really neat tool. Take this simple example embedded language that can embed primitives from the output language and can do function application. >data Expr :: * -> * where > Prim :: String -> Expr a > App :: Expr (a -> b) -> Expr a -> Expr b Take these two dummy types to represent things in the output language. >data MyNum >data MyBool Now it is very easy to create an Num instance for this language: >primPlus :: Expr (MyNum -> MyNum -> MyNum) >primPlus = Prim "prim+" >instance Num (Epxr MyNum) where > a + b = primPlus `App` a `App` b > fromInteger = Prim . show > ... Which allows you to create very beautiful expression for your language embedded inside Haskell. The Haskell expression `10 * 5 + 2' produces a nice and well typed expression in your embedded domain. But unfortunately, not everyone in the Prelude is as tolerant as the Num instance. Take the Eq and the Ord type classes for example, they require you to deliver real Haskell `Bool's. This makes it impossible make your DSL an instance of these two, because there are no `Bool's only `Expr Bool's. Which brings me to the point that, for the sake of embedding other languages, Haskell's Prelude (or an alternative) can greatly benefit from (at least) a Boolean type class like this: class Boolean a where ifthenelse :: a -> b -> b -> b -- Not sure about this representation. ... And one instance: >instance Boolean (Expr MyBool) where > ifthenelse c a b = Prim "if-then-else" `App` c `App` a `App` b Now we can change (for example) the Eq type class to this: >class Eq a where > (==) :: Boolean b => a -> a -> b > (/=) :: Boolean b => a -> a -> b For which we can give an implementation for our domain: >primEq :: Epxr (a -> a -> MyBool) >primEq = Prim "==" >instance Eq (Expr a) where > a == b = primEq `App` a `App` b And now we get all functionality from the Prelude that is based on Eq (like not, &&, ||, etc) for free in our domain specific language! Off course there are many, many more examples of things from the standard libraries that can be generalised in order to serve reuse in EDSLs. Anyone already working on such a generalized Prelude? I can imagine much more domains can benefit from this than my example above. Any interesting thoughts or pointers related to this subject? Gr, -- Sebastiaan Visser

13 15

Re: [Haskell-cafe] Cabal/primes
by michael rice 03 Jun '09

03 Jun '09

OK, I downloaded Numbers. Still missing the three functions I wanted, which are primes, isPrime, and isProbablyPrime. How do I get these? Michael

2 1

ANN: heap-1.0.0
by Stephan Friedrichs 03 Jun '09

03 Jun '09

Hello haskell-cafe, I'm pleased to announce a rewrite of the heap package, heap-1.0.0 [1]. It is not 100% compatible to the version 0.6.0, but provides major improvements: - The HeapPolicy type class hack used to distinguish between min- max-, min-prio- and max-prio-heaps has been replaced by the HeapItem type family (the type family provides functions to convert insertable 'items' to (priority, value) pairs and back. Thus a static min-heap (HeapT) can be used as underlying implementation, but the package can still provide MinHeap, MaxHeap, MinPrioHeap and MaxPrioHeap. - A nice side effect of the above is, that ({Min,Max}PrioHeap p) now is an instance of Functor - Faster {from,to}{Asc,Desc}List conversions - A binary with quickcheck test cases can now be built from cabal (with a "Test" flag) (the old versions already had lots of test cases, but cabal didn't know about them). Regards, Stephan [1] http://hackage.haskell.org/cgi-bin/hackage-scripts/package/heap-1.0.0 -- Früher hieß es ja: Ich denke, also bin ich. Heute weiß man: Es geht auch so. - Dieter Nuhr

1 0

Notice for package authors
by Duncan Coutts 03 Jun '09

03 Jun '09

Package authors, We are about to add an additional quality check in the Hackage upload process that will affect many packages. Hackage will require an upper bound on the version of the base package and reject packages that omit it. Lots of packages currently specify: build-depends: base or build-depends: base >= 3 This is bad. There is no way for the tools to discover if you mean base 3 or 4 and yet most packages break when we pick the wrong one. You must specify an upper bound so that your package does not break when the next major version of the base library is released. For example, if you've tested with base 3 and 4 then use: build-depends: base >= 3 && < 5 Or if it needs version 4 then use: build-depends: base == 4.* Background ---------- When base 4 was released with ghc-6.10.x the vast majority of packages would have broken were it not for a compatibility shim that we added to the cabal-install tool. It defaulted to picking base 3 when the version constraints did not otherwise specify the use of base 4. The same trick will not work when base 5 is released because it will likely not be possible to continue to ship base 3. It is also important that we start to move towards making the majority of packages compatible with base 4. cabal-install changes --------------------- We will shortly release a minor update to cabal-install to change the way it picks between base 3 and 4. Currently if it has the choice it picks version 3. However that is not optimal for cases like: build-depends: base >= 3 && < 5 where it is clear that it is supposed to work with both. In this case we should not be pessimistic in going with the old base 3 and should instead pick base 4. More precisely, we will only apply the compatibility shim when the version is unbounded above. When it is bounded above, as Hackage will soon require, the normal preference to use the latest version applies. If you'd like to help us check this feature is working properly then grab the latest darcs version of cabal-install (which needs the latest darcs version the Cabal lib). See also http://hackage.haskell.org/trac/hackage/ticket/485 Duncan

1 1

HXT XmlPicklers - TH Derivation
by Max Cantor 03 Jun '09

03 Jun '09

Hi, I have developed some simple TH code to automatically derive XmlPickler instances for my types and if there is interest, I will clean it up and submit a patch. Its not complete, but is a start. Any interest? Max

2 1

Datastructure with some business-rules
by Mathijs Kwik 03 Jun '09

03 Jun '09

Hi all, I'm building a tree-like structure that somewhat resembles a package/ dependency structure as most packagemanagers/ports-systems have them. It's tree-like (Data.Tree at the moment), but I will probably need to make some structural changes to allow for more complex stuff like circular dependencies and stuff like 'alternatives'. While I'm still on the Tree (nice & simple), I want to explore some business-rules & validation stuff. This is a bit of a contrived example: Let's say that nodes are (NodeType, Int) pairs, where the Nodetype is just a simple algebraïc type. Now certain types of nodes are only allowed to 'grow' on top of some other nodes, but up to 10 levels deep. So certain nodes are only allowed if one of 10 ancestors is of some other type. Or to make this a bit weirder (maybe too contrived): its parent should have a 'brother' of some type. Ofcourse I can make a 'validate' function that checks if a tree plays by the rules, but I would like to put the typesystem to use somehow, since there aren't that many rules. So I would like to have an error thrown any time an invalid structure is used/created instead of having to validate myself every time. I would like this, because in the future I will need to 'morph' trees into each other so inbetween steps that exist must still be valid. First I thought about creating some auto-validate monad that just validates the result after every step, but before going that way I would like to make sure this is the way to go. I understand that Data.Tree (and other functors) just take 1 type 'payload' and they don't mind what's in there, while my 'validation' rules are about the payload _and_ the place in the tree, so I will probably have to change a bit here. Is this at all possible? Is it ok to do or is a 'external' validation/validation monad clearer? What would be the way to go? Thanks for any help! Mathijs

1 0

ANN: Anglohaskell 2009
by Philippa Cowderoy 03 Jun '09

03 Jun '09

Anglohaskell 2009 is go! I'm taking on the mantle of organiser, and Microsoft Research have offered us space for talks in Cambridge again. The event will be held on the 7th and 8th of August. More info at http://www.haskell.org/haskellwiki/AngloHaskell/2009 , planning and discussion in #anglohaskell on freenode. For those not familiar with Anglohaskell, it's a somewhat-informal get-together featuring a mixture of talks, discussion and socialising with topics from the hobbyist to the pragmatic to the theoretical. All are welcome, regardless of experience, and best of all - it's free! If anyone wants to offer a talk, help with running the event, accomodation for haskellers from out of town or some ideas, please feel free to edit the wiki page appropriately and/or give us a yell in #anglohaskell. -- Philippa Cowderoy <flippa(a)flippac.org>

3 2

beginners question about fromMaybe
by Nico Rolle 02 Jun '09

02 Jun '09

hi there heres a code snipped, don't care about the parameters. the thing is i make a lookup on my map "m" and then branch on that return value probePhase is sc [] m = [] probePhase is sc (x:xs) m | val == Nothing = probePhase is sc xs m | otherwise = jr ++ probePhase is sc xs m where jr = joinTuples sc x (fromMaybe [] val) key = getPartialTuple is x val = Map.lookup key m the line "jr = joinTuples sc x (fromMaybe [] val)" is kind of ugly because i know that it is not Nothing. is there a better way to solve this? regards

5 6

Checking a value against a passed-in constructor?
by Dan Cook 02 Jun '09

02 Jun '09

Hi, (Relatively new to Haskell here ..) So I have the following: data MyVal = Atom String | Bool Bool And I want to do something like this check :: (Bool -> MyVal) -> MyVal -> True check f (f x) = True check _ _ = False What that means is I want to pass a MyVal constructor and a MyVal, and return True if the second argument was constructed with the first. More generally, I'd like to be able to do genCheck :: (* -> MyVal) -> MyVal -> True genCheck f (f x) = True genCheck _ _ = False So that I can pass in _any_ MyVal constructor and let the function just check if the second argument was constructed with the first, without caring which constructor it is. What is the preferred way to do this, since neither of those functions compile? Cheers, - Dan

6 5