TOML is the obvious, minimal configuration language by Tom Preston-Werner. It is an alternative to the XML, YAML and INI formats mainly for the purpose of configuration files. Many will find that XML and YAML are too heavy for the purpose of configuration files prupose while INI is underspecified. TOML is to configuration files, like what Markdown is for rich-text.
- TOML v0.4.0 is implemented by
htoml >= 188.8.131.52
- (currently only one item in this mapping, more will follow)
Apart from this README, documentation for this package may (or may not) be found on Hackage.
htoml is easy. Either by using Stack (recommended):
stack install htoml
Or by using Cabal:
cabal install htoml
In order to make your project depend on it you can add it as a dependency in your project's
.cabal file, and since it is not yet on Stackage you will also have to add it to the
extra-deps section of your
stack.yaml file when using Stack.
To quickly show some features of
htoml we use Stack to start a GHCi-based REPL. It picks up configuration from the
.ghci file in the root of the repository.
git clone https://github.com/cies/htoml.git cd htoml stack init stack --install-ghc ghci
--resolver flag to the
stack init command to specify a specific package snapshot, e.g.:
In case you have missing dependencies (possibly
file-embed), they can be added to the
stack.yaml automatically with:
stack solver --update-config
We can now start exploring
htoml from a GHCi REPL. From the root of this repository run:
Now read a
.toml file from the benchmark suite, with:
txt <- readFile "benchmarks/example.toml" let r = parseTomlDoc "" txt r
Right (fromList [("database",VTable (fromList [("enabled",VBoolean True),("po [...]
Then convert it to Aeson (JSON), with:
let Right toml = r toJSON toml
Object (fromList [("database",Object (fromList [("enabled",Bool True),("po [...]
Finally trigger a parse error, with:
let Left err = parseTomlDoc "" "== invalid toml ==" err
...it errors out (as it should), showing:
(line 1, column 1): unexpected '=' expecting "#", "\n", "\r\n", letter or digit, "_", "-", "\"", "'", "[" or end of input
Note: Some of the above outputs are truncated, indicated by
How to pull data from a TOML file after parsing it
Once you have sucessfully parsed a TOML file you most likely want to pull some piecces of data out of the resulting data structure.
To do so you have two main options. The first is to use pattern matching. For example let's consider the following
Right (fromList [("server",VTable (fromList [("enabled",VBoolean True)] ) )] )
Which could be pattern matched with:
case parseResult of Left _ -> "Could not parse file" Right m -> case m ! "server" of VTable mm -> case mm ! "enabled" of VBoolean b -> "Server is " ++ (if b then "enabled" else "disabled") _ -> "Could not parse server status (Boolean)" _ -> "TOML file does not contain the 'server' key"
The second main option is to use the
toJSON function to transform the data to an Aeson data structure, after which you can use your Aeson toolbelt to tackle the problem. Since TOML is intended to be a close cousin of JSON this is a very practical approach.
Other ways to pull data from a parsed TOML document will most likely exist; possible using the
lens library as documented here.
Currently we are testing against several versions of GHC with Travis CI as defined in the
env section of our
lts-2 implies GHC 7.8.4,
lts-3 implies GHC 7.10.2,
lts-5 imply GHC 7.10.3, and
nightly is build with a regularly updated version of GHC.
Version contraints of
If you encounter any problems because
htoml's dependecies are constrained either too much or too little, please file a issue for that. Or off even better submit a PR.
Tests and benchmarks
Tests are build and run with:
BurntSushi's language agnostic test suite is embedded in the test suite executable. Using a shell script (that lives in
test/BurntSushi) the latest tests can be fetched from its Github repository.
The benchmarks, that use the amazing
criterion library, are build and run with:
stack build :benchmarks
Most welcome! Please raise issues, start discussions, give comments or submit pull-requests. This is one of the first Haskell libraries I wrote, feedback is much appreciated.
- Compatibility to the TOML spec is proven by an extensive test suite
- Incorporates BurntSushi's language agnostic test suite
- Has an internal representation that easily maps to JSON
- Provides an Aeson-style JSON interface (suggested by Greg Weber)
- Useful error messages (thanks to using Parsec over Attoparsec)
- Understands arrays as described in this issue
- Fails on mix-type arrays (as per spec)
- Comes with a benchmark suite to make performance gains/regressions measurable
- Tries to be well documented (please raise an issue if you find documentation lacking)
- Available on Stackage (see top of this README for badges indicating TOMLs inclusion in Stackage status)
- More documentation and start to use the proper Haddock idioms
- Add property tests with QuickCheck (the internet says it's possible for parsers)
- Extensively test error cases (probably improving error reporting along the way)
- See how lenses may (or may not) fit into this package, or an additional package
- Consider moving to one of the more modern parser combinators in Haskell (
megaparsecmaybe?) -- possibly wait until a clear winner shows
Do you see todo that looks like fun thing to implement and you can spare the time? Please knoe that PRs are welcome :)
Originally this project started off by improving the
toml package by Spiros Eliopoulos.
HuwCampbell helped a lot by making tests pass and implementing "explicitness tracking" in Parsec's parser state.
Copyright and licensing
This package includes BurntSushi's language agnostic TOML tests, which are WTFPL licensed.
The TOML examples that are used as part of the benchmarks are copied from Tom Preston-Werner's TOML spec which is MIT licensed.
For all other files in this project the copyrights are specified in the
htoml.cabal file, they are distributed under the BSD3 license as found in the