CSV Pretty-printing

Cookie management helper functions for Scotty framework

This library provides a datatype which can be interpreted by apply-refact. It exists as a seperate library so that applications can specify refactorings without depending on GHC.

IO-Streams interface for lzma/xz compression

pugixml binding. example: docs/Text-XML-Pugi.html

This module provides interprocess communication channels. This is meant to be used by logger-like programs that want to send status reports to N listeners (where N >= 0).

Multimedia streaming on top of Conduit

The classic dice game Yahtzee implemented in Haskell.

SHA hashes for io-streams.

This library provides replacements for the ErrorMessage constructors to write the text of custom error messages easily.

Bindings to the oculus rift sdk head tracking. Requires installation of the OculusSdk, currently only supported for linux installs. You're going to need to either install the sdk under the default include and ld search path, or you can point cabal to your local oculusSdk install by using the "--extra-include-dirs" and "--extra-lib-dirs" flags. For example "cabal install --extra-include-dirs /path/to/OculusSDK/LibOVR/Include --extra-lib-dirs /path/to/OculusSDK/LibOVR/Lib/Linux/Release/x86_64" Below is a small program that initializes the rift and prints the orientation every second until ctrl-C

A library to communicate with MQTT brokers. See the Network.MQTT module for documentation and the project repository for some examples.

UISF is a library for making arrowized GUIs.

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

Usage: List all remote forwards for mail accounts stored in a SQL database. A list of local domains is supplied to the program (more or less) through the --domain-query option. Any addresses which forward to another address not contained in this list of local domains is considered a remote forward. Remote forwards can cause problems for a number of reasons, the most common of which are, If the sender has an SPF record authorizing his mail server to send mail on his behalf, then when his message is forwarded by the recipient's mail server, it will fail any subsequent SPF checks. This will likely cause the message to be rejected, and the original recipient's server will generate backscatter. If any spam makes it through the filter on the recipient's mail server, that spam will then be forwarded to a remote destination. The remote destination will blame the forwarding server for the spam, and that can impact its reputation and potentially lead to a blacklisting even though the spam did not originate on the recipient's server. Whether or not these are an issue depends on the circumstances, but in any case it is useful to know who is forwarding mail off-site. Input: None. Output: A list of addresses that are forwarded to remote domains. Options: The name of the database (or file, if SQLite) to which we should connect. Default: The name of the current user (Postgres only). --domain-query SQL query used to produce a list of local domains. This should return the set of all domains (i.e one column) that are local to the server. See the default value for an example. Default: "SELECT domain FROM domain WHERE domain ALL ORDER BY domain;" The name of a mail exchanger, the forwards of whose domains we should ignore. For example, if one mail exchanger, mx1.example.com, has strict spam filtering, it may be acceptable to have remote forwarding for domains that have mx1.example.com as their sole mail exchanger (MX record). In that case, you might want to exclude those domains from the report by naming mx1.example.com here. A forward will be excluded from the report only if all of its MX records are contained in the given exclude list. This option can be repeated to add mail exchangers to the exclude list. Default: [] (empty) SQL query used to produce a list of all forwards on the mail system. This query should return the set of all (address, goto) triples, where "goto" is the destination address; i.e. to where the "address" forwards. The "goto" field may contain more than one email address, separated by commas. Default: "SELECT address,goto FROM alias ORDER BY address;" Hostname where the database is located (Postgres-only). Default: None, a UNIX domain socket connection is attempted (Postgres only) Password used to connect to the database (Postgres-only). Default: None (assumes passwordless authentication) --port Port number used to connect to the database (Postgres-only). Default: None, a UNIX domain socket connection is attempted (Postgres only) Username used to connect to the database (Postgres-only). Default: The current user Examples: $ list-remote-forwards --database=testfixturespostfixadmin.sqlite3 user1example.com -> user1example.net user2example.com -> user1example.org user2example.com -> user2example.org user2example.com -> user3example.org user7example.com -> user8example.net

RLP serialization as defined in Ethereum Yellow Paper allowing the encoding of arbitrary data and the later decoding of such data. Intended for use with Ethereum transactions or data over the network.

This library contain collection of various utilities for numerical computing. So far there're special mathematical functions, compensated summation algorithm, summation of series, root finding for real functions, polynomial summation and Chebyshev polynomials.

hat-trans transforms Module.hs into Hat/Module.hs such that when the program is executed, a trace file Programname.hat is generated. Various tools (hat-trail, hat-observe, hat-explore ...) then allow viewing the trace file in different ways, to locate a bug or understand how a program works. Hat 2.8 uses the haskell-src-exts parser and other Hackage libraries to reduce its own size and simplify extensions. Module imports and exports have also been improved to handle nearly all kinds of renaming, hiding, etc. Hat 2.8 works only with ghc for Haskell 98 (plus a few extensions) and the standard Haskell 98 libraries plus some Haskell 2010 libraries. Although it should build on any operating system, most viewing tools use ASCII console escape sequences and they open xterms; hence they will only work well under Unix and X11. Tested on MacOS X 10.8.4. Installation: > cabal -v install Flag -v allows you to see what is going on. Building takes a long time (one module has 25.000 lines of code). Don't worry about numerous warning messages. Use: > hat-make MyProgram.hs transforms and compiles all modules of your program and produces the tracing version Hat/MyProgram. Run your program > Hat/MyProgram which will produce trace files MyProgram.hat* Use the viewing tools to explore the trace: > hat-trail / hat-observe / hat-explore /... MyProgram There is documentation in the "docs" folder, but it is partially outdated. There are a few small programs for exploring tracing in the "examples" folder.

Gene Cluster Evolution Determined Order Expansion of Gene Clusters and the Shortest Hamiltonian Path Problem*, Prohaska et al, 2017 Calculate the most likely order of genes in a gene cluster. Apart from being an interesting problem in computational biology, it also serves as an example problem for dynamic programming over unordered sets with interfaces. Binaries available from github: https://github.com/choener/Gene-CluEDO/releases

Import maps from the .tmx map format generated by Tiled, http://www.mapeditor.org.

Fast, pure and practical SHA1 implementation

Please see the README on GitHub at https://github.com/serokell/xrefcheck#readme

Text type represented as JavaScript strings for Fay and Data.Text for GHC. Use with OverloadedStrings and RebindableSyntax to have Fay treat string literals as Text.

keyring provides access to the system's keyring to securely store passwords. Currently this library supports the following keyring implementations: Keychain on OS X KWallet on KDE The System.Keyring module provides the high-level functions getPassword and setPassword to easily get and set passwords in the keyring of the current user. The appropriate backend is chosen automatically.

This package provides a simple, type-safe interface for working with the Bus Pirate's binary interface.

Includes a facets model of the Rubik's Cube and a diagrams-based renderer.

Bit parsing/writing on top of binary. Provides functions to read and write bits to and from 8/16/32/64 words.

Generic implementation of Storable

HBURG is a program that generates tree parsers for cost-augmented tree grammars. It is useful for writing code generators for compilers. Given a mapping of a tree structured intermediate representation onto target machine instructions, HBURG generates a code generator that can be plugged into the instruction selection phase of a compiler. For more information see "http://www.bytelabs.org/pub/papers/hburg07.pdf".

Bindings to the Linux mount() and umount() syscalls.

A rich monadic API for working with leveldb databases.

One module layer over regex-tdfa to replace Text.Regex. regex-compat can't use Unicode characters correctly because of using regex-posix. This is not good for Unicode users. I modified regex-compat to use regex-tdfa for solving today's problem.

Speedy gradient-based traversal through parameter space.

This library provides a function to generate a special f-algebra combinator from any data type (GADTs are not currently supported). This was inspired by the recursion-schemes library where they have a function to automagically generate a base functor. Although, this new base functor data type has custom constructors and to define the *-morphism algebras turns into boring pattern matching. So, this library provides a function called makeCombinator that produces a nice combinator to deal with data types as they were defined in terms of Pairs ( (,) ) and Sums (Either). With this nice combinator we are able to view a data type as its equivalent categorical isomorphism and manipulate it with an interface similar as the either function provided from base.

For more detailed documentation on the service, please refer to the excellent documentation for the forecast.io service.

For package maintainers and hackage trustees

[Index] For package maintainers and hackage trustees

This package provides a MySQL driver for HDBC, implemented via bindings to the C mysqlclient library.

Haskell Wavefront OBJ loader library

Please see README.md

Tries from representations of polynomial functors

Sequential array data type and stream fuctions, along with a sequential reference implementation of the segmented array API defined in dph-prim-interface.

This simple tool sorts input filelines by first collumn suffixed by unit. Recognized units: I needed this for output from 'du -h': Filtered through sorty:

Generate an Elm Subscriber and JSON encoders/decoders for a Wai WebSocket server

A useful Haskell library for running a pingable server within another application, which is useful for health checks and the like. This library runs a background server that listens on a port, and when a connection comes in, it writes "pong" and closes the connection.

Implementation of Cassandra's CQL Binary Protocol Version 3 and Version 4. It provides encoding and decoding functionality as well as representations of the various protocol related types. Thus it can serve as a building block for writing Cassandra drivers, such as cql-io.

This package provides deriveGet and derivePut which can be used to quickly create an instance of Serialize for any type which implements Generic. Naturally, this can be used with -XDeriveGeneric to not have to write any boilerplate code.

Deprecated

This library builds text xoj format file from hoodle data structure

PostgreSQL AST Assembler

throwable-exceptions gives the easy way to throw exceptions

FLTKHS demos moved to a separate package to keep the core package free of additional dependencies.

Graphics for kids and artists. Processing implemented in Haskell

Parser for DWARF debug format.

For end to end testing of web applications from Haskell, the webdriver package is a great tool but just contains the code to communicate with the browser. This package integrates webdriver with hspec.

Transformation of n-ary functions to unary functions

Utils for text

Crack HP, SP and DP floats and 8, 16, 32, 64 bit words and integers. For details, please see: http://github.com/LeventErkok/crackNum/

[Index] For package maintainers and hackage trustees

Deprecated "PCLT" is an abbreviation for "Parametric Composable Localizable Templates" - in fact it should also hold Detalizable. Term "Detailizable content (message)" in this package has a following meaning: some content, representing which it is possible to regulate, in how much details it is represented. Conceptually, this package is a powerful extension to the well known Show class, that (extension) is thought to be embeded in any Haskell program, which requires multilanguage support, and/or where messages should be detailizable. The PCLT catalog consists of: Catalog ID Config, which defines rules and constraints, that are used when catalog gets formed, and when it is used to generate messages. Tempates of messages, possibly related. Each catalog entry is referenced by an ID, and is called "localizable (in languages) template", while it's localization in concrete language is called "localized (in a languages) template". Each catalog entry (localizable template) consists of ID A requirement to detailization level (to used by reciever of representation), which if is not statisfied, the template isn't used. A map of localized templates by languages - the different translations of one same message. Each localized template is a sequence of chunks: plain texts, named parameters placeholders, placeholders for insertion of other template (reference on other template, also called composites). To make a message one needs to specify a catalog, a language, detailization level to orient on a localizable template ID, a map of parameters together with their values. The last two fields (localizable template ID + a map of parameters together with their values) is called instaniation (of templated message). In the program it wrapped in a PCSI data type. A parameter value may be plain text newline nothing a reference to other instaniation (localizable template ID + a map of parameters together with their values) a list of other other instaniation a parameter wrapping, where wrapper is an indentation of text (N whitespaces insertion after each newline character) a list of parameter values. This package comes together with another one - a dependent package PCLT-DB (section Database), which provides a (PostgreSQL 8.4) DB structure where to keep/manage data used for PCLT catalogs formation, simple interface to read this data in haskell program, and a prototype of a longterm service which regularly updates catalog MVar with data from DB. IMPORTANT!!! : It is highly recommended to use ISO 639(3) standard for language names, since PCLT-DB package is oriented on 3 letters (not bigger) language names. Without modifications PCLT-DB won't work for bigger (then 3-letters) names. ToDo considerations for the next versions: Consider using state monad in order to put catalog into an implicit context... and maybe also other uses if monads. Rewrite MakeCatalog, so that it uses CatalogMaths functions. Otherwise the both modules do similar work, and keeping double code is a bad style. Introduction of a new parameter value type: "reparsable" wrapping for parameter value. CatalogMaths extension. Enchance required SDLs with min & max functions. Sacrificing ldtSubcompositesMap of LocalizedTemplate, which initially was introduced to enchance speed of messages generation, in favor of making catalogs easier to modify (which curently isn't supported and isn't an easy task).

This library contains: periodic table with information about elements Readers and writers for different formula formats.

simple and efficient non-textual cve representation

Aggression analysis for Tweets on Twitter

Building Sum Type arbitrary instance is kind of a pain. This tool helps automate the process.

Please see README.md

Parses the output of GHC's man page and generates a bash completion file.

Solve classical planning problems (STRIPS/SAS+) using Haskell & Fast Downward

Partial implementation of JPEG, PNG, TGA, BMP, PSD decoders, with a really simple API.

IPv6DB is a RESTful microservice using Redis as backend to store lists of IPv6 addresses and attach to each of them any valuable data in a schema-free valid JSON value. Each resource can be permanent or TTLed.

This package provides a program needed by the win-hp-path project to make it easy to work with multiple versions of the Haskell Platform on Windows. See the home page on GitHub for more infomation.

Package implements an algorithm to minimize rational objective function over the set of exponent pairs

FFI wrappers for global and local string alignment functions

A demo supercompiler - not really ready for public use yet.

This package provides a simple API for using the Lightning Memory-mapped Database (LMDB).

A work stealing scheduler that is designed for parallelization of heavy work loads. It was primarily developed for massiv array library, but it is general enough to be useful for any computation that fits the model of few workers and many jobs.

Make your Haskell git repositories fashionable.

Deprecated A groupoid is structure consisting of a set of elements (here a Haskell type) and a binary operator (in present case the function gappend). It is comparable to the Monoid typeclass, but there is no obligation that the set supports a neutral element (mempty in Data.Monoid). In geometry, bounding boxes (represented as two points - bottom-left corner and top-right corner) give an example where a groupoid may be more satisfying than a monoid. The union operation on bounding boxes is essential to track the extent of shapes after their superimposition. To fit bounding box union into the Monoid typeclass one can do a clever trick representing mempty with the bottom-left corner at positive infinity and the top-right corner at negative infinity, the standard implementation of union which uses min and max will still proceed to identify the extreme corners correctly. This is nice enough if the bounding box coordinates are represented by Doubles, but a problem if they are Ints (say representing grid coordinates) - one might decide it is better simply to consider concrete bounding boxes and not their empty/infinite cousins.

A Cofunctor is a structure from category theory dual to Functor. A Functor is defined by the operation fmap: This means that its dual must be defined by the following operation: Since beginning his investigations, the author of this package has discovered that this pattern is at least as commonly used as Functor. In fact, many ubiquitous Haskell types (e.g. [], Maybe, ((->) a) turn out to have a Cofunctor instance.

Please see the README on GitHub at https://github.com/mitsuji/sakuraio-platform#readme

Read and write Repa arrays in various formats.

The crypto-enigma package is an Enigma machine simulator with rich display and machine state details. Currently support is only provided for the machine models in most widespread general use during the war years: the I, M3, and M4. For basic functionality, including some introspection of machine state and the mappings performed, simply For richer display functionality additionally (Note that this package assumes support for combining Unicode, without which some output may appear garbled.)

Utilities for manipulating type-level strings natively.

See README at https://github.com/GianlucaGuarini/rob/blob/develop/README.md

Decrypt Ruby on Rails sessions in Haskell

Haskell bindings to GEGL Library

Please see the README on GitHub at https://github.com/Atry/do-notation-dsl#readme

Conveniently configure GHC's dynamic flags for use with Cabal projects

Integrate ogmarkup document with Hakyll

This package contains wrapped name module for TimeLocale.

Haskell bindings to projectroot

✖️⭕Tic-Tac-Toe server

'Checkers' wraps up the expected properties associated with various standard type classes as QuickCheck properties. Also some morphism properties. It also provides arbitrary instances and generator combinators for common data types. © 2008-2013 by Conal Elliott; BSD3 license. Contributions from: Thomas Davie.

Based off of the paper "A Pattern for Almost Homomorphic Functions" at http://www.ittc.ku.edu/~nfrisby/frisby-wgp-2012.pdf, presented at the Workshop on Generic Programming 2012. Also, my dissertation http://www.ittc.ku.edu/~nfrisby/frisby-dissertation.pdf yoko views a nominal datatype as a band of constructors, each a nominal type in its own right. Such datatypes can be disbanded via the disband function into an anonymous sum of nominal constructors, and vice versa via the band function. This library uses extensive type-level programming to enrich its instant-generics foundation with capabilities derived from the constructor-centric perspective. For example, consider the following nominal datatype. This type can of course be understood as a sum of the individual fields types. yoko's conceptual foundations start there. In particular, this allows a constructor, say John, to be used independently of its original range type and sibling constructors. As a generic programming library, yoko extends instant-generics with support for constructor-centric generic programming. The Examples/LambdaLift/LambdaLift.hs file distributed with the yoko source demonstrates defining a lambda-lifting conversion between the two types ULC, which has lambdas, and Prog, which has top-level function declarations instead. These types are defined in separate modules, since they have constructors with the same name. Indeed, the fact that they having matching constructors named App is crucial for yoko's automatic conversion from ULC's App to TLF's App. As written, the generic lambda-lifter would continue to work for any new ULC constructors (e.g. syntax for tuples or mutable references) as long as constructors with the same names and analogous fields were added to TLF and the semantics of those constructors doesn't involve binding. This default generic behavior of the lambda-lifter is specified in about ten lines of user code. The non-generic code is much more complicated. This is intentional: I wanted to show that sometimes shoehorning an algorithm into the requisite type (ie a -> m a') can be difficult and require subtleties like backwards state. Existing generic libraries don't use constructor names to the degree that yoko does, and so cannot accomodate generic conversions as well.

persona-idp is a simple Mozilla Persona (formerly BrowserID) identity provider (IdP) intended to be run behind an HTTP server providing TLS termination and user authentication. For full documentation see https://github.com/frasertweedale/hs-persona-idp.

This package wraps up the process of fetching exchange rates from OpenExchangeRates.org. You will need an AppID.