| app-text/pandoc | 
                Command-line tool and Haskell library for converting from one markup format to another | 
            
        
            
                | dev-haskell/Boolean | 
                Generalized booleans | 
            
        
            
                | dev-haskell/Cabal | 
                The Cabal package | 
            
        
            
                | dev-haskell/ChasingBottoms | 
                Test code involving bottoms or infinite values | 
            
        
            
                | dev-haskell/Crypto | 
                Collects together existing Haskell cryptographic functions into a package | 
            
        
            
                | dev-haskell/DAV | 
                RFC 4918 WebDAV support | 
            
        
            
                | dev-haskell/Diff | 
                Basic implementation of the standard diff algorithm | 
            
        
            
                | dev-haskell/FindBin | 
                This module locates the full directory of the running program | 
            
        
            
                | dev-haskell/GLURaw | 
                A raw binding for the OpenGL graphics system | 
            
        
            
                | dev-haskell/GLUT | 
                A binding for the OpenGL Utility Toolkit | 
            
        
            
                | dev-haskell/Glob | 
                A library for globbing: matching patterns against file paths | 
            
        
            
                | dev-haskell/HTTP | 
                A library for client-side HTTP | 
            
        
            
                | dev-haskell/HUnit | 
                Unit testing framework for Haskell | 
            
        
            
                | dev-haskell/HaXml | 
                Utilities for parsing, filtering, transforming and generating XML documents | 
            
        
            
                | dev-haskell/IfElse | 
                Anaphoric and miscellaneous useful control-flow | 
            
        
            
                | dev-haskell/JuicyPixels | 
                Picture loading/serialization (in png, jpeg, bitmap and gif) | 
            
        
            
                | dev-haskell/List | 
                A List monad transformer and a List class | 
            
        
            
                | dev-haskell/MemoTrie | 
                Trie-based memo functions | 
            
        
            
                | dev-haskell/MissingH | 
                Large utility library | 
            
        
            
                | dev-haskell/MonadCatchIO-transformers | 
                Monad-transformer compatible version of the Control.Exception module | 
            
        
            
                | dev-haskell/MonadRandom | 
                Support for computations which consume random values | 
            
        
            
                | dev-haskell/NumInstances | 
                Instances of numeric classes for functions and tuples | 
            
        
            
                | dev-haskell/ObjectName | 
                Explicitly handled object names | 
            
        
            
                | dev-haskell/OpenGL | 
                A binding for the OpenGL graphics system | 
            
        
            
                | dev-haskell/OpenGLRaw | 
                A raw binding for the OpenGL graphics system | 
            
        
            
                | dev-haskell/PSQueue | 
                Priority Search Queue | 
            
        
            
                | dev-haskell/QuickCheck | 
                An automatic, specification based testing utility for Haskell programs | 
            
        
            
                | dev-haskell/RSA | 
                Implementation of RSA, using the padding schemes of PKCS#1 v2.1 | 
            
        
            
                | dev-haskell/ReadArgs | 
                Simple command line argument parsing | 
            
        
            
                | dev-haskell/SDL | 
                Haskell binding to libSDL | 
            
        
            
                | dev-haskell/SHA | 
                Implementations of the SHA suite of message digest functions | 
            
        
            
                | dev-haskell/Safe | 
                Library for safe (pattern match free) functions | 
            
        
            
                | dev-haskell/SafeSemaphore | 
                Much safer replacement for QSemN, QSem, and SampleVar | 
            
        
            
                | dev-haskell/StateVar | 
                State variables | 
            
        
            
                | dev-haskell/X11 | 
                A haskell binding to the X11 graphics library | 
            
        
            
                | dev-haskell/X11-xft | 
                Bindings to the Xft, X Free Type interface library, and some Xrender parts | 
            
        
            
                | dev-haskell/Yampa | 
                Library for programming hybrid systems | 
            
        
            
                | dev-haskell/abstract-deque | 
                An abstract interface to highly-parameterizable queues/deques | 
            
        
            
                | dev-haskell/abstract-par | 
                The Par monad offers a parallel programming API based on dataflow programming | 
            
        
            
                | dev-haskell/adjunctions | 
                Adjunctions and representable functors | 
            
        
            
                | dev-haskell/aeson | 
                JSON parsing and generation library | 
            
        
            
                | dev-haskell/aeson-compat | 
                Compatibility layer for aeson | 
            
        
            
                | dev-haskell/aeson-pretty | 
                A JSON pretty-printing library compatible with aeson | 
            
        
            
                | dev-haskell/aeson-qq | 
                aeson-qq provides a JSON quasiquoter for Haskell | 
            
        
            
                | dev-haskell/alex | 
                A tool for generating lexical analysers in Haskell | 
            
        
            
                | dev-haskell/alsa-core | 
                Bindings to the ALSA library API | 
            
        
            
                | dev-haskell/alsa-mixer | 
                Bindings to the ALSA simple mixer API | 
            
        
            
                | dev-haskell/ansi-terminal | 
                Simple ANSI terminal support, with Windows compatibility | 
            
        
            
                | dev-haskell/ansi-wl-pprint | 
                The Wadler/Leijen Pretty Printer for colored ANSI terminal output | 
            
        
            
                | dev-haskell/appar | 
                A simple applicative parser in Parsec style | 
            
        
            
                | dev-haskell/array | 
                Mutable and immutable arrays | 
            
        
            
                | dev-haskell/ascii-progress | 
                progress bar for the console | 
            
        
            
                | dev-haskell/asn1-data | 
                ASN1 data reader and writer in RAW, BER, DER and CER forms | 
            
        
            
                | dev-haskell/asn1-encoding | 
                ASN1 data reader and writer in raw form with supports for high level forms of ASN1 | 
            
        
            
                | dev-haskell/asn1-parse | 
                ASN1 data reader and writer in raw form with supports for high level forms of ASN1 | 
            
        
            
                | dev-haskell/asn1-types | 
                ASN.1 standard types | 
            
        
            
                | dev-haskell/async | 
                Run IO operations asynchronously and wait for their results | 
            
        
            
                | dev-haskell/attempt | 
                Concrete data type for handling extensible exceptions as failures | 
            
        
            
                | dev-haskell/attoparsec | 
                Fast parser combinator library | 
            
        
            
                | dev-haskell/attoparsec-conduit | 
                Turn attoparsec parsers into sinks (deprecated) | 
            
        
            
                | dev-haskell/attoparsec-enumerator | 
                Convert an Attoparsec parser into an iteratee | 
            
        
            
                | dev-haskell/augeas | 
                Haskell FFI wrapper for the Augeas API | 
            
        
            
                | dev-haskell/authenticate | 
                Authentication methods for Haskell web applications | 
            
        
            
                | dev-haskell/auto-update | 
                Auto-update | 
            
        
            
                | dev-haskell/aws | 
                Amazon Web Services (AWS) for Haskell | 
            
        
            
                | dev-haskell/base-compat | 
                Provides functions available in later versions of base to a wider range of compilers, without requiring you to use CPP pragmas in your code | 
            
        
            
                | dev-haskell/base-orphans | 
                Backwards-compatible orphan instances for base | 
            
        
            
                | dev-haskell/base-unicode-symbols | 
                Symbols for a number of functions and operators in the base package | 
            
        
            
                | dev-haskell/base16-bytestring | 
                Fast base16 (hex) encoding and decoding for ByteStrings | 
            
        
            
                | dev-haskell/base64-bytestring | 
                Fast base64 encoding and deconding for ByteStrings | 
            
        
            
                | dev-haskell/basic-prelude | 
                Enhanced core prelude; a common foundation for alternate preludes | 
            
        
            
                | dev-haskell/bencode | 
                Parser and printer for bencoded data | 
            
        
            
                | dev-haskell/bifunctors | 
                Bifunctors | 
            
        
            
                | dev-haskell/binary | 
                Binary serialisation for Haskell values using lazy ByteStrings | 
            
        
            
                | dev-haskell/blaze-builder | 
                Builder to efficiently append text, optimized for HTML generation | 
            
        
            
                | dev-haskell/blaze-builder-conduit | 
                Convert streams of builders to streams of bytestrings (deprecated) | 
            
        
            
                | dev-haskell/blaze-builder-enumerator | 
                Integrates the builders from the blaze-builder with enumerator | 
            
        
            
                | dev-haskell/blaze-html | 
                Blazingly fast HTML combinator library | 
            
        
            
                | dev-haskell/blaze-markup | 
                Blazingly fast markup combinator library | 
            
        
            
                | dev-haskell/blaze-textual | 
                Efficiently render Haskell datatypes to bytestrings | 
            
        
            
                | dev-haskell/bloomfilter | 
                Pure and impure Bloom Filter implementations | 
            
        
            
                | dev-haskell/bmp | 
                Read and write uncompressed BMP image files | 
            
        
            
                | dev-haskell/byteable | 
                Abstract class to manipulate sequence of bytes | 
            
        
            
                | dev-haskell/byteorder | 
                Exposes the native endianness or byte ordering of the system | 
            
        
            
                | dev-haskell/bytestring | 
                Fast, packed, strict and lazy byte arrays with a list interface | 
            
        
            
                | dev-haskell/bytestring-builder | 
                bytestring-builder | 
            
        
            
                | dev-haskell/bytestring-handle | 
                The bytestring-handle package | 
            
        
            
                | dev-haskell/bytestring-mmap | 
                Lazy wrapper to mmap(2) | 
            
        
            
                | dev-haskell/bytestring-nums | 
                Parse numeric literals from ByteStrings | 
            
        
            
                | dev-haskell/bytestring-trie | 
                An efficient finite map from (byte)strings to values | 
            
        
            
                | dev-haskell/c2hs | 
                C -> Haskell Interface Generator | 
            
        
            
                | dev-haskell/cabal-helper | 
                Interface to some of Cabal's configuration state used by ghc-mod | 
            
        
            
                | dev-haskell/cabal-install | 
                The command-line interface for Cabal and Hackage | 
            
        
            
                | dev-haskell/case-insensitive | 
                Type constructor which can be parameterised by a string-like type | 
            
        
            
                | dev-haskell/cassava | 
                A CSV parsing and encoding library optimized for ease of use and high performance | 
            
        
            
                | dev-haskell/cereal | 
                Binary serialization library | 
            
        
            
                | dev-haskell/chell | 
                A simple and intuitive library for automated testing | 
            
        
            
                | dev-haskell/chell-quickcheck | 
                QuickCheck support for the Chell testing library | 
            
        
            
                | dev-haskell/chunked-data | 
                Typeclasses for dealing with various chunked data representations | 
            
        
            
                | dev-haskell/cipher-aes | 
                Fast AES cipher implementation with advanced mode of operations | 
            
        
            
                | dev-haskell/cipher-blowfish | 
                Blowfish cipher primitives | 
            
        
            
                | dev-haskell/cipher-camellia | 
                Camellia block cipher primitives | 
            
        
            
                | dev-haskell/cipher-des | 
                DES and 3DES primitives | 
            
        
            
                | dev-haskell/cipher-rc4 | 
                Fast RC4 cipher implementation | 
            
        
            
                | dev-haskell/classy-prelude | 
                typeclass-based Prelude | 
            
        
            
                | dev-haskell/classy-prelude-conduit | 
                conduit instances for classy-prelude | 
            
        
            
                | dev-haskell/clientsession | 
                Store session data in a cookie | 
            
        
            
                | dev-haskell/clock | 
                Convenient access to high-resolution clock and timer functions | 
            
        
            
                | dev-haskell/cmark | 
                This package provides Haskell bindings for libcmark | 
            
        
            
                | dev-haskell/cmdargs | 
                Command line argument processing | 
            
        
            
                | dev-haskell/cmdlib | 
                Library for command line parsing and online help | 
            
        
            
                | dev-haskell/cml | 
                Events and Channels as in Concurrent ML | 
            
        
            
                | dev-haskell/combinat | 
                Generation of various combinatorial objects | 
            
        
            
                | dev-haskell/comonad | 
                Haskell 98 compatible comonads | 
            
        
            
                | dev-haskell/comonad-transformers | 
                Comonad transformers | 
            
        
            
                | dev-haskell/comonads-fd | 
                Comonad transformers using functional dependencies | 
            
        
            
                | dev-haskell/concurrent-output | 
                Ungarble output from several threads or commands | 
            
        
            
                | dev-haskell/conduit | 
                Streaming data processing library | 
            
        
            
                | dev-haskell/conduit-combinators | 
                Commonly used conduit functions, for both chunked and unchunked data | 
            
        
            
                | dev-haskell/conduit-extra | 
                The conduit-extra package | 
            
        
            
                | dev-haskell/connection | 
                Simple network library for all your connection need | 
            
        
            
                | dev-haskell/constraints | 
                Constraint manipulation | 
            
        
            
                | dev-haskell/containers | 
                Assorted concrete container types | 
            
        
            
                | dev-haskell/contravariant | 
                Haskell 98 contravariant functors | 
            
        
            
                | dev-haskell/convertible | 
                Typeclasses and instances for converting between types | 
            
        
            
                | dev-haskell/cookie | 
                HTTP cookie parsing and rendering | 
            
        
            
                | dev-haskell/cpphs | 
                A liberalised re-implementation of cpp, the C pre-processor | 
            
        
            
                | dev-haskell/cprng-aes | 
                Pseudo random number generator | 
            
        
            
                | dev-haskell/cpu | 
                Cpu information and properties helpers | 
            
        
            
                | dev-haskell/criterion | 
                Robust, reliable performance measurement and analysis | 
            
        
            
                | dev-haskell/crypto-api | 
                A generic interface for cryptographic operations | 
            
        
            
                | dev-haskell/crypto-cipher-tests | 
                Generic cryptography cipher tests | 
            
        
            
                | dev-haskell/crypto-cipher-types | 
                Generic cryptography cipher types | 
            
        
            
                | dev-haskell/crypto-conduit | 
                Conduit interface for cryptographic operations (from crypto-api) | 
            
        
            
                | dev-haskell/crypto-numbers | 
                Generic cryptography public keys algorithm types | 
            
        
            
                | dev-haskell/crypto-pubkey | 
                Public Key cryptography | 
            
        
            
                | dev-haskell/crypto-pubkey-types | 
                Generic cryptography public keys algorithm types | 
            
        
            
                | dev-haskell/crypto-random | 
                Simple cryptographic random related types | 
            
        
            
                | dev-haskell/crypto-random-api | 
                Simple random generators API for cryptography related code | 
            
        
            
                | dev-haskell/cryptocipher | 
                Symmetrical Block, Stream and PubKey Ciphers | 
            
        
            
                | dev-haskell/cryptohash | 
                Collection of crypto hashes, fast, pure and practical | 
            
        
            
                | dev-haskell/cryptohash-conduit | 
                Support all the cryptohash package using conduits from the conduit package | 
            
        
            
                | dev-haskell/cryptohash-cryptoapi | 
                Crypto-api interfaces for cryptohash | 
            
        
            
                | dev-haskell/cryptohash-sha256 | 
                Fast, pure and practical SHA-256 implementation | 
            
        
            
                | dev-haskell/cryptonite | 
                Cryptography Primitives sink | 
            
        
            
                | dev-haskell/css-text | 
                CSS parser and renderer | 
            
        
            
                | dev-haskell/curl | 
                Haskell binding to libcurl | 
            
        
            
                | dev-haskell/data-default | 
                A class for types with a default value | 
            
        
            
                | dev-haskell/data-default-class | 
                The data-default-class package | 
            
        
            
                | dev-haskell/data-default-instances-base | 
                Default instances for types in base | 
            
        
            
                | dev-haskell/data-default-instances-containers | 
                Default instances for types in containers | 
            
        
            
                | dev-haskell/data-default-instances-dlist | 
                Default instances for types in dlist | 
            
        
            
                | dev-haskell/data-default-instances-old-locale | 
                Default instances for types in old-locale | 
            
        
            
                | dev-haskell/data-ordlist | 
                This module provides set and multiset operations on ordered lists | 
            
        
            
                | dev-haskell/dataenc | 
                Data encoding library | 
            
        
            
                | dev-haskell/date-cache | 
                Date cacher | 
            
        
            
                | dev-haskell/dbus | 
                A client library for the D-Bus IPC system | 
            
        
            
                | dev-haskell/deepseq | 
                Fully evaluate data structures | 
            
        
            
                | dev-haskell/deepseq-generics | 
                Fully evaluate data structures | 
            
        
            
                | dev-haskell/deriving-compat | 
                Backports of GHC deriving extensions | 
            
        
            
                | dev-haskell/digest | 
                Haskell library providing various cryptographic hashes for ByteStrings | 
            
        
            
                | dev-haskell/directory | 
                Library for directory handling | 
            
        
            
                | dev-haskell/directory-tree | 
                Directory-like tree | 
            
        
            
                | dev-haskell/disk-free-space | 
                Retrieve information about disk space usage | 
            
        
            
                | dev-haskell/distributive | 
                Haskell 98 Distributive functors -- Dual to Traversable | 
            
        
            
                | dev-haskell/djinn-ghc | 
                Generate Haskell code from a type. Bridge from Djinn to GHC API | 
            
        
            
                | dev-haskell/djinn-lib | 
                Generate Haskell code from a type. Library extracted from djinn package | 
            
        
            
                | dev-haskell/dlist | 
                List-like type supporting O(1) append | 
            
        
            
                | dev-haskell/dlist-instances | 
                See the dlist packages | 
            
        
            
                | dev-haskell/dns | 
                DNS library for clients and servers | 
            
        
            
                | dev-haskell/doctemplates | 
                This is the templating system used by pandoc | 
            
        
            
                | dev-haskell/doctest | 
                A program that checks examples in source code comments | 
            
        
            
                | dev-haskell/double-conversion | 
                Fast conversion between double precision floating point and text | 
            
        
            
                | dev-haskell/easy-file | 
                Cross-platform File handling for Unix/Mac/Windows | 
            
        
            
                | dev-haskell/ed25519 | 
                Ed25519 cryptographic signatures | 
            
        
            
                | dev-haskell/edit-distance | 
                Levenshtein and restricted Damerau-Levenshtein edit distances | 
            
        
            
                | dev-haskell/either | 
                An either monad transformer | 
            
        
            
                | dev-haskell/email-validate | 
                Validating an email address string against RFC 5322 | 
            
        
            
                | dev-haskell/enclosed-exceptions | 
                Catching all exceptions raised within an enclosed computation | 
            
        
            
                | dev-haskell/encoding | 
                The encoding package | 
            
        
            
                | dev-haskell/entropy | 
                A platform independent entropy source | 
            
        
            
                | dev-haskell/enumerator | 
                Efficient, predictable, and safe alternative to lazy I/O | 
            
        
            
                | dev-haskell/erf | 
                A type class for the error function, erf, and related functions | 
            
        
            
                | dev-haskell/errorcall-eq-instance | 
                Prior to base-4.7.0.0 there was no Eq instance for ErrorCall | 
            
        
            
                | dev-haskell/errors | 
                The one-stop shop for all your error-handling needs | 
            
        
            
                | dev-haskell/esqueleto | 
                Type-safe EDSL for SQL queries on persistent backends | 
            
        
            
                | dev-haskell/exceptions | 
                Extensible optionally-pure exceptions | 
            
        
            
                | dev-haskell/extensible-exceptions | 
                Extensible exceptions | 
            
        
            
                | dev-haskell/extra | 
                Extra functions I use | 
            
        
            
                | dev-haskell/fail | 
                This package contains the Control.Monad.Fail module providing the MonadFail class that became available in base-4.9.0.0 for older base package versions | 
            
        
            
                | dev-haskell/failure | 
                A simple type class for success/failure computations | 
            
        
            
                | dev-haskell/fast-logger | 
                Fast logging system | 
            
        
            
                | dev-haskell/fclabels | 
                First class composable record labels for Haskell | 
            
        
            
                | dev-haskell/fdo-notify | 
                Desktop Notifications client | 
            
        
            
                | dev-haskell/feed | 
                Interfacing with RSS (v 0.9x, 2.x, 1.0) + Atom feeds | 
            
        
            
                | dev-haskell/file-embed | 
                Use Template Haskell to embed file contents directly | 
            
        
            
                | dev-haskell/file-location | 
                Common debugging/error/exception functions that give file location information | 
            
        
            
                | dev-haskell/filemanip | 
                Expressive file and directory manipulation for Haskell | 
            
        
            
                | dev-haskell/filepath | 
                Library for manipulating FilePaths in a cross platform way | 
            
        
            
                | dev-haskell/fixed | 
                Signed 15.16 precision fixed point arithmetic | 
            
        
            
                | dev-haskell/foldl | 
                This library provides strict left folds that stream in constant memory | 
            
        
            
                | dev-haskell/free | 
                Free monads are useful for many tree-like structures and domain specific languages | 
            
        
            
                | dev-haskell/fsnotify | 
                file creation, modification, and deletion notification | 
            
        
            
                | dev-haskell/generic-deriving | 
                Generic programming library for generalised deriving | 
            
        
            
                | dev-haskell/ghc-boot | 
                Shared functionality between GHC and its boot libraries | 
            
        
            
                | dev-haskell/ghc-boot-th | 
                Shared functionality between GHC and the template-haskell library | 
            
        
            
                | dev-haskell/ghc-mod | 
                Happy Haskell Programming | 
            
        
            
                | dev-haskell/ghc-paths | 
                Knowledge of GHC's installation directories | 
            
        
            
                | dev-haskell/ghc-syb-utils | 
                Scrap Your Boilerplate utilities for the GHC API | 
            
        
            
                | dev-haskell/gloss | 
                Painless 2D vector graphics, animations and simulations | 
            
        
            
                | dev-haskell/gloss-rendering | 
                Gloss picture data types and rendering functions | 
            
        
            
                | dev-haskell/glpk-hs | 
                GLPK bindings | 
            
        
            
                | dev-haskell/gnutls | 
                The gnutls package | 
            
        
            
                | dev-haskell/hS3 | 
                Interface to Amazon's Simple Storage Service (S3) | 
            
        
            
                | dev-haskell/hackage-security | 
                Hackage security library | 
            
        
            
                | dev-haskell/haddock | 
                A documentation-generation tool for Haskell libraries | 
            
        
            
                | dev-haskell/haddock-api | 
                A documentation-generation tool for Haskell libraries | 
            
        
            
                | dev-haskell/haddock-library | 
                A documentation-generation tool for Haskell libraries | 
            
        
            
                | dev-haskell/hakyll | 
                Simple static site generator library | 
            
        
            
                | dev-haskell/half | 
                Half-precision floating-point | 
            
        
            
                | dev-haskell/hamlet | 
                Type-safe generating HTML code (deprecated) | 
            
        
            
                | dev-haskell/happy | 
                A yacc-like parser generator for Haskell | 
            
        
            
                | dev-haskell/hashable | 
                Class for types that can be converted to a hash value | 
            
        
            
                | dev-haskell/haskeline | 
                A command-line interface for user input, written in Haskell | 
            
        
            
                | dev-haskell/haskell-lexer | 
                A fully compliant Haskell 98 lexer | 
            
        
            
                | dev-haskell/haskell-src | 
                Manipulating Haskell source code | 
            
        
            
                | dev-haskell/haskell-src-exts | 
                Manipulating Haskell source: abstract syntax, lexer, parser, and pretty-printer | 
            
        
            
                | dev-haskell/haskell-src-meta | 
                The translation from haskell-src-exts abstract syntax to template-haskell abstract syntax isn't 100% complete yet | 
            
        
            
                | dev-haskell/hastache | 
                Haskell implementation of Mustache templates | 
            
        
            
                | dev-haskell/hexpat | 
                Haskell XML library using Expat | 
            
        
            
                | dev-haskell/highlighting-kate | 
                A syntax highlighting library with support for nearly one hundred languages | 
            
        
            
                | dev-haskell/hinotify | 
                Haskell binding to inotify | 
            
        
            
                | dev-haskell/hint | 
                Interpreter monad | 
            
        
            
                | dev-haskell/hjsmin | 
                Reduces size of javascript files | 
            
        
            
                | dev-haskell/hlibev | 
                FFI interface to libev | 
            
        
            
                | dev-haskell/hlint | 
                Gives suggestions on how to improve your haskell source code | 
            
        
            
                | dev-haskell/hostname | 
                Determines the hostname | 
            
        
            
                | dev-haskell/hourglass | 
                Simple time library focusing on simple but powerful and performant API | 
            
        
            
                | dev-haskell/hpc | 
                Code Coverage Library for Haskell | 
            
        
            
                | dev-haskell/hs-bibutils | 
                Haskell bindings to bibutils, the bibliography conversion utilities | 
            
        
            
                | dev-haskell/hscolour | 
                Colourise Haskell code | 
            
        
            
                | dev-haskell/hsemail | 
                Internet Message Parsers | 
            
        
            
                | dev-haskell/hslogger | 
                Versatile logging framework | 
            
        
            
                | dev-haskell/hslua | 
                A Lua language interpreter embedding in Haskell | 
            
        
            
                | dev-haskell/hspec | 
                Behavior Driven Development for Haskell | 
            
        
            
                | dev-haskell/hspec-core | 
                A Testing Framework for Haskell | 
            
        
            
                | dev-haskell/hspec-discover | 
                Automatically discover and run Hspec tests | 
            
        
            
                | dev-haskell/hspec-expectations | 
                Catchy combinators for HUnit | 
            
        
            
                | dev-haskell/hspec-meta | 
                A version of Hspec which is used to test Hspec itself | 
            
        
            
                | dev-haskell/hspec-wai | 
                Experimental Hspec support for testing WAI applications | 
            
        
            
                | dev-haskell/html | 
                HTML Haskell combinator library | 
            
        
            
                | dev-haskell/html-conduit | 
                A library for parsing HTML documents using xml-conduit datatypes | 
            
        
            
                | dev-haskell/http-api-data | 
                This package defines typeclasses used for converting Haskell data types to and from HTTP API data | 
            
        
            
                | dev-haskell/http-client | 
                An HTTP client engine, intended as a base layer for more user-friendly packages | 
            
        
            
                | dev-haskell/http-client-conduit | 
                An HTTP client engine | 
            
        
            
                | dev-haskell/http-client-tls | 
                An HTTP client engine | 
            
        
            
                | dev-haskell/http-conduit | 
                HTTP client package with conduit interface and HTTPS support | 
            
        
            
                | dev-haskell/http-date | 
                HTTP Date parser/formatter | 
            
        
            
                | dev-haskell/http-reverse-proxy | 
                Reverse proxy HTTP requests, either over raw sockets or with WAI | 
            
        
            
                | dev-haskell/http-types | 
                Generic HTTP types for Haskell | 
            
        
            
                | dev-haskell/httpd-shed | 
                This web server promotes a Request to IO Response function into a local web server | 
            
        
            
                | dev-haskell/hxt | 
                Collection of tools for processing XML with Haskell | 
            
        
            
                | dev-haskell/hxt-charproperties | 
                Character properties and classes for XML and Unicode | 
            
        
            
                | dev-haskell/hxt-regex-xmlschema | 
                Regular expression library for W3C XML Schema regular expressions | 
            
        
            
                | dev-haskell/hxt-unicode | 
                Unicode en-/decoding functions for utf8, iso-latin-* and other encodings | 
            
        
            
                | dev-haskell/idna | 
                Internationalized Domain Names in Applications (RFC 3490 | 
            
        
            
                | dev-haskell/ieee754 | 
                Utilities for dealing with IEEE floating point numbers | 
            
        
            
                | dev-haskell/integer-gmp | 
                Integer-gmp | 
            
        
            
                | dev-haskell/integer-simple | 
                Simple integer library | 
            
        
            
                | dev-haskell/io-choice | 
                Choice for IO and lifted IO | 
            
        
            
                | dev-haskell/iproute | 
                IP Routing Table | 
            
        
            
                | dev-haskell/json | 
                Parser and pretty printer for converting between Haskell values and JSON | 
            
        
            
                | dev-haskell/json-types | 
                Basic types for representing JSON | 
            
        
            
                | dev-haskell/kan-extensions | 
                Kan extensions, Kan lifts, various forms of the Yoneda lemma, and (co)density (co)monads | 
            
        
            
                | dev-haskell/keys | 
                Keyed functors and containers | 
            
        
            
                | dev-haskell/language-c | 
                Analysis and generation of C code | 
            
        
            
                | dev-haskell/language-haskell-extract | 
                Automatically extract functions from the local code | 
            
        
            
                | dev-haskell/language-javascript | 
                Parses Javascript into an Abstract Syntax Tree (AST) | 
            
        
            
                | dev-haskell/largeword | 
                Word128, Word192 and Word256 | 
            
        
            
                | dev-haskell/lens | 
                Lenses, Folds and Traversals | 
            
        
            
                | dev-haskell/libmpd | 
                A client library for MPD, the Music Player Daemon | 
            
        
            
                | dev-haskell/libxml | 
                Binding to libxml2 | 
            
        
            
                | dev-haskell/libxml-sax | 
                Bindings for the libXML2 SAX interface | 
            
        
            
                | dev-haskell/lifted-async | 
                Run lifted IO operations asynchronously and wait for their results | 
            
        
            
                | dev-haskell/lifted-base | 
                Lifted IO operations from the base library | 
            
        
            
                | dev-haskell/logict | 
                A backtracking logic-programming monad | 
            
        
            
                | dev-haskell/lrucache | 
                A simple, pure LRU cache, implemented in terms of Data.Map | 
            
        
            
                | dev-haskell/lushtags | 
                Create ctags compatible tags files for Haskell programs | 
            
        
            
                | dev-haskell/maccatcher | 
                 | 
            
        
            
                | dev-haskell/magic | 
                Interface to C file/magic library | 
            
        
            
                | dev-haskell/math-functions | 
                Special functions and Chebyshev polynomials | 
            
        
            
                | dev-haskell/memory | 
                memory and related abstraction stuff | 
            
        
            
                | dev-haskell/mersenne-random-pure64 | 
                Generate high quality pseudorandom numbers purely using a Mersenne Twister | 
            
        
            
                | dev-haskell/mime-mail | 
                Compose MIME email messages | 
            
        
            
                | dev-haskell/mime-types | 
                Basic mime-type handling types and functions | 
            
        
            
                | dev-haskell/mmap | 
                Memory mapped files for POSIX and Windows | 
            
        
            
                | dev-haskell/mmorph | 
                Monad morphism utilities | 
            
        
            
                | dev-haskell/monad-control | 
                Lift control operations through monad transformers | 
            
        
            
                | dev-haskell/monad-journal | 
                Pure logger typeclass and monad transformer | 
            
        
            
                | dev-haskell/monad-logger | 
                A class of monads which can log messages | 
            
        
            
                | dev-haskell/monad-loops | 
                Monadic loops | 
            
        
            
                | dev-haskell/monad-par | 
                Library for parallel programming based on a monad | 
            
        
            
                | dev-haskell/monad-par-extras | 
                The Par monad offers a parallel programming API based on dataflow programming | 
            
        
            
                | dev-haskell/monad-peel | 
                MonadPeelIO, a subset of MonadIO | 
            
        
            
                | dev-haskell/monads-tf | 
                Monad classes using type families | 
            
        
            
                | dev-haskell/mono-traversable | 
                Type classes for mapping, folding, and traversing monomorphic containers | 
            
        
            
                | dev-haskell/mountpoints | 
                Lists currently mounted filesystems | 
            
        
            
                | dev-haskell/mtl | 
                Monad Transformer Library | 
            
        
            
                | dev-haskell/mtl-compat | 
                Backported Control.Monad.Except module from mtl | 
            
        
            
                | dev-haskell/murmur-hash | 
                MurmurHash2: Good, fast, general-purpose, non-cryptographic hashing function | 
            
        
            
                | dev-haskell/mutable-containers | 
                Mutable containers | 
            
        
            
                | dev-haskell/mwc-random | 
                Generates high quality random numbers | 
            
        
            
                | dev-haskell/nanospec | 
                A lightweight implementation of a subset of Hspec's API | 
            
        
            
                | dev-haskell/nats | 
                Haskell 98 natural numbers | 
            
        
            
                | dev-haskell/network | 
                Networking-related facilities | 
            
        
            
                | dev-haskell/network-conduit | 
                Stream socket data using conduits. (deprecated) | 
            
        
            
                | dev-haskell/network-info | 
                Access the local computer's basic network configuration | 
            
        
            
                | dev-haskell/network-multicast | 
                Simple multicast library | 
            
        
            
                | dev-haskell/network-uri | 
                This package provides an URI manipulation inteface | 
            
        
            
                | dev-haskell/newtype | 
                A typeclass and set of functions for working with newtypes | 
            
        
            
                | dev-haskell/nonce | 
                Generate cryptographic nonces | 
            
        
            
                | dev-haskell/old-locale | 
                Locale library | 
            
        
            
                | dev-haskell/old-time | 
                Time library | 
            
        
            
                | dev-haskell/options | 
                A powerful and easy-to-use command-line option parser | 
            
        
            
                | dev-haskell/optparse-applicative | 
                Utilities and combinators for parsing command line options | 
            
        
            
                | dev-haskell/pandoc-citeproc | 
                functions for using the citeproc system with pandoc | 
            
        
            
                | dev-haskell/pandoc-types | 
                Definitions for the Pandoc data structure | 
            
        
            
                | dev-haskell/parallel | 
                Parallel programming library | 
            
        
            
                | dev-haskell/parsec | 
                Monadic parser combinators | 
            
        
            
                | dev-haskell/path-pieces | 
                Components of paths | 
            
        
            
                | dev-haskell/patience | 
                Patience diff and longest increasing subsequence | 
            
        
            
                | dev-haskell/pcre-light | 
                A small, efficient and portable regex library for Perl 5 compatible regular expressions | 
            
        
            
                | dev-haskell/pem | 
                Privacy Enhanced Mail (PEM) format reader and writer | 
            
        
            
                | dev-haskell/persistent | 
                Type-safe, non-relational, multi-backend persistence | 
            
        
            
                | dev-haskell/persistent-sqlite | 
                Backend for the persistent library using sqlite3 | 
            
        
            
                | dev-haskell/persistent-template | 
                Type-safe, non-relational, multi-backend persistence | 
            
        
            
                | dev-haskell/pipes | 
                Pipes stream library | 
            
        
            
                | dev-haskell/pointed | 
                Pointed and copointed data | 
            
        
            
                | dev-haskell/polyparse | 
                Collection of parser combinator libraries | 
            
        
            
                | dev-haskell/prelude-extras | 
                higher order versions of Prelude classes | 
            
        
            
                | dev-haskell/pretty | 
                Pretty-printing library | 
            
        
            
                | dev-haskell/pretty-show | 
                Tools for working with derived Show instances | 
            
        
            
                | dev-haskell/primes | 
                Efficient lazy wheel sieve for prime generation | 
            
        
            
                | dev-haskell/primitive | 
                Wrappers for primitive array operations from GHC.Prim | 
            
        
            
                | dev-haskell/process | 
                Process libraries | 
            
        
            
                | dev-haskell/profunctors | 
                Profunctors | 
            
        
            
                | dev-haskell/project-template | 
                Specify Haskell project templates and generate files | 
            
        
            
                | dev-haskell/publicsuffixlist | 
                Is a given string a domain suffix? | 
            
        
            
                | dev-haskell/punycode | 
                Encode unicode strings to ascii forms according to RFC 3492 | 
            
        
            
                | dev-haskell/pureMD5 | 
                A Haskell-only implementation of the MD5 digest (hash) algorithm | 
            
        
            
                | dev-haskell/pwstore-fast | 
                Secure password storage | 
            
        
            
                | dev-haskell/quickcheck-assertions | 
                Library with convenient assertions for QuickCheck properties like in HUnit | 
            
        
            
                | dev-haskell/quickcheck-instances | 
                Common quickcheck instances | 
            
        
            
                | dev-haskell/quickcheck-io | 
                The quickcheck-io package | 
            
        
            
                | dev-haskell/quickcheck-unicode | 
                Generator and shrink functions for testing Unicode-related software | 
            
        
            
                | dev-haskell/random | 
                Random number library | 
            
        
            
                | dev-haskell/random-shuffle | 
                Random shuffle implementation | 
            
        
            
                | dev-haskell/ranges | 
                Ranges and various functions on them | 
            
        
            
                | dev-haskell/refact | 
                Specify refactorings to perform with apply-refact | 
            
        
            
                | dev-haskell/reflection | 
                The reflection package | 
            
        
            
                | dev-haskell/regex-applicative | 
                regex-applicative is a Haskell library for parsing using regular expressions | 
            
        
            
                | dev-haskell/regex-base | 
                Interface API for regex-posix, pcre, parsec, tdfa, dfa | 
            
        
            
                | dev-haskell/regex-compat | 
                One module layer over regex-posix to replace Text.Regex | 
            
        
            
                | dev-haskell/regex-compat-tdfa | 
                One module layer over regex-tdfa to replace Text.Regex | 
            
        
            
                | dev-haskell/regex-pcre | 
                PCRE backend to accompany regex-base | 
            
        
            
                | dev-haskell/regex-pcre-builtin | 
                The PCRE backend to accompany regex-base | 
            
        
            
                | dev-haskell/regex-posix | 
                The posix regex backend for regex-base | 
            
        
            
                | dev-haskell/regex-tdfa | 
                A new all Haskell tagged DFA regex engine, inspired by libtre | 
            
        
            
                | dev-haskell/regex-tdfa-rc | 
                A new all Haskell tagged DFA regex engine, inspired by libtre | 
            
        
            
                | dev-haskell/resource-pool | 
                High-performance striped resource pooling implementation | 
            
        
            
                | dev-haskell/resourcet | 
                Deterministic allocation and freeing of scarce resources | 
            
        
            
                | dev-haskell/rfc5051 | 
                This library implements i;unicode-casemap, | 
            
        
            
                | dev-haskell/safe | 
                Library for safe (pattern match free) functions | 
            
        
            
                | dev-haskell/sandi | 
                Data encoding library | 
            
        
            
                | dev-haskell/scientific | 
                The scientific package | 
            
        
            
                | dev-haskell/scotty | 
                A Haskell web framework inspired by Ruby's Sinatra, using WAI and Warp | 
            
        
            
                | dev-haskell/securemem | 
                SecureMem is similar to ByteString | 
            
        
            
                | dev-haskell/semigroupoids | 
                Haskell 98 semigroupoids: Category sans id | 
            
        
            
                | dev-haskell/semigroups | 
                Haskell 98 semigroups | 
            
        
            
                | dev-haskell/sendfile | 
                Zero-copy sendfile functionality in a portable way | 
            
        
            
                | dev-haskell/setenv | 
                A cross-platform library for setting environment variables | 
            
        
            
                | dev-haskell/setlocale | 
                Haskell bindings to setlocale | 
            
        
            
                | dev-haskell/shakespeare | 
                Family of type-safe, efficient templates | 
            
        
            
                | dev-haskell/shakespeare-css | 
                Stick your haskell variables into css at compile time. (deprecated) | 
            
        
            
                | dev-haskell/shakespeare-i18n | 
                Type-based approach to internationalization (deprecated) | 
            
        
            
                | dev-haskell/shakespeare-js | 
                JavaScript template language (deprecated) | 
            
        
            
                | dev-haskell/shakespeare-text | 
                Stick haskell variables into haskell strings | 
            
        
            
                | dev-haskell/shelly | 
                shell-like (systems) programming in Haskell | 
            
        
            
                | dev-haskell/silently | 
                Prevent or capture writing to stdout and other handles | 
            
        
            
                | dev-haskell/simple-reflect | 
                This package allows simple reflection of expressions containing variables | 
            
        
            
                | dev-haskell/simple-sendfile | 
                Cross platform library for the sendfile system call | 
            
        
            
                | dev-haskell/skein | 
                Family of cryptographic hash functions | 
            
        
            
                | dev-haskell/skylighting | 
                A syntax highlighting library with support for nearly one hundred languages | 
            
        
            
                | dev-haskell/smallcheck | 
                A property-based testing library | 
            
        
            
                | dev-haskell/snap-core | 
                Simple and fast web development framework and server | 
            
        
            
                | dev-haskell/snap-server | 
                High performance, epoll-enabled, iteratee-based web server library | 
            
        
            
                | dev-haskell/socks | 
                Socks proxy (version 5) implementation | 
            
        
            
                | dev-haskell/split | 
                Combinator library and utility functions for splitting lists | 
            
        
            
                | dev-haskell/statistics | 
                Provides a number of common functions and types useful in statistics | 
            
        
            
                | dev-haskell/stm | 
                Software Transactional Memory | 
            
        
            
                | dev-haskell/stm-chans | 
                Additional types of channels for STM | 
            
        
            
                | dev-haskell/streaming-commons | 
                Provides low-dependency functionality | 
            
        
            
                | dev-haskell/strict | 
                Strict data types and String IO | 
            
        
            
                | dev-haskell/string-qq | 
                QuasiQuoter for non-interpolated strings, texts and bytestrings | 
            
        
            
                | dev-haskell/stringbuilder | 
                A monadic builder for multi-line string literals | 
            
        
            
                | dev-haskell/stringprep | 
                Implements the StringPrep algorithm | 
            
        
            
                | dev-haskell/stringsearch | 
                A library for fast searching, splitting and replacing of ByteStrings | 
            
        
            
                | dev-haskell/syb | 
                Scrap Your Boilerplate | 
            
        
            
                | dev-haskell/system-fileio | 
                A library providing consistent filesystem interaction across GHC versions | 
            
        
            
                | dev-haskell/system-filepath | 
                High-level, byte-based file and directory path manipulations | 
            
        
            
                | dev-haskell/tagged | 
                Newtype wrappers for phantom types to avoid unsafely passing dummy arguments | 
            
        
            
                | dev-haskell/tagsoup | 
                High-level file download based on URLs | 
            
        
            
                | dev-haskell/tagstream-conduit | 
                Streamlined html tag parser | 
            
        
            
                | dev-haskell/tar | 
                Working with tar files in Haskell | 
            
        
            
                | dev-haskell/tasty | 
                Modern and extensible testing framework | 
            
        
            
                | dev-haskell/tasty-golden | 
                Golden tests support for tasty | 
            
        
            
                | dev-haskell/tasty-hunit | 
                HUnit support for the Tasty test framework | 
            
        
            
                | dev-haskell/tasty-kat | 
                Tests running from simple KATs file | 
            
        
            
                | dev-haskell/tasty-quickcheck | 
                QuickCheck support for the Tasty test framework | 
            
        
            
                | dev-haskell/tasty-smallcheck | 
                SmallCheck support for the Tasty test framework | 
            
        
            
                | dev-haskell/tasty-th | 
                Generate HUnit- and Quickcheck-code using Template Haskell | 
            
        
            
                | dev-haskell/template-haskell | 
                Facilities for manipulating Haskell source code using Template Haskell | 
            
        
            
                | dev-haskell/temporary | 
                Portable temporary file and directory support for Windows and Unix, based on code from Cabal | 
            
        
            
                | dev-haskell/temporary-rc | 
                Portable temporary file and directory support for Windows and Unix, based on code from Cabal | 
            
        
            
                | dev-haskell/terminal-size | 
                Get terminal window height and width | 
            
        
            
                | dev-haskell/terminfo | 
                Haskell bindings to the terminfo library | 
            
        
            
                | dev-haskell/test-framework | 
                Framework for running and organising tests, with HUnit and QuickCheck support | 
            
        
            
                | dev-haskell/test-framework-hunit | 
                HUnit support for the test-framework package | 
            
        
            
                | dev-haskell/test-framework-quickcheck2 | 
                QuickCheck2 support for the test-framework package | 
            
        
            
                | dev-haskell/test-framework-smallcheck | 
                Support for SmallCheck tests in test-framework | 
            
        
            
                | dev-haskell/test-framework-th | 
                Automagically generate the HUnit- and Quickcheck-bulk-code using Template Haskell | 
            
        
            
                | dev-haskell/test-framework-th-prime | 
                Template Haskell for test framework | 
            
        
            
                | dev-haskell/test-shouldbe | 
                Catchy combinators for HUnit | 
            
        
            
                | dev-haskell/texmath | 
                Convert LaTeX math formulas to presentation MathML | 
            
        
            
                | dev-haskell/text | 
                Efficiently packed, immutable Unicode text type | 
            
        
            
                | dev-haskell/text-icu | 
                Bindings to the ICU library | 
            
        
            
                | dev-haskell/text-show | 
                Efficient conversion of values into Text | 
            
        
            
                | dev-haskell/text-stream-decode | 
                Deprecated in favor of streaming-commons | 
            
        
            
                | dev-haskell/tf-random | 
                high-quality splittable pseudorandom number generator | 
            
        
            
                | dev-haskell/th-expand-syns | 
                Expands type synonyms in Template Haskell ASTs | 
            
        
            
                | dev-haskell/th-lift | 
                Derive Template Haskell's Lift class for datatypes | 
            
        
            
                | dev-haskell/th-orphans | 
                Orphan instances for TH datatypes | 
            
        
            
                | dev-haskell/th-reify-many | 
                th-reify-many provides functions for recursively reifying top level declarations | 
            
        
            
                | dev-haskell/time | 
                A time library | 
            
        
            
                | dev-haskell/time-locale-compat | 
                This package contains wrapped name module for TimeLocale | 
            
        
            
                | dev-haskell/tls | 
                TLS/SSL protocol native implementation (Server and Client) | 
            
        
            
                | dev-haskell/torrent | 
                BitTorrent file parser and generater | 
            
        
            
                | dev-haskell/transformers | 
                Haskell 98 part of a monad transformer library | 
            
        
            
                | dev-haskell/transformers-base | 
                Lift computations from the bottom of a transformer stack | 
            
        
            
                | dev-haskell/transformers-compat | 
                Lenses, Folds and Traversals | 
            
        
            
                | dev-haskell/unbounded-delays | 
                Unbounded thread delays and timeouts | 
            
        
            
                | dev-haskell/unexceptionalio | 
                When you've caught all the exceptions that can be handled safely, this is what you're left with | 
            
        
            
                | dev-haskell/unicode-properties | 
                Unicode 3.2.0 character properties | 
            
        
            
                | dev-haskell/uniplate | 
                Library for writing simple and concise generic operations | 
            
        
            
                | dev-haskell/unix | 
                POSIX functionality | 
            
        
            
                | dev-haskell/unix-compat | 
                Portable implementations of parts of the unix package | 
            
        
            
                | dev-haskell/unix-time | 
                Unix time parser/formatter and utilities | 
            
        
            
                | dev-haskell/unordered-containers | 
                Efficient hashing-based container types | 
            
        
            
                | dev-haskell/utf8-light | 
                Lightweight UTF8 handling | 
            
        
            
                | dev-haskell/utf8-string | 
                Support for reading and writing UTF8 Strings | 
            
        
            
                | dev-haskell/uuid | 
                For creating, comparing, parsing and printing Universally Unique Identifiers | 
            
        
            
                | dev-haskell/uuid-types | 
                This library contains type definitions for Universally Unique Identifiers and basic conversion functions | 
            
        
            
                | dev-haskell/vault | 
                Typed, persistent store for values of arbitrary types | 
            
        
            
                | dev-haskell/vector | 
                Implementation of Int-indexed arrays (both mutable and immutable) | 
            
        
            
                | dev-haskell/vector-algorithms | 
                Efficient algorithms for vector arrays | 
            
        
            
                | dev-haskell/vector-binary-instances | 
                Instances of Data.Binary and Data.Serialize for vector | 
            
        
            
                | dev-haskell/vector-instances | 
                The vector-instances package | 
            
        
            
                | dev-haskell/vector-space | 
                Vector spaces, affine spaces, linear maps, and derivatives | 
            
        
            
                | dev-haskell/vector-th-unbox | 
                Deriver for Data.Vector.Unboxed using Template Haskell | 
            
        
            
                | dev-haskell/void | 
                Haskell 98 logically uninhabited data type | 
            
        
            
                | dev-haskell/vty | 
                Terminal GUI library in the niche of ncurses | 
            
        
            
                | dev-haskell/wai | 
                Protocol for communication between web aplications and web servers | 
            
        
            
                | dev-haskell/wai-app-static | 
                WAI application for static serving | 
            
        
            
                | dev-haskell/wai-conduit | 
                conduit wrappers for WAI | 
            
        
            
                | dev-haskell/wai-extra | 
                Provides some basic WAI handlers and middleware | 
            
        
            
                | dev-haskell/wai-handler-fastcgi | 
                Wai handler to fastcgi | 
            
        
            
                | dev-haskell/wai-logger | 
                Logging system for WAI | 
            
        
            
                | dev-haskell/wai-test | 
                Unit test framework for WAI applications (deprecated) | 
            
        
            
                | dev-haskell/warp | 
                A fast, light-weight web server for WAI applications | 
            
        
            
                | dev-haskell/warp-tls | 
                HTTP over SSL/TLS support for Warp via the TLS package | 
            
        
            
                | dev-haskell/web-routes | 
                Types and functions that ensure that URLs generated by an application are valid | 
            
        
            
                | dev-haskell/with-location | 
                The with-location package | 
            
        
            
                | dev-haskell/word8 | 
                 | 
            
        
            
                | dev-haskell/x509 | 
                X509 reader and writer | 
            
        
            
                | dev-haskell/x509-store | 
                X.509 collection accessing and storing methods for certificate, crl, exception list | 
            
        
            
                | dev-haskell/x509-system | 
                System X.509 handling | 
            
        
            
                | dev-haskell/x509-validation | 
                X.509 Certificate and CRL validation | 
            
        
            
                | dev-haskell/xdg-basedir | 
                Implementation of the XDG Base Directory specification | 
            
        
            
                | dev-haskell/xhtml | 
                An XHTML combinator library | 
            
        
            
                | dev-haskell/xml | 
                A simple XML library | 
            
        
            
                | dev-haskell/xml-conduit | 
                Pure-Haskell utilities for dealing with XML with the conduit package | 
            
        
            
                | dev-haskell/xml-hamlet | 
                Hamlet-style quasiquoter for XML content | 
            
        
            
                | dev-haskell/xml-types | 
                Basic types for representing XML | 
            
        
            
                | dev-haskell/xml2html | 
                Blaze-html instances for xml-conduit types | 
            
        
            
                | dev-haskell/xss-sanitize | 
                Sanitize untrusted HTML to prevent XSS attacks | 
            
        
            
                | dev-haskell/yaml | 
                Low-level binding to the libyaml C library | 
            
        
            
                | dev-haskell/yesod | 
                RESTful web framework with strong compile-time guarantees of correctness | 
            
        
            
                | dev-haskell/yesod-auth | 
                Authentication for Yesod | 
            
        
            
                | dev-haskell/yesod-core | 
                Creation of type-safe, RESTful web applications | 
            
        
            
                | dev-haskell/yesod-default | 
                Default config and main functions for your yesod application | 
            
        
            
                | dev-haskell/yesod-form | 
                Form handling support for Yesod Web Framework | 
            
        
            
                | dev-haskell/yesod-json | 
                Generate content for Yesod using the aeson package. (deprecated) | 
            
        
            
                | dev-haskell/yesod-persistent | 
                Some helpers for using Persistent from Yesod | 
            
        
            
                | dev-haskell/yesod-static | 
                Static file serving subsite for Yesod Web Framework | 
            
        
            
                | dev-haskell/yesod-test | 
                Integration testing for WAI/Yesod Applications | 
            
        
            
                | dev-haskell/zip-archive | 
                Haskell library for creating and modifying zip archives | 
            
        
            
                | dev-haskell/zlib | 
                Compression and decompression in the gzip and zlib formats | 
            
        
            
                | dev-haskell/zlib-bindings | 
                Low-level bindings to the zlib package (deprecated) | 
            
        
            
                | dev-haskell/zlib-conduit | 
                Streaming compression/decompression via conduits | 
            
        
            
                | dev-haskell/zlib-enum | 
                Enumerator interface for zlib compression | 
            
        
            
                | dev-lang/ghc | 
                The Glorious Glasgow Haskell Compilation System | 
            
        
            
                | dev-scm/darcs | 
                Distributed, interactive, smart revision control system | 
            
        
            
                | dev-scm/git-annex | 
                git-annex allows managing files with git, without checking the file contents into git | 
            
        
            
                | dev-util/shellcheck | 
                ShellCheck, a static analysis tool for shell scripts | 
            
        
            
                | x11-misc/xmobar | 
                Minimalistic text based status bar | 
            
        
            
                | x11-plugins/xmonad-contrib | 
                Third party extentions for xmonad | 
            
        
            
                | x11-plugins/xmonad-extras | 
                Third party extensions for xmonad with wacky dependencies | 
            
        
            
                | x11-wm/xmonad | 
                A lightweight X11 window manager |