May 2010 - Beginners - Haskell.org

Learning about channels
by Benjamin Edwards 17 Jul '10

17 Jul '10

NB: This was posted in fa.haskell first, I guess it was the wrong forum for this kind of question as it was left unanswered :) Hi, I'm having a few issues getting some toy programs to work whilst I try to get a better understanding of how to model processes and channels. I am just trying to use the real base blocks and failing miserably. Here is an example (yes this is utterly contrived and sill, but I lack imagination... sue me): I want my main thread to do the following: 1. make a channel 2. spawn a thread (producer) that will write a series of lists of integers to the the channel, then exit. 3. spawn another thread that will read from the channel and sum all of the input. It should exit when both the channel is empty and and the producer thread has finished writing to it. 4. Main thread should print the sum. My current code should uses a trick I have seen else where which is to have the result of "task" running in the thread put into an MVar. So my condition for the reading thread exiting is to check if the MVar of the producer thread is not empty and if the channel is empty. If those two things are true, exit the thread. Unfortunately if somehow seems able to to get to a stage where the produce thread has finished and the channel is empty, but is blocking on a read. I have the following code, but it always blocks indefinitely on a read. I am sure there is something obviously deficient with it, but I can't work out what it is. Any help would be greatly appreciated. Of course, if I'm doing it all wrong, please tell me that too :) module Main where import Control.Concurrent import Control.Concurrent.STM import Control.Monad (forever) import Data.Map as M main :: IO () main = do oc <- newChan counter <- newTVarIO (0 :: Integer) p <- forkJoin $ produce oc [1..1000] c <- forkJoin $ loop oc p counter takeMVar c >>= print produce :: Chan [Integer] -> [Integer] -> IO () produce ch [] = return () produce ch xs = do let (hs,ts) = splitAt 100 xs writeChan ch hs produce ch ts loop :: Chan [Integer] -> MVar () -> TVar Integer -> IO Integer loop ch p n = do f <- isEmptyMVar p e <- isEmptyChan ch if e && (not f) then atomically (readTVar n) else do xs <- readChan ch atomically $ do x <- readTVar n writeTVar n (x + sum xs) loop ch p n forkJoin :: IO a -> IO (MVar a) forkJoin task = do mv <- newEmptyMVar forkIO (task >>= putMVar mv) return mv

4 8

lazy IO in readFile
by Andrew Sackville-West 06 Jun '10

06 Jun '10

I'm trying to suss out the best (heh, maybe most idiomatic?) way to handle laziness in a particular file operation. I'm reading a file which contains a list of rss feed items that have been seen previously. I use this list to eliminate feed items I've seen before and thus filter a list of new items. (it's a program to email me feed items from a couple of low frequency feeds). So, the way I do this is to open the history file with readFile, read it into a list and then use that as a parameter to a filter function. Instead of getting confusing, here is some simple code that gets at the nut of the problem: import Control.Monad isNewItem :: [String] -> String -> Bool isNewItem [] = \_ -> True isNewItem ts = \x -> not (any (== x) ts) filterItems :: [String] -> [String] -> [String] filterItems old is = filter (isNewItem old) is getOldData :: IO [String] getOldData = catch (liftM lines $ readFile "testfile") (\_ -> return []) main = do let testData = ["a", "b", "c", "d"] :: [String] currItems <- getOldData let newItems = filterItems currItems $ testData print newItems -- this is important, it mimics another IO action I'm -- doing in the real code... appendFile "testfile" . unlines $ newItems Please ignore, for the moment, whatever *other* problems (idiomatic or just idiotic) that may exist above and focus on the IO problem. This code works fine *if* the file "testfile" has in it some subset of the testData list. If it has the complete set, it fails with a "resource busy" exception. Okay, I can more or less understand what's going on here. Each letter in the testData list gets compared to the contents of the file, but because they are *all* found, the readFile call never has to try and fail to read the last line of the file. Thus the file handle is kept open lazily waiting around not having reached EOF. Fair enough. But what is the best solution? One obvious one, and the one I'm using now, is to move the appendFile call into a function with guards to prevent trying to append an empty list to the end of the file. This solves the problem not by forcing the read on EOF, but by not bothering to open the file for appending: writeHistory [] = return () writeHistory ni = appendFile "testfile" . unlines $ ni And this makes some sense. It's silly to try to write nothing to a file. But it also rubs me the wrong way. It's not solving the problem directly -- closing that file handle. So there's my question, how can I close that thing? Is there some way to force it? Do I need to rework the reading to read one line ahead of whatever I'm testing against (thereby forcing the read of EOF and closing the file)? thanks A --

4 10

Installing GHC and GHCi on a PowerPC Mac running MacOS 10.5.8
by Paul Higham 02 Jun '10

02 Jun '10

I am a complete newbie but fascinated by the Haskell language. I am trying to install GHC and GHCi on an older Mac and it seems like the recommended Haskell Platform is not supported on PowerPC running MacOS 10.5.8. Is this correct? I find that following the links on the site http://haskell.org/ghc/distribution_packages.html#macosx just sends me in circles so I am appealing to you for some hints as to how to proceed. I already have XCode 3.1 installed and I have just updated my MacPorts installation but now I confess I am a bit stuck. Can you recommend a reasonable path to follow from here? Thanx ::paul

4 3

Re: [Haskell-beginners] Learning about channels
by Benjamin Edwards 01 Jun '10

01 Jun '10

That's a really good idea. Thanks for the insight :) On 31 May 2010 19:33, Dean Herington & Elizabeth Lacey < heringtonlacey(a)mindspring.com> wrote: > At 10:06 AM +0100 5/25/10, Benjamin Edwards wrote: > >> NB: This was posted in fa.haskell first, I guess it was the wrong forum >> for this kind of question as it was left unanswered :) >> >> Hi, >> >> I'm having a few issues getting some toy programs to work whilst I try >> to get a better understanding of how to model processes and channels. >> I am just trying to use the real base blocks and failing miserably. >> Here is an example (yes this is utterly contrived and sill, but I lack >> imagination... sue me): >> >> I want my main thread to do the following: >> >> 1. make a channel >> 2. spawn a thread (producer) that will write a series of lists of >> integers to the the channel, then exit. >> 3. spawn another thread that will read from the channel and sum all of >> the input. It should exit when both the channel is empty and and the >> producer thread has finished writing to it. >> 4. Main thread should print the sum. >> >> My current code should uses a trick I have seen else where which is to >> have the result of "task" running in the thread put into an MVar. So >> my condition for the reading thread exiting is to check if the MVar of >> the producer thread is not empty and if the channel is empty. If those >> two things are true, exit the thread. Unfortunately if somehow seems >> able to to get to a stage where the produce thread has finished and >> the channel is empty, but is blocking on a read. >> >> I have the following code, but it always blocks indefinitely on a >> read. I am sure there is something obviously deficient with it, but I >> can't work out what it is. Any help would be greatly appreciated. Of >> course, if I'm doing it all wrong, please tell me that too :) >> >> module Main >> where >> >> import Control.Concurrent >> import Control.Concurrent.STM >> import Control.Monad (forever) >> import Data.Map as M >> >> main :: IO () >> main = do oc <- newChan >> counter <- newTVarIO (0 :: Integer) >> p <- forkJoin $ produce oc [1..1000] >> c <- forkJoin $ loop oc p counter >> takeMVar c >>= print >> >> produce :: Chan [Integer] -> [Integer] -> IO () >> produce ch [] = return () >> produce ch xs = do let (hs,ts) = splitAt 100 xs >> writeChan ch hs >> produce ch ts >> >> loop :: Chan [Integer] -> MVar () -> TVar Integer -> IO Integer >> loop ch p n = do f <- isEmptyMVar p >> e <- isEmptyChan ch >> if e && (not f) >> then atomically (readTVar n) >> else do xs <- readChan ch >> atomically $ do x <- readTVar n >> writeTVar n (x + sum xs) >> loop ch p n >> >> forkJoin :: IO a -> IO (MVar a) >> forkJoin task = do mv <- newEmptyMVar >> forkIO (task >>= putMVar mv) >> return mv >> > > > By encoding end-of-data directly in the channel contents, you can simplify > the code (and make it less prone to hangs such as the one you experienced.) > I've shown one way to do this below. I've also made the accumulating count > a simple parameter to the consumer function. (Because the count is private > to the consumer until it's passed to the main routine via the consumer's > termination MVar, there's no need for additional inter-thread > synchronization.) > > Dean > > > > module Main where > > import Control.Concurrent > > main :: IO () > main = do oc <- newChan > p <- forkJoin $ produce oc [1..1000] > c <- forkJoin $ consume oc 0 > takeMVar c >>= print > > produce :: Chan (Maybe [Integer]) -> [Integer] -> IO () > produce ch [] = writeChan ch Nothing > > produce ch xs = do let (hs,ts) = splitAt 100 xs > writeChan ch (Just hs) > produce ch ts > > consume :: Chan (Maybe [Integer]) -> Integer -> IO Integer > consume ch cnt = do mbInts <- readChan ch > case mbInts of Just xs -> consume ch (cnt + sum xs) > Nothing -> return cnt > > > forkJoin :: IO a -> IO (MVar a) > forkJoin task = do mv <- newEmptyMVar > forkIO (task >>= putMVar mv) > return mv >

1 0

Arrow
by Luca Ciciriello 31 May '10

31 May '10

Hi All. As a mathematician I've studied the Arrows calculus as extension of the lambda calculus. Now I've found in the Haskell programming language that there is a library named Control.Arrow. I've read on Haskell wiki that Control.Arrow is a generalization of monads. So, is that library related in same way with the Arrows calculus? Thanks in advance for any answer. Luca.

2 2

forall confusion
by Philip Scott 30 May '10

30 May '10

Hi all, I was wondering if someone could give me an intuitive explanation of why in f :: forall a.(Show a) => a -> String f x = show x "forall a.(Show a) => a" appears to translate into "Any a, as long as it is an instance of Show" but if I use forall in an type qualifier in an assignment: myList = [] :: [forall a.(Show a) => a] "forall a.(Show a) => a" seems to mean "Any a, as long as it is bottom" I've been poring over http://en.wikibooks.org/wiki/Haskell/Existentially_quantified_types for the last hour and I feel like my eyes are starting to melt. As usual, any input would be warmly received :) All the best, Philip

4 3

ANNOUNCE : leksah 0.8.0.6 rpms for Fedora 13 now available
by Lakshmi Narasimhan T V 29 May '10

29 May '10

Hello, Following the official release of Leksah 0.8, rpms for Fedora 12 and Fedora 13 platforms are now available.. Before proceeding to install, remove any previous installations of leksah done via yum using the following command yum remove leksah leksah-server *Instructions for Fedora 12* *For x86* http://sites.google.com/site/lakshminaras2002/home/leksah-server-0.8.0.6-1.… http://sites.google.com/site/lakshminaras2002/home/leksah-0.8.0.6-1.fc12.i3… To install, use the following command yum --nogpgcheck install leksah-server-0.8.0.6-1.fc12.i386.rpm leksah-0.8.0.6-1.fc12.i386.rpm *For x86_64* http://sites.google.com/site/lakshminaras2002/home/leksah-server-0.8.0.6-1.… http://sites.google.com/site/lakshminaras2002/home/leksah-0.8.0.6-1.fc12.x8… To install, use the following command yum --nogpgcheck install leksah-server-0.8.0.6-1.fc12.x86_64.rpm leksah-0.8.0.6-1.fc12.x86_64.rpm -------------------------------------------------------------------------------------------------------------------------------------------------- *Instructions for Fedora 13* *For x86* http://sites.google.com/site/lakshminaras2002/home/leksah-0.8.0.6-1.f13.i68… http://sites.google.com/site/lakshminaras2002/home/leksah-server-0.8.0.6-1.… To install, use the following command yum --nogpgcheck install leksah-0.8.0.6-1.f13.i686.rpm leksah-server-0.8.0.6-1.f13.i686.rpm *For x86_64* http://sites.google.com/site/lakshminaras2002/home/leksah-server-0.8.0.6-1.… http://sites.google.com/site/lakshminaras2002/home/leksah-0.8.0.6-1.f13.x86… To install, use the following command yum --nogpgcheck install leksah-0.8.0.6-1.f13.x86_64.rpm leksah-server-0.8.0.6-1.f13.x86_64.rpm Thanks, -- Regards Lakshmi Narasimhan T V

1 0

Attribute Grammar and Type signature with Happy
by Julien Lange 28 May '10

28 May '10

Hi all, I am working with a "home-made" language, with a rather big grammar, for which I've made a parser with Happy. I am now trying to use attributes as I'd like to add several typecheck-like rules directly in the grammar. My problem is that as soon as I add attributes to my grammar, the type signatures of the rules seem to be wrong. Happy indeed produces a Haskell file, but GHC complains when I try to compile. *Is it possible to use type signatures with attribute grammar at all, if so, what kind of type is legit?* (I tried to use my grammar without type signature but GHC went mental and I had to kill -9 it.) I attached an example, abc.y (adapted from the Happy ones) which behaves as my grammar. I would like to know what I should put in place of the "????". Say, if I give "[Char]" as type for the first rule, GHC says: -------------------------------------- bc.hs:63:4: The lambda expression `\ happyInhAttrs -> ...' has one argument, but its type `[Char]' has none In the first argument of `HappyAbsSyn4', namely `(\ happyInhAttrs -> let happySelfAttrs = ... (happyConditions_1, happySubAttrs_1) = happy_var_1 happyEmptyAttrs .... in (happyConditions, happySelfAttrs))' (...) skip skip (...) abc.hs:141:54: Couldn't match expected type `Attrs a -> (t, t1)' against inferred type `[Char]' In the expression: f happyEmptyAttrs In a pattern binding: (conds, attrs) = f happyEmptyAttrs In the expression: let f = do_parse toks (conds, attrs) = f happyEmptyAttrs x = foldr seq attrs conds in (value x) -------------------------------------- While, when I remove the type (i.e. ":: {[Char]}"), everything works fine and the parse function is typed as "[Char] -> [Char]". Oh, and I use: - ghc-6.8.2 - happy 1.17 Many thanks, Julien. -- Julien Lange, Graduate Teaching Assistant, PhD Student ----------------------------------------------------- Department of Computer Science, University of Leicester, University Road, Leicester LE1 7RH. T: +44 (0)116 252 3904 http://www.cs.le.ac.uk/people/jl250/ ----------------------------------------------------- { module ABCParser where } %tokentype { Char } %token a { 'a' } %token b { 'b' } %token c { 'c' } %token newline { '\n' } %attributetype { Attrs a } %attribute value { a } %attribute len { Int } %name parse abcstring %% abcstring : alist blist clist newline { $$ = $1 ++ $2 ++ $3 ; $2.len = $1.len ; $3.len = $1.len } alist : a alist { $$ = $1 : $2 ; $$.len = $2.len + 1 } | { $$ = []; $$.len = 0 } blist : b blist { $$ = $1 : $2 ; $2.len = $$.len - 1 } | { $$ = [] ; where failUnless ($$.len == 0) "blist wrong length" } clist : c clist { $$ = $1 : $2 ; $2.len = $$.len - 1 } | { $$ = [] ; where failUnless ($$.len == 0) "clist wrong length" } { happyError = error "parse error" failUnless b msg = if b then () else error msg }

2 2

ANNOUNCE: Haskell Communities and Activities Report (18th ed., May 2010)
by Janis Voigtländer 28 May '10

28 May '10

On behalf of the many, many contributors, I am pleased to announce that the Haskell Communities and Activities Report (18th edition, May 2010) is now available in PDF and HTML formats: http://haskell.org/communities/05-2010/report.pdf http://haskell.org/communities/05-2010/html/report.html Many thanks go to all the people that contributed to this report, both directly, by sending in descriptions, and indirectly, by doing all the interesting things that are reported. I hope you will find it as interesting a read as I did. If you have not encountered the Haskell Communities and Activities Reports before, you may like to know that the first of these reports was published in November 2001. Their goal is to improve the communication between the increasingly diverse groups, projects, and individuals working on, with, or inspired by Haskell. The idea behind these reports is simple: Every six months, a call goes out to all of you enjoying Haskell to contribute brief summaries of your own area of work. Many of you respond (eagerly, unprompted, and sometimes in time for the actual deadline ;-) to the call. The editor collects all the contributions into a single report and feeds that back to the community. When I try for the next update, six months from now, you might want to report on your own work, project, research area or group as well. So, please put the following into your diaries now: ---------------------------------------- End of October 2010: target deadline for contributions to the November 2010 edition of the HC&A Report ---------------------------------------- Unfortunately, many Haskellers working on interesting projects are so busy with their work that they seem to have lost the time to follow the Haskell related mailing lists and newsgroups, and have trouble even finding time to report on their work. If you are a member, user or friend of a project so burdened, please find someone willing to make time to report and ask them to "register" with the editor for a simple e-mail reminder in October (you could point me to them as well, and I can then politely ask if they want to contribute, but it might work better if you do the initial asking). Of course, they will still have to find the ten to fifteen minutes to draw up their report, but maybe we can increase our coverage of all that is going on in the community. Feel free to circulate this announcement further in order to reach people who might otherwise not see it. Enjoy! Janis Voigtlaender <hcar at haskell.org>

1 0

Removing the biggest element from a list - maybe slow?
by Nathan Huesken 26 May '10

26 May '10

Hi, I want to remove the biggest element from a list: withoutBiggest (x:xs) = withoutBiggestImpl (biggest x xs) [] (x:xs) where biggest :: (Ord a) => a -> [a] -> a biggest big [] = big biggest big (x:xs) = if x > big then biggest x xs else biggest big xs withoutBiggestImpl :: (Eq a) => a -> [a] -> [a] -> [a] withoutBiggestImpl big before (x:xs) = if big == x then before ++ xs else withoutBiggestImpl big (before ++ [x]) xs Works, but I am a little concerned that this is slower than needed, because the list has to be iterated twice. Can this be done faster? Regards, Nathan

7 15