mapping group properties need to be extendable

[metagn]

Currently:

const Json = MappingGroup"json"

Then parameters use static MappingGroup.

The obvious thing here is to use a type. But it might be easier to do things in value form.

A user should be able to group things together after the fact, i.e.

const SnakeCase = group(Json, Yaml)

This would be the inverse of what inheritance provides (although the inheritance direction is also fine to have).

These need to be attachable to the format types as well or vice versa. Some kind of link between the two.

An idea is to use an extensible enum with knot but feels early to be doing this.

[metagn]

I think this is just a mime type analogue.

The difference is, the mime type of 1 json library can be more specific than json in general, then grouped together later into the json type, like defining a rule in prolog declareSubset(HoloJson, Json). And completely distinct mime types can be grouped together as well. Don't know if exclusion would be possible.

If types are used this could be accomplished like:

proc `<=`[T, U: MappingGroup](a: T, b: U): bool = false
proc `<=`[T: MappingGroup](a, b: T): bool = true

proc `<=`(a: HoloJson, b: Json): bool = true

If it was a value, then maybe there would be an attached parents seq which could be grown at compile time, but the macrocache stuff does not support deleting so exclusion wouldn't work or would be annoying. Strings would still be good in this case though.

I do not want to require macrocache for everything to work though. For now it might be enough to statically declare the parents at the format declaration site. - Done

Edit: Also literal mimetypes should probably be a property of these rather than directly used.

[metagn]

Problem still remains of default input/output names, which is important for the normalization hooks as in #2. Either the normalizer is passed to the mapping macros, which adds another argument and cannot really be a compile time value, or both are moved to a call to an overload handled by a format argument instead, i.e. instead of calculating the field name mappings in the macro, we instead generate:

case normalize(Format, T, fieldName)
of getNormalizedInputNames(Format, T, "field1", FieldMapping()): ...

This implies that instead of fieldMappings(T, Json), it might make more sense to do individual inputFieldMappings(JsonInputFormat, T) -> InputFieldMappingPairs etc. and split the FieldMapping object accordingly.

Maybe it will impact compile time though?

After this I think I am tapping out for the time being.

[metagn]

Default names and normalizer are fine. Properties being final is still a problem though, leaving open for that.

[metagn]

Ideally this is a separate library (glaze + ketin etc depend on the rest of the macros here), but not sure how to generalize the filters so that they work even without being defined here

Actually I guess none of the mapping macros care about MappingGroup, the getFieldMappings etc defaults could be another module that glaze/ketin specifically don't import (as long as nimble allows mutual dependencies)