- Haskell-Cafe - Haskell.org

Mo' comprehensions
by Diego Navarro 31 Dec '06

31 Dec '06

I was solving some programming puzzles today[1], and found myself pining for Map comprehensions. Maybe there should be a Comprehensible class that's automatically mapped to comprehension syntax. It's rather odd to have them only for lists. That would be both more general and more elegant than just bringing back monad comprehensions. Is there any obvious reason why this wouldn't work? [1] www.projecteuler.net <-- fun stuff! -- -- Diego Navarro

4 3

HaXML - creating a simple document
by Terrence Brannon 31 Dec '06

31 Dec '06

Hello, I don't know why my simple example will not render a simple HTML document. For the moment, I simply want to render this: <html> </html> or whatever, the simplest document is. When I run my source code, it simply hangs (as the transcript below shows) {- SOURCE CODE -} import Text.XML.HaXml.Html.Generate import Text.XML.HaXml.Combinators import Text.XML.HaXml.Wrappers main = processXmlWith go go = html [] {- EXECUTION TRANSCRIPT  ghci mk.hs ___ ___ _ / _ \ /\ /\/ __(_) / /_\// /_/ / / | | GHC Interactive, version 6.6, for Haskell 98. / /_\\/ __ / /___| | http://www.haskell.org/ghc/ \____/\/ /_/\____/|_| Type :? for help. Loading package base ... linking ... done. [1 of 1] Compiling Main ( mk.hs, interpreted ) Ok, modules loaded: Main. *Main> main Loading package haskell98 ... linking ... done. Loading package HaXml-1.17 ... linking ... done. -}

3 3

Re: [Haskell-cafe] Literate Haskell source files. How do I
by Eric Kow 30 Dec '06

30 Dec '06

Hi, > On 30/12/06, Michael T. Richter <ttmrichter(a)gmail.com> wrote: > > Are there any tools which I can use to render .lhs files readable? I'm fine with having them converted into documented source (i.e. source code embedded in documentation) or as pure Haskell source (but without the huge whitespace gaps) -- but I can't figure out how to get either. The darcs code is a bit different in that the LaTeX "comments" are actually the user's manual (for the most part). The code is normally hidden when you compile the pdf. To see the code, you can apply the attached darcs patch. (You could also do it by hand; it's just a couple of changes). When you run make manual/darcs.ps, you will have a ps file that is simultaneously the darcs manual, and various bits of darcs code interspersed and highlighted in blue. (This is > 300 pages of literate darcs, mind you. Maybe just browsing it in a text editor is simpler) -- Eric Kow http://www.loria.fr/~kow PGP Key ID: 08AC04F9 Merci de corriger mon français.

1 0

Seeking advice on a style question
by Steve Schafer 30 Dec '06

30 Dec '06

In my text/graphics formatting work, I find myself doing a lot of "pipeline" processing, where a data structure will undergo a number of step-by-step transformations from input to output. For example, I have a function that looks like this (the names have been changed to protect the innocent--and to focus on the structure): process :: a -> b -> c -> d -> e process x1 x2 x3 x4 = let y01 = f01 x1 x2 x3; y02 = f02 x1; y03 = f03 y02; y04 = f04 y03; y05 = f05 x1 y01 y04; y06 = f06 x2 y05; (y07,y08) = f07 y01 y06; y09 = f08 y07; (y10,y11) = f09 x2 x4 y09 y08; y12 = f10 y10; y13 = f11 y12; y14 = f12 x1 x2 x3 y01 y13; y15 = f13 y14; y16 = f14 y15 y11 in y16 As you can see, the process is somewhat imperative in overall appearance, with each intermediate function f01..f14 accepting some combination of the original input values and/or intermediate values and returning a new value (or, in some cases, a tuple of values). Obviously, not all of the steps need to be broken out this way. We can, for example, skip the second and third steps and directly write: y04 = f04 $ f03 $ f02 x1; Laying it out this way has a couple of advantages. It makes the steps in the process transparently clear, and if I discover at some point that I need to make a change (e.g., a new requirement causes f13 to need access to x2), it's perfectly obvious where to make the modifications. Nevertheless, it also looks like something that would be amenable to processing with a State monad, except for one thing: The "shape" of the state isn't constant throughout the process. At any given step, new information may be added to the state, and old information may be thrown away, if there is no further need for it. In principle, it could be managed with a bunch of nested StateT monads, but my attempts to do so seem to get so caught up in the bookkeeping that I lose the advantages mentioned above. Alternatively, I can wrap all of the state up into a single universal structure that holds everything I will ever need at every step, but doing so seems to me to fly in the face of strong typing; at the early stages of processing, the structure will have "holes" in it that don't contain useful values and shouldn't be accessed. So here's the question: Is there a reasonable way to express this kind of process (where I suppose that "reasonable" means "in keeping with Haskell-nature") that preserves the advantages mentioned above, but avoids having to explicitly pass all of the various bits of state around? The (unattainable?) ideal would be something that looks like this: process = f14 . f13 . ... . f01 or process = f01 >>= f02 >>= ... >>= f14 Steve Schafer Fenestra Technologies Corp. http://www.fenestra.com/

10 21

Idiomatic Haskell equivalent of "keyword arguments" to functions
by Paul Moore 30 Dec '06

30 Dec '06

I'm thinking around the design of a couple of things, and am hitting an issue which I know how I would solve in Python, but I'm not sure what a good idiomatic Haskell approach would be. The problem is that I am trying to write a function which takes a rather large number of arguments, many of which are optional (ie, have sensible defaults). The canonical example of this is creating a GUI window, which involves a lot of style options, most of which would typically be left to default. In Python, this type of interface is often handled either as a function with many keyword arguments, or as a mutable object which has attributes set, and then a method called to handle the function call. Neither of these approaches seems plausible in Haskell. I looked at wxHaskell for inspiration - its approach (button f [text := "Quit", on command := close f]) looks quite readable, but slightly unusual (to me) for Haskell. It also seems fairly complex to implement (ie, my head hurt when I tried to follow the types involved, but maybe that's just because it's getting late :-)) To make things concrete, the example I'm really thinking of is a "send an email" function, which would take a subject, a body, a list of recipients, optional lists of cc and bcc recipients, an optional mailserver (default localhost), an optional port (default 25), and possibly optional authentication details. I found a couple of Haskell modules implementing a SMTP client, but they both just used a list of positional parameters, which I'm not really happy with. At the very least, I'd like to wrap them in a nicer interface for my code. I'd appreciate any ideas about how to think of this sort of problem - I'm pretty sure that what I need to do is think differently about the issue, rather than just mechanically translating the code I'd write in Python. But I don't really know how. Any pointers would be very helpful! Thanks, Paul.

5 6

how unsafe is this?
by Ben Clifford 30 Dec '06

30 Dec '06

I've defined a helper function to let me do regexps in functional style: > sed exp str = unsafePerformIO $ do > regexp <- regcomp exp 0 > regexec regexp str Is this always safe? or where is it not? (I'm using any one regexp more than once so it doesn't bother me that it compiles each time) --

2 1

Efficient way to break up a lazy bytestring
by Ranjan Bagchi 30 Dec '06

30 Dec '06

Hi -- I'm loading a big file (~2G), again, with 72-byte C structs. I've done pretty well [thanks to everyone] interpreting the fields, but I'm finding the traversal of the file to be pretty inefficient. I do the following: breakUp s | L.null s = [] | otherwise = h:(breakUp r) where (h,r) = L.splitAt 72 s Running this on the 2G file blows up the stack pretty quickly, taking the first 1 million records (there are 20M of them) with a big stack parameter gives about 25% productivity, with GC taking the other 75%. My understanding is that while this looks tail recursive, it isn't really because of laziness. I've tried throwing seq operators around, but they don't seem to do much to help the efficiency. Any help's appreciated. Ranjan

6 6

Newbie question
by Pieter Laeremans 30 Dec '06

30 Dec '06

Hi, I'm reading the Haskell school of expression by Paul Hudok. Great book. However I would like some feedback about a solution to an exercise The problem is quite simple : define f1 and f2 (using higher order functions ) such that f1 (f2 (*) [1..4]) 5 => [5,10,15,20] I have come up with the following solution : f2 :: (a->b)->[a] -> [b] f2 f xs = map f xs f1 fs a = map (applyOp a) fs applyOp b f = f b But I guess there must be some more elegant way. f2 isn't at all original. And the applyOp sounds silly. Any comments or suggestions are welcome. thanks, Pieter

2 1

constant functions
by michael rice 29 Dec '06

29 Dec '06

I'm trying to learn Haskell and translating some Lisp functions as exercises. How would I write a Haskell function named ALWAYS that behaves like this: one = always 1 bozo = always "clown" > map one [2,3,4,5,6] [1,1,1,1,1] > one 62 1 > map bozo [2,3,4,5,6] ["clown","clown" ,"clown", "clown"," clown"] > bozo 62 "clown" i.e. ALWAYS returns a function with a single parameter that is ignored, returning instead the value given to ALWAYS when the function was created. This is what I've been trying: always :: (a -> a) -> a -> a always x = (\y -> x) one = always 1 Michael __________________________________________________ Do You Yahoo!? Tired of spam? Yahoo! Mail has the best spam protection around http://mail.yahoo.com

8 13

Combine list of sorted lists
by Quan Ta 29 Dec '06

29 Dec '06

Hi all, I have this function which combines (zip) list of sorted lists into a sorted list (sorted by sum). The function works with infinite list and seems to give correct result. But after I see the code for the Hamming sequence from the Wiki, I wonder if it can be written better, or more clearly, or succint? import Data.List comb [] = [] comb (a:as) = foldl f2 (f1 a) as where f1 :: [Int] -> [[Int]] f1 [] = [] f1 (a:as) = [a] : f1 as f2 :: [[Int]] -> [Int] -> [[Int]] f2 la [] = [] f2 [] lb = [] f2 la@(a:as) lb@(b:bs) = (a ++ [b]) : (f3 (f2 [a] bs) (f2 as lb)) f3 :: [[Int]] -> [[Int]] -> [[Int]] f3 [] lb = lb f3 la [] = la f3 la lb = let a = head la b = head lb in if sum a <= sum b then a : f3 (tail la) lb else b : f3 la (tail lb) t1 = take 500 (comb [[1,2..],[1,23..],[1,5..],[1,9..]]) t2 = take 500 (sortBy (\x y -> compare (sum x) (sum y)) [[a,b,c,d] | a<-[1,2..80],b<-[1,23..80], c<-[1,5..80],d<-[1,9..80]]) --t3 = take 500 (sortBy (\x y -> compare (sum x) (sum y)) -- [[a,b,c,d] | a<-[1,2..],b<-[1,23..], -- c<-[1,5..],d<-[1,9..]]) main = print (show ((map sum t1) == (map sum t2))) -- thanks for looking, -- Quan

4 6