February 2009 - Haskell-Cafe

Confused by SYB example with zipping
by Henry Laxen 16 Feb '09

16 Feb '09

Dear Group, When trying to run the example at: http://www.cs.vu.nl/boilerplate/testsuite/gzip/Main.hs ghc 6.10.1 says A pattern type signature cannot bind scoped type variables `a' unless the pattern has a rigid type context In the pattern: f :: a -> a -> a In the definition of `mkTT': mkTT (f :: a -> a -> a) x y = case (cast x, cast y) of { (Just (x' :: a), Just (y' :: a)) -> cast (f x' y') _ -> Nothing } In the definition of `main': main = print $ gzip (mkTT maxS) genCom1 genCom2 where genCom1 = everywhere (mkT (double "Joost")) genCom genCom2 = everywhere (mkT (double "Marlow")) genCom double x (E (p@(P y _)) (S s)) | x == y = E p (S (2 * s)) double _ e = e maxS (S x) (S y) = S (max x y) .... Failed, modules loaded: CompanyDatatypes. --------------------------------------------------------------------- I must admit I don't really know what to make of this. Any insights would be appreciated. Thanks. Henry Laxen

2 1

Parameterized monad transformers
by Miran Lipovača 16 Feb '09

16 Feb '09

Howdy y'all! I was reading sigfpe's Beyond Monads post (http://blog.sigfpe.com/2009/02/beyond-monads.html) about parameterized monads. Great post, makes you go: this is so elegant and simple, why didn't I think of that? Anyway, I was wondering whether those monads have corresponding transformers, and if so, what they look like and what they are good for? Is there any weight to the idea at all? I don't know much about monad transformer theory, but I do imagine that for transformers to be useful, they have to be stackable, so the underlying monad of a parameterized monad also has to be a parameterized monad. I asked around in #haskell and ski_ and I had a couple of ideas exploring the concept (although he did most of the exploring, I just carried his luggage). Seeing how parameterized monads are gotten by just loosening some restrictions on normal ones and drawing then parallels between them, I think the same methodology could be applied to transformers. So there should be a transformer version t of a parameterized monad m and a lifting operation plift that lifts m to t. At first I did what sigfpe did with non-transformer monads, which was to just implement the appropriate functions for the more general monads and see what GHCI tells us about the type. I first thought about having a parameterized StateT, PStateT: newtype PStateT m s1 s2 a = PStateT { runPStateT :: s1 -> m (a, s2) } along with a lifting operation plift :: (PMonad m) => m s1 s2 a -> t (m s1 s2) s3 s3 a but I don't think that's cool because of the different kind of the underlying monad. So then ski_ suggested newtype PStateT m (s1,s1') (s2,s2') a = PStateT { runPStateT :: s1 -> m s1' s2' (Pair a s2) } where (s1,s1') and (s2,s2') stand for the pair of types and not a (,) type constructor with two types applied as type parameters. That's why the pair in the result is represented as Pair a s2. Anyway, s1' and s2' represent the category tail and head of the underlying parameterized monad. With that, the lifting operation would have a type of plift :: (PMonad pm) => pm s1 s2 a -> t pm (s, s1) (s, s2) a basically I'm just wondering how you guys think the transformer versions of parameterized monads work and what their types should be. And if you think they're feasible at all. So basically just talk about parameterized monad transformers here :] Cheerio!

2 1

Looking for pointfree version
by Edsko de Vries 15 Feb '09

15 Feb '09

Hi, Is there a nice way to write down :: Focus -> [Focus] down p = concat [downPar p, downNew p, downTrans p] in point-free style? (In doesn't make much difference what these functions do; if it helps, their types are downPar, downNew, downTrans :: Focus -> [Focus]). Ideally, I would like to write something like down = downPar ... downNew ... downTrans but I'm not sure what should be on the dots. This works: down = concat . flip map [downPar, downNew, downTrans] . flip ($) but is extremely ugly and doesn't really explain what's going on :) (It seems to me I should be able to take advantage of the list monad, somehow). Pointers appreciated! Edsko

11 12

Help needed with apache config for hackage
by Duncan Coutts 15 Feb '09

15 Feb '09

Hi folks, Does anyone have any experience with apache configuration, particularly mime types and handling browser quirks and would like to help us with an issue we have on hackage? http://hackage.haskell.org/trac/hackage/ticket/498 The problem is described in the ticket but basically IE6 gets confused by the Content-Type and Content-Encoding and ends up saving ".tar.gz" files with the wrong name ".tar.tar". We need help working out how to configure apache to use a workaround and with testing that the solution actually works. Thanks! Duncan

3 5

ANNOUNCE: spacepart-0.1.0.0 (was called data-spacepart)
by Corey O'Connor 15 Feb '09

15 Feb '09

0.1.0.0 - Renamed Math.Geometry to Data.SpacePart.AABB - Renamed Data.QuadTree to Data.SpacePart.QuadTree - Added Data.SpacePart.QuadTree.query. Returns all elements that intersect a given boundary. - The inclusive nature of the boundary's min extent should take precedence of the exclusive nature of the max extent. Before this change many of the tests failed when boundaries of 0 area were involved. One case that did not work was constructing a quadtree containing elements of 0 area. This change corrected this. The tests all_elements_inserted_query_prop and element_bounds_query_is_element_prop still fail if any element involved is of 0 area. - Cannot create quadtrees with initial bounds of 0 area. - Removed requirement on elements being an instance of the Intersectable class. The only required instance is of Data.SpacePart.AABB.HasBoundary. - Changed package name to spacepart instead of data-spacepart. The last release of data-spacepart used a data based version number. This version number policy did not work well with the standard package version policy. - Added some QuickCheck based checks. Run with test/run_verify - Cleaned up the module exports. Cheers, Corey O'Connor

1 1

Type families not as useful over functions
by John Ky 15 Feb '09

15 Feb '09

Hi Haskell Cafe, I tried using type families over functions, but when I try it complains that the two lines marked conflict with each other. class Broadcast a where type Return a broadcast :: a -> Return a instance Broadcast [a -> r] where type Return [a -> r] = a -> [r] -- Conflict! broadcast fs a = [] instance Broadcast [a -> b -> r] where type Return [a -> b -> r] = a -> b -> [r] -- Conflict! broadcast fs a b = [] Given that in Haskell, every function of n+1 arguments is also a function of n arguments, this is likely the cause of the conflict. In this case, currying is not my friend. Unfortunately this means I'm stuck with numbered function names: bc0 :: [r] -> [r] bc0 rs = rs bc1 :: [a -> r] -> a -> [r] bc1 [] a = [] bc1 (r:rs) a = (r a):bc1 rs a bc2 rs a b = rs `bc1` a `bc1` b bc3 rs a b c = rs `bc1` a `bc1` b `bc1` c -- etc Cheers, -John

6 8

Haddock Markup
by David Waern 15 Feb '09

15 Feb '09

I got the subject line wrong, so I'm reposting this: ==== Hi everyone, I received this question from Lennart Augustsson (via Simon M) and thought I'd send out an inquiry to the Haskell community in general (Lennart, I hope you don't mind): Lennart writes: > We have some local patches for haddock that extends the <<blah>> > syntax so you can put TeX formulae in the documentation. > It looks like, <<! LaTeX stuff here !>>, but I'd like to extend it so > you can process the string with any command. > > Are you interested in folding this into the main branch? So the question is about extending the Haddock markup language. When modifying the language we should think about the tension between familiarity, presentation features (pictures, math, whatever) and visual portability across different mediums (HTML, ghci, IDE tooltips, etc). And here I should say that Haddock already supports pictures using the << url >> syntax. IMHO, adding <<! LaTeX !>> for TeX math is fine, because: - math in documentation is often useful - if you're going to write math, you need a format, even when the medium is plain text as in ghci. - TeX formulae seem to be relatively widely used and understood. As for running arbitrary commands, I think we are opening up to a lot of unfamiliar syntax. I'd like to hear what everyone thinks about that. There was also a thread about Haddock markup on haskell-cafe@ about a year ago, which originated with the interesting idea of using Markdown (or a Pandoc-extended version of it) instead of the current language: http://www.mail-archive.com/haskell-cafe@haskell.org/msg38054.html I think the original idea there is pretty nice, but let's first focus on the current markup language in order to answer Lennart's question. That thread contains some useful opinions on this matter, also. So, any comments? :) David

15 33

The wheather is ⊥
by Henk-Jan van Tuyl 15 Feb '09

15 Feb '09

The temperature is now NaN°: http://traviswalters.net/?p=58 -- Met vriendelijke groet, Henk-Jan van Tuyl -- http://functor.bamikanarie.com http://Van.Tuyl.eu/ --

3 2

Need some ideas to map XML Schema types to Haskell types
by Praki Prakash 15 Feb '09

15 Feb '09

Hi, I need to work with a web service that has a few thousand types in its schema. I am trying to automate the generation of data types and serializers from the schema. My first thought was to map each data type to a Haskell record and generate pickle methods thereafter for serialziation/deserialization. However, I am seeing a few challenges in mapping Schema types to Haskell records. First issue is the naming conflicts with record fields. If the number of types were smaller, I could have manually mangled the name with a unique prefix. Using a type class for shared name fields seems like an option but it looks like quite a bit of work. Is there any other technique I can use? Second issue is with capturing the Schema type hierarchy. Is there any way to relate types? If not, what would be a good technique to represent type hierarchies? Thanks, Praki

1 0

Epic failure
by Andrew Coppin 15 Feb '09

15 Feb '09

OK, what did I do wrong here? module Main () where import Data.List top = 10 ^ 8 :: Int main = do let numbers = [1 .. top] print $ foldl' (+) 0 numbers -- Runtime is 20 seconds. #include <stdio.h> int main(void) { int total = 0; int n; for (n = 1, n < 100000000; n++) total += n; printf("%d", n); } // Runtime is 0.8 seconds. module Main () where import Data.List top = 10 ^ 8 :: Int kernel i o = if i < top then o `seq` kernel (i+1) (o+i) else o main = do print $ kernel 1 0 -- Runtime is 0.5 seconds. Clearly these two nearly identical Haskell programs should have exactly the same runtime. Instead, one is 40x slower. Clearly something has gone catastrophically wrong here. The whole point of GHC's extensive optimiser passes are to turn the first example into the second example - but something somewhere hasn't worked. Any suggestions?

2 1