This package defines instances of the Foldable, Unfoldable, Collection, Sequence and Indexed classes from Data.Collections for all pure Vector types (those found in Data.Vector, Data.Vector.Unboxed, Data.Vector.Primitive, Data.Vector.Storable).

Conduit interface for cassava package PRs welcome.

membrain provides newtype wrapper for type-safe work with memory units This data type stores memory unit value phantom type parameter which is represented as type-level natural number. The ideas behind this package are described in the following blog post: Insane in the Membrain

This package provides a standalone implementation of dispatching a function by matching it against a Servant API. A common usecase for this is to convert an URI to an ADT that provides a more structured representation of the URL.

Ponder is PEG parser combinator. This Library is experimental.

Specify axioms for type classes and quickCheck all available instances

A Haskell library for generating fake data.

Various data structures for type aligned sequences: heterogeneous sequences where the types enforce the element order.

High-level IO operations on files/directories, utilizing type-safe Paths

GenericPretty is a Haskell library that supports automatic derivation of pretty printing functions on user defined data types. The form of geenrics used is based on that introduced in the paper: Magalhaes, Dijkstra, Jeuring, and Loh, A Generic Deriving Mechanism for Haskell, 3'rd ACM Symposium on Haskell, pp. 37-48, September 2010, http://dx.doi.org/10.1145/1863523.1863529. Changes from the original paper in the GHC implementation are described here: http://www.haskell.org/haskellwiki/GHC.Generics#Changes_from_the_paper. This package requires the use of the new GHC.Generics features http://www.haskell.org/haskellwiki/GHC.Generics, present from GHC 7.2. Use of these features is indicated by the DeriveGeneric pragma. or the flag -XDeriveGeneric. Pretty printing produces values of type Text.PrettyPrint.Doc, using the Text.PrettyPrint library http://www.haskell.org/ghc/docs/latest/html/libraries/pretty-1.1.1.0/Text-PrettyPrint.html. The output provided is a pretty printed version of that provided by Prelude.show. That is, rendering the document provided by this pretty printer yields an output identical to that of Prelude.show, except for extra whitespace. For information about the functions exported by the package please see the API linked further down this page. For examples of usage, both basic and more complex see the README file and the haskell source code files in the TestSuite folder, both included in the package. Finally for installation instructions also see the README file or this page: http://www.haskell.org/haskellwiki/Cabal/How_to_install_a_Cabal_package

Ivory compiler, to a subset of C99.

Map from HTML5 entity names to the corresponding Unicode text.

RFC 4648-compliant padded and unpadded base64 and base64url encoding and decoding. This library provides performant encoding and decoding primitives, as well as support for textual values.

Haskell client and worker process for the Faktory background job server. Client - an API any process can use to push jobs to the Faktory server. Worker - a process that pulls jobs from Faktory and executes them. Server - the Faktory daemon which stores background jobs in queues to be processed by Workers. This package contains only the Client and Worker.

Deprecated Reactor - task parallel reactive programming

A small program for generating plays for Scrabble tables. Currently only the classic Scrabble board layout is supported and the user interface is pretty much nonexistent. You can change the board, the rack and the number of plays displayed by manually editing the Main source file and rebuilding. Hence, downloading the source distribution is advised.

Takes a command and keeps rerunning it until it returns successfully. Has flags to limit number of retries and sleep between retires.

PagerDuty is an alerting system for IT professionals. PagerDuty connects with a variety of systems (including monitoring tools and ticketing systems) and dispatches alerts via automated phone call, SMS and email. This library implements the full PagerDuty Integration and REST APIs which are documented here: Integration API - http://developer.pagerduty.com/documentation/integration REST API - http://developer.pagerduty.com/documentation/rest Warning: This is an experimental preview release which is still under heavy development and not intended for public consumption, caveat emptor! Note: An alternative source for Haddock documentation can be found here.

Parser for PE/COFF format.

Apply GitHub .gitignore templates to already existing repositories.

For package maintainers and hackage trustees Implementation of a theorem prover for propositional logic using G4ip in Haskell. You can use T, F, /\, \/, ==>, <==, <=>, neg, and () with their usual meanings to form propositions. To form an atom, either use Atom "name" or use one of the predefined atoms: a, b, c, d, e, or f. Here is an example: which prints True as expected ($ if for associativity, you can use parenthesis if you want). Email me at coskuacay@gmail.com for any questions.

Generate regex-constrained strings for QuickCheck

HMatrix Vector and Matrix conversions to and from REPA Array F DIM1/2 (Complex) Double, together with a port of linear algebraic functions.

native Haskell implementation of OpenPGP (RFC4880)

Rotates backdrops for X11 displays using Imagemagic.

A "not-very-Haskelly" API for calculating traversals of graphs that may be too large to fit into memory. The algorithms included are inspired by the visitor concept of the Boost Graph Library. Here is a very simple example of how we might execute a depth-first-search. In this case the visitor simply collects the edges and vertices in the order that the corresponding functions get called. After the necessary imports, create an adjacency list where the vertices are labeled with integers.

Calculate the percentage of difference between code.

This package is aimed to simplify writing bindings for DBus interfaces by using DBus introspection and dbus-th package.

CI Assistant for Haskell projects. Implements package caching.

Doublify API toolkit

Doubly-linked lists, doubly-linked trees, and naïvely-represented graphs, with each vertex literally pointing at its neighbours.

Boxed arrays cannot be allocated without initialization, because in that case the garbage collector would try to follow wild pointers. This is a source of inefficiency; quite a few operations must allocate a new array, initialize it, then overwrite the initial elements with the actually relevant data. This package provides low-level primitives for doing such operations without superfluous copying.

Generic cellular data representation library

Example code for how we swap compiled code within a running Haskell process.

Monad's bind (>>=, >=>) allows the infix chaining of monadic functions, but no analogues exist for functors. This package provides a handful of handy operators that ease the piping together a functor- and monad-level functions.

hledger-stockquotes is an addon for hledger that reads your journal file, pulls the historical stock prices for commodities, and writes out a new journal file containing the respective price directives. The AlphaVantage API is used to fetch the stock quotes and you will need a free API key to use this program. You can install hledger-stockquotes with Stack: stack install --resolver nightly hledger-stockquotes. Then run hledger-stockquotes --help to see the usage instructions & all available options.

Higher-order optimization library See Norman Ramsey, Joao Dias, and Simon Peyton Jones. "Hoopl: A Modular, Reusable Library for Dataflow Analysis and Transformation" (2010) for more details.

[Index] For package maintainers and hackage trustees

In Haskell you very often acquire values using the with... idiom using functions of type (a -> IO r) -> IO r. This idiom forms a Monad, which is a special case of the ContT monad (from transformers) or the Codensity monad (from kan-extensions). The main purpose behind this package is to provide a restricted form of these monads specialized to this unusually common case. The reason this package defines a specialized version of these types is to: be more beginner-friendly, simplify inferred types and error messages, and: provide some additional type class instances that would otherwise be orphan instances

This library provides a way to write minilight component in Lua language.

SPAKE2 key exchange protocol for Haskell

See http://www.phash.org/ for more info. Note that you must have libphash installed on your system to use this library. Check your system library.

HyperLogLog++ with MinHash for efficient cardinality and intersection estimation using constant space. See original AdRoll paper for details: http://tech.adroll.com/media/hllminhash.pdf

This Haskell library implements the Quil language for quantum computing, as specified in "A Practical Quantum Instruction Set Architecture" <https://arxiv.org/abs/1608.03355/>.

tasty-fail-fast wraps any ingredient to fail as soon as the first test fails. For example: Your test suite will now get a --fail-fast flag.

A framework for distributing Haskell tasks running on HDFS data using Cloud Haskell. The goal is speedup through distribution on clusters using regular hardware. This framework provides different, simple workarounds to transport new code to other cluster nodes.

Library to interact with Neo4j databases. This library covers: Cypher transactions CRUD operations for nodes, relationships, labels and indexes Batch calls for CRUD operations. All code has been tested with Neo4j versions 2.0.3 and 2.1.5. This is a fork of: http:hackage.haskell.orgpackagehaskell-neo4j-client. Attempting to bring it up to date. Only supports new Transactional Cypher REST api.

A library that supports generic programming for mutually recursive families in the sum-of-products style. A couple usage examples can be found under Generics.MRSOP.Examples

This library makes it easy to implement monads with tricky control flow. This is useful for: writing web applications in a sequential style, programming games with a uniform interface for human and AI players and easy replay capababilities, implementing fast parser monads, designing monadic DSLs, etc. See the project homepage http://haskell.org/haskellwiki/Operational for a more detailed introduction and features. Related packages: MonadPrompt http://hackage.haskell.org/package/MonadPrompt.

Used to be Haskell 98 Lenses

An efficient compact, immutable byte string type (both strict and lazy) suitable for binary or 8-bit character data. The ByteString type represents sequences of bytes or 8-bit characters. It is suitable for high performance use, both in terms of large data quantities, or high speed requirements. The ByteString functions follow the same style as Haskell's ordinary lists, so it is easy to convert code from using String to ByteString. Two ByteString variants are provided: Strict ByteStrings keep the string as a single large array. This makes them convenient for passing data between C and Haskell. Lazy ByteStrings use a lazy list of strict chunks which makes it suitable for I/O streaming tasks. The Char8 modules provide a character-based view of the same underlying ByteString types. This makes it convenient to handle mixed binary and 8-bit character content (which is common in many file formats and network protocols). The Builder module provides an efficient way to build up ByteStrings in an ad-hoc way by repeated concatenation. This is ideal for fast serialisation or pretty printing. There is also a ShortByteString type which has a lower memory overhead and can can be converted to or from a ByteString, but supports very few other operations. It is suitable for keeping many short strings in memory. ByteStrings are not designed for Unicode. For Unicode strings you should use the Text type from the text package. These modules are intended to be imported qualified, to avoid name clashes with Prelude functions, e.g.

Haskell lens prisms that use stack types

Efficiently scale, crop, flip images with JuicyPixels.

General-purpose sampling approaches like Gibbs sampling are very useful for models that have not been studied extensively. But for some cases, specialized algorithms are available because of the model's commonality (e.g., linear regression) or niche popularity (e.g., Latent Dirichlet Allocation). This package is an effort to collect such algorithms in one place.

This package implemets Red-Black tree data-structure.

Stepwise monad: stepwise computations, providing resolution of non-deterministic choice, breadth-first search strategies and online results.

A library & program that builds parsers from ISO EBNF using Parsec

An implementation of the Wagner–Fischer dynamic programming algorithm to find the optimal edit script and cost between two sequences. The implementation in this package is specialised to sequences represented with Data.Vector but is otherwise agnostic to: The type of values in the vectors; The type representing edit operations; and The type representing the cost of operations.

Pure and impure Bloom Filter implementations.

Provides functions that help writing better UNIX daemons, daemonize and serviced/serviced': daemonize does what a daemon should do (forking and closing descriptors), while serviced does that and more (syslog interface, PID file writing, start-stop-restart command line handling, dropping privileges).

Tools for working with functor combinators: types that take functors (or other indexed types) and returns a new functor that "enhances" or "mixes" them in some way. In the process, you can design featureful programs by composing smaller "primitives" using basic unversal combinators. The main entry point is Data.Functor.Combinators, but more fine-grained functionality and extra combinators (some of them re-implementations for compatibility) are available in other modules as well. This library does not define new functor combinators for the most part, but rather re-exports them from different parts of the Haskell ecosystem and provides a uniform interface. See the README for a quick overview, and also https://blog.jle.im/entry/functor-combinatorpedia.html for an in-depth dive into the motivation behind functor combinator-driven development, examples of the functor combinators in this library, and details about how to use these abstractions!

Haskell Makefile parser

Please see the README on GitHub at https://github.com/isovector/algebra-driven-design#readme

Swagger is a project used to describe and document RESTful APIs. The core of the project is the OpenAPI Specification (OAS). This library implements v2.0 of the spec. Unlike Servant it is language-agnostic and thus is quite popular among developers in different languages. It has also existed for a longer time and has more helpful tooling. This package provides means to generate a Swagger/OAS specification for a Servant API and also to partially test whether an API conforms with its specification. Generated Swagger specification then can be used for many things such as displaying interactive documentation using Swagger UI; generating clients and servers in many languages using Swagger Codegen; and many others.

Wrapper around FreeType 2 library. Relevant exerpts from the FreeType 2 website: What is FreeType 2? FreeType 2 is a software font engine that is designed to be small, efficient, highly customizable, and portable while capable of producing high-quality output (glyph images). It can be used in graphics libraries, display servers, font conversion tools, text image generation tools, and many other products as well. The following is a non-exhaustive list of features provided by FreeType 2. FreeType 2 provides a simple and easy-to-use API to access font content in a uniform way, independently of the file format. Additionally, some format-specific APIs can be used to access special data in the font file. Unlike most comparable libraries, FreeType 2 supports scalable font formats like TrueType or Type 1 natively and can return the outline data (and control instructions/hints) to client applications. By default, FreeType 2 supports the following font formats. TrueType fonts (and collections) Type 1 fonts CID-keyed Type 1 fonts CFF fonts OpenType fonts (both TrueType and CFF variants) SFNT-based bitmap fonts X11 PCF fonts Windows FNT fonts BDF fonts (including anti-aliased ones) PFR fonts Type 42 fonts (limited support) From a given glyph outline, FreeType 2 is capable of producing a high-quality monochrome bitmap, or anti-aliased pixmap, using 256 levels of gray. This is much better than the 5 levels used by Windows 9x/98/NT/2000 or FreeType 1. FreeType 2 supports all the character mappings defined by the TrueType and OpenType specification. It is also capable of automatically synthetizing a Unicode charmap from Type 1 fonts, which puts an end to the painful 'encoding translation' headache common with this format (of course, original encodings are also available in the case where you need them). The FreeType 2 core API provides simple functions to access advanced information like glyph names or kerning data. FreeType 2 provides information that is often not available from other similar font engines, like kerning distances, glyph names, vertical metrics, etc. FreeType 2 provides its own caching subsystem since release 2.0.1. It can be used to cache either face instances or glyph images efficiently.

Composable objects

A library for type-driven interaction with Redis

[Index] [Quick Jump] For package maintainers and hackage trustees

A type and some functions for manipulating and evaluating continued fractions.

The goal of this library is to take advantage of the power of applicatives to provide not only a parser combinator library, but grammar analysis and validation tools. Right now, those tools are minimal, but do include a BNF generator.

hdis86 is an interface to the udis86 disassembler, which decodes machine code for 16-, 32-, and 64-bit x86 and x86-64 / AMD64 processors. hdis86 provides an instruction stream as a Haskell algebraic data type, suitable for inspection by pattern matching. It also provides metadata such as assembly syntax in Intel or AT&T flavors. This library exposes three layers of wrapping: The Pure module has the simplest interface, effectively ByteString -> [Instruction]. The IO module exposes an imperative API closely matching the udis86 state machine, while providing Haskellish types and automatic resource management. The C module is a direct import of the udis86 library, with C types and conventions. Many users can simply import Hdis86. The Incremental module provides disassembly of lazy ByteStrings, and a function for building other incremental operations. By default, hdis86 will statically link a built-in copy of udis86-1.7, which is provided by its author under a similar BSD license. See inside the tarball for more information. If you have udis86 installed on your system, you can instead link dynamically using cabal configure --flags=external-udis86. In that case see also doc/customizing.txt. This code is available on GitHub at https://github.com/kmcallister/hdis86. The udis86 project website is located at http://udis86.sourceforge.net/. New in version 0.2: Disassembly of lazy ByteStrings A function for building other incremental operations Record selectors on Instruction QuickCheck Arbitrary instances for Instruction and related types

Find the repository from where a given repo was forked

Memis allows to efficiently rename and sort image files into directories, via an intelligent web-interface. See Readme on Github.

Perhaps, a monad.

Paginate a list showing a per-item widget and links to other pages

[Index] For package maintainers and hackage trustees

Please see the README on GitHub at https://github.com/evenex/ally-invest#readme

Complete implementation of the classic algorithm W for Hindley-Milner polymorphic type inference in Haskell.

An applicative functor to manage successors

A fixed length list type that encodes its length in its type in a natural way, and is a member of Applicative, Functor, Foldable, Traversable, and Monad.

Entwine provides concurrency types and tools for building correct software.

Hackage documentation generation is not reliable. For up to date documentation, please see: http://www.stackage.org/package/keter.

What4 is a generic library for representing values as symbolic formulae which may contain references to symbolic values, representing unknown variables. It provides support for communicating with a variety of SAT and SMT solvers, including Z3, CVC4, Yices, Boolector, STP, and dReal. The data representation types make heavy use of GADT-style type indices to ensure type-correct manipulation of symbolic values.

This program installs Hascat into a given folder

tn is a simple program to keep journals.

The MultiPass library supports a monadic programming idiom in which multi-pass algorithms are written in a single-pass style.

This package provides various representations of musical pitch. This library is part of the Music Suite, see http://music-suite.github.io.

Some carefully crafted libraries make promises to their users beyond functionality and performance. Examples are: Fusion libraries promise intermediate data structures to be eliminated. Generic programming libraries promise that the generic implementation is identical to the hand-written one. Some libraries may promise allocation-free or branch-free code. Conventionally, the modus operandi in all these cases is that the library author manually inspects the (intermediate or final) code produced by the compiler. This is not only tedious, but makes it very likely that some change, either in the library itself or the surrounding eco-system, breaks the library’s promised without anyone noticing. This package provides a disciplined way of specifying such properties, and have them checked by the compiler. This way, this checking can be part of the ususal development cycle and regressions caught early. See the documentation in Test.Inspection or the project webpage for more examples and more information.

The Cryptographic Protocol Shapes Analyzer (CPSA) attempts to enumerate all essentially different executions possibe for a cryptographic protocol. We call them the shapes of the protocol. Naturally occurring protocols have only finitely many, indeed very few shapes. Authentication and secrecy properties are easy to determine from them, as are attacks and anomalies. For each input problem, the CPSA program is given some initial behavior, and it discovers what shapes are compatible with it. Normally, the initial behavior is from the point of view of one participant. The analysis reveals what the other participants must have done, given the participant's view. The search is based on a high-level algorithm that was claimed to be complete, i.e. every shape can in fact be found in a finite number of steps. Further theoretical work showed classes of executions that are not found by the algorithm, however it also showed that every omitted execution requires an unnatural interpretation of a protocol's roles. Hence the algorithm is complete relative to natural role semantics. The package contains a set of programs used to perform and display the analysis. A standards complient browser, such as Firefox, Safari, or Chrome, is required to display the results. Program documentation is in the doc directory in the source distribution, and installed in the package's data directory. You can locate the package's data directory by typing "cpsa --help" to a command prompt. New users should start learning to use the tool from the manual, found at "cpsamanual.pdf" in the data directory. Examples referenced in the manual can be found in the data directory as well. It is suggested that users make an examples directory and copy "*.scm *.xhtml" to their local examples directory, both so that they may be modified and for ease of access. Serious Windows users should install MSYS so as to allow the use of make and script execution. The theory and algorithm used by CPSA was developed with the help of Joshua D. Guttman, John D. Ramsdell, Jon C. Herzog, Shaddin F. Doghmi, F. Javier Thayer, Paul D. Rowe, and Moses D. Liskov. John D. Ramsdell and Moses D. Liskov implemented the algorithm in Haskell. CPSA was designed and implemented at The MITRE Corporation.

Embedded haskell template using quasiquotes.

The Deadpan-DDP project includes a debugging-tool, as well as a general purpose library. DDP is the protocol that Meteor speaks between client and server. The DDP tech-stack is: Websockets -> JSON -> EJson -> Collections -> Subscriptions + RPC. In order to use the debugging tool, install this package and run deadpan for a usage statement. In order to use the library, simply import Web.DDP.Deadpan. The DSL monad is largely based around RPC calls and callbacks. In order to write an application you would call Web.DDP.Deadpan.runClient with An initial application state (this includes initial callbacks) A set of connection parameters A Web.DDP.Deadpan.DSL.Deadpan application There are several callback-sets provided in Web.DDP.Deadpan, however, if you want to pick in a more granular fashion, look inside Web.DDP.Deadpan.Callbacks. The connection parameters are the triple (Domain, Port, Path)... For convenience the function getURI is provided to turn a URI of the form websocket://localhost:3000/websocket into the triple (Right (localhost, 3000, websocket))... or an error (Left error message). Refer to the README.md on Github for more information.

A library for processing Sybase 15 sysmon reports. The library provides an interface to parse sysmon reports, to query the data, to aggregate the multiple sysmon reports, to generate the optimization hints. The hints parameters can be configured. See the Database.Sybase.Sysmon.Log package for the exported functions and Sample.hs for the usage example.

wrapper around shouldBe so error message is Unicode aware

A library for generating static HTML pages from XML templates and a file-based value dictionary.

This library provides a stable sorting algorithm for primitive arrays. When extra capabilities are available, the sort is parallelized. The algorithm currently uses mergesort on large chunks and switches to insertion sort on small chunks. The are also novel improvements to increase the performance if the input array is already mostly sorted.