A collection of bioinformatics tools

This library provides convenient combinators for working with and building parsing combinator libraries. Given a few simple instances, e.g. for the class Text.Parser.Combinators.Parsing in Text.Parser.Combinators.Parsing you get access to a large number of canned definitions. Instances exist for the parsers provided by parsec, attoparsec and base’s Text.Read.

This package defines new symbols for a number of functions and operators in the containers package. All symbols are documented with their actual definition and information regarding their Unicode code point. They should be completely interchangeable with their definitions.

A Haskell client for Grakn

For package maintainers and hackage trustees

This package provides 2D primitives for drawing/filling simple 2D shapes directly onto a JuicyPixels mutable image

Small GitHub utilities like pull-status and changelog generator

Perfect minimal hashing implementation in native Haskell

For package maintainers and hackage trustees

BiobaseHTTP provides functions to interface the Bioinformatics REST services - Entrez Ensembl NCBI Entrez provides multiple different databases and eutils. For more information on Entrez refer to: http://www.ncbi.nlm.nih.gov/gquery/. Information on the webservice can be found at: http://www.ncbi.nlm.nih.gov/books/NBK25497/. If you plan to include the library in a tool, register it as explained here. Information on ENSEMBL genomes API can be found here: http://rest.ensemblgenomes.org/. BiobaseHTTP is the successor of the deprecated EntrezHTTP library.

A representation of latitude and longitude [Index] For package maintainers and hackage trustees

An implementation of Turing Machine and Automaton for language theory

This package provides bindings to the ALSA simple mixer API.

Lenses for working with YAML documents.

This library provides an interface to generate haskell source code, verifying at compile time that the resulting code typechecks. See https://github.com/bennofs/haskell-generate for an introduction explaining how to use the library.

This package provides the unordered xml parser for aws-sdk package.

Libxslt is the XSLT C library developed for the GNOME project. XSLT itself is a an XML language to define transformation for XML. Libxslt is based on libxml2 the XML C library developed for the GNOME project. It also implements most of the EXSLT set of processor-portable extensions functions and some of Saxon's evaluate and expressions extensions.

A simple document store library for Git + JSON, based on Aeson. Uses command line git. Transactions use flock, so it's safe even across completely separate programs!

virthualenv is a tool (inspired by Python's virtualenv) to create isolated Haskell environments. virthualenv is deprecated, please use the hsenv tool. It creates a sandboxed environment in a .virthualenv/ directory, which, when activated, allows you to use regular Haskell tools (ghc, ghci, ghc-pkg, cabal) to manage your Haskell code and environment. It's possible to create an environment, that uses different GHC version than your currently installed. virthualenv is supposed to be easier to learn (and use) than similar packages (like cabal-dev or capri). Basic usage. First, choose a directory where you want to keep your sandboxed Haskell environment, usually a good choice is a directory containing your cabalized project (if you want to work on a few projects (perhaps an app and its dependent library), just choose any of them, it doesn't really matter). Enter that directory: Next, create your new isolated Haskell environment (this is a one time only (per environment) step): Now, every time you want to use this enviroment, you have to activate it: That's it! Now it's possible to use all regular Haskell tools like usual, but it won't affect your globalsystem's Haskell environment, and also your per-user environment (from ~.cabal and ~/.ghc) will stay the same. All cabal-installed packages will be private to this environment, and also the external environments (global and user) will not affect it (this environment will only inherit very basic packages - mostly ghc and Cabal and their deps). When you're done working with this environment, enter command deactivate, or just close the current shell (with exit). Advanced usage. The only advanced usage is using different GHC version. This can be useful to test your code against different GHC version (even against nightly builds). First, download binary distribution of GHC for your platform (e.g. ghc-7.0.4-i386-unknown-linux.tar.bz2), then create a new environment using that GHC Then, proceed (with [de]activation) as in basic case. Misc. virthualenv has been tested on i386 Linux systems, but it should work on any Posix platform. External (from tarball) GHC feature requires binary GHC distribution compiled for your platform, that can be extracted with tar and installed with "./configure --prefix=PATH; make install". For more info please consult "virthualenv --help" or the attached README file.

A general sequence representation with arbitrary annotations, for use as a base for implementations of various collection types, with examples, as described in section 4 of Ralf Hinze and Ross Paterson, "Finger trees: a simple general-purpose data structure", Journal of Functional Programming 16:2 (2006) pp 197-217. http://staff.city.ac.uk/~ross/papers/FingerTree.html For a tuned sequence type, see Data.Sequence in the containers package, which is a specialization of this structure.

web-interface for iptables with PAM authorization

[Index] [Quick Jump] For package maintainers and hackage trustees Git command-line bindings for Haskell CLI applications.

An efficient implementation of the Aho-Corasick string searching algorithm.

This plugin evaluates constant math expressions at compile-time. For details and full usage information, see; https://github.com/kfish/const-math-ghc-plugin To use it to compile foo.hs: To use it to build a cabal package packagename: Math should run faster.

Haskell implementation of Cuckoo filters as described in B. Fan, D.G. Anderson, M. Kaminsky, M.D. Mitzenmacher. Cuckoo Filter: Practically Better Than Bloom. In Proc. CoNEXT, 2014. Cuckoo filters are a data structure for probabilistic set membership. They support insertion, deletion, and membership queries for set elements. Membership queries may return false positive results. But queries don't return false negative results. Unlike Bloom filters, Cuckoo filters maintain an upper bound on the false positive rate that is independent of the load of the filter. However, insertion of new elements in the filter can fail. For typical configurations this probability is very small for load factors smaller than 90 percent.

This package contains general-purpose implementations of various immutable container types including vectors, heaps and priority heaps.

An implementation of Martin Escardo's exhaustively searchable sets.

maquinitas is a library for MIDI control of hardware

HarmTrace: Harmony Analysis and Retrieval of Music with Type-level Representations of Abstract Chords Entities We present HarmTrace, a system for automatically analysing the harmony of music sequences. HarmTrace is described in the paper: Jose Pedro Magalhaes and W. Bas de Haas. Experience Report: Functional Modelling of Musical Harmony. International Conference on Functional Programming, 2011. http://dreixel.net/research/pdf/fmmh.pdf

Morfette is a tool for supervised learning of inflectional morphology. Given a corpus of sentences annotated with lemmas and morphological labels, and optionally a lexicon, morfette learns how to morphologically analyse new sentences.

Deprecated Provides iteratees backed by mutable buffers. This enables iteratees to run without any extra memory allocations.

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

Common Haskell Libraries

Javascript syntax, functional syntax, hygienic names, compile-time guarantees of syntactic correctness, limited typechecking. Additional documentation available at http://www.haskell.org/haskellwiki/Jmacro

LibClang package provides direct bindings to libclang. This should be enough for parsing C/C++ code, walking the AST and querying nodes and completion queries. NOTE: When configuring, please ensure llvm-config is in path or provide the location of libclang and llvm includes if not in the default locations using You can also use if you'd like to link to the shared library Also use https://github.com/chetant/LibClang/issues to report bugs

Deprecated in favor of aeson Provides the ability to render JSON in a streaming manner using the enumerator package.

Poll functionality allows to wait on different FileDescriptors simultaneously.

Enumeratees for compressing and decompressing streams

This program is to verify (or to put into question) strictness conditions on free theorems that arise if a polymorphic lambda calculus is enriched by general recursion. Given a type the program either returns an instance of the corresponding unrestricted free theorem that does not hold and thereby verifies the need of the additional restrictions or it returns without finding such an instantiation and thereby suggests (but not proves) that the strictness conditions are superfluous. The underlying algorithm is described in "Automatically Generating Counterexamples to Naive Free Theorems" (FLOPS'10) by Daniel Seidel and Janis Voigtländer. A webinterface for the program is also available at http://www-ps.iai.uni-bonn.de/cgi-bin/exfind.cgi. Related to this package you may be interested in the online free theorem generator at http://www-ps.iai.uni-bonn.de/ft that is also available offline via http://hackage.haskell.org/cgi-bin/hackage-scripts/package/free-theorems-webui. Also interesting may be the tool polyseq that generates "optimal" free theorems in a polymorphic lambda calculus with selective strictness. Polyseq can be downloaded at http://hackage.haskell.org/cgi-bin/hackage-scripts/package/polyseq but the functionality is as well provided via a webinterface at http://www-ps.iai.uni-bonn.de/cgi-bin/polyseq.cgi.

This library provides a very thin wrapper around POSIX APIs. It can be compiled on any operating system that implements the standard as specified in IEEE Std 1003.1 faithfully. It has similar goals as the unix package, but its design differs in several areas: ByteArray and Addr are used pervasively. There is no use of String in this library. Functions do not throw errors. This library uses `IO (Either Errno a)` in places where unix would use `IO a`. The numeric types from Foreign.C.Types and System.Posix.Types are used in the type signatures of functions so that a haskell function's type signature matches its underlying POSIX equivalent exactly. Flags are newtypes over CInt (or whatever integral type matches the posix specification) rather than enumerations. The data constructors are exported, making the types extensible for operating system that have additional flags. About a dozen other packages offers wrappers for some subset of the POSIX specification are strewn across hackage. They include regex-posix, posix-paths, posix-timer, posix-socket, posix-filelock, posix-acl, etc. This library differs from all off these in various ways. Here are some of the design guidelines followed here that distinguish this package from some or all of these others: Scope. Although this library does not include all APIs specified by POSIX, it welcomes as many of them as anyone is willing to implement. Monomorphization. Effectful functions in this library return their results in IO rather than using a type that involves MonadIO or MonadBaseControl. Typeclass avoidance. This library does not introduce new typeclasses. Overloading is eschewed in favor of providing multiple functions with distinct names. Minimality. Functions wrapping the POSIX APIs do little more than wrap the underlying functions. The major deviation here is that, when applicable, the wrappers allocate buffers are the underlying functions fill. This eschews C's characteristic buffer-passing in favor of the Haskell convention of allocating internally and returning. A more minor deviation is that for safe FFI calls, this library will perform additional work to ensure that only pinned byte arrays are handed over. Unlike network, this sockets API in this library does not integrate sockets with GHC's event manager. This is geared toward an audience that understands how to use threadWaitRead and threadWaitWrite with unsafe FFI calls to avoid blocking the runtime.

Functions to find the names associated with various identifiers from the USB specification. This is useful if you want to display full human-readable names instead of cryptic numeric codes.

Haskell Library implementing standard functions for the Algebra of Physical Space Cl(3,0)

-semirings of types in base

Hash-based Diffing for AST's

Convert an integer to digits and back. This library is both asymptotically (O(n^1.4) vs. O(n^2)) and practically (2x-40x for typical inputs) faster than Data.Digits.

CSV files are the de-facto standard in many situations involving data transfer, particularly when dealing with enterprise application or disparate database systems. While there are a number of CSV libraries in Haskell, at the time of this project's start in 2010, there wasn't one that provided all of the following: Full flexibility in quote characters, separators, input/output Constant space operation Robust parsing, correctness and error resiliency Convenient interface that supports a variety of use cases Fast operation This library is an attempt to close these gaps. Please note that this library started its life based on the enumerator package and has recently been ported to work with conduits instead. In the process, it has been greatly simplified thanks to the modular nature of the conduits library. Following the port to conduits, the library has also gained the ability to parameterize on the stream type and work both with ByteString and Text. For more documentation and examples, check out the README at: http://github.com/ozataman/csv-conduit

Simple config file parser generator

Welcome to the simplest textual synthesizer. Csound-expression is a Haskell framework for computer music. With the help of the library we can create our instruments on the fly. A few lines in the interpreter is enough to get the cool sound going out of your speakers. It can be used for simple daily sound-file processing or for a full-blown live performances. Got interested? Check out the guide: https://github.com/anton-k/csound-expression/blob/master/tutorial/Index.md Acknowledgements (I'd like to mention those who supported me a lot with their music and ideas): music: entertainment for the braindead, three pandas and the moon, odno no, annsannat & alizbar, toe, iamthemorning, atoms for piece / radiohead, loscil, boards of canada, Hozan Yamamoto, Tony Scott and Shinichi Yuize. ideas: Conal Elliott, Oleg Kiselyov, Paul Hudak, Gabriel Gonzalez, Rich Hickey and Csound's community.

The library provides combinators for lazy, incremental XML parsing. Parsing results are generated lazily and the input is read on demand. It is built on top of the tagsoup library, which is responsible for preliminary tokenization of an XML input, and the polyparse library, which provides primitives for lazy and incremental parsing. To use the library import the Text.XML.PolySoup module.

EIBd Client wrapper for Haskell.

This module contains a writer-like Applicative for giving monoidal annotations to underlying computations. The annotations are available before running the computations. It also allows tagging different parts of a computation as separate steps, so that progress notifications can be emitted during execution. Optional steps are allowed.

This library implements recursion schemes on directed acyclic graphs. The recursion schemes are explained in detail in the paper Generalising Tree Traversals to DAGs (http://dx.doi.org/10.1145/2678015.2682539).

Toolkit for building http client libraries over Network.Http.Conduit. Note: Examples of use can be found in the pin and postmark client libraries.

Journald back-end for logging-facade

This library includes modules covering some basic data types defined by the Debian policy manual - version numbers, control file syntax, etc.

Hevolisa is an application that tries to approximate a bitmap image with colored polygons. It draws a set of random polygons which are changed/mutated in small random steps. There is an error function which compares the bitmap created from the polygons with the original image. If the error between the images is smaller than before then the new image replaces the old. This is done over and over again.

EntrezHTTP provides functions to query the NCBI entrez REST interface. There are multiple different databases and tools, so called eutils, provided by the service. For more information on Entrez refer to: http://www.ncbi.nlm.nih.gov/gquery/. Information on the webservice can be found at: http://www.ncbi.nlm.nih.gov/books/NBK25497/. If you plan to include the library in a tool, register it as explained here.

The Churro library takes an opinionated approach to streaming by focusing on IO processes and allowing different transport options.

The library provides some basic but useful lazy IO functions. Keep in mind that lazy IO is generally discouraged. Perhaps a coroutine library (e.g. pipes) will better suit your needs.

The library that can be used for optimization or another representation of multiple (Ord a) => a -> b transformations

Tools for interacting with Anki database

[Index] For package maintainers and hackage trustees Simple interface to the NIST Randomness Beacon.

Simplified GHC API

SnowWhite.pack "hello" > SnowWhite.unpack " " > hello

A low-boilerplate effect system with easy higher-order effects and very high expressive power

This library allows you to generate RSS 2.0 feeds.

Client-and Server-side Haskell framework that compiles to javascript with the GHCJS compiler and run over Transient. See homepage

Parochial helps manage local documentation by creating an index of a project's html, it also builds a hoogle index. In both instances the project's transitive dependencies are included.

VFR waypoints, as published in the AIP (ERSA) For package maintainers and hackage trustees

Data structures, parsers, and encoders for RDF data sets based on the RDF 1.1 abstract syntax and RFC 3987. The interface is intended to support incremental graph processing in constant space.

This package offers easy conversion from and to BSON data type for most of user defined data types. The interface may change at will.

This package implements urns, which are a simple tree-based data structure that supports sampling from and updating discrete probability distributions in logarithmic time. The details are presented in the paper “Ode on a Random Urn (Functional Pearl)”, by Leonidas Lampropoulos, Antal Spector-Zabusky, and Kenneth Foner, published in Haskell Symposium ’17.

Ebnf2ps generates nice looking syntax diagrams in EPS and FIG format from EBNF specifications and from yacc, bison, and Happy input grammars. The diagrams can be immediatedly included in TeX/LaTeX documents and in texts created with other popular document preparation systems.

Wigner-ville and Pseudo wigner-ville transform algorithm, inspired by "Time-frequency toolbox" and adapted to use with the Accelerate library. If you want to use accelerated backends, like Native or PTX, build accelerate-fft package with corresponding flags.

dft of contiguous memory data structures

This is a wrapper around http://hackage.haskell.org/package/Crypto that currently does fingerprint generation, signature generation, and signature verification (for RSA keys only). It is indended to be used with http://hackage.haskell.org/package/openpgp It is intended that you use qualified imports with this library.

AdBlock Plus browser plugin has great block list files provided by big community, but it is client software and cannot work on a server as proxy. Privoxy proxy has good potential to block ads at server side, but it experiences acute shortage of updated block lists. This software converts adblock lists to privoxy config files format. Almost all adblock features are supported including block/unblock requests (on privoxy) all syntax features are supported except for regex templates matching host name hide/unhide page elements (via CSS) all syntax features are supported all block request options except for outdated ones: Supported: script, image, stylesheet, object, xmlhttprequest, object-subrequest, subdocument, document, elemhide, other, popup, third-party, domain=..., match-case, donottrack Unsupported: collapse, background, xbl, ping and dtd

Retrieve, store and manage real quantum random data, originating from vacuum fluctuations of the electromagnetic field and served by Australian National University. The package is designed to ensure quantum random data is promptly available for your application by keeping a sufficient amount locally. When depleted to a specified level, more data is downloaded concurrently over SSL. It can be configured by specifying the minimum store size (below which more data are retrieved) the target store size (the size of the store after retrieval) and the default display style. For more information on the API service on which this package is based, visit the ANU QRN webpage at http://qrng.anu.edu.au/.

Hack2 Snap server handler

Extra javascript functions when using GHCJS. Please look at README.md

Haskell98 invariant functors (also known as exponential functors). For more information, see Edward Kmett's article "Rotten Bananas": http://comonad.com/reader/2008/rotten-bananas/

A simple monad for shelling out from Haskell programs.

A simple uploader for the Imgur api.

This package provides JSON data encoding and decoding for Haskell. It also provides option for beautifying the JSON encoding output with indentation and line breaks. The JSValue data type is the center of the package, and it is a type constructor; it may have different Integral types, Fractional Types or IsString types.

Deprecated. Use bindings-posix >= 1.2.3 Bindings.Posix.Sys.Mman instead.

Please see the README at https://github.com/NoRedInk/haskell-libraries/tree/trunk/nri-prelude.

Type-level function utilities.

Solve 3×3×3 Rubik's cubes in the fewest possible moves. Or, if you can't wait, get close enough with the two-phase solver.

Simple interface to TLS secured WebSockets.

This package provides a DSL for creating deployment configurations, as well as an interpreter that reads deployment configurations in order to provision application stacks to AWS CloudFormation using Amazonka.

The threadDelay and timeout functions from the base library use the bounded Int type for specifying the delay or timeout period. This packages provides alternatives which use the unbounded Integer type.

Blobs is a diagram editor for directed graphs. It is written in Haskell, using the platform-independent GUI toolkit wxHaskell. It is a community project at a fairly early stage of development - you are encouraged to get involved and improve it! Blobs is a front-end for drawing and editing graph diagrams. You must add your own back-end engine if you want it to do some analysis or processing of the graph.

Parsing & Quasiquoting for RFC 6570 URI Templates

Very fast and memory-compact query-only set and map structures.

A fast pseudorandom number generator, as presented by M.E. O'Neill on http:www.pcg-random.org, See that site for information on the particulars of the technique used. This particular implementation uses two Word64 of internal data and produces a Word32 of output per step. On 64-bit machines it's two to three times as fast as StdGen and uses the same amount of space.

APNs HTTP/2 integration library for Haskell

The dimensional-codata package provides a selection of the CODATA recommended values for fundamental physical constants for use with the dimensional library for physical quantities and units. Major version numbers represent the date of issue of the recommended values.