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 :)