haskell enum - what to do in case value constructors require value instead of nullary? Requirement scenario is given

Question

[...] all the value constructors are nullary (take no parameters, i.e. fields), we can make it part of the Enum typeclass.
data Day = Monday | Tuesday | Wednesday | Thursday | Friday | Saturday | Sunday
deriving (Eq, Ord, Show, Read, Bounded, Enum)

Now, if I take months, it will be

data month = January | February | March | April | May | June | July | August |September | October | November |December     
deriving (Eq, Ord, Show, Read, Bounded, Enum)

My questions are:

Where to store Max Days value for each month?
How to mention and control that for February month if it is leap year then maxDays for February is 29 days otherwise it will be 28 days?

In Java one can code like given below:

public enum Month {  
    January (31),  
    February (29),  
    March (31),  
    April (30),  
    May (31),  
    June (30),  
    July (31),  
    August (31),  
    September (30),           
    October (31),  
    November (30),  
    December (31),  
    ;  
    private int maxDays; // instance variables  
    private (int maxDays) { // constructors always private  
           this.maxDays = maxDays;  
    }  
    Public int getMaxDays () {  
       return maxDays;  
    }

You should use the [time](http://hackage.haskell.org/packages/archive/time/1.4.0.1/doc/html/Data-Time-Calendar.html) package, which was written by someone who really knows what's up. — Daniel Wagner, Jul 26 '12 at 04:27
What you are asking for is not a valid instance of `Enum`. The `Enum` class is for types that can be converted to and from a subset of `Int` without losing information. You've assigned the same number to several months, which makes this conversion impossible. — Heatsink, Jul 26 '12 at 06:12
@Optimight: In your Day example, the `deriving(Enum)` clause generates a valid instance of `Enum`. Specifically, the generated function gives each day a different `Int` value. `Monday = 0`, `Tuesday = 1`, ... `Sunday = 6`. — Heatsink, Jul 26 '12 at 20:47
@HeatSink: In that case, for second example of data Month also, gives January = 0, February = 1, ... December = 11. Only thing , it further attaches the value of maxDays to each month. — Optimight, Jul 26 '12 at 23:12
@Optimight, I see. You wanted maxDays to be separate from the constructor ID. — Heatsink, Jul 27 '12 at 00:49

score 7 · Accepted Answer · edited Jul 26 '12 at 10:21

This should work.

data Month = January | February | March | April | May
           | June | July | August |September | October
           | November | December
           deriving (Eq, Ord, Show, Read, Bounded, Enum)

type Year = Int

isLeapYear :: Year -> Bool
isLeapYear year = year `mod` 4 == 0 && (year `mod` 100 /= 0 || year `mod` 400 == 0)

getMaxDays :: Year -> Month -> Int
getMaxDays _ January = 31

getMaxDays year February
    | isLeapYear year = 29
    | otherwise = 28

getMaxDays _ March = 31
getMaxDays _ April = 30
getMaxDays _ May = 31
getMaxDays _ June = 30
getMaxDays _ July = 31
getMaxDays _ August = 31
getMaxDays _ September = 30
getMaxDays _ October = 31
getMaxDays _ November = 30
getMaxDays _ December = 31

score 7 · Answer 2 · answered Jul 26 '12 at 06:40

Why do you need Month to be an Enum? It seems to me that you are trying to force an OO style in your code, which is not a good idea. The Java object oriented style of writing code does not cleanly translate to functional languages like Haskell.

Where in OO, you would bundle the data structure and all associated operations on that data in a class, in FP, you would define the data structure separately from the associated operations. This means that the FP approach makes it easier to define new operations on data, where as OO approach makes it easier to add new information to your data structure. Personally I find myself defining new operations a lot more than adding new fields and FP style suits that well.

The closest analogue to the Java example in Haskell would be to define a Typeclass -

data Month = January | February | March | April
           | May | June | July | August |September
           | October | November |December
  deriving (Eq, Ord, Show, Read, Bounded, Enum)

data Year = Int

class HasDays X where
  maxdays :: X -> Int
  days    :: X -> Year -> Int
  -- Any other "methods" here

instance HasDays Month where
  maxdays January = 31
  maxdays February = 29
  maxdays .. = .. -- Similar code for other months

  days February y = .. -- Leap year calculation
  days m _ = maxdays m

I am used to OO paradigm, but while going for FP it must be pure and genuine FP approach. — Optimight, Jul 26 '12 at 16:35

haskell enum - what to do in case value constructors require value instead of nullary? Requirement scenario is given

2 Answers2