使用也许用于列表的模式匹配会出现错误

Question

How should i use the Just constructor when decomposing a pattern?
EG:
If my pattern is : (x1,x2,x3,....xn) i will have to enclose each element of the pattern with its Just ?

My problem : i am trying to implement the Init function "safely".
Do i have to use the Just for the tail and for the head too in the second line?

safeInit::[a]->Maybe [a]
safeInit (x:xs)=x: safeInit (Just xs) #Just x : safeInit Just xs ?
safeInit [x,y]=Just [x]
safeInit _ =Nothing

Answer 1

There are two problems here:

• you make a call with as input a Maybe [a] ; and
• your first pattern contains a (strict) superset then the second, so the second one will never fire.

For the first problem, the culprit is in the line:

safeInit (x:xs) = x: safeInit (Just xs)

Here safeInit , expects a list (type [a] ), but you wrap the list in the Just constructor, hence you pass it a Maybe [a] value, and the safeInit can not handle this. So we can rewrite it to:

safeInit (x:xs) = x : safeInit xs

This will however not solve the problem, since now we call the "cons" ( : ) on an a , and Maybe [a] , and again, the function can not handle this. We will first have to inspect whether the recursive call produces a safeInit , and then prepend the x and rewrap it in a Just , we can do this with an fmap :

safeInit (x:xs) = fmap (x:) (safeInit xs)

For the second problem, we can rearrange the clauses:

safeInit :: [a] -> Maybe a
safeInit [x, _] = Just [x]
safeInit (x:xs) = fmap (x:) (safeInit xs)
safeInit [] = Nothing

Nevertheless there are still problems with this approach: it is rather inefficient, since we unwrap and wrap the Just element for all elements (except the last one), given that is not optimized. Furthermore in case we process an infinite list, we will get stuck in an infinite loop. We can improve it, by using an inner function, that calculates the init given we know for sure that that init is valid. For example:

safeInit :: [a] -> Maybe a
safeInit (x:xs) = Just (go x xs)
    where go _ [] = []
          go x (x2:xs) = x : go x2 xs
safeInit [] = Nothing

Answer 2

Well, it depends on what semantics you want. In case of init , once you've found any element at all, you know the result will actually be Just anyway, namely, Just init_xs . You then want to prepend the current x to the included list, not changing anything about the Just . The easiest way to do that is to use Maybe 's Functor instance:

safeInit (x:xs) = (x:) <$> safeInit xs

Note however that this only works if you put in an extra base case, and the clause must go before the generic cons one:

safeInit :: [a] -> Maybe [a]
safeInit [_] = Just []
safeInit (x:xs) = (x:) <$> safeInit xs
safeInit []  = Nothing

An alternative that's perhaps easier to understand is to pattern-match on the recursive result:

safeInit (x:xs) = case safeInit xs of
      Just init_xs -> Just $ x : init_xs
      Nothing -> Just []
safeInit [] = Nothing

Answer 3

Expanding on Elmex80s's suggestion,

safeInit :: [a] -> Maybe [a]
safeInit [] = Nothing
safeInit xs = Just (init xs)