Haskell中的成员函数

Question

Working on a small assignment for class, having a lot of trouble with Haskell. I am trying to make a recursive method for finding if an integer is part of a list or not. I know the gist, but am unable to get it working correctly with the haskell syntax. Check if the current list is empty, if so then False, then check if integer is equal to the head of the current list, if so, then True, then call member again with the same value you are searching for, and the tail of the list. What can I do to get this functioning properly.

Currently this is what I have:

member ::Int -> [Int] -> Bool
member x y
if y [] then False
else if x == head y then True
else member x tail y

I have also tried using

member :: (Eq x) => x -> [x] -> Bool

as the beginning line, and also a much simplier :

let member x y =  if null y then False
else if x == head y then True
else member x tail y

Any help would be appreciated.

Answer 1

with pattern matching you can write it more clearly

member :: (Eq a) => a -> [a] -> Bool
member x [] = False
member x (y:ys) | x==y = True
                | otherwise = member x ys

Answer 2

element _ [] = False
element e (x:xs) = e == x || e `element` xs
-- OR
element e xs = if xs == [] then False
               else if e == head xs then True
                    else e `element` tail xs
-- OR
element e xs = xs /= [] && (e == head xs || e `element` tail xs)
-- x `op` y = op x y

-- If you're feeling cheeky
element = elem

Your syntax appears very confused, but your logic makes sense, so here's a bucket list of things to remember:

• Functions can be defined by multiple equations. Equations are checked top to bottom. That means using = .

• Pattern matches are not equality tests. A pattern match breaks a value into its constituents if it matches and fails otherwise. An equality test x == y returns a Bool about the equality of x and y .

• Pattern matching is used for flow control via...

  • a case statement, like

     case xs of { [] -> ... x:xs' -> ... } 

  • Multiple equations, like

     element _ [] = ... element e (x:xs) = ... 

    Note that you can ignore a value in a pattern with _ . With multiple equations of a function with multiple arguments, you're really pattern matching on all the arguments at once.

• Bool s are used for flow control via if _ then _ else _ :

   if xs == [] then False else True 

  which is really just

   case x == y of { True -> False False -> True } 

  and Bool s can use the ordinary operators (&&) ( infixr 3 ) and (||) ( infixr 2 )

• The difference is especially nefarious on lists. instance Eq a => Eq [a] , so in order to use == on lists, you need to know that the elements of the lists can be compared for equality, too. This is true even when you're just checking (== []) . [] == [] actually causes an error, because the compiler cannot tell what type the elements are. Here it doesn't matter, but if you say, eg nonEmpty xs = xs /= [] , you'll get nonEmpty :: Eq a => [a] -> Bool instead of nonEmpty :: [a] -> Bool , so nonEmpty [not] gives a type error when it should be True .

• Function application has the highest precedence, and is left-associative:

  • element x xs reads as ((element x) xs)
  • element x tail xs reads as (((element x) tail) xs) , which doesn't make sense here

• f $ x = fx , but it's infixr 0 , which means it basically reverses the rules and acts like a big set of parentheses around its right argument

  • element x $ tail xs reads as ((element x) (tail xs)) , which works

• Infix functions always have lower precedence than prefix application:

  • x `element` tail xs means ((element x) (tail xs)) , too

• let decls in expr is an expression . decls is only in scope inside expr , and the entire thing evaluates to whatever expr evaluates to. It makes no sense on the top level.

• Haskell uses indentation to structure code, like Python. Reference