Enable relaxing of UnionEncoder requireRecordFields

[dharmaturtle]

I only did Newtonsoft.Json so far because System.Text.Json is proving annoying. I'll elaborate further if you like what's here.

Ref: #61

[bartelink]

I'm slightly reticent to add this dependency at this level.
My thinking is that the FsCodec package to date has largely only supplied contracts, and does not force many dependencies.
The scenario I had in my head is if someone is using an external library to provide the Codecs (and/or you're using the Create overloads that take an encode and tryDecode pair).
I'm not sure this matters.

This also slightly overlaps with my stance on using InternalsVisible and making things fully DRY by stuffing things into the core. My preferred technique is to have a source file somewhere in the tree and then add it as a reference to multiple projects. This allows one to e.g. keep FsCodec at 2.0.0 while still allowing one to update FsCodec.SystemTextJson to 2.4.0 without necessitating the same change for other modules in a subsystem that still use FsCodec.NewtonsoftJson.

I think this pattern should be followable here?

[bartelink]

not sure about byte, sbyte and char - stuff that naturally maps to JSON seems a reasonable baseline ?

(remember Cosmos, and also things like SqlStreamStore.Postgres will impose their own constraints)

Also, related to comments on checkIfSupported, maybe the rules as to what's roundtripable should live in the store?

A case in point is VerbatimUtf8Converter: it is used by Equinox.Cosmos, but Equinox.CosmosStore (the V3 master impl), uses a different local impl (which, when we take it from jet/equinox#197 will be based on System.Text.Json).

Moving the code and/or mechanisms to live with the store might be an approach to take?

A counterpoint: While EventStore is happy to store any byte[] blob, it also has an IsJson which allows one to write JS projections, and in V20+ it has a Content-Type.

This suggests that a reasonable codec library might be general in nature and allow one to define a profile you're targetting in the abstract, which a concrete store library can define.

Going down that road would also mesh will with the notion of a contract checker which can be used to compile time check a contract adheres to rules - i.e. we might want to be able to define a convention in an integration test library that says "For this Domain lib, event contracts must be rountrippable on Equinox.Cosmos >=V3 and Equinox.EventStore >=V2, and all enums must be represented as strings (which implies having to add the converter attributes on the type)"

In that world, perhaps an FsCodec.Contracts library might depend on TypeShape and implement all this rather than shoving everything into FsCodec ?

[bartelink]

A case in point is VerbatimUtf8Converter: it is used by Equinox.Cosmos, but Equinox.CosmosStore (the V3 master impl), uses a different local impl (which, when we take it from jet/equinox#197 will be based on System.Text.Json).

Moving the code and/or mechanisms to live with the store might be an approach to take?

Hm, pendulum swing: but Propulsion.Kafka.Codec also uses it.

OK, I think that suggests that there are multiple axes of constraints:

• store-imposed: Equinox.Cosmos only wants JSON
• more arbitrary: Propulsion.Kafka is looking to roundtrip a representation of an event from a store over Kafka
• self-imposed: using Equinox.EventStore but we want to have all bodies be valid JSON so we can do JS projections
• style: our team is using F# and we have decided our rule is we use records no matter what for reasons discussed in Relaxing requireRecordFields = true #61
• not all roundtrips may be implemented in all libraries - i.e. some thorny thing might work in FsCodec.SystemTextJson but not in FsCodec.NewtonsoftJson

=> The rule checker may have a common impl to a degree, but we share any shareable bits by coimpiling the common code into a specific impl vs putting it into FsCodec

[bartelink]

You can preserve the symmetry of having a type check either way by doing something like
| U.Double x, U.Double d when Double.IsNaN x => test <@ Double.IsNaN d @> (or true =! Double.isNan d is you prefer)

[bartelink]

🤔 does unquote provide a way to express this?

[bartelink]

hm, consider explicitly listing the cases rather than leaving this open. If Half appears in this union, whats our stance?

[bartelink]

Option.iter ?

[bartelink]

While this may be technically correct, I think I'd stick to using UTF8 in the interests of not overfitting? Same for Guid case.

Also this might make things easier / more sensible for STJ, which is v UTF8 centric

[bartelink]

because System.Text.Json is proving annoying

I know that feeling (and many around the world do!) 😄 see #59

[bartelink]

Thank you for the work thus far - this is looking very promising. Re #61, I had not done much thinking through / imagining of how this might look overall as your implementation is making me do now.

I covered some of these tradeoffs more in the code review comments; there may be things I've yet to consider which will prove some of the following wrong/unworkable, but my thoughts are:

• I had thought that in principle each store should implement it's own checker - you've shown it can live here, and I like it
• I still think I don't want to stuff things into the FsCodec core module but I may ultimately be wrong - someone that wants to write their own mapping functions and/or use a different serializer, they get to define (and maintain) their own rules. Putting helper modules in there also gives a false impression that FsCodec is a massively complex library; the intent is really to define a very minimal set of contracts indeed at that level.
• considering how a contract style checker might be organized can be a useful tool for thinking about where stuff should live; expanding below on that concept

There are multiple axes of constraints:

• store-imposed: Equinox.Cosmos can only store JSON - i.e. embedded byte[] content needs to be base64 encoded
• e.g. DynamoDb might impose slightly different constraints than Cosmos
• more arbitrary: Propulsion.Kafka is looking to roundtrip a representation of an event from a store over Kafka, which in general is fine if its UTF8
• self-imposed: if usin using Equinox.EventStore, any byte[] is fine but we want to have all bodies be valid JSON so we can do JS projections
• style: our team is using F# and we have decided our rule is we use records no matter what for reasons discussed in Relaxing requireRecordFields = true #61
  not all roundtrips may be implemented in all libraries - i.e. some thorny thing might work in FsCodec.SystemTextJson but not in FsCodec.NewtonsoftJson
• We want to define sets of rules that our IUnionContract types should observe as described in feat: Contract types validation #50 (One could imagine building a Roslyn analyzer checking the rules on the fly too)

[bartelink]

require does not Enables ....; Perhaps something like:

/// Controls whether bodies of union cases are permitted to use primitive types,
/// which can be harder to evolve when compared to always wrapping in a record in order to force all fields to have names.
/// Defaults to <c>true</c>, i.e. preventing Guids and primitives from being used directly