Use nullary constructor with algebraic data type instead of wrapping with Maybe?

Question

I was doing this type of thing in my code:

data MyType = Cons1 a b
data OtherType = OtherType
             { val1 :: Int
             , val2 :: String
             , val3 :: Maybe MyType
             }

and I was wondering if changing the code to this would be neater/simpler and what the pros/cons are:

data MyType = Cons1 a b | Missing
data OtherType = OtherType
             { val1 :: Int
             , val2 :: String
             , val3 :: MyType
             }

What I am doing is reading lines from a file into [OtherType], each line has 4 columns say with columns 3 and 4 being used to create val3 :: MyType. Currently I am using readMaybe to read a and b and then passing them to a function that returns Nothing if either of them are Nothing or Just MyType if they are Just a and Just b. I was thinking I could change this to return Missing instead thereby removing one layer of wrapping.

Answer 1

You should only add the Missing constructor to MyType if it makes sense for all MyType values to have the possibility of Missing. You will have to handle Missing in all functions dealing with MyType values. If the majority of these would be non-total—throw an error or otherwise fail—then clearly Missing does not belong in MyType and you should just use Maybe MyType instead.

Simply put: if optionality is inherent in the type, encode it in the type. Otherwise, keep it separate.