add FromAeson class to easily bring Aeson.Value across

[dmvianna]

I spent an inordinate time this afternoon on ToJSON and FromJSON only to realise the internal Parser type in Aeson is from Attoparsec and is really concerned with ByteString.

While what I needed was interoperability between JsonValue and Aeson.Value. Yes, the easiest win would always be to use fromAeson, which I did.

This is all so we don't waste time transforming strings. Maybe we should just expose fromAeson as it was before and be done with it.

[istathar]

Hey @dmvianna thanks for your contribution.

Hm!

I would like to think a FromJSON and ToJSON instance for our JsonValue wrapper shouldn't be beyond the pale. If you like I can try and figure that out with you.

I'd probably prefer that we figure those instances out rather than adding a new typeclass. If we did, then we'd probably want to follow the intoBlah and fromBlah naming convention used in the other packages in this library. Maybe

class Serialize α where
   parseJson :: JsonValue -> Maybe α
   intoJson :: α -> JsonValue

(following the slightly amended pattern in Externalize; not the worse name, although it's not generalized seralizing. Bloatable? Objectable? gawd Objectify maybe)

...but that really is ripping off the machinery in aeson. Not sure if it's worth adding. Maybe it is.

More to the point, I'm not sure if that's what you're looking for.

Anyway:

Option 1: add FromJSON and ToJSON instances for our JsonValue
Option 2: add Seralize (or whatever) typeclass.

[dmvianna]

I think the whole trouble is that I got wrapped up in the idea of using ToJSON and FromJSON because that's what we do with Aeson. But I got into the task without thinking it through.

The ideal outcome would be a function such as (ToJSON a) => a -> JsonValue. Why? Because it is easy to derive ToJSON, many types have that in most codebases, and there aren't many ways to get nice shell output with Doc without implementing it by hand. There is pretty-simple, but it doesn't play nice with unbeliever.

[dmvianna]

What I want is deriving (Pretty) or deriving (Doc).

[istathar]

Sounds like what you want is deriving (Render)! :)

Joking aside, we can almost certainly get

:: (ToJSON a) => a -> JsonValue

happening.

The question is do you need pretty printing (for which we have extensive support via prettyprinter and the Render typeclass) or automated JSON encoding/decoding?

[dmvianna]

Pretty printing please. Not only of JSON.

[dmvianna]

Pretty printing of Haskell records.

[istathar]

You could probably come up with a derived Render instance using GHC Generics, though that's "Here be dragons" territory for me. I can think of a few other packages that seem to have done something similar if you want pointers of code to study.