tomland 1.2.1.0 → 1.3.0.0

raw patch · 107 files changed

+7672/−4063 lines, 107 filesdep +hspecdep +hspec-goldendep +hspec-hedgehogdep −tastydep −tasty-hedgehogdep −tasty-hspecdep ~basedep ~bytestringdep ~timenew-uploaderPVP ok

version bump matches the API change (PVP)

Dependencies added: hspec, hspec-golden, hspec-hedgehog, validation-selective

Dependencies removed: tasty, tasty-hedgehog, tasty-hspec, tasty-silver

Dependency ranges changed: base, bytestring, time

API changes (from Hackage documentation)

Files

• CHANGELOG.md +100/−0
• README.lhs +104/−52
• README.md +104/−52
• examples/Main.hs +93/−9
• src/Toml.hs +39/−15
• src/Toml/Bi.hs +0/−27
• src/Toml/Bi/Code.hs +0/−144
• src/Toml/Bi/Combinators.hs +0/−515
• src/Toml/Bi/Map.hs +0/−577
• src/Toml/Bi/Monad.hs +0/−298
• src/Toml/Codec.hs +122/−0
• src/Toml/Codec/BiMap.hs +237/−0
• src/Toml/Codec/BiMap/Conversion.hs +619/−0
• src/Toml/Codec/Code.hs +122/−0
• src/Toml/Codec/Combinator.hs +152/−0
• src/Toml/Codec/Combinator/Common.hs +77/−0
• src/Toml/Codec/Combinator/Custom.hs +237/−0
• src/Toml/Codec/Combinator/List.hs +222/−0
• src/Toml/Codec/Combinator/Map.hs +399/−0
• src/Toml/Codec/Combinator/Monoid.hs +114/−0
• src/Toml/Codec/Combinator/Primitive.hs +205/−0
• src/Toml/Codec/Combinator/Set.hs +224/−0
• src/Toml/Codec/Combinator/Table.hs +92/−0
• src/Toml/Codec/Combinator/Time.hs +71/−0
• src/Toml/Codec/Combinator/Tuple.hs +100/−0
• src/Toml/Codec/Di.hs +210/−0
• src/Toml/Codec/Error.hs +85/−0
• src/Toml/Codec/Generic.hs +776/−0
• src/Toml/Codec/Types.hs +220/−0
• src/Toml/Edsl.hs +0/−86
• src/Toml/Generic.hs +0/−419
• src/Toml/Parser.hs +31/−14
• src/Toml/Parser/Core.hs +1/−1
• src/Toml/Parser/Item.hs +20/−17
• src/Toml/Parser/Key.hs +2/−3
• src/Toml/Parser/String.hs +1/−2
• src/Toml/Parser/Validate.hs +6/−5
• src/Toml/Parser/Value.hs +1/−2
• src/Toml/PrefixTree.hs +0/−231
• src/Toml/Printer.hs +0/−208
• src/Toml/Type.hs +60/−6
• src/Toml/Type/AnyValue.hs +7/−2
• src/Toml/Type/Edsl.hs +107/−0
• src/Toml/Type/Key.hs +138/−0
• src/Toml/Type/PrefixTree.hs +167/−0
• src/Toml/Type/Printer.hs +229/−0
• src/Toml/Type/TOML.hs +8/−4
• src/Toml/Type/UValue.hs +13/−4
• src/Toml/Type/Value.hs +33/−8
• test/Spec.hs +20/−1
• test/Test/Toml/BiCode/Property.hs +0/−206
• test/Test/Toml/BiMap/Property.hs +0/−67
• test/Test/Toml/Codec.hs +22/−0
• test/Test/Toml/Codec/BiMap.hs +67/−0
• test/Test/Toml/Codec/BiMap/Conversion.hs +71/−0
• test/Test/Toml/Codec/Code.hs +110/−0
• test/Test/Toml/Codec/Combinator.hs +28/−0
• test/Test/Toml/Codec/Combinator/Common.hs +61/−0
• test/Test/Toml/Codec/Combinator/Custom.hs +27/−0
• test/Test/Toml/Codec/Combinator/List.hs +28/−0
• test/Test/Toml/Codec/Combinator/Map.hs +23/−0
• test/Test/Toml/Codec/Combinator/Monoid.hs +24/−0
• test/Test/Toml/Codec/Combinator/Primitive.hs +30/−0
• test/Test/Toml/Codec/Combinator/Set.hs +30/−0
• test/Test/Toml/Codec/Combinator/Table.hs +16/−0
• test/Test/Toml/Codec/Combinator/Time.hs +18/−0
• test/Test/Toml/Codec/Combinator/Tuple.hs +24/−0
• test/Test/Toml/Codec/Di.hs +57/−0
• test/Test/Toml/Codec/Generic.hs +33/−0
• test/Test/Toml/Codec/SmallType.hs +58/−0
• test/Test/Toml/Gen.hs +122/−90
• test/Test/Toml/Parser.hs +34/−0
• test/Test/Toml/Parser/Array.hs +74/−0
• test/Test/Toml/Parser/Bool.hs +22/−0
• test/Test/Toml/Parser/Common.hs +135/−0
• test/Test/Toml/Parser/Date.hs +63/−0
• test/Test/Toml/Parser/Double.hs +45/−0
• test/Test/Toml/Parser/Examples.hs +25/−0
• test/Test/Toml/Parser/Integer.hs +83/−0
• test/Test/Toml/Parser/Key.hs +48/−0
• test/Test/Toml/Parser/Property.hs +21/−0
• test/Test/Toml/Parser/Text.hs +96/−0
• test/Test/Toml/Parser/Toml.hs +163/−0
• test/Test/Toml/Parser/Validate.hs +79/−0
• test/Test/Toml/Parsing/Examples.hs +0/−21
• test/Test/Toml/Parsing/Property.hs +0/−13
• test/Test/Toml/Parsing/Unit.hs +0/−23
• test/Test/Toml/Parsing/Unit/Array.hs +0/−45
• test/Test/Toml/Parsing/Unit/Bool.hs +0/−21
• test/Test/Toml/Parsing/Unit/Common.hs +0/−140
• test/Test/Toml/Parsing/Unit/Date.hs +0/−61
• test/Test/Toml/Parsing/Unit/Double.hs +0/−45
• test/Test/Toml/Parsing/Unit/Integer.hs +0/−82
• test/Test/Toml/Parsing/Unit/Key.hs +0/−35
• test/Test/Toml/Parsing/Unit/Text.hs +0/−95
• test/Test/Toml/Parsing/Unit/Toml.hs +0/−162
• test/Test/Toml/PrefixTree/Property.hs +0/−73
• test/Test/Toml/PrefixTree/Unit.hs +0/−43
• test/Test/Toml/Printer/Golden.hs +0/−64
• test/Test/Toml/Property.hs +30/−14
• test/Test/Toml/TOML/Property.hs +0/−15
• test/Test/Toml/Type.hs +18/−0
• test/Test/Toml/Type/Key.hs +47/−0
• test/Test/Toml/Type/PrefixTree.hs +95/−0
• test/Test/Toml/Type/Printer.hs +68/−0
• test/Test/Toml/Type/TOML.hs +18/−0
• tomland.cabal +91/−46

@@ -3,6 +3,106 @@ tomland uses [PVP Versioning][1]. The changelog is available [on GitHub][2]. +## 1.3.0.0 — May 19, 2020++* [#253](https://github.com/kowainik/tomland/issues/253):+  Support GHC-8.10.1. Move to GHC-8.8.3 from 8.8.1.+* Drop support of GHC-8.2.2.+* [#271](https://github.com/kowainik/tomland/issues/271):+  Use `Validation` from `validation-selective` in `TomlEnv`.+  This allows to accumulate and display all errors that occurs during the+  decoding phase.+  All  previous decode functions return list of all `TomlDecodeError`s.++  __Note:__ Due to the specific of `Validation` data type, there is no `Monad`+  instanse of `Codec` anymore. However, this doesn't limit any previously+  released features.+* Add `decodeValidation`, `decodeFileValidation` functions to return+  `Validation` instead of `Either`.+* [#263](https://github.com/kowainik/tomland/issues/263):+  Simplify `Codec` abstraction. Instead of having `Codec r w c a`+  now it is `Codec TomlEnv TomlState c a`.++  Remove `BiCodec` as it is simple `TomlCodec` with this change.+* [#256](https://github.com/kowainik/tomland/issues/256),+  [#278](https://github.com/kowainik/tomland/issues/278):+  Rename modules to simplify module structure.++  __Migration guide:__ If you use `Toml` module (as advised by the library) then+  no changes required in your code.+   If you import some particular modules from `tomland` here is the renaming+   scheme you can use to apply to your imports:++   | __Old__ | __New__ |+   |-----|-----|+   | `Toml.Bi` | `Toml.Codec` |+   | `Toml.Bi.Combinators` | `Toml.Codec.Combinator` |+   | `Toml.Bi.Monad` | `Toml.Codec.Types` |+   | `Toml.Bi.Code` | `Toml.Codec.Code` or `Toml.Codec.Types` or `Toml.Codec.Error` |+   | `Toml.Bi.Map` | `Toml.Codec.BiMap` or `Toml.Codec.BiMap.Conversion` |+   | `Toml.Generic` | `Toml.Codec.Generic` |+   | `Toml.Edsl` | `Toml.Type.Edsl` |+   | `Toml.Printer` | `Toml.Type.Printer` |+   | `Toml.PrefixTree` | `Toml.Type.PrefixTree` or `Toml.Type.Key` |+++* [#283](https://github.com/kowainik/tomland/issues/283):+  Documentation improvements:+    - Add Codec Tables to each kind of codecs with examples+    - Add high-level description to each reexported module+    - Add @since annotations+    - Improve README+    - Add more examples into functions+* [#237](https://github.com/kowainik/tomland/issues/237):+  Add `BiMap` `_Validate` and codecs `validate` and `validateIf` for custom+  validation.+* [#289](https://github.com/kowainik/tomland/issues/289):+  Add `_Coerce` `TomlBiMap`.+* [#270](https://github.com/kowainik/tomland/issues/270):+  Add `pair` and `triple` codecs for tuples.+* [#261](https://github.com/kowainik/tomland/issues/261):+  Implement `tableMap` codec to use TOML keys as `Map` keys.+* [#243](https://github.com/kowainik/tomland/issues/243):+  Implement `hashMap`, `tableHashMap`, `intMap`, `tableIntMap` codec+  combinators.+* Add `intSet` codec.+* Add `_KeyInt` `BiMap`for key-as-int approach.+* [#242](https://github.com/kowainik/tomland/issues/242):+  Add `HasCodec` instances for `Map`, `HashMap` and `IntMap` for+  `Generic` deriving.+* [#272](https://github.com/kowainik/tomland/issues/272):+  Add `TomlTable` newtype to be used in generic `DerivingVia`.+* [#251](https://github.com/kowainik/tomland/issues/251):+  Implement `ByteStringAsText`, `ByteStringAsBytes`, `LByteStringAsText`,+  `LByteStringAsBytes` newtypes. Add corresponding `HasCodec` instances for+  these data types.+* [#311](https://github.com/kowainik/tomland/issues/311):+  Reimplement custom `TomlState` instead of using `MaybeT` and `State`.+* Rename `ParseException` to `TomlParseError`.+* Rename `DecodeException` to `TomlDecodeError`.+* Add `TableArrayNotFound` constructor to `TomlDecodeError`.+* Remove `TrivialError` and `TypeMismatch` constructors of the `TomlDecodeError`+  type.+* [#313](https://github.com/kowainik/tomland/issues/313):+  Store `Key` in the `BiMapError` constructor of `TomlDecodeError`.+* Add `decodeFileEither` and `encodeToFile` functions.+* Fix `sum` and `product` behaviour on missing fields. Now it returns the+  wrapper of `mempty` instead of failure.+* [#302](https://github.com/kowainik/tomland/issues/302):+  `nonEmpty` codec throws `TableArrayNotFound` instead of `TableNotFound`.+* [#318](https://github.com/kowainik/tomland/issues/318):+  Export a function for parsing TOML keys `parseKey`.+* [#310](https://github.com/kowainik/tomland/issues/310):+  Add tests on all kinds of `TomlDecodeError` with `decode` function.+* [#218](https://github.com/kowainik/tomland/issues/218):+  Add tests for TOML validation.+* [#252](https://github.com/kowainik/tomland/issues/252):+  Move to `hspec-*` family of libraries from `tasty-*`.+* [#297](https://github.com/kowainik/tomland/issues/297):+  Tests parallelism and speed-up.+* [#246](https://github.com/kowainik/tomland/issues/246):+  Bump up `megaparsec` version to `8.0.0`.+ ## 1.2.1.0 — Nov 6, 2019  * [#203](https://github.com/kowainik/tomland/issues/203):

@@ -1,8 +1,8 @@ # tomland  ![palm](https://user-images.githubusercontent.com/4276606/51088259-7a777000-176e-11e9-9d76-6be4023c0ac3.png)+ [![GitHub CI](https://github.com/kowainik/tomland/workflows/CI/badge.svg)](https://github.com/kowainik/tomland/actions)-[![Travis CI](https://img.shields.io/travis/kowainik/tomland.svg?logo=travis)](https://travis-ci.org/kowainik/tomland) [![AppVeyor CI](https://ci.appveyor.com/api/projects/status/github/kowainik/tomland?branch=master&svg=true)](https://ci.appveyor.com/project/kowainik/tomland) [![Hackage](https://img.shields.io/hackage/v/tomland.svg?logo=haskell)](https://hackage.haskell.org/package/tomland) [![Stackage LTS](http://stackage.org/package/tomland/badge/lts)](http://stackage.org/lts/package/tomland)@@ -12,19 +12,28 @@ > “A library is like an island in the middle of a vast sea of ignorance, > particularly if the library is very tall and the surrounding area has been > flooded.”->+ > ― Lemony Snicket, Horseradish -Bidirectional TOML serialization. The following blog post has more details about-library design:+`tomland` is a Haskell library for _Bidirectional TOML+Serialization_. It provides the composable interface for implementing+[TOML](https://github.com/toml-lang/toml) codecs. If you want to use+TOML as a configuration for your tool or application, you can use+`tomland` to easily convert in both ways between textual TOML+representation and Haskell types. -* [`tomland`: Bidirectional TOML serialization](https://kowainik.github.io/posts/2019-01-14-tomland)+✍️ `tomland` supports [TOML spec version 0.5.0](https://github.com/toml-lang/toml/wiki#v050-compliant). +The following blog post has more details about the library design and+internal implementation details:++* [`tomland`: Bidirectional TOML Serialization](https://kowainik.github.io/posts/2019-01-14-tomland)+ This README contains a basic usage example of the `tomland` library. All code below can be compiled and run with the following command:  ```-cabal new-run readme+cabal run readme ```  ## Preamble: imports and language extensions@@ -39,15 +48,15 @@ {-# LANGUAGE OverloadedStrings #-}  import Control.Applicative ((<|>))-import Control.Category ((>>>)) import Data.Text (Text)-import Toml (TomlBiMap, TomlCodec, (.=))+import Data.Time (Day)+import Toml (TomlCodec, (.=))  import qualified Data.Text.IO as TIO import qualified Toml ``` -`tomland` is mostly designed for qualified imports and intended to be imported+`tomland` is designed for qualified imports and intended to be imported as follows:  ```haskell ignore@@ -57,10 +66,40 @@  ## Data type: parsing and printing -We're going to parse TOML configuration from [`examples/readme.toml`](examples/readme.toml) file.+We're going to parse TOML configuration from+[`examples/readme.toml`](examples/readme.toml) file. The configuration+contains the following description of our data: -This static configuration is captured by the following Haskell data type:+```toml+server.port        = 8080+server.codes       = [ 5, 10, 42 ]+server.description = """+This is production server.+Don't touch it!+""" +[mail]+    host = "smtp.gmail.com"+    send-if-inactive = false++[[user]]+   guestId = 42++[[user]]+   guestId = 114++[[user]]+    login = "Foo Bar"+    createdAt = 2020-05-19+```++The above static configuration describes `Settings` for some+server. It has several top-level fields, a table with the name `mail`+and an array of tables with the name `user` that stores list of+different types of users.++We can model such TOML using the following Haskell data types:+ ```haskell data Settings = Settings     { settingsPort        :: !Port@@ -76,25 +115,29 @@     }  data User-    = Admin  !Integer  -- id of admin-    | Client !Text     -- name of the client-    deriving stock (Show)+    = Guest !Integer  -- id of guest+    | Registered !RegisteredUser  -- login and createdAt of registered user +data RegisteredUser = RegisteredUser+    { registeredUserLogin     :: !Text+    , registeredUserCreatedAt :: !Day+    }+ newtype Port = Port Int newtype Host = Host Text ``` -Using `tomland` library, you can write bidirectional converters for these types-using the following guidelines and helper functions:+Using the `tomland` library, you can write bidirectional converters for these types+with the following guidelines and helper functions: -1. If your fields are some simple basic types like `Int` or `Text` you can just+1. If your fields are some simple primitive types like `Int` or `Text` you can just    use standard codecs like `Toml.int` and `Toml.text`. 2. If you want to parse `newtype`s, use `Toml.diwrap` to wrap parsers for    underlying `newtype` representation.-3. For parsing nested data types, use `Toml.table`. But this requires to specify-   this data type as TOML table in `.toml` file.+3. For parsing nested data types, use `Toml.table`. But it requires to specify+   this data type as TOML table in the `.toml` file. 4. If you have lists of custom data types, use `Toml.list`. Such lists are-   represented as array of tables in TOML. If you have lists of primitive types+   represented as _array of tables_ in TOML. If you have lists of the primitive types    like `Int`, `Bool`, `Double`, `Text` or time types, that you can use    `Toml.arrayOf` and parse arrays of values. 5. If you have sets of custom data types, use `Toml.set` or `Toml.HashSet`. Such@@ -121,41 +164,49 @@     <$> Toml.diwrap (Toml.text "host") .= mailHost     <*> Toml.bool "send-if-inactive"   .= mailSendIfInactive -_Admin :: TomlBiMap User Integer-_Admin = Toml.prism Admin $ \case-    Admin i -> Right i-    other   -> Toml.wrongConstructor "Admin" other+matchGuest :: User -> Maybe Integer+matchGuest = \case+   Guest i -> Just i+   _ -> Nothing -_Client :: TomlBiMap User Text-_Client = Toml.prism Client $ \case-    Client n -> Right n-    other    -> Toml.wrongConstructor "Client" other+matchRegistered :: User -> Maybe RegisteredUser+matchRegistered = \case+   Registered u -> Just u+   _ -> Nothing  userCodec :: TomlCodec User userCodec =-        Toml.match (_Admin >>> Toml._Integer) "id"-    <|> Toml.match (_Client >>> Toml._Text) "name"+        Toml.dimatch matchGuest      Guest      (Toml.integer "guestId")+    <|> Toml.dimatch matchRegistered Registered registeredUserCodec++registeredUserCodec :: TomlCodec RegisteredUser+registeredUserCodec = RegisteredUser+    <$> Toml.text "login"     .= registeredUserLogin+    <*> Toml.day  "createdAt" .= registeredUserCreatedAt ``` -And now we're ready to parse our TOML and print the result back to see whether+And now we are ready to parse our TOML and print the result back to see whether everything is okay.  ```haskell main :: IO () main = do-    tomlExample <- TIO.readFile "examples/readme.toml"-    let res = Toml.decode settingsCodec tomlExample-    case res of-        Left err -> print err+    tomlRes <- Toml.decodeFileEither settingsCodec "examples/readme.toml"+    case tomlRes of+        Left errs      -> TIO.putStrLn $ Toml.prettyTomlDecodeErrors errs         Right settings -> TIO.putStrLn $ Toml.encode settingsCodec settings ```  ## Benchmarks and comparison with other libraries -`tomland` is [compared](https://github.com/kowainik/toml-benchmarks) with other libraries. Since it uses 2-step approach with-converting text to intermediate AST and only then decoding Haskell type from-this AST, benchmarks are also implemented in a way to reflect this difference.+You can find benchmarks of the `tomland` library in the following repository: +* [kowainik/toml-benchmarks](https://github.com/kowainik/toml-benchmarks)++Since `tomland` uses 2-step approach with converting text to+intermediate AST and only then decoding Haskell type from this AST,+benchmarks are also implemented in a way to reflect this difference.+ | Library            | parse :: Text -> AST | transform :: AST -> Haskell | |--------------------|----------------------|-----------------------------| | `tomland`          | `305.5 μs`           | `1.280 μs`                  |@@ -163,21 +214,22 @@ | `htoml-megaparsec` | `295.0 μs`           | `33.62 μs`                  | | `toml-parser`      | `164.6 μs`           | `1.101 μs`                  | -You may see that `tomland` is not the fastest one (though still very fast). But-performance hasn’t been optimized so far and:+In addition to the above numbers, `tomland` has several features that+make it unique: -1. `toml-parser` doesn’t support the array of tables and because of that it’s-   hardly possible to specify the list of custom data types in TOML with this-   library.-2. `tomland` supports latest TOML spec while `htoml` and `htoml-megaparsec`-   don’t have support for all types, values and formats.-3. `tomland` is the only library that has pretty-printing.-4. `toml-parser` doesn’t have ways to convert TOML AST to custom Haskell types-   and `htoml*` libraries use typeclasses-based approach via `aeson` library.-5. `tomland` is bidirectional :slightly_smiling_face:+1. `tomland` is the only Haskell library that has pretty-printing.+2. `tomland` is compatible with the latest TOML spec while other libraries are not.+3. `tomland` is bidirectional, which means that your encoding and+   decoding are consistent with each other by construction.+4. `tomland` provides abilities for `Generic` and `DerivingVia`+   deriving out-of-the-box.+5. Despite being the fastest, `toml-parser` doesn’t support the array+   of tables and because of that it’s hardly possible to specify the list+   of custom data types in TOML with this library. In addition,+   `toml-parser` doesn’t have ways to convert TOML AST to custom+   Haskell types and `htoml*` libraries use typeclasses-based approach+   via `aeson` library.  ## Acknowledgement -Icons made by [Freepik](http://www.freepik.com) from-[www.flaticon.com](https://www.flaticon.com/) is licensed by-[CC 3.0 BY](http://creativecommons.org/licenses/by/3.0/).+Icons made by [Freepik](http://www.freepik.com) from [www.flaticon.com](https://www.flaticon.com/) is licensed by [CC 3.0 BY](http://creativecommons.org/licenses/by/3.0/).

@@ -1,8 +1,8 @@ # tomland  ![palm](https://user-images.githubusercontent.com/4276606/51088259-7a777000-176e-11e9-9d76-6be4023c0ac3.png)+ [![GitHub CI](https://github.com/kowainik/tomland/workflows/CI/badge.svg)](https://github.com/kowainik/tomland/actions)-[![Travis CI](https://img.shields.io/travis/kowainik/tomland.svg?logo=travis)](https://travis-ci.org/kowainik/tomland) [![AppVeyor CI](https://ci.appveyor.com/api/projects/status/github/kowainik/tomland?branch=master&svg=true)](https://ci.appveyor.com/project/kowainik/tomland) [![Hackage](https://img.shields.io/hackage/v/tomland.svg?logo=haskell)](https://hackage.haskell.org/package/tomland) [![Stackage LTS](http://stackage.org/package/tomland/badge/lts)](http://stackage.org/lts/package/tomland)@@ -12,19 +12,28 @@ > “A library is like an island in the middle of a vast sea of ignorance, > particularly if the library is very tall and the surrounding area has been > flooded.”->+ > ― Lemony Snicket, Horseradish -Bidirectional TOML serialization. The following blog post has more details about-library design:+`tomland` is a Haskell library for _Bidirectional TOML+Serialization_. It provides the composable interface for implementing+[TOML](https://github.com/toml-lang/toml) codecs. If you want to use+TOML as a configuration for your tool or application, you can use+`tomland` to easily convert in both ways between textual TOML+representation and Haskell types. -* [`tomland`: Bidirectional TOML serialization](https://kowainik.github.io/posts/2019-01-14-tomland)+✍️ `tomland` supports [TOML spec version 0.5.0](https://github.com/toml-lang/toml/wiki#v050-compliant). +The following blog post has more details about the library design and+internal implementation details:++* [`tomland`: Bidirectional TOML Serialization](https://kowainik.github.io/posts/2019-01-14-tomland)+ This README contains a basic usage example of the `tomland` library. All code below can be compiled and run with the following command:  ```-cabal new-run readme+cabal run readme ```  ## Preamble: imports and language extensions@@ -39,15 +48,15 @@ {-# LANGUAGE OverloadedStrings #-}  import Control.Applicative ((<|>))-import Control.Category ((>>>)) import Data.Text (Text)-import Toml (TomlBiMap, TomlCodec, (.=))+import Data.Time (Day)+import Toml (TomlCodec, (.=))  import qualified Data.Text.IO as TIO import qualified Toml ``` -`tomland` is mostly designed for qualified imports and intended to be imported+`tomland` is designed for qualified imports and intended to be imported as follows:  ```haskell ignore@@ -57,10 +66,40 @@  ## Data type: parsing and printing -We're going to parse TOML configuration from [`examples/readme.toml`](examples/readme.toml) file.+We're going to parse TOML configuration from+[`examples/readme.toml`](examples/readme.toml) file. The configuration+contains the following description of our data: -This static configuration is captured by the following Haskell data type:+```toml+server.port        = 8080+server.codes       = [ 5, 10, 42 ]+server.description = """+This is production server.+Don't touch it!+""" +[mail]+    host = "smtp.gmail.com"+    send-if-inactive = false++[[user]]+   guestId = 42++[[user]]+   guestId = 114++[[user]]+    login = "Foo Bar"+    createdAt = 2020-05-19+```++The above static configuration describes `Settings` for some+server. It has several top-level fields, a table with the name `mail`+and an array of tables with the name `user` that stores list of+different types of users.++We can model such TOML using the following Haskell data types:+ ```haskell data Settings = Settings     { settingsPort        :: !Port@@ -76,25 +115,29 @@     }  data User-    = Admin  !Integer  -- id of admin-    | Client !Text     -- name of the client-    deriving stock (Show)+    = Guest !Integer  -- id of guest+    | Registered !RegisteredUser  -- login and createdAt of registered user +data RegisteredUser = RegisteredUser+    { registeredUserLogin     :: !Text+    , registeredUserCreatedAt :: !Day+    }+ newtype Port = Port Int newtype Host = Host Text ``` -Using `tomland` library, you can write bidirectional converters for these types-using the following guidelines and helper functions:+Using the `tomland` library, you can write bidirectional converters for these types+with the following guidelines and helper functions: -1. If your fields are some simple basic types like `Int` or `Text` you can just+1. If your fields are some simple primitive types like `Int` or `Text` you can just    use standard codecs like `Toml.int` and `Toml.text`. 2. If you want to parse `newtype`s, use `Toml.diwrap` to wrap parsers for    underlying `newtype` representation.-3. For parsing nested data types, use `Toml.table`. But this requires to specify-   this data type as TOML table in `.toml` file.+3. For parsing nested data types, use `Toml.table`. But it requires to specify+   this data type as TOML table in the `.toml` file. 4. If you have lists of custom data types, use `Toml.list`. Such lists are-   represented as array of tables in TOML. If you have lists of primitive types+   represented as _array of tables_ in TOML. If you have lists of the primitive types    like `Int`, `Bool`, `Double`, `Text` or time types, that you can use    `Toml.arrayOf` and parse arrays of values. 5. If you have sets of custom data types, use `Toml.set` or `Toml.HashSet`. Such@@ -121,41 +164,49 @@     <$> Toml.diwrap (Toml.text "host") .= mailHost     <*> Toml.bool "send-if-inactive"   .= mailSendIfInactive -_Admin :: TomlBiMap User Integer-_Admin = Toml.prism Admin $ \case-    Admin i -> Right i-    other   -> Toml.wrongConstructor "Admin" other+matchGuest :: User -> Maybe Integer+matchGuest = \case+   Guest i -> Just i+   _ -> Nothing -_Client :: TomlBiMap User Text-_Client = Toml.prism Client $ \case-    Client n -> Right n-    other    -> Toml.wrongConstructor "Client" other+matchRegistered :: User -> Maybe RegisteredUser+matchRegistered = \case+   Registered u -> Just u+   _ -> Nothing  userCodec :: TomlCodec User userCodec =-        Toml.match (_Admin >>> Toml._Integer) "id"-    <|> Toml.match (_Client >>> Toml._Text) "name"+        Toml.dimatch matchGuest      Guest      (Toml.integer "guestId")+    <|> Toml.dimatch matchRegistered Registered registeredUserCodec++registeredUserCodec :: TomlCodec RegisteredUser+registeredUserCodec = RegisteredUser+    <$> Toml.text "login"     .= registeredUserLogin+    <*> Toml.day  "createdAt" .= registeredUserCreatedAt ``` -And now we're ready to parse our TOML and print the result back to see whether+And now we are ready to parse our TOML and print the result back to see whether everything is okay.  ```haskell main :: IO () main = do-    tomlExample <- TIO.readFile "examples/readme.toml"-    let res = Toml.decode settingsCodec tomlExample-    case res of-        Left err -> print err+    tomlRes <- Toml.decodeFileEither settingsCodec "examples/readme.toml"+    case tomlRes of+        Left errs      -> TIO.putStrLn $ Toml.prettyTomlDecodeErrors errs         Right settings -> TIO.putStrLn $ Toml.encode settingsCodec settings ```  ## Benchmarks and comparison with other libraries -`tomland` is [compared](https://github.com/kowainik/toml-benchmarks) with other libraries. Since it uses 2-step approach with-converting text to intermediate AST and only then decoding Haskell type from-this AST, benchmarks are also implemented in a way to reflect this difference.+You can find benchmarks of the `tomland` library in the following repository: +* [kowainik/toml-benchmarks](https://github.com/kowainik/toml-benchmarks)++Since `tomland` uses 2-step approach with converting text to+intermediate AST and only then decoding Haskell type from this AST,+benchmarks are also implemented in a way to reflect this difference.+ | Library            | parse :: Text -> AST | transform :: AST -> Haskell | |--------------------|----------------------|-----------------------------| | `tomland`          | `305.5 μs`           | `1.280 μs`                  |@@ -163,21 +214,22 @@ | `htoml-megaparsec` | `295.0 μs`           | `33.62 μs`                  | | `toml-parser`      | `164.6 μs`           | `1.101 μs`                  | -You may see that `tomland` is not the fastest one (though still very fast). But-performance hasn’t been optimized so far and:+In addition to the above numbers, `tomland` has several features that+make it unique: -1. `toml-parser` doesn’t support the array of tables and because of that it’s-   hardly possible to specify the list of custom data types in TOML with this-   library.-2. `tomland` supports latest TOML spec while `htoml` and `htoml-megaparsec`-   don’t have support for all types, values and formats.-3. `tomland` is the only library that has pretty-printing.-4. `toml-parser` doesn’t have ways to convert TOML AST to custom Haskell types-   and `htoml*` libraries use typeclasses-based approach via `aeson` library.-5. `tomland` is bidirectional :slightly_smiling_face:+1. `tomland` is the only Haskell library that has pretty-printing.+2. `tomland` is compatible with the latest TOML spec while other libraries are not.+3. `tomland` is bidirectional, which means that your encoding and+   decoding are consistent with each other by construction.+4. `tomland` provides abilities for `Generic` and `DerivingVia`+   deriving out-of-the-box.+5. Despite being the fastest, `toml-parser` doesn’t support the array+   of tables and because of that it’s hardly possible to specify the list+   of custom data types in TOML with this library. In addition,+   `toml-parser` doesn’t have ways to convert TOML AST to custom+   Haskell types and `htoml*` libraries use typeclasses-based approach+   via `aeson` library.  ## Acknowledgement -Icons made by [Freepik](http://www.freepik.com) from-[www.flaticon.com](https://www.flaticon.com/) is licensed by-[CC 3.0 BY](http://creativecommons.org/licenses/by/3.0/).+Icons made by [Freepik](http://www.freepik.com) from [www.flaticon.com](https://www.flaticon.com/) is licensed by [CC 3.0 BY](http://creativecommons.org/licenses/by/3.0/).

@@ -1,25 +1,34 @@ {-# OPTIONS -Wno-unused-top-binds #-}+ {-# LANGUAGE DeriveAnyClass #-}+{-# LANGUAGE DerivingVia    #-}  module Main (main) where  import Control.Applicative ((<|>)) import Control.Arrow ((>>>))+import Data.ByteString (ByteString) import Data.Hashable (Hashable) import Data.HashSet (HashSet)+import Data.IntSet (IntSet)+import Data.List.NonEmpty (NonEmpty) import Data.Map.Strict (Map) import Data.Set (Set) import Data.Text (Text) import Data.Time (fromGregorian) import GHC.Generics (Generic) -import Toml (ParseException (..), TomlCodec, pretty, (.=), (<!>))-import Toml.Edsl (mkToml, table, (=:))+import Toml (TomlCodec, TomlParseError (..), pretty, (.=), (<!>))+import Toml.Codec.Generic (ByteStringAsBytes (..), HasCodec (..), TomlTable (..),+                           stripTypeNameCodec) import Toml.Type (TOML (..), Value (..))+import Toml.Type.Edsl (mkToml, table, (=:))  import qualified Data.Text.IO as TIO+ import qualified Toml + newtype TestInside = TestInside { unInside :: Text }  insideCodec :: TomlCodec TestInside@@ -44,7 +53,7 @@     = Light     | Dark     | HighContrast-    deriving stock (Show, Enum, Bounded)+    deriving stock (Show, Read, Enum, Bounded)  data UserStatus     = Registered Text Text@@ -59,33 +68,71 @@ matchAnonymous _                    = Nothing  userPassCodec :: TomlCodec (Text, Text)-userPassCodec = (,)-    <$> Toml.text "username" .= fst-    <*> Toml.text "password" .= snd+userPassCodec = Toml.pair+    (Toml.text "username")+    (Toml.text "password")  userStatusCodec :: TomlCodec UserStatus userStatusCodec =     Toml.dimatch matchRegistered (uncurry Registered) (Toml.table userPassCodec "testStatus")     <|> Toml.dimatch matchAnonymous Anonymous (Toml.text "testStatus") +data Colour+   = Hex Text+   | RGB Rgb++matchHex :: Colour -> Maybe Text+matchHex = \case+    Hex t -> Just t+    _ -> Nothing++matchRgb :: Colour -> Maybe Rgb+matchRgb = \case+    RGB rgb -> Just rgb+    _ -> Nothing++colourCodec :: Toml.Key -> TomlCodec Colour+colourCodec key =+        Toml.dimatch matchHex Hex (Toml.text key)+    <|> Toml.dimatch matchRgb RGB (Toml.table rgbCodec key)++data Rgb = Rgb+    { rgbRed   :: Int+    , rgbGreen :: Int+    , rgbBlue  :: Int+    }++rgbCodec :: TomlCodec Rgb+rgbCodec = Rgb+    <$> Toml.int "red"   .= rgbRed+    <*> Toml.int "green" .= rgbGreen+    <*> Toml.int "blue"  .= rgbBlue+ data Test = Test     { testB      :: !Bool     , testI      :: !Int     , testF      :: !Double     , testS      :: !Text     , testA      :: ![Text]+    , testNE     :: !(NonEmpty Text)+    , testNET    :: !(NonEmpty Int)     , testM      :: !(Maybe Bool)     , testX      :: !TestInside     , testY      :: !(Maybe TestInside)+    , testEven   :: !Int     , testN      :: !N     , testC      :: !ColorScheme+    , testPair   :: !(Int, Text)+    , testTriple :: !(Int, Text, Bool)     , testE1     :: !(Either Integer String)     , testE2     :: !(Either String Double)     , testStatus :: !UserStatus     , users      :: ![User]     , susers     :: !(Set User)     , husers     :: !(HashSet User)+    , intset     :: !IntSet     , payloads   :: !(Map Text Int)+    , colours    :: !(Map Text Colour)     }  @@ -96,19 +143,32 @@     <*> Toml.double "testF" .= testF     <*> Toml.text "testS" .= testS     <*> Toml.arrayOf Toml._Text "testA" .= testA+    <*> Toml.arrayNonEmptyOf Toml._Text "testNE" .= testNE+    <*> Toml.nonEmpty (Toml.int "a") "testNET" .= testNET     <*> Toml.dioptional (Toml.bool "testM") .= testM     <*> Toml.table insideCodec "testX" .= testX-    <*> Toml.dioptional ((Toml.table insideCodec) "testY") .= testY+    <*> Toml.dioptional (Toml.table insideCodec "testY") .= testY+    <*> Toml.validateIf even Toml._Int "testEven" .= testEven     <*> Toml.diwrap (Toml.text "testN") .= testN     <*> Toml.enumBounded "testC" .= testC+    <*> Toml.table pairC "testPair" .= testPair+    <*> Toml.table tripleC "testTriple" .= testTriple     <*> eitherT1 .= testE1     <*> eitherT2 .= testE2     <*> userStatusCodec .= testStatus     <*> Toml.list userCodec "user" .= users     <*> Toml.set userCodec "suser" .= susers     <*> Toml.hashSet userCodec "huser" .= husers+    <*> Toml.arrayIntSet "intset" .= intset     <*> Toml.map (Toml.text "name") (Toml.int "payload") "payloads" .= payloads+    <*> Toml.tableMap Toml._KeyText colourCodec "colours" .= colours   where+    pairC :: TomlCodec (Int, Text)+    pairC = Toml.pair (Toml.int "pNum") (Toml.text "pName")++    tripleC :: TomlCodec (Int, Text, Bool)+    tripleC = Toml.triple (Toml.int "tNum") (Toml.text "tName") (Toml.bool "isFav")+     -- different keys for sum type     eitherT1 :: TomlCodec (Either Integer String)     eitherT1 = Toml.match (Toml._Left >>> Toml._Integer)  "either.Left"@@ -122,6 +182,24 @@              <!> Toml.match (Toml._Right >>> Toml._Double)                ) "either" +data GenericPerson = GenericPerson+    { genericPersonName    :: !Text+    , genericPersonAddress :: !Address+    } deriving stock (Generic)++data Address = Address+    { addressStreet :: !Text+    , addressHouse  :: !Int+    } deriving stock (Generic)+      deriving HasCodec via (TomlTable Address)++testGeneric :: TomlCodec GenericPerson+testGeneric = stripTypeNameCodec++newtype MyByteString = MyByteString+    { unMyByteString :: ByteString+    } deriving HasCodec via ByteStringAsBytes+ main :: IO () main = do     TIO.putStrLn "=== Printing manually specified TOML ==="@@ -130,14 +208,20 @@     TIO.putStrLn "=== Trying to print invalid TOML ==="     content <- TIO.readFile "examples/invalid.toml"     TIO.putStrLn $ case Toml.parse content of-        Left (ParseException e) -> e+        Left (TomlParseError e) -> e         Right toml              -> pretty toml      TIO.putStrLn "=== Testing bidirectional conversion ==="     biFile <- TIO.readFile "examples/biTest.toml"     TIO.putStrLn $ case Toml.decode testT biFile of-        Left msg   -> Toml.prettyException msg+        Left msgs  -> Toml.prettyTomlDecodeErrors msgs         Right test -> Toml.encode testT test++    TIO.putStrLn "=== Testing Deriving Via ==="+    genericFile <- TIO.readFile "examples/generic.toml"+    TIO.putStrLn $ case Toml.decode testGeneric genericFile of+        Left msg   -> Toml.prettyTomlDecodeErrors msg+        Right test -> Toml.encode testGeneric test  myToml :: TOML myToml = mkToml $ do

@@ -1,17 +1,18 @@ {- |-Copyright: (c) 2018-2019 Kowainik+Copyright: (c) 2018-2020 Kowainik SPDX-License-Identifier: MPL-2.0 Maintainer: Kowainik <xrom.xkov@gmail.com> -This module reexports all functionality of @tomland@ package. It's+This module reexports all functionality of the @tomland@ package. It's recommended to import this module qualified, like this:  @-__import__ Toml (TomlCodec, (.=))-__import__ __qualified__ Toml+__import__ "Toml" ('TomlCodec', '(.=)')+__import__ __qualified__ "Toml" @ -Simple @'TomlCodec'@ could be written in the following way:+Simple @'TomlCodec'@ for a Haskell value, that can be decoded from+TOML or encoded as TOML, could be written in the following way:  @ __data__ User = User@@ -25,28 +26,51 @@     \<*\> Toml.'int'  "age"  '.=' userAge @ +A value of such type will look in TOML like this:++@+name = "Alice"+age  = 27+@+ For more detailed examples see README.md in the repository:  * [tomland/README.md](https://github.com/kowainik/tomland#tomland)  For the details of the library implementation see blog post: - * [tomland: Bidirectional TOML serialization](https://kowainik.github.io/posts/2019-01-14-tomland) -}  module Toml-    ( module Toml.Bi-    , module Toml.Generic-    , module Toml.Parser-    , module Toml.PrefixTree-    , module Toml.Printer+    ( -- $codec+      module Toml.Codec+      -- $type     , module Toml.Type+      -- $parser+    , module Toml.Parser     ) where -import Toml.Bi-import Toml.Generic+import Toml.Codec import Toml.Parser-import Toml.PrefixTree-import Toml.Printer import Toml.Type++{- $codec+Main types and functions to implement TOML codecs. This module+provides high-level API of @tomland@ library.+-}++{- $type+Low-level implementation details of types that power @tomland@. The+"Toml.Type" module contains types to represent TOML AST and basic+functions to work with it. This module also contains pretty-printing+API for 'TOML' AST and eDSL for type-safe definition of the TOML+values.+-}++{- $parser+Parser for types, defined in "Toml.Type". This modules contains+low-level functions to parse 'TOML' from text. If you want to convert+between Haskell types and TOML representation, use functions from+"Toml.Codec".+-}

@@ -1,27 +0,0 @@-{- |-Copyright: (c) 2018-2019 Kowainik-SPDX-License-Identifier: MPL-2.0-Maintainer: Kowainik <xrom.xkov@gmail.com>--Reexports functions under @Toml.Bi.*@.--* __"Toml.Bi.Map"__: contains implementation of tagged bidirectional-  isomorphisms.-* __"Toml.Bi.Monad"__: core abstraction for bidirectional conversion based on-  profunctor monads.-* __"Toml.Bi.Combinators"__: TOML specific combinators based on 'Codec' type-  from "Toml.Bi.Monad".-* __"Toml.Bi.Code"__: conversion functions like 'decode' and 'encode'.--}--module Toml.Bi-       ( module Toml.Bi.Code-       , module Toml.Bi.Combinators-       , module Toml.Bi.Map-       , module Toml.Bi.Monad-       ) where--import Toml.Bi.Code-import Toml.Bi.Combinators-import Toml.Bi.Map-import Toml.Bi.Monad

@@ -1,144 +0,0 @@-{-# LANGUAGE DeriveAnyClass #-}--{- |-Copyright: (c) 2018-2019 Kowainik-SPDX-License-Identifier: MPL-2.0-Maintainer: Kowainik <xrom.xkov@gmail.com>--Coding functions like 'decode' and 'encode'. Also contains specialization of 'Codec' for TOML.--}--module Toml.Bi.Code-       ( -- * Types-         TomlCodec-       , Env-       , St--         -- * Exceptions-       , DecodeException (..)-       , LoadTomlException (..)-       , prettyException--         -- * Encode/Decode-       , decode-       , decodeFile-       , runTomlCodec-       , encode-       , execTomlCodec-       ) where--import Control.DeepSeq (NFData)-import Control.Exception (Exception, throwIO)-import Control.Monad.Except (ExceptT, runExceptT)-import Control.Monad.IO.Class (MonadIO (..))-import Control.Monad.Reader (Reader, runReader)-import Control.Monad.State (State, execState)-import Control.Monad.Trans.Maybe (MaybeT (..))-import Data.Bifunctor (first)-import Data.Foldable (toList)-import Data.Semigroup (Semigroup (..))-import Data.Text (Text)-import GHC.Generics (Generic)--import Toml.Bi.Map (TomlBiMapError, prettyBiMapError)-import Toml.Bi.Monad (BiCodec, Codec (..))-import Toml.Parser (ParseException (..), parse)-import Toml.PrefixTree (Key (..), unPiece)-import Toml.Printer (pretty)-import Toml.Type (TOML (..), TValue, showType)--import qualified Data.Text as Text-import qualified Data.Text.IO as TIO----- | Type of exception for converting from TOML to user custom data type.-data DecodeException-    = TrivialError-    | BiMapError !TomlBiMapError-    | KeyNotFound !Key  -- ^ No such key-    | TableNotFound !Key  -- ^ No such table-    | TypeMismatch !Key !Text !TValue  -- ^ Expected type vs actual type-    | ParseError !ParseException  -- ^ Exception during parsing-    deriving stock (Eq, Generic)-    deriving anyclass (NFData)--instance Show DecodeException where-    show = Text.unpack . prettyException--instance Semigroup DecodeException where-    TrivialError <> e = e-    e <> _ = e--instance Monoid DecodeException where-    mempty = TrivialError-    mappend = (<>)---- | Converts 'DecodeException' into pretty human-readable text.-prettyException :: DecodeException -> Text-prettyException de = "tomland decode error:  " <> case de of-    TrivialError -> "'empty' parser from 'Alternative' is used"-    BiMapError biError -> prettyBiMapError biError-    KeyNotFound name -> "Key " <> joinKey name <> " is not found"-    TableNotFound name -> "Table [" <> joinKey name <> "] is not found"-    TypeMismatch name expected actual -> "Type for key " <> joinKey name <> " doesn't match."-        <> "\n  Expected: " <> expected-        <> "\n  Actual:   " <> Text.pack (showType actual)-    ParseError (ParseException msg) -> "Parse error during conversion from TOML to custom user type: \n  " <> msg-  where-    joinKey :: Key -> Text-    joinKey = Text.intercalate "." . map unPiece . toList . unKey---- | Immutable environment for TOML conversion.--- This is @r@ type variable in 'Codec' data type.-type Env = ExceptT DecodeException (Reader TOML)--{- | Mutable context for TOML conversion.-This is @w@ type variable in 'Codec' data type.--@-MaybeT (State TOML) a-    = State TOML (Maybe a)-    = TOML -> (Maybe a, TOML)-@--}-type St = MaybeT (State TOML)--{- | Specialied 'BiCodec' type alias for bidirectional TOML serialization. Keeps-'TOML' object as both environment and state.--}-type TomlCodec a = BiCodec Env St a---- | Convert textual representation of toml into user data type.-decode :: TomlCodec a -> Text -> Either DecodeException a-decode codec text = do-    toml <- first ParseError (parse text)-    runTomlCodec codec toml---- | Convert toml into user data type.-runTomlCodec :: TomlCodec a -> TOML -> Either DecodeException a-runTomlCodec codec = runReader (runExceptT $ codecRead codec)---- | Convert object to textual representation.-encode :: TomlCodec a -> a -> Text-encode codec obj = pretty $ execTomlCodec codec obj---- | Runs 'codecWrite' of 'TomlCodec' and returns intermediate TOML AST.-execTomlCodec :: TomlCodec a -> a -> TOML-execTomlCodec codec obj = execState (runMaybeT $ codecWrite codec obj) mempty---- | File loading error data type.-data LoadTomlException = LoadTomlException !FilePath !Text--instance Show LoadTomlException where-    show (LoadTomlException filePath msg) = "Couldnt parse file " ++ filePath ++ ": " ++ show msg--instance Exception LoadTomlException---- | Decode a value from a file. In case of parse errors, throws 'LoadTomlException'.-decodeFile :: (MonadIO m) => TomlCodec a -> FilePath -> m a-decodeFile codec filePath = liftIO $-    (decode codec <$> TIO.readFile filePath) >>= errorWhenLeft-  where-    errorWhenLeft :: Either DecodeException a -> IO a-    errorWhenLeft (Left e)   = throwIO $ LoadTomlException filePath $ prettyException e-    errorWhenLeft (Right pc) = pure pc

@@ -1,515 +0,0 @@-{-# LANGUAGE AllowAmbiguousTypes #-}-{-# LANGUAGE FlexibleContexts    #-}-{-# LANGUAGE GADTs               #-}--{- |-Copyright: (c) 2018-2019 Kowainik-SPDX-License-Identifier: MPL-2.0-Maintainer: Kowainik <xrom.xkov@gmail.com>--Contains TOML-specific combinators for converting between TOML and user data types.--}--module Toml.Bi.Combinators-       ( -- * Basic codecs for primitive values-         -- ** Boolean-         bool-         -- ** Integral numbers-       , integer-       , natural-       , int-       , word-       , word8-         -- ** Floating point numbers-       , double-       , float-         -- ** Text types-       , text-       , lazyText-       , byteString-       , lazyByteString-       , byteStringArray-       , lazyByteStringArray-       , string-         -- ** Time types-       , zonedTime-       , localTime-       , day-       , timeOfDay--         -- * Codecs for containers of primitives-       , arrayOf-       , arraySetOf-       , arrayIntSet-       , arrayHashSetOf-       , arrayNonEmptyOf--         -- * Codecs for 'Monoid's-         -- ** Bool wrappers-       , all-       , any-         -- ** 'Num' wrappers-       , sum-       , product-         -- ** 'Maybe' wrappers-       , first-       , last--         -- * Additional codecs for custom types-       , textBy-       , read-       , enumBounded--         -- * Combinators for tables-       , table-       , nonEmpty-       , list-       , set-       , hashSet--         -- * Combinators for Maps-       , map--         -- * General construction of codecs-       , match-       ) where--import Prelude hiding (all, any, last, map, product, read, sum)--import Control.Monad (forM)-import Control.Monad.Except (catchError, throwError)-import Control.Monad.Reader (asks, local)-import Control.Monad.State (execState, gets, modify)-import Control.Monad.Trans.Maybe (MaybeT (..), runMaybeT)-import Data.ByteString (ByteString)-import Data.Hashable (Hashable)-import Data.HashSet (HashSet)-import Data.IntSet (IntSet)-import Data.List.NonEmpty (NonEmpty (..), toList)-import Data.Map.Strict (Map)-import Data.Maybe (fromMaybe)-import Data.Monoid (All (..), Any (..), First (..), Last (..), Product (..), Sum (..))-import Data.Semigroup ((<>))-import Data.Set (Set)-import Data.Text (Text)-import Data.Time (Day, LocalTime, TimeOfDay, ZonedTime)-import Data.Word (Word8)-import Numeric.Natural (Natural)--import Toml.Bi.Code (DecodeException (..), Env, St, TomlCodec, execTomlCodec)-import Toml.Bi.Map (BiMap (..), TomlBiMap, _Array, _Bool, _ByteString, _ByteStringArray, _Day,-                    _Double, _EnumBounded, _Float, _HashSet, _Int, _IntSet, _Integer, _LByteString,-                    _LByteStringArray, _LText, _LocalTime, _Natural, _NonEmpty, _Read, _Set,-                    _String, _Text, _TextBy, _TimeOfDay, _Word, _Word8, _ZonedTime)-import Toml.Bi.Monad (Codec (..), dimap, dioptional)-import Toml.PrefixTree (Key)-import Toml.Type (AnyValue (..), TOML (..), insertKeyAnyVal, insertTable, insertTableArrays)--import qualified Data.ByteString.Lazy as BL-import qualified Data.HashMap.Strict as HashMap-import qualified Data.HashSet as HS-import qualified Data.List.NonEmpty as NE-import qualified Data.Map.Strict as Map-import qualified Data.Set as S-import qualified Data.Text.Lazy as L-import qualified Toml.PrefixTree as Prefix---{- | General function to create bidirectional converters for key-value pairs. In-order to use this function you need to create 'TomlBiMap' for your type and-'AnyValue':--@-_MyType :: 'TomlBiMap' MyType 'AnyValue'-@--And then you can create codec for your type using 'match' function:--@-myType :: 'Key' -> 'TomlCodec' MyType-myType = 'match' _MyType-@--}-match :: forall a . TomlBiMap a AnyValue -> Key -> TomlCodec a-match BiMap{..} key = Codec input output-  where-    input :: Env a-    input = do-        mVal <- asks $ HashMap.lookup key . tomlPairs-        case mVal of-            Nothing -> throwError $ KeyNotFound key-            Just anyVal -> case backward anyVal of-                Right v  -> pure v-                Left err -> throwError $ BiMapError err--    output :: a -> St a-    output a = do-        anyVal <- MaybeT $ pure $ either (const Nothing) Just $ forward a-        a <$ modify (insertKeyAnyVal key anyVal)---- | Codec for boolean values.-bool :: Key -> TomlCodec Bool-bool = match _Bool-{-# INLINE bool #-}---- | Codec for integer values.-integer :: Key -> TomlCodec Integer-integer = match _Integer-{-# INLINE integer #-}---- | Codec for integer values.-int :: Key -> TomlCodec Int-int = match _Int-{-# INLINE int #-}---- | Codec for natural values.-natural :: Key -> TomlCodec Natural-natural = match _Natural-{-# INLINE natural #-}---- | Codec for word values.-word :: Key -> TomlCodec Word-word = match _Word-{-# INLINE word #-}--{- | Codec for word8 values.--@since 1.2.0.0--}-word8 :: Key -> TomlCodec Word8-word8 = match _Word8-{-# INLINE word8 #-}---- | Codec for floating point values with double precision.-double :: Key -> TomlCodec Double-double = match _Double-{-# INLINE double #-}---- | Codec for floating point values.-float :: Key -> TomlCodec Float-float = match _Float-{-# INLINE float #-}---- | Codec for text values.-text :: Key -> TomlCodec Text-text = match _Text-{-# INLINE text #-}---- | Codec for lazy text values.-lazyText :: Key -> TomlCodec L.Text-lazyText = match _LText-{-# INLINE lazyText #-}---- | Codec for text values with custom error messages for parsing.-textBy :: (a -> Text) -> (Text -> Either Text a) -> Key -> TomlCodec a-textBy to from = match (_TextBy to from)-{-# INLINE textBy #-}---- | Codec for string values.-string :: Key -> TomlCodec String-string = match _String-{-# INLINE string #-}---- | Codec for values with a 'Read' and 'Show' instance.-read :: (Show a, Read a) => Key -> TomlCodec a-read = match _Read-{-# INLINE read #-}--{- | Codec for general nullary sum data types with a 'Bounded', 'Enum', and-'Show' instance. This codec provides much better error messages than 'read' for-nullary sum types.--@since 1.1.1.0--}-enumBounded :: (Bounded a, Enum a, Show a) => Key -> TomlCodec a-enumBounded = match _EnumBounded-{-# INLINE enumBounded #-}---- | Codec for text values as 'ByteString'.-byteString :: Key -> TomlCodec ByteString-byteString = match _ByteString-{-# INLINE byteString #-}---- | Codec for text values as 'BL.ByteString'.-lazyByteString :: Key -> TomlCodec BL.ByteString-lazyByteString = match _LByteString-{-# INLINE lazyByteString #-}--{- | Codec for positive integer array values as 'ByteString'.--@since 1.2.0.0--}-byteStringArray :: Key -> TomlCodec ByteString-byteStringArray = match _ByteStringArray-{-# INLINE byteStringArray #-}--{- | Codec for positive integer array values as lazy 'ByteString'.--@since 1.2.0.0--}-lazyByteStringArray :: Key -> TomlCodec BL.ByteString-lazyByteStringArray = match _LByteStringArray-{-# INLINE lazyByteStringArray #-}---- | Codec for zoned time values.-zonedTime :: Key -> TomlCodec ZonedTime-zonedTime = match _ZonedTime-{-# INLINE zonedTime #-}---- | Codec for local time values.-localTime :: Key -> TomlCodec LocalTime-localTime = match _LocalTime-{-# INLINE localTime #-}---- | Codec for day values.-day :: Key -> TomlCodec Day-day = match _Day-{-# INLINE day #-}---- | Codec for time of day values.-timeOfDay :: Key -> TomlCodec TimeOfDay-timeOfDay = match _TimeOfDay-{-# INLINE timeOfDay #-}---- | Codec for list of values. Takes converter for single value and--- returns a list of values.-arrayOf :: TomlBiMap a AnyValue -> Key -> TomlCodec [a]-arrayOf = match . _Array-{-# INLINE arrayOf #-}---- | Codec for sets. Takes converter for single value and--- returns a set of values.-arraySetOf :: Ord a => TomlBiMap a AnyValue -> Key -> TomlCodec (Set a)-arraySetOf = match . _Set-{-# INLINE arraySetOf #-}---- | Codec for sets of ints. Takes converter for single value and--- returns a set of ints.-arrayIntSet :: Key -> TomlCodec IntSet-arrayIntSet = match _IntSet-{-# INLINE arrayIntSet #-}---- | Codec for hash sets. Takes converter for single hashable value and--- returns a set of hashable values.-arrayHashSetOf-    :: (Hashable a, Eq a)-    => TomlBiMap a AnyValue-    -> Key-    -> TomlCodec (HashSet a)-arrayHashSetOf = match . _HashSet-{-# INLINE arrayHashSetOf #-}---- | Codec for non- empty lists of values. Takes converter for single value and--- returns a non-empty list of values.-arrayNonEmptyOf :: TomlBiMap a AnyValue -> Key -> TomlCodec (NonEmpty a)-arrayNonEmptyOf = match . _NonEmpty-{-# INLINE arrayNonEmptyOf #-}--------------------------------------------------------------------------------- Monoid codecs-------------------------------------------------------------------------------{- | Codec for 'All' wrapper for boolean values.-Returns @'All' 'True'@ on missing fields.--@since 1.2.1.0--}-all :: Key -> TomlCodec All-all = dimap (Just . getAll) (All . fromMaybe True) . dioptional . bool-{-# INLINE all #-}--{- | Codec for 'Any' wrapper for boolean values.-Returns @'Any' 'False'@ on missing fields.--@since 1.2.1.0--}-any :: Key -> TomlCodec Any-any = dimap (Just . getAny) (Any . fromMaybe False) . dioptional . bool-{-# INLINE any #-}--{- | Codec for 'Sum' wrapper for given converter's values.--@since 1.2.1.0--}-sum :: (Key -> TomlCodec a) -> Key -> TomlCodec (Sum a)-sum codec = dimap getSum Sum . codec-{-# INLINE sum #-}--{- | Codec for 'Product' wrapper for given converter's values.--@since 1.2.1.0--}-product :: (Key -> TomlCodec a) -> Key -> TomlCodec (Product a)-product codec = dimap getProduct Product . codec-{-# INLINE product #-}--{- | Codec for 'First' wrapper for given converter's values.--@since 1.2.1.0--}-first :: (Key -> TomlCodec a) -> Key -> TomlCodec (First a)-first codec = dimap getFirst First . dioptional . codec-{-# INLINE first #-}--{- | Codec for 'Last' wrapper for given converter's values.--@since 1.2.1.0--}-last :: (Key -> TomlCodec a) -> Key -> TomlCodec (Last a)-last codec = dimap getLast Last . dioptional . codec-{-# INLINE last #-}--------------------------------------------------------------------------------- Tables and arrays of tables-------------------------------------------------------------------------------{- | Prepends given key to all errors that contain key. This function is used to-give better error messages. So when error happens we know all pieces of table-key, not only the last one.--}-handleErrorInTable :: Key -> DecodeException -> Env a-handleErrorInTable key = \case-    KeyNotFound name        -> throwError $ KeyNotFound (key <> name)-    TableNotFound name      -> throwError $ TableNotFound (key <> name)-    TypeMismatch name t1 t2 -> throwError $ TypeMismatch (key <> name) t1 t2-    e                       -> throwError e---- | Run 'codecRead' function with given 'TOML' inside 'Control.Monad.Reader.ReaderT' context.-codecReadTOML :: TOML -> TomlCodec a -> Env a-codecReadTOML toml codec = local (const toml) (codecRead codec)---- | Codec for tables. Use it when when you have nested objects.-table :: forall a . TomlCodec a -> Key -> TomlCodec a-table codec key = Codec input output-  where-    input :: Env a-    input = do-        mTable <- asks $ Prefix.lookup key . tomlTables-        case mTable of-            Nothing   -> throwError $ TableNotFound key-            Just toml -> codecReadTOML toml codec `catchError` handleErrorInTable key--    output :: a -> St a-    output a = do-        mTable <- gets $ Prefix.lookup key . tomlTables-        let toml = fromMaybe mempty mTable-        let newToml = execState (runMaybeT $ codecWrite codec a) toml-        a <$ modify (insertTable key newToml)--{- | 'Codec' for 'NonEmpty' list of values. Represented in TOML as array of-tables.--}-nonEmpty :: forall a . TomlCodec a -> Key -> TomlCodec (NonEmpty a)-nonEmpty codec key = Codec input output-  where-    input :: Env (NonEmpty a)-    input = do-        mTables <- asks $ HashMap.lookup key . tomlTableArrays-        case mTables of-            Nothing    -> throwError $ TableNotFound key-            Just tomls -> forM tomls $ \toml ->-                codecReadTOML toml codec `catchError` handleErrorInTable key--    -- adds all TOML objects to the existing list if there are some-    output :: NonEmpty a -> St (NonEmpty a)-    output as = do-        let tomls = fmap (execTomlCodec codec) as-        mTables <- gets $ HashMap.lookup key . tomlTableArrays--        let newTomls = case mTables of-                Nothing       -> tomls-                Just oldTomls -> oldTomls <> tomls--        as <$ modify (insertTableArrays key newTomls)---- | 'Codec' for list of values. Represented in TOML as array of tables.-list :: forall a . TomlCodec a -> Key -> TomlCodec [a]-list codec key = Codec-    { codecRead = (toList <$> codecRead nonEmptyCodec) `catchError` \case-        TableNotFound errKey | errKey == key -> pure []-        err -> throwError err-    , codecWrite = \case-        [] -> pure []-        l@(x:xs) -> l <$ codecWrite nonEmptyCodec (x :| xs)-    }-  where-    nonEmptyCodec :: TomlCodec (NonEmpty a)-    nonEmptyCodec = nonEmpty codec key--{- | 'Codec' for set of values. Represented in TOML as array of tables.--@since 1.2.0.0--}-set :: forall a . Ord a => TomlCodec a -> Key -> TomlCodec (Set a)-set codec key = dimap S.toList S.fromList (list codec key)-{-# INLINE set #-}--{- | 'Codec' for HashSet of values. Represented in TOML as array of tables.--@since 1.2.0.0--}--hashSet :: forall a . (Hashable a, Eq a) => TomlCodec a -> Key -> TomlCodec (HashSet a)-hashSet codec key = dimap HS.toList HS.fromList (list codec key)-{-# INLINE hashSet #-}--------------------------------------------------------------------------------- Map-like combinators-------------------------------------------------------------------------------{- | Bidirectional codec for 'Map'. It takes birectional converter for keys and-values and produces bidirectional codec for 'Map'. Currently it works only with array-of tables, so you need to specify 'Map's in TOML files like this:--@-myMap =-    [ { name = "foo", payload = 42 }-    , { name = "bar", payload = 69 }-    ]-@--'TomlCodec' for such TOML field can look like this:--@-Toml.'map' (Toml.'text' "name") (Toml.'int' "payload") "myMap"-@--If there's no key with the name @"myMap"@ then empty 'Map' is returned.--@since 1.2.1.0--}-map :: forall k v .-       Ord k-    => TomlCodec k  -- ^ Codec for 'Map' keys-    -> TomlCodec v  -- ^ Codec for 'Map' values-    -> Key          -- ^ TOML key where 'Map' is stored-    -> TomlCodec (Map k v)  -- ^ Codec for the 'Map'-map keyCodec valCodec key = Codec input output-  where-    input :: Env (Map k v)-    input = do-        mTables <- asks $ HashMap.lookup key . tomlTableArrays-        case mTables of-            Nothing -> pure Map.empty-            Just tomls -> fmap Map.fromList $ forM (NE.toList tomls) $ \toml -> do-                k <- codecReadTOML toml keyCodec-                v <- codecReadTOML toml valCodec-                pure (k, v)--    output :: Map k v -> St (Map k v)-    output dict = do-        let tomls = fmap-                (\(k, v) -> execTomlCodec keyCodec k <> execTomlCodec valCodec v)-                (Map.toList dict)--        mTables <- gets $ HashMap.lookup key . tomlTableArrays--        let updateAction :: TOML -> TOML-            updateAction = case mTables of-                Nothing -> case tomls of-                    []   -> id-                    t:ts -> insertTableArrays key (t :| ts)-                Just (t :| ts) ->-                    insertTableArrays key $ t :| (ts ++ tomls)--        dict <$ modify updateAction

@@ -1,577 +0,0 @@-{-# LANGUAGE AllowAmbiguousTypes #-}-{-# LANGUAGE DataKinds           #-}-{-# LANGUAGE DeriveAnyClass      #-}-{-# LANGUAGE KindSignatures      #-}-{-# LANGUAGE Rank2Types          #-}-{-# LANGUAGE TypeFamilies        #-}--{- |-Copyright: (c) 2018-2019 Kowainik-SPDX-License-Identifier: MPL-2.0-Maintainer: Kowainik <xrom.xkov@gmail.com>--Implementation of tagged partial bidirectional isomorphism.--}--module Toml.Bi.Map-       ( -- * BiMap idea-         BiMap (..)-       , TomlBiMap-       , invert-       , iso-       , prism--         -- * 'BiMap' errors for TOML-       , TomlBiMapError (..)-       , wrongConstructor-       , prettyBiMapError--         -- * Some predefined bi mappings-       , _Array-       , _Bool-       , _Double-       , _Integer-       , _Text-       , _LText-       , _ZonedTime-       , _LocalTime-       , _Day-       , _TimeOfDay-       , _String-       , _Read-       , _Natural-       , _Word-       , _Word8-       , _Int-       , _Float-       , _ByteString-       , _LByteString-       , _ByteStringArray-       , _LByteStringArray-       , _NonEmpty-       , _Set-       , _IntSet-       , _HashSet--         -- * Helpers for BiMap and AnyValue-       , mkAnyValueBiMap-       , _TextBy-       , _LTextText-       , _NaturalInteger-       , _StringText-       , _ReadString-       , _BoundedInteger-       , _EnumBoundedText-       , _ByteStringText-       , _LByteStringText-       , _Left-       , _Right-       , _EnumBounded-       , _Just--         -- * Useful utility functions-       , toMArray-       ) where--import Control.Arrow ((>>>))-import Control.DeepSeq (NFData)-import Control.Monad ((>=>))-import Data.Bifunctor (bimap, first)-import Data.ByteString (ByteString)-import Data.Hashable (Hashable)-import Data.Map (Map)-import Data.Semigroup (Semigroup (..))-import Data.Text (Text)-import Data.Time (Day, LocalTime, TimeOfDay, ZonedTime)-import Data.Word (Word8)-import GHC.Generics (Generic)-import Numeric.Natural (Natural)-import Text.Read (readEither)--import Toml.Type (AnyValue (..), MatchError (..), TValue (..), Value (..), applyAsToAny, matchBool,-                  matchDay, matchDouble, matchHours, matchInteger, matchLocal, matchText,-                  matchZoned, mkMatchError, toMArray)--import qualified Control.Category as Cat-import qualified Data.ByteString as BS-import qualified Data.ByteString.Lazy as BL-import qualified Data.HashSet as HS-import qualified Data.IntSet as IS-import qualified Data.List.NonEmpty as NE-import qualified Data.Map as M-import qualified Data.Set as S-import qualified Data.Text as T-import qualified Data.Text.Encoding as T-import qualified Data.Text.Lazy as TL-import qualified Data.Text.Lazy.Encoding as TL---------------------------------------------------------------------------------- BiMap concepts and ideas-------------------------------------------------------------------------------{- | Partial bidirectional isomorphism. @BiMap a b@ contains two function:--1. @a -> Either e b@-2. @b -> Either e a@--If you think of types as sets then this data type can be illustrated by the-following picture:--![bimap-type](https://user-images.githubusercontent.com/4276606/50770531-b6a36000-1298-11e9-9528-caae87951d2a.png)--'BiMap' also implements 'Cat.Category' typeclass. And this instance can be described-clearly by this illustration:--![bimap-cat](https://user-images.githubusercontent.com/4276606/50771234-13a01580-129b-11e9-93da-6c5dd0f7f160.png)--}-data BiMap e a b = BiMap-    { forward  :: a -> Either e b-    , backward :: b -> Either e a-    }--instance Cat.Category (BiMap e) where-    id :: BiMap e a a-    id = BiMap Right Right-    {-# INLINE id #-}--    (.) :: BiMap e b c -> BiMap e a b -> BiMap e a c-    bc . ab = BiMap-        { forward  =  forward ab >=>  forward bc-        , backward = backward bc >=> backward ab-        }-    {-# INLINE (.) #-}---- | Inverts bidirectional mapping.-invert :: BiMap e a b -> BiMap e b a-invert (BiMap f g) = BiMap g f-{-# INLINE invert #-}--{- | Creates 'BiMap' from isomorphism. Can be used in the following way:--@-__newtype__ Even = Even Integer-__newtype__ Odd  = Odd  Integer--succEven :: Even -> Odd-succEven (Even n) = Odd (n + 1)--predOdd :: Odd -> Even-predOdd (Odd n) = Even (n - 1)--_EvenOdd :: 'BiMap' e Even Odd-_EvenOdd = 'iso' succEven predOdd-@--}-iso :: (a -> b) -> (b -> a) -> BiMap e a b-iso f g = BiMap (Right . f) (Right . g)-{-# INLINE iso #-}--{- | Creates 'BiMap' from prism-like pair of functions. This combinator can be-used to create 'BiMap' for custom data types like this:--@-__data__ User-    = Admin  Integer  -- id of admin-    | Client Text     -- name of the client-    __deriving__ (Show)--_Admin :: 'TomlBiMap' User Integer-_Admin = Toml.'prism' Admin $ \\__case__-    Admin i -> Right i-    other   -> Toml.'wrongConstructor' \"Admin\" other--_Client :: 'TomlBiMap' User Text-_Client = Toml.'prism' Client $ \\__case__-    Client n -> Right n-    other    -> Toml.'wrongConstructor' \"Client\" other-@--}-prism-    :: (field -> object)-    -> (object -> Either error field)-    -> BiMap error object field-prism review preview = BiMap preview (Right . review)-{-# INLINE prism #-}--------------------------------------------------------------------------------- BiMap error types--------------------------------------------------------------------------------- | 'BiMap' specialized to TOML error.-type TomlBiMap = BiMap TomlBiMapError---- | Type of errors for TOML 'BiMap'.-data TomlBiMapError-    = WrongConstructor -- ^ Error for cases with wrong constructors. For-                       -- example, you're trying to convert 'Left' but-                       -- bidirectional converter expects 'Right'.-        !Text          -- ^ Expected constructor name-        !Text          -- ^ Actual value-    | WrongValue       -- ^ Error for cases with wrong values-        !MatchError    -- ^ Information about failed matching-    | ArbitraryError   -- ^ Arbitrary textual error-        !Text          -- ^ Error message-    deriving stock (Eq, Show, Generic)-    deriving anyclass (NFData)---- | Converts 'TomlBiMapError' into pretty human-readable text.-prettyBiMapError :: TomlBiMapError -> Text-prettyBiMapError = \case-    WrongConstructor expected actual -> T.unlines-        [ "Invalid constructor"-        , "  * Expected: " <> expected-        , "  * Actual:   " <> actual-        ]-    WrongValue (MatchError expected actual) -> T.unlines-        [ "Invalid constructor"-        , "  * Expected: " <> tShow expected-        , "  * Actual:   " <> tShow actual-        ]-    ArbitraryError text  -> text---- | Helper to construct WrongConstuctor error.-wrongConstructor-    :: Show a-    => Text  -- ^ Name of the expected constructor-    -> a     -- ^ Actual value-    -> Either TomlBiMapError b-wrongConstructor constructor x = Left $ WrongConstructor constructor (tShow x)--------------------------------------------------------------------------------- General purpose bimaps--------------------------------------------------------------------------------- | Bimap for 'Either' and its left type-_Left :: (Show l, Show r) => TomlBiMap (Either l r) l-_Left = prism Left $ \case-    Left l -> Right l-    x -> wrongConstructor "Left" x---- | Bimap for 'Either' and its right type-_Right :: (Show l, Show r) => TomlBiMap (Either l r) r-_Right = prism Right $ \case-    Right r -> Right r-    x -> wrongConstructor "Right" x---- | Bimap for 'Maybe'-_Just :: Show r => TomlBiMap (Maybe r) r-_Just = prism Just $ \case-    Just r -> Right r-    x -> wrongConstructor "Just" x---------------------------------------------------------------------------------  BiMaps for value--------------------------------------------------------------------------------- | Creates prism for 'AnyValue'.-mkAnyValueBiMap-    :: forall a (tag :: TValue) . (forall (t :: TValue) . Value t -> Either MatchError a)-    -> (a -> Value tag)-    -> TomlBiMap a AnyValue-mkAnyValueBiMap matchValue toValue = BiMap-    { forward = Right . toAnyValue-    , backward = fromAnyValue-    }-  where-    toAnyValue :: a -> AnyValue-    toAnyValue = AnyValue . toValue--    fromAnyValue :: AnyValue -> Either TomlBiMapError a-    fromAnyValue (AnyValue value) = first WrongValue $ matchValue value---- | Creates bimap for 'Data.Text.Text' to 'AnyValue' with custom functions-_TextBy-    :: forall a .-       (a -> Text)              -- ^ @show@ function for @a@-    -> (Text -> Either Text a)  -- ^ Parser of @a@ from 'Data.Text.Text'-    -> TomlBiMap a AnyValue-_TextBy toText parseText = BiMap toAnyValue fromAnyValue-  where-    toAnyValue :: a -> Either TomlBiMapError AnyValue-    toAnyValue = Right . AnyValue . Text . toText--    fromAnyValue :: AnyValue -> Either TomlBiMapError a-    fromAnyValue (AnyValue v) =-        first WrongValue (matchText v) >>= first ArbitraryError . parseText--{- | 'Prelude.Bool' bimap for 'AnyValue'. Usually used as-'Toml.Bi.Combinators.bool' combinator.--}-_Bool :: TomlBiMap Bool AnyValue-_Bool = mkAnyValueBiMap matchBool Bool-{-# INLINE _Bool #-}--{- | 'Prelude.Integer' bimap for 'AnyValue'. Usually used as-'Toml.Bi.Combinators.integer' combinator.--}-_Integer :: TomlBiMap Integer AnyValue-_Integer = mkAnyValueBiMap matchInteger Integer-{-# INLINE _Integer #-}--{- | 'Prelude.Double' bimap for 'AnyValue'. Usually used as-'Toml.Bi.Combinators.double' combinator.--}-_Double :: TomlBiMap Double AnyValue-_Double = mkAnyValueBiMap matchDouble Double-{-# INLINE _Double #-}--{- | 'Data.Text.Text' bimap for 'AnyValue'. Usually used as-'Toml.Bi.Combinators.text' combinator.--}-_Text :: TomlBiMap Text AnyValue-_Text = mkAnyValueBiMap matchText Text-{-# INLINE _Text #-}---- | Helper bimap for 'Data.Text.Lazy.Text' and 'Data.Text.Text'.-_LTextText :: BiMap e TL.Text Text-_LTextText = iso TL.toStrict TL.fromStrict-{-# INLINE _LTextText #-}--{- | 'Data.Text.Lazy.Text' bimap for 'AnyValue'. Usually used as-'Toml.Bi.Combinators.lazyText' combinator.--}-_LText :: TomlBiMap TL.Text AnyValue-_LText = _LTextText >>> _Text-{-# INLINE _LText #-}--{- | 'Data.Time.ZonedTime' bimap for 'AnyValue'. Usually used as-'Toml.Bi.Combinators.zonedTime' combinator.--}-_ZonedTime :: TomlBiMap ZonedTime AnyValue-_ZonedTime = mkAnyValueBiMap matchZoned Zoned-{-# INLINE _ZonedTime #-}--{- | 'Data.Time.LocalTime' bimap for 'AnyValue'. Usually used as-'Toml.Bi.Combinators.localTime' combinator.--}-_LocalTime :: TomlBiMap LocalTime AnyValue-_LocalTime = mkAnyValueBiMap matchLocal Local-{-# INLINE _LocalTime #-}--{- | 'Data.Time.Day' bimap for 'AnyValue'. Usually used as-'Toml.Bi.Combinators.day' combinator.--}-_Day :: TomlBiMap Day AnyValue-_Day = mkAnyValueBiMap matchDay Day-{-# INLINE _Day #-}--{- | 'Data.Time.TimeOfDay' bimap for 'AnyValue'. Usually used as-'Toml.Bi.Combinators.timeOfDay' combinator.--}-_TimeOfDay :: TomlBiMap TimeOfDay AnyValue-_TimeOfDay = mkAnyValueBiMap matchHours Hours-{-# INLINE _TimeOfDay #-}---- | Helper bimap for 'String' and 'Data.Text.Text'.-_StringText :: BiMap e String Text-_StringText = iso T.pack T.unpack-{-# INLINE _StringText #-}--{- | 'String' bimap for 'AnyValue'. Usually used as-'Toml.Bi.Combinators.string' combinator.--}-_String :: TomlBiMap String AnyValue-_String = _StringText >>> _Text-{-# INLINE _String #-}---- | Helper bimap for 'String' and types with 'Read' and 'Show' instances.-_ReadString :: (Show a, Read a) => TomlBiMap a String-_ReadString = BiMap (Right . show) (first (ArbitraryError . T.pack) . readEither)-{-# INLINE _ReadString #-}---- | Bimap for 'AnyValue' and values with a 'Read' and 'Show' instance.--- Usually used as 'Toml.Bi.Combinators.read' combinator.-_Read :: (Show a, Read a) => TomlBiMap a AnyValue-_Read = _ReadString >>> _String-{-# INLINE _Read #-}---- | Helper bimap for 'Natural' and 'Prelude.Integer'.-_NaturalInteger :: TomlBiMap Natural Integer-_NaturalInteger = BiMap (Right . toInteger) eitherInteger-  where-    eitherInteger :: Integer -> Either TomlBiMapError Natural-    eitherInteger n-      | n < 0     = Left $ ArbitraryError $ "Value is below zero, but expected Natural: " <> tShow n-      | otherwise = Right (fromIntegral n)--{- | 'String' bimap for 'AnyValue'. Usually used as-'Toml.Bi.Combinators.natural' combinator.--}-_Natural :: TomlBiMap Natural AnyValue-_Natural = _NaturalInteger >>> _Integer-{-# INLINE _Natural #-}---- | Helper bimap for 'Prelude.Integer' and integral, bounded values.-_BoundedInteger :: (Integral a, Bounded a, Show a) => TomlBiMap a Integer-_BoundedInteger = BiMap (Right . toInteger) eitherBounded-  where-    eitherBounded :: forall a. (Integral a, Bounded a, Show a) => Integer -> Either TomlBiMapError a-    eitherBounded n-      | n < toInteger (minBound @a) =-         let msg = "Value " <> tShow n <> " is less than minBound: " <> tShow (minBound @a)-         in Left $ ArbitraryError msg-      | n > toInteger (maxBound @a) =-         let msg = "Value " <> tShow n <> " is greater than maxBound: " <> tShow (maxBound @a)-         in Left $ ArbitraryError msg-      | otherwise = Right (fromIntegral n)--{- | Helper bimap for '_EnumBounded' and 'Data.Text.Text'.--@since 1.1.1.0--}-_EnumBoundedText :: forall a. (Show a, Enum a, Bounded a) => TomlBiMap a Text-_EnumBoundedText = BiMap-    { forward  = Right . tShow-    , backward = toEnumBounded-    }-  where-    toEnumBounded :: Text -> Either TomlBiMapError a-    toEnumBounded value = case M.lookup value enumOptions of-        Just a  -> Right a-        Nothing ->-            let msg = "Value is '" <> value <> "' but expected one of: " <> T.intercalate ", " options-            in Left (ArbitraryError msg)-      where-        enumOptions :: Map Text a-        enumOptions = M.fromList $ zip options enums-        options  = fmap tShow enums-        enums = [minBound @a .. maxBound @a]--{- | Bimap for nullary sum data types with 'Show', 'Enum' and 'Bounded'-instances.  Usually used as 'Toml.Bi.Combinators.enumBounded' combinator.--@since 1.1.1.0--}-_EnumBounded :: (Show a, Enum a, Bounded a) => TomlBiMap a AnyValue-_EnumBounded = _EnumBoundedText >>> _Text-{-# INLINE _EnumBounded #-}--{- | 'Word' bimap for 'AnyValue'. Usually used as-'Toml.Bi.Combinators.word' combinator.--}-_Word :: TomlBiMap Word AnyValue-_Word = _BoundedInteger >>> _Integer-{-# INLINE _Word #-}--{- | 'Word8' bimap for 'AnyValue'. Usually used as-'Toml.Bi.Combinators.word8' combinator.--@since 1.2.0.0--}-_Word8 :: TomlBiMap Word8 AnyValue-_Word8 = _BoundedInteger >>> _Integer-{-# INLINE _Word8 #-}--{- | 'Int' bimap for 'AnyValue'. Usually used as-'Toml.Bi.Combinators.int' combinator.--}-_Int :: TomlBiMap Int AnyValue-_Int = _BoundedInteger >>> _Integer-{-# INLINE _Int #-}--{- | 'Float' bimap for 'AnyValue'. Usually used as-'Toml.Bi.Combinators.float' combinator.--}-_Float :: TomlBiMap Float AnyValue-_Float = iso realToFrac realToFrac >>> _Double-{-# INLINE _Float #-}---- | Helper bimap for 'Data.Text.Text' and strict 'ByteString'-_ByteStringText :: TomlBiMap ByteString Text-_ByteStringText = prism T.encodeUtf8 eitherText-  where-    eitherText :: ByteString -> Either TomlBiMapError Text-    eitherText = either (\err -> Left $ ArbitraryError $ tShow err) Right . T.decodeUtf8'-{-# INLINE _ByteStringText #-}---- | UTF8 encoded 'ByteString' bimap for 'AnyValue'.--- Usually used as 'Toml.Bi.Combinators.byteString' combinator.-_ByteString :: TomlBiMap ByteString AnyValue-_ByteString = _ByteStringText >>> _Text-{-# INLINE _ByteString #-}---- | Helper bimap for 'Data.Text.Text' and lazy 'BL.ByteString'.-_LByteStringText :: TomlBiMap BL.ByteString Text-_LByteStringText = prism (TL.encodeUtf8 . TL.fromStrict) eitherText-  where-    eitherText :: BL.ByteString -> Either TomlBiMapError Text-    eitherText = bimap (ArbitraryError . tShow) TL.toStrict . TL.decodeUtf8'-{-# INLINE _LByteStringText #-}---- | UTF8 encoded lazy 'BL.ByteString' bimap for 'AnyValue'.--- Usually used as 'Toml.Bi.Combinators.lazyByteString' combinator.-_LByteString :: TomlBiMap BL.ByteString AnyValue-_LByteString = _LByteStringText >>> _Text-{-# INLINE _LByteString #-}--{- | 'ByteString' bimap for 'AnyValue' encoded as a list of non-negative integers.-Usually used as 'Toml.Bi.Combinators.byteStringArray' combinator.--@since 1.2.0.0--}-_ByteStringArray :: TomlBiMap ByteString AnyValue-_ByteStringArray = iso BS.unpack BS.pack >>> _Array _Word8-{-# INLINE _ByteStringArray #-}--{- | Lazy 'ByteString' bimap for 'AnyValue' encoded as a list of non-negative integers.-Usually used as 'Toml.Bi.Combinators.lazyByteStringArray' combinator.--@since 1.2.0.0--}-_LByteStringArray :: TomlBiMap BL.ByteString AnyValue-_LByteStringArray = iso BL.unpack BL.pack >>>  _Array _Word8-{-# INLINE _LByteStringArray #-}---- | Takes a bimap of a value and returns a bimap between a list of values and 'AnyValue'--- as an array. Usually used as 'Toml.Bi.Combinators.arrayOf' combinator.-_Array :: forall a . TomlBiMap a AnyValue -> TomlBiMap [a] AnyValue-_Array elementBimap = BiMap toAnyValue fromAnyValue-  where-    toAnyValue :: [a] -> Either TomlBiMapError AnyValue-    toAnyValue = mapM (forward elementBimap) >=> bimap WrongValue AnyValue . toMArray--    fromAnyValue :: AnyValue -> Either TomlBiMapError [a]-    fromAnyValue (AnyValue v) = matchElements (backward elementBimap) v--    -- can't reuse matchArray here :(-    matchElements :: (AnyValue -> Either TomlBiMapError a) -> Value t -> Either TomlBiMapError [a]-    matchElements match (Array a) = mapM (applyAsToAny match) a-    matchElements _ val           = first WrongValue $ mkMatchError TArray val----- | Takes a bimap of a value and returns a bimap between a non-empty list of values and 'AnyValue'--- as an array. Usually used as 'Toml.Bi.Combinators.nonEmpty' combinator.-_NonEmpty :: TomlBiMap a AnyValue -> TomlBiMap (NE.NonEmpty a) AnyValue-_NonEmpty bi = _NonEmptyArray >>> _Array bi-{-# INLINE _NonEmpty #-}--_NonEmptyArray :: TomlBiMap (NE.NonEmpty a) [a]-_NonEmptyArray = BiMap-    { forward  = Right . NE.toList-    , backward = maybe (Left $ ArbitraryError "Empty array list, but expected NonEmpty") Right . NE.nonEmpty-    }-{-# INLINE _NonEmptyArray #-}---- | Takes a bimap of a value and returns a bimap between a set of values and 'AnyValue'--- as an array. Usually used as 'Toml.Bi.Combinators.arraySetOf' combinator.-_Set :: (Ord a) => TomlBiMap a AnyValue -> TomlBiMap (S.Set a) AnyValue-_Set bi = iso S.toList S.fromList >>> _Array bi-{-# INLINE _Set #-}---- | Takes a bimap of a value and returns a bimap between a hash set of values and 'AnyValue'--- as an array. Usually used as 'Toml.Bi.Combinators.arrayHashSetOf' combinator.-_HashSet :: (Eq a, Hashable a) => TomlBiMap a AnyValue -> TomlBiMap (HS.HashSet a) AnyValue-_HashSet bi = iso HS.toList HS.fromList >>> _Array bi-{-# INLINE _HashSet #-}--{- | 'IS.IntSet' bimap for 'AnyValue'. Usually used as-'Toml.Bi.Combinators.arrayIntSet' combinator.--}-_IntSet :: TomlBiMap IS.IntSet AnyValue-_IntSet = iso IS.toList IS.fromList >>> _Array _Int-{-# INLINE _IntSet #-}--tShow :: Show a => a -> Text-tShow = T.pack . show-{-# INLINE tShow #-}

@@ -1,298 +0,0 @@-{- |-Copyright: (c) 2018-2019 Kowainik-SPDX-License-Identifier: MPL-2.0-Maintainer: Kowainik <xrom.xkov@gmail.com>--Contains general underlying monad for bidirectional conversion.--}--module Toml.Bi.Monad-       ( Codec (..)-       , BiCodec-       , dimap-       , dioptional-       , diwrap-       , dimatch-       , (<!>)-       , (.=)-       ) where--import Control.Applicative (Alternative (..), optional)-import Control.Monad (MonadPlus (..))-import Data.Coerce (Coercible, coerce)---{- | Monad for bidirectional conversion. Contains pair of functions:--1. How to read value of type @a@ from immutable environment context @r@?-2. How to store value of type @a@ in stateful context @w@?--In practice instead of @r@ we will use some @Reader Toml@ and instead of @w@ we will-use @State Toml@. This approach with the bunch of utility functions allows to-have single description for from/to @TOML@ conversion.--In practice this type will always be used in the following way:--@-type 'BiCodec' r w a = 'Codec' r w a a-@--Type parameter @c@ if fictional. Here some trick is used. This trick is-implemented in the [codec](http://hackage.haskell.org/package/codec) package and-described in more details in related blog post:-<https://blog.poisson.chat/posts/2016-10-12-bidirectional-serialization.html>.--}-data Codec r w c a = Codec-    { -- | Extract value of type @a@ from monadic context @r@.-      codecRead  :: r a--      -- | Store value of type @c@ inside monadic context @w@ and returning-      -- value of type @a@. Type of this function actually should be @a -> w ()@ but with-      -- such type it's impossible to have 'Monad' and other instances.-    , codecWrite :: c -> w a-    }---- | Specialized version of 'Codec' data type. This type alias is used in practice.-type BiCodec r w a = Codec r w a a--instance (Functor r, Functor w) => Functor (Codec r w c) where-    fmap :: (a -> b) -> Codec r w c a -> Codec r w c b-    fmap f codec = Codec-        { codecRead  = f <$> codecRead codec-        , codecWrite = fmap f . codecWrite codec-        }-    {-# INLINE fmap #-}--instance (Applicative r, Applicative w) => Applicative (Codec r w c) where-    pure :: a -> Codec r w c a-    pure a = Codec-        { codecRead  = pure a-        , codecWrite = \_ -> pure a-        }-    {-# INLINE pure #-}--    (<*>) :: Codec r w c (a -> b) -> Codec r w c a -> Codec r w c b-    codecf <*> codeca = Codec-        { codecRead  = codecRead codecf <*> codecRead codeca-        , codecWrite = \c -> codecWrite codecf c <*> codecWrite codeca c-        }-    {-# INLINE (<*>) #-}--instance (Monad r, Monad w) => Monad (Codec r w c) where-    (>>=) :: Codec r w c a -> (a -> Codec r w c b) -> Codec r w c b-    codec >>= f = Codec-        { codecRead  = codecRead codec >>= \a -> codecRead (f a)-        , codecWrite = \c -> codecWrite codec c >>= \a -> codecWrite (f a) c-        }-    {-# INLINE (>>=) #-}--instance (Alternative r, Alternative w) => Alternative (Codec r w c) where-    empty :: Codec r w c a-    empty = Codec-        { codecRead  = empty-        , codecWrite = \_ -> empty-        }-    {-# INLINE empty #-}--    (<|>) :: Codec r w c a -> Codec r w c a -> Codec r w c a-    codec1 <|> codec2 = Codec-        { codecRead  = codecRead codec1 <|> codecRead codec2-        , codecWrite = \c -> codecWrite codec1 c <|> codecWrite codec2 c-        }-    {-# INLINE (<|>) #-}--instance (MonadPlus r, MonadPlus w) => MonadPlus (Codec r w c) where-    mzero = empty-    {-# INLINE mzero #-}-    mplus = (<|>)-    {-# INLINE mplus #-}---- | Alternative instance for function arrow but without 'empty'.-infixl 3 <!>-(<!>) :: Alternative f => (a -> f x) -> (a -> f x) -> (a -> f x)-f <!> g = \a -> f a <|> g a-{-# INLINE (<!>) #-}--{- | This is an instance of @Profunctor@ for 'Codec'. But since there's no-@Profunctor@ type class in @base@ or package with no dependencies (and we don't-want to bring extra dependencies) this instance is implemented as a single-top-level function.--Useful when you want to parse @newtype@s. For example, if you had data type like-this:--@-__data__ Example = Example-    { foo :: Bool-    , bar :: Text-    }-@--Bidirectional TOML converter for this type will look like this:--@-exampleCodec :: TomlCodec Example-exampleCodec = Example-    \<$\> Toml.bool "foo" '.=' foo-    \<*\> Toml.text "bar" '.=' bar-@--Now if you change your type in the following way:--@-__newtype__ Email = Email { unEmail :: Text }--__data__ Example = Example-    { foo :: Bool-    , bar :: Email-    }-@--you need to patch your TOML codec like this:--@-exampleCodec :: TomlCodec Example-exampleCodec = Example-    \<$\> Toml.bool "foo" '.=' foo-    \<*\> 'dimap' unEmail Email (Toml.text "bar") '.=' bar-@--}-dimap-    :: (Functor r, Functor w)-    => (c -> d)       -- ^ Mapper for consumer-    -> (a -> b)       -- ^ Mapper for producer-    -> Codec r w d a  -- ^ Source 'Codec' object-    -> Codec r w c b  -- ^ Target 'Codec' object-dimap f g codec = Codec-    { codecRead  = g <$> codecRead codec-    , codecWrite = fmap g . codecWrite codec . f-    }-{-# INLINE dimap #-}--{- | Bidirectional converter for @Maybe a@ values. For example, given the data-type:--@-__data__ Example = Example-    { foo :: Bool-    , bar :: Maybe Int-    }-@--the TOML codec will look like--@-exampleCodec :: TomlCodec Example-exampleCodec = Example-    \<$\> Toml.bool "foo" '.=' foo-    \<*\> 'dioptional' (Toml.int "bar") '.=' bar-@--}-dioptional-    :: (Alternative r, Applicative w)-    => Codec r w c a-    -> Codec r w (Maybe c) (Maybe a)-dioptional Codec{..} = Codec-    { codecRead  = optional codecRead-    , codecWrite = traverse codecWrite-    }-{-# INLINE dioptional #-}--{- | Combinator used for @newtype@ wrappers. For example, given the data types:--@-__newtype__ N = N Int--__data__ Example = Example-    { foo :: Bool-    , bar :: N-    }-@--the TOML codec can look like--@-exampleCodec :: TomlCodec Example-exampleCodec = Example-    \<$\> Toml.bool "foo" '.=' foo-    \<*\> 'diwrap' (Toml.int "bar") '.=' bar-@--}-diwrap-    :: forall b a r w .-       (Coercible a b, Functor r, Functor w)-    => BiCodec r w a-    -> BiCodec r w b-diwrap = dimap coerce coerce-{-# INLINE diwrap #-}--{- | Bidirectional converter for @sum types@. For example, given the data-type:--@-__data__ Example-    = Foo Int-    | Bar Bool Int-@--the TOML codec will look like--@-matchFoo :: Example -> Maybe Int-matchFoo (Foo num) = Just num-matchFoo _         = Nothing--matchBar :: Example -> Maybe (Bool, Int)-matchBar (Bar b num) = Just (b, num)-matchBar _           = Nothing--barCodec :: TomlCodec (Bool, Int)-barCodec = (,)-    \<$\> Toml.bool "a" '.=' fst-    \<*\> Toml.int "b" '.=' snd--exampleCodec :: TomlCodec Example-exampleCodec =-    dimatch matchFoo Foo (Toml.int "foo")-    \<|\> dimatch matchBar (uncurry Bar) (Toml.table barCodec "bar")-@--@since 1.2.0.0--}-dimatch-    :: (Functor r, Alternative w)-    => (c -> Maybe d) -- ^ Mapper for consumer-    -> (a -> b)       -- ^ Mapper for producer-    -> Codec r w d a  -- ^ Source 'Codec' object-    -> Codec r w c b  -- ^ Target 'Codec' object-dimatch match ctor codec = Codec-    { codecRead = ctor <$> codecRead codec-    , codecWrite = \c -> case match c of-        Nothing -> empty-        Just d  -> ctor <$> codecWrite codec d-    }-{-# INLINE dimatch #-}--{- | Operator to connect two operations:--1. How to get field from object?-2. How to write this field to toml?--In code this should be used like this:--@-__data__ Foo = Foo-    { fooBar :: Int-    , fooBaz :: String-    }--fooCodec :: TomlCodec Foo-fooCodec = Foo-    \<$\> Toml.int "bar" '.=' fooBar-    \<*\> Toml.str "baz" '.=' fooBaz-@--}-infixl 5 .=-(.=) :: Codec r w field a -> (object -> field) -> Codec r w object a-codec .= getter = codec { codecWrite = codecWrite codec . getter }-{-# INLINE (.=) #-}

@@ -0,0 +1,122 @@+{- |+Copyright: (c) 2018-2020 Kowainik+SPDX-License-Identifier: MPL-2.0+Maintainer: Kowainik <xrom.xkov@gmail.com>++This module provides utilities for implementing and using+bidirectional TOML codecs. The concept of bidirectional conversion in+@tomland@ has two parts: __'TomlBiMap'__ and __'TomlCodec'__.++== General TOML description++In the following TOML++@+name = "foo"+@++we call @name@ as __key__ and @"foo"@ as __value__.++== 'TomlBiMap'++'TomlBiMap' provides a bidirectional conversion between+__TOML values__ and Haskell primitive values. TOML specification+defines some primitive values you can use in key-value pairs+(e.g. /integer/, /string/, /local time/). 'TomlBiMap' provides a way+to convert between TOML primitives and Haskell values. 'TomlBiMap'+doesn't know anything about TOML keys.++== 'TomlCodec'++'TomlCodec' describes how to convert in both ways between a single or+multiple key-value pairs and Haskell types. @tomland@ provides basic+primitives for decoding and encoding single key-value pairs, but also+a way to compose multiple 'TomlCodec's into a single one. So, if you+have a custom data type, that has several fields or several+constructors, you need to define 'TomlCodec' for your data type.++== Encoding and decoding++If you have a type like @User@ then @userCodec :: 'TomlCodec' User@ is+an object that describes how to 'encode' a value of type @User@ to+TOML and 'decode' TOML to a value of type @User@.++* To TOML: @'encode' userCodec someUser@+* From TOML: @'decode' userCodec someToml@++== Naming conventions++@tomland@ uses the following naming conventions (and encourages+library users to follow them as well):++* __\_SomeName__: for 'TomlBiMap' (e.g. '_Int', '_Text', '_Array')+* __someName__: for basic 'TomlCodec's (e.g. 'int', 'text', 'arrayOf')+* __someNameCodec__: for user defined codecs for custom types (e.g. @userCodec@, @configCodec@, @serverCodec@)++@since 1.3.0.0+-}++module Toml.Codec+    ( -- $types+      module Toml.Codec.Types+      -- $error+    , module Toml.Codec.Error+      -- $code+    , module Toml.Codec.Code+      -- $di+    , module Toml.Codec.Di+      -- $combinator+    , module Toml.Codec.Combinator+      -- $generic+    , module Toml.Codec.Generic+      -- $bimap+    , module Toml.Codec.BiMap+      -- $bimapConversion+    , module Toml.Codec.BiMap.Conversion+    ) where++import Toml.Codec.BiMap+import Toml.Codec.BiMap.Conversion+import Toml.Codec.Code+import Toml.Codec.Combinator+import Toml.Codec.Di+import Toml.Codec.Error+import Toml.Codec.Generic+import Toml.Codec.Types++{- $types+Core codec types, including @Toml@ specialised ones: 'TomlCodec', 'TomlState'+and 'TomlEnv'.+-}++{- $error+Core error types, including 'TomlDecodeError' and 'LoadTomlException'.+-}++{- $code+Contains TOML-specific combinators for converting between TOML and user data+types.+-}++{- $di+Forward and backward mapping functions and combinators (similar to profunctors).+-}++{- $combinator+Contains TOML-specific combinators and codecs for converting between TOML and+user data types.+-}++{- $generic+Automatic TOML codecs using 'GHC.Generics.Generic'.+-}++{- $bimap+'BiMap' type that represents /Tagged Partial Bidirectional Conversion/+between TOML primitives and Haskell types.+-}++{- $bimapConversion+Specific implementations of 'BiMap' between Haskell types and TOML+values.+-}

@@ -0,0 +1,237 @@+{-# LANGUAGE AllowAmbiguousTypes #-}+{-# LANGUAGE DataKinds           #-}+{-# LANGUAGE DeriveAnyClass      #-}+{-# LANGUAGE GADTs               #-}+{-# LANGUAGE KindSignatures      #-}+{-# LANGUAGE Rank2Types          #-}++{- |+Copyright: (c) 2018-2020 Kowainik+SPDX-License-Identifier: MPL-2.0+Maintainer: Kowainik <xrom.xkov@gmail.com>++Implementation of /Tagged Partial Bidirectional Isomorphism/. This+module contains the 'BiMap' type that represents conversion between+two types with the possibility of failure.++See "Toml.Codec.BiMap.Conversion" for examples of 'BiMap' with+specific types. The 'BiMap' concept is general and is not specific to+TOML, but in this package most usages of 'BiMap' are between TOML+values and Haskell values.+-}++module Toml.Codec.BiMap+    ( -- * 'BiMap' concept+      BiMap (..)+    , invert+    , iso+    , prism++      -- * TOML 'BiMap'+      -- ** Type+    , TomlBiMap+      -- ** Error+    , TomlBiMapError (..)+    , wrongConstructor+    , prettyBiMapError+      -- ** Smart constructors+    , mkAnyValueBiMap+      -- ** Internals+    , tShow+    ) where++import Control.DeepSeq (NFData)+import Control.Monad ((>=>))+import Data.Bifunctor (first)+import Data.Text (Text)+import GHC.Generics (Generic)++import Toml.Type.AnyValue (AnyValue (..), MatchError (..))+import Toml.Type.Value (TValue (..), Value (..))++import qualified Control.Category as Cat+import qualified Data.Text as T+++{- | Partial bidirectional isomorphism. @BiMap a b@ contains two function:++1. @a -> Either e b@+2. @b -> Either e a@++If you think of types as sets then this data type can be illustrated by the+following picture:++![bimap-type](https://user-images.githubusercontent.com/4276606/50770531-b6a36000-1298-11e9-9528-caae87951d2a.png)++'BiMap' also implements 'Cat.Category' typeclass. And this instance can be described+clearly by this illustration:++![bimap-cat](https://user-images.githubusercontent.com/4276606/50771234-13a01580-129b-11e9-93da-6c5dd0f7f160.png)++@since 0.4.0+-}+data BiMap e a b = BiMap+    { forward  :: a -> Either e b+    , backward :: b -> Either e a+    }++-- | @since 0.4.0+instance Cat.Category (BiMap e) where+    id :: BiMap e a a+    id = BiMap Right Right+    {-# INLINE id #-}++    (.) :: BiMap e b c -> BiMap e a b -> BiMap e a c+    bc . ab = BiMap+        { forward  =  forward ab >=>  forward bc+        , backward = backward bc >=> backward ab+        }+    {-# INLINE (.) #-}++{- | Inverts bidirectional mapping.++@since 0.4.0+-}+invert :: BiMap e a b -> BiMap e b a+invert (BiMap f g) = BiMap g f+{-# INLINE invert #-}++{- | Creates 'BiMap' from isomorphism. Can be used in the following way:++@+__newtype__ Even = Even Integer+__newtype__ Odd  = Odd  Integer++succEven :: Even -> Odd+succEven (Even n) = Odd (n + 1)++predOdd :: Odd -> Even+predOdd (Odd n) = Even (n - 1)++_EvenOdd :: 'BiMap' e Even Odd+_EvenOdd = 'iso' succEven predOdd+@++@since 0.4.0+-}+iso :: (a -> b) -> (b -> a) -> BiMap e a b+iso f g = BiMap (Right . f) (Right . g)+{-# INLINE iso #-}++{- | Creates 'BiMap' from prism-like pair of functions. This combinator can be+used to create 'BiMap' for custom sum types like this:++@+__data__ User+    = Admin  Integer  -- id of admin+    | Client Text     -- name of the client+    __deriving__ (Show)++_Admin :: 'TomlBiMap' User Integer+_Admin = Toml.'prism' Admin $ \\__case__+    Admin i -> Right i+    other   -> Toml.'wrongConstructor' \"Admin\" other++_Client :: 'TomlBiMap' User Text+_Client = Toml.'prism' Client $ \\__case__+    Client n -> Right n+    other    -> Toml.'wrongConstructor' \"Client\" other+@++@since 0.4.0+-}+prism+    :: (field -> object)+    -- ^ Constructor+    -> (object -> Either error field)+    -- ^ Match object to either error or field+    -> BiMap error object field+prism review preview = BiMap preview (Right . review)+{-# INLINE prism #-}++----------------------------------------------------------------------------+-- TOML BiMap+----------------------------------------------------------------------------++{- | 'BiMap' specialized to TOML error.++@since 1.0.0+-}+type TomlBiMap = BiMap TomlBiMapError++{- | Type of errors for TOML 'BiMap'.++@since 1.0.0+-}+data TomlBiMapError+    = WrongConstructor -- ^ Error for cases with wrong constructors. For+                       -- example, you're trying to convert 'Left' but+                       -- bidirectional converter expects 'Right'.+        !Text          -- ^ Expected constructor name+        !Text          -- ^ Actual value+    | WrongValue       -- ^ Error for cases with wrong values+        !MatchError    -- ^ Information about failed matching+    | ArbitraryError   -- ^ Arbitrary textual error+        !Text          -- ^ Error message+    deriving stock (Eq, Show, Generic)+    deriving anyclass (NFData)++{- | Converts 'TomlBiMapError' into pretty human-readable text.++@since 1.0.0+-}+prettyBiMapError :: TomlBiMapError -> Text+prettyBiMapError = \case+    WrongConstructor expected actual -> T.unlines+        [ "Invalid constructor"+        , "  * Expected: " <> expected+        , "  * Actual:   " <> actual+        ]+    WrongValue (MatchError expected actual) -> T.unlines+        [ "Invalid constructor"+        , "  * Expected: " <> tShow expected+        , "  * Actual:   " <> tShow actual+        ]+    ArbitraryError text  -> text++{- | Helper to construct WrongConstuctor error.++@since 1.0.0+-}+wrongConstructor+    :: Show a+    => Text  -- ^ Name of the expected constructor+    -> a     -- ^ Actual value+    -> Either TomlBiMapError b+wrongConstructor constructor x = Left $ WrongConstructor constructor (tShow x)++tShow :: Show a => a -> Text+tShow = T.pack . show+{-# INLINE tShow #-}++----------------------------------------------------------------------------+--  BiMaps for value+----------------------------------------------------------------------------++{- | Smart constructor for 'BiMap' from a Haskell value (some+primitive like 'Int' or 'Text') to 'AnyValue'.++@since 0.4.0+-}+mkAnyValueBiMap+    :: forall a (tag :: TValue)+    .  (forall (t :: TValue) . Value t -> Either MatchError a)+    -- ^ Haskell type exctractor from 'Value'+    -> (a -> Value tag)+    -- ^ Convert Haskell type back to 'Value'+    -> TomlBiMap a AnyValue+mkAnyValueBiMap matchValue toValue = BiMap+    { forward  = Right . toAnyValue+    , backward = fromAnyValue+    }+  where+    toAnyValue :: a -> AnyValue+    toAnyValue = AnyValue . toValue++    fromAnyValue :: AnyValue -> Either TomlBiMapError a+    fromAnyValue (AnyValue value) = first WrongValue $ matchValue value

@@ -0,0 +1,619 @@+{-# LANGUAGE GADTs #-}++{- |+Copyright: (c) 2018-2020 Kowainik+SPDX-License-Identifier: MPL-2.0+Maintainer: Kowainik <xrom.xkov@gmail.com>++Implementations of 'BiMap' for specific Haskell types and TOML+values. Usually, you use codecs from the "Toml.Codec.Combinator"+module. You may need to use these 'BiMap's instead of codecs in the+following situations:++1. When using 'Toml.Codec.Combinator.List.arrayOf' combinator (or similar).+2. When using 'Toml.Codec.Combinator.Map.tableMap' combinator (for keys).+3. When implementing custom 'BiMap' for your types.++@since 1.3.0.0+-}++module Toml.Codec.BiMap.Conversion+    ( -- * Primitive+      -- ** Boolean+      _Bool+      -- ** Integral+    , _Int+    , _Word+    , _Word8+    , _Integer+    , _Natural+      -- ** Floating+    , _Double+    , _Float+      -- ** Text+    , _Text+    , _LText+    , _ByteString+    , _LByteString+    , _String++      -- * Time+    , _ZonedTime+    , _LocalTime+    , _Day+    , _TimeOfDay++      -- * Arrays+    , _Array+    , _NonEmpty+    , _Set+    , _HashSet+    , _IntSet+    , _ByteStringArray+    , _LByteStringArray++      -- * Coerce+    , _Coerce++      -- * Custom+    , _EnumBounded+    , _Read+    , _TextBy+    , _Validate++      -- * 'Key's+    , _KeyText+    , _KeyString+    , _KeyInt++      -- * General purpose+    , _Just+    , _Left+    , _Right++      -- * Internal helpers+    , _LTextText+    , _NaturalInteger+    , _NonEmptyList+    , _StringText+    , _ReadString+    , _BoundedInteger+    , _EnumBoundedText+    , _ByteStringText+    , _LByteStringText+    ) where++import Control.Category ((>>>))+import Control.Monad ((>=>))+import Data.Bifunctor (bimap, first)+import Data.ByteString (ByteString)+import Data.Coerce (Coercible, coerce)+import Data.Hashable (Hashable)+import Data.Map (Map)+import Data.Text (Text)+import Data.Time (Day, LocalTime, TimeOfDay, ZonedTime)+import Data.Word (Word8)+import Numeric.Natural (Natural)+import Text.Read (readEither)++import Toml.Codec.BiMap (BiMap (..), TomlBiMap, TomlBiMapError (..), iso, mkAnyValueBiMap, prism,+                         tShow, wrongConstructor)+import Toml.Parser (TomlParseError (..), parseKey)+import Toml.Type.AnyValue (AnyValue (..), applyAsToAny, matchBool, matchDay, matchDouble,+                           matchHours, matchInteger, matchLocal, matchText, matchZoned,+                           mkMatchError, toMArray)+import Toml.Type.Key (Key (..))+import Toml.Type.Printer (prettyKey)+import Toml.Type.Value (TValue (..), Value (..))++import qualified Data.ByteString as BS+import qualified Data.ByteString.Lazy as BL+import qualified Data.HashSet as HS+import qualified Data.IntSet as IS+import qualified Data.List.NonEmpty as NE+import qualified Data.Map as M+import qualified Data.Set as S+import qualified Data.Text as T+import qualified Data.Text.Encoding as T+import qualified Data.Text.Lazy as TL+import qualified Data.Text.Lazy.Encoding as TL++----------------------------------------------------------------------------+-- Primitive+----------------------------------------------------------------------------++{- | 'Prelude.Bool' 'BiMap' for 'AnyValue'. Usually used as the+'Toml.Codec.Combinator.Primitive.bool' combinator.++@since 0.4.0+-}+_Bool :: TomlBiMap Bool AnyValue+_Bool = mkAnyValueBiMap matchBool Bool+{-# INLINE _Bool #-}++{- | 'Prelude.Integer' 'BiMap' for 'AnyValue'. Usually used as the+'Toml.Codec.Combinator.Primitive.integer' combinator.++@since 0.4.0+-}+_Integer :: TomlBiMap Integer AnyValue+_Integer = mkAnyValueBiMap matchInteger Integer+{-# INLINE _Integer #-}++{- | 'Prelude.Double' 'BiMap' for 'AnyValue'. Usually used as the+'Toml.Codec.Combinator.Primitive.double' combinator.++@since 0.4.0+-}+_Double :: TomlBiMap Double AnyValue+_Double = mkAnyValueBiMap matchDouble Double+{-# INLINE _Double #-}++{- | 'Data.Text.Text' 'BiMap' for 'AnyValue'. Usually used as the+'Toml.Codec.Combinator.Primitive.text' combinator.++@since 0.4.0+-}+_Text :: TomlBiMap Text AnyValue+_Text = mkAnyValueBiMap matchText Text+{-# INLINE _Text #-}++{- | Helper bimap for 'Data.Text.Lazy.Text' and 'Data.Text.Text'.++@since 1.0.0+-}+_LTextText :: BiMap e TL.Text Text+_LTextText = iso TL.toStrict TL.fromStrict+{-# INLINE _LTextText #-}++{- | 'Data.Text.Lazy.Text' 'BiMap' for 'AnyValue'. Usually used as the+'Toml.Codec.Combinator.Primitive.lazyText' combinator.++@since 1.0.0+-}+_LText :: TomlBiMap TL.Text AnyValue+_LText = _LTextText >>> _Text+{-# INLINE _LText #-}++{- | 'Data.Time.ZonedTime' bimap for 'AnyValue'. Usually used as the+'Toml.Codec.Combinator.Time.zonedTime' combinator.++@since 0.5.0+-}+_ZonedTime :: TomlBiMap ZonedTime AnyValue+_ZonedTime = mkAnyValueBiMap matchZoned Zoned+{-# INLINE _ZonedTime #-}++{- | 'Data.Time.LocalTime' bimap for 'AnyValue'. Usually used as the+'Toml.Codec.Combinator.Time.localTime' combinator.++@since 0.5.0+-}+_LocalTime :: TomlBiMap LocalTime AnyValue+_LocalTime = mkAnyValueBiMap matchLocal Local+{-# INLINE _LocalTime #-}++{- | 'Data.Time.Day' 'BiMap' for 'AnyValue'. Usually used as the+'Toml.Codec.Combinator.Time.day' combinator.++@since 0.5.0+-}+_Day :: TomlBiMap Day AnyValue+_Day = mkAnyValueBiMap matchDay Day+{-# INLINE _Day #-}++{- | 'Data.Time.TimeOfDay' 'BiMap' for 'AnyValue'. Usually used as the+'Toml.Codec.Combinator.Time.timeOfDay' combinator.++@since 0.5.0+-}+_TimeOfDay :: TomlBiMap TimeOfDay AnyValue+_TimeOfDay = mkAnyValueBiMap matchHours Hours+{-# INLINE _TimeOfDay #-}++{- | Helper 'BiMap' for 'String' and 'Data.Text.Text'.++@since 0.4.0+-}+_StringText :: BiMap e String Text+_StringText = iso T.pack T.unpack+{-# INLINE _StringText #-}++{- | 'String' 'BiMap' for 'AnyValue'. Usually used as the+'Toml.Codec.Combinator.Primitive.string' combinator.++@since 0.4.0+-}+_String :: TomlBiMap String AnyValue+_String = _StringText >>> _Text+{-# INLINE _String #-}++{- | Helper 'BiMap' for 'Natural' and 'Prelude.Integer'.++@since 0.5.0+-}+_NaturalInteger :: TomlBiMap Natural Integer+_NaturalInteger = BiMap (Right . toInteger) eitherInteger+  where+    eitherInteger :: Integer -> Either TomlBiMapError Natural+    eitherInteger n+      | n < 0     = Left $ ArbitraryError $ "Value is below zero, but expected Natural: " <> tShow n+      | otherwise = Right (fromIntegral n)++{- | 'Natural' 'BiMap' for 'AnyValue'. Usually used as the+'Toml.Codec.Combinator.Primitive.natural' combinator.++@since 0.5.0+-}+_Natural :: TomlBiMap Natural AnyValue+_Natural = _NaturalInteger >>> _Integer+{-# INLINE _Natural #-}++{- | Helper 'BiMap' for 'Prelude.Integer' and integral, bounded values.++@since 0.5.0+-}+_BoundedInteger :: (Integral a, Bounded a, Show a) => TomlBiMap a Integer+_BoundedInteger = BiMap (Right . toInteger) eitherBounded+  where+    eitherBounded :: forall a. (Integral a, Bounded a, Show a) => Integer -> Either TomlBiMapError a+    eitherBounded n+      | n < toInteger (minBound @a) =+         let msg = "Value " <> tShow n <> " is less than minBound: " <> tShow (minBound @a)+         in Left $ ArbitraryError msg+      | n > toInteger (maxBound @a) =+         let msg = "Value " <> tShow n <> " is greater than maxBound: " <> tShow (maxBound @a)+         in Left $ ArbitraryError msg+      | otherwise = Right (fromIntegral n)+++{- | 'Word' 'BiMap' for 'AnyValue'. Usually used as the+'Toml.Codec.Combinator.Primitive.word' combinator.++@since 0.5.0+-}+_Word :: TomlBiMap Word AnyValue+_Word = _BoundedInteger >>> _Integer+{-# INLINE _Word #-}++{- | 'Word8' 'BiMap' for 'AnyValue'. Usually used as the+'Toml.Codec.Combinator.Primitive.word8' combinator.++@since 1.2.0.0+-}+_Word8 :: TomlBiMap Word8 AnyValue+_Word8 = _BoundedInteger >>> _Integer+{-# INLINE _Word8 #-}++{- | 'Int' 'BiMap' for 'AnyValue'. Usually used as the+'Toml.Codec.Combinator.Primitive.int' combinator.++@since 0.5.0+-}+_Int :: TomlBiMap Int AnyValue+_Int = _BoundedInteger >>> _Integer+{-# INLINE _Int #-}++{- | 'Float' 'BiMap' for 'AnyValue'. Usually used as the+'Toml.Codec.Combinator.Primitive.float' combinator.++@since 0.5.0+-}+_Float :: TomlBiMap Float AnyValue+_Float = iso realToFrac realToFrac >>> _Double+{-# INLINE _Float #-}++{- | Helper 'BiMap' for 'Data.Text.Text' and strict 'ByteString'++@since 0.5.0+-}+_ByteStringText :: TomlBiMap ByteString Text+_ByteStringText = prism T.encodeUtf8 eitherText+  where+    eitherText :: ByteString -> Either TomlBiMapError Text+    eitherText = either (\err -> Left $ ArbitraryError $ tShow err) Right . T.decodeUtf8'+{-# INLINE _ByteStringText #-}++{- | UTF-8 encoded 'ByteString' 'BiMap' for 'AnyValue'.+Usually used as the 'Toml.Codec.Combinator.Primitive.byteString' combinator.++@since 0.5.0+-}+_ByteString :: TomlBiMap ByteString AnyValue+_ByteString = _ByteStringText >>> _Text+{-# INLINE _ByteString #-}++{- | Helper 'BiMap' for 'Data.Text.Text' and lazy 'BL.ByteString'.++@since 0.5.0+-}+_LByteStringText :: TomlBiMap BL.ByteString Text+_LByteStringText = prism (TL.encodeUtf8 . TL.fromStrict) eitherText+  where+    eitherText :: BL.ByteString -> Either TomlBiMapError Text+    eitherText = bimap (ArbitraryError . tShow) TL.toStrict . TL.decodeUtf8'+{-# INLINE _LByteStringText #-}++{- | UTF-8 encoded lazy 'BL.ByteString' 'BiMap' for 'AnyValue'.+Usually used as the 'Toml.Codec.Combinator.Primitive.lazyByteString' combinator.++@since 0.5.0+-}+_LByteString :: TomlBiMap BL.ByteString AnyValue+_LByteString = _LByteStringText >>> _Text+{-# INLINE _LByteString #-}++----------------------------------------------------------------------------+-- Array+----------------------------------------------------------------------------++{- | 'ByteString' 'BiMap' for 'AnyValue' encoded as a list of bytes+(non-negative integers between 0 and 255). Usually used as the+'Toml.Codec.Combinator.Primitive.byteStringArray' combinator.++@since 1.2.0.0+-}+_ByteStringArray :: TomlBiMap ByteString AnyValue+_ByteStringArray = iso BS.unpack BS.pack >>> _Array _Word8+{-# INLINE _ByteStringArray #-}++{- | Lazy 'ByteString' 'BiMap' for 'AnyValue' encoded as a list of+bytes (non-negative integers between 0 and 255). Usually used as+'Toml.Codec.Combinator.Primitive.lazyByteStringArray' combinator.++@since 1.2.0.0+-}+_LByteStringArray :: TomlBiMap BL.ByteString AnyValue+_LByteStringArray = iso BL.unpack BL.pack >>>  _Array _Word8+{-# INLINE _LByteStringArray #-}++{- | Takes a 'BiMap' of a value and returns a 'BiMap' for a list of values and 'AnyValue'+as an array. Usually used as the 'Toml.Codec.Combinator.List.arrayOf' combinator.++@since 0.4.0+-}+_Array :: forall a . TomlBiMap a AnyValue -> TomlBiMap [a] AnyValue+_Array elementBimap = BiMap toAnyValue fromAnyValue+  where+    toAnyValue :: [a] -> Either TomlBiMapError AnyValue+    toAnyValue = mapM (forward elementBimap) >=> bimap WrongValue AnyValue . toMArray++    fromAnyValue :: AnyValue -> Either TomlBiMapError [a]+    fromAnyValue (AnyValue v) = matchElements (backward elementBimap) v++    -- can't reuse matchArray here :(+    matchElements :: (AnyValue -> Either TomlBiMapError a) -> Value t -> Either TomlBiMapError [a]+    matchElements match (Array a) = mapM (applyAsToAny match) a+    matchElements _ val           = first WrongValue $ mkMatchError TArray val++{- | Takes a 'BiMap' of a value and returns a 'BiMap' for a 'NonEmpty'+list of values and 'AnyValue' as an array. Usually used as the+'Toml.Codec.Combinator.List.arrayNonEmptyOf' combinator.++@since 0.5.0+-}+_NonEmpty :: TomlBiMap a AnyValue -> TomlBiMap (NE.NonEmpty a) AnyValue+_NonEmpty bi = _NonEmptyList >>> _Array bi+{-# INLINE _NonEmpty #-}++{- | Helper 'BiMap' for lists and 'NE.NonEmpty'.++@since 1.3.0.0+-}+_NonEmptyList :: TomlBiMap (NE.NonEmpty a) [a]+_NonEmptyList = BiMap+    { forward  = Right . NE.toList+    , backward = maybe (Left $ ArbitraryError "Empty array list, but expected NonEmpty") Right . NE.nonEmpty+    }+{-# INLINE _NonEmptyList #-}++{- | Takes a 'BiMap' of a value and returns a 'BiMap' for a 'Set' of+values and 'AnyValue' as an array. Usually used as the+'Toml.Codec.Combinator.Set.arraySetOf' combinator.++@since 0.5.0+-}+_Set :: (Ord a) => TomlBiMap a AnyValue -> TomlBiMap (S.Set a) AnyValue+_Set bi = iso S.toList S.fromList >>> _Array bi+{-# INLINE _Set #-}++{- | Takes a 'BiMap' of a value and returns a 'BiMap' for a 'HashSet' of+values and 'AnyValue' as an array. Usually used as the+'Toml.Codec.Combinator.Set.arrayHashSetOf' combinator.++@since 0.5.0+-}+_HashSet :: (Eq a, Hashable a) => TomlBiMap a AnyValue -> TomlBiMap (HS.HashSet a) AnyValue+_HashSet bi = iso HS.toList HS.fromList >>> _Array bi+{-# INLINE _HashSet #-}++{- | 'IS.IntSet' bimap for 'AnyValue'. Usually used as the+'Toml.Codec.Combinator.Set.arrayIntSet' combinator.++@since 0.5.0+-}+_IntSet :: TomlBiMap IS.IntSet AnyValue+_IntSet = iso IS.toList IS.fromList >>> _Array _Int+{-# INLINE _IntSet #-}++----------------------------------------------------------------------------+-- Coerce+----------------------------------------------------------------------------++{- | 'BiMap' for 'Coercible' values. It takes a 'TomlBiMap'+for @a@ type and returns a 'TomlBiMap' @b@ if these types are coercible.++It is supposed to be used to ease the work with @newtypes@.++E.g.++@+__newtype__ Foo = Foo+    { unFoo :: 'Int'+    }++fooBiMap :: 'TomlBiMap' Foo 'AnyValue'+fooBiMap = '_Coerce' '_Int'+@++@since 1.3.0.0+-}+_Coerce :: (Coercible a b) => TomlBiMap a AnyValue -> TomlBiMap b AnyValue+_Coerce = coerce+{-# INLINE _Coerce #-}++----------------------------------------------------------------------------+-- Custom+----------------------------------------------------------------------------++{- | Helper 'BiMap' for 'String' and types with 'Read' and 'Show' instances.++@since 0.5.0+-}+_ReadString :: (Show a, Read a) => TomlBiMap a String+_ReadString = BiMap (Right . show) (first (ArbitraryError . T.pack) . readEither)+{-# INLINE _ReadString #-}++{- | 'BiMap' for 'AnyValue' and values with a 'Read' and 'Show' instances.+Usually used as the 'Toml.Codec.Combinator.Custom.read' combinator.++@since 0.5.0+-}+_Read :: (Show a, Read a) => TomlBiMap a AnyValue+_Read = _ReadString >>> _String+{-# INLINE _Read #-}++{- | Creates 'BiMap' for 'Data.Text.Text' to 'AnyValue' with custom functions.+Usually used as the 'Toml.Codec.Combinator.Custom.textBy' combinator.++@since 0.5.0+-}+_TextBy+    :: forall a .+       (a -> Text)              -- ^ @show@ function for @a@+    -> (Text -> Either Text a)  -- ^ Parser of @a@ from 'Data.Text.Text'+    -> TomlBiMap a AnyValue+_TextBy toText parseText = BiMap toAnyValue fromAnyValue+  where+    toAnyValue :: a -> Either TomlBiMapError AnyValue+    toAnyValue = Right . AnyValue . Text . toText++    fromAnyValue :: AnyValue -> Either TomlBiMapError a+    fromAnyValue (AnyValue v) =+        first WrongValue (matchText v) >>= first ArbitraryError . parseText++{- | By the given 'BiMap' validates it with the given predicate that returns+'Either' the value, if the validation is successful, or the 'Text' of the error+that should be returned in case of validation failure.++Usually used as the 'Toml.Codec.Combinator.Custom.validate' or+'Toml.Codec.Combinator.Custom.validateIf' combinator.++@since 1.3.0.0+-}+_Validate :: forall a . (a -> Either Text a) -> TomlBiMap a AnyValue -> TomlBiMap a AnyValue+_Validate p BiMap{..} = BiMap forward backwardWithValidation+  where+    backwardWithValidation :: AnyValue -> Either TomlBiMapError a+    backwardWithValidation anyVal = backward anyVal >>= first ArbitraryError . p++{- | Helper 'BiMap' for '_EnumBounded' and 'Data.Text.Text'.++@since 1.1.0.0+-}+_EnumBoundedText :: forall a. (Show a, Enum a, Bounded a) => TomlBiMap a Text+_EnumBoundedText = BiMap+    { forward  = Right . tShow+    , backward = toEnumBounded+    }+  where+    toEnumBounded :: Text -> Either TomlBiMapError a+    toEnumBounded value = case M.lookup value enumOptions of+        Just a  -> Right a+        Nothing ->+            let msg = "Value is '" <> value <> "' but expected one of: " <> T.intercalate ", " options+            in Left (ArbitraryError msg)+      where+        enumOptions :: Map Text a+        enumOptions = M.fromList $ zip options enums+        options  = fmap tShow enums+        enums = [minBound @a .. maxBound @a]++{- | 'BiMap' for nullary sum data types (enumerations) with 'Show',+'Enum' and 'Bounded' instances. Usually used as the+'Toml.Codec.Combinator.Custom.enumBounded' combinator.++@since 1.1.0.0+-}+_EnumBounded :: (Show a, Enum a, Bounded a) => TomlBiMap a AnyValue+_EnumBounded = _EnumBoundedText >>> _Text+{-# INLINE _EnumBounded #-}++----------------------------------------------------------------------------+-- Keys+----------------------------------------------------------------------------++{- | Bidirectional converter between 'Key' and+'Data.Text.Text'. Usually used as an argument for+'Toml.Codec.Combinator.Map.tableMap'.++@since 1.3.0.0+-}+_KeyText :: TomlBiMap Key Text+_KeyText = BiMap+    { forward = Right . prettyKey+    , backward = first (ArbitraryError . unTomlParseError) . parseKey+    }++{- | Bidirectional converter between 'Key' and 'String'. Usually used+as an argument for 'Toml.Codec.Combinator.Map.tableMap'.++@since 1.3.0.0+-}+_KeyString :: TomlBiMap Key String+_KeyString = BiMap+    { forward = Right . T.unpack . prettyKey+    , backward = first (ArbitraryError . unTomlParseError) . parseKey . T.pack+    }++{- | Bidirectional converter between 'Key' and 'Int'. Usually used+as an argument for 'Toml.Codec.Combinator.Map.tableIntMap'.++@since 1.3.0.0+-}+_KeyInt :: TomlBiMap Key Int+_KeyInt = BiMap+    { forward = first (ArbitraryError . T.pack) . readEither . T.unpack . prettyKey+    , backward = first (ArbitraryError . unTomlParseError) . parseKey . tShow+    }++----------------------------------------------------------------------------+-- General purpose bimaps+----------------------------------------------------------------------------++{- | 'BiMap' for 'Either' and its 'Left' part.++@since 0.4.0+-}+_Left :: (Show l, Show r) => TomlBiMap (Either l r) l+_Left = prism Left $ \case+    Left l -> Right l+    x -> wrongConstructor "Left" x++{- | 'BiMap' for 'Either' and its 'Right' part.++@since 0.4.0+-}+_Right :: (Show l, Show r) => TomlBiMap (Either l r) r+_Right = prism Right $ \case+    Right r -> Right r+    x -> wrongConstructor "Right" x++{- | 'BiMap' for 'Maybe' and its 'Just' part.++@since 0.5.0+-}+_Just :: Show r => TomlBiMap (Maybe r) r+_Just = prism Just $ \case+    Just r -> Right r+    x -> wrongConstructor "Just" x

@@ -0,0 +1,122 @@+{- |+Copyright: (c) 2018-2020 Kowainik+SPDX-License-Identifier: MPL-2.0+Maintainer: Kowainik <xrom.xkov@gmail.com>++Conversion from textual representation of @TOML@ values to the Haskell data+types by the given 'TomlCodec'.++This module includes coding functions like 'decode' and 'encode'.+-}++module Toml.Codec.Code+       ( -- * Decode+         decode+       , decodeValidation+       , decodeFileEither+       , decodeFile+         -- * Encode+       , encode+       , encodeToFile+         -- * Run+       , runTomlCodec+       , execTomlCodec+       ) where++import Control.Exception (throwIO)+import Control.Monad.IO.Class (MonadIO (..))+import Data.Text (Text)+import Validation (Validation (..), validationToEither)++import Toml.Codec.Error (LoadTomlException (..), TomlDecodeError (..), prettyTomlDecodeErrors)+import Toml.Codec.Types (Codec (..), TomlCodec, TomlState (..))+import Toml.Parser (parse)+import Toml.Type (TOML (..))+import Toml.Type.Printer (pretty)++import qualified Data.Text.IO as TIO+++{- | Convert textual representation of @TOML@ into user data type by the+provided codec.++@since 1.3.0.0+-}+decodeValidation :: TomlCodec a -> Text -> Validation [TomlDecodeError] a+decodeValidation codec text = case parse text of+    Left err   -> Failure [ParseError err]+    Right toml -> runTomlCodec codec toml++{- | Convert textual representation of @TOML@ into user data type by the+provided codec.++@since 0.0.0+-}+decode :: TomlCodec a -> Text -> Either [TomlDecodeError] a+decode codec = validationToEither . decodeValidation codec++{- | Similar to 'decodeValidation', but takes a path to a file with textual @TOML@+values from which it decodes them with the provided codec.++@since 1.3.0.0+-}+decodeFileValidation+    :: forall a m . (MonadIO m)+    => TomlCodec a+    -> FilePath+    -> m (Validation [TomlDecodeError] a)+decodeFileValidation codec = fmap (decodeValidation codec) . liftIO . TIO.readFile++{- | Similar to 'decode', but takes a path to a file with textual @TOML@+values from which it decodes them with the provided codec.++@since 1.3.0.0+-}+decodeFileEither+    :: forall a m . (MonadIO m)+    => TomlCodec a+    -> FilePath+    -> m (Either [TomlDecodeError] a)+decodeFileEither codec = fmap validationToEither . decodeFileValidation codec++{- | Similar to 'decodeFileEither', throws 'LoadTomlException' in case of parse+errors ('TomlDecodeError').++@since 0.3.1+-}+decodeFile :: forall a m . (MonadIO m) => TomlCodec a -> FilePath -> m a+decodeFile codec filePath = decodeFileEither codec filePath >>= errorWhenLeft+  where+    errorWhenLeft :: Either [TomlDecodeError] a -> m a+    errorWhenLeft (Left errs) =+        liftIO+        $ throwIO+        $ LoadTomlException filePath+        $ prettyTomlDecodeErrors errs+    errorWhenLeft (Right pc) = pure pc++{- | Convert data type to the textual representation of @TOML@ values.++@since 0.0.0+-}+encode :: TomlCodec a -> a -> Text+encode codec obj = pretty $ execTomlCodec codec obj++{- | Convert data type to the textual representation of @TOML@ values.+and write it info the given file.++@since 1.3.0.0+-}+encodeToFile :: forall a m . (MonadIO m) => TomlCodec a -> FilePath -> a -> m Text+encodeToFile codec filePath obj = content <$ liftIO (TIO.writeFile filePath content)+  where+    content :: Text+    content = encode codec obj++-- | Convert toml into user data type.+runTomlCodec :: TomlCodec a -> TOML -> Validation [TomlDecodeError] a+runTomlCodec = codecRead++-- | Runs 'codecWrite' of 'TomlCodec' and returns intermediate TOML AST.+execTomlCodec :: TomlCodec a -> a -> TOML+execTomlCodec codec obj = snd $ unTomlState (codecWrite codec obj) mempty

@@ -0,0 +1,152 @@+{- |+Copyright: (c) 2018-2020 Kowainik+SPDX-License-Identifier: MPL-2.0+Maintainer: Kowainik <xrom.xkov@gmail.com>++Contains TOML-specific combinators for converting between TOML and user data+types.+-}++module Toml.Codec.Combinator+    ( -- * Basic codecs for primitive values+      -- $primitive+      module Toml.Codec.Combinator.Primitive+      -- ** Time types+      -- $time+    , module Toml.Codec.Combinator.Time++      -- * Combinators for tables+      -- $table+    , module Toml.Codec.Combinator.Table++      -- * Codecs for containers of primitives+      -- ** Lists+      -- $list+    , module Toml.Codec.Combinator.List+      -- ** Sets+      -- $set+    , module Toml.Codec.Combinator.Set+      -- ** Maps+      -- $map+    , module Toml.Codec.Combinator.Map+      -- ** Tuples+      -- $tuple+    , module Toml.Codec.Combinator.Tuple++      -- * Codecs for 'Monoid's+      -- $monoid+    , module Toml.Codec.Combinator.Monoid++      -- * Additional codecs for custom types+      -- $custom+    , module Toml.Codec.Combinator.Custom++      -- * General construction of codecs+      -- $common+    , module Toml.Codec.Combinator.Common+    ) where++import Prelude hiding (all, any, last, map, product, read, sum)++import Toml.Codec.Combinator.Common+import Toml.Codec.Combinator.Custom+import Toml.Codec.Combinator.List+import Toml.Codec.Combinator.Map+import Toml.Codec.Combinator.Monoid+import Toml.Codec.Combinator.Primitive+import Toml.Codec.Combinator.Set+import Toml.Codec.Combinator.Table+import Toml.Codec.Combinator.Time+import Toml.Codec.Combinator.Tuple++{- $primitive+TOML-specific combinators for converting between TOML and Haskell primitive+types, e.g. 'int' \<-\> 'Int', 'byteString' \<-\> 'ByteString'.++See the "Toml.Codec.Combinators.Primitive" module documentation for the overview+table and more examples.+-}++{- $time+TOML-specific combinators for converting between TOML and Haskell date and time+data types. TOML specification describes date and time primitives you+can use in your configuration. @tomland@ provides mapping of those+primitives to types from the @time@ library.++See the "Toml.Codec.Combinators.Time" module documentation for the overview+table and more examples.+-}++{- $table+Combinators for the @TOML@ tables.++See the "Toml.Codec.Combinators.Table" module documentation for more examples.+-}++{- $list+TOML-specific combinators for converting between TOML and Haskell list-like data+types.++See the "Toml.Codec.Combinators.List" module documentation for the overview+table and more examples.+-}++{- $set+TOML-specific combinators for converting between TOML and Haskell set-like data+types.++See the "Toml.Codec.Combinators.Set" module documentation for the overview+table and more examples.+-}++{- $map+TOML-specific combinators for converting between TOML and Haskell map-like data+types.++See the "Toml.Codec.Combinators.Map" module documentation for the overview+table and more examples.+-}++{- $tuple+TOML-specific combinators for converting between TOML and Haskell tuples.+It's recommended to create your custom data types and implement codecs+for them, but if you need to have tuples (e.g. for decoding different+constructors of sum types), you can find codecs from this module+helpful.++See the "Toml.Codec.Combinators.Tuple" module documentation for the overview+table and more examples.+-}++{- $monoid+TOML-specific combinators for converting between TOML and Haskell 'Monoid'+wrapper data types. These codecs are especially handy when you are implementing+the [Partial Options Monoid](https://medium.com/@jonathangfischoff/the-partial-options-monoid-pattern-31914a71fc67)+pattern.++See the "Toml.Codec.Combinators.Monoid" module documentation for the overview+table and more examples.+-}++{- $custom+This module provides additional combinators that could help in the situation+when some additional manipulations for the standard combinators is required.++/For example,/ 'validate' allows to perform some custom validation on the codec+before encoding. And 'enumBounded' is an automatical codec that uses 'Enum' and+'Bounded' instances of the data type only and provides descriptive error+messages at the same time.++See the "Toml.Codec.Combinators.Custom" module documentation for the overview+table and more examples.+-}++{- $common+This module implements common utilities for writing custom codecs+without diving into internal implementation details. Most of the time+you don't need to implement your own codecs and can reuse existing+ones. But if you need something that library doesn't provide, you can+find functions in this module useful.++See the "Toml.Codec.Combinators.Common" module documentation for more examples.+-}

@@ -0,0 +1,77 @@+{-# LANGUAGE FlexibleContexts #-}++{- |+Copyright: (c) 2018-2020 Kowainik+SPDX-License-Identifier: MPL-2.0+Maintainer: Kowainik <xrom.xkov@gmail.com>++This module implements common utilities for writing custom codecs+without diving into internal implementation details. Most of the time+you don't need to implement your own codecs and can reuse existing+ones. But if you need something that library doesn't provide, you can+find functions in this module useful.++@since 1.3.0.0+-}++module Toml.Codec.Combinator.Common+    ( match+    , whenLeftBiMapError+    ) where++import Control.Monad.State (modify)+import Validation (Validation (..))++import Toml.Codec.BiMap (BiMap (..), TomlBiMap, TomlBiMapError)+import Toml.Codec.Error (TomlDecodeError (..))+import Toml.Codec.Types (Codec (..), TomlCodec, TomlEnv, TomlState, eitherToTomlState)+import Toml.Type.AnyValue (AnyValue (..))+import Toml.Type.Key (Key)+import Toml.Type.TOML (TOML (..), insertKeyAnyVal)++import qualified Data.HashMap.Strict as HashMap+++{- | General function to create bidirectional converters for key-value pairs. In+order to use this function you need to create 'TomlBiMap' for your type and+'AnyValue':++@+_MyType :: 'TomlBiMap' MyType 'AnyValue'+@++And then you can create codec for your type using 'match' function:++@+myType :: 'Key' -> 'TomlCodec' MyType+myType = 'match' _MyType+@++@since 0.4.0+-}+match :: forall a . TomlBiMap a AnyValue -> Key -> TomlCodec a+match BiMap{..} key = Codec input output+  where+    input :: TomlEnv a+    input = \toml -> case HashMap.lookup key (tomlPairs toml) of+        Nothing     -> Failure [KeyNotFound key]+        Just anyVal -> whenLeftBiMapError key (backward anyVal) pure++    output :: a -> TomlState a+    output a = do+        anyVal <- eitherToTomlState $ forward a+        a <$ modify (insertKeyAnyVal key anyVal)+++{- | Throw error on 'Left', or perform a given action with 'Right'.++@since 1.3.0.0+-}+whenLeftBiMapError+    :: Key+    -> Either TomlBiMapError a+    -> (a -> Validation [TomlDecodeError] b)+    -> Validation [TomlDecodeError] b+whenLeftBiMapError key val action = case val of+    Right a  -> action a+    Left err -> Failure [BiMapError key err]

@@ -0,0 +1,237 @@+{- |+Copyright: (c) 2018-2020 Kowainik+SPDX-License-Identifier: MPL-2.0+Maintainer: Kowainik <xrom.xkov@gmail.com>++Contains TOML-specific custom combinators for converting between TOML and+special user data types.++See examples below of the situations you may need the following combinators.++@since 1.3.0.0+-}++module Toml.Codec.Combinator.Custom+    ( -- * 'Text' combinators+      textBy+    , read+    , enumBounded++      -- * Validation+    , validate+    , validateIf+    ) where++import Prelude hiding (read)++import Data.Text (Text)++import Toml.Codec.BiMap (TomlBiMap)+import Toml.Codec.BiMap.Conversion (_EnumBounded, _Read, _TextBy, _Validate)+import Toml.Codec.Combinator.Common (match)+import Toml.Codec.Types (TomlCodec)+import Toml.Type.AnyValue (AnyValue)+import Toml.Type.Key (Key)+import Toml.Type.Printer (prettyKey)+++{- | Codec for text values with custom error messages for parsing.++__Example:__++We have the following type that represents the image format:++@+__data__ Format+    = Jpeg+    | Png+    | Gif+    __deriving__ ('Show', 'Read', 'Enum')+@++But we want to be able to decode and encode this data type through the custom+text representation, that can be formilised in the following functions:++@+showFormat :: Format -> 'Text'+showFormat = \case+    Jpeg -> ".jpeg"+    Png  -> ".png"+    Gif  -> ".gif"++parseFormat :: 'Text' -> 'Either' 'Text' Format+parseFormat = __\case__+    ".jpeg" -> 'Right' Jpeg+    ".png"  -> 'Right' Png+    ".gif"  -> 'Right' Gif+    other   -> 'Left' $ "Unsupported format: " <> other+@++To write the codec for @Format@ data type using the above rules we can use+'textBy' combinator:++@+formatCodec :: 'Key' -> 'TomlCodec' Format+formatCodec = 'textBy' showFormat parseFormat+@++And now with the @formatCodec "foo"@ we can have the following line in our+@TOML@ perfectly encoded:++@+foo = ".gif"+@++But the @foo = "jif"@ will lead to the following error:++@+tomland decode error:  Unsupported format: jif+@++@since 1.0.0+-}+textBy :: (a -> Text) -> (Text -> Either Text a) -> Key -> TomlCodec a+textBy to from = match (_TextBy to from)+{-# INLINE textBy #-}+++{- | Codec for values with a 'Read' and 'Show' instance.++__Example:__++We have the following type that represents the image format:++@+__data__ Format+    = Jpeg+    | Png+    | Gif+    deriving (Show, Read, Enum)+@++And we want to be able to decode and encode this data type through the 'Show'+and 'Read' instances.++To write the codec for @Format@ data type using the existing instances we can+use 'read' combinator. And now with the @Toml.'read' "foo"@ we can have the+following line in our @TOML@ perfectly encoded:++@+foo = "Gif"+@++But the @foo = ".gif"@ will lead to the following error:++@+tomland decode error:  Prelude.read: no parse+@++@since 0.5.0+-}+read :: (Show a, Read a) => Key -> TomlCodec a+read = match _Read+{-# INLINE read #-}++{- | Codec for general nullary sum data types with a 'Bounded', 'Enum', and+'Show' instance. This codec is similar to 'read' but provides much better error+messages than 'read' for nullary sum types.++E.g. for the same @Format@ example from 'read' function, but with the+@Toml.'enumBounded' "foo"@ codec the error for @foo = \"Jif\"@ in the @TOML@ file+will look like this:++@+tomland decode error:  Value is 'Jif' but expected one of: Jpeg, Png, Gif+@++@since 1.1.0.0+-}+enumBounded :: (Bounded a, Enum a, Show a) => Key -> TomlCodec a+enumBounded = match _EnumBounded+{-# INLINE enumBounded #-}++{- | Codec that checks the 'BiMap' on the given predicate.+The predicate function returns the value, if the validation is successful, or+the 'Text' of the error that should be returned in case of validation failure.++__Example:__++Let's imagine that we want to have the list in @TOML@ that could only+have even 'Int's inside. In this case, you can write the following codec:++@+allEven :: ['Int'] -> 'Either' 'Text' ['Int']+allEven xs =+    if all even xs+    then 'Right' xs+    else 'Left' "This is wrong, I asked you for even only :("++allEvenCodec :: 'TomlCodec' ['Int']+allEvenCodec = Toml.'validate' allEven (Toml._Array Toml._Int) \"myEvenList\"+@++Then in your @TOML@ file you can have:++@+myEvenList = [2, 4, 6]+@++But the following one will lead to the error:++@+myEvenList = [1, 2, 3]+@++@+tomland decode error:  This is wrong, I asked you for even only :(+@++@since 1.3.0.0+-}+validate :: (a -> Either Text a) -> TomlBiMap a AnyValue -> Key -> TomlCodec a+validate p biMap = match (_Validate p biMap)+{-# INLINE validate #-}++{- | Similar to 'validate' but takes the predicate that returnes 'Bool'.+The error in case of the validation failure looks like this:++@+Value does not pass the validation for key: KEY_NAME+@++__Example:__++Let's imagine that we want to have the 'Text' field in @TOML@ that could only+have 3 chars in it. In this case, you can write the following codec:++@+my3charTextCodec :: TomlCodec Text+my3CharTextCodec = Toml.'validateIf' ((==) 3 . Text.length) Toml._Text "myKeyName"+@++The in your @TOML@ file you can have:++@+myKeyName = "abc"+@++But the following one will lead to the error:++@+myKeyName = "I have more than enough"+@++@+tomland decode error:  Value does not pass the validation for key: myKeyName+@++@since 1.3.0.0+-}+validateIf :: forall a . (a -> Bool) -> TomlBiMap a AnyValue -> Key -> TomlCodec a+validateIf p biMap k = validate validateEither biMap k+  where+    validateEither :: a -> Either Text a+    validateEither a =+        if p a+        then Right a+        else Left $ "Value does not pass the validation for key: " <> prettyKey k

@@ -0,0 +1,222 @@+{- |+Copyright: (c) 2018-2020 Kowainik+SPDX-License-Identifier: MPL-2.0+Maintainer: Kowainik <xrom.xkov@gmail.com>++TOML-specific combinators for converting between TOML and Haskell list-like data+types.++There are two way to represent list-like structures with the @tomland@ library.++* Ordinary array lists of primitives:++    @+    foo = [100, 200, 300]+    @++* Lists via tables:++    @+    foo =+        [ {x = 100}+        , {x = 200}+        , {x = 300}+        ]++    __OR__++    [[foo]]+        x = 100+    [[foo]]+        x = 200+    [[foo]]+        x = 300+    @++You can find both types of the codecs in this module for different list-like+structures. See the following table for the better understanding:+++-------------------------+----------------------------------+-------------------------------------++|      Haskell Type       |              @TOML@              |             'TomlCodec'             |++=========================+==================================+=====================================++| __@['Int']@__           | @a = [1, 2, 3]@                  | @'arrayOf' 'Toml._Int' "a"@         |++-------------------------+----------------------------------+-------------------------------------++| __@'NonEmpty' 'Int'@__  | @a = [11, 42]@                   | @'arrayNonEmptyOf' 'Toml._Int' "a"@ |++-------------------------+----------------------------------+-------------------------------------++| __@['Text']@__          | @x = [{a = "foo"}, {a = "bar"}]@ | @'list' ('Toml.text' "a") "x"@      |++-------------------------+----------------------------------+-------------------------------------++| __@'NonEmpty' 'Text'@__ | @x = [{a = "foo"}, {a = "bar"}]@ | @'nonEmpty' ('Toml.text' "a") "x"@  |++-------------------------+----------------------------------+-------------------------------------+++@since 1.3.0.0+-}++module Toml.Codec.Combinator.List+    ( -- * Array lists+      arrayOf+    , arrayNonEmptyOf++      -- * Table lists+    , list+    , nonEmpty+    ) where++import Control.Monad.State (gets, modify)+import Data.List.NonEmpty (NonEmpty (..), toList)+import Validation (Validation (..))++import Toml.Codec.BiMap (TomlBiMap)+import Toml.Codec.BiMap.Conversion (_Array, _NonEmpty)+import Toml.Codec.Code (execTomlCodec)+import Toml.Codec.Combinator.Common (match)+import Toml.Codec.Combinator.Table (handleTableErrors)+import Toml.Codec.Error (TomlDecodeError (..))+import Toml.Codec.Types (Codec (..), TomlCodec, TomlEnv, TomlState)+import Toml.Type.AnyValue (AnyValue (..))+import Toml.Type.Key (Key)+import Toml.Type.TOML (TOML (..), insertTableArrays)++import qualified Data.HashMap.Strict as HashMap+++{- | Codec for list of values. Takes converter for single value and+returns a list of values.++__Example:__++Haskell @['Int']@ can look like this in your @TOML@ file:++@+foo = [1, 2, 3]+@++If the key is not present in @TOML@ the following decode error will be spotted:++@+tomland decode error:  Key foo is not found+@++@since 0.1.0+-}+arrayOf :: TomlBiMap a AnyValue -> Key -> TomlCodec [a]+arrayOf = match . _Array+{-# INLINE arrayOf #-}++{- | Codec for non- empty lists of values. Takes converter for single value and+returns a non-empty list of values.++__Example:__++Haskell @'NonEmpty' 'Int'@ can look like this in your @TOML@ file:++@+foo = [1, 2, 3]+@++If you try to decode an empty @TOML@ list you will see the error:++@+tomland decode error:  Empty array list, but expected NonEmpty+@++If the key is not present in @TOML@ the following decode error will be spotted:++@+tomland decode error:  Key foo is not found+@++@since 0.5.0+-}+arrayNonEmptyOf :: TomlBiMap a AnyValue -> Key -> TomlCodec (NonEmpty a)+arrayNonEmptyOf = match . _NonEmpty+{-# INLINE arrayNonEmptyOf #-}++{- | 'Codec' for list of values. Represented in TOML as array of tables.++__Example:__++Haskell @['Int']@ can look like this in your @TOML@ file:++@+foo =+  [ {a = 1}+  , {a = 2}+  , {a = 3}+  ]+@++Decodes to an empty list @[]@ when the key is not present.++@since 1.0.0+-}+list :: forall a . TomlCodec a -> Key -> TomlCodec [a]+list codec key = Codec+    { codecRead = \toml -> case codecRead nonEmptyCodec toml of+        Success ne -> Success $ toList ne+        Failure [TableArrayNotFound errKey]+            | errKey == key -> pure []+        Failure errs -> Failure errs+    , codecWrite = \case+        [] -> pure []+        l@(x:xs) -> l <$ codecWrite nonEmptyCodec (x :| xs)+    }+  where+    nonEmptyCodec :: TomlCodec (NonEmpty a)+    nonEmptyCodec = nonEmpty codec key+++{- | 'Codec' for 'NonEmpty' list of values. Represented in TOML as array of+tables.++__Example:__++Haskell @'NonEmpty' 'Int'@ can look like this in your @TOML@ file:++@+foo =+  [ {a = 1}+  , {a = 2}+  , {a = 3}+  ]+@++If you try to decode an empty @TOML@ list you will see the error:++@+tomland decode error:  Table array [[foo]] is not found+@++or++@+tomland decode error:  Key foo.a is not found+@++If the key is not present in @TOML@ the following decode error will be spotted:++@+tomland decode error:  Table array [[foo]] is not found+@++@since 1.0.0+-}+nonEmpty :: forall a . TomlCodec a -> Key -> TomlCodec (NonEmpty a)+nonEmpty codec key = Codec input output+  where+    input :: TomlEnv (NonEmpty a)+    input = \t -> case HashMap.lookup key $ tomlTableArrays t of+        Nothing    -> Failure [TableArrayNotFound key]+        Just tomls -> traverse (handleTableErrors codec key) tomls+++    -- adds all TOML objects to the existing list if there are some+    output :: NonEmpty a -> TomlState (NonEmpty a)+    output as = do+        let tomls = fmap (execTomlCodec codec) as+        mTables <- gets $ HashMap.lookup key . tomlTableArrays++        let newTomls = case mTables of+                Nothing       -> tomls+                Just oldTomls -> oldTomls <> tomls++        as <$ modify (insertTableArrays key newTomls)

@@ -0,0 +1,399 @@+{-# LANGUAGE ApplicativeDo   #-}+{-# LANGUAGE PatternSynonyms #-}+{-# LANGUAGE TupleSections   #-}++{- |+Copyright: (c) 2018-2020 Kowainik+SPDX-License-Identifier: MPL-2.0+Maintainer: Kowainik <xrom.xkov@gmail.com>++TOML-specific combinators for converting between TOML and Haskell Map-like data+types.++There are two way to represent map-like structures with the @tomland@ library.++* Map structure with the key and value represented as key-value pairs:++    @+    foo =+        [ {myKey = "name", myVal = 42}+        , {myKey = "otherName", myVal = 100}+        ]+    @++* Map structure as a table with the @TOML@ key as the map key:++    @+    [foo]+        name = 42+        otherName = 100+    @++You can find both types of the codecs in this module for different map-like+structures. See the following table for the heads up:+++------------------------------+--------------------------------+----------------------------------------------------++|         Haskell Type         |             @TOML@             |                    'TomlCodec'                     |++==============================+================================+====================================================++| __@'Map' 'Int' 'Text'@__     | @x = [{k = 42, v = "foo"}]@    | @'map' ('Toml.int' "k") ('Toml.text' "v") "x"@     |++------------------------------+--------------------------------+----------------------------------------------------++| __@'Map' 'Text' 'Int'@__     | @x = {a = 42, b = 11}@         | @'tableMap' 'Toml._KeyText' 'Toml.int' "x"@        |++------------------------------+--------------------------------+----------------------------------------------------++| __@'HashMap' 'Int' 'Text'@__ | @x = [{k = 42, v = "foo"}]@    | @'hashMap' ('Toml.int' "k") ('Toml.text' "v") "x"@ |++------------------------------+--------------------------------+----------------------------------------------------++| __@'HashMap' 'Text' 'Int'@__ | @x = {a = 42, b = 11}@         | @'tableHashMap' 'Toml._KeyText' 'Toml.int' "x"@    |++------------------------------+--------------------------------+----------------------------------------------------++| __@'IntMap' 'Text'@__        | @x = [{k = 42, v = "foo"}]@    | @'intMap' ('Toml.int' "k") ('Toml.text' "v") "x"@  |++------------------------------+--------------------------------+----------------------------------------------------++| __@'IntMap' 'Text'@__        | @x = {1 = "one", 2 = "two"}@   | @'tableIntMap' 'Toml._KeyInt' 'Toml.text' "x"@     |++------------------------------+--------------------------------+----------------------------------------------------+++__Note:__ in case of the missing key on the @TOML@ side an empty map structure+is returned.++@since 1.3.0.0+-}++module Toml.Codec.Combinator.Map+    ( -- * 'Map' codecs+      map+    , tableMap+      -- * 'HashMap' codecs+    , hashMap+    , tableHashMap+      -- * 'IntMap' codecs+    , intMap+    , tableIntMap+    ) where++import Prelude hiding (map)++import Control.Applicative (empty)+import Control.Monad (forM_)+import Control.Monad.State (gets, modify)+import Data.Hashable (Hashable)+import Data.HashMap.Strict (HashMap)+import Data.IntMap.Strict (IntMap)+import Data.List.NonEmpty (NonEmpty (..))+import Data.Map.Strict (Map)+import Data.Maybe (fromMaybe)+import Data.Traversable (for)+import Validation (Validation (..))++import Toml.Codec.BiMap (BiMap (..), TomlBiMap)+import Toml.Codec.Code (execTomlCodec)+import Toml.Codec.Combinator.Common (whenLeftBiMapError)+import Toml.Codec.Types (Codec (..), TomlCodec, TomlEnv, TomlState (..))+import Toml.Type.Key (pattern (:||), Key)+import Toml.Type.TOML (TOML (..), insertTable, insertTableArrays)++import qualified Data.HashMap.Strict as HashMap+import qualified Data.IntMap.Strict as IntMap+import qualified Data.List.NonEmpty as NE+import qualified Data.Map.Strict as Map++import qualified Toml.Type.PrefixTree as Prefix+++{- | Bidirectional codec for 'Map'. It takes birectional converter for keys and+values and produces bidirectional codec for 'Map'. Currently it works only with array+of tables, so you need to specify 'Map's in TOML files like this:++@+myMap =+    [ { name = "foo", payload = 42 }+    , { name = "bar", payload = 69 }+    ]+@++'TomlCodec' for such TOML field can look like this:++@+Toml.'map' (Toml.'text' "name") (Toml.'int' "payload") "myMap"+@++If there's no key with the name @"myMap"@ then empty 'Map' is returned.++@since 1.2.1.0+-}+map :: forall k v .+       Ord k+    => TomlCodec k  -- ^ Codec for 'Map' keys+    -> TomlCodec v  -- ^ Codec for 'Map' values+    -> Key          -- ^ TOML key where 'Map' is stored+    -> TomlCodec (Map k v)  -- ^ Codec for the 'Map'+map = internalMap Map.empty Map.toList Map.fromList++{- | This 'TomlCodec' helps you to convert TOML key-value pairs+directly to 'Map' using TOML keys as 'Map' keys. It can be convenient+if your 'Map' keys are types like 'Text' or 'Int' and you want to work with raw+TOML keys directly.++For example, if you have TOML like this:++@+[colours]+yellow = "#FFFF00"+red    = { red = 255, green = 0, blue = 0 }+pink   = "#FFC0CB"+@++You want to convert such TOML configuration into the following Haskell+types:+++@+__data__ Rgb = Rgb+    { rgbRed   :: Int+    , rgbGreen :: Int+    , rgbBlue  :: Int+    }++__data__ Colour+    = Hex Text+    | RGB Rgb++colourCodec :: 'TomlCodec' Colour+colourCodec = ...++__data__ ColourConfig = ColourConfig+    { configColours :: 'Map' 'Text' Colour+    }+@++And you want in the result to have a 'Map' like this:++@+'Map.fromList'+    [ "yellow" -> Hex "#FFFF00"+    , "pink"   -> Hex "#FFC0CB"+    , "red"    -> Rgb 255 0 0+    ]+@++You can use 'tableMap' to define 'TomlCodec' in the following way:++@+colourConfigCodec :: 'TomlCodec' ColourConfig+colourConfigCodec = ColourConfig+    \<$\> Toml.'tableMap' Toml._KeyText colourCodec "colours" .= configColours+@++__Hint:__ You can use 'Toml.Codec.BiMap._KeyText' or+'Toml.Codec.BiMap._KeyString' to convert betwen TOML keys and 'Map'+keys (or you can write your custom 'TomlBiMap').++__NOTE__: Unlike the 'map' codec, this codec is less flexible (i.e. it doesn't+allow to have arbitrary structures as 'Key's, it works only for+text-like keys), but can be helpful if you want to save a few+keystrokes during TOML configuration. A similar TOML configuration,+but suitable for the 'map' codec will look like this:++@+colours =+    [ { key = "yellow", hex = "#FFFF00" }+    , { key = "pink",   hex = "#FFC0CB" }+    , { key = "red",    rgb = { red = 255, green = 0, blue = 0 } }+    ]+@++@since 1.3.0.0+-}+tableMap+    :: forall k v+    .  Ord k+    => TomlBiMap Key k+    -- ^ Bidirectional converter between TOML 'Key's and 'Map' keys+    -> (Key -> TomlCodec v)+    -- ^ Codec for 'Map' values for the corresponding 'Key'+    -> Key+    -- ^ Table name for 'Map'+    -> TomlCodec (Map k v)+tableMap = internalTableMap Map.empty Map.toList Map.fromList++{- | Bidirectional codec for 'HashMap'. It takes birectional converter for keys and+values and produces bidirectional codec for 'HashMap'. It works with array of+tables, so you need to specify 'HashMap's in TOML files like this:++@+myHashMap =+    [ { name = "foo", payload = 42 }+    , { name = "bar", payload = 69 }+    ]+@++'TomlCodec' for such TOML field can look like this:++@+Toml.'hashMap' (Toml.'text' "name") (Toml.'int' "payload") "myHashMap"+@++If there's no key with the name @"myHashMap"@ then empty 'HashMap' is returned.++@since 1.3.0.0+-}+hashMap+    :: forall k v+    .  (Eq k, Hashable k)+    => TomlCodec k  -- ^ Codec for 'HashMap' keys+    -> TomlCodec v  -- ^ Codec for 'HashMap' values+    -> Key          -- ^ TOML key where 'HashMap' is stored+    -> TomlCodec (HashMap k v)  -- ^ Codec for the 'HashMap'+hashMap = internalMap HashMap.empty HashMap.toList HashMap.fromList++{- | This 'TomlCodec' helps to convert TOML key-value pairs+directly to 'HashMap' using TOML keys as 'HashMap' keys.+It can be convenient if your 'HashMap' keys are types like 'Text' or 'Int' and+you want to work with raw TOML keys directly.++For example, if you can write your 'HashMap' in @TOML@ like this:++@+[myHashMap]+key1 = "value1"+key2 = "value2"+@++@since 1.3.0.0+-}+tableHashMap+    :: forall k v+    .  (Eq k, Hashable k)+    => TomlBiMap Key k+    -- ^ Bidirectional converter between TOML 'Key's and 'HashMap' keys+    -> (Key -> TomlCodec v)+    -- ^ Codec for 'HashMap' values for the corresponding 'Key'+    -> Key+    -- ^ Table name for 'HashMap'+    -> TomlCodec (HashMap k v)+tableHashMap = internalTableMap HashMap.empty HashMap.toList HashMap.fromList++{- | Bidirectional codec for 'IntMap'. It takes birectional converter for keys and+values and produces bidirectional codec for 'IntMap'. It works with array of+tables, so you need to specify 'IntMap's in TOML files like this:++@+myIntMap =+    [ { name = "foo", payload = 42 }+    , { name = "bar", payload = 69 }+    ]+@++'TomlCodec' for such TOML field can look like this:++@+Toml.'intMap' (Toml.'text' "name") (Toml.'int' "payload") "myIntMap"+@++If there's no key with the name @"myIntMap"@ then empty 'IntMap' is returned.++@since 1.3.0.0+-}+intMap+    :: forall v+    .  TomlCodec Int  -- ^ Codec for 'IntMap' keys+    -> TomlCodec v  -- ^ Codec for 'IntMap' values+    -> Key          -- ^ TOML key where 'IntMap' is stored+    -> TomlCodec (IntMap v)  -- ^ Codec for the 'IntMap'+intMap = internalMap IntMap.empty IntMap.toList IntMap.fromList++{- | This 'TomlCodec' helps to convert TOML key-value pairs+directly to 'IntMap' using TOML 'Int' keys as 'IntMap' keys.++For example, if you can write your 'IntMap' in @TOML@ like this:++@+[myIntMap]+1 = "value1"+2 = "value2"+@++@since 1.3.0.0+-}+tableIntMap+    :: forall v+    .  TomlBiMap Key Int+    -- ^ Bidirectional converter between TOML 'Key's and 'IntMap' keys+    -> (Key -> TomlCodec v)+    -- ^ Codec for 'IntMap' values for the corresponding 'Key'+    -> Key+    -- ^ Table name for 'IntMap'+    -> TomlCodec (IntMap v)+tableIntMap = internalTableMap IntMap.empty IntMap.toList IntMap.fromList+++----------------------------------------------------------------------------+-- Internal+----------------------------------------------------------------------------++internalMap :: forall map k v+    .  map  -- ^ empty map+    -> (map -> [(k, v)])  -- ^ toList function+    -> ([(k, v)] -> map)  -- ^ fromList function+    -> TomlCodec k  -- ^ Codec for Map keys+    -> TomlCodec v  -- ^ Codec for Map values+    -> Key          -- ^ TOML key where Map is stored+    -> TomlCodec map  -- ^ Codec for the Map+internalMap emptyMap toListMap fromListMap keyCodec valCodec key = Codec input output+  where+    input :: TomlEnv map+    input = \t -> case HashMap.lookup key $ tomlTableArrays t of+        Nothing -> Success emptyMap+        Just tomls -> fmap fromListMap $ for (NE.toList tomls) $ \toml -> do+            k <- codecRead keyCodec toml+            v <- codecRead valCodec toml+            pure (k, v)++    output :: map -> TomlState map+    output dict = do+        let tomls = fmap+                (\(k, v) -> execTomlCodec keyCodec k <> execTomlCodec valCodec v)+                (toListMap dict)++        mTables <- gets $ HashMap.lookup key . tomlTableArrays++        let updateAction :: TOML -> TOML+            updateAction = case mTables of+                Nothing -> case tomls of+                    []   -> id+                    t:ts -> insertTableArrays key (t :| ts)+                Just (t :| ts) ->+                    insertTableArrays key $ t :| (ts ++ tomls)++        dict <$ modify updateAction++internalTableMap+    :: forall map k v+    .  map  -- ^ empty map+    -> (map -> [(k, v)])  -- ^ toList function+    -> ([(k, v)] -> map)  -- ^ fromList function+    -> TomlBiMap Key k+    -- ^ Bidirectional converter between TOML 'Key's and Map keys+    -> (Key -> TomlCodec v)+    -- ^ Codec for Map values for the corresponding 'Key'+    -> Key+    -- ^ Table name for Map+    -> TomlCodec map+internalTableMap emptyMap toListMap fromListMap keyBiMap valCodec tableName = Codec input output+  where+    input :: TomlEnv map+    input = \t -> case Prefix.lookup tableName $ tomlTables t of+        Nothing -> Success emptyMap+        Just toml ->+            let valKeys = HashMap.keys $ tomlPairs toml+                tableKeys = fmap (:|| []) $ HashMap.keys $ tomlTables toml+            in fmap fromListMap $ for (valKeys <> tableKeys) $ \key ->+                whenLeftBiMapError key (forward keyBiMap key) $ \k ->+                    (k,) <$> codecRead (valCodec key) toml++    output :: map -> TomlState map+    output m = do+        mTable <- gets $ Prefix.lookup tableName . tomlTables+        let toml = fromMaybe mempty mTable+        let (_, newToml) = unTomlState updateMapTable toml+        m <$ modify (insertTable tableName newToml)+      where+        updateMapTable :: TomlState ()+        updateMapTable = forM_ (toListMap m) $ \(k, v) -> case backward keyBiMap k of+            Left _    -> empty+            Right key -> codecWrite (valCodec key) v

@@ -0,0 +1,114 @@+{- |+Copyright: (c) 2018-2020 Kowainik+SPDX-License-Identifier: MPL-2.0+Maintainer: Kowainik <xrom.xkov@gmail.com>++TOML-specific combinators for converting between TOML and Haskell 'Monoid'+wrapper data types. These codecs are especially handy when you are implementing+the [Partial Options Monoid](https://medium.com/@jonathangfischoff/the-partial-options-monoid-pattern-31914a71fc67)+pattern.+++-----------------------+------------+----------------------------+---------------------++|     Haskell Type      |   @TOML@   |        'TomlCodec'         | Default on          |+|                       |            |                            | missing field       |++=======================+============+============================+=====================++| __'All'__             | @a = true@ | @'all' "a"@                | @'All' 'True'@      |++-----------------------+------------+----------------------------+---------------------++| __'Any'__             | @a = true@ | @'any' "a"@                | @'Any' 'False'@     |++-----------------------+------------+----------------------------+---------------------++| __@'Sum' 'Int'@__     | @a = 11@   | @'sum' 'Toml.int' "a"@     | @'Sum' 0@           |++-----------------------+------------+----------------------------+---------------------++| __@'Product' 'Int'@__ | @a = 11@   | @'product' 'Toml.int' "a"@ | @'Product' 1@       |++-----------------------+------------+----------------------------+---------------------++| __@'First' 'Int'@__   | @a = 42@   | @'first' 'Toml.int' "a"@   | @'First' 'Nothing'@ |++-----------------------+------------+----------------------------+---------------------++| __@'Last' 'Bool'@__   | @a = true@ | @'last' 'Toml.bool' "a"@   | @'Last' 'Nothing'@  |++-----------------------+------------+----------------------------+---------------------+++@since 1.3.0.0+-}++module Toml.Codec.Combinator.Monoid+    ( -- * Codecs for 'Monoid's+      -- ** Bool wrappers+      all+    , any+      -- ** 'Num' wrappers+    , sum+    , product+      -- ** 'Maybe' wrappers+    , first+    , last+    ) where++import Prelude hiding (all, any, last, product, sum)++import Data.Monoid (All (..), Any (..), First (..), Last (..), Product (..), Sum (..))++import Toml.Codec.Combinator.Primitive (bool)+import Toml.Codec.Di (dimap, dioptional, diwrap)+import Toml.Codec.Types (TomlCodec)+import Toml.Type.Key (Key)+++{- | Codec for 'All' wrapper for boolean values.+Returns @'All' 'True'@ on missing fields.++Decodes to @'All' 'True'@ when the key is not present.++@since 1.2.1.0+-}+all :: Key -> TomlCodec All+all = dimap (Just . getAll) (maybe mempty All) . dioptional . bool+{-# INLINE all #-}++{- | Codec for 'Any' wrapper for boolean values.+Returns @'Any' 'False'@ on missing fields.++Decodes to @'Any' 'False'@ when the key is not present.++@since 1.2.1.0+-}+any :: Key -> TomlCodec Any+any = dimap (Just . getAny) (maybe mempty Any) . dioptional . bool+{-# INLINE any #-}++{- | Codec for 'Sum' wrapper for given converter's values.++Decodes to @'Sum' 0@ when the key is not present.++@since 1.2.1.0+-}+sum :: (Num a) => (Key -> TomlCodec a) -> Key -> TomlCodec (Sum a)+sum codec = dimap (Just . getSum) (maybe mempty Sum) . dioptional . codec+{-# INLINE sum #-}++{- | Codec for 'Product' wrapper for given converter's values.++Decodes to @'Product' 1@ when the key is not present.++@since 1.2.1.0+-}+product :: (Num a) => (Key -> TomlCodec a) -> Key -> TomlCodec (Product a)+product codec = dimap (Just . getProduct) (maybe mempty Product) . dioptional . codec+{-# INLINE product #-}++{- | Codec for 'First' wrapper for given converter's values.++Decodes to @'First' 'Nothing'@ when the key is not present.++@since 1.2.1.0+-}+first :: (Key -> TomlCodec a) -> Key -> TomlCodec (First a)+first codec = diwrap . dioptional . codec+{-# INLINE first #-}++{- | Codec for 'Last' wrapper for given converter's values.++Decodes to @'Last' 'Nothing'@ when the key is not present.++@since 1.2.1.0+-}+last :: (Key -> TomlCodec a) -> Key -> TomlCodec (Last a)+last codec = diwrap . dioptional . codec+{-# INLINE last #-}

@@ -0,0 +1,205 @@+{- |+Copyright: (c) 2018-2020 Kowainik+SPDX-License-Identifier: MPL-2.0+Maintainer: Kowainik <xrom.xkov@gmail.com>++TOML-specific combinators for converting between TOML and Haskell primitive+types, e.g. 'Int', 'ByteString'.++For the overall picture you can see how different types are represented by+codecs in the following table:+++---------------------------+-----------------+---------------------------++|       Haskell Type        |     @TOML@      |      'TomlCodec'          |++===========================+=================+===========================++| 'Bool'                    | @a = true@      | 'bool' "a"                |++---------------------------+-----------------+---------------------------++| 'Integer'                 | @a = 100@       | 'integer' "a"             |++---------------------------+-----------------+---------------------------++| 'Int'                     | @a = -42@       | 'int' "a"                 |++---------------------------+-----------------+---------------------------++| 'Natural'                 | @a = 11@        | 'natural' "a"             |++---------------------------+-----------------+---------------------------++| 'Word'                    | @a = 1@         | 'word' "a"                |++---------------------------+-----------------+---------------------------++| 'Word8'                   | @a = 1@         | 'word8' "a"               |++---------------------------+-----------------+---------------------------++| 'Double'                  | @a = 36.6@      | 'double' "a"              |++---------------------------+-----------------+---------------------------++| 'Float'                   | @a = -100.09@   | 'float' "a"               |++---------------------------+-----------------+---------------------------++| 'String'                  | @a = \"Hello\"@ | 'string' "a"              |++---------------------------+-----------------+---------------------------++| 'Text'                    | @a = \"Hello\"@ | 'text' "a"                |++---------------------------+-----------------+---------------------------++| Lazy'L.Text'              | @a = \"Hey\"@   | 'lazyText' "a"            |++---------------------------+-----------------+---------------------------++| 'ByteString'              | @a = \"Hello\"@ | 'byteString' "a"          |++---------------------------+-----------------+---------------------------++| Lazy'BL.ByteString'       | @a = \"Hey\"@   | 'lazyByteString' "a"      |++---------------------------+-----------------+---------------------------++| 'ByteString' as Array     | @a = [10, 15]@  | 'byteStringArray' "a"     |++---------------------------+-----------------+---------------------------++| Lazy'ByteString' as Array | @a = [15, 10]@  | 'lazyByteStringArray' "a" |++---------------------------+-----------------+---------------------------+++@since 1.3.0.0+-}++module Toml.Codec.Combinator.Primitive+    ( -- * Boolean+      bool+      -- * Integral numbers+    , integer+    , int+    , natural+    , word+    , word8+      -- * Floating point numbers+    , double+    , float+      -- * Text types+    , string+    , text+    , lazyText+    , byteString+    , lazyByteString+    , byteStringArray+    , lazyByteStringArray+    ) where++import Data.ByteString (ByteString)+import Data.Text (Text)+import Data.Word (Word8)+import Numeric.Natural (Natural)++import Toml.Codec.BiMap.Conversion (_Bool, _ByteString, _ByteStringArray, _Double, _Float, _Int,+                                    _Integer, _LByteString, _LByteStringArray, _LText, _Natural,+                                    _String, _Text, _Word, _Word8)+import Toml.Codec.Combinator.Common (match)+import Toml.Codec.Types (TomlCodec)+import Toml.Type.Key (Key)++import qualified Data.ByteString.Lazy as BL+import qualified Data.Text.Lazy as L+++{- | Codec for boolean values.++@since 0.0.0+-}+bool :: Key -> TomlCodec Bool+bool = match _Bool+{-# INLINE bool #-}++{- | Codec for integer values.++@since 0.1.0+-}+integer :: Key -> TomlCodec Integer+integer = match _Integer+{-# INLINE integer #-}++{- | Codec for integer values.++@since 0.0.0+-}+int :: Key -> TomlCodec Int+int = match _Int+{-# INLINE int #-}++{- | Codec for natural values.++@since 0.5.0+-}+natural :: Key -> TomlCodec Natural+natural = match _Natural+{-# INLINE natural #-}++{- | Codec for word values.++@since 0.5.0+-}+word :: Key -> TomlCodec Word+word = match _Word+{-# INLINE word #-}++{- | Codec for word8 values.++@since 1.2.0.0+-}+word8 :: Key -> TomlCodec Word8+word8 = match _Word8+{-# INLINE word8 #-}++{- | Codec for floating point values with double precision.++@since 0.0.0+-}+double :: Key -> TomlCodec Double+double = match _Double+{-# INLINE double #-}++{- | Codec for floating point values.++@since 0.5.0+-}+float :: Key -> TomlCodec Float+float = match _Float+{-# INLINE float #-}++{- | Codec for string values.++@since 0.4.0+-}+string :: Key -> TomlCodec String+string = match _String+{-# INLINE string #-}++{- | Codec for text values.++@since 0.3.0+-}+text :: Key -> TomlCodec Text+text = match _Text+{-# INLINE text #-}++{- | Codec for lazy text values.++@since 1.0.0+-}+lazyText :: Key -> TomlCodec L.Text+lazyText = match _LText+{-# INLINE lazyText #-}++{- | Codec for text values as 'ByteString'.++@since 0.5.0+-}+byteString :: Key -> TomlCodec ByteString+byteString = match _ByteString+{-# INLINE byteString #-}++{- | Codec for text values as 'BL.ByteString'.++@since 0.5.0+-}+lazyByteString :: Key -> TomlCodec BL.ByteString+lazyByteString = match _LByteString+{-# INLINE lazyByteString #-}++{- | Codec for positive integer array values as 'ByteString'.++@since 1.2.0.0+-}+byteStringArray :: Key -> TomlCodec ByteString+byteStringArray = match _ByteStringArray+{-# INLINE byteStringArray #-}++{- | Codec for positive integer array values as lazy 'ByteString'.++@since 1.2.0.0+-}+lazyByteStringArray :: Key -> TomlCodec BL.ByteString+lazyByteStringArray = match _LByteStringArray+{-# INLINE lazyByteStringArray #-}

@@ -0,0 +1,224 @@+{- |+Copyright: (c) 2018-2020 Kowainik+SPDX-License-Identifier: MPL-2.0+Maintainer: Kowainik <xrom.xkov@gmail.com>++TOML-specific combinators for converting between TOML and Haskell Set-like data+types.++There are two way to represent list-like structures with the @tomland@ library.++* Ordinary array sets of primitives:++    @+    foo = [100, 200, 300]+    @++* Sets via tables:++    @+    foo =+        [ {x = 100}+        , {x = 200}+        , {x = 300}+        ]++    __OR__++    [[foo]]+        x = 100+    [[foo]]+        x = 200+    [[foo]]+        x = 300+    @++You can find both types of the codecs in this module for different set-like+structures. See the following table for the better understanding:+++------------------------+----------------------------------+-------------------------------------++|      Haskell Type      |              @TOML@              |             'TomlCodec'             |++========================+==================================+=====================================++| __@'Set' 'Text'@__     | @a = ["foo", "bar", "baz"]@      | @'arraySetOf' 'Toml._Text' "a"@     |++------------------------+----------------------------------+-------------------------------------++| __'IntSet'__           | @a = [11, 42]@                   | @'arrayIntSet' "a"@                 |++------------------------+----------------------------------+-------------------------------------++| __@'HashSet' 'Text'@__ | @a = ["foo", "bar"]@             | @'arrayHashSetOf' 'Toml._Text' "a"@ |++------------------------+----------------------------------+-------------------------------------++| __@'Set' 'Text'@__     | @x = [{a = "foo"}, {a = "bar"}]@ | @'set' ('Toml.text' "a") "x"@       |++------------------------+----------------------------------+-------------------------------------++| __@'HashSet' 'Text'@__ | @x = [{a = "foo"}, {a = "bar"}]@ | @'hashSet' ('Toml.text' "a") "x"@   |++------------------------+----------------------------------+-------------------------------------+++@since 1.3.0.0+-}++module Toml.Codec.Combinator.Set+    ( -- * Array sets+      arraySetOf+    , arrayIntSet+    , arrayHashSetOf+      -- * Table Sets+    , set+    , intSet+    , hashSet+    ) where++import Data.Hashable (Hashable)+import Data.HashSet (HashSet)+import Data.IntSet (IntSet)+import Data.Set (Set)++import Toml.Codec.BiMap (TomlBiMap)+import Toml.Codec.BiMap.Conversion (_HashSet, _IntSet, _Set)+import Toml.Codec.Combinator.Common (match)+import Toml.Codec.Combinator.List (list)+import Toml.Codec.Di (dimap)+import Toml.Codec.Types (TomlCodec)+import Toml.Type.AnyValue (AnyValue (..))+import Toml.Type.Key (Key)++import qualified Data.HashSet as HS+import qualified Data.IntSet as IS+import qualified Data.Set as S+++{- | Codec for sets. Takes converter for single value and+returns a set of values.++__Example:__++Haskell @'Set' 'Int'@ can look like this in your @TOML@ file:++@+foo = [1, 2, 3]+@++In case of the missing field, the following error will be seen:++@+tomland decode error:  Key foo is not found+@++@since 0.5.0+-}+arraySetOf :: Ord a => TomlBiMap a AnyValue -> Key -> TomlCodec (Set a)+arraySetOf = match . _Set+{-# INLINE arraySetOf #-}++{- | Codec for sets of ints. Takes converter for single value and+returns a set of ints.++__Example:__++Haskell @'IntSet'@ can look like this in your @TOML@ file:++@+foo = [1, 2, 3]+@++In case of the missing field, the following error will be seen:++@+tomland decode error:  Key foo is not found+@++@since 0.5.0+-}+arrayIntSet :: Key -> TomlCodec IntSet+arrayIntSet = match _IntSet+{-# INLINE arrayIntSet #-}++{- | Codec for hash sets. Takes converter for single hashable value and+returns a set of hashable values.++__Example:__++Haskell @'HashSet' 'Int'@ can look like this in your @TOML@ file:++@+foo = [1, 2, 3]+@++In case of the missing field, the following error will be seen:++@+tomland decode error:  Key foo is not found+@++@since 0.5.0+-}+arrayHashSetOf+    :: (Hashable a, Eq a)+    => TomlBiMap a AnyValue+    -> Key+    -> TomlCodec (HashSet a)+arrayHashSetOf = match . _HashSet+{-# INLINE arrayHashSetOf #-}++----------------------------------------------------------------------------+-- Tables and arrays of tables+----------------------------------------------------------------------------++{- | 'Codec' for set of values. Represented in TOML as array of tables.++__Example:__++Haskell @'Set' 'Int'@ can look like this in your @TOML@ file:++@+foo =+  [ {a = 1}+  , {a = 2}+  ]+@++Decodes to an empty 'Set' in case of the missing field in @TOML@.++@since 1.2.0.0+-}+set :: forall a . Ord a => TomlCodec a -> Key -> TomlCodec (Set a)+set codec key = dimap S.toList S.fromList (list codec key)+{-# INLINE set #-}++{- | 'Codec' for 'IntSet'. Represented in TOML as an array of tables.++__Example:__++Haskell 'IntSet' can look like this in your @TOML@ file:++@+foo =+  [ {a = 1}+  , {a = 2}+  ]+@++Decodes to an empty 'IntSet' in case of the missing field in @TOML@.++@since 1.3.0.0+-}+intSet :: TomlCodec Int -> Key -> TomlCodec IntSet+intSet codec key = dimap IS.toList IS.fromList (list codec key)+{-# INLINE intSet #-}++{- | 'Codec' for 'HashSet' of values. Represented in TOML as an array of tables.++__Example:__++Haskell @'HashSet' 'Int'@ can look like this in your @TOML@ file:++@+foo =+  [ {a = 1}+  , {a = 2}+  ]+@++Decodes to an empty 'HashSet' in case of the missing field in @TOML@.++@since 1.2.0.0+-}+hashSet :: forall a . (Hashable a, Eq a) => TomlCodec a -> Key -> TomlCodec (HashSet a)+hashSet codec key = dimap HS.toList HS.fromList (list codec key)+{-# INLINE hashSet #-}

@@ -0,0 +1,92 @@+{- |+Copyright: (c) 2018-2020 Kowainik+SPDX-License-Identifier: MPL-2.0+Maintainer: Kowainik <xrom.xkov@gmail.com>++Contains TOML-specific combinators for converting between TOML and user data+types.++Tables can be represented in @TOML@ in one of the following ways:++@+foo =+    { x = ...+    , y = ...+    , ...+    }+@++__Or__++@+[foo]+    x = ...+    y = ...+    ...+@++@since 1.3.0.0+-}++module Toml.Codec.Combinator.Table+    ( -- * Tables+      table+      -- * Error Helpers+    , handleTableErrors+    , mapTableErrors+    ) where++import Control.Monad.State (gets, modify)+import Data.Maybe (fromMaybe)+import Validation (Validation (..))++import Toml.Codec.Error (TomlDecodeError (..))+import Toml.Codec.Types (Codec (..), TomlCodec, TomlEnv, TomlState (..))+import Toml.Type.Key (Key)+import Toml.Type.TOML (TOML (..), insertTable)++import qualified Toml.Type.PrefixTree as Prefix++++{- | Maps errors in tables with 'mapTableErrors'++@since 1.3.0.0+-}+handleTableErrors :: TomlCodec a -> Key -> TOML -> Validation [TomlDecodeError] a+handleTableErrors codec key toml = case codecRead codec toml of+    Success res  -> Success res+    Failure errs -> Failure $ mapTableErrors key errs++{- | Prepends given key to all errors that contain key. This function is used to+give better error messages. So when error happens we know all pieces of table+key, not only the last one.++@since 0.2.0+-}+mapTableErrors :: Key -> [TomlDecodeError] -> [TomlDecodeError]+mapTableErrors key = map (\case+    KeyNotFound name        -> KeyNotFound (key <> name)+    TableNotFound name      -> TableNotFound (key <> name)+    TableArrayNotFound name -> TableArrayNotFound (key <> name)+    e                       -> e+    )++{- | Codec for tables. Use it when when you have nested objects.++@since 0.2.0+-}+table :: forall a . TomlCodec a -> Key -> TomlCodec a+table codec key = Codec input output+  where+    input :: TomlEnv a+    input = \t -> case Prefix.lookup key $ tomlTables t of+        Nothing   -> Failure [TableNotFound key]+        Just toml -> handleTableErrors codec key toml++    output :: a -> TomlState a+    output a = do+        mTable <- gets $ Prefix.lookup key . tomlTables+        let toml = fromMaybe mempty mTable+        let (_, newToml) = unTomlState (codecWrite codec a) toml+        a <$ modify (insertTable key newToml)

@@ -0,0 +1,71 @@+{- |+Copyright: (c) 2018-2020 Kowainik+SPDX-License-Identifier: MPL-2.0+Maintainer: Kowainik <xrom.xkov@gmail.com>++TOML-specific combinators for converting between TOML and Haskell date and time+data types. TOML specification describes date and time primitives you+can use in your configuration. @tomland@ provides mapping of those+primitives to types from the @time@ library.+++-----------------+----------------------------+-------------------++|  Haskell Type   |           @TOML@           |    'TomlCodec'    |++=================+============================+===================++| __'ZonedTime'__ | @a = 2020-05-16T04:32:00Z@ | @'zonedTime' "a"@ |++-----------------+----------------------------+-------------------++| __'LocalTime'__ | @a = 2020-05-16T04:32:00@  | @'localTime' "a"@ |++-----------------+----------------------------+-------------------++| __'Day'__       | @a = 2020-05-16@           | @'day' "a"@       |++-----------------+----------------------------+-------------------++| __'TimeOfDay'__ | @a = 04:32:00@             | @'timeOfDay' "a"@ |++-----------------+----------------------------+-------------------+++@since 1.3.0.0+-}++module Toml.Codec.Combinator.Time+    ( zonedTime+    , localTime+    , day+    , timeOfDay+    ) where++import Data.Time (Day, LocalTime, TimeOfDay, ZonedTime)++import Toml.Codec.BiMap.Conversion (_Day, _LocalTime, _TimeOfDay, _ZonedTime)+import Toml.Codec.Combinator.Common (match)+import Toml.Codec.Types (TomlCodec)+import Toml.Type.Key (Key)+++{- | Codec for zoned time values.++@since 0.5.0+-}+zonedTime :: Key -> TomlCodec ZonedTime+zonedTime = match _ZonedTime+{-# INLINE zonedTime #-}++{- | Codec for local time values.++@since 0.5.0+-}+localTime :: Key -> TomlCodec LocalTime+localTime = match _LocalTime+{-# INLINE localTime #-}++{- | Codec for day values.++@since 0.5.0+-}+day :: Key -> TomlCodec Day+day = match _Day+{-# INLINE day #-}++{- | Codec for time of day values.++@since 0.5.0+-}+timeOfDay :: Key -> TomlCodec TimeOfDay+timeOfDay = match _TimeOfDay+{-# INLINE timeOfDay #-}

@@ -0,0 +1,100 @@+{- |+Copyright: (c) 2018-2020 Kowainik+SPDX-License-Identifier: MPL-2.0+Maintainer: Kowainik <xrom.xkov@gmail.com>++TOML-specific combinators for converting between TOML and Haskell tuples.+It's recommended to create your custom data types and implement codecs+for them, but if you need to have tuples (e.g. for decoding different+constructors of sum types), you can find codecs from this module+helpful.+++-------------------------------+---------------+------------------------++|         Haskell Type          |    @TOML@     |   'TomlCodec'          |++===============================+===============+========================++| __@('Int', 'Text')@__         | @[foo]@       | @'pair'@               |++-------------------------------+---------------+------------------------++|                               | @    a = 42@  | @    ('Toml.int' "a")@ |++-------------------------------+---------------+------------------------++|                               |@    b = "bar"@| @    ('Toml.text' "b")@|++-------------------------------+---------------+------------------------++| __@('Int', 'Text', 'Bool')@__ | @[foo]@       | @'triple'@             |++-------------------------------+---------------+------------------------++|                               | @    a = 42@  | @    ('Toml.int' "a")@ |++-------------------------------+---------------+------------------------++|                               |@    b = "bar"@| @    ('Toml.text' "b")@|++-------------------------------+---------------+------------------------++|                               |@    c = false@| @    ('Toml.bool' "c")@|++-------------------------------+---------------+------------------------+++@since 1.3.0.0+-}++module Toml.Codec.Combinator.Tuple+    ( pair+    , triple+    ) where++import Toml.Codec.Di ((.=))+import Toml.Codec.Types (TomlCodec)+++{- | Codec for pair of values. Takes codecs for the first and for the second+values of the pair.++If I have the following @TOML@ entry++@+myPair = { first = 11, second = "eleven"}+@++and want to convert it into the Haskell tuple of two elements, I can use the+following codec:++@+myPairCodec :: 'TomlCodec' ('Int', 'Text')+myPairCodec = flip Toml.'table' \"myPair\" $ Toml.'pair'+    (Toml.'int' \"first\")+    (Toml.'text' \"second\")+@++@since 1.3.0.0+-}+pair :: TomlCodec a -> TomlCodec b -> TomlCodec (a, b)+pair aCodec bCodec = (,)+    <$> aCodec .= fst+    <*> bCodec .= snd+{-# INLINE pair #-}++{- | Codec for triple of values. Takes codecs for the first, second and third+values of the triple.++If I have the following @TOML@ entry++@+myTriple =+    { first = 11+    , second = "eleven"+    , isMyFavourite = true+    }+@++and want to convert it into the Haskell tuple of three elements, I can use the+following codec:++@+myTripleCodec :: 'TomlCodec' ('Int', 'Text', 'Bool')+myTripleCodec = flip Toml.'table' \"myTriple\" $ Toml.'triple'+    (Toml.'int' \"first\")+    (Toml.'text' \"second\")+    (Toml.'bool' \"isMyFavourite\")+@++@since 1.3.0.0+-}+triple :: TomlCodec a -> TomlCodec b -> TomlCodec c -> TomlCodec (a, b, c)+triple aCodec bCodec cCodec = (,,)+    <$> aCodec .= (\(a, _, _) -> a)+    <*> bCodec .= (\(_, b, _) -> b)+    <*> cCodec .= (\(_, _, c) -> c)+{-# INLINE triple #-}

@@ -0,0 +1,210 @@+{- |+Copyright: (c) 2018-2020 Kowainik+SPDX-License-Identifier: MPL-2.0+Maintainer: Kowainik <xrom.xkov@gmail.com>++Forward and backward mapping functions and combinators (similar to profunctors).++@since 1.3.0.0+-}++module Toml.Codec.Di+    ( dimap+    , dioptional+    , diwrap+    , dimatch+    , (.=)+    ) where++import Control.Applicative (Alternative (..))+import Data.Coerce (Coercible, coerce)++import Toml.Codec.Types (Codec (..), TomlCodec, (<!>))+++{- | This is an instance of @Profunctor@ for 'Codec'. But since there's no+@Profunctor@ type class in @base@ or package with no dependencies (and we don't+want to bring extra dependencies) this instance is implemented as a single+top-level function.++Useful when you want to parse @newtype@s. For example, if you had data type like+this:++@+__data__ Example = Example+    { foo :: Bool+    , bar :: Text+    }+@++Bidirectional TOML converter for this type will look like this:++@+exampleCodec :: TomlCodec Example+exampleCodec = Example+    \<$\> Toml.bool "foo" '.=' foo+    \<*\> Toml.text "bar" '.=' bar+@++Now if you change your type in the following way:++@+__newtype__ Email = Email { unEmail :: Text }++__data__ Example = Example+    { foo :: Bool+    , bar :: Email+    }+@++you need to patch your TOML codec like this:++@+exampleCodec :: TomlCodec Example+exampleCodec = Example+    \<$\> Toml.bool "foo" '.=' foo+    \<*\> 'dimap' unEmail Email (Toml.text "bar") '.=' bar+@++@since 0.2.0+-}+dimap+    :: (b -> a)    -- ^ Mapper for consumer+    -> (a -> b)  -- ^ Mapper for producer+    -> TomlCodec a  -- ^ Source 'Codec' object+    -> TomlCodec b  -- ^ Target 'Codec' object+dimap f g codec = Codec+    { codecRead  = fmap g . codecRead codec+    , codecWrite = fmap g . codecWrite codec . f+    }+{-# INLINE dimap #-}++{- | Bidirectional converter for @Maybe a@ values. For example, given the data+type:++@+__data__ Example = Example+    { foo :: Bool+    , bar :: Maybe Int+    }+@++the TOML codec will look like++@+exampleCodec :: TomlCodec Example+exampleCodec = Example+    \<$\> Toml.bool "foo" '.=' foo+    \<*\> 'dioptional' (Toml.int "bar") '.=' bar+@++@since 0.5.0+-}+dioptional+    :: TomlCodec a+    -> TomlCodec (Maybe a)+dioptional Codec{..} = Codec+    { codecRead  = fmap Just . codecRead <!> \_ -> pure Nothing+    , codecWrite = traverse codecWrite+    }+{-# INLINE dioptional #-}++{- | Combinator used for @newtype@ wrappers. For example, given the data types:++@+__newtype__ N = N Int++__data__ Example = Example+    { foo :: Bool+    , bar :: N+    }+@++the TOML codec can look like++@+exampleCodec :: TomlCodec Example+exampleCodec = Example+    \<$\> Toml.bool "foo" '.=' foo+    \<*\> 'diwrap' (Toml.int "bar") '.=' bar+@++@since 1.0.0+-}+diwrap+    :: forall b a .+       (Coercible a b)+    => TomlCodec a+    -> TomlCodec b+diwrap = coerce+{-# INLINE diwrap #-}++{- | Bidirectional converter for @sum types@. For example, given the data+type:++@+__data__ Example+    = Foo Int+    | Bar Bool Int+@++the TOML codec will look like++@+matchFoo :: Example -> Maybe Int+matchFoo (Foo num) = Just num+matchFoo _         = Nothing++matchBar :: Example -> Maybe (Bool, Int)+matchBar (Bar b num) = Just (b, num)+matchBar _           = Nothing++barCodec :: TomlCodec (Bool, Int)+barCodec = Toml.pair+    (Toml.bool "a")+    (Toml.int "b")++exampleCodec :: TomlCodec Example+exampleCodec =+    dimatch matchFoo Foo (Toml.int "foo")+    \<|\> dimatch matchBar (uncurry Bar) (Toml.table barCodec "bar")+@++@since 1.2.0.0+-}+dimatch+    :: (b -> Maybe a)  -- ^ Mapper for consumer+    -> (a -> b)     -- ^ Mapper for producer+    -> TomlCodec a  -- ^ Source 'Codec' object+    -> TomlCodec b  -- ^ Target 'Codec' object+dimatch match ctor codec = Codec+    { codecRead = fmap ctor . codecRead codec+    , codecWrite = \c -> case match c of+        Nothing -> empty+        Just d  -> ctor <$> codecWrite codec d+    }+{-# INLINE dimatch #-}++{- | Operator to connect two operations:++1. How to get field from object?+2. How to write this field to toml?++In code this should be used like this:++@+__data__ Foo = Foo+    { fooBar :: Int+    , fooBaz :: String+    }++fooCodec :: TomlCodec Foo+fooCodec = Foo+    \<$\> Toml.int "bar" '.=' fooBar+    \<*\> Toml.str "baz" '.=' fooBaz+@+-}+infixl 5 .=+(.=) :: Codec field a -> (object -> field) -> Codec object a+codec .= getter = codec { codecWrite = codecWrite codec . getter }+{-# INLINE (.=) #-}

@@ -0,0 +1,85 @@+{-# LANGUAGE DeriveAnyClass #-}++{- |+Copyright: (c) 2018-2020 Kowainik+SPDX-License-Identifier: MPL-2.0+Maintainer: Kowainik <xrom.xkov@gmail.com>++Core error types, including 'TomlDecodeError' and 'LoadTomlException'.++@since 1.3.0.0+-}++module Toml.Codec.Error+    ( TomlDecodeError (..)+    , prettyTomlDecodeErrors+    , prettyTomlDecodeError++    , LoadTomlException (..)+    ) where++import Control.DeepSeq (NFData)+import Control.Exception (Exception)+import Data.Text (Text)+import GHC.Generics (Generic)++import Toml.Codec.BiMap (TomlBiMapError, prettyBiMapError)+import Toml.Parser (TomlParseError (..))+import Toml.Type.Key (Key (..))+import Toml.Type.Printer (prettyKey)++import qualified Data.Text as Text+++{- | Type of exception for converting from TOML to user custom data type.++@since 1.3.0.0+-}+data TomlDecodeError+    = BiMapError !Key !TomlBiMapError+    | KeyNotFound !Key  -- ^ No such key+    | TableNotFound !Key  -- ^ No such table+    | TableArrayNotFound !Key+      {- ^ No such table array++      @since 1.3.0.0+      -}+    | ParseError !TomlParseError  -- ^ Exception during parsing+    deriving stock (Show, Eq, Generic)+    deriving anyclass (NFData)++{- | Converts 'TomlDecodeError's into pretty human-readable text.++@since 1.3.0.0+-}+prettyTomlDecodeErrors :: [TomlDecodeError] -> Text+prettyTomlDecodeErrors errs = Text.unlines $+    ("tomland errors number: " <> Text.pack (show $ length errs))+    : map prettyTomlDecodeError errs++{- | Converts 'TomlDecodeError' into pretty human-readable text.++@since 1.3.0.0+-}+prettyTomlDecodeError :: TomlDecodeError -> Text+prettyTomlDecodeError de = "tomland decode error:  " <> case de of+    BiMapError name biError -> "BiMap error in key '" <> prettyKey name <> "' : "+        <> prettyBiMapError biError+    KeyNotFound name -> "Key " <> prettyKey name <> " is not found"+    TableNotFound name -> "Table [" <> prettyKey name <> "] is not found"+    TableArrayNotFound name -> "Table array [[" <> prettyKey name <> "]] is not found"+    ParseError (TomlParseError msg) ->+        "Parse error during conversion from TOML to custom user type: \n  " <> msg++{- | File loading error data type.++@since 0.3.1+-}+data LoadTomlException = LoadTomlException !FilePath !Text++-- | @since 0.3.1+instance Show LoadTomlException where+    show (LoadTomlException filePath msg) = "Couldnt parse file " ++ filePath ++ ": " ++ show msg++-- | @since 0.3.1+instance Exception LoadTomlException

@@ -0,0 +1,776 @@+{-# LANGUAGE AllowAmbiguousTypes  #-}+{-# LANGUAGE DataKinds            #-}+{-# LANGUAGE FlexibleContexts     #-}+{-# LANGUAGE FlexibleInstances    #-}+{-# LANGUAGE GADTs                #-}+{-# LANGUAGE PolyKinds            #-}+{-# LANGUAGE Rank2Types           #-}+{-# LANGUAGE TypeOperators        #-}+{-# LANGUAGE TypeSynonymInstances #-}+{-# LANGUAGE UndecidableInstances #-}++{- |+Copyright: (c) 2018-2020 Kowainik+SPDX-License-Identifier: MPL-2.0+Maintainer: Kowainik <xrom.xkov@gmail.com>++This module contains implementation of the 'Generic' TOML codec. If your+data types are big and nested, and you want to have codecs for them without writing a lot of+boilerplate code, you can find this module helpful. Below you can find the detailed+explanation on how the 'Generic' codecs work.++Consider the following Haskell data types:++@+__data__ User = User+    { age     :: Int+    , address :: Address+    , socials :: [Social]+    } __deriving__ ('Generic')++__data__ Address = Address+    { street :: Text+    , house  :: Int+    } __deriving__ ('Generic')++__data__ Social = Social+    { name :: Text+    , link :: Text+    } __deriving__ ('Generic')+@++Value of the @User@ type represents the following TOML:++@+age = 27++[address]+  street = "Miami Beach"+  house  = 42++[[socials]]+  name = \"Twitter\"+  link = "https://twitter.com/foo"++[[socials]]+  name = \"GitHub\"+  link = "https://github.com/bar"+@++Normally you would write 'TomlCodec' for this data type like this:++@+userCodec :: 'TomlCodec' User+userCodec = User+    \<$\> Toml.int "age" .= age+    \<*\> Toml.table addressCodec "address" .= address+    \<*\> Toml.list  socialCodec  "socials" .= socials++addressCodec :: 'TomlCodec' Address+addressCodec = Address+    \<$\> Toml.text "street" .= street+    \<*\> Toml.int  "house"  .= house++socialCodec :: 'TomlCodec' Social+socialCodec = Social+    \<$\> Toml.text "name" .= name+    \<*\> Toml.text "link" .= link+@++However, if you derive 'Generic' instance for your data types (as we do in the+example), you can write your codecs in a simpler way.++@+userCodec :: 'TomlCodec' User+userCodec = 'genericCodec'++__instance__ 'HasCodec' Address __where__+    hasCodec = Toml.table 'genericCodec'++__instance__ 'HasItemCodec' Social __where__+    hasItemCodec = Right 'genericCodec'+@++Several notes about the interface:++1. Your top-level data types are always implemented as 'genericCodec' (or other+generic codecs).+2. If you have a custom data type as a field of another type, you need to implement+the instance of the 'HasCodec' typeclass.+3. If the data type appears as an element of a list, you need to implement the instance+of the 'HasItemCodec' typeclass.++@since 1.1.0.0+-}++module Toml.Codec.Generic+       ( genericCodec+       , genericCodecWithOptions+       , stripTypeNameCodec++         -- * Options+       , TomlOptions (..)+       , GenericOptions (..)+       , stripTypeNameOptions+       , stripTypeNamePrefix++         -- * Core generic typeclass+       , HasCodec (..)+       , HasItemCodec (..)+       , GenericCodec (..)++         -- * 'ByteString' newtypes+         -- $bytestring+       , ByteStringAsText (..)+       , ByteStringAsBytes (..)+       , LByteStringAsText (..)+       , LByteStringAsBytes (..)++         -- * Deriving Via+       , TomlTable (..)+       ) where++import Data.ByteString (ByteString)+import Data.Char (isLower, toLower)+import Data.Coerce (coerce)+import Data.Hashable (Hashable)+import Data.HashMap.Strict (HashMap)+import Data.HashSet (HashSet)+import Data.IntMap.Strict (IntMap)+import Data.IntSet (IntSet)+import Data.Kind (Type)+import Data.List (stripPrefix)+import Data.List.NonEmpty (NonEmpty)+import Data.Map.Strict (Map)+import Data.Monoid (All (..), Any (..), First (..), Last (..), Product (..), Sum (..))+import Data.Proxy (Proxy (..))+import Data.Set (Set)+import Data.String (IsString (..))+import Data.Text (Text)+import Data.Time (Day, LocalTime, TimeOfDay, ZonedTime)+import Data.Typeable (Typeable, typeRep)+import Data.Word (Word8)+import GHC.Generics ((:*:) (..), (:+:), C1, D1, Generic (..), K1 (..), M1 (..), Rec0, S1,+                     Selector (..))+import GHC.TypeLits (ErrorMessage (..), TypeError)+import Numeric.Natural (Natural)++import Toml.Codec.BiMap (TomlBiMap)+import Toml.Codec.Di (diwrap, (.=))+import Toml.Codec.Types (TomlCodec)+import Toml.Type.AnyValue (AnyValue)+import Toml.Type.Key (Key)++import qualified Data.ByteString.Lazy as LBS+import qualified Data.Text.Lazy as L++import qualified Toml.Codec.BiMap.Conversion as Toml+import qualified Toml.Codec.Combinator as Toml+import qualified Toml.Codec.Di as Toml+++{- | Generic codec for arbitrary data types. Uses field names as keys.++@since 1.1.0.0+-}+genericCodec :: (Generic a, GenericCodec (Rep a)) => TomlCodec a+genericCodec = Toml.dimap from to $ genericTomlCodec (GenericOptions id)+{-# INLINE genericCodec #-}++{- | Generic codec with options for arbitrary data types.++@since 1.1.0.0+-}+genericCodecWithOptions+    :: forall a+     . (Generic a, GenericCodec (Rep a), Typeable a)+    => TomlOptions a+    -> TomlCodec a+genericCodecWithOptions = Toml.dimap from to . genericTomlCodec . toGenericOptions @a+{-# INLINE genericCodecWithOptions #-}++{- | Generic codec that uses 'stripTypeNameOptions'.++@since 1.1.0.0+-}+stripTypeNameCodec+    :: forall a+     . (Generic a, GenericCodec (Rep a), Typeable a)+    => TomlCodec a+stripTypeNameCodec = genericCodecWithOptions $ stripTypeNameOptions @a+{-# INLINE stripTypeNameCodec #-}++----------------------------------------------------------------------------+-- Generic typeclasses+----------------------------------------------------------------------------++{- | Options to configure various parameters of generic encoding. Specifically:++*  __'tomlOptionsFieldModifier'__: how to translate field names to TOML keys?++@since 1.1.0.0+-}+data TomlOptions a = TomlOptions+    { tomlOptionsFieldModifier :: Typeable a => Proxy a -> String -> String+    }++{- | Same as 'TomlOptions' but with all data type information erased. This data+type is used internally. Define your options using 'TomlOptions' data type.++@since 1.1.0.0+-}+newtype GenericOptions = GenericOptions+    { genericOptionsFieldModifier :: String -> String+    }++toGenericOptions :: forall a . Typeable a => TomlOptions a -> GenericOptions+toGenericOptions TomlOptions{..} = GenericOptions+    { genericOptionsFieldModifier = tomlOptionsFieldModifier (Proxy @a)+    }++{- | Options that use 'stripTypeNamePrefix' as 'tomlOptionsFieldModifier'.++@since 1.1.0.0+-}+stripTypeNameOptions :: Typeable a => TomlOptions a+stripTypeNameOptions = TomlOptions+    { tomlOptionsFieldModifier = stripTypeNamePrefix+    }++{- | Strips name of the type name from field name prefix.++>>> data UserData = UserData { userDataId :: Int, userDataShortInfo :: Text }+>>> stripTypeNamePrefix (Proxy @UserData) "userDataId"+"id"+>>> stripTypeNamePrefix (Proxy @UserData) "userDataShortInfo"+"shortInfo"+>>> stripTypeNamePrefix (Proxy @UserData) "udStats"+"stats"+>>> stripTypeNamePrefix (Proxy @UserData) "fooBar"+"bar"+>>> stripTypeNamePrefix (Proxy @UserData) "name"+"name"++@since 1.1.0.0+-}+stripTypeNamePrefix :: forall a . Typeable a => Proxy a -> String -> String+stripTypeNamePrefix _ fieldName =+    case stripPrefix (headToLower $ typeName @a) fieldName of+        Just rest -> leaveIfEmpty rest+        Nothing   -> leaveIfEmpty (dropWhile isLower fieldName)+  where+    headToLower :: String -> String+    headToLower = \case+        []   -> error "Cannot use 'headToLower' on empty Text"+        x:xs -> toLower x : xs++    -- if all lower case then leave field as it is+    leaveIfEmpty :: String -> String+    leaveIfEmpty rest = if null rest then fieldName else headToLower rest++typeName :: forall a . Typeable a => String+typeName = show $ typeRep (Proxy @a)++----------------------------------------------------------------------------+-- Generic typeclasses+----------------------------------------------------------------------------++{- | Helper class to derive TOML codecs generically.++@since 1.1.0.0+-}+class GenericCodec (f :: k -> Type) where+    genericTomlCodec :: GenericOptions -> TomlCodec (f p)++-- | @since 1.1.0.0+instance GenericCodec f => GenericCodec (D1 d f) where+    genericTomlCodec = Toml.dimap unM1 M1 . genericTomlCodec+    {-# INLINE genericTomlCodec #-}++type GenericSumTomlNotSupported =+    'Text "Generic TOML deriving for arbitrary sum types is not supported currently."++-- | @since 1.1.0.0+instance (TypeError GenericSumTomlNotSupported) => GenericCodec (f :+: g) where+    genericTomlCodec = error "Not supported"++-- | @since 1.1.0.0+instance GenericCodec f => GenericCodec (C1 c f) where+    genericTomlCodec = Toml.dimap unM1 M1 . genericTomlCodec+    {-# INLINE genericTomlCodec #-}++-- | @since 1.1.0.0+instance (GenericCodec f, GenericCodec g) => GenericCodec (f :*: g) where+    genericTomlCodec options = (:*:)+        <$> genericTomlCodec options .= fstG+        <*> genericTomlCodec options .= sndG+      where+        fstG :: (f :*: g) p -> f p+        fstG (f :*: _) = f++        sndG :: (f :*: g) p -> g p+        sndG (_ :*: g) = g+    {-# INLINE genericTomlCodec #-}++-- | @since 1.1.0.0+instance (Selector s, HasCodec a) => GenericCodec (S1 s (Rec0 a)) where+    genericTomlCodec GenericOptions{..} = genericWrap $ hasCodec @a fieldName+      where+        genericWrap :: TomlCodec a -> TomlCodec (S1 s (Rec0 a) p)+        genericWrap = Toml.dimap (unK1 . unM1) (M1 . K1)++        fieldName :: Key+        fieldName =+            fromString+            $ genericOptionsFieldModifier+            $ selName (error "S1" :: S1 s Proxy ())+    {-# INLINE genericTomlCodec #-}++----------------------------------------------------------------------------+-- Helper typeclasses+----------------------------------------------------------------------------++{- | This typeclass tells how the data type should be coded as an item of a+list. Lists in TOML can have two types: __primitive__ and __table of arrays__.++* If 'hasItemCodec' returns 'Left': __primitive__ arrays codec is used.+* If 'hasItemCodec' returns 'Right:' __table of arrays__ codec is used.++@since 1.1.0.0+-}+class HasItemCodec a where+    hasItemCodec :: Either (TomlBiMap a AnyValue) (TomlCodec a)++-- | @since 1.1.0.0+instance HasItemCodec Bool where+    hasItemCodec = Left Toml._Bool+    {-# INLINE hasItemCodec #-}++-- | @since 1.1.0.0+instance HasItemCodec Int where+    hasItemCodec = Left Toml._Int+    {-# INLINE hasItemCodec #-}++-- | @since 1.1.0.0+instance HasItemCodec Word where+    hasItemCodec = Left Toml._Word+    {-# INLINE hasItemCodec #-}++-- | @since 1.2.0.0+instance HasItemCodec Word8 where+    hasItemCodec = Left Toml._Word8+    {-# INLINE hasItemCodec #-}++-- | @since 1.1.0.0+instance HasItemCodec Integer where+    hasItemCodec = Left Toml._Integer+    {-# INLINE hasItemCodec #-}++-- | @since 1.1.0.0+instance HasItemCodec Natural where+    hasItemCodec = Left Toml._Natural+    {-# INLINE hasItemCodec #-}++-- | @since 1.1.0.0+instance HasItemCodec Double where+    hasItemCodec = Left Toml._Double+    {-# INLINE hasItemCodec #-}++-- | @since 1.1.0.0+instance HasItemCodec Float where+    hasItemCodec = Left Toml._Float+    {-# INLINE hasItemCodec #-}++-- | @since 1.1.0.0+instance HasItemCodec Text where+    hasItemCodec = Left Toml._Text+    {-# INLINE hasItemCodec #-}++-- | @since 1.1.0.0+instance HasItemCodec L.Text where+    hasItemCodec = Left Toml._LText+    {-# INLINE hasItemCodec #-}++-- | @since 1.3.0.0+instance HasItemCodec ByteStringAsText where+    hasItemCodec = Left $ coerce Toml._ByteString+    {-# INLINE hasItemCodec #-}++-- | @since 1.3.0.0+instance HasItemCodec ByteStringAsBytes where+    hasItemCodec = Left $ coerce Toml._ByteStringArray+    {-# INLINE hasItemCodec #-}++-- | @since 1.3.0.0+instance HasItemCodec LByteStringAsText where+    hasItemCodec = Left $ coerce Toml._LByteString+    {-# INLINE hasItemCodec #-}++-- | @since 1.3.0.0+instance HasItemCodec LByteStringAsBytes where+    hasItemCodec = Left $ coerce Toml._LByteStringArray+    {-# INLINE hasItemCodec #-}++-- | @since 1.1.0.0+instance HasItemCodec ZonedTime where+    hasItemCodec = Left Toml._ZonedTime+    {-# INLINE hasItemCodec #-}++-- | @since 1.1.0.0+instance HasItemCodec LocalTime where+    hasItemCodec = Left Toml._LocalTime+    {-# INLINE hasItemCodec #-}++-- | @since 1.1.0.0+instance HasItemCodec Day where+    hasItemCodec = Left Toml._Day+    {-# INLINE hasItemCodec #-}++-- | @since 1.1.0.0+instance HasItemCodec TimeOfDay where+    hasItemCodec = Left Toml._TimeOfDay+    {-# INLINE hasItemCodec #-}++-- | @since 1.1.0.0+instance HasItemCodec IntSet where+    hasItemCodec = Left Toml._IntSet+    {-# INLINE hasItemCodec #-}++{- | If data type @a@ is not primitive then this instance returns codec for list+under key equal to @a@ type name.++@since 1.1.0.0+-}+instance (HasItemCodec a, Typeable a) => HasItemCodec [a] where+    hasItemCodec = case hasItemCodec @a of+        Left prim   -> Left $ Toml._Array prim+        Right codec -> Right $ Toml.list codec (fromString $ typeName @a)+    {-# INLINE hasItemCodec #-}++{- | Helper typeclass for generic deriving. This instance tells how the data+type should be coded if it's a field of another data type.++__NOTE:__ If you implement TOML codecs for your data types manually, prefer more+explicit @Toml.int@ or @Toml.text@ instead of implicit @Toml.hasCodec@.+Implement instances of this typeclass only when using 'genericCodec' and when+your custom data types are not covered here.++@since 1.1.0.0+-}+class HasCodec a where+    hasCodec :: Key -> TomlCodec a++-- | @since 1.1.0.0+instance HasCodec Bool where+    hasCodec = Toml.bool+    {-# INLINE hasCodec #-}++-- | @since 1.1.0.0+instance HasCodec Int where+    hasCodec = Toml.int+    {-# INLINE hasCodec #-}++-- | @since 1.1.0.0+instance HasCodec Word where+    hasCodec = Toml.word+    {-# INLINE hasCodec #-}++-- | @since 1.2.0.0+instance HasCodec Word8 where+    hasCodec = Toml.word8+    {-# INLINE hasCodec #-}++-- | @since 1.1.0.0+instance HasCodec Integer where+    hasCodec = Toml.integer+    {-# INLINE hasCodec #-}++-- | @since 1.1.0.0+instance HasCodec Natural where+    hasCodec = Toml.natural+    {-# INLINE hasCodec #-}++-- | @since 1.1.0.0+instance HasCodec Double where+    hasCodec = Toml.double+    {-# INLINE hasCodec #-}++-- | @since 1.1.0.0+instance HasCodec Float where+    hasCodec = Toml.float+    {-# INLINE hasCodec #-}++-- | @since 1.1.0.0+instance HasCodec Text where+    hasCodec = Toml.text+    {-# INLINE hasCodec #-}++-- | @since 1.1.0.0+instance HasCodec L.Text where+    hasCodec = Toml.lazyText+    {-# INLINE hasCodec #-}++-- | @since 1.3.0.0+instance HasCodec ByteStringAsText where+    hasCodec = diwrap . Toml.byteString+    {-# INLINE hasCodec #-}++-- | @since 1.3.0.0+instance HasCodec ByteStringAsBytes where+    hasCodec = diwrap . Toml.byteStringArray+    {-# INLINE hasCodec #-}++-- | @since 1.3.0.0+instance HasCodec LByteStringAsText where+    hasCodec = diwrap . Toml.lazyByteString+    {-# INLINE hasCodec #-}++-- | @since 1.3.0.0+instance HasCodec LByteStringAsBytes where+    hasCodec = diwrap . Toml.lazyByteStringArray+    {-# INLINE hasCodec #-}++-- | @since 1.1.0.0+instance HasCodec ZonedTime where+    hasCodec = Toml.zonedTime+    {-# INLINE hasCodec #-}++-- | @since 1.1.0.0+instance HasCodec LocalTime where+    hasCodec = Toml.localTime+    {-# INLINE hasCodec #-}++-- | @since 1.1.0.0+instance HasCodec Day where+    hasCodec = Toml.day+    {-# INLINE hasCodec #-}++-- | @since 1.1.0.0+instance HasCodec TimeOfDay where+    hasCodec = Toml.timeOfDay+    {-# INLINE hasCodec #-}++-- | @since 1.1.0.0+instance HasCodec IntSet where+    hasCodec = Toml.arrayIntSet+    {-# INLINE hasCodec #-}++-- | @since 1.1.0.0+instance HasCodec a => HasCodec (Maybe a) where+    hasCodec = Toml.dioptional . hasCodec @a+    {-# INLINE hasCodec #-}++-- | @since 1.1.0.0+instance HasItemCodec a => HasCodec [a] where+    hasCodec = case hasItemCodec @a of+        Left prim   -> Toml.arrayOf prim+        Right codec -> Toml.list codec+    {-# INLINE hasCodec #-}++-- | @since 1.1.0.0+instance HasItemCodec a => HasCodec (NonEmpty a) where+    hasCodec = case hasItemCodec @a of+        Left prim   -> Toml.arrayNonEmptyOf prim+        Right codec -> Toml.nonEmpty codec+    {-# INLINE hasCodec #-}++-- | @since 1.2.0.0+instance (Ord a, HasItemCodec a) => HasCodec (Set a) where+    hasCodec = case hasItemCodec @a of+        Left prim   -> Toml.arraySetOf prim+        Right codec -> Toml.set codec+    {-# INLINE hasCodec #-}++-- | @since 1.2.0.0+instance (Hashable a, Eq a, HasItemCodec a) => HasCodec (HashSet a) where+    hasCodec = case hasItemCodec @a of+        Left prim   -> Toml.arrayHashSetOf prim+        Right codec -> Toml.hashSet codec+    {-# INLINE hasCodec #-}++{- | Encodes 'Map' as array of tables with the @key@ and @val@ TOML+key names for 'Map' keys and values. E.g. if you have a type+@'Map' 'Int' 'Text'@, the 'HasCodec' instance for 'Generic' deriving+will work with the following TOML representation:++@+fieldName =+    [ { key = 10, val = "book" }+    , { key = 42, val = "food" }+    ]+@++@since 1.3.0.0+-}+instance (Ord k, HasCodec k, HasCodec v) => HasCodec (Map k v) where+    hasCodec = Toml.map (hasCodec @k "key") (hasCodec @v "val")+    {-# INLINE hasCodec #-}++{- | Encodes 'HashMap' as array of tables with the @key@ and @val@ TOML+key names for 'HashMap' keys and values. E.g. if you have a type+@'HashMap' 'Text' 'Int'@, the 'HasCodec' instance for 'Generic'+deriving will work with the following TOML representation:++@+fieldName =+    [ { key = "foo", val = 15 }+    , { key = "bar", val = 7  }+    ]+@++@since 1.3.0.0+-}+instance (Hashable k, Eq k, HasCodec k, HasCodec v) => HasCodec (HashMap k v) where+    hasCodec = Toml.hashMap (hasCodec @k "key") (hasCodec @v "val")+    {-# INLINE hasCodec #-}++{- | Encodes 'IntMap' as array of tables with the @key@ and @val@ TOML+key names for 'IntMap' keys and values. E.g. if you have a type+@'IntMap' 'Text'@, the 'HasCodec' instance for 'Generic' deriving will+work with the following TOML representation:++@+fieldName =+    [ { key = 10, val = "foo" }+    , { key = 42, val = "bar" }+    ]+@++@since 1.3.0.0+-}+instance (HasCodec v) => HasCodec (IntMap v) where+    hasCodec = Toml.intMap (hasCodec @Int "key") (hasCodec @v "val")+    {-# INLINE hasCodec #-}++-- | @since 1.3.0.0+instance HasCodec All where+    hasCodec = Toml.all+    {-# INLINE hasCodec #-}++-- | @since 1.3.0.0+instance HasCodec Any where+    hasCodec = Toml.any+    {-# INLINE hasCodec #-}++-- | @since 1.3.0.0+instance (Num a, HasCodec a) => HasCodec (Sum a) where+    hasCodec = Toml.sum (hasCodec @a)+    {-# INLINE hasCodec #-}++-- | @since 1.3.0.0+instance (Num a, HasCodec a) => HasCodec (Product a) where+    hasCodec = Toml.product (hasCodec @a)+    {-# INLINE hasCodec #-}++-- | @since 1.3.0.0+instance HasCodec a => HasCodec (First a) where+    hasCodec = Toml.first (hasCodec @a)+    {-# INLINE hasCodec #-}++-- | @since 1.3.0.0+instance HasCodec a => HasCodec (Last a) where+    hasCodec = Toml.last (hasCodec @a)+    {-# INLINE hasCodec #-}++{- | @newtype@ for generic deriving of 'HasCodec' typeclass for custom data+types that should we wrapped into separate table. Use it only for data types+that are fields of another data types.++@+__data__ Person = Person+    { personName    :: !'Text'+    , personAddress :: !Address+    } __deriving__ ('Generic')++data Address = Address+    { addressStreet :: !'Text'+    , addressHouse  :: !'Int'+    } __deriving__ ('Generic')+      __deriving__ 'HasCodec' __via__ 'TomlTable' Address++personCodec :: 'TomlCodec' Person+personCodec = 'stripTypeNameCodec'+@++@personCodec@ corresponds to the TOML of the following structure:++@+name = "foo"+[address]+    addressStreet = \"Bar\"+    addressHouse = 42+@++@since 1.3.0.0+-}+newtype TomlTable a = TomlTable+    { unTomlTable :: a+    }++-- | @since 1.3.0.0+instance (Generic a, GenericCodec (Rep a)) => HasCodec (TomlTable a) where+    hasCodec :: Key -> TomlCodec (TomlTable a)+    hasCodec = Toml.diwrap . Toml.table (genericCodec @a)+    {-# INLINE hasCodec #-}++-- | @since 1.3.0.0+instance (Generic a, GenericCodec (Rep a)) => HasItemCodec (TomlTable a) where+    hasItemCodec = Right $ Toml.diwrap $ genericCodec @a+    {-# INLINE hasItemCodec #-}++{- $bytestring+There are two ways to encode 'ByteString' in TOML:++1. Via text.+2. Via an array of integers (aka array of bytes).++To handle all these cases, @tomland@ provides helpful newtypes, specifically:++* 'ByteStringAsText'+* 'ByteStringAsBytes'+* 'LByteStringAsText'+* 'LByteStringAsBytes'++As a bonus, on GHC >= 8.6 you can use these newtypes with the @DerivingVia@+extensions for your own 'ByteString' types.++@+__newtype__ MyByteString = MyByteString+    { unMyByteString :: 'ByteString'+    } __deriving__ 'HasCodec' __via__ 'ByteStringAsBytes'+@+-}++{- | Newtype wrapper over 'ByteString' to be used for text values.++@since 1.3.0.0+-}+newtype ByteStringAsText = ByteStringAsText+    { unByteStringAsText :: ByteString+    } deriving newtype (Show, Eq)++{- | Newtype wrapper over 'ByteString' to be used for array of integers+representation.++@since 1.3.0.0+-}+newtype ByteStringAsBytes = ByteStringAsBytes+    { unByteStringAsBytes :: ByteString+    } deriving newtype (Show, Eq)++{- | Newtype wrapper over lazy 'LBS.ByteString' to be used for text values.++@since 1.3.0.0+-}+newtype LByteStringAsText = LByteStringAsText+    { unLByteStringAsText :: LBS.ByteString+    } deriving newtype (Show, Eq)++{- | Newtype wrapper over lazy 'LBS.ByteString' to be used for array of integers+representation.++@since 1.3.0.0+-}+newtype LByteStringAsBytes = LByteStringAsBytes+    { unLByteStringAsBytes :: LBS.ByteString+    } deriving newtype (Show, Eq)

@@ -0,0 +1,220 @@+{-# LANGUAGE FlexibleInstances     #-}+{-# LANGUAGE MultiParamTypeClasses #-}+{-# LANGUAGE TupleSections         #-}+{-# LANGUAGE TypeFamilies          #-}+{-# LANGUAGE UndecidableInstances  #-}++{- |+Copyright: (c) 2018-2020 Kowainik+SPDX-License-Identifier: MPL-2.0+Maintainer: Kowainik <xrom.xkov@gmail.com>++Contains general underlying monad for bidirectional conversion.++@since 1.3.0.0+-}++module Toml.Codec.Types+       ( -- * Toml Codec+         TomlCodec+         -- * Toml Environment+       , TomlEnv+         -- * Toml State+       , TomlState (..)+       , eitherToTomlState++         -- * Codec+       , Codec (..)++         -- * Function alternative+       , (<!>)+       ) where++import Control.Applicative (Alternative (..), liftA2)+import Control.Monad.State (MonadState (..))+import Data.Bifunctor (first)+import Validation (Validation (..))++import Toml.Codec.Error (TomlDecodeError)+import Toml.Type (TOML (..))+++{- | Immutable environment for TOML conversion.++@since 1.3.0.0+-}+type TomlEnv a = TOML -> Validation [TomlDecodeError] a+++{- | Specialied 'Codec' type alias for bidirectional TOML serialization. Keeps+'TOML' object as both environment and state.++@since 0.5.0+-}+type TomlCodec a = Codec a a++{- | Monad for bidirectional conversion. Contains pair of functions:++1. How to read value of type @o@ (out) from immutable environment context+('TomlEnv')?+2. How to store a value of type @i@ (in) in stateful context ('TomlState') and+return a value of type @o@?++This approach with the bunch of utility functions allows to+have single description for from/to @TOML@ conversion.++In practice this type will always be used in the following way:++@+type 'TomlCodec' a = 'Codec' a a+@++Type parameter @i@ if fictional. Here some trick is used. This trick is+implemented in the [codec](http://hackage.haskell.org/package/codec) package and+described in more details in related blog post:+<https://blog.poisson.chat/posts/2016-10-12-bidirectional-serialization.html>.++@since 0.0.0+-}+data Codec i o = Codec+    { -- | Extract value of type @o@ from monadic context 'TomlEnv'.+      codecRead  :: TomlEnv o++      {- | Store value of type @i@ inside monadic context 'TomlState' and+      returning value of type @o@. Type of this function actually should be+      @o -> TomlState ()@ but with such type it's impossible to have 'Monad'+      and other instances.+      -}+    , codecWrite :: i -> TomlState o+    }++-- | @since 0.0.0+instance Functor (Codec i) where+    fmap :: (oA -> oB) -> Codec i oA -> Codec i oB+    fmap f codec = Codec+        { codecRead  = fmap f . codecRead codec+        , codecWrite = fmap f . codecWrite codec+        }+    {-# INLINE fmap #-}++-- | @since 0.0.0+instance Applicative (Codec i) where+    pure :: o -> Codec i o+    pure a = Codec+        { codecRead  = \_ -> Success a+        , codecWrite = \_ -> pure a+        }+    {-# INLINE pure #-}++    (<*>) :: Codec i (oA -> oB) -> Codec i oA -> Codec i oB+    codecf <*> codeca = Codec+        { codecRead  = liftA2 (<*>) (codecRead codecf) (codecRead codeca)+        , codecWrite = \c -> codecWrite codecf c <*> codecWrite codeca c+        }+    {-# INLINE (<*>) #-}++instance Alternative (Codec i) where+    empty :: Codec i o+    empty = Codec+        { codecRead  = \_ -> empty+        , codecWrite = \_ -> empty+        }+    {-# INLINE empty #-}++    (<|>) :: Codec i o -> Codec i o -> Codec i o+    codec1 <|> codec2 = Codec+        { codecRead  = codecRead codec1 <!> codecRead codec2+        , codecWrite = \c -> codecWrite codec1 c <|> codecWrite codec2 c+        }+    {-# INLINE (<|>) #-}++-- | Alternative instance for function arrow but without 'empty'.+infixl 3 <!>+(<!>) :: Alternative f => (a -> f x) -> (a -> f x) -> (a -> f x)+f <!> g = \a -> f a <|> g a+{-# INLINE (<!>) #-}++{- | Mutable context for TOML conversion.+We are introducing our own implemetation of state with 'MonadState' instance due+to some limitation in the design connected to the usage of State.++This newtype is equivalent to the following transformer:++@+MaybeT (State TOML)+@+++@since 1.3.0.0+-}+newtype TomlState a = TomlState+    { unTomlState :: TOML -> (Maybe a, TOML)+    }++-- | @since 1.3.0.0+instance Functor TomlState where+    fmap :: (a -> b) -> TomlState a -> TomlState b+    fmap f TomlState{..} = TomlState (first (fmap f) . unTomlState)+    {-# INLINE fmap #-}++    (<$) :: a -> TomlState b -> TomlState a+    a <$ TomlState{..} = TomlState (first (fmap (const a)) . unTomlState)+    {-# INLINE (<$) #-}++-- | @since 1.3.0.0+instance Applicative TomlState where+    pure :: a -> TomlState a+    pure a = TomlState (Just a,)+    {-# INLINE pure #-}++    (<*>) :: TomlState (a -> b) -> TomlState a -> TomlState b+    tsF <*> tsA = TomlState $ \t ->+        let (mF, tF) = unTomlState tsF t+            (mA, tA) = unTomlState tsA tF+        in (mF <*> mA , tA)+    {-# INLINE (<*>) #-}++-- | @since 1.3.0.0+instance Alternative TomlState where+    empty :: TomlState a+    empty = TomlState (Nothing,)+    {-# INLINE empty #-}++    (<|>) :: TomlState a -> TomlState a -> TomlState a+    ts1 <|> ts2 = TomlState $ \t -> let (m1, t1) = unTomlState ts1 t in case m1 of+        Nothing -> unTomlState ts2 t+        Just _  -> (m1, t1)+    {-# INLINE (<|>) #-}++-- | @since 1.3.0.0+instance Monad TomlState where+    return :: a -> TomlState a+    return = pure+    {-# INLINE return #-}++    (>>=) :: TomlState a -> (a -> TomlState b) -> TomlState b+    tsA >>= f = TomlState $ \t -> let (mA, newT) = unTomlState tsA t in case mA of+        Nothing -> (Nothing, newT)+        Just a  -> unTomlState (f a) newT+    {-# INLINE (>>=) #-}++-- | @since 1.3.0.0+instance (s ~ TOML) => MonadState s TomlState where+    state :: (TOML -> (a, TOML)) -> TomlState a+    state f = TomlState (first Just . f)+    {-# INLINE state #-}++    get :: TomlState TOML+    get = TomlState (\t -> (Just t, t))+    {-# INLINE get #-}++    put :: TOML -> TomlState ()+    put t = TomlState (\_ -> (Just (), t))+    {-# INLINE put #-}++{- | Transform 'Either' into 'TomlState'.++@since 1.3.0.0+-}+eitherToTomlState :: Either e a -> TomlState a+eitherToTomlState e = TomlState (either (const Nothing) Just e,)

@@ -1,86 +0,0 @@-{- |-Copyright: (c) 2018-2019 Kowainik-SPDX-License-Identifier: MPL-2.0-Maintainer: Kowainik <xrom.xkov@gmail.com>--This module introduces EDSL for manually specifying 'TOML' data types.--Consider the following raw TOML:--@-key1 = 1-key2 = true--[meme-quotes]-  quote1 = [ \"Oh\", \"Hi\", \"Mark\" ]--[[arrayName]]-  elem1 = "yes"--[[arrayName]]-  [arrayName.elem2]-    deep = 7--[[arrayName]]-@--using functions from this module you can specify the above TOML in safer way:--@-exampleToml :: 'TOML'-exampleToml = 'mkToml' $ __do__-    \"key1\" '=:' 1-    \"key2\" '=:' Bool True-    'table' \"meme-quotes\" $-        \"quote1\" '=:' Array [\"Oh\", \"Hi\", \"Mark\"]-    'tableArray' \"arrayName\" $-        \"elem1\" '=:' \"yes\" :|-        [ 'table' \"elem2\" $ \"deep\" '=:' Integer 7-        , 'empty'-        ]-@--}--module Toml.Edsl-       ( TDSL-       , mkToml-       , empty-       , (=:)-       , table-       , tableArray-       ) where--import Control.Monad.State (State, execState, modify, put)-import Data.List.NonEmpty (NonEmpty)--import Toml.PrefixTree (Key)-import Toml.Type (TOML (..), Value, insertKeyVal, insertTable, insertTableArrays)----- | Monad for creating TOML.-type TDSL = State TOML ()---- | Creates 'TOML' from the 'TDSL'.-mkToml :: TDSL -> TOML-mkToml env = execState env mempty-{-# INLINE mkToml #-}---- | Creates an empty 'TDSL'.-empty :: TDSL-empty = put mempty-{-# INLINE empty #-}---- | Adds key-value pair to the 'TDSL'.-(=:) :: Key -> Value a -> TDSL-(=:) k v = modify $ insertKeyVal k v-{-# INLINE (=:) #-}---- | Adds table to the 'TDSL'.-table :: Key -> TDSL -> TDSL-table k = modify . insertTable k . mkToml-{-# INLINE table #-}---- | Adds array of tables to the 'TDSL'.-tableArray :: Key -> NonEmpty TDSL -> TDSL-tableArray k = modify . insertTableArrays k . fmap mkToml-{-# INLINE tableArray #-}

@@ -1,419 +0,0 @@-{-# LANGUAGE AllowAmbiguousTypes  #-}-{-# LANGUAGE DataKinds            #-}-{-# LANGUAGE FlexibleContexts     #-}-{-# LANGUAGE FlexibleInstances    #-}-{-# LANGUAGE GADTs                #-}-{-# LANGUAGE PolyKinds            #-}-{-# LANGUAGE Rank2Types           #-}-{-# LANGUAGE TypeOperators        #-}-{-# LANGUAGE TypeSynonymInstances #-}-{-# LANGUAGE UndecidableInstances #-}--{- |-Copyright: (c) 2018-2019 Kowainik-SPDX-License-Identifier: MPL-2.0-Maintainer: Kowainik <xrom.xkov@gmail.com>--This module contains implementation of the 'Generic' TOML codec. If your-data types are big and nested, and you want to have codecs for them without writing a lot of-boilerplate code, you can find this module helpful. Below you can find the detailed-explanation on how the 'Generic' codecs work.--Consider the following Haskell data types:--@-__data__ User = User-    { age     :: Int-    , address :: Address-    , socials :: [Social]-    } __deriving__ ('Generic')--__data__ Address = Address-    { street :: Text-    , house  :: Int-    } __deriving__ ('Generic')--__data__ Social = Social-    { name :: Text-    , link :: Text-    } __deriving__ ('Generic')-@--Value of the @User@ type represents the following TOML:--@-age = 27--[address]-  street = "Miami Beach"-  house  = 42--[[socials]]-  name = \"Twitter\"-  link = "https://twitter.com/foo"--[[socials]]-  name = \"GitHub\"-  link = "https://github.com/bar"-@--Normally you would write 'TomlCodec' for this data type like this:--@-userCodec :: 'TomlCodec' User-userCodec = User-    \<$\> Toml.int "age" .= age-    \<*\> Toml.table addressCodec "address" .= address-    \<*\> Toml.list  socialCodec  "socials" .= socials--addressCodec :: 'TomlCodec' Address-addressCodec = Address-    \<$\> Toml.text "street" .= street-    \<*\> Toml.int  "house"  .= house--socialCodec :: 'TomlCodec' Social-socialCodec = Social-    \<$\> Toml.text "name" .= name-    \<*\> Toml.text "link" .= link-@--However, if you derive 'Generic' instance for your data types (as we do in the-example), you can write your codecs in a simpler way.--@-userCodec :: 'TomlCodec' User-userCodec = 'genericCodec'--__instance__ 'HasCodec' Address __where__-    hasCodec = Toml.table 'genericCodec'--__instance__ 'HasItemCodec' Social __where__-    hasItemCodec = Right 'genericCodec'-@--Several notes about the interface:--1. Your top-level data types are always implemented as 'genericCodec' (or other-generic codecs).-2. If you have a custom data type as a field of another type, you need to implement-the instance of the 'HasCodec' typeclass.-3. If the data type appears as an element of a list, you need to implement the instance-of the 'HasItemCodec' typeclass.--@since 1.1.1.0--}--module Toml.Generic-       ( genericCodec-       , genericCodecWithOptions-       , stripTypeNameCodec--         -- * Options-       , TomlOptions (..)-       , GenericOptions (..)-       , stripTypeNameOptions-       , stripTypeNamePrefix--         -- * Core generic typeclass-       , HasCodec (..)-       , HasItemCodec (..)-       , GenericCodec (..)-       ) where--import Data.Char (isLower, toLower)-import Data.Hashable (Hashable)-import Data.HashSet (HashSet)-import Data.IntSet (IntSet)-import Data.Kind (Type)-import Data.List (stripPrefix)-import Data.List.NonEmpty (NonEmpty)-import Data.Proxy (Proxy (..))-import Data.Set (Set)-import Data.String (IsString (..))-import Data.Text (Text)-import Data.Time (Day, LocalTime, TimeOfDay, ZonedTime)-import Data.Typeable (Typeable, typeRep)-import Data.Word (Word8)-import GHC.Generics ((:*:) (..), (:+:), C1, D1, Generic (..), K1 (..), M1 (..), Rec0, S1,-                     Selector (..))-import GHC.TypeLits (ErrorMessage (..), TypeError)-import Numeric.Natural (Natural)--import Toml.Bi (TomlBiMap, TomlCodec, (.=))-import Toml.PrefixTree (Key)-import Toml.Type (AnyValue)--import qualified Data.Text.Lazy as L-import qualified Toml.Bi as Toml---{- | Generic codec for arbitrary data types. Uses field names as keys.--}-genericCodec :: (Generic a, GenericCodec (Rep a)) => TomlCodec a-genericCodec = Toml.dimap from to $ genericTomlCodec (GenericOptions id)-{-# INLINE genericCodec #-}--{- | Generic codec with options for arbitrary data types.--}-genericCodecWithOptions-    :: forall a-     . (Generic a, GenericCodec (Rep a), Typeable a)-    => TomlOptions a-    -> TomlCodec a-genericCodecWithOptions = Toml.dimap from to . genericTomlCodec . toGenericOptions @a-{-# INLINE genericCodecWithOptions #-}--{- | Generic codec that uses 'stripTypeNameOptions'.--}-stripTypeNameCodec-    :: forall a-     . (Generic a, GenericCodec (Rep a), Typeable a)-    => TomlCodec a-stripTypeNameCodec = genericCodecWithOptions $ stripTypeNameOptions @a-{-# INLINE stripTypeNameCodec #-}--------------------------------------------------------------------------------- Generic typeclasses-------------------------------------------------------------------------------{- | Options to configure various parameters of generic encoding. Specifically:--*  __'tomlOptionsFieldModifier'__: how to translate field names to TOML keys?--}-data TomlOptions a = TomlOptions-    { tomlOptionsFieldModifier :: Typeable a => Proxy a -> String -> String-    }--{- | Same as 'TomlOptions' but with all data type information erased. This data-type is used internally. Define your options using 'TomlOptions' data type.--}-newtype GenericOptions = GenericOptions-    { genericOptionsFieldModifier :: String -> String-    }--toGenericOptions :: forall a . Typeable a => TomlOptions a -> GenericOptions-toGenericOptions TomlOptions{..} = GenericOptions-    { genericOptionsFieldModifier = tomlOptionsFieldModifier (Proxy @a)-    }---- | Options that use 'stripTypeNamePrefix' as 'tomlOptionsFieldModifier'.-stripTypeNameOptions :: Typeable a => TomlOptions a-stripTypeNameOptions = TomlOptions-    { tomlOptionsFieldModifier = stripTypeNamePrefix-    }--{- | Strips name of the type name from field name prefix.-->>> data UserData = UserData { userDataId :: Int, userDataShortInfo :: Text }->>> stripTypeNamePrefix (Proxy @UserData) "userDataId"-"id"->>> stripTypeNamePrefix (Proxy @UserData) "userDataShortInfo"-"shortInfo"->>> stripTypeNamePrefix (Proxy @UserData) "udStats"-"stats"->>> stripTypeNamePrefix (Proxy @UserData) "fooBar"-"bar"->>> stripTypeNamePrefix (Proxy @UserData) "name"-"name"--}-stripTypeNamePrefix :: forall a . Typeable a => Proxy a -> String -> String-stripTypeNamePrefix _ fieldName =-    case stripPrefix (headToLower $ typeName @a) fieldName of-        Just rest -> leaveIfEmpty rest-        Nothing   -> leaveIfEmpty (dropWhile isLower fieldName)-  where-    headToLower :: String -> String-    headToLower = \case-        []   -> error "Cannot use 'headToLower' on empty Text"-        x:xs -> toLower x : xs--    -- if all lower case then leave field as it is-    leaveIfEmpty :: String -> String-    leaveIfEmpty rest = if null rest then fieldName else headToLower rest--typeName :: forall a . Typeable a => String-typeName = show $ typeRep (Proxy @a)--------------------------------------------------------------------------------- Generic typeclasses-------------------------------------------------------------------------------{- | Helper class to derive TOML codecs generically.--}-class GenericCodec (f :: k -> Type) where-    genericTomlCodec :: GenericOptions -> TomlCodec (f p)--instance GenericCodec f => GenericCodec (D1 d f) where-    genericTomlCodec = Toml.dimap unM1 M1 . genericTomlCodec-    {-# INLINE genericTomlCodec #-}--type GenericSumTomlNotSupported =-    'Text "Generic TOML deriving for arbitrary sum types is not supported currently."--instance (TypeError GenericSumTomlNotSupported) => GenericCodec (f :+: g) where-    genericTomlCodec = error "Not supported"--instance GenericCodec f => GenericCodec (C1 c f) where-    genericTomlCodec = Toml.dimap unM1 M1 . genericTomlCodec-    {-# INLINE genericTomlCodec #-}--instance (GenericCodec f, GenericCodec g) => GenericCodec (f :*: g) where-    genericTomlCodec options = (:*:)-        <$> genericTomlCodec options .= fstG-        <*> genericTomlCodec options .= sndG-      where-        fstG :: (f :*: g) p -> f p-        fstG (f :*: _) = f--        sndG :: (f :*: g) p -> g p-        sndG (_ :*: g) = g-    {-# INLINE genericTomlCodec #-}--instance (Selector s, HasCodec a) => GenericCodec (S1 s (Rec0 a)) where-    genericTomlCodec GenericOptions{..} = genericWrap $ hasCodec @a fieldName-      where-        genericWrap :: TomlCodec a -> TomlCodec (S1 s (Rec0 a) p)-        genericWrap = Toml.dimap (unK1 . unM1) (M1 . K1)--        fieldName :: Key-        fieldName =-            fromString-            $ genericOptionsFieldModifier-            $ selName (error "S1" :: S1 s Proxy ())-    {-# INLINE genericTomlCodec #-}--------------------------------------------------------------------------------- Helper typeclasses-------------------------------------------------------------------------------{- | This typeclass tells how the data type should be coded as an item of a-list. Lists in TOML can have two types: __primitive__ and __table of arrays__.--* If 'hasItemCodec' returns 'Left': __primitive__ arrays codec is used.-* If 'hasItemCodec' returns 'Right:' __table of arrays__ codec is used.--}-class HasItemCodec a where-    hasItemCodec :: Either (TomlBiMap a AnyValue) (TomlCodec a)--instance HasItemCodec Bool      where hasItemCodec = Left Toml._Bool-instance HasItemCodec Int       where hasItemCodec = Left Toml._Int-instance HasItemCodec Word      where hasItemCodec = Left Toml._Word--- | @since 1.2.0.0-instance HasItemCodec Word8     where hasItemCodec = Left Toml._Word8-instance HasItemCodec Integer   where hasItemCodec = Left Toml._Integer-instance HasItemCodec Natural   where hasItemCodec = Left Toml._Natural-instance HasItemCodec Double    where hasItemCodec = Left Toml._Double-instance HasItemCodec Float     where hasItemCodec = Left Toml._Float-instance HasItemCodec Text      where hasItemCodec = Left Toml._Text-instance HasItemCodec L.Text    where hasItemCodec = Left Toml._LText-instance HasItemCodec ZonedTime where hasItemCodec = Left Toml._ZonedTime-instance HasItemCodec LocalTime where hasItemCodec = Left Toml._LocalTime-instance HasItemCodec Day       where hasItemCodec = Left Toml._Day-instance HasItemCodec TimeOfDay where hasItemCodec = Left Toml._TimeOfDay-instance HasItemCodec IntSet    where hasItemCodec = Left Toml._IntSet--{- | If data type @a@ is not primitive then this instance returns codec for list-under key equal to @a@ type name.--}-instance (HasItemCodec a, Typeable a) => HasItemCodec [a] where-    hasItemCodec = case hasItemCodec @a of-        Left prim   -> Left $ Toml._Array prim-        Right codec -> Right $ Toml.list codec (fromString $ typeName @a)--{- | Helper typeclass for generic deriving. This instance tells how the data-type should be coded if it's a field of another data type.--__NOTE:__ If you implement TOML codecs for your data types manually, prefer more-explicit @Toml.int@ or @Toml.text@ instead of implicit @Toml.hasCodec@.-Implement instances of this typeclass only when using 'genericCodec' and when-your custom data types are not covered here.--}-class HasCodec a where-    hasCodec :: Key -> TomlCodec a--instance HasCodec Bool      where hasCodec = Toml.bool-instance HasCodec Int       where hasCodec = Toml.int-instance HasCodec Word      where hasCodec = Toml.word--- | @since 1.2.0.0-instance HasCodec Word8     where hasCodec = Toml.word8-instance HasCodec Integer   where hasCodec = Toml.integer-instance HasCodec Natural   where hasCodec = Toml.natural-instance HasCodec Double    where hasCodec = Toml.double-instance HasCodec Float     where hasCodec = Toml.float-instance HasCodec Text      where hasCodec = Toml.text-instance HasCodec L.Text    where hasCodec = Toml.lazyText-instance HasCodec ZonedTime where hasCodec = Toml.zonedTime-instance HasCodec LocalTime where hasCodec = Toml.localTime-instance HasCodec Day       where hasCodec = Toml.day-instance HasCodec TimeOfDay where hasCodec = Toml.timeOfDay-instance HasCodec IntSet    where hasCodec = Toml.arrayIntSet--instance HasCodec a => HasCodec (Maybe a) where-    hasCodec = Toml.dioptional . hasCodec @a--instance HasItemCodec a => HasCodec [a] where-    hasCodec = case hasItemCodec @a of-        Left prim   -> Toml.arrayOf prim-        Right codec -> Toml.list codec--instance HasItemCodec a => HasCodec (NonEmpty a) where-    hasCodec = case hasItemCodec @a of-        Left prim   -> Toml.arrayNonEmptyOf prim-        Right codec -> Toml.nonEmpty codec---- | @since 1.2.0.0-instance (Ord a, HasItemCodec a) => HasCodec (Set a) where-    hasCodec = case hasItemCodec @a of-        Left prim   -> Toml.arraySetOf prim-        Right codec -> Toml.set codec---- | @since 1.2.0.0-instance (Hashable a, Eq a, HasItemCodec a) => HasCodec (HashSet a) where-    hasCodec = case hasItemCodec @a of-        Left prim   -> Toml.arrayHashSetOf prim-        Right codec -> Toml.hashSet codec--{--TODO: uncomment when higher-kinded roles will be implemented-* https://github.com/ghc-proposals/ghc-proposals/pull/233--{- | @newtype@ for generic deriving of 'HasCodec' typeclass for custom data-types that should we wrapped into separate table. Use it only for data types-that are fields of another data types.--@-data Person = Person-    { personName    :: Text-    , personAddress :: Address-    } deriving (Generic)--data Address = Address-    { addressStreet :: Text-    , addressHouse  :: Int-    } deriving (Generic)-      deriving HasCodec via TomlTable Address--personCodec :: TomlCodec Person-personCodec = genericCodec-@--@personCodec@ corresponds to the TOML of the following structure:--@-name = "foo"-[address]-    street = \"Bar\"-    house = 42-@--}-newtype TomlTable a = TomlTable-    { unTomlTable :: a-    }--instance (Generic a, GenericCodec (Rep a)) => HasCodec (TomlTable a) where-    hasCodec :: Key -> TomlCodec (TomlTable a)-    hasCodec = Toml.diwrap . Toml.table (genericCodec @a)--instance (Generic a, GenericCodec (Rep a)) => HasItemCodec (TomlTable a) where-    hasItemCodec = Right $ Toml.diwrap $ genericCodec @a--}