katydid: A haskell implementation of Katydid

[ bsd3, data, library, program ] [ Propose Tags ]

A haskell implementation of Katydid

This includes:

  • Relapse, a validation Language

  • Parsers for JSON, XML and an abstraction for trees

You should only need the following modules:

  • The Relapse module is used for validation.

  • The Json and XML modules are used to create Json and XML trees that can be validated.

If you want to implement your own parser then you can look at the Parsers module


[Skip to Readme]

Downloads

Maintainer's Corner

Package maintainers

For package maintainers and hackage trustees

Candidates

Versions [RSS] 0.1.0.0, 0.1.1.0, 0.2.0.1, 0.3.0.0, 0.3.0.1, 0.3.1.0, 0.4.0.1, 0.4.0.2
Change log changelog.md
Dependencies base (>=4.7 && <5), containers, deepseq, hxt, json, katydid, mtl, parsec, regex-tdfa [details]
License BSD-3-Clause
Copyright Walter Schulze
Author Walter Schulze
Maintainer awalterschulze@gmail.com
Category Data
Home page https://github.com/katydid/katydid-haskell
Source repo head: git clone https://github.com/katydid/katydid-haskell
Uploaded by awalterschulze at 2018-03-19T13:35:22Z
Distributions
Executables katydid-exe
Downloads 4246 total (22 in the last 30 days)
Rating (no votes yet) [estimated by Bayesian average]
Your Rating
  • λ
  • λ
  • λ
Status Docs available [build log]
Last success reported on 2018-03-19 [all 1 reports]

Readme for katydid-0.2.0.1

[back to package description]

Katydid

Build Status

A Haskell implementation of Katydid.

This includes:

Documentation for katydid

Documentation for katydid-haskell

Documentation for katydid-haskell/Relapse

All JSON and XML tests from the language agnostic test suite [passes].

Hackage.

Example

Validating a single structure can be done using the validate function:

validate :: Tree t => Refs -> [t] -> Bool

, where a tree is a class in the Parsers module:

class Tree a where
    getLabel :: a -> Label
    getChildren :: a -> [a]

Here is an example that validates a single JSON tree:

main = either 
    (\err -> putStrLn $ "error:" ++ err) 
    (\valid -> if valid 
        then putStrLn "dragons exist" 
        else putStrLn "dragons are fictional"
    ) $
    Relapse.validate <$> 
        runExcept (Relapse.parseGrammar ".DragonsExist == true") <*> 
        Json.decodeJSON "{\"DragonsExist\": false}"

Efficiency

If you want to validate multiple trees using the same grammar then the filter function does some internal memoization, which makes a huge difference.

filter :: Tree t => Refs -> [[t]] -> [[t]]