Haskell implementation of the TOML configuration language

Optics via the profunctor representation theorem (WIP)

An adapter to convert attoparsec Parsers into blazing-fast Iteratees

Minimalistic library for encoding JSON directly to strict bytestring, which is up to 3x faster than "aeson". For introduction, benchmark results and demo please skip to Readme.

A little ncurses animation of nyan cat.

Fast byte serializer and unserializer

Playlists is a library for working with media playlist files. The original motivation for the library was extracting URLs for streaming radio stations that use PLS and M3U playlist files. The package also includes an executable that can dump the URLs from a playlist file and convert between playlist file formats. Example: Playlist Executable Examples:

Please see the README on GitHub at https://github.com/pkamenarsky/memdb#readme

Parser for the SentiWordNet tab-separated file

Please see the README on GitHub at https://github.com/githubuser/oblivious-transfer#readme

The decision procedure is based on the algorithm used in CVC4, which is itself based on the Omega test.

Haskell bindings and extensions to the curve25519-donna codebase.

svg-tree provides types representing a SVG document, and allows to load and save it. The types definition are aimed at rendering, so they are rather comple. For simpler SVG document building, look after lucid-svg. To render an svg document you can use the rasterific-svg package

Some helpers to make using Prelude.filter and similar value selection a bit easier. Includes combinators for predicates as well as an operator to match the constructor used for the given value.

Implements MurmurHash2, a good, fast, general-purpose, non-cryptographic hashing function. See http://murmurhash.googlepages.com/ for details. This implementation is pure Haskell, so it might be a bit slower than a C FFI binding.

autonix-deps is a library for building automatic dependency detectors for software collections to be built using the Nix package manager.

Please see README.md

WAI Middleware for request rate limiting and throttling. Designed to be configured in the spirit of the NGinx module.

This package provides a QuasiQuotation for llvm-general.

Restart a command on STDIN activity

This program can be used to count lines of code in a program and display them hierarchically. For example, to tally up lines of Haskell code in a git repository: More precisely, recursive-line-count takes a list of file names on standard input, counts lines in each file, and displays the results in a GtkTreeView. Note that although this package is BSD3-licensed, it has LGPL dependencies.

Please see README.md

Query the GitHub REST API programmatically, which can provide a more flexible and clear interface than if all of the endpoints and their types were defined as Haskell values.

hpg is a free, open source password generator. It's design is pretty simple and it generates random passwords between 1 and 2^16 -1 characters.

[Index] For package maintainers and hackage trustees This library offers incremental serialization and deserialization of Haskell values using the binary package. Under the hood, we wrap the incremental decoders from binary's Incremental API as first-class streams as defined in streaming.

Defend the King from the Forces of Different: (work in progress) A simple fast-paced multiplayer RTS game inspired by Bughouse-Chess and Starcraft.

file-command-qq is a simple quasiquoter for running system commands that take a filepath as an argument. For instance will return You can think of [s|echo $filename|] essentially converts into Here is another example All "file parts" start with a '$'. The '$' can be escaped by preceding it with a '\' There are the following options for "file parts" $path $root $directory $parent $filename $dirname $basename $ext Which correspond to the respective functions in https://hackage.haskell.org/package/system-filepath-0.4.6/docs/Filesystem-Path.html#g:1

A modular way to build forms based on applicative functors, based on the work described in: Ezra Cooper, Samuel Lindley, Philip Wadler and Jeremy Yallop "An idiom's guide to formlets" Technical Report, EDI-INF-RR-1263. http://groups.inf.ed.ac.uk/links/formlets/

Intermediate representation for Copilot. 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.

Lackey generates Ruby clients from Servant APIs.

libarchive-conduit reads archives with libarchive. All of the many formats understood by libarchive are supported. Resource use is managed in Haskell with the conduit library. The interface is very simple; archives are read from disk and their contents are presende as a stream of pairs (FilePath, ByteString) of the path to each file and its contents, respectively.

Fst is an application for construction and running of finite state transducers, as based on the concepts of transducers and regular relations developed by Xerox. The syntax of Xerox's fst program has functioned as an inspiration for the syntax of fstStudio. The application was written purely in Haskell, and is intended to be a tool for the Haskell programmer, especially for ones that develop language applications. This package provides an interactive shell for parsing transducers specified in a specialized FST language. See FST.FSTStudio. This package also provides a programmer's interface for building and applying transducers. See FST.TransducerInterface.

For package maintainers and hackage trustees

parse the Yesod routes data structure and generate routes that can be used in typescript

a dAmn ↔ IRC proxy

[Index] For package maintainers and hackage trustees See the demo for an example site with workers set up.

Utilities for flattening servant API types See the documentation of Servant.API.Flatten.flatten.

diagrams-hsqml is a diagrams backend painting on a QtQuick Canvas. To use the package, you only need the main module Diagrams.Backend.HsQML Example usage and QML scripts provided in Diagrams.Backend.HsQML.Tutorial

Experimental

The main feature here is implicit conversion of arguments to AST constructors: Tired of writing things like ? With th-build: Hint: Use () for an empty list argument to an autoconverting function, since [] will yield an type ambiguity error.

Typesafe finite unsigned-integral

The usb package provides a standard Haskell abstraction layer over bindings-libusb providing: abstract types instead of Ptrs, automatic marshalling and unmarshalling, automatic garbage collection, exceptions instead of integer return codes, etc.. While all that is very nice there are still some things that you can do wrong. For example doing I/O with a closed device or reading from or writing to an endpoint which doesn't belong to the claimed interface. Or reading from an Out endpoint or writing to an In endpoint. usb-safe provides the following guarantees: You can't reference handles to devices that are closed. In other words: no I/O with closed handles is possible. The programmer specifies the region in which devices should remain open. On exit from the region the opened devices will be closed automatically. You can't reference handles to configurations that have not been set. You can't reference handles to interfaces that have not been claimed. Just like with devices, the programmer can specify the region in which interfaces should remain claimed. On exit from the region the claimed interfaces will be released automatically. You can't reference handles to alternates that have not been set. You can't reference endpoints that don't belong to a setted alternate. You can't read from an endpoint with an Out transfer direction. You can't write to an endpoint with an In transfer direction. The primary technique used in usb-safe is called "Lightweight monadic regions" which was invented by Oleg Kiselyov and Chung-chieh Shan. See: http://okmij.org/ftp/Haskell/regions.html#light-weight This technique is implemented in the regions package which is re-exported from usb-safe. See the usb-safe-examples package for examples how to use this library:

A color pretty printer with terminfo support

Provides many functions for working with Maybe and Either, including canonical fromMaybeM and fromEitherM functions. Please see README.md.

Cubical implements an experimental simple type checker for type theory with univalence with an evaluator for closed terms.

A simple and pure Haskell implementation of the Huffman encoding algorithm. The huffman function provides the original O(n log n) algorithm implemented with a priority queue. If the input symbols are sorted by probability, the O(n) huffmanSorted function can be used instead.

A flexible Haskell implementation of minimum, maximum, minimum-priority, maximum-priority and custom-ordered heaps.

NetCore is a high-level network programming language. This package provides a NetCore compiler and runtime system for OpenFlow networks. See the Frenetic.NetCore module for commonly used functions. We have several example programs available online at https://github.com/frenetic-lang/netcore/tree/master/examples

A Haskell client to connect to PayPal's REST API (v1)

Please see README.md

A fast lossless compression algorithm, targeting real-time compression scenarios at zlib-level and better compression ratios.

This package defines Monadic functions which provide Choice and Parallelism - (<||&rt;) and (<&&&rt;) - that work on Monads that provide a (MonadBi m IO) instance. Depends on the monadbi library for extracting the IO actions from m. Also provides a good example of how to use the library.

generalized Algebraic Dynamic Programming This library provides efficient multidimensional arrays. Import Data.PrimitiveArray for indices, lenses, and arrays. For generalized ADP users, the library also provides the machinary to fill tables in the correct order required by usual CYK-style parsers, or regular grammars (used e.g. in alignment algorithms). This means that unless your grammar requires a strange order in which parsing is to be performed, it will mostly "just work". In general operations do not perform bounds-checking or other sanity-checking and are aimed towards efficiency as much as possible. Users (like ADPfusion) should perform their own bounds-checking, outside of code that performs "loop-like" operations.

Positive numbers.

Generalized support for list-like structures in Haskell. The ListLike module provides a common interface to the various Haskell types that are list-like. Predefined interfaces include standard Haskell lists, Arrays, ByteStrings, and lazy ByteStrings. Custom types can easily be made ListLike instances as well. ListLike also provides for String-like types, such as String and ByteString, for types that support input and output, and for types that can handle infinite lists.

See https://theam.github.io/require

En este paquete se encuentra los códigos de las librerías desarrolladas en el curso de Informática de 1º del Grado en Matemáticas de la Universidad de Sevilla.

datapacker is a tool to group files by size. It is designed to group files such that they fill fixed-size containers (called bins) using the minimum number of containers. This is useful, for instance, if you want to archive a number of files to CD or DVD, and want to organize them such that you use the minimum possible number of CDs or DVDs. In many cases, datapacker executes almost instantaneously. Of particular note, the hardlink action can be used to effectively copy data into bins without having to actually copy the data at all. datapacker is a tool in the traditional Unix style; it can be used in pipes and call other tools.

Parser for OS X static archive format.

This package provides authentication with passwords hashed and salted using bcrypt which are stored in a database, and works best in situations where an administrator is involved in setting up a user with an initial password. The complete login process, including a default form, is implemented by this plugin, but the application developer must design the interfaces for setting up users and allowing them to change their own passwords, since only the low-level password-setting functions are provided by this package. (Note that other authentication plugins may be more appropriate if you wish to use email verification to set up accounts).

A Haskell binding for the portable TrueType to OpenGL font rendering library FTGL. This package provides OpenGL with polygonal, texture mapped, and extruded fonts using Freetype2 and any truetype font.

cassava-records library helps in auto-creating record data types using Template Haskell by inferring types from the columns of a csv or compatible input file. The record and type classes instances generated can be seamlessly used with cassava(the haskell csv reader library) to load the data into these record types without dealing with any other level of abstraction. Please see README on Github at https://github.com/gdevanla/cassava-records#readme

Argon performs static analysis on your code in order to compute cyclomatic complexity. It is a quantitative measure of the number of linearly indipendent paths through the code. The intended usage is through Argon's executable, which accepts a list of files or directories to analyze. The data can be optionally exported to JSON.

Use this library if you wish to hide your data type's internal representation while still providing a way to exhaustively pattern match on your type using exposed lenses, traversals, or prisms.

A skeleton library to help learners of Haskell concentrate on the pure-functional aspect and let the IO be handled by the library.

Please see the Accuerr Haddock documentation for more information.

Example programs using the Accelerate library. The aim is for this package to evolve and be useful for both performance and regression testing. Refer to the main Accelerate package for more information: http://hackage.haskell.org/package/accelerate

A didactic untyped lambda calculus interpreter.

W3C compliant implementation of GeoPosition API within the Fay Monad

This package defines a framework for linear algebra operations, allowing: Definition of multiple instances of BLAS and LAPACK operations. Definition of multiple representations of vectors and matrices. Arbitrary combination of strategies and structure representations. Type-safe manipulation of context information associated to each strategy. Definition of specialized strategies for a given representation. The framework is based on BLAS (http://www.netlib.org/blas/) and LAPACK (http://www.netlib.org/lapack/) linear algebra libraries, as these are well known libraries in the area. For this reason the design of the framework is strongly oriented to these libraries. Anyway it is possible to easily define operations not considered in these libraries and still maintaining the above properties. Many representations and strategy definitions (from which many are parallel) can be found in the fpnla-examples (http://hackage.haskell.org/package/fpnla-examples) package. Details about the package may be found in the paper: Towards a functional run-time for dense NLA domain. In Proceedings of the 2Nd ACM SIGPLAN Workshop on Functional High-performance Computing. New York, NY, USA. ACM, pages 85-96 (http://www.fing.edu.uy/~mviera/papers/fhpc13.pdf).

This package is intended to ease the transition from GHC 7.6.3- to GHC 7.8+ by providing a backward-compatible role annotation syntax. The module Language.Haskell.RoleAnnots exports backward-compatible declarations usable to assign stricter roles to declarations. Proper role annotations are preferred, but these work, too. The module Language.Haskell.RoleAnnots.Check provides a way to check that a datatype has a set of desired roles. This might be suitable for use in a testsuite. See the module documentation for details. Note that this package works only with GHC 7.4 and up, because it depends on the -XPolyKinds extension. If you need backward compatibility before 7.4, then please look at the source code and adapt the definitions to the kinds of the variables in your program.

A monad to calculate linear recursive sequence efficiently. Matrix multiplication and fast exponentiation algorithm are used to speed up calculating the number with particular index in the sequence. This library also provides a monadic DSL to describe the sequence.

HaXR is a library for writing XML-RPC client and server applications in Haskell.

Wai HMAC Authentication Middleware implementation. This middleware closely models the Amazon AWS Authentication scheme. By default, this middleware will also default to using the HTTP Authorization header. See wai-middleware-hmac-client for ready-to-use client module.

Please see the website https://theam.github.io/tintin

This library provides bindings to the Slack Real Time Messaging API. Users should find it easy to program their own Slack bots using the functionality found in Web.Slack. The bindings are very nearly complete. Library authors looking to build bindings to the Slack Web API may find the FromJSON instances located in Web.Slack.Types useful. Please note that the interface provided by this package is not yet stable. There are a number of unresolved internal inconsistencies which have yet to be resolved by Slack HQ.

CIL is a simplified, intermediate language for C. CIL makes a great frontend for C analysis, instrumentation, and compilation tools.

A small package providing a powerful and easy to use Haskell graph implementation.

Automate keyboard/mouse/clipboard/application interaction.

PortFusion is a minimalistic, cross-platform, transport-layer distributed reverse / forward proxy & tunneling solution for TCP (RDP, SSH, HTTP(S), (S)FTP, VNC, ...) released under GPLv3. A single package that makes the most of each platform by tapping into their unique capabilities, combining this power with an intuitive interface, beautiful design and Haskell's excellent support for unprecedented levels of concurrency and parallelism. It strives for the smallest source code size while delivering maximum throughput with near zero overhead. Windows (: now also builds 64-bit, with GHC 7.6.1 or above *^o*^!! :) GNU/Linux Mac OS X FreeBSD PackagingOnly changes are made for quality assurance reasons. No new official binary releases are made for PackagingOnly changes. Official r.f.i binaries are bit-for-bit the same as r.f.i.p builds for all p.

Deprecated in favor of haskoin This package provides functions for parsing and evaluating bitcoin transaction scripts. Data types are provided for building and deconstructing all of the standard input and output script types.

Type safe indexed list literals

This package exports combinators useful in comparing floating-point numbers in HUnit tests, by using approximate equality.

Add several functions missing in the standard Foreign modules: copy and move based on Storable calloc

A simple DSL for composing drum beats in haskell. Djembe uses the system MIDI device to play these beats.

Graph implemented as an IntMap to Sets of Ints. Functions for Directed and Undirected graphs are provided.

incremental updates to large data structures

The Iteratee monad provides strict, safe, and functional I/O. In addition to pure Iteratee processors, file IO and combinator functions are provided.

This package provides Redis backend for wai-middleware-cache

Please see the README on Github at https://github.com/parsonsmatt/garlic-bread#readme

An automated theorem prover for Zsyntax, a logical calculus for molecular biology inspired by linear logic, that can be used to automatically verify biological pathways expressed as logical sequents. The prover implements automatic proof search for the Zsyntax sequent calculus (ZBS), a logical calculus for a context-sensitive fragment of multiplicative linear logic where sequents are decorated so to account for the biochemical constraints. The theory behind the Zsyntax sequent calculus and its proof search procedure is developed in F. Sestini, S. Crafa, Proof-search in a context-sensitive logic for molecular biology, Journal of Logic and Computation, 2018 (https://doi.org/10.1093/logcom/exy028).

Obtain the host MAC address on *NIX and Windows.

Sproxy is secure by default. No requests makes it to the backend server if they haven't been explicitly whitelisted. Sproxy is independent. Any web application written in any language can use it.