Free a block of memory that was allocated with malloc, mallocBytes, realloc, reallocBytes, Foreign.Marshal.Utils.new or any of the new*X* functions in Foreign.Marshal.Array or Foreign.C.String.

Free monads are useful for many tree-like structures and domain specific languages.
A Monad n is a free Monad for f if every Monad homomorphism from n to another monad m is equivalent to a natural transformation from f to m.
Cofree comonads provide convenient ways to talk about branching streams and rose-trees, and can be used to annotate syntax trees.
A Comonad v is a cofree Comonad for f if every Comonad homomorphism another comonad w to v is equivalent to a natural transformation from w to f.
Version 4.2

Release the storage associated with the given FunPtr, which must have been obtained from a wrapper stub. This should be called whenever the return value from a foreign import wrapper function is no longer required; otherwise, the storage it uses will leak.

Deallocate a memory pool and everything which has been allocated in the pool itself.

Dissolve the association between the stable pointer and the Haskell value. Afterwards, if the stable pointer is passed to deRefStablePtr or freeStablePtr, the behaviour is undefined. However, the stable pointer may still be passed to castStablePtrToPtr, but the Foreign.Ptr.Ptr () value returned by castStablePtrToPtr, in this case, is undefined (in particular, it may be Foreign.Ptr.nullPtr). Nevertheless, the call to castStablePtrToPtr is guaranteed not to diverge.

A free functor is a left adjoint to a forgetful functor. It used to be the case that the only category that was easy to work with in Haskell was Hask itself, so there were no interesting forgetful functors.
But the new ConstraintKinds feature of GHC provides an easy way of creating subcategories of Hask. That brings interesting opportunities for free (and cofree) functors.
The examples directory contains an implementation of non-empty lists as free semigroups, and automata as free actions. The standard example of free higher order functors is free monads, and this definition can be found in Data.Functor.HFree.
Version 0.6.1.1

free-game is a library that abstracts graphical applications with simple interfaces. Twitter: #hs_free_game
Version 0.9.4.3

A reimplementation of the operational package (http://hackage.haskell.org/package/operational) using free monads (from http://hackage.haskell.org/package/free). This implements ideas discussed here:
* http://stackoverflow.com/questions/14263363/is-operational-really-isomorphic-to-a-free-monad
* http://www.reddit.com/r/haskell/comments/17a33g/free_functors_the_reason_free_and_operational_are/
To understand the basic concepts you can do no better than read Heinrich Apfelmus' operational tutorial:
* http://apfelmus.nfshost.com/articles/operational-monad.html
In addition to that, this package supplies operational-style modules for Applicative, Alternative and MonadPlus. Applicative and Alternative programs easily admit of static analysis. See these references for discussion and examples:
* http://gergo.erdi.hu/blog/2012-12-01-static_analysis_with_applicatives/ (discussion: http://www.reddit.com/r/haskell/comments/143wpd/static_analysis_with_applicatives/)
* http://paolocapriotti.com/blog/2013/04/03/free-applicative-functors/ (discussion: http://www.reddit.com/r/haskell/comments/1bnql3/free_applicative_functors_icfp_submission/)
See Control.Applicative.Operational for the bulk of the documentation. Control.Alternative.Operational also has some significant examples.
Version 0.5.0.0

The free-theorems library allows to automatically generate free theorems from Haskell type expressions. It supports nearly all Haskell 98 types except of type constructor classes, and in addition it can also handle higher-rank functions. Free theorems are generated for three different sublanguages of Haskell, a basic one corresponding to the polymorphic lambda-calculus of Girard-Reynolds, an extension of that allowing for recursion and errors, and finally a sublanguage additionally allowing seq. In the last two sublanguages, also inequational free theorems may be derived in addition to classical equational results.
Version 0.3.2.0

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

This package provides access to the functionality of http://hackage.haskell.org/package/free-theorems-seq through a web interface.
An online version of the interface is running at http://www-ps.iai.uni-bonn.de/cgi-bin/polyseq.cgi.
Version 1.0.0.2

This package provides access to the functionality of http://hackage.haskell.org/package/free-theorems through a web interface.
An online version can be seen at http://www-ps.iai.uni-bonn.de/ft/, where you can also find a more detailed description of the functionality.
There is also a shell based interface: http://hackage.haskell.org/package/ftshell.
The CGI binary is called "free-theorems-webui.cgi".
To start it locally for offline usage, just call "free-theorems-webui" after installation. (This needs python)
Version 0.2.1.1

A soccer game.
Version 0.1.2

Interface to the Kinect device. Currently supports depth perception. (No video or audio.)
Version 1.0.2

This package provides a preprocessor executable, 'freesect', which implements a broad generalisation of sections (dubbed 'free sections') for partial application and higher-order style. Some examples of free sections can be found in the included test suite; refer to the homepage for more info.
Version 0.8

Access the Freesound Project database. The Freesound Project is a collaborative database of Creative Commons licensed sounds.
http://www.freesound.org/
http://www.creativecommons.org/
Version 0.1.0

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

Converts a mutable array (any instance of MArray) to an immutable array (any instance of IArray) by taking a complete copy of it.

Based on the freetype-gl library, with large modifications.
This is similar to the FTGL (http://hackage.haskell.org/package/FTGL) library, but avoids C++, which makes it easier to wrap and work with in Haskell-land.
Unfortunately, it seems not to perform as well as FTGL on some setups.
NOTE: Most of the demos and C-side documentation are out-of-date, as the C side was heavily modified, without updating many of the demos or the C documentation.
Version 0.0.4

A pointer to a foreign function equivalent to free, which may be used as a finalizer (cf Foreign.ForeignPtr.ForeignPtr) for storage allocated with malloc, mallocBytes, realloc or reallocBytes.

This package provides datatypes to construct Free monads, Free monad transformers, and useful instances. In addition it provides the constructs to avoid quadratic complexity of left associative bind, as explained in:
* Janis Voigtlander, *Asymptotic Improvement of Computations over Free Monads, MPC'08*
Version 0.5.3

Plus, OpT, Yoneda, CoYoneda, Free, Cofree, Density, Codensity, CoT, CodensityAsk, Initialize, Finalize, Decompose, Recompose
Version 0.1

A free indexed monad
Version 0.3.1

Michael and Scott queues are described in their PODC 1996 paper:
http://dl.acm.org/citation.cfm?id=248052.248106
These are single-ended concurrent queues based on a singlly linked list and using atomic CAS instructions to swap the tail pointers. As a well-known efficient algorithm they became the basis for Java's ConcurrentLinkedQueue.
Version 0.2.0.2

The pointfree tool is a standalone command-line version of the pl plugin for lambdabot.
Version 1.0.4.5

Support for safely freezing multiple arrays in the ST monad. Developed in http://haskell.reinerpope.com/2009/09/making-runstarray-more-flexible-or.html.
The new monad is defined in Control.Monad.ST.Freeze. An example of its use is given in Data.Vector.Generic.Mutable.STFreeze. The module Data.STRef.Freeze is a reexports of Data.STRef but lifted to the new ST monad.
Version 0.2.1

This package is obsolete and all functionality has been merged into the free package.
This library generalizes free monads to free monad transformers.
Version 1.0.1

Freeze a mutable array. Do not mutate the MArray afterwards!

Converts an mutable array into an immutable array. The implementation may either simply cast the array from one type to the other without copying the array, or it may take a full copy of the array.
Note that because the array is possibly not copied, any subsequent modifications made to the mutable version of the array may be shared with the immutable version. It is safe to use, therefore, if the mutable version is never modified after the freeze operation.
The non-copying implementation is supported between certain pairs of array types only; one constraint is that the array types must have identical representations. In GHC, The following pairs of array types have a non-copying O(1) implementation of unsafeFreeze. Because the optimised versions are enabled by specialisations, you will need to compile with optimisation (-O) to get them.
* IOUArray -> UArray
* STUArray -> UArray
* IOArray -> Array
* STArray -> Array

A combinator library for asynchronous waitfree computation among forkIO threads.
Version 0.1.5