**Packages**- package

Haskell formula manipulation program
Version 1.1.3

Leibnizian equality
Version 4.0

Shell command that finds files with equal content in a given set of files. This is useful for finding duplicates in a set of documents where the same document might have been stored by accident with different names. Use it like
> equal-files `find my_dir -type f`
or
> find my_dir -type f | xargs equal-files
If the file names contain spaces, better use
> find my_dir -type f -printf "'%p'\n" | xargs equal-files
or
> equal_files -r my_dir
The program reads all input files simultaneously, driven by sorting and grouping of their content. However be prepared that due to the simultaneous access you may exceed the admissible number of opened files. Thus you may prefer to run it like
> equal_files -r -p 512 my_dir
The program can be used as a nice example of a declarative yet efficient implementation of a non-trivial algorithm, that is enabled by lazy evaluation.
Version 0.0.4

This is an implementation of Tarjan's Union-Find algorithm (Robert E. Tarjan. "Efficiency of a Good But Not Linear Set Union Algorithm", JACM 22(2), 1975) in order to maintain an equivalence relation. This implementation is a port of the *union-find* package using the ST monad transformer (instead of the IO monad).
Version 0.2.3

An abstract interface to highly-parameterizable queues/deques.
Background: There exists a feature space for queues that extends between:
* simple, single-ended, non-concurrent, bounded queues
* double-ended, threadsafe, growable queues
... with important points inbetween (such as the queues used for work-stealing).
This package includes an interface for Deques that allows the programmer to use a single API for all of the above, while using the type-system to select an efficient implementation given the requirements (using type families).
This package also includes a simple reference implementation based on IORef and Data.Sequence.
Version 0.2.2

This package provides access to ALSA sequencer (MIDI support). For audio support see alsa-pcm. Included are some simple example programs. For more example programs including a GUI, see the alsa-gui programs.
Version 0.6.0.2

Tests for the ALSA sequencer library.
Version 0.1

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.
Version 1.1

A queue that is push/pop on one end and pop-only on the other. These are commonly used for work-stealing. This implementation derives directly from the pseudocode in the 2005 SPAA paper:
"http:citeseerx.ist.psu.edu*viewdoc*download?doi=10.1.1.170.1097&rep=rep1&type=pdf"
Version 0.4

Find sequences within lists.
Version 0.1

This package provides methods for fully evaluating data structures ("deep evaluation"). Deep evaluation is often used for adding strictness to a program, e.g. in order to force pending exceptions, remove space leaks, or force lazy I/O to happen. It is also useful in parallel programs, to ensure pending work does not migrate to the wrong thread.
The primary use of this package is via the deepseq function, a "deep" version of seq. It is implemented on top of an NFData typeclass ("Normal Form Data", data structures with no unevaluated components) which defines strategies for fully evaluating different data types.
If you want to automatically derive NFData instances via the GHC.Generics facility, there is a companion package <http:hackage.haskell.org*package*deepseq-generics deepseq-generics> which builds on top of this package.
Version 1.3.0.2

This package provides a GHC.Generics-based Control.DeepSeq.Generics.genericRnf function which can be used for providing a rnf implementation. See the documentation for the genericRnf function in the Control.DeepSeq.Generics module to get started.
The original idea was pioneered in the generic-deepseq package (see http://www.haskell.org/pipermail/haskell-cafe/2012-February/099551.html for more information).
This package differs from the generic-deepseq package by working in combination with the existing deepseq package as opposed to defining a conflicting drop-in replacement for deepseq's Control.Deepseq module.
Version 0.1.1.1

This package provides a Template Haskell based mechanism for deriving optimised NFData instances for custom data types. See documentation in Control.DeepSeq.TH for more information.
See also the deepseq-generics package (http://hackage.haskell.org/package/deepseq-generics) for a less experimental approach.
Version 0.1.0.4

A typeclass for double-ended queues, and an implementation of Banker's Dequeues, as described in Chris Okasaki's Purely Functional Data Structures.
Version 0.1.5

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

This package used to export DPH array primitives, but they're in dph-prim-seq now.
Version 0.5.1.99

Prior to base-4.7.0.0 there was no Eq instance for ErrorCall. This package provides an orphan instance.
Version 0.1.0

Given a term, this program calculates a set of "optimal" free theorems that hold in a lambda calculus with selective strictness. It omits totality (in general, bottom-reflection) and other restrictions when possible. The underlying theory is described in the paper "Taming Selective Strictness" (ATPS'09) by Daniel Seidel and Janis Voigtländer. A webinterface for the program is running online at http://www-ps.iai.uni-bonn.de/cgi-bin/polyseq.cgi or available offline via the package http://hackage.haskell.org/package/free-theorems-seq-webui.
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/package/free-theorems-webui. Additionally interesting may be the counterexample generator for free theorems that exemplifies the need of strictness conditions imposed by general recursion. It can be downloaded at http://hackage.haskell.org/package/free-theorems-counterexamples or used via a webinterface at http://www-ps.iai.uni-bonn.de/cgi-bin/exfind.cgi.
Version 1.0