Library and tiny tool for working with ignore files of different version control systems

mastodon client module for Haskell

A parser and renderer for binary Olson timezone files whose format is specified by the tzfile(5) man page on Unix-like systems. For more information about this format, see http://www.iana.org/time-zones/repository/tz-link.html. Functions are provided for converting the parsed data into TimeZoneSeries objects from the timezone-series package. On many platforms, binary Olson timezone files suitable for use with this package are available in the directory usrshare/zoneinfo and its subdirectories on your computer. For a way to read binary Olson timezone files at compile time, see the timezone-olson-th package (http://hackage.haskell.org/package/timezone-olson-th).

A framework introducing annotations by preprocessing. For using it, it is enough to derive QuickAnnotate.Annotatable and then use the preprocessor (qapp). The package contains an example demonstrating this procedure.

This package allows the linking against GHC-compiled object files and shared libraries. Specialized modules are provided for navigating directory structure and dependency checking. No attempt at type-safe loading of symbols is made.

A library of general-purpose sorting utilities.

A small roguelike; perhaps 10% of a real one. In development

This package defines operations for an interactive hex-caluclator using GHCi. This is a simple and casual interactive tool like Perl and Excel for daily work.

Example applications for Elerea. They are factored out into their own package so as to avoid unnecessary dependencies in the library. Check out the doc directory for the colourful literate sources. The programs included are the following: bounce: an example for creating dynamic collections of signals; left click to create balls, drag existing balls with left button to propel them and drag with right to select balls for deletion (upon release); chase: a minimal example that demonstrates reactivity and mutually recursive signals; breakout: a not too fancy breakout clone; you can simply use the mouse to move the paddle.

This is a Haskell binding for the TradeKing developers API (https:developers.tradeking.com/). It currently supports retrieving quotes and stock information, as well as the quote and trade streaming API. Support for the other TradeKing API endpoints is forthcoming. To use, install the package via cabal. This will create an executable called tradeking. To connect to the TradeKing API, you will need to create a new personal application from the TradeKing developers site. This should give you four strings: an OAuth consumer key, an OAuth consumer secret, an OAuth Token, and an OAuth Token Secret. You supply these into the tradeking application using a configuration file (either `$(HOME)/.tradeking` or /etc/tradeking.conf). This configuration file should look like: Now you can run `tradeking quote SPY` to have it return the current quote for the S&P 500 ETF. `tradeking info MSFT` will provide information on Microsoft, and `tradeking stream MSFT` will provide a live stream of MSFT quotes. All commands accept more than one stock, so `tradeking quote MSFT AAPL`, `tradeking info MSFT SPY`, and `tradeking stream SPY AAPL` work as expected (subject to TradeKing) limits. You can also request quotes programmatically, using the API described here.

The Rakuten API for Haskell

[Index] [Quick Jump] For package maintainers and hackage trustees This module allows you to decode a Pandoc value using any Text.Pandoc.Readers function. You should use newtypes like so:

Please see the README on Github at https://github.com/IvanMalison/gtk-strut#readme

This library can be used as a basis for complex HTML parsers, or for streaming. E.g., by composing it with the "list-t-attoparsec" library you can produce a token stream, thus becoming able to implement a highly efficient stream-parser, which works in a single pass, constant memory and is capable of early termination. "list-t-html-parser" is such a parser.

Run multiple commands, interleaving output and errors

Provides a type-safe encoding of the Rollbar API. Also provides functions to communicate with the Rollbar API.

Most json packages dictate a data structure that corresponds to json values. To serialize other values to json, then that value must be marshalled into the specified structure. This library avoids this marshalling step, and is thus potentially more efficient when serializing arbitrary data structures. Unfortunately json-builder cannot yet read or process json data, and it's not clear to me yet how pull a similar kind of trick to avoid unnecessary data structures when parsing json data into arbitrary data types.

This package provides a GHC.Generics-based Control.DeepSeq.Generics.genericRnf function which can be used for providing a rnf implementation. See the documentation for the genericRnf function in the Control.DeepSeq.Generics module to get started. The original idea was pioneered in the generic-deepseq package (see http://www.haskell.org/pipermail/haskell-cafe/2012-February/099551.html for more information). This package differs from the generic-deepseq package by working in combination with the existing deepseq package as opposed to defining a conflicting drop-in replacement for deepseq's Control.Deepseq module. Note: The ability to auto-derive via GHC.Generics has been merged into deepseq-1.4.0.0. This package is now still useful for writing code that's also compatible with older deepseq versions not yet providing GHC.Generics-support.

Implementation of Overloaded Record Fields based on current GHC proposal. It is built on top of functionality that is included in GHC 8.0.1, but it works on older GHC versions as well. Most importantly, this library provides Template Haskell functions for automatic deriving of instancess for HasField and ModifyField type classes. With these instances overloaded fields can be used directly as getters and lenses. See README for usage examples. More about the current status of OverloadedRecordFields language extension can be found on: GHC Wiki: OverloadedRecordFields.

AERN-Net provides datatypes and abstractions for defining and executing networks of communicating processes. These networks have a fixed topology, which can be infinite via recursion. The communication on each channel is driven by some query-response protocol. Basic protocols for communicating approximations of real numbers and functions are provided together with protocol combinators eg for communicating value pairs or lists and communicating with additional query parameters or with optimised repetitions. An class-based abstraction is provided to make it possible to execute networks on various distributed backends without modification. At the moment there is only one backend, which is not distributed. It is envisaged that truly distributed backends will be added soon, eg based on plain TCP, MPI or REST/SOAP Web services. A mathematical foundation of these networks is described in the draft paper http://www-users.aston.ac.uk/~konecnym/papers/ernets08-draft.html. Simple examples of usage can be found in modules DemoMax and DemoSqrt in folder examples.

Combinators for rendering EDE templates in servant web applications. Documentation and examples available at Servant.EDE.

IP Routing Table is a tree of IP ranges to search one of them on the longest match base. It is a kind of TRIE with one way branching removed. Both IPv4 and IPv6 are supported.

ReaderT transformer pattern for higher kinded composite data.

This library allows you to construct a Merkle tree on top of any underlying key–value database. It works by organizing your key–value pairs into a binary radix tree, which is well suited for storing large dictionaries of fairly random keys, and is optimized for storing keys of the same length.

A free functor is a left adjoint to a forgetful functor. It used to be the case that the only category that was easy to work with in Haskell was Hask itself, so there were no interesting forgetful functors. But the new ConstraintKinds feature of GHC provides an easy way of creating subcategories of Hask. That brings interesting opportunities for free (and cofree) functors. The examples directory contains an implementation of non-empty lists as free semigroups, and automata as free actions. The standard example of free higher order functors is free monads, and this definition can be found in Data.Functor.HFree.

Progression is a library that builds on the criterion benchmarking library. It stores the results of running your benchmarks and graphs the performance of different versions of your program against each other. See the Progression.Main module, and the original blog post at http://chplib.wordpress.com/2010/02/04/progression-supporting-optimisation-in-haskell/ to get started, as well as the later post http://chplib.wordpress.com/2010/03/02/progression-0-3-bar-charts-and-normalisation/.

[Index] For package maintainers and hackage trustees

i3 block hs implementation

Typical usage is described at http://github.com/nonowarn/has/blob/master/examples/Announce04.lhs.

@env-parser is a small library for configuring programs based on information from the environment. It's goals and design are similar to that of @cmdargs@ or @optparse-applicative@ but aimed at automatically managed programs such as those that might be run via Heroku or Runit/daemontools. @env-parser@ intentionally sacrifices power for comprehensibility---the primary interface, @Parser@, implements only @Applicative@. This provides better runtime error messages and automatically generated static help using parser annotations. It also expresses a principle of simplicity in configuration: arbitrary uses of @Monad@ or even @Alternative@ can lead to opaque failures prior to a program even beginning to run.

A library that provides a few multimap variants.

size-grid allows you to make finite sized grids and have their size and shape confirmed at compile time Consult the readme for a short tutorial and explanation.

Hopfli provides a pure interface to compress data using the Zopfli library algorithm.

Allow interoperability between the streaming and conduit data streaming ecosystems.

[Index] For package maintainers and hackage trustees

Deprecated in favor of bytestring (Deprecated) Packed Strings.

This provides a much safer semaphore than the QSem, QSemN, SampleVar in base. Those base modules are not exception safe and can be broken by killThread. See https://github.com/ChrisKuklewicz/SafeSemaphore for more details.

Tools for working with ROS in Haskell. ROS (http://www.ros.org) is a software framework developed by Willow Garage (http://http://www.willowgarage.com/) that aims to provide a standard software architecture for robotic systems. The main idea of the framework is to support the development and execution of loosely coupled Nodes connected by typed Topics. Each Node represents a locus of processing, ideally with a minimal interface specified in terms of the types of Topics it takes as input and offers as output. This package provides libraries for creating new ROS Nodes in Haskell, along with the roshask executable for creating new ROS packages and generating Haskell code from message definition files (see the ROS documentation for information on message types). See http://github.com/acowley/roshask/wiki for more information on getting started.

Haskell module to execute single or multiple shell commands

This package adds quasiquoter for multiline strings, interpolation and simple templating. It can handle repetition templates which makes it Handy for outputting larger structures, such as latex tables or gnuplot files. 0.3.0 - Instead of Strings, the str quasiquoter produces values of type `(Monoid a, IsString a) => a`, making it compatible many other libraries, such as Data.Text and Blaze.Builder. 0.2.6 - A handy quote for printing 0.2.5.1 - version bump for ghc-7.0.1

Print all ANSI console colors.

This module provides an implementation of the Apriori algorithm for association rule mining. It uses Control.Parallel.Strategies for parallelism and allows the user to provide custom selection criteria. See hinduce-examples for an example. hInduce is a framework for knowledge discoverymachine learningdata mining. It has a modular design that hopefully will invite others to re-use and build upon the interface. This module currently deviates from this concept, because we had a different focus and too limited time budget to investigate other rule mining algorithms and find any use for this kind of abstraction.

This package provides a pure interface for compressing and decompressing streams of data represented as lazy ByteStrings. It uses the bz2 C library so it has high performance. It provides a convenient high level API suitable for most tasks and for the few cases where more control is needed it provides access to the full bzip2 feature set.

Methods of controlling class instance resolution in Haskell.

The zip-archive library provides functions for creating, modifying, and extracting files from zip archives. The zip archive format is documented in http://www.pkware.com/documents/casestudies/APPNOTE.TXT. Certain simplifying assumptions are made about the zip archives: in particular, there is no support for strong encryption, zip files that span multiple disks, ZIP64, OS-specific file attributes, or compression methods other than Deflate. However, the library should be able to read the most common zip archives, and the archives it produces should be readable by all standard unzip programs. Archives are built and extracted in memory, so manipulating large zip files will consume a lot of memory. If you work with large zip files or need features not supported by this library, a better choice may be zip, which uses a memory-efficient streaming approach. However, zip can only read and write archives inside instances of MonadIO, so zip-archive is a better choice if you want to manipulate zip archives in "pure" contexts. As an example of the use of the library, a standalone zip archiver and extracter is provided in the source distribution.

This library introduces BoundedChan. BoundedChans differ from Chans in that they are guaranteed to contain no more than a certain number of elements.

No description yet

Poppler is a fork of the xpdf PDF viewer, to provide PDF rendering functionality as a shared library, to centralize the maintenance effort. And move to forward in a number of areas that don't fit within the goals of xpdf.

ROS message parser, render and generator

[Index] [Quick Jump] For package maintainers and hackage trustees A very very minimal package - provides Windows and Linux compatible definitions for the ICMP protocol and the IP Header Include option for the socket library. The library is theoretically also compatible with MacOS but has not been tested.

Haskell implementation of siphash. [http:/131002.netsiphash/siphash.pdf]

The mighty Tiled 2d map editor is an open source app for creating tile based level maps. This package provides types and aeson instances to read Tiled json files.

Please see the README on GitHub at https://github.com/fumieval/liszt#readme

A hashed byte-vector based on algebraic hashes and finger trees

Extends binary with parsec/attoparsec style parsing combinators.

A standalone Web application that provides for paragraph-by-paragraph commentary by document reviewers, based on the user interface from http://book.realworldhaskell.org/. Any Web page can be configured to work with the service by adding just a little bit of Javascript that makes it load the comment Web UI. See the README or the homepage for more information.

Handy functions when using lens.

Zot language (http://semarch.linguistics.fas.nyu.edu/barker/Iota/zot.html) And try and

A simple DSL for writing HTML5 Canvas in haskell and converting it to Javascript. By static we mean non-interactive, so the parts of the Canvas API that need to query the browser for run time information like `isPointInPath(x, y)` are not included. This turns out to be a surprisingly small part of HTML5 Canvas.

This light-weight library provides a basic, but fully-type-checked zipper implementation, suitable for any algebraic data structure. Our implementation has no notion of "left" and "right", and instead uses lenses (from the "yall" package) to indicate directions to "navigate down to". For a similar approach with many more features, but less type-safety see "pez". UPDATE: I have stopped developing this package; instead look into "lens" v3.0 which includes similar functionality CHANGES: 0.2 to 0.3: depend on new yall, depending on new categories

This library aims to be a tool for constructing a settings management UI on top of the relevant part of your program state. The settings tree structure definition is separate from the actual setting values, so your program logic code doesn't need to be changed. It can access the settings as regular Haskell values. The settings are presented to the user as a tree hierarchy. The idea has some similarity to git config and Weechat's settings system, but isn't identical. To get started, see the tutorial in the Data.Settings module.

This library provides the type-class and functions to convert between polymorphic data-types and its monomorphic representation type, such as length-indexed vectors, singletons for type-level natural numbers, etc.

A lightweight API for LeanKit (http://leankit.com)

A Haskell implementation of Foreman

Implements the Modbus TPC/IP protocol.

Several classes that extend the Arrow class, and some transformers that implement or lift these classes.

language-python is a Haskell library for lexical analysis, parsing and pretty printing Python code. It supports versions 2.x and 3.x of Python.

KTX is a format for storing textures for OpenGL® and OpenGL® ES applications. It is distinguished by the simplicity of the loader required to instantiate a GL texture object from the file contents. https://www.khronos.org/opengles/sdk/tools/KTX/file_format_spec/

A domain specific language and a code generator desined to create RESTful services for managing an RDBMS with Yesod web framework and Persistent.

This package provides functionality for generalising the deriving mechanism in Haskell to arbitrary classes. It was first described in the paper: A generic deriving mechanism for Haskell. Jose Pedro Magalhaes, Atze Dijkstra, Johan Jeuring, and Andres Loeh. Haskell'10. The current implementation integrates with the new GHC Generics. See http://www.haskell.org/haskellwiki/GHC.Generics for more information. Template Haskell code is provided for supporting older GHCs. This library is organized as follows: Generics.Deriving.Base defines the core functionality for GHC generics, including the Generic(1) classes and representation data types. On modern versions of GHC, this simply re-exports GHC.Generics from base. On older versions of GHC, this module backports parts of GHC.Generics that were not included at the time, including Generic(1) instances. Generics.Deriving.TH implements Template Haskell functionality for deriving instances of Generic(1). Educational code: in order to provide examples of how to define and use GHC.Generics-based defaults, this library offers a number of modules which define examples of type classes along with default implementations for the classes' methods. Currently, the following modules are provided: Generics.Deriving.Copoint, Generics.Deriving.ConNames, Generics.Deriving.Enum, Generics.Deriving.Eq, Generics.Deriving.Foldable, Generics.Deriving.Functor, Generics.Deriving.Monoid, Generics.Deriving.Semigroup, Generics.Deriving.Show, Generics.Deriving.Traversable, and Generics.Deriving.Uniplate. It is worth emphasizing that these modules are primarly intended for educational purposes. Many of the classes in these modules resemble other commonly used classes—for example, GShow from Generics.Deriving.Show resembles Show from base—but in general, the classes that generic-deriving defines are not drop-in replacements. Moreover, the generic defaults that generic-deriving provide often make simplifying assumptions that may violate expectations of how these classes might work elsewhere. For example, the generic default for GShow does not behave exactly like deriving Show would. If you are seeking GHC.Generics-based defaults for type classes in base, consider using the generic-data library. Generics.Deriving.Default provides newtypes that allow leveraging the generic defaults in this library using the DerivingVia GHC language extension. Generics.Deriving re-exports Generics.Deriving.Base, Generics.Deriving.Default, and a selection of educational modules.

Single line text rendering utility. See README.md for more information.

An interface to the Activity Streams specifications, using an aeson-based representation of the underlying ActivityStream structures. An ActivityStream is a representation of social activities in JSON format, using a standard set of structures. The specification is very flexible in allowing most fields to be omitted, while also allowing arbitrary new fields to be created when necessary. This library attempts to maximize type safety while retaining the flexibility present in the specification.

Library for easily running embedded PostgreSQL server for tests. It downloads, runs, checks and stops PostgreSQL Database instance for you.

Keiretsu is an orchestration manager primarily designed for local development and integration testing. It allows you to specify dependencies that should be running/available before the start of the local application, triggers setup/teardown hooks, and applies a consistent environment to all child processes ensuring deterministic and repeatable configuration.

Some data types useful for describing the hard pointy things inside your mouth

Custom xmonad example, plus several bits of functionality for managing media within XMonad.

A regular expressions library that does not suck. Based on pcre-light. Takes and returns Stringables everywhere. Includes a QuasiQuoter for regexps that does compile time checking. SEARCHES FOR MULTIPLE MATCHES! DOES REPLACEMENT!

Please see github.com/blitzcode/hackage-diff for a user's manual. Sample output

Hexmino is a small game where you have to put domino-like hexagonal tiles into a grid in as little time as possible

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

This package provides bindings to the farmhash library. FarmHash is a family of very fast hash functions (see https://code.google.com/p/farmhash/). They are not suitable for cryptography. This package bundles the library with it so there are no external dependencies.

This library provides functions to simplify extraction of data from generic xml tree structures (as produced by parsing xml with the xml package), while handling location information to provide decent error messages in case of errors. Some limitations Only handles unqualified names. (This is by design to simplify usage.) No column number and sometimes no line number reference in error values.

adp-multi is an implementation of Algebraic Dynamic Programming for multiple context-free languages. It is a library based on the original Haskell implementation and can be considered an unoptimized prototype.

Deprecated in favor of streaming-commons

A tested, minimal wrapper around GitHub's API.

Deprecated Generates HTML for Data.Tree as TreeMap which is possible explore directly in browser because of small javascript code included. Each node is displayed as white box without any nested boxes inside.

Reusable CSS engine allowing you to parse CSS stylesheets and to query the style properties for a given element. It covers CSS parsing, selection, cascade, and inheritance, whilst allowing you to declaratively define supported properties and at-rules. The hope is that this would be useful for implementing new browser engines, web development tools, and UI frameworks.

Native implementation agentx protocol (rfc2741)

Please see the README on Github at https://git.localcooking.com/tooling/tmapmvar#readme

This package provides the pattern-matching facility that fulfills the following three criteria for practical pattern matching for non-free data types: (i) non-linear pattern matching with backtracking; (ii) extensibility of pattern-matching algorithms; (iii) ad-hoc polymorphism of patterns. Non-free data types are data types whose data have no standard forms. For example, multisets are non-free data types because the multiset '[a,b,b]' has two other equivalent but literally different forms '[b,a,b]' and '[b,b,a]'. The design of the pattern-matching facility is originally proposed in this paper and implemented in the Egison programming language.

Parser combinator library designed to be fast. It doesn't support backtracking.

This package contains everything that you need to use a cryptographic package that supports the crypto-api package using conduits from the conduit package.

A method to writing Wai responses This library attempts to make it easier to write nice Wai response handlers by giving us a Sinatra/ Scotty-like syntax for declaring HTTP-verb oriented routes, in addition to file-extension handling and rose-tree like composition. Not only do we have literal route specification, like Scotty & Spock, but we can also embed Attoparsec parsers and Regular Expressions directly in our routes, with our handlers reflecting their results. You can find more information on the demo. As an example: The route specification syntax is a little strange right now - l specifies a literal chunk of a handlable url (ie - l "foo" </> l "bar" </> o would represent the url /foo/bar), while p represents a parsable url chunk, which expects a pair - the left element being merely a reference name for the parser during internal plumbing, and the right being the actual Parser. o represents the end of a url string, and can be used alone in a handler to capture requests to the root path. Each route being handled needs some kind of content. For every parsed url chunk, the route expects a function of arity matching 1-for-1 with the parsed contents. For example, d -> ... in the demonstration above is such a function, where d :: Double. Internally, we match against both the file extension and Accept headers in the HTTP request - the Accept header may override the file extension. When we test our application: requests may end with index and specify the file extension each responding with the closest available file type

This package provides first class labels that can act as bidirectional record fields. The labels can be derived automatically using Template Haskell which means you don't have to write any boilerplate yourself. The labels are implemented as lenses and are fully composable. Lenses can be used to get, set and modify parts of a data type in a consistent way. See Data.Label for an introductory explanation or see the introductory blog post at http://fvisser.nl/post/2013/okt/1/fclabels-2.0.html Total and partial lenses Internally lenses do not used Haskell functions directly, but are implemented as categories. Categories allow the lenses to be run in custom computational contexts. This approach allows us to make partial lenses that point to fields of multi-constructor datatypes in an elegant way. See Data.Label.Partial for the use of partial labels. Monomorphic and polymorphic lenses We have both polymorphic and monomorphic lenses. Polymorphic lenses allow updates that change the type. The types of polymorphic lenses are slightly more verbose than their monomorphic counterparts, but their usage is similar. Because monomorphic lenses are built by restricting the types of polymorphic lenses they are essentially the same and can be freely composed with eachother. See Data.Label.Mono and Data.Label.Poly for the difference between polymorphic and monomorphic lenses. Using fclabels To simplify working with labels we supply both a set of labels for Haskell's base types, like lists, tuples, Maybe and Either, and we supply a set of combinators for working with labels for values in the Reader and State monad. See Data.Label.Base and Data.Label.Monadic for more information. Changelog from 2.0.4 to 2.0.5

Deprecated in favor of yaml Future development will focus on the Data.Yaml module of the yaml package, which leverages aeson's existing Value type. This package is officially deprecated. Provides high level conversions based on the data-object package. Parsing and emitting is handled by the yaml package, which in turn uses the libyaml C library.