| Haskell Hierarchical Libraries | Contents | Index

Haskell Hierarchical Libraries
The libraries are divided into several packages. The available packages are:

`base`
  This package contains the `Prelude` and its support libraries, and a large collection of useful libraries ranging from data structures to parsing combinators and debugging utilities.
`Cabal`
  The Haskell Cabal is the Common Architecture for Building Applications and Libraries. It is a framework which defines a common interface for authors to more easily build their applications in a portable way. The Haskell Cabal is meant to be a part of a larger infrastructure for distributing, organizing, and cataloging Haskell Libraries and Tools. For more information, please see: http://www.haskell.org/cabal/.
`cgi`
  A library for writing CGI programs.
`fgl`
  Martin Erwig's Functional Graph Library.
`filepath`
  Library for manipulating FilePath's in a cross platform way.
`haskell-src`
  Facilities for manipulating Haskell source code: an abstract syntax, lexer, parser and pretty-printer.
`haskell98`
  This package provides compatibility with the modules of Haskell 98 and the FFI addendum, by means of wrappers around modules from the `base` package (which in many cases have additional features). However `Prelude`, `Numeric` and `Foreign` are provided directly by the `base` package. The modules of this package are documented in the Revised Haskell 98 Report, at http://www.haskell.org/onlinereport/, and the Haskell 98 Foreign Function Interface addendum, at http://www.cse.unsw.edu.au/~chak/haskell/ffi/.
`html`
  An Html combinator library.
`HUnit`
  HUnit is a unit testing framework for Haskell, inspired by the JUnit tool for Java, see: http://www.junit.org.
`mtl`
  A monad transformer library, inspired by the paper Functional Programming with Overloading and Higher-Order Polymorphism, Mark P Jones (http://www.cse.ogi.edu/~mpj/) Advanced School of Functional Programming, 1995.
`network`
  Networking-related facilities.
`OpenGL`
  The `OpenGL` package contains a Haskell binding for the OpenGL graphics system (GL, version 2.1) and its accompanying utility library (GLU, version 1.3). OpenGL is the industry's most widely used and supported 2D and 3D graphics application programming interface (API), incorporating a broad set of rendering, texture mapping, special effects, and other powerful visualization functions. For more information about OpenGL, please see: http://www.opengl.org/.
`parsec`
  A monadic parser combinator library, written by Daan Leijen. Parsec is designed from scratch as an industrial-strength parser library. It is simple, safe, well documented, has extensive libraries and good error messages, and is also fast. More documentation can be found on: http://www.cs.uu.nl/~daan/parsec.html
`QuickCheck`
  A library for testing Haskell programs automatically. The programmer provides a specification of the program, in the form of properties which functions should satisfy, and QuickCheck then tests that the properties hold in a large number of randomly generated cases. Specifications are expressed in Haskell, using combinators defined in the QuickCheck library. QuickCheck provides combinators to define properties, observe the distribution of test data, and define test data generators. For more information, please see: http://www.math.chalmers.se/~rjmh/QuickCheck/.
`regex-base`
  Interfaces for regular expressions
`regex-compat`
  Compatibility for Text.Regex
`regex-posix`
  POSIX regular expressions
`stm`
  Software Transactional Memory: a modular composable concurrency abstraction.
`template-haskell`
  Facilities for manipulating Haskell source code using Template Haskell.
`time`
  Clock and calendar time.
`Win32`
  A Haskell binding to the Win32 API.
`xhtml`
  An XHtml combinator library.

Implementation-specific notes:

GHC/GHCi
  Most of the time, all the packages are available without the need to use any additional command-line options. The only time when this is not the case is when linking a program on the command line, without using the `--make` option: in this case you must list all the packages to link to by adding the `-package` P flag (where P is the package name) to the command line for each package. See the User's Guide (../users_guide/index.html) for more details.
Hugs
  Hugs provides almost all of the modules in the above packages, with exceptions listed on the Hugs 98 libraries status page (http://cvs.haskell.org/Hugs/pages/libstatus.html). All those modules are always available.
Nhc98
  Nhc98 provides many of the modules in the above packages (see the Nhc98 libraries page (http://www.haskell.org/nhc98/libraries.html) for a more details). The modules of the `haskell98` package are available without the need to use any additional compile-time options. To use modules from some other package P with Nhc98, add the compile-time option `-package` P.

Modules

Control |  |

Control.Applicative |  | base
Control.Arrow |  | base
Control.Concurrent |  | base

Control.Concurrent.Chan |  | base
Control.Concurrent.MVar |  | base
Control.Concurrent.QSem |  | base
Control.Concurrent.QSemN |  | base
Control.Concurrent.STM |  | stm

Control.Concurrent.STM.TArray |  | stm
Control.Concurrent.STM.TChan |  | stm
Control.Concurrent.STM.TMVar |  | stm
Control.Concurrent.STM.TVar |  | stm

Control.Concurrent.SampleVar |  | base

Control.Exception |  | base
Control.Monad |  | base

Control.Monad.Cont |  | mtl

Control.Monad.Cont.Class |  | mtl

Control.Monad.Error |  | mtl

Control.Monad.Error.Class |  | mtl

Control.Monad.Fix |  | base
Control.Monad.Identity |  | mtl
Control.Monad.Instances |  | base
Control.Monad.List |  | mtl
Control.Monad.RWS |  | mtl

Control.Monad.RWS.Class |  | mtl
Control.Monad.RWS.Lazy |  | mtl
Control.Monad.RWS.Strict |  | mtl

Control.Monad.Reader |  | mtl

Control.Monad.Reader.Class |  | mtl

Control.Monad.ST |  | base

Control.Monad.ST.Lazy |  | base
Control.Monad.ST.Strict |  | base

Control.Monad.STM |  | stm
Control.Monad.State |  | mtl

Control.Monad.State.Class |  | mtl
Control.Monad.State.Lazy |  | mtl
Control.Monad.State.Strict |  | mtl

Control.Monad.Trans |  | mtl
Control.Monad.Writer |  | mtl

Control.Monad.Writer.Class |  | mtl
Control.Monad.Writer.Lazy |  | mtl
Control.Monad.Writer.Strict |  | mtl

Control.Parallel |  | base

Control.Parallel.Strategies |  | base

Data |  |

Data.Array |  | base

Data.Array.Diff |  | base
Data.Array.IArray |  | base
Data.Array.IO |  | base
Data.Array.MArray |  | base
Data.Array.ST |  | base
Data.Array.Storable |  | base
Data.Array.Unboxed |  | base

Data.Bits |  | base
Data.Bool |  | base
Data.ByteString |  | base

Data.ByteString.Base |  | base
Data.ByteString.Char8 |  | base
Data.ByteString.Lazy |  | base

Data.ByteString.Lazy.Char8 |  | base

Data.Char |  | base
Data.Complex |  | base
Data.Dynamic |  | base
Data.Either |  | base
Data.Eq |  | base
Data.Fixed |  | base
Data.Foldable |  | base
Data.FunctorM |  | base
Data.Generics |  | base

Data.Generics.Aliases |  | base
Data.Generics.Basics |  | base
Data.Generics.Instances |  | base
Data.Generics.Schemes |  | base
Data.Generics.Text |  | base
Data.Generics.Twins |  | base

Data.Graph |  | base

Data.Graph.Inductive |  | fgl

Data.Graph.Inductive.Basic |  | fgl
Data.Graph.Inductive.Example |  | fgl
Data.Graph.Inductive.Graph |  | fgl
Data.Graph.Inductive.Graphviz |  | fgl
Internal |  |

Data.Graph.Inductive.Internal.FiniteMap |  | fgl
Data.Graph.Inductive.Internal.Heap |  | fgl
Data.Graph.Inductive.Internal.Queue |  | fgl
Data.Graph.Inductive.Internal.RootPath |  | fgl
Data.Graph.Inductive.Internal.Thread |  | fgl

Data.Graph.Inductive.Monad |  | fgl

Data.Graph.Inductive.Monad.IOArray |  | fgl

Data.Graph.Inductive.NodeMap |  | fgl
Data.Graph.Inductive.Query |  | fgl

Data.Graph.Inductive.Query.ArtPoint |  | fgl
Data.Graph.Inductive.Query.BCC |  | fgl
Data.Graph.Inductive.Query.BFS |  | fgl
Data.Graph.Inductive.Query.DFS |  | fgl
Data.Graph.Inductive.Query.Dominators |  | fgl
Data.Graph.Inductive.Query.GVD |  | fgl
Data.Graph.Inductive.Query.Indep |  | fgl
Data.Graph.Inductive.Query.MST |  | fgl
Data.Graph.Inductive.Query.MaxFlow |  | fgl
Data.Graph.Inductive.Query.MaxFlow2 |  | fgl
Data.Graph.Inductive.Query.Monad |  | fgl
Data.Graph.Inductive.Query.SP |  | fgl
Data.Graph.Inductive.Query.TransClos |  | fgl

Data.Graph.Inductive.Tree |  | fgl

Data.HashTable |  | base
Data.IORef |  | base
Data.Int |  | base
Data.IntMap |  | base
Data.IntSet |  | base
Data.Ix |  | base
Data.List |  | base
Data.Map |  | base
Data.Maybe |  | base
Data.Monoid |  | base
Data.Ord |  | base
Data.PackedString |  | base
Data.Queue |  | base
Data.Ratio |  | base
Data.STRef |  | base

Data.STRef.Lazy |  | base
Data.STRef.Strict |  | base

Data.Sequence |  | base
Data.Set |  | base
Data.Time |  | time

Data.Time.Calendar |  | time

Data.Time.Calendar.Easter |  | time
Data.Time.Calendar.Julian |  | time
Data.Time.Calendar.MonthDay |  | time
Data.Time.Calendar.OrdinalDate |  | time
Data.Time.Calendar.WeekDate |  | time

Data.Time.Clock |  | time

Data.Time.Clock.POSIX |  | time
Data.Time.Clock.TAI |  | time

Data.Time.Format |  | time
Data.Time.LocalTime |  | time

Data.Traversable |  | base
Data.Tree |  | base
Data.Tuple |  | base
Data.Typeable |  | base
Data.Unique |  | base
Data.Version |  | base
Data.Word |  | base

Debug |  |

Debug.QuickCheck |  | QuickCheck

Debug.QuickCheck.Batch |  | QuickCheck
Debug.QuickCheck.Poly |  | QuickCheck
Debug.QuickCheck.Utils |  | QuickCheck

Debug.Trace |  | base

Distribution |  |

Compat |  |

Distribution.Compat.ReadP |  | Cabal

Distribution.Compiler |  | Cabal
Distribution.Extension |  | Cabal
Distribution.InstalledPackageInfo |  | Cabal
Distribution.License |  | Cabal
Distribution.Make |  | Cabal
Distribution.Package |  | Cabal
Distribution.PackageDescription |  | Cabal
Distribution.PreProcess |  | Cabal

Distribution.PreProcess.Unlit |  | Cabal

Distribution.Program |  | Cabal
Distribution.Setup |  | Cabal
Distribution.Simple |  | Cabal

Distribution.Simple.Build |  | Cabal
Distribution.Simple.Configure |  | Cabal
Distribution.Simple.GHC |  | Cabal
Distribution.Simple.GHCPackageConfig |  | Cabal
Distribution.Simple.Hugs |  | Cabal
Distribution.Simple.Install |  | Cabal
Distribution.Simple.JHC |  | Cabal
Distribution.Simple.LocalBuildInfo |  | Cabal
Distribution.Simple.NHC |  | Cabal
Distribution.Simple.Register |  | Cabal
Distribution.Simple.SrcDist |  | Cabal
Distribution.Simple.Utils |  | Cabal

Distribution.Version |  | Cabal

Foreign |  | base

Foreign.C |  | base

Foreign.C.Error |  | base
Foreign.C.String |  | base
Foreign.C.Types |  | base

Foreign.Concurrent |  | base
Foreign.ForeignPtr |  | base
Foreign.Marshal |  | base

Foreign.Marshal.Alloc |  | base
Foreign.Marshal.Array |  | base
Foreign.Marshal.Error |  | base
Foreign.Marshal.Pool |  | base
Foreign.Marshal.Utils |  | base

Foreign.Ptr |  | base
Foreign.StablePtr |  | base
Foreign.Storable |  | base

GHC |  |

GHC.Conc |  | base
GHC.ConsoleHandler |  | base
GHC.Dotnet |  | base
GHC.Dynamic |  | base
GHC.Exts |  | base
GHC.Prim |  | base

Graphics |  |

Rendering |  |

Graphics.Rendering.OpenGL |  | OpenGL

Graphics.Rendering.OpenGL.GL |  | OpenGL

Graphics.Rendering.OpenGL.GL.Antialiasing |  | OpenGL
Graphics.Rendering.OpenGL.GL.BasicTypes |  | OpenGL
Graphics.Rendering.OpenGL.GL.BeginEnd |  | OpenGL
Graphics.Rendering.OpenGL.GL.Bitmaps |  | OpenGL
Graphics.Rendering.OpenGL.GL.BufferObjects |  | OpenGL
Graphics.Rendering.OpenGL.GL.Clipping |  | OpenGL
Graphics.Rendering.OpenGL.GL.ColorSum |  | OpenGL
Graphics.Rendering.OpenGL.GL.Colors |  | OpenGL
Graphics.Rendering.OpenGL.GL.CoordTrans |  | OpenGL
Graphics.Rendering.OpenGL.GL.DisplayLists |  | OpenGL
Graphics.Rendering.OpenGL.GL.Evaluators |  | OpenGL
Graphics.Rendering.OpenGL.GL.Feedback |  | OpenGL
Graphics.Rendering.OpenGL.GL.FlushFinish |  | OpenGL
Graphics.Rendering.OpenGL.GL.Fog |  | OpenGL
Graphics.Rendering.OpenGL.GL.Framebuffer |  | OpenGL
Graphics.Rendering.OpenGL.GL.Hints |  | OpenGL
Graphics.Rendering.OpenGL.GL.LineSegments |  | OpenGL
Graphics.Rendering.OpenGL.GL.PerFragment |  | OpenGL
Graphics.Rendering.OpenGL.GL.PixelRectangles |  | OpenGL

Graphics.Rendering.OpenGL.GL.PixelRectangles.ColorTable |  | OpenGL
Graphics.Rendering.OpenGL.GL.PixelRectangles.Convolution |  | OpenGL
Graphics.Rendering.OpenGL.GL.PixelRectangles.Histogram |  | OpenGL
Graphics.Rendering.OpenGL.GL.PixelRectangles.Minmax |  | OpenGL
Graphics.Rendering.OpenGL.GL.PixelRectangles.PixelMap |  | OpenGL
Graphics.Rendering.OpenGL.GL.PixelRectangles.PixelStorage |  | OpenGL
Graphics.Rendering.OpenGL.GL.PixelRectangles.PixelTransfer |  | OpenGL
Graphics.Rendering.OpenGL.GL.PixelRectangles.Rasterization |  | OpenGL

Graphics.Rendering.OpenGL.GL.Points |  | OpenGL
Graphics.Rendering.OpenGL.GL.Polygons |  | OpenGL
Graphics.Rendering.OpenGL.GL.RasterPos |  | OpenGL
Graphics.Rendering.OpenGL.GL.ReadCopyPixels |  | OpenGL
Graphics.Rendering.OpenGL.GL.Rectangles |  | OpenGL
Graphics.Rendering.OpenGL.GL.SavingState |  | OpenGL
Graphics.Rendering.OpenGL.GL.Selection |  | OpenGL
Graphics.Rendering.OpenGL.GL.Shaders |  | OpenGL
Graphics.Rendering.OpenGL.GL.StateVar |  | OpenGL
Graphics.Rendering.OpenGL.GL.StringQueries |  | OpenGL
Graphics.Rendering.OpenGL.GL.Texturing |  | OpenGL

Graphics.Rendering.OpenGL.GL.Texturing.Application |  | OpenGL
Graphics.Rendering.OpenGL.GL.Texturing.Environments |  | OpenGL
Graphics.Rendering.OpenGL.GL.Texturing.Objects |  | OpenGL
Graphics.Rendering.OpenGL.GL.Texturing.Parameters |  | OpenGL
Graphics.Rendering.OpenGL.GL.Texturing.Queries |  | OpenGL
Graphics.Rendering.OpenGL.GL.Texturing.Specification |  | OpenGL

Graphics.Rendering.OpenGL.GL.VertexArrays |  | OpenGL
Graphics.Rendering.OpenGL.GL.VertexSpec |  | OpenGL

Graphics.Rendering.OpenGL.GLU |  | OpenGL

Graphics.Rendering.OpenGL.GLU.Errors |  | OpenGL
Graphics.Rendering.OpenGL.GLU.Initialization |  | OpenGL
Graphics.Rendering.OpenGL.GLU.Matrix |  | OpenGL
Graphics.Rendering.OpenGL.GLU.Mipmapping |  | OpenGL
Graphics.Rendering.OpenGL.GLU.NURBS |  | OpenGL
Graphics.Rendering.OpenGL.GLU.Quadrics |  | OpenGL
Graphics.Rendering.OpenGL.GLU.Tessellation |  | OpenGL

Graphics.Win32 |  | Win32

Graphics.Win32.Control |  | Win32
Graphics.Win32.Dialogue |  | Win32
Graphics.Win32.GDI |  | Win32

Graphics.Win32.GDI.Bitmap |  | Win32
Graphics.Win32.GDI.Brush |  | Win32
Graphics.Win32.GDI.Clip |  | Win32
Graphics.Win32.GDI.Font |  | Win32
Graphics.Win32.GDI.Graphics2D |  | Win32
Graphics.Win32.GDI.HDC |  | Win32
Graphics.Win32.GDI.Palette |  | Win32
Graphics.Win32.GDI.Path |  | Win32
Graphics.Win32.GDI.Pen |  | Win32
Graphics.Win32.GDI.Region |  | Win32
Graphics.Win32.GDI.Types |  | Win32

Graphics.Win32.Icon |  | Win32
Graphics.Win32.Key |  | Win32
Graphics.Win32.Menu |  | Win32
Graphics.Win32.Message |  | Win32
Graphics.Win32.Misc |  | Win32
Graphics.Win32.Resource |  | Win32
Graphics.Win32.Window |  | Win32

Language |  |

Haskell |  |

Language.Haskell.Extension |  | Cabal
Language.Haskell.Parser |  | haskell-src
Language.Haskell.Pretty |  | haskell-src
Language.Haskell.Syntax |  | haskell-src
Language.Haskell.TH |  | template-haskell

Language.Haskell.TH.Lib |  | template-haskell
Language.Haskell.TH.Ppr |  | template-haskell
Language.Haskell.TH.PprLib |  | template-haskell
Language.Haskell.TH.Syntax |  | template-haskell

Network |  | network

Network.BSD |  | network
Network.CGI |  | cgi

Network.CGI.Cookie |  | cgi
Network.CGI.Monad |  | cgi
Network.CGI.Protocol |  | cgi

Network.Socket |  | network
Network.URI |  | network

Numeric |  | base
Prelude |  | base
System |  |

System.CPUTime |  | base
System.Cmd |  | base
Console |  |

System.Console.GetOpt |  | base

System.Directory |  | base
System.Environment |  | base
System.Exit |  | base
System.FilePath |  | filepath

System.FilePath.Posix |  | filepath
System.FilePath.Windows |  | filepath

System.IO |  | base

System.IO.Error |  | base
System.IO.Unsafe |  | base

System.Info |  | base
System.Locale |  | base
System.Mem |  | base

System.Mem.StableName |  | base
System.Mem.Weak |  | base

Posix |  |

System.Posix.Signals |  | base
System.Posix.Types |  | base

System.Process |  | base
System.Random |  | base
System.Time |  | base
System.Win32 |  | Win32

System.Win32.Console |  | Win32
System.Win32.DLL |  | Win32
System.Win32.DebugApi |  | Win32
System.Win32.File |  | Win32
System.Win32.FileMapping |  | Win32
System.Win32.Info |  | Win32
System.Win32.Mem |  | Win32
System.Win32.NLS |  | Win32
System.Win32.Process |  | Win32
System.Win32.Registry |  | Win32
System.Win32.SimpleMAPI |  | Win32
System.Win32.Time |  | Win32
System.Win32.Types |  | Win32

Test |  |

Test.HUnit |  | HUnit

Test.HUnit.Base |  | HUnit
Test.HUnit.Lang |  | HUnit
Test.HUnit.Terminal |  | HUnit
Test.HUnit.Text |  | HUnit

Test.QuickCheck |  | QuickCheck

Test.QuickCheck.Batch |  | QuickCheck
Test.QuickCheck.Poly |  | QuickCheck
Test.QuickCheck.Utils |  | QuickCheck

Text |  |

Text.Html |  | html

Text.Html.BlockTable |  | html

ParserCombinators |  |

Text.ParserCombinators.Parsec |  | parsec

Text.ParserCombinators.Parsec.Char |  | parsec
Text.ParserCombinators.Parsec.Combinator |  | parsec
Text.ParserCombinators.Parsec.Error |  | parsec
Text.ParserCombinators.Parsec.Expr |  | parsec
Text.ParserCombinators.Parsec.Language |  | parsec
Text.ParserCombinators.Parsec.Perm |  | parsec
Text.ParserCombinators.Parsec.Pos |  | parsec
Text.ParserCombinators.Parsec.Prim |  | parsec
Text.ParserCombinators.Parsec.Token |  | parsec

Text.ParserCombinators.ReadP |  | base
Text.ParserCombinators.ReadPrec |  | base

Text.PrettyPrint |  | base

Text.PrettyPrint.HughesPJ |  | base

Text.Printf |  | base
Text.Read |  | base

Text.Read.Lex |  | base

Text.Regex |  | regex-compat

Text.Regex.Base |  | regex-base

Text.Regex.Base.Context |  | regex-base
Text.Regex.Base.Impl |  | regex-base
Text.Regex.Base.RegexLike |  | regex-base

Text.Regex.Posix |  | regex-posix

Text.Regex.Posix.ByteString |  | regex-posix
Text.Regex.Posix.String |  | regex-posix
Text.Regex.Posix.Wrap |  | regex-posix

Text.Show |  | base

Text.Show.Functions |  | base

Text.XHtml |  | xhtml

Text.XHtml.Debug |  | xhtml
Text.XHtml.Frameset |  | xhtml
Text.XHtml.Strict |  | xhtml
Text.XHtml.Table |  | xhtml
Text.XHtml.Transitional |  | xhtml

Produced by Haddock version 0.8