Ycarus Gentoo ebuild

gentoo

These ebuilds come from .

If you have some problems, go to the official site first.

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 )

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

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

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/zalora/aeson-qq )

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

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

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

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

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/batterseapower/ansi-wl-pprint )

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

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

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 )

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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 )

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 )

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

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

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

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

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 )

citeproc-hs : A Citation Style Language implementation in Haskell ( http://istitutocolli.org/repos/citeproc-hs/ )

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

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 )

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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 )

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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 )

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

hdbc-mysql : MySQL driver for HDBC ( https://github.com/bos/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-sqlite : Sqlite v3 driver for HDBC ( https://github.com/hdbc/hdbc-sqlite3 )

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

hspec : A Testing Framework for Haskell ( 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-meta : A version of Hspec which is used to test Hspec itself ( http://hspec.github.io/ )

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 )

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

language-javascript : Parser for JavaScript ( https://github.com/erikd/language-javascript )

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

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

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

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

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

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 )

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

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

logging-facade : Simple logging abstraction that allows multiple backends ( http://hackage.haskell.org/package/logging-facade )

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

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 )

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

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

memory : memory and related abtraction stuff ( https://github.com/vincenthz/hs-memory )

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

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

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 )

missingh : Large utility library ( https://github.com/jgoerzen/missingh/wiki )

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-logger : A class of monads which can log messages ( https://github.com/kazu-yamamoto/logger )

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

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

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

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 )

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 )

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

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 )

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

mutable-containers : Abstactions and concrete implementations of mutable containers ( https://github.com/fpco/mutable-containers )

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

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

network : Low-level networking interface ( https://github.com/haskell/network )

network-bytestring : Fast, memory-efficient, low-level networking ( https://github.com/tibbe/network-bytestring )

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-info : Access the local computer's basic network configuration ( https://github.com/jystic/network-info )

network-multicast : Simple multicast library ( http://hackage.haskell.org/package/network-multicast )

network-protocol-xmpp : Client library for the XMPP protocol ( https://john-millikin.com/software/haskell-xmpp/ )

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

nonce : Generate cryptographic nonces ( https://github.com/prowdsponsor/nonce )

objectname : Explicitly handled object names ( https://github.com/svenpanne/ObjectName )

old-locale : locale library ( http://hackage.haskell.org/package/old-locale )

old-time : Time library ( http://hackage.haskell.org/package/old-time )

openal : A binding to the OpenAL cross-platform 3D audio API ( https://github.com/haskell-openal/ALUT )

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 )

options : A powerful and easy-to-use command-line option parser ( https://john-millikin.com/software/haskell-options/ )

optparse-applicative : Utilities and combinators for parsing command line options ( https://github.com/pcapriotti/optparse-applicative )

pandoc-citeproc : Supports using pandoc with citeproc ( http://hackage.haskell.org/package/pandoc-citeproc )

pandoc-types : Types for representing a structured document ( http://johnmacfarlane.net/pandoc )

pango : Binding to the Pango text rendering engine ( http://projects.haskell.org/gtk2hs/ )

parallel : Parallel programming library ( http://hackage.haskell.org/package/parallel )

parsec : Monadic parser combinators ( https://github.com/aslatter/parsec )

path-pieces : Components of paths ( http://hackage.haskell.org/package/path-pieces )

patience : Patience diff and longest increasing subsequence ( http://hackage.haskell.org/package/patience )

pcap : A system-independent interface for user-level packet capture ( https://github.com/bos/pcap )

pcre-light : A small, efficient and portable regex library for Perl 5 compatible regular expressions ( https://github.com/Daniel-Diaz/pcre-light )

pem : Privacy Enhanced Mail (PEM) format reader and writer ( https://github.com/vincenthz/hs-pem )

persistent : Type-safe, multi-backend data serialization ( http://www.yesodweb.com/book/persistent )

persistent-sqlite : Backend for the persistent library using sqlite3 ( http://www.yesodweb.com/book/persistent )

persistent-template : Type-safe, non-relational, multi-backend persistence ( http://www.yesodweb.com/book/persistent )

pointed : Pointed and copointed data ( https://github.com/ekmett/pointed/ )

polyparse : A variety of alternative parser combinator libraries ( http://code.haskell.org/~malcolm/polyparse/ )

pool-conduit : Resource pool allocations via ResourceT. (deprecated) ( http://www.yesodweb.com/book/persistent )

prelude-extras : Haskell 98 - 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/ )

pretty-show : Tools for working with derived 'Show' instances and generic inspection of values ( https://wiki.github.com/yav/pretty-show )

prettyclass : Pretty printing class similar to Show ( http://hackage.haskell.org/package/prettyclass )

primitive : Primitive memory-related operations ( https://github.com/haskell/primitive )

process-conduit : Conduits for processes (deprecated) ( https://github.com/snoyberg/process-conduit )

process-extras : Process extras ( https://github.com/seereason/process-extras )

profunctor-extras : This package has been absorbed into profunctors 4.0 ( https://github.com/ekmett/profunctor-extras/ )

profunctors : Profunctors ( https://github.com/ekmett/profunctors/ )

project-template : Specify Haskell project templates and generate files ( https://github.com/fpco/haskell-ide )

psqueue : Priority Search Queue ( http://hackage.haskell.org/package/PSQueue )

publicsuffixlist : Is a given string a domain suffix? ( https://github.com/litherum/publicsuffixlist )

punycode : Encode unicode strings to ascii forms according to RFC 3492 ( https://github.com/litherum/punycode )

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 )

quickcheck : Automatic testing of Haskell programs ( https://github.com/nick8325/quickcheck )

quickcheck-instances : Common quickcheck instances ( https://github.com/aslatter/qc-instances )

quickcheck-io : Use HUnit assertions as QuickCheck properties ( http://hackage.haskell.org/package/quickcheck-io )

quickcheck-unicode : Generator and shrink functions for testing Unicode-related software ( https://github.com/bos/quickcheck-unicode )

random : random number library ( http://hackage.haskell.org/package/random )

ranges : Ranges and various functions on them ( http://hackage.haskell.org/package/ranges )

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 )

recaptcha : Functions for using the reCAPTCHA service in web applications ( https://github.com/jgm/recaptcha/tree/master )

reducers : Semigroups, specialized containers and a general map/reduce framework ( https://github.com/ekmett/reducers/ )

reflection : Reifies arbitrary terms into types that can be reflected back into terms ( https://github.com/ekmett/reflection )

regex-applicative : Regex-based parsing with applicative interface ( https://github.com/feuerbach/regex-applicative )

regex-base : Replaces/Enhances Text.Regex ( http://sourceforge.net/projects/lazy-regex )

regex-compat : Replaces/Enhances Text.Regex ( http://sourceforge.net/projects/lazy-regex )

regex-compat-tdfa : Unicode Support version of Text.Regex, using regex-tdfa ( http://hub.darcs.net/shelarcy/regex-compat-tdfa )

regex-pcre : Replaces/Enhances Text.Regex ( http://hackage.haskell.org/package/regex-pcre )

regex-pcre-builtin : Replaces/Enhances Text.Regex ( http://hackage.haskell.org/package/regex-pcre )

regex-posix : Replaces/Enhances Text.Regex ( http://sourceforge.net/projects/lazy-regex )

regex-tdfa : Replaces/Enhances Text.Regex ( http://hackage.haskell.org/package/regex-tdfa )

regex-tdfa-rc : Replaces/Enhances Text.Regex (fork by Roman Cheplyaka) ( http://hackage.haskell.org/package/regex-tdfa-rc )

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 )

rfc5051 : Simple unicode collation as per RFC5051 ( http://hackage.haskell.org/package/rfc5051 )

safe : Library of safe (exception free) functions ( https://github.com/ndmitchell/safe#readme )

safesemaphore : Much safer replacement for QSemN, QSem, and SampleVar ( https://github.com/ChrisKuklewicz/SafeSemaphore )

sandi : Data encoding library ( http://hackage.haskell.org/package/sandi )

scientific : Numbers represented using scientific notation ( https://github.com/basvandijk/scientific )

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 )

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 )

sha : Implementations of the SHA suite of message digest functions ( http://hackage.haskell.org/package/SHA )

shakespeare : A toolkit for making compile-time interpolated templates ( http://www.yesodweb.com/book/shakespearean-templates )

shakespeare-css : Stick your haskell variables into css at compile time. (deprecated) ( http://www.yesodweb.com/book/shakespearean-templates )

shakespeare-i18n : A type-based approach to internationalization. (deprecated) ( http://www.yesodweb.com/book/shakespearean-templates )

shakespeare-js : Stick your haskell variables into javascript/coffeescript at compile time. (deprecated) ( http://www.yesodweb.com/book/shakespearean-templates )

shakespeare-text : Interpolation with quasi-quotation: put variables strings (deprecated) ( http://www.yesodweb.com/book/shakespearean-templates )

shellish : shell-/perl- like (systems) programming in Haskell ( http://repos.mornfall.net/shellish )

shelly : shell-like (systems) programming in Haskell ( https://github.com/yesodweb/Shelly.hs )

silently : Prevent or capture writing to stdout and other handles ( https://github.com/hspec/silently )

simple-reflect : Simple reflection of expressions containing variables ( http://twanvl.nl/blog/haskell/simple-reflection-of-expressions )

simple-sendfile : Cross platform library for the sendfile system call ( http://hackage.haskell.org/package/simple-sendfile )

skein : Skein, a family of cryptographic hash functions. Includes Skein-MAC as well ( https://github.com/meteficha/skein )

smallcheck : A property-based testing library ( https://github.com/feuerbach/smallcheck )

snap-core : Snap: A Haskell Web Framework (core interfaces and types) ( http://snapframework.com/ )

snap-server : A fast, iteratee-based, epoll-enabled web server for the Snap Framework ( http://snapframework.com/ )

socks : Socks proxy (version 5) implementation ( https://github.com/vincenthz/hs-socks )

split : Combinator library for splitting lists ( http://hackage.haskell.org/package/split )

statevar : State variables ( https://github.com/haskell-opengl/StateVar )

statistics : A library of statistical types, data, and functions ( https://github.com/bos/statistics )

stm : Software Transactional Memory ( http://hackage.haskell.org/package/stm )

stm-chans : Additional types of channels for STM ( http://code.haskell.org/~wren/ )

stmonadtrans : A monad transformer version of the ST monad ( http://hackage.haskell.org/package/STMonadTrans )

stream : A library for manipulating infinite lists ( http://hackage.haskell.org/package/Stream )

streaming-commons : Common lower-level functions needed by various streaming data libraries ( https://github.com/fpco/streaming-commons )

strict : Strict data types and String IO ( http://www.cse.unsw.edu.au/~rl/code/strict.html )

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 )

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 )

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 )

tagged : Haskell 98 phantom types to avoid unsafely passing dummy arguments ( https://github.com/ekmett/tagged )

tagsoup : Parsing and extracting information from (possibly malformed) HTML/XML documents ( http://community.haskell.org/~ndm/tagsoup/ )

tagstream-conduit : streamlined html tag parser ( https://github.com/yihuang/tagstream-conduit )

tar : Reading, writing and manipulating \".tar\" archive files ( http://hackage.haskell.org/package/tar )

tasty : Modern and extensible testing framework ( http://documentup.com/feuerbach/tasty )

tasty-ant-xml : Render tasty output to XML for Jenkins ( https://github.com/ocharles/tasty-ant-xml )

tasty-golden : Golden tests support for tasty ( https://github.com/feuerbach/tasty-golden )

tasty-hunit : HUnit support for the Tasty test framework ( http://documentup.com/feuerbach/tasty )

tasty-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 test tree depending on the result of previous test runs ( https://github.com/ocharles/tasty-rerun )

tasty-smallcheck : SmallCheck support for the Tasty test framework ( http://documentup.com/feuerbach/tasty )

tasty-th : Automagically generate the HUnit- and Quickcheck-bulk-code using Template Haskell ( https://github.com/bennofs/tasty-th )

temporary : Portable temporary file and directory support for Windows and Unix, based on code from Cabal ( https://www.github.com/batterseapower/temporary )

temporary-rc : Portable temporary file and directory support for Windows and Unix, based on code from Cabal ( https://www.github.com/feuerbach/temporary )

tensor : Tensor data types ( http://www.haskell.org/HOpenGL/ )

terminal-size : Get terminal window height and width ( http://hackage.haskell.org/package/terminal-size )

terminfo : Haskell bindings to the terminfo library ( https://github.com/judah/terminfo )

test-framework : Framework for running and organising tests, with HUnit and QuickCheck support ( https://batterseapower.github.io/test-framework/ )

test-framework-hunit : HUnit support for the test-framework package ( https://batterseapower.github.io/test-framework/ )

test-framework-quickcheck2 : QuickCheck2 support for the test-framework package ( https://batterseapower.github.io/test-framework/ )

test-framework-th : Automagically generate the HUnit- and Quickcheck-bulk-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 )

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 )

text : An efficient packed Unicode text type ( https://github.com/bos/text )

text-icu : Bindings to the ICU library ( https://github.com/bos/text-icu )

text-stream-decode : Streaming decoding functions for UTF encodings. (deprecated) ( https://github.com/fpco/text-stream-decode )

tf-random : High-quality splittable pseudorandom number generator ( http://hackage.haskell.org/package/tf-random )

th-expand-syns : Expands type synonyms in Template Haskell ASTs ( http://hackage.haskell.org/package/th-expand-syns )

th-lift : Derive Template Haskell's Lift class for datatypes ( https://github.com/mboes/th-lift )

th-orphans : Orphan instances for TH datatypes ( http://hackage.haskell.org/package/th-orphans )

th-reify-many : Recurseively reify template haskell datatype info ( https://github.com/mgsloan/th-reify-many )

threads : Fork threads and wait for their result ( https://github.com/basvandijk/threads )

time-compat : Compatibility with old-time for the time package ( http://hub.darcs.net/dag/time-compat )

time-locale-compat : Compatibility of TimeLocale between old-locale and time-1.5 ( http://twitter.com/khibino/ )

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-extra : TLS extra default values and helpers ( 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/ )

unbounded-delays : Unbounded thread delays and timeouts ( https://github.com/basvandijk/unbounded-delays )

uniplate : Help writing simple, concise and fast generic operations ( http://community.haskell.org/~ndm/uniplate/ )

uniqueid : Splittable Unique Identifier Supply ( https://github.com/sebfisch/uniqueid/wikis )

unix-compat : Portable POSIX-compatibility layer ( https://github.com/jystic/unix-compat )

unix-time : Unix time parser/formatter and utilities ( http://hackage.haskell.org/package/unix-time )

unixutils : A crude interface between Haskell and Unix-like operating systems ( https://github.com/seereason/haskell-unixutils.git )

unordered-containers : Efficient hashing-based container types ( https://github.com/tibbe/unordered-containers )

uri : Library for working with URIs ( http://gitorious.org/uri )

url : A library for working with URLs ( http://www.haskell.org/haskellwiki/Url )

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

uuagc : 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/aslatter/uuid )

uuid-types : Type definitions for Universally Unique Identifiers ( https://github.com/aslatter/uuid )

uulib : Haskell Utrecht Tools Library ( https://github.com/UU-ComputerScience/uulib )

vault : a persistent store for values of arbitrary types ( https://github.com/HeinrichApfelmus/vault )

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-th-unbox : Deriver for Data.Vector.Unboxed using Template Haskell ( http://hackage.haskell.org/package/vector-th-unbox )

void : A Haskell 98 logically uninhabited data type ( https://github.com/ekmett/void )

wai : Web Application Interface ( https://github.com/yesodweb/wai )

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-extra : Provides some basic WAI handlers and middleware ( 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 )

warp : A fast, light-weight web server for WAI applications ( https://github.com/yesodweb/wai )

warp-tls : HTTP over SSL/TLS support for Warp via the TLS package ( https://github.com/yesodweb/wai )

wl-pprint : The Wadler/Leijen Pretty Printer ( http://hackage.haskell.org/package/wl-pprint )

word8 : Word8 library ( http://hackage.haskell.org/package/word8 )

wxc : wxHaskell C++ wrapper ( http://haskell.org/haskellwiki/WxHaskell )

wxcore : wxHaskell core ( http://haskell.org/haskellwiki/WxHaskell )

wxdirect : helper tool for building wxHaskell ( http://haskell.org/haskellwiki/WxHaskell )

wxhaskell : wxHaskell ( http://haskell.org/haskellwiki/WxHaskell )

x11 : A binding to the X11 graphics library ( https://github.com/haskell-pkg-janitors/X11 )

x11-xft : Bindings to the Xft, X Free Type interface library, and some Xrender parts ( http://hackage.haskell.org/package/X11-xft )

x509 : X509 reader and writer ( 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 )

xhtml : An XHTML combinator library ( https://github.com/haskell/xhtml )

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-types : Basic types for representing XML ( https://john-millikin.com/software/haskell-xml/ )

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

yesod : Creation of type-safe, RESTful web applications ( http://www.yesodweb.com/ )

yesod-auth : Authentication for Yesod ( http://www.yesodweb.com/ )

yesod-auth-hashdb : Authentication plugin for Yesod ( https://github.com/paul-rouse/yesod-auth-hashdb )

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-form : Form handling support for Yesod Web Framework ( http://www.yesodweb.com/ )

yesod-json : Generate content for Yesod using the aeson package. (deprecated) ( http://www.yesodweb.com/ )

yesod-persistent : Some helpers for using Persistent from Yesod ( http://www.yesodweb.com/ )

yesod-platform : Meta package for Yesod (deprecated) ( http://www.yesodweb.com/ )

yesod-routes : Efficient routing for Yesod ( http://www.yesodweb.com/ )

yesod-static : Static file serving subsite for Yesod Web Framework ( http://www.yesodweb.com/ )

yesod-test : integration testing for WAI/Yesod Applications ( http://www.yesodweb.com )

zip-archive : Library for creating and modifying zip archives ( https://github.com/jgm/zip-archive )

zlib : Compression and decompression in the gzip and zlib formats ( http://hackage.haskell.org/package/zlib )

zlib-bindings : Low-level bindings to the zlib package. (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 )

Add an ebuild in portage :

The ebuild is now in the portage tree.

You can also use layman : emerge layman then layman -a gentoo

For Paludis use this rsync : rsync://gentoo.zugaina.org/gentoo-portage

If you have a problem : ycarus(-at-)zugaina.org