A tiny plotting library for Haskell, using gnuplot for rendering. Developed and tested using Mac OS X 10.7.3 with gnuplot 4.4 (via MacPorts). Compiles using GHC 7.0.4 Make sure gnuplot is in your path and everything should work. Some sample plots:

Low overhead value space Decoder on top of Aeson's Parser for combinator style decoding.

For package maintainers and hackage trustees This package provides simple utilities for starting a web server which serves some media. This makes serving media as easy as serve image. For example, here's how you serve a simple diagram: Currently yesod-media-simple supports serving the following media types: Diagrams, by using cairo to render to png. Just call serveDiagram :: Diagram Cairo -> IO (), or the more generic serve :: RenderContent a => a -> IO (). JuicyPixels images. Also includes utilities for putting JuicyPixels images in Diagrams and vice-versa.

A system-independent interface for user-level packet capture

Units of measure as a GHC typechecker plugin

REST resources for the Snap framework. As an example, let's translate the following datatype into a resource. We need a type to represent changes to the resource. This partial type indicates what properties to change: either the name, the age, or both. This type also acts as a search mechanism: we can search by names, ages, or both. We can use either a username or a UserPart search to find users, and define a function to convert URL query string parameters to this search. Now we have the pieces required to define our CRUD behaviour. If we've implemented Aeson instances, we can add JSON as a media format without having to define these manually. Once the behaviour is attached to the resource, it can be served in the handler.

Mathematics utilities and functions for Haskell, currently aimed at solving problems in Project Euler.

Use Template Haskell to read a file or all the files in a directory, and turn them into (path, bytestring) pairs embedded in your Haskell code.

Different functions which are used across multiple @serokell packages. Also contains style-guide.

DSL written in Haskell that provides a set of tools for working with both open and closed numeric intervals.

Fuzzy string search in Haskell

This package exports several splines and curves you can use to interpolate points in between.

This package implements a parser and writer for the Les-Houches event file format as described in hep-ph/0609017

Summarize API differences between revisions of Cabal packages. Precis library is BSD3, Precis executable is LGPL apropos the dependency on CppHs. NOTE for version 0.5.0 - the next version is likely to have substantial changes. Version 0.5.0 does have a better strategy to resolve conditional modules, but otherwise it is not a compelling upgrade. If you have 0.4.0 installed, I recommend you skip this revision and wait for the next version. CHANGES 0.4.0 to 0.5.0 Major re-organization. Module-to-file resolution substantially changed. Should be better for Cabal fines that use condition variables. 0.3.1 to 0.4.0 Substantial changes to reporting - now a summary is printed to the console, and an HTML report can be generated via a command line flag. Changed constructor names for Edit data type

Mid-level library to access MonetDB

Functor-lazy vectors perform the fmap operation in constant time, whereas other vectors require linear time. All vector operations are supported except for slicing. See http://github.com/mikeizbicki/vector-funxtorlazy for details on how this module works under the hood.

Alex is a tool for generating lexical analysers in Haskell. It takes a description of tokens based on regular expressions and generates a Haskell module containing code for scanning text efficiently. It is similar to the tool lex or flex for C/C++.

PastePipe reads from standard in and posts to lpaste.net. It will auto-detect your username, but that can be overridden with command line options (--user) Titles are set with -t, language with -l.

The library provides printing and parsing functions for positional tags and tagsets.

It turns out that this combinator is a powerful thing. It was abstracted from following (commonly used) pattern f . h . g where f and g are fixed. This library not only defines ~@~ combinator, but also some derived combinators that can help us easily define a lot of things including lenses. See lens package for detais on what lenses are. Function Data.Function.on can be implemented using ~@~ as: If function on3 existed in base then it could be defined as: Other usage examples and documentation can be found in Data.Function.Between module.

Email helper functions with some sane defaults such as a resource pool and cli support

Provides Resource and Catch effects capable of reacting to and catching GHC's dynamic exceptions.

An AST for linear equations and inclusive inequalities.

PCRE regex funs

a binding to the C-based CMPH library (http:cmph.sf.net).

A Haskell library for working with files and directories. Includes code for pattern matching, finding files, modifying file contents, and more.

Provides functions available in later versions of base to a wider range of compilers, without requiring you to use CPP pragmas in your code. See the README for what is covered. Also see the changelog for recent changes. Note that base-compat does not add any orphan instances. There is a separate package, base-orphans, for that. In addition, base-compat does not backport any data types or type classes. See this section of the README for more info. base-compat is designed to have zero dependencies. For a version of base-compat that depends on compatibility libraries for a wider support window, see the base-compat-batteries package. Most of the modules in this library have the same names as in base-compat-batteries to make it easier to switch between the two. There also exist versions of each module with the suffix .Repl, which are distinct from anything in base-compat-batteries, to allow for easier use in GHCi.

Based on the card game designed by Reiner Knizia. In this implementation you play against the computer.

All of `base` without the `Prelude` module

Support for working with Arch Linux packages. See also the cabal2arch tool http://hackage.haskell.org/package/cabal2arch for conversion between Hackage and AUR.

The hpc-codecov package contains an executable and library codes for generating Codeocv JSON coverage report from .tix and .mix files made with hpc. See the README for more info.

Given a term, this program calculates a set of "optimal" free theorems that hold in a lambda calculus with selective strictness. It omits totality (in general, bottom-reflection) and other restrictions when possible. The underlying theory is described in the paper "Taming Selective Strictness" (ATPS'09) by Daniel Seidel and Janis Voigtländer.

System.Posix.IO has very low-level bindings to POSIX fcntl advisory locks. This module wraps them in a cleaner API.

Opaque unique identifiers in primitive state monads and a GADT-like type using them as witnesses of type equality.

Ramus is a direct port of purescript-signal into Haskell, offering the Elm signal system for Haskell.

A template haskell utility inspired by the Intrinsic Superclasses Proposal, which allows defining all superclass methods at the "root" subclass of the heirarchy in one declaration, rather than an instance declaration per class. Also permits defining superclass method defaults with the subclass for greater flexibility than the DefaultSignatures extension

Two small example programs where SuperCollider is controlled by MIDI. Control parameters of a wind noise via MIDI controllers Use UGens as instruments, which will be played upon MIDI messages that arrive through ALSA. This way you can play MIDI files using pmidi or you can use your computer as MIDI expander controlled by a keyboard.

Haskell Wiki Library

A package exposing a helper function for generating smart constructors.

Orphan instances and other add-ons for the uuid package

Please see the README on GitHub at https://github.com/Axect/HNumeric#readme

An implementation of a Merkle tree and merkle tree proofs of inclusion

Rosa is a commmand line tool to query the namecoin blockhain. It gets the JSON value of a name and other infos using namecoind local server or the dnschain REST api and display them in a pretty format.

Uses type-level numeric literals to wrap StorableArray in a type that statically fixes its size. The wrapper has a Storable instance, for easy integration with fixed-size native arrays. Deprecated - use storable-static-array instead.

Deprecated A simple library for use creating 2D games, inspired by the Ruby library Tea.

This package contains full-featured string formatting function, similar to Python's string.format. Features include: * Automatically numbered variable placeholders; * Positional variable placeholders; * Named variable placeholders; * Placeholders can be used in any order; one variable can be used several times or not used at all. Specific format can be used for each variable substitution. This package prefers functionality over "light weight" and (probably) performance. It also exposes all required interfaces to extend and customize it. For more details, please refer to Wiki. See also the examples/ directory.

Please see the README on GitHub at https://github.com/ArturGajowy/ghc-clippy-plugin#readme

Just another tool that helps accessing the internet

Haskell code generator

Haskell tldr client with support for viewing tldr pages. Has offline cache for accessing pages. Visit https://tldr.sh for more details.

For package maintainers and hackage trustees Trigger is a cross platform file system watcher for super fast build-and-restart workflows. When files change, it can be configured to: fswatch and others are good general purpose tools for triggering tasks on filesystem changes. However, they don't support stopping and starting background processes. It's Haskell, so download Stack. Clone and run stack build --install This should install trigger on your PATH. If you get linking issues on Windows, see this issue Create a file named trigger.yaml Here is an example: Which consists of:

A console (text/terminal) based client for online encyclopedias such as Wikipedia.

This packages provides a subset of Happstack that is easier to learn but still very useful. It as 100% compatible with the full version of Happstack.

Generalized sleep and timeout functions

Musical time struture, voices, tracks and scores. This library is part of the Music Suite, see http://music-suite.github.io.

Provides functions to inspect and manipulate virtual hard disk (VHD) files, according to the VHD specification (version 1.0).

Task monad transformer can help refactor event and callback heavy programs into monads via co-routines. The idea is loosely based on Combining Events And Threads For Scalable Network Services, by Peng Li and Steve Zdancewic, in PLDI, 2007. (http://www.cis.upenn.edu/~stevez/papers/abstracts.html#LZ07), but with deterministic and co-operative lightweight threads, also known as co-routines, so that the base monad can be anything ranging from IO to state monads, or your favorite monad transformer stack.

RESTful API Modeling Language (RAML) library for Haskell

The Haskell'98 and Haskell'2010 standards define decimal, octal and hexadecimal integer literals. Binary literals are conspicuously missing. Here's a quasiquoter to remedy the situation.

Souffle Datalog bindings for Haskell.

Prime natural numbers - this package was automatically generated from the OpenTheory package natural-prime-1.81

Monokai colour theme for Yi. Check source for yi.hs usage.

This is a library for generating filler text (Lorem ipsum ...).

Ratel notifies Honeybadger about exceptions.

Multipath TCP (www.multipath-tcp.org) starting from version 0.95 provides a netlink path manager module. This package implements the userspace part to allow userspace daemons to control MPTCP behavior.

An executable and library to determine if a file is a DICOM file Exit codes: 0 - is DICOM file 1 - is not a DICOM file 2 - file does not exist 3 - file is not readable 4 - file is a directory

Lens for hw-json. Please see README.md

Another implemention of the EWE programming language originally created and developed by Kent D. Lee. EWE is an extension of the RAM programming language. RAM was created by Sethi.

This program is capable of finding duplicated files and turning one of them into a hard link to the other, effectively reducing the space usage (as the data will not be duplicated in the disk). It works only on POSIXish systems, and was tested in GNU/Linux only. WARNING: As the duplicated files will point to each other, if one of them is modified then the other will as well! You should use make-hard-links only if the files won't be modified, only renamed, removed, or created. The author had a Maildir with lots of duplicated files, and in his case make-hard-links was capable of reducing the space usage in 29% (as measured by du -hcs and du -hcs -l). As a final note, this program currently has a high memory usage as it has to maintain information about all the files that are possibly duplicates in memory at once (the author measured 1.7 GiB of memory for about 300.000 files).

ghcWithPackages cmdline util. supports: multiple ghc versions pure/impure nix-shell entering shell with multiple packages available

This package wraps glibc's crypt_r function in a thread-safe manner.

GDB/MI lets programs drive GDB. It can be used, for example, by GDB frontends. See section 27 of the GDB manual This module encapsualtes a GDB subprocess and provides an API to send commands as well as receive both responses and notifications. The actual GDB behavior diverges from the GDB manual in many points, so the implementation of the Machine Interface highly depends on the GDB version. This module is tested with GDB version 7.4.

A parser for SQL. Parses most SQL:2011 queries, non-query DML, DDL, access control and transaction management syntax. Please see the homepage for more information http://jakewheat.github.io/simple-sql-parser/latest.

A haskell interface to Lester Ingber's adaptive simulating annealing code

Parses connection strings in a manner that agrees with the format that .NET accepts (e.g. ADO.NET).

Express parametrable, composable and portable data pipelines

DataIndex can add index column to data files

Constraint Handling Rules

Light wrapper around errors from sqlite-simple to make working with constraint errors a bit easier.

I can't even be bothered with logging setup.

Encapsulating mutatable state in external libraries

Please see the README on Github at https://github.com/arbor/arbor-monad-metric#readme

One module layer over regex-posix to replace Text.Regex

Bitstream support for Conduit

Helps to order the 7 or less words (or their concatenations) to obtain somewhat suitable for poetry or music text. Can be also used as a research instrument with generalized functions.

Allows one to write programs that generate Haskell programs much more concisely and legibly. This package supports: Antiquotations, denoted by stealing the splice syntax of Template Haskell, for example [hs| $x ++ $(Hs.strE bar) |]. Splices may not nested. Antiquoting pattern variables in patterns, using double parentheses. For instance: Antiquoting bound names. Names that are antiquoted appear surrounded by double underscores. For instance: We need three different syntaxes for antiquotations, because we do not extend the haskell-src-exts parser in any way and the Template Haskell splicing syntax is only available in expression contexts.

urbit-airlock is a Haskell library that helps you connect to the Urbit API. Built on req, conduit, and aeson for stability and simplicity.

Haskell DSA implementation.

Labeled tree structure, on the model of the standard Data.Tree

Parses frontmatter as used in Jekyll markdown files. Provides a parser that'll parse the frontmatter only and one that'll execute a YAML parser on it, so that it's a YAML frontmatter parser.

A simple parser for OpenSCAD

Send metrics directly from Haskell to various monitoring and metrics services. Supported services are Ganglia, Graphite, and statsd. Please see http://github.com/brendanhay/network-metrics/blob/master/README.md for further information and usage.

Create Elm types and JSON decoders from Haskell source.

Instead of manual or semi-automated generation of instances of Data.Binary.Binary you just derive Data.Data.Data and the library automatically figures out how to (de-)serialize the type. You may also define your own type-specific stack of serialisation functions.