January 2010 - Beginners

defining functions in ghci
by Joe Van Dyk 19 Feb '10

19 Feb '10

This messes me up: $ ghci GHCi, version 6.8.2: http://www.haskell.org/ghc/ :? for help double x =Loading package base ... linking ... done. Prelude> double x = x + x <interactive>:1:9: parse error on input `=' Why does that happen? -- Joe Van Dyk http://fixieconsulting.com

7 10

Circular Linked Lists
by Matthew J. Williams 04 Feb '10

04 Feb '10

Dear All How would one mimic, in Haskell, a C++ circular linked list i.e., where the last element precedes (points to) the first? Sincerely Matthew J. Williams

10 20

Using Debug.Trace
by legajid 02 Feb '10

02 Feb '10

Hi, Starting with trace, i have trouble with my calcul'' function while calcul' is ok. When afftrace in calcul'' is commented, the program compiles. When uncommented ( afftrace (" calcul'' vide") ), i get the following messages : ------------------------------------------------------------------------------------------- *Main> :r [1 of 1] Compiling Main ( sud3c.hs, interpreted ) sud3c.hs:62:3: Couldn't match expected type `[Char]' against inferred type `(Plateau, Char)' In a stmt of a 'do' expression: afftrace (" calcul'' vide") In the expression: do afftrace (" calcul'' vide") (pxv, False) In the definition of `calcul''': calcul'' pxv _ [] = do afftrace (" calcul'' vide") (pxv, False) Failed, modules loaded: none. ------------------------------------------------------------------------------------------- I don't understand why, in calcul', it's ok and why, in calcul'', it's problematic. Because return value of calcul'' is a tuple ? When my program is ok, should i remove all trace instructions (and associated do commands too) or just set my modetrace value to False ? Thanks for helping, Didier Below my code : calcul' :: Plateau -> [Cellule] -> Plateau calcul' pxv [] = do afftrace (" Calcul' vide") pxv calcul' pxv (c:cs)= do afftrace (" Calcul' ok1="++show ok1++" c:cs= "++show (c:cs)) afftrace (" "++show xv1) if ok1 then do afftrace (" Calcul' suite") calcul' xv1 cs else do afftrace (" Calcul' pas de valeur") pxv where vallib=[1..length pxv]++[5..7] nbvlib=length vallib (xv1,ok1)=calcul'' pxv c vallib calcul'' :: Plateau -> Cellule -> [Valeur] -> (Plateau, Bool) calcul'' pxv _ [] = do --afftrace (" calcul'' vide") (pxv, False) calcul'' pxv c (li : lis) = do --afftrace (" "++show pxv) --afftrace (" "++show c ++ " "++show(li:lis)) v2 where v2= if (elem li pxv || li==4) then calcul'' pxv c lis else do --afftrace (" calcul'''") (calcul''' pxv c li, True) calcul''' :: Plateau -> Cellule -> Valeur -> Plateau calcul''' pxv c li = take (c-1) pxv ++ [li] ++ drop c pxv afftrace x= if modetrace then trace x " " else " "

2 2

Performance of Idiomatic lazy Haskell
by Markus Böhm 02 Feb '10

02 Feb '10

As a beginner fascinated about Haskell's lazy, idiomatic style I tried a small example: Calculate a numerical approximation of PI based on the Leibniz formula. Variant 1: My lazy, idiomatic approach (as I understand it so far). It takes on my machine with eps = 0.00000001 approx. 25 sec. import Data.List main :: IO () main = do putStrLn "EPS: " eps <- readLn :: IO Double let pi14 = calcpi14 eps putStrLn $ "PI mit EPS "++(show eps)++" = "++ show(4*pi14) calcpi14:: Double->Double calcpi14 eps = foldl' (+) 0 $ takeWhile (\x -> 4 * abs x > eps) ev where e = map (\x->1.0/x) [1.0,3.0..] ev = zipWith (*) e $ cycle [1.0,-1.0] Variant 2: My "C-style" approach achieving state via additonal function parameters. It takes on my machine with eps = 0.00000001 approx. 5 sec. import Data.List main :: IO () main = do putStrLn "EPS: " eps <- readLn :: IO Double let pi14 = pisum 1 3 False eps putStrLn $ "PI mit EPS "++(show eps)++" = "++ show(4*pi14) pisum s i _ eps | 4/i < eps = s pisum s i True eps = let h = s + 1/i in h `seq` pisum h (i+2) False eps pisum s i False eps = let h = s - 1/i in h `seq` pisum h (i+2) True eps I'd like to do idiomatic, lazy Haskell w/o such a performance penalty? How can I learn/achive that? -- Markus

6 23

one more step backwards
by John Moore 31 Jan '10

31 Jan '10

Hi , With help I got the following to print out each step in the evaluation of the add. However I was just wondering if it was possible to make the evaluation go back one step at a time. I tried to use a get count function but this doesnt seem so easy. data Expression = Val Integer | Add Expression Expression | Subtract Expression Expression | Multiply Expression Expression | Divide Expression Expression deriving Show demo1 = (Add(Add(Add(Add(Val 6)(Val 5))(Val 10))(Val 7))(Val 30)) evalStep :: Expression -> Expression evalStep (Val x)= (Val x) evalStep (Add x y) = case x of (Val a) -> case y of (Val b) -> Val (a+b) left -> Add x (evalStep y) right -> Add (evalStep x)y evaluate :: Expression -> IO () -- Base case evaluate (Val a) = return () -- Recursive case evaluate e = do putStrLn "Evaluating one more step" let e' = (evalStep e) putStrLn ("Result is "++(show e')) putStrLn "Do another step (y/n)? :" c <- getLine if (c=="y")then evaluate e' else putStrLn("Ok you said" ++ show[c] ++ "so that's it" ++ show getCount) getCount:: Expression -> Int getCount e' = n, n=1 if(getCount == 1) then putStrLn ("Cannot go back") else putStrLn ("One step back" ++ show n-1) All thoughts welcome! john

3 3

Tracing a program with putStrLn
by legajid 30 Jan '10

30 Jan '10

Hi, i wrote a program that doesn't behave as i wanted. So i tried to putStrLn my data structures to see what happened. Since i did this, all my functions changed type, so i had to modify them (main and calcul : use <- instead of let , add returns) and so on for each function called. Debugging this way causes more trouble than it should save. What is the way to trace data thru function recursive calls without changing program structures? Is putStrLn a good idea ? I'm not used to ghci debug and i find it hard to manage (:break, :trace, :cont ...). Is the 'debugged' version as efficient as the first one, due to impure functional code? What if i want to remove 'debug code' ? Should i modify back my functions ? Here are two very simplified versions of my program, the first one without 'trace', the second modified to include putStrLn as wanted. Thanks in advance, Didier First version ------------- main=do let valeurs=[0,1,3,0] let (valeurs_new)=calcul valeurs afficher_resultat valeurs afficher_resultat valeurs_new calcul :: [Int] -> [Int] calcul xv | nblibr == 0 = map (*2) xv | otherwise = map (+1) xv where libres = [ x | x <- [1..length xv] , xv !! (x-1) == 0] nblibr=length libres afficher_resultat xv = do putStrLn (show xv) Second version ---------------- main=do let valeurs=[0,1,3,0] valeurs_new <- calcul valeurs afficher_resultat valeurs afficher_resultat valeurs_new calcul :: [Int] -> IO [Int] calcul xv | nblibr == 0 = do putStrLn "ok" return (map (*2) xv) | otherwise = return (map (+1) xv) where libres = [ x | x <- [1..length xv] , xv !! (x-1) == 0] nblibr=length libres afficher_resultat xv = do putStrLn (show xv)

3 3

subset
by Luca Ciciriello 29 Jan '10

29 Jan '10

Hi All. Does exist a simple way to check if a lists xs is a subset of another list ys? Thanks in advance Luca. _________________________________________________________________ Tell us your greatest, weirdest and funniest Hotmail stories http://clk.atdmt.com/UKM/go/195013117/direct/01/

2 1

Re: Beginners Digest, Vol 19, Issue 30
by Gabi 29 Jan '10

29 Jan '10

I copy pasted Daniel's code. Changed the code to use Mersenne genrerator and got 4200% (!) improvement: import System.Random.Mersenne import System( getArgs ) inCirc :: Double -> Double -> Int inCirc x y | dx*dx + dy*dy < 0.25 = 1 | otherwise = 0 where dx = x - 0.5 dy = y - 0.5 -- transform a list of coordinates into a list of indicators -- whether the point is inside the circle (sorry for the -- stupid name) inCircles :: [Double] -> [Int] inCircles (x:y:zs) = inCirc x y : inCircles zs inCircles _ = [] -- given a count of experiments and an infinite list of coordinates, -- calculate an approximation to pi calcPi :: Int -> [Double] -> Double calcPi n ds = fromIntegral ct / fromIntegral n * 4 where ct = sum . take n $ inCircles ds -- now the IO part is only -- * getting the number of experiments and -- * getting the StdGen main :: IO () main = do args <- getArgs sg <- getStdGen let n = case args of (a:_) -> read a _ -> 10000 rands <- randoms sg :: IO [Double] print $ calcPi n rands time ./slow-pi +RTS -K1G -RTS 1000000 3.14222 real 0m6.886s user 0m6.680s sys 0m0.200s time ./improved-pi 1000000 3.14364 real 0m0.163s user 0m0.160s sys 0m0.000s Thanks all for the help ! On Fri, Jan 29, 2010 at 12:31 PM, <beginners-request(a)haskell.org> wrote: > Send Beginners mailing list submissions to > beginners(a)haskell.org > > To subscribe or unsubscribe via the World Wide Web, visit > http://www.haskell.org/mailman/listinfo/beginners > or, via email, send a message with subject or body 'help' to > beginners-request(a)haskell.org > > You can reach the person managing the list at > beginners-owner(a)haskell.org > > When replying, please edit your Subject line so it is more specific > than "Re: Contents of Beginners digest..." > > > Today's Topics: > > 1. Could not deduce (Matrix m (Maybe a)) from the context > (Matrix m a) (Lyndon Maydwell) > 2. Re: subset - a little add (Daniel Fischer) > 3. Re: Could not deduce (Matrix m (Maybe a)) from the context > (Matrix m a) (Daniel Fischer) > 4. Re: Could not deduce (Matrix m (Maybe a)) from the context > (Matrix m a) (Lyndon Maydwell) > 5. subset - a little add (Luca Ciciriello) > 6. Re: Could not deduce (Matrix m (Maybe a)) from the context > (Matrix m a) (Daniel Fischer) > 7. PI calculation - Newbie question (Gabi) > > > ---------------------------------------------------------------------- > > Message: 1 > Date: Fri, 29 Jan 2010 16:52:37 +0800 > From: Lyndon Maydwell <maydwell(a)gmail.com> > Subject: [Haskell-beginners] Could not deduce (Matrix m (Maybe a)) > from the context (Matrix m a) > To: beginners(a)haskell.org > Message-ID: > <da8fea9e1001290052x233f51ev8e4c04e2649277e7(a)mail.gmail.com> > Content-Type: text/plain; charset=UTF-8 > > Hi Beginners. > > I'm writing a matrix class for a game of life implementation. When I > try to compile it I get the error "Could not deduce (Matrix m (Maybe > a)) from the context (Matrix m a)" for the method vicinityMatrix. > > However, when I query the type of an identical implementation to > vicinityMatrix in ghci it is successful: > > :t \m x y -> fromRows $ vicinityRows m x y > \m x y -> fromRows $ vicinityRows m x y > :: forall (m :: * -> *) (m1 :: * -> *) a. > (Matrix m (Maybe a), Matrix m1 a) => > m1 a -> Integer -> Integer -> m (Maybe a) > > What might be preventing the class from compiling? > > Thanks guys. > > --- > > My Matrix class definition follows below: > > module Matrix (Matrix) where > > import Data.Array > import Data.Maybe (catMaybes) > import Control.Monad (guard) > > class Matrix m a > where > fromRows :: [[a]] -> m a > toList :: m a -> [a] > rows :: m a -> Integer > columns :: m a -> Integer > row :: m a -> Integer -> [a] > column :: m a -> Integer -> [a] > at :: m a -> Integer -> Integer -> a > (!!!) :: m a -> Integer -> Integer -> a > vicinityRows :: m a -> Integer -> Integer -> [[Maybe a]] > vicinityMatrix :: m a -> Integer -> Integer -> m (Maybe a) > neighbours :: m a -> Integer -> Integer -> [a] > > toList m = do > x <- [0 .. columns m - 1] > y <- [0 .. rows m - 1] > return $ at m x y > > row m n = [at m x n | x <- [0 .. columns m - 1]] > column m n = [at m n y | y <- [0 .. rows m - 1]] > > at = (!!!) > (!!!) = at > > vicinityRows m x y = do > x' <- [x - 1 .. x + 1] > return $ do > y' <- [y - 1 .. y + 1] > return cell where > cell > | x < 0 = Nothing > | y < 0 = Nothing > | x >= columns m = Nothing > | y >= rows m = Nothing > | otherwise = Just $ at m x y > > vicinityMatrix m x y = fromRows $ vicinityRows m x y > > -- neighbours = catMaybes . toListN . vicinityMatrix > > toListN :: Matrix m a => m a -> [a] > toListN m = do > x <- [0 .. columns m - 1] > y <- [0 .. rows m - 1] > guard $ x /= 1 && y /= 1 > return $ at m x y > > > ------------------------------ > > Message: 2 > Date: Fri, 29 Jan 2010 10:06:29 +0100 > From: Daniel Fischer <daniel.is.fischer(a)web.de> > Subject: Re: [Haskell-beginners] subset - a little add > To: beginners(a)haskell.org > Message-ID: <201001291006.30011.daniel.is.fischer(a)web.de> > Content-Type: text/plain; charset="utf-8" > > Am Freitag 29 Januar 2010 08:36:35 schrieb Luca Ciciriello: >> Just a little add to may previous mail. >> >> The solution I've found from myself is: >> >> >> >> subset :: [String] -> [String] -> Bool >> subset xs ys = and [elem x ys | x <- xs] >> > > Variant: > > subset xs ys = all (`elem` ys) xs > > but is that really what you want? That says subset [1,1,1,1] [1] ~> True. > If you regard your lists as representatives of sets (as the name suggests), > then that's correct, otherwise not. > > However, this is O(length xs * length ys). If you need it only for types > belonging to Ord, a much better way is > > import qualified Data.Set as Set > import Data.Set (fromList, isSubsetOf, ...) > > subset xs ys = fromList xs `isSubsetOf` fromList ys > > or, if you don't want to depend on Data.Set, > > subset xs ys = sort xs `isOrderedSublistOf` sort ys > > xxs@(x:xs) `isOrderedSublistOf` (y:ys) > | x < y = False > | x == y = xs `isOrderedSublistOf` ys > | otherwise = xxs `isOrderedSublistOf` ys > [] `isOrderedSublistOf` _ = True > _ `isOrderedSublistOf` [] = False > >> >> >> My question is if exists a more elegant way to do that. >> >> >> >> Luca. > > > > ------------------------------ > > Message: 3 > Date: Fri, 29 Jan 2010 10:17:10 +0100 > From: Daniel Fischer <daniel.is.fischer(a)web.de> > Subject: Re: [Haskell-beginners] Could not deduce (Matrix m (Maybe a)) > from the context (Matrix m a) > To: beginners(a)haskell.org > Message-ID: <201001291017.10744.daniel.is.fischer(a)web.de> > Content-Type: text/plain; charset="utf-8" > > Am Freitag 29 Januar 2010 09:52:37 schrieb Lyndon Maydwell: >> Hi Beginners. >> >> I'm writing a matrix class for a game of life implementation. When I >> try to compile it I get the error "Could not deduce (Matrix m (Maybe >> a)) from the context (Matrix m a)" for the method vicinityMatrix. >> >> However, when I query the type of an identical implementation to >> >> vicinityMatrix in ghci it is successful: >> :t \m x y -> fromRows $ vicinityRows m x y >> >> \m x y -> fromRows $ vicinityRows m x y >> >> :: forall (m :: * -> *) (m1 :: * -> *) a. >> >> (Matrix m (Maybe a), Matrix m1 a) => >> m1 a -> Integer -> Integer -> m (Maybe a) >> >> What might be preventing the class from compiling? > > Well, the error says the compiler (the type checker) can't deduce the > context (Matrix m (Maybe a)) from the givens. If you supply that > information, > > vicinityMatrix :: Matrix m (Maybe a) => > m a -> Integer -> Integer -> m (Maybe a) > > it'll work. > >> >> Thanks guys. >> >> --- >> >> My Matrix class definition follows below: >> >> module Matrix (Matrix) where >> >> import Data.Array >> import Data.Maybe (catMaybes) >> import Control.Monad (guard) >> >> class Matrix m a >> where >> fromRows :: [[a]] -> m a >> toList :: m a -> [a] >> rows :: m a -> Integer >> columns :: m a -> Integer >> row :: m a -> Integer -> [a] >> column :: m a -> Integer -> [a] >> at :: m a -> Integer -> Integer -> a >> (!!!) :: m a -> Integer -> Integer -> a >> vicinityRows :: m a -> Integer -> Integer -> [[Maybe a]] >> vicinityMatrix :: m a -> Integer -> Integer -> m (Maybe a) >> neighbours :: m a -> Integer -> Integer -> [a] >> >> toList m = do >> x <- [0 .. columns m - 1] >> y <- [0 .. rows m - 1] >> return $ at m x y >> >> row m n = [at m x n | x <- [0 .. columns m - 1]] >> column m n = [at m n y | y <- [0 .. rows m - 1]] >> >> at = (!!!) >> (!!!) = at >> >> vicinityRows m x y = do >> x' <- [x - 1 .. x + 1] >> return $ do >> y' <- [y - 1 .. y + 1] >> return cell where >> cell >> >> | x < 0 = Nothing >> | y < 0 = Nothing >> | x >= columns m = Nothing >> | y >= rows m = Nothing >> | otherwise = Just $ at m x y >> >> vicinityMatrix m x y = fromRows $ vicinityRows m x y >> >> -- neighbours = catMaybes . toListN . vicinityMatrix >> >> toListN :: Matrix m a => m a -> [a] >> toListN m = do >> x <- [0 .. columns m - 1] >> y <- [0 .. rows m - 1] >> guard $ x /= 1 && y /= 1 >> return $ at m x y > > > > > ------------------------------ > > Message: 4 > Date: Fri, 29 Jan 2010 17:45:32 +0800 > From: Lyndon Maydwell <maydwell(a)gmail.com> > Subject: Re: [Haskell-beginners] Could not deduce (Matrix m (Maybe a)) > from the context (Matrix m a) > To: Daniel Fischer <daniel.is.fischer(a)web.de> > Cc: beginners(a)haskell.org > Message-ID: > <da8fea9e1001290145n4597e3abk51f6bbc87ef78f89(a)mail.gmail.com> > Content-Type: text/plain; charset=UTF-8 > > Thanks Daniel. > > It works, but I'm a bit confused as to why the extra type information is needed. > > On Fri, Jan 29, 2010 at 5:17 PM, Daniel Fischer > <daniel.is.fischer(a)web.de> wrote: >> Am Freitag 29 Januar 2010 09:52:37 schrieb Lyndon Maydwell: >>> Hi Beginners. >>> >>> I'm writing a matrix class for a game of life implementation. When I >>> try to compile it I get the error "Could not deduce (Matrix m (Maybe >>> a)) from the context (Matrix m a)" for the method vicinityMatrix. >>> >>> However, when I query the type of an identical implementation to >>> >>> vicinityMatrix in ghci it is successful: >>> :t \m x y -> fromRows $ vicinityRows m x y >>> >>> \m x y -> fromRows $ vicinityRows m x y >>> >>> :: forall (m :: * -> *) (m1 :: * -> *) a. >>> >>> (Matrix m (Maybe a), Matrix m1 a) => >>> m1 a -> Integer -> Integer -> m (Maybe a) >>> >>> What might be preventing the class from compiling? >> >> Well, the error says the compiler (the type checker) can't deduce the >> context (Matrix m (Maybe a)) from the givens. If you supply that >> information, >> >> vicinityMatrix :: Matrix m (Maybe a) => >> m a -> Integer -> Integer -> m (Maybe a) >> >> it'll work. >> >>> >>> Thanks guys. >>> >>> --- >>> >>> My Matrix class definition follows below: >>> >>> module Matrix (Matrix) where >>> >>> import Data.Array >>> import Data.Maybe (catMaybes) >>> import Control.Monad (guard) >>> >>> class Matrix m a >>> where >>> fromRows :: [[a]] -> m a >>> toList :: m a -> [a] >>> rows :: m a -> Integer >>> columns :: m a -> Integer >>> row :: m a -> Integer -> [a] >>> column :: m a -> Integer -> [a] >>> at :: m a -> Integer -> Integer -> a >>> (!!!) :: m a -> Integer -> Integer -> a >>> vicinityRows :: m a -> Integer -> Integer -> [[Maybe a]] >>> vicinityMatrix :: m a -> Integer -> Integer -> m (Maybe a) >>> neighbours :: m a -> Integer -> Integer -> [a] >>> >>> toList m = do >>> x <- [0 .. columns m - 1] >>> y <- [0 .. rows m - 1] >>> return $ at m x y >>> >>> row m n = [at m x n | x <- [0 .. columns m - 1]] >>> column m n = [at m n y | y <- [0 .. rows m - 1]] >>> >>> at = (!!!) >>> (!!!) = at >>> >>> vicinityRows m x y = do >>> x' <- [x - 1 .. x + 1] >>> return $ do >>> y' <- [y - 1 .. y + 1] >>> return cell where >>> cell >>> >>> | x < 0 = Nothing >>> | y < 0 = Nothing >>> | x >= columns m = Nothing >>> | y >= rows m = Nothing >>> | otherwise = Just $ at m x y >>> >>> vicinityMatrix m x y = fromRows $ vicinityRows m x y >>> >>> -- neighbours = catMaybes . toListN . vicinityMatrix >>> >>> toListN :: Matrix m a => m a -> [a] >>> toListN m = do >>> x <- [0 .. columns m - 1] >>> y <- [0 .. rows m - 1] >>> guard $ x /= 1 && y /= 1 >>> return $ at m x y >> >> >> > > > ------------------------------ > > Message: 5 > Date: Fri, 29 Jan 2010 10:01:36 +0000 > From: Luca Ciciriello <luca_ciciriello(a)hotmail.com> > Subject: [Haskell-beginners] subset - a little add > To: <beginners(a)haskell.org> > Message-ID: <SNT128-W4078FB7A2593E1F547AAA29A5B0(a)phx.gbl> > Content-Type: text/plain; charset="iso-8859-1" > > > Thanks Daniel. > > Yes my function operate only in a set-theory contest and your solution: > > subset xs ys = all (`elem` ys) xs > > is indeed more elegant than mine. > > Thanks again for your help. > > Luca. > >> From: daniel.is.fischer(a)web.de >> To: beginners(a)haskell.org >> Subject: Re: [Haskell-beginners] subset - a little add >> Date: Fri, 29 Jan 2010 10:06:29 +0100 >> CC: luca_ciciriello(a)hotmail.com >> >> Am Freitag 29 Januar 2010 08:36:35 schrieb Luca Ciciriello: >> > Just a little add to may previous mail. >> > >> > The solution I've found from myself is: >> > >> > >> > >> > subset :: [String] -> [String] -> Bool >> > subset xs ys = and [elem x ys | x <- xs] >> > >> >> Variant: >> >> subset xs ys = all (`elem` ys) xs >> >> but is that really what you want? That says subset [1,1,1,1] [1] ~> True. >> If you regard your lists as representatives of sets (as the name suggests), >> then that's correct, otherwise not. >> >> However, this is O(length xs * length ys). If you need it only for types >> belonging to Ord, a much better way is >> >> import qualified Data.Set as Set >> import Data.Set (fromList, isSubsetOf, ...) >> >> subset xs ys = fromList xs `isSubsetOf` fromList ys >> >> or, if you don't want to depend on Data.Set, >> >> subset xs ys = sort xs `isOrderedSublistOf` sort ys >> >> xxs@(x:xs) `isOrderedSublistOf` (y:ys) >> | x < y = False >> | x == y = xs `isOrderedSublistOf` ys >> | otherwise = xxs `isOrderedSublistOf` ys >> [] `isOrderedSublistOf` _ = True >> _ `isOrderedSublistOf` [] = False >> >> > >> > >> > My question is if exists a more elegant way to do that. >> > >> > >> > >> > Luca. >> > > > > Not got a Hotmail account? Sign-up now - Free > > _________________________________________________________________ > Send us your Hotmail stories and be featured in our newsletter > http://clk.atdmt.com/UKM/go/195013117/direct/01/ >

1 0

Uninstall GHC binary package? ()
by Kwanghoon Choi 29 Jan '10

29 Jan '10

Dear All, After I installed the ghc binary package (ghc-6.12.1-i386-unknown-linux.tar.bz2) manually, I can't find a way to uninstall it. Could anyone help me out? Thanks in advance. Kwanghoon PS. I have installed two versions of ghc. One is with the ghc-6.12.1 package, and the other is ghc-6.8.2 package. The former is downloaded to be installed manually, but the latter is done automatically by using APT tool. They are installed in a different way. I mean the ghc-6.12.1 is under /usr/local/bin, but ghc-6.8.2 is under /usr/bin. (Of course, you can change this default setting though) My original purpose is to install the newest QuickCheck package. Having both ghc packages seems to cause a conflict. After I try with $ runhaskell Setup.lhs configure, I met a dependency error requiring me to install mtl (monad transformer library). I did install by APT tool. But the retrial with $ runhaskell Setup.lhs configure does not work because the configuration is being done by ghc-6.12.1 package. The ghc-6.12.1 package doesn't recognize the presence of mtl package that I installed just before. Only the ghc-6.8.2 package seems to recognize the presence of mtl package. The mtl package seems to be built aligned with ghc-6.8.2 package. I guess this strange phenomena comes from the different configuration of the two versions. This is the reason why I try to uninstall ghc-6.12.1, but it doesn't seem to provide any way to be uninstalled, unfortunately. If I am wrong, please correct me.

2 1

PI calculation - Newbie question
by Gabi 29 Jan '10

29 Jan '10

Hi Group, I am just trying to learn the lang and Implemented this PI calculator. It is really slow and very memory consuming (much much slower than its equivalent in Clojure for instance) I think the problem is in "rs <- sequence (replicate n isRandIn)" - But I don't know how to get around it (how do I get a lazy sequence of rs? Is it the problem anyway?) -- p.hs simple PI calculator, using the Monte Carlo Method import System( getArgs ) import System.Random inCirc :: (Double, Double) -> Int inCirc (x,y) = if ((dx * dx) + (dy * dy)) < 0.25 then 1 else 0 where dx = x - 0.5 dy = y - 0.5 randPoint :: IO (Double, Double) randPoint = do x <-getStdRandom (randomR (0, 1 :: Double)) y <-getStdRandom (randomR (0, 1 :: Double)) return (x, y) isRandIn = do p <- randPoint return (inCirc p) main = do args <- getArgs let n = if null args then 10000 else read $ (head args)::Int rs <- sequence (replicate n isRandIn) let pi = (fromIntegral(sum rs) / fromIntegral n) * 4 print pi

3 2