# bbarks15's solution

## to Leap in the Haskell Track

Published at May 13 2021 · 0 comments
Instructions
Test suite
Solution

#### Note:

This exercise has changed since this solution was written.

Given a year, report if it is a leap year.

The tricky thing here is that a leap year in the Gregorian calendar occurs:

``````on every year that is evenly divisible by 4
except every year that is evenly divisible by 100
unless the year is also evenly divisible by 400
``````

For example, 1997 is not a leap year, but 1996 is. 1900 is not a leap year, but 2000 is.

## Notes

Though our exercise adopts some very simple rules, there is more to learn!

For a delightful, four minute explanation of the whole leap year phenomenon, go watch this youtube video.

## Hints

To complete this exercise you need to implement the function `isLeapYear` that takes a year and determines whether it is a leap year.

## Getting Started

Please refer to the installation and learning help pages.

## Running the tests

To run the test suite, execute the following command:

``````stack test
``````

#### If you get an error message like this...

``````No .cabal file found in directory
``````

You are probably running an old stack version and need to upgrade it.

#### Otherwise, if you get an error message like this...

``````No compiler found, expected minor version match with...
Try running "stack setup" to install the correct GHC...
``````

Just do as it says and it will download and install the correct compiler version:

``````stack setup
``````

## Running GHCi

If you want to play with your solution in GHCi, just run the command:

``````stack ghci
``````

## Feedback, Issues, Pull Requests

The exercism/haskell repository on GitHub is the home for all of the Haskell exercises.

If you have feedback about an exercise, or want to help implementing a new one, head over there and create an issue. We'll do our best to help you!

## Source

JavaRanch Cattle Drive, exercise 3 http://www.javaranch.com/leap.jsp

## Submitting Incomplete Solutions

It's possible to submit an incomplete solution so you can see how others have completed the exercise.

### Tests.hs

``````{-# OPTIONS_GHC -fno-warn-type-defaults #-}
{-# LANGUAGE RecordWildCards #-}

import Data.Foldable     (for_)
import Test.Hspec        (Spec, describe, it, shouldBe)
import Test.Hspec.Runner (configFastFail, defaultConfig, hspecWith)

import LeapYear (isLeapYear)

main :: IO ()
main = hspecWith defaultConfig {configFastFail = True} specs

specs :: Spec
specs = describe "isLeapYear" \$ for_ cases test
where

test Case{..} = it explanation assertion
where
explanation = unwords [show input, "-", description]
assertion   = isLeapYear (fromIntegral input) `shouldBe` expected

data Case = Case { description :: String
, input       :: Integer
, expected    :: Bool
}

cases :: [Case]
cases = [ Case { description = "year not divisible by 4 in common year"
, input       = 2015
, expected    = False
}
, Case { description = "year divisible by 2, not divisible by 4 in common year"
, input       = 1970
, expected    = False
}
, Case { description = "year divisible by 4, not divisible by 100 in leap year"
, input       = 1996
, expected    = True
}
, Case { description = "year divisible by 4 and 5 is still a leap year"
, input       = 1960
, expected    = True
}
, Case { description = "year divisible by 100, not divisible by 400 in common year"
, input       = 2100
, expected    = False
}
, Case { description = "year divisible by 100 but not by 3 is still not a leap year"
, input       = 1900
, expected    = False
}
, Case { description = "year divisible by 400 in leap year"
, input       = 2000
, expected    = True
}
, Case { description = "year divisible by 400 but not by 125 is still a leap year"
, input       = 2400
, expected    = True
}
, Case { description = "year divisible by 200, not divisible by 400 in common year"
, input       = 1800
, expected    = False
}
]``````
``````module LeapYear (isLeapYear) where

isLeapYear :: Integer -> Bool
isLeapYear year = isDivisibleBy 400 || isDivisibleBy 4 && not (isDivisibleBy 100)
where isDivisibleBy n = mod year n == 0``````