Helper for deriving Ron instances. Use like this:

     data MyType = MyType {...}
         deriving (Eq, Show, Generic)
         deriving (ToRon, FromRon)
             via RonWith '[FieldsDropPrefix, EncodeWith SkipSingleConstructor] MyType

This is identical to

     data MyType = MyType {...}
         deriving (Eq, Show, Generic)
     instance ToRon MyType where
         toRon =
             let settings
                 = (s{encodeFlags} -> s{encodeFlags = encodeFlags{skipSingleConstructor = True}})
                 . (s{fieldModifier} -> s{dropPrefix . fieldModifier})
                 $ laxRonSettings
             in toRonGeneric settings

The options are applied left to right, and the starting options are laxRonSettings

All of built-in settings are documented in Deriving module. You can define your own settings by creating new datatypes and creating instances for ReflectSettingsOptions or ReflectFlagOptions

Replace the current settings with strictRonSettings

Sets a flag in encodeFlags. Can set anything with ReflectFlagOptions instances, like ImplicitSome, SkipSingleConstructor

Sets a flag in decodeFlags. Can set anything with ReflectFlagOptions instances

Same as setting both EncodeWith and DecodeWith

Convert fields to snake case. If your field also has prefix, you want to have this option after FieldsDropPrefix, as options are applied left to right

Drop the prefix that is usually used with lenses, that is an underscore followed by several lowercase letters; regex for this prefix is s/^_[[:lowercase:]]+([[:uppercase:]].*)/\1/. You probably want to use this field modifier before other field modifiers, as they are applied left to right

Encode or decode flag that sets implicitSome to True

Encode or decode flag that sets implicitSome to False

Encode or decode flag that sets skipSingleConstructor to True

Encode or decode flag that sets skipSingleConstructor to False

Typeclass for you to implement your own options. Here's how FieldsToSnakeCase uses it:

     instance ReflectSettingsOptions FieldsToSnakeCase where
         reflectS Proxy s@RonSettings {fieldModifier} = s
             { fieldModifier = toSnake . fieldModifier }

Be careful when composing functions to apply them after the already present, to preserve the left-to-right semantics of adding the options

Typeclass for you to implement your own symmetric options. Here's how ImplicitSome uses it

     instance ReflectFlagOptions ImplicitSome where
         reflectF Proxy flags = flags { implicitSome = True }