This library provides a simple way to transform parts of complex data structures. It is based on Data.Data.

Track string casing at the type level

Parser for PCD (point cloud data) formats. See http://pointclouds.org/documentation/tutorials/pcd_file_format.php for more information.

Simple tool to display text files with line numbers and paging

Target is a library for testing Haskell functions based on properties encoded as refinement types. The programmer specifies the expected behavior of a function with a refinement type, and Target then checks that the function satisfies the specification by enumerating valid inputs up to some size, calling the function, and validating the output. Target excels when the space of valid inputs is a sparse subset of all possible inputs, e.g. when dealing with dataypes with complex invariants like red-black trees. Test.Target is the main entry point and should contain everything you need to use Target with types from the Prelude. Test.Target.Targetable will also be useful if you want to test functions that use other types. For information on how to specify interesting properties with refinement types, we have a series of blog posts as well as an evolving tutorial. Target uses the same specification language as LiquidHaskell, so the examples should carry over. Finally, Target requires either Z3 (>=4.3) or CVC4 (>=1.4) to be present in your PATH.

A web development micro framework for haskell that provides easy to use typesafe URLs. See README for more information. Also see examples/ directory for usage examples.

hbf is a compiler and executor of Brainfuck programs. It provides two executables: hbfc the Brainfuck compiler, and hbf the virtual machine that executes compiled Brainfuck programs.

Turing machine simulator written in Haskell

A free indexed monad

Needle is a domain specific language for ASCII-fied arrow notation. See Control.Arrow.Needle for more information and an example.

Middleware that communicates to Rollbar.

Deprecated HUnit assertion operators that show a diff on failure.

Bifunctors.

This package provides approximate discrete values and numbers.

Finite field polynomial arithmetic based on fast Fourier transforms

Yet Another Pong Clone using SDL.

See README for more info

Self optimizing tuple types. Adaptive tuples are tuple types in which the number of elements is determined at run-time. These structures are designed to combine the space-efficiency of tuples with the size flexibility of lists. Adaptive tuples provide lazy and strict, unpacked data structures for all tuple sizes from 0 to 20 elements. Adaptive tuples of more than 20 elements are allowed, however they are stored in an ordinary list.

Low level bindings to HDF5, part of the bindings-* project. See: http://bitbucket.org/mauricio/bindings-dsl http://www.hdfgroup.org/HDF5

Accentuate.us (http://accentuate.us/) is a free and open-source web service that makes computer input really easy for over 115 languages. Using statistics, it will automatically add diacritics ("special characters") to otherwise plain text. In support of being an open web service, an API is provided and documented at http://accentuate.us/api, which is implemented by this package.

Please see the README on GitLab at https://gitlab.com/igrep/pure-shuffle#readme

This package provides a wrapper for functors, which allows their data to be automatically swapped to disk and loaded back when necessary. Although interaction with filesystem is required, whole interface (with exception of initialization) is pure and safe as long as no external manipulation with used database files happens while the program is running. Because only actual data, not indices (in Data.Map.Map, for example), are swapped and some accounting information are remembered for each item, this system is suitable mainly for situations where values are considerably larger then indices. Furthermore, creating complete snapshots to a file of this structure is supported; such snapshot can be then loaded, with individual values being read as they are requested. This package uses the Tokyo Cabinet http://fallabs.com/tokyocabinet/ database, which needs to be installed on the system. A prototype of another data structure, SwapMap, is available in the git repository. It is similar to the Data.Map.Map and like Swapper allows transparent swapping of data to disk, but without requiring any accessory function and with the ability to swap both elements and indices. This one is, however, not complete and thus not provided here.

This package provides a high level binding to the QuickLZ compression library for ByteStrings, under the GPLv2 license. QuickLZ is fast and compresses very well. Check out the home page: http://quicklz.com This package includes the QuickLZ 1.5.0 source code, at compression level 1 and streaming mode disabled. The versioning scheme for this package is unusual. QuickLZ tries to be as fast as possible, and will break backwards compatibility to achieve it in newer versions. This versioning scheme reflects the QuickLZ versioning scheme: the first three digits of version w.x.y.z are the quicklz version, with the z component (and any further needed ones) being updates to this package, not quicklz itself.

clckwrks (pronounced, clockworks) aims to compete directly with popular PHP-based blogging and CMS platforms. Clckwrks aims to support one-click installation of plugins and themes. End users should be able to use it with zero Haskell knowledge. Haskell developers can extend clckwrks by creating new plugins or by building sites around the existing clckwrks core and plugins. clckwrks is still in very early development. Not all features have been implement yet.

Pure Haskell implementation of SplitMix described in Guy L. Steele, Jr., Doug Lea, and Christine H. Flood. 2014. Fast splittable pseudorandom number generators. In Proceedings of the 2014 ACM International Conference on Object Oriented Programming Systems Languages & Applications (OOPSLA '14). ACM, New York, NY, USA, 453-472. DOI: https://doi.org/10.1145/2660193.2660195 The paper describes a new algorithm SplitMix for splittable pseudorandom number generator that is quite fast: 9 64 bit arithmetic/logical operations per 64 bits generated. SplitMix is tested with two standard statistical test suites (DieHarder and TestU01, this implementation only using the former) and it appears to be adequate for "everyday" use, such as Monte Carlo algorithms and randomized data structures where speed is important. In particular, it should not be used for cryptographic or security applications, because generated sequences of pseudorandom values are too predictable (the mixing functions are easily inverted, and two successive outputs suffice to reconstruct the internal state).

Please see README.md

a practical monoid implementation

Safe interpolated SQL queries in Haskell

See README at the bottom. Getting started: See Each.

Quasiquotations for a python like interpolated string formater.

The library uses FFI calls to the DevIL image library to read images from a wide variety of formats, including BMP, JPG, PNG, GIF, ICO and PSD. Please read our README to get a detailed usage and some examples.

The aim of this library is to provide a unified set of operations (new, read, write, swap, various strict mutate* functions and their derivatives (like mutate-and-return-the-old-value) and a certain interface for MVar-like things) over all common variable types: IORef, STRef s, MVar, TVar, TMVar. When possible type classes are generalized to be over abstract containers rather than variables: e.g. it'd make sense to implement MonadRead TChan and MonadMutate_ Vector instances, but no such instances are provided right now. There are also some lenses to be described in an upcoming blog post.

Cayene Low Power Protocol encoding and decoding for Haskell

Use the Hadoop RPC interface from Haskell. This version only supports v9 of the RPC protocol (CDH 5.x and above). Use hadoop-rpc-0.x.x.x if you need v7 support. The API is still evolving and is highly likely to change in the future.

Diagrams based plotting library.

Deprecated in favor of pipes This library offers an abstraction similar in scope to iteratees/enumerators/enumeratees, but with different characteristics and naming conventions. This package is a fork of the original pipes package by Gabriel Gonzalez. See https://github.com/pcapriotti/pipes-core/wiki/pipes-core-vs-pipes for a comparison between the two packages. Differences with traditional iteratees: Simpler semantics: There is only one data type (Pipe), two basic primitives (await and yield), and only one way to compose Pipes (>+>). In fact, (>+>) is just convenient syntax for the composition operator in Category. Most pipes can be implemented just using the Monad instance and composition. Different naming conventions: Enumeratees are called Pipes, Enumerators are Producers, and Iteratees are Consumers. Producers and Consumers are just type synonyms for Pipes with either the input or output end closed. Pipes form a Category: that means that composition is associative, and that there is an identity Pipe. "Vertical" concatenation works on every 'Pipe': (>>), concatenates Pipes. Since everything is a Pipe, you can use it to concatenate Producers, Consumers, and even intermediate Pipe stages. Vertical concatenation can be combined with composition to create elaborate combinators, without the need of executing pipes in "passes" or resuming partially executed pipes. Check out Control.Pipe for a copious introduction (in the spirit of the iterIO library), and Control.Pipe.Combinators for some basic combinators and Pipe examples.

ANTLR is a LL(*) parser generator that supports semantic predicates, syntax predicates and backtracking. antlrc provides a Haskell interface to the ANTLR C runtime. ANTLR generates the lexer and/or parser C code, which can call Haskell code for things such as: semantic predicates which may look up entries in the symbol table, creating symbol table entries, type checking, creating abstract syntax trees, etc. The C source code for the lexer and/or parser are generated from the ANTLR grammar file, which by convention has a .g filename extension. The generated C files can be compiled as C or C++. The main entry point to the program can be written in C or C++, which calls the generated parser and lexer. The parser can make calls to Haskell to build the AST and symbol table, and to implement dis-ambiguating semantic predicates if necessary (for context sensitive languages). The ANTLR parser generator is written in Java. It is necessary to use the same ANTLR parser generator version as the ANTLR C runtime version. antlrc is tested with ANTLR 3.2 and libantlr3c 3.2. In addition to creating the GrammarLexer.c and GrammarParser.c files, the antlr parser generator creates a Grammar.tokens file which contains a list of lexer token identifier numbers and any associated name that is is specified in the tokens section of the Grammar.g file. The antlrcmkenums is run specifying the input Grammar.tokens file, and generates a GrammarTokens.h C/C++ header file containing an enum with enum members for those tokens that have user specified names. This enum is then processed by c2hs to create a Haskell enum for the token identifiers. Examples are provided on github: https://github.com/markwright/antlrc-examples Documentation for the ANTLR C runtime library is at: http://www.antlr.org/wiki/display/ANTLR3/ANTLR3+Code+Generation+-+C Documentation for the ANTLR parser generator is at: http://www.antlr.org/wiki/display/ANTLR3/ANTLR+v3+documentation

Various extra monoid-related definitions and utilities, such as monoid actions, monoid coproducts, "deletable" monoids, "split" monoids, and "cut" monoids.

General tools for Neil. Typically, I don't bother releasing these tools, and just leave them in the Git repo.

This wraps the Juicy.Pixels library to convert into Repa and Data.Vector.Storable formats.

Open algebraic data types. Reuse constructors in different types; add and remove constructors from values.

This package provides efficient cryptographic hash implementations for strict and lazy bytestrings. For now, CRC32 and Adler32 are supported; they are implemented as FFI bindings to efficient code from zlib.

A lightweight library for one-off parsing and printing. See README.

Documentation online at http://mstksg.github.io/ghcjs-websockets/JavaScript-WebSockets.html Deprecated in favor of ghcjs-base's native websockets. ghcjs-websockets aims to provide a clean, idiomatic, efficient, low-level, out-of-your-way, bare bones, concurrency-aware interface with minimal abstractions over the Javascript Websockets API http://www.w3.org/TR/websockets/, inspired by common Haskell idioms found in libraries like io-stream http://hackage.haskell.org/package/io-streams and the server-side websockets http://hackage.haskell.org/package/websockets library, targeting compilation to Javascript with ghcjs. The interface asbtracts websockets as simple IO/file handles, with additional access to the natively typed (text vs binary) nature of the Javascript Websockets API. There are also convenience functions to directly decode serialized data (serialized with binary http://hackage.haskell.org/package/binary) sent through channels. The library is mostly intended to be a low-level FFI library, with the hopes that other, more advanced libraries maybe build on the low-level FFI bindings in order to provide more advanced and powerful abstractions. Most design decisions were made with the intent of keeping things as simple as possible in order for future libraries to abstract over it. Most of the necessary functionality is in hopefully in JavaScript.WebSockets; more of the low-level API is exposed in JavaScript.WebSockets.Internal if you need it for library construction. See the JavaScript.WebSockets module for detailed usage instructions and examples. Some examples:

Haskell bindings for CPLEX

Prettier display of Android Lint issues

Utilities for Control.Lens.Cons

This library defines an optimized type for representing polynomials in Bernstein form, as well as instances of numeric classes and other manipulation functions, and a solver of systems of polynomial equations in this form.

The following extras for hpqtypes library: DSL for easy, modular construction of SQL queries. System for automatic validation and migration of a database schema.

Hackage documentation generation is not reliable. For up to date documentation, please see: http://www.stackage.org/package/yackage.

Language handling for Snap. Support for determining the client's prefered language using the Accept-Language header or using suffixes to the requested URI.

It's like the State monad transformer. But Reversed! The state goes backwards.

This application generates a scaffold for Haskell project from a Git repository. This command will generate: See https://github.com/fujimura/hi for further usage.

A library for crawling exhentai, with the support of streaming

Allow binary serialization/deserialization using io-streams

Multiplatform signal support for Haskell

Please see README.md

Recent front end development tools and languages are growing fast and have quite a complicated ecosystem. Few front end developers want to be forced use Shakespeare templates. Instead, they would rather use node-friendly engines such that pug, slim, and haml. However, in using these template engines, we lose the compile-time variable interpolation and type checking from Shakespeare. Heterocephalus is intended for use with another feature rich template engine and provides a way to interpolate server side variables into a precompiled template file with forall, if, and case statements.

See examples directory for some example effect definitions and handlers.

Deprecated A nice wrapping around System.Random. Full documentation is available in Literate Haskell at the homepage link.

Quasi-quoter for TDFA (extended POSIX) regular expressions.

This package provides DOM selectors based on lenses and prisms. See README.md for examples

This package provides bindings to Twitter's APIs (see https://dev.twitter.com/). This package uses the http-conduit package for accessing the Twitter API (see http://hackage.haskell.org/package/http-conduit). This package also depends on the twitter-types package (see http://hackage.haskell.org/package/twitter-types). You can find basic examples in the https://github.com/himura/twitter-conduit/tree/master/sample directory. This package is under development. If you find something that has not been implemented yet, please send a pull request or open an issue on GitHub.

A very simple but efficient logging framework

This library aims to supply you with common types and operations for working with time and date. Parsing and rendering common formats like ISO8601 and RFC3339. Modifying dates and times in a way that is easy to understand and not overengineered (srsly, who needs something else than the Gregorian Calendar?) A set of classes that provide interfaces for your own application specific or maybe more efficient time and date types. Implement the interfaces and get all the parsing and rendering functions for free! This is a work in progress! Try it out and play with it. Tell me what you think about the API design and naming, but __DON'T USE IT IN PRODUCTION YET!__ Bug reports or (even better) tests are welcome.

This library implements the Noise protocol.

The Amazon EC2 style signature calculator. http://docs.aws.amazon.com/general/latest/gr/signature-version-2.html

Please see README.md

Public Key cryptography Supports RSA PKCS15, RSA OAEP, RSA PSS, DSA, ElGamal signature. Also have primitive support for Diffie Hellman, and ElGamal encryption

Converts KIF (Keep It Functional) iOS integration test logs into other formats, i.e., JUnit XML format

This can be used to send Bitcoins, query balances, etc. It requires the Bitcoin daemon to be running and accessible via HTTP. To learn more about Bitcoin, see http://www.bitcoin.org.

nfc is a set of bindings to libnfc

(deprecated)

A basic library and program for simulated rolling of polyhedral dice, as would be used in pen and paper RPGs.

Alert messages for web applications: Bootstrap 3 Bootstrap 4 Foundation 5 Bulma

diagrams-haddock is a tool for compiling embedded inline diagrams code in Haddock documentation, for an easy way to spice up your documentation with diagrams. Just create some diagrams code using special markup, run diagrams-haddock, and ensure the resulting image files are installed along with your documentation. For complete documentation and examples, see https://github.com/diagrams/diagrams-haddock/blob/master/README.md. For a good example of a package making use of diagrams-haddock, see the diagrams-contrib package (http://hackage.haskell.org/package/diagrams%2Dcontrib).

A fork of of test-framework-th modified to use tasty instead of test-framework.

This library intends to unify, classify, demonstrate, and promote the use, abuse, and exploration of Streams and other infinite (co)data types. Many other languages have substantial feature overlap with Haskell, but Streams and friends proivde excellent demonstrations of Haskell features like laziness. Rivers are not currently defined in this package, because they are still ill-defined. The goal of this package in the meantime is, therefore, is to focus on Streams. Another goal of this package is to demonstrate the ecosystem of Rivers (and Streams), how identical (and indeed sometimes isomorphic) streams can be constucted in many different ways. OEIS (http://www.oeis.org) is used to verify the correctness of numeric streams, where possible.

Haskell QuasiQuoting for times.

This little program helps with the following task: You need to analyse some binary file (e.g., the firmware for some microcontroller). You want to understand how it does certain things, but the file is big. One approach to help you in the process is to erase parts of the file (by overwriting it with binary zeros) and see if the file still does what it should be doing. If it does, then you know that the interesting parts are in another part of the file. binary-binary assists in this process by doing the book-keeping and zeroing out parts of the file.

Package implementing a bag-of-tasks approach to parallelism. This is an approach to non-deterministic parallelism, where non-deterministic means that the order of multiple values from the same set depends on the scheduling.

This package provides an ODBC database backend for HDBC. It is cross-platform and supports unixODBC on UnixLinuxPOSIX platforms and Microsoft ODBC on Windows. It is also the preferred way to access MySQL databases from Haskell.

Matrix library. Basic operations and some algorithms. To get the library update your cabal package list (if needed) with cabal update and then use cabal install matrix, assuming that you already have Cabal installed. Usage examples are included in the API reference generated by Haddock. If you want to use GSL, BLAS and LAPACK, hmatrix (http://hackage.haskell.org/package/hmatrix) is the way to go.

Generic widget library using glazier-react. Please see README.md.

This type implements maps where the keys are themselves complex structured data. For example, the keys may be the abstract syntax trees for a programming language. The map is implemented as a trie, so common parts of the keys will be shared in the representation. The library provides a generic implementation of the data structure, so values of types that have support for Generic may be automatically used as keys in the map.

This library is for parsing, representing in Haskell and pretty printing the data file output of the Linux perf command. The perf command provides performance profiling information for applications running under the Linux operating system. This information includes hardware performance counters and kernel tracepoints. Modern CPUs can provide information about the runtime behaviour of software through so-called hardware performance counters http://en.wikipedia.org/wiki/Hardware_performance_counter. Recent versions of the Linux kernel (since 2.6.31) provide a generic interface to low-level events for running processes. This includes access to hardware counters but also a wide array of software events such as page faults, scheduling activity and system calls. A userspace tool called perf is built on top of the kernel interface, which provides a convenient way to record and view events for running processes. The perf tool has many sub-commands which do a variety of things, but in general it has two main purposes: Recording events. Displaying events. The perf record command records information about performance events in a file called (by default) perf.data. It is a binary file format which is basically a memory dump of the data structures used to record event information. The file has two main parts: A header which describes the layout of information in the file (section sizes, etcetera) and common information about events in the second part of the file (an encoding of event types and their names). The payload of the file which is a sequence of event records. Each event field has a header which says what general type of event it is plus information about the size of its body. There are nine types of event: PERF_RECORD_MMAP: memory map event. PERF_RECORD_LOST: an unknown event. PERF_RECORD_COMM: maps a command name string to a process and thread ID. PERF_RECORD_EXIT: process exit. PERF_RECORD_THROTTLE: PERF_RECORD_UNTHROTTLE: PERF_RECORD_FORK: process creation. PERF_RECORD_READ: PERF_RECORD_SAMPLE: a sample of an actual hardware counter or a software event. The PERF_RECORD_SAMPLE events (samples) are the most interesting ones in terms of program profiling. The other events seem to be mostly useful for keeping track of process technicalities. Samples are timestamped with an unsigned 64 bit word, which records elapsed nanoseconds since some point in time (system running time, based on the kernel scheduler clock). Samples have themselves a type which is defined in the file header and linked to the sample by an integer identifier. Below is an example program which reads a perf.data file and prints out the number of events that it contains.

Implements PKCS #7 padding. This implements the PKCS #7 padding scheme. This scheme is defined in RFC 5652, section 6.3. Strings will be padded out to multiples of the block size; for example, a 5-byte string with an 8-byte block size will have three bytes of padding added. If the length is already a multiple of the block size, an entire block size worth of padding is added. The padding bytes are all set to the number of padding bytes. Returning to the previous example, the padding string would be three bytes of the byte 0x03. Unpadding checks the length and padding, and if this is valid, strips off the padding.

This module contains parser library independent code which can be used to describe inlerleaved execution of applicative style structures. It is amongst other used in the uu-options package, which provides facilities for parsing command-line options or files containing preferences. It generalises the permuting parsers and the list merging parsers as e.g. found in the uulib library. For a more complete description see the Technical Report describing its implementation and use see http:www.cs.uu.nlresearchtechreps/UU-CS-2013-005.html

Control structure similar to Control.Monad.State, allowing multiple nested states, distinguishable by provided phantom types.

Vacuum is a library for extracting graph representations of values from the GHC heap at runtime. Those graphs may then be further processed or translated to various representations for visualization -- like Graphviz, or Ubigraph. By itself this library is not of much use to most users, unless you want to use the raw graph data to visualize the heap in some (new) way. Most people will want to translate the graph representation to something like GraphViz format, which can then be rendered to a pretty PNG or SVG file for viewing. See the vacuum-graphviz package for more.

This package provides some stock lenses for swizzling tuple elements. For instance: The package provide all lenses that are in increasing order, for FieldN classes 1-9. If you want to swap the order or permute the elements, you need to make your own. Custom combos are provided by a Template Haskell function.

This is a library for generating fake placeholder data.

This package provides an implementation of the General Decimal Arithmetic Specification by Mike Cowlishaw. For details, see http://speleotrove.com/decimal/

Classy MTL extension of the lovely Opaleye library, which simply just wraps things up in a MonadReader , MonadError context where the config & error are constrained by Classy Lenses & Prisms rather than by concrete types More info on this pattern can be found in George Wilson's BFPG talk : http://talks.bfpg.org/talks/2015-06-09.next_level_mtl.html Note: This API may not be complete. If you need other functions exported then let me know or drop in a PR Also Note: This is only useful if you only have one DB in your transformer stack. :)

This package provides utilities for working with existential types.

Haskell binding to the MPFR library. The library includes both a pure and a mutable interface. The mutable interface should have a lot less overhead than the pure one. Some simple examples of usage can be found in demo/Demo.hs.