Ycarus Gentoo ebuild

haskell

Ces ebuilds viennent du site .

Si vous avez des problemes allez sur le site officiel.

dev-haskell

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

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

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

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

ac-ppm : Trivial package for writing PPM images ( http://hackage.haskell.org/package/AC-PPM )

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

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

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

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

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

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

acid-state : Add ACID guarantees to any serializable Haskell data structure ( https://github.com/acid-state/acid-state )

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

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

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

adjunctions : Adjunctions and representable functors ( https://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-better-errors : Better error messages when decoding JSON values ( https://github.com/hdgarrood/aeson-better-errors )

aeson-casing : Tools to change the formatting of field names in Aeson instances ( http://hackage.haskell.org/package/aeson-casing )

aeson-compat : Compatibility layer for aeson ( https://github.com/phadej/aeson-compat#readme )

aeson-extra : Extra goodies for aeson ( https://github.com/phadej/aeson-extra#readme )

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

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

aeson-qq : JSON quasiquoter for Haskell ( https://github.com/sol/aeson-qq#readme )

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

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

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

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

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

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

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

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

amazonka-cloudformation : Amazon CloudFormation SDK ( https://github.com/brendanhay/amazonka )

amazonka-cloudfront : Amazon CloudFront SDK ( https://github.com/brendanhay/amazonka )

amazonka-cloudhsm : Amazon CloudHSM SDK ( https://github.com/brendanhay/amazonka )

amazonka-cloudsearch : Amazon CloudSearch SDK ( https://github.com/brendanhay/amazonka )

amazonka-cloudsearch-domains : Amazon CloudSearch Domain SDK ( https://github.com/brendanhay/amazonka )

amazonka-cloudtrail : Amazon CloudTrail SDK ( https://github.com/brendanhay/amazonka )

amazonka-cloudwatch : Amazon CloudWatch SDK ( https://github.com/brendanhay/amazonka )

amazonka-codedeploy : Amazon CodeDeploy SDK ( https://github.com/brendanhay/amazonka )

amazonka-cognito-identity : Amazon Cognito Identity SDK ( https://github.com/brendanhay/amazonka )

amazonka-cognito-sync : Amazon Cognito Sync SDK ( https://github.com/brendanhay/amazonka )

amazonka-config : Amazon Config SDK ( https://github.com/brendanhay/amazonka )

amazonka-core : Core data types and functionality for Amazonka libraries ( https://github.com/brendanhay/amazonka )

amazonka-datapipeline : Amazon Data Pipeline SDK ( https://github.com/brendanhay/amazonka )

amazonka-devicefarm : Amazon Device Farm SDK ( https://github.com/brendanhay/amazonka )

amazonka-directconnect : Amazon Direct Connect SDK ( https://github.com/brendanhay/amazonka )

amazonka-discovery : Amazon Application Discovery Service SDK ( https://github.com/brendanhay/amazonka )

amazonka-dms : Amazon Database Migration Service SDK ( https://github.com/brendanhay/amazonka )

amazonka-dynamodb : Amazon DynamoDB SDK ( https://github.com/brendanhay/amazonka )

amazonka-ec2 : Amazon Elastic Compute Cloud SDK ( https://github.com/brendanhay/amazonka )

amazonka-ecr : Amazon EC2 Container Registry SDK ( https://github.com/brendanhay/amazonka )

amazonka-elasticache : Amazon ElastiCache SDK ( https://github.com/brendanhay/amazonka )

amazonka-elasticsearch : Amazon Elasticsearch Service SDK ( https://github.com/brendanhay/amazonka )

amazonka-elastictranscoder : Amazon Elastic Transcoder SDK ( https://github.com/brendanhay/amazonka )

amazonka-iam : Amazon Identity and Access Management SDK ( https://github.com/brendanhay/amazonka )

amazonka-kinesis : Amazon Kinesis SDK ( https://github.com/brendanhay/amazonka )

amazonka-lambda : Amazon Lambda SDK ( https://github.com/brendanhay/amazonka )

amazonka-marketplace-analytics : Amazon Marketplace Commerce Analytics SDK ( https://github.com/brendanhay/amazonka )

amazonka-opsworks : Amazon OpsWorks SDK ( https://github.com/brendanhay/amazonka )

amazonka-redshift : Amazon Redshift SDK ( https://github.com/brendanhay/amazonka )

amazonka-route53 : Amazon Route 53 SDK ( https://github.com/brendanhay/amazonka )

amazonka-route53-domains : Amazon Route 53 Domains SDK ( https://github.com/brendanhay/amazonka )

amazonka-s3 : Amazon Simple Storage Service SDK ( https://github.com/brendanhay/amazonka )

amazonka-sdb : Amazon SimpleDB SDK ( https://github.com/brendanhay/amazonka )

amazonka-ses : Amazon Simple Email Service SDK ( https://github.com/brendanhay/amazonka )

amazonka-shield : Amazon Shield SDK ( https://github.com/brendanhay/amazonka )

amazonka-sms : Amazon Server Migration Service SDK ( https://github.com/brendanhay/amazonka )

amazonka-sns : Amazon Simple Notification Service SDK ( https://github.com/brendanhay/amazonka )

amazonka-stepfunctions : Amazon Step Functions SDK ( https://github.com/brendanhay/amazonka )

amazonka-storagegateway : Amazon Storage Gateway SDK ( https://github.com/brendanhay/amazonka )

amazonka-support : Amazon Support SDK ( https://github.com/brendanhay/amazonka )

amazonka-test : Common functionality for Amazonka library test-suites ( https://github.com/brendanhay/amazonka )

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

amqp-worker : High level functions for working with message queues ( http://hackage.haskell.org/package/amqp-worker )

angel : Process management and supervision daemon ( https://github.com/MichaelXavier/Angel )

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

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

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

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

api-field-json-th : option of aeson's deriveJSON ( https://github.com/nakaji-dayo/api-field-json-th )

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

applicative-numbers : Applicative-based numeric instances ( http://haskell.org/haskellwiki/applicative-numbers )

applicative-quoters : Quasiquoters for idiom brackets and an applicative do-notation ( http://hackage.haskell.org/package/applicative-quoters )

apply-refact : Perform refactorings specified by the refact library ( http://hackage.haskell.org/package/apply-refact )

argparser : Command line parsing framework for console applications ( http://hackage.haskell.org/package/argparser )

arithmoi : Efficient basic number-theoretic functions. Primes, powers, integer logarithms ( https://github.com/cartazio/arithmoi )

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

ascii-progress : A simple progress bar for the console ( https://github.com/yamadapc/haskell-ascii-progress )

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

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

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

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

astar : General A* search algorithm ( https://github.com/weissi/astar )

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

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

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

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

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

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

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

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

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

attoparsec-iso8601 : Parsing of ISO 8601 dates, originally from aeson ( https://github.com/bos/aeson )

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

attoparsec-path : Convenience bindings between path and attoparsec ( https://github.com/athanclark/attoparsec-path#readme )

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

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

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

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

auto : Denotative, locally stateful programming DSL and platform ( https://github.com/mstksg/auto )

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

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

aws : Amazon Web Services (AWS) for Haskell ( https://github.com/aristidb/aws )

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

base-orphans : Backwards-compatible orphan instances for base ( https://github.com/haskell-compat/base-orphans#readme )

base-prelude : The most complete prelude formed solely from the \\ ( https://github.com/nikita-volkov/base-prelude )

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 ( https://github.com/bos/base16-bytestring )

base58-bytestring : Implementation of BASE58 transcoding for ByteStrings ( https://bitbucket.org/s9gf4ult/base58-bytestring )

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

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

basement : Foundation scrap box of array and string ( https://github.com/haskell-foundation/foundation )

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

bcrypt : Haskell bindings to the bcrypt password hash ( http://hackage.haskell.org/package/bcrypt )

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

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

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

bimap : Bidirectional mapping between two key types ( https://github.com/joelwilliamson/bimap )

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

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

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

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

binary-ieee754 : Backport ieee754 float double combinators to older binary ( https://github.com/winterland1989/binary-ieee754 )

binary-orphans : Orphan instances for binary ( https://github.com/phadej/binary-orphans#readme )

binary-parser : A highly-efficient but limited parser API specialised for bytestrings ( https://github.com/nikita-volkov/binary-parser )

binary-parsers : Extends binary with parsec/attoparsec style parsing combinators ( https://github.com/winterland1989/binary-parsers )

binary-search : Binary and exponential searches ( http://hackage.haskell.org/package/binary-search )

binary-serialise-cbor : Yet Another Binary Serialisation Library (compatibility shim) ( http://hackage.haskell.org/package/binary-serialise-cbor )

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

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

binary-strict : Binary deserialisation using strict ByteStrings ( https://github.com/idontgetoutmuch/binary-low-level )

binary-tagged : Tagged binary serialisation ( https://github.com/phadej/binary-tagged#readme )

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

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

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

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

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

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

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

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

biopsl : Library and executables for working with PSL files ( http://biohaskell.org/ )

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

bitarray : Mutable and immutable bit arrays ( http://code.haskell.org/~bkomuves/ )

bitmap : A library for handling and manipulating bitmaps (rectangular pixel arrays) ( http://code.haskell.org/~bkomuves/ )

bits-atomic : Atomic bit operations on memory locations for low-level synchronization ( http://hackage.haskell.org/package/bits-atomic )

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

bitstring : Lazy bit strings ( http://code.haskell.org/~bkomuves/ )

bitstringrandommonad : A library which turns a bytestring into a random monad ( http://hackage.haskell.org/package/BitStringRandomMonad )

bitsyntax : A module to aid in the (de)serialisation of binary data ( https://github.com/joecrayne/hs-bitsyntax )

bitwise : fast multi-dimensional unboxed bit packed Bool arrays ( http://code.mathr.co.uk/bitwise )

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

blank-canvas : HTML5 Canvas Graphics Library ( https://github.com/ku-fpg/blank-canvas/wiki )

blasthttp : Libary to interface with the NCBI blast REST interface ( https://github.com/eggzilla/BlastHTTP )

blastxml : Library for reading Blast XML output ( http://biohaskell.org/ )

blaze-builder : Efficient buffered output ( https://github.com/lpsmith/blaze-builder )

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

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

blaze-colonnade : Helper functions for using blaze-html with colonnade ( https://github.com/andrewthad/colonnade#readme )

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 ( https://github.com/bos/blaze-textual )

bloodhound : ElasticSearch client library for Haskell ( https://github.com/bitemyapp/bloodhound )

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

bmp : Read and write uncompressed BMP image files ( https://github.com/benl23x5/bmp )

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

boomerang : Library for invertible parsing and printing ( http://hackage.haskell.org/package/boomerang )

bootstrap-types : Bootstrap CSS Framework type-safe interface ( http://hackage.haskell.org/package/bootstrap-types )

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

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

bower-json : Read bower.json from Haskell ( https://github.com/hdgarrood/bower-json )

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

brick : A declarative terminal user interface library ( https://github.com/jtdaugherty/brick/ )

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

btrfs : Bindings to the btrfs API ( https://github.com/redneb/hs-btrfs )

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

byline : Library for creating command-line interfaces (colors, menus, etc.) ( https://github.com/pjones/byline )

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

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

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

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

bytestring-builder : The new bytestring builder, packaged outside of GHC ( http://hackage.haskell.org/package/bytestring-builder )

bytestring-conversion : Type-classes to convert values to and from ByteString ( https://github.com/twittner/bytestring-conversion/ )

bytestring-handle : ByteString-backed Handles ( http://hub.darcs.net/ganesh/bytestring-handle )

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 ( https://github.com/solidsnack/bytestring-nums )

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

bytestring-strict-builder : An efficient strict bytestring builder ( https://github.com/nikita-volkov/bytestring-strict-builder )

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

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

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

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

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

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

cabal-doctest : A Setup.hs helper for doctests running ( https://github.com/phadej/cabal-doctest )

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

cabal-helper : Simple interface to some of Cabal's configuration state used by ghc-mod ( http://hackage.haskell.org/package/cabal-helper )

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 ( https://github.com/danfran/cabal-macosx )

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

cabal-rpm : RPM packaging tool for Haskell Cabal-based packages ( https://github.com/juhp/cabal-rpm )

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

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

call-stack : Use GHC call-stacks in a backward compatible way ( https://github.com/sol/call-stack#readme )

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

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

carray : A C-compatible array library ( http://hackage.haskell.org/package/carray )

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

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

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

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

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

cborg : Concise Binary Object Representation ( http://hackage.haskell.org/package/cborg )

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

cereal : A binary serialization library ( https://github.com/GaloisInc/cereal )

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

cereal-vector : Serialize instances for Data.Vector types ( https://github.com/acfoltzer/cereal-vector )

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

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

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

charsetdetect-ae : Character set detection using Mozilla's Universal Character Set Detector ( https://github.com/aelve/charsetdetect-ae )

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

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

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

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

chart-unit : Native haskell charts ( https://github.com/tonyday567/chart-unit )

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

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

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

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

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

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

chronos : A performant time library ( https://github.com/andrewthad/chronos#readme )

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

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

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

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

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

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

cipher-rc4 : Fast RC4 cipher implementation ( https://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://istitutocolli.org/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/mono-traversable )

classy-prelude-conduit : classy-prelude together with conduit functions ( https://github.com/snoyberg/mono-traversable )

classy-prelude-yesod : Provide a classy prelude including common Yesod functionality ( https://github.com/snoyberg/mono-traversable )

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

clckwrks : A secure, reliable content management system (CMS) and blogging platform ( http://www.clckwrks.com/ )

clckwrks-cli : a command-line interface for adminstrating some aspects of clckwrks ( http://www.clckwrks.com/ )

clckwrks-plugin-media : media plugin for clckwrks ( http://clckwrks.com/ )

clckwrks-plugin-page : support for CMS/Blogging in clckwrks ( http://www.clckwrks.com/ )

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

cli : Command Line Interface ( https://github.com/vincenthz/hs-cli )

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

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

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

cmark : Fast, accurate CommonMark (Markdown) parser and renderer ( https://github.com/jgm/cmark-hs )

cmdargs : Command line argument processing ( https://github.com/ndmitchell/cmdargs#readme )

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 ( https://github.com/eli-frey/cmdtheline )

code-page : Windows code page library for Haskell ( https://github.com/RyanGlScott/code-page )

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 )

colonnade : Generic types and functions for columnar encoding and decoding ( https://github.com/andrewthad/colonnade#readme )

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

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

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

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

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

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

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

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

composition : Combinators for unorthodox function composition ( http://hackage.haskell.org/package/composition )

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

conceit : Concurrent actions that may fail with a value ( http://hackage.haskell.org/package/conceit )

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-output : Ungarble output from several threads or commands ( http://hackage.haskell.org/package/concurrent-output )

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 ( https://github.com/snoyberg/conduit )

conduit-audio : Combinators to efficiently slice and dice audio streams ( https://github.com/mtolly/conduit-audio )

conduit-audio-lame : conduit-audio interface to the LAME MP3 library ( https://github.com/mtolly/conduit-audio )

conduit-audio-samplerate : conduit-audio interface to the libsamplerate resampling library ( https://github.com/mtolly/conduit-audio )

conduit-audio-sndfile : conduit-audio interface to the libsndfile audio file library ( https://github.com/mtolly/conduit-audio )

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

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

config-ini : A library for simple INI-based configuration files ( https://github.com/aisamanra/config-ini )

config-value : Simple, layout-based value language similar to YAML or JSON ( https://github.com/glguy/config-value )

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

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

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

console-program : Interpret the command line and a config file as commands and options ( http://hackage.haskell.org/package/console-program )

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

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

continued-fractions : Continued fractions ( https://github.com/mokus0/continued-fractions )

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

contravariant-extras : Extras for the \"contravariant\" package ( https://github.com/nikita-volkov/contravariant-extras )

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

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

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

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

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

conversion : Universal converter between values of different types ( https://github.com/nikita-volkov/conversion )

conversion-bytestring : \"Conversion\" instances for the \"bytestring\" library ( https://github.com/nikita-volkov/conversion-bytestring )

conversion-text : \"Conversion\" instances for the \"text\" library ( https://github.com/nikita-volkov/conversion-text )

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

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

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

coroutine-object : Object-oriented programming realization using coroutine ( http://hackage.haskell.org/package/coroutine-object )

couchdb : CouchDB interface ( https://github.com/hsenag/haskell-couchdb/ )

country-codes : ISO 3166 country codes and i18n names ( https://github.com/prowdsponsor/country-codes )

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

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

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

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

cracknum : Crack various integer, floating-point data formats ( http://hackage.haskell.org/package/crackNum )

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

criterion : Robust, reliable performance measurement and analysis ( http://www.serpentine.com/criterion )

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

cron : Cron datatypes and Attoparsec parser ( https://github.com/michaelxavier/cron )

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

cryptohash-md5 : Fast, pure and practical MD5 implementation ( https://github.com/hvr/cryptohash-md5 )

cryptohash-sha1 : Fast, pure and practical SHA-1 implementation ( https://github.com/hvr/cryptohash-sha1 )

cryptohash-sha256 : Fast, pure and practical SHA-256 implementation ( https://github.com/hvr/cryptohash-sha256 )

cryptonite : Cryptography Primitives sink ( https://github.com/haskell-crypto/cryptonite )

cryptonite-conduit : cryptonite conduit ( https://github.com/haskell-crypto/cryptonite-conduit )

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

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

csv-to-qif : A small program that will read csv files and create qif files ( https://github.com/mrVanDalo/csv-to-qif/ )

cubicbezier : Efficient manipulating of 2D cubic bezier curves ( http://hackage.haskell.org/package/cubicbezier )

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

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

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

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

daemons : Daemons in Haskell made fun and easy ( https://github.com/scvalex/daemons )

data-accessor : Utilities for accessing and manipulating fields of records ( 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-bword : Extra operations on binary words of fixed length ( https://github.com/mvv/data-bword )

data-checked : Type-indexed runtime-checked properties ( https://github.com/mvv/data-checked )

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-dword : Stick two binary words together to get a bigger one ( https://github.com/mvv/data-dword )

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

data-fix : Fixpoint data types ( https://github.com/anton-k/data-fix )

data-flags : A package for working with bit masks and flags in general ( https://github.com/mvv/data-flags )

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

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

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

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

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

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

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

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

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

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

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

data-serializer : Common API for serialization libraries ( https://github.com/mvv/data-serializer )

data-textual : Human-friendly textual representations ( https://github.com/mvv/data-textual )

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

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

dates : Small library for parsing different dates formats ( http://redmine.iportnov.ru/projects/dates/ )

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

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

dbus : A client library for the D-Bus IPC system ( https://github.com/rblaze/haskell-dbus#readme )

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-generics : GHC.Generics-based Control.DeepSeq.rnf implementation ( https://github.com/hvr/deepseq-generics )

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

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

dependent-sum-template : Template Haskell code to generate instances of classes in dependent-sum package ( https://github.com/mokus0/dependent-sum-template )

derive : A program and library to derive instances for data types ( https://github.com/ndmitchell/derive#readme )

deriving-compat : Backports of GHC deriving extensions ( https://github.com/haskell-compat/deriving-compat )

descriptive : Self-describing consumers/parsers; forms, cmd-line args, JSON, etc ( https://github.com/chrisdone/descriptive )

dhall : A configuration language guaranteed to terminate ( http://hackage.haskell.org/package/dhall )

dhall-nix : Dhall to Nix compiler ( http://hackage.haskell.org/package/dhall-nix )

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

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

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

diagrams-canvas : HTML5 canvas backend for diagrams drawing EDSL ( http://projects.haskell.org/diagrams/ )

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

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

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

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

diagrams-pgf : PGF backend for diagrams drawing EDSL ( https://github.com/cchalmers/diagrams-pgf )

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

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

diagrams-solve : Pure Haskell solver routines used by diagrams ( http://projects.haskell.org/diagrams )

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

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

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

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

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

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

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

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

digestive-functors-snap : Snap backend for the digestive-functors library ( https://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, using Type Families and Data Kinds ( https://github.com/bjornbm/dimensional/ )

dimensions : Safe type-level dimensionality for multidimensional data ( https://github.com/achirkin/easytensor#readme )

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

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

directory-listing-webpage-parser : directory listing webpage parser ( http://hackage.haskell.org/package/directory-listing-webpage-parser )

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 ( https://github.com/mgrabmueller/disassembler )

disk-free-space : Retrieve information about disk space usage ( https://github.com/redneb/disk-free-space )

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

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

distributed-process-tests : Tests and test support tools for distributed-process ( https://github.com/haskell-distributed/distributed-process/tree/master/distributed-process-tests )

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

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

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

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

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

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

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

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

doctemplates : Pandoc-style document templates ( https://github.com/jgm/doctemplates#readme )

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

doctest-prop : Allow QuickCheck-style property testing within doctest ( http://hackage.haskell.org/package/doctest-prop )

dotgen : A simple interface for building .dot graph files ( https://github.com/ku-fpg/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 )

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

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

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

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

dynamic-graph : Draw and update graphs in real time with OpenGL ( https://github.com/adamwalker/dynamic-graph )

dynamic-state : Optionally serializable dynamic state keyed by type ( http://hackage.haskell.org/package/dynamic-state )

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

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

easyrender : User-friendly creation of EPS, PostScript, and PDF files ( http://www.mathstat.dal.ca/~selinger/easyrender/ )

echo : A cross-platform, cross-console way to handle echoing terminal input ( https://github.com/RyanGlScott/echo )

ed25519 : Ed25519 cryptographic signatures ( http://thoughtpolice.github.com/hs-ed25519 )

ede : Templating language with similar syntax and features to Liquid or Jinja2 ( https://github.com/brendanhay/ede )

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

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

edit-distance : Levenshtein and restricted Damerau-Levenshtein edit distances ( https://github.com/phadej/edit-distance )

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

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

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

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

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

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

ekg-json : JSON encoding of ekg metrics ( https://github.com/tibbe/ekg-json )

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

emailaddress : Wrapper around email-validate library adding instances for common type classes ( https://github.com/cdepillabout/emailaddress#readme )

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

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

engine-io : A Haskell implementation of Engine.IO ( https://github.com/ocharles/engine.io )

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

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

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

env-locale : A (non-forking) interface to the current locale ( https://github.com/Ongy/locale-hs )

equivalence : Maintaining an equivalence relation implemented as union-find using STT ( https://github.com/pa-ba/equivalence )

erd : An entity-relationship diagram generator from a plain text description ( https://github.com/BurntSushi/erd )

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

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

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

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

ether : Monad transformers and classes ( https://int-index.github.io/ether/ )

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/ )

exact-pi : Exact rational multiples of pi (and integer powers of pi) ( https://github.com/dmcclean/exact-pi/ )

exception-mtl : Exception monad transformer instances for mtl classes ( http://hackage.haskell.org/package/exception-mtl )

exception-transformers : Type classes and monads for unchecked extensible exceptions ( http://hackage.haskell.org/package/exception-transformers )

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

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

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

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

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

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

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

extra : Extra functions I use ( https://github.com/ndmitchell/extra#readme )

extract-dependencies : Given a hackage package outputs the list of its dependencies ( https://github.com/yamadapc/stack-run-auto )

fail : Forward-compatible MonadFail class ( https://prime.haskell.org/wiki/Libraries/Proposals/MonadFail )

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

fast-logger : A fast logging system ( https://github.com/kazu-yamamoto/logger )

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

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

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

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

fay-dom : DOM FFI wrapper library for Fay ( https://github.com/faylang/fay-dom )

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

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

fay-uri : Persistent FFI bindings for using jsUri in Fay ( https://github.com/faylang/fay-uri )

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

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

fdo-notify : Desktop Notifications client ( https://bitbucket.org/taejo/fdo-notify/ )

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

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

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

fficxx : automatic C++ binding generation ( http://hackage.haskell.org/package/fficxx )

ffmpeg-light : Minimal bindings to the FFmpeg library ( https://github.com/acowley/ffmpeg-light )

fgl : Martin Erwig's Functional Graph Library ( http://hackage.haskell.org/package/fgl )

fgl-arbitrary : QuickCheck support for fgl ( http://hackage.haskell.org/package/fgl-arbitrary )

fgl-visualize : Convert FGL graphs to dot (graphviz) files ( http://hackage.haskell.org/package/fgl-visualize )

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 )

file-modules : Takes a Haskell source-code file and outputs its modules ( https://github.com/yamadapc/stack-run-auto )

filelock : Portable interface to file locking (flock / LockFileEx) ( https://github.com/takano-akio/filelock )

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 )

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

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

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

fix-agda-whitespace : Fixes whitespace issues for Agda sources ( http://hackage.haskell.org/package/fix-agda-whitespace )

fixed : Signed 15.16 precision fixed point arithmetic ( https://github.com/ekmett/fixed )

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

fixed-vector-hetero : Generic heterogeneous vectors ( http://github.org/Shimuuar/fixed-vector-hetero )

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

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

floatinghex : Read and write hexadecimal floating point numbers ( http://hackage.haskell.org/package/FloatingHex )

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

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

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

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

fmlist : FoldMap lists ( https://github.com/sjoerdvisscher/fmlist )

focus : A general abstraction for manipulating elements of container data structures ( https://github.com/nikita-volkov/focus )

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

follow-file : Be notified when a file gets appended, solely with what was added ( http://hackage.haskell.org/package/follow-file )

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

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

formatting : Combinator-based type-safe formatting (like printf() or FORMAT) ( http://hackage.haskell.org/package/formatting )

foundation : Alternative prelude with batteries and no dependencies ( https://github.com/haskell-foundation/foundation )

fpretty : Efficient simple pretty printing combinators ( http://www.cs.kent.ac.uk/~oc/pretty.html )

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

freer : Implementation of the Freer Monad ( https://gitlab.com/queertypes/freer )

fresco-binding : Fresco binding for Haskell ( http://hackage.haskell.org/package/fresco-binding )

friday : A functional image processing library for Haskell ( https://github.com/RaphaelJ/friday )

friday-devil : Haskell bindings for DevIL C library ( https://github.com/RaphaelJ/friday-devil )

frisby : Linear time composable parser for PEG grammars ( http://repetae.net/computer/frisby/ )

from-sum : Canonical fromMaybeM and fromEitherM functions ( https://github.com/cdepillabout/from-sum )

frown : LALR(k) parser generator ( http://hackage.haskell.org/package/frown )

fsnotify : Cross platform library for file change notification ( https://github.com/haskell-fswatch/hfsnotify )

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

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

ftphs : FTP Client and Server Library ( http://software.complete.org/ftphs )

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

functor-monadic : Monad-style combinators for functors ( https://github.com/ombocomp/FunctorMonadic/ )

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

gasp : A framework of algebraic classes ( http://hackage.haskell.org/package/gasp )

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 )

gdiff : Generic diff and patch ( https://github.com/eelco/gdiff )

generic-deriving : Generic programming library for generalised deriving ( https://github.com/dreixel/generic-deriving )

generic-trie : A map, where the keys may be complex structured data ( https://github.com/glguy/tries )

genericpretty : A generic, derivable, haskell pretty printer ( https://github.com/RazvanRanca/GenericPretty )

generics-sop : Generic Programming using True Sums of Products ( http://hackage.haskell.org/package/generics-sop )

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

geniplate-mirror : Use Template Haskell to generate Uniplate-like functions ( https://github.com/danr/geniplate )

genvalidity : Testing utilities for the validity library ( https://github.com/NorfairKing/validity#readme )

genvalidity-hspec : Standard spec's for GenValidity instances ( https://github.com/NorfairKing/validity#readme )

genvalidity-path : GenValidity support for Path ( https://github.com/NorfairKing/validity#readme )

genvalidity-text : GenValidity support for Text ( https://github.com/NorfairKing/validity#readme )

getopt-generics : Create command line interfaces with ease ( https://github.com/soenkehahn/getopt-generics#readme )

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

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

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

ghc-datasize : Determine the size of data structures in GHC's memory ( http://felsin9.de/nnis/ghc-datasize )

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

ghc-exactprint : ExactPrint for GHC ( http://hackage.haskell.org/package/ghc-exactprint )

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

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

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

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

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

ghc-pkg-lib : Provide library support for ghc-pkg information ( https://github.com/JPMoresmau/ghc-pkg-lib )

ghc-prof : Library for parsing GHC time and allocation profiling reports ( https://github.com/maoe/ghc-prof )

ghc-simple : Simplified interface to the GHC API ( https://github.com/valderman/ghc-simple )

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

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

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

ghci-ng : Next generation GHCi ( https://github.com/chrisdone/ghci-ng )

ghcid : GHCi based bare bones IDE ( https://github.com/ndmitchell/ghcid#readme )

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

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

gi-atk : Atk bindings ( https://github.com/haskell-gi/haskell-gi )

gi-cairo : Cairo bindings ( https://github.com/haskell-gi/haskell-gi )

gi-gdk : Gdk bindings ( https://github.com/haskell-gi/haskell-gi )

gi-gdkpixbuf : GdkPixbuf bindings ( https://github.com/haskell-gi/haskell-gi )

gi-gio : Gio bindings ( https://github.com/haskell-gi/haskell-gi )

gi-glib : GLib bindings ( https://github.com/haskell-gi/haskell-gi )

gi-gobject : GObject bindings ( https://github.com/haskell-gi/haskell-gi )

gi-gtk : Gtk bindings ( https://github.com/haskell-gi/haskell-gi )

gi-gtk-hs : A wrapper for gi-gtk, adding a few more idiomatic API parts on top ( https://github.com/haskell-gi/gi-gtk-hs )

gi-gtksource : GtkSource bindings ( https://github.com/haskell-gi/haskell-gi )

gi-javascriptcore : JavaScriptCore bindings ( https://github.com/haskell-gi/haskell-gi )

gi-pango : Pango bindings ( https://github.com/haskell-gi/haskell-gi )

gi-soup : Libsoup bindings ( https://github.com/haskell-gi/haskell-gi )

gi-webkit2 : WebKit2 bindings ( https://github.com/haskell-gi/haskell-gi )

gifcurry : Create animated GIFs, overlaid with optional text, from video files ( https://github.com/lettier/gifcurry )

ginger : An implementation of the Jinja2 template language in Haskell ( https://bitbucket.org/tdammers/ginger )

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

github : Access to the GitHub API, v3 ( https://github.com/phadej/github )

github-backup : backs up everything github knows about a repository, to the repository ( https://github-backup.branchable.com/ )

gitrev : Compile git revision info into Haskell projects ( https://github.com/acfoltzer/gitrev )

gl : Complete OpenGL raw bindings ( http://hackage.haskell.org/package/gl )

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

glambda : A simply typed lambda calculus interpreter, written with GADTs ( https://github.com/goldfirere/glambda )

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

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

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

glirc : Console IRC client ( https://github.com/glguy/irc-core )

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

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

gloss-algorithms : Data structures and algorithms for working with 2D graphics ( http://gloss.ouroborus.net )

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

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

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

gloss-rendering : Gloss picture data types and rendering functions ( http://hackage.haskell.org/package/gloss-rendering )

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

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

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

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

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

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

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

goa : GHCi bindings to lambdabot ( http://hackage.haskell.org/package/goa )

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

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

gpipe : Typesafe functional GPU graphics programming ( https://github.com/tobbebex/GPipe-Core#readme )

gpipe-glfw : GLFW OpenGL context creation for GPipe ( https://github.com/plredmond/GPipe-GLFW )

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

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

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

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

gravatar : Generate Gravatar image URLs ( http://hackage.haskell.org/package/gravatar )

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

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

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

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

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

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

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

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

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

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

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

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

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

gtk3 : Binding to the Gtk+ 3 graphical user interface library ( 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/ )

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

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

hackage-db : access Hackage's package database via Data.Map ( https://github.com/peti/hackage-db )

hackage-security : Hackage security library ( https://github.com/well-typed/hackage-security )

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

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

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

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

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

hakyll-agda : Wrapper to integrate literate Agda files with Hakyll ( https://github.com/bitonic/hakyll-agda )

hakyll-sass : Hakyll SASS compiler over hsass ( https://github.com/meoblast001/hakyll-sass )

half : Half-precision floating-point ( https://github.com/ekmett/half )

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

handa-gdata : Library and command-line utility for accessing Google services and APIs ( http://code.google.com/p/hgdata )

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

hans : 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-authenticate : Happstack Authentication Library ( http://www.happstack.com/ )

happstack-hamlet : Support for Hamlet HTML 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-jmacro : Support for using JMacro with 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 ( https://www.haskell.org/happy/ )

hare : the Haskell Refactorer ( https://github.com/RefactoringTools/HaRe/wiki )

harp : HaRP allows pattern-matching with regular expressions ( https://github.com/seereason/harp )

harpy : Runtime code generation for x86 machine code ( https://github.com/mgrabmueller/harpy )

hascas : Cassandra driver for haskell ( https://github.com/eklavya/hascas#readme )

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

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

hashable-time : Hashable instances for Data.Time ( http://hackage.haskell.org/package/hashable-time )

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

hashmap : Persistent containers Map and Set based on hashing ( https://github.com/foxik/hashmap )

hashring : Efficient consistent hashing ( https://github.com/mkscrg/hashring )

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

haskakafka : Kafka bindings for Haskell ( https://github.com/cosbynator/haskakafka )

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

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

haskell-exp-parser : Simple parser parser from Haskell to TemplateHaskell expressions ( https://github.com/emilaxelsson/haskell-exp-parser )

haskell-gi : Generate Haskell bindings for GObject Introspection capable libraries ( https://github.com/haskell-gi/haskell-gi )

haskell-gi-base : Foundation for libraries generated by haskell-gi ( https://github.com/haskell-gi/haskell-gi-base )

haskell-import-graph : create haskell import graph for graphviz ( http://hackage.haskell.org/package/haskell-import-graph )

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

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

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

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

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

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

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

haskell-src-exts-simple : A simplified view on the haskell-src-exts AST ( https://github.com/int-e/haskell-src-exts-simple )

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

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

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

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

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

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

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

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

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

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

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

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

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

hatex : The Haskell LaTeX library ( https://github.com/Daniel-Diaz/HaTeX/blob/master/README.md )

haxl : A Haskell library for efficient, concurrent, and concise data access ( https://github.com/facebook/Haxl )

haxml : Utilities for manipulating XML documents ( http://projects.haskell.org/HaXml/ )

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

hayland : Haskell bindings for the C Wayland library ( http://hackage.haskell.org/package/hayland )

hcg-minus : haskell cg (minus) ( http://rd.slavepianos.org/t/hcg-minus )

hclip : A small cross-platform library for reading and modifying the system clipboard ( https://github.com/jetho/Hclip )

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

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

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

hdbc-mysql : MySQL driver for HDBC ( https://github.com/ryantm/hdbc-mysql )

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

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

hdbc-session : Bracketed connection for HDBC ( http://khibino.github.io/haskell-relational-record/ )

hdbc-sqlite3 : Sqlite v3 driver for HDBC ( https://github.com/hdbc/hdbc-sqlite3 )

hdevtools : Persistent GHC powered background server for FAST haskell development tools ( https://github.com/hdevtools/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 ( https://github.com/ekmett/heaps/ )

heckle : Jekyll in Haskell (feat. LaTeX) ( https://github.com/2016rshah/heckle )

hedgehog : Hedgehog will eat all your bugs ( https://hedgehog.qa )

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

hedis-config : Easy trivial configuration for Redis ( https://bitbucket.org/s9gf4ult/hedis-config )

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

herbieplugin : automatically improve your code's numeric stability ( https://github.com/mikeizbicki/herbie-haskell )

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

heredoc : multi-line string / here document using QuasiQuotes ( http://hackage.haskell.org/package/heredoc )

heterocephalus : A type-safe template engine for working with popular front end development tools ( https://github.com/arowM/heterocephalus#readme )

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

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

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

hformat : Simple Haskell formatting ( https://github.com/mvoidex/hformat )

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

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

hgamer3d : Toolset for the Haskell Game Programmer ( http://www.hgamer3d.org )

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

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

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

hi : Generate scaffold for cabal project ( https://github.com/fujimura/hi.git#readme )

highlighter : source code highlighting ( http://hackage.haskell.org/package/highlighter )

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

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

hint : Runtime Haskell interpreter (GHC API wrapper) ( https://github.com/mvdan/hint )

hip : Haskell Image Processing (HIP) Library ( https://github.com/lehins/hip )

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

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

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

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

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

hjsmin : Haskell implementation of a javascript minifier ( https://github.com/erikd/hjsmin )

hjsonpointer : JSON Pointer library ( https://github.com/seagreen/hjsonpointer )

hjsonschema : JSON Schema library ( https://github.com/seagreen/hjsonschema )

hledger : Command-line interface for the hledger accounting tool ( http://hledger.org )

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

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

hledger-ui : Curses-style user interface for the hledger accounting tool ( http://hledger.org )

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

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

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

hlibsass : Low-level bindings to Libsass ( https://github.com/jakubfijalkowski/hlibsass )

hlint : Source code suggestions ( https://github.com/ndmitchell/hlint#readme )

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

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

hmatrix : Numeric Linear Algebra ( https://github.com/albertoruiz/hmatrix )

hmatrix-gsl : Numerical computation ( https://github.com/albertoruiz/hmatrix )

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

hmt : Haskell Music Theory ( http://rd.slavepianos.org/t/hmt )

hnix : Haskell implementation of the Nix language ( https://github.com/jwiegley/hnix )

hoauth2 : Haskell OAuth2 authentication client ( https://github.com/freizl/hoauth2 )

hogg : Library and tools to manipulate the Ogg container format ( http://www.kfish.org/software/hogg/ )

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

hoodle : Executable for hoodle ( http://ianwookim.org/hoodle )

hoodle-builder : text builder for hoodle file format ( http://hackage.haskell.org/package/hoodle-builder )

hoodle-core : Core library for hoodle ( http://ianwookim.org/hoodle )

hoodle-parser : Hoodle file parser ( http://ianwookim.org/hoodle )

hoodle-publish : publish hoodle files as a static web site ( http://ianwookim.org/hoodle )

hoodle-render : Hoodle file renderer ( http://hackage.haskell.org/package/hoodle-render )

hoodle-types : Data types for programs for hoodle file format ( http://hackage.haskell.org/package/hoodle-types )

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

hookup : Abstraction over creating network connections with SOCKS5 and TLS ( https://github.com/glguy/irc-core )

hora : date time ( https://github.com/ciez/hora )

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

hostname : A 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 ( https://github.com/luqui/hothasktags )

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

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

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

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

hpack : An alternative format for Haskell packages ( https://github.com/sol/hpack#readme )

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

hpp : A Haskell pre-processor ( https://github.com/acowley/hpp )

hpqtypes : Haskell bindings to libpqtypes ( https://github.com/scrive/hpqtypes )

hprotoc : Parse Google Protocol Buffer specifications ( https://github.com/k-bx/protocol-buffers )

hps : Haskell Postscript ( http://rd.slavepianos.org/?t=hps )

hreader : Generalization of MonadReader and ReaderT using hset ( https://bitbucket.org/s9gf4ult/hreader )

hs-bibutils : Haskell bindings to bibutils, the bibliography conversion utilities ( http://istitutocolli.org/repos/hs-bibutils/ )

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

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

hsass : Integrating Sass into Haskell applications ( https://github.com/jakubfijalkowski/hsass )

hsb2hs : Preprocesses a file, adding blobs from files as string literals ( http://hackage.haskell.org/package/hsb2hs )

hscaffold : Very simple file/directory structure scaffolding writer monad EDSL ( https://github.com/yamadapc/hscaffold#readme )

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

hscrtmpl : Haskell shell script template ( http://hub.darcs.net/dino/hscrtmpl )

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

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

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

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

hset : Primitive list with elements of unique types ( https://bitbucket.org/s9gf4ult/hset )

hsexif : EXIF handling library in pure Haskell ( https://github.com/emmanueltouzery/hsexif )

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

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

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

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

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

hsndfile-vector : Haskell bindings for libsndfile (Data.Vector interface) ( http://haskell.org/haskellwiki/Hsndfile )

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

hsopenssl-x509-system : Use the system's native CA certificate store with HsOpenSSL ( https://github.com/redneb/HsOpenSSL-x509-system )

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

hsparql : A SPARQL query generator and DSL, and a client to query a SPARQL server ( https://github.com/robstewart57/hsparql )

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

hspec-attoparsec : Utility functions for testing your attoparsec parsers with hspec ( https://github.com/alpmestan/hspec-attoparsec )

hspec-contrib : Contributed functionality for Hspec ( http://hspec.github.io/ )

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

hspec-discover : Automatically discover and run Hspec tests ( http://hspec.github.io/ )

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

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

hspec-megaparsec : Utility functions for testing Megaparsec parsers with Hspec ( https://github.com/mrkkrp/hspec-megaparsec )

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

hspec-smallcheck : SmallCheck support for the Hspec testing framework ( http://hspec.github.io/ )

hspec-wai : Experimental Hspec support for testing WAI applications ( https://github.com/hspec/hspec-wai#readme )

hspecvariant : Spec for testing properties for variant types ( https://github.com/sanjorgek/hspecVariant )

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

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

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

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

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

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

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

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

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

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

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

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

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

hsx-jmacro : hsp+jmacro support ( http://www.happstack.com/ )

hsx2hs : HSX (Haskell Source with XML) allows literal XML syntax in Haskell source code ( https://github.com/seereason/hsx2hs )

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

htaglib : Bindings to TagLib, audio meta-data library ( https://github.com/mrkkrp/htaglib )

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

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

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

htoml : Parser for TOML files ( https://github.com/cies/htoml )

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-api-data : Converting to/from HTTP API data like URL pieces, headers and query parameters ( https://github.com/fizruk/http-api-data )

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

http-client : An HTTP client engine ( https://github.com/snoyberg/http-client )

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

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

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

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

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

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

http-link-header : An RFC 5988 parser and writer for the HTTP Link header ( https://github.com/myfreeweb/http-link-header )

http-media : Processing HTTP Content-Type and Accept headers ( https://github.com/zmthy/http-media )

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

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

http-streams : An HTTP client using io-streams ( https://github.com/afcowie/http-streams/ )

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

http2 : HTTP/2.0 library including frames and HPACK ( https://github.com/kazu-yamamoto/http2 )

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 ( https://github.com/hspec/HUnit#readme )

hunit-approx : Approximate equality for floating point numbers with HUnit ( https://github.com/goldfirere/HUnit-approx )

hxt : A collection of tools for processing XML with Haskell ( https://github.com/UweSchmidt/hxt )

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

hxt-http : Interface to native Haskell HTTP package HTTP ( https://github.com/UweSchmidt/hxt )

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 ( https://github.com/UweSchmidt/hxt )

hxt-xpath : The XPath modules for HXT ( https://github.com/UweSchmidt/hxt )

hzenhan : Zenhan library for Haskell ( https://github.com/karky7/hzenhan#readme )

ibus-hs : A simple uncomplete ibus api ( https://github.com/Ongy/ibus-hs )

icalendar : iCalendar data types, parser, and printer ( https://github.com/chrra/iCalendar )

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

idiii : ID3v2 (tagging standard for MP3 files) library ( http://hackage.haskell.org/package/idiii )

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

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

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

ignore : Handle ignore files of different VCSes ( https://github.com/agrafix/ignore )

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

ilist : Optimised list functions for doing index-related things ( https://github.com/aelve/ilist )

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

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

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

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

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

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

inflections : Inflections library for Haskell ( https://github.com/stackbuilders/inflections-hs )

ini : Quick and easy configuration files in the INI format ( https://github.com/chrisdone/ini )

inline-c : Write Haskell source files including C code inline. No FFI required ( http://hackage.haskell.org/package/inline-c )

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

integer-logarithms : Integer logarithms ( https://github.com/phadej/integer-logarithms )

integration : Fast robust numeric integration via tanh-sinh quadrature ( https://github.com/ekmett/integration )

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

intern : Efficient hash-consing for arbitrary data types ( http://github.com/ekmett/intern/ )

intero : Complete interactive development program for Haskell ( https://github.com/commercialhaskell/intero )

interpolate : String interpolation done right ( https://github.com/sol/interpolate#readme )

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

invariant : Haskell 98 invariant functors ( https://github.com/nfrisby/invariant-functors )

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 ( https://github.com/willdonnelly/io-storage )

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

io-streams-haproxy : HAProxy protocol 1.5 support for io-streams ( http://snapframework.com/ )

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/ )

ipv6addr : Library to deal with IPv6 address text representations ( https://github.com/MichelBoucey/IPv6Addr )

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

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

irc-core : IRC core library for glirc ( https://github.com/glguy/irc-core )

ircbot : A library for writing IRC bots ( https://github.com/stepcut/ircbot )

ireal : Real numbers and intervals with relatively efficient exact arithmetic ( http://hackage.haskell.org/package/ireal )

iso3166-country-codes : A datatype for ISO 3166 country codes ( http://hackage.haskell.org/package/iso3166-country-codes )

iso8601-time : Convert to/from the ISO 8601 time format ( https://github.com/nh2/iso8601-time )

itemfield : A brick Widget for selectable summary of many elements on a terminal ( http://hackage.haskell.org/package/itemfield )

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

ix-shapable : Reshape multi-dimensional arrays ( http://hackage.haskell.org/package/ix-shapable )

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

ixset-typed : Efficient relational queries on Haskell sets ( http://hackage.haskell.org/package/ixset-typed )

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 )

js-flot : Obtain minified flot code ( https://github.com/ndmitchell/js-flot#readme )

js-jquery : Obtain minified jQuery code ( https://github.com/ndmitchell/js-jquery#readme )

jsaddle : Interface for JavaScript that works with GHCJS and GHC ( http://hackage.haskell.org/package/jsaddle )

jsaddle-warp : Interface for JavaScript that works with GHCJS and GHC ( http://hackage.haskell.org/package/jsaddle-warp )

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

json-ast : Universal JSON AST datastructure ( https://github.com/nikita-volkov/json-ast )

json-bytes-builder : Direct-to-bytes JSON Builder ( https://github.com/nikita-volkov/json-bytes-builder )

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

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

judy : Fast, scalable, mutable dynamic arrays, maps and hashes ( https://github.com/mwotton/judy )

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

jupyter : A library for creating and using Jupyter kernels ( https://github.com/gibiansky/haskell-jupyter )

jwt : JSON Web Token (JWT) decoding and encoding ( https://bitbucket.org/ssaasen/haskell-jwt )

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

kansas-comet : A JavaScript push mechanism based on the comet idiom ( https://github.com/ku-fpg/kansas-comet/ )

keenser : Initial project template from stack ( https://github.com/jamesdabbs/keenser#readme )

keter : Web application deployment manager, focusing on Haskell web frameworks ( http://www.yesodweb.com/ )

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

kibro : None (deprecated) ( http://hackage.haskell.org/package/kibro )

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

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

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

lambdabot-core : Lambdabot core functionality ( https://wiki.haskell.org/Lambdabot )

lambdabot-haskell-plugins : Lambdabot Haskell plugins ( https://wiki.haskell.org/Lambdabot )

lambdabot-irc-plugins : IRC plugins for lambdabot ( https://wiki.haskell.org/Lambdabot )

lambdabot-misc-plugins : Lambdabot miscellaneous plugins ( https://wiki.haskell.org/Lambdabot )

lambdabot-novelty-plugins : Novelty plugins for Lambdabot ( https://wiki.haskell.org/Lambdabot )

lambdabot-reference-plugins : Lambdabot reference plugins ( https://wiki.haskell.org/Lambdabot )

lambdabot-social-plugins : Social plugins for Lambdabot ( https://wiki.haskell.org/Lambdabot )

lambdabot-trusted : Lambdabot trusted code ( https://wiki.haskell.org/Lambdabot )

language-bash : Parsing and pretty-printing Bash shell scripts ( https://github.com/knrafto/language-bash/ )

language-c : Analysis and generation of C code ( http://visq.github.io/language-c/ )

language-c-quote : C/CUDA/OpenCL/Objective-C quasiquoting library ( https://github.com/mainland/language-c-quote )

language-css : CSS 2.1 syntax ( http://hackage.haskell.org/package/language-css )

language-dot : A library for the analysis and creation of Graphviz DOT files ( http://hackage.haskell.org/package/language-dot )

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

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

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

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

language-javascript : Parser for JavaScript ( https://github.com/erikd/language-javascript )

language-lua : Lua parser and pretty-printer ( https://github.com/glguy/language-lua )

language-python : Parsing and pretty printing of Python code ( https://github.com/bjpop/language-python )

largeword : Provides a way of producing large WordN ( https://github.com/idontgetoutmuch/largeword )

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

lazy-csv : Efficient lazy parsers for CSV (comma-separated values) ( http://code.haskell.org/lazy-csv )

lazy-pbkdf2 : Lazy PBKDF2 generator ( http://hackage.haskell.org/package/Lazy-Pbkdf2 )

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

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

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

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

lens-action : Monadic Getters and Folds ( https://github.com/ekmett/lens-action/ )

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

lens-family : Lens Families ( http://hackage.haskell.org/package/lens-family )

lens-family-core : Haskell 98 Lens Families ( http://hackage.haskell.org/package/lens-family-core )

lens-family-th : Generate lens-family style lenses ( https://github.com/DanBurton/lens-family-th#readme )

lens-simple : simplified import of elementary lens-family combinators ( https://github.com/michaelt/lens-simple )

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

leveldb-haskell : Haskell bindings to LevelDB ( https://github.com/kim/leveldb-haskell )

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

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

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

liblawless : Prelude based on protolude for GHC 8 and beyond ( http://hackage.haskell.org/package/liblawless )

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

libnotify : Bindings to libnotify library ( http://hackage.haskell.org/package/libnotify )

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

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

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

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

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

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

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

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

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

linux-file-extents : Retrieve file fragmentation information under Linux ( https://github.com/redneb/linux-file-extents )

lio : Labeled IO Information Flow Control Library ( https://github.com/plsyssec/lio )

liquid-fixpoint : Predicate Abstraction-based Horn-Clause/Implication Constraint Solver ( https://github.com/ucsd-progsys/liquid-fixpoint )

liquiddesugar : Haskell to GHC Core Desugarar for Liquid Haskell ( http://goto.ucsd.edu/liquidhaskell )

liquidhaskell : Liquid Types for Haskell ( http://goto.ucsd.edu/liquidhaskell )

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

list-t : ListT done right ( https://github.com/nikita-volkov/list-t )

listlike : Generic support for list-like structures ( https://github.com/JohnLato/listlike )

listsafe : Safe wrappers for partial list functions, supporting MonadThrow ( https://github.com/ombocomp/listsafe )

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

lmdb : Lightning MDB bindings ( https://github.com/dmbarbour/haskell-lmdb )

load-env : Load environment variables from a file ( http://hackage.haskell.org/package/load-env )

located-base : Location-aware variants of partial functions ( https://github.com/gridaphobe/located-base )

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

loch-th : Support for precise error locations in source files (Template Haskell version) ( https://github.com/liskin/loch-th )

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

log : Structured logging solution with multiple backends ( https://github.com/scrive/log )

log-base : Structured logging solution (base package) ( https://github.com/scrive/log )

log-domain : Log-domain arithmetic ( https://github.com/ekmett/log-domain/ )

log-elasticsearch : Structured logging solution (Elasticsearch back end) ( https://github.com/scrive/log )

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

logging-effect : A mtl-style monad transformer for general purpose and compositional logging ( https://github.com/ocharles/logging-effect )

logging-facade : Simple logging abstraction that allows multiple back-ends ( http://hackage.haskell.org/package/logging-facade )

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

logict-state : Library for logic programming based on haskell package logict ( https://github.com/atzedijkstra/logict-state )

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

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

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

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

lua-bc : Lua bytecode parser ( https://github.com/GaloisInc/lua-bc )

lucid : Clear to write, read and edit DSL for HTML ( https://github.com/chrisdone/lucid )

lucid-svg : DSL for SVG using lucid for HTML ( https://github.com/jeffreyrosenbluth/lucid-svg.git )

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

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

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

machines : Networked stream transducers ( https://github.com/ekmett/machines/ )

machines-directory : Directory (system) utilities for the machines library ( https://github.com/aloiscochard/machines-directory )

machines-io : IO utilities for the machines library ( https://github.com/aloiscochard/machines-io )

mackerel-client : An API client library for Mackerel ( https://github.com/itchyny/mackerel-client-hs )

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

mainland-pretty : Pretty printing designed for printing source code ( https://github.com/mainland/mainland-pretty )

managed : A monad for managed values ( http://hackage.haskell.org/package/managed )

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

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

markdown-unlit : Literate Haskell support for Markdown ( https://github.com/sol/markdown-unlit#readme )

markov-chain : Markov Chains for generating random sequences with a user definable behaviour ( http://code.haskell.org/~thielema/markov-chain/ )

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

matrices : native matrix based on vector ( http://hackage.haskell.org/package/matrices )

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

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

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

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

megadeth : Simple project template from stack ( https://github.com/CIFASIS/megadeth#readme )

megaparsec : Monadic parser combinators ( https://github.com/mrkkrp/megaparsec )

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

memcache : A memcached client library ( https://github.com/dterei/memcache-hs )

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

memory : memory and related abstraction stuff ( https://github.com/vincenthz/hs-memory )

memotrie : Trie-based memo functions ( https://github.com/conal/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/ )

messagepack : Serialize instance for Message Pack Object ( https://github.com/rodrigosetti/messagepack )

mfsolve : Equation solver and calculator a la metafont ( http://hackage.haskell.org/package/mfsolve )

microlens : A tiny lens library with no dependencies ( https://github.com/aelve/microlens )

microlens-ghc : microlens + array, bytestring, containers, transformers ( https://github.com/aelve/microlens )

microlens-mtl : microlens support for Reader/Writer/State from mtl ( https://github.com/aelve/microlens )

microlens-platform : Feature-complete microlens ( https://github.com/aelve/microlens )

microlens-th : Automatic generation of record lenses for microlens ( https://github.com/aelve/microlens )

microtimer : A tiny library for benchmarking IO actions ( http://thoughtpolice.github.com/hs-microtimer )

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

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

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

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

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

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

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

mintty : A reliable way to detect the presence of a MinTTY console on Windows ( https://github.com/RyanGlScott/mintty )

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

missing-foreign : Convenience functions for FFI work ( http://hackage.haskell.org/package/missing-foreign )

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 )

mockery : Support functions for automated testing ( http://hackage.haskell.org/package/mockery )

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

monad-extras : Extra utility functions for working with monads ( https://github.com/jwiegley/monad-extras )

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

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

monad-logger-syslog : syslog output for monad-logger ( https://github.com/fpco/monad-logger-syslog )

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

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

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

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

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

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

monad-time : Type class for monads which carry the notion of the current time ( https://github.com/scrive/monad-time )

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

monad-unlift : Typeclasses for representing monad transformer unlifting ( https://github.com/fpco/monad-unlift )

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 )

monadio : Overloading of concurrency variables ( http://hackage.haskell.org/package/monadIO )

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

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

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

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

monadplus : Haskell98 partial maps and filters over MonadPlus ( http://hackage.haskell.org/package/monadplus )

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

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

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

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

monky : A system state collecting library and application ( http://hackage.haskell.org/package/monky )

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

mono-traversable-instances : Extra typeclass instances for mono-traversable ( https://github.com/snoyberg/mono-traversable#readme )

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

monoid-subclasses : Subclasses of Monoid ( https://github.com/blamario/monoid-subclasses/ )

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 )

mountpoints : list mount points ( http://hackage.haskell.org/package/mountpoints )

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

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

mtl-compat : Backported Control.Monad.Except module from mtl ( https://github.com/RyanGlScott/mtl-compat )

mtl-prelude : Reexports of most definitions from \"mtl\" and \"transformers\" ( https://github.com/nikita-volkov/mtl-prelude )

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

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

multimap : A multimap ( http://hub.darcs.net/scravy/multimap )

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

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

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

multiset-comb : Combinatorial algorithms over multisets ( http://hackage.haskell.org/package/multiset-comb )

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

mustache : A mustache template parser library ( https://github.com/JustusAdam/mustache )

mutable-containers : Abstactions and concrete implementations of mutable containers ( https://github.com/snoyberg/mono-traversable )

mwc-probability : Sampling function-based probability distributions ( https://github.com/jtobin/mwc-probability )

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/paul-rouse/mysql )

mysql-haskell : pure haskell MySQL driver ( https://github.com/winterland1989/mysql-haskell )

mysql-haskell-nem : Adds a interface like mysql-simple to mysql-haskell ( https://github.com/lorenzo/mysql-haskell-nem#readme )

mysql-haskell-openssl : TLS support for mysql-haskell package using openssl ( https://github.com/winterland1989/mysql-haskell )

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

namegenerator : A name generator written in Haskell ( https://github.com/pommicket/name-generator-haskell )

names-th : Manipulate name strings for TH ( http://khibino.github.io/haskell-relational-record/ )

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

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

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

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

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

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

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

natural-sort : User-friendly text collation ( https://john-millikin.com/software/natural-sort/ )

natural-transformation : A natural transformation package ( https://github.com/ku-fpg/natural-transformation )

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

neat-interpolation : A quasiquoter for neat and simple multiline text interpolation ( https://github.com/nikita-volkov/neat-interpolation )

netlink : Netlink communication for Haskell ( https://github.com/Ongy/netlink-hs )

netpbm : Loading PBM, PGM, PPM image files ( https://github.com/nh2/haskell-netpbm )

netwire : Functional reactive programming library ( https://github.com/esoeylemez/netwire )

network : Low-level networking interface ( https://github.com/haskell/network )

network-conduit : Stream socket data using conduits. (deprecated) ( https://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 ( https://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 ( https://github.com/jystic/network-info )

network-ip : Internet Protocol data structures ( https://github.com/mvv/network-ip )

network-msg : Recvmsg and sendmsg bindings ( http://hackage.haskell.org/package/network-msg )

network-multicast : Simple multicast library ( http://hackage.haskell.org/package/network-multicast )

network-protocol-xmpp : Client library for the XMPP protocol ( https://john-millikin.com/software/haskell-xmpp/ )

network-simple : Simple network sockets usage patterns ( https://github.com/k0001/network-simple )

network-socket-options : Type-safe, portable alternative to getSocketOption/setSocketOption ( https://github.com/joeyadams/haskell-network-socket-options )

network-transport : Network abstraction layer ( http://haskell-distributed.github.com )

network-transport-inmemory : In-memory instantiation of Network.Transport ( http://haskell-distributed.github.com )

network-transport-tcp : TCP instantiation of Network.Transport ( http://haskell-distributed.github.com )

network-transport-tests : Unit tests for Network.Transport implementations ( http://haskell-distributed.github.com )

network-uri : URI manipulation ( https://github.com/haskell/network-uri )

newtype : A typeclass and set of functions for working with newtypes ( http://hackage.haskell.org/package/newtype )

newtype-generics : A typeclass for working with newtypes, with generics support ( http://hackage.haskell.org/package/newtype-generics )

ngx-export : Helper module for Nginx haskell module ( https://github.com/lyokha/nginx-haskell-module )

non-empty : List-like structures with static restrictions on the number of elements ( http://hub.darcs.net/thielema/non-empty/ )

non-negative : Non-negative numbers ( http://code.haskell.org/~thielema/non-negative/ )

nonce : Generate cryptographic nonces ( https://github.com/prowdsponsor/nonce )

normaldistribution : Minimum fuss normally distributed random values ( https://github.com/bjornbm/normaldistribution )

numbers : Various number types ( https://github.com/jwiegley/numbers#readme )

numbersieves : Number Theoretic Sieves: primes, factorization, and Euler's Totient ( http://patch-tag.com/r/lpsmith/NumberSieves )

numeric-extras : Useful tools from the C standard library ( https://github.com/ekmett/numeric-extras )

numeric-prelude : An experimental alternative hierarchy of numeric type classes ( http://www.haskell.org/haskellwiki/Numeric_Prelude )

numeric-quest : Math and quantum mechanics ( http://www.haskell.org/haskellwiki/Numeric_Quest )

numhask : A numeric prelude ( https://github.com/tonyday567/numhask )

numhask-range : Numbers that are range representations ( https://github.com/tonyday567/numhask-range )

numinstances : Instances of numeric classes for functions and tuples ( https://github.com/conal/NumInstances )

numtype : Type-level (low cardinality) integers ( http://dimensional.googlecode.com/ )

numtype-dk : Type-level integers, using TypeNats, Data Kinds, and Closed Type Families ( https://github.com/bjornbm/numtype-dk )

objectname : Explicitly handled object names ( https://github.com/svenpanne/ObjectName )

oeis : Interface to the Online Encyclopedia of Integer Sequences (OEIS) ( http://hackage.haskell.org/package/oeis )

old-locale : locale library ( http://hackage.haskell.org/package/old-locale )

old-time : Time library ( http://hackage.haskell.org/package/old-time )

onetuple : Singleton Tuple ( http://hackage.haskell.org/package/OneTuple )

only : The 1-tuple type or single-value \"collection\" ( http://hackage.haskell.org/package/Only )

onrmt : Text UI library for performing parallel remote SSH operations ( http://hackage.haskell.org/package/OnRmt )

oo-prototypes : Support for OO-like prototypes ( https://github.com/yi-editor/oo-prototypes )

opaleye : An SQL-generating DSL targeting PostgreSQL ( https://github.com/tomjaguarpaw/haskell-opaleye )

open-browser : Open a web browser from Haskell ( https://github.com/rightfold/open-browser )

openal : A binding to the OpenAL cross-platform 3D audio API ( https://github.com/haskell-openal/ALUT )

opencl : Haskell high-level wrapper for OpenCL ( https://github.com/IFCA/opencl )

openclwrappers : The OpenCL Standard for heterogenous data-parallel computing ( https://github.com/jkarlson/OpenCLWrappers )

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

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

openssl-streams : OpenSSL network support for io-streams ( http://hackage.haskell.org/package/openssl-streams )

operational : Implementation of difficult monads made easy with operational semantics ( http://wiki.haskell.org/Operational )

optional-args : Optional function arguments ( http://hackage.haskell.org/package/optional-args )

options : A powerful and easy-to-use command-line option parser ( https://john-millikin.com/software/haskell-options/ )

optparse-applicative : Utilities and combinators for parsing command line options ( https://github.com/pcapriotti/optparse-applicative )

optparse-generic : Auto-generate a command-line parser for your datatype ( http://hackage.haskell.org/package/optparse-generic )

optparse-simple : Simple interface to optparse-applicative ( http://hackage.haskell.org/package/optparse-simple )

package-description-remote : Fetches a 'GenericPackageDescription' from Hackage ( https://github.com/yamadapc/stack-run-auto/package-description-remote )

palette : Utilities for choosing and creating color schemes ( http://projects.haskell.org/diagrams )

pandoc-citeproc : Supports using pandoc with citeproc ( https://github.com/jgm/pandoc-citeproc )

pandoc-crossref : Pandoc filter for cross-references ( http://hackage.haskell.org/package/pandoc-crossref )

pandoc-stylefrommeta : Pandoc filter to customize links, images and paragraphs ( https://github.com/lyokha/styleFromMeta )

pandoc-types : Types for representing a structured document ( http://johnmacfarlane.net/pandoc )

pango : Binding to the Pango text rendering engine ( http://projects.haskell.org/gtk2hs/ )

parallel : Parallel programming library ( http://hackage.haskell.org/package/parallel )

parallel-io : Combinators for executing IO actions in parallel on a thread pool ( http://batterseapower.github.com/parallel-io )

parseargs : Full-featured command-line argument parsing library ( https://github.com/BartMassey/parseargs )

parsec : Monadic parser combinators ( https://github.com/aslatter/parsec )

parsec-extra : Some miscellaneous basic string parsers ( http://hackage.haskell.org/package/parsec-extra )

parsedate : Data and time parsing for CalendarTime ( http://www.cs.chalmers.se/~bringert/darcs/parsedate/doc/ )

parsers : Parsing combinators ( https://github.com/ekmett/parsers/ )

partial-handler : A composable exception handler ( https://github.com/nikita-volkov/partial-handler )

path : Support for well-typed paths ( http://hackage.haskell.org/package/path )

path-extra : Chris Done's path library, enriched with URL-related goodies ( http://hackage.haskell.org/package/path-extra )

path-io : Interface to 'directory' package for users of 'path' ( https://github.com/mrkkrp/path-io )

path-pieces : Components of paths ( http://hackage.haskell.org/package/path-pieces )

pathtype : Type-safe replacement for System.FilePath etc ( http://hub.darcs.net/thielema/pathtype/ )

patience : Patience diff and longest increasing subsequence ( http://hackage.haskell.org/package/patience )

pattern-arrows : Arrows for Pretty Printing ( http://blog.functorial.com/posts/2013-10-27-Pretty-Printing-Arrows.html )

pcap : A system-independent interface for user-level packet capture ( https://github.com/bos/pcap )

pcg-random : Haskell bindings to the PCG random number generator ( https://github.com/cchalmers/pcg-random )

pcre-heavy : A regexp library on top of pcre-light you can actually use ( https://github.com/myfreeweb/pcre-heavy )

pcre-light : Portable regex library for Perl 5 compatible regular expressions ( https://github.com/Daniel-Diaz/pcre-light )

pdf-toolbox-content : A collection of tools for processing PDF files ( https://github.com/Yuras/pdf-toolbox )

pdf-toolbox-core : A collection of tools for processing PDF files ( https://github.com/Yuras/pdf-toolbox )

pdf-toolbox-document : A collection of tools for processing PDF files ( https://github.com/Yuras/pdf-toolbox )

pdfinfo : Wrapper around the pdfinfo command ( https://github.com/chrisdone/pdfinfo )

peggy : The Parser Generator for Haskell ( http://tanakh.github.io/Peggy/ )

pem : Privacy Enhanced Mail (PEM) format reader and writer ( https://github.com/vincenthz/hs-pem )

permutation : A library for permutations and combinations ( https://github.com/spacekitteh/permutation )

persistable-record : Binding between SQL database values and haskell records ( http://khibino.github.io/haskell-relational-record/ )

persistable-types-hdbc-pg : HDBC and Relational-Record instances of PostgreSQL extended types ( http://khibino.github.io/haskell-relational-record/ )

persistent : Type-safe, multi-backend data serialization ( http://www.yesodweb.com/book/persistent )

persistent-instances-iproute : Persistent instances for types in iproute ( http://hackage.haskell.org/package/persistent-instances-iproute )

persistent-mongodb : Backend for the persistent library using mongoDB ( http://www.yesodweb.com/book/persistent )

persistent-mysql : Backend for the persistent library using MySQL database server ( http://www.yesodweb.com/book/persistent )

persistent-postgresql : Backend for the persistent library using postgresql ( http://www.yesodweb.com/book/persistent )

persistent-redis : Backend for persistent library using Redis ( http://hackage.haskell.org/package/persistent-redis )

persistent-relational-record : relational-record on persisten backends ( https://github.com/himura/persistent-relational-record )

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 )

pgdl : browse directory listing webpages and download files from them ( http://hackage.haskell.org/package/pgdl )

pgm : Pure Haskell implementation of PGM image format ( https://github.com/astanin/haskell-pgm )

picedit : simple image manipulation functions ( https://github.com/mdibaiee/picedit#readme )

picoparsec : Fast combinator parsing for bytestrings and text ( https://bitbucket.org/blamario/picoparsec )

pid1 : Do signal handling and orphan reaping for Unix PID1 init processes ( https://github.com/fpco/pid1#readme )

pipes : Compositional pipelines ( http://hackage.haskell.org/package/pipes )

pipes-attoparsec : Attoparsec and Pipes integration ( https://github.com/k0001/pipes-attoparsec )

pipes-binary : Encode and decode binary streams using the pipes and binary libraries ( https://github.com/k0001/pipes-binary )

pipes-bytestring : ByteString support for pipes ( http://hackage.haskell.org/package/pipes-bytestring )

pipes-cereal : Encode and decode binary streams using the pipes and cereal libraries ( http://hackage.haskell.org/package/pipes-cereal )

pipes-concurrency : Concurrency for the pipes ecosystem ( http://hackage.haskell.org/package/pipes-concurrency )

pipes-group : Group streams into substreams ( http://hackage.haskell.org/package/pipes-group )

pipes-http : HTTP client with pipes interface ( http://hackage.haskell.org/package/pipes-http )

pipes-key-value-csv : Streaming processing of CSV files preceded by key-value pairs ( https://github.com/marcinmrotek/key-value-csv )

pipes-network : Use network sockets together with the pipes library ( https://github.com/k0001/pipes-network )

pipes-parse : Parsing infrastructure for the pipes ecosystem ( http://hackage.haskell.org/package/pipes-parse )

pipes-random : Producers for handling randomness ( http://hackage.haskell.org/package/pipes-random )

pipes-safe : Safety for the pipes ecosystem ( http://hackage.haskell.org/package/pipes-safe )

pipes-text : properly streaming text ( https://github.com/michaelt/text-pipes )

pipes-transduce : Interfacing pipes with foldl folds ( http://hackage.haskell.org/package/pipes-transduce )

placeholders : Placeholders for use while developing Haskell code ( https://github.com/ahammar/placeholders )

plailude : plaimi's prelude ( https://secure.plaimi.net/works/plailude )

plugins : Dynamic linking for Haskell and C objects ( http://hub.darcs.net/stepcut/plugins )

plugins-auto : Automatic recompilation and reloading of haskell modules ( http://hackage.haskell.org/package/plugins-auto )

pngload : Pure Haskell loader for PNG images ( http://hackage.haskell.org/package/pngload )

pointed : Pointed and copointed data ( https://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 ( https://github.com/23Skidoo/pointful )

poll : Bindings to poll.h ( http://hackage.haskell.org/package/poll )

polynomial : Polynomials ( https://github.com/mokus0/polynomial )

polyparse : A variety of alternative parser combinator libraries ( http://code.haskell.org/~malcolm/polyparse/ )

pop3-client : POP3 Client Library ( https://github.com/tmrudick/haskell-pop3-client/ )

poppler : Binding to the Poppler ( http://projects.haskell.org/gtk2hs )

portaudio : Haskell bindings for the PortAudio library ( http://code.haskell.org/portaudio )

portmidi : A binding for PortMedia/PortMidi ( https://github.com/ninegua/PortMidi )

postgresql-binary : Encoders and decoders for the PostgreSQL's binary format ( https://github.com/nikita-volkov/postgresql-binary )

postgresql-libpq : low-level binding to libpq ( https://github.com/lpsmith/postgresql-libpq )

postgresql-query : Sql interpolating quasiquote plus some kind of primitive ORM using it ( https://bitbucket.org/s9gf4ult/postgresql-query )

postgresql-simple : Mid-Level PostgreSQL client library ( http://hackage.haskell.org/package/postgresql-simple )

postgresql-typed : PostgreSQL interface with compile-time SQL type checking, optional HDBC backend ( https://github.com/dylex/postgresql-typed )

pqueue : Reliable, persistent, fast priority queues ( http://hackage.haskell.org/package/pqueue )

prelude-extras : Higher order versions of Prelude classes ( https://github.com/ekmett/prelude-extras )

preprocessor-tools : A framework for extending Haskell's syntax via quick-and-dirty preprocessors ( http://www.eecs.harvard.edu/~tov/pubs/haskell-session-types/ )

presburger : A decision procedure for quantifier-free linear arithmetic ( https://github.com/yav/presburger )

pretty-hex : A library for hex dumps of ByteStrings ( http://hackage.haskell.org/package/pretty-hex )

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 )

prim-uniq : Opaque unique identifiers in primitive state monads ( https://github.com/mokus0/prim-uniq )

primes : Efficient, purely functional generation of prime numbers ( https://github.com/sebfisch/primes )

primitive : Primitive memory-related operations ( https://github.com/haskell/primitive )

probability : Probabilistic Functional Programming ( http://www.haskell.org/haskellwiki/Probabilistic_Functional_Programming )

proc : Parse process information for Linux ( http://hackage.haskell.org/package/proc )

process-conduit : Conduits for processes (deprecated) ( https://github.com/snoyberg/process-conduit )

process-extras : Process extras ( https://github.com/seereason/process-extras )

process-leksah : Process libraries ( http://hackage.haskell.org/package/process-leksah )

process-streaming : Streaming interface to system processes ( http://hackage.haskell.org/package/process-streaming )

product-profunctors : product-profunctors ( https://github.com/tomjaguarpaw/product-profunctors )

prof2dot : Convert GHC profiles into GraphViz's dot format ( http://antiope.com/downloads.html )

profiteur : Treemap visualiser for GHC prof files ( https://github.com/jaspervdj/profiteur )

profunctor-extras : This package has been absorbed into profunctors 4.0 ( https://github.com/ekmett/profunctor-extras/ )

profunctors : Profunctors ( https://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 ( https://github.com/k-bx/protocol-buffers )

protocol-buffers-descriptor : module and code generated from the Google Protocol Buffer ( https://github.com/k-bx/protocol-buffers )

protolude : A sensible set of defaults for writing custom Preludes ( https://github.com/sdiehl/protolude )

prover : Automatic Prover of Logical Predicates ( http://hackage.haskell.org/package/prover )

pseudomacros : cpp-style built-in macros using Template Haskell ( http://hackage.haskell.org/package/pseudomacros )

psqueue : Priority Search Queue ( http://hackage.haskell.org/package/PSQueue )

psqueues : Pure priority search queues ( http://hackage.haskell.org/package/psqueues )

publicsuffixlist : Is a given string a domain suffix? ( https://github.com/litherum/publicsuffixlist )

pulseaudio : A low-level (incomplete) wrapper around the pulseaudio client asynchronous api ( http://hackage.haskell.org/package/pulseaudio )

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 )

pwstore-purehaskell : Secure password storage, in pure Haskell ( https://github.com/PeterScott/pwstore )

python-pickle : Serialization/deserialization using Python Pickle format ( http://hackage.haskell.org/package/python-pickle )

qt : Qt bindings ( https://github.com/keerastudios/hsQt )

qthaskellc : qtHaskell C bindings for Qt ( http://qthaskell.berlios.de/ )

quickcheck : Automatic testing of Haskell programs ( https://github.com/nick8325/quickcheck )

quickcheck-assertions : HUnit like assertions for QuickCheck ( https://github.com/s9gf4ult/quickcheck-assertions )

quickcheck-instances : Common quickcheck instances ( https://github.com/phadej/qc-instances )

quickcheck-io : Use HUnit assertions as QuickCheck properties ( https://github.com/hspec/quickcheck-io#readme )

quickcheck-properties : QuickCheck properties for standard type classes ( http://hackage.haskell.org/package/quickcheck-properties )

quickcheck-safe : Safe reimplementation of QuickCheck's core ( http://hackage.haskell.org/package/QuickCheck-safe )

quickcheck-simple : Test properties and default-mains for QuickCheck ( http://hackage.haskell.org/package/quickcheck-simple )

quickcheck-unicode : Generator and shrink functions for testing Unicode-related software ( https://github.com/bos/quickcheck-unicode )

quickcheckvariant : Generator of \"valid\" and \"invalid\" data in a type class ( https://github.com/sanjorgek/QuickCheckVariant )

quicktest : A reflective batch tester for Haskell ( https://github.com/davidsiegel/quicktest )

random : random number library ( http://hackage.haskell.org/package/random )

random-fu : Random number generation ( https://github.com/mokus0/random-fu )

random-shuffle : Random shuffle implementation ( http://hackage.haskell.org/package/random-shuffle )

random-source : Generic basis for random number generators ( https://github.com/mokus0/random-fu )

ranged-sets : Ranged sets for Haskell ( http://code.haskell.org/ranged-sets )

ranges : Ranges and various functions on them ( http://hackage.haskell.org/package/ranges )

rank1dynamic : Like Data.Dynamic/Data.Typeable but with support for rank-1 polymorphic types ( http://haskell-distributed.github.com )

rasterific : A pure haskell drawing engine ( http://hackage.haskell.org/package/Rasterific )

rate-limit : A basic library for rate-limiting IO actions ( https://github.com/acw/rate-limit )

ratio-int : Fast specialisation of Data.Ratio for Int ( https://github.com/RaphaelJ/ratio-int )

rattletrap : Parse and generate Rocket League replays ( https://github.com/tfausak/rattletrap#readme )

raw-strings-qq : Raw string literals for Haskell ( https://github.com/23Skidoo/raw-strings-qq )

rdf4h : A library for RDF processing in Haskell ( https://github.com/robstewart57/rdf4h )

rdtsc : Binding for the rdtsc machine instruction ( https://github.com/mgrabmueller/rdtsc )

re2 : Bindings to the re2 regular expression library ( https://john-millikin.com/software/haskell-re2/ )

reactive-banana : Library for functional reactive programming (FRP) ( http://wiki.haskell.org/Reactive-banana )

reactive-banana-wx : Examples for the reactive-banana library, using wxHaskell ( http://wiki.haskell.org/Reactive-banana )

readable : Reading from Text and ByteString ( https://github.com/mightybyte/readable )

readargs : Simple command line argument parsing ( https://github.com/rampion/ReadArgs )

readline : An interface to the GNU readline library ( http://hackage.haskell.org/package/readline )

rebase : A more progressive alternative to the \"base\" package ( https://github.com/nikita-volkov/rebase )

recaptcha : Functions for using the reCAPTCHA service in web applications ( https://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 ( https://github.com/ekmett/recursion-schemes/ )

redis : A driver for Redis key-value database ( http://hub.darcs.net/ganesh/redis )

reducers : Semigroups, specialized containers and a general map/reduce framework ( https://github.com/ekmett/reducers/ )

ref-tf : A type class for monads with references using type families ( http://hackage.haskell.org/package/ref-tf )

refact : Specify refactorings to perform with apply-refact ( http://hackage.haskell.org/package/refact )

reflection : Reifies arbitrary terms into types that can be reflected back into terms ( https://github.com/ekmett/reflection )

reform : reform is a type-safe HTML form generation and validation library ( http://www.happstack.com/ )

reform-hamlet : Add support for using Hamlet with Reform ( http://www.happstack.com/ )

reform-happstack : Happstack support for reform ( http://www.happstack.com/ )

reform-hsp : Add support for using HSP with Reform ( http://www.happstack.com/ )

refserialize : Write to and read from ByteStrings maintaining internal memory references ( http://hackage.haskell.org/package/RefSerialize )

regex : Toolkit for regex-base ( http://regex.uk )

regex-applicative : Regex-based parsing with applicative interface ( https://github.com/feuerbach/regex-applicative )

regex-applicative-text : regex-applicative on text ( https://github.com/phadej/regex-applicative-text#readme )

regex-base : Replaces/Enhances Text.Regex ( https://sourceforge.net/projects/lazy-regex )

regex-compat : Replaces/Enhances Text.Regex ( https://sourceforge.net/projects/lazy-regex )

regex-compat-tdfa : Unicode Support version of Text.Regex, using regex-tdfa ( http://hub.darcs.net/shelarcy/regex-compat-tdfa )

regex-dfa : Replaces/Enhances Text.Regex ( http://sourceforge.net/projects/lazy-regex )

regex-do : PCRE wrapper ( https://github.com/ciez/regex-do )

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-pcre-text : Text-based PCRE API for regex-base ( https://github.com/cdornan/regex-pcre-text )

regex-posix : Replaces/Enhances Text.Regex ( http://sourceforge.net/projects/lazy-regex )

regex-posix-unittest : Unit tests for the plaform's Posix regex library ( http://hackage.haskell.org/package/regex-posix-unittest )

regex-tdfa : Replaces/Enhances Text.Regex ( https://github.com/ChrisKuklewicz/regex-tdfa )

regex-tdfa-rc : Replaces/Enhances Text.Regex (fork by Roman Cheplyaka) ( http://hackage.haskell.org/package/regex-tdfa-rc )

regex-tdfa-text : Text interface for regex-tdfa ( http://hackage.haskell.org/package/regex-tdfa-text )

regex-tre : Replaces/Enhances Text.Regex ( http://sourceforge.net/projects/lazy-regex )

regex-with-pcre : Toolkit for regex-base ( http://regex.uk )

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 )

relational-query : Typeful, Modular, Relational, algebraic query engine ( http://khibino.github.io/haskell-relational-record/ )

relational-query-hdbc : HDBC instance of relational-query and typed query interface for HDBC ( http://khibino.github.io/haskell-relational-record/ )

relational-record : Meta package of Relational Record ( http://khibino.github.io/haskell-relational-record/ )

relational-schemas : RDBMSs' schema templates for relational-query ( http://khibino.github.io/haskell-relational-record/ )

rematch : A simple api for matchers ( http://hackage.haskell.org/package/rematch )

remote : Cloud Haskell ( 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 )

repl-toolkit : Toolkit for quickly whipping up config files and command-line interfaces ( https://github.com/ombocomp/repl-toolkit )

replib : Generic programming library with representation types ( https://github.com/sweirich/replib )

req : Easy-to-use, type-safe, expandable, high-level HTTP library ( https://github.com/mrkkrp/req )

rerebase : Reexports from \"base\" with a bunch of other standard libraries ( https://github.com/nikita-volkov/rerebase )

resolv : Domain Name Service (DNS) lookup via the libresolv standard library routines ( http://hackage.haskell.org/package/resolv )

resource-pool : A high-performance striped resource pooling implementation ( https://github.com/bos/pool )

resourcet : Deterministic allocation and freeing of scarce resources ( https://github.com/snoyberg/conduit )

retry : Retry combinators for monadic actions that may fail ( https://github.com/Soostone/retry )

rfc5051 : Simple unicode collation as per RFC5051 ( http://hackage.haskell.org/package/rfc5051 )

riff : RIFF parser for Haskell ( https://bitbucket.org/robertmassaioli/riff/overview )

rolling-queue : Bounded channel for STM that discards old entries when full ( https://github.com/joeyadams/haskell-rolling-queue )

roman-numerals : Parsing and pretty printing of Roman numerals ( https://github.com/roelvandijk/roman-numerals )

rosezipper : Generic zipper implementation for Data.Tree ( http://hackage.haskell.org/package/rosezipper )

rotating-log : Size-limited, concurrent, automatically-rotating log writer ( https://github.com/Soostone/rotating-log )

rsa : Implementation of RSA, using the padding schemes of PKCS#1 v2.1 ( http://hackage.haskell.org/package/RSA )

rss : A library for generating RSS 2.0 feeds ( https://github.com/basvandijk/rss )

rvar : Random Variables ( https://github.com/mokus0/random-fu )

safe : Library of safe (exception free) functions ( https://github.com/ndmitchell/safe#readme )

safe-exceptions : Safe, consistent, and easy exception handling ( https://github.com/fpco/safe-exceptions#readme )

safecopy : Binary serialization with version control ( https://github.com/acid-state/safecopy )

safesemaphore : Much safer replacement for QSemN, QSem, and SampleVar ( https://github.com/ChrisKuklewicz/SafeSemaphore )

sample-frame : Handling of samples in an (audio) signal ( http://www.haskell.org/haskellwiki/Synthesizer )

sample-frame-np : Orphan instances for types from sample-frame and numericprelude ( http://www.haskell.org/haskellwiki/Synthesizer )

samtools : Binding to the C samtools library ( http://www.ingolia-lab.org/samtools-tutorial.html )

sandi : Data encoding library ( http://hackage.haskell.org/package/sandi )

say : Initial project template from stack ( https://github.com/fpco/say#readme )

sbv : SMT Based Verification: Symbolic Haskell theorem prover using SMT solving ( http://leventerkok.github.com/sbv/ )

sbvplugin : Formally prove properties of Haskell programs using SBV/SMT ( https://github.com/LeventErkok/sbvPlugin )

scalpel : A high level web scraping library for Haskell ( https://github.com/fimad/scalpel )

scalpel-core : A high level web scraping library for Haskell ( https://github.com/fimad/scalpel )

scanner : Fast non-backtracking incremental combinator parsing for bytestrings ( https://github.com/Yuras/scanner )

scientific : Numbers represented using scientific notation ( https://github.com/basvandijk/scientific )

scion-browser : Command-line interface for browsing and searching packages documentation ( https://github.com/JPMoresmau/scion-class-browser )

scotty : Haskell web framework inspired by Ruby's Sinatra, using WAI and Warp ( https://github.com/scotty-web/scotty )

scotty-hastache : Easy Mustache templating support for Scotty ( https://github.com/scotty-web/scotty-hastache )

scrape-changes : Scrape websites for changes ( http://hackage.haskell.org/package/scrape-changes )

sdl : Binding to libSDL ( http://hackage.haskell.org/package/SDL )

sdl-gfx : Binding to libSDL_gfx ( http://hackage.haskell.org/package/SDL-gfx )

sdl-image : Binding to libSDL_image ( http://hackage.haskell.org/package/SDL-image )

sdl-mixer : Binding to libSDL_mixer ( http://hackage.haskell.org/package/SDL-mixer )

sdl-ttf : Binding to libSDL_ttf ( http://hackage.haskell.org/package/SDL-ttf )

sdl2 : Both high- and low-level bindings to the SDL library (version 2.0.4+) ( http://hackage.haskell.org/package/sdl2 )

sdl2-image : Bindings to SDL2_image ( http://hackage.haskell.org/package/sdl2-image )

sdl2-mixer : Bindings to SDL2_mixer ( http://hackage.haskell.org/package/sdl2-mixer )

securemem : abstraction to an auto scrubbing and const time eq, memory chunk ( https://github.com/vincenthz/hs-securemem )

semigroupoid-extras : Semigroupoids that depend on PolyKinds ( https://github.com/ekmett/semigroupoid-extras )

semigroupoids : Semigroupoids: Category sans id ( https://github.com/ekmett/semigroupoids )

semigroups : Anything that associates ( https://github.com/ekmett/semigroups/ )

sendfile : A portable sendfile library ( http://hub.darcs.net/stepcut/sendfile )

seqloc : Handle sequence locations for bioinformatics ( http://www.ingolia-lab.org/seqloc-tutorial.html )

serialise : A binary serialisation library for Haskell values ( https://github.com/well-typed/cborg )

serialport : Cross platform serial port library ( https://github.com/jputcu/serialport )

servant : A family of combinators for defining webservices APIs ( http://haskell-servant.readthedocs.org/ )

servant-server : A family of combinators for defining webservices APIs and serving them ( http://haskell-servant.readthedocs.org/ )

serversession : Secure, modular server-side sessions ( https://github.com/yesodweb/serversession )

serversession-backend-redis : Storage backend for serversession using Redis ( https://github.com/yesodweb/serversession )

serversession-frontend-yesod : Yesod bindings for serversession ( https://github.com/yesodweb/serversession )

setenv : A cross-platform library for setting environment variables ( http://hackage.haskell.org/package/setenv )

setlocale : Haskell bindings to setlocale ( https://bitbucket.org/IchUndNichtDu/haskell-setlocale )

sfml-audio : minimal bindings to the audio module of sfml ( http://patch-tag.com/r/shahn/sfml-audio )

sha : Implementations of the SHA suite of message digest functions ( http://hackage.haskell.org/package/SHA )

shake : Build system library, like Make, but more accurate dependencies ( http://shakebuild.com )

shakespeare : A toolkit for making compile-time interpolated templates ( http://www.yesodweb.com/book/shakespearean-templates )

shakespeare-css : Stick your haskell variables into css at compile time. (deprecated) ( http://www.yesodweb.com/book/shakespearean-templates )

shakespeare-i18n : A type-based approach to internationalization. (deprecated) ( http://www.yesodweb.com/book/shakespearean-templates )

shakespeare-js : Stick your haskell variables into javascript/coffeescript at compile time ( http://www.yesodweb.com/book/shakespearean-templates )

shakespeare-sass : SASS support for Shakespeare and Yesod ( https://github.com/brcha/shakespeare-sass )

shakespeare-text : Interpolation with quasi-quotation: put variables strings (deprecated) ( http://www.yesodweb.com/book/shakespearean-templates )

shell-conduit : Write shell scripts with Conduit ( https://github.com/psibi/shell-conduit )

shell-escape : Shell escaping library ( https://github.com/solidsnack/shell-escape )

shellac : A framework for creating shell envinronments ( http://rwd.rdockins.name/shellac/home/ )

shellac-compatline : \"compatline\" backend module for Shellac ( http://rwd.rdockins.name/shellac/home/ )

shellac-editline : Editline backend module for Shellac ( http://rwd.rdockins.name/shellac/home/ )

shellac-readline : Readline backend module for Shellac ( http://rwd.rdockins.name/shellac/home/ )

shellish : shell-/perl- like (systems) programming in Haskell ( http://repos.mornfall.net/shellish )

shellmate : Simple interface for shell scripting in Haskell ( https://github.com/valderman/shellmate )

shelly : shell-like (systems) programming in Haskell ( https://github.com/yesodweb/Shelly.hs )

should-not-typecheck : A HUnit/hspec assertion library to verify that an expression does not typecheck ( https://github.com/CRogers/should-not-typecheck )

show : 'Show' instances for Lambdabot ( http://hackage.haskell.org/package/show )

shuffle : Shuffle tool for UHC ( https://github.com/UU-ComputerScience/shuffle )

sibe : Machine Learning algorithms ( https://github.com/mdibaiee/sibe )

silently : Prevent or capture writing to stdout and other handles ( https://github.com/hspec/silently )

simple-log : Simple log for Haskell ( https://github.com/mvoidex/simple-log )

simple-neural-networks : Simple parallel neural networks implementation ( http://eax.me/haskell-neural-networks/ )

simple-reflect : Simple reflection of expressions containing variables ( http://twanvl.nl/blog/haskell/simple-reflection-of-expressions )

simple-sendfile : Cross platform library for the sendfile system call ( http://hackage.haskell.org/package/simple-sendfile )

simple-smt : A simple way to interact with an SMT solver process ( http://hackage.haskell.org/package/simple-smt )

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

simpleargs : Provides a more flexible getArgs function with better error reporting ( http://malde.org/~ketil/simpleargs )

simpleirc : Simple IRC Library ( https://github.com/dom96/SimpleIRC )

singletons : A framework for generating singleton types ( http://www.github.com/goldfirere/singletons )

skein : Skein, a family of cryptographic hash functions. Includes Skein-MAC as well ( https://github.com/meteficha/skein )

skylighting : syntax highlighting library ( https://github.com/jgm/skylighting )

slave-thread : A principal solution to ghost threads and silent exceptions ( https://github.com/nikita-volkov/slave-thread )

smallcheck : A property-based testing library ( https://github.com/feuerbach/smallcheck )

smtlib : A library for working with the SMTLIB format ( http://hackage.haskell.org/package/smtLib )

smtp-mail : Simple email sending via SMTP ( https://github.com/jhickner/smtp-mail )

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 dynamic loader ( http://snapframework.com/ )

snap-loader-static : Snap static loader ( http://snapframework.com/ )

snap-server : A web server for the Snap Framework ( http://snapframework.com/ )

snap-templates : Scaffolding CLI for the Snap Framework ( http://snapframework.com/ )

snaplet-sqlite-simple : sqlite-simple snaplet for the Snap Framework ( https://github.com/nurpax/snaplet-sqlite-simple )

sockaddr : Printing SockAddr ( http://hackage.haskell.org/package/sockaddr )

socket : An extensible socket library ( https://github.com/lpeterse/haskell-socket )

socket-io : This library provides an implementation of Socket.io protocol (version 1) ( https://github.com/ocharles/engine.io )

socket-sctp : STCP socket extensions library ( https://github.com/shlevy/haskell-socket-sctp )

socks : Socks proxy (version 5) implementation ( https://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 )

sourcemap : Implementation of source maps as proposed by Google and Mozilla ( http://hackage.haskell.org/package/sourcemap )

sox : Play, write, read, convert audio signals using Sox ( http://www.haskell.org/haskellwiki/Sox )

spdx : SPDX license expression language ( https://github.com/phadej/spdx )

speculation : A framework for safe, programmable, speculative parallelism ( https://github.com/ekmett/speculation )

sphinx : Haskell bindings to the Sphinx full-text searching daemon ( https://github.com/gregwebs/haskell-sphinx-client )

spintax : Random text generation based on spintax ( https://github.com/MichelBoucey/spintax )

split : Combinator library for splitting lists ( http://hackage.haskell.org/package/split )

splot : A tool for visualizing the lifecycle of many concurrent multi-staged processes ( http://www.haskell.org/haskellwiki/Splot )

spoon : Catch errors thrown from pure computations ( http://hackage.haskell.org/package/spoon )

spreadsheet : Read and write spreadsheets from and to CSV files in a lazy way ( http://www.haskell.org/haskellwiki/Spreadsheet )

sql-words : Simple idea SQL keywords data constructor into OverloadedString ( http://khibino.github.io/haskell-relational-record/ )

sqlite-simple : Mid-Level SQLite client library ( https://github.com/nurpax/sqlite-simple )

sr-extra : A grab bag of modules ( https://github.com/seereason/sr-extra )

srcloc : Data types for managing source code locations ( https://github.com/mainland/srcloc )

ssh : A pure-Haskell SSH server library ( http://hub.darcs.net/ganesh/ssh )

ssh-known-hosts : Read and interpret the SSH known-hosts file ( http://hub.darcs.net/kquick/ssh-known-hosts )

stack : The Haskell Tool Stack ( https://github.com/commercialhaskell/stack )

stack-bin : The Haskell Tool Stack (Binary) ( https://github.com/commercialhaskell/stack )

stack-run-auto : Initial project template from stack ( https://github.com/yamadapc/stack-run-auto#readme )

stateref : Abstraction for things that work like IORef ( http://hackage.haskell.org/package/stateref )

statestack : Simple State-like monad transformer with saveable and restorable state ( http://hackage.haskell.org/package/statestack )

statevar : State variables ( https://github.com/haskell-opengl/StateVar )

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 )

statvfs : Get unix filesystem statistics with statfs, statvfs ( http://hackage.haskell.org/package/statvfs )

stb-image-redux : Image loading and writing microlibrary ( https://github.com/sasinestro/stb-image-redux#readme )

stemmer : Haskell bindings to the Snowball stemming library ( http://www.github.com/bgamari/stemmer )

stickykeyshotkey : get and set STICKYKEYS.SKF_HOTKEYACTIVE ( http://hackage.haskell.org/package/stickyKeysHotKey )

stm : Software Transactional Memory ( http://hackage.haskell.org/package/stm )

stm-chans : Additional types of channels for STM ( http://code.haskell.org/~wren/ )

stm-conduit : Introduces conduits to channels, and promotes using conduits concurrently ( https://github.com/cgaebel/stm-conduit )

stm-containers : Containers for STM ( https://github.com/nikita-volkov/stm-containers )

stm-delay : Updatable one-shot timer polled with STM ( https://github.com/joeyadams/haskell-stm-delay )

stm-linkedlist : Mutable, doubly linked lists for STM ( http://hackage.haskell.org/package/stm-linkedlist )

stm-split : TMVars, TVars and TChans with distinguished input and output side ( http://hackage.haskell.org/package/stm-split )

stmonadtrans : A monad transformer version of the ST monad ( http://hackage.haskell.org/package/STMonadTrans )

storable-complex : Storable instance for Complex ( https://github.com/cartazio/storable-complex )

storable-record : Elegant definition of Storable instances for records ( http://code.haskell.org/~thielema/storable-record/ )

storable-tuple : Storable instance for pairs and triples ( http://code.haskell.org/~thielema/storable-tuple/ )

storablevector : Fast, packed, strict storable arrays with a list interface like ByteString ( http://www.haskell.org/haskellwiki/Storable_Vector )

store : Fast binary serialization ( https://github.com/fpco/store#readme )

store-core : Fast and lightweight binary serialization ( https://github.com/fpco/store#readme )

strafunski-strategylib : Library for strategic programming ( http://hackage.haskell.org/package/Strafunski-StrategyLib )

strategylib : attempt to convert Strafunski's StrategyLib to a heirarchical library ( http://naesten.dyndns.org:8080/repos/StrategyLib )

stream : A library for manipulating infinite lists ( http://hackage.haskell.org/package/Stream )

stream-fusion : Faster Haskell lists using stream fusion ( http://hackage.haskell.org/trac/ghc/ticket/915 )

streaming-commons : Common lower-level functions needed by various streaming data libraries ( https://github.com/fpco/streaming-commons )

streamproc : Stream Processer Arrow ( https://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 ( https://github.com/ygale/strict-concurrency )

strictify : Find a local optimum of strictness annotations ( http://hackage.haskell.org/package/strictify )

string-conversions : Simplifies dealing with different types for strings ( https://github.com/soenkehahn/string-conversions#readme )

string-qq : QuasiQuoter for non-interpolated strings, texts and bytestrings ( http://hackage.haskell.org/package/string-qq )

stringable : A Stringable type class, in the spirit of Foldable and Traversable ( http://hackage.haskell.org/package/stringable )

stringbuilder : A writer monad for multi-line string literals ( http://hackage.haskell.org/package/stringbuilder )

stringprep : Implements the "StringPrep" algorithm ( http://hackage.haskell.org/package/stringprep )

stringsearch : Fast searching, splitting and replacing of ByteStrings ( https://bitbucket.org/dafis/stringsearch )

stringtable-atom : Memoize Strings as Atoms for fast comparison and sorting, with maps and sets ( https://github.com/audreyt/stringtable-atom/ )

strptime : Efficient parsing of LocalTime using a binding to C's strptime ( http://hackage.haskell.org/package/strptime )

stylish-haskell : Haskell code prettifier ( https://github.com/jaspervdj/stylish-haskell )

styx : A generator of nix files ( http://hackage.haskell.org/package/styx )

suffixtree : Efficient, lazy suffix tree implementation ( https://github.com/bos/suffixtree )

suitable : Abstract over the constraints on the parameters to type constructors ( http://hackage.haskell.org/package/suitable )

superdoc : Additional documentation markup and Unicode support ( http://www.mathstat.dal.ca/~selinger/superdoc/ )

svg-builder : DSL for building SVG ( https://github.com/jeffreyrosenbluth/svg-builder.git )

svg-tree : SVG file loader and serializer ( http://hackage.haskell.org/package/svg-tree )

svgcairo : Binding to the libsvg-cairo library ( http://projects.haskell.org/gtk2hs/ )

svgfonts : Fonts from the SVG-Font format ( http://hackage.haskell.org/package/SVGFonts )

sxml : A SXML-parser ( http://blog.luigiscorner.com/ )

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/package/syb-with-class-instances-text )

symbol : A 'Symbol' type for fast symbol comparison ( http://www.cs.drexel.edu/~mainland/ )

synthesizer-core : Audio signal processing coded in Haskell: Low level part ( http://www.haskell.org/haskellwiki/Synthesizer )

system-argv0 : Get argv[0] as a FilePath ( https://john-millikin.com/software/haskell-filesystem/ )

system-fileio : Consistent filesystem interaction across GHC versions (deprecated) ( https://github.com/fpco/haskell-filesystem )

system-filepath : High-level, byte-based file and directory path manipulations (deprecated) ( https://github.com/fpco/haskell-filesystem )

system-info : Get information about CPUs, memory, etc ( https://github.com/ChaosGroup/system-info )

system-posix-redirect : A toy module to temporarily redirect a program's stdout ( http://hackage.haskell.org/package/system-posix-redirect )

system-time-monotonic : Simple library for using the system's monotonic clock ( https://github.com/joeyadams/haskell-system-time-monotonic )

system-uuid : Bindings to system UUID functions ( https://github.com/solidsnack/system-uuid/ )

syz : Scrap Your Zippers ( http://www.cs.indiana.edu/~adamsmd/papers/scrap_your_zippers/ )

tables : In-memory storage with multiple keys using lenses and traversals ( https://github.com/ekmett/tables/ )

tabular : Two-dimensional data tables with rendering functions ( http://hub.darcs.net/kowey/tabular )

tag-bits : Provides access to the dynamic pointer tagging bits used by GHC ( https://github.com/ekmett/tag-bits )

tagged : Haskell 98 phantom types to avoid unsafely passing dummy arguments ( https://github.com/ekmett/tagged )

tagged-transformer : Provides newtype wrappers for phantom types. ( https://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 ( https://github.com/ndmitchell/tagsoup#readme )

tagsoup-megaparsec : A Tag token parser and Tag specific parsing combinators ( https://github.com/kseo/tagsoup-megaparsec#readme )

tagsoup-parsec : Tokenizes Tag, so [ Tag ] can be used as parser input ( http://www.killersmurf.com )

tagstream-conduit : streamlined html tag parser ( https://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 )

tardis : Bidirectional state monad transformer ( https://github.com/DanBurton/tardis )

tasty : Modern and extensible testing framework ( https://github.com/feuerbach/tasty )

tasty-ant-xml : Render tasty output to XML for Jenkins ( https://github.com/ocharles/tasty-ant-xml )

tasty-expected-failure : Mark tasty tests as failure expected ( https://github.com/nomeata/tasty-expected-failure )

tasty-golden : Golden tests support for tasty ( https://github.com/feuerbach/tasty-golden )

tasty-hspec : Hspec support for the Tasty test framework ( https://github.com/mitchellwrosen/tasty-hspec )

tasty-hunit : HUnit support for the Tasty test framework ( http://documentup.com/feuerbach/tasty )

tasty-kat : Known Answer Tests (KAT) framework for tasty ( https://github.com/vincenthz/tasty-kat )

tasty-quickcheck : QuickCheck support for the Tasty test framework ( http://documentup.com/feuerbach/tasty )

tasty-rerun : Run tests by filtering the tests depending on the result of previous runs ( https://github.com/ocharles/tasty-rerun )

tasty-silver : A fancy test runner, including support for golden tests ( https://github.com/phile314/tasty-silver )

tasty-smallcheck : SmallCheck support for the Tasty test framework ( http://documentup.com/feuerbach/tasty )

tasty-th : Automatic tasty test case discovery using TH ( https://github.com/bennofs/tasty-th )

tcache : A Transactional cache with user-defined persistence ( http://hackage.haskell.org/package/TCache )

tcp-streams : One stop solution for tcp client and server with tls support ( https://github.com/didi-FP/tcp-streams )

tcp-streams-openssl : Tcp streams using openssl for tls support ( https://github.com/didi-FP/tcp-streams )

tdigest : On-line accumulation of rank-based statistics ( https://github.com/futurice/haskell-tdigest#readme )

template : Simple string substitution ( http://hackage.haskell.org/package/template )

temporary : Portable temporary file and directory support for Windows and Unix ( https://github.com/feuerbach/temporary )

temporary-rc : Portable temporary file and directory support for Windows and Unix ( https://github.com/feuerbach/temporary )

tensor : Tensor data types ( https://github.com/svenpanne/Tensor )

terminal-progress-bar : A simple progress bar in the terminal ( https://github.com/roelvandijk/terminal-progress-bar )

terminal-size : Get terminal window height and width ( http://hackage.haskell.org/package/terminal-size )

terminfo : Haskell bindings to the terminfo library ( https://github.com/judah/terminfo )

terminfo-hs : A pure-Haskell (no FFI) module for accessing terminfo databases ( http://hackage.haskell.org/package/terminfo-hs )

test-framework : Framework for running and organising tests, with HUnit and QuickCheck support ( https://batterseapower.github.io/test-framework/ )

test-framework-hunit : HUnit support for the test-framework package ( https://batterseapower.github.io/test-framework/ )

test-framework-quickcheck : QuickCheck support for the test-framework package ( http://batterseapower.github.com/test-framework/ )

test-framework-quickcheck2 : QuickCheck2 support for the test-framework package ( http://haskell.github.io/test-framework/ )

test-framework-smallcheck : Support for SmallCheck tests in test-framework ( https://github.com/feuerbach/smallcheck )

test-framework-th : Automagically generate the HUnit and Quickcheck code using Template Haskell ( https://github.com/finnsson/test-generator )

test-framework-th-prime : Template Haskell for test framework ( http://hackage.haskell.org/package/test-framework-th-prime )

testing-feat : Functional Enumeration of Algebraic Types ( http://hackage.haskell.org/package/testing-feat )

testpack : Test Utililty Pack for HUnit and QuickCheck (unmaintained) ( https://github.com/jgoerzen/testpack )

texmath : Conversion between formats used to represent mathematics ( https://github.com/jgm/texmath )

texrunner : Functions for running Tex from Haskell ( http://hackage.haskell.org/package/texrunner )

text : An efficient packed Unicode text type ( https://github.com/bos/text )

text-binary : Binary instances for text types ( https://github.com/kawu/text-binary )

text-format : Text formatting ( https://github.com/bos/text-format )

text-format-simple : Simple text formatting library ( http://hackage.haskell.org/package/text-format-simple )

text-icu : Bindings to the ICU library ( https://github.com/bos/text-icu )

text-icu-normalized : Dealing with Strict Text in NFC normalization ( https://gitlab.com/theunixman/text-icu-normalized )

text-latin1 : Latin-1 (including ASCII) utility functions ( https://github.com/mvv/text-latin1 )

text-manipulate : Case conversion, word boundary manipulation, and textual subjugation ( https://github.com/brendanhay/text-manipulate )

text-metrics : Calculate various string metrics efficiently ( https://github.com/mrkkrp/text-metrics )

text-postgresql : Parser and Printer of PostgreSQL extended types ( http://khibino.github.io/haskell-relational-record/ )

text-printer : Abstract interface for text builders/printers ( https://github.com/mvv/text-printer )

text-region : Marking text regions ( https://github.com/mvoidex/text-region )

text-show : Efficient conversion of values into Text ( https://github.com/RyanGlScott/text-show )

text-stream-decode : Streaming decoding functions for UTF encodings. (deprecated) ( https://github.com/fpco/text-stream-decode )

text-zipper : A text editor zipper library ( https://github.com/jtdaugherty/text-zipper/ )

tf-random : High-quality splittable pseudorandom number generator ( http://hackage.haskell.org/package/tf-random )

tga : Reading and writing of tga image files ( http://hackage.haskell.org/package/tga )

th-data-compat : Compatibility for data definition template of TH ( http://hackage.haskell.org/package/th-data-compat )

th-desugar : Functions to desugar Template Haskell ( http://www.cis.upenn.edu/~eir/packages/th-desugar )

th-expand-syns : Expands type synonyms in Template Haskell ASTs ( https://github.com/DanielSchuessler/th-expand-syns )

th-extras : A grab bag of functions for use with Template Haskell ( https://github.com/mokus0/th-extras )

th-lift : Derive Template Haskell's Lift class for datatypes ( https://github.com/mboes/th-lift )

th-lift-instances : Lift instances for template-haskell for common data types ( https://github.com/bennofs/th-lift-instances/ )

th-orphans : Orphan instances for TH datatypes ( http://hackage.haskell.org/package/th-orphans )

th-reify-compat : Compatibility for the result type of TH reify ( https://github.com/khibino/haskell-th-reify-compat/ )

th-reify-many : Recurseively reify template haskell datatype info ( https://github.com/mgsloan/th-reify-many )

th-utilities : Collection of useful functions for use with Template Haskell ( https://github.com/fpco/th-utilities#readme )

themoviedb : Haskell API bindings for http://themoviedb.org ( https://github.com/pjones/themoviedb )

these : An either-or-both data type and a generalized 'zip with padding' typeclass ( https://github.com/isomorphism/these )

threads : Fork threads and wait for their result ( https://github.com/basvandijk/threads )

threepenny-gui : GUI framework that uses the web browser as a display ( http://wiki.haskell.org/Threepenny-gui )

thyme : A faster time library ( https://github.com/liyang/thyme )

tidal : Pattern language for improvised music ( http://tidalcycles.org/ )

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 )

time-locale-compat : Compatibility of TimeLocale between old-locale and time-1.5 ( https://github.com/khibino/haskell-time-locale-compat )

time-parsers : Parsers for types in 'time' ( https://github.com/phadej/time-parsers#readme )

time-units : A basic library for defining units of time as types ( https://github.com/acw/time-units )

timeit : Time a computation ( http://hackage.haskell.org/package/timeit )

timeplot : A tool for visualizing time series from log files ( http://haskell.org/haskellwiki/Timeplot )

timespan : Useful timespan datatype and functions ( https://github.com/agrafix/timespan#readme )

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) ( https://github.com/vincenthz/hs-tls )

tls-debug : Set of programs for TLS testing and debugging ( https://github.com/vincenthz/hs-tls )

top : Constraint solving framework employed by the Helium Compiler ( http://www.cs.uu.nl/wiki/bin/view/Helium/WebHome )

torrent : BitTorrent file parser and generater ( http://hackage.haskell.org/package/torrent )

transformers : Concrete functor and monad transformers ( http://hackage.haskell.org/package/transformers )

transformers-base : Lift computations from the bottom of a transformer stack ( https://github.com/mvv/transformers-base )

transformers-compat : A small compatibility shim for dev-haskell/transformers ( https://github.com/ekmett/transformers-compat/ )

transformers-free : Free monad transformers ( http://hackage.haskell.org/package/transformers-free )

transformers-lift : Ad-hoc type classes for lifting ( http://hackage.haskell.org/package/transformers-lift )

traverse-with-class : Generic applicative traversals ( http://hackage.haskell.org/package/traverse-with-class )

trifecta : A modern parser combinator library with convenient diagnostics ( https://github.com/ekmett/trifecta/ )

ttasm : TTF assembler ( https://github.com/CIFASIS/ttasm )

ttrie : Contention-free STM hash map ( https://github.com/mcschroeder/ttrie )

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 )

turtle : Shell programming, Haskell-style ( http://hackage.haskell.org/package/turtle )

txt-sushi : The SQL link in your *NIX chain ( http://keithsheppard.name/txt-sushi )

type-aligned : Various type-aligned sequence data structures ( https://github.com/atzeus/type-aligned )

type-eq : Type equality evidence you can carry around ( https://github.com/glaebhoerl/type-eq )

type-equality : Type equality, coercion/cast and other operations ( https://github.com/hesselink/type-equality/ )

type-equality-check : Type equality check ( http://darcs.wolfgang.jeltsch.info/haskell/type-equality-check )

type-fun : Collection of widely reimplemented type families ( https://github.com/s9gf4ult/type-fun )

type-functions : Emulation of type-level functions ( http://darcs.wolfgang.jeltsch.info/haskell/type-functions )

type-hint : Guide type inference with proxy values ( https://github.com/mvv/type-hint )

type-level : Type-level programming library ( http://code.haskell.org/type-level )

type-level-numbers : Type level numbers implemented using type families ( http://hackage.haskell.org/package/type-level-numbers )

typecompose : Type composition classes and instances ( https://github.com/conal/TypeCompose )

typed-process : Run external processes, with strong typing of streams ( https://haskell-lang.org/library/typed-process )

uglymemo : A simple (but internally ugly) memoization function ( http://hackage.haskell.org/package/uglymemo )

uhc-light : Part of UHC packaged as cabal/hackage installable library ( https://github.com/UU-ComputerScience/uhc )

uhc-util : UHC utilities ( https://github.com/UU-ComputerScience/uhc-util )

unamb : Unambiguous choice ( http://haskell.org/haskellwiki/unamb )

unbound : Generic support for programming with names and binders ( https://github.com/sweirich/replib )

unbounded-delays : Unbounded thread delays and timeouts ( https://github.com/basvandijk/unbounded-delays )

unexceptionalio : IO without any non-error, synchronous exceptions ( https://github.com/singpolyma/unexceptionalio )

unicode-transforms : Unicode normalization ( https://github.com/harendra-kumar/unicode-transforms )

unification-fd : Simple generic unification algorithms ( http://code.haskell.org/~wren/ )

union-find : Efficient union and equivalence testing of sets ( https://github.com/nominolo/union-find )

uniplate : Help writing simple, concise and fast generic operations ( http://community.haskell.org/~ndm/uniplate/ )

unique : It provides the functionality like unix \\ ( https://github.com/ekmett/unique/ )

uniqueid : Splittable Unique Identifier Supply ( https://github.com/sebfisch/uniqueid/wikis )

units : A domain-specific type system for dimensional analysis ( https://github.com/goldfirere/units )

units-parser : A parser for units of measure ( http://hackage.haskell.org/package/units-parser )

unix-compat : Portable POSIX-compatibility layer ( https://github.com/jystic/unix-compat )

unix-memory : Unix memory syscalls ( https://github.com/vincenthz/hs-unix-memory )

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 ( https://github.com/seereason/haskell-unixutils.git )

unlambda : Unlambda interpreter ( http://hackage.haskell.org/package/unlambda )

unordered-containers : Efficient hashing-based container types ( https://github.com/tibbe/unordered-containers )

unsafe : Unified interface to unsafe functions ( http://code.haskell.org/~thielema/unsafe/ )

uri : Library for working with URIs ( http://gitorious.org/uri )

uri-bytestring : Haskell URI parsing as ByteStrings ( https://github.com/Soostone/uri-bytestring )

uri-encode : Unicode aware uri-encoding ( http://hackage.haskell.org/package/uri-encode )

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 )

urlpath : Painfully simple URL deployment ( http://hackage.haskell.org/package/urlpath )

userid : The UserId type and useful instances for web development ( http://www.github.com/Happstack/userid )

users : A library simplifying user management for web applications ( https://github.com/agrafix/users )

users-mysql-haskell : A mysql-haskell backend for the users library ( http://hackage.haskell.org/package/users-mysql-haskell )

utf8-light : Unicode ( http://hackage.haskell.org/package/utf8-light )

utf8-string : Support for reading and writing UTF8 Strings ( https://github.com/glguy/utf8-string/ )

utility-ht : Various small helper functions for Lists, Maybes, Tuples, Functions ( http://hackage.haskell.org/package/utility-ht )

utilitytm : Utility functions that are missing from the standard library ( https://github.com/tonymorris/utility-tm )

uu-interleaved : interleaving combinator for use with applicative/alternative style ( http://www.cs.uu.nl/wiki/bin/view/HUT/ParserCombinators )

uu-parsinglib : Online error-correcting monadic applicative and more 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 ( https://github.com/hvr/uuid )

uuid-orphans : Orphan instances for the UUID datatype ( http://hackage.haskell.org/package/uuid-orphans )

uuid-types : Type definitions for Universally Unique Identifiers ( https://github.com/aslatter/uuid )

uulib : Haskell Utrecht Tools Library ( https://github.com/UU-ComputerScience/uulib )

vacuum : Graph representation of the GHC heap ( http://thoughtpolice.github.com/vacuum )

vacuum-cairo : Visualize live Haskell data structures using vacuum, graphviz and cairo ( http://code.haskell.org/~dons/code/vacuum-cairo )

vacuum-graphviz : A library for transforming vacuum graphs into GraphViz output ( http://hackage.haskell.org/package/vacuum-graphviz )

vado : Runs commands on remote machines using ssh ( https://github.com/hamishmack/vado )

validation : A data-type like Either but with an accumulating Applicative ( https://github.com/qfpl/validation )

validity : Validity typeclass ( https://github.com/NorfairKing/validity#readme )

validity-path : Validity instances for Path ( https://github.com/NorfairKing/validity#readme )

validity-text : Validity instances for text ( https://github.com/NorfairKing/validity#readme )

varying : FRP through value streams and monadic splines ( https://github.com/schell/varying )

vault : a persistent store for values of arbitrary types ( https://github.com/HeinrichApfelmus/vault )

vcs-revision : Facilities for accessing the version control revision of the current directory ( http://hackage.haskell.org/package/vcs-revision )

vcsgui : GUI library for source code management systems ( https://github.com/forste/haskellVCSGUI )

vcswrapper : Wrapper for source code management systems ( https://github.com/forste/haskellVCSWrapper )

vect : A low-dimensional linear algebra library, tailored to computer graphics ( http://code.haskell.org/~bkomuves/ )

vector : Efficient Arrays ( https://github.com/haskell/vector )

vector-algorithms : Efficient algorithms for vector arrays ( http://code.haskell.org/~dolio/ )

vector-binary-instances : Instances of Data.Binary and Data.Serialize for vector ( https://github.com/bos/vector-binary-instances )

vector-instances : Orphan Instances for 'Data.Vector' ( https://github.com/ekmett/vector-instances )

vector-random : Generate vectors filled with high quality pseudorandom numbers ( http://code.haskell.org/~dons/code/vector-random )

vector-space : Vector and affine spaces, linear maps, and derivatives ( http://hackage.haskell.org/package/vector-space )

vector-space-points : A type for points, as distinct from vectors ( http://hackage.haskell.org/package/vector-space-points )

vector-th-unbox : Deriver for Data.Vector.Unboxed using Template Haskell ( http://hackage.haskell.org/package/vector-th-unbox )

vgrep : A pager for grep ( https://github.com/fmthoma/vgrep#readme )

viewprof : Text-based interactive GHC .prof viewer ( https://github.com/maoe/viewprof )

vimeta : Frontend for video metadata tagging tools ( https://github.com/pjones/vimeta )

vinyl : Extensible Records ( http://hackage.haskell.org/package/vinyl )

vinyl-gl : Utilities for working with OpenGL's GLSL shading language and vinyl records ( http://hackage.haskell.org/package/vinyl-gl )

vinyl-utils : Utilities for vinyl ( https://github.com/marcinmrotek/vinyl-utils )

void : A Haskell 98 logically uninhabited data type ( https://github.com/ekmett/void )

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

vty : A simple terminal UI library ( https://github.com/jtdaugherty/vty )

vty-ui : An interactive terminal user interface library for Vty ( http://jtdaugherty.github.com/vty-ui/ )

wai : Web Application Interface ( https://github.com/yesodweb/wai )

wai-app-file-cgi : File/CGI/Rev Proxy App of WAI ( http://www.mew.org/~kazu/proj/mighttpd/ )

wai-app-static : WAI application for static serving ( http://www.yesodweb.com/book/web-application-interface )

wai-conduit : conduit wrappers for WAI ( https://github.com/yesodweb/wai )

wai-eventsource : WAI support for server-sent events (deprecated) ( http://www.yesodweb.com/book/web-application-interface )

wai-extra : Provides some basic WAI handlers and middleware ( https://github.com/yesodweb/wai )

wai-handler-launch : Launch a web app in the default browser ( http://hackage.haskell.org/package/wai-handler-launch )

wai-http2-extra : WAI utilities for HTTP/2 ( https://github.com/yesodweb/wai )

wai-logger : A logging system for WAI ( http://hackage.haskell.org/package/wai-logger )

wai-test : Unit test framework (built on HUnit) for WAI applications. (deprecated) ( http://www.yesodweb.com/book/web-application-interface )

wai-websockets : Provide a bridge between WAI and the websockets package ( https://github.com/yesodweb/wai )

warp : A fast, light-weight web server for WAI applications ( https://github.com/yesodweb/wai )

warp-tls : HTTP over TLS support for Warp via the TLS package ( https://github.com/yesodweb/wai )

washngo : WASH is a family of EDSLs for programming Web applications in Haskell ( http://www.informatik.uni-freiburg.de/~thiemann/haskell/WASH/ )

wave : WAVE audio file IO library ( https://github.com/mrkkrp/wave )

wavy : Process WAVE files in Haskell ( http://bitbucket.org/robertmassaioli/wavy )

web-encodings : Encapsulate multiple web encoding in a single package. (deprecated) ( http://hackage.haskell.org/package/web-encodings )

web-plugins : dynamic plugin system for web applications ( https://github.com/clckwrks/web-plugins )

web-routes : portable, type-safe URL routing ( http://www.happstack.com/docs/crashcourse/index.html#web-routes )

web-routes-boomerang : Use boomerang for type-safe URL parsers/printers ( http://hackage.haskell.org/package/web-routes-boomerang )

web-routes-happstack : Adds support for using web-routes with Happstack ( http://hackage.haskell.org/package/web-routes-happstack )

web-routes-hsp : Adds XMLGenerator instance for RouteT monad ( http://hackage.haskell.org/package/web-routes-hsp )

web-routes-th : Support for deriving PathInfo using Template Haskell ( https://github.com/happstack/web-routes-th )

webdriver : a Haskell client for the Selenium WebDriver protocol ( https://github.com/kallisti-dev/hs-webdriver )

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

webkit-javascriptcore : JavaScriptCore FFI from webkitgtk ( http://hackage.haskell.org/package/webkit-javascriptcore )

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

webkitgtk3-javascriptcore : JavaScriptCore FFI from webkitgtk ( http://hackage.haskell.org/package/webkitgtk3-javascriptcore )

webserver : HTTP server library ( http://hackage.haskell.org/package/webserver )

websockets : A sensible and clean way to write WebSocket-capable servers in Haskell ( http://jaspervdj.be/websockets )

websockets-snap : Snap integration for the websockets library ( http://hackage.haskell.org/package/websockets-snap )

weeder : Detect dead code ( https://github.com/ndmitchell/weeder#readme )

weigh : Measure allocations of a Haskell functions/values ( https://github.com/fpco/weigh#readme )

wire-streams : Fast binary io-streams adapter ( https://github.com/winterland1989/wire-streams )

with-location : Use ImplicitParams-based source locations in a backward compatible way ( https://github.com/sol/with-location#readme )

wizards : High level, generic library for interrogative user interfaces ( http://hackage.haskell.org/package/wizards )

wl-pprint : The Wadler/Leijen Pretty Printer ( http://hackage.haskell.org/package/wl-pprint )

wl-pprint-annotated : Wadler/Leijen pretty printer with annotations and slightly modernized API ( https://github.com/minad/wl-pprint-annotated#readme )

wl-pprint-extras : A free monad based on the Wadler/Leijen pretty printer ( https://github.com/ekmett/wl-pprint-extras/ )

wl-pprint-terminfo : A color pretty printer with terminfo support ( https://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 )

word-trie : Implementation of a finite trie over words ( https://github.com/yi-editor/word-trie )

word24 : 24-bit word and int types for GHC ( https://github.com/winterland1989/word24 )

word8 : Word8 library ( http://hackage.haskell.org/package/word8 )

wordexp : wordexp(3) wrappers ( http://hackage.haskell.org/package/wordexp )

wordpass : Dictionary-based password generator ( https://github.com/mgajda/wordpass )

workdays : Workday calculations ( https://github.com/stackbuilders/workdays )

wraparound : Convenient handling of points on a seamless 2-dimensional plane ( http://frigidcode.com )

wreq : An easy-to-use HTTP client library ( http://www.serpentine.com/wreq )

wuss : Secure WebSocket (WSS) clients ( https://github.com/tfausak/wuss#readme )

wx : wxHaskell ( https://wiki.haskell.org/WxHaskell )

wxc : wxHaskell C++ wrapper ( https://wiki.haskell.org/WxHaskell )

wxcore : wxHaskell core ( https://wiki.haskell.org/WxHaskell )

wxdirect : helper tool for building wxHaskell ( https://wiki.haskell.org/WxHaskell )

x11 : A binding to the X11 graphics library ( https://github.com/xmonad/X11 )

x11-xft : Bindings to the Xft, X Free Type interface library, and some Xrender parts ( http://hackage.haskell.org/package/X11-xft )

x509 : X509 reader and writer ( https://github.com/vincenthz/hs-certificate )

x509-store : X.509 collection accessing and storing methods ( https://github.com/vincenthz/hs-certificate )

x509-system : Handle per-operating-system X.509 accessors and storage ( https://github.com/vincenthz/hs-certificate )

x509-validation : X.509 Certificate and CRL validation ( https://github.com/vincenthz/hs-certificate )

xattr : Haskell extended file attributes interface ( http://hackage.haskell.org/package/xattr )

xcb-types : Parses XML files used by the XCB project ( http://community.haskell.org/~aslatter/code/xcb-types )

xdg-basedir : A basic implementation of the XDG Base Directory specification ( https://github.com/willdonnelly/xdg-basedir )

xdg-userdirs : Basic implementation of XDG user directories specification ( http://redmine.iportnov.ru/projects/xdg-userdirs )

xdot : Parse Graphviz xdot files and interactively view them using GTK and Cairo ( http://hackage.haskell.org/package/xdot )

xformat : Extensible, type-safe formatting with scanf- and printf-like functions ( https://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 )

xkbcommon : Haskell bindings for libxkbcommon ( http://hackage.haskell.org/package/xkbcommon )

xlsx : Simple and incomplete Excel file parser/writer ( https://github.com/qrilka/xlsx )

xml : A simple XML library ( http://code.galois.com )

xml-conduit : Pure-Haskell utilities for dealing with XML with the conduit package ( https://github.com/snoyberg/xml )

xml-hamlet : Hamlet-style quasiquoter for XML content ( http://www.yesodweb.com/ )

xml-html-conduit-lens : Optics for xml-conduit and html-conduit ( https://github.com/supki/xml-html-conduit-lens#readme )

xml-lens : Lenses, traversals, and prisms for xml-conduit ( https://github.com/fumieval/xml-lens )

xml-picklers : XML picklers based on xml-types, ported from hexpat-pickle ( http://hackage.haskell.org/package/xml-picklers )

xml-types : Basic types for representing XML ( https://john-millikin.com/software/haskell-xml/ )

xmlgen : Fast XML generation library ( http://hackage.haskell.org/package/xmlgen )

xmlhtml : XML parser and renderer with HTML 5 quirks mode ( https://github.com/snapframework/xmlhtml )

xmms : XMMS2 client library ( http://kawais.org.ua/XMMS/ )

xmonad-screenshot : Workspaces screenshooting utility for XMonad ( https://github.com/supki/xmonad-screenshot )

xournal-parser : Xournal file parser ( http://ianwookim.org/hoodle )

xournal-types : Data types for programs for xournal file format ( http://hackage.haskell.org/package/xournal-types )

xss-sanitize : sanitize untrusted HTML to prevent XSS attacks ( https://github.com/yesodweb/haskell-xss-sanitize )

yaml : Support for parsing and rendering YAML documents ( https://github.com/snoyberg/yaml/ )

yaml-light : A light-weight wrapper with utility functions around HsSyck ( http://hackage.haskell.org/package/yaml-light )

yampa : Library for programming hybrid systems ( http://www.haskell.org/haskellwiki/Yampa )

yarr : Yet another array library ( http://hackage.haskell.org/package/yarr )

yesod : Creation of type-safe, RESTful web applications ( http://www.yesodweb.com/ )

yesod-angular : Angular JS integratoin ( http://hackage.haskell.org/package/yesod-angular )

yesod-auth : Authentication for Yesod ( http://www.yesodweb.com/ )

yesod-auth-account : An account authentication plugin for Yesod ( https://bitbucket.org/wuzzeb/yesod-auth-account )

yesod-auth-bcrypt : BCrypt salted and hashed passwords in a database as auth for yesod ( http://www.yesodweb.com/ )

yesod-auth-hashdb : Authentication plugin for Yesod ( https://github.com/paul-rouse/yesod-auth-hashdb )

yesod-auth-nopassword : A plugin for Yesod to provide email-only authentication ( https://github.com/danpalmer/yesod-auth-nopassword#readme )

yesod-auth-oauth2 : OAuth 2.0 authentication plugins ( https://github.com/thoughtbot/yesod-auth-oauth2 )

yesod-bin : The yesod helper executable ( http://www.yesodweb.com/ )

yesod-bootstrap : Bootstrap widgets for yesod ( https://github.com/andrewthad/haskell-bootstrap )

yesod-colonnade : Helper functions for using yesod with colonnade ( https://github.com/andrewthad/colonnade#readme )

yesod-content-pdf : PDF Content Type for Yesod ( https://github.com/alexkyllo/yesod-content-pdf#readme )

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-dsl : DSL for generating Yesod subsite to manage an RDBMS; ( http://hackage.haskell.org/package/yesod-dsl )

yesod-elements : Non template haskell markup building function in the spirit of lucid ( http://hackage.haskell.org/package/yesod-elements )

yesod-eventsource : Server-sent events support for Yesod apps ( http://www.yesodweb.com/ )

yesod-fay : Utilities for using the Fay Haskell-to-JS compiler with Yesod ( https://github.com/fpco/yesod-fay )

yesod-form : Form handling support for Yesod Web Framework ( http://www.yesodweb.com/ )

yesod-gitrepo : Host content provided by a Git repo ( https://github.com/snoyberg/yesod-gitrepo )

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 ( https://github.com/pbrisbin/yesod-markdown )

yesod-newsfeed : Helper functions and data types for producing News feeds ( http://www.yesodweb.com/ )

yesod-pagination : Pagination in Yesod ( https://github.com/joelteon/yesod-pagination )

yesod-paginator : A pagination approach for yesod ( https://github.com/pbrisbin/yesod-paginator )

yesod-persistent : Some helpers for using Persistent from Yesod ( http://www.yesodweb.com/ )

yesod-platform : Meta package for Yesod (deprecated) ( http://www.yesodweb.com/ )

yesod-recaptcha2 : yesod recaptcha2 ( https://github.com/ncaq/yesod-recaptcha2#readme )

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-static-angular : Yesod generators for embedding AngularJs code into yesod-static at compile time ( https://bitbucket.org/wuzzeb/yesod-static-angular )

yesod-table : HTML tables for Yesod ( https://github.com/andrewthad/yesod-table )

yesod-test : integration testing for WAI/Yesod Applications ( http://www.yesodweb.com )

yesod-text-markdown : Yesod support for Text.Markdown ( http://hackage.haskell.org/package/yesod-text-markdown )

yesod-websockets : WebSockets support for Yesod ( https://github.com/yesodweb/yesod )

yesod-worker : Initial project template from stack ( https://github.com/jamesdabbs/yesod-worker#readme )

yi-language : Collection of language-related Yi libraries ( https://github.com/yi-editor/yi-language )

yi-rope : A rope data structure used by Yi ( http://hackage.haskell.org/package/yi-rope )

zeromq4-haskell : Bindings to ZeroMQ 4.x ( https://gitlab.com/twittner/zeromq-haskell/ )

zip-archive : Library for creating and modifying zip archives ( https://github.com/jgm/zip-archive )

zippers : Traversal based zippers ( https://github.com/ekmett/zippers/ )

zlib : Compression and decompression in the gzip and zlib formats ( http://hackage.haskell.org/package/zlib )

zlib-bindings : Low-level bindings to the zlib package. (deprecated) ( https://github.com/snoyberg/zlib-bindings )

zlib-conduit : Streaming compression/decompression via conduits. (deprecated) ( https://github.com/snoyberg/conduit )

zlib-enum : Enumerator interface for zlib compression ( https://github.com/maltem/zlib-enum )

zmidi-core : Read and write MIDI files ( https://github.com/stephentetley/zmidi-core )

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