Serialize a value to a lazy bytestring. For settings you can use haskellStyle or rustStyle or compactStyle

Serialize a value into a file. For settings you can use haskellStyle or rustStyle or compactStyle

Parse a ByteString to your type. The error is produced by attoparsec and is not very useful.

Parse a lazy ByteString to your type. The error is produced by attoparsec and is not very useful.

Parse file content to your type. Throws ParseError or DecodeError on errors.

Style similar to what is produced in haskell with stylish-haskell or hindent.

• Uses indent size of 4
• Unpacks top level values

Style similar to what is produced by rustfmt, or by ron-rs itself

All whitespace is disabled. Does not unpack toplevel for compatability, so you can set that if you want an even compacter style that can't be read by ron-rs

A class of values that can be encoded to RON format.

There are several ways to define an instance:

1. By producing a Value by hand
2. By using toRonGeneric
3. By DerivingVia extension and using RonWith

When using the second option, the encoding parameters are specified with RonSettings. With the third option, the same parameters are specified by a list of settings found in Deriving.

The default implementation uses generic encoding with laxRonSettings. You can use other settings like this:

     instance ToRon MyType where
         toRon = toRonGeneric strictRonSettings
             { encodeFlags = RonFlags
                 { implicitSome = True
                 , skipSingleConstructor = True
                 }
             }

Or like this:

     deriving via (RonWith '[UseStrict, EncodeWith SkipSingleConstructor, EncodeWith ImplicitSome])
         instance ToRon MyType

A class of values that can be restored from RON format

There are several ways to define an instance:

1. By deconstructing a Value by hand and producing a value of your type
2. By using fromRonGeneric
3. By DerivingVia extension and using RonWith

The default implementation uses generic decoding with laxRonSettings. You can use other settings like this:

     instance FromRon MyType where
         fromRon = fromRonGeneric strictRonSettings
             { decodeFlags = RonFlags
                 { implicitSome = True
                 , skipSingleConstructor = True
                 }
             }

Or like this:

     deriving via (RonWith '[UseStrict, DecodeWith SkipSingleConstructor, DecodeWith ImplicitSome])
         instance FromRon MyType

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