katydid: A haskell implementation of Katydid

This is a package candidate release! Here you can preview how this package release will appear once published to the main package index (which can be accomplished via the 'maintain' link below). Please note that once a package has been published to the main package index it cannot be undone! Please consult the package uploading documentation for more information.

[maintain] [Publish]

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]

Properties

Versions	0.1.0.0, 0.1.1.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	None available
Dependencies	base (>=4.7 && <5), containers, 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 2017-11-06T10:42:51Z

Modules

[Index]

Downloads

katydid-0.1.1.0.tar.gz [browse] (Cabal source package)
Package description (as included in the package)

Maintainer's Corner

Package maintainers

awalterschulze

For package maintainers and hackage trustees

edit package information

Readme for katydid-0.1.1.0

[back to package description]

Katydid

A Haskell implementation of Katydid.

This includes:

Relapse: Validation Language
Parsers: JSON and XML

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]]