In many situations, the liftM operations can be replaced by uses of ap, which promotes function application.
> return f `ap` x1 `ap` ... `ap` xn
is equivalent to
> liftMn f x1 x2 ... xn

Finds the articulation points for a connected undirected graph, by using the low numbers criteria:
a) The root node is an articulation point iff it has two or more children.
b) An non-root node v is an articulation point iff there exists at least one child w of v such that lowNumber(w) >= dfsNumber(v).

The computation appendFile file str function appends the string str, to the file file.
Note that writeFile and appendFile write a literal string to a file. To write a value of any printable type, as with print, use the show function to convert the value to a string first.
> main = appendFile "squares" (show [(x,x*x) | x <- [0,0.1..2]])

approxRational, applied to two real fractional numbers x and epsilon, returns the simplest rational number within epsilon of x. A rational number y is said to be *simpler* than another y' if
* abs (numerator y) <= abs (numerator y'), and
* denominator y <= denominator y'.
Any real interval contains a unique simplest rational; in particular, note that 0/1 is the simplest rational of all.

Haskell implementation of Apache HTTP server specific MD5 digest algorithm that uses OpenSSL MD5() function.
README and ChangeLog can be found in source code package and on GitHub:
* https://github.com/trskop/apache-md5/blob/master/README.md
* https://github.com/trskop/apache-md5/blob/master/ChangeLog.md
Version 0.5.0.1

A gtk2hs server and clan browser for the open source game Tremulous http://tremulous.net. Both Tremulous 1.1 and GPP are supported. Features filtering, player search, a list of online clan members, a clan list and basic perferences.
Version 1.2.3

A simple applicative parser in Parsec style
Version 0.1.4

O_APPEND

Write a string the end of a file.

Some instances for applicative functors and type-level composition. Forkable on github.
Version 0.1.8

Any applicative functor can be given numeric instances in a boilerplate way. The *applicative-numbers* package provides an include file that makes it a snap to define these instances. See Data.Numeric.Function for an example.
Project wiki page: http://haskell.org/haskellwiki/applicative-numbers
Copyright 2009-2013 Conal Elliott; BSD3 license.
Instances of Num classes for applicative functors. To be #include'd after defining APPLICATIVE as the applicative functor name and CONSTRAINTS as a list of constraints, which must carry its own trailing comma if non-empty. The APPLICATIVE symbol gets #undef'd at the end of the include file, so that multiple includes are convenient.
For instance,
@ #define INSTANCE_Ord #define INSTANCE_Enum
#define APPLICATIVE Vec2 #include "ApplicativeNumeric-inc.hs"
#define APPLICATIVE Vec3 #include "ApplicativeNumeric-inc.hs"
#define APPLICATIVE Vec4 #include "ApplicativeNumeric-inc.hs" @
You'll also have to import pure and liftA2 from Control.Applicative and specify the FlexibleContexts language extension (due to an implementation hack).
Some instances are generated only if a corresponding CPP symbol is defined: INSTANCE_Eq, INSTANCE_Ord, INSTANCE_Show, INSTANCE_Enum
Version 0.1.2

Quasiquoters taken from Matt Morrow's haskell-src-meta to implement Conor McBride's idiom brackets, and a do-notation that only requires Applicative (and is correspondingly less powerful).
applicative-quoters currently has no maintainer: if it is broken and you want it to be fixed, then fix it!
Version 0.1.0.8

Functions and utilities to perform paired and unpaired approximate randomization tests (Noreen, 1989).
The utilities can also draw histograms of the applications of the test statistic to the randomized samples. For support for more file formats, install the package with the -withCairo flag.
Version 0.2.1

This package provides approximate discrete values and numbers.
Version 0.2

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 functor with application.
Instances should satisfy the following laws:
* *identity* pure id <*> v = v
* *composition* pure (.) <*> u <*> v <*> w = u <*> (v <*> w)
* *homomorphism* pure f <*> pure x = pure (f x)
* *interchange* u <*> pure y = pure ($ y) <*> u
* *ignore left value* u *> v = pure (const id) <*> u <*> v
* *ignore right value* u <* v = pure const <*> u <*> v
The Functor instance should satisfy
> fmap f x = pure f <*> x
If f is also a Monad, define pure = return and (<*>) = ap.
Minimal complete definition: pure and <*>.

This module describes a structure intermediate between a functor and a monad: it provides pure expressions and sequencing, but no binding. (Technically, a strong lax monoidal functor.) For more details, see *Applicative Programming with Effects*, by Conor McBride and Ross Paterson, online at http://www.soi.city.ac.uk/~ross/papers/Applicative.html.
This interface was introduced for parsers by Niklas Röjemo, because it admits more sharing than the monadic interface. The names here are mostly based on recent parsing work by Doaitse Swierstra.
This class is also useful with instances of the Data.Traversable.Traversable class.

> { f x }

O_APPEND

This library provides an interface to send notifications with the Apple Push Notification Service.
Note: Your connection to Apple's Push Notification service must be secured with SSL. Currently, Haskell's support for SSL is incomplete, therefore you should use an SSL tunnel to connect your application to the push service, such as stunnel.
Version 0.1

This package enables you to compile and execute AppleScript code from Haskell, and provides support for this AppleScript code to call back into Haskell. To get started, see Foreign.AppleScript.Rich.
Version 0.2.0.1

> T a b