View difference between Paste ID: SDV3Lbd1 and ZnERD2Wi

 (*
 Define a date-like triple to be a value of type int*int*int. Examples of date-like triples
 include (2013, 2, 1) and (0,0,1000). A date is a date-like triple whose first part is a
 positive year (i.e., a year in the common era), second part is a month between 1 and 12,
 and third part is a day between 1 and 31 (or 30, 29, or 28, depending on the month and year).
 (2013, 2, 1) is a date; (0,0,1000) is not.
 
 Write a function is_before that takes two dates as input and evaluates to true or false.
 It evaluates to true if the first argument is a date that comes before the second argument.
 (If the two dates are the same, the result is false.)
 
 Your function needs to work correctly only for dates, not for arbitrary date-like triples.
 However, you will probably find it easier to write your solution if you think about making
 it work for arbitrary date-like triples. For example, it's easier to forget about whether
 the input is truly a date, and simply write a function that claims (for example) that
 January 100, 2013 comes before February 34, 2013—because any date in January comes before
 any date in February, but a function that says that January 100, 2013 comes after
 February 34, 2013 is also valid. You may ignore leap years.
 *)
 let is_before a b  =
-    let amonth, aday, ayear = a in
+    let ayear, amonth, aday = a in
-    let bmonth, bday, byear = b in
+    let byear, bmonth, bday = b in
     ayear < byear ||
     (ayear = byear && amonth < bmonth) ||
     (ayear = byear && amonth = bmonth && aday < bday)
 
 
 (*
 Write a function earliest : (int*int*int) list -> (int*int*int) option. It evaluates
 to None if the input list is empty, and to Some d if date d is the earliest date in
 the list. Hint: use is_before.
 
 As in the previous exercise, your function needs to work correctly only for dates,
 not for arbitrary date-like triples.
 *)
 let  earliest l =
     let rec f d l' =
         match l' with
         | [] -> d
         | d' :: ds ->
             if is_before d d' then
                 f d ds
             else
                 f d' ds
     in
     match l with
     | [] -> None
     | d :: ds -> Some (f d ds)