Ycarus Gentoo ebuild

haskell

Ces ebuilds viennent du site https://github.com/gentoo-haskell.

Si vous avez des problemes allez sur le site officiel.

dev-haskell

abstract-deque : Abstract, parameterized interface to mutable Deques ( https://github.com/rrnewton/haskell-lockfree/wiki )

abstract-deque-tests : A test-suite for any queue or double-ended queue satisfying an interface ( https://github.com/rrnewton/haskell-lockfree/wiki )

abstract-par : Type classes generalizing the functionality of the 'monad-par' library ( https://github.com/simonmar/monad-par )

ac-angle : Angles in degrees and radians ( http://hackage.haskell.org/package/AC-Angle )

ac-vector : Efficient geometric vectors and transformations ( http://hackage.haskell.org/package/AC-Vector )

ac-vector-fancy : Fancy type-system stuff for AC-Vector ( http://hackage.haskell.org/package/AC-Vector-Fancy )

accelerate : An embedded language for accelerated array processing ( https://github.com/AccelerateHS/accelerate/ )

accelerate-cuda : Accelerate backend for NVIDIA GPUs ( https://github.com/AccelerateHS/accelerate-cuda/ )

accelerate-fft : FFT using the Accelerate library ( https://github.com/AccelerateHS/accelerate-fft )

accelerate-io : Read and write Accelerate arrays in various formats ( https://github.com/AccelerateHS/accelerate-io )

acid-state : Add ACID guarantees to any serializable Haskell data structure ( http://acid-state.seize.it/ )

action-permutations : Execute a set of actions (e.g. parsers) in each possible order ( http://hackage.haskell.org/package/action-permutations )

active : Abstractions for animation ( http://hackage.haskell.org/package/active )

ad : Automatic Differentiation ( http://github.com/ekmett/ad )

adjunctions : Adjunctions and representable functors ( http://github.com/ekmett/adjunctions/ )

aes : Fast AES encryption/decryption for bytestrings ( http://hackage.haskell.org/package/AES )

aeson : Fast JSON parsing and encoding ( https://github.com/bos/aeson )

aeson-lens : Lens of Aeson ( http://hackage.haskell.org/package/aeson-lens )

aeson-pretty : JSON pretty-printing library and command-line tool ( http://github.com/informatikr/aeson-pretty )

agata : Generator-generator for QuickCheck ( http://hackage.haskell.org/package/Agata )

alex : Alex is a tool for generating lexical analysers in Haskell ( http://www.haskell.org/alex/ )

algebra : Constructive abstract algebra ( http://github.com/ekmett/algebra/ )

allocated-processor : Functional combinators for monadic actions that require allocation and de-allocation ( http://hackage.haskell.org/package/allocated-processor )

alsa-core : Binding to the ALSA Library API (Exceptions) ( http://www.haskell.org/haskellwiki/ALSA )

alsa-mixer : Bindings to the ALSA simple mixer API ( https://github.com/ttuegel/alsa-mixer )

alsa-seq : Binding to the ALSA Library API (MIDI sequencer) ( http://www.haskell.org/haskellwiki/ALSA )

alut : A binding for the OpenAL Utility Toolkit ( https://github.com/haskell-openal/ALUT )

amqp : Client library for AMQP servers (currently only RabbitMQ) ( https://github.com/hreinhardt/amqp )

annotated-wl-pprint : The Wadler/Leijen Pretty Printer, with annotation support ( https://github.com/david-christiansen/annotated-wl-pprint )

annotations : Constructing, analyzing and destructing annotated trees ( http://hackage.haskell.org/package/Annotations )

ansi-terminal : Simple ANSI terminal support, with Windows compatibility ( https://github.com/feuerbach/ansi-terminal )

ansi-wl-pprint : The Wadler/Leijen Pretty Printer for colored ANSI terminal output ( http://github.com/batterseapower/ansi-wl-pprint )

anydbm : Interface for DBM-like database systems ( http://software.complete.org/anydbm )

appar : A simple applicative parser ( http://hackage.haskell.org/package/appar )

arithmoi : Efficient basic number-theoretic functions: Primes, powers, integer logarithms ( https://bitbucket.org/dafis/arithmoi )

arrows : Arrow classes and transformers ( http://www.haskell.org/arrows/ )

asn1-data : ASN1 data reader and writer in RAW, BER and DER forms ( http://github.com/vincenthz/hs-asn1-data )

asn1-encoding : ASN1 data reader and writer in RAW, BER and DER forms ( http://github.com/vincenthz/hs-asn1 )

asn1-parse : Simple monadic parser for ASN1 stream types ( http://github.com/vincenthz/hs-asn1 )

asn1-types : ASN.1 types ( http://github.com/vincenthz/hs-asn1-types )

astar : General A* search algorithm ( http://hackage.haskell.org/package/astar )

async : Run IO operations asynchronously and wait for their results ( https://github.com/simonmar/async )

atomic-primops : A safe approach to CAS and other atomic ops in Haskell ( https://github.com/rrnewton/haskell-lockfree/wiki )

attempt : Concrete data type for handling extensible exceptions as failures. (deprecated) ( http://github.com/snoyberg/attempt/tree/master )

atto-lisp : Efficient parsing and serialisation of S-Expressions ( http://github.com/nominolo/atto-lisp )

attobencode : Fast Bencode encoding and parsing library ( http://bitbucket.org/FlorianHartwig/attobencode )

attojson : Simple lightweight JSON parser, generator and manipulator based on ByteString ( http://github.com/konn/AttoJSON )

attoparsec : Fast combinator parsing for bytestrings and text ( https://github.com/bos/attoparsec )

attoparsec-binary : Binary processing extensions to Attoparsec ( http://hackage.haskell.org/package/attoparsec-binary )

attoparsec-conduit : Consume attoparsec parsers via conduit. (deprecated) ( http://github.com/snoyberg/conduit )

attoparsec-enumerator : Pass input from an enumerator to an Attoparsec parser ( https://john-millikin.com/software/attoparsec-enumerator/ )

attoparsec-iteratee : An adapter to convert attoparsec Parsers into blazing-fast Iteratees ( http://github.com/gregorycollins )

augeas : A Haskell FFI wrapper for the Augeas API ( http://trac.haskell.org/augeas )

authenticate : Authentication methods for Haskell web applications ( http://github.com/yesodweb/authenticate )

authenticate-kerberos : Authentication methods for Haskell web applications ( http://github.com/yesodweb/authenticate )

authenticate-oauth : Library to authenticate with OAuth for Haskell web applications ( http://github.com/yesodweb/authenticate )

auto-update : Efficiently run periodic, on-demand actions ( https://github.com/yesodweb/wai )

avltree : Balanced binary trees using the AVL algorithm ( http://hackage.haskell.org/package/AvlTree )

base-compat : A compatibility layer for base ( http://hackage.haskell.org/package/base-compat )

base-unicode-symbols : Unicode alternatives for common functions and operators ( http://haskell.org/haskellwiki/Unicode-symbols )

base16-bytestring : Fast base16 (hex) encoding and decoding for ByteStrings ( http://github.com/bos/base16-bytestring )

base64-bytestring : Fast base64 encoding and decoding for ByteStrings ( https://github.com/bos/base64-bytestring )

base64-conduit : Base64-encode and decode streams of bytes. (deprecated) ( http://github.com/snoyberg/conduit )

base64-string : Base64 implementation for String's ( http://urchin.earth.li/~ian/cabal/base64-string/ )

basic-prelude : An enhanced core prelude; a common foundation for alternate preludes ( https://github.com/snoyberg/basic-prelude )

bencode : Parser and printer for bencoded data ( http://hackage.haskell.org/package/bencode )

besout : Extended GCD of polynomials over F_p[x] ( http://hackage.haskell.org/package/besout )

bifunctors : Bifunctors ( http://github.com/ekmett/bifunctors/ )

bimap : Bidirectional mapping between two key types ( http://code.haskell.org/bimap )

binary : Binary serialisation for Haskell values using lazy ByteStrings ( https://github.com/kolmodin/binary )

binary-bits : Bit parsing/writing on top of binary ( http://hackage.haskell.org/package/binary-bits )

binary-communicator : Flexible way to ease transmission of binary data ( http://hackage.haskell.org/package/binary-communicator )

binary-conduit : data serialization/deserialization conduit library ( http://github.com/qnikst/binary-conduit )

binary-shared : Sharing for the binary package ( http://www.leksah.org )

binary-state : Simple wrapper around Data.Binary, which adds StateT to Get/Put monads ( http://hackage.haskell.org/package/binary-state )

binary-strict : Binary deserialisation using strict ByteStrings ( http://code.haskell.org/binary-low-level )

bindings-bfd : Bindings for libbfd, a library of the GNU binutils ( http://projects.haskell.org/bindings-bfd/ )

bindings-dsl : FFI domain specific language, on top of hsc2hs ( https://github.com/jwiegley/bindings-dsl/wiki )

bindings-glfw : Low-level bindings to GLFW OpenGL library ( http://hackage.haskell.org/package/bindings-GLFW )

bindings-libzip : Low level bindings to libzip ( http://bitbucket.org/astanin/hs-libzip/ )

bindings-uname : Low-level binding to POSIX uname(3) ( http://hackage.haskell.org/package/bindings-uname )

bio : A bioinformatics library ( http://biohaskell.org/Libraries/Bio )

biocore : A bioinformatics library ( http://hackage.haskell.org/package/biocore )

biofasta : Library for reading fasta sequence files ( https://patch-tag.com/r/dfornika/biofasta/home )

biosff : Library and executables for working with SFF files ( http://biohaskell.org/ )

bits-atomic : Atomic bit operations on memory location ( http://hackage.haskell.org/package/bits-atomic )

bitset : A space-efficient set data structure ( http://hackage.haskell.org/package/bitset )

bitsyntax : A module to aid in the (de)serialisation of binary data ( http://www.imperialviolet.org/bitsyntax )

bktrees : A set data structure with approximate searching ( http://hackage.haskell.org/package/bktrees )

blaze-builder : Efficient buffered output ( http://github.com/meiersi/blaze-builder )

blaze-builder-conduit : Convert streams of builders to streams of bytestrings. (deprecated) ( http://github.com/snoyberg/conduit )

blaze-builder-enumerator : Enumeratees for the incremental conversion of builders to bytestrings ( https://github.com/meiersi/blaze-builder-enumerator )

blaze-html : A blazingly fast HTML combinator library for Haskell ( http://jaspervdj.be/blaze )

blaze-markup : A blazingly fast markup combinator library for Haskell ( http://jaspervdj.be/blaze )

blaze-svg : SVG combinator library ( https://github.com/deepakjois/blaze-svg )

blaze-textual : Fast rendering of common datatypes ( http://github.com/bos/blaze-textual )

bloomfilter : Pure and impure Bloom Filter implementations ( https://github.com/bos/bloomfilter )

bmp : Read and write uncompressed BMP image files ( http://code.ouroborus.net/bmp )

boolean : Generalized booleans and numbers ( http://hackage.haskell.org/package/Boolean )

bound : Making de Bruijn Succ Less ( http://github.com/ekmett/bound/ )

boundedchan : Implementation of bounded channels ( http://hackage.haskell.org/package/BoundedChan )

boxes : 2D text pretty-printing library ( http://hackage.haskell.org/package/boxes )

bson : BSON documents are JSON-like objects with a standard binary encoding ( http://github.com/mongodb-haskell/bson )

buildwrapper : A library and an executable that provide an easy API for a Haskell IDE ( https://github.com/JPMoresmau/BuildWrapper )

buster : Almost but not quite entirely unlike FRP ( http://vis.renci.org/jeff/buster )

byteable : Type class for sequence of bytes ( http://github.com/vincenthz/hs-byteable )

bytedump : Flexible byte dump helpers for human readers ( http://github.com/vincenthz/hs-bytedump )

byteorder : Exposes the native endianness or byte ordering of the system ( http://community.haskell.org/~aslatter/code/byteorder )

bytes : Sharing code for serialization between binary and cereal ( http://github.com/analytics/bytes )

bytestring-lexing : Parse and produce literals efficiently from strict or lazy bytestrings ( http://code.haskell.org/~wren/ )

bytestring-mmap : mmap support for strict ByteStrings ( http://code.haskell.org/~dons/code/bytestring-mmap/ )

bytestring-nums : Parse numeric literals from ByteStrings ( http://github.com/solidsnack/bytestring-nums )

bytestring-show : Efficient conversion of values into readable byte strings ( http://code.haskell.org/~dolio/ )

bytestring-trie : An efficient finite map from (byte)strings to values ( http://code.haskell.org/~wren/ )

bzlib : Compression and decompression in the bzip2 format ( http://hackage.haskell.org/package/bzlib )

c10k : C10k server library using prefork ( http://github.com/kazu-yamamoto/c10k )

c2hs : C-Haskell FFI tool that gives some cross-language type safety ( https://github.com/haskell/c2hs )

cabal : A framework for packaging Haskell software ( http://www.haskell.org/cabal/ )

cabal-db : query tools for the local cabal database ( http://github.com/vincenthz/cabal-db )

cabal-dev : Manage sandboxed Haskell build environments ( http://github.com/creswick/cabal-dev )

cabal-file-th : Template Haskell expressions for reading fields from a project's cabal file ( http://github.com/nkpart/cabal-file-th )

cabal-install : The command-line interface for Cabal and Hackage ( http://www.haskell.org/cabal/ )

cabal-macosx : Cabal support for creating Mac OSX application bundles ( http://github.com/gimbo/cabal-macosx )

cabal-meta : build multiple packages at once ( http://www.yesodweb.com/ )

cabal-src : Alternative install procedure to avoid the diamond dependency issue ( https://github.com/yesodweb/cabal-src )

cairo : Binding to the Cairo library ( http://projects.haskell.org/gtk2hs/ )

canonical-filepath : Abstract data type for canonical file paths ( http://github.com/nominolo/canonical-filepath )

capri : A simple wrapper over cabal-install to operate in project-private mode ( http://hackage.haskell.org/package/capri )

cascading : DSL for HTML CSS (Cascading Style Sheets) ( http://hackage.haskell.org/package/cascading )

case-insensitive : Case insensitive string comparison ( https://github.com/basvandijk/case-insensitive )

cassava : A CSV parsing and encoding library ( https://github.com/tibbe/cassava )

categories : Categories ( http://github.com/ekmett/categories )

category-extras : A meta-package documenting various packages inspired by category theory ( http://comonad.com/reader/ )

cautious-file : Ways to write a file cautiously, reducing e.g. the chances of data loss due to crashes ( http://hackage.haskell.org/package/cautious-file )

cc-delcont : Delimited continuations and dynamically scoped variables ( http://code.haskell.org/~dolio/CC-delcont )

cereal : A binary serialization library ( http://hackage.haskell.org/package/cereal )

cereal-conduit : Turn Data.Serialize Gets and Puts into Sources, Sinks, and Conduits ( https://github.com/snoyberg/conduit )

certificate : Certificates and Key Reader/Writer ( http://github.com/vincenthz/hs-certificate )

cgi : A library for writing CGI programs ( https://github.com/cheecheeo/haskell-cgi )

charset : Fast unicode character sets based on complemented PATRICIA tries ( http://github.com/ekmett/charset )

chart : A library for generating 2D Charts and Plots ( https://github.com/timbod7/haskell-chart/wiki )

chart-cairo : Cairo backend for Charts ( https://github.com/timbod7/haskell-chart/wiki )

chart-gtk : Utility functions for using the chart library with GTK ( https://github.com/timbod7/haskell-chart/wiki )

chart-simple : Wrapper for the chart library to assist with basic plots (Deprecated - use the Easy module instead) ( https://github.com/timbod7/haskell-chart/wiki )

chaselev-deque : Chase and Lev work-stealing lock-free double-ended queues (deques) ( https://github.com/rrnewton/haskell-lockfree/wiki )

chasingbottoms : For testing partial and infinite values ( http://hackage.haskell.org/package/ChasingBottoms )

cheapskate : Experimental markdown processor ( http://github.com/jgm/cheapskate )

checkers : Check properties on standard classes and data structures ( http://hackage.haskell.org/package/checkers )

chell : A simple and intuitive library for automated testing ( https://john-millikin.com/software/chell/ )

chell-quickcheck : QuickCheck support for the Chell testing library ( https://john-millikin.com/software/chell/ )

chunked-data : Typeclasses for dealing with various chunked data representations ( https://github.com/fpco/chunked-data )

cipher-aes : Fast AES cipher implementation with advanced mode of operations ( http://github.com/vincenthz/hs-cipher-aes )

cipher-aes128 : AES and common modes using AES-NI when available ( https://github.com/TomMD/cipher-aes128 )

cipher-blowfish : Blowfish cipher ( http://github.com/vincenthz/hs-crypto-cipher )

cipher-camellia : Camellia block cipher primitives ( http://github.com/vincenthz/hs-crypto-cipher )

cipher-des : DES and 3DES primitives ( http://github.com/vincenthz/hs-crypto-cipher )

cipher-rc4 : Fast RC4 cipher implementation ( http://github.com/vincenthz/hs-cipher-rc4 )

circle-packing : Simple heuristic for packing discs of varying radii in a circle ( http://hackage.haskell.org/package/circle-packing )

citeproc-hs : A Citation Style Language implementation in Haskell ( http://gorgias.mine.nu/repos/citeproc-hs/ )

classify : Library for classification of media files ( http://hackage.haskell.org/package/classify )

classy-prelude : A typeclass-based Prelude ( https://github.com/snoyberg/classy-prelude )

classy-prelude-conduit : conduit instances for classy-prelude ( https://github.com/snoyberg/classy-prelude )

clay : CSS preprocessor as embedded Haskell ( http://fvisser.nl/clay )

clevercss : A CSS preprocessor ( http://sandbox.pocoo.org/clevercss-hs/ )

clientsession : Securely store session data in a client-side cookie ( http://github.com/yesodweb/clientsession/tree/master )

clock : High-resolution clock functions: monotonic, realtime, cputime ( http://corsis.github.com/clock/ )

clocked : timer functionality to clock IO commands ( http://patch-tag.com/r/shahn/clocked/home )

cmdargs : Command line argument processing ( http://community.haskell.org/~ndm/cmdargs/ )

cmdlib : a library for command line parsing and online help ( http://hackage.haskell.org/package/cmdlib )

cmdtheline : Declarative command-line option parsing and documentation library ( http://github.com/eli-frey/cmdtheline )

codec-compression-lzf : LZF compression bindings ( http://www.cs.helsinki.fi/u/ekarttun/Codec-Compression-LZF/ )

codec-image-devil : An FFI interface to the DevIL library ( http://hackage.haskell.org/package/Codec-Image-DevIL )

colock : thread-friendly file locks that don't block the entire program ( http://hackage.haskell.org/package/colock )

colorize-haskell : Highligt Haskell source ( http://github.com/yav/colorize-haskell )

colour : A model for human colour/color perception ( http://www.haskell.org/haskellwiki/Colour )

command-qq : Quasiquoters for external commands ( http://biegunka.github.io/command-qq/ )

comonad : Comonads ( http://github.com/ekmett/comonad/ )

comonad-extras : Exotic comonad transformers ( http://github.com/ekmett/comonad-extras/ )

comonad-transformers : This package has been merged into comonad 4.0 ( http://github.com/ekmett/comonad-transformers/ )

comonads-fd : This package has been merged into comonad 4.0 ( http://github.com/ekmett/comonads-fd/ )

compact-string-fix : Same as compact-string except with a small fix so it builds on ghc-6.12 ( http://twan.home.fmf.nl/compact-string/ )

composition : Combinators for unorthodox function composition ( http://patch-tag.com/r/DanBurton/composition/home )

concatenative : A library for postfix control flow ( https://patch-tag.com/r/salazar/concatenative/snapshot/current/content/pretty )

concrete-typerep : Binary and Hashable instances for TypeRep ( http://hackage.haskell.org/package/concrete-typerep )

concurrent-extra : Extra concurrency primitives ( https://github.com/basvandijk/concurrent-extra )

concurrent-split : MVars and Channels with distinguished input and output side ( http://hackage.haskell.org/package/concurrent-split )

concurrentoutput : Ungarble output from several threads ( http://hackage.haskell.org/package/concurrentoutput )

cond : Basic conditional and boolean operators with monadic variants ( https://github.com/kallisti-dev/cond )

conduit : Streaming data processing library ( http://github.com/snoyberg/conduit )

conduit-combinators : Commonly used conduit functions, for both chunked and unchunked data ( https://github.com/fpco/conduit-combinators )

conduit-extra : Batteries included conduit: adapters for common libraries ( http://github.com/snoyberg/conduit )

configfile : Configuration file reading and writing ( http://software.complete.org/configfile )

configurator : Configuration management ( http://github.com/bos/configurator )

connection : Simple and easy network connections API ( http://github.com/vincenthz/hs-connection )

constraints : Constraint manipulation ( http://github.com/ekmett/constraints/ )

containers-unicode-symbols : Unicode alternatives for common functions and operators ( http://haskell.org/haskellwiki/Unicode-symbols )

continued-fractions : Continued fractions ( /dev/null )

contravariant : Contravariant functors ( http://github.com/ekmett/contravariant/ )

control-monad-exception : Explicitly typed, checked exceptions with stack traces ( http://pepeiborra.github.io/control-monad-exception/ )

control-monad-free : Free monads and monad transformers ( http://github.com/pepeiborra/control-monad-free )

control-monad-loop : Simple monad transformer for imperative-style loops ( https://github.com/joeyadams/haskell-control-monad-loop )

control-timeout : Timeout handling ( http://hackage.haskell.org/package/control-timeout )

converge : Limit operations for converging sequences ( http://hackage.haskell.org/package/converge )

convertible : Typeclasses and instances for converting between types ( http://hackage.haskell.org/cgi-bin/hackage-scripts/package/convertible )

cookie : HTTP cookie parsing and rendering ( http://github.com/snoyberg/cookie )

cordering : An algebraic data type similar to Prelude Ordering ( http://hackage.haskell.org/package/COrdering )

cpphs : A liberalised re-implementation of cpp, the C pre-processor ( http://projects.haskell.org/cpphs/ )

cprng-aes : Crypto Pseudo Random Number Generator using AES in counter mode ( http://github.com/vincenthz/hs-cprng-aes )

cpu : Cpu information and properties helpers ( http://github.com/vincenthz/hs-cpu )

crack : A haskell binding to cracklib ( http://hackage.haskell.org/package/crack )

crc16 : Calculate the crc16-ccitt ( http://hackage.haskell.org/package/crc16 )

criterion : Robust, reliable performance measurement and analysis ( https://github.com/bos/criterion )

crockford : An implementation of Douglas Crockford's base32 encoding ( http://hackage.haskell.org/package/crockford )

crypto : Collects together existing Haskell cryptographic functions into a package ( http://hackage.haskell.org/package/Crypto )

crypto-api : A generic interface for cryptographic operations ( https://github.com/TomMD/crypto-api )

crypto-api-tests : A test framework and KATs for cryptographic operations ( http://trac.haskell.org/crypto-api/wiki )

crypto-cipher-tests : Generic cryptography cipher tests ( http://github.com/vincenthz/hs-crypto-cipher )

crypto-cipher-types : Generic cryptography cipher types ( http://github.com/vincenthz/hs-crypto-cipher )

crypto-conduit : Conduit interface for cryptographic operations (from crypto-api) ( https://github.com/prowdsponsor/crypto-conduit )

crypto-numbers : Cryptographic numbers: functions and algorithms ( http://github.com/vincenthz/hs-crypto-numbers )

crypto-pubkey : Public Key cryptography ( http://github.com/vincenthz/hs-crypto-pubkey )

crypto-pubkey-types : Generic cryptography Public keys algorithm types ( http://github.com/vincenthz/hs-crypto-pubkey-types )

crypto-random : Simple cryptographic random related types ( http://github.com/vincenthz/hs-crypto-random )

crypto-random-api : Simple random generators API for cryptography related code ( http://github.com/vincenthz/hs-crypto-random-api )

cryptocipher : Symmetrical block and stream ciphers ( http://github.com/vincenthz/hs-crypto-cipher )

cryptohash : collection of crypto hashes, fast, pure and practical ( http://github.com/vincenthz/hs-cryptohash )

cryptohash-conduit : cryptohash conduit ( http://github.com/vincenthz/hs-cryptohash-conduit )

cryptohash-cryptoapi : Crypto-api interfaces for cryptohash ( http://github.com/vincenthz/hs-cryptohash-cryptoapi )

css-text : CSS parser and renderer ( http://www.yesodweb.com/ )

csv : CSV loader and dumper ( http://hackage.haskell.org/package/csv )

cuda : FFI binding to the CUDA interface for programming NVIDIA GPUs ( https://github.com/tmcdonell/cuda )

cufft : Haskell bindings for the CUFFT library ( http://github.com/robeverest/cufft )

curl : Haskell binding to libcurl ( http://hackage.haskell.org/package/curl )

cyclotomic : A subfield of the complex numbers for exact calculation ( http://hackage.haskell.org/package/cyclotomic )

data-accessor : Utilities for accessing and manipulating fields of records ( http://www.haskell.org/haskellwiki/Record_access )

data-accessor-monads-fd : Use Accessor to access state in monads-fd State monad class ( http://www.haskell.org/haskellwiki/Record_access )

data-accessor-mtl : Use Accessor to access state in mtl State monad class ( http://www.haskell.org/haskellwiki/Record_access )

data-accessor-template : Utilities for accessing and manipulating fields of records ( http://www.haskell.org/haskellwiki/Record_access )

data-accessor-transformers : Use Accessor to access state in transformers State monad ( http://www.haskell.org/haskellwiki/Record_access )

data-binary-ieee754 : Parser/Serialiser for IEEE-754 floating-point values ( https://john-millikin.com/software/data-binary-ieee754/ )

data-default : A class for types with a default value ( http://hackage.haskell.org/package/data-default )

data-default-class : A class for types with a default value ( http://hackage.haskell.org/package/data-default-class )

data-default-instances-base : Default instances for types in base ( http://hackage.haskell.org/package/data-default-instances-base )

data-default-instances-containers : Default instances for types in containers ( http://hackage.haskell.org/package/data-default-instances-containers )

data-default-instances-dlist : Default instances for types in dlist ( http://hackage.haskell.org/package/data-default-instances-dlist )

data-default-instances-old-locale : Default instances for types in old-locale ( http://hackage.haskell.org/package/data-default-instances-old-locale )

data-endian : Endian-sensitive data ( https://github.com/mvv/data-endian )

data-flags : A package for working with bit masks and flags in general ( http://hackage.haskell.org/package/data-flags )

data-hash : Combinators for building fast hashing functions ( http://hackage.haskell.org/package/data-hash )

data-inttrie : A lazy, infinite trie of integers ( http://github.com/luqui/data-inttrie )

data-lens : Used to be Haskell 98 Lenses ( http://github.com/roconnor/data-lens/ )

data-lens-fd : Lenses ( http://github.com/roconnor/data-lens-fd/ )

data-lens-ixset : A Lens for IxSet ( https://github.com/dag/data-lens-ixset )

data-lens-light : Simple lenses, minimum dependencies ( https://github.com/feuerbach/data-lens-light )

data-lens-template : Utilities for Data.Lens ( http://github.com/roconnor/data-lens-template/ )

data-memocombinators : Combinators for building memo tables ( http://github.com/luqui/data-memocombinators )

data-ordlist : Set and bag operations on ordered lists ( http://hackage.haskell.org/package/data-ordlist )

data-pprint : Prettyprint and compare Data values ( http://hackage.haskell.org/package/data-pprint )

data-reify : Reify a recursive data structure into an explicit graph ( http://www.ittc.ku.edu/csdl/fpg/Tools/IOReification )

dataenc : Data encoding library ( http://www.haskell.org/haskellwiki/Library/Data_encoding )

date-cache : Date cacher ( http://hackage.haskell.org/package/date-cache )

datetime : Utilities to make Data.Time.* easier to use ( http://github.com/esessoms/datetime )

dav : RFC 4918 WebDAV support ( http://floss.scru.org/hDAV )

dbus : A client library for the D-Bus IPC system ( https://john-millikin.com/software/haskell-dbus/ )

dbus-client : Monadic and object-oriented interfaces to DBus ( http://john-millikin.com/software/haskell-dbus/ )

dbus-core : Low-level D-Bus protocol implementation ( https://john-millikin.com/software/dbus-core/ )

decimal : Decimal numbers with variable precision ( https://github.com/PaulJohnson/Haskell-Decimal )

deepseq : Deep evaluation of data structures ( http://hackage.haskell.org/package/deepseq )

deepseq-generics : GHC.Generics-based Control.DeepSeq.rnf implementation ( https://github.com/hvr/deepseq-generics )

dependent-map : Dependent finite maps (partial dependent products) ( https://github.com/mokus0/dependent-map )

dependent-sum : Dependent sum type ( https://github.com/mokus0/dependent-sum )

dependent-sum-template : Template Haskell code to generate instances of classes in dependent-sum package ( /dev/null )

derive : A program and library to derive instances for data types ( http://community.haskell.org/~ndm/derive/ )

diagrams : Embedded domain-specific language for declarative vector graphics ( http://projects.haskell.org/diagrams )

diagrams-builder : hint-based build service for the diagrams graphics EDSL ( http://projects.haskell.org/diagrams )

diagrams-cairo : Cairo backend for diagrams drawing EDSL ( http://projects.haskell.org/diagrams )

diagrams-contrib : Collection of user contributions to diagrams EDSL ( http://projects.haskell.org/diagrams/ )

diagrams-core : Core libraries for diagrams EDSL ( http://projects.haskell.org/diagrams )

diagrams-gtk : Backend for rendering diagrams directly to GTK windows ( http://projects.haskell.org/diagrams/ )

diagrams-lib : Embedded domain-specific language for declarative graphics ( http://projects.haskell.org/diagrams )

diagrams-postscript : Postscript backend for diagrams drawing EDSL ( http://projects.haskell.org/diagrams/ )

diagrams-rasterific : Rasterific backend for diagrams ( http://projects.haskell.org/diagrams/ )

diagrams-svg : SVG backend for diagrams drawing EDSL ( http://projects.haskell.org/diagrams/ )

dice : Simplistic DandD style dice-rolling system ( http://hackage.haskell.org/package/dice )

diff : O(ND) diff algorithm in haskell ( http://hackage.haskell.org/package/Diff )

diffarray : DiffArray ( http://hackage.haskell.org/package/diffarray )

digest : Various cryptographic hashes for bytestrings; CRC32 and Adler32 for now ( http://hackage.haskell.org/package/digest )

digestive-functors : A practical formlet library ( http://github.com/jaspervdj/digestive-functors )

digestive-functors-blaze : Blaze frontend for the digestive-functors library ( http://github.com/jaspervdj/digestive-functors )

digestive-functors-happstack : Happstack backend for the digestive-functors library ( http://github.com/jaspervdj/digestive-functors )

digestive-functors-snap : Snap backend for the digestive-functors library ( http://github.com/jaspervdj/digestive-functors )

digits : Converts integers to lists of digits and back ( http://hackage.haskell.org/package/digits )

dimensional : Statically checked physical dimensions ( http://dimensional.googlecode.com/ )

direct-plugins : Lightweight replacement for Plugins, specific to GHC ( http://dankna.com/software/ )

direct-sqlite : Low-level binding to SQLite3. Includes UTF8 and BLOB support ( https://github.com/IreneKnapp/direct-sqlite )

directory-layout : Directory layout DSL ( http://hackage.haskell.org/package/directory-layout )

directory-tree : A simple directory-like tree datatype, with useful IO functions ( http://brandon.si/code/directory-tree-module-released/ )

disassembler : Disassembler for X86 and AMD64 machine code ( http://hackage.haskell.org/package/disassembler )

distributed-process : Cloud Haskell: Erlang-style concurrency in Haskell ( http://github.com/haskell-distributed/distributed-process )

distributed-process-simplelocalnet : Simple zero-configuration backend for Cloud Haskell ( http://github.com/haskell-distributed/distributed-process )

distributed-static : Compositional, type-safe, polymorphic static values and closures ( http://www.github.com/haskell-distributed/distributed-process )

distributive : Distributive functors -- Dual to Traversable ( http://github.com/ekmett/distributive/ )

djinn : Generate Haskell code from a type ( http://hackage.haskell.org/package/djinn )

djinn-ghc : Generate Haskell code from a type. Bridge from Djinn to GHC API ( http://hackage.haskell.org/package/djinn-ghc )

djinn-lib : Generate Haskell code from a type. Library extracted from djinn package ( http://www.augustsson.net/Darcs/Djinn/ )

dlist : Difference lists ( https://github.com/spl/dlist )

dlist-instances : Difference lists instances ( https://github.com/gregwebs/dlist-instances )

dns : DNS library in Haskell ( http://hackage.haskell.org/package/dns )

doctest : Test interactive Haskell examples ( https://github.com/sol/doctest#readme )

dotgen : A simple interface for building .dot graph files ( http://hackage.haskell.org/package/dotgen )

double-conversion : Fast conversion between double precision floating point and text ( https://github.com/bos/double-conversion )

download-curl : High-level file download based on URLs ( http://code.haskell.org/~dons/code/download-curl )

dph-base : Data Parallel Haskell common config and debugging functions ( http://www.haskell.org/haskellwiki/GHC/Data_Parallel_Haskell )

dph-lifted-base : Data Parallel Haskell common definitions used by other dph-lifted packages ( http://www.haskell.org/haskellwiki/GHC/Data_Parallel_Haskell )

dph-lifted-copy : Data Parallel Haskell lifted array combinators. (deprecated version) ( http://www.haskell.org/haskellwiki/GHC/Data_Parallel_Haskell )

dph-lifted-vseg : Data Parallel Haskell lifted array combinators ( http://www.haskell.org/haskellwiki/GHC/Data_Parallel_Haskell )

dph-prim-interface : Data Parallel Haskell segmented arrays. (abstract interface) ( http://www.haskell.org/haskellwiki/GHC/Data_Parallel_Haskell )

dph-prim-par : Data Parallel Haskell segmented arrays. (production version) ( http://www.haskell.org/haskellwiki/GHC/Data_Parallel_Haskell )

dph-prim-seq : Data Parallel Haskell segmented arrays. (sequential implementation) ( http://www.haskell.org/haskellwiki/GHC/Data_Parallel_Haskell )

drbg : Deterministic random bit generator (aka RNG, PRNG) based HMACs, Hashes, and Ciphers ( http://hackage.haskell.org/package/DRBG )

drift : Program to derive type class instances ( http://repetae.net/computer/haskell/DrIFT/ )

dsp : Haskell Digital Signal Processing ( http://www.haskell.org/haskellwiki/DSP )

dual-tree : Rose trees with cached and accumulating monoidal annotations ( http://hackage.haskell.org/package/dual-tree )

dyre : Dynamic reconfiguration in Haskell ( http://github.com/willdonnelly/dyre )

easy-file : Cross-platform File handling ( http://github.com/kazu-yamamoto/easy-file )

edisonapi : A library of efficent, purely-functional data structures (API) ( http://rwd.rdockins.name/edison/home/ )

edisoncore : A library of efficent, purely-functional data structures (Core Implementations) ( http://rwd.rdockins.name/edison/home/ )

edit-distance : Levenshtein and restricted Damerau-Levenshtein edit distances ( http://github.com/batterseapower/edit-distance )

editline : Bindings to the editline library (libedit) ( http://code.haskell.org/editline )

either : An either monad transformer ( http://github.com/ekmett/either/ )

either-unwrap : Functions for probing and unwrapping values inside of Either ( http://github.com/gcross/either-unwrap )

eithert : EitherT monad transformer ( http://hackage.haskell.org/package/EitherT )

ekg : Remote monitoring of processes ( https://github.com/tibbe/ekg )

ekg-core : Tracking of system metrics ( https://github.com/tibbe/ekg-core )

email-validate : Validating an email address string against RFC 5322 ( http://porg.es/blog/email-address-validation-simpler-faster-more-correct )

enclosed-exceptions : Catching all exceptions from within an enclosed computation ( https://github.com/jcristovao/enclosed-exceptions )

encoding : A library for various character encodings ( http://code.haskell.org/encoding/ )

entropy : A platform independent entropy source ( https://github.com/TomMD/entropy )

enumerator : Reliable, high-performance processing with left-fold enumerators ( https://john-millikin.com/software/enumerator/ )

enumset : Sets of enumeration values represented by machine words ( http://hackage.haskell.org/package/enumset )

equivalence : Maintaining an equivalence relation implemented as union-find using STT ( https://bitbucket.org/paba/equivalence/ )

erf : The error function, erf, and related functions ( http://hackage.haskell.org/package/erf )

errorcall-eq-instance : An orphan Eq instance for ErrorCall ( http://hackage.haskell.org/package/errorcall-eq-instance )

errors : Simplified error-handling ( http://hackage.haskell.org/package/errors )

esqueleto : Type-safe EDSL for SQL queries on persistent backends ( https://github.com/prowdsponsor/esqueleto )

etherbunny : A network analysis toolkit for Haskell ( http://etherbunny.anytini.com/ )

event-list : Event lists with relative or absolute time stamps ( http://code.haskell.org/~thielema/event-list/ )

exception-mtl : Exception monad transformer instances for mtl2 classes ( http://www.cs.drexel.edu/~mainland/ )

exception-transformers : Type classes and monads for unchecked extensible exceptions ( http://www.cs.drexel.edu/~mainland/ )

exceptions : Extensible optionally-pure exceptions ( http://github.com/ekmett/exceptions/ )

executable-path : Finding out the full path of the executable ( http://code.haskell.org/~bkomuves/ )

exif : A Haskell binding to a subset of libexif ( http://hackage.haskell.org/package/exif )

exists : Existential datatypes holding evidence of constraints ( http://github.com/glehel/exists )

explicit-exception : Exceptions which are explicit in the type signature ( http://www.haskell.org/haskellwiki/Exception )

extensible-effects : An Alternative to Monad Transformers ( https://github.com/RobotGymnast/extensible-effects )

extensible-exceptions : Extensible exceptions ( http://hackage.haskell.org/package/extensible-exceptions )

extra : A grab bag of modules ( http://src.seereason.com/haskell-extra )

failure : A simple type class for success/failure computations. (deprecated) ( http://www.haskell.org/haskellwiki/Failure )

fast-logger : A fast logging system ( http://hackage.haskell.org/package/fast-logger )

fastcgi : A Haskell library for writing FastCGI programs ( http://hackage.haskell.org/package/fastcgi )

fastirc : Fast Internet Relay Chat (IRC) library ( http://hackage.haskell.org/package/fastirc )

fay : A compiler for Fay, a Haskell subset that compiles to JavaScript ( https://github.com/faylang/fay/wiki )

fay-base : The base package for Fay ( https://github.com/faylang/fay-base )

fay-jquery : jQuery bindings for Fay ( https://github.com/faylang/fay-jquery )

fay-text : Fay Text type represented as JavaScript strings ( https://github.com/faylang/fay-text )

fb : Bindings to Facebook's API ( https://github.com/prowdsponsor/fb )

fclabels : First class accessor labels implemented as lenses ( https://github.com/sebastiaanvisser/fclabels )

fdo-trash : Utilities related to freedesktop Trash standard ( https://github.com/jkarlson/fdo-trash )

fec : Forward error correction of ByteStrings ( http://allmydata.org/source/zfec )

feed : Interfacing with RSS (v 0.9x, 2.x, 1.0) + Atom feeds ( https://github.com/sof/feed )

fgl : Martin Erwig's Functional Graph Library ( http://web.engr.oregonstate.edu/~erwig/fgl/haskell )

file-embed : Use Template Haskell to embed file contents directly ( https://github.com/snoyberg/file-embed )

file-location : common functions that show file location information ( https://github.com/gregwebs/FileLocation.hs )

filemanip : Expressive file and directory manipulation for Haskell ( https://github.com/bos/filemanip )

filestore : Interface for versioning file stores ( http://hackage.haskell.org/package/filestore )

filesystem-conduit : Use system-filepath data types with conduits. (deprecated) ( http://github.com/snoyberg/conduit )

findbin : Locate directory of original program ( https://github.com/audreyt/findbin )

fingertree : Generic finger-tree structure, with example instances ( http://hackage.haskell.org/package/fingertree )

finite-field : Finite Fields ( http://hackage.haskell.org/package/finite-field )

fixed-vector : Generic vectors with statically known size ( http://hackage.haskell.org/package/fixed-vector )

fixplate : Uniplate-style generic traversals for optionally annotated fixed-point types ( http://code.haskell.org/~bkomuves/ )

flexible-defaults : Generate default function implementations for complex type classes ( https://github.com/mokus0/flexible-defaults )

flock : Wrapper for flock(2) ( http://github.com/hesselink/flock )

flow2dot : Library and binary to generate sequence/flow diagrams from plain text source ( http://adept.linux.kiev.ua:8080/repos/flow2dot )

fluent-logger : A structured logger for Fluentd (Haskell) ( http://hackage.haskell.org/package/fluent-logger )

fluent-logger-conduit : Conduit interface for fluent-logger ( http://hackage.haskell.org/package/fluent-logger-conduit )

fmlist : FoldMap lists ( http://hackage.haskell.org/package/fmlist )

foldl : Composable, streaming, and efficient left folds ( http://hackage.haskell.org/package/foldl )

fontyfruity : A true type file format loader ( http://hackage.haskell.org/package/FontyFruity )

force-layout : Simple force-directed layout ( http://hackage.haskell.org/package/force-layout )

free : Monads for free ( http://github.com/ekmett/free/ )

frown : A parser generator for Haskell ( http://www.informatik.uni-bonn.de/~ralf/frown/ )

fsnotify : Cross platform library for file change notification ( http://hackage.haskell.org/package/fsnotify )

fst : Finite state transducers ( http://www.cse.chalmers.se/alumni/markus/fstStudio/ )

ftgl : Portable TrueType font rendering for OpenGL using the Freetype2 library ( http://hackage.haskell.org/package/FTGL )

ftphs : FTP Client and Server Library ( https://github.com/jgoerzen/ftphs/wiki )

funcmp : Functional MetaPost ( http://savannah.nongnu.org/projects/funcmp/ )

gamma : Gamma function and related functions ( https://github.com/mokus0/gamma )

gconf : Binding to the GNOME configuration database system ( http://projects.haskell.org/gtk2hs/ )

gd : A Haskell binding to a subset of the GD graphics library ( http://hackage.haskell.org/package/gd )

generic-deriving : Generic programming library for generalised deriving ( http://hackage.haskell.org/package/generic-deriving )

geniplate : Use Template Haskell to generate Uniplate-like functions ( http://hackage.haskell.org/package/geniplate )

gf : Grammatical Framework ( http://www.grammaticalframework.org/ )

ghc-api : The Glasgow Haskell Compiler API (ghc package) ( http://www.haskell.org/ghc )

ghc-core : Display GHC's core and assembly output in a pager ( https://github.com/shachaf/ghc-core )

ghc-events : Library and tool for parsing .eventlog files from GHC ( http://hackage.haskell.org/package/ghc-events )

ghc-gc-tune : Graph performance of Haskell programs with different GC flags ( http://code.haskell.org/~dons/code/ghc-gc-tune )

ghc-heap-view : Extract the heap representation of Haskell values and thunks ( http://hackage.haskell.org/package/ghc-heap-view )

ghc-mtl : An mtl compatible version of the Ghc-Api monads and monad-transformers ( http://darcsden.com/jcpetruzza/ghc-mtl )

ghc-parmake : A parallel wrapper for 'ghc --make' ( https://github.com/23Skidoo/ghc-parmake )

ghc-parser : Haskell source parser from GHC ( https://github.com/gibiansky/IHaskell )

ghc-paths : Knowledge of GHC's installation directories ( http://hackage.haskell.org/package/ghc-paths )

ghc-syb : Data and Typeable instances for the GHC API ( http://github.com/nominolo/ghc-syb )

ghc-syb-utils : Scrap Your Boilerplate utilities for the GHC API ( http://github.com/nominolo/ghc-syb )

ghc-vis : Live visualization of data structures in GHCi ( http://felsin9.de/nnis/ghc-vis )

ghci-lib : A library for interactively evaluating Haskell code ( http://github.com/gibiansky/IHaskell )

ghcjs-codemirror : Installs CodeMirror JavaScript files ( https://github.com/ghcjs/CodeMirror )

ghcjs-dom : DOM library that supports both GHCJS and WebKitGTK ( http://hackage.haskell.org/package/ghcjs-dom )

gio : Binding to the GIO ( http://projects.haskell.org/gtk2hs/ )

glade : Binding to the glade library ( http://projects.haskell.org/gtk2hs/ )

glfw : A Haskell binding for GLFW ( http://haskell.org/haskellwiki/GLFW )

glfw-b : Bindings to GLFW OpenGL library ( http://hackage.haskell.org/package/GLFW-b )

glib : Binding to the GLIB library for Gtk2Hs ( http://projects.haskell.org/gtk2hs/ )

glob : Globbing library ( http://iki.fi/matti.niemenmaa/glob/ )

gloss : Painless 2D vector graphics, animations and simulations ( http://gloss.ouroborus.net )

gloss-examples : Examples using the gloss library ( http://gloss.ouroborus.net )

gloss-juicy : Load any image supported by Juicy.Pixels in your gloss application ( http://github.com/alpmestan/gloss-juicy )

gloss-raster : Parallel rendering of raster images ( http://gloss.ouroborus.net )

glpk-hs : Comprehensive GLPK linear programming bindings ( http://hackage.haskell.org/package/glpk-hs )

gluraw : A raw binding for the OpenGL graphics system ( http://www.haskell.org/haskellwiki/Opengl )

glut : A binding for the OpenGL Utility Toolkit ( http://www.haskell.org/haskellwiki/Opengl )

glutil : Miscellaneous OpenGL utilities ( http://hackage.haskell.org/package/GLUtil )

gnuidn : Bindings for GNU IDN ( https://john-millikin.com/software/haskell-gnuidn/ )

gnuplot : 2D and 3D plots using gnuplot ( http://www.haskell.org/haskellwiki/Gnuplot )

gnutls : Bindings for GNU libgnutls ( https://john-millikin.com/software/haskell-gnutls/ )

goa : GHCi on Acid is an extension to GHCi (Interactive GHC) for adding useful lambdabot features ( http://haskell.org/haskellwiki/GHC/GHCi#GHCi_on_Acid )

googlesuggest : Interface to Google Suggest API ( http://hackage.haskell.org/package/GoogleSuggest )

googletranslate : Interface to Google Translate API ( http://hackage.haskell.org/package/GoogleTranslate )

graphalyze : Graph-Theoretic Analysis library ( http://hackage.haskell.org/package/Graphalyze )

graphmod : Present the module dependencies of a program as a \"dot\" graph ( http://github.com/yav/graphmod/wiki )

graphscc : Tarjan's algorithm for computing the strongly connected components of a graph ( http://hackage.haskell.org/package/GraphSCC )

graphviz : Bindings to Graphviz for graph visualisation ( http://projects.haskell.org/graphviz/ )

gravatar : Look up gravatar image urls by email address ( http://github.com/pbrisbin/gravatar )

groom : Pretty printing for well-behaved Show instances ( http://hackage.haskell.org/package/groom )

groundhog : Type-safe datatype-database mapping library ( http://github.com/lykahb/groundhog )

groundhog-postgresql : PostgreSQL backend for the groundhog library ( http://hackage.haskell.org/package/groundhog-postgresql )

groundhog-sqlite : Sqlite3 backend for the groundhog library ( http://hackage.haskell.org/package/groundhog-sqlite )

groundhog-th : Type-safe datatype-database mapping library ( http://hackage.haskell.org/package/groundhog-th )

groupoids : This package has been absorbed into semigroupoids 4.0 ( http://github.com/ekmett/groupoids/ )

groups : Haskell 98 groups ( http://hackage.haskell.org/package/groups )

gsasl : Bindings for GNU libgsasl ( https://john-millikin.com/software/haskell-gsasl/ )

gstreamer : Binding to the GStreamer open source multimedia framework ( http://projects.haskell.org/gtk2hs/ )

gtk : Binding to the Gtk+ graphical user interface library ( http://projects.haskell.org/gtk2hs/ )

gtk-serialized-event : GTK+ Serialized event ( http://www.haskell.org/gtk2hs/ )

gtk-traymanager : A wrapper around the eggtraymanager library for Linux system trays ( http://github.com/travitch/gtk-traymanager )

gtk2hs-buildtools : Tools to build the Gtk2Hs suite of User Interface libraries ( http://projects.haskell.org/gtk2hs/ )

gtkglext : Binding to the GTK+ OpenGL Extension ( http://projects.haskell.org/gtk2hs/ )

gtkimageview : Binding to the GtkImageView library ( http://www.haskell.org/gtk2hs/ )

gtksourceview : Binding to the GtkSourceView library ( http://projects.haskell.org/gtk2hs/ )

hach : Simple chat ( http://github.com/dmalikov/HaCh )

haddock : A documentation-generation tool for Haskell libraries ( http://www.haskell.org/haddock/ )

haddock-library : Library exposing some functionality of Haddock ( http://www.haskell.org/haddock/ )

haha : A simple library for creating animated ascii art on ANSI terminals ( http://hackage.haskell.org/package/haha )

hakyll : A static website compiler library ( http://jaspervdj.be/hakyll )

hamlet : Haml-like template files that are compile-time checked (deprecated) ( http://www.yesodweb.com/book/shakespearean-templates )

handsomesoup : Work with HTML more easily in HXT ( https://github.com/egonSchiele/HandsomeSoup )

hans : IPv4 Network Stack ( http://hackage.haskell.org/package/hans )

happraise : A small program for counting the comments in haskell source ( http://hackage.haskell.org/package/happraise )

happstack : The haskell application server stack + code generation ( http://happstack.com )

happstack-hamlet : Support for Hamlet HTML templates in Happstack ( http://www.happstack.com/ )

happstack-heist : Support for using Heist templates in Happstack ( http://www.happstack.com/ )

happstack-hsp : Support for using HSP templates in Happstack ( http://www.happstack.com/ )

happstack-hstringtemplate : Support for using HStringTemplate in Happstack ( http://www.happstack.com/ )

happstack-plugins : The haskell application server stack + reload ( http://happstack.com )

happstack-server : Web related tools and services ( http://happstack.com )

happstack-server-tls : extend happstack-server with https:// support (TLS/SSL) ( http://www.happstack.com/ )

happy : Happy is a parser generator for Haskell ( http://www.haskell.org/happy/ )

harp : HaRP allows pattern-matching with regular expressions ( http://www.cs.chalmers.se/~d00nibro/harp/ )

harpy : Runtime code generation for x86 machine code ( http://code.haskell.org/harpy/ )

hashable : A class for types that can be converted to a hash value ( http://github.com/tibbe/hashable )

hashable-extras : Higher-rank Hashable ( http://github.com/analytics/hashable-extras/ )

hashed-storage : Hashed file storage support code ( http://hackage.haskell.org/package/hashed-storage )

hashtables : Mutable hash tables in the ST monad ( http://github.com/gregorycollins/hashtables )

haskeline : A command-line interface for user input, written in Haskell ( http://trac.haskell.org/haskeline )

haskell-awk : Transform text from the command-line using Haskell expressions ( http://hackage.haskell.org/package/haskell-awk )

haskell-docs : A program to find and display the docs of a name from a given module ( http://github.com/chrisdone/haskell-docs )

haskell-lexer : A fully compliant Haskell 98 lexer ( http://hackage.haskell.org/package/haskell-lexer )

haskell-mpi : Distributed parallel programming in Haskell using MPI ( http://github.com/bjpop/haskell-mpi )

haskell-names : Name resolution library for Haskell ( http://documentup.com/haskell-suite/haskell-names )

haskell-packages : Haskell suite library for package management and integration with Cabal ( http://documentup.com/haskell-suite/haskell-packages )

haskell-platform : The Haskell Platform ( http://haskell.org/platform )

haskell-src : Support for manipulating Haskell source code ( http://hackage.haskell.org/package/haskell-src )

haskell-src-exts : Manipulating Haskell source: abstract syntax, lexer, parser, and pretty-printer ( https://github.com/haskell-suite/haskell-src-exts )

haskell-src-meta : Parse source to template-haskell abstract syntax ( http://hackage.haskell.org/package/haskell-src-meta )

haskelldb : A library of combinators for generating and executing SQL statements ( https://github.com/m4dc4p/haskelldb )

haskelldb-hdbc : HaskellDB support for HDBC ( https://github.com/m4dc4p/haskelldb )

haskelldb-hdbc-mysql : HaskellDB support for the HDBC MySQL driver ( http://hackage.haskell.org/package/haskelldb-hdbc-mysql )

haskelldb-hdbc-odbc : HaskellDB support for the HDBC ODBC driver ( https://github.com/m4dc4p/haskelldb )

haskelldb-hdbc-postgresql : HaskellDB support for the HDBC PostgreSQL driver ( https://github.com/m4dc4p/haskelldb )

haskelldb-hdbc-sqlite3 : HaskellDB support for the HDBC SQLite driver ( https://github.com/m4dc4p/haskelldb )

haskelldb-th : Template Haskell utilities for HaskellDB ( http://trac.haskell.org/haskelldb-th )

haskellnet : Client support for POP3, SMTP, and IMAP ( https://github.com/jtdaugherty/HaskellNet )

haskellnet-ssl : Helpers to connect to SSL/TLS mail servers with HaskellNet ( https://github.com/dpwright/HaskellNet-SSL )

hasktags : Produces ctags "tags" and etags "TAGS" files for Haskell programs ( http://github.com/MarcWeber/hasktags )

haspell : Haskell bindings to aspell ( https://github.com/otters/haspell )

hastache : Haskell implementation of Mustache templates ( http://github.com/lymar/hastache )

hatex : The Haskell LaTeX library ( http://daniel-diaz.github.io/projects/hatex )

haxml : Utilities for manipulating XML documents ( http://www.cs.york.ac.uk/fp/HaXml/ )

haxr : XML-RPC client and server library ( http://www.haskell.org/haskellwiki/HaXR )

hcodecs : A library to read, write and manipulate MIDI, WAVE, and SoundFont2 files ( http://www-db.informatik.uni-tuebingen.de/team/giorgidze )

hdaemonize : Library to handle the details of writing daemons for UNIX ( http://github.com/madhadron/hdaemonize )

hdbc : Haskell Database Connectivity ( https://github.com/hdbc/hdbc )

hdbc-mysql : MySQL driver for HDBC ( http://github.com/bos/hdbc-mysql )

hdbc-odbc : ODBC driver for HDBC ( https://github.com/hdbc/hdbc-odbc )

hdbc-postgresql : PostgreSQL driver for HDBC ( http://github.com/hdbc/hdbc-postgresql )

hdbc-sqlite : Sqlite v3 driver for HDBC ( http://software.complete.org/hdbc-sqlite3 )

hdevtools : Persistent GHC powered background server for FAST haskell development tools ( https://github.com/bitc/hdevtools/ )

hdfa : A simple library for representing and minimising DFAs ( http://hackage.haskell.org/package/hDFA )

heap : Heaps in Haskell ( http://hackage.haskell.org/package/heap )

heaps : Asymptotically optimal Brodal/Okasaki heaps ( http://github.com/ekmett/heaps/ )

hedis : Client library for the Redis datastore: supports full command set, pipelining ( https://github.com/informatikr/hedis )

heist : An Haskell template system supporting both HTML5 and XML ( http://snapframework.com/ )

here : Here docs and interpolated strings via quasiquotation ( https://github.com/tmhedberg/here )

hex : Convert strings into hexadecimal and back ( http://hackage.haskell.org/package/hex )

hexpat : XML parser/formatter based on expat ( http://haskell.org/haskellwiki/Hexpat/ )

hflags : Command line flag parser, very similar to Google's gflags ( http://github.com/errge/hflags )

hfov : Field-of-view calculation for low-resolution 2D raster grids ( https://github.com/nornagon/hfov )

hgal : library for computation automorphism group and canonical labelling of a graph ( http://hackage.haskell.org/package/hgal )

hgdbmi : GDB Machine Interface: program-driven control of GDB ( https://github.com/copton/hgdbmi )

hgettext : Bindings to libintl.h (gettext, bindtextdomain) ( https://github.com/vasylp/hgettext )

hgl : A simple graphics library based on X11 or Win32 ( http://hackage.haskell.org/package/HGL )

highlighting-kate : Syntax highlighting ( http://github.com/jgm/highlighting-kate )

hinotify : Haskell binding to inotify ( https://github.com/kolmodin/hinotify.git )

hint : Runtime Haskell interpreter (GHC API wrapper) ( http://darcsden.com/jcpetruzza/hint )

hipmunk : A Haskell binding for Chipmunk ( https://github.com/meteficha/Hipmunk )

hipmunkplayground : A playground for testing Hipmunk ( https://github.com/meteficha/HipmunkPlayground )

hit : Git operations in haskell ( http://github.com/vincenthz/hit )

hjavascript : HJavaScript is an abstract syntax for a typed subset of JavaScript ( http://hackage.haskell.org/package/HJavaScript )

hjscript : HJScript is a Haskell EDSL for writing JavaScript programs ( http://patch-tag.com/r/nibro/hjscript )

hjsmin : Haskell implementation of a javascript minifier ( http://github.com/alanz/hjsmin )

hledger : The main command-line interface for the hledger accounting tool ( http://hledger.org )

hledger-interest : computes interest for a given account ( http://github.com/peti/hledger-interest )

hledger-lib : Core data types, parsers and utilities for the hledger accounting tool ( http://hledger.org )

hledger-web : A web interface for the hledger accounting tool ( http://hledger.org )

hlibev : FFI interface to libev ( http://github.com/aycanirican/hlibev )

hlibgit2 : Low-level bindings to libgit2 ( http://hackage.haskell.org/package/hlibgit2 )

hlint : Source code suggestions ( http://community.haskell.org/~ndm/hlint/ )

hlist : Heterogeneous lists ( http://hackage.haskell.org/package/HList )

hmarkup : Simple wikitext-like markup format implementation ( http://hackage.haskell.org/package/hmarkup )

hmatrix : Linear algebra and numerical computation ( https://github.com/albertoruiz/hmatrix )

hmatrix-gsl-stats : GSL Statistics interface ( http://code.haskell.org/hmatrix-gsl-stats )

hoauth2 : hoauth2 ( https://github.com/freizl/hoauth2 )

hood : Debugging by observing in place ( http://www.ittc.ku.edu/csdl/fpg/Hood )

hoogle : Haskell API Search ( http://www.haskell.org/hoogle/ )

hoopl : A library to support dataflow analysis and optimization ( http://ghc.cs.tufts.edu/hoopl/ )

hosc : Haskell Open Sound Control ( http://rd.slavepianos.org/?t=hosc )

hostname : A very simple package providing a cross-platform means of determining the hostname ( http://hackage.haskell.org/package/hostname )

hothasktags : Generates ctags for Haskell, incorporating import lists and qualified imports ( http://github.com/luqui/hothasktags )

hourglass : simple performant time related library ( https://github.com/vincenthz/hs-hourglass )

hp2any-core : Heap profiling helper library ( http://www.haskell.org/haskellwiki/Hp2any )

hp2any-graph : Real-time heap graphing utility and profile stream server with a reusable graphing module ( http://www.haskell.org/haskellwiki/Hp2any )

hp2any-manager : A utility to visualise and compare heap profiles ( http://www.haskell.org/haskellwiki/Hp2any )

hpc : Code Coverage Library for Haskell ( http://hackage.haskell.org/package/hpc )

hpdf : Generation of PDF documents ( http://www.alpheccar.org )

hprotoc : Parse Google Protocol Buffer specifications ( http://code.haskell.org/protocol-buffers/ )

hs-bibutils : Haskell bindings to bibutils, the bibliography conversion utilities ( http://gorgias.mine.nu/repos/hs-bibutils/ )

hs-java : Java .class files assembler/disassembler ( http://hackage.haskell.org/package/hs-java )

hs3 : Interface to Amazon's Simple Storage Service (S3) ( http://gregheartsfield.com/hS3/ )

hscolour : Colourise Haskell code ( http://code.haskell.org/~malcolm/hscolour/ )

hscurses : NCurses bindings for Haskell ( https://github.com/skogsbaer/hscurses )

hsdns : Asynchronous DNS Resolver ( http://github.com/peti/hsdns )

hse-cpp : Preprocess+parse haskell code ( http://hackage.haskell.org/package/hse-cpp )

hsemail : Internet Message Parsers ( http://github.com/peti/hsemail )

hsh : Library to mix shell scripting with Haskell programs ( http://software.complete.org/hsh )

hsimport : A command line program for extending the import list of a Haskell source file ( http://hackage.haskell.org/package/hsimport )

hslogger : Versatile logging framework ( http://software.complete.org/hslogger )

hslua : A Lua language interpreter embedding in Haskell ( http://hackage.haskell.org/package/hslua )

hsndfile : Haskell bindings for libsndfile ( http://haskell.org/haskellwiki/Hsndfile )

hsopenssl : Partial OpenSSL binding for Haskell ( https://github.com/phonohawk/HsOpenSSL )

hsp : Haskell Server Pages is a library for writing dynamic server-side web pages ( http://hub.darcs.net/nibro/hsp )

hspec : A Testing Framework for Haskell ( http://hspec.github.io/ )

hspec-expectations : Catchy combinators for HUnit ( https://github.com/sol/hspec-expectations#readme )

hspec-expectations-lens : Hspec expectations for the lens stuff ( http://supki.github.io/hspec-expectations-lens/ )

hspec-meta : A version of Hspec which is used to test Hspec itself ( http://hspec.github.io/ )

hspread : A client library for the spread toolkit ( http://hackage.haskell.org/package/hspread )

hsql : Database access from Haskell ( http://hackage.haskell.org/package/hsql )

hsql-mysql : MySQL driver for HSQL ( http://hackage.haskell.org/package/hsql-mysql )

hsql-odbc : A Haskell Interface to ODBC ( http://hackage.haskell.org/package/hsql-odbc )

hsql-postgresql : A Haskell Interface to PostgreSQL via the PQ library ( http://hackage.haskell.org/package/hsql-postgresql )

hsql-sqlite3 : SQLite3 driver for HSQL ( http://hackage.haskell.org/package/hsql-sqlite3 )

hsqml : Haskell binding for Qt Quick ( http://www.gekkou.co.uk/software/hsqml/ )

hsshellscript : Haskell for Unix shell scripting tasks ( http://www.volker-wysk.de/hsshellscript/ )

hssyck : Fast, lightweight YAML loader and dumper ( http://hackage.haskell.org/package/HsSyck )

hstatistics : Statistics ( http://code.haskell.org/hstatistics )

hstatsd : Quick and dirty statsd interface ( https://github.com/mokus0/hstatsd )

hstringtemplate : StringTemplate implementation in Haskell ( http://hackage.haskell.org/package/HStringTemplate )

hsx : HSX (Haskell Source with XML) allows literal XML syntax in Haskell source code ( http://patch-tag.com/r/nibro/hsx )

hsx2hs : HSX (Haskell Source with XML) allows literal XML syntax in Haskell source code ( http://hub.darcs.net/nibro/hsx2hs )

hsyslog : FFI interface to syslog(3) from POSIX.1-2001 ( http://github.com/peti/hsyslog )

htf : The Haskell Test Framework ( https://github.com/skogsbaer/HTF/ )

html : HTML combinator library ( http://hackage.haskell.org/package/html )

html-conduit : Parse HTML documents using xml-conduit datatypes ( https://github.com/snoyberg/xml )

htrace : Hierarchical tracing for debugging of lazy evaluation ( http://hackage.haskell.org/package/htrace )

htsn-common : Display/logging facilities used by both htsn and htsn-import ( http://hackage.haskell.org/package/htsn-common )

http : A library for client-side HTTP ( https://github.com/haskell/HTTP )

http-attoparsec : Attoparsec parsers for http-types ( https://github.com/tlaitinen/http-attoparsec )

http-client : An HTTP client engine, intended as a base layer for more user-friendly packages ( https://github.com/snoyberg/http-client )

http-client-conduit : Frontend support for using http-client with conduit (deprecated) ( https://github.com/snoyberg/http-client )

http-client-multipart : Generate multipart uploads for http-client. (deprecated) ( https://github.com/snoyberg/http-client )

http-client-tls : http-client backend using the connection package and tls library ( https://github.com/snoyberg/http-client )

http-common : Common types for HTTP clients and servers ( http://research.operationaldynamics.com/projects/http-streams/ )

http-conduit : HTTP client package with conduit interface and HTTPS support ( http://www.yesodweb.com/book/http-conduit )

http-date : HTTP Date parser/formatter ( http://hackage.haskell.org/package/http-date )

http-querystring : The HTTP query builder ( https://github.com/worksap-ate/http-querystring )

http-reverse-proxy : Reverse proxy HTTP requests, either over raw sockets or with WAI ( https://github.com/fpco/http-reverse-proxy )

http-streams : An HTTP client using io-streams ( http://research.operationaldynamics.com/projects/http-streams/ )

http-types : Generic HTTP types for Haskell (for both client and server code) ( https://github.com/aristidb/http-types )

httpd-shed : A simple web-server with an interact style API ( http://hackage.haskell.org/package/httpd-shed )

huffman : Pure Haskell implementation of the Huffman encoding algorithm ( http://hackage.haskell.org/package/huffman )

hunit : A unit testing framework for Haskell ( http://hunit.sourceforge.net/ )

hxt : A collection of tools for processing XML with Haskell ( http://www.fh-wedel.de/~si/HXmlToolbox/index.html )

hxt-charproperties : Character properties and classes for XML and Unicode ( https://github.com/UweSchmidt/hxt )

hxt-http : Interface to native Haskell HTTP package HTTP ( http://www.fh-wedel.de/~si/HXmlToolbox/index.html )

hxt-regex-xmlschema : A regular expression library for W3C XML Schema regular expressions ( http://www.haskell.org/haskellwiki/Regular_expressions_for_XML_Schema )

hxt-unicode : Unicode en-/decoding functions for utf8, iso-latin-* and other encodings ( http://www.fh-wedel.de/~si/HXmlToolbox/index.html )

hxt-xpath : The XPath modules for HXT ( http://www.fh-wedel.de/~si/HXmlToolbox/index.html )

i18n : Internationalization for Haskell ( http://hackage.haskell.org/package/i18n )

iconv : String encoding conversion ( http://hackage.haskell.org/package/iconv )

idna : Implements IDNA (RFC 3490) ( http://hackage.haskell.org/package/idna )

ieee754 : Utilities for dealing with IEEE floating point numbers ( http://github.com/patperry/hs-ieee754 )

ifelse : Anaphoric and miscellaneous useful control-flow ( http://hackage.haskell.org/package/IfElse )

ihaskell : A Haskell backend kernel for the IPython project ( http://gibiansky.github.io/IHaskell/ )

imagemagick : bindings to imagemagick library ( http://hackage.haskell.org/package/imagemagick )

imagesize-conduit : Determine the size of some common image formats ( http://github.com/silkapp/imagesize-conduit )

imlib : Haskell binding for Imlib 2 ( http://hackage.haskell.org/package/Imlib )

indents : indentation sensitive parser-combinators for parsec ( http://patch-tag.com/r/salazar/indents )

indexed : Haskell98 indexed functors, monads, comonads ( https://github.com/reinerp/indexed )

indexed-extras : Indexed functors, monads and comonads that require extensions to Haskell98 ( https://github.com/reinerp/indexed-extras )

instant-generics : Generic programming library with a sum of products view ( http://www.cs.uu.nl/wiki/GenericProgramming/InstantGenerics )

interlude : Replaces some Prelude functions for enhanced error reporting ( http://malde.org/~ketil/ )

intervals : Interval Arithmetic ( http://github.com/ekmett/intervals )

invariant : Haskell 98 invariant functors ( http://hackage.haskell.org/package/invariant )

io-choice : Choice for IO and lifted IO ( http://hackage.haskell.org/package/io-choice )

io-storage : A key-value store in the IO monad ( http://github.com/willdonnelly/io-storage )

io-streams : Simple, composable, and easy-to-use stream I/O ( http://hackage.haskell.org/package/io-streams )

iorefcas : Atomic compare and swap for IORefs and STRefs ( https://github.com/rrnewton/haskell-lockfree-queue/wiki )

iospec : A pure specification of the IO monad ( http://hackage.haskell.org/package/IOSpec )

ipprint : Tiny helper for pretty-printing values in ghci console ( http://hackage.haskell.org/package/ipprint )

iproute : IP Routing Table ( http://www.mew.org/~kazu/proj/iproute/ )

ipython-kernel : A library for creating kernels for IPython frontends ( http://github.com/gibiansky/IHaskell )

irc : A small library for parsing IRC messages ( http://hackage.haskell.org/package/irc )

ircbot : A library for writing irc bots ( http://hub.darcs.net/stepcut/ircbot )

iteratee : Iteratee-based I/O ( http://www.tiresiaspress.us/haskell/iteratee )

iterio : Iteratee-based IO with pipe operators ( http://www.scs.stanford.edu/~dm/iterIO )

ixset : Efficient relational queries on Haskell sets ( http://happstack.com )

jail : Jailed IO monad ( http://hackage.haskell.org/package/jail )

jmacro : QuasiQuotation library for programmatic generation of Javascript code ( http://hackage.haskell.org/package/jmacro )

jsaddle : High level interface for webkit-javascriptcore ( http://hackage.haskell.org/package/jsaddle )

json : Support for serialising Haskell to and from JSON ( http://hackage.haskell.org/package/json )

json-types : Basic types for representing JSON ( http://hackage.haskell.org/package/json-types )

jsonb : JSON parser that uses byte strings ( http://github.com/solidsnack/JSONb/ )

judy : Fast, scalable, mutable dynamic arrays, maps and hashes ( http://code.haskell.org/~dons/code/judy )

juicypixels : Picture loading/serialization (in png, jpeg, bitmap, gif, tiff and radiance) ( https://github.com/Twinside/Juicy.Pixels )

kan-extensions : Kan extensions, Kan lifts, various forms of the Yoneda lemma, and (co)density (co)monads ( http://github.com/ekmett/kan-extensions/ )

keys : Keyed functors and containers ( http://github.com/ekmett/keys/ )

kibro : Web development framework ( http://hackage.haskell.org/package/kibro )

kinds : Emulation of subkinds and subkind polymorphism ( http://darcs.wolfgang.jeltsch.info/haskell/kinds )

knob : Memory-backed handles ( https://john-millikin.com/software/knob/ )

lambdabot : Lambdabot is a development tool and advanced IRC bot ( http://haskell.org/haskellwiki/Lambdabot )

lambdabot-utils : Utility libraries for the advanced IRC bot, Lambdabot ( http://haskell.org/haskellwiki/Lambdabot )

language-c : Analysis and generation of C code ( http://www.sivity.net/projects/language.c/ )

language-c-quote : C/CUDA/OpenCL/Objective-C quasiquoting library ( http://www.cs.drexel.edu/~mainland/ )

language-ecmascript : JavaScript parser and pretty-printer library ( http://github.com/jswebtools/language-ecmascript )

language-glsl : GLSL abstract syntax tree, parser, and pretty-printer ( http://hackage.haskell.org/package/language-glsl )

language-haskell-extract : Module to automatically extract functions from the local code ( http://github.com/finnsson/template-helper )

language-java : Manipulating Java source: abstract syntax, lexer, parser, and pretty-printer ( http://github.com/vincenthz/language-java )

language-javascript : Parser for JavaScript ( http://github.com/alanz/language-javascript )

largeword : Provides Word128, Word192 and Word256 and a way of producing other large words if required ( https://github.com/idontgetoutmuch/largeword )

layers : Modular type class machinery for monad transformer stacks ( http://github.com/duairc/layers )

lazysmallcheck : A library for demand-driven testing of Haskell programs ( http://www.cs.york.ac.uk/~mfn/lazysmallcheck/ )

lcs : Find longest common sublist of two lists ( http://urchin.earth.li/~ian/cabal/lcs/ )

ldap : Haskell binding for C LDAP API ( https://github.com/ezyang/ldap-haskell )

lens : Lenses, Folds and Traversals ( http://github.com/ekmett/lens/ )

lens-aeson : Law-abiding lenses for aeson ( http://github.com/lens/lens-aeson/ )

lenses : Simple Functional Lenses ( http://github.com/jvranish/Lenses/tree/master )

lhs2tex : Preprocessor for typesetting Haskell sources with LaTeX ( http://www.andres-loeh.de/lhs2tex/ )

libffi : A binding to libffi ( http://hackage.haskell.org/package/libffi )

liblastfm : Lastfm API interface ( http://hackage.haskell.org/package/liblastfm )

libmpd : An MPD client library ( http://github.com/vimus/libmpd-haskell#readme )

libssh2 : FFI bindings to libssh2 SSH2 client library (http://libssh2.org/) ( https://github.com/portnov/libssh2-hs )

libssh2-conduit : Conduit wrappers for libssh2 FFI bindings (see libssh2 package) ( http://redmine.iportnov.ru/projects/libssh2-hs )

libtagc : Binding to TagLib C library ( https://patch-tag.com/r/AndyStewart/libtagc/home )

libvirt-hs : FFI bindings to libvirt virtualization API (http://libvirt.org) ( http://redmine.iportnov.ru/projects/libvirt-hs )

libxml : Binding to libxml2 ( http://hackage.haskell.org/package/libxml )

libxml-sax : Bindings for the libXML2 SAX interface ( https://john-millikin.com/software/haskell-libxml/ )

libzip : Bindings to libzip, a library for manipulating zip archives ( http://bitbucket.org/astanin/hs-libzip/ )

lifted-async : Run lifted IO operations asynchronously and wait for their results ( https://github.com/maoe/lifted-async )

lifted-base : lifted IO operations from the base library ( https://github.com/basvandijk/lifted-base )

linear : Linear Algebra ( http://github.com/ekmett/linear/ )

lio : Labeled IO Information Flow Control Library ( http://hackage.haskell.org/package/lio )

list : List monad transformer and class ( http://github.com/yairchu/generator/tree )

listlike : Generic support for list-like structures ( http://software.complete.org/listlike )

listzipper : Simple zipper for lists ( http://hackage.haskell.org/package/ListZipper )

llvm : Bindings to the LLVM compiler toolkit ( https://github.com/bos/llvm )

llvm-base : FFI bindings to the LLVM compiler toolkit ( https://github.com/bos/llvm )

llvm-general : General purpose LLVM bindings ( http://hackage.haskell.org/package/llvm-general )

llvm-general-pure : Pure Haskell LLVM functionality (no FFI) ( http://hackage.haskell.org/package/llvm-general-pure )

loch : Support for precise error locations in source files ( http://hackage.haskell.org/package/loch )

lockfree-queue : Michael and Scott lock-free queues ( https://github.com/rrnewton/haskell-lockfree/wiki )

logfloat : Log-domain floating point numbers ( http://code.haskell.org/~wren/ )

logict : A backtracking logic-programming monad ( http://code.haskell.org/~dolio/ )

loop : Fast loops (for when GHC can't optimize forM_) ( https://github.com/nh2/loop )

lru : Implements an LRU data structure ( http://www.imperialviolet.org/lru )

lrucache : a simple, pure LRU cache ( http://github.com/chowells79/lrucache )

ltk : Leksah tool kit ( http://www.leksah.org )

lushtags : Create ctags compatible tags files for Haskell programs ( https://github.com/bitc/lushtags )

lvmlib : The Lazy Virtual Machine (LVM) ( http://www.cs.uu.nl/wiki/bin/view/Helium/WebHome )

maccatcher : Obtain the host MAC address on *NIX and Windows ( http://hackage.haskell.org/package/maccatcher )

magic : Interface to C file/magic library ( http://hackage.haskell.org/package/magic )

mainland-pretty : Pretty printing designed for printing source code ( http://www.eecs.harvard.edu/~mainland/ )

manatee : The Haskell/Gtk+ Integrated Live Environment ( http://hackage.haskell.org/package/manatee )

manatee-browser : Browser extension for Manatee ( http://hackage.haskell.org/package/manatee-browser )

manatee-core : The core of Manatee ( http://hackage.haskell.org/package/manatee-core )

manatee-imageviewer : Image viewer extension for Manatee ( http://hackage.haskell.org/package/manatee-imageviewer )

manatee-ircclient : IRC client extension for Manatee ( http://hackage.haskell.org/package/manatee-ircclient )

manatee-mplayer : Mplayer client extension for Manatee ( http://hackage.haskell.org/package/manatee-mplayer )

manatee-pdfviewer : PDF viewer extension for Manatee ( http://hackage.haskell.org/package/manatee-pdfviewer )

manatee-processmanager : Process manager extension for Manatee ( http://hackage.haskell.org/package/manatee-processmanager )

manatee-reader : Feed reader extension for Manatee ( http://hackage.haskell.org/package/manatee-reader )

manatee-terminal : Terminal Emulator extension for Manatee ( http://hackage.haskell.org/package/manatee-terminal )

map-syntax : Syntax sugar for defining maps ( http://hackage.haskell.org/package/map-syntax )

markdown : Convert Markdown to HTML, with XSS protection ( https://github.com/snoyberg/markdown )

markdown-unlit : Literate Haskell support for Markdown ( http://hackage.haskell.org/package/markdown-unlit )

math-functions : Special functions and Chebyshev polynomials ( https://github.com/bos/math-functions )

matrix : A native implementation of matrix operations ( http://hackage.haskell.org/package/matrix )

maybet : MaybeT monad transformer ( http://hackage.haskell.org/package/MaybeT )

mecab : A Haskell binding to MeCab ( http://github.com/tanakh/hsmecab )

mediawiki : Interfacing with the MediaWiki API ( http://hackage.haskell.org/package/mediawiki )

meldable-heap : Asymptotically optimal, Coq-verified meldable heaps, AKA priority queues ( http://code.google.com/p/priority-queues/ )

memoize : A memoization library ( http://hackage.haskell.org/package/memoize )

memotrie : Trie-based memo functions ( http://haskell.org/haskellwiki/MemoTrie )

mersenne-random : Generate high quality pseudorandom numbers using a SIMD Fast Mersenne Twister ( http://code.haskell.org/~dons/code/mersenne-random )

mersenne-random-pure64 : Generate high quality pseudorandom numbers purely using a Mersenne Twister ( http://code.haskell.org/~dons/code/mersenne-random-pure64/ )

midi : Handling of MIDI messages and files ( http://www.haskell.org/haskellwiki/MIDI )

midi-alsa : Convert between datatypes of the midi and the alsa packages ( http://www.haskell.org/haskellwiki/MIDI )

mime : Working with MIME types ( https://github.com/GaloisInc/mime )

mime-mail : Compose MIME email messages ( http://github.com/snoyberg/mime-mail )

mime-string : MIME implementation for String's ( http://hackage.haskell.org/package/mime-string )

mime-types : Basic mime-type handling types and functions ( https://github.com/yesodweb/wai )

minisat : A Haskell bundle of the Minisat SAT solver ( http://hackage.haskell.org/package/minisat )

misfortune : fortune-mod clone ( https://github.com/mokus0/misfortune )

missingh : Large utility library ( http://software.complete.org/missingh )

mmap : Memory mapped files for POSIX and Windows ( http://hackage.haskell.org/package/mmap )

mmorph : Monad morphisms ( http://hackage.haskell.org/package/mmorph )

monad-control : Lift control operations, like exception catching, through monad transformers ( https://github.com/basvandijk/monad-control )

monad-journal : Pure logger typeclass and monad transformer ( https://github.com/phaazon/monad-journal )

monad-logger : A class of monads which can log messages ( https://github.com/kazu-yamamoto/logger )

monad-loops : Monadic loops ( https://github.com/mokus0/monad-loops )

monad-par : A library for parallel programming based on a monad ( https://github.com/simonmar/monad-par )

monad-par-extras : Combinators and extra features for Par monads ( https://github.com/simonmar/monad-par )

monad-parallel : Parallel execution of monadic computations ( http://trac.haskell.org/SCC/wiki/monad-parallel )

monad-peel : Lift control operations like exception catching through monad transformers ( http://andersk.mit.edu/haskell/monad-peel/ )

monad-products : Monad products ( http://github.com/ekmett/monad-products )

monad-unify : Generic first-order unification ( http://hackage.haskell.org/package/monad-unify )

monadcatchio-mtl : Monad-transformer version of the Control.Exception module ( http://darcsden.com/jcpetruzza/MonadCatchIO-mtl )

monadcatchio-transformers : Monad-transformer compatible version of the Control.Exception module ( http://hackage.haskell.org/package/MonadCatchIO-transformers )

monadcryptorandom : A monad for using CryptoRandomGen ( https://github.com/TomMD/monadcryptorandom )

monadlab : Automatically generate layered monads ( http://monadgarden.cs.missouri.edu/MonadLab )

monadlib : A collection of monad transformers ( http://wiki.github.com/yav/monadlib )

monadlist : Monadic versions of list functions ( http://hackage.haskell.org/package/monadlist )

monadloc : A class for monads which can keep a monadic call trace ( http://github.com/pepeiborra/monadloc )

monadprompt : MonadPrompt, implementation and examples ( http://hackage.haskell.org/package/MonadPrompt )

monadrandom : Random-number generation monad ( http://hackage.haskell.org/package/MonadRandom )

monads-fd : Monad classes, using functional dependencies ( http://hackage.haskell.org/package/monads-fd )

monads-tf : Monad classes, using type families ( http://hackage.haskell.org/package/monads-tf )

mongodb : Driver (client) for MongoDB, a free, scalable, fast, document DBMS ( https://github.com/mongodb-haskell/mongodb )

mono-traversable : Type classes for mapping, folding, and traversing monomorphic containers ( https://github.com/snoyberg/mono-traversable )

monoid-extras : Various extra monoid-related definitions and utilities ( http://hackage.haskell.org/package/monoid-extras )

monoid-transformer : Monoid counterparts to some ubiquitous monad transformers ( http://hackage.haskell.org/package/monoid-transformer )

morsecode : Morse code ( http://hackage.haskell.org/package/MorseCode )

msgpack : A Haskell implementation of MessagePack ( http://msgpack.org/ )

mtl : Monad classes, using functional dependencies ( http://github.com/ekmett/mtl )

mtlparse : parse library using mtl package ( http://homepage3.nifty.com/salamander/second/projects/mtlparse/ )

mueval : Safely evaluate pure Haskell expressions ( https://github.com/gwern/mueval )

multipart : HTTP multipart split out of the cgi package ( http://www.github.com/silkapp/multipart )

multirec : Generic programming for families of recursive datatypes ( http://www.cs.uu.nl/wiki/GenericProgramming/Multirec )

multiset : The Data.MultiSet container type ( http://hackage.haskell.org/package/multiset )

murmur-hash : MurmurHash2 implementation for Haskell ( http://github.com/nominolo/murmur-hash )

mwc-random : Fast, high quality pseudo random number generation ( https://github.com/bos/mwc-random )

mysql : A low-level MySQL client library ( https://github.com/bos/mysql )

mysql-simple : A mid-level MySQL client library ( https://github.com/bos/mysql-simple )

nano-md5 : Efficient, ByteString bindings to OpenSSL ( http://code.haskell.org/~dons/code/nano-md5 )

nanomsg : nanomsg - scalability protocols library ( http://hackage.haskell.org/package/nanomsg )

nanomsg-haskell : Bindings to the nanomsg library ( https://github.com/ivarnymoen/nanomsg-haskell )

nanoprolog : Very small interpreter for a Prolog-like language ( http://hackage.haskell.org/package/NanoProlog )

nanospec : A lightweight implementation of a subset of Hspec's API ( http://hackage.haskell.org/package/nanospec )

nats : Natural numbers ( http://github.com/ekmett/nats/ )

natural-numbers : Natural numbers ( http://darcs.wolfgang.jeltsch.info/haskell/natural-numbers )

ncurses : Modernised bindings to GNU ncurses ( https://john-millikin.com/software/haskell-ncurses/ )

nettle-openflow : OpenFlow protocol messages, binary formats, and servers ( http://hackage.haskell.org/package/nettle-openflow )

netwire : Functional reactive programming library ( http://hackage.haskell.org/package/netwire )

network : Low-level networking interface ( https://github.com/haskell/network )

network-conduit : Stream socket data using conduits. (deprecated) ( http://github.com/snoyberg/conduit )

network-data : Library for network data structures and their serialization ( http://hackage.haskell.org/package/network-data )

network-enumerator : Enumerators for network sockets ( https://john-millikin.com/software/network-enumerator/ )

network-fancy : Networking support with a cleaner API ( http://github.com/taruti/network-fancy )

network-house : data and parsers for Ethernet, TCP, UDP, IPv4, IPv6, ICMP, DHCP, TFTP ( https://github.com/nh2/network-house )

network-info : Access the local computer's basic network configuration ( http://github.com/jystic/network-info )

network-multicast : Simple multicast library ( http://hackage.haskell.org/package/network-multicast )

network-protocol-xmpp : Client library for the XMPP protocol ( https://john-millikin.com/software/haskell-xmpp/ )

network-simple : Simple network sockets usage patterns. ( https://github.com/k0001/network-simple )

network-socket-options : Type-safe, portable alternative to getSocketOption/setSocketOption ( https://github.com/joeyadams/haskell-network-socket-options )

network-transport : Network abstraction layer ( http://haskell-distributed.github.com )

network-transport-tcp : TCP instantiation of Network.Transport ( http://github.com/haskell-distributed/distributed-process )

network-transport-tests : Unit tests for Network.Transport implementations ( http://github.com/haskell-distributed/distributed-process )

network-uri : URI manipulation ( https://github.com/haskell/network-uri )

newtype : A typeclass and set of functions for working with newtypes ( http://hackage.haskell.org/package/newtype )

non-empty : List-like structures with static restrictions on the number of elements ( http://code.haskell.org/~thielema/non-empty/ )

non-negative : Non-negative numbers ( http://code.haskell.org/~thielema/non-negative/ )

normaldistribution : Minimum fuss normally distributed random values ( https://github.com/bjornbm/normaldistribution )

numbers : Various number types ( https://github.com/jwiegley/numbers#readme )

numeric-extras : Useful tools from the C standard library ( http://github.com/ekmett/numeric-extras )

numeric-prelude : An experimental alternative hierarchy of numeric type classes ( http://www.haskell.org/haskellwiki/Numeric_Prelude )

numeric-quest : Math and quantum mechanics ( http://www.haskell.org/haskellwiki/Numeric_Quest )

numinstances : Instances of numeric classes for functions and tuples ( https://github.com/conal/NumInstances )

numtype : Type-level (low cardinality) integers ( http://dimensional.googlecode.com/ )

objectname : Explicitly handled object names ( http://www.haskell.org/HOpenGL/ )

oeis : Interface to the Online Encyclopedia of Integer Sequences (OEIS) ( http://hackage.haskell.org/package/oeis )

onetuple : Singleton Tuple ( http://hackage.haskell.org/package/OneTuple )

openal : A binding to the OpenAL cross-platform 3D audio API ( https://github.com/haskell-openal/ALUT )

opencl : Haskell high-level wrapper for OpenCL ( https://github.com/IFCA/opencl )

openclwrappers : The OpenCL Standard for heterogenous data-parallel computing ( https://github.com/jkarlson/OpenCLWrappers )

opengl : A binding for the OpenGL graphics system ( http://www.haskell.org/haskellwiki/Opengl )

openglraw : A raw binding for the OpenGL graphics system ( http://www.haskell.org/haskellwiki/Opengl )

openssl-streams : OpenSSL network support for io-streams ( http://hackage.haskell.org/package/openssl-streams )

operational : Implementation of difficult monads made easy with operational semantics ( http://haskell.org/haskellwiki/Operational )

options : A powerful and easy-to-use command-line option parser ( https://john-millikin.com/software/haskell-options/ )

optparse-applicative : Utilities and combinators for parsing command line options ( https://github.com/pcapriotti/optparse-applicative )

pandoc-citeproc : Supports using pandoc with citeproc ( http://hackage.haskell.org/package/pandoc-citeproc )

pandoc-types : Types for representing a structured document ( http://johnmacfarlane.net/pandoc )

pango : Binding to the Pango text rendering engine ( http://projects.haskell.org/gtk2hs/ )

parallel : Parallel programming library ( http://hackage.haskell.org/package/parallel )

parallel-io : Combinators for executing IO actions in parallel on a thread pool ( http://batterseapower.github.com/parallel-io )

parseargs : Command-line argument parsing library for Haskell programs ( http://github.com/BartMassey/parseargs )

parsec : Monadic parser combinators ( http://www.cs.uu.nl/~daan/parsec.html )

parsedate : Data and time parsing for CalendarTime ( http://www.cs.chalmers.se/~bringert/darcs/parsedate/doc/ )

parsers : Parsing combinators ( http://github.com/ekmett/parsers/ )

path-pieces : Components of paths ( http://hackage.haskell.org/package/path-pieces )

pathlib : A library for safe (file)path manipulation ( http://repos.mornfall.net/pathlib )

pathtype : Type-safe replacement for System.FilePath etc ( http://code.haskell.org/pathtype )

patience : Patience diff and longest increasing subsequence ( http://hackage.haskell.org/package/patience )

pattern-arrows : Arrows for Pretty Printing ( http://blog.functorial.com/posts/2013-10-27-Pretty-Printing-Arrows.html )

pcap : A system-independent interface for user-level packet capture ( https://github.com/bos/pcap )

pcre-light : A small, efficient and portable regex library for Perl 5 compatible regular expressions ( https://github.com/Daniel-Diaz/pcre-light )

pdfinfo : Wrapper around the pdfinfo command ( https://github.com/chrisdone/pdfinfo )

peggy : The Parser Generator for Haskell ( http://tanakh.github.io/Peggy/ )

pem : Privacy Enhanced Mail (PEM) format reader and writer ( http://github.com/vincenthz/hs-pem )

persistent : Type-safe, multi-backend data serialization ( http://www.yesodweb.com/book/persistent )

persistent-mongodb : Backend for the persistent library using mongoDB ( http://www.yesodweb.com/book/persistent )

persistent-mysql : Backend for the persistent library using MySQL database server ( http://www.yesodweb.com/book/persistent )

persistent-postgresql : Backend for the persistent library using postgresql ( http://www.yesodweb.com/book/persistent )

persistent-sqlite : Backend for the persistent library using sqlite3 ( http://www.yesodweb.com/book/persistent )

persistent-template : Type-safe, non-relational, multi-backend persistence ( http://www.yesodweb.com/book/persistent )

persistent-test : Tests for Persistent ( http://www.yesodweb.com/book/persistent )

pgm : Pure Haskell implementation of PGM image format ( https://github.com/astanin/haskell-pgm )

pipes : Compositional pipelines ( http://hackage.haskell.org/package/pipes )

pipes-concurrency : Concurrency for the pipes ecosystem ( http://hackage.haskell.org/package/pipes-concurrency )

pipes-network : Use network sockets together with the pipes library ( https://github.com/k0001/pipes-network )

pipes-safe : Safety for the pipes ecosystem ( http://hackage.haskell.org/package/pipes-safe )

plailude : plaimi's prelude ( https://secure.plaimi.net/works/plailude )

plugins : Dynamic linking for Haskell and C objects ( http://hub.darcs.net/stepcut/plugins )

plugins-auto : Automatic recompilation and reloading of haskell modules ( http://hackage.haskell.org/package/plugins-auto )

pngload : Pure Haskell loader for PNG images ( http://hackage.haskell.org/package/pngload )

pointed : Pointed and copointed data ( http://github.com/ekmett/pointed/ )

pointedlist : A zipper-like comonad which works as a list, tracking a position ( http://hackage.haskell.org/package/pointedlist )

pointfree : Tool for refactoring expressions into pointfree form ( http://hackage.haskell.org/package/pointfree )

pointful : Pointful refactoring tool ( http://github.com/23Skidoo/pointful )

poll : Bindings to poll.h ( http://hackage.haskell.org/package/poll )

polynomial : Polynomials ( https://github.com/mokus0/polynomial )

polyparse : A variety of alternative parser combinator libraries ( http://code.haskell.org/~malcolm/polyparse/ )

pool-conduit : Resource pool allocations via ResourceT. (deprecated) ( http://www.yesodweb.com/book/persistent )

pop3-client : POP3 Client Library ( https://github.com/tmrudick/haskell-pop3-client/ )

poppler : Binding to the Poppler ( http://www.haskell.org/gtk2hs/ )

portaudio : Haskell bindings for the PortAudio library ( http://code.haskell.org/portaudio )

postgresql-libpq : low-level binding to libpq ( http://github.com/lpsmith/postgresql-libpq )

postgresql-simple : Mid-Level PostgreSQL client library ( http://hackage.haskell.org/package/postgresql-simple )

pqc : Parallel batch driver for QuickCheck ( http://hub.darcs.net/shelarcy/pqc )

pqueue : Reliable, persistent, fast priority queues ( http://hackage.haskell.org/package/pqueue )

prelude-extras : Haskell 98 - higher order versions of Prelude classes ( http://github.com/ekmett/prelude-extras )

presburger : A decision procedure for quantifier-free linear arithmetic ( http://github.com/yav/presburger )

pretty-ncols : A implementation of multi-column layout w/ Text.PrettyPrint ( http://hackage.haskell.org/package/pretty-ncols )

pretty-show : Tools for working with derived 'Show' instances and generic inspection of values ( http://wiki.github.com/yav/pretty-show )

pretty-tree : Pretty-print trees ( http://hackage.haskell.org/package/pretty-tree )

prettyclass : Pretty printing class similar to Show ( http://hackage.haskell.org/package/prettyclass )

primes : Efficient, purely functional generation of prime numbers ( http://github.com/sebfisch/primes )

primitive : Primitive memory-related operations ( http://code.haskell.org/primitive )

probability : Probabilistic Functional Programming ( http://www.haskell.org/haskellwiki/Probabilistic_Functional_Programming )

proc : Parse process information for Linux ( http://hackage.haskell.org/package/proc )

process-conduit : Conduits for processes (deprecated) ( http://github.com/snoyberg/process-conduit )

process-extras : Process extras ( https://github.com/davidlazar/process-extras )

process-leksah : Process libraries ( http://hackage.haskell.org/package/process-leksah )

prof2dot : Convert GHC profiles into GraphViz's dot format ( http://antiope.com/downloads.html )

profiteur : Treemap visualiser for GHC prof files ( http://github.com/jaspervdj/profiteur )

profunctor-extras : This package has been absorbed into profunctors 4.0 ( http://github.com/ekmett/profunctor-extras/ )

profunctors : Profunctors ( http://github.com/ekmett/profunctors/ )

progression : Automates the recording and graphing of criterion benchmarks ( http://chplib.wordpress.com/2010/02/04/progression-supporting-optimisation-in-haskell/ )

project-template : Specify Haskell project templates and generate files ( https://github.com/fpco/haskell-ide )

prolog : A Prolog interpreter written in Haskell ( https://github.com/Erdwolf/prolog )

protocol-buffers : Parse Google Protocol Buffer specifications ( http://code.haskell.org/protocol-buffers/ )

protocol-buffers-descriptor : Text.DescriptorProto.Options and code generated from the Google Protocol Buffer specification ( http://code.haskell.org/protocol-buffers/ )

psqueue : Priority Search Queue ( http://hackage.haskell.org/package/PSQueue )

publicsuffixlist : Is a given string a domain suffix? ( https://github.com/litherum/publicsuffixlist )

punycode : Encode unicode strings to ascii forms according to RFC 3492 ( https://github.com/litherum/punycode )

pure-priority-queue : A pure priority queue ( http://hackage.haskell.org/package/pure-priority-queue )

puremd5 : A Haskell-only implementation of the MD5 digest (hash) algorithm ( http://hackage.haskell.org/package/pureMD5 )

pwstore-fast : Secure password storage ( https://github.com/PeterScott/pwstore )

qt : qtHaskell is a set of Haskell bindings for the Qt Widget Library from Nokia ( http://qthaskell.berlios.de/ )

qthaskellc : qtHaskell C bindings. qtHaskell is a set of Haskell bindings for the Qt Widget Library from Nokia ( http://qthaskell.berlios.de/ )

quickcheck : Automatic testing of Haskell programs ( https://github.com/nick8325/quickcheck )

quickcheck-assertions : HUnit like assertions for QuickCheck ( https://github.com/s9gf4ult/quickcheck-assertions )

quickcheck-instances : Common quickcheck instances ( https://github.com/aslatter/qc-instances )

quickcheck-io : Use HUnit assertions as QuickCheck properties ( http://hackage.haskell.org/package/quickcheck-io )

quicktest : A reflective batch tester for Haskell ( https://github.com/davidsiegel/quicktest )

random : random number library ( http://hackage.haskell.org/package/random )

random-fu : Random number generation ( https://github.com/mokus0/random-fu )

random-shuffle : Random shuffle implementation ( http://hackage.haskell.org/package/random-shuffle )

random-source : Generic basis for random number generators ( https://github.com/mokus0/random-fu )

ranged-sets : Ranged sets for Haskell ( http://code.haskell.org/ranged-sets )

ranges : Ranges and various functions on them ( http://hackage.haskell.org/package/ranges )

rank1dynamic : Like Data.Dynamic/Data.Typeable but with support for rank-1 polymorphic types ( http://github.com/haskell-distributed/distributed-process )

rasterific : A pure haskell drawing engine ( http://hackage.haskell.org/package/Rasterific )

raw-strings-qq : Raw string literals for Haskell ( https://github.com/23Skidoo/raw-strings-qq )

rdtsc : Binding for the rdtsc machine instruction ( http://code.haskell.org/rdtsc )

reactive-banana : Library for functional reactive programming (FRP) ( http://haskell.org/haskellwiki/Reactive-banana )

reactive-banana-glfw : reactive-banana for GLFW ( http://hackage.haskell.org/package/reactive-banana-glfw )

reactive-banana-wx : Examples for the reactive-banana library, using wxHaskell ( http://haskell.org/haskellwiki/Reactive-banana )

readargs : Simple command line argument parsing ( http://github.com/rampion/ReadArgs )

readline : An interface to the GNU readline library ( http://hackage.haskell.org/package/readline )

recaptcha : Functions for using the reCAPTCHA service in web applications ( http://github.com/jgm/recaptcha/tree/master )

records : A flexible record system ( http://darcs.wolfgang.jeltsch.info/haskell/records )

recursion-schemes : Generalized bananas, lenses and barbed wire ( http://github.com/ekmett/recursion-schemes/ )

reducers : Semigroups, specialized containers and a general map/reduce framework ( http://github.com/ekmett/reducers/ )

reflection : Reifies arbitrary terms into types that can be reflected back into terms ( http://github.com/ekmett/reflection )

refserialize : Write to and read from ByteStrings maintaining internal memory references ( http://hackage.haskell.org/package/RefSerialize )

regex-base : Replaces/Enhances Text.Regex ( http://sourceforge.net/projects/lazy-regex )

regex-compat : Replaces/Enhances Text.Regex ( http://sourceforge.net/projects/lazy-regex )

regex-compat-tdfa : Unicode Support version of Text.Regex, using regex-tdfa ( http://hub.darcs.net/shelarcy/regex-compat-tdfa )

regex-dfa : Replaces/Enhances Text.Regex ( http://sourceforge.net/projects/lazy-regex )

regex-parsec : Replaces/Enhances Text.Regex ( http://sourceforge.net/projects/lazy-regex )

regex-pcre : Replaces/Enhances Text.Regex ( http://hackage.haskell.org/package/regex-pcre )

regex-pcre-builtin : Replaces/Enhances Text.Regex ( http://hackage.haskell.org/package/regex-pcre )

regex-posix : Replaces/Enhances Text.Regex ( http://sourceforge.net/projects/lazy-regex )

regex-tdfa : Replaces/Enhances Text.Regex ( http://hackage.haskell.org/package/regex-tdfa )

regex-tdfa-rc : Replaces/Enhances Text.Regex ( http://hackage.haskell.org/package/regex-tdfa )

regex-tdfa-text : Text interface for regex-tdfa ( http://hackage.haskell.org/package/regex-tdfa-text )

regex-tre : Replaces/Enhances Text.Regex ( http://sourceforge.net/projects/lazy-regex )

regexpr : regular expression like Perl/Ruby in Haskell ( http://homepage3.nifty.com/salamander/second/projects/regexpr/ )

regular : Generic programming library for regular datatypes ( http://hackage.haskell.org/package/regular )

rematch : A simple api for matchers ( http://hackage.haskell.org/package/rematch )

remote : Cloud Haskell. Fault-tolerant distributed computing framework ( http://hackage.haskell.org/package/remote )

repa : High performance, regular, shape polymorphic parallel arrays ( http://repa.ouroborus.net )

repa-algorithms : Algorithms using the Repa array library ( http://repa.ouroborus.net )

repa-devil : Support for image reading and writing of Repa arrays using in-place FFI calls ( https://github.com/RaphaelJ/repa-devil )

repa-io : Read and write Repa arrays in various formats ( http://repa.ouroborus.net )

replib : Generic programming library with representation types ( http://code.google.com/p/replib/ )

representable-functors : Representable functors ( http://github.com/ekmett/representable-functors/ )

representable-tries : Tries from representations of polynomial functors ( http://github.com/ekmett/representable-tries/ )

resource-pool : A high-performance striped resource pooling implementation ( http://github.com/bos/pool )

resourcet : Deterministic allocation and freeing of scarce resources ( http://github.com/snoyberg/conduit )

retry : Retry combinators for monadic actions that may fail ( http://github.com/Soostone/retry )

rfc5051 : Simple unicode collation as per RFC5051 ( http://hackage.haskell.org/package/rfc5051 )

rmonad : Restricted monad library ( http://hackage.haskell.org/package/rmonad )

rosezipper : Generic zipper implementation for Data.Tree ( http://hackage.haskell.org/package/rosezipper )

rsa : Implementation of RSA, using the padding schemes of PKCS#1 v2.1 ( http://hackage.haskell.org/package/RSA )

rss : A library for generating RSS 2.0 feeds ( https://github.com/basvandijk/rss )

rvar : Random Variables ( https://github.com/mokus0/random-fu )

safe : Library of safe (exception free) functions ( http://community.haskell.org/~ndm/safe/ )

safecopy : Binary serialization with version control ( http://acid-state.seize.it/safecopy )

safesemaphore : Much safer replacement for QSemN, QSem, and SampleVar ( https://github.com/ChrisKuklewicz/SafeSemaphore )

sample-frame : Handling of samples in an (audio) signal ( http://www.haskell.org/haskellwiki/Synthesizer )

sample-frame-np : Orphan instances for types from sample-frame and numericprelude ( http://www.haskell.org/haskellwiki/Synthesizer )

scientific : Numbers represented using scientific notation ( https://github.com/basvandijk/scientific )

scion-browser : Command-line interface for browsing and searching packages documentation ( http://github.com/JPMoresmau/scion-class-browser )

scotty : Haskell web framework inspired by Ruby's Sinatra, using WAI and Warp ( https://github.com/scotty-web/scotty )

scotty-hastache : Easy Mustache templating support for Scotty ( https://github.com/scotty-web/scotty-hastache )

sdl : Binding to libSDL ( http://hackage.haskell.org/package/SDL )

sdl-gfx : Binding to libSDL_gfx ( http://hackage.haskell.org/package/SDL-gfx )

sdl-image : Binding to libSDL_image ( http://hackage.haskell.org/package/SDL-image )

sdl-mixer : Binding to libSDL_mixer ( http://hackage.haskell.org/package/SDL-mixer )

sdl-ttf : Binding to libSDL_ttf ( http://hackage.haskell.org/package/SDL-ttf )

securemem : abstraction to an auto scrubbing and const time eq, memory chunk ( http://github.com/vincenthz/hs-securemem )

semigroupoid-extras : This package has been absorbed into semigroupoids 4.0 ( http://github.com/ekmett/semigroupoid-extras )

semigroupoids : Semigroupoids: Category sans id ( http://github.com/ekmett/semigroupoids )

semigroups : Anything that associates ( http://github.com/ekmett/semigroups/ )

sendfile : A portable sendfile library ( http://hub.darcs.net/stepcut/sendfile )

setenv : A cross-platform library for setting environment variables ( http://hackage.haskell.org/package/setenv )

setlocale : Haskell bindings to setlocale ( http://hackage.haskell.org/package/setlocale )

sfml-audio : minimal bindings to the audio module of sfml ( http://patch-tag.com/r/shahn/sfml-audio )

sha : Implementations of the SHA suite of message digest functions ( http://hackage.haskell.org/package/SHA )

shake : Build system library, like Make, but more accurate dependencies ( https://github.com/ndmitchell/shake#readme )

shakespeare : A toolkit for making compile-time interpolated templates ( http://www.yesodweb.com/book/shakespearean-templates )

shakespeare-css : Stick your haskell variables into css at compile time. (deprecated) ( http://www.yesodweb.com/book/shakespearean-templates )

shakespeare-i18n : A type-based approach to internationalization. (deprecated) ( http://www.yesodweb.com/book/shakespearean-templates )

shakespeare-js : Stick your haskell variables into javascript/coffeescript at compile time. (deprecated) ( http://www.yesodweb.com/book/shakespearean-templates )

shakespeare-text : Interpolation with quasi-quotation: put variables strings (deprecated) ( http://www.yesodweb.com/book/shakespearean-templates )

shellac : A framework for creating shell envinronments ( http://rwd.rdockins.name/shellac/home/ )

shellac-compatline : "compatline" backend module for Shellac ( http://rwd.rdockins.name/shellac/home/ )

shellac-editline : Editline backend module for Shellac ( http://rwd.rdockins.name/shellac/home/ )

shellac-readline : Readline backend module for Shellac ( http://rwd.rdockins.name/shellac/home/ )

shellish : shell-/perl- like (systems) programming in Haskell ( http://repos.mornfall.net/shellish )

shelly : shell-like (systems) programming in Haskell ( https://github.com/yesodweb/Shelly.hs )

show : 'Show' instances for Lambdabot ( http://hackage.haskell.org/package/show )

shuffle : Shuffle tool for UHC ( https://github.com/UU-ComputerScience/shuffle )

silently : Prevent or capture writing to stdout and other handles ( https://github.com/trystan/silently )

simple-reflect : Simple reflection of expressions containing variables ( http://twanvl.nl/blog/haskell/simple-reflection-of-expressions )

simple-sendfile : Cross platform library for the sendfile system call ( http://hackage.haskell.org/package/simple-sendfile )

simpleirc : Simple IRC Library ( http://github.com/dom96/SimpleIRC )

singletons : A framework for generating singleton types ( http://www.cis.upenn.edu/~eir/packages/singletons )

skein : Skein, a family of cryptographic hash functions. Includes Skein-MAC as well ( https://github.com/meteficha/skein )

smallcheck : A property-based testing library ( https://github.com/feuerbach/smallcheck )

smtlib : A library for working with the SMTLIB format ( http://hackage.haskell.org/package/smtLib )

smtpclient : A simple SMTP client library ( http://hackage.haskell.org/package/SMTPClient )

snap : Top-level package for the Snap Web Framework ( http://snapframework.com/ )

snap-app : Simple modules for writing apps with Snap, abstracted from hpaste ( Simple modules for writing apps with Snap, abstracted from hpaste. )

snap-core : Snap: A Haskell Web Framework (core interfaces and types) ( http://snapframework.com/ )

snap-loader-dynamic : Snap: A Haskell Web Framework: dynamic loader ( http://snapframework.com/ )

snap-loader-static : Snap: A Haskell Web Framework: static loader ( http://snapframework.com/ )

snap-server : A fast, iteratee-based, epoll-enabled web server for the Snap Framework ( http://snapframework.com/ )

sockaddr : Printing SockAddr ( http://hackage.haskell.org/package/sockaddr )

socks : Socks proxy (version 5) implementation ( http://github.com/vincenthz/hs-socks )

sodium : Sodium Reactive Programming (FRP) System ( http://hackage.haskell.org/package/sodium )

soegtk : GUI functions as used in the book \"The Haskell School of Expression\" ( http://projects.haskell.org/gtk2hs/ )

sourcegraph : Static code analysis using graph-theoretic techniques ( http://hackage.haskell.org/package/SourceGraph )

sourcemap : Implementation of source maps as proposed by Google and Mozilla ( http://hackage.haskell.org/package/sourcemap )

sox : Play, write, read, convert audio signals using Sox ( http://www.haskell.org/haskellwiki/Sox )

speculation : A framework for safe, programmable, speculative parallelism ( http://github.com/ekmett/speculation )

split : Combinator library for splitting lists ( http://hackage.haskell.org/package/split )

spoon : Catch errors thrown from pure computations ( http://hackage.haskell.org/package/spoon )

srcloc : Data types for managing source code locations ( http://www.cs.drexel.edu/~mainland/ )

stateref : Abstraction for things that work like IORef ( http://hackage.haskell.org/package/stateref )

statestack : Simple State-like monad transformer with saveable and restorable state ( http://hackage.haskell.org/package/statestack )

statevar : State variables ( http://www.haskell.org/HOpenGL/ )

static-hash : Immutable hash ( http://hackage.haskell.org/package/static-hash )

statistics : A library of statistical types, data, and functions ( https://github.com/bos/statistics )

stickykeyshotkey : get and set STICKYKEYS.SKF_HOTKEYACTIVE ( http://hackage.haskell.org/package/stickyKeysHotKey )

stm : Software Transactional Memory ( http://hackage.haskell.org/package/stm )

stm-chans : Additional types of channels for STM ( http://code.haskell.org/~wren/ )

stm-conduit : Introduces conduits to channels, and promotes using conduits concurrently ( https://github.com/wowus/stm-conduit )

stm-split : TMVars, TVars and TChans with distinguished input and output side ( http://hackage.haskell.org/package/stm-split )

stmonadtrans : A monad transformer version of the ST monad ( http://hackage.haskell.org/package/STMonadTrans )

storable-complex : Storable instance for Complex ( http://hackage.haskell.org/package/storable-complex )

storable-record : Elegant definition of Storable instances for records ( http://code.haskell.org/~thielema/storable-record/ )

storable-tuple : Storable instance for pairs and triples ( http://code.haskell.org/~thielema/storable-tuple/ )

storablevector : Fast, packed, strict storable arrays with a list interface like ByteString ( http://www.haskell.org/haskellwiki/Storable_Vector )

strategylib : attempt to convert Strafunski's StrategyLib to a heirarchical library ( http://naesten.dyndns.org:8080/repos/StrategyLib )

stream : A library for manipulating infinite lists ( http://hackage.haskell.org/package/Stream )

stream-fusion : Faster Haskell lists using stream fusion ( http://hackage.haskell.org/trac/ghc/ticket/915 )

streaming-commons : Common lower-level functions needed by various streaming data libraries ( https://github.com/fpco/streaming-commons )

streamproc : Stream Processer Arrow ( http://github.com/peti/streamproc )

strict : Strict data types and String IO ( http://www.cse.unsw.edu.au/~rl/code/strict.html )

strict-concurrency : Strict concurrency abstractions ( http://code.haskell.org/~dons/code/strict-concurrency )

strictify : Find a local optimum of strictness annotations ( http://hackage.haskell.org/package/strictify )

string-qq : QuasiQuoter for non-interpolated strings, texts and bytestrings ( http://hackage.haskell.org/package/string-qq )

stringable : A Stringable type class, in the spirit of Foldable and Traversable ( http://hackage.haskell.org/package/stringable )

stringbuilder : A writer monad for multi-line string literals ( http://hackage.haskell.org/package/stringbuilder )

stringprep : Implements the "StringPrep" algorithm ( http://hackage.haskell.org/package/stringprep )

stringsearch : Fast searching, splitting and replacing of ByteStrings ( https://bitbucket.org/dafis/stringsearch )

stringtable-atom : Memoize Strings as Atoms for fast comparison and sorting, with maps and sets ( http://github.com/audreyt/stringtable-atom/ )

strptime : Efficient parsing of LocalTime using a binding to C's strptime ( http://hackage.haskell.org/package/strptime )

stylish-haskell : Haskell code prettifier ( https://github.com/jaspervdj/stylish-haskell )

suffixtree : Efficient, lazy suffix tree implementation ( http://www.serpentine.com/software/suffixtree/ )

suitable : Abstract over the constraints on the parameters to type constructors ( http://hackage.haskell.org/package/suitable )

svgcairo : Binding to the libsvg-cairo library ( http://projects.haskell.org/gtk2hs/ )

svgfonts : Fonts from the SVG-Font format ( http://hackage.haskell.org/package/SVGFonts )

syb : Scrap Your Boilerplate ( http://www.cs.uu.nl/wiki/GenericProgramming/SYB )

syb-with-class : Scrap Your Boilerplate With Class ( http://hackage.haskell.org/package/syb-with-class )

syb-with-class-instances-text : Scrap Your Boilerplate With Class Text instance ( http://hackage.haskell.org/cgi-bin/hackage-scripts/package/syb-with-class-instances-text )

symbol : A 'Symbol' type for fast symbol comparison ( http://www.cs.drexel.edu/~mainland/ )

synthesizer-core : Audio signal processing coded in Haskell: Low level part ( http://www.haskell.org/haskellwiki/Synthesizer )

system-argv0 : Get argv[0] as a FilePath ( https://john-millikin.com/software/haskell-filesystem/ )

system-fileio : Consistent filesystem interaction across GHC versions ( https://john-millikin.com/software/haskell-filesystem/ )

system-filepath : High-level, byte-based file and directory path manipulations ( https://john-millikin.com/software/haskell-filesystem/ )

system-posix-redirect : A toy module to temporarily redirect a program's stdout ( http://hackage.haskell.org/package/system-posix-redirect )

system-time-monotonic : Simple library for using the system's monotonic clock ( https://github.com/joeyadams/haskell-system-time-monotonic )

tables : In-memory storage with multiple keys using lenses and traversals ( http://github.com/ekmett/tables/ )

tabular : Two-dimensional data tables with rendering functions ( http://hub.darcs.net/kowey/tabular )

tag-bits : Provides access to the dynamic pointer tagging bits used by GHC ( http://github.com/ekmett/tag-bits )

tagged : Haskell 98 phantom types to avoid unsafely passing dummy arguments ( http://github.com/ekmett/tagged )

tagged-transformer : Provides newtype wrappers for phantom types to avoid unsafely passing dummy arguments ( http://github.com/ekmett/tagged-transformer )

tagshare : TagShare - explicit sharing with tags ( http://hackage.haskell.org/package/tagshare )

tagsoup : Parsing and extracting information from (possibly malformed) HTML/XML documents ( http://community.haskell.org/~ndm/tagsoup/ )

tagsoup-parsec : Tokenizes Tag, so [ Tag ] can be used as parser input ( http://www.killersmurf.com )

tagstream-conduit : streamlined html tag parser ( http://github.com/yihuang/tagstream-conduit )

takusen : Database library with left-fold interface, for PostgreSQL, Oracle, SQLite, ODBC ( http://hackage.haskell.org/package/Takusen )

tar : Reading, writing and manipulating ".tar" archive files ( http://hackage.haskell.org/package/tar )

tasty : Modern and extensible testing framework ( http://documentup.com/feuerbach/tasty )

tasty-ant-xml : Render tasty output to XML for Jenkins ( http://github.com/ocharles/tasty-ant-xml )

tasty-golden : Golden tests support for tasty ( https://github.com/feuerbach/tasty-golden )

tasty-hunit : HUnit support for the Tasty test framework ( http://documentup.com/feuerbach/tasty )

tasty-quickcheck : QuickCheck support for the Tasty test framework ( http://documentup.com/feuerbach/tasty )

tasty-rerun : Run tests by filtering the test tree depending on the result of previous test runs ( http://github.com/ocharles/tasty-rerun )

tasty-smallcheck : SmallCheck support for the Tasty test framework ( http://documentup.com/feuerbach/tasty )

tasty-th : Automagically generate the HUnit- and Quickcheck-bulk-code using Template Haskell ( http://github.com/bennofs/tasty-th )

tcache : A Transactional cache with user-defined persistence ( http://hackage.haskell.org/package/TCache )

template : Simple string substitution ( http://hackage.haskell.org/package/template )

temporary : Portable temporary file and directory support for Windows and Unix, based on code from Cabal ( http://www.github.com/batterseapower/temporary )

temporary-rc : Portable temporary file and directory support for Windows and Unix, based on code from Cabal ( http://www.github.com/feuerbach/temporary )

tensor : Tensor data types ( http://www.haskell.org/HOpenGL/ )

terminal-size : Get terminal window height and width ( http://hackage.haskell.org/package/terminal-size )

terminfo : Haskell bindings to the terminfo library ( https://github.com/judah/terminfo )

test-framework : Framework for running and organising tests, with HUnit and QuickCheck support ( https://batterseapower.github.io/test-framework/ )

test-framework-hunit : HUnit support for the test-framework package ( https://batterseapower.github.io/test-framework/ )

test-framework-quickcheck : QuickCheck support for the test-framework package ( http://batterseapower.github.com/test-framework/ )

test-framework-quickcheck2 : QuickCheck2 support for the test-framework package ( https://batterseapower.github.io/test-framework/ )

test-framework-smallcheck : Support for SmallCheck tests in test-framework ( https://github.com/feuerbach/smallcheck )

test-framework-th : Automagically generate the HUnit- and Quickcheck-bulk-code using Template Haskell ( http://github.com/finnsson/test-generator )

test-framework-th-prime : Template Haskell for test framework ( http://hackage.haskell.org/package/test-framework-th-prime )

testing-feat : Functional Enumeration of Algebraic Types ( http://hackage.haskell.org/package/testing-feat )

testpack : Test Utililty Pack for HUnit and QuickCheck ( http://hackage.haskell.org/cgi-bin/hackage-scripts/package/testpack )

texmath : Conversion between formats used to represent mathematics ( http://github.com/jgm/texmath )

text : An efficient packed Unicode text type ( https://github.com/bos/text )

text-format : Text formatting ( https://github.com/bos/text-format )

text-format-simple : Simple text formatting library ( http://hackage.haskell.org/package/text-format-simple )

text-icu : Bindings to the ICU library ( https://github.com/bos/text-icu )

text-stream-decode : Streaming decoding functions for UTF encodings. (deprecated) ( http://github.com/fpco/text-stream-decode )

tf-random : High-quality splittable pseudorandom number generator ( http://hackage.haskell.org/package/tf-random )

tga : Reading and writing of tga image files ( http://hackage.haskell.org/package/tga )

th-desugar : Functions to desugar Template Haskell ( http://www.cis.upenn.edu/~eir/packages/th-desugar )

th-extras : A grab bag of functions for use with Template Haskell ( https://github.com/mokus0/th-extras )

th-lift : Derive Template Haskell's Lift class for datatypes ( http://hackage.haskell.org/package/th-lift )

th-orphans : Orphan instances for TH datatypes ( http://hackage.haskell.org/package/th-orphans )

threads : Fork threads and wait for their result ( https://github.com/basvandijk/threads )

threepenny-gui : GUI framework that uses the web browser as a display ( http://www.haskell.org/haskellwiki/Threepenny-gui )

thyme : A faster time library ( https://github.com/liyang/thyme )

tidal : Pattern language for improvised music ( http://yaxu.org/tidal/ )

time-compat : Compatibility with old-time for the time package ( http://hub.darcs.net/dag/time-compat )

time-lens : Lens-based interface to Data.Time data structures ( http://hackage.haskell.org/package/time-lens )

timeit : Time a computation ( http://hackage.haskell.org/package/timeit )

timeplot : A tool for visualizing time series from log files ( http://haskell.org/haskellwiki/Timeplot )

timezone-olson : A pure Haskell parser and renderer for binary Olson timezone files ( http://projects.haskell.org/time-ng/ )

timezone-series : Enhanced timezone handling for Data.Time ( http://projects.haskell.org/time-ng/ )

tls : TLS/SSL protocol native implementation (Server and Client) ( http://github.com/vincenthz/hs-tls )

tls-extra : TLS extra default values and helpers ( http://github.com/vincenthz/hs-tls )

top : Constraint solving framework employed by the Helium Compiler ( http://www.cs.uu.nl/wiki/bin/view/Helium/WebHome )

transformers : Concrete functor and monad transformers ( http://hackage.haskell.org/package/transformers )

transformers-base : Lift computations from the bottom of a transformer stack ( https://github.com/mvv/transformers-base )

transformers-compat : A small compatibility shim for dev-haskell/transformers ( http://github.com/ekmett/transformers-compat/ )

traverse-with-class : Generic applicative traversals ( http://hackage.haskell.org/package/traverse-with-class )

trifecta : A modern parser combinator library with convenient diagnostics ( http://github.com/ekmett/trifecta/ )

tuple : Various functions on tuples ( http://hackage.haskell.org/package/tuple )

tuple-th : Generate (non-recursive) utility functions for tuples of statically known size ( http://hackage.haskell.org/package/tuple-th )

txt-sushi : The SQL link in your *NIX chain ( http://keithsheppard.name/txt-sushi )

type-eq : Type equality evidence you can carry around ( http://github.com/glaebhoerl/type-eq )

type-equality : Type equality, coercion/cast and other operations ( http://github.com/hesselink/type-equality/ )

type-equality-check : Type equality check ( http://darcs.wolfgang.jeltsch.info/haskell/type-equality-check )

type-functions : Emulation of type-level functions ( http://darcs.wolfgang.jeltsch.info/haskell/type-functions )

type-level : Type-level programming library ( http://code.haskell.org/type-level )

type-level-numbers : Type level numbers implemented using type families ( http://hackage.haskell.org/package/type-level-numbers )

typecompose : Type composition classes and instances ( https://github.com/conal/TypeCompose )

uhc-util : UHC utilities ( https://github.com/UU-ComputerScience/uhc-utils )

unamb : Unambiguous choice ( http://haskell.org/haskellwiki/unamb )

unbound : Generic support for programming with names and binders ( http://code.google.com/p/replib/ )

unbounded-delays : Unbounded thread delays and timeouts ( https://github.com/basvandijk/unbounded-delays )

unification-fd : Simple generic unification algorithms ( http://code.haskell.org/~wren/ )

union-find : Efficient union and equivalence testing of sets ( http://github.com/nominolo/union-find )

uniplate : Help writing simple, concise and fast generic operations ( http://community.haskell.org/~ndm/uniplate/ )

uniqueid : Splittable Unique Identifier Supply ( http://github.com/sebfisch/uniqueid/wikis )

unix-compat : Portable POSIX-compatibility layer ( http://github.com/jystic/unix-compat )

unix-memory : Unix memory syscalls ( http://github.com/vincenthz/hs-unix-memory )

unix-process-conduit : Run processes on Unix systems, with a conduit interface (deprecated) ( https://github.com/snoyberg/conduit )

unix-time : Unix time parser/formatter and utilities ( http://hackage.haskell.org/package/unix-time )

unixutils : A crude interface between Haskell and Unix-like operating systems ( http://src.seereason.com/haskell-unixutils )

unlambda : Unlambda interpreter ( http://hackage.haskell.org/package/unlambda )

unordered-containers : Efficient hashing-based container types ( https://github.com/tibbe/unordered-containers )

unsafe : Unified interface to unsafe functions ( http://code.haskell.org/~thielema/unsafe/ )

uri : Library for working with URIs ( http://gitorious.org/uri )

uri-conduit : Read and write URIs (deprecated) ( http://github.com/snoyberg/xml )

url : A library for working with URLs ( http://www.haskell.org/haskellwiki/Url )

urlencoded : Generate or process x-www-urlencoded data ( https://github.com/pheaver/urlencoded )

utf8-light : Unicode ( http://hackage.haskell.org/package/utf8-light )

utf8-string : Support for reading and writing UTF8 Strings ( http://github.com/glguy/utf8-string/ )

utility-ht : Various small helper functions for Lists, Maybes, Tuples, Functions ( http://hackage.haskell.org/package/utility-ht )

utilitytm : Utility functions that are missing from the standard library ( https://github.com/tonymorris/utility-tm )

uu-interleaved : Providing an interleaving combinator for use with applicative/alternative style implementations ( http://www.cs.uu.nl/wiki/bin/view/HUT/ParserCombinators )

uu-parsinglib : Utrecht University parser combinator library ( http://www.cs.uu.nl/wiki/bin/view/HUT/ParserCombinators )

uuagc : Attribute Grammar System of Universiteit Utrecht ( http://www.cs.uu.nl/wiki/HUT/WebHome )

uuagc-bootstrap : Attribute Grammar System of Universiteit Utrecht ( http://www.cs.uu.nl/wiki/HUT/WebHome )

uuagc-cabal : Cabal plugin for the Universiteit Utrecht Attribute Grammar System ( http://www.cs.uu.nl/wiki/HUT/WebHome )

uuid : For creating, comparing, parsing and printing Universally Unique Identifiers ( http://projects.haskell.org/uuid/ )

uulib : Haskell Utrecht Tools Library ( http://www.cs.uu.nl/wiki/HUT/WebHome )

vacuum : Graph representation of the GHC heap ( http://thoughtpolice.github.com/vacuum )

vacuum-cairo : Visualize live Haskell data structures using vacuum, graphviz and cairo ( http://code.haskell.org/~dons/code/vacuum-cairo )

vacuum-graphviz : A library for transforming vacuum graphs into GraphViz output ( http://hackage.haskell.org/package/vacuum-graphviz )

vado : Runs commands on remote machines using ssh ( https://github.com/hamishmack/vado )

vault : a persistent store for values of arbitrary types ( https://github.com/HeinrichApfelmus/vault )

vcs-revision : Facilities for accessing the version control revision of the current directory ( http://hackage.haskell.org/package/vcs-revision )

vcsgui : GUI library for source code management systems ( https://github.com/leksah/haskellVCSGUI )

vcswrapper : Wrapper for source code management systems ( https://github.com/forste/haskellVCSWrapper )

vector : Efficient Arrays ( https://github.com/haskell/vector )

vector-algorithms : Efficient algorithms for vector arrays ( http://code.haskell.org/~dolio/ )

vector-binary-instances : Instances of Data.Binary and Data.Serialize for vector ( https://github.com/bos/vector-binary-instances )

vector-instances : Orphan Instances for 'Data.Vector' ( http://github.com/ekmett/vector-instances )

vector-random : Generate vectors filled with high quality pseudorandom numbers ( http://code.haskell.org/~dons/code/vector-random )

vector-space : Vector and affine spaces, linear maps, and derivatives ( http://hackage.haskell.org/package/vector-space )

vector-space-points : A type for points, as distinct from vectors ( http://hackage.haskell.org/package/vector-space-points )

vector-th-unbox : Deriver for Data.Vector.Unboxed using Template Haskell ( http://hackage.haskell.org/package/vector-th-unbox )

vinyl : Extensible Records ( http://hackage.haskell.org/package/vinyl )

vinyl-gl : Utilities for working with OpenGL's GLSL shading language and vinyl records ( http://hackage.haskell.org/package/vinyl-gl )

void : A Haskell 98 logically uninhabited data type ( http://github.com/ekmett/void )

vte : Binding to the VTE library ( http://projects.haskell.org/gtk2hs/ )

vty : A simple terminal UI library ( https://github.com/coreyoconnor/vty )

vty-ui : An interactive terminal user interface library for Vty ( http://jtdaugherty.github.com/vty-ui/ )

wai : Web Application Interface ( https://github.com/yesodweb/wai )

wai-app-file-cgi : File/CGI/Rev Proxy App of WAI ( http://www.mew.org/~kazu/proj/mighttpd/ )

wai-app-static : WAI application for static serving ( http://www.yesodweb.com/book/web-application-interface )

wai-conduit : conduit wrappers for WAI ( https://github.com/yesodweb/wai )

wai-eventsource : WAI support for server-sent events (deprecated) ( http://www.yesodweb.com/book/web-application-interface )

wai-extra : Provides some basic WAI handlers and middleware ( http://github.com/yesodweb/wai )

wai-handler-devel : WAI server that automatically reloads code after modification. (deprecated) ( http://github.com/yesodweb/wai )

wai-handler-launch : Launch a web app in the default browser ( http://hackage.haskell.org/package/wai-handler-launch )

wai-logger : A logging system for WAI ( http://hackage.haskell.org/package/wai-logger )

wai-logger-prefork : A logging system for preforked WAI apps ( http://hackage.haskell.org/package/wai-logger-prefork )

wai-test : Unit test framework (built on HUnit) for WAI applications. (deprecated) ( http://www.yesodweb.com/book/web-application-interface )

warp : A fast, light-weight web server for WAI applications ( http://github.com/yesodweb/wai )

warp-tls : HTTP over SSL/TLS support for Warp via the TLS package ( http://github.com/yesodweb/wai )

washngo : WASH is a family of EDSLs for programming Web applications in Haskell ( http://www.informatik.uni-freiburg.de/~thiemann/haskell/WASH/ )

wave : WAVE audio file IO library ( http://github.com/BartMassey/WAVE )

web-encodings : Encapsulate multiple web encoding in a single package. (deprecated) ( http://hackage.haskell.org/package/web-encodings )

web-plugins : dynamic plugin system for web applications ( http://www.happstack.com/ )

web-routes : Library for maintaining correctness and composability of URLs within an application ( http://hackage.haskell.org/package/web-routes )

web-routes-happstack : Adds support for using web-routes with Happstack ( http://hackage.haskell.org/package/web-routes-happstack )

webkit : Binding to the Webkit library ( http://projects.haskell.org/gtk2hs/ )

webkitgtk-javascriptcore : JavaScriptCore FFI from webkitgtk ( http://hackage.haskell.org/package/webkitgtk3-javascriptcore )

webserver : HTTP server library ( http://hackage.haskell.org/package/webserver )

websockets : A sensible and clean way to write WebSocket-capable servers in Haskell ( http://jaspervdj.be/websockets )

websockets-snap : Snap integration for the websockets library ( http://hackage.haskell.org/package/websockets-snap )

wizards : High level, generic library for interrogative user interfaces ( http://hackage.haskell.org/package/wizards )

wl-pprint : The Wadler/Leijen Pretty Printer ( http://hackage.haskell.org/package/wl-pprint )

wl-pprint-extras : A free monad based on the Wadler/Leijen pretty printer ( http://github.com/ekmett/wl-pprint-extras/ )

wl-pprint-terminfo : A color pretty printer with terminfo support ( http://github.com/ekmett/wl-pprint-terminfo/ )

wl-pprint-text : A Wadler/Leijen Pretty Printer for Text values ( http://hackage.haskell.org/package/wl-pprint-text )

word8 : Word8 library ( http://hackage.haskell.org/package/word8 )

wordexp : wordexp(3) wrappers ( http://hackage.haskell.org/package/wordexp )

wraparound : Convenient handling of points on a seamless 2-dimensional plane ( http://frigidcode.com )

wreq : An easy-to-use HTTP client library ( http://www.serpentine.com/wreq )

wxc : wxHaskell C++ wrapper ( http://haskell.org/haskellwiki/WxHaskell )

wxcore : wxHaskell core ( http://haskell.org/haskellwiki/WxHaskell )

wxdirect : helper tool for building wxHaskell ( http://haskell.org/haskellwiki/WxHaskell )

wxhaskell : wxHaskell ( http://haskell.org/haskellwiki/WxHaskell )

x11 : A binding to the X11 graphics library ( https://github.com/haskell-pkg-janitors/X11 )

x11-xft : Bindings to the Xft, X Free Type interface library, and some Xrender parts ( http://hackage.haskell.org/package/X11-xft )

x509 : X509 reader and writer ( http://github.com/vincenthz/hs-certificate )

x509-store : X.509 collection accessing and storing methods ( http://github.com/vincenthz/hs-certificate )

x509-system : Handle per-operating-system X.509 accessors and storage ( http://github.com/vincenthz/hs-certificate )

x509-validation : X.509 Certificate and CRL validation ( http://github.com/vincenthz/hs-certificate )

xattr : Haskell extended file attributes interface ( http://hackage.haskell.org/package/xattr )

xcb-types : Parses XML files used by the XCB project ( http://community.haskell.org/~aslatter/code/xcb-types )

xdg-basedir : A basic implementation of the XDG Base Directory specification ( http://github.com/willdonnelly/xdg-basedir )

xdot : Parse Graphviz xdot files and interactively view them using GTK and Cairo ( http://hackage.haskell.org/package/xdot )

xformat : Extensible, type-safe formatting with scanf- and printf-like functions ( http://github.com/spl/xformat )

xhtml : An XHTML combinator library ( https://github.com/haskell/xhtml )

xhtml-combinators : Fast and easy to use XHTML combinators ( http://www.dcs.shef.ac.uk/~aca08aa/xhtmlc.html )

xml : A simple XML library ( http://code.galois.com )

xml-catalog : Parse XML catalog files (deprecated) ( http://github.com/snoyberg/xml )

xml-conduit : Pure-Haskell utilities for dealing with XML with the conduit package ( http://github.com/snoyberg/xml )

xml-hamlet : Hamlet-style quasiquoter for XML content ( http://www.yesodweb.com/ )

xml-html-conduit-lens : Optics for xml-conduit and html-conduit ( https://github.com/supki/xml-html-conduit-lens#readme )

xml-picklers : XML picklers based on xml-types, ported from hexpat-pickle ( http://hackage.haskell.org/package/xml-picklers )

xml-types : Basic types for representing XML ( https://john-millikin.com/software/haskell-xml/ )

xmlgen : Fast XML generation library ( http://hackage.haskell.org/package/xmlgen )

xmlhtml : XML parser and renderer with HTML 5 quirks mode ( http://hackage.haskell.org/package/xmlhtml )

xmms : XMMS2 client library ( http://kawais.org.ua/XMMS/ )

xmonad-screenshot : Workspaces screenshooting utility for XMonad ( http://github.com/supki/xmonad-screenshot )

xss-sanitize : sanitize untrusted HTML to prevent XSS attacks ( http://github.com/yesodweb/haskell-xss-sanitize )

yaml : Support for parsing and rendering YAML documents ( http://github.com/snoyberg/yaml/ )

yesod : Creation of type-safe, RESTful web applications ( http://www.yesodweb.com/ )

yesod-auth : Authentication for Yesod ( http://www.yesodweb.com/ )

yesod-auth-hashdb : Authentication plugin for Yesod ( http://www.yesodweb.com/ )

yesod-bin : The yesod helper executable ( http://www.yesodweb.com/ )

yesod-core : Creation of type-safe, RESTful web applications ( http://www.yesodweb.com/ )

yesod-default : Default config and main functions for your yesod application (deprecated) ( http://www.yesodweb.com/ )

yesod-eventsource : Server-sent events support for Yesod apps ( http://www.yesodweb.com/ )

yesod-form : Form handling support for Yesod Web Framework ( http://www.yesodweb.com/ )

yesod-json : Generate content for Yesod using the aeson package. (deprecated) ( http://www.yesodweb.com/ )

yesod-markdown : Tools for using markdown in a yesod application ( http://github.com/pbrisbin/yesod-markdown )

yesod-newsfeed : Helper functions and data types for producing News feeds ( http://www.yesodweb.com/ )

yesod-paginator : A pagination approach for yesod ( http://github.com/pbrisbin/yesod-paginator )

yesod-persistent : Some helpers for using Persistent from Yesod ( http://www.yesodweb.com/ )

yesod-platform : Meta package for Yesod ( http://www.yesodweb.com/ )

yesod-routes : Efficient routing for Yesod ( http://www.yesodweb.com/ )

yesod-sitemap : Generate XML sitemaps ( http://www.yesodweb.com/ )

yesod-static : Static file serving subsite for Yesod Web Framework ( http://www.yesodweb.com/ )

yesod-test : integration testing for WAI/Yesod Applications ( http://www.yesodweb.com )

zeromq-haskell : Bindings to ZeroMQ 2.1.x ( http://github.com/twittner/zeromq-haskell/ )

zeromq3-haskell : Bindings to ZeroMQ 3.x ( http://github.com/twittner/zeromq-haskell/ )

zeromq4-haskell : Bindings to ZeroMQ 4.x ( http://github.com/twittner/zeromq-haskell/ )

zip-archive : Library for creating and modifying zip archives ( http://github.com/jgm/zip-archive )

zippers : Traversal based zippers ( http://github.com/ekmett/zippers/ )

zlib : Compression and decompression in the gzip and zlib formats ( http://hackage.haskell.org/package/zlib )

zlib-bindings : Low-level bindings to the zlib package. (deprecated) ( http://github.com/snoyberg/zlib-bindings )

zlib-conduit : Streaming compression/decompression via conduits. (deprecated) ( http://github.com/snoyberg/conduit )

zlib-enum : Enumerator interface for zlib compression ( http://github.com/maltem/zlib-enum )

zmidi-core : Read and write MIDI files ( http://code.google.com/p/copperbox/ )

ztail : Multi-file, colored, filtered log tailer ( http://hackage.haskell.org/package/ztail )

Pour rajouter une e-build dans l'arbre de portage :

L'ebuild est alors rajouté dans l'arbre de portage.

Vous pouvez aussi utiliser layman : emerge layman puis layman -a haskell

Pour Paludis utilisez ce rsync : rsync://gentoo.zugaina.org/haskell-portage

En cas de problèmes : ycarus(-at-)zugaina.org