如何使用Haskell检查列表是否为空

Question

Below is my code attempt for trying to create and then check the intersection of two lists in Haskell. Can someone help me get it to run?

empty_intersection :: (Eq a_ => [a] -> [a] -> Bool
empty_intersection as bs = (true if ([x | x <- as, x  `elem` bs) else false)

Answer 1

You've basically got the right idea here, there are just a few slight issues:

• You haven't closed the brackets around the list comprehension, which results in a parse error.
• A list can't be used directly with if , since if only works with values of type Bool . You may perhaps be thinking of some other languages where lists/arrays are considered "true" if and only if they are non-empty - but Haskell does no automatic type conversions, so you have to explicitly check if the list is non-empty. The best and easiest way to do this is to use the null function (which takes a list and returns True if its empty, and False otherwise).
• As @Bergi pointed out (and I missed initially), you've got a typo in your (Eq a) constraint.
• The if statement is backwards. Python has the construct x if (condition) else y , but Haskell instead uses if condition then x else y . Also, although this isn't wrong, there's no need for it when your x and y are True and False , because the whole thing just evaluates to whatever (condition) is.

So the code should be:

empty_intersection :: (Eq a) => [a] -> [a] -> Bool
empty_intersection as bs = null [x | x <- as, x  `elem` bs]

Answer 2

Problem

Your code will not compile because a list cannot be a boolean, so you cannot have it in an if statement. There are however functions like all , any and null that can take lists and return booleans.

Solution

Just use the Prelude function null :: [a] -> Bool which returns true if your list is empty. (Also note as @Bergi said you have a typo in your type constraint)

empty_intersection :: (Eq a => [a] -> [a] -> Bool
empty_intersection as bs = null [x | x <- as, x  `elem` bs]

Even better

Also, as it's your second question on set unions and intersections, note that there is a library Data.Set for dealing with ordered sets which has much more efficients functions for intersection, union, membership, difference, etc.

Answer 3

You can use intersect

empty_intersection :: (Eq a) => [a] -> [a] -> Bool
empty_intersection = null . intersect