The Fig library provides parsing and printing for the FIG 3.2 format (the format used by the Xfig drawing program) together with a simple search-and-replace facility.

An experimental testing framework. Not ready for use yet

filediff is a Haskell library for creating diffs, and applying diffs to files and directories.

Update CSS in the browser without reloading the page.

Generators of Hilbert and Moore space-filling curves in configurable coordinate domains.

Given a list of files and directories to include, binembed generates assembly source to include the data into an object file that can be linked to a library or executable, along with interface modules for higher level access from languages such as C, Haskell, ... See the package binembed-example for a concrete example.

Following clutering methods are included in this library: 1 Agglomerative hierarchical clustering. Complete linkage O(n^2), Single linkage O(n^2), Average linkage O(n^2), Weighted linkage O(n^2), Ward's linkage O(n^2). 2 KMeans clustering.

An applicative monad that batches commands for later more efficient execution

Pretty printing designed for printing source code based on Wadler's paper A Prettier Printer. The main advantage of this library is its ability to automatically track the source locations associated with pretty printed values and output appropriate #line pragmas and its ability to produce output in the form of lazy text using a builder.

Simple fix-expression parser

Contains a MonadRef type class that abstracts over the details of manipulating references, allowing one to write code that can operate in either the ST monad or the IO monad.

Please see the README on GitHub at https://github.com/reygoch/valor#readme

A multi-level lift.

A wget-like utility for retrieving files from XDCC bots on IRC

Multi-version concurrency control

High precision conversion between GPS and UK Grid

Interval datatype, interval arithmetic and interval-based containers for Haskell. Unlike the intervals package (http://hackage.haskell.org/package/intervals), this package provides both open and closed intervals and is intended to be used with exact number types such as Rational and Integer.

See README at https://github.com/advancedtelematic/quickcheck-state-machine#readme

A consul client for Haskell Requires consul 0.5 or later.

The JSON Resume initiative (http://jsonresume.org) provides a standard format for representing resumes/CVs in JSON form. This library encodes that standard in Haskell datatypes, and provides a parser to read a CV in the JSON Resume format.

Base64 encoding in Haskell

This package contains a datatype, TaggedList, that provides a fixed-length list tagged with a phantom type-level natural number that corresponds to the length of the list. It also contains some basic operations on these lists, as well as a typeclass for converting tagged lists to and from tuples. New in version 1.1: added function castTag, improved error reporting in fromList, and fixed compiler error with GHC 7.0.*

toysat driver as backend for satchmo

"Higher-kinded data" utilities, e.g. and other classes and types. Note: this package is experimental.

Deprecated in favor of filepather Functions over System.FilePath including a find function for recursing down directories.

Snap Framework static loader

Please see http://www.stackage.org/package/stackage-curator for a description and documentation.

For package maintainers and hackage trustees

Support for construction, rendering, and parsing of CUE sheets.

Atomic operations on PrimArray and ByteArray

Interacts with tesseract to ease reading of RAW Japanese manga.

Jukebox is a suite of tools for transforming problems in first-order logic. It reads problems in TPTP (FOF and TFF) format. Currently it can translate typed problems to untyped (by efficiently encoding types) and clausify problems (both typed and untyped).

Happy Haskell Programming

See the dlist packages. This package is the canonical source for some orphan instances. Orphan instances are placed here to avoid dependencies elsewhere.

Contains several implementations of data structures implementing a single-in, single-out paradigm. Intended to be a better, more useful replacement for pqueue-mtl. In particular, includes an experimental and possibly genuinely new trie-based priority queue on strings. Feedback is appreciated.

[Index] For package maintainers and hackage trustees

This package lets you convert between Aeson's JSON and Bson objects.

A collection of optics for the hreader library

The HoleyMonoid allows building monoidal values of which certain components are to be filled in later. For example:

The Parser Generator for Haskell http://tanakh.github.com/Peggy

A library of basic functionality needed for number-theoretic calculations. The aim of this library is to provide efficient implementations of the functions. Primes and related things (totients, factorisation), powers (integer roots and tests, modular exponentiation), integer logarithms. Note: Requires GHC >= 6.12 with the integer-gmp package for efficiency. Portability is on the to-do list (with low priority, however).

Please see the README on GitHub at https://github.com/sjshuck/hs-pcre2

This package simplifies the creation of subprocesses that interact with their parent via a pseudo terminal (see man pty).

A high-performance, reasonably robust HTML5 tokenizer

Language C is a haskell library for the analysis and generation of C code. It features a complete, well tested parser and pretty printer for all of C99 and a large set of C11 and clang/GNU extensions.

A morphological disambiguation library based on constrained conditional random fields.

Bundle data files inside executables, for easy access and single file distribution.

An Haskell implementation of Google's Protocol Buffers version 2 with an emphasis on simplicity. The implementation consists of a library for encoding and decoding of data and the protobuf-simple-protoc executable for generating Haskell types from proto files. In fact, the types that are used in the tests are generated with the following command: In the example below, the CustomType is a Haskell type that was generated with the protobuf-simple-protoc executable. The encCustomType function encodes a CustomType into a ByteString. The decCustomType function decodes a ByteString into either a CustomType or an error. The library exposes two modules, Data.ProtoBuf, which is used for encoding and decoding and Data.ProtoBufInt, which is an internal module that is used by the generated types.

Haskell Client for the DataRobot API

blaze-html integration for Snap

hmatrix operations lifted for backprop, along with orphan instances. Meant to act as a drop-in replacement to the API of Numeric.LinearAlgebra.Static. Just change your imports, and your functions are automatically backpropagatable. See README on Github at https://github.com/mstksg/hmatrix-backprop#readme

[Index] For package maintainers and hackage trustees

Extra functions for Control.Arrow

From System F to Typed-Assembly Language

MPFR bindings for Haskell

A package emulating the functionality of Debug.Trace, but capable of writing to files

A pool of connections for Hasql

[Index] For package maintainers and hackage trustees

Deprecated This package allows you to define several typesafe indizes on a set. You can query the set with an SQL-like set of query operations. This package was developed as a successor of Data.IxSet. It is meant to be more space efficient, since it uses Data.IntSet and Data.TrieMap as an underlying represenation. It also has the potential to be fast, since indizes don't need to be recalculated after each query and since Patricia trees perform quite well for intersection and union. This package comes without warranties. Although I use it without problems in a large web project it is neither properly tested nor benchmarked. Patches or suggestions for improvement are welcome. If you like, start an issue on github.

Bindings to the Termbox library.

An implementation of first order logic in Haskell that includes a library of modules for incorporating first order logic into other programs as well as an executable theorem prover that uses resolution to prove theorems in first order logic.

Can be used with Debug.Trace, Test.QuickCheck, or just plain old System.IO's putStrLn. See README.md and FEATURES.md for further details.

sandman aims to reduce the amount of time spent rebuilding commonly used Hackage packages by managing a global set of Cabal sandboxes that can be mixed into any project's Cabal sandbox. For more information, check the README.

A simple general purpose shared state cache map with automatic expiration of values, for caching the results of accessing a resource such as reading a file. With variations for Ord and Hashable keys using Data.Map.Strict and Data.HashMap.Strict, respectively.

The Levenberg-Marquardt algorithm is a minimization algorithm for functions expressed as a sum of squared errors This can be used for curve-fitting, multidimensional function minimization, and neural networks training Go to https://github.com/ktklam9/HaskellLM for example usage (in tests)

Utilities to encode and decode Pipes streams of JSON. See the changelog.md file in the source distribution to learn about any important changes between version.

Cross platform library for file creation, modification, and deletion notification. This library builds upon existing libraries for platform-specific Windows, Mac, and Linux filesystem event notification.

Haskell gearman client library

redo builds a target file from source files using a do script. It also tracks when source files have changed and rebuilds target files as necessary.

An auth plugin for accounts. Each account consists of a username, email, and password. The plugin provides new account, email verification, and password reset pages that can be customized to enhance the user experience. This is a fork of the yesod-auth-account package with the following additions: Login using either username or e-mail. JSON support for single page applications. We'd like to merge these changes back upstream but its maintainer has been unresponsive.

Complete bindings to all functions about graph properties of the igraph C library. Requires igraph 0.6. Documentation is available at: http://giorgidze.github.com/igraph/

This library provides a set of Monad transformers (and instances for common transformers) on top of widget switching primitives for reflex. For example ReaderT and WriterT which operate in the presence of widget switching, allowing you to pass inputs and outputs up and down the UI tree.

This package defines MonadPeelIO, a subset of MonadIO into which generic control operations such as catch can be lifted from IO. Instances are based on monad transformers in MonadTransPeel, which includes all standard monad transformers in the transformers library except ContT. For convenience, it provides a wrapped version of Control.Exception with types generalized from IO to all monads in MonadPeelIO.

instance-map provides Template Haskell functions that help go from serialized values with value-level type witnesses (i.e. TypeRep values) to existential types containing type-level evidence of membership in a type class. It is useful for dealing with serialized values when only membership in a certain class (and not the monomorphic type) is known at the site of deserialization.

A command line utility for practicing typing and measuring your WPM and accuracy.

[Index] For package maintainers and hackage trustees

This package contains a universal CI/build script packcheck.sh and config files designed such that you can just copy over .travis.yml, appveyor.yml or .circleci/config.yml to your package repo and your package is CI ready in a jiffy. You can build and test packages on local machine as well. For local testing, copy packcheck.sh to your local machine, put it in your PATH, and run it from your package directory: You can try the script on this package itself. It builds and comprehensively sanity tests a Haskell package across build tools (stack/cabal), uniformly, consistently and across all platforms (Linux/MacOS/Windows). You do not need to be familiar with any of the build tools to use it. This is also a minimal yet complete model package (with tests, benchmarks, CI already working) that can be used as a starting point to develop a new package. Beginners can use it to learn about haskell package metadata structure, benchmarks, tests, CI configs etc. See the README for comprehensive documentation.

Deprecated in favor of tasty-golden This package provides support for «golden testing». A golden test is an IO action that writes its result to a file. To pass the test, this output file should be identical to the corresponding «golden» file, which contains the correct result for the test.

The Haskell Test Framework (HTF for short) lets you define unit tests (http://hunit.sourceforge.net), QuickCheck properties (http://www.cs.chalmers.se/~rjmh/QuickCheck/), and black box tests in an easy and convenient way. HTF uses a custom preprocessor that collects test definitions automatically. Furthermore, the preprocessor allows HTF to report failing test cases with exact file name and line number information. Additionally, HTF tries to produce highly readable output for failing tests: for example, it colors and pretty prints expected and actual results and provides a diff between the two values. The documentation of the Test.Framework.Tutorial module provides a tutorial for HTF. There is also a slightly out-dated blog article (http://factisresearch.blogspot.de/2011/10/new-version-of-htf-with-diffs-colors.html) demonstrating HTF's coloring, pretty-printing and diff functionality.

Cleanup and kill async threads.

Potrace bindings for the diagrams library. Converts images using the JuicyPixels library to create diagrams paths.

Generic library for vectors with statically known size. Implementation is based on <http://unlines.wordpress.com/2010/11/15/generics-for-small-fixed-size-vectors/> Same functions could be used to work with both ADT based vector like > data Vec3 a = a a a Tuples are vectors too: >>> sum (1,2,3) 6 Vectors which are represented internally by arrays are provided by library. Both boxed and unboxed arrays are supported. Library is structured as follows: * Data.Vector.Fixed Generic API. It's suitable for both ADT-based vector like Complex and array-based ones. * Data.Vector.Fixed.Cont Continuation based vectors. Internally all functions use them. * Data.Vector.Fixed.Mutable Type classes for array-based implementation and API for working with mutable state. * Data.Vector.Fixed.Unboxed Unboxed vectors. * Data.Vector.Fixed.Boxed Boxed vector which can hold elements of any type. * Data.Vector.Fixed.Storable Unboxed vectors of Storable types. * Data.Vector.Fixed.Primitive Unboxed vectors based on pritimive package. * Data.Vector.Fixed.Monomorphic Wrappers for monomorphic vectors

A library of algebra focusing mainly on commutative ring theory from a constructive point of view. Classical structures are implemented without Noetherian assumptions. This means that it is not assumed that all ideals are finitely generated. For example, instead of principal ideal domains one gets Bezout domains which are integral domains in which all finitely generated ideals are principal (and not necessarily that all ideals are principal). This give a good framework for implementing many interesting algorithms.

This package provides simple Haskell bindings for Compact Language Detector 2, a language-detection library used by Google Chrome. See https://code.google.com/p/cld2/ for more information on CLD2.

Allows you to use https:// without relying on apache, nginx, etc

Compose a list of a project's transitive dependencies with their licenses

Properties of functions and relations, perhaps for use with quickcheck

Fixing data-flow problems in expression trees. This should be useful if you want to write optimizations for your favorite programming language. See the Tutorial module for an introduction. After that, you might want to take a look at the examples/ folder in the repository.

Haskell OAuth2 authentication client. Tested with the following services: AzureAD: https://docs.microsoft.com/en-us/azure/active-directory/develop/v1-protocols-oauth-code Google: https://developers.google.com/accounts/docs/OAuth2WebServer Github: http://developer.github.com/v3/oauth/ Facebook: http://developers.facebook.com/docs/facebook-login/ Fitbit: http://dev.fitbit.com/docs/oauth2/ StackExchange: https://api.stackexchange.com/docs/authentication DropBox: https://www.dropbox.com/developers/reference/oauth-guide Weibo: http://open.weibo.com/wiki/Oauth2 Douban: http://developers.douban.com/wiki/?title=oauth2

This package provides a common API for serialization libraries like binary and cereal.

Interface to byte arrays with unaligned words

WebCont allows continuation based web programming to be integrated with Happstack, allowing step based interfaces along with traditional handlers. It is based on http://gist.github.com/260052

Parsers for the standard Haskell data types

Provides Word128, Word192 and Word256 and a way of producing other large words if required.