Add JPropCodec variants of sum codecs

[garyb]

@m-bock Right before I made the release as per #80 I ran into a case where I found myself wanting a JPropCodec for a sum type so I could combine it with another codec for a surrounding type:

import Prelude

import Data.Codec.Argonaut ((~))
import Data.Codec.Argonaut as CA
import Data.Codec.Argonaut.Sum as CAS
import Data.Generic.Rep (class Generic)
import Data.String as String
import Data.Tuple (Tuple(..), fst, snd)

type Var = Tuple String

codecVar ∷ ∀ a. String → CA.JPropCodec a → CA.JsonCodec (Var a)
codecVar name codec =
  CA.object name $ Tuple
    <$> fst ~ CA.prop "name" CA.string
    <*> snd ~ codec

data Typed
  = Str String
  | Bool Boolean
  | Num Number

derive instance Generic Typed _

type Value = Var Typed

codecValue ∷ CA.JsonCodec Value
codecValue = codecVar "Value" $ CAS.sumWith' encoding
  { "Str": CA.string
  , "Bool": CA.boolean
  , "Num": CA.number
  }
  where
  encoding =
    CAS.EncodeTagged
      { tagKey: "type"
      , valuesKey: "value"
      , unwrapSingleArguments: true
      , omitEmptyArguments: true
      , mapTag: String.toLower
      }

This gives us Tuple "foo" (Str "BAR") ⇔ { "name": "foo", "type": "str", "value": "BAR" }. The motivating case was a bit more involved, so this looks like a lot of work for something of questionable necessity, but hopefully it illustrates the idea still! Basically, without this, we can't deal with complex sums and would have to match our PS representation to the flat structure of the JSON object (aside from introducing further types and doing a conversion step or something like that).

(Also, isn't it kinda cool the way codecVar worked out? 😄)

[m-bock]

Nice idea, i see the purpose! Just one thing to consider: Doesn't this imply that Sum.Encoding alway describes encodings to objects? What if we want to extend it with third case that encodes to tuple-Arrays, like e.g. for Typed sample:

["Str", "hello"]
["Bool", true]
["Num", 42]

[m-bock]

Or maybe one day there's an encoding that encodes constructors without args just as strings.

data Sample = Foo Int | Bar String | Baz

{"type": "Foo", "value": 6}
{"type": "Bar", "value": "abc"}
"Baz"

[garyb]

Yeah, those are good points. Maybe there's something that could be done for this case that could be constrained to sumFlatWith, since that does imply an object encoding and is somewhat similar to what I wanted to achieve.

If I can't come up with anything for that I might just merge this as it is for now, as I definitely have this use case (and have also had it in the past) and haven't personally encountered cases for those other encodings yet. 😉

[m-bock]

I might just merge this as it is for now

go for it :)

[m-bock]

@garyb Any news on this topic?

I think after some time I am getting more and more convinced that it may be better to stay with the initial JsonCodec approach.

I see that the JPropCodec approach makes lot of sense in your scenario. But restricting Sum encodings to Records seems to be a bit too restrictive to me.

Think about encodings that need to be optimized for size. Maybe you want to encode as Strings or Ints to save much space as possible.

data Foo = Bar String | Baz Int

So If you have an (Array Foo) it makes a difference on large data:
[{ tag: "Bar", value: "Name1"}, { tag: "Bar", value: "Name2"}, { tag: "Baz", value: 42}, { tag: "Baz", value: 0}, ....]
vs.
["Name1", "Name2, 42, 0, ....]

(of course that's not possible with what we have today, but maybe in the future...)

So I think to settle on Records is a bit arbitrary. Maybe there is a way to handle your case with a wrapper using some unsafe internal implementation?

[wclr]

I thought about something like this. I had case where I need JSON object codec for sum type, like this:

type JsonObjectCodec a = Codec' (Either JsonDecodeError) (Object Json) a

Maybe there is a way to handle your case with a wrapper using some unsafe internal implementation?

To get this I have to go unsafe (to get it from sum's JsonCodec a) and I don't like it much.

This approach also allows to safely implement typed tags mapping as a separate module/function, something like this:

mapTags ∷
  ∀ r' rep a. GTagsMap r' rep ⇒ Generic a rep ⇒ Record r' → JPropCodec a -> JPropCodec a
mapTags tagsMap codec =
  Codec.codec
    (\obj → (Codec.decode codec =<< foldTags obj))
   (mapKeys <<< Codec.encode codec)
  where
  tagsObj = gTagsMap (Proxy @rep) tagsMap
  fromTagsMap s = fromMaybe s (FO.lookup s tagsObj)
  mapKeys = map (lmap fromTagsMap)
  foldTags obj = FO.fromFoldable <$> for (FO.toUnfoldable tagsObj :: List _)
    \(Tuple tag mappedTag) ->
      maybe (Left MissingValue) (Right <<< Tuple tag) (FO.lookup mappedTag obj)

I see that the JPropCodec approach makes lot of sense in your scenario. But restricting Sum encodings to Records seems to be a bit too restrictive to me.

So I'm not sure if such restriction is a bad thing. Anyway, you can transform JPropCodec to anything you like.