- Beginners - Haskell.org

help using Data.Map lookup - how to get values after the "Just" constructor
by Martin Tomko 21 Sep '10

21 Sep '10

Dear All, as a newbie, I am only just discovering some intricacies of haskell. I have a Data.Map map, and am trying the lookup function to get the value for a given key (it is a list in my case, btw). I am struggling to get access to the value, as it is constructed using Just. I know that the question is therefore more general then the application on Map, so I would be glad to get a wider picture. I Checked in Real World Haskell, btu did nto find and answer. In Haskell the craft of... I found the following (p263): mapValue :: (a->b)-> Maybe a -> Maybe b mapValue g (Just a) = Just (g a) mapValue g Nothing = Nothing Which is fine, but it makes the Just constructor travel through the whole code, which is annoying. Is there a way out? Or would that be a dirty hack? I do not quite understand the following discussion of maybe (p263-4), but it seems like the code suggested is able to return a value at the end... Thanks Martin

3 10

Re: [Haskell-beginners] The cost of generality, or how expensive is realToFrac?
by Daniel Fischer 20 Sep '10

20 Sep '10

On Monday 20 September 2010 05:09:16 you wrote: > I'm building with the latest Haskell Platform. GHC 6.12.3 and OpenGL > 2.2.1.1 :sigh: So we can forget about rewrite rules, newtypes, unsafeCoerce and all that Jazz. In OpenGL-2.2.1.1, GLclampf (and GLfloat &c.) were not newtypes, they were type synonyms, type GLclampf = Float and so on. So it's clear that GHC rewrites realToFrac to double2Float# in the benchmark, since it's converting to Float (that also explains the absence of casts in your core). Then, if floatToFloat is faster than realToFrac in your programme (compiled with optimisations), that probably means GHC doesn't spot an opportunity to replace realToFrac with double2Float# because the types are still polymorphic. Perhaps some type annotations would help.

1 0

database question
by Gaius Hammond 19 Sep '10

19 Sep '10

Hi all, I am trying to write the simplest possible database program in a monadic style. The aim of the program is to connect to the database, run a query, then print the results. My approach is - use the Reader monad to pass around the connection handle (lda) to the database - use the Writer monad to store the result set (rs) on its way back out - converted into [String] (one String per row) My code is: module Main where import Control.Monad.Reader import Control.Monad.Writer import Database.HDBC import Database.HDBC.Sqlite3 runDbApp lda f = do (a, rs) <- runWriterT (runReaderT f lda) return rs doQuery::MonadIO m => ReaderT Connection (WriterT [String] m) () doQuery = do lda <- ask -- get the database handle from the Reader rs <- quickQuery lda "select datetime ('now')" [] let rs' = map convRow rs mapM_ tell rs' -- store the results in the Writer where convRow [x] = (fromSql x)::String main = handleSqlError $ do lda <- connectSqlite3 "test.db" rs <- runDbApp lda $ doQuery mapM_ putStrLn rs -- end of file And the error is home/gaius/Projects/MonadDb/MonadDb.hs:15:2: Couldn't match expected type `IO [[SqlValue]]' against inferred type `ReaderT Connection (WriterT [String] m) [[SqlValue]]' In a stmt of a 'do' expression: rs <- quickQuery lda "select datetime ('now')" [] Why does it think that that is the final expression of the function? Any advice greatly appreciated. I have been struggling with this since lunchtime! Thanks, G

4 6

The cost of generality, or how expensive is realToFrac?
by Greg 19 Sep '10

19 Sep '10

First, to anyone who recognizes me by name, thanks to the help I've been getting here I've managed to put together a fairly complex set of code files that all compile together nicely, run, and do exactly what I wanted them to do. Success! The trouble is that my implementation is dog slow Fortunately, this isn't the first time I've been in over my head and I started by putting up some simpler scaffolding- which runs much more quickly. Working backwards, it looks like the real bottle neck is in the data types I've created, the type variables I've introduced, and the conversion code I needed to insert to make it all happy. I'm not sure it helps, but I've attached a trimmed down version of the relevant code. What should be happening is my pair is being converted to the canonical form for Coord2D which is Cartesian2D and then converted again to Vertex2. There shouldn't be any change made to the values, they're only being handed from one container to another in this case (Polar coordinates would require computation, but I've stripped that out for the time being). However, those handoffs require calls to realToFrac to make the type system happy, and that has to be what is eating up all my CPU. I think there are probably 4 calls to realToFrac. If I walk through the code, the result, given the pair p, should be: Vertex2 (realToFrac (realToFrac (fst p))) (realToFrac (realToFrac (snd p))) I'd like to maintain type independence if possible, but I expect most uses of this code to feed Doubles in for processing and probably feed GLclampf (Floats, I believe) to the OpenGL layer. If there's a way to do so, I wouldn't mind optimizing for that particular set of types. I've tried GLdouble, and it doesn't really improve things with the current code. Is there a way to short circuit those realToFrac calls if we know the input and output are the same type? Is there a way merge the nested calls? Any other thoughts on what I can do here? The slow down between the two implementations is at least 20x, which seems like a steep penalty to pay. And while I'm at it, is turning on FlexibleInstances the only way to create an instance for (a,a)? Thanks-- Greg --I want to scatter plot a list of pairs of Doubles data ScatterPlot = ScatterPlot {scatterPoints :: [(Double,Double)] } --this way is plenty fast GL.renderPrimitive GL.Points $ mapM_ GL.vertex (map pair2vertex $ scatterPoints plot) --using this function in the map pair2vertex :: (a,a) -> GL.Vertex2 a pair2vertex (x,y) = GL.Vertex2 x y --then I started to get fancy and build custom types for coordinates, hoping to start developing a library useful for --cartesian, polar, 3D, etc. I needed to create this trivial function to resolve a type ambiguity coordToVertex2 :: Coord2D a => a -> (GL.Vertex2 GL.GLclampf) coordToVertex2 = coordToCoord2D --which I call instead of pair2vertex GL.renderPrimitive GL.Points $ mapM_ GL.vertex (map coordToVertex2 $ scatterPoints plot) --Coord2D is a typeclass I created to hold 2D data data Cartesian2D a = Cartesian2D a a deriving (Show, Eq, Read) class Coord2D a where xComponent :: (RealFloat b) => a -> b yComponent :: (RealFloat b) => a -> b toCartesian2D :: (RealFloat b) => a -> Cartesian2D b toCartesian2D p = Cartesian2D (xComponent p) (yComponent p) fromCartesian2D :: (RealFloat b) => Cartesian2D b -> a --and this function allows conversion between coordinate representations coordToCoord2D :: (Coord2D a, Coord2D b) => a -> b coordToCoord2D = fromCartesian2D . toCartesian2D --I think the only other interesting bit of code is the instance definitions: {- Pair instances -} instance (RealFloat a, RealFloat b) => Coord2D (a,b) where xComponent = realToFrac . fst yComponent = realToFrac . snd fromCartesian2D p = ((xComponent p),(yComponent p)) {- Cartesian 2D instances -} instance (RealFloat a) => Coord2D (Cartesian2D a) where xComponent (Cartesian2D x _) = realToFrac x yComponent (Cartesian2D _ y) = realToFrac y fromCartesian2D p = Cartesian2D (xComponent p) (yComponent p) {- Vertex2 instance -} instance (RealFloat a) => Coord2D (Vertex2 a) where xComponent (Vertex2 x _) = realToFrac x yComponent (Vertex2 _ y) = realToFrac y fromCartesian2D p = Vertex2 (xComponent p) (yComponent p)

2 7

Haskell, Graphs, and Underpants
by Andrew Pennebaker 18 Sep '10

18 Sep '10

A quick and dirty guide to publishing graphs with Haskell and GraphViz: http://speely.wordpress.com/2010/09/17/haskell-graphs-and-underpants/ Cheers, Andrew Pennebaker

1 0

Re: [Haskell-beginners] Re: [Haskell-cafe] try, seq, and IO
by Jeroen van Maanen 17 Sep '10

17 Sep '10

Op 2010-09-17 06:32, Dean Herington schreef: > At 10:54 AM +0200 9/16/10, Jeroen van Maanen wrote: >> Op 2010-09-16 08:50, Jeroen van Maanen schreef: >> [...] >> >> Gregs suggestion provided the way out: evaluate. My code now looks like this: >> >> do let maybeUpdatedModel = f update startModel >> theCheckSum = maybe 0 checkSum maybeUpdatedModel >> logException exception = logger "Exception" [showString label, shows (exception :: SomeException)] >> return Nothing >> logger "Received update" [showString label, logs update] >> resultOrException <- try $ evaluate $ seq theCheckSum maybeUpdatedModel >> maybeNextModel <- either logException return resultOrException >> logger "Maybe next model" [showString label, logs maybeNextModel] >> -- ... >> >> I still don't understand why evaluating maybeUpdatedModel to WHNF after seq evaluated theCheckSum to WHNF forces the lurking exception to the surface. Or is the phrase 'when the resultant IO action is executed' in the documentation of 'evaluate' significant here? > > I still don't follow all your code, but presuming maybeUpdatedModel is of non-IO type, I'm guessing it's the evaluation of theCheckSum that causes evaluation of maybeUpdatedModel (which raises the exception). What I don't understand is the difference between: try $ return $ seq theCheckSum maybeUpdatedModel or even try $! return $! seq theCheckSum maybeUpdatedModel and try $ evaluate $ seq theCheckSum maybeUpdatedModel How is it possible that the exception escapes the former two expressions, but gets caught by the third try? Cheers, Jeroen

2 1

randomize the order of a list
by Gabriel Scherer 17 Sep '10

17 Sep '10

Gaius Hammond wrote: > I am trying to randomly reorder a list (e.g. shuffle a deck of cards) . > My initial approach is to treat it as an array, generate a list of > unique random numbers between 0 and n - 1, then use those numbers as new > indexes. Felipe Lessa wrote: > Note: you could use random-shuffle package [1]. > > [1] http://hackage.haskell.org/package/random-shuffle Heinrich Apfelmus wrote: > For another approach, see also > > http://apfelmus.nfshost.com/articles/random-permutations.html Thanks for the link apfelmus, it's fairly interesting. The key to making it work is the weighting of lists during merging based on their lengths. I wonder if other sort algorithm can be adapted in such a way, while preserving uniformity. Quicksort for example : is it enough to choose the result position of the pivot randomly, and then placing elements on either side with a probability of 1/2 ? There is another sort-based approach that is probably less elegant, but simpler in the sense that you don't have to rewrite your sorting routines : pick random "weights" for each of your elements, and sort the list based on the weights. This approach has been studied and criticized by [Oleg], whose analysis is the base of the random-shuffle package. Oleg rightly points out that this method does not achieve uniformity in general. What he failed to notice is that there is a simple workaround to regain uniformity with minimal changes. [Oleg] http://okmij.org/ftp/Haskell/perfect-shuffle.txt The uniformity breaker is the case were two elements get equal weights. In his example, weights for a 2-size lists are choosed in {0, 1}. In the two corner case were both elements get picked the same weight, the sorting routine make an arbitrary choice : for example, if it is stable, it will put first the element occuring sooner in the list. This arbitrary choice breaks uniformity. The workaround is simple : pick weights that are all differents. If the weights are picked among [1, n] were n is the size of the list, it is difficult and inneficient to generate a list of unique random numbers. But you can choose weights in arbitrary intervals. The bigger it is, the smaller the chance you have to pick weights again becomes (though due to the birthday paradox, it does not decrease that fast). To sum it up, here is the algorithm to shuffle a list : - for each element in the list, pick a random list - pick another weight list while two equal weights were picked - once you've picked *unique* weights, shuffle the elements of the list by comparing their weights If the weight are taken in a big enough interval (say [1, 2^64]), the average number of repicks necessary is small enough for this algorithm to be just a sorting using your preferred algorithm. I haven't went through the trouble of computing the necessary interval bound to get a small enough chance of conflict, but I believe the forth power of the size of the list should be enough. An even better technique is to use lazy lists of {0, 1} (representing real numbers) as weights, with each list element lazily randomly computed. You are sure than no two such lists are equal (they're different with probability 1). This amounts to a dynamical random refining of weights during the sorting : "two of my real number weights are equal at granularity 2^-N ? Let's make a random choice so that their {N-1}th digit is different !"

4 9

How to delete a range from AVL tree.
by Alexander.Vladislav.Popov 17 Sep '10

17 Sep '10

Hi. Help me to solve the problem I faced with. I'm trying to delete items from the AVL tree 'itree' that are between 0 and 2. But as you can see the result tree contains value of 1. > import Data.Tree.AVL > import Data.COrdering > mydelete' :: (Ord a) => a -> a -> AVL a -> AVL a > mydelete' p1 p2 tree = let res = delete cmp tree in > case contains res cmp of > True -> mydelete' p1 p2 res > otherwise -> res > where > cmp = between p1 p2 > between a b x = if x < a > then LT > else if x > b > then GT > else EQ > itree = push ((sndByCC compare) 3) 3 (pair 1 2) > idel = mydelete' 0 2 *Main> idel itree P (Z E 1 E) 3 E *Main> idel $ idel itree P (Z E 1 E) 3 E *Main> Explain me why I got following results and where I made error. *Main> (mydelete' 0 3) itree E *Main> (mydelete' 0 2) itree P (Z E 1 E) 3 E *Main> (mydelete' 1 2) itree P (Z E 1 E) 3 E *Main> (mydelete' 1 1) itree Z (Z E 1 E) 2 (Z E 3 E) *Main> (mydelete' 2 1) itree Z (Z E 1 E) 2 (Z E 3 E) *Main> (mydelete' 0 1) itree Z (Z E 1 E) 2 (Z E 3 E) *Main> (mydelete' 0 2) itree P (Z E 1 E) 3 E *Main> (mydelete' (-1) 2) itree P (Z E 1 E) 3 E Alexander

3 4

Installing package hsc3 – Haskell supercollider
by Deb Midya 17 Sep '10

17 Sep '10

Hi Haskell Users, Thanks in advance. I am using Haskell on Windows XP. I have downloaded HaskellPlatform-2010.2.0.0-setup.exe and installed it. I have checked that GHCi version is 6.12.3. May I request you to assist me for the following please: To install Haskell supercollider package, I have downloaded hsc3-0.7.tar.gz. How can I install this package now? Is there any document (how to use) on this package? To assist me for this, I have also checked that whether cabal is working or not. To do that: At dos prompt: \ghc>cabal –help \ghc> cabal install –help It shows me flags for help and installation. Once again, thank you very much for the time you have given. Regards, Deb

2 1

Re: [Haskell-beginners] Padding List with Zeros
by Hein Hundal 16 Sep '10

16 Sep '10

On Wed, 15 Sep 2010 16:23:49, Daniel Fischer wrote: > On Wednesday 15 September 2010 15:15:49, Henry Olders wrote: > > On 2010-09-14, at 19:35 , Lorenzo Isella wrote: > > > Dear All, > > > I still have to find my way with immutable lists and list > > > comprehension. Consider the following lists > > > > > > A=[0,10,20,30,40,50] > > > B=[0,10,50] (i.e. B is a subset of list A; list A is > > > already ordered in increasing order and so is B). > > > C=[2,1,-5] i.e. there is a corresponding element in C for every > > > element in B. > > > > > > Now, I would like to define a new list D having length equal > > > to the length of A. The elements of D in the position of the > > > elements of A in common with B are equal to the corresponding > > > entries in C, whereas the other ones are zero i.e. > > > D=[2,1,0,0,0,-5]. How can I achieve that? The first thought > > > that comes to my mind is to define a list of zeros which I > > > would modify according to my needs, but that is not allowed... Yes, that is not allowed. First thing I thought of also. > > > Many thanks > > > > > > Lorenzo > > > > Being a real Haskell newby, I can figure out a one-line solution in > > Python, but I don't know how to do something similar in Haskell, or even > > if it's possible. Please correct me if I'm wrong, but there does not > > seem to be a dictionary type in Haskell, and I am not aware of how to > > specify an inline if...else inside a list comprehension. I would really > > appreciate it if someone could show me how to do something similar to > > this Python statement in Haskell. > > > >import Data.Maybe > > > >>> A=[0,10,20,30,40,50] > > >>> B=[0,10,50] > > >>> C=[2,1,-5] > > These have to be lowercase in Haskell, of course :) > > > >>> [dict(zip(B,C))[a] if a in B else 0 for a in A] > > map (fromMaybe 0 . (`lookup` zip b c)) a > > or, as a list comprehension, > > [fromMaybe 0 (lookup v dic) | let dic = zip b c, v <- a] > > Slightly more verbose than the Python. > > But this doesn't deal with multiple entries (istr that was > mentioned previously in this thread), for > > a = [0, 10, 10, 20, 30 , 40, 50] > b = [0, 10, 10, 50] > c = [2, 1, 3, -5] > > neither would produce > > [2, 1, 3, 0, 0, 0, -5] > > which I believe would be the desired behavior. > > > > > [2, 1, 0, 0, 0, -5] > > > > Henry I love the map solution and the lookup solutions--very concise. Someday perhaps those will occur to me when I look at these problems. Here is my (extremely) verbose beginner solution. I think this solution is linear time and it returns the "desired behavior" in Daniel's post. -- indices v1 v2 -- find the elemIndex of v2's elements in v1 -- almost equivalent to (map (flip elemIndex v1) v2) -- indices v1 v2 = indices' 0 v1 v2 indices' iOff (x:xs) (y:ys) | x < y = indices' (iOff+1) xs (y:ys) | x ==y = iOff:(indices' (iOff+1) xs ys) | x > y = error "indicies:: elem not found" indices' _ _ [] = [] indices' _ [] (y:ys) = error "indices:: elem not found" -- makevec 0 indices values -- returns a vector with values filled in at the indices given -- makevec _ [] _ = [] makevec _ _ [] = error "makevec:: " makevec iOffSet (i:is) (x:xs) | iOffSet < i = replicate (i-iOffSet) 0 ++ makevec i (i:is) (x:xs) | iOffSet ==i = x:(makevec (iOffSet+1) is xs) | iOffSet > i = error "makevec error" hisfunc :: [Integer] -> [Integer] -> [Integer] -> [Integer] hisfunc a b c = let front = makevec 0 (indices a b) c in front ++ replicate (length a - length front) 0 test1 = hisfunc a b c test2 = hisfunc (a++[70, 90]) b c test3 = hisfunc (a++[70, 90]) (b++[70]) (c++[-14]) test4 = hisfunc [0,10,10,20,30,40,50] [0,10,10,50] [2,1,3,-5]

3 2