- Haskell-Cafe - Haskell.org

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