Type-level default fields for aeson Generic FromJSON parser

import Data.Aeson ( FromJSON(parseJSON), decode ) import Data.Default ( Default(..) ) import GHC.Generics (Generic) import qualified Data.Text as T import qualified Data.Aeson as AE import Data.Aeson.DefaultField -- Define some custom datatype for json data data Color = Red | Green | Blue deriving (Generic, FromJSON, Show) -- We may want a default instance for later use with DefDefault instance Default Color where def = Red -- Alternatively, we may create a separate default type that would be coerced back -- to Color with DefDefaultConstant. This allows for different default values -- with the same type for different fields. newtype BlueDefault = BlueDefault Color deriving Generic instance DefaultConstant BlueDefault where defValue _ = Blue -- Simply create the data object we want to parse from the file; add a type parameter -- so that we can use the type family magic to create 2 different type representations. -- Normal fields act normally. Use DefaultField with the appropriate settings -- to configure the parsing of the missing fields. Null fields are NOT replaced -- with the default value; only missing fields are. data ConfigFileT d = ConfigFile { defaultEnabled :: DefaultField d (DefBool True) , defaultDisabled :: DefaultField d (DefBool False) , defaultText :: DefaultField d (DefText "default text") , defaultInt :: DefaultField d (DefInt 42) , defaultNegativeInt :: DefaultField d (DefNegativeInt 42) , defaultRed :: DefaultField d (DefDefault Color) , defaultBlue :: DefaultField d (DefDefaultConstant BlueDefault) , normalField :: T.Text , normalOptional :: Maybe Int } deriving (Generic) -- Create a type alias so that we can (mostly) handle the type as if nothing special -- was happening under the hood. type ConfigFile = ConfigFileT Final deriving instance Show ConfigFile -- Create a custom parsing instance for the data object. instance FromJSON ConfigFile where parseJSON = parseWithDefaults AE.defaultOptions{AE.rejectUnknownFields=True} 

>>> AE.decode "{\"defaultDisabled\":true,\"normalField\":\"text\"}" :: Maybe ConfigFile >>> Just (ConfigFile {  defaultEnabled = True , defaultDisabled = True , defaultText = "default text" , defaultInt = 42 , defaultNegativeInt = -42 , defaultRed = Red , defaultBlue = Blue , normalField = "text" , normalOptional = Nothing} ) 

The provided DefText, DefInt, etc. newtypes should provide enough flexibility to configure the missing fields for the objects. If a special type of configuration is needed, a newtype based on a final type must be created with Generic and FromJSON instances. See the source code for examples.

The default newtypes do not replace null value with the default value. You can create your own types that behave differently.

E.g. a configuration that would use the singletons package is:

newtype DefSing (a :: k) = DefSing (Demote k) deriving Generic instance (SingI a, SingKind k, FromJSON (Demote k)) => FromJSON (DefSing (a :: k)) where omittedField = Just $ DefSing $ fromSing (sing @a) parseJSON v = DefSing <$> parseJSON v

The configuration would then be:

defaultBool :: DefaultField d (DefSing False)

The final step in the parsing is coercing the structure with newtypes (e.g. DefBool) to a structure with the final types (e.g. Bool). Unfortunately, the type families in Haskell cause the type not to be directly coercible between the intermediate and the Final stage. However, it is possible through the Generic instances.

This solution probably brings some performance degradation in the sense that the structure must be recreated. Benchmark before use in performance-sensitive situations.