Haskell中的模式匹配列表

Question

[Noob question] I have a list in haskell with only two elements :

mylist = ["Apple", "Mango"]

When I try to do pattern matching like this

[firstelemet ,secondelement] = mylist;

I get this kind of warning.

warning: [-Wincomplete-uni-patterns] Pattern match(es) are non-exhaustive In a pattern binding: Patterns not matched: [] [ ] ( : : :_)

Any suggestions on how this can be done in a better way. Actually I need to do this for unit testing that returns a list with two elements.

Answer 1

When teaching people to unit test in ML-based languages, I often get the question on how to verify a monadic value. Is that what's you're trying to do here?

The question is often a variation on:

How do I get the value out of the monad?

My answer is typically:

You don't. You step into the monad.

Are you trying to do something like this?

assertEquals "Apple" firstelement
assertEquals "Mango" secondelement

Here, I'm assuming that you have some sort of assertEquals function...

If so, it helps to realise that Haskell lists are Eq when elements are Eq , so instead, you could just write something like this:

assertEquals ["Apple", "Mango"] mylist

If that doesn't work for you, you could introduce a little helper function like this:

tryPair :: [a] -> Maybe (a, a)
tryPair [x, y] = Just (x, y)
tryPair _      = Nothing

This would enable you to first do this:

m = tryPair mylist

Maybe a is also Eq if a is Eq , so you could write your assertion like this:

assertEquals (Just ("Apple", "Mango")) m

If this still doesn't work for you, perhaps you could write a test utility function like this:

assertJust :: Maybe a -> (a -> ()) -> ()
assertJust (Just x) f = f x
assertJust Nothing _ = assertFail "Boo! Nothing!"

This would enable you to write something like this:

assertJust (tryPair mylist) $ \(x, y) -> assertEquals "Apple" x

Answer 2

You can write this as

mylist = ["Apple", "Mango"]
firstelement : secondelement : _ = mylist

to get the exact thing that you want, though the other approaches suggested here are probably better, conceptually. Note that this will only work with lists of at least 2 elements.