- Beginners - Haskell.org

Re: foldl' vs seq
by Gabi 02 Feb '10

02 Feb '10

Thank you Ertugrul, I think I got it now. My lesson here is to avoid recursion as much possible and use foldr' instead.There are too many pitfalls. -- Regards, Gabi http://bugspy.net

2 1

foldl' vs seq
by Gabi 02 Feb '10

02 Feb '10

Hi Stephen, Thanks for the answer. Now I got confused :) 1. What is seq used for if it doesn't force strictness ? 2. Why the accumulator is important ? In other words why the following is much slower ? Isn't it RT too ? slowSum :: [Integer] -> Integer slowSum[] = 0 slowSum (x:xs) = x `seq` x + slowSum xs

3 3

Re: [Haskell-beginners] one more step backwards
by Felipe Lessa 01 Feb '10

01 Feb '10

On Mon, Feb 01, 2010 at 10:32:00PM +0000, John Moore wrote: > Hi Felipe, > this is way complicated for my level, could you look at this > below and see if I could use this instead. I understand you, it also took me some time to understand the monad transformer library :). > 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 Even without the Writer monad you capture that pattern in an auxiliary function. You just extract the common bits and abstract the specific ones: aux calcOp mkOp x y = case x of (Val a) -> case y of (Val b) -> Val (a `calcOp` b) left -> mkOp x (evalStep y) right -> mkOp (evalStep x) y Note that: - I've changed (+) into calcOp and Add into mkOp. - Instead of deconstructing with a pattern match, I receive x and y as proper arguments. The type is type CalcOp = Integer -> Integer -> Integer type MkOp = Expression -> Expression -> Expression aux :: CalcOp -> MkOp -> Expression -> Expression -> (Expression -> Expression) You can write your evalStep as evalStep :: Expression -> Expression evalStep (Val x) = Val x evalStep (Add x y) = aux (+) Add x y evalStep (Subtract x y) = aux (-) Subtract x y evalStep (Multiply x y) = aux (*) Multiply x y evalStep (Divide x y) = aux div Divide x y Much cleaner ;). > What I mean to do is build up a history on a list and then take it of a > list( Same principle as a stack but a little more simple) the problem is how > do I get the other elements back of the list as in the line "r" -> evaluate > (I'm not sure what I put here) Hopes this makes some sort of sense. It does makes sense. In most languages this is the sort of code you would write: when the user tell us to evaluate, we evaluate and then save the result. However in our language we can leverage the laziness: buildHistory :: Expression -> [Expression] buildHistory expr = expr : buildHistory (evalStep) You may recognize this function as buildHistory = iterate evalStep (Note that unless your expression is infinite, then this list will contain an infinite number of duplicates when we reach the fixed point of the evalStep function.) The idea is to take everything you can out of IO. With buildHistory we take the logic of evaluating the expressions further out of IO. Now your function is as trivial as mine. In fact, it is the same. HTH, -- Felipe.

1 0

problem with hsc2hs
by Jose A. Ortega Ruiz 01 Feb '10

01 Feb '10

Hi, I'm trying to writing a simple C binding for statfs(2). Simplifying, writing an hsc file that contains the following snippet: #include <sys/vfs.h> data CStatfs foreign import ccall unsafe "sys/vfs.h statfs" c_statfs :: CString -> Ptr CStatfs -> IO CInt getFileSystemStats :: String -> IO CLong getFileSystemStats path = allocaBytes (#size struct statfs) $ \vfs -> useAsCString (pack path) $ \cpath -> do res <- c_statfs cpath vfs case res of -1 -> return 0 _ -> do bsize <- (#peek struct statfs, f_bsize) vfs bcount <- (#peek struct statfs, f_blocks) vfs bfree <- (#peek struct statfs, f_bfree) vfs bavail <- (#peek struct statfs, f_bavail) vfs -- Just for demonstration: the original code creates a data structure return $ bsize + bcount + bavail + bfree gives rise, when using hsc2hs, to this translation: getFileSystemStats path = allocaBytes ((84)) $ \vfs -> useAsCString (pack path) $ \cpath -> do res <- c_statfs cpath vfs case res of -1 -> return 0 _ -> do bsize <- ((\hsc_ptr -> peekByteOff hsc_ptr 4)) vfs bcount <- ((\hsc_ptr -> peekByteOff hsc_ptr 8)) vfs bfree <- ((\hsc_ptr -> peekByteOff hsc_ptr 16)) vfs bavail <- ((\hsc_ptr -> peekByteOff hsc_ptr 24)) vfs return $ bsize + bcount + bavail + bfree (where i have deleted LINE directives). The problem is that the size and some of the offsets of the C struct statfs computed by hsc2c are wrong: i'm in a 32bit linux system, and i've checked, using a C program, that sizeof(struct statfs) is 64 (hsc2 is giving 84 -- although perhaps Haskell needs additional space for housekeeping?), and that the offsets of f_bfree and f_bavail are, respectively, 12 and 16 (not 16 and 24). Also, i know that 12 and 16 are the right values because putting them by hand gives me the correct statfs values. (This is ghc 6.10.4 on a debian/sid system) What am i doing wrong? TIA! jao

1 0

foldl' vs seq
by Gabi 01 Feb '10

01 Feb '10

Hi I am trying to understand the behavior of foldl' and seq. Why is the following code is much slower than the foldl' version ? (which is foldl' (+) 0) I thought the the below code is equivalent to foldr' but apparently I was wrong. mySum :: [Integer] -> Integer mySum[] = 0 mySum (x:xs) = seq x (mySum xs + x)

2 1

foldl' vs seq
by Gabi 01 Feb '10

01 Feb '10

Update: I came up with the following somewhat faster function. But still, it is much slower than the original foldl' mySum2 (x:y:xs) = let sum = x + y in seq sum (sum + mySum2 xs) mySum2 (x:[]) = x mySum2 [] = 0

1 0

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