Please see the README on GitHub at https://github.com/ChrisPenner/lens-errors#readme

[Index] For package maintainers and hackage trustees

fortune-mod clone, in library and executable form.

Tag-stream is a library for parsing HTMLXML to a token stream. It can parse unstructured and malformed HTML from the web. It also provides an Enumeratee which can parse streamline html, which means it consumes constant memory. Users can start from the tests/Tests.hs module to see what it can do.

lifted-threads exports IO operations from the base library lifted to any instance of MonadBase or MonadBaseControl.

https://github.com/mtth/flags-applicative

This library allows to create and control scsynth processes. ChangeLog: https://github.com/kaoskorobase/hsc3-process/blob/master/ChangeLog.md

safe binding for the nettle (http://www.lysator.liu.se/~nisse/nettle/nettle.html) library. Tested with 3.4, might work with 3.2 (but not earlier).

:pill: a GHC.Generics-based entity component system

This package uses closed type families and type literals to implement open records and variants. The core is based off of the CTRex package, but it also includes polymorphic variants and a number of additional functions. That said, it is not a proper superset of CTRex as it specifically forbids records from having more than one element of the same label.

Please see the README and docs at https://www.stackage.org/package/bzlib-conduit

A group of Hash related utilities (currently wraps MurmurHash3 C implementation)

Please see the README on GitHub at https://github.com/ChrisPenner/lens-regex-pcre#readme

Deprecated Num, Enum, Eq, Integral, Ord, Real, and Show instances for Lazy ByteStrings

This module provides functions that can replace calls to atomically and count how often the transaction was retried until it succeeded. It can emit warnings when transaction are retried more often than a given threshold, and provides global statistics across all transaction. As an additional feature, if the transaction was named, transaction-related exceptions such as BlockedIndefinitelyOnSTM are replaced by variants that indicate which transaction caused the exception. Changelog:

A minimal pretty-printing library for Show instances in Haskell.

This package provides a simple wrapper around the Linux FIEMAP ioctl. It can be used to retrieve the list of all the extents of any given file, i.e. the area of the disk where the file is actually stored. This is similar to the filefrag command line tool provided by the e2fsprogs package.

This package provides bindings to the fftw library for one-dimensional vectors. It provides both high-level functions and more low-level manipulation of fftw plans. We provide three different modules which wrap fftw's operations: Numeric.FFT.Vector.Unnormalized contains the raw transforms; Numeric.FFT.Vector.Invertible scales the backwards transforms to be true inverses; Numeric.FFT.Vector.Unitary additionally scales all transforms to preserve the L2 (sum-of-squares) norm of the input. Note that this package is currently not thread-safe.

Please see the README on GitHub at https://github.com/satosystems/macrm#readme

[Index] [Quick Jump] Static link Use -f <flag> to enable a flag, or -f -<flag> to disable that flag. More info For package maintainers and hackage trustees Checkmate is a small program to generate human-readable checklists from a given patch (or pull request). Leave CHECK comments (that are the same fashion as FIXME or TODO comments); then Checkmate detects when a diff touches some code scopes having any CHECK comments, and lists the checks. It helps contributors and reviewers to remind matters that require attention when a part of the code is changed. Let's say there's a dictionary, and we should update the manual when a key is added to or removed from it: The above example may be artificial, but suppose lines of the dictionary are lengthy. Such tasks should be done outside of the source code repository so that they cannot be automated by simply eliminating code duplicates. Contributors and reviewers altogether are easy to forget about such tasks. To remind peers of such tasks, Checkmate detects CHECK comments like the above example when a relevant code block is touched and show peers a checklist. How does Checkmate list only relevant checks to a diff? It currently doesn't have any language-specific algorithms, but only a language-agnostic heuristics on indented blocks. Suppose the following diff: Since it touched a code block with a CHECK comment, Checkmate generates the following checklist: Suppose a patch touches only code blocks without any CHECK comments too, e.g.: Since the touched block doesn't have any CHECK comments, Checkmate generates an empty checklist. Note that it doesn't parse code's semantics, but only scans blocks through indentation. Even if a block is wrapped in curly braces without indentation, it isn't counted as a block. Some checks may need to be listed for a whole directory. Checkmate recognizes files named .check or CHECK in a directory and include checks in that to the checklist if any file in the directory are changed. Its syntax is basically a simple bullet list and a bullet can be */-/+/CHECK or digits followed by ./), e.g.: We provide an official Linux x86_64 binary for every release. See also the latest release. Note that official binaries are distributed as statically-linked standalone executable, and they aren't gzipped. Download and give an +x permission; then it's ready. On the other platforms you can download and install using Haskell Cabal or Stack since source tarballs also are distributed on Hackage: Note: if you experience an error like ConnectionFailure Network.BSD.getProtocolByName: does not exist (no such protocol name: tcp) on Debian/Ubuntu Linux, try to install netbase package. (Read this explanation for details.) Since Checkmate usually is executed as a part of CI build, we show examples for widely-used CI services. All examples assume the environment variables are defined: GITHUB_TOKEN contains the access token to leave comments on a corresponding GitHub repository. See also GitHub's official article about personal API tokens. CHECKMATE_DOWNLOAD_URL contains the download link to the prebuilt binary of the latest release, i.e.: You can run checkmate github command with explicit arguments: If you're using GitHub Enterprise on premise use --endpoint option. Further reading: checkmate github --help.

This package provides a monad transformer that helps create “mocks” of mtl-style typeclasses, intended for use in unit tests. A mock can be executed by providing a sequence of expected monadic calls and their results, and the mock will verify that the computation conforms to the expectation. For more information, see the module documentation for Control.Monad.Mock.

Use jsx-like syntax in Reflex

See README.md and SMCDEL.pdf for references and documentation.

Utility library for monads, particularly those involving state.

Sixel can show graphics on a terminal emulator. This library is developed to showing images on ghci.

Parse a .env file and load any declared variables into the current process's environment. This allows for a .env file to specify development-friendly defaults for configuration values normally set in the deployment environment.

scan checks the format of your haskell source code regarding: comments, white spaces and line breaks.

This library includes data types for storing permutations and combinations. It implements pure and impure types, the latter of which can be modified in-place. The library uses aggressive inlining and MutableByteArray#s internally, so it is very efficient. The main utility of the library is converting between the linear representation of a permutation and a sequence of swaps. This allows, for instance, applying a permutation or its inverse to an array with O(1) memory use. Much of the interface for the library is based on the permutation and combination functions in the GNU Scientific Library (GSL).

multi-line string / here document using QuasiQuotes

Instances of Aeson's ToJSON and FromJSON for UUIDs. NOTE: Starting with aeson-1.1, ToJSON and FromJSON non-orphan instances are provided by aeson directly.

Control library for the Elgato Stream Deck

D-Bus is a simple, message-based protocol for inter-process communication, which allows applications to interact with other parts of the machine and the user's session using remote procedure calls. D-Bus is a essential part of the modern Linux desktop, where it replaces earlier protocols such as CORBA and DCOP. This library is an implementation of the D-Bus protocol in Haskell. It can be used to add D-Bus support to Haskell applications, without the awkward interfaces common to foreign bindings. Example: connect to the session bus, and get a list of active names.

This package implemets API for a HandlerSocket client.

Please see the README on Github at https://github.com/masterdezign/dde#readme

The linearscan library is an implementation -- in Coq, extracted to Haskell -- of a register allocation algorithm developed by Christian Wimmer. It is described in detail in his Masters thesis, which can be found at http://www.christianwimmer.at/Publications/Wimmer04a/Wimmer04a.pdf. A Java implementation of this same algorithm, by that author, is used in Oracle's Graal project. This version of the algorithm was written and verified in Coq, containing over 130 proved lemmas, at over 5K LOC. It was funded as a research project by BAE Systems (http://www.baesystems.com), to be used in an in-house compiler written in Haskell. In order for the Coq code to be usable from Haskell, it is first extracted from Coq as a Haskell library, during which many of Coq's fundamental types are mapped directly onto counterparts in the Haskell Prelude. Thus, it should be within the performance range of an equivalent implementation written directly in Haskell. Note that not every conceivable property of this library has been proven. For some of the lower layers this is true, because the algebraic constraints on these components could be exhaustively described in the context of their use. However, higher-level components represent a great variety of use cases, and not every one of these cases has been proven correct. This represents an ongoing effort, with the hope that proofs will entirely replace the necessity for ad hoc unit testing, and that at some point we can know that any allocation produced by this library must either fail, or be mathematically sound. This library's sole entry point is the LinearScan.allocate function, which takes a list of information about basic blocks to an equivalent list, with annotations indicating allocation choices.

Safe, checked exceptions

Grapefruit is a library for Functional Reactive Programming (FRP) with a focus on user interfaces. FRP makes it possible to implement reactive and interactive systems in a declarative style. To learn more about FRP, have a look at http://haskell.org/haskellwiki/Functional_Reactive_Programming. This package contains general user interface support. To make use of it, it has to be complemented by a UI backend. It is possible to have different UI backends implementing the same general interface on top of different UI toolkits. At the moment, the only backend is one based on GTK+. This is provided by the grapefruit-ui-gtk package.

For package maintainers and hackage trustees

Deprecated in favor of wai-extra

It can be useful (especially with @PolyKinds@) to get the \"bare\" type (e.g. @Either@) of some parameterized type (e.g. @Either Char Int@). This library provides closed classes that can strip and reapply type arguments, as well as useful utility functions. Here are some examples: Force @Left 1@ to be of type @Either Float a@ using a partially-applied 'Proxy'. >>> let t = (Left 1) `asApplied` (Proxy :: Proxy (Either Float)) >>> :t t t :: Either Float a Do the same, but illustrating type application with @ap@ >>> let t0 = (Left 1) `asApplied` ((Proxy :: Proxy Either) `ap` (Proxy :: Proxy Float)) >>> :t t0 t0 :: Either Float a Force polymorphic @undefined@ to some polymorphic @Either@ type, the base type of @t@ defined above. >>> let u = undefined `asApplied` (unappliedOf t) >>> :t u u :: Either a a1

Network.Protocol.NetSNMP is a partial binding to the library portion of the net-snmp package. It uses the 'single-session api', which is claimed to be thread-safe. Not all operations are supported yet; please contact the maintainer if you're in need of expanded functionality, and especially if you would like to contribute.

Text.HTML.Light is a very simple Haskell module for writing [x]html documents. It provides constructors for html elements and attributes in terms of Text.XML.Light.

Deprecated in favor of Spock Adding PHP-like session management to Scotty.

A thin wrapper for the Hyperpublic API, which uses http-enumerator to fetch results and aeson to return them as JSON.

Multi-set rewrite rules with guards and a parallel execution scheme

Lists with cheap snocs.

[Index] For package maintainers and hackage trustees

This package implements a Template Haskell quasi quoter for format strings.

pretty-ncols allows for the following layouts to work nicely, so that: One Two Three 1 2 3 a b c can be written as: cols_rowMajor = map text $ [[One, Two, Three], [1, 2,3], [a,b,c]] cols_colMajor = transpose $ cols_rowMajors asColumns cols_rowMajor asColumns cols_colMajor

Removed; please see fmlist.

Just a wrapper around the pdfinfo command (for collecting PDF file info). See man pdfinfo.

This package aims to provide a comprehensive interface to the MathWorks MATLAB(R) libraries and native data structures, including complete matrix access, MAT-format files, linking and execution of runtime libraries and engine. Requires MATLAB for full functionality or an installed Matlab Component Runtime (MCR). This has been tested with MATLAB R2014a and might work with others.

a module for systemd socket activation. See http://0pointer.de/blog/projects/socket-activation.html and http://www.freedesktop.org/software/systemd/man/systemd.socket.html for more details.

Here docs & interpolated strings via quasiquotation

Easily create histograms of your data

Convert yarn.lock files to nix expressions. See yarn2nix executable. Contains a nix library to call the generated nix files in nix-lib/. Library functions and module names might be restructured in the future.

This package will make it easier to derive class instance for complex composited data types by using Template Haskell.

Please see the README on GitHub at https://github.com/tmcdonell/gloss-accelerate#readme

This snaplet contains support for using the Stripe payment platform with a Snap Framework application.

In their 1994 paper "Volume Changes in Protein Evolution", Gerstein, Sonnhammer and Chothia developed a weighting procedure for protein sequences to avoid over-represented sequences in the appendix "A Method to Weight Protein Sequences to Correct for Unequal Representation". Although their method was developed for protein sequences, it is readily extended to work on any measurable set. This package calculates GSC weights for any reasonable dendrogram. If you want to recreate their algorithm, then just use UPGMA as linkage and residue identity as distance function when creating the dendrogram. Changes in version 0.2: Updated to work with hierarchical-clustering 0.4. Changes in version 0.1.1.1: Use an stricter upper bound on hierachical-clustering. Changes in version 0.1.1: Now works even when some (or all) branches have distance zero (i.e. elements below that branches are all equal with respect to distance metric that was used to create the dendrogram).

[Index] For package maintainers and hackage trustees

A Haskell 98 logically uninhabited data type, used to indicate that a given term should not exist.

sak is a command-line tool that detects and handles various compression formats

Integrates lambdabot with Zulip Chat.

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

Please see README.md

A Haskell binding to the Xdamage X11 extention graphics library. The binding is a direct translation of the C binding; for documentation of these calls, refer to The Xlib Programming Manual, available online at http://tronche.com/gui/x/xlib/.

Infinite search in finite time with Hilbert's epsilon

Evaluation-orthogonal serialisation of Haskell data, as a library

The purpose of this module is to provide newtype wrappers that allow one to effectively override the equality operator of a value so that it is approximate rather than exact. The wrappers use type annotations to specify the tolerance; the Digits type constructor has been provided for specifying the tolerance using type-level natural numbers. Instances for all of the classes in the numerical hierarchy have been provided for the wrappers, so the wrapped values can mostly be used in the same way as the original values. (In fact, most of the time one doesn't even have to wrap the starting values, since expressions such as (1+sqrt 2/3) are automatically wrapped thanks to the fromIntegral method of the Num typeclass.) See the documentation for Data.Eq.Approximate for more detailed information on how to use this package. New in version 1.1: Added explicit Show constraints to the Show instances, as the Num class in the newest version of GHC (wisely) no longer includes Show as a constraint.

A Haskell DSL for Generating Dockerfiles

Chorale is a Haskell module that contains basic functions that the prelude does not offer. The prelude is traditionally followed by a chorale ...

Roguestar-glut and roguestar-gtk depend on this library for the bulk of their functionality.

Efficient implementation of the implicit treap data structure. Use this data structure if you want dynamic arrays with fast operations on segments.

show dist dir of 'cabal copy/install'

A program and a library that can be used as a simple basic interface to some SoX functionality or to produce your voice in Ukrainian (if you pronounce the sounds properly) represented by the separate sounds or something special like soft sign.

A simple music typesetting model in haskell

Typical zip functions like zip, zipWith, and zipWith3 will stop with the shortest list exhausted. Consequently information is lost. This library solves this issue by inserting default values. The these package serves a similar purpose but allows more than just lists to be zipped with the Align type class. However, zipping several lists and using defaults is not as easy.

[Index] For package maintainers and hackage trustees Let's write a hello world app. Note, we are not importing any interface! If we take a closer look at the type of hello: This is a pure app! Shall we run it? Test it: wow ~ Exercise: write a tcp cat

Printing SockAddr

Haskell library for quick JSON extractions with Aeson

Please see the README on Github at https://github.com/oisdk/groupBy#readme

Typeable for polymorphic types.

Mushu is a minimalist MPD client with a TUI and an incremental fuzzy finder for your music library

cgen parses C++ headers and generates C wrappers and Haskell bindings to a C++ library.

A logging back-end to syslog(3) for the logging-facade library

Simple monadic interface for mwc-random.

see example: https://github.com/philopon/barrier/blob/master/examples/example.hs

[Index] For package maintainers and hackage trustees

Hack2: a Haskell Webserver Interface (V2)

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.

Simple computation of visibility polygons.

This library provides bindings to Mackerel APIs. The official site of Mackerel: https://mackerel.io/. The reference of Mackerel API: https://mackerel.io/api-docs/.

Please see README.md

On Unix platforms, this should be a very straightforward implementation of the XDG User Directory spec. On Windows, it will attempt to do the right thing with regards to choosing appropriate directories.

This library allows you to extract information from cabal files without depending on the Cabal library. Since GHC currently depends on Cabal, it's difficult to directly use Cabal if you also like to use the GHC API. This package solves that problem by using the GHC API itself to interface with Cabal, which means that it can use whatever Cabal version the user has installed, at run time (the version is not fixed at compile time). For a short tutorial, see https://github.com/bennofs/dynamic-cabal. Note: As of GHC 7.10, the ghc library no longer depends on Cabal. So you only need this package if you want to support older GHC versions.