Haskell关于列表函数中的递归

Question

i'm tryin to create a function(i'm new in haskell) which Needs two lists and Returns one List. The List should have all of the Elements of the first list,who aren't in the second and all of the second List, who aren't in the first.

So: func [3,2,1,4] [2,5,1] should return [3,4,5]

I think my Code goes to the right direction, but somewhere in it is a big mistake.

func :: [Int] -> [Int] -> [Int]
func [] a = a
func a [] = a
func (x:xs) (y:ys) | elem x (y:ys) = filter (/=x) (y:ys)
                   | otherwise = func ys xs

Answer 1

Pretending not to have any experience with this domain of problems or be very familiar with the functions in base , I'll rephrase your problem statement to describe the operation we want and show you how I'd approach it:

The result of fun on two lists is: all of the Elements of the first list,who aren't in the second and all of the second List, who aren't in the first.

To begin expressing this in code, replace "is" with = :

func l1 l2 = (elementsOfFirstNotInSecond l1 l2) ++(elementsOfFirstNotInSecond l2 l1)

Now we need to implement elementsOfFirstNotInSecond , so let's start with words:

elementsOfFirstNotInSecond on two lists is: if l1 is the empty list then the empty list, otherwise if the head of l1 (we'll call it " x ") is a member of l2 then x consed onto elementsOfFirstNotInSecond of the tail of l1 and l2 . Otherwise (if x was not in l2 ) it's just elementsOfFirstNotInSecond of the tail of l1 and l2

See if you can translate that to haskell, using not-yet-implemented functions (eg you might want to use ( isAMemberOf :: Int -> [Int] -> Bool ), and repeat the excercie.

Answer 2

Does output order matter?

If not, you could just use list difference (\\\\) from Data.List

Prelude > import Data.List
Prelude Data.List> as = [3,2,1,4]
Prelude Data.List> bs = [2,5,1]
Prelude Data.List> notinSec = as \\ bs
Prelude Data.List> notinFst = bs \\ as
Prelude Data.List> ans = notinSec ++ notinFst 
Prelude Data.List> ans
[3,4,5]

Answer 3

Since you want recursion and are new with haskell,so solution(movin' in your direction) would be something like

func (x:xs) (y:ys) | elem x (y:ys) && (not (elem y (x:xs))) = func xs (filter (/=x) (y:ys))
                   | (not (elem x (y:ys))) && (elem y (x:xs)) = func (filter (/=y) (x:xs)) ys
                   | (elem x (y:ys)) && (elem y (x:xs)) = func (filter (/=y) (xs)) (filter (/=x) (ys))
                   | otherwise = x : y : (func xs ys)

But you can see how ugly and imbecile this is at later stages in your learning path. I suggest you go with simpler and concise alternative.