- Haskell-Cafe - Haskell.org

Re: Converting typeset mathematics into Haskell ?
by Bernd Brassel 25 Aug '09

25 Aug '09

Sometimes the synchronicity of events is eery. Incidentally I have just written a proposal for just such a project. You can have a look at it at http://www-ps.informatik.uni-kiel.de/~bbr/WebOfProofs.html Although not directly mentioned in the proposal, there will be a lot of "Converting typeset mathematics into Haskell" going on. Kind regards Bernd PS: And just in case I did it wrong again; this is the message I wanted to reply to http://www.haskell.org/pipermail/haskell-cafe/2009-August/065572.html

2 1

Converting typeset mathematics into Haskell ?
by Mark Wassell 25 Aug '09

25 Aug '09

Does anyone know of any papers or projects, either for Haskell or any other language, that relate to what I am going to attempt to describe in the following: Go to any paper or book that includes some amount of calculation type mathematics. An example is the formula in the Description section of http://en.wikipedia.org/wiki/K-means_clustering. Think about how you would convert this into Haskell. You might then find yourself wondering why you have to convert it into Haskell at all. Given that most mathematics online is typeset using something like latex or mathml, why can't we parse this typesetting and convert it into Haskell code? In all likelyhood the conversion might be ambiguous so some rules might be needed to guide the conversion. Furthermore, if there are editors that allow you to edit these sorts of equations in a wysiwyg style, why not leverage these to edit the Haskell+Math code also in a wysiwyg style. I think this goes to the larger question of why are most programming languages (or to be more exact the way we write programs in those languages) is still based around a linear sequence of tokens rather than something that is more 2D (there is still some linearity as even in math formula there is still a top down and left to right flow). Mark

4 3

Generics for constructing Rows
by Max Desyatov 25 Aug '09

25 Aug '09

Hi, all. I've come into trouble defining function `gmap` which will work on these data types: > data Row = Row > (E Name) > (E Salary) > (E Department) > type E a = Either (Maybe RowIndex) (Maybe a) > type RowIndex = Int `RowIndex`, `Name`, `Salary`, `Department` have kind * pseudocode: > gmap :: (E a -> E a) -> Row -> Row > readRow :: [String] -> Row -> Row > readRow l = gmap (\(Left (Just ri)) -> Right $ l `atMay` c >>= readMay) `atMay` and `readMay` are defined in module `Safe` from package `safe` > atMay :: [a] -> Int -> Maybe a > readMay :: (Read a) => String -> Maybe a Basically we have optional Row indices and try to read raw row (list of Strings) into the same Row type if index is present. At this moment I just have separate data type for row which has been read and just a list of row indices, but it is definitely flawed when I need to add fields to Row from time to time, as it is too easy to introduce bugs while positioning in list of row indices, not mentioning all those boilerplate code flowing around. I've tried to define gmap using libraries for generic programming but failed each time while type checking for different reasons. With `Data.Generics` and `gmapT` it fails because gmapT doesn't allow traversion function to have `Read a` constraint (Data and Typeable instances for Row and inner data types of course were derived). EMGM's map demands traversion function to be non-polymorphic, i.e. type-checker fails with the message, complaining it cannot match `E a` against `E Name`, against `E Salary` etc. For each of this I've spent smth about five hours just reading API docs, papers, and trying to beat type-checker. Maybe I'll look into Smash, RepLib and others, but I hope someone was also trying to define such gmap and succeeded. So, generic programming folks, is it even possible to define such function? I don't really care about using GHC extensions, I don't care about code being portable, I just want to remove boilerplate and prevent introducing bugs. Thanks in advance, Max.

3 5

ANNOUNCE: graphtype — A simple tool to illustrate dependencies between Haskell types
by Max Desyatov 25 Aug '09

25 Aug '09

While developing applications which deal with complex data it is crucial to know how exactly you manipulate this data. Haskell provides excellent tools for expressing a data scheme you work with: ADTs, `type` and `newtype` declarations, type classes and much more is hidden in rich Haskell's type system. Obviously, when types of data in your domain you work with grow — all declarations grow, and it becomes hard to grasp all dependencies, to change them and to remove them deliberately. graphtype was developed to visualise type declarations in you Haskell source files. It produces .dot-file for subsequent processing with graphviz. Results for example file bundled with graphtype: http://i.piccy.info/i4/00/90/bfa07290012c2d3b455696bdaa86.png To play with it, you can use hackage: http://hackage.haskell.org/package/graphtype or hack some code: http://github.com/explicitcall/graphtype Visualisation of dependencies in complex type class hierarchies is still on the way. It isn't obvious how do to this nicely, as in most cases type class declarations are imported from other libraries, and you don't always have source files for them. Anyway, graphtype is fairly usable. Leave here your questions, suggestions and have fun looking at type dependencies in your code. WBR, Max

2 1

Linking problem with GHCi
by Maurício CA 24 Aug '09

24 Aug '09

With a specific package (bindings-common, with the latest version in hackage) if I ask GHCi to read it I get: ghc-6.8.2: /home/mauricio/lib/bindings-common-0.2.5/ghc-6.8.2/HSbindings-common-0.2.5.o: unknown symbol `atexit' If I build a library or executable cabal package depending on it, I have no problems. Also, if I remove that 'atexit' wrap from 'bindings-common' I don't get this ghci error message anymore. Why would just this 'atexit' function be a problem? It's wrap does work well, and I can use it from a Haskell program through bindings-common (although not in ghci, of course). This happens at least in ghc-6.8.2 and 6.10.3. Thanks, Maurício

1 1

rotate image
by h 24 Aug '09

24 Aug '09

Hello, I already studied the references of gtk2hs for hours, as well as searched in the web, but didn't found any working solution. The problem is to load an image, a png with alpha channel, rotate it e.g. 10 degree, and show it on the screen, basically as when it would be shown with imageNewFromFile with transparency. Thanks in advance for your help. -- Best regards H.

3 2

ANN: rss2irc 0.3 released
by Simon Michael 24 Aug '09

24 Aug '09

rss2irc is an irc bot created by Don Stewart to watch rss feeds and announce new items on irc. I have been tweaking and testing it for a while, and have taken up the maintainer reins. I'm happy to announce release 0.3, with: - reliable http networking - irc flood protection - better error handling & reporting - extensive debugging output - Atom support - more useful defaults (enter channel silently, hide email addresses etc.) - precise control of irc output, including regexp rewrites - installable on mac osx Feedback and patches welcome. I am currently using it to run a number of announce-bots on freenode, including hackagebot and darcscommitbot. (A tip: if you experiment, avoid joining the irc server too frequently; once per minute may be ok.) home: http://hackage.haskell.org/package/rss2irc darcs repo: http://joyful.com/darcsweb/darcsweb.cgi?r=rss2irc -Simon

1 0

Problem building encoding-0.6.0: missing Data.CharMap.Builder
by João Rafael Nicola 24 Aug '09

24 Aug '09

Hi, I am trying to install the encoding-0.6.0 package, but it complains that that package "Data.CharMap.Builder" is missing. I could not find any reference to that package anywhere on the web. Does anyone know where I can find it or a workaround? Thanks, João Rafael > cabal install encoding Resolving dependencies... /tmp/encoding-0.6.08632/encoding-0.6.0/Data/Encoding/Preprocessor/XMLMappingBuilder.hs:11:7: Could not find module `Data.CharMap.Builder': Use -v to see a list of the files searched for. cabal: Error: some packages failed to install: encoding-0.6.0 failed during the configure step. The exception was: exit: ExitFailure 1

1 0

Gtk2Hs drag and drop
by frantisek kocun 24 Aug '09

24 Aug '09

Hi, have somebody used drag and drop feature of Gtk2hs? I can't find any tutorial or demo. I'm using only the documentation but I think I'm missing something. Can anyone give me an example? Thanks in forward! Fero

1 0

[ann] formlets 0.6
by Chris Eidhof 24 Aug '09

24 Aug '09

Hey everyone, I wanted to let you know that the formlets team has released a new version of the formlets [1] on hackage, a library to build type-safe, composable web forms. Most notably, Mightybyte and I worked on the massInput functionality, which is now ready for use! Mightybyte has an excellent article [2] on how to use the massInput to build dynamic forms on the client side. If you're building web apps with Haskell, make sure you check it out. -chris [1]: http://hackage.haskell.org/package/formlets [2]: http://softwaresimply.blogspot.com/2009/08/dynamic-list-formlets-in-haskell…

1 0

Functional Dependencies and multiparameter typeclasses
by Harald ROTTER 24 Aug '09

24 Aug '09

Dear Haskellers, I am using multi parameter typeclasses to represent images consisting of pixels (e.g. bitmap images). {-# OPTIONS_GHC -XMultiParamTypeClasses #-} module Bitmap where -- | a pixel could be a Word8 (e.g. a graysclale image) -- | or a 3-tuple for RGB images class Pixel p where .... <pixel related functions go here> -- | an image could be a UArray or a list of lists of pixels class Pixel p => Image a p where width :: a -> Int height :: a -> Int dims :: a -> (Int, Int) dims img = (height img, width img) If I try to load this module into ghci I get: Could not deduce (Image a p) from the context (Image a p2) arising from a use of 'height' at ..... and Could not deduce (Image a p1) from the context (Image a p2) arising from a use of 'width' at ...... where both errors originate from the 'dims' function. Eventually I figured out that I could remedy the situattion by using functional dependencies like this: class Pixel p => Image a p | a -> p where ... However, I do not really understand the cause of the original problem. Why do I need the functional dependency to make this work ? Any help is appreciated. Thanks Harald. " Ce courriel et les documents qui y sont attaches peuvent contenir des informations confidentielles. Si vous n'etes pas le destinataire escompte, merci d'en informer l'expediteur immediatement et de detruire ce courriel ainsi que tous les documents attaches de votre systeme informatique. Toute divulgation, distribution ou copie du present courriel et des documents attaches sans autorisation prealable de son emetteur est interdite." " This e-mail and any attached documents may contain confidential or proprietary information. If you are not the intended recipient, please advise the sender immediately and delete this e-mail and all attached documents from your computer system. Any unauthorised disclosure, distribution or copying hereof is prohibited."

3 2

Re: [Haskell-cafe] Functional Dependencies and multiparametertypeclasses
by Harald ROTTER 24 Aug '09

24 Aug '09

Thanks for the quick response. Your explanation is so much clearer than ghc's error messages :-)) Harald. |---------+------------------------------> | | Miguel Mitrofanov | | | <miguelimo38@yandex| | | .ru> | | | | | | | | | 24.08.2009 13:29 | | | Delivered date: | | | 24.08.2009 13:31 | | | | |---------+------------------------------> >------------------------------------------------------------------------------------------------------------| | | | To: Harald ROTTER <harald.rotter(a)sagem.com> | | cc: haskell-cafe(a)haskell.org | | Subject: Re: [Haskell-cafe] Functional Dependencies and multiparameter typeclasses | >------------------------------------------------------------------------------------------------------------| > However, I do not really understand the cause of the original problem. Why > do I need the functional dependency to make this work ? Suppose you have an instance: instance Pixel MyPixel where... instance Image MyImage MyPixel where width i = countPixels i ... And somebody (not necessarily you) makes another instance: instance Pixel CustomPixel where... instance Image MyImage CustomPixel where width i = 0 ... Now, take any image im :: MyImage Then you'd expect that width im :: Int But now there are TWO implementations of "width :: MyImage -> Int" and no way for compiler to figure out which one to use. GHC sort of foresees this problem. By adding a functional dependency you instruct it to forbid the second declaration, when the first one is present, thus removing the problem. " Ce courriel et les documents qui y sont attaches peuvent contenir des informations confidentielles. Si vous n'etes pas le destinataire escompte, merci d'en informer l'expediteur immediatement et de detruire ce courriel ainsi que tous les documents attaches de votre systeme informatique. Toute divulgation, distribution ou copie du present courriel et des documents attaches sans autorisation prealable de son emetteur est interdite." " This e-mail and any attached documents may contain confidential or proprietary information. If you are not the intended recipient, please advise the sender immediately and delete this e-mail and all attached documents from your computer system. Any unauthorised disclosure, distribution or copying hereof is prohibited."

1 0

ANNOUNCE: OAuth library in haskell
by Diego Souza 24 Aug '09

24 Aug '09

Dear Haskellers, hoauth is a library which helps you to deal with oauth protocol. Currently it supports only consumer side applications, but there are plans to add service providers support in near future. The source code can be found at [darcs]: http://projects.bitforest.org/hoauth/ and now in hackage: http://hackage.haskell.org/package/hoauth If you have any questions, comments or criticism, please get in touch with me. I'll appreciate it very much, specially because there are so many things yet to learn. Thanks, PS: This is the first piece of code I produce in Haskell since I've start learning it few months ago. I must say it has been a joy since then. -- ~dsouza yahoo!im: paravinicius gpg key fingerprint: 71B8 CE21 3A6E F894 5B1B 9ECE F88E 067F E891 651E

1 0

Where does documentation get installed with cabal?
by Colin Paul Adams 23 Aug '09

23 Aug '09

Hello, I'm trying to find the API documentation for happstack 0.3 (online is for 0.2). So I did: cabal install happstack --reinstall --enable-documentation but I can't find it anywhere within ~/.cabal - where should I look? -- Colin Adams Preston Lancashire

5 6

hslogger and syslog-ng
by Magnus Therning 23 Aug '09

23 Aug '09

I'm having some problem with logging to syslog using System.Log.Logger and friends. I have the following: > :m +System.Log.Logger > :m +System.Log.Handler.Syslog > sl <- openlog "foo" [PID] USER DEBUG > updateGlobalLogger rootLoggerName (addHandler sl) > warningM "bar" "test" *** Exception: sendTo: protocol error (Protocol wrong type for socket) What could be the cause for this? I've tried hsyslog and it reports to my instance of syslog without problems. My system is a 32-bit Arch Linux, running syslog-ng 3.0.3. /M -- Magnus Therning (OpenPGP: 0xAB4DFBA4) magnus＠therning．org Jabber: magnus＠therning．org http://therning.org/magnus identi.ca|twitter: magthe

2 6

Monad woes
by Levi Greenspan 23 Aug '09

23 Aug '09

Hi all, I try to create a simple monad using a stack of Reader and IO but when using it, I encounter some problems. The Monad is defined as M a: {-# LANGUAGE GeneralizedNewtypeDeriving #-} module Main where import Control.Monad.Reader import Control.Concurrent newtype M a = M { unM :: ReaderT String IO a } deriving (Monad, MonadIO, MonadReader String) runM :: String -> M a -> IO a runM s m = runReaderT (unM m) s loop :: (String -> M ()) -> M () loop f = forever $ f "hello" I then define a callback function to be invoked by 'loop': callback :: String -> M () callback s = liftIO $ print s >> threadDelay 1000000 So far so good. Then I test it like this: test1 :: IO () test1 = runM "foo" $ do loop callback liftIO $ print "here" -- OK. Never reached Still works fine. 'loop' never returns. In a real life application 'loop' is an event loop and I'd like to fork it into a new thread like this: test3 :: IO () test3 = runM "foo" $ liftIO $ do forkIO $ do return $ loop callback return () print "here" threadDelay 2000000 This not only looks ugly, it also doesn't work. For 'loop callback' to pass the type checker, it had to be returned into the IO monad. But I guess due to laziness, 'loop' will never be called. This can be confirmed without forkIO: test2 :: IO () test2 = runM "foo" $ liftIO $ do return $ loop callback print "here" Again, 'loop callback' will not be invoked. Now, given that I must find a way to combine IO and my M monad I don't know what to try next. Prima facie it seems I must somehow force 'loop callback' to be evaluated, but how? Not to mention all the liftIO clutter. I would greatly appreciate some help here. Thank you very much! Cheers, Levi

3 5

STM problems
by Michael Speer 23 Aug '09

23 Aug '09

I am playing a writing a simple STM hashtable. I expected the following code to alter the TVars in it, but they appear immutable. I assume I am simply doing something wrong, but I am not sure what it is. Any pointers would be greatly appreciated. import Control.Concurrent.STM import Control.Concurrent import Array data HashTable a b = HashTable (a -> Int) (STM (Array Int (TVar (Maybe b)))) mkHashTable :: ( a -> Int ) -> Int -> HashTable a b mkHashTable hashfn numBuckets | numBuckets > 0 = do HashTable hashfn $ do vs <- mapM (\v -> newTVar Nothing >>= \tv -> return (v,tv) ) [1..numBuckets] return $ array (1,numBuckets) vs readHashTable :: HashTable a b -> a -> STM (Maybe b) readHashTable hashtable key = let (HashTable hashfn table) = hashtable in table >>= \tb -> readTVar (tb ! hashfn key) writeHashTable :: HashTable a b -> a -> (Maybe b) -> STM () writeHashTable hashtable key value = let (HashTable hashfn table) = hashtable in table >>= \tb -> writeTVar (tb ! hashfn key) value >> return () main = let ht = mkHashTable id 10 :: HashTable Int String in do v <- atomically $ do mapM_ (\n -> writeHashTable ht n (Just $ "hello " ++ show n)) [1..10] mapM (\n -> readHashTable ht n) [1..10] print v

2 2

ANN: haskell-src-exts-1.1.3
by Niklas Broberg 23 Aug '09

23 Aug '09

Fellow Haskelleers, I'm pleased to announce the release of haskell-src-exts-1.1.3. * On hackage: http://hackage.haskell.org/package/haskell-src-exts * Via darcs: darcs get http://code.haskell.org/haskell-src-exts * Report bugs: http://trac.haskell.org/haskell-src-exts haskell-src-exts is a package for Haskell source code manipulation. In particular it defines an abstract syntax tree representation, and a parser and pretty-printer to convert between this representation and String. It handles (almost) all syntactic extensions to the Haskell 98 standard implemented by GHC, and the parsing can be parametrised on what extensions to recognise. haskell-src-exts-1.1.3 is a highly experimental release, which (apart from a small bug fix, see below) doesn't do anything at all to the current stable part of haskell-src-exts. But the release is far from as boring as all that may sound, as it includes a whole new set of modules implementing a new and more accurate syntax tree where all nodes are adorned with annotations. Together with this comes a parser that retains exact source information, stored in the aforementioned annotations. There is also support for various precision for source information, including SrcSpans. The new modules mirror the ones in the stable part of haskell-src-exts but instead live in Language.Haskell.Exts.Annotated{.Syntax,.Parser,...} (except that SrcLoc and friends now have their own module). The point of this release is that those of you that for one reason or other are waiting for these features can help me look, feel, test and comment these things in isolation, and hopefully report a lot of bugs, before I integrate this stuff with the main haskell-src-exts body of code. Note that that coming integration is intended to be backwards-compatible, but a lot of the behind-the-scenes will be switched over to the new and more general machinery. Feature-wise, with this accurate source tree in hand, the next step is to write a printer that uses the full location information to allow full and exact round-tripping, i.e. (print . parse == id). == haskell-src-exts-1.1.3 == * Adds support for more accurate, and fully annotated, abstract syntax, see above. * Fixes a bug that forced 'rec' statement groups to end with a qualifier (like 'do'). Cheers and Happy Haskelling, /Niklas

3 3

Help starting a Haskell blog
by Peter Verswyvelen 23 Aug '09

23 Aug '09

I'm going start my very first blog, documenting my everyday struggle to switch my old imperative mind to the lazy functional setting, with a focus on FRP. Although you can find a lot of articles that provide help to get started with general blogging, it might be useful to pick a blog in which presenting Haskell code is easy (e.g. like hpaste that does the syntax coloring for you), and where users can give feedback, providing code, also with syntax coloring preferably. It would also be nice to allow hyperlinking every function in the code to the standard Haskell library docs or to the docs on Hackage. Googling for "how to start a Haskell blog" just revealed a lot of Haskell blogs. Could you share your experiences with me about starting a blog? BTW: I'm on Windows. Thanks a lot, Peter Verswyvelen

6 8

ANN: ByteString Nums
by Jason Dusek 23 Aug '09

23 Aug '09

This is a simple package for relatively careless parsing of numbers from ByteStrings. It works to parse out integer strings, floating point strings and hex strings. http://hackage.haskell.org/package/bytestring-nums For integer strings, an initial sign is detected and non-digit characters are ignored: Prelude> :load Data.ByteString.Nums.Careless.Int *Data.ByteString.Nums.Careless.Int> let strings = ["121.3040", "1o2", "-a1", "0xff", "-0x30"] *Data.ByteString.Nums.Careless.Int> fmap (int . pack) strings :: [Int] [1213040,12,-1,0,-30] *Data.ByteString.Nums.Careless.Int> fmap (int . pack) strings :: [Double] [1213040.0,12.0,-1.0,0.0,-30.0] For hexadecimal strings, no signs are recognized and characters that aren't hex digits are ignored. One consequence of this is that an initial `0x` is skipped. Prelude> :load Data.ByteString.Nums.Careless.Hex *Data.ByteString.Nums.Careless.Hex> let strings = ["121.3040", "1o2", "-a1", "0xff", "-0x30"] *Data.ByteString.Nums.Careless.Hex> fmap (hex . pack) strings :: [Int] [18952256,18,161,255,48] The float parser recognizes the last group of digits behind a comma or period as the fractional part; all preceding digits are treated as the integral part. Naturally, signs are handled. Prelude> :load Data.ByteString.Nums.Careless.Float *Data.ByteString.Nums.Careless.Float> let strings = ["121.3040", "2.100,32", "1,o2", "-a1", "0xff", "-0x30"] *Data.ByteString.Nums.Careless.Float> fmap (float . pack) strings :: [Double] [122.304,2100.32,1.2,-1.0,0.0,-30.0] *Data.ByteString.Nums.Careless.Float> fmap (float . pack) strings :: [Rational] [15163 % 125,52508 % 25,6 % 5,(-1) % 1,0 % 1,(-30) % 1] I have not applied any `SPECIALIZE` or `INLINE` directives at this time; it'd be great to have some insight in to optimizing collections of small functions like this library. -- Jason Dusek

1 0

Strange console IO behavior (at least on Windows)
by Peter Verswyvelen 23 Aug '09

23 Aug '09

The following program http://hpaste.org/fastcgi/hpaste.fcgi/view?id=8445#a8445 should echo the ASCII code of each character the user types, on the fly, with no line buffering whatsoever. But it doesn't. At least not under Windows's cmd, and even less with msys. Under Windows, I have to press enter before anything is printed to the screen. It then always prints 71 (that's upper G, no idea where that comes from), and then blocks. Pressing enter again prints the codes of all characters typed, except the first one, following by the two codes of the linefeeds. So e.g. when I type "abc" ENTER, I get 71, then hitting ENTER again, I get 98 99 10 10. Under msys, it just ignores both the hSetBuffering and hSetEcho, but when hitting enter, it at least prints the codes correctly. How does it behave under OSX and Linux? Is this a bug or am I doing something wrong?

4 5

Re: quick and dirty file parsing (was: no subject)
by John Lato 22 Aug '09

22 Aug '09

> From: staafmeister <g.c.stavenga(a)uu.nl> > > Thank you for the reply. > > > Thomas ten Cate wrote: >> >> Although you most certainly can use a State monad, in most problems >> this isn't necessary. Most algorithms that you need to solve >> programming contest problems can be written in a purely functional >> style, so you can limit monadic code to just a few helper functions. >> > > Yes I know but there are a lot of problems requiring O(1) array updates > so then you are stuck with IO again Depending on the problem, you may be able to find a better data type than an array. Of course, since we're discussing generalities it's hard to make any specific recommendations. > > Thomas ten Cate wrote: >> >> For example, this reads input in the style you mention (assuming the >> strings don't contain whitespace): >> >>> import Control.Monad >>> >>> answer = id >>> >>> parse [] = [] >>> parse (s:p:r) = (s, (read p) :: Int) : parse r >>> >>> run = getLine >> getLine >>= putStrLn . show . answer . parse . words >>> >>> main = flip replicateM_ run =<< readLn >> >> The answer function would be a pure function that computes the answer >> for a particular run. This main function is reusable for all problems >> with many runs. >> >> Observe that the number of edges (e), provided as a convenience for >> memory allocation in many other languages, is not even necessary in >> Haskell :) >> > > Yes you're main is short. But how would you do it elegantly if > instead of line breaks and spaces one would have only spaces. > Every thing on one big line. My C code would not mind one bit. If I read it properly, this code won't either. The "words" function at the end of the pipeline will split tokens on any whitespace. > > > Thomas ten Cate wrote: >> >> (If anyone knows a better way than explicit recursion to map over a >> list, two elements at a time, or zip its even elements with its odd >> elements, I'd love to hear! I can imagine a convoluted fold with a >> boolean in its state, but it's ugly.) >> > > Yes I missed such a function in a couple of problems I wanted to solve. > I would expect a generic function > groupN::Int -> [a] -> [[a]] > that groups a list into groups of N I often use this function as well. I think it's not in the libraries because it's so simple to define: groupN :: Int -> [a] -> [[a]] groupN n [] = [] groupN n xs = let (h,t) = splitAt n xs in h:groupN n t Or, for a nonrecursive version: groupN2 = fix g where g f n [] = [] g f n xs = let (h,t) = splitAt n xs in h: f n t but that's probably not what you had in mind. I've found that using unfoldr is simpler than fold if you wish to use HOFs to accomplish this, but neither is as simple as explicit recursion. John Lato

1 0

Requesting suggestions for the GraphViz library
by Ivan Lazar Miljenovic 22 Aug '09

22 Aug '09

Whilst I've apparently been on holidays overseas, I was bored enough (and frustrated enough with it) to re-write large parts of the GraphViz library. In particular, I now use a pretty-printing class and a new parsing class so I think the problem with quotes is over \o/ However, there are some design decisions I'd like advice on from users of this library; these are items that I can implement either way but I'm not sure what other people would prefer: * I have re-written large parts of the overall DotGraph and associated data structures, with one difference being that they are polymorphic in the node type; this should make the eventual change to the generic graph class (whenever we get around to doing it) simpler. However, I have left the ID of the DotGraph and the new DotSubGraph data structures as being the GraphID type (which is an algebraic type with number, string and URL support to match the official types of values understood by GraphViz); should I leave it as this or make them polymorphic in the Graph ID type as well? That is, you would have something like "DotGraph l n", with `l' being the type of the GraphIDs and `n' being the type of the node IDs. * With parsing of Dot code, the new data structure layout now more fully/correctly supports upstream by specifying a "DotStatements" data structure for use with DotGraph and DotSubGraph; DotStatements contains a list of (Global) Attributes, a list of DotSubGraphs, a list of Nodes and a list of Edges. At the moment, the parser expects these four types of statements to indeed be listed in that order, though it would be feasible to have the parser accept them in any order and then split them into these four types. Note that this could change the behaviour of how the graph is drawn (specifically in terms of where the Attributes are listed). Do people want a fully-fledged/capable parser or is the current setup sufficient? * The FGL <-> DotGraph functions now have the option to take a Bool parameter which indicates whether the specified graph is directed or undirected (with primed versions attempting to automatically determine this). If the graph is indicated to be undirected, then an edge (n1,n2) is kept if n1 <= n2; should I replace this Bool with a ternary algebraic type that allows the user to indicate that the graph is undirected but to keep all edges? * In the current available release, I had rudimentary error detection support for misuse of attributes. I have re-written this to an extent, and can do so even more to find even more possible errors (e.g. duplicate node IDs); do people actually care about this type of error detection? Am I just wasting my time on this? * With Color values (and since the issue seems to have re-arisen about spelling regarding Russell O'Connor's colour package, I use the American spelling because that's what upstream uses), I do not as yet bother matching up String color names with the colorset being used, etc. Something like this would require a State-based parser; does anyone care enough about this that they want it? The same thing goes for LayerSep, etc. Note that the user would then have to check themselves to make sure that they are using these correctly (that is, they have previously set which colorset they are using). If you're interested in seeing exactly what I've done, the darcs repo is at http://code.haskell.org/graphviz. Han Joosten has already asked me to implement record-based shapes, which I'll be looking at at some point to see how I can implement it into the current system. Otherwise, out of the 7 items on the TODO list I had from the previous version, this as-yet unreleased version has fixed 4 of them. If there's any other requests on what to do, please let me know. -- Ivan Lazar Miljenovic Ivan.Miljenovic(a)gmail.com IvanMiljenovic.wordpress.com

1 0

Re: [Haskell-cafe] Re: Where do I put the seq?
by Peter Verswyvelen 21 Aug '09

21 Aug '09

Not at all, use it for whatever you want to :-) I'm writing this code because I'm preparing to write a bunch of tutorials on FRP, and I first wanted to start with simple console based FRP, e.g. making a little text adventure game, where the input/choices of the user might be parsed ala parsec, using monadic style, applicative style, and arrows, and then doing the same with FRP frameworks like Yampa, Elera, Reactive, etc... After that I would start writing tutorials that use OpenGL, making some very simple games, again with the above approaches, and ending with a conversion of a very old game of mine (Zarathrusta written in assembler from 1991, which was based on Thrust <http://www.bytecellar.com/archives/000106.php>from 1986, converted by myself in C++ to PocketPC as G-Pod<http://www.handango.com/catalog/ProductDetails.jsp?productId=16574&platform…>, and so I would like to make a version in Haskell that runs on the iPhone :-) This of course is a lot of work, and I would like to put this on the Haskell wiki or a blog or something, so others can contribute and comment. I would like to show real examples that explain the shortcomings of the FRP approaches, because now this is still a bit blurry to me. On Wed, Aug 19, 2009 at 5:43 PM, David Leimbach <leimy2k(a)gmail.com> wrote: > This Monad you've created is quite excellent. I was trying to do something > like this about a year ago, to make the input and output handling of an > interactive bowling score card work nicely. I kept running into issues, and > did not believe that seq was going to do the trick. Nice work! > This is a very useful monad I think, it could be called "Prompter" or > something to that effect. > > Do you mind if I use it in some of my code? > > Dave > > > On Wed, Aug 19, 2009 at 8:42 AM, Peter Verswyvelen <bugfact(a)gmail.com>wrote: > >> LOL. Maybe we should have that coffee together ;-) at least virtually! >> >> On Wed, Aug 19, 2009 at 5:39 PM, David Leimbach <leimy2k(a)gmail.com>wrote: >> >>> Argh... I too have been up too late :-). I edited THE WRONG FILE! No >>> wonder your change didn't take effect! :-/ >>> Time for coffee I suppose. >>> >>> >>> On Wed, Aug 19, 2009 at 8:38 AM, David Leimbach <leimy2k(a)gmail.com>wrote: >>> >>>> This doesn't seem to be working for me interactively though on a Mac. I >>>> still get "Welcome" before I've entered text. >>>> >>>> >>>> On Wed, Aug 19, 2009 at 8:25 AM, Peter Verswyvelen <bugfact(a)gmail.com>wrote: >>>> >>>>> I fixed it myself but it's really tricky :-) >>>>> http://hpaste.org/fastcgi/hpaste.fcgi/view?id=8316#a8330 >>>>> >>>>> <http://hpaste.org/fastcgi/hpaste.fcgi/view?id=8316#a8330>The idea is, >>>>> that when the input is requested, the output that is then generated must be >>>>> in sync with the input. >>>>> >>>>> inp = S $ \s i -> let r = (*s** **`**D**.**append**`** **(**i** **`**seq**`** **D**.**empty**)*, head i) in (tail i, r) >>>>> >>>>> >>>>> >>>>> I first had >>>>> >>>>> inp = S $ \s i -> let r = (i `seq` *s*, head i) in (tail i, r) >>>>> >>>>> >>>>> But that was too eager, since i syncs the input not with the output, >>>>> but with the function that will generate the output. >>>>> >>>>> Okay, now I can sleep again :-) >>>>> >>>>> >>>>> >>>>> >>>>> On Wed, Aug 19, 2009 at 5:12 PM, Peter Verswyvelen <bugfact(a)gmail.com>wrote: >>>>> >>>>>> Thanks, but that doesn't really matter in my example, my code is just >>>>>> buggy, and I'm not sure why. For example if I change my test function so >>>>>> that it outputs lines only, then it still prints Welcome first before asking >>>>>> for input. >>>>>> See e.g. http://hpaste.org/fastcgi/hpaste.fcgi/view?id=8316#a8328 >>>>>> >>>>>> On Wed, Aug 19, 2009 at 5:00 PM, David Leimbach <leimy2k(a)gmail.com>wrote: >>>>>> >>>>>>> Try LineBuffering. >>>>>>> I do linewise stuff with interact a lot. You'll find stuff like >>>>>>> >>>>>>> unlines . lines >>>>>>> >>>>>>> may help too. In fact I just wrote a blog post about this. >>>>>>> >>>>>>> http://leimy9.blogspot.com >>>>>>> >>>>>>> I'm trying to write some interactive code to automate working with >>>>>>> serial console controlled power strips, so I need to either use Expect >>>>>>> (yuck) or do my own thing. >>>>>>> >>>>>>> Dave >>>>>>> >>>>>>> On Wed, Aug 19, 2009 at 7:35 AM, Peter Verswyvelen < >>>>>>> bugfact(a)gmail.com> wrote: >>>>>>> >>>>>>>> Apparently this particular example happens to work on Mac and Linux >>>>>>>> because of different buffering (thanks Martijn for the help!) >>>>>>>> To make sure we have no buffering at all, the main function should >>>>>>>> be: >>>>>>>> >>>>>>>> main = do hSetBuffering stdout NoBuffering hSetBuffering stdin NoBuffering test >>>>>>>> >>>>>>>> Now I think it should also be *incorrect* on Unix systems. >>>>>>>> >>>>>>>> I guess the way I'm concatenating the strings is not correct, not >>>>>>>> sure. >>>>>>>> >>>>>>>> I would like to use a graphical tool to show the graph reduction >>>>>>>> step by step, to get a better understanding of the laziness & strictness. >>>>>>>> Does such a tool exist? I know people often say this is not usable because >>>>>>>> the amount of information is too much, but I used to be an assembly language >>>>>>>> programmer so I still would like to give it a try :-) >>>>>>>> >>>>>>>> >>>>>>>> >>>>>>>> On Wed, Aug 19, 2009 at 1:07 PM, Peter Verswyvelen < >>>>>>>> bugfact(a)gmail.com> wrote: >>>>>>>> >>>>>>>>> In an attempt to get a deeper understanding of several monads >>>>>>>>> (State, ST, IO, ...) I skimmed over some of the research papers (but didn't >>>>>>>>> understand all of it, I lack the required education) and decided to write a >>>>>>>>> little program myself without using any prefab monad instances that should >>>>>>>>> mimic the following: >>>>>>>>> main = do >>>>>>>>> putStrLn "Enter your name:" >>>>>>>>> x <- getLine >>>>>>>>> putStr "Welcome " >>>>>>>>> putStrLn x >>>>>>>>> putStrLn "Goodbye!" >>>>>>>>> >>>>>>>>> But instead of using IO, I wanted to make my own pure monad that >>>>>>>>> gets evaluated with interact, and does the same. >>>>>>>>> >>>>>>>>> However, I get the following output: >>>>>>>>> >>>>>>>>> Enter your name: >>>>>>>>> Welcome ...... >>>>>>>>> >>>>>>>>> So the Welcome is printed too soon. >>>>>>>>> >>>>>>>>> This is obvious since my monad is lazy, so I tried to put a seq at >>>>>>>>> some strategic places to get the same behavior as IO. But I completely >>>>>>>>> failed doing so, either the program doesn't print anything and asks input >>>>>>>>> first, or it still prints too much output. >>>>>>>>> >>>>>>>>> Of course I could just use ST, State, transformers, etc, but this >>>>>>>>> is purely an exercise I'm doing. >>>>>>>>> >>>>>>>>> So, I could re-read all papers and look in detail at all the code, >>>>>>>>> but maybe someone could help me out where to put the seq or what to do :-) >>>>>>>>> >>>>>>>>> The code is at http://hpaste.org/fastcgi/hpaste.fcgi/view?id=8316 >>>>>>>>> >>>>>>>>> Oh btw, the usage of DList here might not be needed; intuitively it >>>>>>>>> felt like the correct thing to do, but when it comes to Haskell, my >>>>>>>>> intuition is usually wrong ;-) >>>>>>>>> >>>>>>>>> Thanks a lot, >>>>>>>>> Peter Verswyvelen >>>>>>>>> >>>>>>>>> >>>>>>>> >>>>>>>> _______________________________________________ >>>>>>>> Haskell-Cafe mailing list >>>>>>>> Haskell-Cafe(a)haskell.org >>>>>>>> http://www.haskell.org/mailman/listinfo/haskell-cafe >>>>>>>> >>>>>>>> >>>>>>> >>>>>> >>>>> >>>> >>> >> >

13 45

Re: How to convert a list to a vector encoding its length in its type?
by John Lato 21 Aug '09

21 Aug '09

> From: David Menendez <dave(a)zednenem.com> > > or, equivalently, by using a higher-order function. > > toPeano :: Int -> (forall n. Nat n => n -> t) -> t > Incidentally, this is the approach used in the type-level library [1], which provides the function: reifyIntegral :: Integral i => i -> (forall n. Nat n => n -> r) -> r The docs describe this as "In CPS style (best possible solution)," although I didn't see any reference for that assertion. Bas, if you'd like some examples, the ForSyDe project [2] has a tutorial on using type-level vectors, which I found helpful when faced with the same problem recently [3], [4]. Cheers, John Lato [1] http://hackage.haskell.org/package/type-level [2] http://www.ict.kth.se/forsyde/files/tutorial/apa.html [3] http://inmachina.net/~jwlato/haskell/iter-audio/src/Sound/Iteratee/Channeli… [4] http://inmachina.net/~jwlato/haskell/iter-audio/examples/channelized_reader…

1 0

Fwd: [BostonHaskell] September meeting polls
by Ravi Nanavati 21 Aug '09

21 Aug '09

I'm forwarding this to haskell-cafe to catch any current or new Boston-area Haskellers who haven't yet joined the BostonHaskell Google group: http://groups.google.com/group/bostonhaskell If you're interested in Boston-area Haskell activity, please join the Google group so you won't miss out on relevant discussions and announcements. Thanks, - Ravi Nanavati ---------- Forwarded message ---------- From: Ravi Nanavati <ravi_n(a)alum.mit.edu> Date: Fri, Aug 21, 2009 at 6:26 PM Subject: [BostonHaskell] September meeting polls To: bostonhaskell(a)googlegroups.com In the interests of getting the September BostonHaskell meeting organized sooner rather than later (and because Doodle polling has been successful so far), I'd like to take a different approach to arranging the meeting. I've created three polls to get the BostonHaskell community's opinion on the three decision points required before I can organize the meeting: 1. When: https://doodle.com/upd74stbe4d95zpb 2. Where: https://doodle.com/fpicbvb927nbb72v 3. What (to talk about): https://doodle.com/7b8kkcb9queiv89k If you're interested in attending the September BostonHaskell meeting, please answer any of the polls you have opinions about. The first two polls are approval polls (where you can indicate which alternatives you approve of), while the third poll (about choosing which talks) is a binary choice. Thank you in advance for participating. I'd also love to hear any comments people have on this new approach to organizing meetings. Thank you, - Ravi Nanavati --~--~---------~--~----~------------~-------~--~----~ You received this message because you are subscribed to the Google Groups "BostonHaskell" group. To post to this group, send email to bostonhaskell(a)googlegroups.com To unsubscribe from this group, send email to bostonhaskell%2Bunsubscribe(a)googlegroups.com For more options, visit this group at http://groups.google.com/group/bostonhaskell?hl=en -~----------~----~----~----~------~----~------~--~---

1 0

testing par with simple program
by Paolino 21 Aug '09

21 Aug '09

Hi, reading a previous thread I got interested. I simplified the example pointed by dons in import Control.Parallel main = a `par` b `pseq` print (a + b ) where a = ack 3 11 b = ack 3 11 ack 0 n = n+1 ack m 0 = ack (m-1) 1 ack m n = ack (m-1) (ack m (n-1)) compiled with ghc --make prova -O2 -threaded timings paolino@paolino-casa:~$ time ./prova +RTS -N1 32762 real 0m7.031s user 0m6.304s sys 0m0.004s paolino@paolino-casa:~$ time ./prova +RTS -N2 32762 real 0m6.997s user 0m6.728s sys 0m0.020s paolino@paolino-casa:~$ without optimizations it gets worse paolino@paolino-casa:~$ time ./prova +RTS -N1 32762 real 1m20.706s user 1m18.197s sys 0m0.104s paolino@paolino-casa:~$ time ./prova +RTS -N2 32762 real 1m38.927s user 1m45.039s sys 0m0.536s paolino@paolino-casa:~$ staring at the resource usage graph I can see it does use 2 cores when told to do it, but with -N1 the used cpu goes 100% and with -N2 they both run just over 50% thanks for comments paolino

2 3

Keeping an indexed collection of values?
by Job Vranish 21 Aug '09

21 Aug '09

I've been in a situation a lot lately where I need to keep a collection of values, and keep track of them by a persistent index. IO and ST refs can do this, but for various reasons I can't/don't want to use them. My first hacked up attempt is as follows: data IndexedCollection a = IndexedCollection { nextKey :: Int, availableKeys :: [Int], items :: (IntMap Int a) } deriving (Show) emptyIndexedCollection :: IndexedCollection a emptyIndexedCollection = IndexedCollection 0 [] empty addItem :: a -> IndexedCollection a -> (Int, IndexedCollection a) addItem a (IndexedCollection nextKey' [] t) = (nextKey', IndexedCollection (nextKey' + 1) [] (insert nextKey' a t)) addItem a (IndexedCollection nextKey' (k:ks) t) = (k, IndexedCollection nextKey' ks (insert k a t)) removeItem :: Int -> IndexedCollection a -> IndexedCollection a removeItem k (IndexedCollection nextKey' ks t) = IndexedCollection nextKey' (k:ks) (delete k t) lookupItem :: Int -> IndexedCollection a -> Maybe a lookupItem k (IndexedCollection _ _ t) = lookup k t Basically: when you add an item, use the first index in availableKeys (if there is one), otherwise use "nextKey" for the index, and then increment it for the next item. When and Item is removed, add it's index to availableKeys This keeps the code for keeping track of/generating indexes hidden away from the rest of the program which is nice, and it remains fairly efficient. Items will be added and removed on very regular basis. Often enough that I'm slightly concerned about overflow of nextKey for very long run times, and hence the availableKeys list. Does anyone know of a better/already existent data structure for handling this problem? Or perhaps a better way of keeping a "key pool" than my availableKeys solution? - Job

4 7

Re: [Haskell-cafe] Right way to implement setPixel function
by CK Kashyap 21 Aug '09

21 Aug '09

thank you very much Job. Regards, Kashyap On Thu Aug 20th, 2009 1:13 PM EDT Job Vranish wrote: >Opps: >setPixel = State setPixel' > >should be: >setPixel x y rgb = State $ setPixel' x y rgb > >- Job > >On Thu, Aug 20, 2009 at 1:05 PM, Job Vranish <jvranish(a)gmail.com> wrote: > >> Your setPixel function is almost ready to work in a State monad >> If you modify your setPixel function slightly like so: >> >> setPixel' :: Int -> Int -> Color -> B.ByteString -> ((), B.ByteString) >> setPixel' x y (r,g,b) image = ((), B.concat [beforePixel, pixel, >> afterPixel]) >> >> and then wrap it in the State monad constructor: >> >> setPixel = State setPixel' >> >> then you can do >> >> drawPixels = do >> setPixel 5 10 (200, 0, 0) >> setPixel 20 1 (0, 200, 0) >> setPixel 90 2 (0, 0, 200) >> >> modifiedImage = execState drawPixels originalImage >> >> See! you were already using a monad and didn't even know it! :D >> >> Performance wise, B.concat is O(n), which is very not good for your >> purpose. It copies the whole string and the optimizer won't be able to >> magically make it go away. For something that works in O(1), you will have >> to use something like STArrays instead of bytestrings. >> >> - Job >> >> >> >> On Thu, Aug 20, 2009 at 2:32 AM, CK Kashyap <ck_kashyap(a)yahoo.com> wrote: >> >>> Hi, >>> I had posted a note on line drawing algo with Haskell some time back. Now, >>> I am trying to write a PNM image. >>> >>> import qualified Data.ByteString as B >>> >>> width = 256 >>> height = 256 >>> bytesInImage = width * height * 3 >>> blankImage = B.pack $ take bytesInImage (repeat 0) >>> >>> type Color = (Int,Int,Int) >>> setPixel :: B.ByteString -> Int -> Int -> Color -> B.ByteString >>> setPixel image x y (r,g,b) = B.concat [beforePixel, pixel, afterPixel] >>> where >>> beforePixel = B.take before image >>> afterPixel = B.drop (before+3) image >>> pixel=B.pack [(fromIntegral r),(fromIntegral >>> g),(fromIntegral b)] >>> -- number of bytes before the 3 bytes of >>> -- the pixel at x y >>> before = (y * width * 3) + (x * 3) - 3 >>> >>> main = do >>> putStrLn "P6" >>> putStrLn ( (show width) ++ " " ++ (show height) ) >>> putStrLn "255" >>> -- Set a red pixel at 100 100 >>> B.putStr (setPixel blankImage 100 100 (255,0,0)) >>> >>> >>> Can I please have some review comments on the code above? Would recreating >>> the entire ByteString for each setPixel be an overhead? >>> Also, I am barely beginning to grasp the Monad concept....I was wondering >>> if there could be a monadic style of implementation of this - that could >>> potentially have a series of setPixels inside a do block? >>> >>> Regards, >>> Kashyap >>> >>> >>> _______________________________________________ >>> Haskell-Cafe mailing list >>> Haskell-Cafe(a)haskell.org >>> http://www.haskell.org/mailman/listinfo/haskell-cafe >>> >>> >>

1 0

Parsec lookahead and <|>
by Martijn van Steenbergen 21 Aug '09

21 Aug '09

Goedemiddag café, Consider the following function, using parsec-3.0.0: > la :: Parsec String () (Maybe Char) > la = lookAhead (optionMaybe anyChar) *Lookahead> parseTest (char 'a' <|> char 'b') "a" 'a' *Lookahead> parseTest (char 'a' <|> char 'b') "b" 'b' *Lookahead> parseTest (la *> char 'a' <|> char 'b') "a" 'a' *Lookahead> parseTest (la *> char 'a' <|> char 'b') "b" parse error at (line 1, column 2): unexpected "b" expecting "a" The first three work fine and as expected, but the fourth example fails where I would expect success. I know <|> won't try the rhs if the lhs consumed input, but lookAhead's documentation promises not to consume any input. Is this a bug in Parsec or am I missing something? Thanks, Martijn.

4 5

Re: Parsec lookahead and <|>
by Daniel Fischer 21 Aug '09

21 Aug '09

Apologies to Christian for the double post, didn't look at the To-field. Am Thursday 20 August 2009 20:21:30 schrieben Sie: > Daniel Fischer wrote: > > Am Donnerstag 20 August 2009 13:44:15 schrieb Martijn van Steenbergen: > >> Goedemiddag café, > >> > >> Consider the following function, using parsec-3.0.0: > >>> la :: Parsec String () (Maybe Char) > >>> la = lookAhead (optionMaybe anyChar) > >> > >> *Lookahead> parseTest (char 'a' <|> char 'b') "a" > >> 'a' > >> *Lookahead> parseTest (char 'a' <|> char 'b') "b" > >> 'b' > >> *Lookahead> parseTest (la *> char 'a' <|> char 'b') "a" > >> 'a' > >> *Lookahead> parseTest (la *> char 'a' <|> char 'b') "b" > >> parse error at (line 1, column 2): > >> unexpected "b" > >> expecting "a" > >> > >> The first three work fine and as expected, but the fourth example fails > >> where I would expect success. I know <|> won't try the rhs if the lhs > >> consumed input, but lookAhead's documentation promises not to consume > >> any input. Is this a bug in Parsec or am I missing something? > > > > Bad bug in Parsec (from the beginning, the same happens in parsec-2), I'd > > say. > > I'd say, its a feature. lookAhead returns whatever its argument returns. > So in this case it returns "Consumed" without consuming. In that case, the comment "lookAhead p parses p without consuming any input." from the parsec-3 docs is highly misleading. But lookAhead returning Consumed is not only counterintuitive, try parseTest (many la) "a" for a nice memory bomb. > > You can always wrap around a "try" to force the alternative: > > parseTest (try (la >> char 'a') <|> char 'b') "b" > > Cheers Christian > > Maybe it should have been: > > la >> (char 'a' <|> char 'b') > > in the first place.

2 1

Tips for deployment?
by Günther Schmidt 20 Aug '09

20 Aug '09

Hi all, my haskell app is getting closer to shipping and what I need to do now is to give product protection some thought. The product is for hospitals and therefore a very limited set of clients. I do not expect anyone to try to "hack" my application but I need a basic protection mechanism in place, if only to check for a valid license key. As I've never done this before I'd be grateful for some suggestions here. Günther

2 1

Right way to implement setPixel function
by CK Kashyap 20 Aug '09

20 Aug '09

Hi, I had posted a note on line drawing algo with Haskell some time back. Now, I am trying to write a PNM image. import qualified Data.ByteString as B width = 256 height = 256 bytesInImage = width * height * 3 blankImage = B.pack $ take bytesInImage (repeat 0) type Color = (Int,Int,Int) setPixel :: B.ByteString -> Int -> Int -> Color -> B.ByteString setPixel image x y (r,g,b) = B.concat [beforePixel, pixel, afterPixel] where beforePixel = B.take before image afterPixel = B.drop (before+3) image pixel=B.pack [(fromIntegral r),(fromIntegral g),(fromIntegral b)] -- number of bytes before the 3 bytes of -- the pixel at x y before = (y * width * 3) + (x * 3) - 3 main = do putStrLn "P6" putStrLn ( (show width) ++ " " ++ (show height) ) putStrLn "255" -- Set a red pixel at 100 100 B.putStr (setPixel blankImage 100 100 (255,0,0)) Can I please have some review comments on the code above? Would recreating the entire ByteString for each setPixel be an overhead? Also, I am barely beginning to grasp the Monad concept....I was wondering if there could be a monadic style of implementation of this - that could potentially have a series of setPixels inside a do block? Regards, Kashyap

2 2

Haddock: Failed to create dependency graph (when adding sections with * or a module heading)
by Jared Updike 20 Aug '09

20 Aug '09

I compiled and installed haddock-2.4.2 from the tarball source. Adding a few simple comments to the code here: https://dl.getdropbox.com/u/143480/doc/DualMap.hs and running haddock $ haddock -h -o doc Data/DualMap.hs Warning: Data.DualMap: could not find link destinations for: Data.Typeable.Typeable2 GHC.Base.Eq GHC.Show.Show GHC.Base.Ord GHC.Base.Bool Data.Set.Set yields: https://dl.getdropbox.com/u/143480/doc/Data-DualMap.html Things look good. (Note that this module only depends on libs that ship with GHC and no other source modules.) However, when I try to add sections (a la http://www.haskell.org/haddock/doc/html/ch03s04.html#id289234 ) in the comments with "-- * test" I get: $ haddock -h -o doc Data/DualMap.hs Data/DualMap.hs:20:0: parse error on input `-- * test' haddock: Failed to create dependency graph I have no idea where to begin getting this to work since this error message only tells me that Haddock.Interface.depanal returned Nothing (according to a grep of the haddock sources) but not how to stop the dependency analysis from failing. Perhaps I need some more command line arguments or references to missing link destinations in GHC/base/containers documentation or some haddock config file? Searching Google yielded plenty of cabal build errors of the same ilk for packages on hackage but nothing about how to fix them. Jared.

1 1

Can't derive Binary for StdGen
by Grigory Sarnitskiy 20 Aug '09

20 Aug '09

Hello! I'm trying to derive Binary for StdGen with DrIFT: module Main where import System.Random import Data.Binary {-!for StdGen derive : Binary !-} data Foo = Foo StdGen StdGen deriving (Show) {-! derive : Binary !-} but I got error "DrIFT: can't find module System/Random" What shall I do?

2 1

generalize RecordPuns and RecordWildCards to work with qualified names?
by Evan Laforge 20 Aug '09

20 Aug '09

Record punning is not all that useful with qualified module names. If I write '(M.Record { M.rec_x })' it says " Qualified variable in pattern" and if I write '(M.Record { rec_x })' it says 'Not in scope: `rec_x''. Could it be this extension be further extended slightly so that 'f (M.Record { M.rec_x })' will desugar to 'f (M.Record { M.rec_x = rec_x })'? Similarly, RecordWildCards could support this too. It seems simple and useful to me... am I missing anything fatally problematic about this? Would anyone else use it?

4 7

gbp sign showing as unknown character by GHC
by Iain Barnett 20 Aug '09

20 Aug '09

Quick question: I've tested this in a couple of different terminals (roxterm and xterm), so I'm fairly sure it's GHC that's the problem. Have I missed a setting? GHCi, version 6.10.4 Prelude> putStrLn "£" � Hugs98 200609-3 Hugs> putStrLn "£" £ I get the same character output from a password generator I've writtern, after compilation with GHC [iainb]$ ./makepass2 50 2 >> testfile.txt [iainb]$ cat testfile.txt H(xW!:maNyxZ;h,IW=Uu4G$ztc>k@Q[g6?y:�TbG&5Nd")+"5+ Iain

7 12

ANNOUNCE: ministg-0.2, an interpreter for STG operational semantics
by Bernie Pope 20 Aug '09

20 Aug '09

I'm pleased to announce the first public release of Ministg. Ministg is an interpreter for a high-level, small-step, operational semantics for the STG machine. The STG machine is the abstract machine at the core of GHC. The operational semantics used in Ministg is taken from the paper "Making a fast curry: push/enter vs. eval/apply for higher-order languages" by Simon Marlow and Simon Peyton Jones. Ministg implements both sets of evaluation rules from the paper. One of the main features of Ministg is the ability to record a trace of the execution steps as a sequence of html files. And example trace can be viewed here: http://www.cs.mu.oz.au/~bjpop/trace/step0.html The example shows the execution of a program which sums a list of three integers, using the well-known space-leaky version of sum. Follow the "next" and "previous" links to step forwards and backwards through the trace. The main reason I wrote Ministg is to explore various extensions to the STG machine. The current release features a simple extension in the form of call-stack tracing, which is strongly influenced by the cost-centre stacks of GHC. I expect it will also be a useful tool for people who are interested in learning more about the STG machine. More detailed information is available from the haskellwiki page: http://www.haskell.org/haskellwiki/Ministg You can download it from hackagedb: http://hackage.haskell.org/package/ministg Or you can get the latest code from patch-tag: darcs get http://patch-tag.com/r/ministg/pullrepo ministg Cheers, Bernie.

1 0

Generics for constructing Rows
by Max Desyatov 20 Aug '09

20 Aug '09

Sorry for a type and probably confusing you, it must be: > readRow l = gmap (\(Left (Just ri)) -> Right $ l `atMay` ri >>= readMay) instead of > l `atMay` c

1 0

Planning for a website
by Colin Paul Adams 20 Aug '09

20 Aug '09

I'm intending to replace my current website - which uses Drupal, with a hand-written-in-Haskell version this autumn, for a number of reasons (a principal one is the lack of an upgrade path in Drupal). So I'm currently looking into the libraries available to see how much I'll have to write myself. One problem will be to get GHC ported to DragonFly BSD, but that can wait until I have a test version of the site working on Linux. The next major challange is to implement something like Drupal's Image and Image Gallery modules. That doesn't seem to be a great problem, as the exif and GD libraries seem to cover everything I'll need. So my major decision is what framework and html-generating libraries to use. There is such a wide choice on the Haskell Wiki. But I guess some are more maintained than others. For instance, WASH attracts me, with it's guarantee of valid generated pages, but it isn't clear to me that it's actively maintained (last date I can see on the web pages is 2006). HappStack is obviously currently maintained, and since it seems to have a blogging module in development, that is attractive. HASP is maintained too, I think. Has anyone written a comparison of the various libraries, or gone through the same decision process recently? -- Colin Adams Preston Lancashire

8 11

Control.Parallel on 6.10.4 - Mac OS X version
by Kevin Smith 20 Aug '09

20 Aug '09

I'm using the Control.Parallel package on ghc version 6.10.4 and I don't seem to be getting any parallel threads or sparks created at all with the "-threaded" compilation option using runtime flags "+RTS -N2". I'm using simple examples from the paper "A Tutorial on Parallel and Concurrent Programming in Haskell" by Jones and Singh. I'm running on an Intel Mac core 2 duo. Does anyone know how I can check if the parallel functionality in ghc is working on my 6.10.4 ghc package installed on this platform ? I installed it from the "supported" runtime pkg for OS X from the ghc website. thanks

2 2

Re: [Haskell-cafe] gbp sign showing as unknown character by GHC
by Iain Barnett 19 Aug '09

19 Aug '09

2009/8/19 David Leimbach <leimy2k(a)gmail.com> > Interesting... GHCI bug? Didn't the readline dependency go away not too > long ago? Could it be related? > I just tried this Prelude> putStrLn "\£" ghc: panic! (the 'impossible' happened) (GHC version 6.10.4 for i386-unknown-linux): charType: '\163' Please report this as a GHC bug: http://www.haskell.org/ghc/reportabug So perhaps I should put in a bug report, as that shouldn't happen (it doesn't with some other characters I tried), unless anyone has a different idea? I'm running Arch Linux with xmonad and using roxterm, so perhaps it's something to do with my setup? Iain

4 4

Observations about foldM
by Jason McCarty 19 Aug '09

19 Aug '09

[This message is literate Haskell] Hi -cafe, I was trying to use Monad.foldM in the State monad recently and ran into some performance issues. They were eventually fixed with seq, but along the way I made some discoveries, which I thought I would share. The Report defines foldM as foldM :: (Monad m) => (a -> b -> m a) -> a -> [b] -> m a foldM f z [] = return z foldM f z (x:xs) = f z x >>= \z' -> foldM f z' xs It turns out that foldM is essentially a right fold. Define f' = \h t -> flip f h >=> t. The operator (>=>) is (reverse) Kleisli composition, defined in Control.Monad as f >=> g = \x -> f x >>= g. Now foldM f z xs = foldr f' return xs z. Proof. On the empty list, foldM f z [] = return z [definition of foldM] = foldr f' return [] z [definition of foldr] Now fix a list xs and inductively assume that foldM f z xs = foldr f' return xs z for all z. Then for any z and x, foldM f z (x:xs) = f z x >>= \z' -> foldM f z' xs [definition of foldM] = f z x >>= \z' -> foldr f' return xs z' [inductive hypothesis] = f z x >>= foldr f' return xs [eta-conversion(*)] = flip f x z >>= foldr f' return xs [definition of flip] = (\z' -> flip f x z' >>= foldr f' return xs) z [beta-reduction] = (flip f x >=> foldr f' return xs) z [definition of >=>] = (f' x (foldr f' return xs)) z [definition of f'] = foldr f' return (x:xs) z [definition of foldr] (*) The eta-conversion preserves strictness as long as return /= _|_, since f >=> g is in WHNF. Interestingly, foldM can also be written as a left fold. To see this, note that it is a theorem that foldr f z xs = foldl f z xs as long as f is associative and z is a unit for f. Since (>=>) is associative with unit return, we have foldr (\h t -> flip f h >=> t) return = foldr (>=>) return . map (flip f) [foldr/map fusion] = foldl (>=>) return . map (flip f) [by the theorem] = foldl (\t h -> t >=> flip f h) return [foldl/map fusion] Therefore foldM f z xs = foldr f' return xs z = foldl f'' return xs z, where f'' = \t h -> t >=> flip f h. But this doesn't mean these all have the same performance characteristics. Exercise for the reader: find examples where the foldr version performs better than the foldl version and vice-versa. I've noticed this distinction between State and [] in particular. They both may require use of seq in the function f to prevent stack overflow. Here is a module implementing these versions of foldM. It seems reasonable to have versions with <=< and with f unflipped as well, but those could be derived from the functions below. > module FoldM (foldrM, foldr1M, foldlM, foldl1M) where > import Control.Monad((>=>)) > -- foldrM nests to the right: > -- foldrM f z [x1, ..., xn] = (flip f x1 >=> (... >=> (flip f xn)...)) $ z > foldrM :: Monad m => (a -> b -> m a) -> a -> [b] -> m a > foldrM f z xs = foldr (\h t -> flip f h >=> t) return xs z Surprisingly, this may or may not be faster than the equivalent foldrM f z = return z >>= foldr (\h t -> flip f h >=> t) return xs depending on the monad. But they're both slower than foldM. > foldr1M f (x:xs) = foldrM f x xs > -- foldlM nests to the left: > -- foldlM f z [x1, ..., xn] = (...(flip f x1) >=> ...) >=> flip f xn) $ z > foldlM :: Monad m => (a -> b -> m a) -> a -> [b] -> m a > foldlM f z xs = foldl (\t h -> t >=> flip f h) return xs z Again, this is apparently faster or slower than either of foldlM f z xs = return z >>= foldl (\t h -> t >=> flip f h) return xs foldlM f = foldl (\t h -> t >>= flip f h) . return depending on the monad. > foldl1M f (x:xs) = foldlM f x xs -- Jason McCarty <jmccarty(a)sent.com>

5 5

ANN: Typeful/Text/HTMLs (for AngloHaskell/for scrap?)
by Jon Fairbairn 19 Aug '09

19 Aug '09

A while ago I wrote this rather pedantic html library (it guarantees standards compliance via types, even down to the nesting restrictions). I announced it on the libraries list, but chronic fatigue gets in the way of following things up, so I haven't taken it any further until recently. And recently there have been other efforts in the HTML area that may make it out of date. Anyway, I think there are one or two useful ideas in it, and if I manage to get to AngloHaskell, I'd like to discuss it a bit, hence the announcement (rather closer to AH than I intended). You can get the whole thing with darcs get --partial http://homepage.ntlworld.com/jon.fairbairn/Typeful/Text/nHTMLs It should build with ghc 6.10 and haddock 2.4.2 or you can browse the documentation starting at <http://homepage.ntlworld.com/jon.fairbairn/Typeful/Text/HTMLs/Documentation…> and AngloHaskell people who are interested might want to look at <http://homepage.ntlworld.com/jon.fairbairn/Typeful/Text/HTMLs/TODO> -- Jón Fairbairn Jon.Fairbairn(a)cl.cam.ac.uk

2 4

Where do I put the seq?
by Peter Verswyvelen 19 Aug '09

19 Aug '09

In an attempt to get a deeper understanding of several monads (State, ST, IO, ...) I skimmed over some of the research papers (but didn't understand all of it, I lack the required education) and decided to write a little program myself without using any prefab monad instances that should mimic the following: main = do putStrLn "Enter your name:" x <- getLine putStr "Welcome " putStrLn x putStrLn "Goodbye!" But instead of using IO, I wanted to make my own pure monad that gets evaluated with interact, and does the same. However, I get the following output: Enter your name: Welcome ...... So the Welcome is printed too soon. This is obvious since my monad is lazy, so I tried to put a seq at some strategic places to get the same behavior as IO. But I completely failed doing so, either the program doesn't print anything and asks input first, or it still prints too much output. Of course I could just use ST, State, transformers, etc, but this is purely an exercise I'm doing. So, I could re-read all papers and look in detail at all the code, but maybe someone could help me out where to put the seq or what to do :-) The code is at http://hpaste.org/fastcgi/hpaste.fcgi/view?id=8316 Oh btw, the usage of DList here might not be needed; intuitively it felt like the correct thing to do, but when it comes to Haskell, my intuition is usually wrong ;-) Thanks a lot, Peter Verswyvelen

2 7

Hugs used in circuit simulations code
by Fernan Bolando 19 Aug '09

19 Aug '09

Hi all thanks to everyone that reviewed my code. The good news 1. I happy to say that it has become useful enough for me to use it in some matlab type caluculations. includes transient and dc op 2. The simple pivtoing code I added into the DSP Lu appears to be useable for this application. The bad news 1. If you dont use some strategy in simplifying circuits and use the simulator only, it would take a considerable amount of time to converge. A simple 10x10 non linear matrix will take 13 minutes. In a high-end circuit simulator this would have taken less than a second. What is everybodies expereience in speed difference between C and interpreted haskell? I am hoping to achieve at least 10x an equivalent C code. So if a 10x10 matrix takes 1 second for C I want it to take 10seconds for hugs. regards fernan -- http://www.fernski.com

4 4

Some trouble with AttoParsec.
by Jason Dusek 19 Aug '09

19 Aug '09

The linked to text demoes a seemingly impossible error when processing a lazy byte string with AttoParsec: I check to see if the ByteString is null, take the last character and get an exception. -- Jason Dusek http://hpaste.org/fastcgi/hpaste.fcgi/view?id=8309#a8309

1 2

Type family signatures
by Thomas van Noort 19 Aug '09

19 Aug '09

Hello, I have a question regarding type family signatures. Consider the following type family: type family Fam a :: * Then I define a GADT that takes such a value and wraps it: data GADT :: * -> * where GADT :: a -> Fam a -> GADT (Fam a) and an accompanying unwrapper: unwrap :: GADT (Fam a) -> (a, Fam a) unwrap (GADT x y) = (x, y) When Fam is declared using the first notation, type family Fam a :: * GHC HEAD gives the following error message: Main.hs:9:21: Couldn't match expected type `a' against inferred type `a1' `a' is a rigid type variable bound by the type signature for `unwrap' at Main.hs:8:20 `a1' is a rigid type variable bound by the constructor `GADT' at Main.hs:9:8 In the expression: x In the expression: (x, y) In the definition of `unwrap': unwrap (GADT x y) = (x, y) However, when Fam is declared as (moving the a to the other side of the :: and changing it into *), type family Fam :: * -> * everything is ok. So, it seems to me that GHC HEAD considers both signatures to be really different. However, I do not quite understand the semantic difference in my example, other than that Fam needs to be fully satisfied in its named type arguments. Note that GHC 6.10.3 does not accept the latter signature for Fam since it requires at least one index for some reason, that's why I'm using GHC HEAD. Regards, Thomas

5 7

Text.Html introduction
by Colin Paul Adams 19 Aug '09

19 Aug '09

http://www.haskell.org/ghc/docs/latest/html/libraries/xhtml/Text-XHtml.html says: "Based on the original Text.Html library by Andy Gill. See http://www.cse.ogi.edu/~andy/html/intro.htm for an introduction to that library. " But that link gives a not-found page. Anyone know where it is know? -- Colin Adams Preston Lancashire

4 3

simulation in the haskell way
by Eric Wong 19 Aug '09

19 Aug '09

Hello, Haskellers! I'm relatively new to haskell and due to my strong imperative background, it's really a pain to learn haskell. But I'm really indulged in it. :) Now I think I understand the basics of Haskell very well, such as the type system and monad. And for those data-flow kind of applications, I can easily structure the problem in a functional way and sketch out an intuitive picture of the computation. But for simulation kind-of problems, in which I think OO really fits the best, what's the haskell way to structure such problems? I once thought maybe I can use the State monad to simulate objects. But it's really hard for me to implement, because I think State monad is used to simulate a global shared state, is it right? Then what's the best way to simulate private states or just instead how to solve simulation problems such as a physical engine using the haskell way? Best regards. Eric

9 17