Bindings to APR: http://apr.apache.org/

[Index] For package maintainers and hackage trustees

A Haskell module offering easy access to the google geocoding web service

Snaplet for dynamically compiling GHCJS

FRP style where sequential composition (switching) is more primitive than in other approaches.

Encoding and Decoding Expressions and Formulæ à la carte from Z3

The ancient greek philosopher Parmenides provided a proof that change is impossible. It therefore stands to reason that there is only one moment in time, and it never changes. This library provides an interface to that moment, allowing it to be used in computations.

This library encourages you to do memoization in three separate steps: Create a memoizable function Create or select an appropriate memoizer Run the memoizer on the memoizable function Let's start with the first. When you create a memoizable function, you should use the self convention, which is that the first input to the function is self, and all recursive calls are replaced with self. One common convention that goes well with the self convention is using a helper function go, like so: Now for the second. For this example, we need a Memoizer that can handle an Integer input, and an Integer output. Data.MemoCombinators provides integral, which handles any Integral input, and any output. Data.MemoUgly provides memo, which can memoize any function a -> b, given an Ord instance for a. Third, let's run our memoizers! Since we have decoupled the definition of the memoized function from its actual memoization, we can create multiple memoized versions of the same function if we so desire. You could easily do the same with Data.MemoTrie.memo, Data.Function.Memoize.memoize, etc. Using this technique, you can create local memoized functions whose memo tables are garbage collected as soon as they are no longer needed.

An attempt to break up the monolithic IO monad into small, composable classes that can be used to restrict a function to only having access to, say, functions to work with the standard pipes, or a function that can access the environment. The motivation for this library is to allow people to make a stricter contract than simply this function does IO, and express through the type system exactly what IO is being performed.

A small cross-platform library for reading and modifying the system clipboard. Hclip works on Windows, Mac OS X and Linux (but see the requirements below!). Requirements: Windows: No additional requirements. Mac OS X: Requires the pbcopy and pbpaste commands, which ship with Mac OS X. Linux: Requires xclip or xsel installed.

This is an implementation of RSA encryption with PKCS1 padding, developed as part of the Barracuda ad-hoc P2P chat client. The Darcs repository can be found at http://repos.mroot.net/sep07-adhoc

generate thumbnail image

This package provides Erlang-like mailboxes for message passing. It also supports wrapping communication via e.g. sockets.

[Index] For package maintainers and hackage trustees Haskell interface to Naver Translate. Note that Naver Translate doesn't provide any official API. Written by Hong Minhee and distributed under GPLv3 or higher. See also LICENSE file.

This library provides an easy way to download data from Quandl.com.

Haskell Sendgrid v3 API Library

ghclive is an interactive multi-user Haskell interpreter in a browser. It mixes a pastebin with an interpreter and is designed for remote teaching.

This library helps producing web content out of command line scripts, and pointing the user to it

Types, classes, and functions for using the Collection+JSON—Hypermedia Type in Haskell.

Meta tic-tac-toe ncurses game.

This package provides Generic instance for Int8 and WOrd primitive types.

(Haskell) Write functions in tacit (pointless) style using Applicative and De Bruijn index notation.

CLI tools for dsmc library. README and examples are included in package distribution.

Deprecated in favor of gitlib This package provides data types for Git objects, enumerator-based parser of Git object files and manipulation functions.

The unification problem is given the problem statement t =? t', find a most general substitution s such that s(t) = s(t') modulo the axioms of a commutative monoid. Substitition s is more general than s' if there is a substitition s" such that s' = s" o s.

This permits parsec parsers to be written using the combinators from the parsers package.

Haskell binding to sqlite3 http://sqlite.org/.

A version of the async package's Control.Concurrent.Async.Concurrently for which the actions may fail with a value.

(Up to date documentation is maintained at https://mstksg.github.com/auto) Read the README first! https://github.com/mstksg/auto/blob/master/README.md , for motivating examples, and concrete explanations of things described here. auto is a Haskell DSL and platform providing declarative, compositional, denotative semantics for discrete-step, locally stateful, interactive programs, games, and automations, with implicitly derived serialization. It is suited for any domain where either the input or the output can be described as a stream of values: a stream of input events, output views, etc. auto works by providing a type that encapsulates value stream transformers, or locally stateful functions; by specifying your program as a (potentially cyclic) graph of relationships between value streams, you create a way of declaring a system based simply on static relationships between quantities. Instead of a state monad type solution, where all functions have access to a rigid global state, auto works by specifying relationships which each exist independently and on their own, without any global state. A more fuller exposition is in the README.md, in this project directory and also online at https://github.com/mstksg/auto/blob/master/README.md; you can get started by reading the tutorial, which is also in this project directory in the tutorial directory, and also incidentally online at https://github.com/mstksg/auto/blob/master/tutorial/tutorial.md. Also, check out the auto-examples repository on github for plenty of real-world and toy examples to learn from; I've also done a blog series on this library, with examples and full tutorials! Support available on freenode's #haskell-auto, #haskell-game, and also on the github issue tracker for the source repository. Import Control.Auto to begin!

This package contains the basic functions supported by Mailchimp JSON API. For HTTP Authentication, it uses Basic HTTP Authentication.

Koofr is a storage as a service provider located in Europe. See https:koofr.eu for more info. This is an API wrapper that simplifies working with files. Filesystem roots are called mounts and cannot be manipulated through api. The API is contained in a type class in order to allow mocking. Mock runner and wider API coverage coming soon.

A library to model relationships between two objects that are subclasses of Ord. Instead using a Map structure we use a two Maps that allows fast searching either by the key element or the value element. Each of Map is between an element and a set of values. Thus careful coordination of operations is required. This library lacks of extensive testing, formal testing or automated testing. Also in comparison to Data.Set or Data.Map (which provide the underlying infrastructure used) there are some missing methods. An example of use is the include source file T02_Relacion.hs.

GentleMark is a gentle markup language which is designed to fit forum-like systems. Styles: Accents: Unordered lists: Ordered lists: Custom tags:

A port of Clojure's efficient persistent and hash map data structure to Haskell

This library provides a way of structured tracing, which are useful for logging call graphs.

This package contains bindings to GTS (http://gts.sourceforge.net) library using bindings-DSL macros and style. Like GObject, it's not useful by itself, but as a foundation for other libraries making use of its type system. NOTE: these bindings were not made by the author(s) of GTS so please don't bug them about issues with the bindings! Any errors in these bindings are my responsibility not that of the GTS team. Changelog:

Haskell interface for antigate.com captcha recognition service and other services supporting its API (e.g. captchabot, decaptcher)

This library uniquely supports different types of AWS Lambda Handlers for your needs/comfort with advanced Haskell. Instead of exposing a single function that constructs a Lambda, this library exposes many.

This package provides a getHiddenChar function which works reasonably consistently across the Windows, Linux and macOS platforms. getHiddenChar yields a single character from the standard input device with buffering and echoing to standard output disabled.

git-fmt provides a wrapper around omnifmt, an automatic code formatter. It adds the ability to operate on specific tracked files in the repository.

CASR 61.345 Pilot Personal Logbook reports [Index] Choose the new, split-up base package. Use -f <flag> to enable a flag, or -f -<flag> to disable that flag. More info For package maintainers and hackage trustees

A cluss enables you to achieve function overloading, or ad-hoc polymorphism, without creating a new type class. In order to give ad-hoc polymorphism to a type variable a, you simply use In with a list of "type patterns" like In [Type T, ...] a, which indicates that the type matches some of the patterns; which is analogous to a type class indicating that a type matches some of its "instances". The constraint In [Type T, ...] a is what we call a "cluss". Clusses can easily be used in a nested way and even be recursive; therefore, they are expressive enough to imitate Haskell-98-style type classes. Clusses, however, go beyond a mere alternative to type classes. They have closed and prioritized instances and open methods, while type classes have open and unprioritized instances and closed methods. Those properties give clusses the advantages different from type classes: You can judge whether a type a belongs to a cluss In as, on some level, writing Has as a, since cluss instances are closed. You can make cluss instances more flexibly, without causing overlapping instances or incoherent instances, since cluss instances are prioritized. You can create new methods for clusses anywhere in any module, since cluss methods are open. More information can be found in the hackage's haddock or the updated haddock.

A continuation-based stream processor implemented as an Arrow. This version generalizes the SP type described in John Hughes "Generalising Monads to Arrows" to function as a wrapper for arbitrary monads.

This library generates pretty hex dumps of ByteStrings in the style of other common *nix hex dump tools.

Scion Browser aims to be a command-line interface for getting information about installed Haskell packages, that could be later used by development environments. It also provides integration with Hoogle. By now, it has been integrated in EclipseFP.

The module Data.CaseInsensitive provides the CI type constructor which can be parameterised by a string-like type like: String, ByteString, Text, etc.. Comparisons of values of the resulting type will be insensitive to cases.

Binding to NCurses, a library of functions that manage an application's display on character-cell terminals. Additionally, it contains some basic widgets such as a text input widget and a table widget.

A fast JASONETTE-iOS JSON combinator library for haskell.

A small, efficient and portable regex library for Perl 5 compatible regular expressions The PCRE library is a set of functions that implement regular expression pattern matching using the same syntax and semantics as Perl 5. If installation fails reporting that you are missing the prce C library, try installing the libpcre3-dev package (linux) or brew install pcre (MacOS).

This package provides an alternative to the Win32 library's error handling mechanism. The goal is to provide a nearly drop-in replacement for Win32's error-handling functions while offering the following benefits: Ability to distinguish between different Win32 error codes. Ability to catch Win32 exceptions separately from other exception types. Ability to query for the generating function's name and standard system error massage associated with the exception.

Export Persistent Entities to Elm types

Convert numbers to number words in a number of languages. Each language has its own module. The module name is based on the ISO 639-3 code for that language. Each module contains one or more cardinal and ordinal functions and a struct function. The cardinal functions directly convert cardinal numbers to a string-like representation of their spoken form. The ordinal functions do the same but for ordinal numbers. The struct functions convert numbers to a polymorphic representation of their grammatical structure. See the Text.Numeral module for information on how to use this library.

Haskell typeclass for truthfulness

This package contains a collection of essential data types and functions. Please note, that the deal function imposes a range of 2-9 players.

Concurrent, streaming access to the input and outputs of system processes.

FoldMap lists are lists represented by their foldMap function. FoldMap lists have O(1) cons, snoc and append, just like DLists, but other operations might have favorable performance characteristics as well. These wild claims are still completely unverified though.

Tools to change the formatting of field names in Aeson instances. This includes CamelCasing, Pascal Casing and Snake Casing.

Cross-platform File handling for Unix/Mac/Windows

Deprecated A cross-platform RPC library

A simple distributed parallel job execution engine in Haskell

Control.Effects.Parser is a parsing effect for the Control.Effects library. Control.Effects is a library for programming with effects, like in the the Eff language by Andrej Bauer and Matija Pretnar. Effects can be used instead of monad transformers. See the home page for some example code.

The pdfname command-line program names a PDF file using the author, year of creation and title information extracted from the pdfinfo program.

This package contains data types for defining Markov's normal algorithms and a function to run them.

Library for testing Haskell PRNGs for correctness using TestU01 suite

In addition to providing the Data.Array module as specified in the Haskell 2010 Language Report, this package also defines the classes IArray of immutable arrays and MArray of arrays mutable within appropriate monads, as well as some instances of these classes.

Please see the README on GitHub at https://github.com/lumihq/record-wrangler#readme

This package contains the necessary glue to allow the use of wires from the netwire-input package. In general, the types associated here should be used only sparingly to plumb the input state through your netwire program. Otherwise, the state should not be modified directly.

A Haskell FFI wrapper for the Augeas API

This Haskell package provides some tools for visualizing the decomposition of different divide and conquer algorithms.

Repeatable builds for cabalized Haskell projects 'cabal-constraints' provides repeatable builds for cabalized Haskell projects by "freezing" the exact versions of the dependencies selected by 'cabal-install'. All build environments for the project, such as the test or staging build environments, or other developers collaborating on the project, will then use the same dependency versions. It is designed to be used alongside 'cabal-install' sandboxes, in which case isolated, repeatable builds can be achieved. Using cabal-constraints 'cabal-constraints' should be run from the root directory of a cabalized Haskell project and given the path to the setup-config file to use. It will print out all dependencies of the project in a format suitable for use in a cabal-install config file. For example, running 'cabal-constraints' against itself produces the following: A single mandatory argument must be provided which is the path to the setup-config file to use. The file will be located under the dist directory. Usually there will be a single setup-config file which can be found by running find dist -name setup-config from the root directory of the project. If your project has more than one such file, it is likely because you have built it either with and without sandboxes or with multiple sandboxes. You probably want the most recently modified file which can be found with ls -tr $( find dist -name setup-config ) | tail -n1. To use these constraints for reproducible builds, one should make use of the new sandbox feature of cabal-install 1.18. The constraints can be redirected to cabal.config and committed to your code repository. When the project is built, the same set of dependency versions will be resolved by cabal-install ensuring repeatable builds. If cabal.config contains no other information the simplest solution is to overwrite it: If cabal.config contains information that needs to be preserved, the following will replace the constraints section and everything following it with the new constraints. If you ensure that the constraints section is the last section of the file, all other information in it will be kept.

HTML tables for yesod

The United States Environmental Protection Agency (EPA) Storm Water Management Model (SWMM) is a dynamic hydrology-hydraulic water quality simulation model for single event or long-term (continuous) simulation of runoff quantity and quality from primarily urban areas. SWMM 5, which is currently the newest version of SWMM, produces a binary .OUT file as its output. SWMMoutGetMB is a SWMM binary reader using the Get monad in Haskell to retrieve contents of this binary file and save it into a SWMMObject, which can then be used in Haskell programs.

LambdaBase is a lambda based language hosting an other language (defined by the person using it).

Quick and dirty statsd interface

Generic encoding of records. It currently provides a single, polymorphic function to encode sum types (i.e. categorical variables) as one-hot vectors.

The haskell-src package provides support for manipulating Haskell source code. The package provides a lexer, parser and pretty-printer, and a definition of a Haskell abstract syntax tree (AST). Common uses of this package are to parse or generate Haskell 98 code.

A numeric type for managing and automating engineering units.

[Index] For package maintainers and hackage trustees

This program can be used to see exactly how much time you spent working on file X, project Y or language Z. It can also be used to see for instance what your most productive time of the year, month or week is. In the long-run, this might help you make better time estimates, while also providing you with an overview of what you have worked on (which can also be nice for CV's). In short; this program allows you to query your logs and generate reports in plain text, html, xhtml and CSV. Support for more output formats is planned for the future. See the github page for more information.

As in polyhedra. Generates dice rolls in the REPL or in a standalone executable. Example REPL session: Example session in the executable:

Liquid Haskell integration for Cabal and stack

Deprecated in favor of mono-traversable Like Data.Foldable, but works with ByteStrings too

See readme.md for description.

[Index] For package maintainers and hackage trustees

HTTP media type functionality as a complement to Snap's method and methods functions. Branches based on the value of the Accept header of the current request, automatically setting the Content-Type header of the response.

This library provides bindings to the libg15 library. Note that the trunk version from SVN is required to build this

Easy and reasonably efficient probabilistic programming and random generation This library gives a common language to speak about probability distributions and random generation, by wrapping both, when necessary, in a RandT monad defined in Math.Probable.Random. This module also provides a lot of useful little combinators for easily describing how random values for your types should be generated. In Math.Probable.Distribution, you'll find functions for generating random values that follow any distribution supported by mwc-random. In Math.Probable.Distribution.Finite, you'll find an adaptation of Eric Kidd's work on probability monads (from here). You may want to check the examples bundled with this package, viewable online at https://github.com/alpmestan/probable/tree/master/examples. One of these examples is simple enough to be worth reproducing here. Please report any feature request or problem, either by email or through github's issues/feature requests.

Bow before the ultimate generality of the Royal Monad!

Pontarius Media Server will be a free and privacy-aware Extended Personal Media Network (XPMN) media server.

see the Enumerate.Function module for examples for documentation.

Useful for GHC devs or people who want to do something with GHC's AST but don't want to hook into the GHC API itself.

[Index] For package maintainers and hackage trustees A dead-simple templating utility for simple shell interpolation. Use at your own risk and only on trusted templates. Here's a simple use-case: Then we can render the template with tempered ./post.md to get: If you want you can add a shebang to the top of your template and just run it as an executable, tempered will strip the shebang for you automagically: test.txt Examples Here Mac and Linux binaries are provided HERE; If you're familiar with Haskell Stack: There's really not much to it; parses the file and runs anything inside {{ }} as a shell expression and pipes stdout into its spot. If you're clever you can do pretty much anything you want with this. Sure; It's bash. You can set up environment overrides in env.yaml, tempered looks up through the file-system to find an env.yaml from the cwd NOT the template location. Here's an example env.yaml; we can do simple strings or commands here; just make sure to quote any entries that start with {{ or the YAML parser gets mad. env.yaml Then you can use them just like normal variables. It's bash; go for it: output: Chances are you're forgetting to echo an env-var; {{ $TITLE }} will try to run the contents of $TITLE as a command, you want {{ echo "$TITLE" }}. Probably.

Edge cases and special values for QuickCheck Arbitrary instances

Parse Microsoft Excel spreadsheet files in .xls file format (extension .xls) more specifically known as 'BIFF/Excel 97-2004'. The library is based on the C library https://github.com/libxls/libxls.

[Index] For package maintainers and hackage trustees

A cfipu processor that can interpret and process cfipu source. cfipu is a toy brainfuck-like language.