Ces ebuilds viennent du site https://github.com/gentoo-haskell.
Si vous avez des problemes allez sur le site officiel.
abstract-deque : Abstract, parameterized interface to mutable Deques. ( https://github.com/rrnewton/haskell-lockfree-queue/wiki )
abstract-par : Type classes generalizing the functionality of the 'monad-par' library. ( https://github.com/simonmar/monad-par )
accelerate : An embedded language for accelerated array processing ( https://github.com/AccelerateHS/accelerate/ )
accelerate-cuda : Accelerate backend for NVIDIA GPUs ( http://www.cse.unsw.edu.au/~chak/project/accelerate/ )
accelerate-io : Read and write Accelerate arrays in various formats ( http://www.cse.unsw.edu.au/~chak/project/accelerate/ )
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 )
adjunctions : Adjunctions ( 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 )
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/ )
alsa-core : Binding to the ALSA Library API (Exceptions). ( http://www.haskell.org/haskellwiki/ALSA )
alsa-mixer : Bindings to the ALSA simple mixer API. ( http://hackage.haskell.org/package/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 ( http://connect.creativelabs.com/openal/ )
annotations : Constructing, analyzing and destructing annotated trees ( http://hackage.haskell.org/package/Annotations )
ansi-terminal : Simple ANSI terminal support, with Windows compatibility ( http://batterseapower.github.com/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 ( 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-types : ASN.1 types ( http://github.com/vincenthz/hs-asn1-types )
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-queue/wiki )
attempt : Concrete data type for handling extensible exceptions as failures. ( http://github.com/snoyberg/attempt/tree/master )
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. ( 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 )
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. ( 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/cgi-bin/hackage-scripts/package/bencode )
bifunctors : Haskell 98 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-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-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. ( http://bitbucket.org/mauricio/bindings-dsl )
bindings-libzip : Low level bindings to libzip. ( http://bitbucket.org/astanin/hs-libzip/ )
bio : A bioinformatics library ( http://biohaskell.org/Libraries/Bio )
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. ( http://github.com/snoyberg/conduit )
blaze-builder-enumerator : Enumeratees for the incremental conversion of builders t ( 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 )
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 binar ( http://github.com/selectel/bson-haskell )
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 )
byteorder : Exposes the native endianness or byte ordering of the system. ( http://community.haskell.org/~aslatter/code/byteorder )
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 )
c2hs : C-Haskell FFI tool that gives some cross-language type safety ( http://www.cse.unsw.edu.au/~chak/haskell/c2hs/ )
cabal : A framework for packaging Haskell software ( http://www.haskell.org/cabal/ )
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/ )
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 )
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, to reduce the chances of problems such as data loss due to crashes or power failures ( 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 )
certificate : Certificates and Key Reader/Writer ( http://github.com/vincenthz/hs-certificate )
cgi : A library for writing CGI programs ( http://andersk.mit.edu/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 ( http://www.dockerz.net/software/chart.html )
chart-gtk : Utility functions for using the chart library with GTK ( http://www.dockerz.net/software/chart.html )
chasingbottoms : For testing partial and infinite values. ( http://hackage.haskell.org/package/ChasingBottoms )
checkers : Check properties on standard classes and data structures. ( http://hackage.haskell.org/package/checkers )
cipher-aes : Fast AES cipher implementation with advanced mode of operations ( http://github.com/vincenthz/hs-cipher-aes )
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 )
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/ )
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 )
comonad : Haskell 98 compatible comonads ( http://github.com/ekmett/comonad/ )
comonad-extras : Comonad transformers requiring extensions to Haskell 98 ( http://github.com/ekmett/comonad-extras/ )
comonad-transformers : Comonad transformers ( http://github.com/ekmett/comonad-transformers/ )
comonads-fd : Comonad transformers using functional dependencies ( 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/ )
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 )
configfile : Configuration file reading and writing ( http://software.complete.org/configfile )
configurator : Configuration management ( http://github.com/bos/configurator )
constraints : Constraint manipulation ( http://github.com/ekmett/constraints/ )
containers-unicode-symbols : Unicode alternatives for common functions and operators ( http://haskell.org/haskellwiki/Unicode-symbols )
contravariant : Haskell 98 contravariant functors ( http://github.com/ekmett/contravariant/ )
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 )
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://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-conduit : Conduit interface for cryptographic operations (from crypto-api). ( https://github.com/meteficha/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-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-cryptocipher )
cryptohash : collection of crypto hashes, fast, pure and practical ( http://github.com/vincenthz/hs-cryptohash )
cryptohash-cryptoapi : Crypto-api interfaces for cryptohash ( http://github.com/vincenthz/hs-cryptohash-cryptoapi )
cuda : FFI binding to the CUDA interface for programming NVIDIA GPUs ( http://hackage.haskell.org/package/cuda )
curl : Haskell binding to libcurl ( http://hackage.haskell.org/package/curl )
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-inttrie : A lazy, infinite trie of integers. ( http://github.com/luqui/data-inttrie )
data-lens : 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-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-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 )
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 )
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-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-lib : Embedded domain-specific language for declarative graphics ( http://projects.haskell.org/diagrams )
diagrams-svg : SVG backend for diagrams drawing EDSL. ( http://projects.haskell.org/diagrams/ )
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/ )
directory-layout : Declare, construct and verify directory layout ( 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 : Haskell 98 Distributive functors -- Dual to Traversable ( http://github.com/ekmett/distributive/ )
djinn : Generate Haskell code from a type ( http://www.augustsson.net/Darcs/Djinn/ )
dlist : Differences lists ( http://code.haskell.org/~dons/code/dlist/ )
doctest : Test interactive Haskell examples ( https://github.com/sol/doctest-haskell#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 )
drift : Preprocessor for automatic derivation of Haskell class instances ( http://repetae.net/john/computer/haskell/DrIFT/ )
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 )
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/ )
email-validate : Validating an email address string against RFC 5322 ( http://porg.es/blog/email-address-validation-simpler-faster-more-correct )
encoding : A library for various character encodings ( http://code.haskell.org/encoding/ )
entropy : A platform independent entropy source ( http://trac.haskell.org/crypto-api/wiki )
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 )
erf : The error function, erf, and related functions. ( http://hackage.haskell.org/package/erf )
errors : Simplified error-handling ( http://hackage.haskell.org/package/errors )
esqueleto : Bare bones, type-safe EDSL for SQL queries on persistent backends. ( https://github.com/meteficha/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.eecs.harvard.edu/~mainland/ )
exception-transformers : Type classes and monads for unchecked extensible exceptions. ( http://www.eecs.harvard.edu/~mainland/ )
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-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. ( 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. ( http://fay-lang.org/ )
fay-base : The base package for Fay. ( https://github.com/faylang/fay-base )
fclabels : First class accessor labels. ( 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. ( http://hackage.haskell.org/package/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. ( 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 )
fixed-vector : Generic vectors with statically known size. ( http://hackage.haskell.org/package/fixed-vector )
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 )
force-layout : Simple force-directed layout ( http://hackage.haskell.org/package/force-layout )
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/ )
ftphs : FTP Client and Server Library ( http://software.complete.org/ftphs )
funcmp : Functional MetaPost ( http://savannah.nongnu.org/projects/funcmp/ )
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-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 monad ( http://darcsden.com/jcpetruzza/ghc-mtl )
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 )
glade : Binding to the glade library. ( http://projects.haskell.org/gtk2hs/ )
glfw : A Haskell binding for GLFW ( http://haskell.org/haskellwiki/GLFW )
glfw-b : GLFW bindings ( http://hackage.haskell.org/package/GLFW-b )
glib : Binding to the GLIB library for Gtk2Hs. ( http://projects.haskell.org/gtk2hs/ )
gloss : Painless 2D vector graphics, animations and simulations. ( http://gloss.ouroborus.net )
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 )
gnuidn : Bindings for GNU IDN ( http://john-millikin.com/software/bindings/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 )
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 Sho ( http://hackage.haskell.org/package/groom )
groundhog : Type-safe datatype-database mapping library. ( http://hackage.haskell.org/package/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 )
groupoids : Haskell 98 Groupoids ( http://github.com/ekmett/groupoids/ )
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/ )
gtksourceview2 : Binding to the GtkSourceView library. ( http://projects.haskell.org/gtk2hs/ )
haddock : A documentation-generation tool for Haskell libraries ( http://www.haskell.org/haddock/ )
hakyll : A static website compiler library ( http://jaspervdj.be/hakyll )
hamlet : Haml-like template files that are compile-time checked ( http://www.yesodweb.com/book/shakespearean-templates )
handsomesoup : Add CSS2 selector support to 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 )
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-docs : A program to find and display the docs of a name from ( 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-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 ( http://code.haskell.org/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 )
hasktags : Produces ctags "tags" and etags "TAGS" files for Haskell programs ( http://hackage.haskell.org/package/hasktags )
hastache : Haskell implementation of Mustache templates ( http://github.com/lymar/hastache )
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 )
hdaemonize : Library to handle the details of writing daemons for UNIX ( http://github.com/madhadron/hdaemonize )
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 ( https://github.com/informatikr/hedis )
heist : An Haskell template system supporting both HTML5 and XML. ( http://snapframework.com/ )
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/ )
hgal : library for computation automorphism group and canonical labelling of a graph ( http://hackage.haskell.org/package/hgal )
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. ( http://patch-tag.com/r/felipe/hipmunk/home )
hipmunkplayground : A playground for testing Hipmunk. ( http://patch-tag.com/r/felipe/hipmunkplayground/home )
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 )
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/ )
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 )
hpc : Code Coverage Library for Haskell ( http://hackage.haskell.org/package/hpc )
hprotoc : Parse Google Protocol Buffer specifications ( http://code.haskell.org/protocol-buffers/ )
hs-bibutils : Haskell bindings to bibutils, the bibliograph ( http://gorgias.mine.nu/repos/hs-bibutils/ )
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 )
hsemail : Internet Message Parsers ( http://github.com/peti/hsemail )
hsh : Library to mix shell scripting with Haskell programs ( http://software.complete.org/hsh )
hslogger : Versatile logging framework ( http://software.complete.org/hslogger )
hslua : A Lua language interpreter embedding in Haskell ( http://hackage.haskell.org/package/hslua )
hsopenssl : (Incomplete) OpenSSL binding for Haskell ( https://github.com/phonohawk/HsOpenSSL )
hsp : Haskell Server Pages is a library for writing dynamic server-side web pages. ( http://patch-tag.com/r/nibro/hsp )
hspec : Behavior-Driven Development for Haskell ( http://hspec.github.com/ )
hspec-expectations : Catchy combinators for HUnit ( https://github.com/sol/hspec-expectations#readme )
hspec-meta : A version of Hspec which is used to test Hspec itself ( http://hspec.github.com/ )
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 )
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 )
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 )
hsyslog : FFI interface to syslog(3) from POSIX.1-2001. ( http://github.com/peti/hsyslog )
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 )
http : A library for client-side HTTP ( https://github.com/haskell/HTTP )
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-reverse-proxy : Reverse proxy HTTP requests, either over raw sockets or with WAI ( https://github.com/fpco/http-reverse-proxy )
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 ( 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 )
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 )
imagemagick : bindings to imagemagick library ( http://hackage.haskell.org/package/imagemagick )
imagesize-conduit : Determine the size of some common image formats. ( http://github.com/snoyberg/conduit )
imlib : Haskell binding for Imlib 2 ( http://hackage.haskell.org/package/Imlib )
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 )
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 )
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/ )
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 )
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 )
kan-extensions : Kan extensions, the Yoneda lemma, and (co)density (co)monads ( http://github.com/ekmett/kan-extensions/ )
kibro : Web development framework. ( http://hackage.haskell.org/package/kibro )
kinds : Emulation of subkinds and subkind polymorphism ( http://darcs.wolfgang.jeltsch.info/haskell/kinds )
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 quasiquoting library. ( http://www.eecs.harvard.edu/~mainland/ )
language-ecmascript : JavaScript analysis tools ( http://github.com/jswebtools/language-ecmascript )
language-haskell-extract : Module to automatically extract functions from the local code. ( http://github.com/finnsson/template-helper )
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 )
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 )
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/ )
liblastfm : Lastfm API interface ( http://hackage.haskell.org/package/liblastfm )
libmpd : An MPD client library. ( http://github.com/joachifm/libmpd-haskell )
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-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-base : lifted IO operations from the base library ( https://github.com/basvandijk/lifted-base )
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 )
listlike-instances : Extra instances of the ListLike class ( http://jwlato.webfactional.com/haskell/listlike-instances )
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 )
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-queue/wiki )
logict : A backtracking logic-programming monad. ( http://code.haskell.org/~dolio/logict )
lru : Implements an LRU data structure ( http://www.imperialviolet.org/lru )
lrucache : a simple, pure LRU cache ( http://github.com/chowells79/lrucache )
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 )
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 )
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/ )
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-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 )
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-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-peel : Lift control operations like exception catching through monad transformers ( http://andersk.mit.edu/haskell/monad-peel/ )
monad-products : Haskell 98 monad products ( http://github.com/ekmett/monad-products )
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 )
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, documen ( http://github.com/selectel/mongodb-haskell )
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 ( http://code.haskell.org/mubot/ )
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 )
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 )
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 : Flexible wire arrows for FRP ( http://hackage.haskell.org/package/netwire )
network : Low-level networking interface ( https://github.com/haskell/network )
network-bytestring : Fast, memory-efficient, low-level networking ( http://github.com/tibbe/network-bytestring )
network-conduit : Stream socket data using conduits. ( 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-socket-options : Type-safe, portable alternative to getSocketOption/setSocketOption ( https://github.com/joeyadams/haskell-network-socket-options )
network-transport : Network abstraction layer ( http://github.com/haskell-distributed/distributed-process )
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 )
newtype : A typeclass and set of functions for working with newtypes. ( http://hackage.haskell.org/package/newtype )
non-negative : Non-negative numbers ( http://code.haskell.org/~thielema/non-negative/ )
numbers : Various number types ( https://github.com/DanBurton/numbers#readme )
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 ( 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 ( http://connect.creativelabs.com/openal/ )
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 )
operational : Implementation of difficult monads made eas ( http://haskell.org/haskellwiki/Operational )
optparse-applicative : Utilities and combinators for parsing command line options ( https://github.com/pcapriotti/optparse-applicative )
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 )
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/ )
path-pieces : Components of paths. ( http://hackage.haskell.org/package/path-pieces )
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 ( http://code.haskell.org/~dons/code/pcre-light )
pdfinfo : Wrapper around the pdfinfo command. ( http://hackage.haskell.org/package/pdfinfo )
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-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 )
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 : Haskell 98 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 )
polyparse : A variety of alternative parser combinator libraries. ( http://code.haskell.org/~malcolm/polyparse/ )
pool-conduit : Resource pool allocations via ResourceT. ( 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/ )
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 )
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 ( http://github.com/tanakh/process-conduit )
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 )
profunctor-extras : Profunctor extras ( http://github.com/ekmett/profunctor-extras/ )
profunctors : Haskell 98 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 ( http://code.haskell.org/QuickCheck )
quickcheck-assertions : HUnit like assertions for QuickCheck ( https://github.com/s9gf4ult/quickcheck-assertions )
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-shuffle : Random shuffle implementation. ( http://hackage.haskell.org/package/random-shuffle )
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 )
rdtsc : Binding for the rdtsc machine instruction ( http://code.haskell.org/rdtsc )
reactive-banana : Practical library for functional reactive programming (FRP). ( http://haskell.org/haskellwiki/Reactive-banana )
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-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-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 )
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/ )
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://hackage.haskell.org/package/retry )
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 )
safe : Library for safe (pattern match 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 )
scion-browser : Command-line interface for browsing and searching packages documentation ( http://github.com/JPMoresmau/scion-class-browser )
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 )
semigroupoid-extras : Semigroupoids requiring Haskell extensions ( http://github.com/ekmett/semigroupoid-extras )
semigroupoids : Haskell 98 semigroupoids: Category sans id ( http://github.com/ekmett/semigroupoids )
semigroups : Haskell 98 semigroups ( 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 )
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. ( http://community.haskell.org/~ndm/shake/ )
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. ( http://www.yesodweb.com/book/shakespearean-templates )
shakespeare-i18n : A type-based approach to internationalization. ( http://www.yesodweb.com/book/shakespearean-templates )
shakespeare-js : Stick your haskell variables into javascript/coffeescript at compile time. ( http://www.yesodweb.com/book/shakespearean-templates )
shakespeare-text : Interpolation with quasi-quotation: put variables strings ( http://www.yesodweb.com/book/shakespearean-templates )
shellac : A framework for creating shell envinronments ( http://www.cs.princeton.edu/~rdockins/shellac/home/ )
shellac-compatline : "compatline" backend module for Shellac ( http://www.cs.princeton.edu/~rdockins/shellac/home/ )
shellac-editline : Editline backend module for Shellac ( http://www.cs.princeton.edu/~rdockins/shellac/home/ )
shellac-readline : Readline backend module for Shellac ( http://hackage.haskell.org/package/Shellac-readline )
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://twan.home.fmf.nl/blog/haskell/simple-reflection-of-expressions.details )
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 )
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-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/ )
socks : Socks proxy (version 5) implementation. ( http://github.com/vincenthz/hs-socks )
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 )
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 )
srcloc : Data types for managing source code locations. ( http://www.eecs.harvard.edu/~mainland/ )
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 )
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 usin ( 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 )
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/ )
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 )
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 )
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://hackage.haskell.org/package/stringtable-atom )
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/ )
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.eecs.harvard.edu/~mainland/ )
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-time-monotonic : Simple library for using the system's monotonic clock ( https://github.com/joeyadams/haskell-system-time-monotonic )
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 )
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 )
terminal-size : Get terminal window height and width ( http://hackage.haskell.org/package/terminal-size )
terminfo : Haskell bindings to the terminfo library. ( http://code.haskell.org/terminfo )
test-framework : Framework for running and organising tests, with HUnit and QuickCheck support ( http://batterseapower.github.com/test-framework/ )
test-framework-hunit : HUnit support for the test-framework package. ( http://batterseapower.github.com/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. ( http://batterseapower.github.com/test-framework/ )
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 Abstract 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 of LaTeX math formulas to MathML or OMML. ( 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-icu : Bindings to the ICU library ( https://bitbucket.org/bos/text-icu )
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 )
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 )
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 )
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 exposing the new types from transformers 0.3 to older Haskell platforms. ( http://github.com/ekmett/transformers-compat/ )
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-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 )
typecompose : Type composition classes and instances ( https://github.com/conal/TypeCompose )
uhc-util : UHC utilities ( https://github.com/UU-ComputerScience/uhc-utils )
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/ )
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-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 )
uri-conduit : Read and write URIs ( 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-parsinglib : Fast, online, error-correcting, monadic, applicative, merging, permuting, idiomatic parser combinators. ( 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 )
vault : a persistent store for values of arbitrary types ( https://github.com/HeinrichApfelmus/vault )
vcsgui : GUI library for source code management systems ( https://github.com/forste/haskellVCSGUI )
vcswrapper : Wrapper for source code management systems ( https://github.com/forste/haskellVCSWrapper )
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-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 )
vinyl : Extensible Records ( http://hackage.haskell.org/package/vinyl )
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-ui : An interactive terminal user interface library for Vty ( http://jtdaugherty.github.com/vty-ui/ )
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-eventsource : WAI support for server-sent events ( 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. ( http://github.com/yesodweb/wai )
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. ( http://www.yesodweb.com/book/web-application-interface )
warp : A fast, light-weight web server for WAI applications. ( 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/ )
web-encodings : Encapsulate multiple web encoding in a single package. (deprecated) ( http://github.com/snoyberg/web-encodings/tree/master )
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/ )
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 )
wordexp : wordexp(3) wrappers ( http://hackage.haskell.org/package/wordexp )
wraparound : Convenient handling of points on a seamless 2-dimensional plane ( http://frigidcode.com )
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 is a portable and native GUI library for Haskell ( 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/cgi-bin/hackage-scripts/package/X11-xft )
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 )
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-catalog : Parse XML catalog files ( 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-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/ )
xmlhtml : XML parser and renderer with HTML 5 quirks mode ( http://hackage.haskell.org/package/xmlhtml )
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-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/ )
zip-archive : Library for creating and modifying zip archives. ( http://github.com/jgm/zip-archive )
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. ( http://github.com/snoyberg/zlib-bindings )
zlib-conduit : Streaming compression/decompression via conduits. ( http://github.com/snoyberg/conduit )
zlib-enum : Enumerator interface for zlib compression ( http://github.com/maltem/zlib-enum )
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