I am reading through the "Starting Out" chapter of Learn You a Haskell for Great Good!. It says:
nullchecks if a list is empty. If it is, it returnsTrue, otherwise it returnsFalse. Use this function instead ofxs == [](if you have a list calledxs)
I tried in ghci:
xs = [] -- and then,
xs == []
null xs
Both of them are True.
I wonder what's the difference.
Should I use the null function instead of == [] and why?
You should use null. In most cases it doesn't matter, but it is a good habit to get into anyway, because occasionally you may want to check if a list of non-comparable things is empty. Here is a short, crisp example showing this difference:
> null [id]
False
> [id] == []
<interactive>:1:1: error:
• No instance for (Eq (a0 -> a0)) arising from a use of ‘==’
(maybe you haven't applied a function to enough arguments?)
• In the expression: [id] == []
In an equation for ‘it’: it = [id] == []
Eq constraint (even if they will indeed in most cases be instantiated with Eq types).
length xs == 0 is a bad idea.
length xs == 0 is a bad idea because it needs to traverse the whole linked list (which is O(n) and never terminates on an infinte list).There is a difference. In order to use x == [], the type of the elements of the list should be a member of the Eq typeclass. Indeed, checking the equality of two lists is defined by the instance declaration:
instance Eq a => Eq [a] where
[] == [] = True
(x:xs) == (y:ys) = x == y && xs == ys
_ == _ = FalseThat means that you can not use x == [] if x is for example a list of IO Ints.
null :: [a] -> Bool on the other hand, uses pattern matching. This is implemented as:
null :: [a] -> Bool null [] = True null (_:_) = False
So regardless what type the elements of the list are, it will always typecheck.
In addition to the good answers given so far, null actually has type
null :: Foldable t => t a -> Bool
I don't know if you've gotten to typeclasses in LYAH, but the short of it is that null can be used not just for lists, but for any data structure that implements null.
This is to say that using null on a Map or a Set is valid, too.
> null Map.empty
True
> null (Map.singleton 1)
False
> null Set.empty
True
> null (Set.singleton 1)
False
> null []
True
> null [1]
False
I don't think it's especially common to write functions that need to be this general, but it doesn't hurt to default to writing more general code.
In many cases, you'll end up wanting to use a function like null to do conditional behavior on a list (or other data structure). If you already know that your input is a specific data structure, it's more elegant to just pattern match on its empty case.
Compare
myMap :: (a -> b) -> [a] -> [b]
myMap f xs
| null xs = []
myMap f (x:xs) = f x : myMap f xs
to
myMap' :: (a -> b) -> [a] -> [b]
myMap' f [] = []
myMap' f (x:xs) = f x : myMap' f xs
In general, you should try to prefer pattern matching if it makes sense.
Also a simple function that filter all empty list would fail:
withoutEmpty = filter (== [])
and that would be:
withoutEmpty = filter null
notice that:
withoutEmpty ls = filter (==[]) ls
will work just fine, but the important point is that in some cases like the other one could fail.
Also look at @cole answer, it complements all the answers here, the typeclass Foldable has the null function there to be implemented:
To see more info of Foldable here
withoutEmpty = filter (==[]) may cause an error, but withoutEmpty x = filter (==[]) x works fine.