push-notify-apn is a library and command line utility that can be used to send push notifications to mobile devices running iOS. Push notifications are small messages that can be sent to apps on smart phones and tablets without the need to keep open a long lived TCP connection per app, dramatically reducing the power consumption in standby mode.

This snaplet contains support for using the Postgresql database with a Snap Framework application via the postgresql-simple package. It also includes an authentication backend.

Please see README.md

Deprecated in favor of markdown This library leverages existing high-performance libraries (attoparsec, blaze-html, text, and conduit), and should integrate well with existing codebases.

The source package contains efficient general-purpose implementations of various basic immutable container types. The declared cost of each operation is either worst-case or amortized, but remains valid even if structures are shared. Here we redistribute it, but with hidden modules exposed.

Provides core types to work with CoreNLP, SyntaxNet. Handling CoNLL format and Syntax Trees.

An alternative haskell prelude

A Pandoc filter that replaces code blocks (that have the class table) with tables generated from CSV. The CSV is read from the code block and from an optional external CSV file and concatenated. There's a flag to enable parsing of inline markdown.

This is an experimental library for multidimensional arrays, oriented to support simple tensor computations and multilinear algebra. Array dimensions have an "identity" which is preserved in data manipulation. Indices are explicitly selected by name in expressions, and Einstein's summation convention for repeated indices is automatically applied. The library has a purely functional interface: arrays are immutable, and operations typically work on whole structures which can be assembled and decomposed using simple primitives. Arguments are automatically made conformant by replicating them along extra dimensions appearing in an operation. There is preliminary support for Geometric Algebra and for solving multilinear systems. A tutorial can be found in the website of the project.

This package makes it possible to define schemas for use when loading configuration files using the config-value format. These schemas can be used to process a configuration file into a Haskell value or to automatically generate documentation for the file format.

Lightweight and performance implementation of optics — lenses, prisms, traversals. The library uses hardcore abstractions internally, but provides beginner-friendly, composable and convenient interface for working with data structures.

Slices of ByteArray and MutableByteArray

hledger-diff is a command-line utility to compare two journal files. It looks at the transactions of a single account and prints out the transactions which are in one journal file but not in the other. This is useful for reconciling existing journals with bank statements.

Parsers and printers for bencoded data. Bencode (pronounced like B encode) is the encoding used by the peer-to-peer file sharing system BitTorrent for storing and transmitting loosely structured data.

A library of looping constructs with continue and exit control flow statements.

This package provides functions to easily generate bindings for DBus functions. See Test.hs for examples.

This library enables fast and safe streaming of byte data, in either Word8 or Char form. It is a core addition to the streaming ecosystem and avoids the usual pitfalls of combinbing lazy ByteStrings with lazy IO. We follow the philosophy shared by streaming that "the best API is the one you already know". Thus this library mirrors the API of the bytestring library as closely as possible. See the module documentation and the README for more information.

ISO 3166 country codes and i18n names.

This Haskell library provides an implementation of the Davis-Putnam-Logemann-Loveland algorithm (cf. http://en.wikipedia.org/wiki/DPLL_algorithm) for the boolean satisfiability problem. It not only allows to solve boolean formulas in one go but also to add constraints and query bindings of variables incrementally.

A simple snaplet based off of snaplet-fay but for CoffeeScript.

Hoed is a tracer and debugger for the programming language Haskell. To locate a defect with Hoed you annotate suspected functions and compile as usual. Then you run your program, information about the annotated functions is collected. Finally you connect to a debugging session.

Please see README.md

A programmable LALR(1) parser builder system. Please see the README on GitHub at https://github.com/kwanghoon/yapb#readme

This library lets you remotely monitor a running process over HTTP. It provides a simple way to integrate a monitoring server into any application. This is a port of the ekg library to depend on wai instead of snap.

OpenGL support for the vect low-dimensional linear algebra library.

There are plenty of memoizing libraries on Hackage, but they usually fall into two categories: Store cache as a flat array, enabling us to obtain cached values in O(1) time, which is nice. The drawback is that one must specify the size of the array beforehand, limiting an interval of inputs, and actually allocate it at once. Store cache as a lazy binary tree. Thanks to laziness, one can freely use the full range of inputs. The drawback is that obtaining values from a tree takes logarithmic time and is unfriendly to CPU cache, which kinda defeats the purpose. This package intends to tackle both issues, providing a data type Chimera for lazy infinite compact streams with cache-friendly O(1) indexing. Additional features include: memoization of recursive functions and recurrent sequences, memoization of functions of several, possibly signed arguments, efficient memoization of boolean predicates.

See README at https://github.com/athanclark/websockets-simple#readme

Additional type-level operations on GHC.TypeLits.Nat: Max: type-level max Min: type-level min Div: type-level div Mod: type-level mod FLog: type-level equivalent of integerLogBase# i.e. the exact integer equivalent to floor (logBase x y) CLog: type-level equivalent of the ceiling of integerLogBase# i.e. the exact integer equivalent to ceiling (logBase x y) Log: type-level equivalent of integerLogBase# where the operation only reduces when floor (logBase b x) ~ ceiling (logBase b x) GCD: a type-level gcd LCM: a type-level lcm And a custom solver for the above operations defined in GHC.TypeLits.Extra.Solver as a GHC type-checker plugin. To use the plugin, add the pragma to the header of your file.

Stand-alone command-line version of the pointful plugin for Lambdabot.

This library provides a type IReal of real numbers and intervals with arbitrary precision arithmetic, instance declarations for the standard numeric classes, Eq and Ord (the two latter non-total for computability reasons). Significantly more efficient than other Haskell modules for exact real arithmetic that we are aware of. Does not depend on non-Haskell libraries. A QuickCheck test suite, documentation, and a number of small example applications in validated numerics are available at https://github.com/sydow/ireal.git.

Shake rules to minify CSS and JS files. shake-minify doesn't require any external tools to be on the $PATH and uses native Haskell CSS and JS minifiers.

This module offers opinionated helpers to declare a type-safe and a flexible pagination mecanism for Servant APIs. This design, inspired by Heroku's API, provides a small framework to communicate about a possible pagination feature of an endpoint, enabling a client to consume the API in different fashions (pagination with offset / limit, endless scroll using last referenced resources, ascending and descending ordering, etc.)

Atomically write to a file on POSIX-compliant systems while preserving permissions. On most Unix systems, mv is an atomic operation. This makes it simple to write to a file atomically just by using the mv operation. However, this will destroy the permissions on the original file. This library does the following to preserve permissions while atomically writing to a file: If an original file exists, take those permissions and apply them to the temp file before mving the file into place. If the original file does not exist, create a following with default permissions (based on the currently-active umask). This way, when the file is mv'ed into place, the permissions will be the ones held by the original file. This library is based on similar implementations found in common libraries in Ruby and Python: Ruby on Rails includes a similar method called atomic_write Chef includes atomic update functionality There is a python library for atomically updating a file To use atomic-write, import the module corresponding to the type you wish to write atomically, e.g., to write a (strict) ByteString atomically: Then you can use the atomicWrite function that accepts a FilePath and a ByteString, e.g.:

This is a set of tools that is supposed to fill all your Puppet needs : syntax checks, catalog compilation, PuppetDB queries, simulation of complex interactions between nodes, Puppet master replacement, and more !

Mandelbrot Set fractal explorer using the ruff library. Requires GTK, OpenGL, and GLSL fragment shader support; lots of RAM and multiple CPU cores recommended. If you want to explore very deep zooms, you'll need hmpfr which currently requires GHC to be compiled with integer-simple instead of the default integer-gmp. To install with MPFR support, use cabal install gruff -fmpfr. Note that the default setting for this flag has changed since gruff-0.2. gruff-0.3.4 updates dependencies for ghc-7.8. Colouring is improved. gruff-0.3.3 relaxes dependencies for ghc-7.6. gruff-0.3.1 is a bugfix release, fixing a performance problem wherein offscreen tiles were needlessly calculated. The performance gain is much less (and in many cases is in fact a performance loss) when using integer-simple. gruff-0.3 includes a small library to allow external programs to create diagrams and animations with gruff. See the gruff-examples package. The interface has been remodelled to simplify it and add informative feature overlays. gruff-0.2.1 was a bugfix release. Changes since gruff-0.2: Supersampling bugs are fixed (no more undocumented quantization leading to inconsistent appearance at different zoom levels). Race condition bugs in cache management are fixed (no more incompletely rendered images). Internal changes/refactoring to make future additions easier. Features in this version include: Interactive fractal browser display with mouse controls: Left click to zoom in (press shift for bigger jumps). Right click to zoom out (press shift for bigger jumps). Middle click to center. Shift middle click to auto-focus. Control left click to label with period. Control right click to label with angled internal address (slow!). Session persistance (stored in ~/.gruff/state.gruff - states can also be loaded from and saved to other files, including labels and rays). Note that the file format is incompatible with previous releases of gruff. Tile cache (by default in ~/.gruff/cache - symlink it somewhere with a few GB of space if you plan on exploring a lot). Can use MPFR if desired for higher precision, allowing deeper zooms and locating high period nucleii. Limited amount of customizable colouring (colours for interior, border, and exterior points, as well as labels and rays). Supersampling for more detailed images (useful range is 1 to 16). Rudimentary scripting support (see the gruff-examples package). Future versions will focus on enhancing the scripting support.

hpyrg is a pyrg analog written in Haskell. pyrg is an utility which colorizes Python unittest module's unit tests output. It has a few fatal flaws: It cannot into lazy IO It cannot into really verbose colorization To address these issues there is hpyrg.

It provides a convenient way of sending string input to a subprocess and reading output from it lazily. It requires the Posix module and has been tested under ghc5 so far.

WAI middleware to automatically encrypt and sign cookies

Please see the README on GitHub at https://github.com/parsonsmatt/persistent-pagination#readme

HTTP/2.0 library including frames and HPACK. Currently HTTP/2 16 framing and HPACK 10 is supported.

Charade is a tool for rapid website prototyping using Heist and Snap. Charade-generated sites can easily be dropped into Snap applications and work out of the box with no modification. The main thing provided by this package is the charade executable that serves your prototype sites. The library provided contains a Heist splice that you use to make all evidence of charade disappear in your production app. For more information, see the README: https://github.com/soostone/charade/blob/master/README.md

This package provides a mutable, singly-linked list type for use in STM. It is based on the design of Control.Concurrent.TChan, and can be used to implement a wide variety of channel types.

L-Estimators for robust statistics

See the README.md file and the homepage for details.

Please see the README on GitHub at https://github.com/oisdk/lean-peano#readme

This tool allow you sanity check the history of local git repository. A sane history is one where there is no interleaved merged.

Extensions to Pandoc syntax highlighting

Extract interesting commands and add them to a text file. "Interesting" means not matching any regular expression in the file. This allows one to keep a textual database of commands. Never again say "I wish I remembered what arguments to give wibble to make it flibber the gibbet" three months after you looked it up. WARNING: historian truncates ~/.bash_history.

Functions that should have been in Debug.Trace

Process lists easily

This tool permits browsing of users, changing their roles, and other features.

Now. Implemented only following features. Paragraph, header, code, list, image Not yet implemented following features. newline, bold, quote, link, horizontal line

Unofficial CLI client for the Kattis online judge system (currently in BETA). Written in a git-like fashion, it supports automatic downloading of test cases, easy submissions, and more. Basically a problem is initialized as follows (creates a directory and downloads any available test cases): Source files, problem names, and language identification is handled automatically when submitting solutions: There is also built-in support for problem sessions, which initalizes all problems in the problem list. Get started by downloading a .kattisrc config from the official site, make sure you have the haskell platform installed, then run cabal install katt. Please note that the beta release is limited to C, C++, Java, and Haskell. It also only supports running on unix. Changes since last release: Support for Haskell submissions HTTP client replaced with wreq Improved code readability

Nonstandard parsers for the syntax defined in RFC2822, forked from hsemail proper. Should not be used for parsing incoming emails, only emails stored on disk.

Visualize the graph-rewrite steps of a Haskell program. Currently it only shows the right-hand-sides of rewrite rules (function alternatives).

[Index] For package maintainers and hackage trustees A monad transformer for tracing error provenience. If you want a nice example of how to use it, this bidirectional type checker provides a very nice example and motivation.

Framework-agnostic pagination boilerplate.

generalized Algebraic Dynamic Programming ADPfusion combines stream-fusion (using the stream interface provided by the vector library) and type-level programming to provide highly efficient dynamic programming combinators. ADPfusion allows writing dynamic programs for single- and multi-tape problems. Inputs can be sequences, or sets. New input types can be defined, without having to rewrite this library thanks to the open-world assumption of ADPfusion. The library provides the machinery for Outside and Ensemble algorithms as well. Ensemble algorithms combine Inside and Outside calculations. Starting with version 0.4.1 we support writing multiple context-free grammars (interleaved syntactic variables). Such grammars have applications in bioinformatics and linguistics. The homepage provides a number of tutorial-style examples, with linear and context-free grammars over sequence and set inputs. The formal background for generalized algebraic dynamic programming and ADPfusion is described in a number of papers. These can be found on the gADP homepage and in the README. Note: The core ADPfusion library only provides machinery for linear language over sequences. The add-ons ADPfusionSubword, ADPfusionForest, and others provide specialized machinery for other types of formal languages.

Demo for displaying operation of ROC online clustering.

This package defines the classes Var and MTuple of variables and tuples mutable within appropriate monads, as well as some instances of these classes.

This is a demonstration of GLFW-b (http://hackage.haskell.org/package/GLFW-b) allowing the user to interact with colorful spinning gears using cursor keys, mouse, scroll wheel, and joystick. Here's a screenshot: http://i.imgur.com/JZKwVSu.png

hscope is a partial cscope line oriented mode reimplementation for Haskell code. Currently it supports finding the definition and callers of the function, types. Also works searching for files and in files. See hscope --help for available options. Being cscope-compatible gives Vim integration for free. Use :set cscopeprg to configure hscope as cscope replacement for haskell files.

A Haskell binding to the X11 graphics library. The binding is a direct translation of the C binding; for documentation of these calls, refer to The Xlib Programming Manual, available online at http://tronche.com/gui/x/xlib/.

A library wrapping Prelude/Data.List functions that can throw exceptions, such as head and !!. Each unsafe function has up to four variants, e.g. with tail: tail :: [a] -> [a], raises an error on tail []. tailMay :: [a] -> Maybe [a], turns errors into Nothing. tailDef :: [a] -> [a] -> [a], takes a default to return on errors. tailNote :: String -> [a] -> [a], takes an extra argument which supplements the error message. tailSafe :: [a] -> [a], returns some sensible default if possible, [] in the case of tail. This package is divided into three modules: Safe contains safe variants of Prelude and Data.List functions. Safe.Foldable contains safe variants of Foldable functions. Safe.Exact creates crashing versions of functions like zip (errors if the lists are not equal) and take (errors if there are not enough elements), then wraps them to provide safe variants.

Multidimentional array library build on top of the vector package, using indices from the linear package. Native support for mutable arrays, stencils and parallel computation.

A library for deriving JSON parsers (using Aeson) by indicating JSON structure at the type level.

This package allows you to create vty terminal applications using frpnow's frp interface. A demo executable is also included to show how to use this library.

Data types representing the digits zero through nine. Each of the following modules defines a different type named D10, all of which are different representations of the same concept: Data.D10.Char - Defines a D10 type as a newtype for Char, where the values are restricted to characters between 0 and 9. Data.D10.Num - Defines a D10 type as a newtype for any type with an instance of the Num class, where the values are restricted to numbers between fromInteger 0 and fromInteger 9. Data.D10.Safe - Defines a D10 type as D0 | D1 | D2 | ... | D9. Other modules: Data.D10.Predicate - Functions to test whether values of various types represent digits in the range 0 to 9. Each module that defines a D10 type also defines quasi-quoters for it. With the QuasiQuotes GHC extension enabled, a single digit like 7 can be written as [d10|7|], and a list of digits like [4,5,6] can be written as [d10|456|]. For Data.D10.Char and Data.D10.Num, the quasi-quoters are an important feature, because the D10 types defined in these modules have unsafe constructors, and the quasi-quoters provide compile-time assurance that we never construct a D10 that represents a value outside the range 0 to 9. For Data.D10.Safe, the quasi-quoter is offered merely as a possible convenience, allowing you to write [d10|456789|] in place of the somewhat longer expression [D4,D5,D6,D7,D8,D9].

Deprecated This package has been removed.

For package maintainers and hackage trustees

A parser for DSON strings built with parsec3.

Constructs FAlgebras from typeclasses, making Haskell functions homoiconic

strict functions that should be in base

An API for parsing "aeson" JSON tree into Haskell types

Control.Lens Strict, Wrapped, Magnify and Zoomed instances for the stricter WriterT and RWST from writer-cps-transformers.

AMQP tools consisting of: AMQP consumer which can create a temporary queue and attach it to an exchange, or attach to an existing queue; display header and body info; save message bodies to files; call a callback script. AMQP publisher with file, line-by-line and hotfolder capabilities. AMQP rpc client and server.

This library provides data types and combinators that allow you to declare, encode, and decode the IAM JSON policy language with a modicum of safety, minus any extreme type-level features. The IAM policy documents can be safely constructed via the provided datatypes and mapped, folded, and traversed via the provided instances, combinators, and lenses. The resulting structure can then be encoded as a valid IAM JSON policy document for using with Amazon IAM and related services. The details of what goes into a policy vary for each service, depending on what actions the service makes available, what types of resources it contains, and so on. When you're writing policies for a specific service, it's helpful to see examples of policies for that service. View the AWS Services That Work with IAM documentation for more information. See Amazonka.IAM.Policy to get started.

Usage: markdown2svg foo.md Usage: markdown2svg --help Now. Implemented only following features. paragraph, header, code, list, image Not yet implemented following features. newline, bold, quote, link, horizontal line

Note: This is experimental! If you are looking for a stable solution for testing Haskell code, try Hspec: http://hspec.github.com/

Flexible password generator. For each service, passwords are generated deterministically from a main password and a code. Internally, Scrypt is used to obtain the hash generating the passwords.

A collection of user agents, easily select a random one.

This package contains utilities for solving SDE instances in various ways. Basically an SDE instance is solved using some SDESolver working with some distribution mechanism. Results are gathered at the end point of the specified interval. Included in the package are ways of doing distributed calculations over an MPI cluster, or optionally only using the local solver with built in parallelization. Two SDE instances have been implemented; geometric brownian motion and the Langevin equation, see the haddock documentation for an example. The main interface is accessible through Numeric.DSDE which provides various way of solving generic problems. This module supports either local or distributed calculations in the IO monad and gathering the results as a distribution. Under the surface there is also a working pure implementation for monadic environments, using a pure Mersenne twister PRNG. Internally there are several abstractions used when dealing with each component building up a solution. Given some SDE and SDESolver instances, it is also required to have some PRNG providing normally distributed numbers. This has been implemented over some specific monads and only results of type Double. All of the internal components are written with polymorphism in mind, acting over some monad instance and generic result types in all cases.

This package takes modules parsed with haskell-src-exts, resolves used names and annotates the parsed module with scoping information.

A program and a library that show a sorted list of the Ukrainian sounds representations that can be used by mmsyn7 series of programs

Run the selenium standalone server for usage with webdriver

A command line program for extracting data from the Mathematics Genealogy Project (http://genealogy.math.ndsu.nodak.edu/index.php). Note that this database also contains many entries of computer scientists. Lookup your entry at http://genealogy.math.ndsu.nodak.edu/index.php and then use that URL as a command line argument. For example, if Carl Gauss wanted to explore his academic ancestors, he would type which produces the directed acyclic graph http://dl.dropbox.com/u/22490968/genealogy_of_gauss.svg. See for the complete list of options. Requires the dot program, which is part of the GraphViz package (version 2.28.0 or later!) to run. Feedback and bug reports are appreciated! Changes in 1.3.0: Switched to HTML-like labels in GraphViz. This is required for the advanced font formatting options. ATTENTION: this needs a recent installation of GraphViz (Linux: 2.28.0; MacOS: 2.29) and will yield best results for SVG output files. If you have an older version of GraphViz or run into issues, try the --oldtextlabels option. Downloaded entries are stored locally. This avoids re-downloading the same data if you want to generate multiple graphs of the same entry with different formatting options. Added more options for fine-tuning the fonts and colors. (requested by users) Default output is now SVG, as this is the format best supported by GraphViz. Changes in 1.2.0: Fixed handling of entries that have multiple degrees. (reported by Dima Pasechnik) Changes in 1.1.1: Provide error message when given invalid start URL Documentation and code cleanup Changes in 1.0.0: Choice between PDF and PNG output Optional inclusion of PhD theses in output Changes in 0.0.2: Fixed handling of trailing commas (reported by Alexander Koessler)

SVG renderer that will let you render svg-tree parsed SVG file to a JuicyPixel image or Rasterific Drawing.

Partial isomorphisms

Mid-level SQLite client library, based on postgresql-simple. Main documentation (with examples): Database.SQLite.Simple You can view the project page at http://github.com/nurpax/sqlite-simple for more information.

The lazy DFA engine, based on CTKLight, for regex-base

Low level bindings to libusb-1.*: http://libusb.sourceforge.net/api-1.0/ This package uses bindings-DSL and conforms to its naming convention. For a higher-level and more Haskell friendly binding (which uses this package) see the usb package: http://hackage.haskell.org/package/usb

At last, a module that combines the dynamic flexibility of Haskell with the strong design principles of PHP!

Lie Algebras in Haskell

The functions of this package helps loading GPipe textures from file. It is based on the stb-image package, and supports subsets of the JPG, PNG, TGA, BMP and PSD formats.

gitlib is a high-level, lazy and conduit-aware set of abstractions for programming with Git types.

[Index] [Quick Jump] For package maintainers and hackage trustees