CODEWITHSUNDEEP
haskellpattern-matching
user6293434
user6293434

Reputation:

Writing overlaps function

I want to write a polymorphic function that inputs two lists and tells me whether these two lists contain a common element. My attempt at writing this function is as follows: 

overlaps :: (Eq a) => [a] -> [a] -> Bool
overlaps x:xs y:ys  
   | x `is_element_of` ys = True
   | otherwise = False

where

is_element_of :: (Eq a) => a -> [a] -> Bool
is_element_of e list = case list of
[] -> False
x: xs -> e == x || e `is_element_of` xs

However this isn't working... Is it possible to pattern match against two lists? Is this a possible way of writing this function?

Upvotes: 2

Views: 124

Answers (2)

Kwarrtz
Kwarrtz

Reputation: 2753

Your function is_elem_of already exists in the Data.List package as elem. Using that, overlaps is easy to write. 

overlaps []     _  = False
overlaps (x:xs) ys = x `elem` ys || overlaps xs ys

As you can tell, it is possible to pattern match on lists. If you want to write the function without pattern matching on lists, you can use the foldr function.

overlaps xs ys = foldr (\x acc -> x `elem` ys || acc) False xs

Upvotes: 2

Evan Trimboli
Evan Trimboli

Reputation: 30082

I think you would want something like this (untested):

overlaps :: (Eq a) => [a] -> [a] -> Bool
overlaps [] _        = False
overlaps _ []        = False
overlaps (x:xs) list = x `myelem` list || overlaps xs list

myelem :: (Eq a) => a -> [a] -> Bool
myelem _ []     = False
myelem x (y:ys) = x == y || myelem x ys

AFAIK using the pattern matching appropach is more idiomatic.

Upvotes: 0

Related Questions