Comparing dates in list in Haskell - list

Question

So I created this function which takes 2 items and compares them and returns the largest date.
biggerDate :: (Ord a1,Ord a2,Ord a3) => (a3,a2,a1)->(a3,a2,a1)->(a3,a2,a1)
biggerDate (x, x1, x2) (y, y1, y2) =
if x2 > y2
then (x, x1, x2)
else if x1 > y1 then (x, x1, x2) else (y, y1, y2)
Now I am trying to have a list of dates and compare all of them to find the largest date.
All I have two far is
maxDate :: (Ord a1, Ord a2, Ord a3) => [(a3, a2, a1)] -> (a3, a2, a1)
I am stuck with trying to take 2 elements out of the list and compare them.

Answer 1

Let's think functionally and let the types guide us through this.
maxDate :: (Ord a1, Ord a2, Ord a3) => [(a3, a2, a1)] -> (a3, a2, a1)
maxDate xs = ???
We take a list and... do something. Well, the first question is: what do we want to happen if the list is empty? There are a couple of ways we could handle this, but for our purposes we'll just say that was a mistake and signal an error
maxDate :: (Ord a1, Ord a2, Ord a3) => [(a3, a2, a1)] -> (a3, a2, a1)
maxDate [] = error "Empty list of dates!"
maxDate (x : xs) = ???
Okay, the next simplest case is a single-element list. In that case, the biggest date is obviously the only one. After all, we've only got one choice.
maxDate :: (Ord a1, Ord a2, Ord a3) => [(a3, a2, a1)] -> (a3, a2, a1)
maxDate [] = error "Empty list of dates!"
maxDate [x] = x
maxDate (x : xs) = ???
Now we're left with the general case: there are several elements in our list. I've used pattern matching x : xs to extract the first one. What we want to do now is figure out which is bigger: the first element or the rest of the list. We can figure out what the biggest element in the rest of the list is with recursion: maxDate xs. Then we need to figure out whether that thing is bigger than or smaller than the first element x. You already wrote a function to do that, so let's use it.
maxDate :: (Ord a1, Ord a2, Ord a3) => [(a3, a2, a1)] -> (a3, a2, a1)
maxDate [] = error "Empty list of dates!"
maxDate [x] = x
maxDate (x : xs) = biggerDate x (maxDate xs)
And now we have a working implementation. But let's not stop there. Let's make it better.
First off, notice that we could do this for any binary function on (a3, a2, a1), not just biggerDate. Let's abstract our function a bit and take an additional argument
foldDate :: (Ord a1, Ord a2, Ord a3) => ((a3, a2, a1) -> (a3, a2, a1) -> (a3, a2, a1)) -> [(a3, a2, a1)] -> (a3, a2, a1)
foldDate _ [] = error "Empty list!"
foldDate _ [x] = x
foldDate f (x : xs) = f x (foldDate f xs)
I've added an additional argument to make our function more useful in general. Now, maxDate is just a special case of foldDate.
maxDate :: (Ord a1, Ord a2, Ord a3) => [(a3, a2, a1)] -> (a3, a2, a1)
maxDate = foldDate biggerDate
But we can go further, as it turns out, foldDate doesn't really need its arguments to be dates at all. It can work on any types.
fold :: (a -> a -> a) -> [a] -> a
fold _ [] = error "Empty list!"
fold _ [x] = x
fold f (x : xs) = f x (fold f xs)
maxDate :: (Ord a1, Ord a2, Ord a3) => [(a3, a2, a1)] -> (a3, a2, a1)
maxDate = fold biggerDate
Now, there's a very useful tool in Haskell called Hoogle. You can plug a type signature into it, and it'll tell you if something matching that signature is built-in or in a well-known Haskell library. Let's plug in our abstracted fold function's type: (a -> a -> a) -> [a] -> a. One of the first results is a function called foldr1. While the source is a bit more complex than what we've written here, it turns out foldr1 is literally the exact function we want. We didn't even need to write a fold function ourselves; it's already built-in.
maxDate :: (Ord a1, Ord a2, Ord a3) => [(a3, a2, a1)] -> (a3, a2, a1)
maxDate = foldr1 biggerDate
Great! maxDate is just two words now. That's pretty snazzy. But we can work on biggerDate too. See, as it turns out, Ord has an instance for 3-tuples of things, which automatically sorts starting with the first element, then the second, then the third. So, if you're willing to orient your dates in YMD order (rather than DMY as it looks like you're doing now), your biggerDate can get simpler as well.
biggerDate :: (Ord a1,Ord a2,Ord a3) => (a3, a2, a1) -> (a3, a2, a1) -> (a3, a2, a1)
biggerDate x y = if x > y then x else y
If you still want the dates to print in DMY format, you can always define a custom datatype (data Date = Date Int Int Int) with its own Show instance, but for now we'll just use YMD since it makes some things simpler.
Okay, but again, let's abstract. That function didn't do anything with tuples, so it should work for any Ord things, right?
bigger :: Ord a => a -> a -> a
bigger x y = if x > y then x else y
maxDate :: (Ord a1, Ord a2, Ord a3) => [(a3, a2, a1)] -> (a3, a2, a1)
maxDate = foldr1 bigger
Okay, that type signature looks pretty abstract now. Let's hop over to Hoogle once again. Lo and behold, the bigger function is built-in as well: it's called max. So we didn't even need bigger.
maxDate :: (Ord a1, Ord a2, Ord a3) => [(a3, a2, a1)] -> (a3, a2, a1)
maxDate = foldr1 max
Let's abstract once again. This version of maxDate didn't really use tuples either, so its type signature could be as general as Ord a => [a] -> a. One more trip through Hoogle tells us that even that function is available in Haskell. So our final definition is
maxDate :: (Ord a1, Ord a2, Ord a3) => [(a3, a2, a1)] -> (a3, a2, a1)
maxDate = maximum
The function maxDate is literally built-in to Haskell, if you know how to use the abstraction techniques at your disposal.
The reason I go through all of this in such detail is exactly that. It's valuable, especially when starting out, to be prepared to write these recursive definitions yourself, and I recommend you do so. In fact, just going through the standard library (Data.List in particular is a goldmine) and implementing the functions you see there by hand is a wonderful exercise when learning Haskell.
But it's also important to note that a lot of common design patterns are captured well by the standard library. Your pattern of "I have a binary function and I want to collapse a list" was captured by foldr1 (and its family of fold functions), and even more generally, your pattern of "I want the biggest thing in this list, for some definition of 'biggest'" was captured by the maximum function. This is why people use Haskell; it does a whole lot with its polymorphism capabilities and provides a relatively small standard library (compared to, say, Java) that turns out to be far more useful than it appears at first glance, based on its size, and captures a lot of higher-order programming patterns very elegantly.