How to conditionally parse JSON based on settings in a Reader environment? - haskell

Question

Is there any way to pass down a reader environment to the JSON (de)serialisation functions of Aeson? Here's a real-life example of why this could be required?
-- JSON instances for decimal -- ORPHAN instances
defaultPrecision :: Word8
defaultPrecision = fromInteger 2
instance ToJSON Data.Decimal.Decimal where
toJSON d = toJSON $ show d
instance FromJSON Data.Decimal.Decimal where
-- TODO: New problem! How do we get the precision dynamically, based on
-- the currency settings of the logged-in user
parseJSON (Number n) = return $ Data.Decimal.realFracToDecimal defaultPrecision n
parseJSON x = fail $ "Expectig a number in the JSON to parse to a Decimal. Received " ++ (show x)

Answer 1

If instance depends on some runtime value then what you really want is an ability to create instances at runtime. You can implement FromJSON for Reader as it's done in your gist. But as you correctly noticed, you can't do the same for ToJSON because you don't know this precision. The easiest solution would be just store precision as separate field in data type. Like this:
data DecimalWithPrecision = MkDWP
{ value :: Decimal
, precision :: Word8
}
If you store this data type in your data base and query it after user login, then this is the easiest solution and doesn't require type level tricks from you.
If you don't know precision in advance, for example user inputs precision through console (I don't know why, but lets assume this), then this wouldn't work for you. As we all know that «type classes are just syntax sugar for data types», you can replace ToJSON/FromJSON constraints with JsonDict for Money_ in the following manner:
newtype Money_ = Money_ (Reader Word8 Decimal)
data JsonDict a = JsonDict
{ jdToJSON :: a -> Value
, jdParseJSON :: Value -> Parser a
}
mkJsonDict :: Word8 -- precision
-> JsonDict Money_
You can create such dictionary (or something similar to it) on-the-fly using Word8 from context and just pass it to function which needs it. See this blog post by Gabriel Gonzalez for details.
If you really want to have toJSON implementation inside instance, you can use reflection library. Precision is a natural number which gives you ability to use this library. Using it you basically can create instances in runtime as in previous approach, but you still have your type classes. See this blog post where similar technique was applied to make Arbitrary instances depend on runtime values. In your case this will look like this:
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE UndecidableInstances #-}
import Control.Monad.Reader (Reader, ask)
import Data.Aeson (FromJSON (..), Result (..), ToJSON (..),
Value, fromJSON, withNumber)
import Data.Aeson.Types (Parser)
import Data.Decimal (Decimal, realFracToDecimal)
import Data.Proxy (Proxy (..))
import Data.Reflection (Reifies (reflect), reify)
import Data.Word8 (Word8)
newtype PreciseDecimal s = PD Decimal
instance Reifies s Int => FromJSON (PreciseDecimal s) where
parseJSON = withNumber "a number" $ \n -> do
let precision = fromIntegral $ reflect (Proxy :: Proxy s)
pure $ PD $ realFracToDecimal precision n
instance Reifies s Int => ToJSON (PreciseDecimal s) where
toJSON (PD decimal) =
let precision = reflect (Proxy :: Proxy s)
ratDec = realToFrac decimal :: Double
in toJSON ratDec -- use precision if needed
makeMoney :: Decimal -> Reader Word8 (Value, Decimal)
makeMoney value = do
precision <- fromIntegral <$> ask
let jsoned = reify precision $ \(Proxy :: Proxy s) ->
toJSON (PD value :: PreciseDecimal s)
let parsed = reify precision $ \(Proxy :: Proxy s) ->
let Success (PD res :: PreciseDecimal s)
= fromJSON jsoned in res
pure (jsoned, parsed)
And then you can run it like this to test:
ghci> runReader (makeMoney 3.12345) 2
(Number 3.12345,3.12)