Data-category is a collection of categories, and some categorical constructions on them. You can restrict the types of the objects of your category by using a GADT for the arrow type. To be able to proof to the compiler that a type is an object in some category, objects also need to be represented at the value level. The corresponding identity arrow of the object is used for that. See the Boolean and Product categories for some examples. Note: Strictly speaking this package defines Hask-enriched categories, not ordinary categories (which are Set-enriched.) In practice this means we are allowed to ignore undefined (f.e. when talking about uniqueness of morphisms), and we can treat the categories as normal categories.

HaNS <-> Network Shims for easier porting to HaNS and the HaLVM

Please see the README on Github at https://github.com/athanclark/rose-trees#readme

This is an experimental subword construction algorithm for the adp-multi package. It uses the constraint programming framework monadiccp with the constraint solver OvertonFD. It is slower than the built-in algorithm in adp-multi and serves research purposes. Use it by importing ADP.Multi.Constraint.All instead of ADP.Multi.Rewriting.All in your grammar files.

A cereal-based parser for the Modbus protocol

A tool for starring GitHub repositories. It detects dependent libraries which are hosted on GitHub via .cabal files, and stars the repositories all at once.

Representable functors

Provides an alternative implementation of the Prelude.lines function that treats the following sequences as newline characters: "\r\n" (Windows style) "\r" (Macintosh style, before OS X) "\n" (Unix style) Haskell's IO system supports both platform-specific line ending conversion (by opening the file in "text mode"), and explicit setting of the newline mode for input and output (see System.IO.hSetNewlineMode). However: If you don't know the line ending format in advance, you would have to open the file and detect the newline format manually. ByteString currently honors neither of these; see http://stackoverflow.com/questions/6837628.

For package maintainers and hackage trustees

This package provides a fancy test runner and support for «golden testing». A golden test is an IO action that writes its result to a file. To pass the test, this output file should be identical to the corresponding «golden» file, which contains the correct result for the test. The test runner allows filtering tests using regexes, and to interactively inspect the result of golden tests. This package is a heavily extended fork of tasty-golden.

Sequence optimized for monoidal construction and folding

Details can be found here: http://www.nd.edu/~ccl/software/workqueue

Example data for use with hInduce

The purpose of this package is to provide a faithful implementation of the RFC-2616 HTTP grammar rules without concession to popular deviations that happen in the wild. The implementation is far from complete. My development plan for this package is to add various productions from time to time as I need them in other work I'm doing. Contributions are most welcome and highly encouraged.

The xml-to-json executable (and library) converts XMLs to json format, gaining readability while losing information such as comments, attribute ordering, and such. For files that are slow to process, please use xml-to-json-fast which (starting with version 2.0.0) resides in its own package. The original purpose was to convert legacy XML-based data into a format that can be imported into JSON databases such as CouchDB and MongoDB. The package also includes an executable to directly invoke the library on files (or urls on non-windows platforms). See https://github.com/sinelaw/xml-to-json#readme for details and usage.

A simple use-case for this library is to run the stages of a pipelined streaming computation concurrently. If data is streaming through multiple processing stages, you might build a machine like The >~> operator connects the machines on either side with a one-element buffer. This means that data is pulled from upstream sources eagerly (perhaps pulling one more value than will be consumed by downstream), but it also means that each stage can be working simultaneously, increasing throughput of the entire pipeline. A few small examples are available in the examples directory of the source repository.

Perfectly streaming PNG image decoding.

Size-parameterized vector types and functions using a data-type promotion.

Eventually consistent STM transactions. \ Consistent provides eventually consistent atomic transactions, by delaying updates until no threads is mutating a shared variable. \ This comes at a cost of having a separate TVar for every thread, but has the advantage that no thread will ever lock or retry except for the manager actor responsible for performing the updates.

Small library streaming stock market data from the yahoo finance api

The Pinboard API is a way to interact programatically with your bookmarks, notes and other Pinboard data. This library wraps the API exposing functions and data structures suitable for usage in Haskell programs.

Clear to write, read and edit DSL for HTML. Names are consistent, and do not conflict with base or are keywords (all have suffix _) Same combinator can be used for attributes and elements (e.g. style_) For more, read the blog post See the Lucid module for more documentation.

Maps (and sets) indexed by keys satisfying PartialOrd. The goal is to provide asymptotically better data structures than simple association lists or lookup tables. Asymptotics depend on the partial order used as keys, its width \(w\) specifically (the size of the biggest anti-chain). For partial orders with great width, this package won't provide any benefit over using association lists, so benchmark for your use-case!

For package maintainers and hackage trustees

Data.BufferBuilder is an efficient library for incrementally building up ByteStrings, one chunk at a time. Early benchmarks show it is over twice as fast as ByteString Builder, primarily because BufferBuilder is built upon an ST-style restricted monad and mutable state instead of ByteString Builder's monoidal AST. Internally, BufferBuilder is backed by a few C functions. Examination of GHC's output shows nearly optimal code generation with no intermediate thunks -- and thus, continuation passing and its associated indirect jumps and stack traffic only occur when BufferBuilder is asked to append a non-strict ByteString. I benchmarked four approaches with a URL encoding benchmark: State monad, concatenating ByteStrings: 6.98 us State monad, ByteString Builder: 2.48 us Crazy explicit RealWorld baton passing with unboxed state: 28.94 us (GHC generated really awful code for this, but see the revision history for the technique) C + FFI + ReaderT: 1.11 us Using BufferBuilder is very simple: This package also provides Data.BufferBuilder.Utf8 for generating UTF-8 buffers and Data.BufferBuilder.Json for encoding data structures into JSON.

Create Arch Linux packages from Cabal packages.

Conway's life as an OpenGL example. Special thanks to Will Donnelly for his pure-functional Brians Brain code that got this started (cabal unpack brians-brain).

The cuBLAS library is an implementation of BLAS (Basic Linear Algebra Subprograms) for NVIDIA GPUs. This package provides FFI bindings to the functions of the cuBLAS library. You will need to install the CUDA driver and developer toolkit: http://developer.nvidia.com/cuda-downloads See the travis-ci.org build matrix for tested CUDA library versions.

Please see the README on Github at https://github.com/MarisaKirisame/HappyTree#readme

ARM SVD and CubeMX XML parser and pretty printer for STM32 family

Toy-level solver implementation of various problems including SAT, SMT, Max-SAT, PBSPBO (Pseudo Boolean SatisfactionOptimization), MILP (Mixed Integer Linear Programming) and non-linear real arithmetic.

Parse without thinking ... yuuko "/body" "htmlbodyhi<body>/html"

Postmaster implements an ESMTP server. Given a configuration, it starts up and listens for incoming SMTP connections, handles them, and pipes the accepted e-mail messages into an arbitrary local mailer of your choice. A good local mailer is Procmail. Beyond that, you can configure and modify every little step of the SMTP transaction. All the real work is done through call-back functions.

haskell-cypher makes it easy to send cypher commands to neo4j servers over their REST API. Additionally, it allows users to parse haskell datatypes from cypher queries.

Warning: This software is pre 1.0 and thus its API may change very dynamically while updating only minor versions. This package will follow the PVP once it reaches version 1.0. OAuth is a popular protocol allowing servers to offer resources owned by some user to a series of authorized clients securely. For instance, OAuth lets Twitter provide access to a user's private tweets to the Twitter client registered on their phone. oauthenticated is a Haskell library implementing OAuth protocols atop the minimalistic http-client HTTP client library extracted from http-conduit. Network.OAuth offers simple functions for signing Network.HTTP.Client.Requests along with tools for Network.OAuth.Credential management and Network.OAuth.Server configuration. Network.OAuth.Simple provides a slightly more heavy-weight interface which manages the necessary state and configuration using a monad transformer stack. There's also an implementation of OAuth's three-legged credential acquisition protocol built atop the Network.OAuth API. This can be handled in both conformant and old-style modes: conformant will reject server responses which are not conformant with RFC 5849 (which builds atop community version OAuth 1.0a) while old-style better allows for less-than-compliant servers. See Network.OAuth.Types.Params.Version for more details. Currently oauthenticated only supports OAuth 1.0 and is in alpha. OAuth 2.0 support is a potential goal, but it's unclear if it can be transparently supported at a similar level of abstraction.

Fast AES cipher implementation with advanced mode of operations. The modes of operations available are ECB (Electronic code book), CBC (Cipher block chaining), CTR (Counter), XTS (XEX with ciphertext stealing), GCM (Galois Counter Mode). The AES implementation uses AES-NI when available (on x86 and x86-64 architecture), but fallback gracefully to a software C implementation. The software implementation uses S-Boxes, which might suffer for cache timing issues. However do notes that most other known software implementations, including very popular one (openssl, gnutls) also uses similar implementation. If it matters for your case, you should make sure you have AES-NI available, or you'll need to use a different implementation.

See examples and full readme on the Github page: https://github.com/egonSchiele/actionkid

A library for efficiently rendering Haskell datatypes to bytestrings. Note: if you use GHCi or Template Haskell, please see the README file for important details about building this package, and other packages that depend on it: https://github.com/mailrank/blaze-textual#readme

Haskell CSS EDSL

Parsing and manipulation of rtorrent state file contents

Useful utility functions that only depend on base.

git-config is a simple megaparsec parser for Git configuration files. It aims to provide the simplest API possible for parsing Git configuration files so that you can get to whatever it was you were doing. A sample of this library in use:

Simple storage interface to PostgreSQL written in Haskell

MonadReader and MonadState without the functional dependencies

Library for reading phd sequence files

This template includes working callbacks to handle the File and Help menus and File Save/Open dialogs, with dummy handlers for selecting filenames and the Edit menu's Cut, Copy, and Paste. The main canvas uses Cairo for graphics rendering, and includes example code from the cairo package. To build your own application on top of this, first grab the code. You can either grab it from hackage with cabal unpack cairo-appbase, or clone the git repo: To add widgets, install glade from your distro system and run glade data/main.ui. Save the resulting file in GtkBuilder format. Note that you must run cabal install to put the UI file in the correct place for your application to pick it up. To modify the code, edit src/cairo-appbase.hs. Hooking up functions to widgets is very simple: get a widget by name (which you set in ui file), and hook one of its signals (which you found in the Signals tab in glade) to an IO () action: The template code includes a trivial definition of myCut: A real application will want to pass data to the callback. In C, this is fairly tedious as you only have a single void * to pass to callbacks as user_data, and applications typically do lots of marshalling and unmarshalling to pass data around. In Haskell however, you can make yourself a more complex callback handler and use a curried version of it in each instance:

Generalized stream processors

Simple TokyoCabinet CLI interface

Please see the README on GitHub at https://github.com/ChrisPenner/slick#readme

Grouped lists work like regular lists, except for two conditions: Grouped lists are always finite. Attempting to construct an infinite grouped list will result in an infinite loop. Grouped lists internally represent consecutive equal elements as only one, hence the name of grouped lists. This mean that grouped lists are ideal for cases where the list has many repetitions (like [1,1,1,1,7,7,7,7,7,7,7,7,2,2,2,2,2], although they might present some deficiencies in the absent of repetitions.

This package provides a partial binding to the Win32 DHCP Server Management API. Its purpose is to query and control a Microsoft DHCP server. Enough functionality is defined so so that Ipv4 client lease and reservation records can be manipulated programmatically._Only 32-bit versions of GHC are supported at this time._ Here are a few notes on the required environment: Only 32-bit executables are supported. This is mainly because pointers are assumed to be 4 bytes wide in a few places. Support for 64-bit executables may be added in the future. All library calls should be supported on Windows 7 or above. Simple Example and Usage

Types, classes, and functions for using the Siren—Hypermedia Type in Haskell.

Keyboard events in web browsers are often represented as keycodes, which (1) are difficult to remember, and (2) sometimes vary from browser to browser. Web.KeyCode allows one to look up a key press's keycode and get a plain English description of the key that was pressed, to reduce confusion.

Please see the README on Github at https://github.com/ChrisCoffey/haskell-opentracing-light#readme

A library for parsing, pretty-printing, and manipulating Bash shell scripts.

IO Monadic binding for libbladeRF software defined radio.

Haskell streaming library targeting Conduit API while being smaller and faster

The hsexif library provides functions for working with EXIF data contained in JPEG files. Currently it only supports reading the data.

The optparse-applicative package, as well as optparse-simple, has some undesirable behavior by default, and is quite verbose. This package exists to work around those two. For instance: optparse-applicative does not show help on error by default. optparse-applicative does not disambiguate commands. So, if you have a command my-executable foobar, but your user runs my-executable f, optparse-applicative will not disambiguate this by default. For more specific documentation, see the module documentation for Options.Applicative.Helper.

HGamer3D is a toolset for developing 3D games in the programming language Haskell. This package provides the SDL2 binding. HGamer3D-SDL2-Binding is available on Windows and Linux. This binding does not claim to have full coverage of SDL2 functionality, but only to support what is needed for the HGamer3D-WinEvent package.

A vty-based wrapper around the fswatch utility, which makes it easy to monitor parallel Cabal builds.

Please see the README on GitHub at https://github.com/shlok/streamly-lmdb#readme

A simple request dispatcher.

See README

Wadler/Leijen pretty printer with annotations and support for colorful console output

Type classes, pickling combinators, and GHC.Generics implementations for Query Strings

Happstack is a web application framework. HSP is an XML templating solution. This package makes it easy to use HSP templates with Happstack.

Haskell mini-language to create HTML documents with a mixture of markup and plots based on the C3.js library. See the github page for an introduction.

See the README on GitHub at https://github.com/aviaviavi/confetti#readme

chatter is a collection of simple Natural Language Processing algorithms. Chatter supports: Part of speech tagging with Averaged Perceptrons. Based on the Python implementation by Matthew Honnibal: (http://honnibal.wordpress.com/2013/09/11/a-good-part-of-speechpos-tagger-in-about-200-lines-of-python/) See NLP.POS for the details of part-of-speech tagging with chatter. Phrasal Chunking (also with an Averaged Perceptron) to identify arbitrary chunks based on training data. Document similarity; A cosine-based similarity measure, and TF-IDF calculations, are available in the NLP.Similarity.VectorSim module. Information Extraction patterns via (http://www.haskell.org/haskellwiki/Parsec/) Parsec Chatter comes with models for POS tagging and Phrasal Chunking that have been trained on the Brown corpus (POS only) and the Conll2000 corpus (POS and Chunking)

Prolog with lojban

A BSON Document is an untyped (dynamically type-checked) record. I.e. it is a list of name-value pairs, where a Value is a single sum type with constructors for basic types (Bool, Int, Float, String, and Time), compound types (List, and (embedded) Document), and special types (Binary, Javascript, ObjectId, RegEx, and a few others). A BSON Document is serialized to a standard binary encoding defined at http://bsonspec.org. This implements version 1 of that spec.

The games: Ataxx, Bamp, Halma, Hez, Kram, Nim, Reversi, TicTacToe and Zenix

For package maintainers and hackage trustees

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

This package provides the region monad transformer. Scarce resources like files, memory pointers or USB devices for example can be opened in a region. When the region terminates, all opened resources will be automatically closed. The main advantage of regions is that the opened resources can not be returned from the region which ensures no I/O with closed resources is possible. The primary technique used in this package 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 Also see the regions-mtl and regions-monadstf packages which provide instances for the classes in the respected monad transformers packages. For an example on how to use this library see the safer-file-handles, usb-safe or regional-pointers packages.

High-performance JSON parser

JSON quasiquatation library for Haskell. This package only expose functionality so quasiquoters for different JSON-libraries can more easily be constructed. See text-json-qq and aeson-qq for libraries that are based on json-qq.

Please see README.md

Designed for xmonad users relies on feh to setup wallpaper. It allows user to setup a random image as the wallpaper choosed from user specified image directories.

For package maintainers and hackage trustees

Deprecated in favour of http://hackage.haskell.org/package/writer-cps-mtl-0.1.0.0

Template Haskell based derivers for typical newtype instances, which the GeneralizedNewtypeDeriving extension refuses to handle. Amongst others provides support for the "monad-control" classes: Control.Monad.Trans.Control.MonadTransControl Control.Monad.Trans.Control.MonadBaseControl

Extract the source code for Haskell declarations by name, for use in documentation.

Pass a list of percent-encoded strings to the executable as arguments and it will print the decoded versions, separated by newlines.

Documentation is here: https://generics-eot.readthedocs.io/

protobuf-native uses the code generated from protobuf for C++ in Haskell. [Index] For package maintainers and hackage trustees protobuf-native uses the code generated from protobuf for C++ in Haskell to go between Haskell and protobuf data structures. It makes use of Template Haskell to assist in generating the interface between protobuf and your data structures. Objects have finalizers so you never need to worry about memory management. protobuf is a Template Haskell splice that takes the file path to a compiled protobuf object file and the name of the data type you want to build bindings to. The data type must: For example, if we have a Person protobuf structure in the file person.proto: First we run protoc --cpp_out=. person.proto then compile the person.pb.cc file. Unfortunately, at this point, you need to mangle the C++ header file as per the Protobuf Mangling Guide below, ideally this would be automated. Do not re-run protoc unless you want to re-mangle the file. Always check these files in to source control. Then we can write two Haskell data structures to represent these types: If you get any of this wrong, you will get a compiler error. Note that NameT is the type of the name field in PersonT. With data kinds you may get confusing error messages here. Now we can: The C++ are ForeignPtrs with finalizers, so you do not need to free anything. Working with Cabal requires extra build steps. See this project's Setup.hs for an example on how to run protoc and clang++ in the build phase. The property above is used by QuickCheck to test the library works. The tests are located in tests/Tests.hs. Namely, for all types in Protobuf the following property holds: By profiling the tests you can verify the library does not leak memory. This is a temporary measure until we make a post-processor for protobuf header files. This is an inline function that must be un-inlined. Go to the header file and search for that function name (in this case clear_firstname). You will find two occurances: Remove the inline from both of these. Go to the header file and find set_lastname and remove the inline. It may also look like an field name, such as: Remove the inline from: When dealing with a string setter, you only need to un-inline the std::string function. I.e. This is currently another work around that is fixable. If your problem has performance constraints you may want to consider using this library. When working with large protobuf files, you may want to write file iterators / network operations in C++ and process the data in Haskell. This library lets you only pay for converting the parts of the data structure you need. You can, for example, iterate over a large file 20 elements at a time and only pull out the components of the protobuf structure you need to pass to Haskell.

This plugin provides the programmer with a way to annotate certain types using a Fuse pragma from the fusion-plugin-types package. The programmer would annotate the types that are to be eliminated by fusion. During the simplifier phase the plugin goes through the relevant bindings and if one of these types are found inside a binding then that binding is marked to be inlined irrespective of the size. This plugin was primarily motivated by streamly but it can be used in general.

Flattens European non-ASCII characaters into ASCII

Space Privateers is a roguelike game set in space.

pinpon is a gateway for various cloud notification services, such as the Amazon AWS SNS service. Think of pinpon as a hub for dispatching notifications originating from multiple notification sources. Clients of the pinpon service create topics and send notifications via the REST-ish pinpon service, and the pinpon server takes care of the per-service details and communicating with the upstream cloud services. Advantages of this approach, compared to programming directly to the individual notification services' interfaces, are: A common API for all supported notification services. The secret credentials required to communicate with each cloud notification service can be kept in a central location (namely, the pinpon server), rather than being distributed to each notification source host, therefore reducing the attack surface. Hosts which send notifications via the pinpon gateway can be firewalled from the public Internet. This is especially useful in IoT applications. Currently-supported notification services: Amazon AWS SNS

This package defines a class, Hashable, for types that can be converted to a hash value. This class exists for the benefit of hashing-based data structures. The package provides instances for basic types and a way to combine hash values.

[Index] For package maintainers and hackage trustees Very simple library for downloading a list of proxies from http://proxy-list.org Library exports two functions. Proxy is represented by a tuple (Host, Port). Example:

Please see the README on GitHub at https://gitlab.com/costar-astrology/freer-simple-contrib/tree/master/freer-simple-http

Lenses for types in generics-sop package

See module docs for more information, and cv-combinators package for example usage.

Generate a COLLADA file with textures, materials, animations, ... It can be used to visualize algorithms that produce a stream of positions, see http://www.youtube.com/watch?v=ZpJzG28Yv8Y

Annotations provides utility functions to make working with annotated trees easier. There are two implementations: one for working with open datatypes that explicitly make their child positions accessible through a type argument, and one for working with MultiRec datatypes. Parser combinators make it easy to construct trees annotated with position information. For the MultiRec implementation, there is the Yield monad that allows construction of trees in postorder. Error algebras allow destruction of trees using catamorphisms. The algebra is allowed to indicate failure in which case the error is automatically coupled with the annotation at the position at which the error occurred.