NSIS (Nullsoft Scriptable Install System, http://nsis.sourceforge.net/) is a tool that allows programmers to create installers for Windows. This library provides an alternative syntax for NSIS scripts, as an embedded Haskell language, removing much of the hard work in developing an install script. Simple NSIS installers should look mostly the same, complex ones should be significantly more maintainable.

Fast, memory-efficient, low-level socket functions that use Data.ByteStrings instead of Strings.

Deprecated API for generating reactive objects

An extremely customizable error pretty printer that can handle many kinds of error formatting. It can handle errors that are connected, disconnected, and those spanning multiple lines. You can get started by importing the Errata module.

Library with convenient assertions for QuickCheck properties like in HUnit

Falling Turnip is an interactive particle simulation. Like others in the same genre (typically dubbed falling sand games), it has some degree of approximation for gravity, fluid flow and alchemical reactions. Unlike the others, it is based entirely on cellular automata and runs in parallel. A short demo video is available here: http:youtu.be/hlL9yi2hGx0

crunghc is a program that acts like runghc. When it executes a Haskell script, it automatically stores a compiled cache of the script to the disk, so that the compilation overhead can be avoided in subsequent runs.

manatee-curl is multithreads download manager extension for Manatee (Haskell/Gtk+ Integrated Live Environment) Default configuration template at Config/Curl.hs, copy to directory HOME/.manatee/config/. Note, you need re-install package to start the configuration file take effect the next time, Video (Select 720p HD) at : http://www.youtube.com/watch?v=weS6zys3U8k http://www.youtube.com/watch?v=A3DgKDVkyeM http://v.youku.com/v_show/id_XMjI2MDMzODI4.html Screenshots at : http://goo.gl/MkVw Manual at : http://haskell.org/haskellwiki/Manatee IRC channel: irc.freenode.net 6667 ##manatee Mailing-List: manatee-user@googlegroups.com manatee-develop@googlegroups.com

The library extends the numeric types with an array-like interface over individual set bits. It also provides an API for conversion to and from the binary notation.

A package for creating plots, built on top of the Cairo rendering engine. An ambitious attempt to replace gnuplot. Monadic actions are used to configure a figure, which is a (rxc) array of subplots. Each plot displays a graph with optional heading, labels, legend, and annotations. The annotations themselves may be used to draw diagrams. A figure is preprocessed in preparation for rendering by the Cairo renderer. The Cairo library can be used to output the figure to PS, PDF, SVG, and PNG file formats, or to display the figure in a GTK Drawable context. (see package plot-gtk). The preprocessed figure can be embedded as an arbitrary Cairo render, including in a diagram created with the diagram package. Conversely, arbitrary Cairo renders can be embedded in the data region of a Figure. The data series are type Data.Packed.Vector from hmatrix, which, when hmatrix is compiled with -fvector, is a synonym for Data.Vector.Storable from the vector package and are thus compatible with packages such as statistics. The example in Graphics.Rendering.Plot can be viewed at http://code.haskell.org/plot/examples/perturbed-sine.png

UnitTyped is a Haskell library that makes it possible to do computations on values with a dimension and a unit. The typechecker ensures that all operations are using the proper dimensions, and all units can be converted to compatible units automatically. New dimensions and units can be defined from other modules, requiring just a data type and one class instance to work with everything else. The library comes with all SI dimensions and units, and many units derived from those.

Small and simple library for computing values of Theta functions. They're the special functions of two variables. Described very well at https://en.wikipedia.org/wiki/Theta_function. Library exports four theta-functions and a small helper to calculate their second parameter. Theta functions are functions of Complex variables, FYI.

This packages defines a list data type with statically known length by nesting the NonEmpty and Empty data structure from the non-empty package. We provide a closed world class for this class of structures http://www.haskell.org/haskellwiki/Closed_world_instances and a wrapper that makes all these lists Traversable and Applicative with ZipList semantics. Similar packages: fixed-list: Defines an open world class.

Fast ByteString Builder

A sane and simple API that sits on top of the time library; it allows the creation of time intervals and provides to manipulate time using them.

simple radixtree implementation for parsing purposes

Koen Claessen's PPP, Modified.

A graph type, analysis of graphs and manipulation of graphs.

Compute a CRC16 checksum of some bytes using a lookup table. This table matches the particular CRC flavor used by Crystalfontz LCDs. If you can extend this code to suit another application, or have any other improvements, please send me suggestions or patches.

You can create your processors with your own instruction set and cpu simulator and development tools. Feature: easy try, easy modify a purely functional CPU core (without IO) (you can embed it anywhere) including a very simple prototype assembler including a very simple prototype debugger including a very simple prototype profiler

Display GHC core using a friendly colored, clickable and dynamic html output

MonadTime type class for monads which carry the notion of the current time.

Please see the README on Github at https://github.com/Fuuzetsu/ghc-prof-aeson-flamegraph#readme

For package maintainers and hackage trustees

Please see README.md at https://www.stackage.org/package/servius

This package provides a convenient and fast alternative to the common `forM_ [1..n]` idiom, which in many cases GHC cannot fuse to efficient code. See https:ghc.haskell.orgtracghcticket8763.

Please see the README on GitHub at https://github.com/harporoeder/concurrent-batch#readme

This library contains: A small specialized subset of the *singletons* library as it pertains to Nat and Symbol, for when you need some simple functionality without wanting to invoke the entire *singletons* library. Operations for manipulating these singletons and KnownNat and KnownSymbol instances, such as addition and multiplication of singletons/KnownNat instances. Operations for the comparison of Nats in a way that works well with GHC.TypeLits*'s different comparison systems. This is helpful for bridging together libraries that use different systems; this functionality is not yet provided by *singletons*.

Lua bytecode parser

polydirectional maps for Haskell

A (very preliminary) library to access the Dropbox HTTP API: https://www.dropbox.com/developers/reference/api

The classic Metropolis sampling algorithm.

ENet is a networking library on top of UDP. In it's own words: "ENet's purpose is to provide a relatively thin, simple and robust network communication layer on top of UDP (User Datagram Protocol). The primary feature it provides is optional reliable, in-order delivery of packets. ENet omits certain higher level networking features such as authentication, lobbying, server discovery, encryption, or other similar tasks that are particularly application specific so that the library remains flexible, portable, and easily embeddable." This library contains both bindings and a slightly cleaned up interface on top. The bindings are as close to the original as possible. Names are striped of the leading 'enet_' and converted to CamelCase, and the occasional newtype is used instead, but otherwise all functions signatures are exactly the same. The bindings are in 'Network.ENet.Bindings'. The higher level interface is all other exposed modules. Functions like 'enet_host_*' are placed in 'Network.ENet.Host'. All functions are present except for the 'enet_socket*' functions: they are just wrappers of the Posix Sockets Interface, which is already provided in Haskell by the 'network' package. Changes are fairly minimal: "Out-Args" are now returned with a tuple, conversions between C and Haskell types happen automatically (when Haskell versions exists), and nullable pointer types have been replaced with Maybes. In short, there should be very few reasons to use the raw bindings over the "nice" interface. At the moment, consult the ENet website for documentation. In the vast majority of cases the documentation there should apply here exactly, I will try to add Haddock documentation for everywhere it does not. ENet currently only supports IPv4 at the moment (though that should soon change), and must be called from only one bound thread (i.e. thread created with 'forkOS'). Richer native networking libraries leveraging Haskell's strengths exist, and for new projects I'd recommend those. But for interfacing with existing protocols using ENet, this package should be quite useful.

This package provides "orphan" IsList instances for Array data types with Integral indices up to 5 dimensions to allow initializing Arrays from [nested] lists using OverloadedLists GHC extension. It also includes more generic arrayNestedList and toNestedList functions to convert between nested lists and Arrays with any indices.

Sort Simplified Chinese by pinyin

eventlog2html is a library for visualising eventlogs. At the moment, the intended use is to visualise eventlogs which have heap profiling events, as a replacement to hp2ps and hp2pretty. eventlog2html creates a static webpage which contains a collection of different interactive charts for analysing heap usage. Trace events are displayed on the chart and the charts can be zoomed, scrolled and filtered to give a more exploratory feel to heap profile analysis.

Write software defined radio applications in Haskell. Features: Signal processing blocks can be chained together using the Pipes library Zero copy design Signal processing functions are implemented in both Haskell and C (with SIMD acceleration) Can FIR filter, decimate and resample Helper functions for FIR filter design using window functions and plotting of the frequency response FFTs using FFTW Line and waterfall plots using OpenGL FM demodulation PulseAudio sound sink rtl-sdr and BladeRF based radio sources/sinks supported and other sources are easily added See https://github.com/adamwalker/sdr for more features and screenshots. A collection of simple apps that use this library can be found here. These include an FM radio receiver, an OpenGL waterfall plotter and an AM radio receiver.

Please see the README on GitHub at https://github.com/isovector/do-notation#readme

This tools produces diagrams of Haskell type interdependencies in the given source. Actual drawing is done by graphviz tools (dot).

This library is based on an STM-specialized implementation of a Hash Array Mapped Trie. It provides efficient implementations of Map, Set and other data structures, which are slightly slower than their counterparts from "unordered-containers", but scale very well on concurrent access patterns. For details on performance of the library see this blog post.

Bindings to GitHub's C markdown library: https://github.com/vmg/sundown. The Haskell code is in the public domain. For sundown's license, refer to its GitHub page.

Reusable algorithms using the Repa array library.

Haskell Client for Discogs REST API

The sweet-egison is a shallow embedding implementation of non-linear pattern matching with extensible and polymorphic patterns. In other words, this implements Egison pattern matching in Haskell by desugaring pattern expressions. This library provides a base of the Pattern-Match-Oriented (PMO) programming style for Haskell users at a practical level of efficiency.

Generate JSON values for Hedgehog tests

Haskell CSV parser/emitter based on ReadP.

Cake3 is a EDSL for building Makefiles, written in Haskell. With cake3, developer can write their build logic in Haskell, obtain clean and safe Makefile and distribute it among the non-Haskell-aware users. Currenly, GNU Make is the only backend supported. Example program Basic workflow Install the cake3 Create Cakefile.hs in the project root Build the application using cake3 script provided Execute the application to obtain the Makefile See the README on the GitHub https://github.com/grwlf/cake3 for more information. Distribution contains several example projects.

Modelled after Erlang OTP's gen_server, this framework provides similar facilities for Cloud Haskell, grouping essential practices for client/server development into a set of modules and standards designed to help you build concurrent, distributed applications with relative ease.

Add CORS (cross-origin resource sharing) headers to Snap applications. This enables web applications running on other domains to make requests against another application. Currently this package provides support for setting the Access-Control-Allow-Origin and Access-Control-Allow-Credentials headers, it does not yet do pre-flighting. If you need this, please open an issue on Github and I'll fix it ASAP (otherwise I will add this feature as time permits).

Please see the README on Github at https://github.com/lpeterse/haskell-terminal#readme

music-diatonic provides an implementation of basic western musical theory objects. Includes notes, scales, chords, degrees and harmonies.

This package exports bindings to Twilio's REST API (https://www.twilio.com/docs/api/rest). While we would like to have a complete binding to Twilio's REST API, this package is being developed on demand. If you need something that has not been implemented yet, please send a pull request or file an issue on GitHub (https://github.com/markandrus/twilio-haskell).

Fast functions for number theory and combinatorics with a high level of safety guaranteed by ATS.

Unicode 3.2.0 character names

Basic4x6 font for OpenGL containing digits and symbols. It is called "4x6" because it was drawn in 4x6 grids on graph paper. This library might not be a good idea, but I needed to display some simple values and didn't want to introduce any heavy dependencies. Run executable show-font-basic4x6 for a demo.

Please see the README on GitHub at https://github.com/kawu/nerf#readme

Serialization of data structures with references.

Optimal Ate pairing over Barreto-Naehrig curves

Optimised list functions for doing index-related things. They're faster than common idioms in all cases, they avoid space leaks, and sometimes they fuse better as well.

Haskell supports exception hierarchies, but they require quite a bit of boilerplate to declare. This package leverages Template Haskell to automate declaration of large exception hierarchies. This package requires GHC 7.6, as a bug in GHC 7.4 prevents expansion of Template Haskell splices using 'deriving Typeable'.

Elliptic Curve Cryptography in Haskell, evolved for correctness and practical usability from higher-level libraries. The implementation is pure Haskell and as generic and fast as reasonably possible. Timing-attack resistance is important, failure must be documented. This library was formerly known and its code originated as hecc, but since this would imply Hyperelliptic ECC, the name was changed. Also the scope was changed by selecting best internal formats and no longer trying to be overly general, allowing more optimizations.

A Set and Map implementation that is completly lazy and works for infinite sets and maps.

Please see README.md

Tropical numbers are the same as real numbers, except the operations are different. See the documentation for more information.

svfactor is a library for parsing, manipulating, and printing CSV and similar formats (such as PSV, TSV, and many more). svfactor retains all syntactic information including newlines, and provides lenses, prisms, and traversals to query and manipulate this structure. This should make it useful for writing custom CSV transformations and sanitisation tools. For example, one could easily use it to rewrite all CRLF newlines to LF. It also extends RFC4180 by allowing optional spacing surrounding fields. svfactor's parser is exposed so you can use it independently and printing is similarly standalone. Please note that there are known performance problems with svfactor. Examples: Handling multiple logical documents in one file: Concat.hs Fixing inconsistent formatting with lenses: Requote.hs [Index] For package maintainers and hackage trustees

Type-level and value-typed unary natural numbers, inequality proofs, and length-typed vectors. There are probably many of these packages. Perhaps consolidate.

Run an IO action protected by a pidfile.

blog system with tags

Please see README.md

This package provides basic pseudo-random number generation, including the ability to split random number generators. In pure code, use System.Random.uniform and System.Random.uniformR from System.Random to generate pseudo-random numbers with a pure pseudo-random number generator like System.Random.StdGen. As an example, here is how you can simulate rolls of a six-sided die using System.Random.uniformR: See System.Random for more details. In monadic code, use System.Random.Stateful.uniformM and System.Random.Stateful.uniformRM from System.Random.Stateful to generate pseudo-random numbers with a monadic pseudo-random number generator, or using a monadic adapter. As an example, here is how you can simulate rolls of a six-sided die using System.Random.Stateful.uniformRM: The monadic adapter System.Random.Stateful.runGenState_ is used here to lift the pure pseudo-random number generator pureGen into the System.Random.Stateful.StatefulGen context. The monadic interface can also be used with existing monadic pseudo-random number generators. In this example, we use the one provided in the mwc-random package: See System.Random.Stateful for more details.

Finds out whether an entity comes from different distributions (statuses).

Haskell JobQueue is a library used for building a job scheduler with priority queues. The state of jobs is stored in a backend database such as Apache Zookeeper or other highly reliable message queue systems.

The standard theory library - this package was automatically generated from the OpenTheory package base-1.197

Bindings to the isoHunt torrent search API, as described in http://ca.isohunt.com/forum/viewtopic.php?p=433527#433527 To get started, see IsoHunt.Search.

Intuitive, simple building blocks for building composable, completely self-managed web applications

An efficient strict text builder

A simple library for creating and manipulating constraints of one variable. See "polydata" and "hetero-list" for usage examples.

The specification of a class in Haskell often starts with stating, in text, the laws that should be satisfied by methods defined in instances of the class, followed by the type of the methods of the class. The ClassLaws library is a framework that supports testing such class laws using QuickCheck. Our framework is a light-weight class law testing framework, which requires a limited amount of work per class law, and per datatype for which the class law is tested. We also show how to test class laws with partially-defined values. Using partially-defined values, we show that the standard lazy and strict implementations of the state monad do not satisfy the expected laws. More information can be found at http://wiki.portal.chalmers.se/cse/pmwiki.php/FP/ClassLaws. Built with ghc-7.4.2 and ghc-7.6.1. (Fails to build with ghc-7.2.2 due to http://hackage.haskell.org/trac/ghc/ticket/5745. Could be worked around.)

Haskell cabal Taxonomy libary contains tools, parsers, datastructures and visualisation for the NCBI (National Center for Biotechnology Information) Taxonomy datasources. It can utilize information from the Entrez REST interface via EntrezHTTP, as well as from the files of the Taxonomy database dump. Input data is parsed into a FGL based datastructure, which enables a wealth of processing steps like node distances, retrieval of parent nodes or extraction of subtrees. Trees can be visualised via dot-format (graphviz)

Easy C++ code analysis with pure Haskell

This is an API client library for interacting with Smith.

Derive a mock server for free from your servant API types See the Servant.Mock module for the documentation and an example.

This packages is intended to make perl developers happy to use Haskell. (:

A Haskell datastructure for working with locations in trees or forests.

Precise geographical coordinates (latitude & longitude), with conversion between different reference frames and projections. Certain distinguished reference frames and grids are given distinct types so that coordinates expressed within them cannot be confused with from coordinates in other frames.

husky is a command line calculator with a small memory footprint. It can be used in a fashion similar to the interactive shells of python, octave, or ruby.

A contention-free STM hash map. "Contention-free" means that the map will never cause spurious conflicts. A transaction operating on the map will only ever have to retry if another transaction is operating on the same key at the same time. This is an implementation of the transactional trie, which is basically a lock-free concurrent hash trie lifted into STM. For a detailed discussion, including an evaluation of its performance, see Chapter 4 of my master's thesis.

This package provides a base to analyze and transform the Eiffel language. It is suitable to build parsers.