Implementation of the Snappy framing format (SVN revision 71, cf. http://code.google.com/p/snappy/source/browse/trunk/framing_format.txt?r=71)

It supports authentication by password or keys. Everything is in the SimpleSSH monad which is ErrorT SimpleSSHError IO, allowing to manage errors in a haskeller way.

Contravariant functors.

Authentication via hashed message code (HMAC) based on RFC1945.

Yampa-based, domain-specific language embedded in Haskell for programming robots. At present, only simulated robots. However, the infrastructure is separated into generic and robot-specific parts, and set up so as to make it possible to write robot code that depends only on specific features, as opposed to specific platforms or versions of those platforms. Thus, it is in principle possible to write quite generic robot code. (Once upon a time, the Pioneer platform, a real robot, was supported.)

[Index] For package maintainers and hackage trustees

Haskell library for CRC-32C

[Index] For package maintainers and hackage trustees

I really like having sandboxes baked into cabal-install. However, I got tired of waiting for big packages like Yesod and Lens to compile in project after project that used them. However, I still didn't want to install them in the user database. I wanted to maintain some sandboxing among a group of projects that all share a common set of packages, but I wanted to be able to switch from them or upgrade them easily. That's the itch I was trying to scratch with castle. It allows you to share one Cabal sandbox between multiple projects. This keeps the package versions for all of these projects in line. It also means that you don't have to constantly be re-installing everything, but you still get the ability to blow away a set of packages without borking your whole system.

This library wraps the simplified ("lite") interface to the HDF5 data format.

Simple example of chat application. Consists of 3 components: hach-server, hach-client (simple console client), hach-nclient (vty-ui client).

Bookmark directories, then select a bookmark by fuzzy matching. You need to set up a small shell function for this to work properly (see the README).

A variety of alternative parser combinator libraries, including the original HuttonMeijer set. The Poly sets have features like good error reporting, arbitrary token type, running state, lazy parsing, and so on. Finally, Text.Parse is a proposed replacement for the standard Read class, for better deserialisation of Haskell values from Strings.

When developing interactive command line applications in an editor like Emacs GHCi typically has no access to an actual terminal. This is good enough for applications that only read lines from stdin and print diagnostics to stdout, but as soon as terminal functionality is needed, the application has to be tested elsewhere. This package provides functionality that, when used together with the rapid library, can open a persistent terminal that the application can access directly, such that terminal applications can be tested with the main GHCi instance. You can find a tutorial in the documentation of the Rapid.Term module.

Annotated splay trees (compare to 2-3 finger trees)

Overview Base types used by a variety of HTTP clients and servers. See http-streams Network.Http.Client or pipes-http Pipes.Http.Client for full documentation. You can import Network.Http.Types if you like, but both http-streams and pipes-http re-export this package's types and functions.

Please see the README on GitHub at https://github.com/jprupp/nqe#readme

L-systems in Haskell

Please see README.md

Optics for xml-conduit and html-conduit

This framework provides functionality for testing Haskell functions against properties, similar to QuickCheck, but allowing different test data generation strategies for different structures, and even within the same structure using composition strategies. Reporting, test case scheduling and data generation modules can be assembled to customize the test program based on the situation. Test data generation is based on combinatorial theory and uses explicit enumeration of regular polynomial types, combined with selection strategies to build data generators. Generators can be composed or combined in parallel to create composite strategies for data sampling.

All the benefits of stringly typed programming at all of the costs.

Multiaddr is a self-describing network address format supporting a variety of protocols, with both string and binary representations.

dwergaz is a minimal testing library with no external dependencies.

The game of tetris for braille display users, implemented using unicode braille rotated 90 degrees. Tetriminos are "falling" from right to left.

Haskell Library to deal with resource availability in a Calendar

Exposes Hakyll compilers for passing file paths to external processes. Transformed results are made available as Hakyll Items.

Library for Sender Policy Framework, SenderID, DomainKeys and DKIM.

This is a binding to a (currently very small) subset of the GD graphics library.

A library for handling and manipulating bitmaps (that is, rectangular pixel arrays).

This ingredient for the tasty testing framework allows filtering a test tree depending on the outcome of the previous run. This may be useful in many scenarios, especially when a test suite grows large.

Just a simple library that provides cross-platform support (Windows and Unix) for retrieving file access times

This is a simulated world I invented. It has pollution and energy and trees and mountains and chaos storms. It is randomly generated and non-interactive at present.

Operations on zip archives.

[Index] For package maintainers and hackage trustees

This library allows to connect to NNTP server.

For package maintainers and hackage trustees

Provides an effect and carrier capable of resuming control flow from an exceptoin handler.

This package provides a data type NF representing data which has been evaluated to normal form. This is a useful type discipline for many situations when normal form data is necessary, e.g. when transmitting data to other threads over channels.

[Index] For package maintainers and hackage trustees

Deprecated in favor of yaml Uses the yaml package, which is built off of libyaml.

A Monus is a commutative monoid that allows a notion of substraction, with the following laws: x <> (y - x) = y <> (x - y) (x - y) - z = x - (y <> z) x - x = mempty mempty - x = mempty

Players take turns in a labyrinth, competing with each other to pick a treasure and carry it out. They only know everyone's moves and responses, but do not see the map and must deduce it themselves.

Generic encoder and decode for JSON-RPC

Lzip compression / Lzlib bindings

Please see the README on Github at https://github.com/ChrisCoffey/cuckoo-filter#readme

Deprecated in favor of prettyclass Pretty printing class similar to Show, based on the HughesPJ pretty printing library. Provides the pretty printing class and instances for the Prelude types. This upload replaces the old pretty-class package (which I believe nobody is using) with a copy of Lennart's prettyclass package with a small change to its Char instance.

Please see the README on Github at https://github.com/tek/polysemy-http

A pretty-printing library for laying out text in two dimensions, using a simple box model.

A reasonably efficient implementation of arbitrary-but-fixed precision real numbers. This is inspired by, and partly based on, Data.Number.Fixed and Data.Number.CReal, but more efficient.

Fast alternative HTML decoder for tagsoup

HsLua provides bindings, wrappers, types, and helper functions to bridge Haskell and Lua. This package contains a full Lua interpreter version 5.3.6. If you want to link it with a system-wide Lua installation, use the system-lua flag. Example programs are available in a separate repository.

[Index] Use -f <flag> to enable a flag, or -f -<flag> to disable that flag. More info For package maintainers and hackage trustees

Nuha is a library for numerical linear algebra based on multidimensional arrays (holors). The goals of Nuha are: to be user friendly to be lightweight with few dependencies to be fast (although there haven't been many benchmarks yet)

This is a bunch of trivial routines for inspecting git repositories. It is in no way useful beyond that.

This package contains code for generating high quality random numbers that follow either a uniform or normal distribution. The generated numbers are suitable for use in statistical applications. The uniform PRNG uses Marsaglia's MWC256 (also known as MWC8222) multiply-with-carry generator, which has a period of 2^8222 and fares well in tests of randomness. It is also extremely fast, between 2 and 3 times faster than the Mersenne Twister. Compared to the mersenne-random package, this package has a more convenient API, is faster, and supports more statistical distributions.

This is a client library for querying a WebFinger resource and parsing the response.

A CLI tool to speed up multi-stage docker file builds by caching intermediate

This package is a back-end from Copilot to C. Copilot is a stream (i.e., infinite lists) domain-specific language (DSL) in Haskell that compiles into embedded C. Copilot contains an interpreter, multiple back-end compilers, and other verification tools. A tutorial, examples, and other information are available at https://copilot-language.github.io.

Simple routing based on a URL path pieces mapped to web applications.

This package provides fixed-length large integer types and arithmetic operations for Accelerate. Signed and unsigned 96, 128, 160, 192, 224, 256, and 512-bit types are predefined. Refer to the main Accelerate package for more information: http://hackage.haskell.org/package/accelerate

A modern library for working with email addresses. This package can be used to validate user input or handle various flavors of addresses that appear in places such as mail messages. Email addresses can be decoded, manipulated, then rendered back to text using the simple local-part@domain format or the more complete syntax that allows for display names and comments. Comprehensive documentation can be found in the Addy module.

Typeclasses standardizing operations dealing with datatypes representing booleans by their constructors

This package is intended for developers of text editors who want to make their text editor compatible with the Language Server Protocol. I have developed this package with plans to integrate it in the Yi Editor.

For package maintainers and hackage trustees

Helpers for creating database tests with hspec and pg-transact hspec-pg-transact utilizes tmp-postgres to automatically and connect to a temporary instance of postgres on a random port. In the example above describeDB wraps describe with a beforeAll hook for creating a db and a afterAll hook for stopping a db. Tests can be written with itDB which is wrapper around it that uses the passed in Connection to run a db transaction automatically for the test. The libary also provides a few other functions for more fine grained control over running transactions in tests.

Console line fuzzy search as a library

This package provides the account management tool and the library for account management. This package is a porting of Pit (see https://github.com/cho45/pit).

A very simple interface for processing data in ESRI shapefile format. Includes functions for reading or writing whole .shp and .shx files, as well as for generating .shx index files from .shp data files. Also includes an interface to read individual records on-demand from shapefiles, useful for very large databases.

Generate a HTML summary report of GPS tracks

Convert 128-bit ByteString to/from 12 English words.

[Index] For package maintainers and hackage trustees Flowdock API bindings for Haskell

Support for computations which consume values from a (possibly infinite) supply.

nc-indicators displays a CPU load and memory usage mini-graphs in your i3bar, much like Gnome's indicator-multiload applet. To use nc-indicators simply exec it on startup: You can turn off either indicator and change the update interval, eg.: nc-indicators uses the standard system tray icon protocol, so it can be used with any system tray-like application, not just i3bar. But it was originally created to be used with i3bar.

Haskell CloudI API (see https://cloudi.org for more details)

interactive (prototype) tool for discovery and analysis of predictive relations in nominal data reads tables in Open Office Calc .csv format, saves results in .csv and .dot (GraphViz)

Simple WebService to convert markdown to reveal-js | https://github.com/j4/slidemews

[Index] For package maintainers and hackage trustees instant-bytes allows you to generically derive binary representations (from the bytes package) for your types using instant-generics, which in particular, supports deriving generic representations for GADTs.

[Index] [Quick Jump] For package maintainers and hackage trustees Nix command-line bindings for Haskell CLI applications.

Simple http server in haskell, similar to as provided by `python -m SimpleHTTPServer`.

This module splits Control.Concurrent.Chan into sending and receiving halves, which allows the type system to more finely constrain program behavior. As a secondary benefit, messages written to channels with no receive ports associated with them can be reliably garbage collected. In addition, this module incorporates several of clean-ups and additions to the venerable Chan. Most notably, the deprecated thread-unsafe functions have been removed, the ability to duplicate Receive Ports has been added, the sendMany operation allows for multiple messages to be sent atomically, and the split operation turns a single channel into two.

Chuchu is a system similar to Ruby's Cucumber for Behaviour Driven Development. It works with a language similar to Cucumber's Gherkin, which is parsed using package abacate.

This package provides various data types for free categories, type aligned queues, arrows and type classes which allow to write abstract categories with side effects (Kleisli like categories). These are useful for encoding type safe state machines. Free arrows are also provided.

Use triples of Doubles to represent vectors (slower with vector library arrays) Use -f <flag> to enable a flag, or -f -<flag> to disable that flag. More info For package maintainers and hackage trustees CSG is a constructive solid geometry library with support for ray casting. CSG allows you to define a complex solid as a composition of primitives. It also provides functions to perform ray casting (find an intersection of a ray and the defined solid) or test whether a point belongs to the solid (for Monte Carlo volume calculation). Please consult the Hackage page for csg for full documentation. By default csg is built using CVec3 from simple-vec3 to represent vectors and points, which according to benchmarks shows better performance with Unboxed and Storable vectors. Build csg with triples flag to use (Double, Double, Double) instead which may be a more convenient programmatic interface that needs no fromXYZ/toXYZ. See alternatives too. The package also includes csg-raycaster executable, which is a simple interactive GUI for the ray casting algorithm. csg-raycaster takes a geometry defintion file as input. See cube.geo: Please consult the Hackage page for Data.CSG.Parser for full format specification. csg-raycaster may be run as Run as csg-raycaster --help to see all options. When run without a file argument, csg-raycaster will try to display an arbitrary CSG solid. In the GUI window the following controls are supported: | Input | Function | |---------------------------|--------------------------------------| | Left mouse button + drag | Rotate | | Right mouse button + drag | Pan | | Mouse wheel up | Zoom in | | Mouse wheel down | Zoom out | | r | Reset zoom level and camera position | csg library performs no surface interpolation when doing ray casting. Instead, we only solve ray-surface intersection equation numerically. The library was written with Repa/vector compatibility and performance in mind. There're other Haskell libraries for CSG: GlomeTrace: Has more ray tracing-specific features, such as light sources, different textures and materials. Unlike csg, has no tests or benchmarks. In csg solids use the same type as opposed to different types with an existential box in GlomeTrace. implicit: Offers a much richer operation set. Uses function representation for CSG solids. If implicit had ray-casting support in early 2012 then I probably wouldn't write csg. mecha: Only provides types and functions to define solids and export definitions to external formats. No support for ray casting.

Basic utility to search an ISBN using the Google Books webservice

Deprecated in favor of contravariant This library provides a Cofunctor class useful for types that are sinks or make use of IO effects. See documentation for details. Some supporting constructions are also provided.

Extra functions for the Control.Newtype typeclass

Interpolated Haskell

[Index] For package maintainers and hackage trustees

Deprecated None

Simple functional bidirectional ring type. Given that the ring terminiology clashes with certain mathematical branches, we're using the term CList or CircularList instead.

[Index] For package maintainers and hackage trustees

FFI to OS syscalls (open, close, sendfile etc...).