Provides an interface for parsing Nagios performance data formatted according to the plugin development guidelines.

A Pandoc filter for including code from source files

Small and flexible implementation of the dbus protocol.

DEPRECATED: this library is still fully functional, but please use cryptonite for new projects and convert old one to use cryptonite. This is where things are at nowadays. A collection of crypto hashes, with a practical incremental and one-pass, pure APIs, with performance close to the fastest implementations available in other languages. The implementations are made in C with a haskell FFI wrapper that hide the C implementation. Simple examples using the unified API: Simple examples using the module API:

Conduit bridge for cryptonite For now only provide a conduit version for hash and hmac, but with contribution, this could provide cipher conduits too, and probably other things.

A library of algorithms for coin selection and fee balancing.

A grab bag of functions for use with Template Haskell. This is basically the place I put all my ugly CPP hacks to support the ever-changing interface of the template haskell system by providing high-level operations and making sure they work on as many versions of Template Haskell as I can.

Support for file uploads in multipart/form-data for servant

This is a simple lexer which converts Haskell source code into tokins and back to ordinary haskell again.

Tail files in Unix, using hinotify.

A Browser based on WebKit, concepted to be easy to use and extendable.

A simple library for fast web prototyping in Haskell.

Fast robust numeric integration via tanh-sinh quadrature

Rasterific is a vector drawing library (a rasterizer) implemented in pure haskell. Can render vector graphics to an image and export vector data to PDF. [Index] [Quick Jump] Embed a reduced version of Linear avoiding a (huge) dep Use -f <flag> to enable a flag, or -f -<flag> to disable that flag. More info For package maintainers and hackage trustees Rasterific is a Haskell rasterization engine (a vectorial renderer) implemented on top of JuicyPixels. Rasterific bases its text rendering on FontyFruity. The renderer design is based on the Nile / Gezira renderer from the STEP project from the VPRI institute. The interesting thing about this renderer is the conciseness of it's implementation, providing antialiased rendering in the way.

This is very much a "bumping up" of the term-level spine view, c.f. Hinze's work and Emil Axelsson's hackage package syntactic. See the type-cereal and type-ord packages for use cases (ultimately supporting the yoko package).

See readme.md

Elm-street allows you to generate automatically derived from Haskell types definitions of Elm data types, JSON encoders and decoders. This helps to avoid writing and maintaining huge chunk of boilerplate code when developing full-stack applications.

An extension to Data.Serialize with built-in version control.

The maximum entropy method, or MAXENT, is variational approach for computing probability distributions given a list of moment, or expected value, constraints. Here are some links for background info. A good overview of applications: http://cmm.cit.nih.gov/maxent/letsgo.html On the idea of maximum entropy in general: http://en.wikipedia.org/wiki/Principle_of_maximum_entropy Use this package to compute discrete maximum entropy distributions over a list of values and list of constraints. Here is a the example from Probability the Logic of Science The classic dice example One can use different constraints besides the average value there.

A Haskell library for using Dozenal (Duodecimal - Base 12) numbers.

A Haskell interface to SUMP-compatible logic analyzers

System Test is a Haskell application which allows you to specify and run system tests of applications. Tests are defined in JSON files, whereby each test has a name, command, and expected output.

A package re-exporting the verified subset of containers

HaRP, or Haskell Regular Patterns, is a Haskell extension that extends the normal pattern matching facility with the power of regular expressions. This expressive power is highly useful in a wide range of areas, including text parsing and XML processing. Regular expression patterns in HaRP work over ordinary Haskell lists ([]) of arbitrary type. We have implemented HaRP as a pre-processor to ordinary Haskell. For details on usage, please see the website.

Expands type synonyms in Template Haskell ASTs

Please see the README on GitHub at https://github.com/groscoe/simple-units#readme

This package provides some stand-alone tools for Quipper, with demos for how to write more such tools.

Thread communication queues that group items/requests that occur close together in time

Representing and handling OPML subscription information. OPML (Outline Processor Markup Language) is an XML format for outlines, most commonly used to exchange lists of web feeds between web feed aggregators. http://www.opml.org/

Regular expression matching of Haskell types using nondeterministic finite automata.

Library for tagging IO actions and getting logs of total time spent per tag.

This is an implementation of the Stripe API as it is documented at https://stripe.com/docs/api

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.

Fraxl is a free monad designed to make concurrent data fetching easy.

This package provides a set of functions for creating and playing continuous animations of the form Time -> a. Finite animations (with a length) and infinite animations complement one another, we chose a representation of finite animations which has only a length (and not a starting point) to keep things simple. If needed such animations can be converted to infinite animations, combined, and clipped as required.

Ropes optimised for updating using UTF-16 code units and row/column pairs. This implementation uses splay trees instead of the usual finger trees. According to my benchmarks, splay trees are faster in most situations.

Function generation for Hedgehog

Functions that could be added to Data.Set.

Support for monitoring NTP server performance, including quering NTP system variables and system status.

This package wraps the mwc-random package and provides a convenient interface to invoke its functions from an effect stack.

Typically this is used as the return type of a combining comparison, which combines two values if they are deemed equal in some sense. Currently combining comparisons are used extensively by the AVL tree package (AvlTree).

Push ekg metrics to Amazon Cloudwatch

Client-side consumption of a ServerEvent.

This package provides Data.Sum, an open-union type, similar to the Union type that powers the implementation of Oleg Kiselyov's extensible-effects library. Unlike most open-union implementations, this type is very fast to compile, even when the type-level list of alternatives contains hundreds of entries. Membership queries are constant-time, compiling to a single type-level natural lookup in a closed type family, unlike the traditional encoding of Union, which relies on recursive typeclass lookups. As such, this type lends itself to representing abstract syntax trees or other rich data structures. This project is safe to use in production. Any performance problems at compile-time or runtime should be filed as bugs.

A library for reading Java class-files.

Please see the README on GitHub at https://github.com/Toucandy/data-index#readme

This library is intended to be used as a drop-in replacement for the primitive library in test environments. It adds bounds-checking to all functions in primitive that are able to cause segfaults. It is not recommended to use this library in production. However, if you are testing a library or application you wrote that uses primitive, you can temporarily replace your primitive dependency with primitive-checked, and your segfaults will become normal haskell exceptions that you can hunt down with GHC's stack trace facilities. The versioning for this library matches the version of primitive that is targeted. The first three digits of the version match the version of primitive. The fourth digit is used for bug fixes. This packages deviates slightly from the PVP in that functions can be added to the API with only a bump to the fourth digit.

Datatypes that I use as keys to index other data types. Here you will find a wrap of UUID and also constraints on Text so that it never exceeds a given number of characters.

This package includes definitions for Groups (Monoids with invertibility), including order calculations as well as finite, free, cyclic, and permutation groups. Additionally, we add the concept of Cancellative functors, building upon Alternative applicative functors. There are other group theory related packages on Hackage: groups: A minimal, low-footprint definition magmas: A pedagogical hierarchy of algebras, starting from Magmas, including Loops, and Inverse Semigroups. arithmoi: Number theory, typelevel modular arithmetic, and cyclic groups. This package, group-theory, tries to combine the best parts, while focusing on usability and intuitiveness.

A wrapper for the Irrlicht game engine allowing games to be written with functional reactive programming.

Provides extended yes command to reproduce phrases in Yes! Precure 5 or Yes! PreCure5 GoGo! See https://github.com/igrep/yes-precure5-command/blob/master/README.mkd for details.

Provides functions for reading in the signing keys from file and making up time-limited, signed URLS for accessing CloudFront-hosted files.

flAccurateRip is a command line tool to verify the accuracy of FLAC files ripped from CD, using the information contained in the AccurateRip™ database about other rips of the same CD. Usage: suppose you ripped a CD into track01.flac, track02.flac, ..., trackNN.flac. Open a shell in the directory containing the FLAC files, and run: If a pressing of this CD is present in the AccurateRip™ database, flaccuraterip will output the ripping accuracy for each track. If the CD was ripped without setting the drive offset, you should use the flag --with-sample-offset=N, where N is the offset indicated in http://accuraterip.com/driveoffsets.htm for your drive.

[Index] For package maintainers and hackage trustees Found the need to be able to create a time range in list form. Ended up writing a bunch of new types, functions, and some prisms, so here we are. Suggestions for the API, types, extra granularity or other such things is encouraged and appreciated. This is very much a WIP in library as it was created for a very specific need, but I thought others might find it useful. WIP WIP WIP WIP

[Index] For package maintainers and hackage trustees

Htzaar, an implementation of Tzaar ((c) 2007 Kris Brum), is a two player abstract strategy game played on a hexagonal board. Tzaar is the latest from the GIPF game series.

Happy is a parser generator for Haskell. Given a grammar specification in BNF, Happy generates Haskell code to parse the grammar. Happy works in a similar way to the yacc tool for C.

Empirical Mode decomposition and Hilbert-Huang Transform in pure Haskell.

A prototypical 2d platform game

Please see the README file on Github for more info

Please see the README at https://github.com/mlang/diagrams-braille#readme

Introduces a monad transformer and MTL-style class for open recursion.

Types used for natural language applications. Includes an internalized text type, BTI which represents internalized Text values with Ints.

Just size lens implementation.

Generates testcases from program-snippets in any language, with varables, that are substituted and a directed graph structure of the snippets and test hints

A small collection of X utilities useful when running XMonad. It includes: hxsel: which returns the text currently in the X selection; hxput: sets the value of the X paste buffer; hslock: a simple X screen lock; hmanage: an utility to toggle the override-redirect property of any window; and hhp: a simple utility to hide the pointer, similar to unclutter.

Autoexporter automatically re-exports modules.

Allows to send and receive Http requests using the HttpSpec specifications.

flatten a latex multi-file latex document and remove all comments

Skip lists provide efficient amortized indexing deep into lists by building an index that, essentially, converts the list into a balance binary tree. See the wikipedia entry on skip lists for more information.

TIP solver for simply typed lambda calculus. Can automatically infer code from type definitions. (TemplateHaskell)

Easy to use JSON parser fully supporting incremental parsing. Parsing grammar in applicative form. The parser is compatibile with aeson and its FromJSON class. It is possible to use aeson monadic parsing when appropriate. The parser supports constant-space safe incremental parsing regardless of the input data. In addition to performance-critical parts written in C, a lot of performance is gained by being less memory intensive especially when used for stream parsing. WARNING: 0.4.0.0 has code-breaking semantic changes, see changelog!

The Discrete Event System Sepcification (DEVS) formalism defines discrete event simulation models in a hierachical, modular manner.

Creating and extracting arbitrary archives.

This is a library for remotely controlling Java Swing desktop applications that have been instrumented with a special pianola agent. The agent exposes the Swing component hierarchy over the network, and accepts requests for generating GUI events. The library handles the interaction on the Haskell side.

Provides a utility to write server program which can be called via Perl's https://github.com/kazuho/p5-Server-Starter program using Haskell. This module does not provide a Haskell implementation of start_server, so you need to use the original Perl version or use a version ported to golang.

Generate sparkline graphs of hackage statistics

Please see the README on GitHub at https://github.com/alexkazik/qrcode/qrcode-juicypixels#readme

Records and prints out slow Hspec tests

Allows you to generate hexpat node trees using blaze syntax.

Hoobuddy parses the specified cabal project file and invokes hoogle to fetch databases for all specified dependencies merging the result into a default.hoo file in the current directory.

Interact with the IPFS network by shelling out to a local IPFS node or communicating via the HTTP interface of a remote IPFS node.

Awesomium (http://awesomium.com) is a windowless port of Chromium/Webkit. You can integrate it with your program, and write all of your UI with HTML/CSS/JS. If you plan to integrate Awesomium with GLUT you can also check out this package (http://hackage.haskell.org/package/awesomium-glut).

[Index] [Quick Jump] Use bundled C sources. It is unstable due to the GHC bug. Use -f <flag> to enable a flag, or -f -<flag> to disable that flag. More info For package maintainers and hackage trustees

This package provides expectations for use with hspec that use Template Haskell to assert that a value matches a particular pattern. The primary expectation is shouldMatch: Additionally, any bindings created by the pattern will be returned if the pattern is successfully matched, making it easier to extract the result of some assertion and use it to make further assertions.

Manage multiple configuration profiles for the same program. Swap out dot files quickly.

Facilities for manipulating Core Erlang source code: an abstract syntax, parser and pretty-printer.

This package is a fork of pandoc-types intended to support the development of Scholdoc. It includes some non-trivial extensions to the Pandoc types and builder functions that are not easily implemented by depending on and extending the pandoc-types modules. This package is currently up to date with pandoc-types version 1.12.4 For descriptions of the original pandoc-types package, please visit http://hackage.haskell.org/package/pandoc-types

Run forms defined using digestive functors with Spock

[Index] For package maintainers and hackage trustees

This is the text templating system used by pandoc. It supports variable interpolation, iteration, tests for non-blank values, pipes, and partials. Templates are rendered to doclayout Docs, and variable values may come from a variety of different sources, including aeson Values.

This is an alternative to Prelude that is not meant to depart drastically from the standard. The principles of Hydrogen are: 1. Be total, not partial. 2. Use Data.Text.Text, not Data.String.String. 3. Use generic functions, not Data.List functions. 4. Whatever is omitted should be replaced. To use this package, use the NoImplicitPrelude language option, and import H.Prelude.

Evaluate Haskell expressions using Nix to get packages.

Lets you quickly run ssh on a machine that you have an sshfs connection to. It works out the username, host and the directory on the host based on the current directory and the output of mount.

Code highlighting for cmark